@gitlab/ui 80.13.0 → 80.13.2

package/src/components/base/filtered_search/filtered_search_suggestion.spec.js

@@ -1,67 +0,0 @@
-import { shallowMount } from '@vue/test-utils';
-import Vue from 'vue';
-import GlDropdownItem from '../dropdown/dropdown_item.vue';
-import FilteredSearchSuggestion from './filtered_search_suggestion.vue';
-
-describe('Filtered search suggestion component', () => {
-  let wrapper;
-  let listMock;
-
-  const createComponent = (value) => {
-    wrapper = shallowMount(FilteredSearchSuggestion, {
-      propsData: { value },
-      provide: {
-        filteredSearchSuggestionListInstance: listMock,
-      },
-    });
-  };
-
-  beforeEach(() => {
-    listMock = Vue.observable({
-      register: jest.fn(),
-      unregister: jest.fn(),
-      $emit: jest.fn(),
-      activeItem: null,
-    });
-  });
-
-  beforeAll(() => {
-    if (!HTMLElement.prototype.scrollIntoView) {
-      HTMLElement.prototype.scrollIntoView = jest.fn();
-    }
-  });
-
-  afterAll(() => {
-    if (HTMLElement.prototype.scrollIntoView.mock) {
-      delete HTMLElement.prototype.scrollIntoView;
-    }
-  });
-
-  it('registers in list instance when mounted', () => {
-    createComponent();
-    expect(listMock.register).toHaveBeenCalledWith(wrapper.vm);
-  });
-
-  it('unregisters in list instance when unmounted', () => {
-    createComponent();
-    wrapper.destroy();
-    expect(listMock.unregister).toHaveBeenCalledWith(wrapper.vm);
-  });
-
-  it('emits suggestion event on list instance when clicked', () => {
-    const value = 'demo';
-    createComponent(value);
-    wrapper.findComponent(GlDropdownItem).trigger('mousedown');
-    expect(listMock.$emit).toHaveBeenCalledWith('suggestion', value);
-  });
-
-  it('adds active class to dropdown when active in list', () => {
-    createComponent();
-    listMock.activeItem = wrapper.vm;
-    return wrapper.vm.$nextTick(() => {
-      expect(wrapper.findComponent(GlDropdownItem).classes()).toContain(
-        'gl-filtered-search-suggestion-active'
-      );
-    });
-  });
-});

package/src/components/base/filtered_search/filtered_search_suggestion.stories.js

@@ -1,33 +0,0 @@
-import GlFilteredSearchSuggestion from './filtered_search_suggestion.vue';
-import readme from './filtered_search_suggestion.md';
-
-const noop = () => {};
-
-export const Default = () => ({
-  components: { GlFilteredSearchSuggestion },
-  provide: {
-    filteredSearchSuggestionListInstance: {
-      register: noop,
-      unregister: noop,
-      $emit: noop,
-      activeItem: null,
-    },
-  },
-  template: `
-    <ul>
-      <gl-filtered-search-suggestion value="demo">Demo suggestion</gl-filtered-search-suggestion>
-    </ul>
-  `,
-});
-
-export default {
-  title: 'base/filtered-search/suggestion',
-  component: GlFilteredSearchSuggestion,
-  parameters: {
-    docs: {
-      description: {
-        component: readme,
-      },
-    },
-  },
-};

package/src/components/base/filtered_search/filtered_search_suggestion_list.spec.js

