@spinnaker/kayenta 0.0.0-main-2

package/src/kayenta/reducers/index.ts

@@ -0,0 +1,245 @@
+import * as Actions from 'kayenta/actions';
+import * as Creators from 'kayenta/actions/creators';
+import { CanarySettings } from 'kayenta/canary.settings';
+import {
+  ICanaryAnalysisResult,
+  ICanaryJudgeConfig,
+  ICanaryMetricConfig,
+  IJudge,
+  KayentaAccountType,
+} from 'kayenta/domain';
+import { JudgeSelectRenderState } from 'kayenta/edit/judgeSelect';
+import { metricResultsSelector } from 'kayenta/selectors';
+import { mapStateToConfig } from 'kayenta/service/canaryConfig.service';
+import { chain, isEqual } from 'lodash';
+import { Action, combineReducers } from 'redux';
+import { combineActions, handleActions } from 'redux-actions';
+
+import { app, IAppState } from './app';
+import { AsyncRequestState } from './asyncRequest';
+import { data, IDataState } from './data';
+import { ISelectedConfigState, selectedConfig } from './selectedConfig';
+import { ISelectedRunState, selectedRun } from './selectedRun';
+import { validationErrorsReducer } from './validators';
+
+export interface ICanaryState {
+  app: IAppState;
+  data: IDataState;
+  selectedConfig: ISelectedConfigState;
+  selectedRun: ISelectedRunState;
+}
+
+const combined = combineReducers<ICanaryState>({
+  app,
+  configValidationErrors: () => null,
+  data,
+  selectedConfig,
+  selectedRun,
+});
+
+const getRenderState = (judges: IJudge[], judgeConfig: ICanaryJudgeConfig): JudgeSelectRenderState => {
+  if (judges.some((judge) => judge.name === judgeConfig.name)) {
+    if (judges.length === 1) {
+      return JudgeSelectRenderState.None;
+    } else {
+      return JudgeSelectRenderState.Multiple;
+    }
+  } else {
+    return JudgeSelectRenderState.Single;
+  }
+};
+
+const judgeRenderStateReducer = handleActions(
+  {
+    [combineActions(Actions.SELECT_CONFIG, Actions.UPDATE_JUDGES)]: (state: ICanaryState) => {
+      // At this point, we've already passed through the rest of the reducers, so
+      // the judge has been normalized on the state.
+      const {
+        data: { judges = [] },
+        selectedConfig: {
+          judge: { judgeConfig },
+        },
+      } = state;
+
+      if (!judgeConfig) {
+        return state;
+      } else {
+        return {
+          ...state,
+          selectedConfig: {
+            ...state.selectedConfig,
+            judge: {
+              ...state.selectedConfig.judge,
+              renderState: getRenderState(judges, judgeConfig),
+            },
+          },
+        };
+      }
+    },
+  },
+  null,
+);
+
+const isInSyncWithServerReducer = (state: ICanaryState): ICanaryState => {
+  return {
+    ...state,
+    selectedConfig: {
+      ...state.selectedConfig,
+      isInSyncWithServer: (() => {
+        const editedConfig = mapStateToConfig(state);
+        if (!editedConfig) {
+          return true;
+        } else {
+          const originalConfig = state.data.configs.find((c) => c.id === editedConfig.id);
+          // If we're saving the config right now, don't warn that
+          // the config hasn't been saved.
+          if (
+            !originalConfig &&
+            editedConfig.isNew &&
+            state.selectedConfig.save.state === AsyncRequestState.Requesting
+          ) {
+            return true;
+          }
+          return isEqual(editedConfig, originalConfig);
+        }
+      })(),
+    },
+  };
+};
+
+const resolveSelectedMetricId = (state: ICanaryState, action: Action & any): string => {
+  switch (action.type) {
+    case Actions.SELECT_REPORT_METRIC:
+      return action.payload.metricId;
+
+    // On report load, pick the first metric.
+    case Actions.LOAD_RUN_SUCCESS:
+      return metricResultsSelector(state).length ? metricResultsSelector(state)[0].id : null;
+
+    // On group select, pick the first metric in the group.
+    case Actions.SELECT_REPORT_METRIC_GROUP: {
+      const results = metricResultsSelector(state);
+      if (!results.length) {
+        return null;
+      }
+
+      const group = action.payload.group;
+      const filter: (r: ICanaryAnalysisResult) => boolean = group ? (r) => r.groups.includes(group) : () => true;
+
+      return results.find(filter) ? results.find(filter).id : null;
+    }
+
+    default:
+      return null;
+  }
+};
+
+const selectedMetricReducer = (state: ICanaryState, action: Action & any) => {
+  if (
+    ![Actions.SELECT_REPORT_METRIC, Actions.SELECT_REPORT_METRIC_GROUP, Actions.LOAD_RUN_SUCCESS].includes(action.type)
+  ) {
+    return state;
+  }
+
+  const id = resolveSelectedMetricId(state, action);
+  if (!id) {
+    return state;
+  }
+
+  // Load metric set pair.
+  action.asyncDispatch(
+    Creators.loadMetricSetPairRequest({
+      pairId: id,
+    }),
+  );
+
+  return {
+    ...state,
+    selectedRun: {
+      ...state.selectedRun,
+      selectedMetric: id,
+      metricSetPair: {
+        ...state.selectedRun.metricSetPair,
+        load: AsyncRequestState.Requesting,
+      },
+    },
+  };
+};
+
+// TODO(dpeach): this assumes that a config can only use one metric store.
+// If that changes, then metric store handling will have to be done per metric.
+const selectedMetricStoreReducer = (state: ICanaryState, action: Action & any) => {
+  switch (action.type) {
+    case Actions.SELECT_CONFIG:
+    case Actions.LOAD_KAYENTA_ACCOUNTS_SUCCESS: {
+      const stores = chain(state.data.kayentaAccounts.data)
+        .filter((account) => account.supportedTypes.includes(KayentaAccountType.MetricsStore))
+        .map((account) => account.metricsStoreType || account.type)
+        .uniq()
+        .valueOf();
+
+      let selectedStore = (state.selectedConfig.metricList || [])
+        .map((metric) => metric.query.type)
+        .find((store) => !!store);
+
+      selectedStore =
+        selectedStore ||
+        (stores.length ? (stores.includes(CanarySettings.metricStore) ? CanarySettings.metricStore : stores[0]) : null);
+
+      return {
+        ...state,
+        selectedConfig: {
+          ...state.selectedConfig,
+          selectedStore,
+        },
+      };
+    }
+
+    case Actions.SELECT_METRIC_STORE: {
+      const selectedStore: string = action.payload.store;
+      // Flips all metrics to use the selected metric store.
+      const metricUpdater = (metric: ICanaryMetricConfig): ICanaryMetricConfig => ({
+        ...metric,
+        query: { ...metric.query, type: selectedStore, serviceType: selectedStore },
+      });
+
+      return {
+        ...state,
+        selectedConfig: {
+          ...state.selectedConfig,
+          metricList: state.selectedConfig.metricList.map(metricUpdater),
+          selectedStore,
+        },
+      };
+    }
+
+    default:
+      return state;
+  }
+};
+
+const disableConfigEditReducer = (state: ICanaryState) => {
+  if (!state.selectedConfig.config) {
+    return state;
+  }
+
+  return {
+    ...state,
+    app: {
+      ...state.app,
+      disableConfigEdit: !state.selectedConfig.config.applications.includes(state.data.application.name),
+    },
+  };
+};
+
+export const rootReducer = (state: ICanaryState, action: Action & any): ICanaryState => {
+  return [
+    combined,
+    judgeRenderStateReducer,
+    selectedMetricStoreReducer,
+    selectedMetricReducer,
+    disableConfigEditReducer,
+    validationErrorsReducer,
+    isInSyncWithServerReducer,
+  ].reduce((s, reducer) => reducer(s, action), state);
+};

