Adding some test for loading jquery.sheet gadget and reset, saving, loading sheets

src/lib/qunit/qunit.css

+/**
+ * QUnit v1.12.0 - A JavaScript Unit Testing Framework
+ *
+ * http://qunitjs.com
+ *
+ * Copyright 2012 jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+/** Font Family and Sizes */
+
+#qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
+	font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
+}
+
+#qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
+#qunit-tests { font-size: smaller; }
+
+
+/** Resets */
+
+#qunit-tests, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter {
+	margin: 0;
+	padding: 0;
+}
+
+
+/** Header */
+
+#qunit-header {
+	padding: 0.5em 0 0.5em 1em;
+
+	color: #8699a4;
+	background-color: #0d3349;
+
+	font-size: 1.5em;
+	line-height: 1em;
+	font-weight: normal;
+
+	border-radius: 5px 5px 0 0;
+	-moz-border-radius: 5px 5px 0 0;
+	-webkit-border-top-right-radius: 5px;
+	-webkit-border-top-left-radius: 5px;
+}
+
+#qunit-header a {
+	text-decoration: none;
+	color: #c2ccd1;
+}
+
+#qunit-header a:hover,
+#qunit-header a:focus {
+	color: #fff;
+}
+
+#qunit-testrunner-toolbar label {
+	display: inline-block;
+	padding: 0 .5em 0 .1em;
+}
+
+#qunit-banner {
+	height: 5px;
+}
+
+#qunit-testrunner-toolbar {
+	padding: 0.5em 0 0.5em 2em;
+	color: #5E740B;
+	background-color: #eee;
+	overflow: hidden;
+}
+
+#qunit-userAgent {
+	padding: 0.5em 0 0.5em 2.5em;
+	background-color: #2b81af;
+	color: #fff;
+	text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
+}
+
+#qunit-modulefilter-container {
+	float: right;
+}
+
+/** Tests: Pass/Fail */
+
+#qunit-tests {
+	list-style-position: inside;
+}
+
+#qunit-tests li {
+	padding: 0.4em 0.5em 0.4em 2.5em;
+	border-bottom: 1px solid #fff;
+	list-style-position: inside;
+}
+
+#qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running  {
+	display: none;
+}
+
+#qunit-tests li strong {
+	cursor: pointer;
+}
+
+#qunit-tests li a {
+	padding: 0.5em;
+	color: #c2ccd1;
+	text-decoration: none;
+}
+#qunit-tests li a:hover,
+#qunit-tests li a:focus {
+	color: #000;
+}
+
+#qunit-tests li .runtime {
+	float: right;
+	font-size: smaller;
+}
+
+.qunit-assert-list {
+	margin-top: 0.5em;
+	padding: 0.5em;
+
+	background-color: #fff;
+
+	border-radius: 5px;
+	-moz-border-radius: 5px;
+	-webkit-border-radius: 5px;
+}
+
+.qunit-collapsed {
+	display: none;
+}
+
+#qunit-tests table {
+	border-collapse: collapse;
+	margin-top: .2em;
+}
+
+#qunit-tests th {
+	text-align: right;
+	vertical-align: top;
+	padding: 0 .5em 0 0;
+}
+
+#qunit-tests td {
+	vertical-align: top;
+}
+
+#qunit-tests pre {
+	margin: 0;
+	white-space: pre-wrap;
+	word-wrap: break-word;
+}
+
+#qunit-tests del {
+	background-color: #e0f2be;
+	color: #374e0c;
+	text-decoration: none;
+}
+
+#qunit-tests ins {
+	background-color: #ffcaca;
+	color: #500;
+	text-decoration: none;
+}
+
+/*** Test Counts */
+
+#qunit-tests b.counts                       { color: black; }
+#qunit-tests b.passed                       { color: #5E740B; }
+#qunit-tests b.failed                       { color: #710909; }
+
+#qunit-tests li li {
+	padding: 5px;
+	background-color: #fff;
+	border-bottom: none;
+	list-style-position: inside;
+}
+
+/*** Passing Styles */
+
+#qunit-tests li li.pass {
+	color: #3c510c;
+	background-color: #fff;
+	border-left: 10px solid #C6E746;
+}
+
+#qunit-tests .pass                          { color: #528CE0; background-color: #D2E0E6; }
+#qunit-tests .pass .test-name               { color: #366097; }
+
+#qunit-tests .pass .test-actual,
+#qunit-tests .pass .test-expected           { color: #999999; }
+
+#qunit-banner.qunit-pass                    { background-color: #C6E746; }
+
+/*** Failing Styles */
+
+#qunit-tests li li.fail {
+	color: #710909;
+	background-color: #fff;
+	border-left: 10px solid #EE5757;
+	white-space: pre;
+}
+
+#qunit-tests > li:last-child {
+	border-radius: 0 0 5px 5px;
+	-moz-border-radius: 0 0 5px 5px;
+	-webkit-border-bottom-right-radius: 5px;
+	-webkit-border-bottom-left-radius: 5px;
+}
+
+#qunit-tests .fail                          { color: #000000; background-color: #EE5757; }
+#qunit-tests .fail .test-name,
+#qunit-tests .fail .module-name             { color: #000000; }
+
+#qunit-tests .fail .test-actual             { color: #EE5757; }
+#qunit-tests .fail .test-expected           { color: green;   }
+
+#qunit-banner.qunit-fail                    { background-color: #EE5757; }
+
+
+/** Result */
+
+#qunit-testresult {
+	padding: 0.5em 0.5em 0.5em 2.5em;
+
+	color: #2b81af;
+	background-color: #D2E0E6;
+
+	border-bottom: 1px solid white;
+}
+#qunit-testresult .module-name {
+	font-weight: bold;
+}
+
+/** Fixture */
+
+#qunit-fixture {
+	position: absolute;
+	top: -10000px;
+	left: -10000px;
+	width: 1000px;
+	height: 1000px;
+}

