Skip to content

Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.

9.6 KB
Raw Blame
// SPDX-License-Identifier: MIT
// Copyright contributors to the kepler.gl project

import React from 'react';
import test from 'tape';
import {mount} from 'enzyme';
import configureStore from 'redux-mock-store';
import {Provider} from 'react-redux';
import sinon from 'sinon';
import {console as Console} from 'global/window';

import {
  withState,
  injector,
  injectComponents,
  PanelHeaderFactory,
  provideRecipesToInjector
} from '@kepler.gl/components';

import {keplerGlInit} from '@kepler.gl/actions';
import {
  keplerGlReducerCore as coreReducer,
  visStateLens,
  uiStateLens,
  mapStateLens,
  mapStyleLens
} from '@kepler.gl/reducers';

const mockStore = configureStore();
const initialCoreState = coreReducer(undefined, keplerGlInit({}));

test('Components -> injector -> injectComponents', t => {
  const CustomHeader = () => <div className="my-test-header">smoothie</div>;
  const myCustomHeaderFactory = () => CustomHeader;

  const KeplerGl = injectComponents([[PanelHeaderFactory, myCustomHeaderFactory]]);

  // assume instance reducer is already mounted
  const store = mockStore({
    keplerGl: {
      foo: initialCoreState
    }
  });

  const wrapper = mount(
    <Provider store={store}>
      <KeplerGl id="foo" mapboxApiAccessToken="smoothie_and_milkshake" />
    </Provider>
  );

  // test if custom header is rendered
  t.ok(wrapper.find('.my-test-header').length, 'should render custom header');
  t.end();
});

test('Components -> injector -> missing deps', t => {
  const spy = sinon.spy(Console, 'error');
  // eslint-disable-next-line react/display-name
  const myCustomNameFactory = () => () => <div className="my-test-header-name">name</div>;
  // eslint-disable-next-line react/display-name
  const myCustomHeaderFactory = Name => () =>
    (
      <div className="my-test-header-1">
        <Name />
        smoothie
      </div>
    );
  myCustomHeaderFactory.deps = [myCustomNameFactory];

  const KeplerGl = injectComponents([[PanelHeaderFactory, myCustomHeaderFactory]]);

  // assume instance reducer is already mounted
  const store = mockStore({
    keplerGl: {
      foo: initialCoreState
    }
  });

  const wrapper = mount(
    <Provider store={store}>
      <KeplerGl id="foo" mapboxApiAccessToken="smoothie_and_milkshake" />
    </Provider>
  );

  t.ok(spy.notCalled, 'Should automatically add custom deps and not call console.error');

  t.ok(wrapper.find('.my-test-header-name').length, 'should still render custom header name');

  spy.restore();
  t.end();
});

test('Components -> injector -> wrong factory type', t => {
  const spy = sinon.spy(Console, 'error');
  // eslint-disable-next-line react/display-name
  const myCustomHeaderFactory = Name => () =>
    (
      <div className="my-test-header-2">
        <Name />
        smoothie
      </div>
    );

  const KeplerGl = injectComponents([[undefined, myCustomHeaderFactory]]);

  // assume instance reducer is already mounted
  const store = mockStore({
    keplerGl: {
      foo: initialCoreState
    }
  });

  const wrapper = mount(
    <Provider store={store}>
      <KeplerGl id="foo" mapboxApiAccessToken="smoothie_and_milkshake" />
    </Provider>
  );

  t.equal(
    spy.getCall(0).args[0],
    'Error injecting factory: ',
    'should warn when default factory is not provided'
  );

  t.equal(
    spy.getCall(1).args[0],
    'factory and its replacement should be a function',
    'should warn when default factory is not provided'
  );
  // test if custom header is rendered
  t.ok(wrapper.find('.side-panel__panel-header').length, 'should render default header');

  spy.restore();
  t.end();
});

test('Components -> injector -> wrong replacement type', t => {
  const spy = sinon.spy(Console, 'error');
  // const spy = sinon.spy(Console, 'error');

  const KeplerGl = injectComponents([[PanelHeaderFactory, undefined]]);

  // assume instance reducer is already mounted
  const store = mockStore({
    keplerGl: {
      foo: initialCoreState
    }
  });

  const wrapper = mount(
    <Provider store={store}>
      <KeplerGl id="foo" mapboxApiAccessToken="smoothie_and_milkshake" />
    </Provider>
  );

  t.ok(spy.calledTwice, 'should call console.error twice');
  t.equal(
    spy.getCall(0).args[0],
    'Error injecting replacement for: ',
    'should warn when replace factory is not provided'
  );

  // test if custom header is rendered
  t.ok(wrapper.find('.side-panel__panel-header').length, 'should render default header');

  spy.restore();
  t.end();
});