package/src/kayenta/reducers/prometheusMetricConfig.spec.ts

@@ -0,0 +1,33 @@
+import * as Actions from 'kayenta/actions';
+
+import { prometheusMetricConfigReducer } from './prometheusMetricConfig';
+
+describe('Reducer: prometheusMetricConfigReducer', () => {
+  describe('update query field', () => {
+    it('updates arbitrary query key/value pairs on a query', () => {
+      const nextState = prometheusMetricConfigReducer({ query: { resourceType: 'aws_ec2_instance' } } as any, {
+        type: Actions.UPDATE_PROMETHEUS_METRIC_QUERY_FIELD,
+        payload: { field: 'resourceType', value: 'gce_instance' },
+      });
+      expect(nextState.query.resourceType).toEqual('gce_instance');
+    });
+
+    it('creates key/value pair if not already extant on the query', () => {
+      const nextState = prometheusMetricConfigReducer({ query: {} } as any, {
+        type: Actions.UPDATE_PROMETHEUS_METRIC_QUERY_FIELD,
+        payload: { field: 'resourceType', value: 'gce_instance' },
+      });
+      expect(nextState.query.resourceType).toEqual('gce_instance');
+    });
+
+    it('deletes key/value pair if passed falsy value', () => {
+      [null, undefined, ''].forEach((falsyValue) => {
+        const nextState = prometheusMetricConfigReducer({ query: { resourceType: 'aws_ec2_instance' } } as any, {
+          type: Actions.UPDATE_PROMETHEUS_METRIC_QUERY_FIELD,
+          payload: { field: 'resourceType', value: falsyValue },
+        });
+        expect(nextState.query.resourceType).toBeUndefined();
+      });
+    });
+  });
+});

