blob: fb1f051db995b500f4121497d26d7c0fe9d3e0b6 [file] [log] [blame]
// Copyright 2019 The Chromium Authors. All rights reserved.
// 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 {prpcClient} from 'prpc-client-instance.js';
import * as projectV0 from './projectV0.js';
import {store} from './base.js';
import * as example from 'shared/test/constants-projectV0.js';
import {restrictionLabelsForPermissions} from 'shared/convertersV0.js';
import {fieldTypes, SITEWIDE_DEFAULT_COLUMNS} from 'shared/issue-fields.js';
describe('project reducers', () => {
it('root reducer initial state', () => {
const actual = projectV0.reducer(undefined, {type: null});
const expected = {
name: null,
configs: {},
presentationConfigs: {},
customPermissions: {},
visibleMembers: {},
templates: {},
requests: {
fetchConfig: {
error: null,
requesting: false,
},
fetchCustomPermissions: {
error: null,
requesting: false,
},
fetchMembers: {
error: null,
requesting: false,
},
fetchPresentationConfig: {
error: null,
requesting: false,
},
fetchTemplates: {
error: null,
requesting: false,
},
},
};
assert.deepEqual(actual, expected);
});
it('name', () => {
const action = {type: projectV0.SELECT, projectName: example.PROJECT_NAME};
assert.deepEqual(projectV0.nameReducer(null, action), example.PROJECT_NAME);
});
it('configs updates when fetching Config', () => {
const action = {
type: projectV0.FETCH_CONFIG_SUCCESS,
projectName: example.PROJECT_NAME,
config: example.CONFIG,
};
const expected = {[example.PROJECT_NAME]: example.CONFIG};
assert.deepEqual(projectV0.configsReducer({}, action), expected);
});
it('customPermissions', () => {
const action = {
type: projectV0.FETCH_CUSTOM_PERMISSIONS_SUCCESS,
projectName: example.PROJECT_NAME,
permissions: example.CUSTOM_PERMISSIONS,
};
const expected = {[example.PROJECT_NAME]: example.CUSTOM_PERMISSIONS};
assert.deepEqual(projectV0.customPermissionsReducer({}, action), expected);
});
it('presentationConfigs', () => {
const action = {
type: projectV0.FETCH_PRESENTATION_CONFIG_SUCCESS,
projectName: example.PROJECT_NAME,
presentationConfig: example.PRESENTATION_CONFIG,
};
const expected = {[example.PROJECT_NAME]: example.PRESENTATION_CONFIG};
assert.deepEqual(projectV0.presentationConfigsReducer({}, action),
expected);
});
it('visibleMembers', () => {
const action = {
type: projectV0.FETCH_VISIBLE_MEMBERS_SUCCESS,
projectName: example.PROJECT_NAME,
visibleMembers: example.VISIBLE_MEMBERS,
};
const expected = {[example.PROJECT_NAME]: example.VISIBLE_MEMBERS};
assert.deepEqual(projectV0.visibleMembersReducer({}, action), expected);
});
it('templates', () => {
const action = {
type: projectV0.FETCH_TEMPLATES_SUCCESS,
projectName: example.PROJECT_NAME,
templates: [example.TEMPLATE_DEF],
};
const expected = {[example.PROJECT_NAME]: [example.TEMPLATE_DEF]};
assert.deepEqual(projectV0.templatesReducer({}, action), expected);
});
});
describe('project selectors', () => {
it('viewedProjectName', () => {
const actual = projectV0.viewedProjectName(example.STATE);
assert.deepEqual(actual, example.PROJECT_NAME);
});
it('viewedVisibleMembers', () => {
assert.deepEqual(projectV0.viewedVisibleMembers({}), {});
assert.deepEqual(projectV0.viewedVisibleMembers({projectV0: {}}), {});
assert.deepEqual(projectV0.viewedVisibleMembers(
{projectV0: {visibleMembers: {}}}), {});
const actual = projectV0.viewedVisibleMembers(example.STATE);
assert.deepEqual(actual, example.VISIBLE_MEMBERS);
});
it('viewedCustomPermissions', () => {
assert.deepEqual(projectV0.viewedCustomPermissions({}), []);
assert.deepEqual(projectV0.viewedCustomPermissions({projectV0: {}}), []);
assert.deepEqual(projectV0.viewedCustomPermissions(
{projectV0: {customPermissions: {}}}), []);
const actual = projectV0.viewedCustomPermissions(example.STATE);
assert.deepEqual(actual, example.CUSTOM_PERMISSIONS);
});
it('viewedPresentationConfig', () => {
assert.deepEqual(projectV0.viewedPresentationConfig({}), {});
assert.deepEqual(projectV0.viewedPresentationConfig({projectV0: {}}), {});
const actual = projectV0.viewedPresentationConfig(example.STATE);
assert.deepEqual(actual, example.PRESENTATION_CONFIG);
});
it('defaultColumns', () => {
assert.deepEqual(projectV0.defaultColumns({}), SITEWIDE_DEFAULT_COLUMNS);
assert.deepEqual(
projectV0.defaultColumns({projectV0: {}}), SITEWIDE_DEFAULT_COLUMNS);
assert.deepEqual(
projectV0.defaultColumns({projectV0: {presentationConfig: {}}}),
SITEWIDE_DEFAULT_COLUMNS);
const expected = ['ID', 'Summary', 'AllLabels'];
assert.deepEqual(projectV0.defaultColumns(example.STATE), expected);
});
it('defaultQuery', () => {
assert.deepEqual(projectV0.defaultQuery({}), '');
assert.deepEqual(projectV0.defaultQuery({projectV0: {}}), '');
const actual = projectV0.defaultQuery(example.STATE);
assert.deepEqual(actual, example.DEFAULT_QUERY);
});
it('fieldDefs', () => {
assert.deepEqual(projectV0.fieldDefs({projectV0: {}}), []);
assert.deepEqual(projectV0.fieldDefs({projectV0: {config: {}}}), []);
const actual = projectV0.fieldDefs(example.STATE);
assert.deepEqual(actual, example.FIELD_DEFS);
});
it('labelDefMap', () => {
const labelDefs = (permissions) =>
restrictionLabelsForPermissions(permissions).map((labelDef) =>
[labelDef.label.toLowerCase(), labelDef]);
assert.deepEqual(
projectV0.labelDefMap({projectV0: {}}), new Map(labelDefs([])));
assert.deepEqual(
projectV0.labelDefMap({projectV0: {config: {}}}), new Map(labelDefs([])));
const expected = new Map([
['one', {label: 'One'}],
['enum', {label: 'EnUm'}],
['enum-options', {label: 'eNuM-Options'}],
['hello-world', {label: 'hello-world', docstring: 'hmmm'}],
['hello-me', {label: 'hello-me', docstring: 'hmmm'}],
...labelDefs(example.CUSTOM_PERMISSIONS),
]);
assert.deepEqual(projectV0.labelDefMap(example.STATE), expected);
});
it('labelPrefixValueMap', () => {
const builtInLabelPrefixes = [
['Restrict', new Set(['View-EditIssue', 'AddIssueComment-EditIssue'])],
['Restrict-View', new Set(['EditIssue'])],
['Restrict-AddIssueComment', new Set(['EditIssue'])],
];
assert.deepEqual(projectV0.labelPrefixValueMap({projectV0: {}}),
new Map(builtInLabelPrefixes));
assert.deepEqual(projectV0.labelPrefixValueMap(
{projectV0: {config: {}}}), new Map(builtInLabelPrefixes));
const expected = new Map([
['Restrict', new Set(['View-Google', 'View-Security', 'EditIssue-Google',
'EditIssue-Security', 'AddIssueComment-Google',
'AddIssueComment-Security', 'DeleteIssue-Google',
'DeleteIssue-Security', 'FlagSpam-Google', 'FlagSpam-Security',
'View-EditIssue', 'AddIssueComment-EditIssue'])],
['Restrict-View', new Set(['Google', 'Security', 'EditIssue'])],
['Restrict-EditIssue', new Set(['Google', 'Security'])],
['Restrict-AddIssueComment', new Set(['Google', 'Security', 'EditIssue'])],
['Restrict-DeleteIssue', new Set(['Google', 'Security'])],
['Restrict-FlagSpam', new Set(['Google', 'Security'])],
['eNuM', new Set(['Options'])],
['hello', new Set(['world', 'me'])],
]);
assert.deepEqual(projectV0.labelPrefixValueMap(example.STATE), expected);
});
it('labelPrefixFields', () => {
const fields1 = projectV0.labelPrefixFields({projectV0: {}});
assert.deepEqual(fields1, ['Restrict']);
const fields2 = projectV0.labelPrefixFields({projectV0: {config: {}}});
assert.deepEqual(fields2, ['Restrict']);
const expected = [
'hello', 'Restrict', 'Restrict-View', 'Restrict-EditIssue',
'Restrict-AddIssueComment', 'Restrict-DeleteIssue', 'Restrict-FlagSpam'
];
assert.deepEqual(projectV0.labelPrefixFields(example.STATE), expected);
});
it('enumFieldDefs', () => {
assert.deepEqual(projectV0.enumFieldDefs({projectV0: {}}), []);
assert.deepEqual(projectV0.enumFieldDefs({projectV0: {config: {}}}), []);
const expected = [example.FIELD_DEF_ENUM];
assert.deepEqual(projectV0.enumFieldDefs(example.STATE), expected);
});
it('optionsPerEnumField', () => {
assert.deepEqual(projectV0.optionsPerEnumField({projectV0: {}}), new Map());
const expected = new Map([
['enum', [
{label: 'eNuM-Options', optionName: 'Options'},
]],
]);
assert.deepEqual(projectV0.optionsPerEnumField(example.STATE), expected);
});
it('viewedPresentationConfigLoaded', () => {
const loadConfigAction = {
type: projectV0.FETCH_PRESENTATION_CONFIG_SUCCESS,
projectName: example.PROJECT_NAME,
presentationConfig: example.PRESENTATION_CONFIG,
};
const selectProjectAction = {
type: projectV0.SELECT,
projectName: example.PROJECT_NAME,
};
let projectState = {};
assert.equal(false, projectV0.viewedPresentationConfigLoaded(
{projectV0: projectState}));
projectState = projectV0.reducer(projectState, selectProjectAction);
projectState = projectV0.reducer(projectState, loadConfigAction);
assert.equal(true, projectV0.viewedPresentationConfigLoaded(
{projectV0: projectState}));
});
it('fetchingPresentationConfig', () => {
const projectState = projectV0.reducer(undefined, {type: null});
assert.equal(false,
projectState.requests.fetchPresentationConfig.requesting);
});
describe('extractTypeForFieldName', () => {
let typeExtractor;
describe('built-in fields', () => {
beforeEach(() => {
typeExtractor = projectV0.extractTypeForFieldName({});
});
it('not case sensitive', () => {
assert.deepEqual(typeExtractor('id'), fieldTypes.ISSUE_TYPE);
assert.deepEqual(typeExtractor('iD'), fieldTypes.ISSUE_TYPE);
assert.deepEqual(typeExtractor('Id'), fieldTypes.ISSUE_TYPE);
});
it('gets type for ID', () => {
assert.deepEqual(typeExtractor('ID'), fieldTypes.ISSUE_TYPE);
});
it('gets type for Project', () => {
assert.deepEqual(typeExtractor('Project'), fieldTypes.PROJECT_TYPE);
});
it('gets type for Attachments', () => {
assert.deepEqual(typeExtractor('Attachments'), fieldTypes.INT_TYPE);
});
it('gets type for AllLabels', () => {
assert.deepEqual(typeExtractor('AllLabels'), fieldTypes.LABEL_TYPE);
});
it('gets type for AllLabels', () => {
assert.deepEqual(typeExtractor('AllLabels'), fieldTypes.LABEL_TYPE);
});
it('gets type for Blocked', () => {
assert.deepEqual(typeExtractor('Blocked'), fieldTypes.STR_TYPE);
});
it('gets type for BlockedOn', () => {
assert.deepEqual(typeExtractor('BlockedOn'), fieldTypes.ISSUE_TYPE);
});
it('gets type for Blocking', () => {
assert.deepEqual(typeExtractor('Blocking'), fieldTypes.ISSUE_TYPE);
});
it('gets type for CC', () => {
assert.deepEqual(typeExtractor('CC'), fieldTypes.USER_TYPE);
});
it('gets type for Closed', () => {
assert.deepEqual(typeExtractor('Closed'), fieldTypes.TIME_TYPE);
});
it('gets type for Component', () => {
assert.deepEqual(typeExtractor('Component'), fieldTypes.COMPONENT_TYPE);
});
it('gets type for ComponentModified', () => {
assert.deepEqual(typeExtractor('ComponentModified'),
fieldTypes.TIME_TYPE);
});
it('gets type for MergedInto', () => {
assert.deepEqual(typeExtractor('MergedInto'), fieldTypes.ISSUE_TYPE);
});
it('gets type for Modified', () => {
assert.deepEqual(typeExtractor('Modified'), fieldTypes.TIME_TYPE);
});
it('gets type for Reporter', () => {
assert.deepEqual(typeExtractor('Reporter'), fieldTypes.USER_TYPE);
});
it('gets type for Stars', () => {
assert.deepEqual(typeExtractor('Stars'), fieldTypes.INT_TYPE);
});
it('gets type for Status', () => {
assert.deepEqual(typeExtractor('Status'), fieldTypes.STATUS_TYPE);
});
it('gets type for StatusModified', () => {
assert.deepEqual(typeExtractor('StatusModified'), fieldTypes.TIME_TYPE);
});
it('gets type for Summary', () => {
assert.deepEqual(typeExtractor('Summary'), fieldTypes.STR_TYPE);
});
it('gets type for Type', () => {
assert.deepEqual(typeExtractor('Type'), fieldTypes.ENUM_TYPE);
});
it('gets type for Owner', () => {
assert.deepEqual(typeExtractor('Owner'), fieldTypes.USER_TYPE);
});
it('gets type for OwnerModified', () => {
assert.deepEqual(typeExtractor('OwnerModified'), fieldTypes.TIME_TYPE);
});
it('gets type for Opened', () => {
assert.deepEqual(typeExtractor('Opened'), fieldTypes.TIME_TYPE);
});
});
it('gets types for custom fields', () => {
typeExtractor = projectV0.extractTypeForFieldName({projectV0: {
name: example.PROJECT_NAME,
configs: {[example.PROJECT_NAME]: {fieldDefs: [
{fieldRef: {fieldName: 'CustomIntField', type: 'INT_TYPE'}},
{fieldRef: {fieldName: 'CustomStrField', type: 'STR_TYPE'}},
{fieldRef: {fieldName: 'CustomUserField', type: 'USER_TYPE'}},
{fieldRef: {fieldName: 'CustomEnumField', type: 'ENUM_TYPE'}},
{fieldRef: {fieldName: 'CustomApprovalField',
type: 'APPROVAL_TYPE'}},
]}},
}});
assert.deepEqual(typeExtractor('CustomIntField'), fieldTypes.INT_TYPE);
assert.deepEqual(typeExtractor('CustomStrField'), fieldTypes.STR_TYPE);
assert.deepEqual(typeExtractor('CustomUserField'), fieldTypes.USER_TYPE);
assert.deepEqual(typeExtractor('CustomEnumField'), fieldTypes.ENUM_TYPE);
assert.deepEqual(typeExtractor('CustomApprovalField'),
fieldTypes.APPROVAL_TYPE);
});
it('defaults to string type for other fields', () => {
typeExtractor = projectV0.extractTypeForFieldName({projectV0: {
name: example.PROJECT_NAME,
configs: {[example.PROJECT_NAME]: {fieldDefs: [
{fieldRef: {fieldName: 'CustomIntField', type: 'INT_TYPE'}},
{fieldRef: {fieldName: 'CustomUserField', type: 'USER_TYPE'}},
]}},
}});
assert.deepEqual(typeExtractor('FakeUserField'), fieldTypes.STR_TYPE);
assert.deepEqual(typeExtractor('NotOwner'), fieldTypes.STR_TYPE);
});
});
describe('extractFieldValuesFromIssue', () => {
let clock;
let issue;
let fieldExtractor;
describe('built-in fields', () => {
beforeEach(() => {
// Built-in fields will always act the same, regardless of
// project config.
fieldExtractor = projectV0.extractFieldValuesFromIssue({});
// Set clock to some specified date for relative time.
const initialTime = 365 * 24 * 60 * 60;
issue = {
localId: 33,
projectName: 'chromium',
summary: 'Test summary',
attachmentCount: 22,
starCount: 2,
componentRefs: [{path: 'Infra'}, {path: 'Monorail>UI'}],
blockedOnIssueRefs: [{localId: 30, projectName: 'chromium'}],
blockingIssueRefs: [{localId: 60, projectName: 'chromium'}],
labelRefs: [{label: 'Restrict-View-Google'}, {label: 'Type-Defect'}],
reporterRef: {displayName: 'test@example.com'},
ccRefs: [{displayName: 'test@example.com'}],
ownerRef: {displayName: 'owner@example.com'},
closedTimestamp: initialTime - 120, // 2 minutes ago
modifiedTimestamp: initialTime - 60, // a minute ago
openedTimestamp: initialTime - 24 * 60 * 60, // a day ago
componentModifiedTimestamp: initialTime - 60, // a minute ago
statusModifiedTimestamp: initialTime - 60, // a minute ago
ownerModifiedTimestamp: initialTime - 60, // a minute ago
statusRef: {status: 'Duplicate'},
mergedIntoIssueRef: {localId: 31, projectName: 'chromium'},
};
clock = sinon.useFakeTimers({
now: new Date(initialTime * 1000),
shouldAdvanceTime: false,
});
});
afterEach(() => {
clock.restore();
});
it('computes strings for ID', () => {
const fieldName = 'ID';
assert.deepEqual(fieldExtractor(issue, fieldName),
['chromium:33']);
});
it('computes strings for Project', () => {
const fieldName = 'Project';
assert.deepEqual(fieldExtractor(issue, fieldName),
['chromium']);
});
it('computes strings for Attachments', () => {
const fieldName = 'Attachments';
assert.deepEqual(fieldExtractor(issue, fieldName),
['22']);
});
it('computes strings for AllLabels', () => {
const fieldName = 'AllLabels';
assert.deepEqual(fieldExtractor(issue, fieldName),
['Restrict-View-Google', 'Type-Defect']);
});
it('computes strings for Blocked when issue is blocked', () => {
const fieldName = 'Blocked';
assert.deepEqual(fieldExtractor(issue, fieldName),
['Yes']);
});
it('computes strings for Blocked when issue is not blocked', () => {
const fieldName = 'Blocked';
issue.blockedOnIssueRefs = [];
assert.deepEqual(fieldExtractor(issue, fieldName),
['No']);
});
it('computes strings for BlockedOn', () => {
const fieldName = 'BlockedOn';
assert.deepEqual(fieldExtractor(issue, fieldName),
['chromium:30']);
});
it('computes strings for Blocking', () => {
const fieldName = 'Blocking';
assert.deepEqual(fieldExtractor(issue, fieldName),
['chromium:60']);
});
it('computes strings for CC', () => {
const fieldName = 'CC';
assert.deepEqual(fieldExtractor(issue, fieldName),
['test@example.com']);
});
it('computes strings for Closed', () => {
const fieldName = 'Closed';
assert.deepEqual(fieldExtractor(issue, fieldName),
['2 minutes ago']);
});
it('computes strings for Component', () => {
const fieldName = 'Component';
assert.deepEqual(fieldExtractor(issue, fieldName),
['Infra', 'Monorail>UI']);
});
it('computes strings for ComponentModified', () => {
const fieldName = 'ComponentModified';
assert.deepEqual(fieldExtractor(issue, fieldName),
['a minute ago']);
});
it('computes strings for MergedInto', () => {
const fieldName = 'MergedInto';
assert.deepEqual(fieldExtractor(issue, fieldName),
['chromium:31']);
});
it('computes strings for Modified', () => {
const fieldName = 'Modified';
assert.deepEqual(fieldExtractor(issue, fieldName),
['a minute ago']);
});
it('computes strings for Reporter', () => {
const fieldName = 'Reporter';
assert.deepEqual(fieldExtractor(issue, fieldName),
['test@example.com']);
});
it('computes strings for Stars', () => {
const fieldName = 'Stars';
assert.deepEqual(fieldExtractor(issue, fieldName),
['2']);
});
it('computes strings for Status', () => {
const fieldName = 'Status';
assert.deepEqual(fieldExtractor(issue, fieldName),
['Duplicate']);
});
it('computes strings for StatusModified', () => {
const fieldName = 'StatusModified';
assert.deepEqual(fieldExtractor(issue, fieldName),
['a minute ago']);
});
it('computes strings for Summary', () => {
const fieldName = 'Summary';
assert.deepEqual(fieldExtractor(issue, fieldName),
['Test summary']);
});
it('computes strings for Type', () => {
const fieldName = 'Type';
assert.deepEqual(fieldExtractor(issue, fieldName),
['Defect']);
});
it('computes strings for Owner', () => {
const fieldName = 'Owner';
assert.deepEqual(fieldExtractor(issue, fieldName),
['owner@example.com']);
});
it('computes strings for OwnerModified', () => {
const fieldName = 'OwnerModified';
assert.deepEqual(fieldExtractor(issue, fieldName),
['a minute ago']);
});
it('computes strings for Opened', () => {
const fieldName = 'Opened';
assert.deepEqual(fieldExtractor(issue, fieldName),
['a day ago']);
});
});
describe('custom approval fields', () => {
beforeEach(() => {
const fieldDefs = [
{fieldRef: {type: 'APPROVAL_TYPE', fieldName: 'Goose-Approval'}},
{fieldRef: {type: 'APPROVAL_TYPE', fieldName: 'Chicken-Approval'}},
{fieldRef: {type: 'APPROVAL_TYPE', fieldName: 'Dodo-Approval'}},
];
fieldExtractor = projectV0.extractFieldValuesFromIssue({
projectV0: {
name: example.PROJECT_NAME,
configs: {
[example.PROJECT_NAME]: {
projectName: 'chromium',
fieldDefs,
},
},
},
});
issue = {
localId: 33,
projectName: 'bird',
approvalValues: [
{fieldRef: {type: 'APPROVAL_TYPE', fieldName: 'Goose-Approval'},
approverRefs: []},
{fieldRef: {type: 'APPROVAL_TYPE', fieldName: 'Chicken-Approval'},
status: 'APPROVED'},
{fieldRef: {type: 'APPROVAL_TYPE', fieldName: 'Dodo-Approval'},
status: 'NEED_INFO', approverRefs: [
{displayName: 'kiwi@bird.test'},
{displayName: 'mini-dino@bird.test'},
],
},
],
};
});
it('handles approval approver columns', () => {
assert.deepEqual(fieldExtractor(issue, 'goose-approval-approver'), []);
assert.deepEqual(fieldExtractor(issue, 'chicken-approval-approver'),
[]);
assert.deepEqual(fieldExtractor(issue, 'dodo-approval-approver'),
['kiwi@bird.test', 'mini-dino@bird.test']);
});
it('handles approval value columns', () => {
assert.deepEqual(fieldExtractor(issue, 'goose-approval'), ['NotSet']);
assert.deepEqual(fieldExtractor(issue, 'chicken-approval'),
['Approved']);
assert.deepEqual(fieldExtractor(issue, 'dodo-approval'),
['NeedInfo']);
});
});
describe('custom fields', () => {
beforeEach(() => {
const fieldDefs = [
{fieldRef: {type: 'STR_TYPE', fieldName: 'aString'}},
{fieldRef: {type: 'ENUM_TYPE', fieldName: 'ENUM'}},
{fieldRef: {type: 'INT_TYPE', fieldName: 'Cow-Number'},
bool_is_phase_field: true, is_multivalued: true},
];
// As a label prefix, aString conflicts with the custom field named
// "aString". In this case, Monorail gives precedence to the
// custom field.
const labelDefs = [
{label: 'aString-ignore'},
{label: 'aString-two'},
];
fieldExtractor = projectV0.extractFieldValuesFromIssue({
projectV0: {
name: example.PROJECT_NAME,
configs: {
[example.PROJECT_NAME]: {
projectName: 'chromium',
fieldDefs,
labelDefs,
},
},
},
});
const fieldValues = [
{fieldRef: {type: 'STR_TYPE', fieldName: 'aString'},
value: 'test'},
{fieldRef: {type: 'STR_TYPE', fieldName: 'aString'},
value: 'test2'},
{fieldRef: {type: 'ENUM_TYPE', fieldName: 'ENUM'},
value: 'a-value'},
{fieldRef: {type: 'INT_TYPE', fieldId: '6', fieldName: 'Cow-Number'},
phaseRef: {phaseName: 'Cow-Phase'}, value: '55'},
{fieldRef: {type: 'INT_TYPE', fieldId: '6', fieldName: 'Cow-Number'},
phaseRef: {phaseName: 'Cow-Phase'}, value: '54'},
{fieldRef: {type: 'INT_TYPE', fieldId: '6', fieldName: 'Cow-Number'},
phaseRef: {phaseName: 'MilkCow-Phase'}, value: '56'},
];
issue = {
localId: 33,
projectName: 'chromium',
fieldValues,
};
});
it('gets values for custom fields', () => {
assert.deepEqual(fieldExtractor(issue, 'aString'), ['test', 'test2']);
assert.deepEqual(fieldExtractor(issue, 'enum'), ['a-value']);
assert.deepEqual(fieldExtractor(issue, 'cow-phase.cow-number'),
['55', '54']);
assert.deepEqual(fieldExtractor(issue, 'milkcow-phase.cow-number'),
['56']);
});
it('custom fields get precedence over label fields', () => {
issue.labelRefs = [{label: 'aString-ignore'}];
assert.deepEqual(fieldExtractor(issue, 'aString'),
['test', 'test2']);
});
});
describe('label prefix fields', () => {
beforeEach(() => {
issue = {
localId: 33,
projectName: 'chromium',
labelRefs: [
{label: 'test-label'},
{label: 'test-label-2'},
{label: 'ignore-me'},
{label: 'Milestone-UI'},
{label: 'Milestone-Goodies'},
],
};
fieldExtractor = projectV0.extractFieldValuesFromIssue({
projectV0: {
name: example.PROJECT_NAME,
configs: {
[example.PROJECT_NAME]: {
projectName: 'chromium',
labelDefs: [
{label: 'test-1'},
{label: 'test-2'},
{label: 'milestone-1'},
{label: 'milestone-2'},
],
},
},
},
});
});
it('gets values for label prefixes', () => {
assert.deepEqual(fieldExtractor(issue, 'test'), ['label', 'label-2']);
assert.deepEqual(fieldExtractor(issue, 'Milestone'), ['UI', 'Goodies']);
});
});
});
it('fieldDefsByApprovalName', () => {
assert.deepEqual(projectV0.fieldDefsByApprovalName({projectV0: {}}),
new Map());
assert.deepEqual(projectV0.fieldDefsByApprovalName({projectV0: {
name: example.PROJECT_NAME,
configs: {[example.PROJECT_NAME]: {
fieldDefs: [
{fieldRef: {fieldName: 'test', type: fieldTypes.INT_TYPE}},
{fieldRef: {fieldName: 'ignoreMe', type: fieldTypes.APPROVAL_TYPE}},
{fieldRef: {fieldName: 'yay', approvalName: 'ThisIsAnApproval'}},
{fieldRef: {fieldName: 'ImAField', approvalName: 'ThisIsAnApproval'}},
{fieldRef: {fieldName: 'TalkToALawyer', approvalName: 'Legal'}},
],
}},
}}), new Map([
['ThisIsAnApproval', [
{fieldRef: {fieldName: 'yay', approvalName: 'ThisIsAnApproval'}},
{fieldRef: {fieldName: 'ImAField', approvalName: 'ThisIsAnApproval'}},
]],
['Legal', [
{fieldRef: {fieldName: 'TalkToALawyer', approvalName: 'Legal'}},
]],
]));
});
});
let dispatch;
describe('project action creators', () => {
beforeEach(() => {
sinon.stub(prpcClient, 'call');
dispatch = sinon.stub();
});
afterEach(() => {
prpcClient.call.restore();
});
it('select', () => {
projectV0.select('project-name')(dispatch);
const action = {type: projectV0.SELECT, projectName: 'project-name'};
sinon.assert.calledWith(dispatch, action);
});
it('fetchCustomPermissions', async () => {
const action = projectV0.fetchCustomPermissions('chromium');
prpcClient.call.returns(Promise.resolve({permissions: ['google']}));
await action(dispatch);
sinon.assert.calledWith(dispatch,
{type: projectV0.FETCH_CUSTOM_PERMISSIONS_START});
sinon.assert.calledWith(
prpcClient.call,
'monorail.Projects',
'GetCustomPermissions',
{projectName: 'chromium'});
sinon.assert.calledWith(dispatch, {
type: projectV0.FETCH_CUSTOM_PERMISSIONS_SUCCESS,
projectName: 'chromium',
permissions: ['google'],
});
});
it('fetchPresentationConfig', async () => {
const action = projectV0.fetchPresentationConfig('chromium');
prpcClient.call.returns(Promise.resolve({projectThumbnailUrl: 'test'}));
await action(dispatch);
sinon.assert.calledWith(dispatch,
{type: projectV0.FETCH_PRESENTATION_CONFIG_START});
sinon.assert.calledWith(
prpcClient.call,
'monorail.Projects',
'GetPresentationConfig',
{projectName: 'chromium'});
sinon.assert.calledWith(dispatch, {
type: projectV0.FETCH_PRESENTATION_CONFIG_SUCCESS,
projectName: 'chromium',
presentationConfig: {projectThumbnailUrl: 'test'},
});
});
it('fetchVisibleMembers', async () => {
const action = projectV0.fetchVisibleMembers('chromium');
prpcClient.call.returns(Promise.resolve({userRefs: [{userId: '123'}]}));
await action(dispatch);
sinon.assert.calledWith(dispatch,
{type: projectV0.FETCH_VISIBLE_MEMBERS_START});
sinon.assert.calledWith(
prpcClient.call,
'monorail.Projects',
'GetVisibleMembers',
{projectName: 'chromium'});
sinon.assert.calledWith(dispatch, {
type: projectV0.FETCH_VISIBLE_MEMBERS_SUCCESS,
projectName: 'chromium',
visibleMembers: {userRefs: [{userId: '123'}]},
});
});
});
describe('helpers', () => {
beforeEach(() => {
sinon.stub(prpcClient, 'call');
});
afterEach(() => {
prpcClient.call.restore();
});
describe('fetchFieldPerms', () => {
it('fetch field permissions', async () => {
const projectName = 'proj';
const fieldDefs = [
{
fieldRef: {
fieldName: 'testField',
fieldId: 1,
type: 'ENUM_TYPE',
},
},
];
const response = {};
prpcClient.call.returns(Promise.resolve(response));
await store.dispatch(projectV0.fetchFieldPerms(projectName, fieldDefs));
const args = {names: ['projects/proj/fieldDefs/1']};
sinon.assert.calledWith(
prpcClient.call, 'monorail.v3.Permissions',
'BatchGetPermissionSets', args);
});
it('fetch with no fieldDefs', async () => {
const config = {projectName: 'proj'};
const response = {};
prpcClient.call.returns(Promise.resolve(response));
// fieldDefs will be undefined.
await store.dispatch(projectV0.fetchFieldPerms(
config.projectName, config.fieldDefs));
const args = {names: []};
sinon.assert.calledWith(
prpcClient.call, 'monorail.v3.Permissions',
'BatchGetPermissionSets', args);
});
});
});