src/lib/sinon/sinon-qunit.js

+/**
+ * sinon-qunit 1.0.0, 2010/12/09
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ *
+ * (The BSD License)
+ * 
+ * Copyright (c) 2010-2011, Christian Johansen, christian@cjohansen.no
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ *     * Redistributions of source code must retain the above copyright notice,
+ *       this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright notice,
+ *       this list of conditions and the following disclaimer in the documentation
+ *       and/or other materials provided with the distribution.
+ *     * Neither the name of Christian Johansen nor the names of his contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*global sinon, QUnit, test*/
+sinon.assert.fail = function (msg) {
+    QUnit.ok(false, msg);
+};
+
+sinon.assert.pass = function (assertion) {
+    QUnit.ok(true, assertion);
+};
+
+sinon.config = {
+    injectIntoThis: true,
+    injectInto: null,
+    properties: ["spy", "stub", "mock", "clock", "sandbox"],
+    useFakeTimers: true,
+    useFakeServer: false
+};
+
+(function (global) {
+    var qTest = QUnit.test;
+    
+    QUnit.test = global.test = function (testName, expected, callback, async) {
+        if (arguments.length === 2) {
+            callback = expected;
+            expected = null;
+        }
+
+        return qTest(testName, expected, sinon.test(callback), async);
+    };
+}(this));

test/jqs-gadget-test.html

+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, height=device-height"/>
+    
+    <title>Test Jquery Spreadsheet Gadget</title>
+    
+    <link rel="stylesheet" href="../src/lib/qunit/qunit.css">
+    
+    <script src="../src/lib/jquery.js"></script>
+    <script src="../src/lib/qunit/qunit.js"></script>
+    <script src="../src/lib/sinon/sinon.js"></script>
+    <script src="../src/lib/jschannel.js"></script>
+    <script src="../src/lib/renderjs.js"></script>
+    <script src="jqs-gadget-test.js"></script>
+  </head>
+  <body>
+    <div id="qunit"></div>
+    <div id="qunit-fixture"></div>
+    <div class="jqs-gadget"></div>
+  </body>
+</html>

test/jqs-gadget-test.js

