pax_global_header00006660000000000000000000000064127353432710014521gustar00rootroot0000000000000052 comment=56196882e66d0f7d033de4c71e99cef724b2adb1 simulate-event-1.4.0/000077500000000000000000000000001273534327100144655ustar00rootroot00000000000000simulate-event-1.4.0/.editorconfig000066400000000000000000000005631273534327100171460ustar00rootroot00000000000000# EditorConfig helps developers define and maintain consistent # coding styles between different editors and IDEs # editorconfig.org root = true [*] indent_style = space indent_size = 2 end_of_line = lf charset = utf-8 trim_trailing_whitespace = true insert_final_newline = true [*.md] trim_trailing_whitespace = false [Makefile] indent_style = tab indent_size = 4 simulate-event-1.4.0/.gitignore000066400000000000000000000000471273534327100164560ustar00rootroot00000000000000.DS_Store node_modules/ coverage/ dist/simulate-event-1.4.0/.travis.yml000066400000000000000000000004771273534327100166060ustar00rootroot00000000000000language: node_js node_js: - '0.12' sudo: false notifications: email: on_success: never on_failure: change before_script: - "export DISPLAY=:99.0" - "sh -e /etc/init.d/xvfb start" - sleep 3 # give xvfb some time to start after_script: "npm install coveralls@2 && cat ./coverage/lcov.info | coveralls" simulate-event-1.4.0/Gruntfile.js000066400000000000000000000040121273534327100167570ustar00rootroot00000000000000/** * Standard options for the Browserify builds. * * @type {Object} */ var debugOptions = { debug: true, transform: [], standalone: 'simulateEvent' } /** * Options for a minified Browserify build. * * @type {Object} */ var minifyOptions = { debug: false, transform: ['uglifyify'], standalone: 'simulateEvent' } /** * Initialize the grunt configuration script. * * @param {Object} grunt */ module.exports = function (grunt) { require('load-grunt-tasks')(grunt) grunt.initConfig({ /** * Compile browser-side modules for simplified consumption. * * @type {Object} */ browserify: { debug: { src: 'simulate-event.js', dest: 'dist/simulate-event.js', options: debugOptions }, minify: { src: 'simulate-event.js', dest: 'dist/simulate-event.min.js', options: minifyOptions } }, /** * Uglify the output of the minified Browserified files. * * @type {Object} */ uglify: { minify: { files: { 'dist/simulate-event.min.js': ['dist/simulate-event.min.js'] } } }, /** * Execute the test suite using Karma. * * @type {Object} */ karma: { options: { configFile: 'karma.conf.js' }, unit: { singleRun: false, background: true }, ci: { singleRun: true } }, /** * Watch for any file changes and run the supporting processes. * * @type {Object} */ watch: { build: { files: ['<%= jshint.all.src %>'], tasks: ['build'] }, lint: { files: ['<%= jshint.all.src %>'], tasks: ['newer:jshint:all'] }, karma: { files: ['lib/**/*.js', 'test/**/*.js'], tasks: ['karma:unit:run'] } } }) grunt.registerTask('test', ['jshint', 'karma:ci']) grunt.registerTask('build', ['browserify', 'uglify']) grunt.registerTask('default', ['build', 'karma:unit', 'watch']) } simulate-event-1.4.0/LICENSE000066400000000000000000000021171273534327100154730ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2013 Blake Embrey (hello@blakeembrey.com) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. simulate-event-1.4.0/README.md000066400000000000000000000021511273534327100157430ustar00rootroot00000000000000# Simulate Event [![NPM version][npm-image]][npm-url] [![NPM downloads][downloads-image]][downloads-url] [![Build status][travis-image]][travis-url] [![Test coverage][coveralls-image]][coveralls-url] > Simply trigger DOM events on any element. ## Installation ```shell npm install simulate-event --save-dev ``` ## Usage ```javascript // Simulate an event on an element simulateEvent.simulate(document.body, 'click'); // Generate an event for custom use var evt = simulateEvent.generate('click', { clientX: 10 }); ``` ## License MIT [npm-image]: https://img.shields.io/npm/v/simulate-event.svg?style=flat [npm-url]: https://npmjs.org/package/simulate-event [downloads-image]: https://img.shields.io/npm/dm/simulate-event.svg?style=flat [downloads-url]: https://npmjs.org/package/simulate-event [travis-image]: https://img.shields.io/travis/blakeembrey/simulate-event.svg?style=flat [travis-url]: https://travis-ci.org/blakeembrey/simulate-event [coveralls-image]: https://img.shields.io/coveralls/blakeembrey/simulate-event.svg?style=flat [coveralls-url]: https://coveralls.io/r/blakeembrey/simulate-event?branch=master simulate-event-1.4.0/karma.conf.js000066400000000000000000000042141273534327100170430ustar00rootroot00000000000000module.exports = function (config) { config.set({ /** * The base path that will be used to resolve files. * * @type {String} */ basePath: '', /** * Test frameworks to use. * * @type {Array} */ frameworks: ['mocha', 'sinon-chai'], /** * Preprocess files matching a given pattern. * * @type {Object} */ preprocessors: { 'dist/**/*.js': ['coverage'] }, /** * List of files and patterns to load in the browser. * * @type {Array} */ files: [ 'dist/simulate-event.js', 'test/**/*.js' ], /** * List of files and patterns to exclude in the browser. * * @type {Array} */ exclude: [], /** * Test results reporter to use. * Possible values: 'dots', 'progress', 'junit', 'growl', 'coverage' * * @type {Array} */ reporters: ['progress', 'coverage'], /** * Web server port number. * * @type {Number} */ port: 9876, /** * Enable or disable colors in the output (reporters and logs). * * @type {Boolean} */ colors: true, /** * Level of logging. * Possible values: * - config.LOG_DISABLE * - config.LOG_ERROR * - config.LOG_WARN * - config.LOG_INFO * - config.LOG_DEBUG * * @type {Number} */ logLevel: config.LOG_INFO, /** * Enable and disable file watching and execution of tests when a * file changes. * * @type {Boolean} */ autoWatch: true, /** * Start these browsers automatically. Currently available: * - Chrome * - ChromeCanary * - Firefox * - Opera * - Safari (only Mac) * - PhantomJS * - IE (only Windows) * * @type {Array} */ browsers: ['Chrome', 'Firefox'], /** * If a browser does not capture within a given timeout, kill it. * * @type {Number} */ captureTimeout: 60000, /** * Continuous Integration mode. If true, it will capture browsers, run * tests and exit. * * @type {Boolean} */ singleRun: true }) } simulate-event-1.4.0/package.json000066400000000000000000000037031273534327100167560ustar00rootroot00000000000000{ "name": "simulate-event", "version": "1.4.0", "description": "A library for triggering DOM events.", "main": "simulate-event.js", "typings": "simulate-event.d.ts", "files": [ "simulate-event.js", "simulate-event.d.ts" ], "scripts": { "build": "grunt build", "dev": "grunt watch:build & karma start", "lint": "standard", "test:debug": "npm run build && karma start --browsers=Firefox --singleRun=false --debug=true", "test:chrome": "npm run build && karma start --browsers=Chrome", "test:ie": "npm run build && karma start --browsers=IE", "test": "npm run build && npm run lint && karma start --browsers=Firefox" }, "standard": { "ignore": [ "dist/", "node_modules/", "coverage/" ] }, "repository": "https://github.com/blakeembrey/simulate-event", "keywords": [ "simulate", "event", "dom", "mouse", "keyboard" ], "author": { "name": "Blake Embrey", "email": "hello@blakeembrey.com", "url": "http://blakeembrey.me" }, "license": "MIT", "devDependencies": { "browserify": "^3.18.0", "grunt": "^0.4.2", "grunt-browserify": "^1.3.0", "grunt-cli": "^0.1.11", "grunt-contrib-jshint": "^0.8.0", "grunt-contrib-uglify": "^0.2.7", "grunt-contrib-watch": "^0.5.3", "grunt-karma": "^0.10.1", "grunt-newer": "^0.6.0", "karma": "^0.12.37", "karma-chrome-launcher": "^0.1.2", "karma-coffee-preprocessor": "^0.1.2", "karma-coverage": "^0.1.4", "karma-firefox-launcher": "^0.1.3", "karma-html2js-preprocessor": "^0.1.0", "karma-ie-launcher": "^0.2.0", "karma-jasmine": "^0.1.5", "karma-mocha": "^0.1.1", "karma-requirejs": "^0.2.1", "karma-script-launcher": "^0.1.0", "karma-sinon-chai": "^0.1.4", "load-grunt-tasks": "^0.2.1", "mocha": "^1.16.2", "requirejs": "^2.1.9", "standard": "^7.0.1", "uglifyify": "^1.0.1" }, "dependencies": { "xtend": "^4.0.1" } } simulate-event-1.4.0/simulate-event.d.ts000066400000000000000000000002261273534327100202210ustar00rootroot00000000000000 export function generate(type: string, options?: any): Event; export function simulate(element: EventTarget, type: string, options?: any): boolean; simulate-event-1.4.0/simulate-event.js000066400000000000000000000230511273534327100177660ustar00rootroot00000000000000var extend = require('xtend/mutable') /** * Set some default options. * * @type {Object} */ var eventOptions = { UIEvent: function () { return { view: document.defaultView } }, FocusEvent: function () { return eventOptions.UIEvent.apply(this, arguments) }, MouseEvent: function (type) { return { button: 0, bubbles: (type !== 'mouseenter' && type !== 'mouseleave'), cancelable: (type !== 'mouseenter' && type !== 'mouseleave'), ctrlKey: false, altKey: false, shiftKey: false, metaKey: false, clientX: 1, clientY: 1, screenX: 0, screenY: 0, view: document.defaultView, relatedTarget: document.documentElement } }, WheelEvent: function (type) { return eventOptions.MouseEvent.apply(this, arguments) }, KeyboardEvent: function () { return { view: document.defaultView, ctrlKey: false, altKey: false, shiftKey: false, metaKey: false, keyCode: 0 } } } /** * Map event names to constructor names. * * @type {Object} */ var eventTypes = { beforeprint: 'Event', afterprint: 'Event', beforeunload: 'Event', abort: 'Event', error: 'Event', change: 'Event', submit: 'Event', reset: 'Event', cached: 'Event', canplay: 'Event', canplaythrough: 'Event', chargingchange: 'Event', chargingtimechange: 'Event', checking: 'Event', close: 'Event', downloading: 'Event', durationchange: 'Event', emptied: 'Event', ended: 'Event', fullscreenchange: 'Event', fullscreenerror: 'Event', invalid: 'Event', levelchange: 'Event', loadeddata: 'Event', loadedmetadata: 'Event', noupdate: 'Event', obsolete: 'Event', offline: 'Event', online: 'Event', open: 'Event', orientationchange: 'Event', pause: 'Event', pointerlockchange: 'Event', pointerlockerror: 'Event', copy: 'Event', cut: 'Event', paste: 'Event', play: 'Event', playing: 'Event', ratechange: 'Event', readystatechange: 'Event', seeked: 'Event', seeking: 'Event', stalled: 'Event', success: 'Event', suspend: 'Event', timeupdate: 'Event', updateready: 'Event', visibilitychange: 'Event', volumechange: 'Event', waiting: 'Event', load: 'UIEvent', unload: 'UIEvent', resize: 'UIEvent', scroll: 'UIEvent', select: 'UIEvent', drag: 'MouseEvent', dragenter: 'MouseEvent', dragleave: 'MouseEvent', dragover: 'MouseEvent', dragstart: 'MouseEvent', dragend: 'MouseEvent', drop: 'MouseEvent', touchcancel: 'UIEvent', touchend: 'UIEvent', touchenter: 'UIEvent', touchleave: 'UIEvent', touchmove: 'UIEvent', touchstart: 'UIEvent', blur: 'UIEvent', focus: 'UIEvent', focusin: 'UIEvent', focusout: 'UIEvent', input: 'UIEvent', show: 'MouseEvent', click: 'MouseEvent', dblclick: 'MouseEvent', mouseenter: 'MouseEvent', mouseleave: 'MouseEvent', mousedown: 'MouseEvent', mouseup: 'MouseEvent', mouseover: 'MouseEvent', mousemove: 'MouseEvent', mouseout: 'MouseEvent', contextmenu: 'MouseEvent', wheel: 'WheelEvent', message: 'MessageEvent', storage: 'StorageEvent', timeout: 'StorageEvent', keydown: 'KeyboardEvent', keypress: 'KeyboardEvent', keyup: 'KeyboardEvent', progress: 'ProgressEvent', loadend: 'ProgressEvent', loadstart: 'ProgressEvent', popstate: 'PopStateEvent', hashchange: 'HashChangeEvent', transitionend: 'TransitionEvent', compositionend: 'CompositionEvent', compositionstart: 'CompositionEvent', compositionupdate: 'CompositionEvent', pagehide: 'PageTransitionEvent', pageshow: 'PageTransitionEvent' } /** * Map the event type constructor to the initialization method. * * @type {Object} */ var eventInit = { Event: 'initEvent', UIEvent: 'initUIEvent', FocusEvent: 'initUIEvent', MouseEvent: 'initMouseEvent', WheelEvent: 'initMouseEvent', MessageEvent: 'initMessageEvent', StorageEvent: 'initStorageEvent', KeyboardEvent: 'initKeyboardEvent', ProgressEvent: 'initEvent', PopStateEvent: 'initEvent', TransitionEvent: 'initEvent', HashChangeEvent: 'initHashChangeEvent', CompositionEvent: 'initCompositionEvent', DeviceMotionEvent: 'initDeviceMotionEvent', PageTransitionEvent: 'initEvent', DeviceOrientationEvent: 'initDeviceOrientationEvent' } /** * Map the options object to initialization parameters. * * @type {Object} */ var eventParameters = { initEvent: [], initUIEvent: [ 'view', 'detail' ], initKeyboardEvent: [ 'view', 'char', 'key', 'location', 'modifiersList', 'repeat', 'locale' ], initKeyEvent: [ 'view', 'ctrlKey', 'altKey', 'shiftKey', 'metaKey', 'keyCode', 'charCode' ], initMouseEvent: [ 'view', 'detail', 'screenX', 'screenY', 'clientX', 'clientY', 'ctrlKey', 'altKey', 'shiftKey', 'metaKey', 'button', 'relatedTarget' ], initHashChangeEvent: [ 'oldURL', 'newURL' ], initCompositionEvent: [ 'view', 'data', 'locale' ], initDeviceMotionEvent: [ 'acceleration', 'accelerationIncludingGravity', 'rotationRate', 'interval' ], initDeviceOrientationEvent: [ 'alpha', 'beta', 'gamma', 'absolute' ], initMessageEvent: [ 'data', 'origin', 'lastEventId', 'source' ], initStorageEvent: [ 'key', 'oldValue', 'newValue', 'url', 'storageArea' ] } /** * Map the event types to constructors. * * @type {Object} */ var eventConstructors = { UIEvent: window.UIEvent, FocusEvent: window.FocusEvent, MouseEvent: window.MouseEvent, WheelEvent: window.MouseEvent, KeyboardEvent: window.KeyboardEvent } /** * Get attributes which must be overriden manually. * * @param {String} eventType * @param {Object} options. */ function getOverrides (eventType, options) { if (eventType === 'KeyboardEvent' && options) { return { keyCode: options.keyCode || 0, key: options.key || 0, which: options.which || options.keyCode || 0 } } } /** * Generate an event. * * @param {String} type * @param {Object} options * @return {Event} */ exports.generate = function (type, options) { // Immediately throw an error when the event name does not translate. if (!eventTypes.hasOwnProperty(type)) { throw new SyntaxError('Unsupported event type') } var eventType = eventTypes[type] var event var key // Handle parameters which must be manually overridden using // `Object.defineProperty`. var overrides = getOverrides(eventType, options) // Extend a new object with the default and passed in options. // Existing events already have all of their defaults set. if (!(options instanceof window.Event)) { // Check for extra defaults to pass in. if (eventType in eventOptions) { options = extend({ bubbles: true, cancelable: true }, eventOptions[eventType](type, options), options) } else { options = extend({ bubbles: true, cancelable: true }, options) } } // Attempt the Event Constructors DOM API. var Constructor = eventConstructors[eventType] || window.Event try { event = new Constructor(type, options) // Add the override properties. for (key in overrides) { Object.defineProperty(event, key, { value: overrides[key] }) } return event } catch (e) { // Continue. } // In IE11, the Keyboard event does not allow setting the // keyCode property, even with Object.defineProperty, // so we have to use UIEvent. var ua = window.navigator.userAgent.toLowerCase() var msie = Math.max(ua.indexOf('msie'), ua.indexOf('trident')) if (msie >= 0 && eventType === 'KeyboardEvent') { eventType = 'UIEvent' } var initEvent = eventInit[eventType] // In < IE9, the `createEvent` function is not available and we have to // resort to using `fireEvent`. if (!document.createEvent) { event = extend(document.createEventObject(), options) // Add the override properties. for (key in overrides) { Object.defineProperty(event, key, { value: overrides[key] }) } return event } event = extend(document.createEvent(eventType), options) // Handle differences between `initKeyboardEvent` and `initKeyEvent`. if (initEvent === 'initKeyboardEvent') { if (event[initEvent] === void 0) { initEvent = 'initKeyEvent' } else if (!('modifiersList' in options)) { var mods = [] if (options.metaKey) mods.push('Meta') if (options.altKey) mods.push('Alt') if (options.shiftKey) mods.push('Shift') if (options.ctrlKey) mods.push('Control') options['modifiersList'] = mods.join(' ') } } // Map argument names to the option values. var args = eventParameters[initEvent].map(function (parameter) { return options[parameter] }) // Initialize the event using the built-in method. event[initEvent].apply( event, [type, options.bubbles, options.cancelable].concat(args) ) // Add the override properties. for (key in overrides) { Object.defineProperty(event, key, { value: overrides[key] }) } return event } /** * Simulate an event which is dispatched on the given element. * * @param {Element} element * @param {String} type * @param {Object} options * @return {Boolean} */ exports.simulate = function (element, type, options) { var event = exports.generate(type, options) // In < IE9, the `createEvent` function is not available and we have to // resort to using `fireEvent`. if (!document.createEvent) { return element.fireEvent('on' + type, event) } return element.dispatchEvent(event) } simulate-event-1.4.0/test/000077500000000000000000000000001273534327100154445ustar00rootroot00000000000000simulate-event-1.4.0/test/events.js000066400000000000000000000015231273534327100173070ustar00rootroot00000000000000/* global describe, it, simulateEvent, sinon, expect, beforeEach, afterEach */ describe('Events', function () { var eventNames = 'abort change open storage loadend popstate transitionend ' eventNames += 'pagehide' var events = eventNames.split(' ') var fixture beforeEach(function () { fixture = document.createElement('div') document.body.appendChild(fixture) }) afterEach(function () { fixture.parentNode.removeChild(fixture) fixture = null }) events.forEach(function (eventName) { it('should trigger ' + eventName, function () { var spy = sinon.spy() fixture.addEventListener(eventName, spy) simulateEvent.simulate(fixture, eventName) expect(spy).to.have.been.calledOnce var evt = simulateEvent.generate(eventName) expect(evt.type).to.equal(eventName) }) }) }) simulate-event-1.4.0/test/key-events.js000066400000000000000000000034231273534327100200760ustar00rootroot00000000000000/* global describe, it, simulateEvent, sinon, expect */ describe('Key Events', function () { var fixture = document.createElement('div') document.body.appendChild(fixture) describe('keydown', function () { it('should trigger with the correct options', function () { var spy = sinon.spy() fixture.addEventListener('keydown', spy) simulateEvent.simulate(fixture, 'keydown', { keyCode: 27, key: 'A', altKey: true }) expect(spy).to.have.been.calledOnce var evt = spy.getCall(0).args[0] expect(evt.keyCode).to.equal(27) expect(evt.key).to.equal('A') expect(evt.altKey).to.equal(true) expect(evt.bubbles).to.equal(true) }) it('should clone an existing event', function () { var spy = sinon.spy() fixture.addEventListener('keydown', spy) simulateEvent.simulate(fixture, 'keydown', { keyCode: 27, key: 'A', altKey: true }) expect(spy).to.have.been.calledOnce var evt = spy.getCall(0).args[0] simulateEvent.simulate(fixture, 'keydown', evt) var clone = spy.getCall(1).args[0] expect(clone.keyCode).to.equal(27) expect(clone.key).to.equal('A') expect(clone.altKey).to.equal(true) }) it('should generate an event', function () { var evt = simulateEvent.generate('keydown', { keyCode: 27, key: 'A', altKey: true }) expect(evt.keyCode).to.equal(27) expect(evt.key).to.equal('A') expect(evt.altKey).to.equal(true) expect(evt.type).to.equal('keydown') }) }) describe('keyup', function () { it('should trigger', function () { var spy = sinon.spy() fixture.addEventListener('keyup', spy) simulateEvent.simulate(fixture, 'keyup') expect(spy).to.have.been.calledOnce }) }) }) simulate-event-1.4.0/test/mouse-events.js000066400000000000000000000111521273534327100204340ustar00rootroot00000000000000/* global describe, it, simulateEvent, sinon, expect */ describe('Mouse Events', function () { var fixture = document.createElement('div') document.body.appendChild(fixture) describe('click', function () { it('should trigger with the correct options', function () { var spy = sinon.spy() fixture.addEventListener('click', spy) simulateEvent.simulate(fixture, 'click', { clientX: 10, ctrlKey: true, button: 1 }) expect(spy).to.have.been.calledOnce var evt = spy.getCall(0).args[0] expect(evt.clientX).to.equal(10) expect(evt.ctrlKey).to.equal(true) expect(evt.button).to.equal(1) expect(evt.bubbles).to.equal(true) expect(evt.cancelable).to.equal(true) }) it('should clone an existing event', function () { var spy = sinon.spy() fixture.addEventListener('click', spy) simulateEvent.simulate(fixture, 'click', { clientX: 10, ctrlKey: true, button: 1 }) expect(spy).to.have.been.calledOnce var evt = spy.getCall(0).args[0] simulateEvent.simulate(fixture, 'click', evt) var clone = spy.getCall(1).args[0] expect(clone.clientX).to.equal(10) expect(clone.ctrlKey).to.equal(true) expect(clone.button).to.equal(1) }) it('should generate an event', function () { var evt = simulateEvent.generate('click', { clientX: 10, ctrlKey: true, button: 1 }) expect(evt.clientX).to.equal(10) expect(evt.ctrlKey).to.equal(true) expect(evt.button).to.equal(1) expect(evt.type).to.equal('click') }) }) describe('mousedown', function () { it('should trigger', function () { var spy = sinon.spy() fixture.addEventListener('mousedown', spy) simulateEvent.simulate(fixture, 'mousedown') expect(spy).to.have.been.calledOnce var evt = spy.getCall(0).args[0] expect(evt.bubbles).to.equal(true) expect(evt.cancelable).to.equal(true) }) }) describe('mouseup', function () { it('should trigger', function () { var spy = sinon.spy() fixture.addEventListener('mouseup', spy) simulateEvent.simulate(fixture, 'mouseup') expect(spy).to.have.been.calledOnce var evt = spy.getCall(0).args[0] expect(evt.bubbles).to.equal(true) expect(evt.cancelable).to.equal(true) }) }) describe('mouseenter', function () { it('should trigger', function () { var spy = sinon.spy() fixture.addEventListener('mouseenter', spy) simulateEvent.simulate(fixture, 'mouseenter') expect(spy).to.have.been.calledOnce var evt = spy.getCall(0).args[0] expect(evt.bubbles).to.equal(false) expect(evt.cancelable).to.equal(false) }) }) describe('mouseleave', function () { it('should trigger', function () { var spy = sinon.spy() fixture.addEventListener('mouseleave', spy) simulateEvent.simulate(fixture, 'mouseleave') expect(spy).to.have.been.calledOnce var evt = spy.getCall(0).args[0] expect(evt.bubbles).to.equal(false) expect(evt.cancelable).to.equal(false) }) }) describe('mouseover', function () { it('should trigger', function () { var spy = sinon.spy() fixture.addEventListener('mouseover', spy) simulateEvent.simulate(fixture, 'mouseover') expect(spy).to.have.been.calledOnce var evt = spy.getCall(0).args[0] expect(evt.bubbles).to.equal(true) expect(evt.cancelable).to.equal(true) }) }) describe('mousemove', function () { it('should trigger', function () { var spy = sinon.spy() fixture.addEventListener('mousemove', spy) simulateEvent.simulate(fixture, 'mousemove') expect(spy).to.have.been.calledOnce var evt = spy.getCall(0).args[0] expect(evt.bubbles).to.equal(true) expect(evt.cancelable).to.equal(true) }) }) describe('mouseout', function () { it('should trigger', function () { var spy = sinon.spy() fixture.addEventListener('mouseout', spy) simulateEvent.simulate(fixture, 'mouseout') expect(spy).to.have.been.calledOnce var evt = spy.getCall(0).args[0] expect(evt.bubbles).to.equal(true) expect(evt.cancelable).to.equal(true) }) }) describe('contextmenu', function () { it('should trigger', function () { var spy = sinon.spy() fixture.addEventListener('contextmenu', spy) simulateEvent.simulate(fixture, 'contextmenu') expect(spy).to.have.been.calledOnce var evt = spy.getCall(0).args[0] expect(evt.bubbles).to.equal(true) expect(evt.cancelable).to.equal(true) }) }) }) simulate-event-1.4.0/test/ui-events.js000066400000000000000000000013641273534327100177250ustar00rootroot00000000000000/* global describe, it, simulateEvent, sinon, expect, beforeEach, afterEach */ describe('UI Events', function () { var events = 'blur focus focusin focusout'.split(' ') var fixture beforeEach(function () { fixture = document.createElement('input') document.body.appendChild(fixture) }) afterEach(function () { fixture.parentNode.removeChild(fixture) fixture = null }) events.forEach(function (eventName) { it('should trigger', function () { var spy = sinon.spy() fixture.addEventListener(eventName, spy) simulateEvent.simulate(fixture, eventName) expect(spy).to.have.been.calledOnce var evt = simulateEvent.generate(eventName) expect(evt.type).to.equal(eventName) }) }) })