admin-lte 2.4.12 → 2.4.18

package/bower_components/seiyria-bootstrap-slider/test/specs/AccessibilitySpec.js

@@ -0,0 +1,67 @@
+describe("Accessibility Tests", function() {
+  var sliderA;
+  var sliderB;
+
+  it("Should have the slider role", function() {
+    sliderA = $('#accessibilitySliderA').slider();
+    sliderB = $('#accessibilitySliderB').slider();
+    var $sliderElementA = $(sliderA.slider('getElement'));
+    var $sliderElementB = $(sliderB.slider('getElement'));
+
+    expect($sliderElementA.find('.min-slider-handle').attr('role')).toBe('slider');
+    expect($sliderElementB.find('.min-slider-handle').attr('role')).toBe('slider');
+    expect($sliderElementB.find('.max-slider-handle').attr('role')).toBe('slider');
+
+    expect($sliderElementA.find('.tooltip-main').attr('role')).toBe('presentation');
+    expect($sliderElementA.find('.tooltip-min').attr('role')).toBe('presentation');
+    expect($sliderElementA.find('.tooltip-max').attr('role')).toBe('presentation');
+  });
+
+  it('Should have an aria-labelledby attribute', function() {
+    sliderA = $('#accessibilitySliderA').slider();
+    sliderB = $('#accessibilitySliderB').slider();
+
+    expect($(sliderA.slider('getElement')).find('.min-slider-handle').attr('aria-labelledby')).toBe('accessibilitySliderLabelA');
+    expect($(sliderB.slider('getElement')).find('.min-slider-handle').attr('aria-labelledby')).toBe('accessibilitySliderLabelA');
+    expect($(sliderB.slider('getElement')).find('.max-slider-handle').attr('aria-labelledby')).toBe('accessibilitySliderLabelB');
+  });
+
+  it('Should have an aria-valuemax and aria-valuemin value', function() {
+    sliderA = $('#accessibilitySliderA').slider({ min: 5, max: 10 });
+    sliderB = $('#accessibilitySliderB').slider({ min: 5, max: 10 });
+    var $sliderElementA = $(sliderA.slider('getElement'));
+    var $sliderElementB = $(sliderB.slider('getElement'));
+
+    expect($sliderElementA.find('.min-slider-handle').attr('aria-valuemin')).toBe('5');
+    expect($sliderElementA.find('.min-slider-handle').attr('aria-valuemax')).toBe('10');
+    expect($sliderElementB.find('.min-slider-handle').attr('aria-valuemin')).toBe('5');
+    expect($sliderElementB.find('.min-slider-handle').attr('aria-valuemax')).toBe('10');
+    expect($sliderElementB.find('.max-slider-handle').attr('aria-valuemin')).toBe('5');
+    expect($sliderElementB.find('.max-slider-handle').attr('aria-valuemax')).toBe('10');
+  });
+
+  it('Should have an aria-valuenow with the current value', function() {
+    sliderA = $('#accessibilitySliderA').slider({ min: 5, value: 7 });
+    sliderB = $('#accessibilitySliderB').slider({ min: 5, value: [2, 8] });
+    var $sliderElementA = $(sliderA.slider('getElement'));
+    var $sliderElementB = $(sliderB.slider('getElement'));
+
+    expect($sliderElementA.find('.min-slider-handle').attr('aria-valuenow')).toBe('7');
+    expect($sliderElementB.find('.min-slider-handle').attr('aria-valuenow')).toBe('5');
+    expect($sliderElementB.find('.max-slider-handle').attr('aria-valuenow')).toBe('8');
+
+    // Change the value and check if aria-valuenow is still the same
+    sliderA.slider('setValue', 1);
+    sliderB.slider('setValue', [4, 9]);
+
+    expect($sliderElementA.find('.min-slider-handle').attr('aria-valuenow')).toBe('5');
+    expect($sliderElementB.find('.min-slider-handle').attr('aria-valuenow')).toBe('5');
+    expect($sliderElementB.find('.max-slider-handle').attr('aria-valuenow')).toBe('9');
+  });
+
+  afterEach(function() {
+    if(sliderA) { sliderA.slider('destroy'); }
+    if(sliderB) { sliderB.slider('destroy'); }
+  });
+
+});

package/bower_components/seiyria-bootstrap-slider/test/specs/AriaValueTextFormatterSpec.js

