@zeedhi/common 1.112.0 → 3.0.0

package/tests/unit/components/zd-list/list-item.spec.ts

@@ -0,0 +1,51 @@
+import { ListItem } from '../../../../src';
+
+describe('ListItem', () => {
+  describe('constructor', () => {
+    test('should create a new list item with the default values', () => {
+      const listItem = new ListItem({ name: 'listItem', component: 'ZdListItem' });
+
+      expect(listItem.appendIcon).toBeUndefined();
+      expect(listItem.disabled).toBeFalsy();
+      expect(listItem.leftField).toBeUndefined();
+      expect(listItem.prependIcon).toBeUndefined();
+      expect(listItem.rightField).toBeUndefined();
+      expect(listItem.ripple).toBeTruthy();
+      expect(listItem.subtitle).toBeUndefined();
+      expect(listItem.lines).toBe('one');
+      expect(listItem.title).toBeUndefined();
+    });
+
+    test('should create a new list item with the defined values', () => {
+      const listItem = new ListItem({
+        name: 'listItem',
+        component: 'ZdListItem',
+        appendIcon: 'append',
+        disabled: true,
+        leftField: {
+          name: 'left',
+          component: 'ZdComponent',
+        },
+        prependIcon: 'prepend',
+        rightField: {
+          name: 'right',
+          component: 'ZdComponent',
+        },
+        ripple: false,
+        subtitle: 'a subtitle',
+        lines: 'two',
+        title: 'a title',
+      });
+
+      expect(listItem.appendIcon).toEqual('append');
+      expect(listItem.disabled).toBeTruthy();
+      expect(listItem.leftField).toEqual({ name: 'left', component: 'ZdComponent' });
+      expect(listItem.prependIcon).toEqual('prepend');
+      expect(listItem.rightField).toEqual({ name: 'right', component: 'ZdComponent' });
+      expect(listItem.ripple).toBeFalsy();
+      expect(listItem.subtitle).toEqual('a subtitle');
+      expect(listItem.lines).toBe('two');
+      expect(listItem.title).toEqual('a title');
+    });
+  });
+});

package/tests/unit/components/zd-list/list.spec.ts

@@ -0,0 +1,107 @@
+import { List } from '../../../../src';
+import { ItemNotFoundError } from '../../../../src/components/zd-list/item-not-found';
+
+describe('List', () => {
+  describe('constructor', () => {
+    test('should create a new list with the default values', () => {
+      const list = new List({ name: 'list', component: 'ZdList' });
+
+      expect(list.color).toBe(undefined);
+      expect(list.dark).toBeFalsy();
+      expect(list.dense).toBeFalsy();
+      expect(list.disabled).toBeFalsy();
+      expect(list.divided).toBeFalsy();
+      expect(list.light).toBeFalsy();
+      expect(list.lines).toBe('one');
+      expect(list.elevation).toEqual(0);
+      expect(list.openStrategy).toBe('single');
+      expect(list.height).toBe('auto');
+      expect(list.minHeight).toBe('auto');
+      expect(list.maxHeight).toBe('none');
+      expect(list.fillHeight).toBeFalsy();
+      expect(list.width).toBe('100%');
+      expect(list.minWidth).toBe('auto');
+      expect(list.maxWidth).toBe('none');
+    });
+
+    test('should create a new list with the defined values', () => {
+      const list = new List({
+        name: 'list',
+        component: 'ZdList',
+        color: 'yellow',
+        dark: true,
+        dense: true,
+        disabled: true,
+        divided: true,
+        light: true,
+        lines: 'two',
+        elevation: 24,
+        openStrategy: 'list',
+        height: '400px',
+        maxHeight: '500px',
+        minHeight: '500px',
+        width: '400px',
+        maxWidth: '500px',
+        minWidth: '500px',
+        fillHeight: true,
+      });
+
+      expect(list.color).toEqual('yellow');
+      expect(list.dark).toBeTruthy();
+      expect(list.dense).toBeTruthy();
+      expect(list.disabled).toBeTruthy();
+      expect(list.divided).toBeTruthy();
+      expect(list.light).toBeTruthy();
+      expect(list.lines).toBe('two');
+      expect(list.elevation).toEqual(24);
+      expect(list.openStrategy).toBe('list');
+      expect(list.height).toBe('400px');
+      expect(list.maxHeight).toBe('500px');
+      expect(list.minHeight).toBe('500px');
+      expect(list.width).toBe('400px');
+      expect(list.maxWidth).toBe('500px');
+      expect(list.minWidth).toBe('500px');
+      expect(list.fillHeight).toBeTruthy();
+    });
+  });
+
+  describe('getItem', () => {
+    test('should get the item if it exists', () => {
+      const list = new List({
+        name: 'list',
+        component: 'ZdList',
+        items: [
+          {
+            name: 'item',
+            component: 'ZdListItem',
+          },
+          {
+            name: 'item 2',
+            component: 'ZdListItem',
+          },
+        ],
+      });
+
+      expect(list.getItem('item')).toEqual({ name: 'item', component: 'ZdListItem' });
+    });
+
+    test('should throw when item doesn\'t exist', () => {
+      const list = new List({
+        name: 'list',
+        component: 'ZdList',
+        items: [
+          {
+            name: 'item',
+            component: 'ZdListItem',
+          },
+          {
+            name: 'item 2',
+            component: 'ZdListItem',
+          },
+        ],
+      });
+
+      expect(() => list.getItem('item 5')).toThrowError(new ItemNotFoundError('item 5', 'list'));
+    });
+  });
+});

