// // Utility functions for the HTML notebook's CasperJS tests. // casper.get_notebook_server = function () { // Get the URL of a notebook server on which to run tests. var port = casper.cli.get("port"); port = (typeof port === 'undefined') ? '8888' : port; return casper.cli.get("url") || ('http://127.0.0.1:' + port); }; // casper.thenClick doesn't seem to trigger click events properly casper.thenClick = function (selector) { return this.thenEvaluate(function(selector) { var el = $(selector); if (el.length === 0) { console.error("Missing element!", selector) } el.click(); }, {selector: selector}) } casper.open_new_notebook = function () { // Create and open a new notebook. var baseUrl = this.get_notebook_server(); this.start(baseUrl); this.waitFor(this.page_loaded); this.waitForSelector('#kernel-python2 a, #kernel-python3 a'); this.thenClick('#kernel-python2 a, #kernel-python3 a'); this.waitForPopup(''); this.withPopup('', function () {this.waitForSelector('.CodeMirror-code');}); this.then(function () { this.open(this.popups[0].url); }); this.waitFor(this.page_loaded); // Hook the log and error methods of the console, forcing them to // serialize their arguments before printing. This allows the // Objects to cross into the phantom/slimer regime for display. this.thenEvaluate(function(){ var serialize_arguments = function(f, context) { return function() { var pretty_arguments = []; for (var i = 0; i < arguments.length; i++) { var value = arguments[i]; if (value instanceof Object) { var name = value.name || 'Object'; // Print a JSON string representation of the object. // If we don't do this, [Object object] gets printed // by casper, which is useless. The long regular // expression reduces the verbosity of the JSON. pretty_arguments.push(name + ' {' + JSON.stringify(value, null, ' ') .replace(/(\s+)?({)?(\s+)?(}(\s+)?,?)?(\s+)?(\s+)?\n/g, '\n') .replace(/\n(\s+)?\n/g, '\n')); } else { pretty_arguments.push(value); } } f.apply(context, pretty_arguments); }; }; console.log = serialize_arguments(console.log, console); console.error = serialize_arguments(console.error, console); }); // Make sure the kernel has started this.waitFor(this.kernel_running); // track the IPython busy/idle state this.thenEvaluate(function () { require(['base/js/namespace', 'base/js/events'], function (IPython, events) { events.on('kernel_idle.Kernel',function () { IPython._status = 'idle'; }); events.on('kernel_busy.Kernel',function () { IPython._status = 'busy'; }); }); }); }; casper.page_loaded = function() { // Return whether or not the page has been loaded. return this.evaluate(function() { return typeof IPython !== "undefined" && IPython.page !== undefined; }); }; casper.kernel_running = function() { // Return whether or not the kernel is running. return this.evaluate(function() { return IPython && IPython.notebook && IPython.notebook.kernel && IPython.notebook.kernel.is_connected(); }); }; casper.kernel_disconnected = function() { return this.evaluate(function() { return IPython.notebook.kernel.is_fully_disconnected(); }); }; casper.wait_for_kernel_ready = function () { this.waitFor(this.kernel_running); this.thenEvaluate(function () { IPython._kernel_ready = false; IPython.notebook.kernel.kernel_info( function () { IPython._kernel_ready = true; }); }); this.waitFor(function () { return this.evaluate(function () { return IPython._kernel_ready; }); }); }; casper.shutdown_current_kernel = function () { // Shut down the current notebook's kernel. this.thenEvaluate(function() { IPython.notebook.session.delete(); }); // We close the page right after this so we need to give it time to complete. this.wait(1000); }; casper.delete_current_notebook = function () { // Delete created notebook. // For some unknown reason, this doesn't work?!? this.thenEvaluate(function() { IPython.notebook.delete(); }); }; casper.wait_for_busy = function () { // Waits for the notebook to enter a busy state. this.waitFor(function () { return this.evaluate(function () { return IPython._status == 'busy'; }); }); }; casper.wait_for_idle = function () { // Waits for the notebook to idle. this.waitFor(function () { return this.evaluate(function () { return IPython._status == 'idle'; }); }); }; casper.wait_for_output = function (cell_num, out_num) { // wait for the nth output in a given cell this.wait_for_idle(); 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}); }, function then() { }, function timeout() { this.echo("wait_for_output timed out on cell "+cell_num+", waiting for "+out_num+" outputs ."); var pn = this.evaluate(function get_prompt(c) { return (IPython.notebook.get_cell(c)|| {'input_prompt_number':'no cell'}).input_prompt_number; }); this.echo("cell prompt was :'"+pn+"'."); }); }); }; casper.wait_for_widget = function (widget_info) { // 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. // Clear the results of a previous query, if they exist. Make sure a // dictionary exists to store the async results in. this.thenEvaluate(function(model_id) { if (window.pending_msgs === undefined) { window.pending_msgs = {}; } else { window.pending_msgs[model_id] = -1; } }, {model_id: widget_info.model_id}); // Wait for the pending messages to be 0. this.waitFor(function () { var pending = this.evaluate(function (model_id) { // Get the model. Once the model is had, store it's pending_msgs // count in the window's dictionary. IPython.notebook.kernel.widget_manager.get_model(model_id) .then(function(model) { window.pending_msgs[model_id] = model.pending_msgs; }); // Return the pending_msgs result. return window.pending_msgs[model_id]; }, {model_id: widget_info.model_id}); if (pending === 0) { return true; } else { return false; } }); }; casper.cell_has_outputs = function (cell_num) { var result = casper.evaluate(function (c) { var cell = IPython.notebook.get_cell(c); return cell.output_area.outputs.length; }, {c : cell_num}); return result > 0; }; casper.get_output_cell = function (cell_num, out_num, message) { messsge = message+': ' ||'no category :' // return an output of a given cell out_num = out_num || 0; var result = casper.evaluate(function (c, o) { var cell = IPython.notebook.get_cell(c); return cell.output_area.outputs[o]; }, {c : cell_num, o : out_num}); 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, message+"Cell " + cell_num + " has no output #" + out_num + " (" + num_outputs + " total)" ); } else { return result; } }; casper.get_cells_length = function () { // return the number of cells in the notebook var result = casper.evaluate(function () { return IPython.notebook.get_cells().length; }); return result; }; casper.set_cell_text = function(index, text){ // Set the text content of a cell. this.evaluate(function (index, text) { var cell = IPython.notebook.get_cell(index); cell.set_text(text); }, index, text); }; casper.get_cell_text = function(index){ // Get the text content of a cell. return this.evaluate(function (index) { var cell = IPython.notebook.get_cell(index); return cell.get_text(); }, index); }; casper.insert_cell_at_bottom = function(cell_type){ // Inserts a cell at the bottom of the notebook // Returns the new cell's index. return this.evaluate(function (cell_type) { var cell = IPython.notebook.insert_cell_at_bottom(cell_type); return IPython.notebook.find_cell_index(cell); }, cell_type); }; casper.append_cell = function(text, cell_type) { // Insert a cell at the bottom of the notebook and set the cells text. // Returns the new cell's index. var index = this.insert_cell_at_bottom(cell_type); if (text !== undefined) { this.set_cell_text(index, text); } return index; }; casper.execute_cell = function(index, expect_failure){ // Asynchronously executes a cell by index. // Returns the cell's index. if (expect_failure === undefined) expect_failure = false; var that = this; this.then(function(){ that.evaluate(function (index) { var cell = IPython.notebook.get_cell(index); cell.execute(); }, index); }); 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')); } }); return index; }; casper.execute_cell_then = function(index, then_callback, expect_failure) { // 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. var return_val = this.execute_cell(index, expect_failure); this.wait_for_idle(); var that = this; this.then(function(){ if (then_callback!==undefined) { then_callback.apply(that, [index]); } }); return return_val; }; casper.append_cell_execute_then = function(text, then_callback, expect_failure) { // Append a code cell and execute it, optionally calling a then_callback var c = this.append_cell(text); return this.execute_cell_then(c, then_callback, expect_failure); }; casper.assert_output_equals = function(text, output_text, message) { // Append a code cell with the text, then assert the output is equal to output_text this.append_cell_execute_then(text, function(index) { this.test.assertEquals(this.get_output_cell(index).text.trim(), output_text, message); }); }; casper.wait_for_element = function(index, selector){ // Utility function that allows us to easily wait for an element // within a cell. Uses JQuery selector to look for the element. var that = this; this.waitFor(function() { return that.cell_element_exists(index, selector); }); }; casper.cell_element_exists = function(index, selector){ // Utility function that allows us to easily check if an element exists // within a cell. Uses JQuery selector to look for the element. 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){ // Utility function that allows us to execute a jQuery function on an // element within a cell. 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); }; casper.validate_notebook_state = function(message, mode, cell_index) { // Validate the entire dual mode state of the notebook. Make sure no more than // one cell is selected, focused, in edit mode, etc... // 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 + '; expecting cell ' + cell_index + ' to be the only cell selected. Got selected cell(s):'+ (function(){ return casper.evaluate(function(){ return IPython.notebook.get_selected_cells_indices(); }) })() ); } // 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 '+ this.cells_modes()); // 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'); } }; casper.select_cell = function(index, moveanchor) { // Select a cell in the notebook. this.evaluate(function (i, moveanchor) { IPython.notebook.select(i, moveanchor); }, {i: index, moveanchor: moveanchor}); }; casper.select_cells = function(index, bound, moveanchor) { // Select a block of cells in the notebook. // like Python range, selects [index,bound) this.evaluate(function (i, n, moveanchor) { Jupyter.notebook.select(i, moveanchor); Jupyter.notebook.extend_selection_by(n); }, {i: index, n: (bound - index - 1), moveanchor: moveanchor}); }; casper.click_cell_editor = function(index) { // Emulate a click on a cell's editor. // 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) { var cm = IPython.notebook.get_cell(i).code_mirror; if (cm.options.readOnly != "nocursor" && (document.activeElement != cm.display.input)){ cm.display.input.focus(); } }, {i: index}); }; casper.set_cell_editor_cursor = function(index, line_index, char_index) { // Set the Code Mirror instance cursor's location. this.evaluate(function (i, l, c) { IPython.notebook.get_cell(i).code_mirror.setCursor(l, c); }, {i: index, l: line_index, c: char_index}); }; casper.focus_notebook = function() { // Focus the notebook div. this.evaluate(function (){ $('#notebook').focus(); }, {}); }; casper.trigger_keydown = function() { // Emulate a keydown in the notebook. for (var i = 0; i < arguments.length; i++) { this.evaluate(function (k) { var element = $(document); var event = IPython.keyboard.shortcut_to_event(k, 'keydown'); element.trigger(event); }, {k: arguments[i]}); } }; casper.get_keyboard_mode = function() { // Get the mode of the keyboard manager. return this.evaluate(function() { return IPython.keyboard_manager.mode; }, {}); }; casper.get_notebook_mode = function() { // Get the mode of the notebook. return this.evaluate(function() { return IPython.notebook.mode; }, {}); }; casper.get_cell = function(index) { // Get a single cell. // // Note: Handles to DOM elements stored in the cell will be useless once in // CasperJS context. 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) { // Make sure a cell's editor is the only editor focused on the page. return this.evaluate(function(i) { 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]; } } return false; }, {i : index}); }; casper.is_only_cell_selected = function(index) { // Check if a cell is the only cell selected. // Pass null as the index to check if no cells are selected. return this.is_only_cell_on(index, 'selected', 'unselected'); }; casper.is_only_cell_edit = function(index) { // 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. var cells_length = this.get_cells_length(); for (var j = 0; j < cells_length; j++) { if (j === index) { if (!this.cell_mode_is(j, 'edit')) { return false; } } else { if (this.cell_mode_is(j, 'edit')) { return false; } } } return true; }; casper.is_only_cell_on = function(i, on_class, off_class) { // 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`. 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.cells_modes = function(){ return this.evaluate(function(){ return IPython.notebook.get_cells().map(function(x,c){return x.mode}) }, {}); }; casper.cell_mode_is = function(index, mode) { // Check if a cell is in a specific mode return this.evaluate(function(i, m) { var cell = IPython.notebook.get_cell(i); if (cell) { return cell.mode === m; } return false; }, {i : index, m: mode}); }; casper.cell_has_class = function(index, classes) { // Check if a cell has a class. 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}); }; casper.is_cell_rendered = function (index) { return this.evaluate(function(i) { return !!IPython.notebook.get_cell(i).rendered; }, {i:index}); }; 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 preceding 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') { var 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); }; casper.notebook_test = function(test) { // Wrap a notebook test to reduce boilerplate. this.open_new_notebook(); // Echo whether or not we are running this test using SlimerJS if (this.evaluate(function(){ return typeof InstallTrigger !== 'undefined'; // Firefox 1.0+ })) { console.log('This test is running in SlimerJS.'); this.slimerjs = true; } // Make sure to remove the onbeforeunload callback. This callback is // responsible for the "Are you sure you want to quit?" type messages. // PhantomJS ignores these prompts, SlimerJS does not which causes hangs. this.then(function(){ this.evaluate(function(){ window.onbeforeunload = function(){}; }); }); this.then(test); // Kill the kernel and delete the notebook. this.shutdown_current_kernel(); // This is still broken but shouldn't be a problem for now. // this.delete_current_notebook(); // 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; }); // Run the browser automation. this.run(function() { this.test.done(); }); }; casper.wait_for_dashboard = function () { // Wait for the dashboard list to load. casper.waitForSelector('.list_item'); }; /** * Open the dashboard page * @param {bool} use_start - If true, will use casper.start(), otherwise * casper.open(). You should only set it to true if the dashboard * is the first URL to be opened in the test, because calling * casper.start() multiple times causes casper to skip subsequent then() */ casper.open_dashboard = function (use_start) { if (use_start === undefined) { use_start = false; } // Start casper by opening the dashboard page. var baseUrl = this.get_notebook_server(); if (use_start) { this.start(baseUrl); } else { this.open(baseUrl); } this.waitFor(this.page_loaded); this.wait_for_dashboard(); }; casper.dashboard_test = function (test) { // Open the dashboard page and run a test. this.open_dashboard(true); this.then(test); this.then(function () { this.page.close(); this.page = null; }); // Run the browser automation. this.run(function() { this.test.done(); }); }; // note that this will only work for UNIQUE events -- if you want to // listen for the same event twice, this will not work! casper.event_test = function (name, events, action, timeout) { // set up handlers to listen for each of the events this.thenEvaluate(function (events) { var make_handler = function (event) { return function () { IPython._events_triggered.push(event); IPython.notebook.events.off(event, null, IPython._event_handlers[event]); delete IPython._event_handlers[event]; }; }; IPython._event_handlers = {}; IPython._events_triggered = []; for (var i=0; i < events.length; i++) { IPython._event_handlers[events[i]] = make_handler(events[i]); IPython.notebook.events.on(events[i], IPython._event_handlers[events[i]]); } }, [events]); // execute the requested action this.then(action); // wait for all the events to be triggered this.waitFor(function () { return this.evaluate(function (events) { return IPython._events_triggered.length >= events.length; }, [events]); }, undefined, undefined, timeout); // test that the events were triggered in the proper order this.then(function () { var triggered = this.evaluate(function () { return IPython._events_triggered; }); var handlers = this.evaluate(function () { return Object.keys(IPython._event_handlers); }); this.test.assertEquals(triggered.length, events.length, name + ': ' + events.length + ' events were triggered'); this.test.assertEquals(handlers.length, 0, name + ': all handlers triggered'); for (var i=0; i < events.length; i++) { this.test.assertEquals(triggered[i], events[i], name + ': ' + events[i] + ' was triggered'); } }); // turn off any remaining event listeners this.thenEvaluate(function () { for (var event in IPython._event_handlers) { IPython.notebook.events.off(event, null, IPython._event_handlers[event]); delete IPython._event_handlers[event]; } }); }; casper.options.waitTimeout=10000; casper.on('waitFor.timeout', function onWaitForTimeout(timeout) { this.echo("Timeout for " + casper.get_notebook_server()); this.echo("Is the notebook server running?"); }); casper.print_log = function () { // Pass `console.log` calls from page JS to casper. this.on('remote.message', function(msg) { this.echo('Remote message caught: ' + msg); }); }; casper.on("page.error", function onError(msg, trace) { // show errors in the browser this.echo("Page Error"); this.echo(" Message: " + msg.split('\n').join('\n ')); this.echo(" Call stack:"); var local_path = this.get_notebook_server(); 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"; } // remove the version tag from the path file = file.replace(/(\?v=[0-9abcdef]+)/, ''); // remove the local address from the beginning of the path if (file.indexOf(local_path) === 0) { file = file.substr(local_path.length); } var frame_text = (frame.function.length > 0) ? " in " + frame.function : ""; this.echo(" line " + frame.line + " of " + file + frame_text); } }); casper.capture_log = function () { // show captured errors var captured_log = []; var seen_errors = 0; this.on('remote.message', function(msg) { captured_log.push(msg); }); var that = this; 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++) { var output = String(captured_log[i]).split('\n'); for (var j = 0; j < output.length; j++) { casper.echo(" " + output[j]); } } } seen_errors = current_errors; captured_log = []; }); }; casper.interact = function() { // Start an interactive Javascript console. var system = require('system'); system.stdout.writeLine('JS interactive console.'); system.stdout.writeLine('Type `exit` to quit.'); function read_line() { system.stdout.writeLine('JS: '); var line = system.stdin.readLine(); return line; } var input = read_line(); while (input.trim() != 'exit') { var output = this.evaluate(function(code) { return String(eval(code)); }, {code: input}); system.stdout.writeLine('\nOut: ' + output); input = read_line(); } }; casper.capture_log();