casperjs 1.0.0.RC1

data/tests/suites/casper/hooks.js

@@ -0,0 +1,41 @@
+// Dear curious test reader,
+// The on* family of methods is considered deprecated since 0.6.0; please use events instead
+
+// Casper.options.onStepComplete
+casper.start('tests/site/index.html', function() {
+    this.options.onStepComplete = function(self, stepResult) {
+        this.test.comment('Casper.options.onStepComplete()');
+        this.test.assertEquals(stepResult, 'ok', 'Casper.options.onStepComplete() is called on step complete');
+        self.options.onStepComplete = null;
+    };
+    return 'ok';
+});
+
+// Casper.options.onResourceRequested & Casper.options.onResourceReceived
+casper.then(function() {
+    this.options.onResourceReceived = function(self, resource) {
+        this.test.comment('Casper.options.onResourceReceived()');
+        this.test.assertType(resource, 'object', 'Casper.options.onResourceReceived() retrieve a resource object');
+        this.test.assert('status' in resource, 'Casper.options.onResourceReceived() retrieve a valid resource object');
+        self.options.onResourceReceived = null;
+    };
+    this.options.onResourceRequested = function(self, request) {
+        this.test.comment('Casper.options.onResourceRequested()');
+        this.test.assertType(request, 'object', 'Casper.options.onResourceRequested() retrieve a request object');
+        this.test.assert('method' in request, 'Casper.options.onResourceRequested() retrieve a valid request object');
+        self.options.onResourceRequested = null;
+    };
+    this.thenOpen('tests/site/page1.html');
+});
+
+// Casper.options.onAlert()
+casper.then(function() {
+    this.options.onAlert = function(self, message) {
+        self.test.assertEquals(message, 'plop', 'Casper.options.onAlert() can intercept an alert message');
+    };
+});
+
+casper.run(function() {
+    this.options.onAlert = null;
+    this.test.done();
+});

data/tests/suites/casper/logging.js

@@ -0,0 +1,38 @@
+casper.start('tests/site/index.html');
+
+var oldLevel = casper.options.logLevel;
+
+casper.options.logLevel = 'info';
+casper.options.verbose = false;
+
+casper.test.comment('Casper.log()');
+casper.log('foo', 'info');
+casper.test.assert(casper.result.log.some(function(e) {
+    return e.message === 'foo' && e.level === 'info';
+}), 'Casper.log() adds a log entry');
+
+casper.options.logLevel = oldLevel;
+casper.options.verbose = true;
+
+casper.then(function() {
+    var oldLevel = casper.options.logLevel;
+    casper.options.logLevel = 'debug';
+    casper.options.verbose = false;
+    casper.evaluate(function() {
+        __utils__.log('debug message');
+        __utils__.log('info message', 'info');
+    });
+    this.test.assert(casper.result.log.some(function(e) {
+        return e.message === 'debug message' && e.level === 'debug' && e.space === 'remote';
+    }), 'ClientUtils.log() adds a log entry');
+    this.test.assert(casper.result.log.some(function(e) {
+        return e.message === 'info message' && e.level === 'info' && e.space === 'remote';
+    }), 'ClientUtils.log() adds a log entry at a given level');
+    casper.options.logLevel = oldLevel;
+    casper.options.verbose = true;
+});
+
+casper.run(function() {
+    this.test.assertEquals(this.result.log.length, 3, 'Casper.log() logged messages');
+    this.test.done();
+});

data/tests/suites/casper/mouseevents.js

