@truedat/bg 7.0.5 → 7.0.7

package/src/taxonomy/components/DomainLoader.js

@@ -1,60 +0,0 @@
-import React from "react";
-import { withRouter } from "react-router-dom";
-import PropTypes from "prop-types";
-import { compose } from "redux";
-import { connect } from "react-redux";
-import { Loading } from "@truedat/core/components";
-import { clearDomain, fetchDomain } from "../routines";
-
-class DomainLoader extends React.Component {
-  static propTypes = {
-    fetchDomain: PropTypes.func,
-    clearDomain: PropTypes.func,
-    match: PropTypes.object,
-    domainLoading: PropTypes.bool,
-  };
-
-  componentDidMount() {
-    const { clearDomain, fetchDomain, match } = this.props;
-    const { id } = match.params;
-    if (id) {
-      fetchDomain({ id });
-    } else {
-      clearDomain();
-    }
-  }
-
-  componentDidUpdate(prevProps) {
-    const { clearDomain, fetchDomain, match } = this.props;
-    const { id } = match.params;
-    if (prevProps.match.params.id !== id) {
-      if (id) {
-        fetchDomain({ id });
-      } else {
-        clearDomain();
-      }
-    }
-  }
-
-  componentWillUnmount() {
-    const { clearDomain } = this.props;
-    clearDomain();
-  }
-
-  render() {
-    const { domainLoading } = this.props;
-
-    if (domainLoading) {
-      return <Loading />;
-    } else {
-      return null;
-    }
-  }
-}
-
-const mapStateToProps = ({ domainLoading }) => ({ domainLoading });
-
-export default compose(
-  withRouter,
-  connect(mapStateToProps, { clearDomain, fetchDomain })
-)(DomainLoader);

package/src/taxonomy/components/DomainMembersLoader.js

@@ -1,44 +0,0 @@
-import React from "react";
-import { withRouter } from "react-router-dom";
-import PropTypes from "prop-types";
-import { compose } from "redux";
-import { connect } from "react-redux";
-import { fetchDomainMembers } from "../routines";
-
-class DomainMembersLoader extends React.Component {
-  static propTypes = {
-    fetchDomainMembers: PropTypes.func,
-    match: PropTypes.object,
-  };
-
-  componentDidMount() {
-    const { fetchDomainMembers, match } = this.props;
-    const { id } = match.params;
-    if (id) {
-      fetchDomainMembers({ id });
-    }
-  }
-
-  componentDidUpdate(prevProps) {
-    const { fetchDomainMembers, match } = this.props;
-    const { id } = match.params;
-    if (prevProps.match.params.id !== id) {
-      if (id) {
-        fetchDomainMembers({ id });
-      }
-    }
-  }
-
-  render() {
-    return null;
-  }
-}
-
-const mapStateToProps = ({ domainMembersLoading }) => ({
-  domainMembersLoading,
-});
-
-export default compose(
-  withRouter,
-  connect(mapStateToProps, { fetchDomainMembers })
-)(DomainMembersLoader);

package/src/taxonomy/components/DomainsLoader.js

@@ -1,40 +0,0 @@
-import React from "react";
-import PropTypes from "prop-types";
-import { connect } from "react-redux";
-import { Loading } from "@truedat/core/components";
-import { clearDomains, fetchDomains } from "../routines";
-
-export class DomainsLoader extends React.Component {
-  static propTypes = {
-    actions: PropTypes.string,
-    clearDomains: PropTypes.func,
-    fetchDomains: PropTypes.func,
-    filter: PropTypes.string,
-    domainLoading: PropTypes.bool,
-  };
-
-  componentDidMount() {
-    const { fetchDomains, actions, filter } = this.props;
-    fetchDomains({ actions, filter });
-  }
-
-  componentWillUnmount() {
-    const { clearDomains } = this.props;
-    clearDomains();
-  }
-
-  render() {
-    const { domainLoading } = this.props;
-    if (domainLoading) {
-      return <Loading />;
-    } else {
-      return null;
-    }
-  }
-}
-
-const mapStateToProps = ({ domainLoading }) => ({ domainLoading });
-
-export default connect(mapStateToProps, { clearDomains, fetchDomains })(
-  DomainsLoader
-);

