static_src/reducers/hotlists.test.js

// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import {assert} from 'chai';
import sinon from 'sinon';

import * as hotlists from './hotlists.js';
import * as example from 'shared/test/constants-hotlists.js';
import * as exampleIssues from 'shared/test/constants-issueV0.js';
import * as exampleUsers from 'shared/test/constants-users.js';

import {prpcClient} from 'prpc-client-instance.js';

let dispatch;

describe('hotlist reducers', () => {
  it('root reducer initial state', () => {
    const actual = hotlists.reducer(undefined, {type: null});
    const expected = {
      name: null,
      byName: {},
      hotlistItems: {},
      requests: {
        deleteHotlist: {error: null, requesting: false},
        fetch: {error: null, requesting: false},
        fetchItems: {error: null, requesting: false},
        removeEditors: {error: null, requesting: false},
        removeItems: {error: null, requesting: false},
        rerankItems: {error: null, requesting: false},
        update: {error: null, requesting: false},
      },
    };
    assert.deepEqual(actual, expected);
  });

  it('name updates on SELECT', () => {
    const action = {type: hotlists.SELECT, name: example.NAME};
    const actual = hotlists.nameReducer(null, action);
    assert.deepEqual(actual, example.NAME);
  });

  it('byName updates on RECEIVE_HOTLIST', () => {
    const action = {type: hotlists.RECEIVE_HOTLIST, hotlist: example.HOTLIST};
    const actual = hotlists.byNameReducer({}, action);
    assert.deepEqual(actual, example.BY_NAME);
  });

  it('byName fills in missing fields on RECEIVE_HOTLIST', () => {
    const action = {
      type: hotlists.RECEIVE_HOTLIST,
      hotlist: {name: example.NAME},
    };
    const actual = hotlists.byNameReducer({}, action);

    const hotlist = {name: example.NAME, defaultColumns: [], editors: []};
    assert.deepEqual(actual, {[example.NAME]: hotlist});
  });

  it('hotlistItems updates on FETCH_ITEMS_SUCCESS', () => {
    const action = {
      type: hotlists.FETCH_ITEMS_SUCCESS,
      name: example.NAME,
      items: [example.HOTLIST_ITEM],
    };
    const actual = hotlists.hotlistItemsReducer({}, action);
    assert.deepEqual(actual, example.HOTLIST_ITEMS);
  });
});

