diff options
author | GitLab Bot <gitlab-bot@gitlab.com> | 2020-01-31 09:08:53 +0000 |
---|---|---|
committer | GitLab Bot <gitlab-bot@gitlab.com> | 2020-01-31 09:08:53 +0000 |
commit | fd3a95f07ae9cd78fecffcfa5de4494f933a7808 (patch) | |
tree | a38a8abb0afb14aa396edd30137ddf45e71d2713 /spec/frontend | |
parent | 6a7005feed2e88568f42627e7190ff5c4f2aa8d3 (diff) | |
download | gitlab-ce-fd3a95f07ae9cd78fecffcfa5de4494f933a7808.tar.gz |
Add latest changes from gitlab-org/gitlab@master
Diffstat (limited to 'spec/frontend')
-rw-r--r-- | spec/frontend/boards/issue_card_spec.js | 25 | ||||
-rw-r--r-- | spec/frontend/lib/utils/datetime_range_spec.js | 327 | ||||
-rw-r--r-- | spec/frontend/monitoring/utils_spec.js | 97 |
3 files changed, 359 insertions, 90 deletions
diff --git a/spec/frontend/boards/issue_card_spec.js b/spec/frontend/boards/issue_card_spec.js index 08cffed5f00..526cdb81ac6 100644 --- a/spec/frontend/boards/issue_card_spec.js +++ b/spec/frontend/boards/issue_card_spec.js @@ -97,6 +97,9 @@ describe('Issue card component', () => { issue: { ...wrapper.props('issue'), assignees: [user], + updateData(newData) { + Object.assign(this, newData); + }, }, }); @@ -118,6 +121,28 @@ describe('Issue card component', () => { it('renders avatar', () => { expect(wrapper.find('.board-card-assignee img').exists()).toBe(true); }); + + it('renders the avatar using avatar_url property', done => { + wrapper.props('issue').updateData({ + ...wrapper.props('issue'), + assignees: [ + { + id: '1', + name: 'test', + state: 'active', + username: 'test_name', + avatar_url: 'test_image_from_avatar_url', + }, + ], + }); + + wrapper.vm.$nextTick(() => { + expect(wrapper.find('.board-card-assignee img').attributes('src')).toBe( + 'test_image_from_avatar_url?width=24', + ); + done(); + }); + }); }); describe('assignee default avatar', () => { diff --git a/spec/frontend/lib/utils/datetime_range_spec.js b/spec/frontend/lib/utils/datetime_range_spec.js index 13eb69e1761..8b1f284615d 100644 --- a/spec/frontend/lib/utils/datetime_range_spec.js +++ b/spec/frontend/lib/utils/datetime_range_spec.js @@ -1,10 +1,46 @@ import _ from 'lodash'; -import { getRangeType, convertToFixedRange } from '~/lib/utils/datetime_range'; +import { + getRangeType, + convertToFixedRange, + isEqualTimeRanges, + findTimeRange, + timeRangeToParams, + timeRangeFromParams, +} from '~/lib/utils/datetime_range'; const MOCK_NOW = Date.UTC(2020, 0, 23, 20); const MOCK_NOW_ISO_STRING = new Date(MOCK_NOW).toISOString(); +const mockFixedRange = { + label: 'January 2020', + start: '2020-01-01T00:00:00.000Z', + end: '2020-01-31T23:59:00.000Z', +}; + +const mockAnchoredRange = { + label: 'First two minutes of 2020', + anchor: '2020-01-01T00:00:00.000Z', + direction: 'after', + duration: { + seconds: 60 * 2, + }, +}; + +const mockRollingRange = { + label: 'Next 2 minutes', + direction: 'after', + duration: { + seconds: 60 * 2, + }, +}; + +const mockOpenRange = { + label: '2020 so far', + anchor: '2020-01-01T00:00:00.000Z', + direction: 'after', +}; + describe('Date time range utils', () => { describe('getRangeType', () => { it('infers correctly the range type from the input object', () => { @@ -43,38 +79,28 @@ describe('Date time range utils', () => { }); describe('When a fixed range is input', () => { - const defaultFixedRange = { - start: '2020-01-01T00:00:00.000Z', - end: '2020-01-31T23:59:00.000Z', - label: 'January 2020', - }; - - const mockFixedRange = params => ({ ...defaultFixedRange, ...params }); - it('converts a fixed range to an equal fixed range', () => { - const aFixedRange = mockFixedRange(); - - expect(convertToFixedRange(aFixedRange)).toEqual({ - start: defaultFixedRange.start, - end: defaultFixedRange.end, + expect(convertToFixedRange(mockFixedRange)).toEqual({ + start: mockFixedRange.start, + end: mockFixedRange.end, }); }); it('throws an error when fixed range does not contain an end time', () => { - const aFixedRangeMissingEnd = _.omit(mockFixedRange(), 'end'); + const aFixedRangeMissingEnd = _.omit(mockFixedRange, 'end'); expect(() => convertToFixedRange(aFixedRangeMissingEnd)).toThrow(); }); it('throws an error when fixed range does not contain a start time', () => { - const aFixedRangeMissingStart = _.omit(mockFixedRange(), 'start'); + const aFixedRangeMissingStart = _.omit(mockFixedRange, 'start'); expect(() => convertToFixedRange(aFixedRangeMissingStart)).toThrow(); }); it('throws an error when the dates cannot be parsed', () => { - const wrongStart = mockFixedRange({ start: 'I_CANNOT_BE_PARSED' }); - const wrongEnd = mockFixedRange({ end: 'I_CANNOT_BE_PARSED' }); + const wrongStart = { ...mockFixedRange, start: 'I_CANNOT_BE_PARSED' }; + const wrongEnd = { ...mockFixedRange, end: 'I_CANNOT_BE_PARSED' }; expect(() => convertToFixedRange(wrongStart)).toThrow(); expect(() => convertToFixedRange(wrongEnd)).toThrow(); @@ -82,97 +108,61 @@ describe('Date time range utils', () => { }); describe('When an anchored range is input', () => { - const defaultAnchoredRange = { - anchor: '2020-01-01T00:00:00.000Z', - direction: 'after', - duration: { - seconds: 60 * 2, - }, - label: 'First two minutes of 2020', - }; - const mockAnchoredRange = params => ({ ...defaultAnchoredRange, ...params }); - it('converts to a fixed range', () => { - const anAnchoredRange = mockAnchoredRange(); - - expect(convertToFixedRange(anAnchoredRange)).toEqual({ + expect(convertToFixedRange(mockAnchoredRange)).toEqual({ start: '2020-01-01T00:00:00.000Z', end: '2020-01-01T00:02:00.000Z', }); }); it('converts to a fixed range with a `before` direction', () => { - const anAnchoredRange = mockAnchoredRange({ direction: 'before' }); - - expect(convertToFixedRange(anAnchoredRange)).toEqual({ + expect(convertToFixedRange({ ...mockAnchoredRange, direction: 'before' })).toEqual({ start: '2019-12-31T23:58:00.000Z', end: '2020-01-01T00:00:00.000Z', }); }); it('converts to a fixed range without an explicit direction, defaulting to `before`', () => { - const anAnchoredRange = _.omit(mockAnchoredRange(), 'direction'); + const defaultDirectionRange = _.omit(mockAnchoredRange, 'direction'); - expect(convertToFixedRange(anAnchoredRange)).toEqual({ + expect(convertToFixedRange(defaultDirectionRange)).toEqual({ start: '2019-12-31T23:58:00.000Z', end: '2020-01-01T00:00:00.000Z', }); }); it('throws an error when the anchor cannot be parsed', () => { - const wrongAnchor = mockAnchoredRange({ anchor: 'I_CANNOT_BE_PARSED' }); + const wrongAnchor = { ...mockAnchoredRange, anchor: 'I_CANNOT_BE_PARSED' }; + expect(() => convertToFixedRange(wrongAnchor)).toThrow(); }); }); describe('when a rolling range is input', () => { it('converts to a fixed range', () => { - const aRollingRange = { - direction: 'after', - duration: { - seconds: 60 * 2, - }, - label: 'Next 2 minutes', - }; - - expect(convertToFixedRange(aRollingRange)).toEqual({ + expect(convertToFixedRange(mockRollingRange)).toEqual({ start: '2020-01-23T20:00:00.000Z', end: '2020-01-23T20:02:00.000Z', }); }); it('converts to a fixed range with an implicit `before` direction', () => { - const aRollingRangeWithNoDirection = { - duration: { - seconds: 60 * 2, - }, - label: 'Last 2 minutes', - }; + const noDirection = _.omit(mockRollingRange, 'direction'); - expect(convertToFixedRange(aRollingRangeWithNoDirection)).toEqual({ + expect(convertToFixedRange(noDirection)).toEqual({ start: '2020-01-23T19:58:00.000Z', end: '2020-01-23T20:00:00.000Z', }); }); it('throws an error when the duration is not in the right format', () => { - const wrongDuration = { - direction: 'before', - duration: { - minutes: 20, - }, - label: 'Last 20 minutes', - }; + const wrongDuration = { ...mockRollingRange, duration: { minutes: 20 } }; expect(() => convertToFixedRange(wrongDuration)).toThrow(); }); it('throws an error when the anchor is not valid', () => { - const wrongAnchor = { - anchor: 'CAN_T_PARSE_THIS', - direction: 'after', - label: '2020 so far', - }; + const wrongAnchor = { ...mockRollingRange, anchor: 'CAN_T_PARSE_THIS' }; expect(() => convertToFixedRange(wrongAnchor)).toThrow(); }); @@ -180,52 +170,213 @@ describe('Date time range utils', () => { describe('when an open range is input', () => { it('converts to a fixed range with an `after` direction', () => { - const soFar2020 = { - anchor: '2020-01-01T00:00:00.000Z', - direction: 'after', - label: '2020 so far', - }; - - expect(convertToFixedRange(soFar2020)).toEqual({ + expect(convertToFixedRange(mockOpenRange)).toEqual({ start: '2020-01-01T00:00:00.000Z', end: '2020-01-23T20:00:00.000Z', }); }); it('converts to a fixed range with the explicit `before` direction', () => { - const before2020 = { - anchor: '2020-01-01T00:00:00.000Z', - direction: 'before', - label: 'Before 2020', - }; + const beforeOpenRange = { ...mockOpenRange, direction: 'before' }; - expect(convertToFixedRange(before2020)).toEqual({ + expect(convertToFixedRange(beforeOpenRange)).toEqual({ start: '1970-01-01T00:00:00.000Z', end: '2020-01-01T00:00:00.000Z', }); }); it('converts to a fixed range with the implicit `before` direction', () => { - const alsoBefore2020 = { - anchor: '2020-01-01T00:00:00.000Z', - label: 'Before 2020', - }; + const noDirectionOpenRange = _.omit(mockOpenRange, 'direction'); - expect(convertToFixedRange(alsoBefore2020)).toEqual({ + expect(convertToFixedRange(noDirectionOpenRange)).toEqual({ start: '1970-01-01T00:00:00.000Z', end: '2020-01-01T00:00:00.000Z', }); }); it('throws an error when the anchor cannot be parsed', () => { - const wrongAnchor = { - anchor: 'CAN_T_PARSE_THIS', - direction: 'after', - label: '2020 so far', - }; + const wrongAnchor = { ...mockOpenRange, anchor: 'CAN_T_PARSE_THIS' }; expect(() => convertToFixedRange(wrongAnchor)).toThrow(); }); }); }); + + describe('isEqualTimeRanges', () => { + it('equal only compares relevant properies', () => { + expect( + isEqualTimeRanges( + { + ...mockFixedRange, + label: 'A label', + default: true, + }, + { + ...mockFixedRange, + label: 'Another label', + default: false, + anotherKey: 'anotherValue', + }, + ), + ).toBe(true); + + expect( + isEqualTimeRanges( + { + ...mockAnchoredRange, + label: 'A label', + default: true, + }, + { + ...mockAnchoredRange, + anotherKey: 'anotherValue', + }, + ), + ).toBe(true); + }); + }); + + describe('findTimeRange', () => { + const timeRanges = [ + { + label: 'Before 2020', + anchor: '2020-01-01T00:00:00.000Z', + }, + { + label: 'Last 30 minutes', + duration: { seconds: 60 * 30 }, + }, + { + label: 'In 2019', + start: '2019-01-01T00:00:00.000Z', + end: '2019-12-31T12:59:59.999Z', + }, + { + label: 'Next 2 minutes', + direction: 'after', + duration: { + seconds: 60 * 2, + }, + }, + ]; + + it('finds a time range', () => { + const tr0 = { + anchor: '2020-01-01T00:00:00.000Z', + }; + expect(findTimeRange(tr0, timeRanges)).toBe(timeRanges[0]); + + const tr1 = { + duration: { seconds: 60 * 30 }, + }; + expect(findTimeRange(tr1, timeRanges)).toBe(timeRanges[1]); + + const tr1Direction = { + direction: 'before', + duration: { + seconds: 60 * 30, + }, + }; + expect(findTimeRange(tr1Direction, timeRanges)).toBe(timeRanges[1]); + + const tr2 = { + someOtherLabel: 'Added arbitrarily', + start: '2019-01-01T00:00:00.000Z', + end: '2019-12-31T12:59:59.999Z', + }; + expect(findTimeRange(tr2, timeRanges)).toBe(timeRanges[2]); + + const tr3 = { + direction: 'after', + duration: { + seconds: 60 * 2, + }, + }; + expect(findTimeRange(tr3, timeRanges)).toBe(timeRanges[3]); + }); + + it('doesnot finds a missing time range', () => { + const nonExistant = { + direction: 'before', + duration: { + seconds: 200, + }, + }; + expect(findTimeRange(nonExistant, timeRanges)).toBeUndefined(); + }); + }); + + describe('conversion to/from params', () => { + const mockFixedParams = { + start: '2020-01-01T00:00:00.000Z', + end: '2020-01-31T23:59:00.000Z', + }; + + const mockAnchoredParams = { + anchor: '2020-01-01T00:00:00.000Z', + direction: 'after', + duration_seconds: '120', + }; + + const mockRollingParams = { + direction: 'after', + duration_seconds: '120', + }; + + describe('timeRangeToParams', () => { + it('converts fixed ranges to params', () => { + expect(timeRangeToParams(mockFixedRange)).toEqual(mockFixedParams); + }); + + it('converts anchored ranges to params', () => { + expect(timeRangeToParams(mockAnchoredRange)).toEqual(mockAnchoredParams); + }); + + it('converts rolling ranges to params', () => { + expect(timeRangeToParams(mockRollingRange)).toEqual(mockRollingParams); + }); + }); + + describe('timeRangeFromParams', () => { + it('converts fixed ranges from params', () => { + const params = { ...mockFixedParams, other_param: 'other_value' }; + const expectedRange = _.omit(mockFixedRange, 'label'); + + expect(timeRangeFromParams(params)).toEqual(expectedRange); + }); + + it('converts anchored ranges to params', () => { + const expectedRange = _.omit(mockRollingRange, 'label'); + + expect(timeRangeFromParams(mockRollingParams)).toEqual(expectedRange); + }); + + it('converts rolling ranges from params', () => { + const params = { ...mockRollingParams, other_param: 'other_value' }; + const expectedRange = _.omit(mockRollingRange, 'label'); + + expect(timeRangeFromParams(params)).toEqual(expectedRange); + }); + + it('converts rolling ranges from params with a default direction', () => { + const params = { + ...mockRollingParams, + direction: 'before', + other_param: 'other_value', + }; + const expectedRange = _.omit(mockRollingRange, 'label', 'direction'); + + expect(timeRangeFromParams(params)).toEqual(expectedRange); + }); + + it('converts to null when for no relevant params', () => { + const range = { + useless_param_1: 'value1', + useless_param_2: 'value2', + }; + + expect(timeRangeFromParams(range)).toBe(null); + }); + }); + }); }); diff --git a/spec/frontend/monitoring/utils_spec.js b/spec/frontend/monitoring/utils_spec.js index 9df48eb0ad3..2d9417bf971 100644 --- a/spec/frontend/monitoring/utils_spec.js +++ b/spec/frontend/monitoring/utils_spec.js @@ -1,13 +1,35 @@ import * as monitoringUtils from '~/monitoring/utils'; +import { queryToObject, mergeUrlParams, removeParams } from '~/lib/utils/url_utility'; import { + mockHost, + mockProjectDir, graphDataPrometheusQuery, graphDataPrometheusQueryRange, anomalyMockGraphData, } from './mock_data'; +jest.mock('~/lib/utils/url_utility'); + +const mockPath = `${mockHost}${mockProjectDir}/-/environments/29/metrics`; + +const generatedLink = 'http://chart.link.com'; + +const chartTitle = 'Some metric chart'; + +const range = { + start: '2019-01-01T00:00:00.000Z', + end: '2019-01-10T00:00:00.000Z', +}; + +const rollingRange = { + duration: { seconds: 120 }, +}; + describe('monitoring/utils', () => { - const generatedLink = 'http://chart.link.com'; - const chartTitle = 'Some metric chart'; + afterEach(() => { + mergeUrlParams.mockReset(); + queryToObject.mockReset(); + }); describe('trackGenerateLinkToChartEventOptions', () => { it('should return Cluster Monitoring options if located on Cluster Health Dashboard', () => { @@ -117,4 +139,75 @@ describe('monitoring/utils', () => { expect(monitoringUtils.graphDataValidatorForAnomalyValues(fourMetrics)).toBe(false); }); }); + + describe('timeRangeFromUrl', () => { + const { timeRangeFromUrl } = monitoringUtils; + + it('returns a fixed range when query contains `start` and `end` paramters are given', () => { + queryToObject.mockReturnValueOnce(range); + + expect(timeRangeFromUrl()).toEqual(range); + }); + + it('returns a rolling range when query contains `duration_seconds` paramters are given', () => { + const { seconds } = rollingRange.duration; + + queryToObject.mockReturnValueOnce({ + dashboard: '.gitlab/dashboard/my_dashboard.yml', + duration_seconds: `${seconds}`, + }); + + expect(timeRangeFromUrl()).toEqual(rollingRange); + }); + + it('returns null when no time range paramters are given', () => { + const params = { + dashboard: '.gitlab/dashboards/custom_dashboard.yml', + param1: 'value1', + param2: 'value2', + }; + + expect(timeRangeFromUrl(params, mockPath)).toBe(null); + }); + }); + + describe('removeTimeRangeParams', () => { + const { removeTimeRangeParams } = monitoringUtils; + + it('returns when query contains `start` and `end` paramters are given', () => { + removeParams.mockReturnValueOnce(mockPath); + + expect(removeTimeRangeParams(`${mockPath}?start=${range.start}&end=${range.end}`)).toEqual( + mockPath, + ); + }); + }); + + describe('timeRangeToUrl', () => { + const { timeRangeToUrl } = monitoringUtils; + + it('returns a fixed range when query contains `start` and `end` paramters are given', () => { + const toUrl = `${mockPath}?start=${range.start}&end=${range.end}`; + const fromUrl = mockPath; + + removeParams.mockReturnValueOnce(fromUrl); + mergeUrlParams.mockReturnValueOnce(toUrl); + + expect(timeRangeToUrl(range)).toEqual(toUrl); + expect(mergeUrlParams).toHaveBeenCalledWith(range, fromUrl); + }); + + it('returns a rolling range when query contains `duration_seconds` paramters are given', () => { + const { seconds } = rollingRange.duration; + + const toUrl = `${mockPath}?duration_seconds=${seconds}`; + const fromUrl = mockPath; + + removeParams.mockReturnValueOnce(fromUrl); + mergeUrlParams.mockReturnValueOnce(toUrl); + + expect(timeRangeToUrl(rollingRange)).toEqual(toUrl); + expect(mergeUrlParams).toHaveBeenCalledWith({ duration_seconds: `${seconds}` }, fromUrl); + }); + }); }); |