test('Components -> injector -> replace and render existing', t => {
  myCustomHeaderFactory.deps = PanelHeaderFactory.deps;

  function myCustomHeaderFactory(...deps) {
    const PanelHeader = PanelHeaderFactory(...deps);
    PanelHeader.defaultProps;
    const MyHeader = props => {
      return <PanelHeader {...props} appName="taro" />;
    };
    return MyHeader;
  }

  const KeplerGl = injectComponents([[PanelHeaderFactory, myCustomHeaderFactory]]);
  // assume instance reducer is already mounted
  const store = mockStore({
    keplerGl: {
      foo: initialCoreState
    }
  });

  let wrapper;
  t.doesNotThrow(() => {
    wrapper = mount(
      <Provider store={store}>
        <KeplerGl id="foo" mapboxApiAccessToken="smoothie_and_milkshake" />
      </Provider>
    );
  }, 'should not throw error when replace and render existing component');

  t.equal(wrapper.find('.logo__link').text(), 'taro', 'should render provided prop');
  t.end();
});

test('Components -> injector -> withState.lens', t => {
  const CustomHeader = () => <div className="my-test-header-3">smoothie</div>;
  const myCustomHeaderFactory = () =>
    withState([visStateLens, mapStateLens, uiStateLens, mapStyleLens])(CustomHeader);

  const KeplerGl = injectComponents([[PanelHeaderFactory, myCustomHeaderFactory]]);

  // assume instance reducer is already mounted
  const store = mockStore({
    keplerGl: {
      foo: initialCoreState
    }
  });

  const wrapper = mount(
    <Provider store={store}>
      <KeplerGl id="foo" mapboxApiAccessToken="smoothie_and_milkshake" />
    </Provider>
  );

  const header = wrapper.find(CustomHeader).at(0);
  const props = header.props();

  t.ok(header, 'should render CustomHeader');
  // test if custom header is rendered
  t.ok(props.visState, 'should add visState to props');
  t.ok(props.mapState, 'should add mapState to props');
  t.ok(props.mapStyle, 'should add mapStyle to props');
  t.ok(props.uiState, 'should add uiState to props');

  t.end();
});

test('Components -> injector -> withState.mapStateToProps', t => {
  const CustomHeader = () => <div className="my-test-header-3">smoothie</div>;
  const myCustomHeaderFactory = () =>
    withState([], state => ({ids: Object.keys(state)}))(CustomHeader);

  const KeplerGl = injectComponents([[PanelHeaderFactory, myCustomHeaderFactory]]);

  // assume instance reducer is already mounted
  const store = mockStore({
    keplerGl: {
      foo: initialCoreState
    }
  });

  const wrapper = mount(
    <Provider store={store}>
      <KeplerGl id="foo" mapboxApiAccessToken="smoothie_and_milkshake" />
    </Provider>
  );

  // test if custom header is rendered
  const header = wrapper.find(CustomHeader).at(0);
  const props = header.props();

  t.ok(header, 'should render CustomHeader');
  t.deepEqual(props.ids, ['keplerGl'], 'should run mapStateToProps');

  t.end();
});

test('Components -> injector -> actions', t => {
  const CustomHeader = ({add}) => (
    <div className="my-test-header-3" onClick={add}>
      smoothie
    </div>
  );

  const testAction = () => ({type: 'ADD'});

  const myCustomHeaderFactory = () =>
    withState([], state => state, {add: testAction})(CustomHeader);

  const KeplerGl = injectComponents([[PanelHeaderFactory, myCustomHeaderFactory]]);

  // assume instance reducer is already mounted
  const store = mockStore({
    keplerGl: {
      foo: initialCoreState
    }
  });

  const wrapper = mount(
    <Provider store={store}>
      <KeplerGl id="foo" mapboxApiAccessToken="smoothie_and_milkshake" />
    </Provider>
  );

  // test if custom header is rendered
  const header = wrapper.find(CustomHeader).at(0);
  const props = header.props();

  t.ok(header, 'should render CustomHeader');
  t.ok(typeof props.add === 'function', 'should add actions');

  wrapper.find(CustomHeader).simulate('click');

  const lastAction = store.getActions().pop();
  t.deepEqual(lastAction, {type: 'ADD'}, 'should dispatch custom actions');

  t.end();
});

test('Components -> injector -> provideRecipesToInjector', t => {
  // Header1 -> Header 2 -> Header 3
  const spyMyHeader3Factory = sinon.spy();
  const spyMyHeader2Factory = sinon.spy();
  const spyMyHeader1Factory = sinon.spy();

  const myHeader3Factory = () => {
    spyMyHeader3Factory('getHeader3');
    const Header3 = () => <div className="my-test-header-3">hello world</div>;
    return Header3;
  };

  const myHeader2Factory = MyHeader3 => {
    spyMyHeader2Factory('getHeader2');
    const Header2 = () => (
      <div className="my-test-header-2">
        <MyHeader3 />
      </div>
    );
    return Header2;
  };
  myHeader2Factory.deps = [myHeader3Factory];

  const myHeader1Factory = MyCustomHeader2 => {
    spyMyHeader1Factory('getHeader1');
    const Header1 = () => (
      <div className="my-test-header-1">
        <MyCustomHeader2 />
      </div>
    );
    return Header1;
  };

  myHeader1Factory.deps = [myHeader2Factory];

  const recipe1 = [myHeader1Factory, myHeader1Factory];

  provideRecipesToInjector([recipe1], injector());

  t.equal(spyMyHeader1Factory.called, true, 'Should call myHeader1Factory');
  t.equal(spyMyHeader2Factory.called, true, 'Should call myHeader2Factory');
  t.equal(spyMyHeader3Factory.called, true, 'Should call myHeader3Factory');

  t.end();
});