@zeedhi/common 1.112.0 → 3.0.0

package/tests/unit/components/tek-grid/tek-rest-datasource.spec.ts

@@ -0,0 +1,422 @@
+import {
+  IConfig, Config, Router, Http, URL, IDictionary, init,
+} from '@zeedhi/core';
+import {
+  TekRestDatasource, ITekRestDatasource,
+} from '../../../../src';
+import { flushPromises } from '../../__helpers__';
+
+describe('TekRestDatasource', () => {
+  init({
+    controllers: {
+      AppController: class AppController {
+        public value = '1';
+
+        public join: string[] | number[] = ['1', '2'];
+      },
+    },
+  });
+  let datasource: ITekRestDatasource;
+  let router: any;
+  const config: IConfig = {
+    endPoint: 'http://localhost:9000/',
+    metadataEndPoint: 'http://localhost:9000/metadata/',
+    title: 'Samples',
+    mode: 'production',
+    datasourceLimit: 10,
+  };
+  let httpSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    datasource = {
+      uniqueKey: 'id',
+      route: '/zeedhi',
+      lazyLoad: true,
+    };
+    Config.set(config);
+    router = {
+      push: () => jest.fn,
+      replace: (route: any) => {
+        window.history.replaceState(null, '', `${window.location.pathname}?${URL.getFormattedQueryString(route.query)}`);
+      },
+      back: () => jest.fn,
+      getCurrentRoute: () => ({
+        path: '',
+        hash: '',
+        query: {},
+        params: {},
+        fullPath: '',
+      }),
+      getPath: () => '',
+      getHash: () => '',
+      getQuery: () => ({}),
+      getParams: () => ({}),
+      getFullPath: () => '',
+    };
+    Router.setInstance(router);
+    httpSpy = jest.spyOn(Http, 'get').mockImplementation(() => Promise.resolve({
+      data: {
+        data: [
+          { name: '1', id: 1 }, { name: '2', id: 2 }, { name: '3', id: 3 },
+          { name: '4', id: 4 }, { name: '5', id: 5 }, { name: '6', id: 6 },
+        ],
+        pagination: {
+          page: 1,
+          total: 6,
+          limit: 15,
+        },
+      },
+    }));
+  });
+
+  afterEach(() => {
+    httpSpy.mockClear();
+  });
+
+  describe('constuctor()', () => {
+    it('should assign all properties', async () => {
+      const instance = new TekRestDatasource({
+        ...datasource,
+        dynamicFilter: {
+          name: { operation: 'EQUALS', relation: 'AND', value: '1' },
+        },
+        searchJoin: { col1: ['1', '2'], col2: [2], col3: [] },
+      });
+      await flushPromises();
+
+      expect(instance.route).toBe('/zeedhi');
+      expect(instance.lazyLoad).toBeTruthy();
+      expect(instance.dynamicFilter).toEqual({ name: { operation: 'EQUALS', relation: 'AND', value: '1' } });
+      expect(instance.data.length).toBe(0);
+      expect(instance.searchJoin).toEqual({ col1: ['1', '2'], col2: [2], col3: [] });
+    });
+
+    it('should assign all properties', async () => {
+      const instance = new TekRestDatasource({
+        ...datasource,
+        dynamicFilter: {
+          name: { operation: 'EQUALS', relation: 'AND', value: '{{AppController.value}}' },
+        },
+        searchJoin: { col1: '{{AppController.join}}' as any, col2: [2], col3: [] },
+      });
+      await flushPromises();
+
+      expect(instance.route).toBe('/zeedhi');
+      expect(instance.lazyLoad).toBeTruthy();
+      expect(instance.dynamicFilter).toEqual({ name: { operation: 'EQUALS', relation: 'AND', value: '1' } });
+      expect(instance.data.length).toBe(0);
+      expect(instance.searchJoin).toEqual({ col1: ['1', '2'], col2: [2], col3: [] });
+    });
+
+    it('should create without lazyLoad', async () => {
+      const instance = new TekRestDatasource({
+        ...datasource,
+        lazyLoad: false,
+        dynamicFilter: {
+          name: { operation: 'EQUALS', relation: 'AND', value: '1' },
+        },
+      });
+      instance.initialize();
+      await flushPromises();
+
+      expect(instance.data.length).toBe(6);
+    });
+
+    it('should set values from url', () => {
+      router.getFullPath = () => 'localhost/?page=2&limit=10&order=id.asc&search=2&id=1&filter=applied';
+      datasource.watchUrl = true;
+      const instance = new TekRestDatasource(datasource);
+      expect(instance.filter).toEqual({ id: '1' });
+      expect(instance.limit).toBe(10);
+      expect(instance.order).toEqual(['id.asc']);
+      expect(instance.page).toBe(2);
+      expect(instance.search).toBe('2');
+    });
+  });
+
+  describe('urlHasChanged()', () => {
+    it('should return true when url query string is different from datasource query string', () => {
+      datasource.watchUrl = true;
+      const spy = jest.spyOn(URL, 'getParsedQueryStringFromUrl').mockReturnValue({
+        dynamic_filter: 'eyJuYW1lIjpbeyJ2YWx1ZSI6IjIiLCJvcGVyYXRpb24iOiJDT05UQUlOUyIsInJlbGF0aW9uIjoiQU5EIn1dfQ==',
+        search_join: 'eyJjb2wxIjpbIjEiLCIyIl19',
+      });
+      const instance = new TekRestDatasource(datasource);
+      instance.dynamicFilter = { name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] };
+      instance.searchJoin = { col1: ['1', '2'], col2: [2], col3: [] };
+      instance.initialize();
+      expect(instance.urlHasChanged()).toBeTruthy();
+
+      spy.mockClear();
+    });
+  });
+
+  describe('addDynamicFilter()', () => {
+    it('should add/remove dynamic filter value', () => {
+      datasource.watchUrl = false;
+      const instance = new TekRestDatasource(datasource);
+      instance.addDynamicFilter('name', [{ operation: 'EQUALS', relation: 'AND', value: '1' }]);
+      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
+      instance.addDynamicFilter('name', [{ operation: 'foo', relation: 'AND', value: '1' }]);
+      expect(instance.dynamicFilter).toEqual({});
+    });
+  });
+
+  describe('setDynamicFilter()', () => {
+    it('should add/remove dynamic filter value', () => {
+      datasource.watchUrl = false;
+      const instance = new TekRestDatasource(datasource);
+      instance.setDynamicFilter({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
+      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
+
+      instance.setDynamicFilter({ name: [{ operation: 'foo', relation: 'AND', value: '1' }] });
+      expect(instance.dynamicFilter).toEqual({});
+
+      instance.setDynamicFilter({
+        department_id: undefined, hire_date: null, name: [], id: [{}],
+      });
+      expect(instance.dynamicFilter).toEqual({});
+    });
+
+    // it('should add dynamic filter value with watchUrl', () => {
+    //   let dynamicFilterValue = 'eyJuYW1lIjpbeyJvcGVyYXRpb24iOiJFUVVBTFMiLCJyZWxhdGlvbiI6IkFORCIsInZhbHVlIjoiMSJ9XX0=';
+    //   router.getFullPath = () => `localhost/?dynamic_filter=${dynamicFilterValue}`;
+    //   const urlSpy = jest.spyOn(URL, 'updateQueryString');
+
+    //   datasource.watchUrl = true;
+    //   const instance = new TekRestDatasource(datasource);
+    //   instance.initialize();
+    //   expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
+
+    //   dynamicFilterValue = 'eyJuYW1lIjpbeyJvcGVyYXRpb24iOiJFUVVBTFMiLCJyZWxhdGlvbiI6IkFORCIsInZhbHVlIjoiMiJ9XX0=';
+    //   instance.setDynamicFilter({ name: [{ operation: 'EQUALS', relation: 'AND', value: '2' }] });
+    //   expect(urlSpy).toHaveBeenCalledWith({
+    //     dynamic_filter: dynamicFilterValue,
+    //   });
+    //   expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '2' }] });
+    //   urlSpy.mockClear();
+    // });
+  });
+
+  describe('clearDynamicFilter()', () => {
+    it('should clear dynamic filter', () => {
+      datasource.watchUrl = false;
+      const instance = new TekRestDatasource(datasource);
+      instance.setDynamicFilter({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
+      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
+      instance.clearDynamicFilter();
+      expect(instance.dynamicFilter).toEqual({});
+    });
+
+    // it('should clear dynamic filter value with watchUrl', () => {
+    //   let dynamicFilterValue = 'eyJuYW1lIjpbeyJvcGVyYXRpb24iOiJFUVVBTFMiLCJyZWxhdGlvbiI6IkFORCIsInZhbHVlIjoiMSJ9XX0=';
+    //   router.getFullPath = () => `localhost/?dynamic_filter=${dynamicFilterValue}`;
+    //   const urlSpy = jest.spyOn(URL, 'updateQueryString');
+
+    //   datasource.watchUrl = true;
+    //   const instance = new TekRestDatasource(datasource);
+    //   instance.initialize();
+    //   expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
+
+    //   dynamicFilterValue = '';
+    //   instance.clearDynamicFilter();
+    //   expect(urlSpy).toHaveBeenCalledWith({
+    //     dynamic_filter: undefined,
+    //   });
+    //   expect(instance.dynamicFilter).toEqual({});
+    //   urlSpy.mockClear();
+    // });
+  });
+
+  describe('get()', () => {
+    it('should send dynamic filter and searchJoin on get request params', async () => {
+      datasource.watchUrl = false;
+      const instance = new TekRestDatasource(datasource);
+      const dynFilter = { name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] };
+      const searchJoin = { join: [1, 2, 3] };
+      instance.setDynamicFilter(dynFilter);
+      instance.searchJoin = searchJoin;
+
+      await instance.get();
+
+      const expectedFilter = btoa(JSON.stringify(dynFilter));
+      const expectedSJoin = btoa(JSON.stringify(searchJoin));
+      expect(httpSpy).toHaveBeenCalledWith('/zeedhi',
+        expect.objectContaining({
+          params: expect.objectContaining({
+            dynamic_filter: expectedFilter,
+            search_join: expectedSJoin,
+          }),
+        }));
+    });
+
+    it('should send dynamic filter on get request params', async () => {
+      datasource.watchUrl = false;
+      const instance = new TekRestDatasource(datasource);
+      const dynFilter = { name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] };
+      instance.setDynamicFilter(dynFilter);
+
+      await instance.get();
+
+      const expectedFilter = btoa(JSON.stringify(dynFilter));
+
+      // should have dynamic_filter
+      expect(httpSpy).toHaveBeenCalledWith('/zeedhi',
+        expect.objectContaining({
+          params: expect.objectContaining({
+            dynamic_filter: expectedFilter,
+          }),
+        }));
+      // should not have search_join
+      expect(httpSpy).toHaveBeenCalledWith('/zeedhi',
+        expect.objectContaining({
+          params: expect.not.objectContaining({
+            search_join: expect.anything(),
+          }),
+        }));
+    });
+
+    it('should send search join on get request params', async () => {
+      datasource.watchUrl = false;
+      const instance = new TekRestDatasource(datasource);
+      const searchJoin = { join: [1, 2, 3] };
+      instance.searchJoin = searchJoin;
+
+      await instance.get();
+
+      const expectedSJoin = btoa(JSON.stringify(searchJoin));
+      // should have search_join
+      expect(httpSpy).toHaveBeenCalledWith('/zeedhi',
+        expect.objectContaining({
+          params: expect.objectContaining({
+            search_join: expectedSJoin,
+          }),
+        }));
+      // should not have dynamic_filter
+      expect(httpSpy).toHaveBeenCalledWith('/zeedhi',
+        expect.objectContaining({
+          params: expect.not.objectContaining({
+            dynamic_filter: expect.anything(),
+          }),
+        }));
+    });
+
+    it('should not send empty dynamic filter properties', async () => {
+      const filter: IDictionary = {
+        department_id: undefined, hire_date: null, name: [], id: [{}],
+      };
+      const instance = new TekRestDatasource(datasource);
+      instance.initialize();
+      instance.dynamicFilter = filter;
+
+      await instance.get();
+
+      expect(httpSpy).toHaveBeenCalledWith('/zeedhi', expect.objectContaining({
+        params: {
+          in: [],
+          order: [],
+          search: undefined,
+          search_in: [],
+          page: 1,
+          limit: 10,
+        },
+      }));
+    });
+
+    it('when using watchUrl, should update the dynamicFilter using the value from url query string', async () => {
+      const instance = new TekRestDatasource(datasource);
+      instance.initialize();
+      instance.watchUrl = true;
+      const spy = jest.spyOn(URL, 'getParsedQueryStringFromUrl').mockReturnValue({ dynamic_filter: 'eyJuYW1lIjpbeyJvcGVyYXRpb24iOiJFUVVBTFMiLCJyZWxhdGlvbiI6IkFORCIsInZhbHVlIjoiMSJ9XX0=' });
+
+      await instance.get();
+
+      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
+      spy.mockClear();
+    });
+  });
+
+  describe('clone', () => {
+    it('should return an object with all datasource props', async () => {
+      const data = [{ value: 'item 1' }];
+      const dynamicFilter = {
+        name: { operation: 'EQUALS', relation: 'AND', value: 'item 1' },
+      };
+      const searchJoin = { col1: ['1', '2'], col2: [2], col3: [] };
+      const instance = new TekRestDatasource({
+        route: '/zeedhi',
+        data,
+        dynamicFilter,
+        searchJoin,
+      });
+      instance.initialize();
+
+      const props = instance.clone();
+
+      expect(props).toEqual({
+        data,
+        dynamicFilter,
+        searchJoin,
+        currentRow: {},
+        filter: {},
+        find: {},
+        limit: 10,
+        order: [],
+        page: 1,
+        search: '',
+        searchIn: [],
+        uniqueKey: 'id',
+        watchUrl: false,
+        events: {},
+        loadAll: false,
+        lazyLoad: true,
+        arrayFormat: 'repeat',
+        route: '/zeedhi',
+        type: 'tek-rest',
+      });
+    });
+  });
+
+  describe('hasFilter()', () => {
+    it('should return true if there is a filter for the column', () => {
+      const instance = new TekRestDatasource(datasource);
+      instance.initialize();
+      expect(instance.hasFilter('name')).toBeFalsy();
+      instance.dynamicFilter = { name: [{ value: 'name 1', operation: 'CONTAINS', relation: 'AND' }] };
+      expect(instance.hasFilter('name')).toBeTruthy();
+    });
+  });
+
+  describe('updateDynamicFilter()', () => {
+    it('when watching url, should update the url with the new dynamic filter', async () => {
+      const instance = new TekRestDatasource(datasource);
+      instance.initialize();
+      const dynamicFilter = { name: [{ value: 'name 1', operation: 'CONTAINS', relation: 'AND' }] };
+      instance.dynamicFilter = { ...dynamicFilter };
+      instance.watchUrl = true;
+      const spy = jest.spyOn(URL, 'updateQueryString');
+
+      await instance.updateDynamicFilter();
+
+      expect(spy).toHaveBeenCalledWith({
+        dynamic_filter: btoa(JSON.stringify(dynamicFilter)),
+      });
+      spy.mockClear();
+    });
+
+    it('when watching url, when dynamicFilter is empty, should update the url with undefined', async () => {
+      const instance = new TekRestDatasource(datasource);
+      instance.initialize();
+      instance.dynamicFilter = {};
+      instance.watchUrl = true;
+      const spy = jest.spyOn(URL, 'updateQueryString');
+
+      await instance.updateDynamicFilter();
+
+      expect(spy).toHaveBeenCalledWith({
+        dynamic_filter: undefined,
+      });
+      spy.mockClear();
+    });
+  });
+});

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

