Update test to modify class config for default_cell_type

IPython/html/static/services/config.js

@@ -1,104 +1,129 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     'jquery',
     'base/js/utils',
     ],
 function($, utils) {
     "use strict";
     var ConfigSection = function(section_name, options) {
         this.section_name = section_name;
         this.base_url = options.base_url;
         this.data = {};
         
         var that = this;
         
         /* .loaded is a promise, fulfilled the first time the config is loaded
          * from the server. Code can do:
          *      conf.loaded.then(function() { ... using conf.data ... });
          */
         this._one_load_finished = false;
         this.loaded = new Promise(function(resolve, reject) {
             that._finish_firstload = resolve;
         });
     };
 
     ConfigSection.prototype.api_url = function() {
         return utils.url_join_encode(this.base_url, 'api/config', this.section_name);
     };
     
     ConfigSection.prototype._load_done = function() {
         if (!this._one_load_finished) {
             this._one_load_finished = true;
             this._finish_firstload();
         }
     };
     
     ConfigSection.prototype.load = function() {
         var that = this;
         return utils.promising_ajax(this.api_url(), {
             cache: false,
             type: "GET",
             dataType: "json",
         }).then(function(data) {
             that.data = data;
             that._load_done();
             return data;
         });
     };
     
+    /**
+     * Modify the config values stored. Update the local data immediately,
+     * send the change to the server, and use the updated data from the server
+     * when the reply comes.
+     */
     ConfigSection.prototype.update = function(newdata) {
+        $.extend(true, this.data, newdata);  // true -> recursive update
+        
         var that = this;
         return utils.promising_ajax(this.api_url(), {
             processData: false,
             type : "PATCH",
             data: JSON.stringify(newdata),
             dataType : "json",
             contentType: 'application/json',
         }).then(function(data) {
             that.data = data;
             that._load_done();
             return data;
         });
     };
     
     
     var ConfigWithDefaults = function(section, defaults, classname) {
         this.section = section;
         this.defaults = defaults;
         this.classname = classname;
     };
     
     ConfigWithDefaults.prototype._class_data = function() {
         if (this.classname) {
             return this.section.data[this.classname] || {};
         } else {
             return this.section.data
         }
     };
     
     /**
      * Wait for config to have loaded, then get a value or the default.
      * Returns a promise.
      */
     ConfigWithDefaults.prototype.get = function(key) {
         var that = this;
         return this.section.loaded.then(function() {
             return this._class_data()[key] || this.defaults[key]
         });
     };
     
     /**
      * Return a config value. If config is not yet loaded, return the default
      * instead of waiting for it to load.
      */
     ConfigWithDefaults.prototype.get_sync = function(key) {
         return this._class_data()[key] || this.defaults[key];
     };
     
+    /**
+     * Set a config value. Send the update to the server, and change our
+     * local copy of the data immediately.
+     * Returns a promise which is fulfilled when the server replies to the
+     * change.
+     */
+     ConfigWithDefaults.prototype.set = function(key, value) {
+         var d = {};
+         d[key] = value;
+         if (this.classname) {
+            var d2 = {};
+            d2[this.classname] = d;
+            return this.section.update(d2);
+        } else {
+            return this.section.update(d);
+        }
+    };
+    
     return {ConfigSection: ConfigSection,
             ConfigWithDefaults: ConfigWithDefaults,
            };
 
 });

IPython/html/tests/notebook/dualmode_cellinsert.js

@@ -1,77 +1,77 b''
 
 // Test
 casper.notebook_test(function () {
     var a = 'print("a")';
     var index = this.append_cell(a);
     this.execute_cell_then(index);
 
     var b = 'print("b")';
     index = this.append_cell(b);
     this.execute_cell_then(index);
 
     var c = 'print("c")';
     index = this.append_cell(c);
     this.execute_cell_then(index);
     
     this.thenEvaluate(function() {
         IPython.notebook.default_cell_type = 'code';
     });
     
     this.then(function () {
         // Cell insertion
         this.select_cell(2);
         this.trigger_keydown('m'); // Make it markdown
         this.trigger_keydown('a'); // Creates one cell
         this.test.assertEquals(this.get_cell_text(2), '', 'a; New cell 2 text is empty');
         this.test.assertEquals(this.get_cell(2).cell_type, 'code', 'a; inserts a code cell');
         this.validate_notebook_state('a', 'command', 2);
         this.trigger_keydown('b'); // Creates one cell
         this.test.assertEquals(this.get_cell_text(2), '', 'b; Cell 2 text is still empty');
         this.test.assertEquals(this.get_cell_text(3), '', 'b; New cell 3 text is empty');
         this.test.assertEquals(this.get_cell(3).cell_type, 'code', 'b; inserts a code cell');
         this.validate_notebook_state('b', 'command', 3);
     });
     
     this.thenEvaluate(function() {
-        IPython.notebook.default_cell_type = 'selected';
+        IPython.notebook.class_config.set('default_cell_type', 'selected');
     });
     
     this.then(function () {
         this.select_cell(2);
         this.trigger_keydown('m'); // switch it to markdown for the next test
         this.test.assertEquals(this.get_cell(2).cell_type, 'markdown', 'test cell is markdown');
         this.trigger_keydown('a'); // new cell above
         this.test.assertEquals(this.get_cell(2).cell_type, 'markdown', 'a; inserts a markdown cell when markdown selected');
         this.trigger_keydown('b'); // new cell below
         this.test.assertEquals(this.get_cell(3).cell_type, 'markdown', 'b; inserts a markdown cell when markdown selected');
     });
     
     this.thenEvaluate(function() {
-        IPython.notebook.default_cell_type = 'above';
+        IPython.notebook.class_config.set('default_cell_type', 'above');
     });
     
     this.then(function () {
         this.select_cell(2);
         this.trigger_keydown('y'); // switch it to code for the next test
         this.test.assertEquals(this.get_cell(2).cell_type, 'code', 'test cell is code');
         this.trigger_keydown('b'); // new cell below
         this.test.assertEquals(this.get_cell(3).cell_type, 'code', 'b; inserts a code cell below code cell');
         this.trigger_keydown('a'); // new cell above
         this.test.assertEquals(this.get_cell(3).cell_type, 'code', 'a; inserts a code cell above code cell');
     });
     
     this.thenEvaluate(function() {
-        IPython.notebook.default_cell_type = 'below';
+        IPython.notebook.class_config.set('default_cell_type', 'below');
     });
     
     this.then(function () {
         this.select_cell(2);
         this.trigger_keydown('r'); // switch it to markdown for the next test
         this.test.assertEquals(this.get_cell(2).cell_type, 'raw', 'test cell is raw');
         this.trigger_keydown('a'); // new cell above
         this.test.assertEquals(this.get_cell(2).cell_type, 'raw', 'a; inserts a raw cell above raw cell');
         this.trigger_keydown('y'); // switch it to code for the next test
         this.trigger_keydown('b'); // new cell below
         this.test.assertEquals(this.get_cell(3).cell_type, 'raw', 'b; inserts a raw cell below raw cell');
     });
 });