@@ -0,0 +1,27 @@
+casper.start('tests/site/mouse-events.html');
+
+casper.then(function() {
+    this.test.comment('CasperUtils.mouseEvent()');
+    this.test.assert(this.mouseEvent('mousedown', '#test1'), 'CasperUtils.mouseEvent() can dispatch a mousedown event');
+    this.test.assert(this.mouseEvent('mousedown', '#test2'), 'CasperUtils.mouseEvent() can dispatch a mousedown event handled by unobstrusive js');
+    this.test.assert(this.mouseEvent('mouseup', '#test3'), 'CasperUtils.mouseEvent() can dispatch a mouseup event');
+    this.test.assert(this.mouseEvent('mouseup', '#test4'), 'CasperUtils.mouseEvent() can dispatch a mouseup event handled by unobstrusive js');
+    this.test.assert(this.mouseEvent('mouseover', '#test5'), 'CasperUtils.mouseEvent() can dispatch a mouseover event');
+    this.test.assert(this.mouseEvent('mouseover', '#test6'), 'CasperUtils.mouseEvent() can dispatch a mouseover event handled by unobstrusive js');
+    this.test.assert(this.mouseEvent('mouseout', '#test7'), 'CasperUtils.mouseEvent() can dispatch a mouseout event');
+    this.test.assert(this.mouseEvent('mouseout', '#test8'), 'CasperUtils.mouseEvent() can dispatch a mouseout event handled by unobstrusive js');
+
+    var results = this.getGlobal('results');
+    this.test.assert(results.test1, 'CasperUtils.mouseEvent() triggered mousedown');
+    this.test.assert(results.test2, 'CasperUtils.mouseEvent() triggered mousedown via unobstrusive js');
+    this.test.assert(results.test3, 'CasperUtils.mouseEvent() triggered mouseup');
+    this.test.assert(results.test4, 'CasperUtils.mouseEvent() triggered mouseup via unobstrusive js');
+    this.test.assert(results.test5, 'CasperUtils.mouseEvent() triggered mouseover');
+    this.test.assert(results.test6, 'CasperUtils.mouseEvent() triggered mouseover via unobstrusive js');
+    this.test.assert(results.test7, 'CasperUtils.mouseEvent() triggered mouseout');
+    this.test.assert(results.test8, 'CasperUtils.mouseEvent() triggered mouseout via unobstrusive js');
+});
+
+casper.run(function() {
+    this.test.done();
+});

data/tests/suites/casper/onerror.js

@@ -0,0 +1,19 @@
+casper.test.comment("page.error event");
+
+var error = {};
+
+casper.start();
+
+casper.on("page.error", function onError(msg, trace) {
+    error.msg = msg;
+    error.trace = trace;
+});
+
+casper.thenOpen('tests/site/error.html', function() {
+    this.test.assertEquals(error.msg, "ReferenceError: Can't find variable: plop", 'page.error event has been caught OK');
+    this.test.assertMatch(error.trace[0].file, /error.html/, 'page.error retrieves correct stack trace');
+});
+
+casper.run(function() {
+    this.test.done();
+});

data/tests/suites/casper/open.js

@@ -0,0 +1,73 @@
+var t = casper.test, current = 0, tests = [
+    function(settings) {
+        t.assertEquals(settings, {
+            method: "get"
+        }, "Casper.open() used the expected GET settings");
+    },
+    function(settings) {
+        t.assertEquals(settings, {
+            method: "post",
+            data:   "plop=42&chuck=norris"
+        }, "Casper.open() used the expected POST settings");
+    },
+    function(settings) {
+        t.assertEquals(settings, {
+            method: "put",
+            data:   "plop=42&chuck=norris"
+        }, "Casper.open() used the expected PUT settings");
+    },
+    function(settings) {
+        t.assertEquals(settings, {
+            method: "get",
+            username: 'bob',
+            password: 'sinclar'
+        }, "Casper.open() used the expected HTTP auth settings");
+    }
+];
+
+casper.start();
+
+casper.on('open', function(url, settings) {
+    tests[current++](settings);
+});
+
+// GET
+casper.open('tests/site/index.html').then(function() {
+    t.pass("Casper.open() can open and load a location using GET");
+});
+
+// POST
+casper.open('tests/site/index.html', {
+    method: 'post',
+    data:   {
+        plop: 42,
+        chuck: 'norris'
+    }
+}).then(function() {
+    t.pass("Casper.open() can open and load a location using POST");
+});
+
+// PUT
+casper.open('tests/site/index.html', {
+    method: 'put',
+    data:   {
+        plop: 42,
+        chuck: 'norris'
+    }
+}).then(function() {
+    t.pass("Casper.open() can open and load a location using PUT");
+});
+
+// HTTP Auth
+casper.open('tests/site/index.html', {
+    method: 'get',
+    username: 'bob',
+    password: 'sinclar'
+}).then(function() {
+    t.pass("Casper.open() can open and load a location using HTTP auth");
+});
+
+casper.run(function() {
+    this.removeAllListeners('open');
+    t.done();
+});