describe('hotlist selectors', () => {
  it('name', () => {
    const state = {hotlists: {name: example.NAME}};
    assert.deepEqual(hotlists.name(state), example.NAME);
  });

  it('byName', () => {
    const state = {hotlists: {byName: example.BY_NAME}};
    assert.deepEqual(hotlists.byName(state), example.BY_NAME);
  });

  it('hotlistItems', () => {
    const state = {hotlists: {hotlistItems: example.HOTLIST_ITEMS}};
    assert.deepEqual(hotlists.hotlistItems(state), example.HOTLIST_ITEMS);
  });

  describe('viewedHotlist', () => {
    it('normal case', () => {
      const state = {hotlists: {name: example.NAME, byName: example.BY_NAME}};
      assert.deepEqual(hotlists.viewedHotlist(state), example.HOTLIST);
    });

    it('no name', () => {
      const state = {hotlists: {name: null, byName: example.BY_NAME}};
      assert.deepEqual(hotlists.viewedHotlist(state), null);
    });

    it('hotlist not found', () => {
      const state = {hotlists: {name: example.NAME, byName: {}}};
      assert.deepEqual(hotlists.viewedHotlist(state), null);
    });
  });

  describe('viewedHotlistOwner', () => {
    it('normal case', () => {
      const state = {
        hotlists: {name: example.NAME, byName: example.BY_NAME},
        users: {byName: exampleUsers.BY_NAME},
      };
      assert.deepEqual(hotlists.viewedHotlistOwner(state), exampleUsers.USER);
    });

    it('no hotlist', () => {
      const state = {hotlists: {}, users: {}};
      assert.deepEqual(hotlists.viewedHotlistOwner(state), null);
    });
  });

  describe('viewedHotlistEditors', () => {
    it('normal case', () => {
      const state = {
        hotlists: {
          name: example.NAME,
          byName: {[example.NAME]: {
            ...example.HOTLIST,
            editors: [exampleUsers.NAME, exampleUsers.NAME_2],
          }},
        },
        users: {byName: exampleUsers.BY_NAME},
      };

      const editors = [exampleUsers.USER, exampleUsers.USER_2];
      assert.deepEqual(hotlists.viewedHotlistEditors(state), editors);
    });

    it('no user data', () => {
      const editors = [exampleUsers.NAME, exampleUsers.NAME_2];
      const state = {
        hotlists: {
          name: example.NAME,
          byName: {[example.NAME]: {...example.HOTLIST, editors}},
        },
        users: {byName: {}},
      };
      assert.deepEqual(hotlists.viewedHotlistEditors(state), [null, null]);
    });

    it('no hotlist', () => {
      const state = {hotlists: {}, users: {}};
      assert.deepEqual(hotlists.viewedHotlistEditors(state), null);
    });
  });

  describe('viewedHotlistItems', () => {
    it('normal case', () => {
      const state = {hotlists: {
        name: example.NAME,
        hotlistItems: example.HOTLIST_ITEMS,
      }};
      const actual = hotlists.viewedHotlistItems(state);
      assert.deepEqual(actual, [example.HOTLIST_ITEM]);
    });

    it('no name', () => {
      const state = {hotlists: {
        name: null,
        hotlistItems: example.HOTLIST_ITEMS,
      }};
      assert.deepEqual(hotlists.viewedHotlistItems(state), []);
    });

    it('hotlist not found', () => {
      const state = {hotlists: {name: example.NAME, hotlistItems: {}}};
      assert.deepEqual(hotlists.viewedHotlistItems(state), []);
    });
  });

  describe('viewedHotlistIssues', () => {
    it('normal case', () => {
      const state = {
        hotlists: {
          name: example.NAME,
          hotlistItems: example.HOTLIST_ITEMS,
        },
        issue: {
          issuesByRefString: {
            [exampleIssues.ISSUE_REF_STRING]: exampleIssues.ISSUE,
          },
        },
        users: {byName: {[exampleUsers.NAME]: exampleUsers.USER}},
      };
      const actual = hotlists.viewedHotlistIssues(state);
      assert.deepEqual(actual, [example.HOTLIST_ISSUE]);
    });

    it('no issue', () => {
      const state = {
        hotlists: {
          name: example.NAME,
          hotlistItems: example.HOTLIST_ITEMS,
        },
        issue: {
          issuesByRefString: {
            [exampleIssues.ISSUE_OTHER_PROJECT_REF_STRING]: exampleIssues.ISSUE,
          },
        },
        users: {byName: {}},
      };
      assert.deepEqual(hotlists.viewedHotlistIssues(state), []);
    });
  });

  describe('viewedHotlistColumns', () => {
    it('sitewide currentColumns overrides hotlist defaultColumns', () => {
      const state = {
        sitewide: {queryParams: {colspec: 'Summary+ColumnName'}},
        hotlists: {},
      };
      const actual = hotlists.viewedHotlistColumns(state);
      assert.deepEqual(actual, ['Summary', 'ColumnName']);
    });

    it('uses DEFAULT_COLUMNS when no hotlist', () => {
      const actual = hotlists.viewedHotlistColumns({hotlists: {}});
      assert.deepEqual(actual, hotlists.DEFAULT_COLUMNS);
    });

    it('uses DEFAULT_COLUMNS when hotlist has empty defaultColumns', () => {
      const state = {hotlists: {
        name: example.HOTLIST.name,
        byName: {
          [example.HOTLIST.name]: {...example.HOTLIST, defaultColumns: []},
        },
      }};
      const actual = hotlists.viewedHotlistColumns(state);
      assert.deepEqual(actual, hotlists.DEFAULT_COLUMNS);
    });

    it('uses hotlist defaultColumns', () => {
      const state = {hotlists: {
        name: example.HOTLIST.name,
        byName: {[example.HOTLIST.name]: {
          ...example.HOTLIST,
          defaultColumns: [{column: 'ID'}, {column: 'ColumnName'}],
        }},
      }};
      const actual = hotlists.viewedHotlistColumns(state);
      assert.deepEqual(actual, ['ID', 'ColumnName']);
    });
  });

  describe('viewedHotlistPermissions', () => {
    it('normal case', () => {
      const permissions = [hotlists.ADMINISTER, hotlists.EDIT];
      const state = {
        hotlists: {name: example.NAME, byName: example.BY_NAME},
        permissions: {byName: {[example.NAME]: {permissions}}},
      };
      assert.deepEqual(hotlists.viewedHotlistPermissions(state), permissions);
    });

    it('no issue', () => {
      const state = {hotlists: {}, permissions: {}};
      assert.deepEqual(hotlists.viewedHotlistPermissions(state), []);
    });
  });
});