package/src/kayenta/reducers/prometheusMetricConfig.ts

@@ -0,0 +1,56 @@
+import * as Actions from 'kayenta/actions';
+import { IKayentaAction } from 'kayenta/actions/creators';
+import { ICanaryMetricConfig } from 'kayenta/domain';
+import { IUpdateListPayload, updateListReducer } from 'kayenta/layout/list';
+import { IPrometheusCanaryMetricSetQueryConfig } from 'kayenta/metricStore/prometheus/domain/IPrometheusCanaryMetricSetQueryConfig';
+import { omit } from 'lodash';
+import { Action } from 'redux';
+import { handleActions } from 'redux-actions';
+
+const updateLabelBindingsReducer = updateListReducer();
+const updateGroupByReducer = updateListReducer();
+
+type IPrometheusMetricConfig = ICanaryMetricConfig<IPrometheusCanaryMetricSetQueryConfig>;
+
+export const prometheusMetricConfigReducer = handleActions<IPrometheusMetricConfig, Action & any>(
+  {
+    [Actions.UPDATE_PROMETHEUS_METRIC_TYPE]: (state: IPrometheusMetricConfig, action: Action & any) => ({
+      ...state,
+      query: { ...state.query, metricName: action.payload.metricName, type: 'prometheus' },
+    }),
+    [Actions.UPDATE_PROMETHEUS_METRIC_QUERY_FIELD]: (state: IPrometheusMetricConfig, action: Action & any) => {
+      if (!action.payload.value) {
+        return {
+          ...state,
+          query: omit(state.query, action.payload.field),
+        };
+      }
+
+      return {
+        ...state,
+        query: { ...state.query, [action.payload.field]: action.payload.value },
+      };
+    },
+    [Actions.UPDATE_PROMETHEUS_LABEL_BINDINGS]: (
+      state: IPrometheusMetricConfig,
+      action: IKayentaAction<IUpdateListPayload>,
+    ) => ({
+      ...state,
+      query: {
+        ...state.query,
+        labelBindings: updateLabelBindingsReducer(state.query.labelBindings || [], action),
+      },
+    }),
+    [Actions.UPDATE_PROMETHEUS_GROUP_BY_FIELDS]: (
+      state: IPrometheusMetricConfig,
+      action: IKayentaAction<IUpdateListPayload>,
+    ) => ({
+      ...state,
+      query: {
+        ...state.query,
+        groupByFields: updateGroupByReducer(state.query.groupByFields || [], action),
+      },
+    }),
+  },
+  null,
+);

package/src/kayenta/reducers/selectedConfig.spec.ts