data/tests/suites/casper/prompt.js

@@ -0,0 +1,17 @@
+// skip this test for phantom versions < 1.5
+if (phantom.version.major === 1 && phantom.version.minor < 6) {
+    casper.test.comment('Skipped tests, PhantomJS 1.6 required');
+    casper.test.done();
+} else {
+    casper.setFilter('page.prompt', function(message, value) {
+        return 'Chuck ' + value;
+    });
+
+    casper.start('tests/site/prompt.html', function() {
+        this.test.assertEquals(this.getGlobal('name'), 'Chuck Norris', 'prompted value has been received');
+    });
+
+    casper.run(function() {
+        this.test.done();
+    });
+}

data/tests/suites/casper/resources.coffee

@@ -0,0 +1,24 @@
+casper.start "tests/site/resources.html", ->
+  @test.assertEquals @resources.length, 1, "only one resource found"
+  onTime = ->
+    @test.assertEquals(
+      @resources.length
+      2
+      "two resources found"
+    )
+    @test.assertResourceExists(
+      /phantom\.png/i
+      "phantom image found via test RegExp"
+    )
+    @test.assertResourceExists(
+      (res) -> res.url.match "phantom.png"
+      "phantom image found via test Function"
+    )
+    @test.assertResourceExists(
+      "phantom.png"
+      "phantom image found via test String"
+    )
+  onTimeout = -> @test.fail "waitForResource timeout occured"
+  @waitForResource "phantom.png", onTime, onTimeout
+
+casper.run(-> @test.done())

data/tests/suites/casper/start.js

@@ -0,0 +1,15 @@
+casper.test.comment('Casper.start()');
+
+casper.start('tests/site/index.html', function() {
+    this.test.pass('Casper.start() can chain a next step');
+    this.test.assertTitle('CasperJS test index', 'Casper.start() opened the passed url');
+    this.test.assertEval(function() {
+        return typeof(__utils__) === "object";
+    }, 'Casper.start() injects ClientUtils instance within remote DOM');
+});
+
+casper.test.assert(casper.started, 'Casper.start() started');
+
+casper.run(function() {
+    this.test.done();
+});

data/tests/suites/casper/steps.js

@@ -0,0 +1,32 @@
+casper.test.comment('Casper.then()');
+
+casper.start('tests/site/index.html');
+
+var nsteps = casper.steps.length;
+
+casper.then(function(self) {
+    this.test.assertTitle('CasperJS test index', 'Casper.then() added a new step');
+});
+
+casper.test.assertEquals(casper.steps.length, nsteps + 1, 'Casper.then() can add a new step');
+
+casper.test.comment('Casper.thenOpen()');
+
+casper.thenOpen('tests/site/test.html');
+
+casper.test.assertEquals(casper.steps.length, nsteps + 2, 'Casper.thenOpen() can add a new step');
+
+casper.thenOpen('tests/site/test.html', function() {
+    this.test.assertTitle('CasperJS test target', 'Casper.thenOpen() opened a location and executed a step');
+});
+
+casper.test.assertEquals(casper.steps.length, nsteps + 4, 'Casper.thenOpen() can add a new step for opening, plus another step');
+
+casper.test.comment('Casper.each()');
+casper.each([1, 2, 3], function(self, item, i) {
+    self.test.assertEquals(i, item - 1, 'Casper.each() passes a contextualized index');
+});
+
+casper.run(function() {
+    this.test.done();
+});

data/tests/suites/casper/viewport.js

