gitlab-org--gitlab-foss/spec/javascripts/behaviors/bind_in_out_spec.js

import BindInOut from '~/behaviors/bind_in_out';
import ClassSpecHelper from '../helpers/class_spec_helper';

describe('BindInOut', function() {
  describe('constructor', function() {
    beforeEach(function() {
      this.in = {};
      this.out = {};

      this.bindInOut = new BindInOut(this.in, this.out);
    });

    it('should set .in', function() {
      expect(this.bindInOut.in).toBe(this.in);
    });

    it('should set .out', function() {
      expect(this.bindInOut.out).toBe(this.out);
    });

    it('should set .eventWrapper', function() {
      expect(this.bindInOut.eventWrapper).toEqual({});
    });

    describe('if .in is an input', function() {
      beforeEach(function() {
        this.bindInOut = new BindInOut({ tagName: 'INPUT' });
      });

      it('should set .eventType to keyup ', function() {
        expect(this.bindInOut.eventType).toEqual('keyup');
      });
    });

    describe('if .in is a textarea', function() {
      beforeEach(function() {
        this.bindInOut = new BindInOut({ tagName: 'TEXTAREA' });
      });

      it('should set .eventType to keyup ', function() {
        expect(this.bindInOut.eventType).toEqual('keyup');
      });
    });

    describe('if .in is not an input or textarea', function() {
      beforeEach(function() {
        this.bindInOut = new BindInOut({ tagName: 'SELECT' });
      });

      it('should set .eventType to change ', function() {
        expect(this.bindInOut.eventType).toEqual('change');
      });
    });
  });

  describe('addEvents', function() {
    beforeEach(function() {
      this.in = jasmine.createSpyObj('in', ['addEventListener']);

      this.bindInOut = new BindInOut(this.in);

      this.addEvents = this.bindInOut.addEvents();
    });

    it('should set .eventWrapper.updateOut', function() {
      expect(this.bindInOut.eventWrapper.updateOut).toEqual(jasmine.any(Function));
    });

    it('should call .addEventListener', function() {
      expect(this.in.addEventListener).toHaveBeenCalledWith(
        this.bindInOut.eventType,
        this.bindInOut.eventWrapper.updateOut,
      );
    });

    it('should return the instance', function() {
      expect(this.addEvents).toBe(this.bindInOut);
    });
  });

  describe('updateOut', function() {
    beforeEach(function() {
      this.in = { value: 'the-value' };
      this.out = { textContent: 'not-the-value' };

      this.bindInOut = new BindInOut(this.in, this.out);

      this.updateOut = this.bindInOut.updateOut();
    });

    it('should set .out.textContent to .in.value', function() {
      expect(this.out.textContent).toBe(this.in.value);
    });

    it('should return the instance', function() {
      expect(this.updateOut).toBe(this.bindInOut);
    });
  });

  describe('removeEvents', function() {
    beforeEach(function() {
      this.in = jasmine.createSpyObj('in', ['removeEventListener']);
      this.updateOut = () => {};

      this.bindInOut = new BindInOut(this.in);
      this.bindInOut.eventWrapper.updateOut = this.updateOut;

      this.removeEvents = this.bindInOut.removeEvents();
    });

    it('should call .removeEventListener', function() {
      expect(this.in.removeEventListener).toHaveBeenCalledWith(
        this.bindInOut.eventType,
        this.updateOut,
      );
    });

    it('should return the instance', function() {
      expect(this.removeEvents).toBe(this.bindInOut);
    });
  });

  describe('initAll', function() {
    beforeEach(function() {
      this.ins = [0, 1, 2];
      this.instances = [];

      spyOn(document, 'querySelectorAll').and.returnValue(this.ins);
      spyOn(Array.prototype, 'map').and.callThrough();
      spyOn(BindInOut, 'init');

      this.initAll = BindInOut.initAll();
    });

    ClassSpecHelper.itShouldBeAStaticMethod(BindInOut, 'initAll');

    it('should call .querySelectorAll', function() {
      expect(document.querySelectorAll).toHaveBeenCalledWith('*[data-bind-in]');
    });

    it('should call .map', function() {
      expect(Array.prototype.map).toHaveBeenCalledWith(jasmine.any(Function));
    });

    it('should call .init for each element', function() {
      expect(BindInOut.init.calls.count()).toEqual(3);
    });

    it('should return an array of instances', function() {
      expect(this.initAll).toEqual(jasmine.any(Array));
    });
  });

  describe('init', function() {
    beforeEach(function() {
      spyOn(BindInOut.prototype, 'addEvents').and.callFake(function() {
        return this;
      });
      spyOn(BindInOut.prototype, 'updateOut').and.callFake(function() {
        return this;
      });

      this.init = BindInOut.init({}, {});
    });

    ClassSpecHelper.itShouldBeAStaticMethod(BindInOut, 'init');

    it('should call .addEvents', function() {
      expect(BindInOut.prototype.addEvents).toHaveBeenCalled();
    });

    it('should call .updateOut', function() {
      expect(BindInOut.prototype.updateOut).toHaveBeenCalled();
    });

    describe('if no anOut is provided', function() {
      beforeEach(function() {
        this.anIn = { dataset: { bindIn: 'the-data-bind-in' } };

        spyOn(document, 'querySelector');

        BindInOut.init(this.anIn);
      });

      it('should call .querySelector', function() {
        expect(document.querySelector).toHaveBeenCalledWith(
          `*[data-bind-out="${this.anIn.dataset.bindIn}"]`,
        );
      });
    });
  });
});