util.js
627 lines
| 20.5 KiB
| application/javascript
|
JavascriptLexer
|
r13249 | // | ||
// Utility functions for the HTML notebook's CasperJS tests. | ||||
// | ||||
|
r13275 | casper.get_notebook_server = function () { | ||
|
r15942 | // Get the URL of a notebook server on which to run tests. | ||
|
r15939 | port = casper.cli.get("port"); | ||
|
r13271 | port = (typeof port === 'undefined') ? '8888' : port; | ||
|
r15939 | return 'http://127.0.0.1:' + port; | ||
|
r13249 | }; | ||
|
r13275 | casper.open_new_notebook = function () { | ||
|
r15942 | // Create and open a new notebook. | ||
|
r13275 | var baseUrl = this.get_notebook_server(); | ||
|
r13284 | this.start(baseUrl); | ||
|
r17212 | this.waitFor(this.page_loaded); | ||
|
r13284 | this.thenClick('button#new_notebook'); | ||
this.waitForPopup(''); | ||||
|
r13290 | this.withPopup('', function () {this.waitForSelector('.CodeMirror-code');}); | ||
|
r13284 | this.then(function () { | ||
this.open(this.popups[0].url); | ||||
}); | ||||
|
r17212 | this.waitFor(this.page_loaded); | ||
|
r13284 | |||
|
r14965 | // Make sure the kernel has started | ||
|
r17212 | this.waitFor(this.kernel_running); | ||
|
r14933 | // track the IPython busy/idle state | ||
this.thenEvaluate(function () { | ||||
|
r17324 | require(['base/js/namespace', 'base/js/events'], function (IPython, events) { | ||
events.on('status_idle.Kernel',function () { | ||||
IPython._status = 'idle'; | ||||
}); | ||||
events.on('status_busy.Kernel',function () { | ||||
IPython._status = 'busy'; | ||||
}); | ||||
|
r14933 | }); | ||
}); | ||||
|
r16828 | |||
// Because of the asynchronous nature of SlimerJS (Gecko), we need to make | ||||
// sure the notebook has actually been loaded into the IPython namespace | ||||
// before running any tests. | ||||
this.waitFor(function() { | ||||
return this.evaluate(function () { | ||||
return IPython.notebook; | ||||
}); | ||||
}); | ||||
|
r13302 | }; | ||
|
r17212 | casper.page_loaded = function() { | ||
|
r15942 | // Return whether or not the kernel is running. | ||
|
r17212 | return this.evaluate(function() { | ||
|
r18076 | return typeof IPython !== "undefined" && | ||
|
r17318 | IPython.page !== undefined; | ||
|
r17212 | }); | ||
}; | ||||
casper.kernel_running = function() { | ||||
// Return whether or not the kernel is running. | ||||
return this.evaluate(function() { | ||||
|
r13302 | return IPython.notebook.kernel.running; | ||
|
r13290 | }); | ||
|
r13249 | }; | ||
|
r13275 | casper.shutdown_current_kernel = function () { | ||
|
r15942 | // Shut down the current notebook's kernel. | ||
|
r13249 | this.thenEvaluate(function() { | ||
|
r17224 | IPython.notebook.session.delete(); | ||
|
r13249 | }); | ||
|
r14965 | // We close the page right after this so we need to give it time to complete. | ||
this.wait(1000); | ||||
|
r13249 | }; | ||
|
r13275 | casper.delete_current_notebook = function () { | ||
|
r15942 | // Delete created notebook. | ||
|
r14965 | // For some unknown reason, this doesn't work?!? | ||
|
r13249 | this.thenEvaluate(function() { | ||
|
r14965 | IPython.notebook.delete(); | ||
|
r13249 | }); | ||
}; | ||||
|
r15042 | casper.wait_for_busy = function () { | ||
|
r15942 | // Waits for the notebook to enter a busy state. | ||
|
r15042 | this.waitFor(function () { | ||
return this.evaluate(function () { | ||||
return IPython._status == 'busy'; | ||||
}); | ||||
}); | ||||
}; | ||||
|
r14933 | casper.wait_for_idle = function () { | ||
|
r15942 | // Waits for the notebook to idle. | ||
|
r14934 | this.waitFor(function () { | ||
return this.evaluate(function () { | ||||
return IPython._status == 'idle'; | ||||
|
r14933 | }); | ||
}); | ||||
}; | ||||
|
r14904 | casper.wait_for_output = function (cell_num, out_num) { | ||
|
r15942 | // wait for the nth output in a given cell | ||
|
r14933 | this.wait_for_idle(); | ||
|
r14904 | out_num = out_num || 0; | ||
this.then(function() { | ||||
this.waitFor(function (c, o) { | ||||
return this.evaluate(function get_output(c, o) { | ||||
var cell = IPython.notebook.get_cell(c); | ||||
return cell.output_area.outputs.length > o; | ||||
}, | ||||
// pass parameter from the test suite js to the browser code js | ||||
{c : cell_num, o : out_num}); | ||||
}); | ||||
|
r14435 | }, | ||
function then() { }, | ||||
function timeout() { | ||||
this.echo("wait_for_output timed out!"); | ||||
|
r13294 | }); | ||
}; | ||||
|
r14970 | casper.wait_for_widget = function (widget_info) { | ||
|
r15942 | // wait for a widget msg que to reach 0 | ||
// | ||||
// Parameters | ||||
// ---------- | ||||
// widget_info : object | ||||
// Object which contains info related to the widget. The model_id property | ||||
// is used to identify the widget. | ||||
|
r14970 | this.waitFor(function () { | ||
var pending = this.evaluate(function (m) { | ||||
return IPython.notebook.kernel.widget_manager.get_model(m).pending_msgs; | ||||
}, {m: widget_info.model_id}); | ||||
|
r15939 | if (pending === 0) { | ||
|
r14970 | return true; | ||
} else { | ||||
return false; | ||||
} | ||||
}); | ||||
|
r15939 | }; | ||
|
r14970 | |||
|
r14147 | casper.get_output_cell = function (cell_num, out_num) { | ||
|
r15942 | // return an output of a given cell | ||
|
r14147 | out_num = out_num || 0; | ||
var result = casper.evaluate(function (c, o) { | ||||
|
r13299 | var cell = IPython.notebook.get_cell(c); | ||
|
r14147 | return cell.output_area.outputs[o]; | ||
|
r13299 | }, | ||
|
r14147 | {c : cell_num, o : out_num}); | ||
|
r14864 | if (!result) { | ||
var num_outputs = casper.evaluate(function (c) { | ||||
var cell = IPython.notebook.get_cell(c); | ||||
return cell.output_area.outputs.length; | ||||
}, | ||||
{c : cell_num}); | ||||
this.test.assertTrue(false, | ||||
"Cell " + cell_num + " has no output #" + out_num + " (" + num_outputs + " total)" | ||||
); | ||||
} else { | ||||
return result; | ||||
} | ||||
|
r13299 | }; | ||
|
r13300 | casper.get_cells_length = function () { | ||
|
r15942 | // return the number of cells in the notebook | ||
|
r13300 | var result = casper.evaluate(function () { | ||
return IPython.notebook.get_cells().length; | ||||
|
r15939 | }); | ||
|
r13300 | return result; | ||
}; | ||||
|
r13765 | casper.set_cell_text = function(index, text){ | ||
|
r15942 | // Set the text content of a cell. | ||
|
r13765 | this.evaluate(function (index, text) { | ||
var cell = IPython.notebook.get_cell(index); | ||||
cell.set_text(text); | ||||
|
r14933 | }, index, text); | ||
|
r13765 | }; | ||
|
r15929 | casper.get_cell_text = function(index){ | ||
|
r15942 | // Get the text content of a cell. | ||
|
r15929 | return this.evaluate(function (index) { | ||
var cell = IPython.notebook.get_cell(index); | ||||
return cell.get_text(); | ||||
}, index); | ||||
}; | ||||
|
r13766 | casper.insert_cell_at_bottom = function(cell_type){ | ||
|
r15942 | // Inserts a cell at the bottom of the notebook | ||
// Returns the new cell's index. | ||||
|
r13766 | return this.evaluate(function (cell_type) { | ||
var cell = IPython.notebook.insert_cell_at_bottom(cell_type); | ||||
return IPython.notebook.find_cell_index(cell); | ||||
|
r14933 | }, cell_type); | ||
|
r13766 | }; | ||
|
r13765 | casper.append_cell = function(text, cell_type) { | ||
|
r15942 | // Insert a cell at the bottom of the notebook and set the cells text. | ||
// Returns the new cell's index. | ||||
|
r13766 | var index = this.insert_cell_at_bottom(cell_type); | ||
|
r13765 | if (text !== undefined) { | ||
|
r13766 | this.set_cell_text(index, text); | ||
|
r13765 | } | ||
return index; | ||||
}; | ||||
|
r18170 | casper.execute_cell = function(index, expect_failure){ | ||
|
r15942 | // Asynchronously executes a cell by index. | ||
// Returns the cell's index. | ||||
|
r18170 | |||
if (expect_failure === undefined) expect_failure = false; | ||||
|
r13765 | var that = this; | ||
this.then(function(){ | ||||
that.evaluate(function (index) { | ||||
var cell = IPython.notebook.get_cell(index); | ||||
cell.execute(); | ||||
|
r14933 | }, index); | ||
|
r13765 | }); | ||
|
r18170 | this.wait_for_idle(); | ||
this.then(function () { | ||||
var error = that.evaluate(function (index) { | ||||
var cell = IPython.notebook.get_cell(index); | ||||
var outputs = cell.output_area.outputs; | ||||
for (var i = 0; i < outputs.length; i++) { | ||||
if (outputs[i].output_type == 'error') { | ||||
return outputs[i]; | ||||
} | ||||
} | ||||
return false; | ||||
}, index); | ||||
if (error === null) { | ||||
this.test.fail("Failed to check for error output"); | ||||
} | ||||
if (expect_failure && error === false) { | ||||
this.test.fail("Expected error while running cell"); | ||||
} else if (!expect_failure && error !== false) { | ||||
this.test.fail("Error running cell:\n" + error.traceback.join('\n')); | ||||
} | ||||
}); | ||||
|
r13765 | return index; | ||
}; | ||||
|
r18170 | casper.execute_cell_then = function(index, then_callback, expect_failure) { | ||
|
r15942 | // Synchronously executes a cell by index. | ||
// Optionally accepts a then_callback parameter. then_callback will get called | ||||
// when the cell has finished executing. | ||||
// Returns the cell's index. | ||||
|
r18170 | var return_val = this.execute_cell(index, expect_failure); | ||
|
r13765 | |||
|
r14933 | this.wait_for_idle(); | ||
|
r13765 | |||
var that = this; | ||||
this.then(function(){ | ||||
if (then_callback!==undefined) { | ||||
then_callback.apply(that, [index]); | ||||
} | ||||
|
r18170 | }); | ||
|
r13765 | |||
return return_val; | ||||
}; | ||||
casper.cell_element_exists = function(index, selector){ | ||||
|
r15942 | // Utility function that allows us to easily check if an element exists | ||
// within a cell. Uses JQuery selector to look for the element. | ||||
|
r13765 | return casper.evaluate(function (index, selector) { | ||
var $cell = IPython.notebook.get_cell(index).element; | ||||
return $cell.find(selector).length > 0; | ||||
}, index, selector); | ||||
}; | ||||
casper.cell_element_function = function(index, selector, function_name, function_args){ | ||||
|
r15942 | // Utility function that allows us to execute a jQuery function on an | ||
// element within a cell. | ||||
|
r13765 | return casper.evaluate(function (index, selector, function_name, function_args) { | ||
var $cell = IPython.notebook.get_cell(index).element; | ||||
var $el = $cell.find(selector); | ||||
return $el[function_name].apply($el, function_args); | ||||
}, index, selector, function_name, function_args); | ||||
}; | ||||
|
r15935 | casper.validate_notebook_state = function(message, mode, cell_index) { | ||
|
r15942 | // Validate the entire dual mode state of the notebook. Make sure no more than | ||
// one cell is selected, focused, in edit mode, etc... | ||||
|
r15935 | // General tests. | ||
this.test.assertEquals(this.get_keyboard_mode(), this.get_notebook_mode(), | ||||
message + '; keyboard and notebook modes match'); | ||||
// Is the selected cell the only cell that is selected? | ||||
if (cell_index!==undefined) { | ||||
this.test.assert(this.is_only_cell_selected(cell_index), | ||||
message + '; cell ' + cell_index + ' is the only cell selected'); | ||||
} | ||||
// Mode specific tests. | ||||
if (mode==='command') { | ||||
// Are the notebook and keyboard manager in command mode? | ||||
this.test.assertEquals(this.get_keyboard_mode(), 'command', | ||||
message + '; in command mode'); | ||||
// Make sure there isn't a single cell in edit mode. | ||||
this.test.assert(this.is_only_cell_edit(null), | ||||
message + '; all cells in command mode'); | ||||
this.test.assert(this.is_cell_editor_focused(null), | ||||
message + '; no cell editors are focused while in command mode'); | ||||
} else if (mode==='edit') { | ||||
// Are the notebook and keyboard manager in edit mode? | ||||
this.test.assertEquals(this.get_keyboard_mode(), 'edit', | ||||
message + '; in edit mode'); | ||||
if (cell_index!==undefined) { | ||||
// Is the specified cell the only cell in edit mode? | ||||
this.test.assert(this.is_only_cell_edit(cell_index), | ||||
message + '; cell ' + cell_index + ' is the only cell in edit mode'); | ||||
// Is the specified cell the only cell with a focused code mirror? | ||||
this.test.assert(this.is_cell_editor_focused(cell_index), | ||||
message + '; cell ' + cell_index + '\'s editor is appropriately focused'); | ||||
} | ||||
} else { | ||||
this.test.assert(false, message + '; ' + mode + ' is an unknown mode'); | ||||
} | ||||
}; | ||||
|
r15932 | |||
casper.select_cell = function(index) { | ||||
|
r15942 | // Select a cell in the notebook. | ||
|
r15932 | this.evaluate(function (i) { | ||
IPython.notebook.select(i); | ||||
}, {i: index}); | ||||
}; | ||||
casper.click_cell_editor = function(index) { | ||||
|
r15942 | // Emulate a click on a cell's editor. | ||
|
r15932 | // Code Mirror does not play nicely with emulated brower events. | ||
// Instead of trying to emulate a click, here we run code similar to | ||||
// the code used in Code Mirror that handles the mousedown event on a | ||||
// region of codemirror that the user can focus. | ||||
this.evaluate(function (i) { | ||||
|
r15933 | var cm = IPython.notebook.get_cell(i).code_mirror; | ||
|
r15932 | if (cm.options.readOnly != "nocursor" && (document.activeElement != cm.display.input)) | ||
cm.display.input.focus(); | ||||
}, {i: index}); | ||||
}; | ||||
|
r15933 | casper.set_cell_editor_cursor = function(index, line_index, char_index) { | ||
|
r15942 | // Set the Code Mirror instance cursor's location. | ||
|
r15933 | this.evaluate(function (i, l, c) { | ||
IPython.notebook.get_cell(i).code_mirror.setCursor(l, c); | ||||
}, {i: index, l: line_index, c: char_index}); | ||||
}; | ||||
|
r15932 | casper.focus_notebook = function() { | ||
|
r15942 | // Focus the notebook div. | ||
|
r15932 | this.evaluate(function (){ | ||
$('#notebook').focus(); | ||||
}, {}); | ||||
}; | ||||
casper.trigger_keydown = function() { | ||||
|
r15942 | // Emulate a keydown in the notebook. | ||
|
r15932 | for (var i = 0; i < arguments.length; i++) { | ||
this.evaluate(function (k) { | ||||
|
r15937 | var element = $(document); | ||
var event = IPython.keyboard.shortcut_to_event(k, 'keydown'); | ||||
element.trigger(event); | ||||
|
r15932 | }, {k: arguments[i]}); | ||
} | ||||
}; | ||||
casper.get_keyboard_mode = function() { | ||||
|
r15942 | // Get the mode of the keyboard manager. | ||
|
r15932 | return this.evaluate(function() { | ||
return IPython.keyboard_manager.mode; | ||||
}, {}); | ||||
}; | ||||
casper.get_notebook_mode = function() { | ||||
|
r15942 | // Get the mode of the notebook. | ||
|
r15932 | return this.evaluate(function() { | ||
return IPython.notebook.mode; | ||||
}, {}); | ||||
}; | ||||
casper.get_cell = function(index) { | ||||
|
r15942 | // Get a single cell. | ||
// | ||||
// Note: Handles to DOM elements stored in the cell will be useless once in | ||||
// CasperJS context. | ||||
|
r15932 | return this.evaluate(function(i) { | ||
var cell = IPython.notebook.get_cell(i); | ||||
if (cell) { | ||||
return cell; | ||||
} | ||||
return null; | ||||
}, {i : index}); | ||||
}; | ||||
casper.is_cell_editor_focused = function(index) { | ||||
|
r15942 | // Make sure a cell's editor is the only editor focused on the page. | ||
|
r15932 | return this.evaluate(function(i) { | ||
|
r15934 | var focused_textarea = $('#notebook .CodeMirror-focused textarea'); | ||
if (focused_textarea.length > 1) { throw 'More than one Code Mirror editor is focused at once!'; } | ||||
if (i === null) { | ||||
return focused_textarea.length === 0; | ||||
} else { | ||||
var cell = IPython.notebook.get_cell(i); | ||||
if (cell) { | ||||
return cell.code_mirror.getInputField() == focused_textarea[0]; | ||||
} | ||||
|
r15932 | } | ||
return false; | ||||
}, {i : index}); | ||||
}; | ||||
casper.is_only_cell_selected = function(index) { | ||||
|
r15942 | // Check if a cell is the only cell selected. | ||
// Pass null as the index to check if no cells are selected. | ||||
|
r15932 | return this.is_only_cell_on(index, 'selected', 'unselected'); | ||
}; | ||||
casper.is_only_cell_edit = function(index) { | ||||
|
r15942 | // Check if a cell is the only cell in edit mode. | ||
// Pass null as the index to check if all of the cells are in command mode. | ||||
|
r15932 | return this.is_only_cell_on(index, 'edit_mode', 'command_mode'); | ||
}; | ||||
casper.is_only_cell_on = function(i, on_class, off_class) { | ||||
|
r15942 | // Check if a cell is the only cell with the `on_class` DOM class applied to it. | ||
// All of the other cells are checked for the `off_class` DOM class. | ||||
// Pass null as the index to check if all of the cells have the `off_class`. | ||||
|
r15932 | var cells_length = this.get_cells_length(); | ||
for (var j = 0; j < cells_length; j++) { | ||||
if (j === i) { | ||||
if (this.cell_has_class(j, off_class) || !this.cell_has_class(j, on_class)) { | ||||
return false; | ||||
} | ||||
} else { | ||||
if (!this.cell_has_class(j, off_class) || this.cell_has_class(j, on_class)) { | ||||
return false; | ||||
} | ||||
} | ||||
} | ||||
return true; | ||||
}; | ||||
casper.cell_has_class = function(index, classes) { | ||||
|
r15942 | // Check if a cell has a class. | ||
|
r15932 | return this.evaluate(function(i, c) { | ||
var cell = IPython.notebook.get_cell(i); | ||||
if (cell) { | ||||
return cell.element.hasClass(c); | ||||
} | ||||
return false; | ||||
}, {i : index, c: classes}); | ||||
}; | ||||
|
r16843 | casper.is_cell_rendered = function (index) { | ||
|
r16840 | return this.evaluate(function(i) { | ||
return !!IPython.notebook.get_cell(i).rendered; | ||||
|
r16843 | }, {i:index}); | ||
|
r16840 | }; | ||
|
r16839 | casper.assert_colors_equal = function (hex_color, local_color, msg) { | ||
// Tests to see if two colors are equal. | ||||
// | ||||
// Parameters | ||||
// hex_color: string | ||||
// Hexadecimal color code, with or without preceeding hash character. | ||||
// local_color: string | ||||
// Local color representation. Can either be hexadecimal (default for | ||||
// phantom) or rgb (default for slimer). | ||||
// Remove parentheses, hashes, semi-colons, and space characters. | ||||
hex_color = hex_color.replace(/[\(\); #]/, ''); | ||||
local_color = local_color.replace(/[\(\); #]/, ''); | ||||
// If the local color is rgb, clean it up and replace | ||||
if (local_color.substr(0,3).toLowerCase() == 'rgb') { | ||||
components = local_color.substr(3).split(','); | ||||
local_color = ''; | ||||
for (var i = 0; i < components.length; i++) { | ||||
var part = parseInt(components[i]).toString(16); | ||||
while (part.length < 2) part = '0' + part; | ||||
local_color += part; | ||||
} | ||||
} | ||||
this.test.assertEquals(hex_color.toUpperCase(), local_color.toUpperCase(), msg); | ||||
}; | ||||
|
r13275 | casper.notebook_test = function(test) { | ||
|
r15942 | // Wrap a notebook test to reduce boilerplate. | ||
|
r13275 | this.open_new_notebook(); | ||
|
r14965 | |||
|
r16828 | // Echo whether or not we are running this test using SlimerJS | ||
if (this.evaluate(function(){ | ||||
return typeof InstallTrigger !== 'undefined'; // Firefox 1.0+ | ||||
|
r16841 | })) { | ||
console.log('This test is running in SlimerJS.'); | ||||
this.slimerjs = true; | ||||
} | ||||
|
r16828 | |||
// Make sure to remove the onbeforeunload callback. This callback is | ||||
|
r16861 | // responsible for the "Are you sure you want to quit?" type messages. | ||
|
r16828 | // PhantomJS ignores these prompts, SlimerJS does not which causes hangs. | ||
this.then(function(){ | ||||
this.evaluate(function(){ | ||||
window.onbeforeunload = function(){}; | ||||
|
r17338 | }); | ||
|
r16828 | }); | ||
this.then(test); | ||||
|
r14965 | // Kill the kernel and delete the notebook. | ||
|
r13288 | this.shutdown_current_kernel(); | ||
|
r14965 | // This is still broken but shouldn't be a problem for now. | ||
// this.delete_current_notebook(); | ||||
|
r13285 | |||
|
r14965 | // This is required to clean up the page we just finished with. If we don't call this | ||
// casperjs will leak file descriptors of all the open WebSockets in that page. We | ||||
// have to set this.page=null so that next time casper.start runs, it will create a | ||||
// new page from scratch. | ||||
this.then(function () { | ||||
this.page.close(); | ||||
this.page = null; | ||||
}); | ||||
|
r13253 | |||
// Run the browser automation. | ||||
this.run(function() { | ||||
this.test.done(); | ||||
}); | ||||
}; | ||||
|
r15081 | casper.wait_for_dashboard = function () { | ||
// Wait for the dashboard list to load. | ||||
casper.waitForSelector('.list_item'); | ||||
|
r15939 | }; | ||
|
r15081 | |||
casper.open_dashboard = function () { | ||||
// Start casper by opening the dashboard page. | ||||
var baseUrl = this.get_notebook_server(); | ||||
this.start(baseUrl); | ||||
|
r17212 | this.waitFor(this.page_loaded); | ||
|
r15081 | this.wait_for_dashboard(); | ||
|
r15939 | }; | ||
|
r15081 | |||
casper.dashboard_test = function (test) { | ||||
// Open the dashboard page and run a test. | ||||
this.open_dashboard(); | ||||
this.then(test); | ||||
this.then(function () { | ||||
this.page.close(); | ||||
this.page = null; | ||||
}); | ||||
// Run the browser automation. | ||||
this.run(function() { | ||||
this.test.done(); | ||||
}); | ||||
|
r15939 | }; | ||
|
r15081 | |||
|
r15939 | casper.options.waitTimeout=10000; | ||
|
r13272 | casper.on('waitFor.timeout', function onWaitForTimeout(timeout) { | ||
|
r13275 | this.echo("Timeout for " + casper.get_notebook_server()); | ||
|
r13272 | this.echo("Is the notebook server running?"); | ||
}); | ||||
|
r15934 | casper.print_log = function () { | ||
|
r15942 | // Pass `console.log` calls from page JS to casper. | ||
|
r13249 | this.on('remote.message', function(msg) { | ||
this.echo('Remote message caught: ' + msg); | ||||
}); | ||||
}; | ||||
|
r17338 | |||
casper.on("page.error", function onError(msg, trace) { | ||||
// show errors in the browser | ||||
this.echo("Page Error!"); | ||||
for (var i = 0; i < trace.length; i++) { | ||||
var frame = trace[i]; | ||||
var file = frame.file; | ||||
// shorten common phantomjs evaluate url | ||||
// this will have a different value on slimerjs | ||||
if (file === "phantomjs://webpage.evaluate()") { | ||||
file = "evaluate"; | ||||
} | ||||
this.echo("line " + frame.line + " of " + file); | ||||
if (frame.function.length > 0) { | ||||
this.echo("in " + frame.function); | ||||
} | ||||
} | ||||
this.echo(msg); | ||||
}); | ||||
casper.capture_log = function () { | ||||
// show captured errors | ||||
var captured_log = []; | ||||
var seen_errors = 0; | ||||
this.on('remote.message', function(msg) { | ||||
captured_log.push(msg); | ||||
}); | ||||
this.test.on("test.done", function (result) { | ||||
// test.done runs per-file, | ||||
// but suiteResults is per-suite (directory) | ||||
var current_errors; | ||||
if (this.suiteResults) { | ||||
// casper 1.1 has suiteResults | ||||
current_errors = this.suiteResults.countErrors() + this.suiteResults.countFailed(); | ||||
} else { | ||||
// casper 1.0 has testResults instead | ||||
current_errors = this.testResults.failed; | ||||
} | ||||
if (current_errors > seen_errors && captured_log.length > 0) { | ||||
casper.echo("\nCaptured console.log:"); | ||||
for (var i = 0; i < captured_log.length; i++) { | ||||
casper.echo(" " + captured_log[i]); | ||||
} | ||||
} | ||||
seen_errors = current_errors; | ||||
captured_log = []; | ||||
}); | ||||
}; | ||||
casper.capture_log(); | ||||