@northern.tech/store 0.1.1 → 0.1.3

package/deploymentsSlice/thunks.ts

@@ -1,382 +0,0 @@
-// Copyright 2024 Northern.tech AS
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-// @ts-nocheck
-
-/*eslint import/namespace: ['error', { allowComputed: true }]*/
-import storeActions from '@northern.tech/store/actions';
-import GeneralApi from '@northern.tech/store/api/general-api';
-import { DEVICE_LIST_DEFAULTS, SORTING_OPTIONS, TIMEOUTS, headerNames } from '@northern.tech/store/constants';
-import { getDevicesById, getGlobalSettings, getUserCapabilities } from '@northern.tech/store/selectors';
-import { commonErrorHandler } from '@northern.tech/store/store';
-import { getDeviceAuth, getDeviceById, saveGlobalSettings } from '@northern.tech/store/thunks';
-import { mapTermsToFilters } from '@northern.tech/store/utils';
-import { deepCompare, isEmpty, standardizePhases, startTimeSort } from '@northern.tech/utils/helpers';
-import { createAsyncThunk } from '@reduxjs/toolkit';
-import isUUID from 'validator/lib/isUUID';
-
-import { actions, sliceName } from '.';
-import { DEPLOYMENT_ROUTES, DEPLOYMENT_STATES, DEPLOYMENT_TYPES, deploymentPrototype, deploymentsApiUrl, deploymentsApiUrlV2 } from './constants';
-import { getDeploymentsById, getDeploymentsByStatus as getDeploymentsByStatusSelector } from './selectors';
-
-const { receivedDevice, setSnackbar } = storeActions;
-
-// default per page until pagination and counting integrated
-const { page: defaultPage, perPage: defaultPerPage } = DEVICE_LIST_DEFAULTS;
-
-export const deriveDeploymentGroup = ({ filter = {}, group, groups = [], name }) => (group || (groups.length === 1 && !isUUID(name)) ? groups[0] : filter.name);
-
-const transformDeployments = (deployments, deploymentsById) =>
-  deployments.sort(startTimeSort).reduce(
-    (accu, item) => {
-      const filter = item.filter ?? {};
-      let deployment = {
-        ...deploymentPrototype,
-        ...deploymentsById[item.id],
-        ...item,
-        filter: item.filter ? { ...filter, name: filter.name ?? filter.id, filters: mapTermsToFilters(filter.terms) } : undefined,
-        name: decodeURIComponent(item.name)
-      };
-      // deriving the group in a second step to potentially make use of the merged data from the existing group state + the decoded name
-      deployment = { ...deployment, group: deriveDeploymentGroup(deployment) };
-      accu.deployments[item.id] = deployment;
-      accu.deploymentIds.push(item.id);
-      return accu;
-    },
-    { deployments: {}, deploymentIds: [] }
-  );
-
-/*Deployments */
-export const getDeploymentsByStatus = createAsyncThunk(`${sliceName}/getDeploymentsByStatus`, (options = {}, { dispatch, getState }) => {
-  const { status, page = defaultPage, per_page = defaultPerPage, startDate, endDate, group, type, shouldSelect = true, sort = SORTING_OPTIONS.desc } = options;
-  const created_after = startDate ? `&created_after=${startDate}` : '';
-  const created_before = endDate ? `&created_before=${endDate}` : '';
-  const search = group ? `&search=${group}` : '';
-  const typeFilter = type ? `&type=${type}` : '';
-  return GeneralApi.get(
-    `${deploymentsApiUrl}/deployments?status=${status}&per_page=${per_page}&page=${page}${created_after}${created_before}${search}${typeFilter}&sort=${sort}`
-  ).then(res => {
-    const { deployments, deploymentIds } = transformDeployments(res.data, getState().deployments.byId);
-    const total = Number(res.headers[headerNames.total]);
-    let tasks = [
-      dispatch(actions.receivedDeployments(deployments)),
-      dispatch(
-        actions.receivedDeploymentsForStatus({
-          deploymentIds,
-          status,
-          total: !(startDate || endDate || group || type) ? total : getState().deployments.byStatus[status].total
-        })
-      )
-    ];
-    tasks = deploymentIds.reduce((accu, deploymentId) => {
-      if (deployments[deploymentId].type === DEPLOYMENT_TYPES.configuration) {
-        accu.push(dispatch(getSingleDeployment(deploymentId)));
-      }
-      return accu;
-    }, tasks);
-    if (shouldSelect) {
-      tasks.push(dispatch(actions.selectDeploymentsForStatus({ deploymentIds, status, total })));
-    }
-    tasks.push({ deploymentIds, total });
-    return Promise.all(tasks);
-  });
-});
-
-const MAX_PREVIOUS_PHASES_COUNT = 5;
-export const createDeployment = createAsyncThunk(`${sliceName}/createDeployment`, ({ newDeployment, hasNewRetryDefault = false }, { dispatch, getState }) => {
-  let request;
-  if (newDeployment.filter_id) {
-    request = GeneralApi.post(`${deploymentsApiUrlV2}/deployments`, newDeployment);
-  } else if (newDeployment.group) {
-    request = GeneralApi.post(`${deploymentsApiUrl}/deployments/group/${newDeployment.group}`, newDeployment);
-  } else {
-    request = GeneralApi.post(`${deploymentsApiUrl}/deployments`, newDeployment);
-  }
-  return request
-    .catch(err => commonErrorHandler(err, 'Error creating deployment.', dispatch))
-    .then(data => {
-      const lastslashindex = data.headers.location.lastIndexOf('/');
-      const deploymentId = data.headers.location.substring(lastslashindex + 1);
-      const deployment = {
-        ...newDeployment,
-        id: deploymentId,
-        devices: newDeployment.devices ? newDeployment.devices.map(id => ({ id, status: 'pending' })) : [],
-        statistics: { status: {} }
-      };
-      let tasks = [
-        dispatch(actions.createdDeployment(deployment)),
-        dispatch(getSingleDeployment(deploymentId)),
-        dispatch(setSnackbar('Deployment created successfully', TIMEOUTS.fiveSeconds))
-      ];
-      const { canManageUsers } = getUserCapabilities(getState());
-      if (canManageUsers) {
-        const { phases, retries } = newDeployment;
-        const { previousPhases = [], retries: previousRetries = 0 } = getGlobalSettings(getState());
-        let newSettings = { retries: hasNewRetryDefault ? retries : previousRetries, hasDeployments: true };
-        if (phases) {
-          const standardPhases = standardizePhases(phases);
-          let prevPhases = previousPhases.map(standardizePhases);
-          if (!prevPhases.find(previousPhaseList => previousPhaseList.every(oldPhase => standardPhases.find(phase => deepCompare(phase, oldPhase))))) {
-            prevPhases.push(standardPhases);
-          }
-          newSettings.previousPhases = prevPhases.slice(-1 * MAX_PREVIOUS_PHASES_COUNT);
-        }
-        tasks.push(dispatch(saveGlobalSettings(newSettings)));
-      }
-      return Promise.all(tasks);
-    });
-});
-
-export const getDeploymentDevices = createAsyncThunk(`${sliceName}/getDeploymentDevices`, (options, { dispatch, getState }) => {
-  const { id, page = defaultPage, perPage = defaultPerPage } = options;
-  return GeneralApi.get(`${deploymentsApiUrl}/deployments/${id}/devices/list?&page=${page}&per_page=${perPage}`).then(response => {
-    const { devices: deploymentDevices = {} } = getState().deployments.byId[id] || {};
-    const devices = response.data.reduce((accu, item) => {
-      accu[item.id] = item;
-      const log = (deploymentDevices[item.id] || {}).log;
-      if (log) {
-        accu[item.id].log = log;
-      }
-      return accu;
-    }, {});
-    const selectedDeviceIds = Object.keys(devices);
-    let tasks = [
-      dispatch(
-        actions.receivedDeploymentDevices({
-          id,
-          devices,
-          selectedDeviceIds,
-          totalDeviceCount: Number(response.headers[headerNames.total])
-        })
-      )
-    ];
-    const devicesById = getDevicesById(getState());
-    // only update those that have changed & lack data
-    const lackingData = selectedDeviceIds.reduce((accu, deviceId) => {
-      const device = devicesById[deviceId];
-      if (!device || !device.identity_data || !device.attributes || Object.keys(device.attributes).length === 0) {
-        accu.push(deviceId);
-      }
-      return accu;
-    }, []);
-    // get device artifact, inventory and identity details not listed in schedule data
-    tasks = lackingData.reduce((accu, deviceId) => [...accu, dispatch(getDeviceById(deviceId)), dispatch(getDeviceAuth(deviceId))], tasks);
-    return Promise.all(tasks);
-  });
-});
-
-const parseDeviceDeployment = ({
-  deployment: { id, artifact_name: release, status: deploymentStatus },
-  device: { created, deleted, id: deviceId, finished, status, log }
-}) => ({
-  id,
-  release,
-  created,
-  deleted,
-  deviceId,
-  finished,
-  status,
-  log,
-  route: Object.values(DEPLOYMENT_ROUTES).reduce((accu, { key, states }) => {
-    if (!accu) {
-      return states.includes(deploymentStatus) ? key : accu;
-    }
-    return accu;
-  }, '')
-});
-
-export const getDeviceDeployments = createAsyncThunk(`${sliceName}/getDeviceDeployments`, (options, { dispatch }) => {
-  const { deviceId, filterSelection = [], page = defaultPage, perPage = defaultPerPage } = options;
-  const filters = filterSelection.map(item => `&status=${item}`).join('');
-  return GeneralApi.get(`${deploymentsApiUrl}/deployments/devices/${deviceId}?page=${page}&per_page=${perPage}${filters}`)
-    .then(({ data, headers }) =>
-      Promise.resolve(
-        dispatch(
-          receivedDevice({
-            id: deviceId,
-            deviceDeployments: data.map(parseDeviceDeployment),
-            deploymentsCount: Number(headers[headerNames.total])
-          })
-        )
-      )
-    )
-    .catch(err => commonErrorHandler(err, 'There was an error retrieving the device deployment history:', dispatch));
-});
-
-export const resetDeviceDeployments = createAsyncThunk(`${sliceName}/resetDeviceDeployments`, (deviceId, { dispatch }) =>
-  GeneralApi.delete(`${deploymentsApiUrl}/deployments/devices/${deviceId}/history`)
-    .then(() => Promise.resolve(dispatch(getDeviceDeployments({ deviceId }))))
-    .catch(err => commonErrorHandler(err, 'There was an error resetting the device deployment history:', dispatch))
-);
-
-export const getSingleDeployment = createAsyncThunk(`${sliceName}/getSingleDeployment`, (id, { dispatch, getState }) =>
-  GeneralApi.get(`${deploymentsApiUrl}/deployments/${id}`).then(({ data }) => {
-    const { deployments } = transformDeployments([data], getState().deployments.byId);
-    return Promise.resolve(dispatch(actions.receivedDeployment(deployments[id])));
-  })
-);
-
-export const getDeviceLog = createAsyncThunk(`${sliceName}/getDeviceLog`, ({ deploymentId, deviceId }, { dispatch }) =>
-  GeneralApi.get(`${deploymentsApiUrl}/deployments/${deploymentId}/devices/${deviceId}/log`)
-    .catch(e => {
-      console.log('no log here', e);
-      return Promise.reject();
-    })
-    .then(({ data: log }) =>
-      Promise.all([Promise.resolve(dispatch(actions.receivedDeploymentDeviceLog({ id: deploymentId, deviceId, log }))), Promise.resolve(log)])
-    )
-);
-
-export const abortDeployment = createAsyncThunk(`${sliceName}/abortDeployment`, (deploymentId, { dispatch, getState }) =>
-  GeneralApi.put(`${deploymentsApiUrl}/deployments/${deploymentId}/status`, { status: 'aborted' })
-    .then(() => {
-      const deploymentsByStatus = getDeploymentsByStatusSelector(getState());
-      let status = DEPLOYMENT_STATES.pending;
-      let index = deploymentsByStatus.pending.deploymentIds.findIndex(id => id === deploymentId);
-      if (index < 0) {
-        status = DEPLOYMENT_STATES.inprogress;
-        index = deploymentsByStatus.inprogress.deploymentIds.findIndex(id => id === deploymentId);
-      }
-      const deploymentIds = [...deploymentsByStatus[status].deploymentIds.slice(0, index), ...deploymentsByStatus[status].deploymentIds.slice(index + 1)];
-      const deploymentsById = getDeploymentsById(getState());
-      const deployments = deploymentIds.reduce((accu, id) => {
-        accu[id] = deploymentsById[id];
-        return accu;
-      }, {});
-      const total = Math.max(deploymentsByStatus[status].total - 1, 0);
-      return Promise.all([
-        dispatch(actions.receivedDeployments(deployments)),
-        dispatch(actions.receivedDeploymentsForStatus({ deploymentIds, status, total })),
-        dispatch(actions.removedDeployment(deploymentId)),
-        dispatch(setSnackbar('The deployment was successfully aborted'))
-      ]);
-    })
-    .catch(err => commonErrorHandler(err, 'There was an error while aborting the deployment:', dispatch))
-);
-
-export const updateDeploymentControlMap = createAsyncThunk(`${sliceName}/updateDeploymentControlMap`, ({ deploymentId, updateControlMap }, { dispatch }) =>
-  GeneralApi.patch(`${deploymentsApiUrl}/deployments/${deploymentId}`, { update_control_map: updateControlMap })
-    .catch(err => commonErrorHandler(err, 'There was an error while updating the deployment status:', dispatch))
-    .then(() => Promise.resolve(dispatch(getSingleDeployment(deploymentId))))
-);
-
-export const setDeploymentsState = createAsyncThunk(`${sliceName}/setDeploymentsState`, (selection, { dispatch, getState }) => {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const { page, perPage, ...selectionState } = selection;
-  const currentState = getState().deployments.selectionState;
-  let nextState = {
-    ...currentState,
-    ...selectionState,
-    ...Object.keys(DEPLOYMENT_STATES).reduce((accu, item) => {
-      accu[item] = {
-        ...currentState[item],
-        ...selectionState[item]
-      };
-      return accu;
-    }, {}),
-    general: {
-      ...currentState.general,
-      ...selectionState.general
-    }
-  };
-  let tasks = [dispatch(actions.setDeploymentsState(nextState))];
-  if (nextState.selectedId && currentState.selectedId !== nextState.selectedId) {
-    tasks.push(dispatch(getSingleDeployment(nextState.selectedId)));
-  }
-  return Promise.all(tasks);
-});
-
-const deltaAttributeMappings = [
-  { here: 'compressionLevel', there: 'compression_level' },
-  { here: 'disableChecksum', there: 'disable_checksum' },
-  { here: 'disableDecompression', there: 'disable_external_decompression' },
-  { here: 'sourceWindow', there: 'source_window_size' },
-  { here: 'inputWindow', there: 'input_window_size' },
-  { here: 'duplicatesWindow', there: 'compression_duplicates_window' },
-  { here: 'instructionBuffer', there: 'instruction_buffer_size' }
-];
-
-const mapExternalDeltaConfig = (config = {}) =>
-  deltaAttributeMappings.reduce((accu, { here, there }) => {
-    if (config[there] !== undefined) {
-      accu[here] = config[there];
-    }
-    return accu;
-  }, {});
-
-export const getDeploymentsConfig = createAsyncThunk(`${sliceName}/getDeploymentsConfig`, (_, { dispatch, getState }) =>
-  GeneralApi.get(`${deploymentsApiUrl}/config`).then(({ data }) => {
-    const oldConfig = getState().deployments.config;
-    const { delta = {} } = data;
-    const { binary_delta = {}, binary_delta_limits = {} } = delta;
-    const { xdelta_args = {}, timeout: timeoutConfig = oldConfig.binaryDelta.timeout } = binary_delta;
-    const { xdelta_args_limits = {}, timeout: timeoutLimit = oldConfig.binaryDeltaLimits.timeout } = binary_delta_limits;
-    const config = {
-      ...oldConfig,
-      hasDelta: Boolean(delta.enabled),
-      binaryDelta: {
-        ...oldConfig.binaryDelta,
-        timeout: timeoutConfig,
-        ...mapExternalDeltaConfig(xdelta_args)
-      },
-      binaryDeltaLimits: {
-        ...oldConfig.binaryDeltaLimits,
-        timeout: timeoutLimit,
-        ...mapExternalDeltaConfig(xdelta_args_limits)
-      }
-    };
-    return Promise.resolve(dispatch(actions.setDeploymentsConfig(config)));
-  })
-);
-
-// traverse a source object and remove undefined & empty object properties to only return an attribute if there really is content worth sending
-const deepClean = source =>
-  Object.entries(source).reduce((accu, [key, value]) => {
-    if (value !== undefined) {
-      let cleanedValue = typeof value === 'object' ? deepClean(value) : value;
-      if (cleanedValue === undefined || (typeof cleanedValue === 'object' && isEmpty(cleanedValue))) {
-        return accu;
-      }
-      accu = { ...(accu ?? {}), [key]: cleanedValue };
-    }
-    return accu;
-  }, undefined);
-
-export const saveDeltaDeploymentsConfig = createAsyncThunk(`${sliceName}/saveDeltaDeploymentsConfig`, (config, { dispatch, getState }) => {
-  const configChange = {
-    timeout: config.timeout,
-    xdelta_args: deltaAttributeMappings.reduce((accu, { here, there }) => {
-      if (config[here] !== undefined) {
-        accu[there] = config[here];
-      }
-      return accu;
-    }, {})
-  };
-  const result = deepClean(configChange);
-  if (!result) {
-    return Promise.resolve();
-  }
-  return GeneralApi.put(`${deploymentsApiUrl}/config/binary_delta`, result)
-    .catch(err => commonErrorHandler(err, 'There was a problem storing your delta artifact generation configuration.', dispatch))
-    .then(() => {
-      const oldConfig = getState().deployments.config;
-      const newConfig = {
-        ...oldConfig,
-        binaryDelta: {
-          ...oldConfig.binaryDelta,
-          ...config
-        }
-      };
-      return Promise.all([dispatch(actions.setDeploymentsConfig(newConfig)), dispatch(setSnackbar('Settings saved successfully'))]);
-    });
-});

