import {
	IAppFuncHelper,
	IOpenViewHelper,
	IAppCodeListHelper,
	IAppViewMsgHelper,
	IAppCounterHelper,
	ILoadingHelper,
	IGlobalActionHelper,
	IGlobalNotificationHelper,
	IViewLogicHelper,
	INotificationHelper,
	IDialogHelper,
	IParam,
	IProjectSetting,
	IAppFunc,
	IEntityDetail,
	IAppConfig,
	IDevActionHelper,
	IAppData,
} from '@/core/interface';

describe('getAppFuncHelper unit test', () => {
	test('getAppFuncHelper result type is IAppFuncHelper', () => {
		expectTypeOf(App.getAppFuncHelper).toBeFunction();
		assertType<IAppFuncHelper>(App.getAppFuncHelper());
	});
});

describe('getOpenViewHelper unit test', () => {
	test('getOpenViewHelper result type is IOpenViewHelper', () => {
		expectTypeOf(App.getOpenViewHelper).toBeFunction();
		assertType<IOpenViewHelper>(App.getOpenViewHelper());
	});
});

describe('getAppCodeListHelper unit test', () => {
	test('getAppCodeListHelper result type is IAppCodeListHelper', () => {
		expectTypeOf(App.getAppCodeListHelper).toBeFunction();
		assertType<IAppCodeListHelper>(App.getAppCodeListHelper());
	});
});

describe('getAppViewMsgHelper unit test', () => {
	test('getAppViewMsgHelper result type is IAppViewMsgHelper', () => {
		expectTypeOf(App.getAppViewMsgHelper).toBeFunction();
		assertType<IAppViewMsgHelper>(App.getAppViewMsgHelper());
	});
});

describe('getAppCounterHelper unit test', () => {
	test('getAppCounterHelper result type is IAppCounterHelper', () => {
		expectTypeOf(App.getAppCounterHelper).toBeFunction();
		assertType<IAppCounterHelper>(App.getAppCounterHelper());
	});
});

describe('getAppLoadingHelper unit test', () => {
	test('getAppLoadingHelper result type is ILoadingHelper', () => {
		expectTypeOf(App.getAppLoadingHelper).toBeFunction();
		assertType<ILoadingHelper>(App.getAppLoadingHelper());
	});
});

describe('getGlobalActionHelper unit test', () => {
	test('getGlobalActionHelper result type is IGlobalActionHelper', () => {
		expectTypeOf(App.getGlobalActionHelper).toBeFunction();
		assertType<IGlobalActionHelper>(App.getGlobalActionHelper());
	});
});

describe('getGlobalNotificationHelper unit test', () => {
	test('getGlobalNotificationHelper result type is IGlobalNotificationHelper', () => {
		expectTypeOf(App.getGlobalNotificationHelper).toBeFunction();
		assertType<IGlobalNotificationHelper>(
			App.getGlobalNotificationHelper()
		);
	});
});

describe('getViewLogicHelper unit test', () => {
	test('getViewLogicHelper result type is IViewLogicHelper', () => {
		expectTypeOf(App.getViewLogicHelper).toBeFunction();
		assertType<IViewLogicHelper>(App.getViewLogicHelper());
	});
});

describe('getNotificationHelper unit test', () => {
	test('getNotificationHelper result type is INotificationHelper', () => {
		expectTypeOf(App.getNotificationHelper).toBeFunction();
		assertType<INotificationHelper>(App.getNotificationHelper());
	});
});

describe('getDialogHelper unit test', () => {
	test('getDialogHelper result type is IDialogHelper', () => {
		expectTypeOf(App.getDialogHelper).toBeFunction();
		assertType<IDialogHelper>(App.getDialogHelper());
	});
});

describe('getDataService unit test', () => {
	test('getDataService', () => {
		expectTypeOf(App.getDataService).toBeFunction();
	});
});

describe('getUIService unit test', () => {
	test('getUIService', () => {
		expectTypeOf(App.getUIService).toBeFunction();
	});
});

describe('setUIAppInstance unit test', () => {
	test('setUIAppInstance', () => {
		expectTypeOf(App.setUIAppInstance).toBeFunction();
	});
});

describe('getUIAppInstance unit test', () => {
	test('getUIAppInstance result type is IParam | undefined', () => {
		expectTypeOf(App.getUIAppInstance).toBeFunction();
		assertType<IParam | undefined>(App.getUIAppInstance());
	});
});

describe('getAppViewConfig unit test', () => {
	test('getAppViewConfig result type is IParam', () => {
		expectTypeOf(App.getAppViewConfig).toBeFunction();
		assertType<IParam>(App.getAppViewConfig());
	});
});

