| import './index'; |
| import { setUpElementUnderTest, eventSequencePromise, eventPromise, setQueryString, expectQueryStringToEqual, noEventPromise } from '../../../infra-sk/modules/test_util'; |
| import { searchResponse, statusResponse, paramSetResponse, changeListSummaryResponse } from './demo_data'; |
| import fetchMock from 'fetch-mock'; |
| import { deepCopy } from 'common-sk/modules/object'; |
| import { fromObject } from 'common-sk/modules/query'; |
| import { SearchPageSk, SearchRequest } from './search-page-sk'; |
| import { SearchPageSkPO } from './search-page-sk_po'; |
| import { Label, SearchResponse, TriageRequest } from '../rpc_types'; |
| import { testOnlySetSettings } from '../settings'; |
| import { SearchCriteria } from '../search-controls-sk/search-controls-sk'; |
| import { SearchControlsSkPO } from '../search-controls-sk/search-controls-sk_po'; |
| import { ChangelistControlsSkPO } from '../changelist-controls-sk/changelist-controls-sk_po'; |
| import { BulkTriageSkPO } from '../bulk-triage-sk/bulk-triage-sk_po'; |
| |
| const expect = chai.expect; |
| |
| describe('search-page-sk', () => { |
| const newInstance = setUpElementUnderTest<SearchPageSk>('search-page-sk'); |
| |
| let searchPageSk: SearchPageSk; |
| let searchPageSkPO: SearchPageSkPO; |
| let searchControlsSkPO: SearchControlsSkPO; |
| let changelistControlsSkPO: ChangelistControlsSkPO; |
| let bulkTriageSkPO: BulkTriageSkPO; |
| |
| // SearchCriteria shown by the search-controls-sk component when the search page loads without any |
| // URL parameters. |
| const defaultSearchCriteria: SearchCriteria = { |
| corpus: 'infra', |
| leftHandTraceFilter: {}, |
| rightHandTraceFilter: {}, |
| includePositiveDigests: false, |
| includeNegativeDigests: false, |
| includeUntriagedDigests: true, |
| includeDigestsNotAtHead: false, |
| includeIgnoredDigests: false, |
| minRGBADelta: 0, |
| maxRGBADelta: 255, |
| mustHaveReferenceImage: false, |
| sortOrder: 'descending' |
| }; |
| |
| // Default request to the /json/v1/search RPC when the page is loaded with an empty query string. |
| const defaultSearchRequest: SearchRequest = { |
| fref: false, |
| frgbamax: 255, |
| frgbamin: 0, |
| head: true, |
| include: false, |
| neg: false, |
| pos: false, |
| query: 'source_type=infra', |
| rquery: 'source_type=infra', |
| sort: 'desc', |
| unt: true, |
| } |
| |
| // Query string that will produce the searchRequestWithCL defined below upon page load. |
| const queryStringWithCL = '?crs=gerrit&issue=123456'; |
| |
| // Request to the /json/v1/search RPC when URL parameters crs=gerrit and issue=123456 are present. |
| const searchRequestWithCL: SearchRequest = deepCopy(defaultSearchRequest); |
| searchRequestWithCL.crs = 'gerrit'; |
| searchRequestWithCL.issue = '123456'; |
| |
| // Search response when the query matches 0 digests. |
| const emptySearchResponse: SearchResponse = deepCopy(searchResponse); |
| emptySearchResponse.size = 0; |
| emptySearchResponse.digests = []; |
| |
| // Options for the instantiate() function below. |
| interface InstantiationOptions { |
| initialQueryString: string; |
| expectedInitialSearchRequest: SearchRequest; |
| initialSearchResponse: SearchResponse; |
| mockAndWaitForChangelistSummaryRPC: boolean; |
| }; |
| |
| // Instantiation options for tests where the URL params crs=gerrit and issue=123456 are present. |
| const instantiationOptionsWithCL: Partial<InstantiationOptions> = { |
| initialQueryString: queryStringWithCL, |
| expectedInitialSearchRequest: searchRequestWithCL, |
| mockAndWaitForChangelistSummaryRPC: true, |
| }; |
| |
| // Instantiates the search page, sets up the necessary mock RPCs and waits for it to load. |
| const instantiate = async (opts: Partial<InstantiationOptions> = {}) => { |
| const defaults: InstantiationOptions = { |
| initialQueryString: '', |
| expectedInitialSearchRequest: defaultSearchRequest, |
| initialSearchResponse: searchResponse, |
| mockAndWaitForChangelistSummaryRPC: false, |
| }; |
| |
| // Override defaults with the given options, if any. |
| opts = {...defaults, ...opts}; |
| |
| fetchMock.getOnce('/json/v1/trstatus', () => statusResponse); |
| fetchMock.getOnce('/json/v1/paramset', () => paramSetResponse); |
| fetchMock.get( |
| '/json/v1/search?' + fromObject(opts.expectedInitialSearchRequest as any), |
| () => opts.initialSearchResponse); |
| |
| // We always wait for at least the three above RPCs. |
| const eventsToWaitFor = ['end-task', 'end-task', 'end-task']; |
| |
| // This mocked RPC corresponds to the queryStringWithCL and searchRequestWithCL constants |
| // defined above. |
| if (opts.mockAndWaitForChangelistSummaryRPC) { |
| fetchMock.getOnce('/json/v1/changelist/gerrit/123456', () => changeListSummaryResponse); |
| eventsToWaitFor.push('end-task'); |
| } |
| |
| // The search page will derive its initial search RPC from the query parameters in the URL. |
| setQueryString(opts.initialQueryString!); |
| |
| // Instantiate search page and wait for all of the above mocked RPCs to complete. |
| const events = eventSequencePromise(eventsToWaitFor); |
| searchPageSk = newInstance(); |
| await events; |
| |
| searchPageSkPO = new SearchPageSkPO(searchPageSk); |
| searchControlsSkPO = await searchPageSkPO.getSearchControlsSkPO(); |
| changelistControlsSkPO = await searchPageSkPO.getChangelistControlsSkPO(); |
| bulkTriageSkPO = await searchPageSkPO.getBulkTriageSkPO(); |
| } |
| |
| before(() => { |
| testOnlySetSettings({ |
| title: 'Skia Infra', |
| defaultCorpus: 'infra', |
| baseRepoURL: 'https://skia.googlesource.com/buildbot.git', |
| }); |
| }); |
| |
| afterEach(() => { |
| expect(fetchMock.done()).to.be.true; // All mock RPCs called at least once. |
| fetchMock.reset(); |
| }); |
| |
| // This function adds tests to ensure that a search field in the UI is correctly bound to its |
| // corresponding query parameter in the URL and to its corresponding field in the SearchRequest |
| // object. |
| const searchFieldIsBoundToURLAndRPC = <T>( |
| instantiationOpts: Partial<InstantiationOptions>, |
| queryStringWithSearchField: string, |
| uiValueGetterFn: () => Promise<T>, |
| uiValueSetterFn: () => Promise<void>, |
| expectedUiValue: T, |
| expectedSearchRequest: SearchRequest, |
| ) => { |
| it('is read from the URL and included in the initial search RPC', async () => { |
| // We initialize the search page using a query string that contains the search field under |
| // test, so that said field is included in the initial search RPC. |
| // |
| // If the search RPC is not called with the expected SearchRequest, the top-level |
| // afterEach() hook will fail. |
| await instantiate({ |
| ...instantiationOpts, |
| initialQueryString: queryStringWithSearchField, |
| expectedInitialSearchRequest: expectedSearchRequest |
| }); |
| |
| // The search field in the UI should reflect the value from the URL. |
| expect(await uiValueGetterFn()).to.deep.equal(expectedUiValue); |
| }); |
| |
| it('is reflected in the URL and included in the search RPC when set via the UI', async () => { |
| // We initialize the search page using the default query string. |
| await instantiate(instantiationOpts); |
| |
| // We will trigger a search RPC when we set the value of the field under test via the UI. |
| // If the RPC is not called with the expected SearchRequest, the top-level afterEach() hook |
| // will fail. |
| fetchMock.get( |
| '/json/v1/search?' + fromObject(expectedSearchRequest as any), () => searchResponse); |
| |
| // Set the search field under test via the UI and wait for the above RPC to complete. |
| const event = eventPromise('end-task'); |
| await uiValueSetterFn(); |
| await event; |
| |
| // The search field under test should now be reflected in the URL. |
| expectQueryStringToEqual(queryStringWithSearchField); |
| }); |
| } |
| |
| describe('search-controls-sk', () => { |
| const itIsBoundToURLAndRPC = ( |
| queryString: string, |
| searchCriteria: Partial<SearchCriteria>, |
| serachRequest: Partial<SearchRequest> |
| ) => { |
| const expectedSearchCriteria: SearchCriteria = {...defaultSearchCriteria, ...searchCriteria}; |
| const expectedSearchRequest: SearchRequest = {...defaultSearchRequest, ...serachRequest}; |
| |
| searchFieldIsBoundToURLAndRPC<SearchCriteria>( |
| /* initializationOpts= */ {}, |
| queryString, |
| () => searchControlsSkPO.getSearchCriteria(), |
| () => searchControlsSkPO.setSearchCriteria(expectedSearchCriteria!), |
| expectedSearchCriteria!, |
| expectedSearchRequest!); |
| } |
| |
| describe('field "corpus"', () => { |
| itIsBoundToURLAndRPC( |
| '?corpus=my-corpus', |
| {corpus: 'my-corpus'}, |
| {query: 'source_type=my-corpus', rquery: 'source_type=my-corpus'}); |
| }); |
| |
| describe('field "left-hand trace filter"', () => { |
| itIsBoundToURLAndRPC( |
| '?left_filter=name%3Dam_email-chooser-sk', |
| {leftHandTraceFilter: {'name': ['am_email-chooser-sk']}}, |
| {query: 'name=am_email-chooser-sk&source_type=infra'}); |
| }); |
| |
| describe('field "right-hand trace filter"', () => { |
| itIsBoundToURLAndRPC( |
| '?right_filter=name%3Dam_email-chooser-sk', |
| {rightHandTraceFilter: {'name': ['am_email-chooser-sk']}}, |
| {rquery: 'name=am_email-chooser-sk&source_type=infra'}); |
| }); |
| |
| describe('field "include positive digests"', () => { |
| itIsBoundToURLAndRPC( |
| '?positive=true', |
| {includePositiveDigests: true}, |
| {pos: true}); |
| }); |
| |
| describe('field "include negative digests"', () => { |
| itIsBoundToURLAndRPC( |
| '?negative=true', |
| {includeNegativeDigests: true}, |
| {neg: true}); |
| }); |
| |
| describe('field "include untriaged digests"', () => { |
| // This field is true by default, so we set it to false. |
| itIsBoundToURLAndRPC( |
| '?untriaged=false', |
| {includeUntriagedDigests: false}, |
| {unt: false}); |
| }); |
| |
| describe('field "include digests not at head"', () => { |
| itIsBoundToURLAndRPC( |
| '?not_at_head=true', |
| {includeDigestsNotAtHead: true}, |
| {head: false}); // SearchRequest field "head" means "at head only". |
| }); |
| |
| describe('field "include ignored digests"', () => { |
| itIsBoundToURLAndRPC( |
| '?include_ignored=true', |
| {includeIgnoredDigests: true}, |
| {include: true}); |
| }); |
| |
| describe('field "min RGBA delta"', () => { |
| itIsBoundToURLAndRPC( |
| '?min_rgba=10', |
| {minRGBADelta: 10}, |
| {frgbamin: 10}); |
| }); |
| |
| describe('field "max RGBA delta"', () => { |
| itIsBoundToURLAndRPC( |
| '?max_rgba=200', |
| {maxRGBADelta: 200}, |
| {frgbamax: 200}); |
| }); |
| |
| describe('field "max RGBA delta"', () => { |
| itIsBoundToURLAndRPC( |
| '?max_rgba=200', |
| {maxRGBADelta: 200}, |
| {frgbamax: 200}); |
| }); |
| |
| describe('field "must have reference image"', () => { |
| itIsBoundToURLAndRPC( |
| '?reference_image_required=true', |
| {mustHaveReferenceImage: true}, |
| {fref: true}); |
| }); |
| |
| describe('field "sort order"', () => { |
| itIsBoundToURLAndRPC( |
| '?sort=ascending', |
| {sortOrder: 'ascending'}, |
| {sort: 'asc'}); |
| }); |
| }); |
| |
| describe('changelist-controls-sk', () => { |
| it('is hidden if no CL is provided in the query string', async () => { |
| // When instantiated without URL parameters "crs" and "issue", the search page does not make |
| // an RPC to /json/v1/changelist, therefore there is no changelist summary for the |
| // changelist-controls-sk component to display. |
| await instantiate(); |
| expect(await changelistControlsSkPO.isVisible()).to.be.false; |
| }); |
| |
| it( |
| 'is visible if a CL is provided in the query string and /json/v1/changelist returns a ' + |
| 'non-empty response', |
| async () => { |
| // We instantiate the serach page with URL parameters "crs" and "issue", which causes it to |
| // make an RPC to /json/v1/changelist. The returned changelist summary is passed to the |
| // changelist-controls-sk component, which then makes itself visible. |
| await instantiate(instantiationOptionsWithCL); |
| expect(await changelistControlsSkPO.isVisible()).to.be.true; |
| }); |
| |
| describe('field "patchset"', () => { |
| searchFieldIsBoundToURLAndRPC<string>( |
| instantiationOptionsWithCL, |
| queryStringWithCL + '&patchsets=1', |
| () => changelistControlsSkPO.getPatchset(), |
| () => changelistControlsSkPO.setPatchset('PS 1'), |
| /* expectedUiValue= */ 'PS 1', |
| {...searchRequestWithCL, patchsets: 1}); |
| }); |
| |
| describe('radio "exclude results from primary branch"', () => { |
| // When this radio is clicked, the "master" parameter is removed from the URL if present, so |
| // we need to test this backwards by starting with "master=true" in the URL (which means the |
| // initial search RPC will include "master=true" in the SearchRequest as well) and then |
| // asserting that "master" is removed from both the URL and the SearchRequest when the radio |
| // is clicked. |
| searchFieldIsBoundToURLAndRPC<boolean>( |
| { |
| ...instantiationOptionsWithCL, |
| expectedInitialSearchRequest: {...searchRequestWithCL, master: true, patchsets: 2}, |
| initialQueryString: queryStringWithCL + '&master=true&patchsets=2' |
| }, |
| queryStringWithCL + '&patchsets=2', |
| () => changelistControlsSkPO.isExcludeResultsFromPrimaryRadioChecked(), |
| () => changelistControlsSkPO.clickExcludeResultsFromPrimaryRadio(), |
| /* expectedUiValue= */ true, |
| {...searchRequestWithCL, patchsets: 2}); |
| }); |
| |
| describe('radio "show all results"', () => { |
| searchFieldIsBoundToURLAndRPC<boolean>( |
| instantiationOptionsWithCL, |
| queryStringWithCL + '&master=true&patchsets=2', |
| () => changelistControlsSkPO.isShowAllResultsRadioChecked(), |
| () => changelistControlsSkPO.clickShowAllResultsRadio(), |
| /* expectedUiValue= */ true, |
| {...searchRequestWithCL, master: true, patchsets: 2}); |
| }); |
| }); |
| |
| describe('search results', () => { |
| it('shows empty search results', async () => { |
| await instantiate({initialSearchResponse: emptySearchResponse}); |
| |
| expect(await searchPageSkPO.getSummary()) |
| .to.equal('No results matched your search criteria.'); |
| expect(await searchPageSkPO.getDigests()).to.be.empty; |
| }); |
| |
| it('shows search results', async () => { |
| await instantiate(); |
| |
| expect(await searchPageSkPO.getSummary()).to.equal('Showing results 1 to 3 (out of 85).'); |
| expect(await searchPageSkPO.getDigests()).to.deep.equal([ |
| 'Left: fbd3de3fff6b852ae0bb6751b9763d27', |
| 'Left: 2fa58aa430e9c815755624ca6cca4a72', |
| 'Left: ed4a8cf9ea9fbb57bf1f302537e07572' |
| ]); |
| }); |
| |
| it('shows search results with changelist information', async () => { |
| await instantiate(instantiationOptionsWithCL); |
| |
| expect(await searchPageSkPO.getDigests()).to.deep.equal([ |
| 'Left: fbd3de3fff6b852ae0bb6751b9763d27', |
| 'Left: 2fa58aa430e9c815755624ca6cca4a72', |
| 'Left: ed4a8cf9ea9fbb57bf1f302537e07572' |
| ]); |
| |
| const diffDetailsHrefs = await searchPageSkPO.getDiffDetailsHrefs(); |
| expect(diffDetailsHrefs[0]).to.contain('changelist_id=123456&crs=gerrit'); |
| expect(diffDetailsHrefs[1]).to.contain('changelist_id=123456&crs=gerrit'); |
| expect(diffDetailsHrefs[2]).to.contain('changelist_id=123456&crs=gerrit'); |
| }); |
| }); |
| |
| // TODO(lovisolo): Add some sort of indication in the UI when searching by blame. |
| describe('"blame" URL parameter', () => { |
| it('is reflected in the initial search RPC', async () => { |
| // No explicit assertions are necessary because if the search RPC is not called with the |
| // expected SearchRequest then the fetchMock.done() call in the top-level afterEach() hook |
| // will fail. |
| await instantiate({ |
| initialQueryString: |
| '?blame=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', |
| expectedInitialSearchRequest: { |
| ...defaultSearchRequest, |
| blame: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' |
| }, |
| }); |
| }); |
| }); |
| |
| describe('help dialog', () => { |
| it('is closed by default', async () => { |
| await instantiate(); |
| expect(await searchPageSkPO.isHelpDialogOpen()).to.be.false; |
| }); |
| |
| it('opens when clicking the "Help" button', async () => { |
| await instantiate(); |
| await searchPageSkPO.clickHelpBtn(); |
| expect(await searchPageSkPO.isHelpDialogOpen()).to.be.true; |
| }); |
| |
| it('closes when the "Close" button is clicked', async () => { |
| await instantiate(); |
| await searchPageSkPO.clickHelpBtn(); |
| await searchPageSkPO.clickHelpDialogCancelBtn(); |
| expect(await searchPageSkPO.isHelpDialogOpen()).to.be.false; |
| }); |
| }); |
| |
| describe('bulk triage dialog', () => { |
| describe('opening and closing', () => { |
| it('is closed by default', async () => { |
| await instantiate(); |
| expect(await searchPageSkPO.isBulkTriageDialogOpen()).to.be.false; |
| }); |
| |
| it('opens when clicking the "Bulk Triage" button', async () => { |
| await instantiate(); |
| await searchPageSkPO.clickBulkTriageBtn(); |
| expect(await searchPageSkPO.isBulkTriageDialogOpen()).to.be.true; |
| }); |
| |
| it('closes when the "Cancel" button is clicked', async () => { |
| await instantiate(); |
| await searchPageSkPO.clickBulkTriageBtn(); |
| await bulkTriageSkPO.clickCancelBtn(); |
| expect(await searchPageSkPO.isBulkTriageDialogOpen()).to.be.false; |
| }); |
| |
| it('closes when the "Triage ..." button is clicked', async () => { |
| fetchMock.post('/json/v1/triage', 200); // We ignore the TriageRequest in this test. |
| |
| await instantiate(); |
| await searchPageSkPO.clickBulkTriageBtn(); |
| await bulkTriageSkPO.clickTriageBtn(); |
| expect(await searchPageSkPO.isBulkTriageDialogOpen()).to.be.false; |
| }); |
| }); |
| |
| describe('affected CL', () => { |
| it('does not show an affected CL if none is provided', async () => { |
| await instantiate(); |
| await searchPageSkPO.clickBulkTriageBtn(); |
| expect(await bulkTriageSkPO.isAffectedChangelistIdVisible()).to.be.false; |
| }); |
| |
| it('shows the affected CL if one is provided', async () => { |
| await instantiate(instantiationOptionsWithCL); |
| await searchPageSkPO.clickBulkTriageBtn(); |
| expect(await bulkTriageSkPO.isAffectedChangelistIdVisible()).to.be.true; |
| expect(await bulkTriageSkPO.getAffectedChangelistId()).to.equal( |
| 'This affects Changelist 123456.'); |
| }); |
| }); |
| |
| describe('RPCs', () => { |
| describe('search results from current page only', () => { |
| const expectedTriageRequest: TriageRequest = { |
| testDigestStatus: { |
| 'gold_search-controls-sk_right-hand-trace-filter-editor': { |
| 'fbd3de3fff6b852ae0bb6751b9763d27': 'positive', |
| }, |
| 'perf_alert-config-sk': { |
| '2fa58aa430e9c815755624ca6cca4a72': 'positive', |
| 'ed4a8cf9ea9fbb57bf1f302537e07572': 'positive', |
| }, |
| }, |
| changelist_id: '', |
| crs: '', |
| }; |
| |
| it('can bulk-triage without a CL', async () => { |
| fetchMock.post('/json/v1/triage', 200, {body: expectedTriageRequest}); |
| |
| await instantiate(); |
| await searchPageSkPO.clickBulkTriageBtn(); |
| await bulkTriageSkPO.clickPositiveBtn(); |
| await bulkTriageSkPO.clickTriageBtn(); |
| }); |
| |
| it('can bulk-triage with a CL', async () => { |
| fetchMock.post('/json/v1/triage', 200, { |
| body: { |
| ...expectedTriageRequest, |
| changelist_id: '123456', |
| crs: 'gerrit', |
| } |
| }); |
| |
| await instantiate(instantiationOptionsWithCL); |
| await searchPageSkPO.clickBulkTriageBtn(); |
| await bulkTriageSkPO.clickPositiveBtn(); |
| await bulkTriageSkPO.clickTriageBtn(); |
| }); |
| }); |
| |
| describe('all search results', () => { |
| const expectedTriageRequest: TriageRequest = { |
| testDigestStatus: { |
| 'gold_details-page-sk': { |
| '29f31f703510c2091840b5cf2b032f56': 'positive', |
| '7c0a393e57f14b5372ec1590b79bed0f': 'positive', |
| '971fe90fa07ebc2c7d0c1a109a0f697c': 'positive', |
| 'e49c92a2cff48531810cc5e863fad0ee': 'positive' |
| }, |
| 'gold_search-controls-sk_right-hand-trace-filter-editor': { |
| '5d8c80eda80e015d633a4125ab0232dc': 'positive', |
| 'd20f37006e436fe17f50ecf49ff2bdb5': 'positive', |
| 'fbd3de3fff6b852ae0bb6751b9763d27': 'positive' |
| }, |
| 'perf_alert-config-sk': { |
| '2fa58aa430e9c815755624ca6cca4a72': 'positive', |
| 'ed4a8cf9ea9fbb57bf1f302537e07572': 'positive' |
| }, |
| }, |
| changelist_id: '', |
| crs: '', |
| } |
| |
| it('can bulk-triage without a CL', async () => { |
| fetchMock.post('/json/v1/triage', 200, {body: expectedTriageRequest}); |
| |
| await instantiate(); |
| await searchPageSkPO.clickBulkTriageBtn(); |
| await bulkTriageSkPO.clickTriageAllCheckbox(); |
| await bulkTriageSkPO.clickPositiveBtn(); |
| await bulkTriageSkPO.clickTriageBtn(); |
| }); |
| |
| it('can bulk-triage with a CL', async () => { |
| fetchMock.post('/json/v1/triage', 200, { |
| body: { |
| ...expectedTriageRequest, |
| changelist_id: '123456', |
| crs: 'gerrit', |
| } |
| }); |
| |
| await instantiate(instantiationOptionsWithCL); |
| await searchPageSkPO.clickBulkTriageBtn(); |
| await bulkTriageSkPO.clickTriageAllCheckbox(); |
| await bulkTriageSkPO.clickPositiveBtn(); |
| await bulkTriageSkPO.clickTriageBtn(); |
| }); |
| }); |
| }); |
| }); |
| |
| describe('keyboard shortcuts', () => { |
| // TODO(lovisolo): Clean this up after digest-details-sk is ported to TypeScript and we have |
| // a DigestDetailsSkPO. |
| const firstDigest = 'Left: fbd3de3fff6b852ae0bb6751b9763d27'; |
| const secondDigest = 'Left: 2fa58aa430e9c815755624ca6cca4a72'; |
| const thirdDigest = 'Left: ed4a8cf9ea9fbb57bf1f302537e07572'; |
| |
| const expectLabelsForFirstSecondAndThirdDigestsToBe = |
| async (firstLabel: Label, secondLabel: Label, thirdLabel: Label) => { |
| expect(await searchPageSkPO.getLabelForDigest(firstDigest)).to.equal(firstLabel); |
| expect(await searchPageSkPO.getLabelForDigest(secondDigest)).to.equal(secondLabel); |
| expect(await searchPageSkPO.getLabelForDigest(thirdDigest)).to.equal(thirdLabel); |
| } |
| |
| describe('navigation', () => { |
| it('initially has an empty selection', async () => { |
| await instantiate(); |
| expect(await searchPageSkPO.getSelectedDigest()).to.be.null; |
| }); |
| |
| it('can navigate between digests with keys "J" and "K"', async () => { |
| await instantiate(); |
| |
| expect(await searchPageSkPO.getSelectedDigest()).to.be.null; |
| |
| // Forward. |
| await searchPageSkPO.typeKey('j'); |
| expect(await searchPageSkPO.getSelectedDigest()).to.equal(firstDigest); |
| |
| // Forward. |
| await searchPageSkPO.typeKey('j'); |
| expect(await searchPageSkPO.getSelectedDigest()).to.equal(secondDigest); |
| |
| // Forward. |
| await searchPageSkPO.typeKey('j'); |
| expect(await searchPageSkPO.getSelectedDigest()).to.equal(thirdDigest); |
| |
| // Forward. Nothing happens because we're at the last search result. |
| await searchPageSkPO.typeKey('j'); |
| expect(await searchPageSkPO.getSelectedDigest()).to.equal(thirdDigest); |
| |
| // Back. |
| await searchPageSkPO.typeKey('k'); |
| expect(await searchPageSkPO.getSelectedDigest()).to.equal(secondDigest); |
| |
| // Back. |
| await searchPageSkPO.typeKey('k'); |
| expect(await searchPageSkPO.getSelectedDigest()).to.equal(firstDigest); |
| |
| // Back. Nothing happens because we're at the first search result. |
| await searchPageSkPO.typeKey('k'); |
| expect(await searchPageSkPO.getSelectedDigest()).to.equal(firstDigest); |
| }); |
| |
| it('resets the selection when the search results change', async () => { |
| await instantiate(); |
| |
| // Select the first search result. |
| await searchPageSkPO.typeKey('j'); |
| |
| // Refresh the results by changing a search parameter. |
| fetchMock.get('glob:/json/v1/search?*', searchResponse); |
| const event = eventPromise('end-task'); |
| await searchControlsSkPO.clickIncludePositiveDigestsCheckbox(); |
| await event; |
| |
| // Search results should be non-empty, but selection should be empty. |
| expect(await searchPageSkPO.getDigests()).to.not.be.empty; |
| expect(await searchPageSkPO.getSelectedDigest()).to.be.null; |
| }); |
| }); |
| |
| describe('triaging', () => { |
| it('cannot triage with "A", "S" and "D" keys when the selection is empty', async () => { |
| await instantiate(); |
| |
| // Check initial labels. |
| await expectLabelsForFirstSecondAndThirdDigestsToBe('positive', 'negative', 'untriaged'); |
| |
| // Triaging as positive should have no effect. |
| await searchPageSkPO.typeKey('a'); |
| await expectLabelsForFirstSecondAndThirdDigestsToBe('positive', 'negative', 'untriaged'); |
| |
| // Triaging as negative should have no effect. |
| await searchPageSkPO.typeKey('s'); |
| await expectLabelsForFirstSecondAndThirdDigestsToBe('positive', 'negative', 'untriaged'); |
| |
| // Triaging as untriaged should have no effect. |
| await searchPageSkPO.typeKey('d'); |
| await expectLabelsForFirstSecondAndThirdDigestsToBe('positive', 'negative', 'untriaged'); |
| }); |
| |
| it('can triage the selected digest with keys "A", "S" and "D"', async () => { |
| fetchMock.post('/json/v1/triage', 200); // We ignore the TriageRequest in this test. |
| |
| await instantiate(); |
| |
| // Check initial labels. |
| await expectLabelsForFirstSecondAndThirdDigestsToBe('positive', 'negative', 'untriaged'); |
| |
| // Select the second search result. |
| await searchPageSkPO.typeKey('j'); |
| await searchPageSkPO.typeKey('j'); |
| |
| // We will also test that, when the user triages a digest, the new label remains in place |
| // even after the search-page-sk component is re-rendered with the same (now stale) |
| // cached SearchResults from an earlier RPC to /json/v1/search. The SearchResults are now |
| // stale because they reflect the RPC response prior to the user's triage action. |
| // |
| // This behavior is important to test because it exercises logic in search-page-sk that |
| // patches the cached SearchResults with a new label when the user triages a digest via the |
| // digest-details-sk component, or via the "A", "S" or "D" keyboard shortcuts. |
| // |
| // Currently there are no situations that would cause the search page to be re-rendered with |
| // cached SearchResults. It used to be the case that navigating between search results with |
| // the "J" and "K" keyboard shortcuts would trigger a re-render in order to redraw the box |
| // around the selected search result. However, this turned out to be slow for pages with |
| // many search results. So this is now done in an ad-hoc way by manually updating the |
| // affected DOM nodes, which is much faster than calling lit-html's render() function. |
| // |
| // We still want to test this behavior in case we decide to revert the above optimization |
| // (e.g. if we add pagination, therefore limiting the number of results displayed at once), |
| // or if we decide to implement new features that might require re-rendering the page with |
| // cached SearchResults. We exercise this behavior by forcing a page re-render via the |
| // _render() method. |
| // |
| // We test this behavior here via keyboard shortcuts for convenience. |
| |
| // Triage as positive. |
| let event = eventPromise('end-task'); |
| await searchPageSkPO.typeKey('a'); |
| await event; |
| |
| // It should be positive, and the label should stick after the page is re-rendered. |
| await expectLabelsForFirstSecondAndThirdDigestsToBe('positive', 'positive', 'untriaged'); |
| (searchPageSk as any)._render(); // We cast to "any" because _render is not public. |
| await expectLabelsForFirstSecondAndThirdDigestsToBe('positive', 'positive', 'untriaged'); |
| |
| // Triage as negative. |
| event = eventPromise('end-task'); |
| await searchPageSkPO.typeKey('s'); |
| await event; |
| |
| // It should be negative, and the label should stick after the page is re-rendered. |
| await expectLabelsForFirstSecondAndThirdDigestsToBe('positive', 'negative', 'untriaged'); |
| (searchPageSk as any)._render(); // We cast to "any" because _render is not public. |
| await expectLabelsForFirstSecondAndThirdDigestsToBe('positive', 'negative', 'untriaged'); |
| |
| // Triage as untriaged. |
| event = eventPromise('end-task'); |
| await searchPageSkPO.typeKey('d'); |
| await event; |
| |
| // It should be untriaged, and the label should stick after the page is re-rendered. |
| await expectLabelsForFirstSecondAndThirdDigestsToBe('positive', 'untriaged', 'untriaged'); |
| (searchPageSk as any)._render(); // We cast to "any" because _render is not public. |
| await expectLabelsForFirstSecondAndThirdDigestsToBe('positive', 'untriaged', 'untriaged'); |
| }); |
| }); |
| |
| describe('zoom', () => { |
| it('cannot zoom with the "W" key when the selection is empty', async () => { |
| await instantiate(); |
| |
| // Check that there is no open zoom dialog. |
| expect(await searchPageSkPO.getDigestWithOpenZoomDialog()).to.be.null; |
| |
| // The keyboard shortcut should have no effect as no digest is selected. |
| await searchPageSkPO.typeKey('w'); |
| expect(await searchPageSkPO.getDigestWithOpenZoomDialog()).to.be.null; |
| }); |
| |
| it('can zoom into the selected digest with the "W" key', async () => { |
| await instantiate(); |
| |
| // Select the second search result. |
| await searchPageSkPO.typeKey('j'); |
| await searchPageSkPO.typeKey('j'); |
| |
| // The zoom dialog for the second search result should open. |
| await searchPageSkPO.typeKey('w'); |
| expect(await searchPageSkPO.getDigestWithOpenZoomDialog()).to.equal(secondDigest); |
| }); |
| }); |
| |
| it('shows the help dialog when pressing the "?" key', async () => { |
| await instantiate(); |
| await searchPageSkPO.typeKey('?'); |
| expect(await searchPageSkPO.isHelpDialogOpen()).to.be.true; |
| }); |
| |
| describe('shortcuts are disabled when a dialog is open', () => { |
| beforeEach(async () => { |
| await instantiate(); |
| |
| // Select the second search result. The expectKeyboardShortcutsToBeDisabled() helper below |
| // relies on this. |
| await searchPageSkPO.typeKey('j'); |
| await searchPageSkPO.typeKey('j'); |
| }); |
| |
| const expectKeyboardShortcutsToBeDisabled = async () => { |
| // Navigation shortcuts should have no effect. |
| expect(await searchPageSkPO.getSelectedDigest()).to.equal(secondDigest); |
| await searchPageSkPO.typeKey('j'); |
| expect(await searchPageSkPO.getSelectedDigest()).to.equal(secondDigest); |
| await searchPageSkPO.typeKey('k'); |
| expect(await searchPageSkPO.getSelectedDigest()).to.equal(secondDigest); |
| |
| // Check initial triage labels. |
| await expectLabelsForFirstSecondAndThirdDigestsToBe('positive', 'negative', 'untriaged'); |
| |
| // Shortcut for triaging as positive should have no effect. |
| let noEvent = noEventPromise('begin-task'); |
| await searchPageSkPO.typeKey('a'); |
| await noEvent; |
| await expectLabelsForFirstSecondAndThirdDigestsToBe('positive', 'negative', 'untriaged'); |
| |
| // Shortcut for triaging as negative should have no effect. |
| noEvent = noEventPromise('begin-task'); |
| await searchPageSkPO.typeKey('s'); |
| await noEvent; |
| await expectLabelsForFirstSecondAndThirdDigestsToBe('positive', 'negative', 'untriaged'); |
| |
| // Shortcut for triaging as untriagaed should have no effect. |
| noEvent = noEventPromise('begin-task'); |
| await searchPageSkPO.typeKey('d'); |
| await noEvent; |
| await expectLabelsForFirstSecondAndThirdDigestsToBe('positive', 'negative', 'untriaged'); |
| |
| // Shortcut for the help dialog should have no effect, but we can only test this if the |
| // help dialog is not already open, otherwise the shortcut has no effect. |
| if (!(await searchPageSkPO.isHelpDialogOpen())) { |
| await searchPageSkPO.typeKey('?'); |
| expect(await searchPageSkPO.isHelpDialogOpen()).to.be.false; |
| } |
| }; |
| |
| it('disables keyboard shortcuts when the help dialog is open', async () => { |
| await searchPageSkPO.clickHelpBtn(); // Open help dialog. |
| |
| expect(await searchPageSkPO.isHelpDialogOpen()).to.be.true; |
| await expectKeyboardShortcutsToBeDisabled(); |
| }); |
| |
| it('disables keyboard shortcuts when the bulk triage dialog is open', async () => { |
| await searchPageSkPO.clickBulkTriageBtn(); // Open bulk triage dialog. |
| |
| expect(await searchPageSkPO.isBulkTriageDialogOpen()).to.be.true; |
| await expectKeyboardShortcutsToBeDisabled(); |
| }); |
| |
| it('disables keyboard shortcuts when the left-hand trace filter dialog is open', async () => { |
| const leftHandTraceFilterSkPO = await searchControlsSkPO.getTraceFilterSkPO(); |
| await leftHandTraceFilterSkPO.clickEditBtn(); // Open left-hand trace filter dialog. |
| |
| expect(await leftHandTraceFilterSkPO.isQueryDialogSkOpen()).to.be.true; |
| await expectKeyboardShortcutsToBeDisabled(); |
| }); |
| |
| it('disables keyboard shortcuts when the more filters dialog is open', async () => { |
| const filterDialogSkPO = await searchControlsSkPO.getFilterDialogSkPO(); |
| await searchControlsSkPO.clickMoreFiltersBtn(); // Open more filters dialog. |
| |
| expect(await filterDialogSkPO.isDialogOpen()).to.be.true; |
| await expectKeyboardShortcutsToBeDisabled(); |
| }); |
| |
| it( |
| 'disables keyboard shortcuts when the right-hand trace filter dialog is open', |
| async () => { |
| |
| const filterDialogSkPO = await searchControlsSkPO.getFilterDialogSkPO(); |
| await searchControlsSkPO.clickMoreFiltersBtn(); // Open more filters dialog. |
| |
| const rightHandTraceFilterSkPO = await filterDialogSkPO.getTraceFilterSkPO(); |
| await rightHandTraceFilterSkPO.clickEditBtn(); // Open right-hand trace filter dialog. |
| |
| expect(await filterDialogSkPO.isDialogOpen()).to.be.true; |
| expect(await rightHandTraceFilterSkPO.isQueryDialogSkOpen()).to.be.true; |
| await expectKeyboardShortcutsToBeDisabled(); |
| }); |
| |
| it('disables keyboard shortcuts when the zoom dialog is open', async () => { |
| await searchPageSkPO.typeKey('w'); // Open zoom dialog. |
| |
| expect(await searchPageSkPO.getDigestWithOpenZoomDialog()).to.not.be.null; |
| await expectKeyboardShortcutsToBeDisabled(); |
| }); |
| }); |
| }); |
| }); |