@@ -0,0 +1,114 @@
+describe("Aria-valuetext Tests", function() {
+      it("Sets the aria-valuetext to 'formatter' value", function() {
+      var textValArrayA = new Array('Monday','Wednesday','Friday');
+      var tooltipFormatterA = function(value) {
+        var arrActiveValueA = value;
+        return textValArrayA[arrActiveValueA-1];
+      };
+      
+      //Formatter is used
+      var testSliderA = $("#accessibilitySliderA").slider({
+        formatter : tooltipFormatterA
+      });
+      testSliderA.slider('setValue', 2);
+      
+      var tooltipMessageA = $("#accessibilitySliderA").prev(".slider").children(".min-slider-handle").attr("aria-valuetext");
+      var expectedMessageA = tooltipFormatterA(2);
+      expect(tooltipMessageA).toBe(expectedMessageA);
+
+      $("#accessibilitySliderA").slider('destroy');
+    });
+    
+    it("Does not use aria-valuetext if 'formatter' is not used", function() {
+    	  
+      //Formatter is not used  
+      var testSliderB = $("#accessibilitySliderB").slider({});
+      testSliderB.slider('setValue', 1);
+    
+      var ariaValueTextB = $("#accessibilitySliderB").prev(".slider").children(".min-slider-handle").attr("aria-valuetext");
+      expect(ariaValueTextB).not.toBeDefined();
+
+      $("#accessibilitySliderB").slider('destroy');
+    });
+    
+    it("aria-valuetext if 'formatter' is used and has min & max value", function() {
+      var textValArrayC = new Array('Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday');
+      var tooltipFormatterC = function(value) {
+          if(value[1]){
+            var arrActiveValueC0 = value[0];
+            var arrActiveValueC1 = value[1];  
+            return [ textValArrayC[arrActiveValueC0-1], textValArrayC[arrActiveValueC1-1] ];
+          } else {
+          	var arrActiveValueC = value;
+  			return textValArrayC[arrActiveValueC-1];
+          }
+      };
+      
+      //Formatter is used for ranges
+      var testSliderC = $("#accessibilitySliderC").slider({
+        range: true,
+        formatter : tooltipFormatterC
+      });
+      var valuesToSet = [2,4];
+      testSliderC.slider('setValue', valuesToSet);
+      var expectedMessageC = tooltipFormatterC([2,4]);
+      var ttminMessage = $("#accessibilitySliderC").prev(".slider").children(".min-slider-handle").attr("aria-valuetext");
+      var ttmaxMessage = $("#accessibilitySliderC").prev(".slider").children(".max-slider-handle").attr("aria-valuetext");
+      expect(ttminMessage).toBe(expectedMessageC[0]);
+      expect(ttmaxMessage).toBe(expectedMessageC[1]);
+
+      $('#accessibilitySliderC').slider('destroy');
+    });
+
+    describe("Unset 'aria-valuetext' attribute when value can be represented as a number", function() {
+      var $testSliderC;
+      var dayOfWeek;
+
+      var dayFormatter = function(value) {
+        if (value[1]) {
+          return [ dayOfWeek[value[0]-1], dayOfWeek[value[1]-1] ];
+        }
+        return dayOfWeek[value-1];
+      };
+
+      beforeEach(function() {
+        dayOfWeek = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'];
+
+        $testSliderC = $('#accessibilitySliderC').slider({
+          id: 'testAccessbilitySlider',
+          min: 1,
+          max: 7,
+          formatter : dayFormatter
+        });
+      });
+
+      afterEach(function() {
+        if ($testSliderC) {
+          $testSliderC.slider('destroy');
+        }
+      });
+
+      it("Should unset 'aria-valuetext' attribute", function() {
+        dayOfWeek[0] = '1';
+
+        var valueToSet = 1;
+        $testSliderC.slider('setValue', valueToSet);
+        var ariaValueText = $('#testAccessbilitySlider').find('.min-slider-handle')[0].getAttribute('aria-valuetext');
+        expect(ariaValueText).toBeNull();
+      });
+
+      it("Should unset 'aria-valuetext' attributes for range sliders", function() {
+        dayOfWeek[0] = '1';
+        dayOfWeek[6] = '7';
+        $testSliderC.slider('setAttribute', 'range', true);
+        $testSliderC.slider('refresh');
+
+        var valuesToSet = [1, 7];
+        $testSliderC.slider('setValue', valuesToSet);
+        var ariaValueText1 = $('#testAccessbilitySlider').find('.min-slider-handle')[0].getAttribute('aria-valuetext');
+        var ariaValueText2 = $('#testAccessbilitySlider').find('.max-slider-handle')[0].getAttribute('aria-valuetext');
+        expect(ariaValueText1).toBeNull();
+        expect(ariaValueText2).toBeNull();
+      });
+    });
+});