@@ -0,0 +1,11 @@
+casper.test.comment('Casper.viewport()');
+
+casper.start();
+
+casper.viewport(1337, 999);
+
+casper.test.assertEquals(casper.page.viewportSize.width, 1337, 'Casper.viewport() can change the width of page viewport');
+casper.test.assertEquals(casper.page.viewportSize.height, 999, 'Casper.viewport() can change the height of page viewport');
+casper.test.assertRaises(casper.viewport, ['a', 'b'], 'Casper.viewport() validates viewport size data');
+
+casper.test.done();

data/tests/suites/casper/visible.js

@@ -0,0 +1,17 @@
+casper.start('tests/site/visible.html', function() {
+    this.test.comment('Casper.visible()');
+    this.test.assert(this.visible('#img1'), 'Casper.visible() can detect if an element is visible');
+    this.test.assert(!this.visible('#img2'), 'Casper.visible() can detect if an element is invisible');
+    this.test.assert(!this.visible('#img3'), 'Casper.visible() can detect if an element is invisible');
+    this.waitWhileVisible('#img1', function() {
+        this.test.comment('Casper.waitWhileVisible()');
+        this.test.pass('Casper.waitWhileVisible() can wait while an element is visible');
+    }, function() {
+        this.test.comment('Casper.waitWhileVisible()');
+        this.test.fail('Casper.waitWhileVisible() can wait while an element is visible');
+    }, 2000);
+});
+
+casper.run(function() {
+    this.test.done();
+});

data/tests/suites/casper/wait.js

@@ -0,0 +1,27 @@
+var waitStart;
+
+casper.start('tests/site/index.html', function() {
+    waitStart = new Date().getTime();
+});
+
+casper.wait(1000, function() {
+    this.test.comment('Casper.wait()');
+    this.test.assert(new Date().getTime() - waitStart > 1000, 'Casper.wait() can wait for a given amount of time');
+    // Casper.waitFor()
+    casper.thenOpen('tests/site/waitFor.html', function() {
+        this.test.comment('Casper.waitFor()');
+        this.waitFor(function() {
+            return this.evaluate(function() {
+                return document.querySelectorAll('li').length === 4;
+            });
+        }, function() {
+            this.test.pass('Casper.waitFor() can wait for something to happen');
+        }, function() {
+            this.test.fail('Casper.waitFor() can wait for something to happen');
+        });
+    });
+});
+
+casper.run(function() {
+    this.test.done();
+});

data/tests/suites/casper/xpath.js

@@ -0,0 +1,32 @@
+var x = require('casper').selectXPath;
+
+casper.test.comment('XPath');
+
+casper.start('tests/site/index.html', function() {
+    this.test.assertExists({
+        type: 'xpath',
+        path: '/html/body/ul/li[2]'
+    }, 'XPath selector can find an element');
+    this.test.assertDoesntExist({
+        type: 'xpath',
+        path: '/html/body/ol/li[2]'
+    }, 'XPath selector does not retrieve an unexistent element');
+    this.test.assertExists(x('/html/body/ul/li[2]'), 'selectXPath() shortcut can find an element as well');
+    this.test.assertEvalEquals(function() {
+        return __utils__.findAll({type: 'xpath', path: '/html/body/ul/li'}).length;
+    }, 3, 'Correct number of elements are found');
+});
+
+casper.thenClick(x('/html/body/a[2]'), function() {
+    this.test.assertTitle('CasperJS test form', 'Clicking XPath works as expected');
+    this.fill(x('/html/body/form'), {
+        email: 'chuck@norris.com'
+    });
+    this.test.assertEvalEquals(function() {
+        return document.querySelector('input[name="email"]').value;
+    }, 'chuck@norris.com', 'Casper.fill() can fill an input[type=text] form field');
+});
+
+casper.run(function() {
+    this.test.done();
+});

data/tests/suites/cli.js