@@ -0,0 +1,62 @@
+import { Alert } from '../../../../src';
+
+describe('Alert', () => {
+	describe('constructor()', () => {
+		it('should create new alert with default values', () => {
+			const instance = new Alert({ name: 'alert' });
+			expect(instance.color).toBe('');
+			expect(instance.text).toBe('');
+			expect(instance.timeout).toBe(5000);
+			expect(instance.top).toBeFalsy();
+			expect(instance.right).toBeFalsy();
+			expect(instance.bottom).toBeTruthy();
+			expect(instance.left).toBeTruthy();
+			expect(instance.vertical).toBeFalsy();
+			expect(instance.multiLine).toBeFalsy();
+			expect(instance.showDismiss).toBeFalsy();
+			expect(instance.dismissColor).toBe('');
+			expect(instance.buttonsSlot).toEqual([]);
+		});
+
+		it('should create new alert replacing default values', () => {
+			const instance = new Alert({
+				name: 'alert2',
+				color: 'red',
+				text: 'text',
+				timeout: 1000,
+				top: true,
+				right: true,
+				bottom: false,
+				left: false,
+				vertical: true,
+				multiLine: true,
+				showDismiss: true,
+				dismissColor: 'red',
+				buttonsSlot: [{ name: 'button', component: 'ZdButton' }],
+			});
+			expect(instance.color).toBe('red');
+			expect(instance.text).toBe('text');
+			expect(instance.timeout).toBe(1000);
+			expect(instance.top).toBeTruthy();
+			expect(instance.right).toBeTruthy();
+			expect(instance.bottom).toBeFalsy();
+			expect(instance.left).toBeFalsy();
+			expect(instance.vertical).toBeTruthy();
+			expect(instance.multiLine).toBeTruthy();
+			expect(instance.showDismiss).toBeTruthy();
+			expect(instance.dismissColor).toBe('red');
+			expect(instance.buttonsSlot).toEqual([{ name: 'button', component: 'ZdButton' }]);
+		});
+	});
+
+	describe('show and hide', () => {
+		it('should change the alert visibility', () => {
+			const instance = new Alert({ name: 'alert' });
+			expect(instance.isVisible).toBeFalsy();
+			instance.show();
+			expect(instance.isVisible).toBeTruthy();
+			instance.hide();
+			expect(instance.isVisible).toBeFalsy();
+		});
+	});
+});

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

