github
/
nocodb
mirror of https://github.com/nocodb/nocodb
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

work on map view tests - WIP

pull/4749/head
Daniel Spaude 2 years ago
parent
592d5c3672
commit
1c14d095c1
No known key found for this signature in database
GPG Key ID: 654A3D1FA4F35FFE
6 changed files with 355 additions and 416 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      packages/nc-gui/components/smartsheet/Map.vue
  2. 125
      tests/playwright/pages/Dashboard/Map/index.ts
  3. 6
      tests/playwright/pages/Dashboard/ViewSidebar/index.ts
  4. 5
      tests/playwright/pages/Dashboard/common/Toolbar/index.ts
  5. 2
      tests/playwright/tests/columnGeoData.spec.ts
  6. 629
      tests/playwright/tests/viewMap.spec.ts

4
packages/nc-gui/components/smartsheet/Map.vue
Unescape View File

@ -85,7 +85,9 @@ const addMarker = (lat: number, long: number, row: RowType) => {
if (markersClusterGroupRef.value == null) {
throw new Error('Marker cluster is null')
}
const newMarker = L.marker([lat, long]).on('click', () => {
const newMarker = L.marker([lat, long], {
alt: `${lat}, ${long}`
}).on('click', () => {
expandForm(row)
})
markersClusterGroupRef.value?.addLayer(newMarker)

125
tests/playwright/pages/Dashboard/Map/index.ts
Unescape View File

@ -1,4 +1,3 @@
import { expect } from '@playwright/test';
import { DashboardPage } from '..';
import BasePage from '../../Base';
import { ToolbarPage } from '../common/Toolbar';
@ -14,127 +13,29 @@ export class MapPage extends BasePage {
}
get() {
return this.dashboard.get().locator('[data-testid="nc-kanban-wrapper"]');
return this.dashboard.get().locator('[data-testid="nc-map-wrapper"]');
}
card(index: number) {
return this.get().locator(`.ant-card`).nth(index);
marker(lat: string, long: string) {
const latLongStr = `${lat}, ${long}`;
return this.get().locator(`.leaflet-marker-pane img[alt="${latLongStr}"]`);
}
async openExpandedRow({ index }: { index: number }) {
await this.card(index).click();
await (await this.rootPage.locator('.ant-drawer-body').elementHandle())?.waitForElementState('stable');
}
// todo: Implement
async addOption() {}
// todo: Implement
async dragDropCard(param: { from: string; to: string }) {
// const { from, to } = param;
// const srcStack = await this.get().locator(`.nc-kanban-stack`).nth(1);
// const dstStack = await this.get().locator(`.nc-kanban-stack`).nth(2);
// const fromCard = await srcStack.locator(`.nc-kanban-item`).nth(1);
// const toCard = await dstStack.locator(`.nc-kanban-item`).nth(1);
// const [fromCard, toCard] = await Promise.all([
// srcStack.locator(`.nc-kanban-item[data-draggable="true"]`).nth(0),
// dstStack.locator(`.nc-kanban-item[data-draggable="true"]`).nth(0),
// ]);
// const fromCard = await this.get().locator(`.nc-kanban-item`).nth(0);
// const toCard = await this.get().locator(`.nc-kanban-item`).nth(25);
// await fromCard.dragTo(toCard);
}
async dragDropStack(param: { from: number; to: number }) {
const { from, to } = param;
const [fromStack, toStack] = await Promise.all([
this.rootPage.locator(`.nc-kanban-stack-head`).nth(from),
this.rootPage.locator(`.nc-kanban-stack-head`).nth(to),
]);
await fromStack.dragTo(toStack);
}
async verifyStackCount(param: { count: number }) {
const { count } = param;
await expect(this.get().locator(`.nc-kanban-stack`)).toHaveCount(count);
}
async verifyStackOrder(param: { order: string[] }) {
const { order } = param;
const stacks = await this.get().locator(`.nc-kanban-stack`).count();
for (let i = 0; i < stacks; i++) {
const stack = await this.get().locator(`.nc-kanban-stack`).nth(i);
// Since otherwise stack title will be repeated as title is in two divs, with one having hidden class
const stackTitle = await stack.locator(`.nc-kanban-stack-head >> [data-testid="truncate-label"]`);
await expect(stackTitle).toHaveText(order[i], { ignoreCase: true });
async zoomOut(times: number) {
await this.rootPage.pause();
for (let i = 0; i < times; i++) {
await this.get().locator('.leaflet-control-zoom-out').click();
}
await this.rootPage.pause();
}
async verifyStackFooter(param: { count: number[] }) {
const { count } = param;
const stacks = await this.get().locator(`.nc-kanban-stack`).count();
for (let i = 0; i < stacks; i++) {
const stack = await this.get().locator(`.nc-kanban-stack`).nth(i);
const stackFooter = await stack.locator(`.nc-kanban-data-count`).innerText();
await expect(stackFooter).toContain(`${count[i]} record${count[i] !== 1 ? 's' : ''}`);
}
}
async verifyCardCount(param: { count: number[] }) {
const { count } = param;
const stacks = await this.get().locator(`.nc-kanban-stack`).count();
for (let i = 0; i < stacks; i++) {
const stack = await this.get().locator(`.nc-kanban-stack`).nth(i);
const stackCards = stack.locator(`.nc-kanban-item`);
await expect(stackCards).toHaveCount(count[i]);
}
}
async verifyCardOrder(param: { order: string[]; stackIndex: number }) {
const { order, stackIndex } = param;
const stack = await this.get().locator(`.nc-kanban-stack`).nth(stackIndex);
for (let i = 0; i < order.length; i++) {
const card = await stack.locator(`.nc-kanban-item`).nth(i);
const cardTitle = await card.locator(`.nc-cell`);
await expect(cardTitle).toHaveText(order[i]);
}
}
// async openExpandedRow({ index }: { index: number }) {
// await this.card(index).click();
// await (await this.rootPage.locator('.ant-drawer-body').elementHandle())?.waitForElementState('stable');
// }
// todo: Wait for render to complete
async waitLoading() {
await this.rootPage.waitForTimeout(1000);
}
async addNewStack(param: { title: string }) {
await this.toolbar.clickAddEditStack();
await this.toolbar.addEditStack.addOption({ title: param.title });
}
async collapseStack(param: { index: number }) {
await this.get().locator(`.nc-kanban-stack-head`).nth(param.index).click();
const modal = await this.rootPage.locator(`.nc-dropdown-kanban-stack-context-menu`);
await modal.locator('.ant-dropdown-menu-item:has-text("Collapse Stack")').click();
}
async expandStack(param: { index: number }) {
await this.rootPage.locator(`.nc-kanban-collapsed-stack`).nth(param.index).click();
}
async verifyCollapseStackCount(param: { count: number }) {
await expect(this.rootPage.locator('.nc-kanban-collapsed-stack')).toHaveCount(param.count);
}
async addCard(param: { stackIndex: number }) {
await this.get().locator(`.nc-kanban-stack-head`).nth(param.stackIndex).click();
const modal = await this.rootPage.locator(`.nc-dropdown-kanban-stack-context-menu`);
await modal.locator('.ant-dropdown-menu-item:has-text("Add new record")').click();
}
async deleteStack(param: { index: number }) {
await this.get().locator(`.nc-kanban-stack-head`).nth(param.index).click();
const modal = await this.rootPage.locator(`.nc-dropdown-kanban-stack-context-menu`);
await modal.locator('.ant-dropdown-menu-item:has-text("Delete Stack")').click();
const confirmationModal = await this.rootPage.locator(`.nc-modal-kanban-delete-stack`);
await confirmationModal.locator(`button:has-text("Delete")`).click();
}
}

6
tests/playwright/pages/Dashboard/ViewSidebar/index.ts
Unescape View File

@ -9,6 +9,7 @@ export class ViewSidebarPage extends BasePage {
readonly createGridButton: Locator;
readonly createFormButton: Locator;
readonly createKanbanButton: Locator;
readonly createMapButton: Locator;
constructor(dashboard: DashboardPage) {
super(dashboard.rootPage);
@ -17,6 +18,7 @@ export class ViewSidebarPage extends BasePage {
this.createGridButton = this.get().locator('.nc-create-grid-view:visible');
this.createFormButton = this.get().locator('.nc-create-form-view:visible');
this.createKanbanButton = this.get().locator('.nc-create-kanban-view:visible');
this.createMapButton = this.get().locator('.nc-create-map-view:visible');
}
get() {
@ -78,6 +80,10 @@ export class ViewSidebarPage extends BasePage {
await this.createView({ title, locator: this.createKanbanButton });
}
async createMapView({ title }: { title: string }) {
await this.createView({ title, locator: this.createMapButton });
}
// Todo: Make selection better
async verifyView({ title, index }: { title: string; index: number }) {
await expect(

5
tests/playwright/pages/Dashboard/common/Toolbar/index.ts
Unescape View File

@ -15,9 +15,10 @@ import { ToolbarStackbyPage } from './StackBy';
import { ToolbarAddEditStackPage } from './AddEditKanbanStack';
import { ToolbarSearchDataPage } from './SearchData';
import { RowHeight } from './RowHeight';
import { MapPage } from '../../Map';
export class ToolbarPage extends BasePage {
readonly parent: GridPage | GalleryPage | FormPage | KanbanPage;
readonly parent: GridPage | GalleryPage | FormPage | KanbanPage | MapPage;
readonly fields: ToolbarFieldsPage;
readonly sort: ToolbarSortPage;
readonly filter: ToolbarFilterPage;
@ -29,7 +30,7 @@ export class ToolbarPage extends BasePage {
readonly searchData: ToolbarSearchDataPage;
readonly rowHeight: RowHeight;
constructor(parent: GridPage | GalleryPage | FormPage | KanbanPage) {
constructor(parent: GridPage | GalleryPage | FormPage | KanbanPage | MapPage) {
super(parent.rootPage);
this.parent = parent;
this.fields = new ToolbarFieldsPage(this);

2
tests/playwright/tests/columnGeoData.spec.ts
Unescape View File

@ -3,7 +3,7 @@ import { DashboardPage } from '../pages/Dashboard';
import setup from '../setup';
import { GridPage } from '../pages/Dashboard/Grid';
test.describe.only('Geo Data column', () => {
test.describe('Geo Data column', () => {
let dashboard: DashboardPage;
let grid: GridPage;
let context: any;

629
tests/playwright/tests/viewMap.spec.ts
Unescape View File

@ -3,328 +3,357 @@ import { DashboardPage } from '../pages/Dashboard';
import { ToolbarPage } from '../pages/Dashboard/common/Toolbar';
import setup from '../setup';
import { isPg, isSqlite } from '../setup/db';
const filmRatings = ['G', 'PG', 'PG-13', 'R', 'NC-17'];
test.describe('Map View', () => {
test.describe.only('Map View', () => {
let dashboard: DashboardPage, toolbar: ToolbarPage;
let context: any;
test.beforeEach(async ({ page }) => {
context = await setup({ page });
dashboard = new DashboardPage(page, context.project);
toolbar = toolbar = dashboard.map.toolbar;
toolbar = dashboard.map.toolbar;
await dashboard.viewSidebar.activateGeoDataEasterEgg();
// close 'Team & Auth' tab
await dashboard.closeTab({ title: 'Team & Auth' });
await dashboard.treeView.openTable({ title: 'Film' });
if (isSqlite(context)) {
await dashboard.treeView.deleteTable({ title: 'FilmList' });
}
if (isPg(context)) {
// Since these view depend on the Ratings column of the Film table
await dashboard.treeView.deleteTable({ title: 'NicerButSlowerFilmList' });
await dashboard.treeView.deleteTable({ title: 'FilmList' });
}
if (isSqlite(context) || isPg(context)) {
await dashboard.grid.column.openEdit({ title: 'Rating' });
await dashboard.grid.column.selectType({ type: 'SingleSelect' });
let count = 0;
for (const rating of filmRatings) {
await dashboard.grid.column.selectOption.addOption({
index: count,
option: rating,
skipColumnModal: true,
});
count = count + 1;
}
await dashboard.grid.column.save();
}
});
test('Kanban', async () => {
await dashboard.viewSidebar.createKanbanView({
title: 'Film Kanban',
});
await dashboard.viewSidebar.verifyView({
title: 'Film Kanban',
index: 1,
});
await dashboard.treeView.openTable({ title: 'Actor' });
// configure stack-by field
await toolbar.clickStackByField();
await toolbar.stackBy.click({ title: 'Rating' });
// click again to close menu
await toolbar.clickStackByField();
const grid = dashboard.grid;
const kanban = dashboard.kanban;
await kanban.verifyStackCount({ count: 6 });
await kanban.verifyStackOrder({
order: ['Uncategorized', 'G', 'PG', 'PG-13', 'R', 'NC-17'],
});
await kanban.verifyStackFooter({
count: [0, 178, 194, 223, 195, 210],
});
await kanban.verifyCardCount({
count: [0, 25, 25, 25, 25, 25],
await grid.column.create({
title: 'Actors Birthplace',
type: 'GeoData',
});
// hide fields
await toolbar.fields.hideAll();
await toolbar.fields.toggle({ title: 'Title' });
await kanban.verifyCardCount({
count: [0, 25, 25, 25, 25, 25],
});
await grid.column.verify({ title: 'Actors Birthplace', isVisible: true });
// verify card order
const order = [
['ACE GOLDFINGER', 'AFFAIR PREJUDICE', 'AFRICAN EGG'],
['ACADEMY DINOSAUR', 'AGENT TRUMAN', 'ALASKA PHANTOM'],
['AIRPLANE SIERRA', 'ALABAMA DEVIL', 'ALTER VICTORY'],
['AIRPORT POLLOCK', 'ALONE TRIP', 'AMELIE HELLFIGHTERS'],
['ADAPTATION HOLES', 'ALADDIN CALENDAR', 'ALICE FANTASIA'],
];
for (let i = 1; i <= order.length; i++)
await kanban.verifyCardOrder({
stackIndex: i,
order: order[i - 1],
});
// // verify inter stack drag-drop
// await kanban.dragDropCard({
// from: "ACE GOLDFINGER",
// to: "ACADEMY DINOSAUR",
// });
// verify drag drop stack
await kanban.dragDropStack({
from: 1, // G
to: 2, // PG
await grid.cell.geoData.open({
index: 0,
columnHeader: 'Actors Birthplace',
});
await kanban.verifyStackOrder({
order: ['Uncategorized', 'PG', 'G', 'PG-13', 'R', 'NC-17'],
});
// verify drag drop stack
await kanban.dragDropStack({
from: 2, // G
to: 1, // PG
});
await kanban.verifyStackOrder({
order: ['Uncategorized', 'G', 'PG', 'PG-13', 'R', 'NC-17'],
await grid.cell.geoData.enterLatLong({
lat: '50.4501',
long: '30.5234',
});
await grid.cell.geoData.clickSave();
// verify sort
await toolbar.sort.add({
columnTitle: 'Title',
isAscending: false,
isLocallySaved: false,
});
// verify card order
const order2 = [
['YOUNG LANGUAGE', 'WEST LION'],
['WORST BANGER', 'WORDS HUNTER'],
];
for (let i = 1; i <= order2.length; i++)
await kanban.verifyCardOrder({
stackIndex: i,
order: order2[i - 1],
});
await toolbar.sort.reset();
// verify card order
const order3 = [
['ACE GOLDFINGER', 'AFFAIR PREJUDICE', 'AFRICAN EGG'],
['ACADEMY DINOSAUR', 'AGENT TRUMAN', 'ALASKA PHANTOM'],
];
for (let i = 1; i <= order3.length; i++)
await kanban.verifyCardOrder({
stackIndex: i,
order: order3[i - 1],
});
// verify filter
await toolbar.clickFilter({
networkValidation: true,
await grid.cell.verifyGeoDataCell({
index: 0,
columnHeader: 'Actors Birthplace',
lat: '50.4501000',
long: '30.5234000',
});
await toolbar.filter.add({
columnTitle: 'Title',
opType: 'is like',
value: 'BA',
isLocallySaved: false,
});
await toolbar.clickFilter();
// verify card order
const order4 = [
['BAKED CLEOPATRA', 'BALLROOM MOCKINGBIRD'],
['ARIZONA BANG', 'EGYPT TENENBAUMS'],
];
for (let i = 1; i <= order4.length; i++)
await kanban.verifyCardOrder({
stackIndex: i,
order: order4[i - 1],
});
await toolbar.filter.reset();
const order5 = [
['ACE GOLDFINGER', 'AFFAIR PREJUDICE', 'AFRICAN EGG'],
['ACADEMY DINOSAUR', 'AGENT TRUMAN', 'ALASKA PHANTOM'],
];
for (let i = 1; i <= order5.length; i++)
await kanban.verifyCardOrder({
stackIndex: i,
order: order5[i - 1],
});
await dashboard.rootPage.waitForTimeout(1000);
});
test('Kanban view operations', async () => {
test.slow();
await dashboard.viewSidebar.createKanbanView({
title: 'Film Kanban',
});
await dashboard.viewSidebar.verifyView({
title: 'Film Kanban',
index: 1,
});
await toolbar.sort.add({
columnTitle: 'Title',
isAscending: false,
isLocallySaved: false,
});
await toolbar.clickFilter();
await toolbar.filter.add({
columnTitle: 'Title',
opType: 'is like',
value: 'BA',
isLocallySaved: false,
});
await toolbar.clickFilter();
await toolbar.fields.hideAll();
await toolbar.fields.toggle({ title: 'Title' });
await dashboard.viewSidebar.copyView({ title: 'Film Kanban' });
await dashboard.viewSidebar.verifyView({
title: 'Kanban-1',
index: 2,
});
const kanban = dashboard.kanban;
await kanban.verifyStackCount({ count: 6 });
await kanban.verifyStackOrder({
order: ['Uncategorized', 'G', 'PG', 'PG-13', 'R', 'NC-17'],
});
await kanban.verifyStackFooter({
count: [0, 4, 5, 8, 6, 6],
});
await kanban.verifyCardCount({
count: [0, 4, 5, 8, 6, 6],
});
// verify card order
const order2 = [
['BAREFOOT MANCHURIAN', 'BARBARELLA STREETCAR'],
['WORST BANGER', 'PRESIDENT BANG'],
];
for (let i = 1; i <= order2.length; i++)
await kanban.verifyCardOrder({
stackIndex: i,
order: order2[i - 1],
});
await dashboard.viewSidebar.changeViewIcon({
title: 'Kanban-1',
icon: 'american-football',
});
await dashboard.viewSidebar.deleteView({ title: 'Kanban-1' });
///////////////////////////////////////////////
await dashboard.viewSidebar.openView({ title: 'Film Kanban' });
// add new stack
await kanban.addNewStack({ title: 'Test' });
await dashboard.rootPage.waitForTimeout(1000);
await kanban.verifyStackCount({ count: 7 });
await kanban.verifyStackOrder({
order: ['Uncategorized', 'G', 'PG', 'PG-13', 'R', 'NC-17', 'Test'],
});
// collapse stack
await kanban.verifyCollapseStackCount({ count: 0 });
await kanban.collapseStack({ index: 0 });
await kanban.verifyCollapseStackCount({ count: 1 });
await kanban.expandStack({ index: 0 });
await kanban.verifyCollapseStackCount({ count: 0 });
// add record to stack & verify
await toolbar.fields.hideAll();
await toolbar.fields.toggleShowSystemFields();
await toolbar.fields.toggle({ title: 'LanguageId' });
await toolbar.fields.toggle({ title: 'Title' });
await toolbar.sort.reset();
await toolbar.filter.reset();
await kanban.addCard({ stackIndex: 6 });
await dashboard.expandedForm.fillField({
columnTitle: 'Title',
value: 'New record',
});
await dashboard.expandedForm.fillField({
columnTitle: 'LanguageId',
value: '1',
});
// todo: Check why kanban doesnt reload the rows data
await dashboard.expandedForm.save({ waitForRowsData: false });
await kanban.verifyStackCount({ count: 7 });
await kanban.verifyStackOrder({
order: ['Uncategorized', 'G', 'PG', 'PG-13', 'R', 'NC-17', 'Test'],
});
await kanban.verifyCardCount({
count: [0, 25, 25, 25, 25, 25, 1],
});
// delete stack
await kanban.deleteStack({ index: 6 });
await dashboard.rootPage.waitForTimeout(1000);
await kanban.verifyStackCount({ count: 6 });
await kanban.verifyStackOrder({
order: ['Uncategorized', 'G', 'PG', 'PG-13', 'R', 'NC-17'],
});
await kanban.verifyCardCount({
count: [1, 25, 25, 25, 25, 25],
// if (isSqlite(context)) {
// await dashboard.treeView.deleteTable({ title: 'FilmList' });
// }
// if (isPg(context)) {
// // Since these view depend on the Ratings column of the Film table
// await dashboard.treeView.deleteTable({ title: 'NicerButSlowerFilmList' });
// await dashboard.treeView.deleteTable({ title: 'FilmList' });
// }
// if (isSqlite(context) || isPg(context)) {
// await dashboard.grid.column.openEdit({ title: 'Rating' });
// await dashboard.grid.column.selectType({ type: 'SingleSelect' });
// let count = 0;
// for (const rating of filmRatings) {
// await dashboard.grid.column.selectOption.addOption({
// index: count,
// option: rating,
// skipColumnModal: true,
// });
// count = count + 1;
// }
// await dashboard.grid.column.save();
// }
test('Map View', async () => {
await dashboard.viewSidebar.createMapView({
title: 'Map 1',
});
// Zoom out
await dashboard.map.zoomOut();
});
test('Kanban shared view operations', async ({ page }) => {
test.slow();
await dashboard.viewSidebar.createKanbanView({
title: 'Film Kanban',
});
await dashboard.viewSidebar.verifyView({
title: 'Film Kanban',
index: 1,
});
// Share view
await toolbar.fields.toggle({ title: 'Rating' });
await toolbar.clickShareView();
const sharedLink = await toolbar.shareView.getShareLink();
await toolbar.shareView.close();
// sign-out
await dashboard.signOut();
// Open shared view & verify stack count
await page.goto(sharedLink);
const kanban = dashboard.kanban;
await kanban.verifyStackCount({ count: 6 });
});
// await dashboard.viewSidebar.verifyView({
// title: 'Film Kanban',
// index: 1,
// });
// // configure stack-by field
// await toolbar.clickStackByField();
// await toolbar.stackBy.click({ title: 'Rating' });
// // click again to close menu
// await toolbar.clickStackByField();
// const kanban = dashboard.kanban;
// await kanban.verifyStackCount({ count: 6 });
// await kanban.verifyStackOrder({
// order: ['Uncategorized', 'G', 'PG', 'PG-13', 'R', 'NC-17'],
// });
// await kanban.verifyStackFooter({
// count: [0, 178, 194, 223, 195, 210],
// });
// await kanban.verifyCardCount({
// count: [0, 25, 25, 25, 25, 25],
// });
// // hide fields
// await toolbar.fields.hideAll();
// await toolbar.fields.toggle({ title: 'Title' });
// await kanban.verifyCardCount({
// count: [0, 25, 25, 25, 25, 25],
// });
// // verify card order
// const order = [
// ['ACE GOLDFINGER', 'AFFAIR PREJUDICE', 'AFRICAN EGG'],
// ['ACADEMY DINOSAUR', 'AGENT TRUMAN', 'ALASKA PHANTOM'],
// ['AIRPLANE SIERRA', 'ALABAMA DEVIL', 'ALTER VICTORY'],
// ['AIRPORT POLLOCK', 'ALONE TRIP', 'AMELIE HELLFIGHTERS'],
// ['ADAPTATION HOLES', 'ALADDIN CALENDAR', 'ALICE FANTASIA'],
// ];
// for (let i = 1; i <= order.length; i++)
// await kanban.verifyCardOrder({
// stackIndex: i,
// order: order[i - 1],
// });
// // // verify inter stack drag-drop
// // await kanban.dragDropCard({
// // from: "ACE GOLDFINGER",
// // to: "ACADEMY DINOSAUR",
// // });
// // verify drag drop stack
// await kanban.dragDropStack({
// from: 1, // G
// to: 2, // PG
// });
// await kanban.verifyStackOrder({
// order: ['Uncategorized', 'PG', 'G', 'PG-13', 'R', 'NC-17'],
// });
// // verify drag drop stack
// await kanban.dragDropStack({
// from: 2, // G
// to: 1, // PG
// });
// await kanban.verifyStackOrder({
// order: ['Uncategorized', 'G', 'PG', 'PG-13', 'R', 'NC-17'],
// });
// // verify sort
// await toolbar.sort.add({
// columnTitle: 'Title',
// isAscending: false,
// isLocallySaved: false,
// });
// // verify card order
// const order2 = [
// ['YOUNG LANGUAGE', 'WEST LION'],
// ['WORST BANGER', 'WORDS HUNTER'],
// ];
// for (let i = 1; i <= order2.length; i++)
// await kanban.verifyCardOrder({
// stackIndex: i,
// order: order2[i - 1],
// });
// await toolbar.sort.reset();
// // verify card order
// const order3 = [
// ['ACE GOLDFINGER', 'AFFAIR PREJUDICE', 'AFRICAN EGG'],
// ['ACADEMY DINOSAUR', 'AGENT TRUMAN', 'ALASKA PHANTOM'],
// ];
// for (let i = 1; i <= order3.length; i++)
// await kanban.verifyCardOrder({
// stackIndex: i,
// order: order3[i - 1],
// });
// // verify filter
// await toolbar.clickFilter({
// networkValidation: true,
// });
// await toolbar.filter.add({
// columnTitle: 'Title',
// opType: 'is like',
// value: 'BA',
// isLocallySaved: false,
// });
// await toolbar.clickFilter();
// // verify card order
// const order4 = [
// ['BAKED CLEOPATRA', 'BALLROOM MOCKINGBIRD'],
// ['ARIZONA BANG', 'EGYPT TENENBAUMS'],
// ];
// for (let i = 1; i <= order4.length; i++)
// await kanban.verifyCardOrder({
// stackIndex: i,
// order: order4[i - 1],
// });
// await toolbar.filter.reset();
// const order5 = [
// ['ACE GOLDFINGER', 'AFFAIR PREJUDICE', 'AFRICAN EGG'],
// ['ACADEMY DINOSAUR', 'AGENT TRUMAN', 'ALASKA PHANTOM'],
// ];
// for (let i = 1; i <= order5.length; i++)
// await kanban.verifyCardOrder({
// stackIndex: i,
// order: order5[i - 1],
// });
// await dashboard.rootPage.waitForTimeout(1000);
// });
// test('Kanban view operations', async () => {
// test.slow();
// await dashboard.viewSidebar.createKanbanView({
// title: 'Film Kanban',
// });
// await dashboard.viewSidebar.verifyView({
// title: 'Film Kanban',
// index: 1,
// });
// await toolbar.sort.add({
// columnTitle: 'Title',
// isAscending: false,
// isLocallySaved: false,
// });
// await toolbar.clickFilter();
// await toolbar.filter.add({
// columnTitle: 'Title',
// opType: 'is like',
// value: 'BA',
// isLocallySaved: false,
// });
// await toolbar.clickFilter();
// await toolbar.fields.hideAll();
// await toolbar.fields.toggle({ title: 'Title' });
// await dashboard.viewSidebar.copyView({ title: 'Film Kanban' });
// await dashboard.viewSidebar.verifyView({
// title: 'Kanban-1',
// index: 2,
// });
// const kanban = dashboard.kanban;
// await kanban.verifyStackCount({ count: 6 });
// await kanban.verifyStackOrder({
// order: ['Uncategorized', 'G', 'PG', 'PG-13', 'R', 'NC-17'],
// });
// await kanban.verifyStackFooter({
// count: [0, 4, 5, 8, 6, 6],
// });
// await kanban.verifyCardCount({
// count: [0, 4, 5, 8, 6, 6],
// });
// // verify card order
// const order2 = [
// ['BAREFOOT MANCHURIAN', 'BARBARELLA STREETCAR'],
// ['WORST BANGER', 'PRESIDENT BANG'],
// ];
// for (let i = 1; i <= order2.length; i++)
// await kanban.verifyCardOrder({
// stackIndex: i,
// order: order2[i - 1],
// });
// await dashboard.viewSidebar.changeViewIcon({
// title: 'Kanban-1',
// icon: 'american-football',
// });
// await dashboard.viewSidebar.deleteView({ title: 'Kanban-1' });
// ///////////////////////////////////////////////
// await dashboard.viewSidebar.openView({ title: 'Film Kanban' });
// // add new stack
// await kanban.addNewStack({ title: 'Test' });
// await dashboard.rootPage.waitForTimeout(1000);
// await kanban.verifyStackCount({ count: 7 });
// await kanban.verifyStackOrder({
// order: ['Uncategorized', 'G', 'PG', 'PG-13', 'R', 'NC-17', 'Test'],
// });
// // collapse stack
// await kanban.verifyCollapseStackCount({ count: 0 });
// await kanban.collapseStack({ index: 0 });
// await kanban.verifyCollapseStackCount({ count: 1 });
// await kanban.expandStack({ index: 0 });
// await kanban.verifyCollapseStackCount({ count: 0 });
// // add record to stack & verify
// await toolbar.fields.hideAll();
// await toolbar.fields.toggleShowSystemFields();
// await toolbar.fields.toggle({ title: 'LanguageId' });
// await toolbar.fields.toggle({ title: 'Title' });
// await toolbar.sort.reset();
// await toolbar.filter.reset();
// await kanban.addCard({ stackIndex: 6 });
// await dashboard.expandedForm.fillField({
// columnTitle: 'Title',
// value: 'New record',
// });
// await dashboard.expandedForm.fillField({
// columnTitle: 'LanguageId',
// value: '1',
// });
// // todo: Check why kanban doesnt reload the rows data
// await dashboard.expandedForm.save({ waitForRowsData: false });
// await kanban.verifyStackCount({ count: 7 });
// await kanban.verifyStackOrder({
// order: ['Uncategorized', 'G', 'PG', 'PG-13', 'R', 'NC-17', 'Test'],
// });
// await kanban.verifyCardCount({
// count: [0, 25, 25, 25, 25, 25, 1],
// });
// // delete stack
// await kanban.deleteStack({ index: 6 });
// await dashboard.rootPage.waitForTimeout(1000);
// await kanban.verifyStackCount({ count: 6 });
// await kanban.verifyStackOrder({
// order: ['Uncategorized', 'G', 'PG', 'PG-13', 'R', 'NC-17'],
// });
// await kanban.verifyCardCount({
// count: [1, 25, 25, 25, 25, 25],
// });
// });
// test('Kanban shared view operations', async ({ page }) => {
// test.slow();
// await dashboard.viewSidebar.createKanbanView({
// title: 'Film Kanban',
// });
// await dashboard.viewSidebar.verifyView({
// title: 'Film Kanban',
// index: 1,
// });
// // Share view
// await toolbar.fields.toggle({ title: 'Rating' });
// await toolbar.clickShareView();
// const sharedLink = await toolbar.shareView.getShareLink();
// await toolbar.shareView.close();
// // sign-out
// await dashboard.signOut();
// // Open shared view & verify stack count
// await page.goto(sharedLink);
// const kanban = dashboard.kanban;
// await kanban.verifyStackCount({ count: 6 });
// });
});

Write Preview
Loading…
Cancel
Save