package/tests/unit/components/zd-loading/loading.spec.ts

@@ -0,0 +1,72 @@
+import { Loading, LoadingService, ILoading } from '../../../../src';
+
+jest.useFakeTimers();
+
+describe('Loading', () => {
+	describe('constructor()', () => {
+		it('should create new loading with default values', () => {
+			const instance = new Loading({ name: 'loading' });
+			expect(instance.text).toBe('Loading');
+			expect(instance.defaultText).toBe('Loading');
+			expect(instance.zIndex).toBe(1999);
+		});
+
+		it('should create new loading replacing default values', () => {
+			const instance = new Loading({
+				name: 'loading2',
+				text: 'Loading...',
+				zIndex: '160',
+			});
+			expect(instance.text).toBe('Loading...');
+			expect(instance.defaultText).toBe('Loading...');
+			expect(instance.zIndex).toBe('160');
+		});
+	});
+
+	describe('show and hide', () => {
+		it('should change the loading visibility', () => {
+			const instance = new Loading({ name: 'loading' });
+			expect(instance.isVisible).toBeFalsy();
+			instance.show();
+			expect(instance.isVisible).toBeTruthy();
+			instance.hide();
+			expect(instance.isVisible).toBeFalsy();
+		});
+
+		it('should change the loading text', () => {
+			const instance = new Loading({ name: 'loading' });
+
+			instance.show('Loading...');
+			expect(instance.text).toBe('Loading...');
+			expect(instance.defaultText).toBe('Loading');
+			instance.hide();
+
+			instance.show();
+			expect(instance.text).toBe('Loading');
+			expect(instance.defaultText).toBe('Loading');
+			instance.hide();
+		});
+	});
+});
+
+describe('Loading Service', () => {
+	let loadingMock: ILoading;
+
+	beforeEach(() => {
+		loadingMock = {
+			name: 'loading',
+			show: jest.fn(),
+			hide: jest.fn(),
+		};
+		LoadingService.loading = loadingMock;
+	});
+	it('should change the loading service show', () => {
+		LoadingService.show('Loading...');
+		expect(loadingMock.show).toHaveBeenCalledWith('Loading...');
+	});
+
+	it('should hide the loading', () => {
+		LoadingService.hide();
+		expect(loadingMock.hide).toHaveBeenCalled();
+	});
+});

package/tests/unit/components/zd-login/login-button.spec.ts