@@ -1,337 +0,0 @@
-import { nextTick } from 'vue';
-import { shallowMount, mount } from '@vue/test-utils';
-import FilteredSearchSuggestion from './filtered_search_suggestion.vue';
-import FilteredSearchSuggestionList from './filtered_search_suggestion_list.vue';
-
-describe('Filtered search suggestion list component', () => {
-  let wrapper;
-
-  describe('suggestions API', () => {
-    const createComponent = ({ termsAsTokens = false } = {}) => {
-      wrapper = shallowMount(FilteredSearchSuggestionList, {
-        provide: { suggestionsListClass: () => 'custom-class', termsAsTokens: () => termsAsTokens },
-      });
-    };
-
-    it('has expected public methods', () => {
-      createComponent();
-      expect(wrapper.vm.register).toBeInstanceOf(Function);
-      expect(wrapper.vm.unregister).toBeInstanceOf(Function);
-      expect(wrapper.vm.getValue).toBeInstanceOf(Function);
-      expect(wrapper.vm.nextItem).toBeInstanceOf(Function);
-      expect(wrapper.vm.prevItem).toBeInstanceOf(Function);
-    });
-
-    describe('navigation', () => {
-      const stubs = [{ value: 'stub1' }, { value: 'stub2' }, { value: 'stub3' }];
-      beforeEach(() => {
-        createComponent();
-        stubs.forEach((s) => {
-          wrapper.vm.register(s);
-        });
-      });
-
-      it('does not select item by default', () => {
-        expect(wrapper.vm.getValue()).toBe(null);
-      });
-
-      it('selects first item on nextItem call', async () => {
-        wrapper.vm.nextItem();
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe(stubs[0].value);
-      });
-
-      it('deselects first item on prevItem call', async () => {
-        wrapper.vm.nextItem();
-        wrapper.vm.prevItem();
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe(null);
-      });
-
-      it('deselects last item on nextItem call', async () => {
-        stubs.forEach(() => wrapper.vm.nextItem());
-        wrapper.vm.nextItem();
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe(null);
-      });
-
-      it('remove selection if suggestion is unregistered', async () => {
-        wrapper.vm.nextItem();
-        await nextTick();
-        wrapper.vm.unregister(stubs[0]);
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe(null);
-      });
-
-      it('selects correct suggestion when item (un)registration is late', async () => {
-        // Initially stub2 is at index 1.
-        await wrapper.setProps({ initialValue: 'stub2' });
-        // Remove item at index 0, so stub2 moves to index 0
-        wrapper.vm.unregister(stubs[0]);
-        await nextTick();
-        // stub2 should still be selected
-        expect(wrapper.vm.getValue()).toBe('stub2');
-      });
-    });
-
-    describe('navigation with termsAsTokens', () => {
-      const stubs = [{ value: 'stub1' }, { value: 'stub2' }, { value: 'stub3' }];
-      beforeEach(() => {
-        createComponent({ termsAsTokens: true });
-        stubs.forEach((s) => {
-          wrapper.vm.register(s);
-        });
-      });
-
-      it('does not select item by default', () => {
-        expect(wrapper.vm.getValue()).toBe(null);
-      });
-
-      it('selects first item on nextItem call', async () => {
-        wrapper.vm.nextItem();
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe(stubs[0].value);
-      });
-
-      it('wraps to last item on prevItem call', async () => {
-        wrapper.vm.nextItem();
-        wrapper.vm.prevItem();
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe(stubs[2].value);
-      });
-
-      it('wraps to first item on nextItem call', async () => {
-        stubs.forEach(() => wrapper.vm.nextItem());
-        wrapper.vm.nextItem();
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe(stubs[0].value);
-      });
-
-      it('remove selection if suggestion is unregistered', async () => {
-        wrapper.vm.nextItem();
-        await nextTick();
-        wrapper.vm.unregister(stubs[0]);
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe(null);
-      });
-
-      it('selects correct suggestion when item (un)registration is late', async () => {
-        // Initially stub2 is at index 1.
-        await wrapper.setProps({ initialValue: 'stub2' });
-        // Remove item at index 0, so stub2 moves to index 0
-        wrapper.vm.unregister(stubs[0]);
-        await nextTick();
-        // stub2 should still be selected
-        expect(wrapper.vm.getValue()).toBe('stub2');
-      });
-    });
-  });
-
-  describe('integration tests', () => {
-    const list = {
-      components: {
-        GlFilteredSearchSuggestion: FilteredSearchSuggestion,
-      },
-      template: `
-        <div>
-          <gl-filtered-search-suggestion value="One">One</gl-filtered-search-suggestion>
-          <gl-filtered-search-suggestion value="Two">Two</gl-filtered-search-suggestion>
-          <gl-filtered-search-suggestion :value="false">Three</gl-filtered-search-suggestion>
-        </div>
-      `,
-    };
-
-    const createComponent = ({ termsAsTokens = false } = {}) => {
-      wrapper = mount(FilteredSearchSuggestionList, {
-        provide: { suggestionsListClass: () => 'custom-class', termsAsTokens: () => termsAsTokens },
-        slots: {
-          default: list,
-        },
-      });
-    };
-
-    const findActiveSuggestion = () => wrapper.find('.gl-filtered-search-suggestion-active');
-
-    beforeAll(() => {
-      if (!HTMLElement.prototype.scrollIntoView) {
-        HTMLElement.prototype.scrollIntoView = jest.fn();
-      }
-    });
-
-    afterAll(() => {
-      if (HTMLElement.prototype.scrollIntoView.mock) {
-        delete HTMLElement.prototype.scrollIntoView;
-      }
-    });
-
-    describe('with termsAsTokens = false', () => {
-      beforeEach(() => {
-        createComponent();
-      });
-
-      it('selects first suggestion', async () => {
-        wrapper.vm.nextItem();
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe('One');
-      });
-
-      it('selects second suggestion', async () => {
-        wrapper.vm.nextItem();
-        wrapper.vm.nextItem();
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe('Two');
-      });
-
-      it('deselects first suggestion after list end', async () => {
-        wrapper.vm.nextItem();
-        wrapper.vm.nextItem();
-        wrapper.vm.nextItem();
-        wrapper.vm.nextItem();
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe(null);
-      });
-
-      it('deselects first suggestion after list start', async () => {
-        wrapper.vm.nextItem();
-        wrapper.vm.prevItem();
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe(null);
-      });
-
-      it('selects last suggestion in circle when selecting previous item', async () => {
-        wrapper.vm.nextItem();
-        wrapper.vm.prevItem();
-        wrapper.vm.prevItem();
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe(false);
-      });
-
-      it('selects first suggestion in circle when selecting next item', async () => {
-        wrapper.vm.nextItem();
-        wrapper.vm.nextItem();
-        wrapper.vm.nextItem();
-        wrapper.vm.nextItem();
-        wrapper.vm.nextItem();
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe('One');
-      });
-
-      it('highlights suggestion if initial-value is provided', async () => {
-        await wrapper.setProps({ initialValue: 'Two' });
-        expect(findActiveSuggestion().text()).toBe('Two');
-      });
-
-      it('highlights suggestion if initial-value is provided, regardless of case sensitivity', async () => {
-        await wrapper.setProps({ initialValue: 'two' });
-        expect(findActiveSuggestion().text()).toBe('Two');
-      });
-
-      it('highlights suggestion if initial-value is provided, regardless of falsiness', async () => {
-        await wrapper.setProps({ initialValue: false });
-        expect(findActiveSuggestion().text()).toBe('Three');
-      });
-
-      it('highlights first suggestion if initial-value is provided, deselected then selected', async () => {
-        await wrapper.setProps({ initialValue: 'One' });
-        wrapper.vm.prevItem();
-        wrapper.vm.nextItem();
-        await nextTick();
-        expect(findActiveSuggestion().text()).toBe('One');
-      });
-
-      it('does not highlight anything if initial-value matches nothing', async () => {
-        await wrapper.setProps({ initialValue: 'missing' });
-        expect(findActiveSuggestion().exists()).toBe(false);
-      });
-
-      it('applies the injected suggestion-list-class to the dropdown', () => {
-        expect(wrapper.classes()).toContain('custom-class');
-      });
-    });
-
-    describe('with termsAsTokens = true', () => {
-      beforeEach(() => {
-        createComponent({ termsAsTokens: true });
-      });
-
-      it('selects first suggestion', async () => {
-        wrapper.vm.nextItem();
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe('One');
-      });
-
-      it('selects second suggestion', async () => {
-        wrapper.vm.nextItem();
-        wrapper.vm.nextItem();
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe('Two');
-      });
-
-      it('wraps to first suggestion after list end', async () => {
-        wrapper.vm.nextItem();
-        wrapper.vm.nextItem();
-        wrapper.vm.nextItem();
-        wrapper.vm.nextItem();
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe('One');
-      });
-
-      it('wraps to last suggestion before list start', async () => {
-        wrapper.vm.nextItem();
-        wrapper.vm.prevItem();
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe(false);
-      });
-
-      it('selects second-to-last suggestion in circle when selecting previous item', async () => {
-        wrapper.vm.nextItem();
-        wrapper.vm.prevItem();
-        wrapper.vm.prevItem();
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe('Two');
-      });
-
-      it('selects second suggestion in circle when selecting next item', async () => {
-        wrapper.vm.nextItem();
-        wrapper.vm.nextItem();
-        wrapper.vm.nextItem();
-        wrapper.vm.nextItem();
-        wrapper.vm.nextItem();
-        await nextTick();
-        expect(wrapper.vm.getValue()).toBe('Two');
-      });
-
-      it('highlights suggestion if initial-value is provided', async () => {
-        await wrapper.setProps({ initialValue: 'Two' });
-        expect(findActiveSuggestion().text()).toBe('Two');
-      });
-
-      it('highlights suggestion if initial-value is provided, regardless of case sensitivity', async () => {
-        await wrapper.setProps({ initialValue: 'two' });
-        expect(findActiveSuggestion().text()).toBe('Two');
-      });
-
-      it('highlights suggestion if initial-value is provided, regardless of falsiness', async () => {
-        await wrapper.setProps({ initialValue: false });
-        expect(findActiveSuggestion().text()).toBe('Three');
-      });
-
-      it('highlights first suggestion if initial-value is provided, deselected then selected', async () => {
-        await wrapper.setProps({ initialValue: 'One' });
-        wrapper.vm.prevItem();
-        wrapper.vm.nextItem();
-        await nextTick();
-        expect(findActiveSuggestion().text()).toBe('One');
-      });
-
-      it('does not highlight anything if initial-value matches nothing', async () => {
-        await wrapper.setProps({ initialValue: 'missing' });
-        expect(findActiveSuggestion().exists()).toBe(false);
-      });
-
-      it('applies the injected suggestion-list-class to the dropdown', () => {
-        expect(wrapper.classes()).toContain('custom-class');
-      });
-    });
-  });
-});

