alloy-js-test-san 0.1.0

data/test/regression/prototype/unit/tests/ajax_test.js

@@ -0,0 +1,379 @@
+var extendDefault = function(options) {
+  return Object.extend({
+    asynchronous: false,
+    method: 'get',
+    onException: function(e) { throw e }
+  }, options);
+};
+
+new Test.Unit.Runner({
+  setup: function() {
+    $('content').update('');
+    $('content2').update('');
+  },
+  
+  teardown: function() {
+    // hack to cleanup responders
+    Ajax.Responders.responders = [Ajax.Responders.responders[0]];
+  },
+  
+  testSynchronousRequest: function() {
+    this.assertEqual("", $("content").innerHTML);
+    
+    this.assertEqual(0, Ajax.activeRequestCount);
+    new Ajax.Request("../fixtures/hello.js", {
+      asynchronous: false,
+      method: 'GET',
+      evalJS: 'force'
+    });
+    this.assertEqual(0, Ajax.activeRequestCount);
+    
+    var h2 = $("content").firstChild;
+    this.assertEqual("Hello world!", h2.innerHTML);
+  },
+  
+  testAsynchronousRequest: function() {
+    this.assertEqual("", $("content").innerHTML);
+    
+    new Ajax.Request("../fixtures/hello.js", {
+      asynchronous: true,
+      method: 'get',
+      evalJS: 'force'
+    });
+    this.wait(1000, function() {
+      var h2 = $("content").firstChild;
+      this.assertEqual("Hello world!", h2.innerHTML);
+    });
+  },
+  
+  testUpdater: function() {
+    this.assertEqual("", $("content").innerHTML);
+    
+    new Ajax.Updater("content", "../fixtures/content.html", { method:'get' });
+    
+    this.wait(1000, function() {
+      this.assertEqual(sentence, $("content").innerHTML.strip().toLowerCase());
+      
+      $('content').update('');
+      this.assertEqual("", $("content").innerHTML);
+       
+      new Ajax.Updater({ success:"content", failure:"content2" },
+        "../fixtures/content.html", { method:'get', parameters:{ pet:'monkey' } });
+      
+      new Ajax.Updater("", "../fixtures/content.html", { method:'get', parameters:"pet=monkey" });
+      
+      this.wait(1000, function() {
+        this.assertEqual(sentence, $("content").innerHTML.strip().toLowerCase());
+        this.assertEqual("", $("content2").innerHTML);
+      });
+    }); 
+  },
+  
+  testUpdaterWithInsertion: function() {
+    $('content').update();
+    new Ajax.Updater("content", "../fixtures/content.html", { method:'get', insertion: Insertion.Top });
+    this.wait(1000, function() {
+      this.assertEqual(sentence, $("content").innerHTML.strip().toLowerCase());
+      $('content').update();
+      new Ajax.Updater("content", "../fixtures/content.html", { method:'get', insertion: 'bottom' });      
+      this.wait(1000, function() {
+        this.assertEqual(sentence, $("content").innerHTML.strip().toLowerCase());
+        
+        $('content').update();
+        new Ajax.Updater("content", "../fixtures/content.html", { method:'get', insertion: 'after' });      
+        this.wait(1000, function() {
+          this.assertEqual('five dozen', $("content").next().innerHTML.strip().toLowerCase());
+        });
+      });
+    });
+  },
+  
+  testUpdaterOptions: function() {
+    var options = {
+      method: 'get',
+      asynchronous: false,
+      evalJS: 'force',
+      onComplete: Prototype.emptyFunction
+    }
+    var request = new Ajax.Updater("content", "../fixtures/hello.js", options);
+    request.options.onComplete = Prototype.emptyFunction;
+    this.assertIdentical(Prototype.emptyFunction, options.onComplete);
+  },
+  
+  testResponders: function(){
+    // check for internal responder
+    this.assertEqual(1, Ajax.Responders.responders.length);
+    
+    var dummyResponder = {
+      onComplete: Prototype.emptyFunction
+    };
+    
+    Ajax.Responders.register(dummyResponder);
+    this.assertEqual(2, Ajax.Responders.responders.length);
+    
+    // don't add twice
+    Ajax.Responders.register(dummyResponder);
+    this.assertEqual(2, Ajax.Responders.responders.length);
+    
+    Ajax.Responders.unregister(dummyResponder);
+    this.assertEqual(1, Ajax.Responders.responders.length);
+    
+    var responder = {
+      onCreate:   function(req){ responderCounter++ },
+      onLoading:  function(req){ responderCounter++ },
+      onComplete: function(req){ responderCounter++ }
+    };
+    Ajax.Responders.register(responder);
+    
+    this.assertEqual(0, responderCounter);
+    this.assertEqual(0, Ajax.activeRequestCount);
+    new Ajax.Request("../fixtures/content.html", { method:'get', parameters:"pet=monkey" });
+    this.assertEqual(1, responderCounter);
+    this.assertEqual(1, Ajax.activeRequestCount);
+    
+    this.wait(1000,function() {
+      this.assertEqual(3, responderCounter);
+      this.assertEqual(0, Ajax.activeRequestCount);
+    });
+  },
+  
+  testEvalResponseShouldBeCalledBeforeOnComplete: function() {
+    if (this.isRunningFromRake) {
+      this.assertEqual("", $("content").innerHTML);
+    
+      this.assertEqual(0, Ajax.activeRequestCount);
+      new Ajax.Request("../fixtures/hello.js", extendDefault({
+        onComplete: function(response) { this.assertNotEqual("", $("content").innerHTML) }.bind(this)
+      }));
+      this.assertEqual(0, Ajax.activeRequestCount);
+    
+      var h2 = $("content").firstChild;
+      this.assertEqual("Hello world!", h2.innerHTML);
+    } else {
+      this.info(message);
+    }
+  },
+  
+  testContentTypeSetForSimulatedVerbs: function() {
+    if (this.isRunningFromRake) {
+      new Ajax.Request('/inspect', extendDefault({
+        method: 'put',
+        contentType: 'application/bogus',
+        onComplete: function(response) {
+          this.assertEqual('application/bogus; charset=UTF-8', response.responseJSON.headers['content-type']);
+        }.bind(this)
+      }));
+    } else {
+      this.info(message);
+    }
+  },
+  
+  testOnCreateCallback: function() {
+    new Ajax.Request("../fixtures/content.html", extendDefault({
+      onCreate: function(transport) { this.assertEqual(0, transport.readyState) }.bind(this),
+      onComplete: function(transport) { this.assertNotEqual(0, transport.readyState) }.bind(this)
+    }));
+  },
+  
+  testEvalJS: function() {
+    if (this.isRunningFromRake) {
+      
+      $('content').update();
+      new Ajax.Request("/response", extendDefault({
+        parameters: Fixtures.js,
+        onComplete: function(transport) { 
+          var h2 = $("content").firstChild;
+          this.assertEqual("Hello world!", h2.innerHTML);
+        }.bind(this)
+      }));
+      
+      $('content').update();
+      new Ajax.Request("/response", extendDefault({
+        evalJS: false,
+        parameters: Fixtures.js,
+        onComplete: function(transport) { 
+          this.assertEqual("", $("content").innerHTML);
+        }.bind(this)
+      }));
+    } else {
+      this.info(message);
+    }
+    
+    $('content').update();
+    new Ajax.Request("../fixtures/hello.js", extendDefault({
+      evalJS: 'force',
+      onComplete: function(transport) { 
+        var h2 = $("content").firstChild;
+        this.assertEqual("Hello world!", h2.innerHTML);
+      }.bind(this)
+    }));
+  },
+
+  testCallbacks: function() {
+    var options = extendDefault({
+      onCreate: function(transport) { this.assertInstanceOf(Ajax.Response, transport) }.bind(this)
+    });
+    
+    Ajax.Request.Events.each(function(state){
+      options['on' + state] = options.onCreate;
+    });
+
+    new Ajax.Request("../fixtures/content.html", options);
+  },
+
+  testResponseText: function() {
+    new Ajax.Request("../fixtures/empty.html", extendDefault({
+      onComplete: function(transport) { this.assertEqual('', transport.responseText) }.bind(this)
+    }));
+    
+    new Ajax.Request("../fixtures/content.html", extendDefault({
+      onComplete: function(transport) { this.assertEqual(sentence, transport.responseText.toLowerCase()) }.bind(this)
+    }));
+  },
+  
+  testResponseXML: function() {
+    if (this.isRunningFromRake) {
+      new Ajax.Request("/response", extendDefault({
+        parameters: Fixtures.xml,
+        onComplete: function(transport) { 
+          this.assertEqual('foo', transport.responseXML.getElementsByTagName('name')[0].getAttribute('attr'))
+        }.bind(this)
+      }));
+    } else {
+      this.info(message);
+    }
+  },
+      
+  testResponseJSON: function() {
+    if (this.isRunningFromRake) {
+      new Ajax.Request("/response", extendDefault({
+        parameters: Fixtures.json,
+        onComplete: function(transport) { this.assertEqual(123, transport.responseJSON.test) }.bind(this)
+      }));
+      
+      new Ajax.Request("/response", extendDefault({
+        parameters: {
+          'Content-Length': 0,
+          'Content-Type': 'application/json'
+        },
+        onComplete: function(transport) { this.assertNull(transport.responseJSON) }.bind(this)
+      }));
+      
+      new Ajax.Request("/response", extendDefault({
+        evalJSON: false,
+        parameters: Fixtures.json,
+        onComplete: function(transport) { this.assertNull(transport.responseJSON) }.bind(this)
+      }));
+    
+      new Ajax.Request("/response", extendDefault({
+        parameters: Fixtures.jsonWithoutContentType,
+        onComplete: function(transport) { this.assertNull(transport.responseJSON) }.bind(this)
+      }));
+    
+      new Ajax.Request("/response", extendDefault({
+        sanitizeJSON: true,
+        parameters: Fixtures.invalidJson,
+        onException: function(request, error) {
+          this.assert(error.message.include('Badly formed JSON string'));
+          this.assertInstanceOf(Ajax.Request, request);
+        }.bind(this)
+      }));
+    } else {
+      this.info(message);
+    }
+    
+    new Ajax.Request("../fixtures/data.json", extendDefault({
+      evalJSON: 'force',
+      onComplete: function(transport) { this.assertEqual(123, transport.responseJSON.test) }.bind(this)
+    }));
+  },
+  
+  testHeaderJSON: function() {
+    if (this.isRunningFromRake) {
+      new Ajax.Request("/response", extendDefault({
+        parameters: Fixtures.headerJson,
+        onComplete: function(transport, json) {
+          this.assertEqual('hello #éà', transport.headerJSON.test);
+          this.assertEqual('hello #éà', json.test);
+        }.bind(this)
+      }));
+    
+      new Ajax.Request("/response", extendDefault({
+        onComplete: function(transport, json) { 
+          this.assertNull(transport.headerJSON)
+          this.assertNull(json)
+        }.bind(this)
+      }));
+    } else {
+      this.info(message);
+    }
+  },
+  
+  testGetHeader: function() {
+    if (this.isRunningFromRake) {
+     new Ajax.Request("/response", extendDefault({
+        parameters: { 'X-TEST': 'some value' },
+        onComplete: function(transport) {
+          this.assertEqual('some value', transport.getHeader('X-Test'));
+          this.assertNull(transport.getHeader('X-Inexistant'));
+        }.bind(this)
+      }));
+    } else {
+      this.info(message);
+    }
+  },
+  
+  testParametersCanBeHash: function() {
+    if (this.isRunningFromRake) {
+      new Ajax.Request("/response", extendDefault({
+        parameters: $H({ "one": "two", "three": "four" }),
+        onComplete: function(transport) {
+          this.assertEqual("two", transport.getHeader("one"));
+          this.assertEqual("four", transport.getHeader("three"));
+          this.assertNull(transport.getHeader("toObject"));
+        }.bind(this)
+      }));
+    } else {
+      this.info(message);
+    }
+  },
+  
+  testIsSameOriginMethod: function() {
+    var isSameOrigin = Ajax.Request.prototype.isSameOrigin;
+    this.assert(isSameOrigin.call({ url: '/foo/bar.html' }), '/foo/bar.html');
+    this.assert(isSameOrigin.call({ url: window.location.toString() }), window.location);
+    this.assert(!isSameOrigin.call({ url: 'http://example.com' }), 'http://example.com');
+
+    if (this.isRunningFromRake) {
+      Ajax.Request.prototype.isSameOrigin = function() {
+        return false
+      };
+
+      $("content").update('same origin policy');
+      new Ajax.Request("/response", extendDefault({
+        parameters: Fixtures.js,
+        onComplete: function(transport) { 
+          this.assertEqual("same origin policy", $("content").innerHTML);
+        }.bind(this)
+      }));
+
+      new Ajax.Request("/response", extendDefault({
+        parameters: Fixtures.invalidJson,
+        onException: function(request, error) {
+          this.assert(error.message.include('Badly formed JSON string'));
+        }.bind(this)
+      }));
+
+      new Ajax.Request("/response", extendDefault({
+        parameters: { 'X-JSON': '{});window.attacked = true;({}' },
+        onException: function(request, error) {
+          this.assert(error.message.include('Badly formed JSON string'));
+        }.bind(this)
+      }));
+
+      Ajax.Request.prototype.isSameOrigin = isSameOrigin;
+    } else {
+      this.info(message);
+    }
+  }
+});