@@ -0,0 +1,36 @@
+import { Badge } from '../../../../src';
+
+describe('Badge', () => {
+	describe('constructor()', () => {
+		it('should create new badge with default values', () => {
+			const instance = new Badge({ name: 'badge', component: 'Badge' });
+			expect(instance.badge).toBe(0);
+			expect(instance.showBadgeCounter).toBeTruthy();
+		});
+
+		it('should create new badge replacing default values', () => {
+			const instance = new Badge({
+				badge: 99,
+				component: 'Badge',
+				name: 'badge',
+				showBadgeCounter: false,
+			});
+			expect(instance.badge).toBe(99);
+			expect(instance.showBadgeCounter).toBeFalsy();
+		});
+	});
+
+	describe('getBadgeText()', () => {
+		const instance = new Badge({ name: 'badge', component: 'Badge' });
+		it('should return badge number as string when badge < 100', () => {
+			expect(instance.getBadgeText()).toBe('0');
+			instance.badge = 99;
+			expect(instance.getBadgeText()).toBe('99');
+		});
+
+		it('should return 99+ when badge => 100', () => {
+			instance.badge = 100;
+			expect(instance.getBadgeText()).toBe('99+');
+		});
+	});
+});

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

@@ -0,0 +1,39 @@
+import { Breadcrumbs } from '../../../../src';
+
+describe('Breadcrumbs', () => {
+	describe('constructor', () => {
+		test('should create a new breadcrumbs with the default values', () => {
+			const breadcrumbs = new Breadcrumbs({ name: 'breadcrumbs', component: 'ZdBreadcrumbs' });
+
+			expect(breadcrumbs.dark).toBeFalsy();
+			expect(breadcrumbs.divider).toBe('/');
+			expect(breadcrumbs.iconName).toBe('');
+			expect(breadcrumbs.items).toStrictEqual([]);
+			expect(breadcrumbs.large).toBeFalsy();
+			expect(breadcrumbs.light).toBeFalsy();
+			expect(breadcrumbs.small).toBeFalsy();
+		});
+
+		test('should create a new breadcrumbs with the defined values', () => {
+			const breadcrumbs = new Breadcrumbs({
+				name: 'breadcrumbs',
+				component: 'ZdBreadcrumbs',
+				dark: true,
+				divider: '>',
+				iconName: 'icon',
+				items: [{ text: 'item text' }],
+				large: true,
+				light: false,
+				small: true,
+			});
+
+			expect(breadcrumbs.dark).toBeTruthy();
+			expect(breadcrumbs.divider).toBe('>');
+			expect(breadcrumbs.iconName).toBe('icon');
+			expect(breadcrumbs.items).toStrictEqual([{ text: 'item text' }]);
+			expect(breadcrumbs.large).toBeTruthy();
+			expect(breadcrumbs.light).toBeFalsy();
+			expect(breadcrumbs.small).toBeTruthy();
+		});
+	});
+});

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