@@ -0,0 +1,305 @@
+import {
+  Http, Cookie, Router, IConfig, Config,
+} from '@zeedhi/core';
+import { LoginButton, Form } from '../../../../src';
+
+describe('LoginButton', () => {
+  let config!: IConfig;
+  const defaultToken: string = 'M.MQ==';
+  const defaultRequestHeader: Object = {
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+    },
+  };
+
+  beforeEach(() => {
+    config = {
+      endPoint: 'http://localhost:9000/',
+      metadataEndPoint: 'http://localhost:9000/metadata/',
+      title: 'Samples',
+      homeUrl: '/home',
+      mode: 'development',
+      env: {
+        authUrl: 'configEnvUrl',
+      },
+    };
+    Config.set(config);
+  });
+
+  describe('constructor()', () => {
+    it('should create new login button with default values', () => {
+      const instance = new LoginButton({
+        name: 'loginButton',
+        component: 'ZdLoginButton',
+        authUrl: '/authUrl',
+      });
+      expect(instance.authUrl).toBe((config.env as any).authUrl);
+      expect(instance.redirectUrl).toBe(config.homeUrl);
+      expect(instance.requestParams).toEqual({});
+    });
+
+    it('should create new login button replacing default values', () => {
+      const instance = new LoginButton({
+        name: 'loginButton',
+        component: 'ZdLoginButton',
+        redirectUrl: '/urlToRedirect',
+        requestParams: {
+          myParam: 'value',
+        },
+      });
+      expect(instance.redirectUrl).toBe('/urlToRedirect');
+      expect(instance.requestParams).toEqual({ myParam: 'value' });
+    });
+
+    it('should handle authUrl before set', () => {
+      let instance = new LoginButton({
+        name: 'loginButton',
+        component: 'ZdLoginButton',
+        authUrl: '/authUrl',
+      });
+      expect(instance.authUrl).toBe((config.env as any).authUrl);
+
+      delete (config.env as any).authUrl;
+      instance = new LoginButton({
+        name: 'loginButton',
+        component: 'ZdLoginButton',
+        authUrl: '/authUrl',
+      });
+      expect(instance.authUrl).toBe('/authUrl');
+
+      delete config.env;
+      instance = new LoginButton({
+        name: 'loginButton',
+        component: 'ZdLoginButton',
+        authUrl: '/otherAuthUrl',
+      });
+      expect(instance.authUrl).toBe('/otherAuthUrl');
+    });
+  });
+
+  describe('click', () => {
+    let postSpy: any;
+    let cookieSpy: any;
+    let routerSpy: any;
+    let instance: LoginButton;
+
+    beforeEach(() => {
+      const httpPostFunction = () => Promise.resolve({ status: 200, data: { token: defaultToken } });
+      postSpy = jest.spyOn(Http, 'post').mockImplementation(httpPostFunction);
+      cookieSpy = jest.spyOn(Cookie, 'setCookie');
+      routerSpy = jest.spyOn(Router, 'replace').mockImplementation(() => true);
+      instance = new LoginButton({
+        name: 'loginButton',
+        component: 'ZdLoginButton',
+        redirectUrl: '/dashboard',
+      });
+    });
+
+    afterEach(() => {
+      postSpy.mockClear();
+      cookieSpy.mockClear();
+      routerSpy.mockClear();
+    });
+
+    it('should not set cookie if parent is not set', async () => {
+      instance.parent = undefined;
+      await instance.click({} as Event, {});
+      expect(cookieSpy).not.toHaveBeenCalled();
+    });
+
+    it('should not set cookie if parent is not valid', async () => {
+      instance.parent = new Form({
+        name: 'form',
+        component: 'ZdForm',
+        value: {
+          param1: 'value1',
+          param2: 'value2',
+        },
+      });
+      instance.parent.validate = async () => await {valid: false};
+      await instance.click({} as Event, {});
+      expect(cookieSpy).not.toHaveBeenCalled();
+    });
+
+    it('should set a cookie with the token', async () => {
+      instance.parent = new Form({
+        name: 'form',
+        component: 'ZdForm',
+        value: {
+          param1: 'value1',
+          param2: 'value2',
+        },
+      });
+      await instance.click({} as Event, {});
+      expect(cookieSpy).toHaveBeenCalledWith('token', defaultToken);
+    });
+
+    it('should redirect to the configured url', async () => {
+      instance.parent = new Form({
+        name: 'form',
+        component: 'ZdForm',
+        value: {
+          param1: 'value1',
+          param2: 'value2',
+        },
+      });
+      await instance.click({} as Event, {});
+      expect(routerSpy).toHaveBeenCalledWith('/dashboard');
+    });
+
+    it('should do nothing when login wasn\'t successed', async () => {
+      instance.parent = new Form({
+        name: 'form',
+        component: 'ZdForm',
+        value: {
+          param1: 'value1',
+          param2: 'value2',
+        },
+      });
+      const spy = jest.spyOn(Http, 'post').mockImplementation(() => Promise.resolve({ status: 202 }));
+      await instance.click({} as Event, {});
+      expect(spy).toBeCalled();
+      expect(cookieSpy).not.toBeCalled();
+      expect(routerSpy).not.toBeCalled();
+      spy.mockClear();
+    });
+
+    describe('should send params', () => {
+      it('should send requestParams values', async () => {
+        const queryString = 'requestParam1=value1&requestParam2=value2&param1=value1&param2=value2';
+        instance.parent = new Form({
+          name: 'form',
+          component: 'ZdForm',
+          value: {
+            param1: 'value1',
+            param2: 'value2',
+          },
+        });
+        instance.requestParams = {
+          requestParam1: 'value1',
+          requestParam2: 'value2',
+        };
+        await instance.click({} as Event, {});
+        expect(postSpy).toHaveBeenCalledWith(instance.authUrl, queryString, defaultRequestHeader);
+        expect(cookieSpy).toBeCalled();
+        expect(routerSpy).toBeCalled();
+      });
+
+      it('should send form value', async () => {
+        const queryString = 'field1=value1&field2=value2';
+        instance.parent = new Form({
+          name: 'form',
+          component: 'ZdForm',
+          value: {
+            field1: 'value1',
+            field2: 'value2',
+          },
+        });
+        await instance.click({} as Event, {});
+        expect(postSpy).toHaveBeenCalledWith(instance.authUrl, queryString, defaultRequestHeader);
+        expect(cookieSpy).toBeCalled();
+        expect(routerSpy).toBeCalled();
+      });
+
+      it('should send requestParams and form value', async () => {
+        const queryString = 'requestParam1=value1&requestParam2=value2&param1=value1&param2=value2';
+        instance.parent = new Form({
+          name: 'form',
+          component: 'ZdForm',
+          value: {
+            param1: 'value1',
+            param2: 'value2',
+          },
+        });
+        instance.requestParams = {
+          requestParam1: 'value1',
+          requestParam2: 'value2',
+        };
+        await instance.click({} as Event, {});
+        expect(postSpy).toHaveBeenCalledWith(instance.authUrl, queryString, defaultRequestHeader);
+        expect(cookieSpy).toBeCalled();
+        expect(routerSpy).toBeCalled();
+      });
+    });
+
+    describe('should trigger LoginButton events ', () => {
+      it('should trigger loginSuccess when response code is 200', async () => {
+        instance.parent = new Form({
+          name: 'form',
+          component: 'ZdForm',
+          value: {
+            param1: 'value1',
+            param2: 'value2',
+          },
+        });
+        const successFn = jest.fn();
+        instance.events.loginSuccess = successFn;
+        await instance.click({} as Event, {});
+        expect(successFn).toHaveBeenCalled();
+      });
+
+      it('should do nothing when loginSuccess was prevented', async () => {
+        instance.parent = new Form({
+          name: 'form',
+          component: 'ZdForm',
+          value: {
+            param1: 'value1',
+            param2: 'value2',
+          },
+        });
+        const successFn = jest.fn().mockImplementation(() => true);
+        instance.events.loginSuccess = successFn;
+        await instance.click({} as Event, {});
+        expect(successFn).toHaveBeenCalled();
+        expect(cookieSpy).not.toBeCalled();
+        expect(routerSpy).not.toBeCalled();
+      });
+
+      it('should trigger loginFail when response code isn\'t 200', async () => {
+        instance.parent = new Form({
+          name: 'form',
+          component: 'ZdForm',
+          value: {
+            param1: 'value1',
+            param2: 'value2',
+          },
+        });
+        const spy = jest.spyOn(Http, 'post').mockImplementation(() => Promise.resolve({ status: 202 }));
+        const successFn = jest.fn();
+        const failFn = jest.fn();
+
+        instance.events.loginSuccess = successFn;
+        instance.events.loginFail = failFn;
+
+        await instance.click({} as Event, {});
+        expect(spy).toBeCalled();
+        expect(successFn).not.toHaveBeenCalled();
+        expect(failFn).toHaveBeenCalled();
+        spy.mockClear();
+      });
+
+      it('should trigger loginFail when Http.post throws an error', async () => {
+        instance.parent = new Form({
+          name: 'form',
+          component: 'ZdForm',
+          value: {
+            param1: 'value1',
+            param2: 'value2',
+          },
+        });
+        const spy = jest.spyOn(Http, 'post').mockImplementation(() => Promise.reject(new Error('Some error')));
+        const successFn = jest.fn();
+        const failFn = jest.fn();
+
+        instance.events.loginSuccess = successFn;
+        instance.events.loginFail = failFn;
+
+        await instance.click({} as Event, {});
+        expect(spy).toBeCalled();
+        expect(successFn).not.toHaveBeenCalled();
+        expect(failFn).toHaveBeenCalled();
+        spy.mockClear();
+      });
+    });
+  });
+});

