casperjs 1.0.0.RC1 → 1.0.0

data/tests/suites/require.js

@@ -0,0 +1,31 @@
+/*global casper*/
+/*jshint strict:false*/
+var fs = require('fs');
+var modroot = fs.pathJoin(phantom.casperPath, 'tests', 'sample_modules');
+var jsmod, csmod, config;
+
+casper.test.comment('Javascript module loading')
+try {
+    jsmod = require(fs.pathJoin(modroot, 'jsmodule'));
+    casper.test.assertTrue(jsmod.ok, 'require() patched version can load a js module');
+} catch (e) {
+    casper.test.fail('require() patched version can load a js module');
+}
+
+casper.test.comment('CoffeeScript module loading')
+try {
+    csmod = require(fs.pathJoin(modroot, 'csmodule'));
+    casper.test.assertTrue(csmod.ok, 'require() patched version can load a coffeescript module');
+} catch (e) {
+    casper.test.fail('require() patched version can load a coffeescript module');
+}
+
+casper.test.comment('JSON module loading')
+try {
+    config = require(fs.pathJoin(modroot, 'config.json'));
+    casper.test.assertTrue(config.ok, 'require() patched version can load a json module');
+} catch (e) {
+    casper.test.fail('require() patched version can load a json module');
+}
+
+casper.test.done(3);

data/tests/suites/tester.js

@@ -1,33 +1,10 @@
+/*global casper*/
+/*jshint strict:false maxstatements:99*/
 var fs = require('fs');
-
 var t = casper.test;
 
 casper.start();
 
-t.comment('Tester.testEquals()');
-t.assert(t.testEquals(null, null), 'Tester.testEquals() null equality');
-t.assertNot(t.testEquals(null, undefined), 'Tester.testEquals() null vs. undefined inequality');
-t.assert(t.testEquals("hi", "hi"), 'Tester.testEquals() string equality');
-t.assertNot(t.testEquals("hi", "ih"), 'Tester.testEquals() string inequality');
-t.assert(t.testEquals(5, 5), 'Tester.testEquals() number equality');
-t.assertNot(t.testEquals("5", 5), 'Tester.testEquals() number equality without implicit cast');
-t.assert(t.testEquals(5, 5.0), 'Tester.testEquals() number equality with cast');
-t.assertNot(t.testEquals(5, 10), 'Tester.testEquals() number inequality');
-t.assert(t.testEquals([], []), 'Tester.testEquals() empty array equality');
-t.assert(t.testEquals([1,2], [1,2]), 'Tester.testEquals() array equality');
-t.assert(t.testEquals([1,2,[1,2,function(){}]], [1,2,[1,2,function(){}]]), 'Tester.testEquals() complex array equality');
-t.assertNot(t.testEquals([1,2,[1,2,function(a){}]], [1,2,[1,2,function(b){}]]), 'Tester.testEquals() complex array inequality');
-t.assertNot(t.testEquals([1,2], [2,1]), 'Tester.testEquals() shuffled array inequality');
-t.assertNot(t.testEquals([1,2], [1,2,3]), 'Tester.testEquals() array length inequality');
-t.assert(t.testEquals({}, {}), 'Tester.testEquals() empty object equality');
-t.assert(t.testEquals({a:1,b:2}, {a:1,b:2}), 'Tester.testEquals() object length equality');
-t.assert(t.testEquals({a:1,b:2}, {b:2,a:1}), 'Tester.testEquals() shuffled object keys equality');
-t.assertNot(t.testEquals({a:1,b:2}, {a:1,b:3}), 'Tester.testEquals() object inequality');
-t.assert(t.testEquals({1:{name:"bob",age:28}, 2:{name:"john",age:26}}, {1:{name:"bob",age:28}, 2:{name:"john",age:26}}), 'Tester.testEquals() complex object equality');
-t.assertNot(t.testEquals({1:{name:"bob",age:28}, 2:{name:"john",age:26}}, {1:{name:"bob",age:28}, 2:{name:"john",age:27}}), 'Tester.testEquals() complex object inequality');
-t.assert(t.testEquals(function(x){return x;}, function(x){return x;}), 'Tester.testEquals() function equality');
-t.assertNot(t.testEquals(function(x){return x;}, function(y){return y+2;}), 'Tester.testEquals() function inequality');
-
 t.comment('Tester.sortFiles()');
 var testDirRoot = fs.pathJoin(phantom.casperPath, 'tests', 'testdir');
 var files = t.findTestFiles(testDirRoot);