describe('getAppThemeConfig unit test', () => {
	test('getAppThemeConfig result type is IParam[]', () => {
		expectTypeOf(App.getAppThemeConfig).toBeFunction();
		assertType<IParam[]>(App.getAppThemeConfig());
	});
});

describe('getProjectSetting unit test', () => {
	test('getProjectSetting result type is IProjectSetting', () => {
		expectTypeOf(App.getProjectSetting).toBeFunction();
		assertType<IProjectSetting>(App.getProjectSetting());
	});
});

describe('getAppFuncConfig unit test', () => {
	test('getAppFuncConfig result type is IAppFunc[]', () => {
		expectTypeOf(App.getAppFuncConfig).toBeFunction();
		assertType<IAppFunc[]>(App.getAppFuncConfig());
	});
});

describe('getAppCodeListConfig unit test', () => {
	test('getAppCodeListConfig result type is IAppFunc[]', () => {
		expectTypeOf(App.getAppCodeListConfig).toBeFunction();
		assertType<IParam>(App.getAppCodeListConfig());
	});
});

describe('getAppCounterConfig unit test', () => {
	test('getAppCounterConfig result type is IParam', () => {
		expectTypeOf(App.getAppCounterConfig).toBeFunction();
		assertType<IParam>(App.getAppCounterConfig());
	});
});

describe('getAppViewMsgConfig unit test', () => {
	test('getAppViewMsgConfig result type is IParam', () => {
		expectTypeOf(App.getAppViewMsgConfig).toBeFunction();
		assertType<IParam>(App.getAppViewMsgConfig());
	});
});

describe('getAppEntityConfig unit test', () => {
	test('getAppEntityConfig result type is IEntityDetail[]', () => {
		expectTypeOf(App.getAppEntityConfig).toBeFunction();
		assertType<IEntityDetail[]>(App.getAppEntityConfig());
	});
});

describe('getAppConfig unit test', () => {
	test('getAppConfig result type is IAppConfig', () => {
		expectTypeOf(App.getAppConfig).toBeFunction();
		assertType<IAppConfig>(App.getAppConfig());
	});
});

describe('getEnableAppPermission unit test', () => {
	test('getEnableAppPermission result type is boolean', () => {
		expectTypeOf(App.getEnableAppPermission).toBeFunction();
		expect(App.getEnableAppPermission()).toBeTypeOf('boolean');
	});
});

describe('getAppMenuAuth unit test', () => {
	test('getAppMenuAuth result type is boolean', () => {
		expectTypeOf(App.getAppMenuAuth).toBeFunction();
		expect(App.getAppMenuAuth('')).toBeTypeOf('boolean');
	});
});

describe('getAppUniresAuth unit test', () => {
	test('getAppUniresAuth result type is boolean', () => {
		expectTypeOf(App.getAppUniresAuth).toBeFunction();
		expect(App.getAppUniresAuth('')).toBeTypeOf('boolean');
	});
});

describe('getDevActionHelper unit test', () => {
	test('getDevActionHelper result type is IDevActionHelper', () => {
		expectTypeOf(App.getDevActionHelper).toBeFunction();
		assertType<IDevActionHelper>(App.getDevActionHelper());
	});
});

describe('login unit test', () => {
	test('login', async () => {
		const login = await App.login('admin', '123456');
		expect(login).toBe(undefined);
	});
});

describe('logout unit test', () => {
	test('logout', async () => {
		// const logout = await App.logout();
		// expect(logout).toStrictEqual(undefined);
	});
});

describe('getAppData unit test', () => {
	test('getAppData result type is IAppData', () => {
		expectTypeOf(App.getAppData).toBeFunction();
		assertType<IAppData>(App.getAppData());
	});
});

describe('clearAppData unit test', () => {
	test('clearAppData result type is boolean', () => {
		expectTypeOf(App.clearAppData).toBeFunction();
		expect(App.clearAppData()).toBeTypeOf('boolean');
	});
});

describe('ts unit test', () => {
	test('ts result type is string', () => {
		expectTypeOf(App.ts).toBeFunction();
		expect(App.ts('', 'test')).toBe('test');
	});
});

describe('closeView unit test', () => {
	test('closeView', () => {
		expectTypeOf(App.closeView).toBeFunction();
	});
});

describe('closeAppLoadding unit test', () => {
	test('closeAppLoadding', () => {
		expectTypeOf(App.closeAppLoadding).toBeFunction();
	});
});