package/src/components/base/filtered_search/filtered_search_suggestion_list.stories.js

@@ -1,53 +0,0 @@
-import { userEvent, within } from '@storybook/test';
-import GlFilteredSearchSuggestionList from './filtered_search_suggestion_list.vue';
-import GlFilteredSearchSuggestion from './filtered_search_suggestion.vue';
-import { provide } from './common_story_options';
-import readme from './filtered_search_suggestion_list.md';
-
-export const Default = () => ({
-  components: { GlFilteredSearchSuggestionList, GlFilteredSearchSuggestion },
-  data() {
-    return {
-      iteration: 1,
-      items: Array.from({ length: 5 }).map((_, idx) => `item-${idx}-iteration-1`),
-    };
-  },
-  provide,
-  methods: {
-    change() {
-      this.iteration += 1;
-      this.items = Array.from({ length: 3 + Math.floor(Math.random() * 5) }).map(
-        (_, idx) => `item-${idx}-iteration-${this.iteration}`
-      );
-    },
-  },
-  template: `
-      <div>
-        <button @click="$refs.suggestions.prevItem()">prev</button>
-        <button @click="$refs.suggestions.nextItem()">next</button>
-        <button @click="change">replace suggestions in list</button>
-        <gl-filtered-search-suggestion-list ref="suggestions" style="float: none; position: relative;">
-          <gl-filtered-search-suggestion v-for="item in items" :key="item" :value="item">
-            {{item}}
-          </gl-filtered-search-suggestion>
-        </gl-filtered-search-suggestion-list>
-      </div>
-    `,
-});
-Default.play = async ({ canvasElement }) => {
-  const canvas = within(canvasElement);
-  const button = canvas.getByRole('button', { name: 'next' });
-  await userEvent.click(button);
-};
-
-export default {
-  title: 'base/filtered-search/suggestion-list',
-  component: GlFilteredSearchSuggestionList,
-  parameters: {
-    docs: {
-      description: {
-        component: readme,
-      },
-    },
-  },
-};