package/tests/unit/components/zd-login/login.spec.ts

@@ -0,0 +1,52 @@
+import { Login } from '../../../../src';
+
+describe('Login', () => {
+  describe('constructor()', () => {
+    it('should create new login with default values', () => {
+      const instance = new Login({ name: 'login', component: 'Login' });
+      expect(instance.backgroundStyle).toBe('');
+      expect(instance.bottomLink).toEqual([]);
+      expect(instance.cardWidth).toBe('33%');
+      expect(instance.color).toBe('');
+      expect(instance.dark).toBeFalsy();
+      expect(instance.flatForm).toBeFalsy();
+      expect(instance.layout).toBe('center');
+      expect(instance.logo).toBe('');
+      expect(instance.logoMessage).toBe('');
+      expect(instance.poweredByImage).toBe('');
+      expect(instance.poweredByImageCard).toBe('');
+      expect(instance.socialLogin).toEqual([]);
+    });
+
+    it('should create new login replacing default values', () => {
+      const instance = new Login({
+        name: 'login',
+        component: 'Login',
+        backgroundStyle: '#b1b1b1',
+        bottomLink: [{ name: 'button', component: 'ZdButton' }],
+        cardWidth: 200,
+        color: 'primary',
+        dark: true,
+        flatForm: true,
+        layout: 'right',
+        logo: '/img/zeedhi.svg',
+        logoMessage: 'Sign in',
+        poweredByImage: '/img/zeedhi.svg',
+        poweredByImageCard: '/img/zeedhi.svg',
+        socialLogin: [{ name: 'button', component: 'ZdButton' }],
+      });
+      expect(instance.backgroundStyle).toBe('#b1b1b1');
+      expect(instance.bottomLink).toEqual([{ name: 'button', component: 'ZdButton' }]);
+      expect(instance.cardWidth).toBe(200);
+      expect(instance.color).toBe('primary');
+      expect(instance.dark).toBeTruthy();
+      expect(instance.flatForm).toBeTruthy();
+      expect(instance.layout).toBe('right');
+      expect(instance.logo).toBe('/img/zeedhi.svg');
+      expect(instance.logoMessage).toBe('Sign in');
+      expect(instance.poweredByImage).toBe('/img/zeedhi.svg');
+      expect(instance.poweredByImageCard).toBe('/img/zeedhi.svg');
+      expect(instance.socialLogin).toEqual([{ name: 'button', component: 'ZdButton' }]);
+    });
+  });
+});

