Implement API, saga and reducer code to interact with TAAR Lite service via addons-server

src/amo/api/recommendations.js

@@ -0,0 +1,28 @@
+/* @flow */
+import invariant from 'invariant';
+
+import { callApi } from 'core/api';
+import type { ApiStateType } from 'core/reducers/api';
+import type { PaginatedApiResponse } from 'core/types/api';
+import type { ExternalAddonType } from 'core/types/addons';
+
+
+export type GetRecommendationsParams = {|
+  api: ApiStateType,
+  guid: string,
+  recommended: boolean,
+|};
+
+export const getRecommendations = (
+  { api, guid, recommended }: GetRecommendationsParams
+): Promise<PaginatedApiResponse<ExternalAddonType>> => {
+  invariant(guid, 'A guid is required.');
+  invariant(typeof recommended === 'boolean', 'recommended is required');
+
+  return callApi({
+    auth: true,
+    endpoint: 'addons/recommendations/',
+    params: { guid, recommended },
+    state: api,
+  });
+};

src/amo/reducers/recommendations.js

@@ -0,0 +1,182 @@
+/* @flow */
+import invariant from 'invariant';
+
+import { createInternalAddon } from 'core/reducers/addons';
+import type { ExternalAddonType } from 'core/types/addons';
+
+export const ABORT_FETCH_RECOMMENDATIONS: 'ABORT_FETCH_RECOMMENDATIONS'
+  = 'ABORT_FETCH_RECOMMENDATIONS';
+export const FETCH_RECOMMENDATIONS: 'FETCH_RECOMMENDATIONS'
+  = 'FETCH_RECOMMENDATIONS';
+export const LOAD_RECOMMENDATIONS: 'LOAD_RECOMMENDATIONS'
+  = 'LOAD_RECOMMENDATIONS';
+
+export type Recommendations = {|
+  addons: Array<ExternalAddonType> | null,
+  fallbackReason: string | null,
+  loading: boolean,
+  outcome: string | null,
+|};
+
+export type RecommendationsState = {|
+  byGuid: {
+    [guid: string]: Recommendations,
+  },
+|};
+
+export const initialState: RecommendationsState = {
+  byGuid: {},
+};
+
+export type AbortFetchRecommendationsParams = {|
+  guid: string,
+|};
+
+type AbortFetchRecommendationsAction = {|
+  type: typeof ABORT_FETCH_RECOMMENDATIONS,
+  payload: AbortFetchRecommendationsParams,
+|};
+
+export const abortFetchRecommendations = ({
+  guid,
+}: AbortFetchRecommendationsParams = {}): AbortFetchRecommendationsAction => {
+  invariant(guid, 'guid is required');
+  return {
+    type: ABORT_FETCH_RECOMMENDATIONS,
+    payload: { guid },
+  };
+};
+
+type FetchRecommendationsParams = {|
+  errorHandlerId: string,
+  guid: string,
+  recommended: boolean,
+|};
+
+export type FetchRecommendationsAction = {|
+  type: typeof FETCH_RECOMMENDATIONS,
+  payload: FetchRecommendationsParams,
+|};
+
+export const fetchRecommendations = ({
+  errorHandlerId,
+  guid,
+  recommended,
+}: FetchRecommendationsParams = {}): FetchRecommendationsAction => {
+  invariant(errorHandlerId, 'errorHandlerId is required');
+  invariant(guid, 'guid is required');
+  invariant(typeof recommended === 'boolean', 'recommended is required');
+
+  return {
+    type: FETCH_RECOMMENDATIONS,
+    payload: { errorHandlerId, guid, recommended },
+  };
+};
+
+export type LoadRecommendationsParams = {|
+  addons: Array<ExternalAddonType>,
+  fallbackReason: string,
+  guid: string,
+  outcome: string,
+|};
+
+type LoadRecommendationsAction = {|
+  type: typeof LOAD_RECOMMENDATIONS,
+  payload: LoadRecommendationsParams,
+|};
+
+export const loadRecommendations = ({
+  addons,
+  fallbackReason,
+  guid,
+  outcome,
+}: LoadRecommendationsParams = {}): LoadRecommendationsAction => {
+  invariant(addons, 'addons is required');
+  invariant(fallbackReason, 'fallbackReason is required');
+  invariant(guid, 'guid is required');
+  invariant(outcome, 'outcome is required');
+
+  return {
+    type: LOAD_RECOMMENDATIONS,
+    payload: { addons, guid, outcome, fallbackReason },
+  };
+};
+
+type GetRecommendationsByGuidParams = {|
+  guid: string,
+  state: RecommendationsState,
+|};
+
+export const getRecommendationsByGuid = (
+  { guid, state }: GetRecommendationsByGuidParams
+): Recommendations | null => {
+  invariant(guid, 'guid is required');
+  invariant(state, 'state is required');
+
+  return state.byGuid[guid] || null;
+};
+
+type Action =
+  | AbortFetchRecommendationsAction
+  | FetchRecommendationsAction
+  | LoadRecommendationsAction;
+
+const reducer = (
+  state: RecommendationsState = initialState,
+  action: Action
+): RecommendationsState => {
+  switch (action.type) {
+    case ABORT_FETCH_RECOMMENDATIONS:
+      return {
+        ...state,
+        byGuid: {
+          ...state.byGuid,
+          [action.payload.guid]: {
+            addons: null,
+            fallbackReason: null,
+            loading: false,
+            outcome: null,
+          },
+        },
+      };
+
+    case FETCH_RECOMMENDATIONS:
+      return {
+        ...state,
+        byGuid: {
+          ...state.byGuid,
+          [action.payload.guid]: {
+            addons: null,
+            fallbackReason: null,
+            loading: true,
+            outcome: null,
+          },
+        },
+      };
+
+    case LOAD_RECOMMENDATIONS: {
+      const { fallbackReason, guid, outcome } = action.payload;
+
+      const addons = action.payload.addons
+        .map((addon) => createInternalAddon(addon));
+
+      return {
+        ...state,
+        byGuid: {
+          ...state.byGuid,
+          [guid]: {
+            addons,
+            fallbackReason,
+            loading: false,
+            outcome,
+          },
+        },
+      };
+    }
+
+    default:
+      return state;
+  }
+};
+
+export default reducer;