@@ -0,0 +1,190 @@
+import * as Actions from 'kayenta/actions/index';
+
+import { ICanaryMetricConfig, IGroupWeights } from '../domain/ICanaryConfig';
+import { IGroupState } from './group';
+import {
+  changeMetricGroupConfirmReducer,
+  editGroupConfirmReducer,
+  ISelectedConfigState,
+  updateGroupWeightsReducer,
+} from './selectedConfig';
+
+describe('Reducer: editGroupConfirmReducer', () => {
+  const createSelectedConfigState = (groupName: string): ISelectedConfigState =>
+    ({
+      metricList: [
+        {
+          name: 'metricA',
+          groups: [groupName, 'groupC'],
+        },
+      ] as ICanaryMetricConfig[],
+      group: {
+        list: [groupName, 'groupC'],
+        groupWeights: {
+          [groupName]: 50,
+          otherGroupName: 50,
+        },
+        selected: groupName,
+      },
+    } as any); // Ignore missing fields for type ISelectedConfigState.
+
+  let state: ISelectedConfigState;
+
+  beforeEach(() => {
+    state = createSelectedConfigState('groupA');
+  });
+
+  it('ignores actions other than EDIT_GROUP_CONFIRM', () => {
+    expect(editGroupConfirmReducer(state, { type: 'arbitrary_action' })).toEqual(createSelectedConfigState('groupA'));
+  });
+
+  it('replaces a group name throughout the app state', () => {
+    const action = {
+      type: Actions.EDIT_GROUP_CONFIRM,
+      payload: {
+        group: 'groupA',
+        edit: 'groupB',
+      },
+    };
+
+    expect(editGroupConfirmReducer(state, action)).toEqual(createSelectedConfigState('groupB'));
+  });
+
+  it('ignores the updated group name if the value is JS false', () => {
+    const editedGroupNames = ['', null, undefined];
+
+    editedGroupNames.forEach((edited) => {
+      const action = {
+        type: Actions.EDIT_GROUP_CONFIRM,
+        payload: {
+          group: 'groupA',
+          edit: edited,
+        },
+      };
+
+      expect(editGroupConfirmReducer(state, action)).toEqual(createSelectedConfigState('groupA'));
+    });
+  });
+
+  it('ignores the updated group name if the group already exists', () => {
+    const action = {
+      type: Actions.EDIT_GROUP_CONFIRM,
+      payload: {
+        group: 'groupA',
+        edit: 'groupC',
+      },
+    };
+
+    expect(editGroupConfirmReducer(state, action)).toEqual(createSelectedConfigState('groupA'));
+  });
+});
+
+describe('Reducer: changeMetricGroupConfirmReducer', () => {
+  const createAction = (metricId: string) => ({
+    type: Actions.CHANGE_METRIC_GROUP_CONFIRM,
+    payload: {
+      metricId,
+    },
+  });
+
+  const createSelectedConfigState = (groups: string[], toGroup: string): ISelectedConfigState =>
+    ({
+      metricList: [
+        {
+          name: 'myMetric',
+          id: '1',
+          groups,
+        },
+        {
+          name: 'myOtherMetric',
+          id: '2',
+          groups: [],
+        },
+      ] as ICanaryMetricConfig[],
+      changeMetricGroup: {
+        toGroup,
+      },
+    } as any);
+
+  it("updates a metric's group, leaving other metrics's groups unchanged", () => {
+    const state = createSelectedConfigState(['myGroup'], 'updatedGroup');
+    const action = createAction('1');
+
+    const updatedState = changeMetricGroupConfirmReducer(state, action);
+
+    expect(updatedState.metricList.find((m) => m.id === '1').groups).toEqual(['updatedGroup']);
+
+    expect(updatedState.metricList.find((m) => m.id === '2').groups).toEqual([]);
+  });
+
+  it('handles metrics with multiple groups', () => {
+    let state = createSelectedConfigState(['a', 'b'], 'c');
+    let action = createAction('1');
+
+    let updatedState = changeMetricGroupConfirmReducer(state, action);
+
+    expect(updatedState.metricList.find((m) => m.id === '1').groups).toEqual(['c']);
+
+    state = createSelectedConfigState(['a', 'b'], 'b');
+    action = createAction('1');
+
+    updatedState = changeMetricGroupConfirmReducer(state, action);
+
+    expect(updatedState.metricList.find((m) => m.id === '1').groups).toEqual(['b']);
+  });
+});
+
+describe('Reducer: updateGroupWeightsReducer', () => {
+  const createAction = () => ({ type: Actions.SELECT_CONFIG });
+
+  const createSelectedConfigState = (
+    metricList: ICanaryMetricConfig[],
+    groupWeights: IGroupWeights,
+  ): ISelectedConfigState =>
+    ({
+      metricList,
+      group: {
+        groupWeights,
+      } as IGroupState,
+    } as any);
+
+  it('prunes weights for groups that do not exist', () => {
+    const metrics = [
+      {
+        name: 'metricA',
+        groups: ['a', 'b'],
+      },
+      {
+        name: 'metricB',
+        groups: ['c'],
+      },
+    ] as ICanaryMetricConfig[];
+    const weights: IGroupWeights = { a: 25, b: 25, c: 25, d: 25 };
+
+    const state = createSelectedConfigState(metrics, weights);
+    const action = createAction();
+
+    const updatedState = updateGroupWeightsReducer(state, action);
+    expect(updatedState.group.groupWeights).toEqual({ a: 25, b: 25, c: 25 });
+  });
+
+  it('initializes weights for groups that exist on the metrics only', () => {
+    const metrics = [
+      {
+        name: 'metricA',
+        groups: ['a'],
+      },
+      {
+        name: 'metricB',
+        groups: ['b', 'c'],
+      },
+    ] as ICanaryMetricConfig[];
+    const weights: IGroupWeights = { a: 50, b: 50 };
+
+    const state = createSelectedConfigState(metrics, weights);
+    const action = createAction();
+
+    const updatedState = updateGroupWeightsReducer(state, action);
+    expect(updatedState.group.groupWeights).toEqual({ a: 50, b: 50, c: 0 });
+  });
+});