package/tests/unit/components/zd-main/main.spec.ts

@@ -0,0 +1,22 @@
+import { Main } from '../../../../src';
+
+describe('Main', () => {
+	describe('constructor()', () => {
+		it('should create new Main with default values', () => {
+			const instance = new Main({ name: 'main', component: 'Main', height: '100%' });
+			expect(instance.scrollable).toBeFalsy();
+			expect(instance.tag).toBe('main');
+		});
+
+		it('should create new Main replacing default values', () => {
+			const instance = new Main({
+				name: 'main',
+				component: 'Main',
+				scrollable: true,
+				tag: 'div',
+			});
+			expect(instance.scrollable).toBeTruthy();
+			expect(instance.tag).toBe('div');
+		});
+	});
+});

package/tests/unit/components/zd-master-detail/detail-not-found.spec.ts

@@ -0,0 +1,11 @@
+import { DetailNotFoundError } from '../../../../src/components/zd-master-detail/detail-not-found';
+
+describe('DetailNotFound', () => {
+  describe('constructor()', () => {
+    it('should create new instance', () => {
+      const instance = new DetailNotFoundError('detailName');
+      expect(instance.message).toBe("[Zeedhi Common err]: Detail component 'detailName' not found.");
+      expect(instance.name).toBe('DetailNotFoundError'); 
+    });
+  });
+});