src/amo/sagas/recommendations.js

@@ -0,0 +1,48 @@
+/* @flow */
+import { call, put, select, takeLatest } from 'redux-saga/effects';
+import {
+  FETCH_RECOMMENDATIONS,
+  abortFetchRecommendations,
+  loadRecommendations,
+} from 'amo/reducers/recommendations';
+import * as api from 'amo/api/recommendations';
+import log from 'core/logger';
+import { createErrorHandler, getState } from 'core/sagas/utils';
+import type { GetRecommendationsParams } from 'amo/api/recommendations';
+import type {
+  FetchRecommendationsAction,
+} from 'amo/reducers/recommendations';
+
+
+export function* fetchRecommendations({
+  payload: { errorHandlerId, guid, recommended },
+}: FetchRecommendationsAction): Generator<any, any, any> {
+  const errorHandler = createErrorHandler(errorHandlerId);
+  yield put(errorHandler.createClearingAction());
+
+  try {
+    const state = yield select(getState);
+
+    const params: GetRecommendationsParams = {
+      api: state.api, guid, recommended,
+    };
+    const recommendations = yield call(api.getRecommendations, params);
+    const { fallback_reason: fallbackReason, outcome, results: addons }
+      = recommendations;
+
+    yield put(loadRecommendations({
+      addons,
+      fallbackReason,
+      guid,
+      outcome,
+    }));
+  } catch (error) {
+    log.warn(`Failed to fetch user collections: ${error}`);
+    yield put(errorHandler.createErrorAction(error));
+    yield put(abortFetchRecommendations({ guid }));
+  }
+}
+
+export default function* recommendationsSaga(): Generator<any, any, any> {
+  yield takeLatest(FETCH_RECOMMENDATIONS, fetchRecommendations);
+}

src/amo/store.js

@@ -7,6 +7,7 @@ import addonsByAuthors from 'amo/reducers/addonsByAuthors';
 import collections from 'amo/reducers/collections';
 import home from 'amo/reducers/home';
 import landing from 'amo/reducers/landing';
