Make all tests async display safe

IPython/html/static/widgets/js/widget.js

@@ -1,603 +1,603
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define(["widgets/js/manager",
         "underscore",
         "backbone",
         "jquery",
         "base/js/utils",
         "base/js/namespace",
 ], function(widgetmanager, _, Backbone, $, utils, IPython){
 
     var WidgetModel = Backbone.Model.extend({
         constructor: function (widget_manager, model_id, comm) {
             // Constructor
             //
             // Creates a WidgetModel instance.
             //
             // Parameters
             // ----------
             // widget_manager : WidgetManager instance
             // model_id : string
             //      An ID unique to this model.
             // comm : Comm instance (optional)
             this.widget_manager = widget_manager;
             this.state_change = Promise.resolve();
             this._buffered_state_diff = {};
             this.pending_msgs = 0;
             this.msg_buffer = null;
             this.state_lock = null;
             this.id = model_id;
             this.views = {};
 
             if (comm !== undefined) {
                 // Remember comm associated with the model.
                 this.comm = comm;
                 comm.model = this;
 
                 // Hook comm messages up to model.
                 comm.on_close($.proxy(this._handle_comm_closed, this));
                 comm.on_msg($.proxy(this._handle_comm_msg, this));
             }
             return Backbone.Model.apply(this);
         },
 
         send: function (content, callbacks) {
             // Send a custom msg over the comm.
             if (this.comm !== undefined) {
                 var data = {method: 'custom', content: content};
                 this.comm.send(data, callbacks);
                 this.pending_msgs++;
             }
         },
 
         _handle_comm_closed: function (msg) {
             // Handle when a widget is closed.
             this.trigger('comm:close');
             this.stopListening();
             this.trigger('destroy', this);
             delete this.comm.model; // Delete ref so GC will collect widget model.
             delete this.comm;
             delete this.model_id; // Delete id from model so widget manager cleans up.
             for (var id in this.views) {
                 if (this.views.hasOwnProperty(id)) {
                     this.views[id].remove();
                 }
             }
         },
 
         _handle_comm_msg: function (msg) {
             // Handle incoming comm msg.
             var method = msg.content.data.method;
             var that = this;
             switch (method) {
                 case 'update':
                     this.state_change = this.state_change.then(function() {
                         return that.set_state(msg.content.data.state);
                     }).catch(utils.reject("Couldn't process update msg for model id '" + String(that.id) + "'", true));
                     break;
                 case 'custom':
                     this.trigger('msg:custom', msg.content.data.content);
                     break;
                 case 'display':
-                    return that.widget_manager.display_view(msg, that);
+                    this.widget_manager.display_view(msg, that);
                     break;
             }
         },
 
         set_state: function (state) {
             var that = this;
             // Handle when a widget is updated via the python side.
             return this._unpack_models(state).then(function(state) {
                 that.state_lock = state;
                 try {
                     WidgetModel.__super__.set.call(that, state);
                 } finally {
                     that.state_lock = null;
                 }
                 return Promise.resolve();
             }, utils.reject("Couldn't set model state", true));
         },
 
         _handle_status: function (msg, callbacks) {
             // Handle status msgs.
 
             // execution_state : ('busy', 'idle', 'starting')
             if (this.comm !== undefined) {
                 if (msg.content.execution_state ==='idle') {
                     // Send buffer if this message caused another message to be
                     // throttled.
                     if (this.msg_buffer !== null &&
                         (this.get('msg_throttle') || 3) === this.pending_msgs) {
                         var data = {method: 'backbone', sync_method: 'update', sync_data: this.msg_buffer};
                         this.comm.send(data, callbacks);
                         this.msg_buffer = null;
                     } else {
                         --this.pending_msgs;
                     }
                 }
             }
         },
 
         callbacks: function(view) {
             // Create msg callbacks for a comm msg.
             var callbacks = this.widget_manager.callbacks(view);
 
             if (callbacks.iopub === undefined) {
                 callbacks.iopub = {};
             }
 
             var that = this;
             callbacks.iopub.status = function (msg) {
                 that._handle_status(msg, callbacks);
             };
             return callbacks;
         },
 
         set: function(key, val, options) {
             // Set a value.
             var return_value = WidgetModel.__super__.set.apply(this, arguments);
 
             // Backbone only remembers the diff of the most recent set()
             // operation.  Calling set multiple times in a row results in a 
             // loss of diff information.  Here we keep our own running diff.
             this._buffered_state_diff = $.extend(this._buffered_state_diff, this.changedAttributes() || {});
             return return_value;
         },
 
         sync: function (method, model, options) {
             // Handle sync to the back-end.  Called when a model.save() is called.
 
             // Make sure a comm exists.
             var error = options.error || function() {
                 console.error('Backbone sync error:', arguments);
             };
             if (this.comm === undefined) {
                 error();
                 return false;
             }
 
             // Delete any key value pairs that the back-end already knows about.
             var attrs = (method === 'patch') ? options.attrs : model.toJSON(options);
             if (this.state_lock !== null) {
                 var keys = Object.keys(this.state_lock);
                 for (var i=0; i<keys.length; i++) {
                     var key = keys[i];
                     if (attrs[key] === this.state_lock[key]) {
                         delete attrs[key];
                     }
                 }
             }
 
             // Only sync if there are attributes to send to the back-end.
             attrs = this._pack_models(attrs);
             if (_.size(attrs) > 0) {
 
                 // If this message was sent via backbone itself, it will not
                 // have any callbacks.  It's important that we create callbacks
                 // so we can listen for status messages, etc...
                 var callbacks = options.callbacks || this.callbacks();
 
                 // Check throttle.
                 if (this.pending_msgs >= (this.get('msg_throttle') || 3)) {
                     // The throttle has been exceeded, buffer the current msg so
                     // it can be sent once the kernel has finished processing 
                     // some of the existing messages.
                     
                     // Combine updates if it is a 'patch' sync, otherwise replace updates
                     switch (method) {
                         case 'patch':
                             this.msg_buffer = $.extend(this.msg_buffer || {}, attrs);
                             break;
                         case 'update':
                         case 'create':
                             this.msg_buffer = attrs;
                             break;
                         default:
                             error();
                             return false;
                     }
                     this.msg_buffer_callbacks = callbacks;
 
                 } else {
                     // We haven't exceeded the throttle, send the message like 
                     // normal.
                     var data = {method: 'backbone', sync_data: attrs};
                     this.comm.send(data, callbacks);
                     this.pending_msgs++;
                 }
             }
             // Since the comm is a one-way communication, assume the message 
             // arrived.  Don't call success since we don't have a model back from the server
             // this means we miss out on the 'sync' event.
             this._buffered_state_diff = {};
         },
 
         save_changes: function(callbacks) {
             // Push this model's state to the back-end
             //
             // This invokes a Backbone.Sync.
             this.save(this._buffered_state_diff, {patch: true, callbacks: callbacks});
         },
 
         _pack_models: function(value) {
             // Replace models with model ids recursively.
             var that = this;
             var packed;
             if (value instanceof Backbone.Model) {
                 return "IPY_MODEL_" + value.id;
 
             } else if ($.isArray(value)) {
                 packed = [];
                 _.each(value, function(sub_value, key) {
                     packed.push(that._pack_models(sub_value));
                 });
                 return packed;
             } else if (value instanceof Date || value instanceof String) {
                 return value;
             } else if (value instanceof Object) {
                 packed = {};
                 _.each(value, function(sub_value, key) {
                     packed[key] = that._pack_models(sub_value);
                 });
                 return packed;
 
             } else {
                 return value;
             }
         },
 
         _unpack_models: function(value) {
             // Replace model ids with models recursively.
             var that = this;
             var unpacked;
             if ($.isArray(value)) {
                 unpacked = [];
                 _.each(value, function(sub_value, key) {
                     unpacked.push(that._unpack_models(sub_value));
                 });
                 return Promise.all(unpacked);
             } else if (value instanceof Object) {
                 unpacked = {};
                 _.each(value, function(sub_value, key) {
                     unpacked[key] = that._unpack_models(sub_value);
                 });
                 return utils.resolve_dict(unpacked);
             } else if (typeof value === 'string' && value.slice(0,10) === "IPY_MODEL_") {
                 // get_model returns a promise already
                 return this.widget_manager.get_model(value.slice(10, value.length));
             } else {
                 return Promise.resolve(value);
             }
         },
 
         on_some_change: function(keys, callback, context) {
             // on_some_change(["key1", "key2"], foo, context) differs from
             // on("change:key1 change:key2", foo, context).
             // If the widget attributes key1 and key2 are both modified, 
             // the second form will result in foo being called twice
             // while the first will call foo only once.
             this.on('change', function() {
                 if (keys.some(this.hasChanged, this)) {
                     callback.apply(context);
                 }
             }, this);
 
        },
     });
     widgetmanager.WidgetManager.register_widget_model('WidgetModel', WidgetModel);
 
 
     var WidgetView = Backbone.View.extend({
         initialize: function(parameters) {
             // Public constructor.
             this.model.on('change',this.update,this);
             this.options = parameters.options;
             this.child_model_views = {};
             this.child_views = {};
             this.id = this.id || utils.uuid();
             this.model.views[this.id] = this;
             this.on('displayed', function() { 
                 this.is_displayed = true; 
             }, this);
         },
 
         update: function(){
             // Triggered on model change.
             //
             // Update view to be consistent with this.model
         },
 
         create_child_view: function(child_model, options) {
             // Create and promise that resolves to a child view of a given model
             var that = this;
             options = $.extend({ parent: this }, options || {});
             return this.model.widget_manager.create_view(child_model, options).then(function(child_view) {
                 // Associate the view id with the model id.
                 if (that.child_model_views[child_model.id] === undefined) {
                     that.child_model_views[child_model.id] = [];
                 }
                 that.child_model_views[child_model.id].push(child_view.id);
                 // Remember the view by id.
                 that.child_views[child_view.id] = child_view;
                 return child_view;
             }, utils.reject("Couldn't create child view"));
         },
 
         pop_child_view: function(child_model) {
             // Delete a child view that was previously created using create_child_view.
             var view_ids = this.child_model_views[child_model.id];
             if (view_ids !== undefined) {
 
                 // Only delete the first view in the list.
                 var view_id = view_ids[0];
                 var view = this.child_views[view_id];
                 delete this.child_views[view_id];
                 view_ids.splice(0,1);
                 delete child_model.views[view_id];
             
                 // Remove the view list specific to this model if it is empty.
                 if (view_ids.length === 0) {
                     delete this.child_model_views[child_model.id];
                 }
                 return view;
             }
             return null;
         },
 
         do_diff: function(old_list, new_list, removed_callback, added_callback) {
             // Difference a changed list and call remove and add callbacks for 
             // each removed and added item in the new list.
             //
             // Parameters
             // ----------
             // old_list : array
             // new_list : array
             // removed_callback : Callback(item)
             //      Callback that is called for each item removed.
             // added_callback : Callback(item)
             //      Callback that is called for each item added.
 
             // Walk the lists until an unequal entry is found.
             var i;
             for (i = 0; i < new_list.length; i++) {
                 if (i >= old_list.length || new_list[i] !== old_list[i]) {
                     break;
                 }
             }
 
             // Remove the non-matching items from the old list.
             for (var j = i; j < old_list.length; j++) {
                 removed_callback(old_list[j]);
             }
 
             // Add the rest of the new list items.
             for (; i < new_list.length; i++) {
                 added_callback(new_list[i]);
             }
         },
 
         callbacks: function(){
             // Create msg callbacks for a comm msg.
             return this.model.callbacks(this);
         },
 
         render: function(){
             // Render the view.
             //
             // By default, this is only called the first time the view is created
         },
 
         show: function(){
             // Show the widget-area
             if (this.options && this.options.cell &&
                 this.options.cell.widget_area !== undefined) {
                 this.options.cell.widget_area.show();
             }
         },
 
         send: function (content) {
             // Send a custom msg associated with this view.
             this.model.send(content, this.callbacks());
         },
 
         touch: function () {
             this.model.save_changes(this.callbacks());
         },
 
         after_displayed: function (callback, context) {
             // Calls the callback right away is the view is already displayed
             // otherwise, register the callback to the 'displayed' event.
             if (this.is_displayed) {
                 callback.apply(context);
             } else {
                 this.on('displayed', callback, context);
             }
         },
     });
 
 
     var DOMWidgetView = WidgetView.extend({
         initialize: function (parameters) {
             // Public constructor
             DOMWidgetView.__super__.initialize.apply(this, [parameters]);
             this.on('displayed', this.show, this);
             this.model.on('change:visible', this.update_visible, this);
             this.model.on('change:_css', this.update_css, this);
 
             this.model.on('change:_dom_classes', function(model, new_classes) {
                 var old_classes = model.previous('_dom_classes');
                 this.update_classes(old_classes, new_classes);
             }, this);
 
             this.model.on('change:color', function (model, value) { 
                 this.update_attr('color', value); }, this);
 
             this.model.on('change:background_color', function (model, value) { 
                 this.update_attr('background', value); }, this);
 
             this.model.on('change:width', function (model, value) { 
                 this.update_attr('width', value); }, this);
 
             this.model.on('change:height', function (model, value) { 
                 this.update_attr('height', value); }, this);
 
             this.model.on('change:border_color', function (model, value) { 
                 this.update_attr('border-color', value); }, this);
 
             this.model.on('change:border_width', function (model, value) { 
                 this.update_attr('border-width', value); }, this);
 
             this.model.on('change:border_style', function (model, value) { 
                 this.update_attr('border-style', value); }, this);
 
             this.model.on('change:font_style', function (model, value) { 
                 this.update_attr('font-style', value); }, this);
 
             this.model.on('change:font_weight', function (model, value) { 
                 this.update_attr('font-weight', value); }, this);
 
             this.model.on('change:font_size', function (model, value) { 
                 this.update_attr('font-size', this._default_px(value)); }, this);
 
             this.model.on('change:font_family', function (model, value) { 
                 this.update_attr('font-family', value); }, this);
 
             this.model.on('change:padding', function (model, value) { 
                 this.update_attr('padding', value); }, this);
 
             this.model.on('change:margin', function (model, value) { 
                 this.update_attr('margin', this._default_px(value)); }, this);
 
             this.model.on('change:border_radius', function (model, value) { 
                 this.update_attr('border-radius', this._default_px(value)); }, this);
 
             this.after_displayed(function() {
                 this.update_visible(this.model, this.model.get("visible"));
                 this.update_classes([], this.model.get('_dom_classes'));
                 
                 this.update_attr('color', this.model.get('color'));
                 this.update_attr('background', this.model.get('background_color'));
                 this.update_attr('width', this.model.get('width'));
                 this.update_attr('height', this.model.get('height'));
                 this.update_attr('border-color', this.model.get('border_color'));
                 this.update_attr('border-width', this.model.get('border_width'));
                 this.update_attr('border-style', this.model.get('border_style'));
                 this.update_attr('font-style', this.model.get('font_style'));
                 this.update_attr('font-weight', this.model.get('font_weight'));
                 this.update_attr('font-size', this.model.get('font_size'));
                 this.update_attr('font-family', this.model.get('font_family'));
                 this.update_attr('padding', this.model.get('padding'));
                 this.update_attr('margin', this.model.get('margin'));
                 this.update_attr('border-radius', this.model.get('border_radius'));
 
                 this.update_css(this.model, this.model.get("_css"));
             }, this);
         },
 
         _default_px: function(value) {
             // Makes browser interpret a numerical string as a pixel value.
             if (/^\d+\.?(\d+)?$/.test(value.trim())) {
                 return value.trim() + 'px';
             }
             return value;
         },
 
         update_attr: function(name, value) {
             // Set a css attr of the widget view.
             this.$el.css(name, value);
         },
 
         update_visible: function(model, value) {
             // Update visibility
             this.$el.toggle(value);
          },
 
         update_css: function (model, css) {
             // Update the css styling of this view.
             var e = this.$el;
             if (css === undefined) {return;}
             for (var i = 0; i < css.length; i++) {
                 // Apply the css traits to all elements that match the selector.
                 var selector = css[i][0];
                 var elements = this._get_selector_element(selector);
                 if (elements.length > 0) {
                     var trait_key = css[i][1];
                     var trait_value = css[i][2];
                     elements.css(trait_key ,trait_value);
                 }
             }
         },
 
         update_classes: function (old_classes, new_classes, $el) {
             // Update the DOM classes applied to an element, default to this.$el.
             if ($el===undefined) {
                 $el = this.$el;
             }
             this.do_diff(old_classes, new_classes, function(removed) {
                 $el.removeClass(removed);
             }, function(added) {
                 $el.addClass(added);
             });
         },
 
         update_mapped_classes: function(class_map, trait_name, previous_trait_value, $el) {
             // Update the DOM classes applied to the widget based on a single
             // trait's value.
             //
             // Given a trait value classes map, this function automatically
             // handles applying the appropriate classes to the widget element
             // and removing classes that are no longer valid.
             //
             // Parameters
             // ----------
             // class_map: dictionary
             //  Dictionary of trait values to class lists.
             //  Example:
             //      {
             //          success: ['alert', 'alert-success'],
             //          info: ['alert', 'alert-info'],
             //          warning: ['alert', 'alert-warning'],
             //          danger: ['alert', 'alert-danger']
             //      };
             // trait_name: string
             //  Name of the trait to check the value of.
             // previous_trait_value: optional string, default ''
             //  Last trait value
             // $el: optional jQuery element handle, defaults to this.$el
             //  Element that the classes are applied to.
             var key = previous_trait_value;
             if (key === undefined) {
                 key = this.model.previous(trait_name);
             }
             var old_classes = class_map[key] ? class_map[key] : [];
             key = this.model.get(trait_name);
             var new_classes = class_map[key] ? class_map[key] : [];
 
             this.update_classes(old_classes, new_classes, $el || this.$el);
         },
         
         _get_selector_element: function (selector) {
             // Get the elements via the css selector.
             var elements;
             if (!selector) {
                 elements = this.$el;
             } else {
                 elements = this.$el.find(selector).addBack(selector);
             }
             return elements;
         },
     });
 
     
     var widget = {
         'WidgetModel': WidgetModel,
         'WidgetView': WidgetView,
         'DOMWidgetView': DOMWidgetView,
     };
 
     // For backwards compatability.
     $.extend(IPython, widget);
 
     return widget;
 });