+/*global window, document, QUnit, jQuery, rJS, sinon */
+/*jslint indent: 2, maxerr: 3, maxlen: 79 */
+"use strict";
+
+QUnit.config.testTimeout = 500;
+
+(function (window, $, QUnit, sinon, rJS) {
+  var test = QUnit.test,
+    stop = QUnit.stop,
+    start = QUnit.start,
+    ok = QUnit.ok,
+    equal = QUnit.equal,
+    expect = QUnit.expect,
+    throws = QUnit.throws,
+    deepEqual = QUnit.deepEqual;
+  
+  function iframeSelector(selectorString) {
+    return $('iframe').contents().find(selectorString);
+  }
+
+  rJS(window).ready(function () {
+    var g = rJS(this),
+      jqs_context = g.context.find('.jqs-gadget').first();
+   
+    asyncTest("jquery.sheet loading", function () {
+      expect(2);
+      g.declareIframedGadget('../src/gadget/jqs.html', jqs_context);
+      
+      setTimeout(function () {
+        ok(iframeSelector("table.jSheet td#0_table0_cell_c0_r0").length != 0);
+        ok(iframeSelector("table.jSheet td#0_table0_cell_c1_r1").length != 0);
+        start();
+      },100);
+    });
+
+    asyncTest("reset sheet", function () {
+      expect(2);
+      g.declareIframedGadget('../src/gadget/jqs.html', jqs_context)
+        .then(function (gadget) {
+          iframeSelector("table.jSheet td#0_table0_cell_c0_r0").html('c0r0Value');
+          iframeSelector("table.jSheet td#0_table0_cell_c1_r1").html('c1r1Value');
+          return gadget;
+        })
+        .then(function (gadget) {
+          gadget.resetSheet().then(function () {
+            equal(iframeSelector("table.jSheet td#0_table0_cell_c0_r0").text(),"");
+            equal(iframeSelector("table.jSheet td#0_table0_cell_c1_r1").text(),"");
+            start();
+          });
+        });
+    });
+    
+    asyncTest("get content of sheet", function () {
+      expect(2);
+      var c0r0selector, c1r1selector;
+      g.declareIframedGadget('../src/gadget/jqs.html', jqs_context)
+        .then(function (gadget) {
+          iframeSelector("table.jSheet td#0_table0_cell_c0_r0").html('c0r0Value');
+          iframeSelector("table.jSheet td#0_table0_cell_c1_r1").html('c1r1Value');
+          return gadget;
+        })
+        .then(function (gadget) {
+          gadget.getContent().then(function (content) {
+            var json = JSON.parse(content)[0];
+            equal(json.data.r0.c0.value,"c0r0Value");
+            equal(json.data.r1.c1.value,"c1r1Value");
+            start();
+          });
+        });
+    });
+
+    asyncTest("set content of sheet", function () {
+      expect(4);
+      var gadget, content; 
+
+      g.declareIframedGadget('../src/gadget/jqs.html', jqs_context)
+        .then(function (gd) {
+          iframeSelector("table.jSheet td#0_table0_cell_c0_r0").html('c0r0Value');
+          iframeSelector("table.jSheet td#0_table0_cell_c1_r1").html('c1r1Value');
+          gadget = gd;
+        })
+        .always(function () {
+          gadget.getContent()
+            .then(function (c) {content = c;})
+            .always(function () {
+              gadget.resetSheet().then(function () {
+                equal(iframeSelector("table.jSheet td#0_table0_cell_c0_r0").text(),"");
+                equal(iframeSelector("table.jSheet td#0_table0_cell_c1_r1").text(),"");
+              })
+                .always(function () {
+                  gadget.putContent(content)
+                    .always(function () {
+                      equal(iframeSelector("table.jSheet td#2_table0_cell_c0_r0").text(),"c0r0Value");
+                      equal(iframeSelector("table.jSheet td#2_table0_cell_c1_r1").text(),"c1r1Value");
+                      start();
+                    });
+                });
+            });
+        });
+    });
+  });
+} (window, jQuery, QUnit, sinon, rJS));
+    

test/runner.js