package/devicesSlice/constants.ts

@@ -1,56 +0,0 @@
-// Copyright 2019 Northern.tech AS
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-import { DEVICE_FILTERING_OPTIONS, apiUrl } from '@northern.tech/store/constants';
-
-export const emptyFilter = { key: null, value: '', operator: DEVICE_FILTERING_OPTIONS.$eq.key, scope: 'inventory' };
-
-export const deviceAuthV2 = `${apiUrl.v2}/devauth`;
-export const deviceConnect = `${apiUrl.v1}/deviceconnect`;
-export const inventoryApiUrl = `${apiUrl.v1}/inventory`;
-export const inventoryApiUrlV2 = `${apiUrl.v2}/inventory`;
-export const deviceConfig = `${apiUrl.v1}/deviceconfig/configurations/device`;
-export const reportingApiUrl = `${apiUrl.v1}/reporting`;
-export const iotManagerBaseURL = `${apiUrl.v1}/iot-manager`;
-
-// see https://github.com/mendersoftware/go-lib-micro/tree/master/ws
-//     for the description of proto_header and the consts
-// *Note*: this needs to be aligned with mender-connect and deviceconnect.
-export const DEVICE_MESSAGE_PROTOCOLS = {
-  Shell: 1
-};
-export const DEVICE_MESSAGE_TYPES = {
-  Delay: 'delay',
-  New: 'new',
-  Ping: 'ping',
-  Pong: 'pong',
-  Resize: 'resize',
-  Shell: 'shell',
-  Stop: 'stop'
-};
-
-// we can't include the dismiss state with the rest since this would include dismissed devices in several queries
-export const DEVICE_DISMISSAL_STATE = 'dismiss';
-export const DEVICE_STATES = {
-  accepted: 'accepted',
-  pending: 'pending',
-  preauth: 'preauthorized',
-  rejected: 'rejected'
-};
-export const DEVICE_CONNECT_STATES = {
-  connected: 'connected',
-  disconnected: 'disconnected',
-  unknown: 'unknown'
-};
-
-export const geoAttributes = ['geo-lat', 'geo-lon'].map(attribute => ({ attribute, scope: 'inventory' }));