@@ -47,18 +24,40 @@ t.assertEquals(files, expected, 'findTestFiles() find test files and sort them')
 casper.thenOpen('tests/site/index.html', function() {
     t.comment('Tester.assertTextExists()');
     t.assertTextExists('form', 'Tester.assertTextExists() checks that page body contains text');
-});
 
-casper.then(function() {
+    t.comment('Tester.assertTextExist()');
+    t.assertTextExist('form', 'Tester.assertTextExist() checks that page body contains text [alias]');
+
+    t.comment('Tester.assertTextDoesntExist()');
+    t.assertTextDoesntExist('blah', "Tester.assertTextDoesntExist() checks that page body doesn't contain provided text");
+
+    t.comment('Tester.assertSelectorHasText()');
+    t.assertSelectorHasText('h1', 'Title', 'Tester.assertSelectorHasText() works as expected');
+
+    t.comment('Tester.assertSelectorDoesntHaveText()');
+    t.assertSelectorDoesntHaveText('h1', 'Subtitle', 'Tester.assertSelectorDoesntHaveText() works as expected');
+
     t.comment('Tester.assert()');
     t.assert(true, 'Tester.assert() works as expected');
 
+    t.comment('Tester.assertTrue()');
+    t.assertTrue(true, 'Tester.assertTrue() works as expected [alias]');
+
+    t.comment('Tester.assertTruthy()');
+    t.assertTruthy('1', 'Tester.assertTruthy() works as expected');
+
+    t.comment('Tester.assertFalsy()');
+    t.assertFalsy('', 'Tester.assertFalsy() works as expected');
+
     t.comment('Tester.assertNot()');
     t.assertNot(false, 'Tester.assertNot() works as expected');
 
     t.comment('Tester.assertEquals()');
     t.assertEquals(true, true, 'Tester.assertEquals() works as expected');
 
+    t.comment('Tester.assertEqual()');
+    t.assertEqual(true, true, 'Tester.assertEqual() works as expected [alias]');
+
     t.comment('Tester.assertNotEquals()');
     t.assertNotEquals(true, false, 'Tester.assertNotEquals() works as expected');
 
@@ -67,43 +66,138 @@ casper.then(function() {
         return true;
     }, 'Tester.assertEval() works as expected');
 
+    t.comment('Tester.assertEvaluate()');
+    t.assertEvaluate(function() {
+        return true;
+    }, 'Tester.assertEvaluate() works as expected [alias]');
+
     t.comment('Tester.assertEvalEquals()');
     t.assertEvalEquals(function() {
         return 42;
     }, 42, 'Tester.assertEvalEquals() works as expected');
 
+    t.comment('Tester.assertEvalEqual()');
+    t.assertEvalEqual(function() {
+        return 42;
+    }, 42, 'Tester.assertEvalEqual() works as expected [alias]');
+
     t.comment('Tester.assertExists()');
     t.assertExists('body', 'Tester.assertExists() works as expected');
 
+    t.comment('Tester.assertExist()');
+    t.assertExist('body', 'Tester.assertExist() works as expected [alias]');
+
+    t.comment('Tester.assertSelectorExists()');
+    t.assertSelectorExists('body', 'Tester.assertSelectorExists() works as expected [alias]');
+
+    t.comment('Tester.assertSelectorExists()');
+    t.assertSelectorExist('body', 'Tester.assertSelectorExist() works as expected [alias]');
+
     t.comment('Tester.assertDoesntExist()');
     t.assertDoesntExist('foobar', 'Tester.assertDoesntExist() works as expected');
 
+    t.comment('Tester.assertNotExist()');
+    t.assertDoesntExist('foobar', 'Tester.assertNotExist() works as expected [alias]');
+
     t.comment('Tester.assertHttpStatus()');
     // using file:// protocol, HTTP status is always null
-    t.assertHttpStatus(null, 'Tester.assertHttpStatus() works as expected');
+    t.assertHttpStatus(200, 'Tester.assertHttpStatus() works as expected');
 
     t.comment('Tester.assertMatch()');
     t.assertMatch("the lazy dog", /lazy/, 'Tester.assertMatch() works as expected');
 
+    t.comment('Tester.assertMatches()');
+    t.assertMatches("the lazy dog", /lazy/, 'Tester.assertMatches() works as expected [alias]');
+
     t.comment('Tester.assertRaises()');
     t.assertRaises(function() {
         throw new Error('plop');
     }, [], 'Tester.assertRaises() works as expected');
 
+    t.comment('Tester.assertRaise()');
+    t.assertRaise(function() {
+        throw new Error('plop');
+    }, [], 'Tester.assertRaise() works as expected [alias]');
+
+    t.comment('Tester.assertThrows()');
+    t.assertThrows(function() {
+        throw new Error('plop');
+    }, [], 'Tester.assertThrows() works as expected [alias]');
+
     t.comment('Tester.assertResourceExists()');
     t.assertResourceExists(/index\.html/, 'Tester.assertResourceExists() works as expected');
 
+    t.comment('Tester.assertResourceExist()');
+    t.assertResourceExist(/index\.html/, 'Tester.assertResourceExist() works as expected [alias]');
+
     t.comment('Tester.assertTitle()');
     t.assertTitle('CasperJS test index', 'Tester.assertTitle() works as expected');
 
     t.comment('Tester.assertTitleMatch()');
     t.assertTitleMatch(/test index/, 'Tester.assertTitleMatch() works as expected');
 
+    t.comment('Tester.assertTitleMatches()');
+    t.assertTitleMatches(/test index/, 'Tester.assertTitleMatches() works as expected [alias]');
+
     t.comment('Tester.assertType()');
     t.assertType("plop", "string", "Tester.assertType() works as expected");
 
     t.comment('Tester.assertUrlMatch()');
     t.assertUrlMatch(/index\.html$/, "Tester.assertUrlMatch() works as expected");
+
+    t.comment('Tester.assertUrlMatches()');
+    t.assertUrlMatches(/index\.html$/, "Tester.assertUrlMatches() works as expected [alias]");
+
+    t.comment('Tester.assertVisible()');
+    t.assertVisible('img', 'Tester.assertVisible() works as expected');
+
+    t.comment('Tester.assertNotVisible()');
+    t.assertNotVisible('p#hidden', 'Tester.assertNotVisible() works as expected');
+
+    t.comment('Tester.assertInvisible()');
+    t.assertInvisible('p#hidden', 'Tester.assertInvisible() works as expected [alias]');
+});
+
+casper.thenOpen('tests/site/form.html', function() {
+    t.comment('Tester.assertField()');
+    t.comment('1. Fill inputs');
+    var fpath = phantom.libraryPath + '/README.md';
+    this.fill('form[action="result.html"]', {
+        'email':       'chuck@norris.com',
+        'content':     'Am watching thou',
+        'check':       true,
+        'choice':      'no',
+        'topic':       'bar',
+        'file':        fpath,
+        'checklist[]': ['1', '3']
+    });
+    t.assertField('email', 'chuck@norris.com', 'Tester.assertField() works as expected with inputs');
+    t.assertField('content', 'Am watching thou', 'Tester.assertField() works as expected with textarea');
+    t.assertField('check', true, 'Tester.assertField() works as expected with checkboxes');
+    t.assertField('choice', 'no', 'Tester.assertField() works as expected with radios');
+    t.assertField('topic', 'bar', 'Tester.assertField() works as expected with selects');
+    t.assertField('file', 'C:\\fakepath\\README.md', 'Tester.assertField() works as expected with file inputs');
+    t.assertField('checklist[]', ['1', '3'], 'Tester.assertField() works as expected with check lists');
+});
+
+casper.reload(function() {
+    t.comment('2. Unfill inputs');
+    this.fill('form[action="result.html"]', {
+        'email':       '',
+        'content':     '',
+        'check':       false,
+        'choice':      '',
+        'topic':       '',
+        'file':        '',
+        'checklist[]': []
+    });
+    t.assertField('email', '', 'Tester.assertField() works as expected with inputs');
+    t.assertField('content', '', 'Tester.assertField() works as expected with textarea');
+    t.assertField('check', false, 'Tester.assertField() works as expected with checkboxes');
+    t.assertField('choice', null, 'Tester.assertField() works as expected with radios');
+    t.assertField('topic', 'foo', 'Tester.assertField() works as expected with selects');
+    t.assertField('file', '', 'Tester.assertField() works as expected with file inputs');
+    t.assertField('checklist[]', [], 'Tester.assertField() works as expected with check lists');
 });
 
 casper.then(function() {
@@ -116,6 +210,17 @@ casper.then(function() {
     t.assertEquals(t.getPasses().length, passCount + 1, "Tester.getPasses() works as expected");
 });
 
+casper.then(function() {
+    t.comment('Tester.calculateSuiteDuration()');
+    function add(a, b) {
+        return a + b;
+    }
+    var passedTime = t.getPassesTime().reduce(add, 0),
+        failedTime = t.getFailuresTime().reduce(add, 0),
+        calculatedSum = t.calculateSuiteDuration();
+    t.assertEquals(calculatedSum, passedTime + failedTime, "Tester.calculateSuiteDuration() works as expected")
+});
+
 casper.run(function() {
-    t.done();
+    t.done(59);
 });

data/tests/suites/utils.js

@@ -1,4 +1,82 @@
-var utils = require('utils'), t = casper.test, x = require('casper').selectXPath;
+/*global casper*/
+/*jshint strict:false maxstatements:99*/
+var utils = require('utils'),
+    t = casper.test,
+    x = require('casper').selectXPath;
+
+t.comment('betterTypeOf()');
+(function() {
+    var testCases = [
+        {subject: 1, expected: 'number'},
+        {subject: '1', expected: 'string'},
+        {subject: {}, expected: 'object'},
+        {subject: [], expected: 'array'},
+        {subject: undefined, expected: 'undefined'},
+        {subject: null, expected: 'null'},
+        {subject: function(){}, expected: 'function'},
+        {subject: window, expected: 'domwindow'},
+        {subject: new Date(), expected: 'date'},
+        {subject: new RegExp(), expected: 'regexp'}
+    ];
+    testCases.forEach(function(testCase) {
+        t.assertEquals(utils.betterTypeOf(testCase.subject), testCase.expected,
+            require('utils').format('betterTypeOf() detects expected type "%s"', testCase.subject));
+    });
+})();
+
+t.comment('cleanUrl()');
+(function() {
+    var testCases = {
+        'http://google.com/': 'http://google.com/',
+        'http://google.com': 'http://google.com/',
+        'http://www.google.com/': 'http://www.google.com/',
+        'http://www.google.com/?plop=2': 'http://www.google.com/?plop=2',
+        'https://google.com/': 'https://google.com/',
+        'https://google.com': 'https://google.com/',
+        'https://www.google.com/': 'https://www.google.com/',
+        'https://www.google.com/?plop=2': 'https://www.google.com/?plop=2',
+        'file:///Users/toto/toto.html': 'file:///Users/toto/toto.html',
+        '/100': '/100'
+    };
+    for (var testCase in testCases) {
+        t.assertEquals(utils.cleanUrl(testCase), testCases[testCase], 'cleanUrl() cleans an URL');
+    }
+})();
+
+t.comment('clone()');
+(function() {
+    var a = {a: 1, b: 2, c: [1, 2]};
+    t.assertEquals(utils.clone(a), a);
+    var b = [1, 2, 3, a];
+    t.assertEquals(utils.clone(b), b);
+})();
+
+t.comment('equals()');
+(function() {
+    t.assert(utils.equals(null, null), 'equals() null equality');
+    t.assertNot(utils.equals(null, undefined), 'equals() null vs. undefined inequality');
+    t.assert(utils.equals("hi", "hi"), 'equals() string equality');
+    t.assertNot(utils.equals("hi", "ih"), 'equals() string inequality');
+    t.assert(utils.equals(5, 5), 'equals() number equality');
+    t.assertNot(utils.equals("5", 5), 'equals() number equality without implicit cast');
+    t.assert(utils.equals(5, 5.0), 'equals() number equality with cast');
+    t.assertNot(utils.equals(5, 10), 'equals() number inequality');
+    t.assert(utils.equals([], []), 'equals() empty array equality');
+    t.assert(utils.equals([1,2], [1,2]), 'equals() array equality');
+    t.assert(utils.equals([1,2,[1,2,function(){}]], [1,2,[1,2,function(){}]]), 'equals() complex array equality');
+    t.assertNot(utils.equals([1,2,[1,2,function(a){}]], [1,2,[1,2,function(b){}]]), 'equals() complex array inequality');
+    t.assertNot(utils.equals([1,2], [2,1]), 'equals() shuffled array inequality');
+    t.assertNot(utils.equals([1,2], [1,2,3]), 'equals() array length inequality');
+    t.assert(utils.equals({}, {}), 'equals() empty object equality');
+    t.assert(utils.equals({a:1,b:2}, {a:1,b:2}), 'equals() object length equality');
+    t.assert(utils.equals({a:1,b:2}, {b:2,a:1}), 'equals() shuffled object keys equality');
+    t.assertNot(utils.equals({a:1,b:2}, {a:1,b:3}), 'equals() object inequality');
+    t.assert(utils.equals({1:{name:"bob",age:28}, 2:{name:"john",age:26}}, {1:{name:"bob",age:28}, 2:{name:"john",age:26}}), 'equals() complex object equality');
+    t.assertNot(utils.equals({1:{name:"bob",age:28}, 2:{name:"john",age:26}}, {1:{name:"bob",age:28}, 2:{name:"john",age:27}}), 'equals() complex object inequality');
+    t.assert(utils.equals(function(x){return x;}, function(x){return x;}), 'equals() function equality');
+    t.assertNot(utils.equals(function(x){return x;}, function(y){return y+2;}), 'equals() function inequality');
+    t.assert(utils.equals([{a:1, b:2}, {c:3, d:4}], [{a:1, b:2}, {c:3, d:4}]), 'equals() arrays of objects');
+})();
 
 t.comment('fileExt()');
 (function() {
@@ -18,7 +96,7 @@ t.comment('fileExt()');
 
 t.comment('fillBlanks()');
 (function() {
-    testCases = {
+    var testCases = {
         'foo':         'foo       ',
         '  foo bar ':  '  foo bar ',
         '  foo bar  ': '  foo bar  '
@@ -31,7 +109,7 @@ t.comment('fillBlanks()');
 
 t.comment('getPropertyPath()');
 (function() {
-    testCases = [
+    var testCases = [
         {
             input:  utils.getPropertyPath({}, 'a.b.c'),
             output: undefined
@@ -75,7 +153,7 @@ t.comment('isArray()');
 
 t.comment('isClipRect()');
 (function() {
-    testCases = [
+    var testCases = [
         [{},                                              false],
         [{top: 2},                                        false],
         [{top: 2, left: 2, width: 2, height: 2},          true],
@@ -88,6 +166,22 @@ t.comment('isClipRect()');
     });
 })();
 
+t.comment('isHTTPResource()');
+(function() {
+    var testCases = [
+        [{},                              false],
+        [{url: 'file:///var/www/i.html'}, false],
+        [{url: 'mailto:plop@plop.com'},   false],
+        [{url: 'ftp://ftp.plop.com'},     false],
+        [{url: 'HTTP://plop.com/'},       true],
+        [{url: 'https://plop.com/'},      true]
+    ];
+
+    testCases.forEach(function(testCase) {
+        t.assertEquals(utils.isHTTPResource(testCase[0]), testCase[1], 'isHTTPResource() checks for an HTTP resource');
+    });
+})();
+
 t.comment('isObject()');
 (function() {
     t.assertEquals(utils.isObject({}), true, 'isObject() checks for an Object');
@@ -137,7 +231,7 @@ t.comment('isWebPage()');
 
 t.comment('isJsFile()');
 (function() {
-    testCases = {
+    var testCases = {
         '':             false,
         'toto.png':     false,
         'plop':         false,
@@ -152,7 +246,7 @@ t.comment('isJsFile()');
 
 t.comment('mergeObjects()');
 (function() {
-    testCases = [
+    var testCases = [
         {
             obj1: {a: 1}, obj2: {b: 2}, merged: {a: 1, b: 2}
         },
@@ -181,9 +275,15 @@ t.comment('mergeObjects()');
     });
 })();
 
+t.comment('objectValues()');
+(function() {
+    t.assertEquals(utils.objectValues({}), [], 'objectValues() can extract object values');
+    t.assertEquals(utils.objectValues({a: 1, b: 2}), [1, 2], 'objectValues() can extract object values');
+})();
+
 t.comment('unique()');
 (function() {
-    testCases = [
+    var testCases = [
         {
             input:  [1,2,3],
             output: [1,2,3]
@@ -206,4 +306,4 @@ t.comment('unique()');
     });
 })();
 
-t.done();
+t.done(112);

data/tests/suites/xunit.js

@@ -1,16 +1,47 @@
+/*global casper*/
+/*jshint strict:false*/
 casper.test.comment('phantom.Casper.XUnitExporter');
 
-xunit = require('xunit').create();
+var xunit = require('xunit').create();
 xunit.addSuccess('foo', 'bar');
-casper.test.assertMatch(xunit.getXML(), /<testcase classname="foo" name="bar"/, 'XUnitExporter.addSuccess() adds a successful testcase');
+casper.test.assertMatch(xunit.getXML(),
+    /<testcase classname="foo" name="bar"/,
+    'XUnitExporter.addSuccess() adds a successful testcase');
 xunit.addFailure('bar', 'baz', 'wrong', 'chucknorriz');
-casper.test.assertMatch(xunit.getXML(), /<testcase classname="bar" name="baz"><failure type="chucknorriz">wrong/, 'XUnitExporter.addFailure() adds a failed testcase');
+casper.test.assertMatch(xunit.getXML(),
+    /<testcase classname="bar" name="baz"><failure type="chucknorriz">wrong/,
+    'XUnitExporter.addFailure() adds a failed testcase');
 
 // named classname
 xunit = require('xunit').create();
 xunit.addSuccess(require('fs').workingDirectory + '/plop.js', 'It worked');
-casper.test.assertMatch(xunit.getXML(), /<testcase classname="plop" name="It worked"/, 'XUnitExporter.addSuccess() handles class name');
+casper.test.assertMatch(xunit.getXML(),
+    /<testcase classname="(.*)plop" name="It worked"/,
+    'XUnitExporter.addSuccess() handles class name');
 xunit.addSuccess(require('fs').workingDirectory + '/plip.js', 'Failure');
-casper.test.assertMatch(xunit.getXML(), /<testcase classname="plip" name="Failure"/, 'XUnitExporter.addFailure() handles class name');
+casper.test.assertMatch(xunit.getXML(),
+    /<testcase classname="(.*)plip" name="Failure"/,
+    'XUnitExporter.addFailure() handles class name');
+
+// named with time
+xunit = require('xunit').create();
+xunit.addSuccess('foo', 'It worked', 1024);
+casper.test.assertMatch(xunit.getXML(),
+    /<testcase classname="foo" name="It worked" time="(.*)"/,
+    'XUnitExporter.addSuccess() writes duration of test');
+xunit.addFailure('bar', 'baz', 'wrong', 'chucknorriz', 1024);
+casper.test.assertMatch(xunit.getXML(),
+    /<testcase classname="bar" name="baz" time="(.*)"><failure type="chucknorriz">wrong/,
+    'XUnitExporter.addFailure() adds a failed testcase with duration');
+
+// named with time
+xunit = require('xunit').create();
+casper.test.assertMatch(xunit.getXML(),
+    /<testsuite>/,
+    'XUnitExporter.create() created <testsuite> without time');
+xunit.setSuiteDuration(1024);
+casper.test.assertMatch(xunit.getXML(),
+    /<testsuite time="1.024">/,
+    'XUnitExporter.setSuiteDuration() sets time in seconds');
 
-casper.test.done();
+casper.test.done(8);