slick-table 1.1.5 → 1.1.7

package/src/shared/lib/slickgrid/model/SlickTable/filters/decorators/ColumnFilter/Filter.test.ts

@@ -1,264 +0,0 @@
-import { EColumnFilter } from "shared/model/enums";
-
-import { filter } from "./Filter";
-
-describe("Filter", () => {
-	const spring = "2024-03-20",
-		summer = "2024-06-21",
-		automn = "2024-09-23",
-		winter = "2024-12-21";
-
-	it("should filter EColumnFilter.Boolean", () => {
-		const trueResult = filter.passed(
-			"1",
-			{ 1: "true", 2: "" },
-			EColumnFilter.Boolean,
-		);
-		const falseResult = filter.passed(
-			"0",
-			{ 1: "", 2: "false" },
-			EColumnFilter.Boolean,
-		);
-		const falseResult_ = filter.passed(
-			"10",
-			{ 1: "", 2: "false" },
-			EColumnFilter.Boolean,
-		);
-		const emptyResult = filter.passed(
-			"",
-			{ 1: "", 2: "false" },
-			EColumnFilter.Boolean,
-		);
-		const defaultResult = filter.passed(
-			"0",
-			{ 1: "", 2: "" },
-			EColumnFilter.Boolean,
-		);
-
-		expect(trueResult).toBe(true);
-		expect(falseResult).toBe(true);
-		expect(falseResult_).toBe(false);
-		expect(emptyResult).toBe(true);
-		expect(defaultResult).toBe(true);
-	});
-
-	it("should filter EColumnFilter.DateBetween", () => {
-		const between = filter.passed(
-			summer,
-			{ 1: spring, 2: automn },
-			EColumnFilter.DateBetween,
-		);
-		const before = filter.passed(
-			summer,
-			{ 1: automn, 2: winter },
-			EColumnFilter.DateBetween,
-		);
-		const after = filter.passed(
-			winter,
-			{ 1: spring, 2: automn },
-			EColumnFilter.DateBetween,
-		);
-
-		const before2 = filter.passed(
-			winter,
-			{ 1: spring, 2: "" },
-			EColumnFilter.DateBetween,
-		);
-		const after2 = filter.passed(
-			winter,
-			{ 1: "", 2: automn },
-			EColumnFilter.DateBetween,
-		);
-
-		expect(between).toBe(true);
-		expect(before).toBe(false);
-		expect(after).toBe(false);
-		expect(before2).toBe(true);
-		expect(after2).toBe(false);
-	});
-
-	it("should filter EColumnFilter.DateEqual", () => {
-		const dateEqual = filter.passed(
-			summer,
-			{ 1: summer, 2: "" },
-			EColumnFilter.DateEqual,
-		);
-		const dateNotEqual = filter.passed(
-			summer,
-			{ 1: winter, 2: "" },
-			EColumnFilter.DateEqual,
-		);
-
-		expect(dateEqual).toBe(true);
-		expect(dateNotEqual).toBe(false);
-	});
-
-	it("should filter EColumnFilter.DateTo", () => {
-		const dateBefore = filter.passed(
-			spring,
-			{ 1: summer, 2: "" },
-			EColumnFilter.DateTo,
-		);
-		const sameDay = filter.passed(
-			summer,
-			{ 1: summer, 2: "" },
-			EColumnFilter.DateTo,
-		);
-		const dateAfter = filter.passed(
-			summer,
-			{ 1: spring, 2: "" },
-			EColumnFilter.DateTo,
-		);
-
-		expect(dateBefore).toBe(true);
-		expect(sameDay).toBe(true);
-		expect(dateAfter).toBe(false);
-	});
-
-	it("should filter EColumnFilter.DateFrom", () => {
-		const dateBefore = filter.passed(
-			spring,
-			{ 1: summer, 2: "" },
-			EColumnFilter.DateFrom,
-		);
-		const sameDay = filter.passed(
-			summer,
-			{ 1: summer, 2: "" },
-			EColumnFilter.DateFrom,
-		);
-		const dateAfter = filter.passed(
-			summer,
-			{ 1: spring, 2: "" },
-			EColumnFilter.DateFrom,
-		);
-
-		expect(dateBefore).toBe(false);
-		expect(sameDay).toBe(true);
-		expect(dateAfter).toBe(true);
-	});
-
-	it("should filter EColumnFilter.NumberBetween", () => {
-		const value = { 1: "25", 2: "75" };
-		const result1 = filter.passed("50", value, EColumnFilter.NumberBetween);
-		const result2 = filter.passed("20", value, EColumnFilter.NumberBetween);
-		const result3 = filter.passed("80", value, EColumnFilter.NumberBetween);
-
-		const result4 = filter.passed(
-			"20",
-			{ 1: "", 2: "50" },
-			EColumnFilter.NumberBetween,
-		);
-
-		const result5 = filter.passed(
-			"20",
-			{ 1: "10", 2: "" },
-			EColumnFilter.NumberBetween,
-		);
-
-		expect(result1).toBe(true);
-		expect(result2).toBe(false);
-		expect(result3).toBe(false);
-		expect(result4).toBe(true);
-		expect(result5).toBe(true);
-	});
-
-	it("should filter EColumnFilter.NumberFrom", () => {
-		const value = { 1: "25", 2: "" };
-		const result1 = filter.passed("50", value, EColumnFilter.NumberFrom);
-		const result2 = filter.passed("25", value, EColumnFilter.NumberFrom);
-		const result3 = filter.passed("20", value, EColumnFilter.NumberFrom);
-
-		expect(result1).toBe(true);
-		expect(result2).toBe(true);
-		expect(result3).toBe(false);
-	});
-
-	it("should filter EColumnFilter.NumberTo", () => {
-		const value = { 1: "25", 2: "" };
-		const result1 = filter.passed("50", value, EColumnFilter.NumberTo);
-		const result2 = filter.passed("25", value, EColumnFilter.NumberTo);
-		const result3 = filter.passed("20", value, EColumnFilter.NumberTo);
-
-		expect(result1).toBe(false);
-		expect(result2).toBe(true);
-		expect(result3).toBe(true);
-	});
-
-	it("should filter EColumnFilter.NumberEqual", () => {
-		const value = { 1: "25", 2: "" };
-		const result1 = filter.passed("50", value, EColumnFilter.NumberEqual);
-		const result2 = filter.passed("25", value, EColumnFilter.NumberEqual);
-		const result3 = filter.passed("20", value, EColumnFilter.NumberEqual);
-
-		expect(result1).toBe(false);
-		expect(result2).toBe(true);
-		expect(result3).toBe(false);
-	});
-
-	it("should filter EColumnFilter.TextEqual", () => {
-		const value = { 1: "hello world", 2: "" };
-		const result1 = filter.passed(
-			"Hello World",
-			value,
-			EColumnFilter.TextEqual,
-		);
-		const result2 = filter.passed(
-			"HELLO WORLD",
-			value,
-			EColumnFilter.TextEqual,
-		);
-		const result3 = filter.passed(
-			"Goodbye World",
-			value,
-			EColumnFilter.TextEqual,
-		);
-
-		expect(result1).toBe(true);
-		expect(result2).toBe(true);
-		expect(result3).toBe(false);
-	});
-
-	it("should filter EColumnFilter.TextNotEqual", () => {
-		const value = { 1: "hello world", 2: "" };
-		const result1 = filter.passed(
-			"Hello World",
-			value,
-			EColumnFilter.TextNotEqual,
-		);
-		const result2 = filter.passed(
-			"HELLO WORLD",
-			value,
-			EColumnFilter.TextNotEqual,
-		);
-		const result3 = filter.passed(
-			"Goodbye World",
-			value,
-			EColumnFilter.TextNotEqual,
-		);
-
-		expect(result1).toBe(false);
-		expect(result2).toBe(false);
-		expect(result3).toBe(true);
-	});
-
-	it("should filter EColumnFilter.TextContain (returns an array of matching string)", () => {
-		const string = "any value",
-			matching = "an";
-		const result = filter.passed(
-			string,
-			{ 1: matching, 2: "" },
-			EColumnFilter.TextContain,
-		);
-
-		expect(result).toBeTruthy();
-	});
-
-	it("should filter EColumnFilter.TextNotContain", () => {
-		const result = filter.passed(
-			"any value",
-			{ 1: " val", 2: "" },
-			EColumnFilter.TextNotContain,
-		);
-		expect(result).toBe(false);
-	});
-});