+import recommendations from 'amo/reducers/recommendations';
 import reviews from 'amo/reducers/reviews';
 import userAbuseReports from 'amo/reducers/userAbuseReports';
 import users from 'amo/reducers/users';
@@ -51,6 +52,7 @@ export default function createStore({
       landing,
       languageTools,
       redirectTo,
+      recommendations,
       reviews,
       routing,
       search,

tests/unit/amo/api/test_recommendations.js

@@ -0,0 +1,35 @@
+import * as api from 'core/api';
+import { getRecommendations } from 'amo/api/recommendations';
+import { createApiResponse } from 'tests/unit/helpers';
+import { dispatchClientMetadata } from 'tests/unit/amo/helpers';
+
+
+describe(__filename, () => {
+  it('calls the recommendations API', async () => {
+    const mockApi = sinon.mock(api);
+    const apiState = dispatchClientMetadata().store.getState().api;
+
+    const params = {
+      guid: 'addon-guid',
+      recommended: true,
+    };
+
+    mockApi
+      .expects('callApi')
+      .withArgs({
+        auth: true,
+        endpoint:
+          'addons/recommendations/',
+        params,
+        state: apiState,
+      })
+      .once()
+      .returns(createApiResponse());
+
+    await getRecommendations({
+      api: apiState,
+      ...params,
+    });
+    mockApi.verify();
+  });
+});

tests/unit/amo/reducers/test_recommendations.js

@@ -0,0 +1,82 @@
+import reducer, {
+  abortFetchRecommendations,
+  fetchRecommendations,
+  getRecommendationsByGuid,
+  initialState,
+  loadRecommendations,
+} from 'amo/reducers/recommendations';
+import { createInternalAddon } from 'core/reducers/addons';
+import { createStubErrorHandler } from 'tests/unit/helpers';
+import { fakeAddon } from 'tests/unit/amo/helpers';
+
+
+describe(__filename, () => {
+  it('initializes properly', () => {
+    const state = reducer(undefined, {});
+    expect(state).toEqual(initialState);
+  });
+
+  it('ignores unrelated actions', () => {
+    const state = reducer(initialState, { type: 'UNRELATED_ACTION' });
+    expect(state).toEqual(initialState);
+  });
+
+  it('sets the loading flag when fetching recommendations', () => {
+    const guid = 'some-guid';
+    const state = reducer(undefined, fetchRecommendations({
+      errorHandlerId: createStubErrorHandler().id,
+      guid,
+      recommended: true,
+    }));
+
+    expect(state.byGuid[guid].loading).toEqual(true);
+    expect(state.byGuid[guid].addons).toEqual(null);
+  });
+
+  it('loads recommendations', () => {
+    const addons = [fakeAddon, fakeAddon];
+    const fallbackReason = 'timeout';
+    const guid = 'some-guid';
+    const outcome = 'recommended_fallback';
+    const state = reducer(undefined, loadRecommendations({
+      addons,
+      fallbackReason,
+      guid,
+      outcome,
+    }));
+
+    const expectedAddons = addons.map((addon) => createInternalAddon(addon));
+
+    const loadedRecommendations = getRecommendationsByGuid({ guid, state });
+
+    expect(loadedRecommendations).toEqual({
+      addons: expectedAddons,
+      fallbackReason,
+      loading: false,
+      outcome,
+    });
+  });
+
+  it('resets the loading flag when fetching is aborted', () => {
+    const guid = 'some-guid';
+    const state = reducer(undefined, fetchRecommendations({
+      errorHandlerId: createStubErrorHandler().id,
+      guid,
+      recommended: true,
+    }));
+
+    expect(state.byGuid[guid].loading).toEqual(true);
+
+    const newState = reducer(state, abortFetchRecommendations({ guid }));
+    expect(newState.byGuid[guid].loading).toEqual(false);
+  });
+
+  describe('getRecommendationsByGuid', () => {
+    it('returns null if no recommendations exist for the guid', () => {
+      const state = reducer(undefined, {});
+      const guid = 'a-non-existent-guid';
+
+      expect(getRecommendationsByGuid({ guid, state })).toEqual(null);
+    });
+  });
+});