1133 lines
33 KiB
JavaScript
Vendored
1133 lines
33 KiB
JavaScript
Vendored
/*global ZeroClipboard, _currentElement:true, _flashState:true, _extend, _clipData, _clipDataFormatMap */
|
|
|
|
(function(module, test) {
|
|
"use strict";
|
|
|
|
var originalFlashState, originalConfig, originalFlashDetect;
|
|
|
|
|
|
module("client/api.js unit tests - constructor and bridge", {
|
|
setup: function() {
|
|
// Store
|
|
originalFlashDetect = ZeroClipboard.isFlashUnusable;
|
|
originalConfig = ZeroClipboard.config();
|
|
// Modify
|
|
ZeroClipboard.isFlashUnusable = function() {
|
|
return false;
|
|
};
|
|
ZeroClipboard.config({ swfPath: originalConfig.swfPath.replace(/\/(?:src|test)\/.*$/i, "/dist/ZeroClipboard.swf") });
|
|
},
|
|
teardown: function() {
|
|
// Restore
|
|
ZeroClipboard.destroy();
|
|
ZeroClipboard.isFlashUnusable = originalFlashDetect;
|
|
ZeroClipboard.config(originalConfig);
|
|
}
|
|
});
|
|
|
|
|
|
test("Client is created properly by `ZeroClipboard`", function(assert) {
|
|
assert.expect(3);
|
|
|
|
// Arrange & Act
|
|
var client = new ZeroClipboard();
|
|
|
|
// Assert
|
|
assert.ok(client);
|
|
assert.ok(client.id);
|
|
assert.strictEqual(client instanceof ZeroClipboard, true);
|
|
});
|
|
|
|
|
|
test("New client is not the same client (no singleton) but does share the same bridge", function(assert) {
|
|
assert.expect(6);
|
|
|
|
// Arrange
|
|
var containerClass = "." + ZeroClipboard.config("containerClass");
|
|
|
|
// Assert, arrange, assert, act, assert
|
|
assert.strictEqual($(containerClass).length, 0);
|
|
var client1 = new ZeroClipboard();
|
|
assert.ok(client1.id);
|
|
assert.strictEqual($(containerClass).length, 1);
|
|
var client2 = new ZeroClipboard();
|
|
assert.strictEqual($(containerClass).length, 1);
|
|
assert.notEqual(client2.id, client1.id);
|
|
assert.notEqual(client2, client1);
|
|
});
|
|
|
|
|
|
test("No more client singleton!", function(assert) {
|
|
assert.expect(7);
|
|
|
|
// Arrange
|
|
ZeroClipboard.isFlashUnusable = function() {
|
|
return false;
|
|
};
|
|
|
|
// Assert, arrange, assert, act, assert
|
|
assert.ok(!ZeroClipboard.prototype._singleton, "The client singleton does not exist on the prototype before creating a client");
|
|
var client1 = new ZeroClipboard();
|
|
assert.ok(!ZeroClipboard.prototype._singleton, "The client singleton does not exist on the prototype after creating a client");
|
|
assert.ok(!client1._singleton, "The client singleton does not exist on the client instance after creating a client");
|
|
var client2 = new ZeroClipboard();
|
|
assert.ok(!ZeroClipboard.prototype._singleton, "The client singleton does not exist on the prototype after creating a second client");
|
|
assert.ok(!client1._singleton, "The client singleton does not exist on the first client instance after creating a second client");
|
|
assert.ok(!client2._singleton, "The client singleton does not exist on the second client instance after creating a second client");
|
|
ZeroClipboard.destroy();
|
|
assert.ok(!ZeroClipboard.prototype._singleton, "The client singleton does not exist on the prototype after calling `destroy`");
|
|
});
|
|
|
|
|
|
test("`destroy` clears up the client", function(assert) {
|
|
assert.expect(6);
|
|
|
|
// Arrange
|
|
var containerId = "#" + ZeroClipboard.config("containerId");
|
|
ZeroClipboard.isFlashUnusable = function() {
|
|
return false;
|
|
};
|
|
|
|
// Assert, arrange, assert, act, assert
|
|
assert.ok(!ZeroClipboard.prototype._singleton, "The client singleton does not exist before creating a client");
|
|
assert.equal($(containerId)[0], null, "The HTML bridge does not exist before creating a client");
|
|
/*jshint nonew:false */
|
|
new ZeroClipboard();
|
|
assert.ok(!ZeroClipboard.prototype._singleton, "The client singleton does exist after creating a client");
|
|
assert.notEqual($(containerId)[0], null, "The HTML bridge does exist after creating a client");
|
|
ZeroClipboard.destroy();
|
|
assert.ok(!ZeroClipboard.prototype._singleton, "The client singleton does not exist after calling `destroy`");
|
|
assert.equal($(containerId)[0], null, "The HTML bridge does not exist after calling `destroy`");
|
|
});
|
|
|
|
|
|
module("client/api.js unit tests - clipboard", {
|
|
setup: function() {
|
|
// Store
|
|
originalConfig = ZeroClipboard.config();
|
|
// Modify
|
|
ZeroClipboard.config({ swfPath: originalConfig.swfPath.replace(/\/(?:src|test)\/.*$/i, "/dist/ZeroClipboard.swf") });
|
|
},
|
|
teardown: function() {
|
|
ZeroClipboard.destroy();
|
|
ZeroClipboard.config(originalConfig);
|
|
}
|
|
});
|
|
|
|
|
|
test("`setText` works", function(assert) {
|
|
assert.expect(4);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
|
|
// Assert, Act, repeat ad nauseam
|
|
assert.deepEqual(_clipData, {}, "`_clipData` is empty");
|
|
|
|
client.setText("zc4evar");
|
|
assert.deepEqual(_clipData, { "text/plain": "zc4evar" }, "`_clipData` contains expected text");
|
|
|
|
client.setText("ZeroClipboard");
|
|
assert.deepEqual(_clipData, { "text/plain": "ZeroClipboard" }, "`_clipData` contains expected updated text");
|
|
|
|
_clipData["text/html"] = "<b>Win</b>";
|
|
client.setText("goodbye");
|
|
assert.deepEqual(_clipData, { "text/plain": "goodbye", "text/html": "<b>Win</b>" }, "`_clipData` contains expected updated text AND the other data");
|
|
});
|
|
|
|
|
|
test("`setHtml` works", function(assert) {
|
|
assert.expect(4);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
|
|
// Assert, Act, repeat ad nauseam
|
|
assert.deepEqual(_clipData, {}, "`_clipData` is empty");
|
|
|
|
client.setHtml("zc4evar");
|
|
assert.deepEqual(_clipData, { "text/html": "zc4evar" }, "`_clipData` contains expected HTML");
|
|
|
|
client.setHtml("<b>ZeroClipboard</b>");
|
|
assert.deepEqual(_clipData, { "text/html": "<b>ZeroClipboard</b>" }, "`_clipData` contains expected updated HTML");
|
|
|
|
_clipData["text/plain"] = "blah";
|
|
client.setHtml("<i>goodbye</i>");
|
|
assert.deepEqual(_clipData, { "text/html": "<i>goodbye</i>", "text/plain": "blah" }, "`_clipData` contains expected updated HTML AND the other data");
|
|
});
|
|
|
|
|
|
test("`setRichText` works", function(assert) {
|
|
assert.expect(4);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
|
|
// Assert, Act, repeat ad nauseam
|
|
assert.deepEqual(_clipData, {}, "`_clipData` is empty");
|
|
|
|
client.setRichText("zc4evar");
|
|
assert.deepEqual(_clipData, { "application/rtf": "zc4evar" }, "`_clipData` contains expected RTF");
|
|
|
|
client.setRichText("{\\rtf1\\ansi\n{\\b ZeroClipboard}}");
|
|
assert.deepEqual(_clipData, { "application/rtf": "{\\rtf1\\ansi\n{\\b ZeroClipboard}}" }, "`_clipData` contains expected updated RTF");
|
|
|
|
_clipData["text/plain"] = "blah";
|
|
client.setRichText("{\\rtf1\\ansi\n{\\i Foo}}");
|
|
assert.deepEqual(_clipData, { "application/rtf": "{\\rtf1\\ansi\n{\\i Foo}}", "text/plain": "blah" }, "`_clipData` contains expected updated RTF AND the other data");
|
|
});
|
|
|
|
|
|
test("`setData` works", function(assert) {
|
|
assert.expect(4);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
|
|
// Assert, Act, repeat ad nauseam
|
|
assert.deepEqual(_clipData, {}, "`_clipData` is empty");
|
|
|
|
client.setData("text/plain", "zc4evar");
|
|
assert.deepEqual(_clipData, { "text/plain": "zc4evar" }, "`_clipData` contains expected text");
|
|
|
|
client.setData("text/html", "<i>ZeroClipboard</i>");
|
|
assert.deepEqual(_clipData, { "text/plain": "zc4evar", "text/html": "<i>ZeroClipboard</i>" }, "`_clipData` contains expected text and custom format");
|
|
|
|
client.setData({ "text/html": "<b>Win</b>" });
|
|
assert.deepEqual(_clipData, { "text/html": "<b>Win</b>" }, "`_clipData` contains expected HTML and cleared out old data because an object was passed in");
|
|
});
|
|
|
|
|
|
test("`clearData` works", function(assert) {
|
|
assert.expect(4);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
|
|
// Assert
|
|
assert.deepEqual(_clipData, {}, "`_clipData` is empty");
|
|
|
|
// Arrange & Assert
|
|
_clipData["text/plain"] = "zc4evar";
|
|
_clipData["application/rtf"] = "{\\rtf1\\ansi\n{\\i Foo}}";
|
|
_clipData["text/html"] = "<b>Win</b>";
|
|
assert.deepEqual(_clipData, {
|
|
"text/plain": "zc4evar",
|
|
"application/rtf": "{\\rtf1\\ansi\n{\\i Foo}}",
|
|
"text/html": "<b>Win</b>"
|
|
}, "`_clipData` contains all expected data");
|
|
|
|
// Act & Assert
|
|
client.clearData("application/rtf");
|
|
assert.deepEqual(_clipData, {
|
|
"text/plain": "zc4evar",
|
|
"text/html": "<b>Win</b>"
|
|
}, "`_clipData` had 'application/rtf' successfully removed");
|
|
|
|
// Act & Assert
|
|
client.clearData();
|
|
assert.deepEqual(_clipData, {}, "`_clipData` had all data successfully removed");
|
|
});
|
|
|
|
|
|
test("`setText` overrides the data-clipboard-text attribute", function(assert) {
|
|
assert.expect(3);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var currentEl = document.getElementById("d_clip_button");
|
|
|
|
// Act
|
|
client.clip(currentEl);
|
|
client.setText("This is the new text");
|
|
ZeroClipboard.activate(currentEl);
|
|
var pendingText = ZeroClipboard.emit("copy");
|
|
|
|
// Assert
|
|
assert.deepEqual(_clipData, { "text/plain": "This is the new text" });
|
|
assert.deepEqual(pendingText, { "text": "This is the new text" });
|
|
assert.deepEqual(_clipDataFormatMap, { "text": "text/plain" });
|
|
});
|
|
|
|
|
|
test("`setText` overrides data-clipboard-target pre", function(assert) {
|
|
assert.expect(3);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var currentEl = document.getElementById("d_clip_button_pre_text");
|
|
|
|
// Act
|
|
client.clip(currentEl);
|
|
client.setText("This is the new text");
|
|
ZeroClipboard.activate(currentEl);
|
|
var pendingText = ZeroClipboard.emit("copy");
|
|
|
|
// Assert
|
|
assert.deepEqual(_clipData, { "text/plain": "This is the new text" });
|
|
assert.deepEqual(pendingText, { "text": "This is the new text" });
|
|
assert.deepEqual(_clipDataFormatMap, { "text": "text/plain" });
|
|
});
|
|
|
|
|
|
test("`setHtml` overrides data-clipboard-target pre", function(assert) {
|
|
assert.expect(3);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var currentEl = document.getElementById("d_clip_button_pre_text");
|
|
|
|
// Act
|
|
client.clip(currentEl);
|
|
client.setHtml("This is the new HTML");
|
|
ZeroClipboard.activate(currentEl);
|
|
var pendingText = ZeroClipboard.emit("copy");
|
|
|
|
// Assert
|
|
assert.deepEqual(_clipData, { "text/html": "This is the new HTML" });
|
|
assert.deepEqual(pendingText, { "html": "This is the new HTML" });
|
|
assert.deepEqual(_clipDataFormatMap, { "html": "text/html" });
|
|
});
|
|
|
|
|
|
test("`setText` AND `setHtml` override data-clipboard-target pre", function(assert) {
|
|
assert.expect(3);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var currentEl = document.getElementById("d_clip_button_pre_text");
|
|
|
|
// Act
|
|
client.clip(currentEl);
|
|
client.setText("This is the new text");
|
|
client.setHtml("This is the new HTML");
|
|
ZeroClipboard.activate(currentEl);
|
|
var pendingText = ZeroClipboard.emit("copy");
|
|
|
|
// Assert
|
|
assert.deepEqual(_clipData, {
|
|
"text/plain": "This is the new text",
|
|
"text/html": "This is the new HTML"
|
|
});
|
|
assert.deepEqual(pendingText, {
|
|
"text": "This is the new text",
|
|
"html": "This is the new HTML"
|
|
});
|
|
assert.deepEqual(_clipDataFormatMap, { "text": "text/plain", "html": "text/html" });
|
|
});
|
|
|
|
|
|
module("client/api.js unit tests - event", {
|
|
setup: function() {
|
|
// Store
|
|
originalFlashState = _extend({}, _flashState);
|
|
originalConfig = ZeroClipboard.config();
|
|
originalFlashDetect = ZeroClipboard.isFlashUnusable;
|
|
// Modify
|
|
_currentElement = null;
|
|
_flashState = {
|
|
bridge: null,
|
|
version: "0.0.0",
|
|
disabled: null,
|
|
outdated: null,
|
|
unavailable: null,
|
|
deactivated: null,
|
|
ready: null
|
|
};
|
|
//ZeroClipboard.config({ swfPath: originalConfig.swfPath.replace(/\/(?:src|test)\/.*$/i, "/dist/ZeroClipboard.swf") });
|
|
},
|
|
teardown: function() {
|
|
ZeroClipboard.destroy();
|
|
_currentElement = null;
|
|
_flashState = originalFlashState;
|
|
ZeroClipboard.config(originalConfig);
|
|
ZeroClipboard.isFlashUnusable = originalFlashDetect;
|
|
}
|
|
});
|
|
|
|
|
|
test("Clip element after new client", function(assert) {
|
|
assert.expect(4);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var target = document.getElementById("d_clip_button");
|
|
|
|
// Assert, Act, Assert
|
|
assert.strictEqual("zcClippingId" in target, false);
|
|
assert.deepEqual(client.elements(), []);
|
|
client.clip(target);
|
|
assert.strictEqual("zcClippingId" in target, true);
|
|
assert.deepEqual(client.elements(), [target]);
|
|
});
|
|
|
|
|
|
test("unclip element removes items", function(assert) {
|
|
assert.expect(12);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var targets = [
|
|
document.getElementById("d_clip_button"),
|
|
document.getElementById("d_clip_button2"),
|
|
document.getElementById("d_clip_button3")
|
|
];
|
|
|
|
// Assert pre-conditions
|
|
assert.strictEqual("zcClippingId" in targets[0], false);
|
|
assert.strictEqual("zcClippingId" in targets[1], false);
|
|
assert.strictEqual("zcClippingId" in targets[2], false);
|
|
assert.deepEqual(client.elements(), []);
|
|
|
|
// Act
|
|
client.clip(targets);
|
|
|
|
// Assert initial state
|
|
assert.strictEqual("zcClippingId" in targets[0], true);
|
|
assert.strictEqual("zcClippingId" in targets[1], true);
|
|
assert.strictEqual("zcClippingId" in targets[2], true);
|
|
assert.deepEqual(client.elements(), targets);
|
|
|
|
// Act more
|
|
client.unclip([
|
|
document.getElementById("d_clip_button3"),
|
|
document.getElementById("d_clip_button2")
|
|
]);
|
|
|
|
// Assert end state
|
|
assert.strictEqual("zcClippingId" in targets[0], true);
|
|
assert.strictEqual("zcClippingId" in targets[1], false);
|
|
assert.strictEqual("zcClippingId" in targets[2], false);
|
|
assert.deepEqual(client.elements(), [targets[0]]);
|
|
});
|
|
|
|
|
|
test("Element won't be clipped twice", function(assert) {
|
|
assert.expect(3);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var currentEl = document.getElementById("d_clip_button");
|
|
|
|
// Assert, act, assert
|
|
assert.deepEqual(client.elements(), []);
|
|
client.clip(currentEl);
|
|
assert.deepEqual(client.elements(), [currentEl]);
|
|
client.clip(currentEl);
|
|
assert.deepEqual(client.elements(), [currentEl]);
|
|
});
|
|
|
|
|
|
test("Registering Events", function(assert) {
|
|
assert.expect(6);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
|
|
// Act
|
|
client.on("ready", function(){});
|
|
client.on("onError", function(){});
|
|
client.on("onCustomEvent", function(){});
|
|
|
|
// Assert
|
|
assert.ok(client.handlers().ready);
|
|
assert.ok(client.handlers().error);
|
|
assert.ok(client.handlers().customevent);
|
|
assert.strictEqual(client.handlers().ready.length, 1);
|
|
assert.strictEqual(client.handlers().error.length, 1);
|
|
assert.strictEqual(client.handlers().customevent.length, 1);
|
|
});
|
|
|
|
|
|
test("Registering Events with Maps", function(assert) {
|
|
assert.expect(6);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
|
|
// Act
|
|
client.on({
|
|
"ready": function(){},
|
|
"onError": function(){},
|
|
"onCustomEvent": function(){}
|
|
});
|
|
|
|
// Assert
|
|
assert.ok(client.handlers().ready);
|
|
assert.ok(client.handlers().error);
|
|
assert.ok(client.handlers().customevent);
|
|
assert.strictEqual(client.handlers().ready.length, 1);
|
|
assert.strictEqual(client.handlers().error.length, 1);
|
|
assert.strictEqual(client.handlers().customevent.length, 1);
|
|
});
|
|
|
|
|
|
test("Unregistering Events", function(assert) {
|
|
assert.expect(6);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var ready = function(){};
|
|
var onError = function(){};
|
|
var onCustomEvent = function(){};
|
|
|
|
// Act
|
|
client.on("ready", ready);
|
|
client.on("onError", onError);
|
|
client.on("onCustomEvent", onCustomEvent);
|
|
|
|
// Assert
|
|
assert.deepEqual(client.handlers().ready, [ready]);
|
|
assert.deepEqual(client.handlers().error, [onError]);
|
|
assert.deepEqual(client.handlers().customevent, [onCustomEvent]);
|
|
|
|
// Act & Assert
|
|
client.off("ready", ready);
|
|
assert.deepEqual(client.handlers().ready, []);
|
|
|
|
// Act & Assert
|
|
client.off("onError", onError);
|
|
assert.deepEqual(client.handlers().error, []);
|
|
|
|
// Act & Assert
|
|
client.off("onCustomEvent", onCustomEvent);
|
|
assert.deepEqual(client.handlers().customevent, []);
|
|
});
|
|
|
|
|
|
test("Unregistering Events with Maps", function(assert) {
|
|
assert.expect(6);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var ready = function(){};
|
|
var onError = function(){};
|
|
var onCustomEvent = function(){};
|
|
|
|
// Act
|
|
client.on("ready", ready);
|
|
client.on("onError", onError);
|
|
client.on("onCustomEvent", onCustomEvent);
|
|
|
|
// Assert
|
|
assert.deepEqual(client.handlers().ready, [ready]);
|
|
assert.deepEqual(client.handlers().error, [onError]);
|
|
assert.deepEqual(client.handlers().customevent, [onCustomEvent]);
|
|
|
|
// Act & Assert
|
|
client.off({ "ready": ready });
|
|
assert.deepEqual(client.handlers().ready, []);
|
|
|
|
// Act & Assert
|
|
client.off({ "onError": onError });
|
|
assert.deepEqual(client.handlers().error, []);
|
|
|
|
// Act & Assert
|
|
client.off({ "onCustomEvent": onCustomEvent });
|
|
assert.deepEqual(client.handlers().customevent, []);
|
|
});
|
|
|
|
|
|
test("Registering two events works", function(assert) {
|
|
assert.expect(6);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
|
|
// Assert
|
|
assert.ok(!client.handlers().ready);
|
|
assert.ok(!client.handlers().aftercopy);
|
|
|
|
// Act
|
|
client.on("ready onaftercopy", function(){});
|
|
|
|
// Assert more
|
|
assert.ok(client.handlers().ready);
|
|
assert.ok(client.handlers().aftercopy);
|
|
assert.strictEqual(client.handlers().ready.length, 1);
|
|
assert.strictEqual(client.handlers().aftercopy.length, 1);
|
|
});
|
|
|
|
|
|
test("Registering two events with a map works", function(assert) {
|
|
assert.expect(6);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
|
|
// Assert
|
|
assert.ok(!client.handlers().ready);
|
|
assert.ok(!client.handlers().aftercopy);
|
|
|
|
// Act
|
|
client.on({
|
|
"ready onaftercopy": function(){}
|
|
});
|
|
|
|
// Assert more
|
|
assert.ok(client.handlers().ready);
|
|
assert.ok(client.handlers().aftercopy);
|
|
assert.strictEqual(client.handlers().ready.length, 1);
|
|
assert.strictEqual(client.handlers().aftercopy.length, 1);
|
|
});
|
|
|
|
|
|
test("Unregistering two events works", function(assert) {
|
|
assert.expect(6);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var func = function() {};
|
|
|
|
// Assert
|
|
assert.ok(!client.handlers().ready);
|
|
assert.ok(!client.handlers().aftercopy);
|
|
|
|
// Act
|
|
client.on("ready onaftercopy", func);
|
|
|
|
// Assert more
|
|
assert.deepEqual(client.handlers().ready, [func]);
|
|
assert.deepEqual(client.handlers().aftercopy, [func]);
|
|
|
|
// Act more
|
|
client.off("ready onaftercopy", func);
|
|
|
|
// Assert even more
|
|
assert.deepEqual(client.handlers().ready, []);
|
|
assert.deepEqual(client.handlers().aftercopy, []);
|
|
});
|
|
|
|
|
|
test("Unregistering two events with a map works", function(assert) {
|
|
assert.expect(6);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var func = function() {};
|
|
|
|
// Assert
|
|
assert.ok(!client.handlers().ready);
|
|
assert.ok(!client.handlers().aftercopy);
|
|
|
|
// Act
|
|
client.on("ready onaftercopy", func);
|
|
|
|
// Assert more
|
|
assert.deepEqual(client.handlers().ready, [func]);
|
|
assert.deepEqual(client.handlers().aftercopy, [func]);
|
|
|
|
// Act more
|
|
client.off({
|
|
"ready onaftercopy": func
|
|
});
|
|
|
|
// Assert even more
|
|
assert.deepEqual(client.handlers().ready, []);
|
|
assert.deepEqual(client.handlers().aftercopy, []);
|
|
});
|
|
|
|
|
|
test("`on` can add multiple handlers for the same event", function(assert) {
|
|
assert.expect(3);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var func1 = function() {};
|
|
var func2 = function() {};
|
|
|
|
// Assert
|
|
assert.ok(!client.handlers().ready);
|
|
|
|
// Act
|
|
client.on("ready", func1);
|
|
|
|
// Assert more
|
|
assert.deepEqual(client.handlers().ready, [func1]);
|
|
|
|
// Act more
|
|
client.on("ready", func2);
|
|
|
|
// Assert even more
|
|
assert.deepEqual(client.handlers().ready, [func1, func2]);
|
|
});
|
|
|
|
|
|
test("`off` can remove multiple handlers for the same event", function(assert) {
|
|
assert.expect(5);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var func1 = function() {};
|
|
var func2 = function() {};
|
|
var func3 = function() {};
|
|
|
|
// Assert
|
|
assert.ok(!client.handlers().ready);
|
|
|
|
// Act
|
|
client.on("ready", func1);
|
|
client.on("ready", func2);
|
|
client.on("ready", func3);
|
|
|
|
// Assert more
|
|
assert.deepEqual(client.handlers().ready, [func1, func2, func3]);
|
|
|
|
// Act and assert even more
|
|
client.off("ready", func3); // Remove from the end
|
|
assert.deepEqual(client.handlers().ready, [func1, func2]);
|
|
|
|
client.off("ready", func1); // Remove from the start
|
|
assert.deepEqual(client.handlers().ready, [func2]);
|
|
|
|
client.off("ready", func2); // Remove the last one
|
|
assert.deepEqual(client.handlers().ready, []);
|
|
});
|
|
|
|
|
|
test("`on` can add more than one entry of the same handler function for the same event", function(assert) {
|
|
assert.expect(2);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var func1 = function() {};
|
|
|
|
// Assert
|
|
assert.ok(!client.handlers().ready);
|
|
|
|
// Act
|
|
client.on("ready", func1);
|
|
client.on("ready", func1);
|
|
|
|
// Assert more
|
|
assert.deepEqual(client.handlers().ready, [func1, func1]);
|
|
});
|
|
|
|
|
|
test("`off` will remove all entries of the same handler function for the same event", function(assert) {
|
|
assert.expect(3);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var func1 = function() {};
|
|
|
|
// Assert
|
|
assert.ok(!client.handlers().ready);
|
|
|
|
// Act
|
|
client.on("ready", func1);
|
|
client.on("ready", func1);
|
|
|
|
// Assert more
|
|
assert.deepEqual(client.handlers().ready, [func1, func1]);
|
|
|
|
// Act more
|
|
client.off("ready", func1);
|
|
|
|
// Assert even more
|
|
assert.deepEqual(client.handlers().ready, []);
|
|
});
|
|
|
|
|
|
test("`off` will remove all handler functions for an event if no function is specified", function(assert) {
|
|
assert.expect(3);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var func1 = function() {};
|
|
var func2 = function() {};
|
|
var func3 = function() {};
|
|
|
|
// Assert
|
|
assert.ok(!client.handlers().ready);
|
|
|
|
// Act
|
|
client.on("ready", func1);
|
|
client.on("ready", func2);
|
|
client.on("ready", func3);
|
|
client.on("ready", func1);
|
|
|
|
// Assert more
|
|
assert.deepEqual(client.handlers().ready, [func1, func2, func3, func1]);
|
|
|
|
// Act and assert even more
|
|
client.off("ready"); // Remove all
|
|
assert.deepEqual(client.handlers().ready, []);
|
|
});
|
|
|
|
|
|
test("`off` will remove all handler functions for all events if no event type is specified", function(assert) {
|
|
assert.expect(6);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var func1 = function() {};
|
|
var func2 = function() {};
|
|
var func3 = function() {};
|
|
|
|
// Assert
|
|
assert.ok(!client.handlers().ready);
|
|
assert.ok(!client.handlers().error);
|
|
|
|
// Act
|
|
client.on("ready", func1);
|
|
client.on("ready", func2);
|
|
client.on("error", func3);
|
|
|
|
// Assert more
|
|
assert.deepEqual(client.handlers().ready, [func1, func2]);
|
|
assert.deepEqual(client.handlers().error, [func3]);
|
|
|
|
// Act and assert even more
|
|
client.off(); // Remove all handlers for all types
|
|
assert.deepEqual(client.handlers().ready, []);
|
|
assert.deepEqual(client.handlers().error, []);
|
|
});
|
|
|
|
|
|
test("Test disabledFlash Event", function(assert) {
|
|
assert.expect(6);
|
|
|
|
// Arrange
|
|
_flashState.disabled = true;
|
|
var client = new ZeroClipboard();
|
|
var id = client.id;
|
|
|
|
// Act (should auto-fire immediately but the handler will be invoked asynchronously)
|
|
client.on( "error", function(event) {
|
|
// Assert
|
|
assert.strictEqual(this, client);
|
|
assert.strictEqual(this.id, id);
|
|
assert.strictEqual(_flashState.disabled, true);
|
|
assert.strictEqual(event.type, "error");
|
|
assert.strictEqual(event.name, "flash-disabled");
|
|
assert.strictEqual(event.target, null);
|
|
QUnit.start();
|
|
} );
|
|
QUnit.stop();
|
|
});
|
|
|
|
|
|
test("Test outdatedFlash Event", function(assert) {
|
|
assert.expect(8);
|
|
|
|
// Arrange
|
|
_flashState.disabled = false;
|
|
_flashState.outdated = true;
|
|
_flashState.version = "10.0.0";
|
|
var client = new ZeroClipboard();
|
|
var id = client.id;
|
|
|
|
// Act
|
|
client.on( "ready", function(/* event */) {
|
|
assert.ok(false, "The `ready` event should NOT have fired!");
|
|
} );
|
|
client.on( "error", function(event) {
|
|
// Assert
|
|
assert.strictEqual(this, client);
|
|
assert.strictEqual(this.id, id);
|
|
assert.strictEqual(_flashState.outdated, true);
|
|
assert.strictEqual(event.type, "error");
|
|
assert.strictEqual(event.name, "flash-outdated");
|
|
assert.strictEqual(event.target, null);
|
|
assert.strictEqual(event.version, "10.0.0");
|
|
assert.strictEqual(event.minimumVersion, "11.0.0");
|
|
QUnit.start();
|
|
} );
|
|
QUnit.stop();
|
|
});
|
|
|
|
|
|
test("Test deactivatedFlash Event", function(assert) {
|
|
assert.expect(10);
|
|
|
|
// Arrange
|
|
_flashState.disabled = false;
|
|
_flashState.outdated = false;
|
|
_flashState.version = "11.0.0";
|
|
ZeroClipboard.config({ flashLoadTimeout: 2000 });
|
|
var client = new ZeroClipboard();
|
|
var id = client.id;
|
|
client.on( "ready", function(/* event */) {
|
|
assert.ok(false, "The `ready` event should NOT have fired!");
|
|
} );
|
|
client.on( "error", function(event) {
|
|
// Assert
|
|
assert.strictEqual(this, client);
|
|
assert.strictEqual(this.id, id);
|
|
assert.strictEqual(_flashState.deactivated, true);
|
|
assert.strictEqual(_flashState.ready, false);
|
|
assert.strictEqual(event.type, "error");
|
|
assert.strictEqual(event.name, "flash-deactivated");
|
|
assert.strictEqual(event.target, null);
|
|
assert.strictEqual(event.version, "11.0.0");
|
|
assert.strictEqual(event.minimumVersion, "11.0.0");
|
|
QUnit.start();
|
|
} );
|
|
|
|
// Act
|
|
setTimeout(function() {
|
|
assert.strictEqual(_flashState.deactivated, null);
|
|
}, 500);
|
|
QUnit.stop();
|
|
// The "deactivatedFlash" event will automatically fire in 2 seconds if the `ready` event does not fire first
|
|
});
|
|
|
|
|
|
test("Test deactivatedFlash Event after first resolution", function(assert) {
|
|
assert.expect(8);
|
|
|
|
// Arrange
|
|
_flashState.disabled = false;
|
|
_flashState.outdated = false;
|
|
_flashState.version = "11.0.0";
|
|
_flashState.deactivated = true;
|
|
var client = new ZeroClipboard();
|
|
var id = client.id;
|
|
client.on( "ready", function(/* event */) {
|
|
assert.ok(false, "The `ready` event should NOT have fired!");
|
|
} );
|
|
client.on( "error", function(event) {
|
|
// Assert
|
|
assert.strictEqual(this, client);
|
|
assert.strictEqual(this.id, id);
|
|
assert.strictEqual(_flashState.deactivated, true);
|
|
assert.strictEqual(event.type, "error");
|
|
assert.strictEqual(event.name, "flash-deactivated");
|
|
assert.strictEqual(event.target, null);
|
|
assert.strictEqual(event.version, "11.0.0");
|
|
assert.strictEqual(event.minimumVersion, "11.0.0");
|
|
QUnit.start();
|
|
} );
|
|
|
|
// Act
|
|
QUnit.stop();
|
|
// The "deactivatedFlash" event will automatically fire in 0 seconds (when the event loop gets to it)
|
|
});
|
|
|
|
|
|
test("Test ready Event", function(assert) {
|
|
assert.expect(6);
|
|
|
|
// Arrange
|
|
_flashState.disabled = false;
|
|
_flashState.outdated = false;
|
|
_flashState.version = "11.9.0";
|
|
var client = new ZeroClipboard();
|
|
var currentEl = document.getElementById("d_clip_button");
|
|
var id = client.id;
|
|
client.clip(currentEl);
|
|
client.on( "ready", function(event) {
|
|
// Assert
|
|
assert.strictEqual(this, client);
|
|
assert.strictEqual(this.id, id);
|
|
assert.strictEqual(event.type, "ready");
|
|
assert.strictEqual(event.target, null);
|
|
assert.strictEqual(_flashState.deactivated, false);
|
|
assert.strictEqual(event.version, "11.9.0");
|
|
QUnit.start();
|
|
} );
|
|
|
|
// Act
|
|
QUnit.stop();
|
|
ZeroClipboard.emit("ready");
|
|
});
|
|
|
|
|
|
test("Test ready Event after first load", function(assert) {
|
|
assert.expect(6);
|
|
|
|
// Arrange
|
|
_flashState.disabled = false;
|
|
_flashState.outdated = false;
|
|
_flashState.deactivated = false;
|
|
_flashState.version = "11.9.0";
|
|
_flashState.ready = true;
|
|
_flashState.bridge = {};
|
|
var client = new ZeroClipboard();
|
|
var id = client.id;
|
|
|
|
// Act (should auto-fire immediately but the handler will be invoked asynchronously)
|
|
client.on( "ready", function(event) {
|
|
// Assert
|
|
assert.strictEqual(this, client);
|
|
assert.strictEqual(this.id, id);
|
|
assert.strictEqual(event.type, "ready");
|
|
assert.strictEqual(event.target, null);
|
|
assert.strictEqual(_flashState.deactivated, false);
|
|
assert.strictEqual(event.version, "11.9.0");
|
|
QUnit.start();
|
|
} );
|
|
QUnit.stop();
|
|
});
|
|
|
|
|
|
test("Test overdueFlash Event", function(assert) {
|
|
assert.expect(15);
|
|
|
|
// Arrange
|
|
_flashState.disabled = false;
|
|
_flashState.outdated = false;
|
|
_flashState.version = "11.0.0";
|
|
_flashState.deactivated = true;
|
|
var client = new ZeroClipboard();
|
|
var id = client.id;
|
|
client.on( "ready", function(/* event */) {
|
|
assert.ok(false, "The `ready` event should NOT have fired!");
|
|
} );
|
|
client.on( "error", function(event) {
|
|
// Assert
|
|
assert.strictEqual(this, client);
|
|
assert.strictEqual(this.id, id);
|
|
if (event.name === "flash-deactivated") {
|
|
assert.strictEqual(event.type, "error");
|
|
assert.strictEqual(event.name, "flash-deactivated");
|
|
assert.strictEqual(_flashState.deactivated, true);
|
|
assert.strictEqual(event.version, "11.0.0");
|
|
assert.strictEqual(event.minimumVersion, "11.0.0");
|
|
}
|
|
else if (event.name === "flash-overdue") {
|
|
assert.strictEqual(event.type, "error");
|
|
assert.strictEqual(event.name, "flash-overdue");
|
|
assert.strictEqual(_flashState.deactivated, false);
|
|
assert.strictEqual(_flashState.overdue, true);
|
|
assert.strictEqual(event.version, "11.0.0");
|
|
assert.strictEqual(event.minimumVersion, "11.0.0");
|
|
|
|
QUnit.start();
|
|
}
|
|
} );
|
|
|
|
// Act
|
|
QUnit.stop();
|
|
// The "deactivatedFlash" event will automatically fire in 0 seconds (when the event loop gets to it)
|
|
|
|
setTimeout(function() {
|
|
// Emit a "ready" event (as if from the SWF) to trigger an "overdueFlash" event
|
|
ZeroClipboard.emit("ready");
|
|
}, 1000);
|
|
});
|
|
|
|
|
|
test("Test string function name as handler", function(assert) {
|
|
assert.expect(2);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var currentEl = document.getElementById("d_clip_button");
|
|
var id = client.id;
|
|
client.clip(currentEl);
|
|
window.zcLoadCallback = function(event) {
|
|
// Assert
|
|
assert.strictEqual(this.id, id);
|
|
assert.strictEqual(event.type, "ready");
|
|
QUnit.start();
|
|
delete window.zcLoadCallback;
|
|
};
|
|
client.on( "ready", "zcLoadCallback" );
|
|
|
|
// Act
|
|
QUnit.stop();
|
|
ZeroClipboard.emit("ready");
|
|
});
|
|
|
|
|
|
test("Test EventListener object as handler", function(assert) {
|
|
assert.expect(4);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var currentEl = document.getElementById("d_clip_button");
|
|
var id = client.id;
|
|
client.clip(currentEl);
|
|
var eventListenerObj = {
|
|
handleEvent: function(event) {
|
|
// Assert
|
|
assert.strictEqual(event.type, "ready");
|
|
assert.strictEqual(event.client, client);
|
|
assert.strictEqual(event.client.id, id);
|
|
assert.strictEqual(this, eventListenerObj);
|
|
QUnit.start();
|
|
}
|
|
};
|
|
client.on( "ready", eventListenerObj );
|
|
|
|
// Act
|
|
QUnit.stop();
|
|
ZeroClipboard.emit("ready");
|
|
});
|
|
|
|
|
|
test("Test for appropriate context inside of invoked event handlers", function(assert) {
|
|
assert.expect(12);
|
|
|
|
// Arrange
|
|
var client = new ZeroClipboard();
|
|
var currentEl = document.getElementById("d_clip_button");
|
|
assert.ok(currentEl);
|
|
assert.strictEqual(currentEl.id, "d_clip_button");
|
|
|
|
client.clip(currentEl);
|
|
ZeroClipboard.activate(currentEl);
|
|
|
|
client.on( "ready error", function(/* event */) {
|
|
// Assert
|
|
assert.strictEqual(this, client);
|
|
} );
|
|
client.on( "beforecopy", function(event) {
|
|
// Assert
|
|
assert.strictEqual(event.target, currentEl);
|
|
} );
|
|
client.on( "copy", function(event) {
|
|
// Assert
|
|
assert.strictEqual(event.target, currentEl);
|
|
assert.ok(_clipData["text/plain"]);
|
|
} );
|
|
client.on( "aftercopy", function(event) {
|
|
// Assert
|
|
assert.strictEqual(event.target, currentEl);
|
|
assert.ok(!_clipData["text/plain"]);
|
|
QUnit.start();
|
|
} );
|
|
|
|
// Act
|
|
QUnit.stop();
|
|
ZeroClipboard.emit("ready");
|
|
ZeroClipboard.emit({"type":"error", "name":"flash-disabled"});
|
|
ZeroClipboard.emit({"type":"error", "name":"flash-outdated"});
|
|
ZeroClipboard.emit({"type":"error", "name":"flash-deactivated"});
|
|
ZeroClipboard.emit({"type":"error", "name":"flash-overdue"});
|
|
ZeroClipboard.emit("beforecopy");
|
|
ZeroClipboard.emit("copy");
|
|
ZeroClipboard.emit("aftercopy");
|
|
});
|
|
|
|
|
|
module("client/api.js unit tests - element clipping", {
|
|
setup: function() {
|
|
// Store
|
|
originalConfig = ZeroClipboard.config();
|
|
// Modify
|
|
ZeroClipboard.config({ swfPath: originalConfig.swfPath.replace(/\/(?:src|test)\/.*$/i, "/dist/ZeroClipboard.swf") });
|
|
},
|
|
teardown: function() {
|
|
ZeroClipboard.destroy();
|
|
ZeroClipboard.config(originalConfig);
|
|
}
|
|
});
|
|
|
|
|
|
test("Client without selector doesn't have elements", function(assert) {
|
|
assert.expect(2);
|
|
|
|
// Arrange & Act
|
|
var client = new ZeroClipboard();
|
|
|
|
// Assert
|
|
assert.ok(client);
|
|
assert.deepEqual(client.elements(), []);
|
|
});
|
|
|
|
|
|
})(QUnit.module, QUnit.test);
|