package/src/shared/lib/slickgrid/model/SlickTable/filters/decorators/DecoratorFilter.test.ts

@@ -1,139 +0,0 @@
-import { SlickGrid } from "slickgrid";
-
-import { ISlickRow } from "shared/model/types";
-import { IFilter } from "shared/model/types";
-
-import { SlickTable } from "../../table";
-import { DecoratorFilter } from "./DecoratorFilter";
-
-class TestDecoratorFilter extends DecoratorFilter {
-	filterFn(): boolean {
-		return true;
-	}
-}
-
-describe("DecoratorFilter", () => {
-	let decoratorFilter: TestDecoratorFilter;
-	let mockFilter: IFilter;
-
-	beforeEach(() => {
-		mockFilter = {
-			getFilterFn: jest.fn(),
-			reset: jest.fn(),
-			print: jest.fn(),
-			args: {},
-			grid: {} as SlickGrid,
-			tableId: "test-table",
-		} as unknown as IFilter;
-
-		decoratorFilter = new TestDecoratorFilter(mockFilter);
-	});
-
-	it("should combine the decorator's filterFn with the wrapped filter's filterFn", () => {
-		jest
-			.spyOn(mockFilter, "getFilterFn")
-			.mockReturnValue((row) => row.id % 2 === 0);
-
-		jest
-			.spyOn(decoratorFilter, "filterFn")
-			.mockImplementation((row: ISlickRow) => row.value > 10);
-
-		const combinedFilterFn = decoratorFilter.getFilterFn();
-
-		const row1 = { id: 1, value: 15 };
-		const row2 = { id: 2, value: 5 };
-		const row3 = { id: 3, value: 20 };
-		const row4 = { id: 4, value: 25 };
-
-		expect(combinedFilterFn(row1, {})).toBe(false);
-		expect(combinedFilterFn(row2, {})).toBe(false);
-		expect(combinedFilterFn(row3, {})).toBe(false);
-		expect(combinedFilterFn(row4, {})).toBe(true);
-
-		expect(mockFilter.getFilterFn).toHaveBeenCalledTimes(1);
-	});
-
-	it("should set and get args through the decorator", () => {
-		const testArgs = { key: "value" };
-
-		decoratorFilter.args = testArgs;
-		expect(decoratorFilter.args).toEqual(testArgs);
-		expect(mockFilter.args).toEqual(testArgs);
-
-		const retrievedArgs = decoratorFilter.args;
-
-		expect(retrievedArgs).toEqual(testArgs);
-	});
-
-	it("should set and get grid through the decorator", () => {
-		mockFilter.grid = null;
-		decoratorFilter = new TestDecoratorFilter(mockFilter);
-		const testGrid = {} as SlickGrid;
-		decoratorFilter.grid = testGrid;
-
-		expect(decoratorFilter.grid).toBe(testGrid);
-		expect(mockFilter.grid).toBe(testGrid);
-
-		const retrievedGrid = decoratorFilter.grid;
-
-		expect(retrievedGrid).toBe(testGrid);
-	});
-
-	it("should set and get tableId through the decorator", () => {
-		const testTableId = "test-table-id";
-
-		mockFilter.tableId = "";
-		decoratorFilter.tableId = testTableId;
-
-		expect(decoratorFilter.tableId).toBe(testTableId);
-		expect(mockFilter.tableId).toBe(testTableId);
-
-		const retrievedTableId = decoratorFilter.tableId;
-		expect(retrievedTableId).toBe(testTableId);
-	});
-
-	it("should register the filter with the grid and apply it to the data view", () => {
-		mockFilter.args = { testArg: "value" };
-		mockFilter.grid = null;
-		jest.spyOn(mockFilter, "getFilterFn").mockReturnValue(() => true);
-
-		const mockDataView = {
-			setFilter: jest.fn(),
-			setFilterArgs: jest.fn(),
-			refresh: jest.fn(),
-		};
-
-		const mockGrid = {
-			getData: jest.fn().mockReturnValue(mockDataView),
-		} as unknown as SlickGrid;
-
-		decoratorFilter.register(mockGrid, "test-table-id");
-
-		expect(decoratorFilter.tableId).toBe("test-table-id");
-		expect(decoratorFilter.grid).toBe(mockGrid);
-		expect(mockGrid.getData).toHaveBeenCalled();
-		expect(mockDataView.setFilter).toHaveBeenCalledWith(expect.any(Function));
-		expect(mockDataView.setFilterArgs).toHaveBeenCalledWith(mockFilter.args);
-		expect(mockDataView.refresh).toHaveBeenCalled();
-	});
-
-	it("should return the wrapped filter's print result when print is called", () => {
-		const mockTable = {} as SlickTable;
-		const mockPrintResult = [
-			document.createElement("tr"),
-			document.createElement("tr"),
-		];
-
-		jest.spyOn(mockFilter, "print").mockReturnValue(mockPrintResult);
-		const result = decoratorFilter.print(mockTable);
-
-		expect(mockFilter.print).toHaveBeenCalledWith(mockTable);
-		expect(result).toBe(mockPrintResult);
-	});
-
-	it("should reset both the decorator and the wrapped filter when reset is called", () => {
-		decoratorFilter.reset();
-
-		expect(mockFilter.reset).toHaveBeenCalledTimes(1);
-	});
-});