package/src/taxonomy/components/__tests__/DomainCards.spec.js

@@ -1,30 +0,0 @@
-import React from "react";
-import { shallow } from "enzyme";
-import { intl } from "@truedat/test/intl-stub";
-import { DomainCards } from "../DomainCards";
-
-// workaround for enzyme issue with React.useContext
-// see https://github.com/airbnb/enzyme/issues/2176#issuecomment-532361526
-jest.spyOn(React, "useContext").mockImplementation(() => intl);
-
-describe("<DomainCards />", () => {
-  const domainsFilter = "d";
-
-  it("matches the latest snapshot", () => {
-    const visibleDomains = [
-      { id: 1, name: "domain1" },
-      { id: 2, name: "domain2" }
-    ];
-    const props = { visibleDomains, domainsFilter };
-    const wrapper = shallow(<DomainCards {...props} />);
-    expect(wrapper).toMatchSnapshot();
-  });
-
-  it("matches the latest snapshot (no subdomains)", () => {
-    const domain = { id: 1 };
-    const visibleDomains = [];
-    const props = { domain, visibleDomains, domainsFilter };
-    const wrapper = shallow(<DomainCards {...props} />);
-    expect(wrapper).toMatchSnapshot();
-  });
-});

package/src/taxonomy/components/__tests__/DomainsLoader.spec.js

@@ -1,38 +0,0 @@
-import React from "react";
-import { mount } from "enzyme";
-import { DomainsLoader } from "../DomainsLoader";
-
-const getProps = () => ({
-  clearDomains: jest.fn(),
-  domainsLoading: false,
-  fetchDomains: jest.fn(),
-  actions: "create_ingest",
-  filter: "all"
-});
-
-describe("<DomainsLoader />", () => {
-  it("calls fetchDomains when component mounts but not when it unmounts", () => {
-    const props = getProps();
-    const wrapper = mount(<DomainsLoader {...props} />);
-    expect(props.fetchDomains).toHaveBeenCalledTimes(1);
-    wrapper.unmount();
-    expect(props.fetchDomains).toHaveBeenCalledTimes(1);
-  });
-
-  it("calls clearDomains and clearDomainDefaultFilters when component unmounts but not when it mounts", () => {
-    const props = getProps();
-    const wrapper = mount(<DomainsLoader {...props} />);
-    expect(props.clearDomains).toHaveBeenCalledTimes(0);
-    wrapper.unmount();
-    expect(props.clearDomains).toHaveBeenCalledTimes(1);
-  });
-
-  it("renders Loading when domainLoading is true", () => {
-    const props = getProps();
-
-    const wrapper = mount(
-      <DomainsLoader {...{ ...props, domainLoading: true }} />
-    );
-    expect(wrapper.find("Loading").length).toBe(1);
-  });
-});

package/src/taxonomy/components/__tests__/__snapshots__/DomainCards.spec.js.snap