data/test/regression/prototype/unit/tests/array_test.js

@@ -0,0 +1,186 @@
+var globalArgsTest = 'nothing to see here';
+
+new Test.Unit.Runner({
+  test$A: function(){
+    this.assertEnumEqual([], $A({}));
+  },
+  
+  testToArrayOnArguments: function(){
+    function toArrayOnArguments(){
+      globalArgsTest = $A(arguments);
+    }
+    toArrayOnArguments();
+    this.assertEnumEqual([], globalArgsTest);
+    toArrayOnArguments('foo');
+    this.assertEnumEqual(['foo'], globalArgsTest);
+    toArrayOnArguments('foo','bar');
+    this.assertEnumEqual(['foo','bar'], globalArgsTest);
+  },
+  
+  testToArrayOnNodeList: function(){
+    // direct HTML
+    this.assertEqual(3, $A($('test_node').childNodes).length);
+    
+    // DOM
+    var element = document.createElement('div');
+    element.appendChild(document.createTextNode('22'));
+    (2).times(function(){ element.appendChild(document.createElement('span')) });
+    this.assertEqual(3, $A(element.childNodes).length);
+    
+    // HTML String
+    element = document.createElement('div');
+    $(element).update('22<span></span><span></span');
+    this.assertEqual(3, $A(element.childNodes).length);
+  },
+  
+  testClear: function(){
+    this.assertEnumEqual([], [].clear());
+    this.assertEnumEqual([], [1].clear());
+    this.assertEnumEqual([], [1,2].clear());
+  },
+  
+  testClone: function(){
+    this.assertEnumEqual([], [].clone());
+    this.assertEnumEqual([1], [1].clone());
+    this.assertEnumEqual([1,2], [1,2].clone());
+    this.assertEnumEqual([0,1,2], [0,1,2].clone());
+    var a = [0,1,2];
+    var b = a;
+    this.assertIdentical(a, b);
+    b = a.clone();
+    this.assertNotIdentical(a, b);
+  },
+  
+  testFirst: function(){
+    this.assertUndefined([].first());
+    this.assertEqual(1, [1].first());
+    this.assertEqual(1, [1,2].first());
+  },
+  
+  testLast: function(){
+    this.assertUndefined([].last());
+    this.assertEqual(1, [1].last());
+    this.assertEqual(2, [1,2].last());
+  },
+  
+  testCompact: function(){
+    this.assertEnumEqual([],      [].compact());
+    this.assertEnumEqual([1,2,3], [1,2,3].compact());
+    this.assertEnumEqual([0,1,2,3], [0,null,1,2,undefined,3].compact());
+    this.assertEnumEqual([1,2,3], [null,1,2,3,null].compact());
+  },
+  
+  testFlatten: function(){
+    this.assertEnumEqual([],      [].flatten());
+    this.assertEnumEqual([1,2,3], [1,2,3].flatten());
+    this.assertEnumEqual([1,2,3], [1,[[[2,3]]]].flatten());
+    this.assertEnumEqual([1,2,3], [[1],[2],[3]].flatten());
+    this.assertEnumEqual([1,2,3], [[[[[[[1]]]]]],2,3].flatten());
+  },
+  
+  testIndexOf: function(){
+    this.assertEqual(-1, [].indexOf(1));
+    this.assertEqual(-1, [0].indexOf(1));
+    this.assertEqual(0, [1].indexOf(1));
+    this.assertEqual(1, [0,1,2].indexOf(1));
+    this.assertEqual(0, [1,2,1].indexOf(1));
+    this.assertEqual(2, [1,2,1].indexOf(1, -1));
+    this.assertEqual(1, [undefined,null].indexOf(null));
+  },
+
+  testLastIndexOf: function(){
+    this.assertEqual(-1,[].lastIndexOf(1));
+    this.assertEqual(-1, [0].lastIndexOf(1));
+    this.assertEqual(0, [1].lastIndexOf(1));
+    this.assertEqual(2, [0,2,4,6].lastIndexOf(4));
+    this.assertEqual(3, [4,4,2,4,6].lastIndexOf(4));
+    this.assertEqual(3, [0,2,4,6].lastIndexOf(6,3));
+    this.assertEqual(-1, [0,2,4,6].lastIndexOf(6,2));
+    this.assertEqual(0, [6,2,4,6].lastIndexOf(6,2));
+    
+    var fixture = [1,2,3,4,3];
+    this.assertEqual(4, fixture.lastIndexOf(3));
+    this.assertEnumEqual([1,2,3,4,3],fixture);
+    
+    //tests from http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Objects:Array:lastIndexOf
+    var array = [2, 5, 9, 2];
+    this.assertEqual(3,array.lastIndexOf(2));
+    this.assertEqual(-1,array.lastIndexOf(7));
+    this.assertEqual(3,array.lastIndexOf(2,3));
+    this.assertEqual(0,array.lastIndexOf(2,2));
+    this.assertEqual(0,array.lastIndexOf(2,-2));
+    this.assertEqual(3,array.lastIndexOf(2,-1));
+  },
+  
+  testInspect: function(){
+    this.assertEqual('[]',[].inspect());
+    this.assertEqual('[1]',[1].inspect());
+    this.assertEqual('[\'a\']',['a'].inspect());
+    this.assertEqual('[\'a\', 1]',['a',1].inspect());
+  },
+  
+  testIntersect: function(){
+    this.assertEnumEqual([1,3], [1,1,3,5].intersect([1,2,3]));
+    this.assertEnumEqual([1], [1,1].intersect([1,1]));
+    this.assertEnumEqual([], [1,1,3,5].intersect([4]));
+    this.assertEnumEqual([], [1].intersect(['1']));
+    
+    this.assertEnumEqual(
+      ['B','C','D'], 
+      $R('A','Z').toArray().intersect($R('B','D').toArray())
+    );
+  },
+  
+  testToJSON: function(){
+    this.assertEqual('[]', [].toJSON());
+    this.assertEqual('[\"a\"]', ['a'].toJSON());
+    this.assertEqual('[\"a\", 1]', ['a', 1].toJSON());
+    this.assertEqual('[\"a\", {\"b\": null}]', ['a', {'b': null}].toJSON());
+  },
+  
+  testReverse: function(){
+    this.assertEnumEqual([], [].reverse());
+    this.assertEnumEqual([1], [1].reverse());
+    this.assertEnumEqual([2,1], [1,2].reverse());
+    this.assertEnumEqual([3,2,1], [1,2,3].reverse());
+  },
+  
+  testSize: function(){
+    this.assertEqual(4, [0, 1, 2, 3].size());
+    this.assertEqual(0, [].size());
+  },
+
+  testUniq: function(){
+    this.assertEnumEqual([1], [1, 1, 1].uniq());
+    this.assertEnumEqual([1], [1].uniq());
+    this.assertEnumEqual([], [].uniq());
+    this.assertEnumEqual([0, 1, 2, 3], [0, 1, 2, 2, 3, 0, 2].uniq());
+    this.assertEnumEqual([0, 1, 2, 3], [0, 0, 1, 1, 2, 3, 3, 3].uniq(true));
+  },
+  
+  testWithout: function(){
+    this.assertEnumEqual([], [].without(0));
+    this.assertEnumEqual([], [0].without(0));
+    this.assertEnumEqual([1], [0,1].without(0));
+    this.assertEnumEqual([1,2], [0,1,2].without(0));
+  },
+  
+  test$w: function(){
+    this.assertEnumEqual(['a', 'b', 'c', 'd'], $w('a b c d'));
+    this.assertEnumEqual([], $w(' '));
+    this.assertEnumEqual([], $w(''));
+    this.assertEnumEqual([], $w(null));
+    this.assertEnumEqual([], $w(undefined));
+    this.assertEnumEqual([], $w());
+    this.assertEnumEqual([], $w(10));
+    this.assertEnumEqual(['a'], $w('a'));
+    this.assertEnumEqual(['a'], $w('a '));
+    this.assertEnumEqual(['a'], $w(' a'));
+    this.assertEnumEqual(['a', 'b', 'c', 'd'], $w(' a   b\nc\t\nd\n'));
+  },
+  
+  testConcat: function(){
+    var args = (function() { return [].concat(arguments) })(1, 2);
+    this.assertIdentical(1, args[0][0]);
+  }
+});