IPython/html/tests/util.js

@@ -1,778 +1,799
 //
 // 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.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.thenClick('button#new_notebook');
     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';
             });
         });
     });
 
     // 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;
         });
     });
 };
 
 casper.page_loaded = function() {
     // Return whether or not the kernel is running.
     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!");
     });
 };
 
 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 (m) {
-            return IPython.notebook.kernel.widget_manager.get_model(m).pending_msgs;
-        }, {m: widget_info.model_id});
+        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.get_output_cell = function (cell_num, out_num) {
     // 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,
             "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.waitfor_cell_element = function(index, selector){
+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);
-    }, function() { console.log('FOUND!'); });
+    });
 };
 
 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 + '; 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');
     }
 };
 
 casper.select_cell = function(index) {
     // Select a cell in the notebook.
     this.evaluate(function (i) {
         IPython.notebook.select(i);
     }, {i: index});
 };
 
 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.
     return this.is_only_cell_on(index, 'edit_mode', 'command_mode');
 };
 
 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.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 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);
 };
 
 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');
 };
 
 casper.open_dashboard = function () {
     // Start casper by opening the dashboard page.
     var baseUrl = this.get_notebook_server();
     this.start(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();
     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();

IPython/html/tests/widgets/widget.js

@@ -1,191 +1,191
 var xor = function (a, b) {return !a ^ !b;}; 
 var isArray = function (a) {
     try {
         return Object.toString.call(a) === "[object Array]" || Object.toString.call(a) === "[object RuntimeArray]";
     } catch (e) {
         return Array.isArray(a);
     }
 };
 var recursive_compare = function(a, b) {
     // Recursively compare two objects.
     var same = true;
     same = same && !xor(a instanceof Object || typeof a == 'object', b instanceof Object || typeof b == 'object');
     same = same && !xor(isArray(a), isArray(b));
 
     if (same) {
         if (a instanceof Object) {
             var key;
             for (key in a) {
                 if (a.hasOwnProperty(key) && !recursive_compare(a[key], b[key])) {
                     same = false;
                     break;
                 }
             }
             for (key in b) {
                 if (b.hasOwnProperty(key) && !recursive_compare(a[key], b[key])) {
                     same = false;
                     break;
                 }
             }
         } else {
             return a === b;
         }    
     }
     
     return same;
 };
 
 // Test the widget framework.
 casper.notebook_test(function () {
     var index;
 
     index = this.append_cell(
         'from IPython.html import widgets\n' + 
         'from IPython.display import display, clear_output\n' +
         'print("Success")');
     this.execute_cell_then(index);
 
     this.then(function () {
 
         // Functions that can be used to test the packing and unpacking APIs
         var that = this;
         var test_pack = function (input) {
             var output = that.evaluate(function(input) {
                 var model = new IPython.WidgetModel(IPython.notebook.kernel.widget_manager, undefined);
                 var results = model._pack_models(input);
                 return results;
             }, {input: input});
             that.test.assert(recursive_compare(input, output), 
                 JSON.stringify(input) + ' passed through Model._pack_model unchanged');
         };
         var test_unpack = function (input) {
             that.thenEvaluate(function(input) {
                 window.results = undefined;
                 var model = new IPython.WidgetModel(IPython.notebook.kernel.widget_manager, undefined);
                 model._unpack_models(input).then(function(results) { 
                     window.results = results; 
                 });    
             }, {input: input});
             
             that.waitFor(function check() {
                 return that.evaluate(function() { 
                     return window.results; 
                 }); 
             });
             
             that.then(function() {
                 var results = that.evaluate(function() { 
                     return window.results; 
                 });
                 that.test.assert(recursive_compare(input, results), 
                     JSON.stringify(input) + ' passed through Model._unpack_model unchanged');
             });
         };
         var test_packing = function(input) {
             test_pack(input);
             test_unpack(input);
         };
         
         test_packing({0: 'hi', 1: 'bye'});
         test_packing(['hi', 'bye']);
         test_packing(['hi', 5]);
         test_packing(['hi', '5']);
         test_packing([1.0, 0]);
         test_packing([1.0, false]);
         test_packing([1, false]);
         test_packing([1, false, {a: 'hi'}]);
         test_packing([1, false, ['hi']]);
         test_packing([String('hi'), Date("Thu Nov 13 2014 13:46:21 GMT-0500")])
 
         // Test multi-set, single touch code.  First create a custom widget.
         this.thenEvaluate(function() {
             var MultiSetView = IPython.DOMWidgetView.extend({
                 render: function(){
                     this.model.set('a', 1);
                     this.model.set('b', 2);
                     this.model.set('c', 3);
                     this.touch();
                 },
             });
             IPython.WidgetManager.register_widget_view('MultiSetView', MultiSetView);
         }, {});
     });
 
     // Try creating the multiset widget, verify that sets the values correctly.
     var multiset = {};
     multiset.index = this.append_cell(
         'from IPython.utils.traitlets import Unicode, CInt\n' +
         'class MultiSetWidget(widgets.Widget):\n' +
         '    _view_name = Unicode("MultiSetView", sync=True)\n' +
         '    a = CInt(0, sync=True)\n' +
         '    b = CInt(0, sync=True)\n' +
         '    c = CInt(0, sync=True)\n' +
         '    d = CInt(-1, sync=True)\n' + // See if it sends a full state.
         '    def set_state(self, sync_data):\n' +
         '        widgets.Widget.set_state(self, sync_data)\n'+
         '        self.d = len(sync_data)\n' +
         'multiset = MultiSetWidget()\n' +
         'display(multiset)\n' +
         'print(multiset.model_id)');
     this.execute_cell_then(multiset.index, function(index) {
         multiset.model_id = this.get_output_cell(index).text.trim();
     });
 
-    this.wait_for_widget(multiset);
+    this.wait_for_widget(multiset); 
 
     index = this.append_cell(
         'print("%d%d%d" % (multiset.a, multiset.b, multiset.c))');
     this.execute_cell_then(index, function(index) {
         this.test.assertEquals(this.get_output_cell(index).text.trim(), '123',
             'Multiple model.set calls and one view.touch update state in back-end.');
     });
 
     index = this.append_cell(
         'print("%d" % (multiset.d))');
     this.execute_cell_then(index, function(index) {
         this.test.assertEquals(this.get_output_cell(index).text.trim(), '3',
             'Multiple model.set calls sent a partial state.');
     });
 
     var textbox = {};
     throttle_index = this.append_cell(
         'import time\n' +
         'textbox = widgets.Text()\n' +
         'display(textbox)\n' +
         'textbox._dom_classes = ["my-throttle-textbox"]\n' +
         'def handle_change(name, old, new):\n' +
         '    display(len(new))\n' +
         '    time.sleep(0.5)\n' +
         'textbox.on_trait_change(handle_change, "value")\n' +
         'print(textbox.model_id)');
     this.execute_cell_then(throttle_index, function(index){
         textbox.model_id = this.get_output_cell(index).text.trim();
 
         this.test.assert(this.cell_element_exists(index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(index, 
             '.my-throttle-textbox'), 'Textbox exists.');
 
         // Send 20 characters
         this.sendKeys('.my-throttle-textbox input', '....................');
     });
 
     this.wait_for_widget(textbox);
 
     this.then(function () { 
         var outputs = this.evaluate(function(i) {
             return IPython.notebook.get_cell(i).output_area.outputs;
         }, {i : throttle_index});
 
         // Only 4 outputs should have printed, but because of timing, sometimes
         // 5 outputs will print.  All we need to do is verify num outputs <= 5
         // because that is much less than 20.
         this.test.assert(outputs.length <= 5, 'Messages throttled.');
 
         // We also need to verify that the last state sent was correct.
         var last_state = outputs[outputs.length-1].data['text/plain'];
         this.test.assertEquals(last_state, "20", "Last state sent when throttling.");
     });
 });

IPython/html/tests/widgets/widget_bool.js

@@ -1,88 +1,91
 // Test widget bool class
 casper.notebook_test(function () {
-    // index = this.append_cell(
-    //     'print("Success")');
-    // this.execute_cell_then(index);
 
+    // Create a checkbox and togglebutton.
     var bool_index = this.append_cell(
         'from IPython.html import widgets\n' + 
         'from IPython.display import display, clear_output\n' +
         'bool_widgets = [widgets.Checkbox(description="Title", value=True),\n' +
         '    widgets.ToggleButton(description="Title", value=True)]\n' +
         'display(bool_widgets[0])\n' +
         'display(bool_widgets[1])\n' +
         'print("Success")');
     this.execute_cell_then(bool_index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Create bool widget cell executed with correct output.');
     });
 
-    this.waitfor_cell_element(bool_index, '.widget-area .widget-subarea .widget-hbox input');
-    this.waitfor_cell_element(bool_index, '.widget-area .widget-subarea button');
+    // Wait for the widgets to actually display.
+    var widget_checkbox_selector = '.widget-area .widget-subarea .widget-hbox input';
+    var widget_togglebutton_selector = '.widget-area .widget-subarea button';
+    this.wait_for_element(bool_index, widget_checkbox_selector);
+    this.wait_for_element(bool_index, widget_togglebutton_selector);
 
+    // Continue the tests.
     this.then(function() {
         this.test.assert(this.cell_element_exists(bool_index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(bool_index, 
-            '.widget-area .widget-subarea .widget-hbox input'),
+            widget_checkbox_selector),
             'Checkbox exists.');
 
         this.test.assert(this.cell_element_function(bool_index, 
-            '.widget-area .widget-subarea .widget-hbox input', 'prop', ['checked']),
+            widget_checkbox_selector, 'prop', ['checked']),
             'Checkbox is checked.');
 
         this.test.assert(this.cell_element_exists(bool_index, 
             '.widget-area .widget-subarea .widget-hbox .widget-label'),
             'Checkbox label exists.');
 
         this.test.assert(this.cell_element_function(bool_index, 
             '.widget-area .widget-subarea .widget-hbox .widget-label', 'html')=="Title",
             'Checkbox labeled correctly.');
 
         this.test.assert(this.cell_element_exists(bool_index, 
-            '.widget-area .widget-subarea button'),
+            widget_togglebutton_selector),
             'Toggle button exists.');
 
         this.test.assert(this.cell_element_function(bool_index, 
-            '.widget-area .widget-subarea button', 'html')=="Title",
+            widget_togglebutton_selector, 'html')=="Title",
             'Toggle button labeled correctly.');
 
         this.test.assert(this.cell_element_function(bool_index, 
-            '.widget-area .widget-subarea button', 'hasClass', ['active']),
+            widget_togglebutton_selector, 'hasClass', ['active']),
             'Toggle button is toggled.');
     });
 