@@ -0,0 +1,125 @@
+var cli = require('cli'), t = casper.test;
+
+t.comment('parse(), get(), has()');
+
+(function(parsed) {
+    // clean
+    t.assertEquals(parsed.args, [], 'parse() returns expected positional args array');
+    t.assertEquals(parsed.options, {}, 'parse() returns expected options object');
+    t.assertEquals(parsed.get(0), undefined, 'parse() does not return inexistant positional arg');
+    t.assertEquals(parsed.get('blah'), undefined, 'parse() does not return inexistant option');
+    t.assert(!parsed.has(0), 'has() checks if an arg is set');
+    t.assert(!parsed.has('blah'), 'has() checks if an option is set');
+    // raw
+    t.assertEquals(parsed.raw.args, [], 'parse() returns expected positional args array');
+    t.assertEquals(parsed.raw.options, {}, 'parse() returns expected options object');
+    t.assertEquals(parsed.raw.get(0), undefined, 'parse() does not return inexistant positional arg');
+    t.assertEquals(parsed.raw.get('blah'), undefined, 'parse() does not return inexistant option');
+    t.assert(!parsed.raw.has(0), 'has() checks if a raw arg is set');
+    t.assert(!parsed.raw.has('blah'), 'has() checks if a raw option is set');
+})(cli.parse([]));
+
+(function(parsed) {
+    // clean
+    t.assertEquals(parsed.args, ['foo', 'bar'], 'parse() returns expected positional args array');
+    t.assertEquals(parsed.options, {}, 'parse() returns expected options object');
+    t.assertEquals(parsed.get(0), 'foo', 'parse() retrieve first positional arg');
+    t.assertEquals(parsed.get(1), 'bar', 'parse() retrieve second positional arg');
+    t.assert(parsed.has(0), 'has() checks if an arg is set');
+    t.assert(parsed.has(1), 'has() checks if an arg is set');
+    t.assert(!parsed.has(2), 'has() checks if an arg is not set');
+    // raw
+    t.assertEquals(parsed.raw.args, ['foo', 'bar'], 'parse() returns expected positional raw args array');
+    t.assertEquals(parsed.raw.options, {}, 'parse() returns expected raw options object');
+    t.assertEquals(parsed.raw.get(0), 'foo', 'parse() retrieve first positional raw arg');
+    t.assertEquals(parsed.raw.get(1), 'bar', 'parse() retrieve second positional raw arg');
+    t.assert(parsed.raw.has(0), 'has() checks if a arw arg is set');
+    t.assert(parsed.raw.has(1), 'has() checks if a arw arg is set');
+    t.assert(!parsed.raw.has(2), 'has() checks if a arw arg is not set');
+})(cli.parse(['foo', 'bar']));
+
+(function(parsed) {
+    // clean
+    t.assertEquals(parsed.args, [], 'parse() returns expected positional args array');
+    t.assertEquals(parsed.options, {foo: 'bar', baz: true}, 'parse() returns expected options object');
+    t.assertEquals(parsed.get('foo'), 'bar', 'parse() retrieve an option value');
+    t.assert(parsed.get('baz'), 'parse() retrieve boolean option flag');
+    t.assert(parsed.has("foo"), 'has() checks if an option is set');
+    t.assert(parsed.has("baz"), 'has() checks if an option is set');
+    // raw
+    t.assertEquals(parsed.raw.args, [], 'parse() returns expected positional raw args array');
+    t.assertEquals(parsed.raw.options, {foo: 'bar', baz: true}, 'parse() returns expected options raw object');
+    t.assertEquals(parsed.raw.get('foo'), 'bar', 'parse() retrieve an option raw value');
+    t.assert(parsed.raw.get('baz'), 'parse() retrieve boolean raw option flag');
+    t.assert(parsed.raw.has("foo"), 'has() checks if a raw option is set');
+    t.assert(parsed.raw.has("baz"), 'has() checks if a raw option is set');
+})(cli.parse(['--foo=bar', '--baz']));
+
+(function(parsed) {
+    // clean
+    t.assertEquals(parsed.args, [], 'parse() returns expected positional args array');
+    t.assertEquals(parsed.options, { '&é"à': "42===42" }, 'parse() returns expected options object');
+    t.assertEquals(parsed.get('&é"à'), "42===42", 'parse() handles options with exotic names');
+    t.assert(parsed.has('&é"à'), 'has() checks if an option is set');
+    // raw
+    t.assertEquals(parsed.raw.args, [], 'parse() returns expected positional raw args array');
+    t.assertEquals(parsed.raw.options, { '&é"à': "42===42" }, 'parse() returns expected options raw object');
+    t.assertEquals(parsed.raw.get('&é"à'), "42===42", 'parse() handles raw options with exotic names');
+    t.assert(parsed.raw.has('&é"à'), 'has() checks if a raw option is set');
+})(cli.parse(['--&é"à=42===42']));
+
+(function(parsed) {
+    // clean
+    t.assertEquals(parsed.args, ['foo & bar', 'baz & boz'], 'parse() returns expected positional args array');
+    t.assertEquals(parsed.options, { universe: 42, lap: 13.37, chucknorris: true, oops: false }, 'parse() returns expected options object');
+    t.assertEquals(parsed.get('universe'), 42, 'parse() can cast a numeric option value');
+    t.assertEquals(parsed.get('lap'), 13.37, 'parse() can cast a float option value');
+    t.assertType(parsed.get('lap'), "number", 'parse() can cast a boolean value');
+    t.assert(parsed.get('chucknorris'), 'parse() can get a flag value by its option name');
+    t.assertType(parsed.get('oops'), "boolean", 'parse() can cast a boolean value');
+    t.assertEquals(parsed.get('oops'), false, 'parse() can cast a boolean value');
+    t.assert(parsed.has(0), 'has() checks if an arg is set');
+    t.assert(parsed.has(1), 'has() checks if an arg is set');
+    t.assert(parsed.has("universe"), 'has() checks if an option is set');
+    t.assert(parsed.has("lap"), 'has() checks if an option is set');
+    t.assert(parsed.has("chucknorris"), 'has() checks if an option is set');
+    t.assert(parsed.has("oops"), 'has() checks if an option is set');
+
+    t.comment('drop()');
+
+    parsed.drop(0);
+    t.assertEquals(parsed.get(0), 'baz & boz', 'drop() dropped arg');
+    parsed.drop("universe");
+    t.assert(!parsed.has("universe"), 'drop() dropped option');
+    t.assertEquals(parsed.args, ["baz & boz"], 'drop() did not affect other args');
+    t.assertEquals(parsed.options, {
+        lap: 13.37,
+        chucknorris: true,
+        oops: false
+    }, 'drop() did not affect other options');
+
+    // raw
+    t.assertEquals(parsed.raw.args, ['foo & bar', 'baz & boz'], 'parse() returns expected positional raw args array');
+    t.assertEquals(parsed.raw.options, { universe: "42", lap: "13.37", chucknorris: true, oops: "false" }, 'parse() returns expected options raw object');
+    t.assertEquals(parsed.raw.get('universe'), "42", 'parse() does not a raw numeric option value');
+    t.assertEquals(parsed.raw.get('lap'), "13.37", 'parse() does not cast a raw float option value');
+    t.assertType(parsed.raw.get('lap'), "string", 'parse() does not cast a numeric value');
+    t.assert(parsed.raw.get('chucknorris'), 'parse() can get a flag value by its option name');
+    t.assertType(parsed.raw.get('oops'), "string", 'parse() can cast a boolean value');
+    t.assertEquals(parsed.raw.get('oops'), "false", 'parse() can cast a boolean value');
+
+    t.comment('drop() for raw');
+
+    parsed.raw.drop(0);
+    t.assertEquals(parsed.raw.get(0), 'baz & boz', 'drop() dropped raw arg');
+    parsed.raw.drop("universe");
+    t.assert(!parsed.raw.has("universe"), 'drop() dropped raw option');
+    t.assertEquals(parsed.raw.args, ["baz & boz"], 'drop() did not affect other raw args');
+    t.assertEquals(parsed.raw.options, {
+        lap: "13.37",
+        chucknorris: true,
+        oops: "false"
+    }, 'drop() did not affect other raw options');
+})(cli.parse(['foo & bar', 'baz & boz', '--universe=42', '--lap=13.37', '--chucknorris', '--oops=false']));
+
+t.done();