data/test/regression/prototype/unit/tests/base_test.js

@@ -0,0 +1,43 @@
+new Test.Unit.Runner({
+  testBrowserDetection: function() {
+    var results = $H(Prototype.Browser).map(function(engine){
+      return engine;
+    }).partition(function(engine){
+      return engine[1] === true
+    });
+    var trues = results[0], falses = results[1];
+    
+    this.info('User agent string is: ' + navigator.userAgent);
+    
+    this.assert(trues.size() == 0 || trues.size() == 1, 
+      'There should be only one or no browser detected.');
+    
+    // we should have definite trues or falses here
+    trues.each(function(result) {
+      this.assert(result[1] === true);
+    }, this);
+    falses.each(function(result) {
+      this.assert(result[1] === false);
+    }, this);
+    
+    if(navigator.userAgent.indexOf('AppleWebKit/') > -1) {
+      this.info('Running on WebKit');
+      this.assert(Prototype.Browser.WebKit);
+    }
+    
+    if(!!window.opera) {
+      this.info('Running on Opera');
+      this.assert(Prototype.Browser.Opera);
+    }
+    
+    if(!!(window.attachEvent && !window.opera)) {
+      this.info('Running on IE');
+      this.assert(Prototype.Browser.IE);
+    }
+    
+    if(navigator.userAgent.indexOf('Gecko') > -1 && navigator.userAgent.indexOf('KHTML') == -1) {
+      this.info('Running on Gecko');
+      this.assert(Prototype.Browser.Gecko);
+    } 
+  }  
+});