+/*
+ * QtWebKit-powered headless test runner using PhantomJS
+ *
+ * PhantomJS binaries: http://phantomjs.org/download.html
+ * Requires PhantomJS 1.6+ (1.7+ recommended)
+ *
+ * Run with:
+ *   phantomjs runner.js [url-of-your-qunit-testsuite]
+ *
+ * e.g.
+ *   phantomjs runner.js http://localhost/qunit/test/index.html
+ */
+
+/*global phantom:false, require:false, console:false, window:false, QUnit:false */
+
+(function() {
+  'use strict';
+
+  var url, page, timeout,
+  args = require('system').args;
+
+  // arg[0]: scriptName, args[1...]: arguments
+  if (args.length < 2 || args.length > 3) {
+    console.error('Usage:\n  phantomjs runner.js [url-of-your-qunit-testsuite] [timeout-in-seconds]');
+    phantom.exit(1);
+  }
+
+  url = args[1];
+  page = require('webpage').create();
+  if (args[2] !== undefined) {
+    timeout = parseInt(args[2], 10);
+  }
+
+  // Route `console.log()` calls from within the Page context to the main Phantom context (i.e. current `this`)
+  page.onConsoleMessage = function(msg) {
+    console.log(msg);
+  };
+
+  page.onInitialized = function() {
+    page.evaluate(addLogging);
+  };
+
+  page.onCallback = function(message) {
+    var result,
+    failed;
+
+    if (message) {
+      if (message.name === 'QUnit.done') {
+	result = message.data;
+	failed = !result || result.failed;
+
+	phantom.exit(failed ? 1 : 0);
+      }
+    }
+  };
+
+  page.open(url, function(status) {
+    if (status !== 'success') {
+      console.error('Unable to access network: ' + status);
+      phantom.exit(1);
+    } else {
+      // Cannot do this verification with the 'DOMContentLoaded' handler because it
+      // will be too late to attach it if a page does not have any script tags.
+      var qunitMissing = page.evaluate(function() { return (typeof QUnit === 'undefined' || !QUnit); });
+      if (qunitMissing) {
+	console.error('The `QUnit` object is not present on this page.');
+	phantom.exit(1);
+      }
+
+      // Set a timeout on the test running, otherwise tests with async problems will hang forever
+      if (typeof timeout === 'number') {
+	setTimeout(function() {
+	  console.error('The specified timeout of ' + timeout + ' seconds has expired. Aborting...');
+	  phantom.exit(1);
+	}, timeout * 1000);
+      }
+
+      // Do nothing... the callback mechanism will handle everything!
+    }
+  });
+
+  function addLogging() {
+    window.document.addEventListener('DOMContentLoaded', function() {
+      var currentTestAssertions = [];
+
+      QUnit.log(function(details) {
+	var response;
+
+	// Ignore passing assertions
+	if (details.result) {
+	  return;
+	}
+
+	response = details.message || '';
+
+	if (typeof details.expected !== 'undefined') {
+	  if (response) {
+	    response += ', ';
+	  }
+
+	  response += 'expected: ' + details.expected + ', but was: ' + details.actual;
+	}
+
+	if (details.source) {
+	  response += "\n" + details.source;
+	}
+
+	currentTestAssertions.push('Failed assertion: ' + response);
+      });
+
+      QUnit.testDone(function(result) {
+	var i,
+	len,
+	name = result.module + ': ' + result.name;
+
+	if (result.failed) {
+	  console.log('Test failed: ' + name);
+
+	  for (i = 0, len = currentTestAssertions.length; i < len; i++) {
+	    console.log('    ' + currentTestAssertions[i]);
+	  }
+	}
+
+	currentTestAssertions.length = 0;
+      });
+
+      QUnit.done(function(result) {
+	console.log('Took ' + result.runtime +  'ms to run ' + result.total + ' tests. ' + result.passed + ' passed, ' + result.failed + ' failed.');
+
+	if (typeof window.callPhantom === 'function') {
+	  window.callPhantom({
+	    'name': 'QUnit.done',
+	    'data': result
+	  });
+	}
+      });
+    }, false);
+  }
+})();