@@ -0,0 +1,79 @@
+import { Button } from '../../../../src';
+
+describe('Button', () => {
+	describe('constructor()', () => {
+		it('should create new button with default values', () => {
+			const instance = new Button({ name: 'button', component: 'Button' });
+			expect(instance.absolute).toBeFalsy();
+			expect(instance.bottom).toBeFalsy();
+			expect(instance.color).toBe('primary');
+			expect(instance.disabled).toBeFalsy();
+			expect(instance.fab).toBeFalsy();
+			expect(instance.fixed).toBeFalsy();
+			expect(instance.flat).toBeFalsy();
+			expect(instance.href).toBe('');
+			expect(instance.icon).toBeFalsy();
+			expect(instance.iconName).toBe('');
+			expect(instance.label).toBe('');
+			expect(instance.large).toBeFalsy();
+			expect(instance.left).toBeFalsy();
+			expect(instance.outline).toBeFalsy();
+			expect(instance.right).toBeFalsy();
+			expect(instance.round).toBeFalsy();
+			expect(instance.small).toBeFalsy();
+			expect(instance.target).toBe('_self');
+			expect(instance.to).toBe('');
+			expect(instance.top).toBeFalsy();
+			expect(instance.type).toBe('button');
+		});
+
+		it('should create new button replacing default values', () => {
+			const instance = new Button({
+				absolute: true,
+				bottom: true,
+				color: 'secondary',
+				component: 'Button',
+				disabled: true,
+				fab: true,
+				fixed: true,
+				flat: true,
+				href: 'http://zeedhi.com',
+				icon: true,
+				iconName: 'icon',
+				label: 'Zeedhi',
+				name: 'button',
+				large: true,
+				left: true,
+				outline: true,
+				right: true,
+				round: true,
+				small: true,
+				target: '_blank',
+				to: '/home',
+				top: true,
+				type: 'submit',
+			});
+			expect(instance.absolute).toBeTruthy();
+			expect(instance.bottom).toBeTruthy();
+			expect(instance.color).toBe('secondary');
+			expect(instance.disabled).toBeTruthy();
+			expect(instance.fab).toBeTruthy();
+			expect(instance.fixed).toBeTruthy();
+			expect(instance.flat).toBeTruthy();
+			expect(instance.href).toBe('http://zeedhi.com');
+			expect(instance.icon).toBeTruthy();
+			expect(instance.iconName).toBe('icon');
+			expect(instance.label).toBe('Zeedhi');
+			expect(instance.large).toBeTruthy();
+			expect(instance.left).toBeTruthy();
+			expect(instance.outline).toBeTruthy();
+			expect(instance.right).toBeTruthy();
+			expect(instance.round).toBeTruthy();
+			expect(instance.small).toBeTruthy();
+			expect(instance.target).toBe('_blank');
+			expect(instance.to).toBe('/home');
+			expect(instance.top).toBeTruthy();
+			expect(instance.type).toBe('submit');
+		});
+	});
+});