@@ -1,160 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`<DomainCards /> matches the latest snapshot (no subdomains) 1`] = `
-<Fragment>
-  <Divider
-    hidden={true}
-  />
-  <Header
-    as="h4"
-  >
-    <Icon
-      as="i"
-      name="search"
-    />
-    <HeaderContent>
-      <MemoizedFormattedMessage
-        id="domains.search.results.empty"
-      />
-    </HeaderContent>
-  </Header>
-  <Message
-    header="domain.children.empty"
-  />
-  <CardGroup />
-</Fragment>
-`;
-
-exports[`<DomainCards /> matches the latest snapshot 1`] = `
-<Fragment>
-  <Divider
-    hidden={true}
-  />
-  <Header
-    as="h4"
-  >
-    <Icon
-      as="i"
-      name="search"
-    />
-    <HeaderContent>
-      <MemoizedFormattedMessage
-        id="domains.search.results.count"
-        values={
-          {
-            "count": 2,
-          }
-        }
-      />
-    </HeaderContent>
-  </Header>
-  <CardGroup>
-    <Card
-      as={
-        {
-          "$$typeof": Symbol(react.forward_ref),
-          "displayName": "Link",
-          "propTypes": {
-            "innerRef": [Function],
-            "onClick": [Function],
-            "replace": [Function],
-            "target": [Function],
-            "to": [Function],
-          },
-          "render": [Function],
-        }
-      }
-      key="1"
-      link={true}
-      to="/domains/1"
-    >
-      <CardContent>
-        <CardHeader>
-          <Icon
-            as="i"
-            name="cube"
-          />
-          domain1
-        </CardHeader>
-        <CardMeta>
-          <span>
-            <MemoizedFormattedMessage
-              id="domain"
-            />
-          </span>
-        </CardMeta>
-      </CardContent>
-      <CardContent />
-      <CardContent
-        extra={true}
-      >
-        <Icon
-          as="i"
-          name="cubes"
-        />
-        <MemoizedFormattedMessage
-          id="domain.props.children"
-          values={
-            {
-              "count": undefined,
-            }
-          }
-        />
-      </CardContent>
-    </Card>
-    <Card
-      as={
-        {
-          "$$typeof": Symbol(react.forward_ref),
-          "displayName": "Link",
-          "propTypes": {
-            "innerRef": [Function],
-            "onClick": [Function],
-            "replace": [Function],
-            "target": [Function],
-            "to": [Function],
-          },
-          "render": [Function],
-        }
-      }
-      key="2"
-      link={true}
-      to="/domains/2"
-    >
-      <CardContent>
-        <CardHeader>
-          <Icon
-            as="i"
-            name="cube"
-          />
-          domain2
-        </CardHeader>
-        <CardMeta>
-          <span>
-            <MemoizedFormattedMessage
-              id="domain"
-            />
-          </span>
-        </CardMeta>
-      </CardContent>
-      <CardContent />
-      <CardContent
-        extra={true}
-      >
-        <Icon
-          as="i"
-          name="cubes"
-        />
-        <MemoizedFormattedMessage
-          id="domain.props.children"
-          values={
-            {
-              "count": undefined,
-            }
-          }
-        />
-      </CardContent>
-    </Card>
-  </CardGroup>
-</Fragment>
-`;

package/src/taxonomy/reducers/__tests__/domain.spec.js

