@truedat/bg 6.3.2 → 6.3.4

package/src/concepts/reducers/__tests__/conceptActiveFilters.spec.js

@@ -1,83 +0,0 @@
-import { initialState } from "../conceptActiveFilters";
-import { fetchDomain } from "../../../taxonomy/routines";
-import {
-  addConceptFilter,
-  applyConceptUserFilter,
-  closeConceptFilter,
-  removeConceptFilter,
-  resetConceptFilters,
-  toggleConceptFilterValue,
-} from "../../routines";
-import { conceptActiveFilters } from "..";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: conceptActiveFilters", () => {
-  it("should provide the initial state", () => {
-    expect(conceptActiveFilters(undefined, {})).toEqual(initialState);
-  });
-
-  it("should handle the addConceptFilter.TRIGGER action", () => {
-    const filter = "baz";
-    const payload = { filter };
-    expect(conceptActiveFilters(fooState, addConceptFilter(payload))).toEqual({
-      ...fooState,
-      baz: [],
-    });
-  });
-
-  it("should handle the applyConceptUserFilter.TRIGGER action", () => {
-    const filters = { country: ["Sp"] };
-    const payload = { userFilter: { filters } };
-    expect(
-      conceptActiveFilters(fooState, applyConceptUserFilter(payload))
-    ).toEqual({ ...filters });
-  });
-
-  it("should handle the closeConceptFilter.TRIGGER action", () => {
-    const foo = ["foo1"];
-    const bar = [];
-    const state = { foo, bar };
-    const payload = { filter: "bar" };
-    expect(conceptActiveFilters(state, closeConceptFilter(payload))).toEqual({
-      foo,
-    });
-  });
-
-  it("should handle the removeConceptFilter.TRIGGER action", () => {
-    const foo = ["foo1"];
-    const bar = [];
-    const state = { foo, bar };
-    const payload = { filter: "foo" };
-    expect(conceptActiveFilters(state, removeConceptFilter(payload))).toEqual({
-      bar,
-    });
-  });
-
-  it("should handle the resetConceptFilters.TRIGGER action", () => {
-    expect(conceptActiveFilters(fooState, resetConceptFilters())).toEqual(
-      initialState
-    );
-  });
-
-  it("should handle the toggleConceptFilterValue.TRIGGER action", () => {
-    const foo = ["foo1", "foo2", "foo3"];
-    const bar = [];
-    const state = { foo, bar };
-    const payload = { filter: "foo", value: "foo2" };
-    expect(
-      conceptActiveFilters(state, toggleConceptFilterValue(payload))
-    ).toEqual({ foo: ["foo1", "foo3"], bar });
-  });
-
-  it("should omit the taxonomy filter on fetchDomain.TRIGGER", () => {
-    const state = { taxonomy: ["foo"], foo: ["bar"] };
-    expect(conceptActiveFilters(state, fetchDomain())).toEqual({
-      foo: ["bar"],
-    });
-  });
-
-  it("should ignore unknown actions", () => {
-    expect(conceptActiveFilters(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

package/src/concepts/reducers/__tests__/conceptCount.spec.js

@@ -1,33 +0,0 @@
-import { clearConcepts, fetchConcepts } from "../../routines";
-import { conceptCount } from "..";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: conceptCount", () => {
-  const initialState = 0;
-
-  it("should provide the initial state", () => {
-    expect(conceptCount(undefined, {})).toEqual(initialState);
-  });
-
-  it("should handle the clearConcepts.TRIGGER action", () => {
-    expect(conceptCount(fooState, { type: clearConcepts.TRIGGER })).toEqual(
-      initialState
-    );
-  });
-
-  it("should handle the fetchConcepts.SUCCESS action", () => {
-    const count = 123;
-    const headers = { "x-total-count": `${count}` };
-    expect(
-      conceptCount(fooState, {
-        type: fetchConcepts.SUCCESS,
-        payload: { headers }
-      })
-    ).toEqual(count);
-  });
-
-  it("should ignore unknown actions", () => {
-    expect(conceptCount(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

package/src/concepts/reducers/__tests__/conceptFilters.spec.js

@@ -1,49 +0,0 @@
-import _ from "lodash/fp";
-import { clearConceptFilters, fetchConceptFilters } from "../../routines";
-import { conceptFilters } from "..";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: conceptFilters", () => {
-  const initialState = {};
-
-  it("should provide the initial state", () => {
-    expect(conceptFilters(undefined, {})).toEqual(initialState);
-  });
-
-  it("should handle the clearConceptFilters.TRIGGER action", () => {
-    expect(
-      conceptFilters(fooState, { type: clearConceptFilters.TRIGGER })
-    ).toEqual(initialState);
-  });
-
-  it("should handle the fetchConceptFilters.SUCCESS action", () => {
-    const data = {
-      filter1: { values: ["value1", "value2"] },
-      filter2: { values: ["value1"] },
-    };
-    expect(
-      conceptFilters(fooState, {
-        type: fetchConceptFilters.SUCCESS,
-        payload: { data },
-      })
-    ).toEqual(data);
-  });
-
-  it("should handle the fetchConceptFilters.SUCCESS action and omit field current", () => {
-    const data = {
-      filter1: { values: ["value1", "value2"] },
-      current: { values: ["value1"] },
-    };
-    expect(
-      conceptFilters(fooState, {
-        type: fetchConceptFilters.SUCCESS,
-        payload: { data },
-      })
-    ).toEqual(_.omit(["current"])(data));
-  });
-
-  it("should ignore unknown actions", () => {
-    expect(conceptFilters(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

package/src/concepts/reducers/__tests__/conceptFiltersLoading.spec.js

@@ -1,28 +0,0 @@
-import { fetchConceptFilters } from "../../routines";
-import { conceptFiltersLoading } from "..";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: conceptFiltersLoading", () => {
-  const initialState = false;
-
-  it("should provide the initial state", () => {
-    expect(conceptFiltersLoading(undefined, {})).toEqual(initialState);
-  });
-
-  it("should handle the fetchConceptFilters.REQUEST action", () => {
-    expect(
-      conceptFiltersLoading(fooState, { type: fetchConceptFilters.REQUEST })
-    ).toEqual(true);
-  });
-
-  it("should handle the fetchConceptFilters.FULFILL action", () => {
-    expect(
-      conceptFiltersLoading(fooState, { type: fetchConceptFilters.FULFILL })
-    ).toEqual(false);
-  });
-
-  it("should ignore unknown actions", () => {
-    expect(conceptFiltersLoading(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

package/src/concepts/reducers/__tests__/conceptQuery.spec.js

@@ -1,75 +0,0 @@
-import { initialState } from "../conceptQuery";
-import {
-  applyConceptUserFilter,
-  clearConceptFilters,
-  searchConcepts,
-  selectConceptPage
-} from "../../routines";
-import { conceptQuery } from "..";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: conceptQuery", () => {
-  it("should provide the initial state", () => {
-    expect(conceptQuery(undefined, {})).toEqual(initialState);
-  });
-
-  it("should handle the applyConceptUserFilter.TRIGGER action", () => {
-    const initialPage = initialState.page;
-
-    expect(
-      conceptQuery(fooState, { type: applyConceptUserFilter.TRIGGER })
-    ).toEqual({ ...fooState, page: initialPage });
-  });
-
-  it("should handle the selectConceptPage.TRIGGER action", () => {
-    const activePage = 123;
-    const payload = { activePage };
-    expect(
-      conceptQuery(fooState, { type: selectConceptPage.TRIGGER, payload })
-    ).toEqual({ ...fooState, page: activePage });
-  });
-
-  it("should handle the clearConceptFilters.TRIGGER action", () => {
-    expect(
-      conceptQuery(fooState, { type: clearConceptFilters.TRIGGER })
-    ).toEqual({
-      ...fooState,
-      page: 1
-    });
-  });
-
-  describe("action: searchConcepts.TRIGGER", () => {
-    const query = "some query";
-    it("should set the query from the payload", () => {
-      const payload = { query };
-      expect(
-        conceptQuery(fooState, { type: searchConcepts.TRIGGER, payload })
-      ).toMatchObject({ query });
-    });
-
-    it("when query is not empty it should order by relevance and name", () => {
-      const payload = { query };
-      expect(
-        conceptQuery(fooState, { type: searchConcepts.TRIGGER, payload })
-      ).toMatchObject({
-        query,
-        sort: [{ _score: "desc" }, { "name.raw": "asc" }]
-      });
-    });
-
-    it("when query is empty it should order by name", () => {
-      const payload = { query: "" };
-      expect(
-        conceptQuery(fooState, { type: searchConcepts.TRIGGER, payload })
-      ).toMatchObject({
-        query: "",
-        sort: [{ "name.raw": "asc" }]
-      });
-    });
-  });
-
-  it("should ignore unknown actions", () => {
-    expect(conceptQuery(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

package/src/concepts/reducers/__tests__/conceptSelectedFilter.spec.js

@@ -1,66 +0,0 @@
-import { initialState } from "../conceptSelectedFilter";
-import {
-  addConceptFilter,
-  closeConceptFilter,
-  openConceptFilter,
-  removeConceptFilter,
-  resetConceptFilters
-} from "../../routines";
-import { conceptSelectedFilter } from "..";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: conceptSelectedFilter", () => {
-  it("should provide the initial state", () => {
-    expect(conceptSelectedFilter(undefined, {})).toEqual(initialState);
-  });
-
-  it("should handle the addConceptFilter.TRIGGER action", () => {
-    const filter = "baz";
-    const payload = { filter };
-    expect(
-      conceptSelectedFilter(fooState, {
-        type: addConceptFilter.TRIGGER,
-        payload
-      })
-    ).toEqual(filter);
-  });
-
-  it("should handle the closeConceptFilter.TRIGGER action", () => {
-    expect(
-      conceptSelectedFilter(fooState, { type: closeConceptFilter.TRIGGER })
-    ).toEqual(initialState);
-  });
-
-  it("should handle the openConceptFilter.TRIGGER action", () => {
-    const filter = "baz";
-    const payload = { filter };
-    expect(
-      conceptSelectedFilter(fooState, {
-        type: openConceptFilter.TRIGGER,
-        payload
-      })
-    ).toEqual(filter);
-  });
-
-  it("should handle the removeConceptFilter.TRIGGER action", () => {
-    const filter = "baz";
-    const payload = { filter };
-    expect(
-      conceptSelectedFilter(fooState, {
-        type: removeConceptFilter.TRIGGER,
-        payload
-      })
-    ).toEqual(initialState);
-  });
-
-  it("should handle the resetConceptFilters.TRIGGER action", () => {
-    expect(
-      conceptSelectedFilter(fooState, { type: resetConceptFilters.TRIGGER })
-    ).toEqual(initialState);
-  });
-
-  it("should ignore unknown actions", () => {
-    expect(conceptSelectedFilter(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

package/src/concepts/reducers/__tests__/conceptSelectedUserFilter.spec.js

@@ -1,53 +0,0 @@
-import { initialState } from "../conceptSelectedUserFilter";
-import {
-  applyConceptUserFilter,
-  removeConceptFilter,
-  resetConceptFilters
-} from "../../routines";
-import { conceptSelectedUserFilter } from "..";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: conceptActiveFilters", () => {
-  it("should provide the initial state", () => {
-    expect(conceptSelectedUserFilter(undefined, {})).toEqual(initialState);
-  });
-
-  it("should handle the applyConceptUserFilter.TRIGGER action", () => {
-    const name = "by country";
-    const payload = { userFilter: { name } };
-    expect(
-      conceptSelectedUserFilter(fooState, {
-        type: applyConceptUserFilter.TRIGGER,
-        payload
-      })
-    ).toEqual(name);
-
-    expect(
-      conceptSelectedUserFilter(name, {
-        type: applyConceptUserFilter.TRIGGER,
-        payload
-      })
-    ).toEqual(null);
-  });
-
-  it("should handle the removeConceptFilter.TRIGGER action", () => {
-    expect(
-      conceptSelectedUserFilter(fooState, {
-        type: removeConceptFilter.TRIGGER
-      })
-    ).toEqual(initialState);
-  });
-
-  it("should handle the resetConceptFilters.TRIGGER action", () => {
-    expect(
-      conceptSelectedUserFilter(fooState, {
-        type: resetConceptFilters.TRIGGER
-      })
-    ).toEqual(initialState);
-  });
-
-  it("should ignore unknown actions", () => {
-    expect(conceptSelectedUserFilter(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

package/src/concepts/reducers/__tests__/conceptUserFilters.spec.js

@@ -1,76 +0,0 @@
-import _ from "lodash/fp";
-import { accentInsensitivePathOrder } from "@truedat/core/services/sort";
-import { initialState } from "../conceptUserFilters";
-import {
-  fetchConceptUserFilters,
-  clearConceptUserFilters,
-  deleteConceptUserFilter,
-  saveConceptFilters
-} from "../../routines";
-import { conceptUserFilters } from "..";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: conceptActiveFilters", () => {
-  it("should provide the initial state", () => {
-    expect(conceptUserFilters(undefined, {})).toEqual(initialState);
-  });
-
-  it("should handle the fetchConceptUserFilters.SUCCESS action", () => {
-    const filters = [
-      { name: "b", id: 1, filters: { country: ["S"] } },
-      { name: "a", id: 2, filters: { country: ["S2"] } }
-    ];
-    const sortedFilters = _.sortBy(accentInsensitivePathOrder("name"))(filters);
-    expect(
-      conceptUserFilters(fooState, {
-        type: fetchConceptUserFilters.SUCCESS,
-        payload: { data: filters }
-      })
-    ).toEqual(sortedFilters);
-  });
-
-  it("should handle the saveConceptFilters.SUCCESS action", () => {
-    const filters = [
-      { name: "b", id: 1, filters: { country: ["S"] } },
-      { name: "a", id: 2, filters: { country: ["S2"] } }
-    ];
-    const newFilter = { name: "c", id: 3, filters: { country: ["S3"] } };
-    const sortedFilters = _.flow(
-      _.concat([newFilter]),
-      _.sortBy(accentInsensitivePathOrder("name"))
-    )(filters);
-
-    expect(
-      conceptUserFilters(filters, {
-        type: saveConceptFilters.SUCCESS,
-        payload: { data: newFilter }
-      })
-    ).toEqual(sortedFilters);
-  });
-
-  it("should handle the deleteConceptUserFilter.SUCCESS action", () => {
-    const filters = [
-      { name: "b", id: 1, filters: { country: ["S"] } },
-      { name: "a", id: 2, filters: { country: ["S2"] } }
-    ];
-    expect(
-      conceptUserFilters(filters, {
-        type: deleteConceptUserFilter.SUCCESS,
-        meta: { id: 1 }
-      })
-    ).toEqual([{ name: "a", id: 2, filters: { country: ["S2"] } }]);
-  });
-
-  it("should handle the clearConceptUserFilters.TRIGGER action", () => {
-    expect(
-      conceptUserFilters(fooState, {
-        type: clearConceptUserFilters.TRIGGER
-      })
-    ).toEqual(initialState);
-  });
-
-  it("should ignore unknown actions", () => {
-    expect(conceptUserFilters(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

package/src/concepts/reducers/__tests__/concepts.spec.js

@@ -1,40 +0,0 @@
-import { clearConcepts, fetchConcepts } from "../../routines";
-import { concepts } from "..";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: concept", () => {
-  const initialState = [];
-
-  it("should provide the initial state", () => {
-    expect(concepts(undefined, {})).toEqual(initialState);
-  });
-
-  it("should handle the clearConcepts.TRIGGER action", () => {
-    expect(concepts(fooState, { type: clearConcepts.TRIGGER })).toEqual(
-      initialState
-    );
-  });
-
-  it("should handle the fetchConcepts.FAILURE action", () => {
-    expect(concepts(fooState, { type: fetchConcepts.FAILURE })).toEqual(
-      initialState
-    );
-  });
-
-  it("should handle the fetchConcepts.SUCCESS action", () => {
-    const collection = [{ id: 1, name: "Concept 1", business_concept_id: 4 }];
-    const data = { data: collection };
-    const headers = { "x-total-count": "123" };
-    expect(
-      concepts(fooState, {
-        type: fetchConcepts.SUCCESS,
-        payload: { data, headers }
-      })
-    ).toEqual(collection);
-  });
-
-  it("should ignore unknown actions", () => {
-    expect(concepts(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

package/src/concepts/reducers/__tests__/conceptsActions.spec.js

@@ -1,38 +0,0 @@
-import { fetchConcepts } from "../../routines";
-import { conceptsActions } from "..";
-
-const fooState = { foo: "bar" };
-const payload = {};
-
-describe("reducers: conceptsActions", () => {
-  it("should provide the initial state", () => {
-    expect(conceptsActions(undefined, {})).toEqual({});
-  });
-
-  it("should be an empty object after receiving the fetchConcepts.REQUEST action", () => {
-    expect(
-      conceptsActions(fooState, { type: fetchConcepts.REQUEST, payload })
-    ).toEqual({});
-  });
-
-  it("should extract _actions from the fetchConcepts.SUCCESS action", () => {
-    const _actions = { delete: { foo: "bar" } };
-    const data = { _actions };
-    const payload = { data };
-    expect(
-      conceptsActions(fooState, { type: fetchConcepts.SUCCESS, payload })
-    ).toMatchObject(_actions);
-  });
-
-  it("should be an empty object after receiving the fetchConcepts.SUCCESS action without _actions", () => {
-    const data = [{ id: 1 }];
-    const payload = { data };
-    expect(
-      conceptsActions(fooState, { type: fetchConcepts.SUCCESS, payload })
-    ).toEqual({});
-  });
-
-  it("should ignore unhandled actions", () => {
-    expect(conceptsActions(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

package/src/concepts/reducers/__tests__/conceptsLoading.spec.js

@@ -1,32 +0,0 @@
-import { fetchConcepts } from "../../routines";
-import { conceptsLoading } from "..";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: conceptsLoading", () => {
-  it("should provide the initial state", () => {
-    expect(conceptsLoading(undefined, {})).toBe(false);
-  });
-
-  it("should be true after receiving the fetchConcepts.REQUEST action", () => {
-    expect(conceptsLoading(fooState, { type: fetchConcepts.REQUEST })).toBe(
-      true
-    );
-  });
-
-  it("should be false after receiving the fetchConcepts.SUCCESS action", () => {
-    expect(conceptsLoading(fooState, { type: fetchConcepts.SUCCESS })).toBe(
-      false
-    );
-  });
-
-  it("should be false after receiving the fetchConcepts.FAILURE action", () => {
-    expect(conceptsLoading(fooState, { type: fetchConcepts.FAILURE })).toBe(
-      false
-    );
-  });
-
-  it("should ignore unhandled actions", () => {
-    expect(conceptsLoading(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

package/src/concepts/reducers/__tests__/conceptsPageSize.spec.js

@@ -1,33 +0,0 @@
-import { fetchConcepts } from "../../routines";
-import { conceptsPageSize } from "..";
-
-const fooState = { foo: "bar" };
-const initialState = 20;
-
-describe("reducers: conceptsPageSize", () => {
-  it("should provide the initial state", () => {
-    expect(conceptsPageSize(undefined, {})).toEqual(initialState);
-  });
-
-  describe("action: fetchConcepts.TRIGGER", () => {
-    describe("with an empty payload", () => {
-      it("should return the passed state if no size is specified", () => {
-        const payload = {};
-        expect(
-          conceptsPageSize(fooState, { type: fetchConcepts.TRIGGER, payload })
-        ).toEqual(fooState);
-      });
-    });
-
-    it("should set size value if specified", () => {
-      const size = 1234;
-
-      expect(
-        conceptsPageSize(fooState, {
-          type: fetchConcepts.TRIGGER,
-          payload: { size }
-        })
-      ).toBe(1234);
-    });
-  });
-});

package/src/concepts/reducers/__tests__/previousConceptQuery.spec.js

@@ -1,23 +0,0 @@
-import { fetchConcepts } from "../../routines";
-import { previousConceptQuery } from "..";
-
-const fooState = { foo: "bar" };
-const initialState = {};
-
-describe("reducers: previousConceptQuery", () => {
-  it("should provide the initial state", () => {
-    expect((undefined, {})).toEqual(initialState);
-  });
-
-  it("should handle the fetchConcepts.TRIGGER action", () => {
-    const payload = {
-      filters: { status: ["published"] },
-      page: 0,
-      size: 20,
-      query: "some quey"
-    };
-    expect(
-      previousConceptQuery(fooState, { type: fetchConcepts.TRIGGER, payload })
-    ).toEqual(payload);
-  });
-});