+    // Try changing the state of the widgets programatically.
     index = this.append_cell(
         'bool_widgets[0].value = False\n' +
         'bool_widgets[1].value = False\n' +
         'print("Success")');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Change bool widget value cell executed with correct output.');
 
         this.test.assert(! this.cell_element_function(bool_index, 
-            '.widget-area .widget-subarea .widget-hbox input', 'prop', ['checked']),
+            widget_checkbox_selector, 'prop', ['checked']),
             'Checkbox is not checked. (1)');
 
         this.test.assert(! this.cell_element_function(bool_index, 
-            '.widget-area .widget-subarea button', 'hasClass', ['active']),
+            widget_togglebutton_selector, 'hasClass', ['active']),
             'Toggle button is not toggled. (1)');
  
         // Try toggling the bool by clicking on the checkbox.
-        this.cell_element_function(bool_index, '.widget-area .widget-subarea .widget-hbox input', 'click');
+        this.cell_element_function(bool_index, widget_checkbox_selector, 'click');
 
         this.test.assert(this.cell_element_function(bool_index, 
-            '.widget-area .widget-subarea .widget-hbox input', 'prop', ['checked']),
+            widget_checkbox_selector, 'prop', ['checked']),
             'Checkbox is checked. (2)');
 
         // Try toggling the bool by clicking on the toggle button.
