@qrvey/filters 0.0.45 → 0.1.0

package/tests/classes/FilterBuilder.test.ts

@@ -1,903 +0,0 @@
-import { FilterBuilder } from "../../src/classes/FilterBuilder";
-import { FILTER_GROUPING } from "../../src/resources/filter-grouping.resources";
-import { FILTER_OPERATOR } from "../../src/resources/filter-operators.resources";
-import { FILTER_SCOPE } from "../../src/resources/filter-scopes.resources";
-import { FILTER_VALIDATOR } from "../../src/resources/filter-validators.resources";
-import {
-  IFilterValue,
-  IFilterValueRange,
-  IFilterValueRegular,
-} from "../../src/resources/filter-values.resources";
-import { DEFAULT_FILTER, IFilter } from "../../src/resources/filters.resources";
-import {
-  __mockFilter1,
-  __mockFilter2,
-  __mockFilter3,
-  __mockFilter4,
-  __mockFilter5,
-  __mockFilter6,
-  __mockFilters1,
-  __mockFilters2,
-} from "../mock/filters.mock";
-
-describe("Testing wrong arguments", () => {
-  test("Undefined argument", () => {
-    const builder = new FilterBuilder(undefined);
-    expect(builder.getFilters()).toEqual([]);
-  });
-
-  test("Null argument", () => {
-    // @ts-expect-error: Expected wrong params
-    const builder = new FilterBuilder(null);
-    expect(builder.getFilters()).toEqual([]);
-  });
-
-  test("Boolean argument", () => {
-    // @ts-expect-error: Expected wrong params
-    const builder = new FilterBuilder(false);
-    expect(builder.getFilters()).toEqual([]);
-  });
-
-  test("Numeric argument", () => {
-    // @ts-expect-error: Expected wrong params
-    const builder = new FilterBuilder(0);
-    expect(builder.getFilters()).toEqual([]);
-  });
-
-  test("String argument", () => {
-    // @ts-expect-error: Expected wrong params
-    const builder = new FilterBuilder("Sales");
-    expect(builder.getFilters()).toEqual([]);
-  });
-
-  test("Function-like argument", () => {
-    // @ts-expect-error: Expected wrong params
-    const builder = new FilterBuilder(() => "Hola");
-    expect(builder.getFilters()).toEqual([]);
-  });
-});
-
-describe("Testing Adding Filters - Empty Filters", () => {
-  let builder: FilterBuilder;
-  beforeEach(() => {
-    builder = new FilterBuilder([]);
-  });
-
-  test("Adding single", () => {
-    const resulting = builder.addSingle(__mockFilter1);
-    const mockFilter1 = { ...__mockFilter1, id: "global|D123|C123|equals" };
-
-    expect(resulting).toEqual({
-      resulting: [mockFilter1],
-      affected: mockFilter1,
-      original: __mockFilter1,
-    });
-    expect(builder.getFilters()).toEqual([mockFilter1]);
-  });
-
-  test("Adding Multiple", () => {
-    const resulting = builder.addMultiple([__mockFilter1, __mockFilter2]);
-    const mockFilter1 = { ...__mockFilter1, id: "global|D123|C123|equals" };
-    const mockFilter2 = { ...__mockFilter2, id: "global|D123|C456|equals|day" };
-    const resultingFilters = [mockFilter1, mockFilter2];
-
-    expect(resulting).toEqual({
-      resulting: resultingFilters,
-      affected: resultingFilters,
-      original: [],
-    });
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-});
-
-describe("Testing Adding Filters - With Filters", () => {
-  let builder: FilterBuilder;
-  beforeEach(() => {
-    builder = new FilterBuilder(__mockFilters1);
-  });
-
-  test("Adding single", () => {
-    const resulting = builder.addSingle(__mockFilter4);
-    const mockFilter4 = { ...__mockFilter4, id: "page|D456|C654|greater_than" };
-
-    const resultingFilters = [
-      __mockFilter1,
-      __mockFilter2,
-      __mockFilter3,
-      mockFilter4,
-    ];
-
-    expect(resulting).toEqual({
-      resulting: resultingFilters,
-      affected: mockFilter4,
-      original: __mockFilter4,
-    });
-
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("Adding single between items", () => {
-    const resulting = builder.addSingle(__mockFilter6);
-    const mockFilter6 = {
-      ...__mockFilter6,
-      id: "global|D123|C456|equals|week",
-    };
-    const mockFilter2 = {
-      ...__mockFilter2,
-      operator: FILTER_OPERATOR.AND,
-    };
-    const resultingFilters = [
-      __mockFilter1,
-      mockFilter2,
-      mockFilter6,
-      __mockFilter3,
-    ];
-
-    expect(resulting.resulting).toEqual(resultingFilters);
-    expect(resulting.affected).toEqual(mockFilter6);
-    expect(resulting.original).toEqual(__mockFilter6);
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("Adding single between items - Automatic Operator Off", () => {
-    const resulting = builder.addSingle(__mockFilter6, undefined, {
-      automaticOperator: false,
-    });
-    const mockFilter6 = {
-      ...__mockFilter6,
-      id: "global|D123|C456|equals|week",
-    };
-
-    const resultingFilters = [
-      __mockFilter1,
-      __mockFilter2,
-      mockFilter6,
-      __mockFilter3,
-    ];
-
-    expect(resulting.resulting).toEqual(resultingFilters);
-    expect(resulting.affected).toEqual(mockFilter6);
-    expect(resulting.original).toEqual(__mockFilter6);
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("Adding single between items - Custom Index - Automatic Operator Off", () => {
-    const resulting = builder.addSingle(__mockFilter6, 1, {
-      automaticOperator: false,
-    });
-    const mockFilter6 = {
-      ...__mockFilter6,
-      id: "global|D123|C456|equals|week",
-    };
-
-    const resultingFilters = [
-      __mockFilter1,
-      mockFilter6,
-      __mockFilter2,
-      __mockFilter3,
-    ];
-
-    expect(resulting.resulting).toEqual(resultingFilters);
-    expect(resulting.affected).toEqual(mockFilter6);
-    expect(resulting.original).toEqual(__mockFilter6);
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("Adding Multiple", () => {
-    const resulting = builder.addMultiple([__mockFilter4, __mockFilter5]);
-    const mockFilter4 = { ...__mockFilter4, id: "page|D456|C654|greater_than" };
-    const mockFilter5 = { ...__mockFilter5, id: "page|D789|C135|not_equal" };
-
-    const resultingFilters = [
-      __mockFilter1,
-      __mockFilter2,
-      __mockFilter3,
-      mockFilter4,
-      mockFilter5,
-    ];
-    expect(resulting).toEqual({
-      resulting: resultingFilters,
-      affected: [mockFilter4, mockFilter5],
-      original: __mockFilters1,
-    });
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("No adding due to duplicate", () => {
-    const resulting = builder.addSingle(__mockFilter2);
-    expect(resulting).toEqual({
-      resulting: __mockFilters1,
-    });
-    expect(builder.getFilters()).toEqual(__mockFilters1);
-  });
-});
-
-describe("Testing Adding Filters Values", () => {
-  let builder: FilterBuilder;
-  beforeEach(() => {
-    builder = new FilterBuilder(__mockFilters1);
-  });
-
-  test("Adding One value", () => {
-    const newValue: IFilterValueRegular = {
-      enabled: true,
-      displayed: true,
-      value: "Except this value",
-    };
-    const resulting = builder.addValue("F123", newValue);
-
-    const mockFilter1: IFilter = { ...__mockFilter1, values: [newValue] };
-    const resultingFilters: IFilter[] = [
-      mockFilter1,
-      __mockFilter2,
-      __mockFilter3,
-    ];
-
-    expect(resulting).toEqual({
-      resulting: resultingFilters,
-      affected: mockFilter1,
-      original: __mockFilter1,
-    });
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("Adding Multiple values", () => {
-    const newValues: IFilterValueRegular[] = [
-      {
-        enabled: true,
-        displayed: true,
-        value: "Except this value",
-      },
-      {
-        enabled: true,
-        displayed: true,
-        value: "and this value",
-      },
-    ];
-    const resulting = builder.addValues("F123", newValues);
-
-    const mockFilter1: IFilter = { ...__mockFilter1, values: newValues };
-    const resultingFilters: IFilter[] = [
-      mockFilter1,
-      __mockFilter2,
-      __mockFilter3,
-    ];
-
-    expect(resulting).toEqual({
-      resulting: resultingFilters,
-      affected: mockFilter1,
-      original: __mockFilter1,
-    });
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-});
-
-describe("Testing Deleting Filters", () => {
-  let builder: FilterBuilder;
-  beforeEach(() => {
-    builder = new FilterBuilder(__mockFilters1);
-  });
-
-  test("Deleting by Params", () => {
-    const resulting = builder.deleteByParams({
-      columnId: "C456",
-      grouping: FILTER_GROUPING.DAY,
-    });
-    const resultingFilters = [__mockFilter1, __mockFilter3];
-
-    expect(resulting).toEqual({
-      resulting: resultingFilters,
-      affected: [__mockFilter2],
-      original: __mockFilters1,
-    });
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("Deleting Single", () => {
-    const resulting = builder.deleteSingle("F123");
-    const resultingFilters = [__mockFilter2, __mockFilter3];
-
-    expect(resulting).toEqual({
-      resulting: resultingFilters,
-      affected: __mockFilter1,
-      original: __mockFilter1,
-    });
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("Deleting Multiple", () => {
-    const resulting = builder.deleteMultiple(["F123", "F789"]);
-    const resultingFilters = [__mockFilter2];
-
-    expect(resulting).toEqual({
-      resulting: resultingFilters,
-      affected: [__mockFilter1, __mockFilter3],
-      original: __mockFilters1,
-    });
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-});
-
-describe("Testing Deleting Filters Values", () => {
-  test("no delete filter values because of Empty values", () => {
-    const builder = new FilterBuilder(__mockFilters1);
-
-    const resulting = builder.deleteValue("F123", 1);
-
-    const resultingFilters: IFilter[] = [
-      __mockFilter1,
-      __mockFilter2,
-      __mockFilter3,
-    ];
-
-    expect(resulting).toEqual({
-      resulting: resultingFilters,
-      affected: __mockFilter1,
-      original: __mockFilter1,
-    });
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("Deleting One value", () => {
-    const builder = new FilterBuilder(__mockFilters1);
-
-    const resulting = builder.deleteValue("F789", 0);
-    const mockFilter3 = {
-      ...__mockFilter3,
-      values: [__mockFilter3.values![1]],
-    };
-    const affectedMockFilter3 = {
-      ...__mockFilter3,
-      values: [__mockFilter3.values![0]],
-    };
-    const resultingFilters: IFilter[] = [
-      __mockFilter1,
-      __mockFilter2,
-      mockFilter3,
-    ];
-
-    expect(resulting).toEqual({
-      resulting: resultingFilters,
-      affected: affectedMockFilter3,
-      original: __mockFilter3,
-    });
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("Deleting multiples values", () => {
-    const builder = new FilterBuilder(__mockFilters2);
-
-    const resulting = builder.deleteValues("F457", [0, 3]);
-    const resultingMockFilter6 = {
-      ...__mockFilter6,
-      values: [__mockFilter6.values![1], __mockFilter6.values![2]],
-    };
-    const affectedMockFilter6 = {
-      ...__mockFilter6,
-      values: [__mockFilter6.values![1], __mockFilter6.values![2]],
-    };
-    const resultingFilters: IFilter[] = [
-      __mockFilter4,
-      __mockFilter5,
-      resultingMockFilter6,
-    ];
-
-    expect(resulting).toEqual({
-      resulting: resultingFilters,
-      affected: affectedMockFilter6,
-      original: __mockFilter6,
-    });
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-});
-
-describe("Testing Editing Filters", () => {
-  let builder: FilterBuilder;
-  beforeEach(() => {
-    builder = new FilterBuilder(__mockFilters1);
-  });
-
-  test("Editing Single", () => {
-    const filter: Partial<IFilter> = {
-      grouping: FILTER_GROUPING.MONTH,
-      values: [
-        {
-          displayed: true,
-          enabled: true,
-          value: "Jan 1991",
-        },
-      ],
-    };
-    const resulting = builder.editSingle("F456", filter);
-    const mockFilter2 = {
-      ...__mockFilter2,
-      ...filter,
-      id: "global|D123|C456|equals|month",
-    };
-    const resultingFilters = [__mockFilter1, mockFilter2, __mockFilter3];
-
-    expect(resulting).toEqual({
-      resulting: resultingFilters,
-      affected: mockFilter2,
-      original: __mockFilter2,
-    });
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("Wrong parameters on Editing multiple filters", () => {
-    const filter1: Partial<IFilter> = {
-      validator: FILTER_VALIDATOR.NOT_EQUAL,
-    };
-
-    const resulting = builder.editMultiple(["F456", "F123"], [filter1], {
-      automaticId: false,
-    });
-    expect(resulting).toEqual({
-      resulting: __mockFilters1,
-    });
-    expect(builder.getFilters()).toEqual(__mockFilters1);
-  });
-
-  test("Editing Multiple", () => {
-    const filter1: Partial<IFilter> = {
-      validator: FILTER_VALIDATOR.NOT_EQUAL,
-    };
-    const filter2: Partial<IFilter> = {
-      grouping: FILTER_GROUPING.MONTH,
-      values: [
-        {
-          displayed: true,
-          enabled: true,
-          value: "Jan 1991",
-        },
-      ],
-    };
-
-    const resulting = builder.editMultiple(
-      ["F456", "F123"],
-      [filter2, filter1],
-      { automaticId: false },
-    );
-    const mockFilter1 = {
-      ...__mockFilter1,
-      ...filter1,
-    };
-    const mockFilter2 = {
-      ...__mockFilter2,
-      ...filter2,
-    };
-    const resultingFilters = [mockFilter1, mockFilter2, __mockFilter3];
-
-    expect(resulting).toEqual({
-      resulting: resultingFilters,
-      affected: [mockFilter2, mockFilter1],
-      original: __mockFilters1,
-    });
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("No editing due to duplicate", () => {
-    const resulting = builder.editSingle("F456", __mockFilter3);
-    expect(resulting).toEqual({
-      resulting: __mockFilters1,
-    });
-    expect(builder.getFilters()).toEqual(__mockFilters1);
-  });
-});
-
-describe("Cannot editing filter values", () => {
-  let builder: FilterBuilder;
-  beforeEach(() => {
-    builder = new FilterBuilder(__mockFilters1);
-  });
-
-  test("Cannot edit one value", () => {
-    const newValue: IFilterValueRegular = {
-      enabled: false,
-      displayed: true,
-      value: "Hola",
-    };
-    const resulting = builder.editValue("F123", newValue, 0);
-
-    expect(resulting).toEqual({
-      resulting: __mockFilters1,
-    });
-    expect(builder.getFilters()).toEqual(__mockFilters1);
-  });
-
-  test("Cannot edit multiple values", () => {
-    const newValues: IFilterValueRegular[] = [
-      {
-        enabled: false,
-        displayed: true,
-        value: "Hola",
-      },
-      {
-        enabled: true,
-        displayed: true,
-        value: "Hello",
-      },
-    ];
-    const resulting = builder.editValues("F457", newValues, [0, 3]);
-
-    expect(resulting).toEqual({
-      resulting: __mockFilters1,
-    });
-    expect(builder.getFilters()).toEqual(__mockFilters1);
-  });
-});
-
-describe("Testing Editing Filters Values", () => {
-  let builder: FilterBuilder;
-  beforeEach(() => {
-    builder = new FilterBuilder(__mockFilters2);
-  });
-
-  test("Editing One value", () => {
-    const newValue: IFilterValueRegular = {
-      enabled: false,
-      displayed: true,
-      value: "Q4 2023",
-    };
-    const resulting = builder.editValue("F457", newValue, 0);
-
-    const mockFilter6: IFilter = {
-      ...__mockFilter6,
-      values: [
-        newValue,
-        __mockFilter6.values![1],
-        __mockFilter6.values![2],
-        __mockFilter6.values![3],
-      ],
-    };
-    const resultingFilters: IFilter[] = [
-      __mockFilter4,
-      __mockFilter5,
-      mockFilter6,
-    ];
-
-    expect(resulting).toEqual({
-      resulting: resultingFilters,
-      affected: mockFilter6,
-      original: __mockFilter6,
-    });
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("Editing Multiple values", () => {
-    const newValues: IFilterValueRegular[] = [
-      {
-        enabled: false,
-        displayed: true,
-        value: "Q4 2023",
-      },
-      {
-        enabled: true,
-        displayed: true,
-        value: "Q1 2025",
-      },
-    ];
-    const resulting = builder.editValues("F457", newValues, [0, 3]);
-
-    const mockFilter6: IFilter = {
-      ...__mockFilter6,
-      values: [
-        newValues[0],
-        __mockFilter6.values![1],
-        __mockFilter6.values![2],
-        newValues[1],
-      ],
-    };
-    const resultingFilters: IFilter[] = [
-      __mockFilter4,
-      __mockFilter5,
-      mockFilter6,
-    ];
-
-    expect(resulting.affected).toEqual(mockFilter6);
-    expect(resulting.resulting).toEqual(resultingFilters);
-    expect(resulting.original).toEqual(__mockFilter6);
-
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-});
-
-describe("Testing Merging Filters", () => {
-  let builder: FilterBuilder;
-  beforeEach(() => {
-    builder = new FilterBuilder(__mockFilters1);
-  });
-
-  test("Merging Single", () => {
-    const resulting = builder.mergeSingle(__mockFilter4);
-    const mockFilter4 = {
-      ...__mockFilter4,
-      id: "page|D456|C654|greater_than",
-    };
-    const resultingFilters = [
-      __mockFilter1,
-      __mockFilter2,
-      __mockFilter3,
-      mockFilter4,
-    ];
-
-    expect(resulting.resulting).toEqual(resultingFilters);
-    expect(resulting.affected).toEqual(mockFilter4);
-    expect(resulting.original).toEqual(__mockFilter4);
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("Wrong parameters on Merging single filter", () => {
-    // @ts-expect-error: Expected wrong params
-    const resulting = builder.mergeSingle(undefined);
-
-    expect(resulting).toEqual({
-      resulting: __mockFilters1,
-    });
-    expect(builder.getFilters()).toEqual(__mockFilters1);
-  });
-
-  test("Merging Multiple", () => {
-    const resulting = builder.mergeMultiple([__mockFilter5, __mockFilter6]);
-    const mockFilter2 = {
-      ...__mockFilter2,
-      operator: FILTER_OPERATOR.AND,
-    };
-    const mockFilter5 = {
-      ...__mockFilter5,
-      id: "page|D789|C135|not_equal",
-    };
-    const mockFilter6 = {
-      ...__mockFilter6,
-      id: "global|D123|C456|equals|week",
-    };
-    const resultingFilters = [
-      __mockFilter1,
-      mockFilter2,
-      mockFilter6,
-      __mockFilter3,
-      mockFilter5,
-    ];
-
-    expect(resulting.resulting).toEqual(resultingFilters);
-    expect(resulting.affected).toEqual([mockFilter5, mockFilter6]);
-    expect(resulting.original).toEqual(__mockFilters1);
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("Merging Multiple - Automatic Operator Off", () => {
-    const resulting = builder.mergeMultiple([__mockFilter5, __mockFilter6], {
-      automaticOperator: false,
-    });
-    const mockFilter5 = {
-      ...__mockFilter5,
-      id: "page|D789|C135|not_equal",
-    };
-    const mockFilter6 = {
-      ...__mockFilter6,
-      id: "global|D123|C456|equals|week",
-    };
-    const resultingFilters = [
-      __mockFilter1,
-      __mockFilter2,
-      mockFilter6,
-      __mockFilter3,
-      mockFilter5,
-    ];
-
-    expect(resulting.resulting).toEqual(resultingFilters);
-    expect(resulting.affected).toEqual([mockFilter5, mockFilter6]);
-    expect(resulting.original).toEqual(__mockFilters1);
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("Wrong parameters on Merging multiple filter", () => {
-    const resulting = builder.mergeMultiple([]);
-    expect(resulting).toEqual({
-      resulting: __mockFilters1,
-    });
-    expect(builder.getFilters()).toEqual(__mockFilters1);
-  });
-
-  test("No merging due to duplicate", () => {
-    const resulting = builder.mergeMultiple([__mockFilter3]);
-
-    expect(resulting.resulting).toEqual(__mockFilters1);
-    expect(resulting.affected).toEqual([__mockFilter3]);
-    expect(resulting.original).toEqual(__mockFilters1);
-    expect(builder.getFilters()).toEqual(__mockFilters1);
-  });
-});
-
-describe("Testing Merging Filters Values", () => {
-  let builder: FilterBuilder;
-  beforeEach(() => {
-    builder = new FilterBuilder(__mockFilters1);
-  });
-
-  test("Merging Regular values", () => {
-    const newValues: IFilterValueRegular[] = [
-      {
-        enabled: true,
-        displayed: true,
-        value: "Except this value",
-      },
-      {
-        enabled: true,
-        displayed: true,
-        value: "and this value",
-      },
-    ];
-    const resulting = builder.mergeValues("F456", newValues);
-
-    const mockFilter2: IFilter = {
-      ...__mockFilter2,
-      values: [...(__mockFilter2.values ?? []), ...newValues],
-    };
-    const resultingFilters: IFilter[] = [
-      __mockFilter1,
-      mockFilter2,
-      __mockFilter3,
-    ];
-
-    expect(resulting.resulting).toEqual(resultingFilters);
-    expect(resulting.affected).toEqual(mockFilter2);
-    expect(resulting.original).toEqual(__mockFilter2);
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("Merging Range values", () => {
-    const newValues: IFilterValueRange[] = [
-      {
-        enabled: true,
-        displayed: true,
-        min: "0",
-      },
-      {
-        enabled: true,
-        displayed: true,
-        min: "10",
-        max: "100",
-      },
-    ];
-    const resulting = builder.mergeValues("F789", newValues);
-
-    const mockFilter3: IFilter = {
-      ...__mockFilter3,
-      values: [...(__mockFilter3.values ?? []), ...newValues],
-    };
-    const resultingFilters: IFilter[] = [
-      __mockFilter1,
-      __mockFilter2,
-      mockFilter3,
-    ];
-
-    expect(resulting.resulting).toEqual(resultingFilters);
-    expect(resulting.affected).toEqual(mockFilter3);
-    expect(resulting.original).toEqual(__mockFilter3);
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("No Merging due to duplicate", () => {
-    const newValues: IFilterValue[] = [
-      __mockFilter3.values![0],
-      __mockFilter3.values![1],
-    ];
-    const resulting = builder.mergeValues("F789", newValues);
-
-    expect(resulting.resulting).toEqual(__mockFilters1);
-    expect(resulting.affected).toEqual(__mockFilter3);
-    expect(resulting.original).toEqual(__mockFilter3);
-    expect(builder.getFilters()).toEqual(__mockFilters1);
-  });
-});
-
-describe("Creating the masked Filter", () => {
-  test("Default filter", () => {
-    const filter: IFilter = FilterBuilder.createFilter({});
-    expect(filter).toEqual({ ...DEFAULT_FILTER, id: "global|equals" });
-  });
-
-  test("Some custom properties", () => {
-    const partialFilter: Partial<IFilter> = {
-      columnId: "Column123",
-      operator: FILTER_OPERATOR.OR,
-      validator: FILTER_VALIDATOR.BETWEEN_EXCLUSIVE,
-    };
-    const filter: IFilter = FilterBuilder.createFilter(partialFilter);
-    expect(filter).toEqual({
-      ...DEFAULT_FILTER,
-      ...partialFilter,
-      id: "global|Column123|between_exclusive",
-    });
-  });
-});
-
-describe("Replacing filters", () => {
-  let builder: FilterBuilder;
-  beforeEach(() => {
-    builder = new FilterBuilder(__mockFilters2);
-  });
-
-  test("By Params", () => {
-    const filters: IFilter[] = [__mockFilter1, __mockFilter2];
-    const params = { scope: FILTER_SCOPE.PAGE };
-    const resulting = builder.replaceByParams(filters, params);
-
-    const mockFilter1 = { ...__mockFilter1, id: "global|D123|C123|equals" };
-    const mockFilter2 = { ...__mockFilter2, id: "global|D123|C456|equals|day" };
-    const resultingFilters = [__mockFilter6, mockFilter2, mockFilter1];
-    const affected = [mockFilter1, mockFilter2];
-
-    expect(resulting.resulting).toEqual(resultingFilters);
-    expect(resulting.affected).toEqual(affected);
-    expect(resulting.original).toEqual(__mockFilters2);
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("By Params - Automatic Operator On", () => {
-    const filters: IFilter[] = [__mockFilter1, __mockFilter2];
-    const params = { scope: FILTER_SCOPE.PAGE };
-    const resulting = builder.replaceByParams(filters, params, {
-      automaticOperator: true,
-    });
-
-    const mockFilter1 = { ...__mockFilter1, id: "global|D123|C123|equals" };
-    const mockFilter2 = { ...__mockFilter2, id: "global|D123|C456|equals|day" };
-    const mockFilter6 = { ...__mockFilter6, operator: FILTER_OPERATOR.OR };
-    const resultingFilters = [mockFilter6, mockFilter2, mockFilter1];
-    const affected = [mockFilter1, mockFilter2];
-
-    expect(resulting.resulting).toEqual(resultingFilters);
-    expect(resulting.affected).toEqual(affected);
-    expect(resulting.original).toEqual(__mockFilters2);
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("By Params - Adding In Same Index", () => {
-    const filters: IFilter[] = [__mockFilter1, __mockFilter2];
-    const params = { validator: FILTER_VALIDATOR.NOT_EQUAL };
-    const resulting = builder.replaceByParams(filters, params, {
-      addingInSameIndex: true,
-    });
-
-    const mockFilter1 = { ...__mockFilter1, id: "global|D123|C123|equals" };
-    const mockFilter2 = { ...__mockFilter2, id: "global|D123|C456|equals|day" };
-    const resultingFilters = [
-      __mockFilter4,
-      mockFilter1,
-      __mockFilter6,
-      mockFilter2,
-    ];
-    const affected = [mockFilter1, mockFilter2];
-
-    expect(resulting.resulting).toEqual(resultingFilters);
-    expect(resulting.affected).toEqual(affected);
-    expect(resulting.original).toEqual(__mockFilters2);
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-
-  test("By Params - Adding In Same Index Off", () => {
-    const filters: IFilter[] = [__mockFilter1, __mockFilter2];
-    const params = { validator: FILTER_VALIDATOR.NOT_EQUAL };
-    const resulting = builder.replaceByParams(filters, params, {
-      addingInSameIndex: false,
-    });
-
-    const mockFilter1 = { ...__mockFilter1, id: "global|D123|C123|equals" };
-    const mockFilter2 = { ...__mockFilter2, id: "global|D123|C456|equals|day" };
-    const resultingFilters = [
-      __mockFilter4,
-      __mockFilter6,
-      mockFilter2,
-      mockFilter1,
-    ];
-
-    const affected = [mockFilter1, mockFilter2];
-
-    expect(resulting.resulting).toEqual(resultingFilters);
-    expect(resulting.affected).toEqual(affected);
-    expect(resulting.original).toEqual(__mockFilters2);
-    expect(builder.getFilters()).toEqual(resultingFilters);
-  });
-});