package/src/shared/lib/slickgrid/model/SlickTable/printer/DefaultPrinter.test.ts

@@ -1,226 +0,0 @@
-import { SlickGrid } from "slickgrid";
-
-import { injectStore } from "shared/model/redux";
-
-// eslint-disable-next-line import/no-internal-modules
-import * as getDisplayedRowsModule from "../../../lib/functions/getDisplayedRows";
-import { SlickTable } from "../table";
-import { DefaultPrinter } from "./DefaultPrinter";
-import { Printer } from "./model";
-
-jest.mock("app/store/store");
-
-describe("shared | slickgrid | DefaultPrinter", () => {
-	let defaultPrinter: Printer;
-	let mockTable: SlickTable;
-	let mockStore: any;
-
-	beforeEach(() => {
-		defaultPrinter = new DefaultPrinter();
-		mockTable = {
-			id: "mock_table",
-			name: "Mock Table",
-			grid: {
-				getColumns: jest.fn().mockReturnValue([]),
-				getData: jest.fn().mockReturnValue({
-					getItem: jest.fn(),
-					getItemMetadata: jest.fn(),
-				}),
-			} as unknown as SlickGrid,
-		} as unknown as SlickTable;
-
-		mockStore = {
-			getState: jest.fn().mockReturnValue({
-				client: {
-					clientInfo: {
-						value: "Test Client",
-					},
-				},
-			}),
-		};
-		injectStore(mockStore);
-	});
-
-	it("should create a client name row with correct colspan when client name is provided", () => {
-		const instance = new DefaultPrinter();
-		const result = instance.clientName();
-
-		expect(result.tagName).toBe("TR");
-		expect(result.children.length).toBe(1);
-		expect(result.children[0].tagName).toBe("TH");
-		expect(result.children[0].classList.contains("client")).toBe(true);
-		expect(result.children[0].getAttribute("colspan")).toBe("4");
-		expect(result.children[0].innerText).toBe("Test Client");
-	});
-
-	it("should generate column names row with correct number of columns based on 'forPrint' property", () => {
-		const mockColumns = [
-			{ name: "Column 1", forPrint: true },
-			{ name: "Column 2", forPrint: false },
-			{ name: "Column 3", forPrint: true },
-			{ name: "Column 4", forPrint: true },
-		];
-		jest.spyOn(mockTable.grid, "getColumns").mockReturnValue(mockColumns);
-		const result = defaultPrinter.columnNames(mockTable);
-
-		expect(result.tagName).toBe("TR");
-		expect(result.children.length).toBe(3);
-		expect(
-			Array.from(result.children).every((child) => child.tagName === "TH"),
-		).toBe(true);
-		expect(
-			Array.from(result.children).every((child) =>
-				child.classList.contains("column_name"),
-			),
-		).toBe(true);
-		expect(result.children[0].innerText).toBe("Column 1");
-		expect(result.children[1].innerText).toBe("Column 3");
-		expect(result.children[2].innerText).toBe("Column 4");
-	});
-
-	it("should create table name and time row with current date in correct format", () => {
-		mockTable.name = "Test Table";
-
-		const result = defaultPrinter.tableNameAndTime(mockTable);
-
-		expect(result.tagName).toBe("TR");
-		expect(result.classList.contains("heading")).toBe(true);
-		expect(result.children.length).toBe(2);
-
-		const tableName = result.children[0] as HTMLTableCellElement;
-		expect(tableName.tagName).toBe("TH");
-		expect(tableName.getAttribute("colspan")).toBe("2");
-		expect(tableName.classList.contains("table_name")).toBe(true);
-		expect(tableName.innerText).toBe(mockTable.name);
-
-		const dateStamp = result.children[1] as HTMLTableCellElement;
-		expect(dateStamp.tagName).toBe("TH");
-		expect(dateStamp.getAttribute("colspan")).toBe("100%");
-		expect(dateStamp.classList.contains("date_stamp")).toBe(true);
-
-		const dateRegex = /^\d{2}\/\d{2}\/\d{4} \d{1,2}:\d{2} (AM|PM)$/;
-		expect(dateRegex.test(dateStamp.innerText)).toBe(true);
-	});
-
-	it("should create table body with correct number of rows and columns based on displayed data", () => {
-		const mockColumns = [
-			{ name: "Column 1", forPrint: true },
-			{ name: "Column 2", forPrint: false },
-			{ name: "Column 3", forPrint: true },
-		];
-		const mockDisplayedRows = [
-			{ id: 1, col1: "Value 1", col3: "Value 3" },
-			{ id: 2, col1: "Value 4", col3: "Value 6" },
-		];
-		const mockDataView = {
-			getItem: jest.fn((index) => mockDisplayedRows[index]),
-			getItemMetadata: jest.fn(),
-		};
-
-		// @ts-ignore
-		jest.spyOn(mockTable.grid, "getColumns").mockReturnValue(mockColumns);
-		// @ts-ignore
-		jest.spyOn(mockTable.grid, "getData").mockReturnValue(mockDataView);
-
-		jest.spyOn(defaultPrinter, "createTr").mockImplementation(() => {
-			const tr = document.createElement("tr");
-			tr.innerHTML = "<td></td><td></td>";
-			return tr;
-		});
-		jest.spyOn(defaultPrinter, "totals").mockReturnValue([]);
-
-		jest
-			.spyOn(getDisplayedRowsModule, "getDisplayedRows")
-			.mockImplementation(jest.fn())
-			.mockReturnValue(mockDisplayedRows);
-
-		const result = defaultPrinter.createTbody(mockTable);
-
-		expect(result.tagName).toBe("TBODY");
-		expect(result.children.length).toBe(2);
-		expect(result.children[0].children.length).toBe(2);
-		expect(result.children[1].children.length).toBe(2);
-		expect(defaultPrinter.totals).toHaveBeenCalledWith(mockTable);
-		expect(getDisplayedRowsModule.getDisplayedRows).toHaveBeenCalledWith(
-			mockDataView,
-		);
-	});
-
-	it("should create filters row when table has filters", () => {
-		const mockTable: SlickTable = {
-			filter: {
-				print: jest
-					.fn()
-					.mockReturnValue([
-						document.createElement("tr"),
-						document.createElement("tr"),
-					]),
-			},
-		} as unknown as SlickTable;
-
-		const result = defaultPrinter.filters(mockTable);
-
-		expect(result.length).toBe(3);
-		expect(result[0].tagName).toBe("TR");
-		expect(result[0].children[0].tagName).toBe("TH");
-		expect(result[0].children[0].getAttribute("colspan")).toBe("100%");
-		expect(result[0].children[0].classList.contains("client")).toBe(true);
-		expect(result[0].children[0].innerText).toBe("Applied filters");
-		expect(result[1].tagName).toBe("TR");
-		expect(result[2].tagName).toBe("TR");
-		expect(mockTable.filter.print).toHaveBeenCalledWith(mockTable);
-	});
-
-	it("should create a table element with correct structure and content", () => {
-		jest
-			.spyOn(defaultPrinter, "createThead")
-			.mockReturnValue(document.createElement("thead"));
-		jest
-			.spyOn(defaultPrinter, "createTbody")
-			.mockReturnValue(document.createElement("tbody"));
-
-		const result = defaultPrinter.createTableElement(mockTable);
-
-		expect(result.tagName).toBe("TABLE");
-		expect(result.children.length).toBe(2);
-		expect(result.children[0].tagName).toBe("THEAD");
-		expect(result.children[1].tagName).toBe("TBODY");
-		expect(defaultPrinter.createThead).toHaveBeenCalledWith(mockTable);
-		expect(defaultPrinter.createTbody).toHaveBeenCalledWith(mockTable);
-	});
-
-	it("should handle group titles in createTr method", () => {
-		const mockColumns = [
-			{ name: "Column 1", field: "col1", forPrint: true },
-			{ name: "Column 2", field: "col2", forPrint: true },
-		];
-		const mockRowIndex = 0;
-		const mockGrid = {
-			getData: jest.fn().mockReturnValue({
-				getItem: jest.fn().mockReturnValue({
-					__group: true,
-					title: "Group Title <span>with HTML</span>",
-				}),
-				getItemMetadata: jest.fn(),
-			}),
-		} as unknown as SlickGrid;
-
-		const result = defaultPrinter.createTr(mockColumns, mockRowIndex, mockGrid);
-
-		expect(result.tagName).toBe("TR");
-		expect(result.children.length).toBe(1);
-		expect(result.children[0].tagName).toBe("TD");
-		expect(result.children[0].getAttribute("colspan")).toBe("100%");
-		expect(result.children[0].innerText).toBe("Group Title with HTML");
-	});
-
-	it("should return an empty array for totals method in DefaultPrinter", () => {
-		mockTable = {} as SlickTable;
-
-		const result = defaultPrinter.totals(mockTable);
-
-		expect(result).toEqual([]);
-		expect(Array.isArray(result)).toBe(true);
-		expect(result.length).toBe(0);
-	});
-});