-        this.cell_element_function(bool_index, '.widget-area .widget-subarea button', 'click');
+        this.cell_element_function(bool_index, widget_togglebutton_selector, 'click');
 
         this.test.assert(this.cell_element_function(bool_index, 
-            '.widget-area .widget-subarea button', 'hasClass', ['active']),
+            widget_togglebutton_selector, 'hasClass', ['active']),
             'Toggle button is toggled. (3)');
 
     });
 });
  No newline at end of file

IPython/html/tests/widgets/widget_box.js

@@ -1,80 +1,92
 // Test container class
 casper.notebook_test(function () {
-    index = this.append_cell(
-        'from IPython.html import widgets\n' + 
-        'from IPython.display import display, clear_output\n' +
-        'print("Success")');
-    this.execute_cell_then(index);
 
+    // Create a box widget.
     var container_index = this.append_cell(
+        'from IPython.html import widgets\n' + 
+        'from IPython.display import display, clear_output\n' +
         'container = widgets.Box()\n' +
         'button = widgets.Button()\n'+
         'container.children = [button]\n'+
         'display(container)\n'+
         'container._dom_classes = ["my-test-class"]\n'+
         'print("Success")\n');
     this.execute_cell_then(container_index, function(index){
-
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Create container cell executed with correct output.');
+    });
 
-        this.test.assert(this.cell_element_exists(index, 
+    // Wait for the widgets to actually display.
+    var widget_box_selector = '.widget-area .widget-subarea .widget-box';
+    var widget_box_button_selector = '.widget-area .widget-subarea .widget-box button';
+    this.wait_for_element(container_index, widget_box_selector);
+    this.wait_for_element(container_index, widget_box_button_selector);
+
+    // Continue with the tests.
+    this.then(function() {
+        this.test.assert(this.cell_element_exists(container_index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
-        this.test.assert(this.cell_element_exists(index, 
-            '.widget-area .widget-subarea .widget-box'),
+        this.test.assert(this.cell_element_exists(container_index, 
+            widget_box_selector),
             'Widget container exists.');
 
-        this.test.assert(this.cell_element_exists(index, 
+        this.test.assert(this.cell_element_exists(container_index, 
             '.widget-area .widget-subarea .my-test-class'),
             '_dom_classes works.');
 
-        this.test.assert(this.cell_element_exists(index, 
-            '.widget-area .widget-subarea .my-test-class button'),
+        this.test.assert(this.cell_element_exists(container_index, 
+            widget_box_button_selector),
             'Container parent/child relationship works.');
     });
 
     index = this.append_cell(
         'container.box_style = "success"\n'+
         'print("Success")\n');
     this.execute_cell_then(index, function(index){
 
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Set box_style cell executed with correct output.');
 
         this.test.assert(this.cell_element_exists(container_index, 
             '.widget-box.alert-success'),
             'Set box_style works.');
     });
 
     index = this.append_cell(
         'container._dom_classes = []\n'+
         'print("Success")\n');
     this.execute_cell_then(index, function(index){
 
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Remove container class cell executed with correct output.');
 
         this.test.assert(! this.cell_element_exists(container_index, 
             '.widget-area .widget-subarea .my-test-class'),
             '_dom_classes can be used to remove a class.');
     });
 
-    index = this.append_cell(
+    var boxalone_index = this.append_cell(
         'display(button)\n'+
         'print("Success")\n');
-    this.execute_cell_then(index, function(index){
-
+    this.execute_cell_then(boxalone_index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Display container child executed with correct output.');
+    });
+
+    // Wait for the widget to actually display.
+    var widget_button_selector = '.widget-area .widget-subarea button';
+    this.wait_for_element(boxalone_index, widget_button_selector);
 
-        this.test.assert(! this.cell_element_exists(index, 
-            '.widget-area .widget-subarea .widget-box'),
+    // Continue with the tests.
+    this.then(function() {
+        this.test.assert(! this.cell_element_exists(boxalone_index, 
+            widget_box_selector),
             'Parent container not displayed.');
 
-        this.test.assert(this.cell_element_exists(index, 
-            '.widget-area .widget-subarea button'),
+        this.test.assert(this.cell_element_exists(boxalone_index, 
+            widget_button_selector),
             'Child displayed.');
     });
 });
  No newline at end of file

IPython/html/tests/widgets/widget_button.js

@@ -1,43 +1,45
 // Test widget button class
 casper.notebook_test(function () {
-    index = this.append_cell(
+    var button_index = this.append_cell(
         'from IPython.html import widgets\n' + 
         'from IPython.display import display, clear_output\n' +
-        'print("Success")');
-    this.execute_cell_then(index);
-
-    var button_index = this.append_cell(
         'button = widgets.Button(description="Title")\n' +
         'display(button)\n' +
         'print("Success")\n' +
         'def handle_click(sender):\n' +
         '    display("Clicked")\n' +
         'button.on_click(handle_click)');
     this.execute_cell_then(button_index, function(index){
-
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n',
             'Create button cell executed with correct output.');
+    });
+
+    // Wait for the widgets to actually display.
+    var widget_button_selector = '.widget-area .widget-subarea button';
+    this.wait_for_element(button_index, widget_button_selector);
 
-        this.test.assert(this.cell_element_exists(index, 
+    // Continue with the tests.
+    this.then(function() {
+        this.test.assert(this.cell_element_exists(button_index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
-        this.test.assert(this.cell_element_exists(index, 
-            '.widget-area .widget-subarea button'),
+        this.test.assert(this.cell_element_exists(button_index, 
+            widget_button_selector),
             'Widget button exists.');
 
-        this.test.assert(this.cell_element_function(index, 
-            '.widget-area .widget-subarea button', 'html')=='Title',
+        this.test.assert(this.cell_element_function(button_index, 
+            widget_button_selector, 'html')=='Title',
             'Set button description.');
 
-        this.cell_element_function(index, 
-            '.widget-area .widget-subarea button', 'click');
+        this.cell_element_function(button_index, 
+            widget_button_selector, 'click');
     });
 
     this.wait_for_output(button_index, 1);
 
     this.then(function () {
         this.test.assertEquals(this.get_output_cell(button_index, 1).data['text/plain'], "'Clicked'",
             'Button click event fires.');
     });
 });
  No newline at end of file

IPython/html/tests/widgets/widget_float.js

@@ -1,100 +1,109
 // Test widget float class
 casper.notebook_test(function () {
-    index = this.append_cell(
-        'from IPython.html import widgets\n' + 
-        'from IPython.display import display, clear_output\n' +
-        'print("Success")');
-    this.execute_cell_then(index);
-
     var float_text = {};
     float_text.query = '.widget-area .widget-subarea .my-second-float-text input';
     float_text.index = this.append_cell(
+        'from IPython.html import widgets\n' + 
+        'from IPython.display import display, clear_output\n' +
         'float_widget = widgets.FloatText()\n' +
         'display(float_widget)\n' + 
         'float_widget._dom_classes = ["my-second-float-text"]\n' + 
         'print(float_widget.model_id)\n');
     this.execute_cell_then(float_text.index, function(index){
         float_text.model_id = this.get_output_cell(index).text.trim();
-        
-        this.test.assert(this.cell_element_exists(index, 
+    });
+
+    // Wait for the widget to actually display.
+    this.wait_for_element(float_text.index, float_text.query);
+
+    // Continue with the tests
+    this.then(function(){        
+        this.test.assert(this.cell_element_exists(float_text.index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
-        this.test.assert(this.cell_element_exists(index, float_text.query),
+        this.test.assert(this.cell_element_exists(float_text.index, float_text.query),
             'Widget float textbox exists.');
 
         this.cell_element_function(float_text.index, float_text.query, 'val', ['']);
+        console.log('send keys');
         this.sendKeys(float_text.query, '1.05');
+        console.log('send keys done');
     });
 
     this.wait_for_widget(float_text);
 
     index = this.append_cell('print(float_widget.value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '1.05\n', 
             'Float textbox value set.');
         this.cell_element_function(float_text.index, float_text.query, 'val', ['']);
         this.sendKeys(float_text.query, '123456789.0');
     });
 
     this.wait_for_widget(float_text);
     
     index = this.append_cell('print(float_widget.value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '123456789.0\n', 
             'Long float textbox value set (probably triggers throttling).');
         this.cell_element_function(float_text.index, float_text.query, 'val', ['']);
         this.sendKeys(float_text.query, '12hello');
     });
 
     this.wait_for_widget(float_text);
 
     index = this.append_cell('print(float_widget.value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '12.0\n', 
             'Invald float textbox value caught and filtered.');
     });
 
     var float_text_query = '.widget-area .widget-subarea .widget-numeric-text';
     var slider = {};
     slider.query = '.widget-area .widget-subarea .slider';
     slider.index = this.append_cell(
         'floatrange = [widgets.BoundedFloatText(), \n' +
         '    widgets.FloatSlider()]\n' +
         '[display(floatrange[i]) for i in range(2)]\n' + 
         'print("Success")\n');
     this.execute_cell_then(slider.index, function(index){
-
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Create float range cell executed with correct output.');
+    });
+
+    // Wait for the widgets to actually display.
+    this.wait_for_element(slider.index, slider.query);
+    this.wait_for_element(slider.index, float_text_query);
 
-        this.test.assert(this.cell_element_exists(index, 
+    this.then(function(){
+        this.test.assert(this.cell_element_exists(slider.index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
-        this.test.assert(this.cell_element_exists(index, slider.query),
+        this.test.assert(this.cell_element_exists(slider.index, slider.query),
             'Widget slider exists.');
 
-        this.test.assert(this.cell_element_exists(index, float_text_query),
+        this.test.assert(this.cell_element_exists(slider.index, float_text_query),
             'Widget float textbox exists.');
     });
 
     index = this.append_cell(
         'for widget in floatrange:\n' +
         '    widget.max = 50.0\n' +
         '    widget.min = -50.0\n' +
         '    widget.value = 25.0\n' +
         'print("Success")\n');
     this.execute_cell_then(index, function(index){
 
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Float range properties cell executed with correct output.');
 
         this.test.assert(this.cell_element_exists(slider.index, slider.query), 
             'Widget slider exists.');
 
         this.test.assert(this.cell_element_function(slider.index, slider.query, 
             'slider', ['value']) == 25.0,
             'Slider set to Python value.');
     });
 });
  No newline at end of file

IPython/html/tests/widgets/widget_image.js

@@ -1,44 +1,48
 // Test image class
 casper.notebook_test(function () {
     index = this.append_cell(
         'from IPython.html import widgets\n' + 
         'from IPython.display import display, clear_output\n' +
         'print("Success")');
     this.execute_cell_then(index);
 
     // Get the temporary directory that the test server is running in.
     var cwd = '';
     index = this.append_cell('!echo $(pwd)');
     this.execute_cell_then(index, function(index){
         cwd = this.get_output_cell(index).text.trim();
     });
 
     var test_jpg = '/9j/4AAQSkZJRgABAQEASABIAAD//gATQ3JlYXRlZCB3aXRoIEdJTVD/2wBDACAWGBwYFCAcGhwkIiAmMFA0MCwsMGJGSjpQdGZ6eHJmcG6AkLicgIiuim5woNqirr7EztDOfJri8uDI8LjKzsb/2wBDASIkJDAqMF40NF7GhHCExsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsb/wgARCAABAAEDAREAAhEBAxEB/8QAFAABAAAAAAAAAAAAAAAAAAAAA//EABUBAQEAAAAAAAAAAAAAAAAAAAME/9oADAMBAAIQAxAAAAECv//EABQQAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQEAAQUCf//EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQMBAT8Bf//EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQIBAT8Bf//EABQQAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQEABj8Cf//EABQQAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQEAAT8hf//aAAwDAQACAAMAAAAQn//EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQMBAT8Qf//EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQIBAT8Qf//EABQQAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQEAAT8Qf//Z';
 
     var image_index = this.append_cell(
         'import base64\n' + 
         'data = base64.b64decode("' + test_jpg + '")\n' +
         'image = widgets.Image()\n' +
         'image.format = "jpeg"\n' +
         'image.value = data\n' +
         'image.width = "50px"\n' +
         'image.height = "50px"\n' +
         'display(image)\n' + 
         'print("Success")\n');
     this.execute_cell_then(image_index, function(index){
-
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Create image executed with correct output.');
+    });
+
+    // Wait for the widget to actually display.
+    var img_selector = '.widget-area .widget-subarea img';
+    this.wait_for_element(image_index, img_selector);
 
-        this.test.assert(this.cell_element_exists(index, 
+    this.then(function(){
+        this.test.assert(this.cell_element_exists(image_index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
-        var img_sel = '.widget-area .widget-subarea img';
-        this.test.assert(this.cell_element_exists(index, img_sel), 'Image exists.');
+        this.test.assert(this.cell_element_exists(image_index, img_selector), 'Image exists.');
 
         // Verify that the image's base64 data has made it into the DOM.
-        var img_src = this.cell_element_function(image_index, img_sel, 'attr', ['src']);
+        var img_src = this.cell_element_function(image_index, img_selector, 'attr', ['src']);
         this.test.assert(img_src.indexOf(test_jpg) > -1, 'Image src data exists.');
     });    
 });
  No newline at end of file

IPython/html/tests/widgets/widget_int.js

@@ -1,175 +1,177
 // Test widget int class
 casper.notebook_test(function () {
-    index = this.append_cell(
-        'from IPython.html import widgets\n' + 
-        'from IPython.display import display, clear_output\n' +
-        'print("Success")');
-    this.execute_cell_then(index);
-
     var int_text = {};
     int_text.query = '.widget-area .widget-subarea .my-second-int-text input';
     int_text.index = this.append_cell(
+        'from IPython.html import widgets\n' + 
+        'from IPython.display import display, clear_output\n' +
         'int_widget = widgets.IntText()\n' +
         'display(int_widget)\n' + 
         'int_widget._dom_classes = ["my-second-int-text"]\n' + 
         'print(int_widget.model_id)\n');
     this.execute_cell_then(int_text.index, function(index){
         int_text.model_id = this.get_output_cell(index).text.trim();
-        
-        this.test.assert(this.cell_element_exists(index, 
+    });
+
+    // Wait for the widget to actually display.
+    this.wait_for_element(int_text.index, int_text.query);
+
+    // Continue with the tests.
+    this.then(function() {
+        this.test.assert(this.cell_element_exists(int_text.index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
-        this.test.assert(this.cell_element_exists(index, int_text.query),
+        this.test.assert(this.cell_element_exists(int_text.index, int_text.query),
             'Widget int textbox exists.');
 
         this.cell_element_function(int_text.index, int_text.query, 'val', ['']);
         this.sendKeys(int_text.query, '1.05');
     });
 
     this.wait_for_widget(int_text);
 
     index = this.append_cell('print(int_widget.value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '1\n', 
             'Int textbox value set.');
         this.cell_element_function(int_text.index, int_text.query, 'val', ['']);
         this.sendKeys(int_text.query, '123456789');
     });
 
     this.wait_for_widget(int_text);
 
     index = this.append_cell('print(int_widget.value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '123456789\n', 
             'Long int textbox value set (probably triggers throttling).');
         this.cell_element_function(int_text.index, int_text.query, 'val', ['']);
         this.sendKeys(int_text.query, '12hello');
     });
 
     this.wait_for_widget(int_text);
 
     index = this.append_cell('print(int_widget.value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '12\n', 
             'Invald int textbox value caught and filtered.');
     });
-    
-    index = this.append_cell(
-        'from IPython.html import widgets\n' + 
-        'from IPython.display import display, clear_output\n' +
-        'print("Success")');
-    this.execute_cell_then(index);
-
 
     var slider_query = '.widget-area .widget-subarea .slider';
     var int_text2 = {};
     int_text2.query = '.widget-area .widget-subarea .my-second-num-test-text input';
     int_text2.index = this.append_cell(
         'intrange = [widgets.BoundedIntTextWidget(),\n' +
         '    widgets.IntSliderWidget()]\n' +
         '[display(intrange[i]) for i in range(2)]\n' +
         'intrange[0]._dom_classes = ["my-second-num-test-text"]\n' +  
         'print(intrange[0].model_id)\n');
     this.execute_cell_then(int_text2.index, function(index){
         int_text2.model_id = this.get_output_cell(index).text.trim();
+    });
+
+    // Wait for the widgets to actually display.
+    this.wait_for_element(int_text2.index, int_text2.query);
+    this.wait_for_element(int_text2.index, slider_query);
 
-        this.test.assert(this.cell_element_exists(index, 
+    // Continue with the tests.
+    this.then(function(){
+        this.test.assert(this.cell_element_exists(int_text2.index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
-        this.test.assert(this.cell_element_exists(index, slider_query),
+        this.test.assert(this.cell_element_exists(int_text2.index, slider_query),
             'Widget slider exists.');
 
-        this.test.assert(this.cell_element_exists(index, int_text2.query),
+        this.test.assert(this.cell_element_exists(int_text2.index, int_text2.query),
             'Widget int textbox exists.');
     });
 
     index = this.append_cell(
         'for widget in intrange:\n' +
         '    widget.max = 50\n' +
         '    widget.min = -50\n' +
         '    widget.value = 25\n' +
         'print("Success")\n');
     this.execute_cell_then(index, function(index){
 
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Int range properties cell executed with correct output.');
 
         this.test.assert(this.cell_element_exists(int_text2.index, slider_query), 
             'Widget slider exists.');
 
         this.test.assert(this.cell_element_function(int_text2.index, slider_query, 
             'slider', ['value']) == 25,
             'Slider set to Python value.');
 
         this.test.assert(this.cell_element_function(int_text2.index, int_text2.query,
             'val') == 25, 'Int textbox set to Python value.');
 
         // Clear the int textbox value and then set it to 1 by emulating
         // keyboard presses.
         this.evaluate(function(q){
             var textbox = IPython.notebook.element.find(q);
             textbox.val('1');
             textbox.trigger('keyup');
         }, {q: int_text2.query});
     });
 
     this.wait_for_widget(int_text2);
 
     index = this.append_cell('print(intrange[0].value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '1\n', 
             'Int textbox set int range value');
 
         // Clear the int textbox value and then set it to 120 by emulating
         // keyboard presses.
         this.evaluate(function(q){
             var textbox = IPython.notebook.element.find(q);
             textbox.val('120');
             textbox.trigger('keyup');
         }, {q: int_text2.query});
     });
 
     this.wait_for_widget(int_text2);
 
     index = this.append_cell('print(intrange[0].value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '50\n', 
             'Int textbox value bound');
 
         // Clear the int textbox value and then set it to 'hello world' by 
         // emulating keyboard presses.  'hello world' should get filtered...
         this.evaluate(function(q){
             var textbox = IPython.notebook.element.find(q);
             textbox.val('hello world');
             textbox.trigger('keyup');
         }, {q: int_text2.query});
     });
 
     this.wait_for_widget(int_text2);
 
     index = this.append_cell('print(intrange[0].value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '50\n', 
             'Invalid int textbox characters ignored');
     });    
 
     index = this.append_cell(
         'a = widgets.IntSlider()\n' +
         'display(a)\n' +
         'a.max = -1\n' +
         'print("Success")\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(0, 0, 'Invalid int range max bound does not cause crash.');
     }, true); 
 
     index = this.append_cell(
         'a = widgets.IntSlider()\n' +
         'display(a)\n' +
         'a.min = 101\n' +
         'print("Success")\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(0, 0, 'Invalid int range min bound does not cause crash.');
     }, true);
 });
  No newline at end of file

IPython/html/tests/widgets/widget_selection.js

@@ -1,138 +1,147
 // Test selection class
 casper.notebook_test(function () {
     index = this.append_cell(
         'from IPython.html import widgets\n' + 
         'from IPython.display import display, clear_output\n' +
         'print("Success")');
     this.execute_cell_then(index);
 
     var combo_selector = '.widget-area .widget-subarea .widget-hbox .btn-group .widget-combo-btn';
     var multibtn_selector = '.widget-area .widget-subarea .widget-hbox .btn-group[data-toggle="buttons-radio"]';
     var radio_selector = '.widget-area .widget-subarea .widget-hbox .widget-radio-box';
     var list_selector = '.widget-area .widget-subarea .widget-hbox .widget-listbox';
 
     var selection_index;
     var selection_values = 'abcd';
     var check_state = function(context, index, state){
         if (0 <= index && index < selection_values.length) {
             var multibtn_state = context.cell_element_function(selection_index, multibtn_selector + ' .btn:nth-child(' + (index + 1) + ')', 'hasClass', ['active']);
             var radio_state = context.cell_element_function(selection_index, radio_selector + ' .radio:nth-child(' + (index + 1) + ') input', 'prop', ['checked']);
             var list_val = context.cell_element_function(selection_index, list_selector, 'val');
             var combo_val = context.cell_element_function(selection_index, combo_selector, 'html');
             
             var val = selection_values.charAt(index);
             var list_state = (val == list_val);
             var combo_state = (val == combo_val);
 
             return multibtn_state == state &&
                 radio_state == state &&
                 list_state == state &&
                 combo_state == state;
         }
         return true;
     };
 
     var verify_selection = function(context, index){
         for (var i = 0; i < selection_values.length; i++) {
             if (!check_state(context, i, i==index)) {
                 return false;
             }
         }
         return true;
     };
 
 //values=["' + selection_values + '"[i] for i in range(4)]
     selection_index = this.append_cell(
         'values=["' + selection_values + '"[i] for i in range(4)]\n' +
         'selection = [widgets.Dropdown(values=values),\n' +
         '    widgets.ToggleButtons(values=values),\n' +
         '    widgets.RadioButtons(values=values),\n' +
         '    widgets.Select(values=values)]\n' +
         '[display(selection[i]) for i in range(4)]\n' +
         'for widget in selection:\n' +
         '    def handle_change(name,old,new):\n' +
         '        for other_widget in selection:\n' +
         '            other_widget.value = new\n' +
         '    widget.on_trait_change(handle_change, "value")\n' +
         'print("Success")\n');
     this.execute_cell_then(selection_index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Create selection cell executed with correct output.');
+    });
+
+    // Wait for the widgets to actually display.
+    this.wait_for_element(selection_index, combo_selector);
+    this.wait_for_element(selection_index, multibtn_selector);
+    this.wait_for_element(selection_index, radio_selector);
+    this.wait_for_element(selection_index, list_selector);
 
-        this.test.assert(this.cell_element_exists(index, 
+    // Continue with the tests.
+    this.then(function() {
+        this.test.assert(this.cell_element_exists(selection_index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
-        this.test.assert(this.cell_element_exists(index, combo_selector),
+        this.test.assert(this.cell_element_exists(selection_index, combo_selector),
              'Widget combobox exists.');
 
-        this.test.assert(this.cell_element_exists(index, multibtn_selector),
+        this.test.assert(this.cell_element_exists(selection_index, multibtn_selector),
             'Widget multibutton exists.');
 
-        this.test.assert(this.cell_element_exists(index, radio_selector),
+        this.test.assert(this.cell_element_exists(selection_index, radio_selector),
             'Widget radio buttons exists.');
 
-        this.test.assert(this.cell_element_exists(index, list_selector),
+        this.test.assert(this.cell_element_exists(selection_index, list_selector),
             'Widget list exists.');
 
         // Verify that no items are selected.
         this.test.assert(verify_selection(this, 0), 'Default first item selected.');
     });
 
     index = this.append_cell(
         'for widget in selection:\n' +
         '    widget.value = "a"\n' +
         'print("Success")\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Python select item executed with correct output.');
 
         // Verify that the first item is selected.
         this.test.assert(verify_selection(this, 0), 'Python selected');
 
         // Verify that selecting a radio button updates all of the others.
         this.cell_element_function(selection_index, radio_selector + ' .radio:nth-child(2) input', 'click');
     });
     this.wait_for_idle();
     this.then(function () {
         this.test.assert(verify_selection(this, 1), 'Radio button selection updated view states correctly.');
 
         // Verify that selecting a list option updates all of the others.
         this.cell_element_function(selection_index, list_selector + ' option:nth-child(3)', 'click');
     });
     this.wait_for_idle();
     this.then(function () {
         this.test.assert(verify_selection(this, 2), 'List selection updated view states correctly.');
 
         // Verify that selecting a multibutton option updates all of the others.
         // Bootstrap3 has changed the toggle button group behavior.  Two clicks
         // are required to actually select an item.
         this.cell_element_function(selection_index, multibtn_selector + ' .btn:nth-child(4)', 'click');
         this.cell_element_function(selection_index, multibtn_selector + ' .btn:nth-child(4)', 'click');
     });
     this.wait_for_idle();
     this.then(function () {
         this.test.assert(verify_selection(this, 3), 'Multibutton selection updated view states correctly.');
 
         // Verify that selecting a combobox option updates all of the others.
         this.cell_element_function(selection_index, '.widget-area .widget-subarea .widget-hbox .btn-group ul.dropdown-menu li:nth-child(3) a', 'click');
     });
     this.wait_for_idle();
     this.then(function () {
         this.test.assert(verify_selection(this, 2), 'Combobox selection updated view states correctly.');
     });
 
     this.wait_for_idle();
 
     index = this.append_cell(
         'for widget in selection:\n' +
         '    d = widget.values.copy()\n' +
         '    d["z"] = "z"\n' +
         '    widget.values = d\n' +
         'selection[0].value = "z"');
     this.execute_cell_then(index, function(index){
 
         // Verify that selecting a combobox option updates all of the others.
         this.test.assert(verify_selection(this, 4), 'Item added to selection widget.');
     });
 });
  No newline at end of file

IPython/html/tests/widgets/widget_selectioncontainer.js

@@ -1,113 +1,120
 // Test multicontainer class
 casper.notebook_test(function () {
     index = this.append_cell(
         'from IPython.html import widgets\n' + 
         'from IPython.display import display, clear_output\n' +
         'print("Success")');
     this.execute_cell_then(index);
 
     // Test tab view
     var multicontainer1_query = '.widget-area .widget-subarea div div.nav-tabs';
     var multicontainer1_index = this.append_cell(
         'multicontainer = widgets.Tab()\n' +
         'page1 = widgets.Text()\n' +
         'page2 = widgets.Text()\n' +
         'page3 = widgets.Text()\n' +
         'multicontainer.children = [page1, page2, page3]\n' +
         'display(multicontainer)\n' +
         'multicontainer.selected_index = 0\n' +
         'print("Success")\n');
     this.execute_cell_then(multicontainer1_index, function(index){
-        
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Create multicontainer cell executed with correct output. (1)');
+    });
+
+    // Wait for the widget to actually display.
+    this.wait_for_element(multicontainer1_index, multicontainer1_query);
 
-        this.test.assert(this.cell_element_exists(index, 
+    // Continue with the tests.
+    this.then(function() {
+        this.test.assert(this.cell_element_exists(multicontainer1_index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
-        this.test.assert(this.cell_element_exists(index, multicontainer1_query),
+        this.test.assert(this.cell_element_exists(multicontainer1_index, multicontainer1_query),
             'Widget tab list exists.');
 
-        this.test.assert(this.cell_element_exists(index, multicontainer1_query),
-            'First widget tab list exists.');
-
         // JQuery selector is 1 based
         this.click(multicontainer1_query + ' li:nth-child(2) a');
     });
 
     this.wait_for_idle();
 
     index = this.append_cell(
         'print(multicontainer.selected_index)\n' +
         'multicontainer.selected_index = 2'); // 0 based
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '1\n', // 0 based
             'selected_index property updated with tab change.');
 
         // JQuery selector is 1 based
         this.test.assert(!this.cell_element_function(multicontainer1_index, multicontainer1_query + ' li:nth-child(1)', 'hasClass', ['active']),
                 "Tab 1 is not selected.");
         this.test.assert(!this.cell_element_function(multicontainer1_index, multicontainer1_query + ' li:nth-child(2)', 'hasClass', ['active']),
                 "Tab 2 is not selected.");
         this.test.assert(this.cell_element_function(multicontainer1_index, multicontainer1_query + ' li:nth-child(3)', 'hasClass', ['active']),
                 "Tab 3 is selected.");
     });
 
     index = this.append_cell('multicontainer.set_title(1, "hello")\nprint("Success")'); // 0 based
     this.execute_cell_then(index, function(index){
         this.test.assert(this.cell_element_function(multicontainer1_index, multicontainer1_query +
             ' li:nth-child(2) a', 'html') == 'hello',
             'Tab page title set (after display).');
     });
 
     // Test accordion view
     var multicontainer2_query = '.widget-area .widget-subarea .panel-group';
     var multicontainer2_index = this.append_cell(
         'multicontainer = widgets.Accordion()\n' +
         'page1 = widgets.Text()\n' +
         'page2 = widgets.Text()\n' +
         'page3 = widgets.Text()\n' +
         'multicontainer.children = [page1, page2, page3]\n' +
         'multicontainer.set_title(2, "good")\n' +
         'display(multicontainer)\n' +
         'multicontainer.selected_index = 0\n' +
         'print("Success")\n');
     this.execute_cell_then(multicontainer2_index, function(index){
-
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Create multicontainer cell executed with correct output. (2)');
+    });
+
+    // Wait for the widget to actually display.
+    this.wait_for_element(multicontainer2_index, multicontainer2_query);
 
-        this.test.assert(this.cell_element_exists(index, 
+    // Continue with the tests.
+    this.then(function() {
+        this.test.assert(this.cell_element_exists(multicontainer2_index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
-        this.test.assert(this.cell_element_exists(index, multicontainer2_query),
+        this.test.assert(this.cell_element_exists(multicontainer2_index, multicontainer2_query),
             'Widget accordion exists.');
 
-        this.test.assert(this.cell_element_exists(index, multicontainer2_query + 
+        this.test.assert(this.cell_element_exists(multicontainer2_index, multicontainer2_query + 
             ' .panel:nth-child(1) .panel-collapse'),
             'First accordion page exists.');
 
         // JQuery selector is 1 based
-        this.test.assert(this.cell_element_function(index, multicontainer2_query + 
+        this.test.assert(this.cell_element_function(multicontainer2_index, multicontainer2_query + 
             ' .panel.panel-default:nth-child(3) .panel-heading .accordion-toggle', 
             'html')=='good', 'Accordion page title set (before display).');
 
         // JQuery selector is 1 based
         this.click(multicontainer2_query + ' .panel:nth-child(2) .panel-heading .accordion-toggle');
     });
 
     this.wait_for_idle();
 
     index = this.append_cell('print(multicontainer.selected_index)'); // 0 based
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '1\n', // 0 based
             'selected_index property updated with tab change.');
 
         var is_collapsed = this.evaluate(function(s){
              return $(s + ' div.panel:nth-child(2) a').hasClass('collapsed'); // 1 based
         }, {s: multicontainer2_query});
         this.test.assertEquals(is_collapsed, false, 'Was tab actually opened?');
     });
 });
  No newline at end of file

IPython/html/tests/widgets/widget_string.js

@@ -1,53 +1,59
 // Test widget string class
 casper.notebook_test(function () {
-    index = this.append_cell(
+    var string_index = this.append_cell(
         'from IPython.html import widgets\n' + 
         'from IPython.display import display, clear_output\n' +
-        'print("Success")');
-    this.execute_cell_then(index);
-
-    var string_index = this.append_cell(
         'string_widget = [widgets.Text(value = "xyz", placeholder = "abc"),\n' +
         '    widgets.Textarea(value = "xyz", placeholder = "def"),\n' +
         '    widgets.HTML(value = "xyz"),\n' +
         '    widgets.Latex(value = "$\\\\LaTeX{}$")]\n' +
         '[display(widget) for widget in string_widget]\n'+
         'print("Success")');
     this.execute_cell_then(string_index, function(index){
-
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Create string widget cell executed with correct output.');
+    });
+
+    // Wait for the widget to actually display.
+    var textbox_selector = '.widget-area .widget-subarea .widget-hbox input[type=text]';
+    var textarea_selector = '.widget-area .widget-subarea .widget-hbox textarea';
+    var latex_selector = '.widget-area .widget-subarea div span.MathJax_Preview';
+    this.wait_for_element(string_index, textbox_selector);
+    this.wait_for_element(string_index, textarea_selector);
+    this.wait_for_element(string_index, latex_selector);
 
-        this.test.assert(this.cell_element_exists(index, 
+    // Continue with the tests.
+    this.then(function(){
+        this.test.assert(this.cell_element_exists(string_index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
-        this.test.assert(this.cell_element_exists(index, 
-            '.widget-area .widget-subarea .widget-hbox input[type=text]'),
+        this.test.assert(this.cell_element_exists(string_index, 
+            textbox_selector),
             'Textbox exists.');
 
-        this.test.assert(this.cell_element_exists(index, 
-            '.widget-area .widget-subarea .widget-hbox textarea'),
+        this.test.assert(this.cell_element_exists(string_index, 
+            textarea_selector),
             'Textarea exists.');
 
-        this.test.assert(this.cell_element_function(index, 
-            '.widget-area .widget-subarea .widget-hbox textarea', 'val')=='xyz',
+        this.test.assert(this.cell_element_function(string_index, 
+            textarea_selector, 'val')=='xyz',
             'Python set textarea value.');
 
-        this.test.assert(this.cell_element_function(index, 
-            '.widget-area .widget-subarea .widget-hbox input[type=text]', 'val')=='xyz',
+        this.test.assert(this.cell_element_function(string_index, 
+            textbox_selector, 'val')=='xyz',
             'Python set textbox value.');
 
         this.test.assert(this.cell_element_exists(string_index, 
-            '.widget-area .widget-subarea div span.MathJax_Preview'),
+            latex_selector),
             'MathJax parsed the LaTeX successfully.');
 
-        this.test.assert(this.cell_element_function(index, 
-            '.widget-area .widget-subarea .widget-hbox textarea', 'attr', ['placeholder'])=='def',
+        this.test.assert(this.cell_element_function(string_index, 
+            textarea_selector, 'attr', ['placeholder'])=='def',
             'Python set textarea placeholder.');
 
-        this.test.assert(this.cell_element_function(index, 
-            '.widget-area .widget-subarea .widget-hbox input[type=text]', 'attr', ['placeholder'])=='abc',
+        this.test.assert(this.cell_element_function(string_index, 
+            textbox_selector, 'attr', ['placeholder'])=='abc',
             'Python set textbox placehoder.');
     });
 });