package/bower_components/seiyria-bootstrap-slider/test/specs/AutoRegisterDataProvideSpec.js

@@ -0,0 +1,21 @@
+describe("Auto register data-provide Tests", function() {
+  it("checks that the autoregister Slider was automatically registerd", function() {
+    var $el = $("#autoregisterSlider");
+
+    var sliderInstancesExists = $el.siblings().is(".slider");
+    expect(sliderInstancesExists).toBeTruthy();
+
+    var sliderInstancesCount = $el.siblings(".slider").length;
+    expect(sliderInstancesCount).toEqual(1);
+  });
+
+  it("checks that the autoregistered Slider can be accessed", function() {
+    var $el = $("#autoregisterSlider");
+    
+    expect($el.slider('getValue')).toBe(1);
+
+    $el.slider('setValue', 2);
+
+    expect($el.slider('getValue')).toBe(2);
+  });
+});

package/bower_components/seiyria-bootstrap-slider/test/specs/ConflictingOptionsSpec.js

@@ -0,0 +1,73 @@
+/*
+  *************************
+
+  Conflicting Options Tests
+
+  *************************
+
+  This spec has tests for checking if two or more options do not conflict with one another
+  As option conflicts are reported and resolved, write tests for them here.
+  This will help ensure that they are accounted for and do not arise again.
+*/
+describe("Conflicting Options Tests", function() {
+
+  var testSlider;
+
+  it("Should have the value zero when it is slided to zero", function() {
+    testSlider = $("#testSlider1").slider({
+      value: 0,
+      step: 1
+    });
+    var flag = false;
+    var mouse = document.createEvent('MouseEvents');
+
+    testSlider.on('slide', function(slideEvt) {
+      expect(slideEvt.value).toBe(0);
+      flag = true;
+    });
+
+    testSlider.data('slider')._mousemove(mouse);
+    expect(flag).toBeTruthy();
+  });
+
+  it("should set the `precision` to be the number of digits after the decimal of the `step` (assuming no `precision` is specified)", function() {
+    // Create Slider
+    testSlider = $("#testSlider1").slider({
+      value: 8.115,
+      step: 0.01
+    });
+    // Retrieve slider value
+    var value = testSlider.slider("getValue");
+    // Run tests
+    expect(value).toBe(8.12);
+  });
+
+  it("should properly allow for a slider that has `range` set to true and `reversed` set to true", function() {
+    // Create Slider
+    testSlider = new Slider("#testSlider1", {
+      reversed: true,
+      range: true,
+      min: -5,
+      max: 20
+    });
+
+    // Set Value
+    testSlider.setValue([-5, 20]);
+
+    // Assert that selection slider section is 100% of slider width
+    var selectedSectionWidth = testSlider.sliderElem.querySelector(".slider-selection").style.width;
+    expect(selectedSectionWidth).toBe("100%");
+
+    // Cleanup
+    testSlider.destroy();
+    testSlider = null;
+  });
+
+  afterEach(function() {
+    if(testSlider) {
+      testSlider.slider('destroy');
+      testSlider = null;
+    }
+  });
+
+});

package/bower_components/seiyria-bootstrap-slider/test/specs/DestroyMethodTests.js