@@ -1,58 +0,0 @@
-import { clearDomain, fetchDomain, updateDomain } from "../../routines";
-import { domain } from "..";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: domain", () => {
-  const initialState = {};
-
-  it("should provide the initial state", () => {
-    expect(domain(undefined, {})).toEqual(initialState);
-  });
-
-  it("should handle the clearDomain.TRIGGER action", () => {
-    expect(domain(fooState, { type: clearDomain.TRIGGER })).toEqual(
-      initialState
-    );
-  });
-
-  it("should handle the fetchDomain.TRIGGER action", () => {
-    expect(domain(fooState, { type: fetchDomain.TRIGGER })).toEqual(
-      initialState
-    );
-  });
-
-  it("should handle the fetchDomain.SUCCESS action", () => {
-    const data = {
-      id: 1,
-      name: "Domain 1",
-      external_id: "External Id 1",
-      domain_group: { id: 1, name: "Group" }
-    };
-    expect(
-      domain(fooState, {
-        type: fetchDomain.SUCCESS,
-        payload: { data }
-      })
-    ).toEqual(data);
-  });
-
-  it("should handle the updateDomain.SUCCESS action", () => {
-    const domain1 = {
-      id: 1,
-      name: "Domain 1",
-      external_id: "External Id 1",
-      domain_group: { id: 1, name: "Group" }
-    };
-    expect(
-      domain(fooState, {
-        type: updateDomain.SUCCESS,
-        payload: { data: domain1 }
-      })
-    ).toEqual(domain1);
-  });
-
-  it("should ignore unknown actions", () => {
-    expect(domain(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

package/src/taxonomy/reducers/__tests__/domainConceptLoading.spec.js

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

package/src/taxonomy/reducers/__tests__/domainCreating.spec.js

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

package/src/taxonomy/reducers/__tests__/domainLoading.spec.js

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

package/src/taxonomy/reducers/__tests__/domainMembersActions.spec.js

@@ -1,38 +0,0 @@
-import { fetchDomain, fetchDomainMembers, clearDomain } from "../../routines";
-import { domainMembersActions, initialState } from "../domainMembersActions";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: domainsMembersActions", () => {
-  it("should provide the initial state", () => {
-    expect(domainMembersActions(undefined, {})).toBe(initialState);
-  });
-
-  it("should be an empty object after receiving the fetchDomain.TRIGGER action", () => {
-    expect(domainMembersActions(fooState, { type: fetchDomain.TRIGGER })).toBe(
-      initialState
-    );
-  });
-
-  it("should be an empty object after receiving the clearDomain.TRIGGER action", () => {
-    expect(domainMembersActions(fooState, { type: clearDomain.TRIGGER })).toBe(
-      initialState
-    );
-  });
-
-  it("should extract links from the fetchDomainMembers.SUCCESS action", () => {
-    const self = { href: "/foo/bar", methods: ["GET", "DELETE"] };
-    const _links = { self };
-    const payload = { _links };
-    expect(
-      domainMembersActions(fooState, {
-        type: fetchDomainMembers.SUCCESS,
-        payload
-      })
-    ).toBe(self);
-  });
-
-  it("should ignore unhandled actions", () => {
-    expect(domainMembersActions(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

package/src/taxonomy/reducers/__tests__/domainMembersLoading.spec.js

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

package/src/taxonomy/reducers/__tests__/domainRedirect.spec.js

@@ -1,36 +0,0 @@
-import { clearRedirect } from "@truedat/core/routines";
-import { createDomain, updateDomain } from "../../routines";
-import { domainRedirect } from "..";
-
-describe("reducers: domainRedirect", () => {
-  const id = 10;
-  const resource_id = 20;
-  const payload = { data: { id, resource_id } };
-  const initialState = "";
-
-  it("should provide the initial state", () => {
-    expect(domainRedirect(undefined, {})).toEqual("");
-  });
-
-  it("should handle the clearRedirect.TRIGGER action", () => {
-    expect(domainRedirect("foo", { type: clearRedirect.TRIGGER })).toEqual(
-      initialState
-    );
-  });
-
-  it("should handle the createDomain.SUCCESS action", () => {
-    expect(
-      domainRedirect("foo", { type: createDomain.SUCCESS, payload })
-    ).toEqual("/domains/10");
-  });
-
-  it("should handle the updateDomain.SUCCESS action", () => {
-    expect(
-      domainRedirect("foo", { type: updateDomain.SUCCESS, payload })
-    ).toEqual("/domains/10");
-  });
-
-  it("should ignore unknown actions", () => {
-    expect(domainRedirect("foo", { type: "bar", payload })).toEqual("foo");
-  });
-});

package/src/taxonomy/reducers/__tests__/domainUpdating.spec.js

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

package/src/taxonomy/reducers/__tests__/domains.spec.js

@@ -1,30 +0,0 @@
-import { fetchDomains } from "../../routines";
-import { domains } from "..";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: domains", () => {
-  const initialState = [];
-
-  it("should provide the initial state", () => {
-    expect(domains(undefined, {})).toEqual(initialState);
-  });
-
-  it("should handle the SUCCESS action", () => {
-    const data = [
-      { id: 1, name: "Domain 1", description: "Desc 1" },
-      { id: 2, name: "Domain 2", description: "Desc 2", parent_id: 1 },
-    ];
-
-    expect(
-      domains(fooState, {
-        type: fetchDomains.SUCCESS,
-        payload: { data: { data } },
-      })
-    ).toMatchObject(data);
-  });
-
-  it("should ignore unknown actions", () => {
-    expect(domains(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});