open-nomad/ui/tests/unit/mixins/searchable-test.js

import { alias } from '@ember/object/computed';
import EmberObject, { computed } from '@ember/object';
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
import Searchable from 'nomad-ui/mixins/searchable';

module('Unit | Mixin | Searchable', function(hooks) {
  setupTest(hooks);

  hooks.beforeEach(function() {
    this.subject = function() {
      // eslint-disable-next-line ember/no-new-mixins
      const SearchableObject = EmberObject.extend(Searchable, {
        source: null,
        searchProps: computed(function() {
          return ['id', 'name'];
        }),
        listToSearch: alias('source'),
      });

      this.owner.register('test-container:searchable-object', SearchableObject);
      return this.owner.lookup('test-container:searchable-object');
    };
  });

  test('the searchable mixin does nothing when there is no search term', function(assert) {
    const subject = this.subject();
    subject.set('source', [{ id: '1', name: 'hello' }, { id: '2', name: 'world' }]);

    assert.deepEqual(subject.get('listSearched'), subject.get('source'));
  });

  test('the searchable mixin allows for regex search', function(assert) {
    const subject = this.subject();
    subject.set('source', [
      { id: '1', name: 'hello' },
      { id: '2', name: 'world' },
      { id: '3', name: 'oranges' },
    ]);

    subject.set('searchTerm', '.+l+[A-Z]$');
    assert.deepEqual(
      subject.get('listSearched'),
      [{ id: '1', name: 'hello' }, { id: '2', name: 'world' }],
      'hello and world matched for regex'
    );
  });

  test('the searchable mixin only searches the declared search props', function(assert) {
    const subject = this.subject();
    subject.set('source', [
      { id: '1', name: 'United States of America', continent: 'North America' },
      { id: '2', name: 'Canada', continent: 'North America' },
      { id: '3', name: 'Mexico', continent: 'North America' },
    ]);

    subject.set('searchTerm', 'America');
    assert.deepEqual(
      subject.get('listSearched'),
      [{ id: '1', name: 'United States of America', continent: 'North America' }],
      'Only USA matched, since continent is not a search prop'
    );
  });

  test('the fuzzy search mode is off by default', function(assert) {
    const subject = this.subject();
    subject.set('source', [
      { id: '1', name: 'United States of America', continent: 'North America' },
      { id: '2', name: 'Canada', continent: 'North America' },
      { id: '3', name: 'Mexico', continent: 'North America' },
    ]);

    subject.set('searchTerm', 'Ameerica');
    assert.deepEqual(
      subject.get('listSearched'),
      [],
      'Nothing is matched since America is spelled incorrectly'
    );
  });

  test('the fuzzy search mode can be enabled', function(assert) {
    const subject = this.subject();
    subject.set('source', [
      { id: '1', name: 'United States of America', continent: 'North America' },
      { id: '2', name: 'Canada', continent: 'North America' },
      { id: '3', name: 'Mexico', continent: 'North America' },
    ]);

    subject.set('fuzzySearchEnabled', true);
    subject.set('searchTerm', 'Ameerica');
    assert.deepEqual(
      subject.get('listSearched'),
      [{ id: '1', name: 'United States of America', continent: 'North America' }],
      'America is matched due to fuzzy matching'
    );
  });

  test('the fuzzy search can include match results', function(assert) {
    const subject = this.subject();
    subject.set('source', [
      EmberObject.create({ id: '1', name: 'United States of America', continent: 'North America' }),
      EmberObject.create({ id: '2', name: 'Canada', continent: 'North America' }),
      EmberObject.create({ id: '3', name: 'Mexico', continent: 'North America' }),
    ]);

    subject.set('fuzzySearchEnabled', true);
    subject.set('includeFuzzySearchMatches', true);
    subject.set('searchTerm', 'Ameerica');
    assert.deepEqual(
      subject
        .get('listSearched')
        .map(object => object.getProperties('id', 'name', 'continent', 'fuzzySearchMatches')),
      [
        {
          id: '1',
          name: 'United States of America',
          continent: 'North America',
          fuzzySearchMatches: [
            {
              indices: [[2, 2], [4, 4], [9, 9], [11, 11], [17, 23]],
              value: 'United States of America',
              key: 'name',
            },
          ],
        },
      ],
      'America is matched due to fuzzy matching'
    );
  });

  test('the exact match search mode can be disabled', function(assert) {
    const subject = this.subject();
    subject.set('source', [
      { id: '1', name: 'United States of America', continent: 'North America' },
      { id: '2', name: 'Canada', continent: 'North America' },
      { id: '3', name: 'Mexico', continent: 'North America' },
    ]);

    subject.set('regexSearchProps', []);
    subject.set('searchTerm', 'Mexico');

    assert.deepEqual(
      subject.get('listSearched'),
      [{ id: '3', name: 'Mexico', continent: 'North America' }],
      'Mexico is matched exactly'
    );

    subject.set('exactMatchEnabled', false);

    assert.deepEqual(
      subject.get('listSearched'),
      [],
      'Nothing is matched now that exactMatch is disabled'
    );
  });

  test('the regex search mode can be disabled', function(assert) {
    const subject = this.subject();
    subject.set('source', [
      { id: '1', name: 'United States of America', continent: 'North America' },
      { id: '2', name: 'Canada', continent: 'North America' },
      { id: '3', name: 'Mexico', continent: 'North America' },
    ]);

    subject.set('searchTerm', '^.{6}$');
    assert.deepEqual(
      subject.get('listSearched'),
      [
        { id: '2', name: 'Canada', continent: 'North America' },
        { id: '3', name: 'Mexico', continent: 'North America' },
      ],
      'Canada and Mexico meet the regex criteria'
    );

    subject.set('regexEnabled', false);

    assert.deepEqual(
      subject.get('listSearched'),
      [],
      'Nothing is matched now that regex is disabled'
    );
  });

  test('each search mode has independent search props', function(assert) {
    const subject = this.subject();
    subject.set('source', [
      { id: '1', name: 'United States of America', continent: 'North America' },
      { id: '2', name: 'Canada', continent: 'North America' },
      { id: '3', name: 'Mexico', continent: 'North America' },
    ]);

    subject.set('fuzzySearchEnabled', true);
    subject.set('regexSearchProps', ['id']);
    subject.set('exactMatchSearchProps', ['continent']);
    subject.set('fuzzySearchProps', ['name']);

    subject.set('searchTerm', 'Nor America');
    assert.deepEqual(
      subject.get('listSearched'),
      [],
      'Not an exact match on continent, not a matchAllTokens match on fuzzy, not a regex match on id'
    );

    subject.set('searchTerm', 'America States');
    assert.deepEqual(
      subject.get('listSearched'),
      [{ id: '1', name: 'United States of America', continent: 'North America' }],
      'Fuzzy match on one country, but not an exact match on continent'
    );

    subject.set('searchTerm', '^(.a){3}$');
    assert.deepEqual(
      subject.get('listSearched'),
      [],
      'Canada is not matched by the regex because only id is looked at for regex search'
    );
  });

  test('the resetPagination method is a no-op', function(assert) {
    const subject = this.subject();
    assert.strictEqual(subject.get('currentPage'), undefined, 'No currentPage value set');
    subject.resetPagination();
    assert.strictEqual(subject.get('currentPage'), undefined, 'Still no currentPage value set');
  });
});

module('Unit | Mixin | Searchable (with pagination)', function(hooks) {
  setupTest(hooks);

  hooks.beforeEach(function() {
    this.subject = function() {
      // eslint-disable-next-line ember/no-new-mixins
      const SearchablePaginatedObject = EmberObject.extend(Searchable, {
        source: null,
        searchProps: computed(function() {
          return ['id', 'name'];
        }),
        listToSearch: alias('source'),
        currentPage: 1,
      });

      this.owner.register('test-container:searchable-paginated-object', SearchablePaginatedObject);
      return this.owner.lookup('test-container:searchable-paginated-object');
    };
  });

  test('the resetPagination method sets the currentPage to 1', function(assert) {
    const subject = this.subject();
    subject.set('currentPage', 5);
    assert.equal(subject.get('currentPage'), 5, 'Current page is something other than 1');
    subject.resetPagination();
    assert.equal(subject.get('currentPage'), 1, 'Current page gets reset to 1');
  });
});