describe('hotlist action creators', () => {
  beforeEach(() => {
    sinon.stub(prpcClient, 'call');
    dispatch = sinon.stub();
  });

  afterEach(() => {
    prpcClient.call.restore();
  });

  it('select', () => {
    const actual = hotlists.select(example.NAME);
    const expected = {type: hotlists.SELECT, name: example.NAME};
    assert.deepEqual(actual, expected);
  });

  describe('deleteHotlist', () => {
    it('success', async () => {
      prpcClient.call.returns(Promise.resolve({}));

      await hotlists.deleteHotlist(example.NAME)(dispatch);

      sinon.assert.calledWith(dispatch, {type: hotlists.DELETE_START});

      const args = {name: example.NAME};
      sinon.assert.calledWith(
          prpcClient.call, 'monorail.v3.Hotlists', 'DeleteHotlist', args);

      sinon.assert.calledWith(dispatch, {type: hotlists.DELETE_SUCCESS});
    });

    it('failure', async () => {
      prpcClient.call.throws();

      await hotlists.deleteHotlist(example.NAME)(dispatch);

      const action = {
        type: hotlists.DELETE_FAILURE,
        error: sinon.match.any,
      };
      sinon.assert.calledWith(dispatch, action);
    });
  });

  describe('fetch', () => {
    it('success', async () => {
      const hotlist = example.HOTLIST;
      prpcClient.call.returns(Promise.resolve(hotlist));

      await hotlists.fetch(example.NAME)(dispatch);

      const args = {name: example.NAME};
      sinon.assert.calledWith(
          prpcClient.call, 'monorail.v3.Hotlists', 'GetHotlist', args);

      sinon.assert.calledWith(dispatch, {type: hotlists.FETCH_START});
      sinon.assert.calledWith(dispatch, {type: hotlists.FETCH_SUCCESS});
      sinon.assert.calledWith(
          dispatch, {type: hotlists.RECEIVE_HOTLIST, hotlist});
    });

    it('failure', async () => {
      prpcClient.call.throws();

      await hotlists.fetch(example.NAME)(dispatch);

      const action = {type: hotlists.FETCH_FAILURE, error: sinon.match.any};
      sinon.assert.calledWith(dispatch, action);
    });
  });

  describe('fetchItems', () => {
    it('success', async () => {
      const response = {items: [example.HOTLIST_ITEM]};
      prpcClient.call.returns(Promise.resolve(response));

      const returnValue = await hotlists.fetchItems(example.NAME)(dispatch);
      assert.deepEqual(returnValue, [{...example.HOTLIST_ITEM, rank: 0}]);

      const args = {parent: example.NAME, orderBy: 'rank'};
      sinon.assert.calledWith(
          prpcClient.call, 'monorail.v3.Hotlists', 'ListHotlistItems', args);

      sinon.assert.calledWith(dispatch, {type: hotlists.FETCH_ITEMS_START});
      const action = {
        type: hotlists.FETCH_ITEMS_SUCCESS,
        name: example.NAME,
        items: [{...example.HOTLIST_ITEM, rank: 0}],
      };
      sinon.assert.calledWith(dispatch, action);
    });

    it('failure', async () => {
      prpcClient.call.throws();

      await hotlists.fetchItems(example.NAME)(dispatch);

      const action = {
        type: hotlists.FETCH_ITEMS_FAILURE,
        error: sinon.match.any,
      };
      sinon.assert.calledWith(dispatch, action);
    });

    it('success with empty hotlist', async () => {
      const response = {items: []};
      prpcClient.call.returns(Promise.resolve(response));

      const returnValue = await hotlists.fetchItems(example.NAME)(dispatch);
      assert.deepEqual(returnValue, []);

      sinon.assert.calledWith(dispatch, {type: hotlists.FETCH_ITEMS_START});

      const args = {parent: example.NAME, orderBy: 'rank'};
      sinon.assert.calledWith(
          prpcClient.call, 'monorail.v3.Hotlists', 'ListHotlistItems', args);

      const action = {
        type: hotlists.FETCH_ITEMS_SUCCESS,
        name: example.NAME,
        items: [],
      };
      sinon.assert.calledWith(dispatch, action);
    });
  });

  describe('removeEditors', () => {
    it('success', async () => {
      prpcClient.call.returns(Promise.resolve({}));

      const editors = [exampleUsers.NAME];
      await hotlists.removeEditors(example.NAME, editors)(dispatch);

      const args = {name: example.NAME, editors};
      sinon.assert.calledWith(
          prpcClient.call, 'monorail.v3.Hotlists',
          'RemoveHotlistEditors', args);

      sinon.assert.calledWith(dispatch, {type: hotlists.REMOVE_EDITORS_START});
      const action = {type: hotlists.REMOVE_EDITORS_SUCCESS};
      sinon.assert.calledWith(dispatch, action);
    });

    it('failure', async () => {
      prpcClient.call.throws();

      await hotlists.removeEditors(example.NAME, [])(dispatch);

      const action = {
        type: hotlists.REMOVE_EDITORS_FAILURE,
        error: sinon.match.any,
      };
      sinon.assert.calledWith(dispatch, action);
    });
  });

  describe('removeItems', () => {
    it('success', async () => {
      prpcClient.call.returns(Promise.resolve({}));

      const issues = [exampleIssues.NAME];
      await hotlists.removeItems(example.NAME, issues)(dispatch);

      const args = {parent: example.NAME, issues};
      sinon.assert.calledWith(
          prpcClient.call, 'monorail.v3.Hotlists',
          'RemoveHotlistItems', args);

      sinon.assert.calledWith(dispatch, {type: hotlists.REMOVE_ITEMS_START});
      sinon.assert.calledWith(dispatch, {type: hotlists.REMOVE_ITEMS_SUCCESS});
    });

    it('failure', async () => {
      prpcClient.call.throws();

      await hotlists.removeItems(example.NAME, [])(dispatch);

      const action = {
        type: hotlists.REMOVE_ITEMS_FAILURE,
        error: sinon.match.any,
      };
      sinon.assert.calledWith(dispatch, action);
    });
  });

  describe('rerankItems', () => {
    it('success', async () => {
      prpcClient.call.returns(Promise.resolve({}));

      const items = [example.HOTLIST_ITEM_NAME];
      await hotlists.rerankItems(example.NAME, items, 0)(dispatch);

      const args = {
        name: example.NAME,
        hotlistItems: items,
        targetPosition: 0,
      };
      sinon.assert.calledWith(
          prpcClient.call, 'monorail.v3.Hotlists',
          'RerankHotlistItems', args);

      sinon.assert.calledWith(dispatch, {type: hotlists.RERANK_ITEMS_START});
      sinon.assert.calledWith(dispatch, {type: hotlists.RERANK_ITEMS_SUCCESS});
    });

    it('failure', async () => {
      prpcClient.call.throws();

      await hotlists.rerankItems(example.NAME, [], 0)(dispatch);

      const action = {
        type: hotlists.RERANK_ITEMS_FAILURE,
        error: sinon.match.any,
      };
      sinon.assert.calledWith(dispatch, action);
    });
  });

  describe('update', () => {
    it('success', async () => {
      const hotlistOnlyWithUpdates = {
        displayName: example.HOTLIST.displayName + 'foo',
        summary: example.HOTLIST.summary + 'abc',
      };
      const hotlist = {...example.HOTLIST, ...hotlistOnlyWithUpdates};
      prpcClient.call.returns(Promise.resolve(hotlist));

      await hotlists.update(
          example.HOTLIST.name, hotlistOnlyWithUpdates)(dispatch);

      const hotlistArg = {
        ...hotlistOnlyWithUpdates,
        name: example.HOTLIST.name,
      };
      const fieldMask = 'displayName,summary';
      const args = {hotlist: hotlistArg, updateMask: fieldMask};
      sinon.assert.calledWith(
          prpcClient.call, 'monorail.v3.Hotlists', 'UpdateHotlist', args);

      sinon.assert.calledWith(dispatch, {type: hotlists.UPDATE_START});
      sinon.assert.calledWith(dispatch, {type: hotlists.UPDATE_SUCCESS});
      sinon.assert.calledWith(
          dispatch, {type: hotlists.RECEIVE_HOTLIST, hotlist});
    });

    it('failure', async () => {
      prpcClient.call.throws();
      const hotlistOnlyWithUpdates = {
        displayName: example.HOTLIST.displayName + 'foo',
        summary: example.HOTLIST.summary + 'abc',
      };
      try {
        // TODO(crbug.com/monorail/7883): Use Chai Promises plugin
        // to assert promise rejected.
        await hotlists.update(
            example.HOTLIST.name, hotlistOnlyWithUpdates)(dispatch);
      } catch (e) {}

      const action = {
        type: hotlists.UPDATE_FAILURE,
        error: sinon.match.any,
      };
      sinon.assert.calledWith(dispatch, action);
    });
  });
});

describe('helpers', () => {
  beforeEach(() => {
    sinon.stub(prpcClient, 'call');
    dispatch = sinon.stub();
  });

  afterEach(() => {
    prpcClient.call.restore();
  });

  describe('getHotlistName', () => {
    it('success', async () => {
      const response = {hotlistId: '1234'};
      prpcClient.call.returns(Promise.resolve(response));

      const name = await hotlists.getHotlistName('foo@bar.com', 'hotlist');
      assert.deepEqual(name, 'hotlists/1234');

      const args = {hotlistRef: {
        owner: {displayName: 'foo@bar.com'},
        name: 'hotlist',
      }};
      sinon.assert.calledWith(
          prpcClient.call, 'monorail.Features', 'GetHotlistID', args);
    });

    it('failure', async () => {
      prpcClient.call.throws();

      assert.isNull(await hotlists.getHotlistName('foo@bar.com', 'hotlist'));
    });
  });
});