package/src/shared/lib/slickgrid/model/SlickTable/table/SlickTable.test.ts

@@ -1,72 +0,0 @@
-import { SlickGrid } from "slickgrid";
-
-import { IFilter, WithoutFilter } from "../filters";
-import { DefaultPrinter, Printer } from "../printer";
-import { SlickTable } from "./SlickTable";
-
-jest.mock("app/store/store");
-
-describe("SlickTable", () => {
-	let slickTable: SlickTable;
-
-	beforeEach(() => {
-		slickTable = new SlickTable({ id: "test-table" });
-	});
-
-	it("should create a SlickTable instance with default values when only 'id' is provided", () => {
-		expect(slickTable.id).toBe("test-table");
-		expect(slickTable.name).toBe("");
-		expect(slickTable.printer).toBeInstanceOf(DefaultPrinter);
-		expect(slickTable.filter).toBeInstanceOf(WithoutFilter);
-	});
-
-	it("should return null for grid property before createGrid is called", () => {
-		expect(slickTable.grid).toBeNull();
-	});
-
-	it("should return false for isReady property before createGrid is called", () => {
-		expect(slickTable.isReady).toBeFalsy();
-		expect(slickTable.isReady).toEqual(false);
-	});
-
-	it("should return false for isEdited property before createGrid is called", () => {
-		expect(slickTable.isEdited).toBeFalsy();
-		expect(slickTable.isEdited).toEqual(false);
-	});
-
-	it("should correctly set custom name, filter, and printer when provided in constructor", () => {
-		const mockFilter = {} as IFilter;
-		const mockPrinter = {} as Printer;
-		const slickTable = new SlickTable({
-			id: "custom-table",
-			name: "Custom Table",
-			filter: mockFilter,
-			printer: mockPrinter,
-		});
-
-		expect(slickTable.id).toBe("custom-table");
-		expect(slickTable.name).toBe("Custom Table");
-		expect(slickTable.filter).toBe(mockFilter);
-		expect(slickTable.printer).toBe(mockPrinter);
-	});
-
-	it("should clear selected rows when reset() is called if a selection model exists", () => {
-		const mockGrid = {
-			onKeyDown: { unsubscribe: jest.fn() },
-			getSelectionModel: jest.fn().mockReturnValue(true),
-			setSelectedRows: jest.fn(),
-		} as unknown as SlickGrid;
-
-		slickTable.grid = mockGrid;
-		slickTable.isEdited = true;
-
-		expect(slickTable.isEdited).toBeTruthy();
-		expect(slickTable.grid).toEqual(mockGrid);
-
-		slickTable.reset();
-
-		expect(mockGrid.setSelectedRows).toHaveBeenCalledWith([]);
-		expect(slickTable.isEdited).toBeFalsy();
-		expect(slickTable.grid).toBeNull();
-	});
-});