@@ -0,0 +1,416 @@
+describe("'destroy()' Method tests", function() {
+  var testSlider;
+  
+  function createSliderFn() {
+    testSlider = new Slider("#testSlider1", {
+      id: "destroyMethodTestSlider"
+    });
+  }
+
+  it("removes the extra DOM elements associated with a slider", function() {
+
+    createSliderFn();
+
+    testSlider.destroy();
+
+    var sliderParentElement = $("#testSlider1").parent('div.slider').length;
+    var sliderChildrenElements = $("#testSlider1").siblings('div.slider-track, div.tooltip').length;
+
+    expect(sliderParentElement).toBe(0);
+    expect(sliderChildrenElements).toBe(0);
+  });
+
+  describe("Destroy slider instance associated with <input> element", function() {
+    var sourceJS = "temp/bootstrap-slider.js";
+    var defaultNamespace = 'slider';
+    var alternateNamespace = 'bootstrapSlider';
+
+    it("Should remove the instance associated with the <input> DOM element", function() {
+      var $testSlider = $('#testSlider1').slider();
+
+      var sliderInst = $testSlider.data(defaultNamespace);
+      expect(sliderInst).toBeTruthy();
+
+      $testSlider.slider('destroy');
+      sliderInst = $testSlider.data(defaultNamespace);
+      expect(sliderInst).toBeUndefined();
+    });
+
+    describe("Check alternate namespace", function() {
+
+      afterEach(function(done) {
+        $.fn.bootstrapSlider = undefined;
+        $.fn.slider = undefined;
+    
+        $.getScript(sourceJS, function() {
+          done();
+        });
+      });
+
+      it("Should remove the instance associated with the <input> DOM element with alternate namespace", function(done) {
+        $.fn.slider = function() {};
+
+        $.getScript(sourceJS, function() {
+          var $testSlider = $('#testSlider1').bootstrapSlider();
+
+          $testSlider.bootstrapSlider('destroy');
+
+          var sliderInst = $testSlider.data(alternateNamespace);
+          expect(sliderInst).toBeUndefined();
+
+          done();
+        });
+      });
+    });
+  });
+
+  describe("unbinds all slider events", function() {
+    var flag, evtName;
+
+    beforeEach(function() {
+      createSliderFn();
+      flag = false;
+    });
+
+    it("unbinds from 'slideStart' event", function() {
+      evtName = 'slideStart';
+      $("#destroyMethodTestSlider").on(evtName, function() {
+        flag = true;
+      });
+      testSlider.destroy();
+      $("#destroyMethodTestSlider").trigger(evtName);
+      expect(flag).toBeFalsy();
+    });
+
+    it("unbinds from 'slide' event", function() {
+      evtName = 'slide';
+      $("#destroyMethodTestSlider").on(evtName, function() {
+        flag = true;
+      });
+      testSlider.destroy();
+      $("#destroyMethodTestSlider").trigger(evtName);
+      expect(flag).toBeFalsy();
+    });
+
+    it("unbinds from 'slideStop' event", function() {
+      evtName = 'slideStop';
+      $("#destroyMethodTestSlider").on(evtName, function() {
+        flag = true;
+      });
+      testSlider.destroy();
+      $("#destroyMethodTestSlider").trigger(evtName);
+      expect(flag).toBeFalsy();
+    });
+
+    it("unbinds from 'slideChange' event", function() {
+      evtName = 'slideChange';
+      $("#destroyMethodTestSlider").on(evtName, function() {
+        flag = true;
+      });
+      testSlider.destroy();
+      $("#destroyMethodTestSlider").trigger(evtName);
+      expect(flag).toBeFalsy();
+    });
+
+    it("unbinds all slider events and allows you to re-create the slider without runtime error", function() {
+      // Setup
+      var createSliderAndBindEvent = function () {
+        $("#testSlider1").bootstrapSlider({
+          min: 0,
+          max: 1000 * 1000,
+          step: 1000
+        });
+        testSlider = $("#testSlider1").data("bootstrapSlider");
+        testSlider.on("slideStop", function() {});
+      };
+      // Destroy existing slider from default bootstrap step
+      testSlider.destroy();
+
+      // Create new Slider
+      createSliderAndBindEvent();
+
+      // Destroy slider
+      testSlider.destroy();
+
+      // Re-create Slider and try to re-bind event
+      var throwsRuntimeError = false;
+      
+      try {
+        createSliderAndBindEvent();
+      }
+      catch (e) {
+        throwsRuntimeError = true;
+      }
+
+      testSlider.destroy();
+
+      // reCreateSliderAndBindEvent(): Assert error is not thrown
+      expect(throwsRuntimeError).toBeFalsy();
+    });
+  });
+
+  describe("DOM event listener removal tests", function() {
+    describe("When tooltips are always hidden for single value sliders", function() {
+      beforeEach(function() {
+        // Create slider
+        testSlider = new Slider("#testSlider1", {
+          id: "destroyMethodTestSlider",
+          tooltip: "hide"
+        });
+      });
+
+      it("does not try to remove 'focus' event listener from handle1", function() {
+        // Set up spy on 'removeEventListener'
+        spyOn(testSlider.handle1, "removeEventListener");
+
+        // Destroy slider
+        testSlider.destroy();
+
+        // Assert
+        expect(testSlider.handle1.removeEventListener).not.toHaveBeenCalledWith("focus", undefined, false);
+      });
+
+      it("does not try to remove 'blur' event listener from handle1", function() {
+        // Set up spy on 'removeEventListener'
+        spyOn(testSlider.handle1, "removeEventListener");
+
+        // Destroy slider
+        testSlider.destroy();
+
+        // Assert
+        expect(testSlider.handle1.removeEventListener).not.toHaveBeenCalledWith("blur", undefined, false);
+      });
+
+      it("does not try to remove 'mouseenter' event listener from slider", function() {
+        // Set up spy on 'removeEventListener'
+        spyOn(testSlider.sliderElem, "removeEventListener");
+
+        // Destroy slider
+        testSlider.destroy();
+
+        // Assert
+        expect(testSlider.sliderElem.removeEventListener).not.toHaveBeenCalledWith("mouseenter", undefined, false);
+      });
+
+      it("does not try to remove 'mouseleave' event listener from slider", function() {
+        // Set up spy on 'removeEventListener'
+        spyOn(testSlider.sliderElem, "removeEventListener");
+
+        // Destroy slider
+        testSlider.destroy();
+
+        // Assert
+        expect(testSlider.sliderElem.removeEventListener).not.toHaveBeenCalledWith("mouseleave", undefined, false);
+      });
+    });
+
+    describe("When tooltips are always shown for single value sliders", function() {
+      beforeEach(function() {
+        // Create slider
+        testSlider = new Slider("#testSlider1", {
+          id: "destroyMethodTestSlider",
+          tooltip: "always"
+        });
+      });
+
+      it("does not try to remove 'focus' event listener from handle1 when tooltip is always shown for single handle sliders", function() {
+        // Set up spy on 'removeEventListener'
+        spyOn(testSlider.handle1, "removeEventListener");
+
+        // Destroy slider
+        testSlider.destroy();
+
+        // Assert
+        expect(testSlider.handle1.removeEventListener).not.toHaveBeenCalledWith("focus", undefined, false);
+      });
+
+      it("does not try to remove 'blur' event listener from handle1 when tooltip is always shown for single handle sliders", function() {
+          // Set up spy on 'removeEventListener'
+          spyOn(testSlider.handle1, "removeEventListener");
+
+          // Destroy slider
+          testSlider.destroy();
+
+          // Assert
+          expect(testSlider.handle1.removeEventListener).not.toHaveBeenCalledWith("blur", undefined, false);
+      });
+
+      it("does not try to remove 'mouseenter' event listener from slider is always shown for single handle slider", function() {
+        // Set up spy on 'removeEventListener'
+        spyOn(testSlider.handle1, "removeEventListener");
+
+        // Destroy slider
+        testSlider.destroy();
+
+        // Assert
+        expect(testSlider.handle1.removeEventListener).not.toHaveBeenCalledWith("mouseenter", undefined, false);
+      });
+
+      it("does not try to remove 'mouseleave' event listener from slider is always shown for single handle slider", function() {
+        // Set up spy on 'removeEventListener'
+        spyOn(testSlider.sliderElem, "removeEventListener");
+
+        // Destroy slider
+        testSlider.destroy();
+
+        // Assert
+        expect(testSlider.sliderElem.removeEventListener).not.toHaveBeenCalledWith("mouseleave", undefined, false);
+      });
+    });
+
+    describe("When tooltips are always hidden for range sliders", function() {
+      beforeEach(function() {
+        // Create slider
+        testSlider = new Slider("#testSlider1", {
+          id: "destroyMethodTestSlider",
+          tooltip: "always",
+          value: [2,5]
+        });
+      });
+
+      it("does not try to remove 'focus' event listener from handle1", function() {
+        // Set up spy on 'removeEventListener'
+        spyOn(testSlider.handle1, "removeEventListener");
+
+        // Destroy slider
+        testSlider.destroy();
+
+        // Assert
+        expect(testSlider.handle1.removeEventListener).not.toHaveBeenCalledWith("focus", undefined, false);
+      });
+
+      it("does not try to remove 'focus' event listener from handle2", function() {
+        // Set up spy on 'removeEventListener'
+        spyOn(testSlider.handle2, "removeEventListener");
+
+        // Destroy slider
+        testSlider.destroy();
+
+        // Assert
+        expect(testSlider.handle2.removeEventListener).not.toHaveBeenCalledWith("focus", undefined, false);
+      });
+
+      it("does not try to remove 'blur' event listener from handle1", function() {
+        // Set up spy on 'removeEventListener'
+        spyOn(testSlider.handle1, "removeEventListener");
+
+        // Destroy slider
+        testSlider.destroy();
+
+        // Assert
+        expect(testSlider.handle1.removeEventListener).not.toHaveBeenCalledWith("blur", undefined, false);
+      });
+
+      it("does not try to remove 'blur' event listener from handle2", function() {
+        // Set up spy on 'removeEventListener'
+        spyOn(testSlider.handle2, "removeEventListener");
+
+        // Destroy slider
+        testSlider.destroy();
+
+        // Assert
+        expect(testSlider.handle2.removeEventListener).not.toHaveBeenCalledWith("blur", undefined, false);
+      });
+
+      it("does not try to remove 'mouseenter' event listener from slider", function() {
+        // Set up spy on 'removeEventListener'
+        spyOn(testSlider.sliderElem, "removeEventListener");
+
+        // Destroy slider
+        testSlider.destroy();
+
+        // Assert
+        expect(testSlider.sliderElem.removeEventListener).not.toHaveBeenCalledWith("mouseenter", undefined, false);
+      });
+
+      it("does not try to remove 'mouseleave' event listener from slider", function() {
+        // Set up spy on 'removeEventListener'
+        spyOn(testSlider.sliderElem, "removeEventListener");
+
+        // Destroy slider
+        testSlider.destroy();
+
+        // Assert
+        expect(testSlider.sliderElem.removeEventListener).not.toHaveBeenCalledWith("mouseleave", undefined, false);
+      });
+    });
+
+    describe("When tooltips are always shown for range sliders", function() {
+      beforeEach(function() {
+        // Create slider
+        testSlider = new Slider("#testSlider1", {
+          id: "destroyMethodTestSlider",
+          tooltip: "always",
+          value: [2,5]
+        });
+      });
+
+      it("does not try to remove 'focus' event listener from handle1", function() {
+        // Set up spy on 'removeEventListener'
+        spyOn(testSlider.handle1, "removeEventListener");
+
+        // Destroy slider
+        testSlider.destroy();
+
+        // Assert
+        expect(testSlider.handle1.removeEventListener).not.toHaveBeenCalledWith("focus", undefined, false);
+      });
+      
+      it("does not try to remove 'focus' event listener from handle2", function() {
+        // Set up spy on 'removeEventListener'
+        spyOn(testSlider.handle2, "removeEventListener");
+
+        // Destroy slider
+        testSlider.destroy();
+
+        // Assert
+        expect(testSlider.handle2.removeEventListener).not.toHaveBeenCalledWith("focus", undefined, false);
+      });
+
+      it("does not try to remove 'blur' event listener from handle1", function() {
+        // Set up spy on 'removeEventListener'
+        spyOn(testSlider.handle1, "removeEventListener");
+
+        // Destroy slider
+        testSlider.destroy();
+
+        // Assert
+        expect(testSlider.handle1.removeEventListener).not.toHaveBeenCalledWith("blur", undefined, false);
+      });
+      
+       it("does not try to remove 'blur' event listener from handle1 and handle2", function() {
+        // Set up spy on 'removeEventListener'
+        spyOn(testSlider.handle2, "removeEventListener");
+
+        // Destroy slider
+        testSlider.destroy();
+
+        // Assert
+        expect(testSlider.handle2.removeEventListener).not.toHaveBeenCalledWith("blur", undefined, false);
+      });
+
+      it("does not try to remove 'mouseenter' event listener from slider", function() {
+        // Set up spy on 'removeEventListener'
+        spyOn(testSlider.sliderElem, "removeEventListener");
+
+        // Destroy slider
+        testSlider.destroy();
+
+        // Assert
+        expect(testSlider.sliderElem.removeEventListener).not.toHaveBeenCalledWith("mouseenter", undefined, false);
+      });
+
+      it("does not try to remove 'mouseleave' event listener from slider", function() {
+        // Set up spy on 'removeEventListener'
+        spyOn(testSlider.sliderElem, "removeEventListener");
+
+        // Destroy slider
+        testSlider.destroy();
+
+        // Assert
+        expect(testSlider.sliderElem.removeEventListener).not.toHaveBeenCalledWith("mouseleave", undefined, false);
+      });
+    });
+  });
+
+});