package/src/components/base/filtered_search/filtered_search_term.spec.js

@@ -1,212 +0,0 @@
-import { nextTick } from 'vue';
-import { shallowMount } from '@vue/test-utils';
-import GlToken from '../token/token.vue';
-import FilteredSearchTerm from './filtered_search_term.vue';
-import { INTENT_ACTIVATE_PREVIOUS, TERM_TOKEN_TYPE } from './filtered_search_utils';
-
-const availableTokens = [
-  { type: 'foo', title: 'test1-foo', token: 'stub', icon: 'eye' },
-  { type: 'bar', title: 'test2-bar', token: 'stub', icon: 'eye' },
-  { type: 'baz', title: 'test1-baz', token: 'stub', icon: 'eye' },
-];
-
-const pointerClass = 'gl-cursor-pointer';
-
-describe('Filtered search term', () => {
-  let wrapper;
-
-  const searchInputAttributes = { 'data-testid': 'foo-bar', 'data-prop': 'foo-property' };
-
-  const defaultProps = {
-    availableTokens: [],
-    cursorPosition: 'end',
-  };
-
-  const segmentStub = {
-    name: 'gl-filtered-search-token-segment-stub',
-    template: '<div><slot v-if="!active" name="view"></slot><slot name="suggestions"></slot></div>',
-    props: [
-      'searchInputAttributes',
-      'isLastToken',
-      'currentValue',
-      'viewOnly',
-      'options',
-      'active',
-    ],
-  };
-
-  const createComponent = ({ termsAsTokens = false, ...props } = {}) => {
-    wrapper = shallowMount(FilteredSearchTerm, {
-      propsData: { ...defaultProps, ...props },
-      provide: {
-        termsAsTokens: () => termsAsTokens,
-      },
-      stubs: {
-        'gl-filtered-search-token-segment': segmentStub,
-      },
-    });
-  };
-
-  const findSearchInput = () => wrapper.find('input');
-  const findTokenSegmentComponent = () => wrapper.findComponent(segmentStub);
-  const findToken = () => wrapper.findComponent(GlToken);
-
-  it('renders value in inactive mode', () => {
-    createComponent({ value: { data: 'test-value' } });
-    expect(wrapper.html()).toMatchSnapshot();
-  });
-
-  it('renders token in inactive mode with termsAsTokens', () => {
-    createComponent({ value: { data: 'test value' }, termsAsTokens: true });
-    expect(findToken().exists()).toBe(true);
-    expect(findToken().props().viewOnly).toBe(false);
-    expect(findToken().classes()).toContain(pointerClass);
-    expect(findToken().text()).toBe('test value');
-  });
-
-  it('renders nothing with value in active mode (delegates to segment)', () => {
-    createComponent({ value: { data: 'test-value' }, active: true });
-    expect(wrapper.text()).not.toContain('test-value');
-    expect(wrapper.html()).toMatchSnapshot();
-  });
-
-  it('renders input with placeholder if placeholder prop is provided', () => {
-    createComponent({ placeholder: 'placeholder-stub' });
-    expect(findSearchInput().attributes('placeholder')).toBe('placeholder-stub');
-  });
-
-  it('filters suggestions by input', async () => {
-    createComponent({ availableTokens, active: true, value: { data: 'test1' } });
-
-    await nextTick();
-
-    expect(findTokenSegmentComponent().props('options')).toHaveLength(2);
-  });
-
-  it('suggests text search when termsAsTokens=true', async () => {
-    createComponent({
-      availableTokens,
-      active: true,
-      value: { data: 'foo' },
-      termsAsTokens: true,
-    });
-
-    await nextTick();
-
-    expect(findTokenSegmentComponent().props('options')).toEqual([
-      expect.objectContaining({
-        value: 'foo',
-        title: 'test1-foo',
-      }),
-      expect.objectContaining({
-        value: TERM_TOKEN_TYPE,
-        title: 'Search for this text',
-      }),
-    ]);
-  });
-
-  it.each`
-    originalEvent   | originalPayload    | emittedEvent    | payload
-    ${'activate'}   | ${undefined}       | ${'activate'}   | ${undefined}
-    ${'deactivate'} | ${undefined}       | ${'deactivate'} | ${undefined}
-    ${'split'}      | ${'foo'}           | ${'split'}      | ${'foo'}
-    ${'submit'}     | ${undefined}       | ${'submit'}     | ${undefined}
-    ${'previous'}   | ${undefined}       | ${'previous'}   | ${undefined}
-    ${'next'}       | ${undefined}       | ${'next'}       | ${undefined}
-    ${'complete'}   | ${'foo'}           | ${'replace'}    | ${{ type: 'foo' }}
-    ${'complete'}   | ${TERM_TOKEN_TYPE} | ${'complete'}   | ${undefined}
-    ${'backspace'}  | ${undefined}       | ${'destroy'}    | ${{ intent: INTENT_ACTIVATE_PREVIOUS }}
-  `(
-    'emits $emittedEvent when token segment emits $originalEvent',
-    async ({ originalEvent, originalPayload, emittedEvent, payload }) => {
-      createComponent({ active: true, value: { data: 'something' } });
-
-      findTokenSegmentComponent().vm.$emit(originalEvent, originalPayload);
-
-      await nextTick();
-
-      expect(wrapper.emitted(emittedEvent)).toHaveLength(1);
-
-      if (payload !== undefined) {
-        expect(wrapper.emitted(emittedEvent)[0][0]).toEqual(payload);
-      }
-    }
-  );
-
-  it('passes `searchInputAttributes`, `isLastToken`, `currentValue` & `viewOnly` props to `GlFilteredSearchTokenSegment`', () => {
-    const isLastToken = true;
-    const viewOnly = true;
-    const currentValue = [
-      { type: 'filtered-search-term', value: { data: 'something' } },
-      { type: 'filtered-search-term', value: { data: '' } },
-    ];
-
-    createComponent({
-      value: { data: 'something' },
-      searchInputAttributes,
-      isLastToken,
-      currentValue,
-      viewOnly,
-    });
-
-    expect(findTokenSegmentComponent().props()).toEqual(
-      expect.objectContaining({
-        searchInputAttributes,
-        isLastToken,
-        currentValue,
-        viewOnly,
-      })
-    );
-  });
-
-  it('by default sets `viewOnly` to false on `GlFilteredSearchTokenSegment`', () => {
-    createComponent();
-
-    expect(findTokenSegmentComponent().props('viewOnly')).toBe(false);
-  });
-
-  it('sets viewOnly prop and removes pointer class on token when termsAsTokens=true', () => {
-    createComponent({
-      value: { data: 'foo' },
-      viewOnly: true,
-      termsAsTokens: true,
-    });
-
-    expect(findToken().props().viewOnly).toBe(true);
-    expect(findToken().classes()).not.toContain(pointerClass);
-  });
-
-  it('adds `searchInputAttributes` prop to search term input', () => {
-    createComponent({
-      placeholder: 'placeholder-stub',
-      searchInputAttributes,
-    });
-
-    expect(findSearchInput().attributes('data-prop')).toBe(searchInputAttributes['data-prop']);
-  });
-
-  it('activates and deactivates when the input is focused/blurred', async () => {
-    createComponent({ placeholder: 'placeholder-stub' });
-    await nextTick();
-
-    expect(wrapper.emitted()).toEqual({});
-
-    await findSearchInput().trigger('focusin');
-
-    expect(wrapper.emitted()).toEqual({ activate: [[]] });
-
-    await findSearchInput().trigger('focusout');
-
-    expect(wrapper.emitted()).toEqual({ activate: [[]], deactivate: [[]] });
-  });
-
-  describe.each([true, false])('when `viewOnly` is %s', (viewOnly) => {
-    beforeEach(() => {
-      createComponent({ viewOnly, searchInputAttributes, placeholder: 'placeholder-stub' });
-    });
-
-    it(`${viewOnly ? 'adds' : 'does not add'} \`gl-bg-gray-10\` class to search term input`, () => {
-      expect(findSearchInput().classes('gl-bg-gray-10')).toBe(viewOnly);
-    });
-  });
-});