package/devicesSlice/reducer.test.ts

@@ -1,194 +0,0 @@
-// Copyright 2024 Northern.tech AS
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-// @ts-nocheck
-
-/*eslint import/namespace: ['error', { allowComputed: true }]*/
-import reducer, { actions, initialState } from '.';
-import { defaultState } from '../../../../tests/mockData';
-import { DEVICE_STATES } from './constants';
-
-describe('device reducer', () => {
-  it('should return the initial state', async () => {
-    expect(reducer(undefined, {})).toEqual(initialState);
-  });
-
-  it('should handle RECEIVE_GROUPS', async () => {
-    expect(reducer(undefined, { type: actions.receivedGroups, payload: defaultState.devices.groups.byId }).groups.byId).toEqual(
-      defaultState.devices.groups.byId
-    );
-    expect(reducer(initialState, { type: actions.receivedGroups, payload: defaultState.devices.groups.byId }).groups.byId).toEqual(
-      defaultState.devices.groups.byId
-    );
-    expect(
-      reducer(initialState, { type: actions.receivedGroups, payload: { testExtra: { deviceIds: [], total: 0, filters: [] } } }).groups.byId.testExtra
-    ).toEqual({
-      deviceIds: [],
-      total: 0,
-      filters: []
-    });
-  });
-  it('should handle RECEIVE_GROUP_DEVICES', async () => {
-    expect(
-      reducer(undefined, {
-        type: actions.addGroup,
-        payload: {
-          groupName: 'testGroupDynamic',
-          group: defaultState.devices.groups.byId.testGroupDynamic
-        }
-      }).groups.byId.testGroupDynamic
-    ).toEqual(defaultState.devices.groups.byId.testGroupDynamic);
-    expect(
-      reducer(initialState, {
-        type: actions.addGroup,
-        payload: {
-          groupName: 'testGroupDynamic',
-          group: defaultState.devices.groups.byId.testGroupDynamic
-        }
-      }).groups.byId.testGroupDynamic
-    ).toEqual(defaultState.devices.groups.byId.testGroupDynamic);
-  });
-  it('should handle RECEIVE_DYNAMIC_GROUPS', async () => {
-    expect(reducer(undefined, { type: actions.receivedGroups, payload: defaultState.devices.groups.byId }).groups.byId).toEqual(
-      defaultState.devices.groups.byId
-    );
-    expect(reducer(initialState, { type: actions.receivedGroups, payload: defaultState.devices.groups.byId }).groups.byId).toEqual(
-      defaultState.devices.groups.byId
-    );
-    expect(
-      reducer(initialState, { type: actions.receivedGroups, payload: { testExtra: { deviceIds: [], total: 0, filters: [] } } }).groups.byId.testExtra
-    ).toEqual({ deviceIds: [], total: 0, filters: [] });
-  });
-  it('should handle ADD_TO_GROUP', async () => {
-    let state = reducer(undefined, { type: actions.receivedGroups, payload: defaultState.devices.groups.byId });
-    expect(reducer(state, { type: actions.addToGroup, payload: { group: 'testExtra', deviceIds: ['d1'] } }).groups.byId.testExtra.deviceIds).toHaveLength(1);
-    expect(
-      reducer(initialState, { type: actions.addToGroup, payload: { group: 'testGroup', deviceIds: ['123', '1243'] } }).groups.byId.testGroup.deviceIds
-    ).toHaveLength(2);
-  });
-  it('should handle REMOVE_FROM_GROUP', async () => {
-    let state = reducer(undefined, { type: actions.receivedGroups, payload: defaultState.devices.groups.byId });
-    state = reducer(state, { type: actions.selectGroup, payload: 'testGroup' });
-    expect(
-      reducer(state, { type: actions.removeFromGroup, payload: { group: 'testGroup', deviceIds: [defaultState.devices.groups.byId.testGroup.deviceIds[0]] } })
-        .groups.byId.testGroup.deviceIds
-    ).toHaveLength(defaultState.devices.groups.byId.testGroup.deviceIds.length - 1);
-    expect(
-      reducer(state, { type: actions.removeFromGroup, payload: { group: 'testGroup', deviceIds: defaultState.devices.groups.byId.testGroup.deviceIds } }).groups
-        .byId.testGroup
-    ).toBeFalsy();
-    expect(
-      reducer(initialState, { type: actions.removeFromGroup, payload: { group: 'testExtra', deviceIds: ['123', '1243'] } }).groups.byId.testExtra
-    ).toBeFalsy();
-  });
-  it('should handle ADD_DYNAMIC_GROUP', async () => {
-    expect(
-      reducer(undefined, { type: actions.addGroup, payload: { groupName: 'test', group: { something: 'test' } } }).groups.byId.test.something
-    ).toBeTruthy();
-    expect(
-      reducer(initialState, { type: actions.addGroup, payload: { groupName: 'test', group: { something: 'test' } } }).groups.byId.test.something
-    ).toBeTruthy();
-  });
-  it('should handle ADD_STATIC_GROUP', async () => {
-    expect(
-      reducer(undefined, { type: actions.addGroup, payload: { groupName: 'test', group: { something: 'test' } } }).groups.byId.test.something
-    ).toBeTruthy();
-    expect(
-      reducer(initialState, { type: actions.addGroup, payload: { groupName: 'test', group: { something: 'test' } } }).groups.byId.test.something
-    ).toBeTruthy();
-  });
-
-  it('should handle REMOVE_DYNAMIC_GROUP', async () => {
-    let state = reducer(undefined, { type: actions.receivedGroups, payload: defaultState.devices.groups.byId });
-    expect(Object.keys(reducer(state, { type: actions.removeGroup, payload: 'testGroupDynamic' }).groups.byId)).toHaveLength(
-      Object.keys(defaultState.devices.groups.byId).length - 1
-    );
-    expect(Object.keys(reducer(initialState, { type: actions.removeGroup, payload: 'testGroupDynamic' }).groups.byId)).toHaveLength(0);
-  });
-  it('should handle REMOVE_STATIC_GROUP', async () => {
-    let state = reducer(undefined, { type: actions.receivedGroups, payload: defaultState.devices.groups.byId });
-    expect(Object.keys(reducer(state, { type: actions.removeGroup, payload: 'testGroup' }).groups.byId)).toHaveLength(
-      Object.keys(defaultState.devices.groups.byId).length - 1
-    );
-    expect(Object.keys(reducer(initialState, { type: actions.removeGroup, payload: 'testGroup' }).groups.byId)).toHaveLength(0);
-  });
-  it('should handle SET_DEVICE_LIST_STATE', async () => {
-    expect(reducer(undefined, { type: actions.setDeviceListState, payload: { deviceIds: ['test'] } }).deviceList.deviceIds).toEqual(['test']);
-    expect(reducer(initialState, { type: actions.setDeviceListState, payload: { deviceIds: ['test'] } }).deviceList.deviceIds).toEqual(['test']);
-  });
-  it('should handle SET_DEVICE_FILTERS', async () => {
-    expect(reducer(undefined, { type: actions.setDeviceFilters, payload: defaultState.devices.groups.byId.testGroupDynamic.filters }).filters).toHaveLength(1);
-    expect(reducer(initialState, { type: actions.setDeviceFilters, payload: [{ key: 'test', operator: 'test' }] }).filters).toHaveLength(0);
-  });
-  it('should handle SET_FILTERABLES_CONFIG', async () => {
-    expect(reducer(undefined, { type: actions.setFilterablesConfig, payload: { attributes: { asd: true } } }).filteringAttributesConfig).toEqual({
-      attributes: { asd: true },
-      count: undefined,
-      limit: undefined
-    });
-    expect(
-      reducer(initialState, { type: actions.setFilterablesConfig, payload: { attributes: { asd: true }, count: 1, limit: 10 } }).filteringAttributesConfig
-    ).toEqual({ attributes: { asd: true }, count: 1, limit: 10 });
-  });
-  it('should handle SET_FILTER_ATTRIBUTES', async () => {
-    expect(reducer(undefined, { type: actions.setFilterAttributes, payload: { things: '12' } }).filteringAttributes).toEqual({ things: '12' });
-    expect(reducer(initialState, { type: actions.setFilterAttributes, payload: { things: '12' } }).filteringAttributes).toEqual({ things: '12' });
-  });
-  it('should handle SET_TOTAL_DEVICES', async () => {
-    expect(reducer(undefined, { type: actions.setTotalDevices, payload: 2 }).total).toEqual(2);
-    expect(reducer(initialState, { type: actions.setTotalDevices, payload: 4 }).total).toEqual(4);
-  });
-  it('should handle SET_DEVICE_LIMIT', async () => {
-    expect(reducer(undefined, { type: actions.setDeviceLimit, payload: 500 }).limit).toEqual(500);
-    expect(reducer(initialState, { type: actions.setDeviceLimit, payload: 200 }).limit).toEqual(200);
-  });
-
-  it('should handle RECEIVE_DEVICE', async () => {
-    expect(reducer(undefined, { type: actions.receivedDevice, payload: defaultState.devices.byId.b1 }).byId.b1).toEqual(defaultState.devices.byId.b1);
-    expect(reducer(initialState, { type: actions.receivedDevice, payload: defaultState.devices.byId.b1 }).byId).not.toBe({});
-  });
-  it('should handle RECEIVE_DEVICES', async () => {
-    expect(reducer(undefined, { type: actions.receivedDevices, payload: defaultState.devices.byId }).byId).toEqual(defaultState.devices.byId);
-    expect(reducer(initialState, { type: actions.receivedDevices, payload: defaultState.devices.byId }).byId).toEqual(defaultState.devices.byId);
-  });
-  it('should handle SET_INACTIVE_DEVICES', async () => {
-    expect(
-      reducer(undefined, { type: actions.setInactiveDevices, payload: { activeDeviceTotal: 1, inactiveDeviceTotal: 1 } }).byStatus.active.total
-    ).toBeTruthy();
-    expect(
-      reducer(initialState, { type: actions.setInactiveDevices, payload: { activeDeviceTotal: 1, inactiveDeviceTotal: 1 } }).byStatus.inactive.total
-    ).toEqual(1);
-  });
-  it('should handle SET_DEVICE_REPORTS', async () => {
-    expect(reducer(undefined, { type: actions.setDeviceReports, payload: [1, 2, 3] }).reports).toHaveLength(3);
-    expect(reducer(initialState, { type: actions.setDeviceReports, payload: [{ something: 'here' }] }).reports).toEqual([{ something: 'here' }]);
-  });
-  it('should handle SET_<authstatus>_DEVICES', async () => {
-    Object.values(DEVICE_STATES).forEach(status => {
-      expect(reducer(undefined, { type: actions.setDevicesByStatus, payload: { deviceIds: ['a1'], total: 1, status } }).byStatus[status]).toEqual({
-        deviceIds: ['a1'],
-        total: 1
-      });
-      expect(reducer(initialState, { type: actions.setDevicesByStatus, payload: { deviceIds: ['a1'], status } }).byStatus[status]).toEqual({
-        deviceIds: [],
-        total: 0
-      });
-    });
-  });
-  it('should handle SET_<authstatus>_DEVICES_COUNT', async () => {
-    Object.values(DEVICE_STATES).forEach(status => {
-      expect(reducer(undefined, { type: actions.setDevicesCountByStatus, payload: { count: 1, status } }).byStatus[status].total).toEqual(1);
-      expect(reducer(initialState, { type: actions.setDevicesCountByStatus, payload: { count: 1, status } }).byStatus[status].total).toEqual(1);
-    });
-  });
-});