Subversion Repositories Applications.papyrus

if(!dojo._hasResource["tests.data.ItemFileWriteStore"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["tests.data.ItemFileWriteStore"] = true;
dojo.provide("tests.data.ItemFileWriteStore");
dojo.require("tests.data.readOnlyItemFileTestTemplates");

dojo.require("dojo.data.ItemFileWriteStore");
dojo.require("dojo.data.api.Read");
dojo.require("dojo.data.api.Identity");
dojo.require("dojo.data.api.Write");
dojo.require("dojo.data.api.Notification");


// First, make sure ItemFileWriteStore can still pass all the same unit tests 
// that we use for its superclass, ItemFileReadStore:
tests.data.readOnlyItemFileTestTemplates.registerTestsForDatastore("dojo.data.ItemFileWriteStore");


// Now run some tests that are specific to the write-access features:
doh.register("tests.data.ItemFileWriteStore", 
        [
                function test_getFeatures(){
                        //      summary: 
                        //              Simple test of the getFeatures function of the store
                        //      description:
                        //              Simple test of the getFeatures function of the store
                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

                        var features = store.getFeatures(); 

                        // make sure we have the expected features:
                        doh.assertTrue(features["dojo.data.api.Read"] != null);
                        doh.assertTrue(features["dojo.data.api.Identity"] != null);
                        doh.assertTrue(features["dojo.data.api.Write"] != null);
                        doh.assertTrue(features["dojo.data.api.Notification"] != null);
                        doh.assertFalse(features["iggy"]);
                        
                        // and only the expected features:
                        var count = 0;
                        for(var i in features){
                                doh.assertTrue((i === "dojo.data.api.Read" || 
                                        i === "dojo.data.api.Identity" || 
                                        i === "dojo.data.api.Write" || 
                                        i === "dojo.data.api.Notification"));
                                count++;
                        }
                        doh.assertEqual(count, 4);
                },
                function testWriteAPI_setValue(){
                        //      summary: 
                        //              Simple test of the setValue API
                        //      description:
                        //              Simple test of the setValue API
                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

                        var deferred = new doh.Deferred();
                        function onComplete(items, request){
                                doh.assertEqual(1, items.length);
                                var item = items[0];
                                doh.assertTrue(store.containsValue(item, "capital", "Cairo"));
                                
                                // FIXME:  
                                //    Okay, so this seems very odd.  Maybe I'm just being dense.
                                //    These tests works:
                                doh.assertEqual(store.isDirty(item), false);
                                doh.assertTrue(store.isDirty(item) == false);
                                //    But these seemingly equivalent tests will not work:
                                // doh.assertFalse(store.isDirty(item));
                                // doh.assertTrue(!(store.isDirty(item)));
                                //   
                                //    All of which seems especially weird, given that this *does* work:
                                doh.assertFalse(store.isDirty());
                                
                                
                                doh.assertTrue(store.isDirty(item) == false);
                                doh.assertTrue(!store.isDirty());
                                store.setValue(item, "capital", "New Cairo");
                                doh.assertTrue(store.isDirty(item));
                                doh.assertTrue(store.isDirty());
                                doh.assertEqual(store.getValue(item, "capital").toString(), "New Cairo");
                                deferred.callback(true);
                        }
                        function onError(error, request){
                                deferred.errback(error);
                        }
                        store.fetch({query:{name:"Egypt"}, onComplete: onComplete, onError: onError});
                        return deferred; //Object
                },
                function testWriteAPI_setValues(){
                        //      summary: 
                        //              Simple test of the setValues API
                        //      description:
                        //              Simple test of the setValues API
                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

                        var deferred = new doh.Deferred();
                        function onComplete(items, request){
                                doh.assertEqual(1, items.length);
                                var item = items[0];
                                doh.assertTrue(store.containsValue(item, "name", "Egypt"));
                                doh.assertTrue(store.isDirty(item) == false);
                                doh.assertTrue(!store.isDirty());
                                store.setValues(item, "name", ["Egypt 1", "Egypt 2"]);
                                doh.assertTrue(store.isDirty(item));
                                doh.assertTrue(store.isDirty());
                                var values = store.getValues(item, "name");
                                doh.assertTrue(values[0] == "Egypt 1");
                                doh.assertTrue(values[1] == "Egypt 2");
                                deferred.callback(true);
                        }
                        function onError(error, request){
                                deferred.errback(error);
                        }
                        store.fetch({query:{name:"Egypt"}, onComplete: onComplete, onError: onError});
                        return deferred; //Object
                },
                function testWriteAPI_unsetAttribute(){
                        //      summary: 
                        //              Simple test of the unsetAttribute API
                        //      description:
                        //              Simple test of the unsetAttribute API
                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

                        var deferred = new doh.Deferred();
                        function onComplete(items, request) {
                                doh.assertEqual(1, items.length);
                                var item = items[0];
                                doh.assertTrue(store.containsValue(item, "name", "Egypt"));
                                doh.assertTrue(store.isDirty(item) == false);
                                doh.assertTrue(!store.isDirty());
                                store.unsetAttribute(item, "name");
                                doh.assertTrue(store.isDirty(item));
                                doh.assertTrue(store.isDirty());
                                doh.assertTrue(!store.hasAttribute(item, "name"));
                                deferred.callback(true);
                        }
                        function onError(error, request) {
                                deferred.errback(error);
                        }
                        store.fetch({query:{name:"Egypt"}, onComplete: onComplete, onError: onError});
                        return deferred; //Object
                },
                function testWriteAPI_newItem(){
                        //      summary: 
                        //              Simple test of the newItem API
                        //      description:
                        //              Simple test of the newItem API
                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

                        var deferred = new doh.Deferred();
                        doh.assertTrue(!store.isDirty());

                        var onNewInvoked = false;
                        store.onNew = function(newItem, parentInfo){

                                doh.assertTrue(newItem !== null);
                                doh.assertTrue(parentInfo === null);
                                doh.assertTrue(store.isItem(newItem));
                                onNewInvoked = true;
                        };
                        var canada = store.newItem({name: "Canada", abbr:"ca", capital:"Ottawa"});
                        doh.assertTrue(onNewInvoked);
                        
                        doh.assertTrue(store.isDirty(canada));
                        doh.assertTrue(store.isDirty());
                        doh.assertTrue(store.getValues(canada, "name") == "Canada");
                        function onComplete(items, request){
                                doh.assertEqual(1, items.length);
                                var item = items[0];
                                doh.assertTrue(store.containsValue(item, "name", "Canada"));
                                deferred.callback(true);
                        }
                        function onError(error, request){
                                deferred.errback(error);
                        }
                        store.fetch({query:{name:"Canada"}, onComplete: onComplete, onError: onError});
                        return deferred; //Object
                },
                function testWriteAPI_newItem_withParent(){
                        //      summary: 
                        //              Simple test of the newItem API with a parent assignment
                        //      description:
                        //              Simple test of the newItem API with a parent assignment
                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

                        var deferred = new doh.Deferred();
                        doh.assertTrue(!store.isDirty());
                        function onComplete(items, request){
                                doh.assertEqual(1, items.length);
                                var item = items[0];
                                doh.assertTrue(store.containsValue(item, "name", "Egypt"));

                                //Attach an onNew to validate we get expected values.
                                var onNewInvoked = false;
                                store.onNew = function(newItem, parentInfo){
                                        doh.assertEqual(item, parentInfo.item);
                                        doh.assertEqual("cities", parentInfo.attribute);
                                        doh.assertTrue(parentInfo.oldValue === undefined);
                                        doh.assertTrue(parentInfo.newValue === newItem);
                                        onNewInvoked = true;
                                };
                
                                //Attach an onSet and verify onSet is NOT called in this case.
                                store.onSet = function(item, attribute, oldValue, newValue){
                                        doh.assertTrue(false);
                                };

                                //See if we can add in a new item representing the city of Cairo.
                                //This should also call the onNew set above....
                                var newItem = store.newItem({name: "Cairo", abbr: "Cairo"}, {parent: item, attribute: "cities"});
                                doh.assertTrue(onNewInvoked);

                                function onCompleteNewItemShallow(items, request){
                                        doh.assertEqual(0, items.length);
                                        function onCompleteNewItemDeep(items, request){
                                                doh.assertEqual(1, items.length);
                                                var item = items[0];
                                                doh.assertEqual("Cairo", store.getValue(item, "name"));
                                                deferred.callback(true);
                                        }
                                        //Do a deep search now, should find the new item of the city with name attribute Cairo.
                                        store.fetch({query:{name:"Cairo"}, onComplete: onCompleteNewItemDeep, onError: onError, queryOptions: {deep:true}});
                                }
                                //Do a shallow search first, should find nothing.
                                store.fetch({query:{name:"Cairo"}, onComplete: onCompleteNewItemShallow, onError: onError});
                        }
                        function onError(error, request){
                                deferred.errback(error);
                        }
                        store.fetch({query:{name:"Egypt"}, onComplete: onComplete, onError: onError});
                        return deferred; //Object
                },
                
                function testWriteAPI_newItem_multiple_withParent(){
                        //      summary: 
                        //              Simple test of the newItem API with a parent assignment multiple times.
                        //      description:
                        //              Simple test of the newItem API with a parent assignment multiple times.
                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

                        var deferred = new doh.Deferred();
                        
                        doh.assertTrue(!store.isDirty());
                        
                        function onComplete(items, request){
                                doh.assertEqual(1, items.length);
                                var item = items[0];
                                doh.assertTrue(store.containsValue(item, "name", "Egypt"));

                                //Attach an onNew to validate we get expected values.
                                store.onNew = function(newItem, parentInfo){
                                        doh.assertEqual(item, parentInfo.item);
                                        doh.assertEqual("cities", parentInfo.attribute);
                                        
                                        doh.assertTrue(parentInfo.oldValue === undefined);
                                        
                                        doh.assertTrue(parentInfo.newValue === newItem);
                                };

                                //See if we can add in a new item representing the city of Cairo.
                                //This should also call the onNew set above....
                                var newItem1 = store.newItem({name: "Cairo", abbr: "Cairo"}, {parent: item, attribute: "cities"});
                                
                                //Attach a new onNew to validate we get expected values.
                                store.onNew = function(newItem, parentInfo){
                                        doh.assertEqual(item, parentInfo.item);
                                        doh.assertEqual("cities", parentInfo.attribute);
                                        
                                        console.log(parentInfo.oldValue);
                                        doh.assertTrue(parentInfo.oldValue == newItem1);
                                        
                                        doh.assertTrue(parentInfo.newValue[0] == newItem1);
                                        doh.assertTrue(parentInfo.newValue[1] == newItem);
                                };
                                var newItem2 = store.newItem({name: "Banha", abbr: "Banha"}, {parent: item, attribute: "cities"});
                                
                                //Attach a new onNew to validate we get expected values.
                                store.onNew = function(newItem, parentInfo){
                                        doh.assertEqual(item, parentInfo.item);
                                        doh.assertEqual("cities", parentInfo.attribute);
                                        
                                        doh.assertTrue(parentInfo.oldValue[0] == newItem1);
                                        doh.assertTrue(parentInfo.oldValue[1] == newItem2);
                                        
                                        doh.assertTrue(parentInfo.newValue[0] == newItem1);
                                        doh.assertTrue(parentInfo.newValue[1] == newItem2);
                                        doh.assertTrue(parentInfo.newValue[2] == newItem);
                                };
                                var newItem3 = store.newItem({name: "Damanhur", abbr: "Damanhur"}, {parent: item, attribute: "cities"});
                                deferred.callback(true);
                        }
                        function onError(error, request){
                                deferred.errback(error);
                        }
                        store.fetch({query:{name:"Egypt"}, onComplete: onComplete, onError: onError});
                        return deferred; //Object
                },

                function testWriteAPI_deleteItem(){
                        //      summary: 
                        //              Simple test of the deleteItem API
                        //      description:
                        //              Simple test of the deleteItem API
                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

                        var deferred = new doh.Deferred();
                        function onComplete(items, request){
                                doh.assertEqual(1, items.length);
                                var item = items[0];
                                doh.assertTrue(store.containsValue(item, "name", "Egypt"));
                                doh.assertTrue(store.isDirty(item) == false);
                                doh.assertTrue(!store.isDirty());
                                store.deleteItem(item);
                                doh.assertTrue(store.isDirty(item));
                                doh.assertTrue(store.isDirty());
                                function onCompleteToo(itemsToo, requestToo) {
                                        doh.assertEqual(0, itemsToo.length);
                                        deferred.callback(true);
                                }
                                store.fetch({query:{name:"Egypt"}, onComplete: onCompleteToo, onError: onError});
                        }
                        function onError(error, request){
                                deferred.errback(error);
                        }
                        store.fetch({query:{name:"Egypt"}, onComplete: onComplete, onError: onError});
                        return deferred; //Object
                },
                function testWriteAPI_isDirty(){
                        //      summary: 
                        //              Simple test of the isDirty API
                        //      description:
                        //              Simple test of the isDirty API
                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

                        var deferred = new doh.Deferred();
                        function onComplete(items, request) {
                                doh.assertEqual(1, items.length);
                                var item = items[0];
                                doh.assertTrue(store.containsValue(item, "name", "Egypt"));
                                store.setValue(item, "name", "Egypt 2");
                                doh.assertTrue(store.getValue(item, "name") == "Egypt 2");
                                doh.assertTrue(store.isDirty(item));
                                deferred.callback(true);
                        }
                        function onError(error, request) {
                                deferred.errback(error);
                        }
                        store.fetch({query:{name:"Egypt"}, onComplete: onComplete, onError: onError});
                        return deferred; //Object
                },
                function testWriteAPI_revert(){
                        //      summary: 
                        //              Simple test of the revert API
                        //      description:
                        //              Simple test of the revert API
                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

                        var deferred = new doh.Deferred();
                        function onComplete(items, request) {
                                doh.assertEqual(1, items.length);
                                var item = items[0];
                                doh.assertTrue(store.containsValue(item, "name", "Egypt"));
                                doh.assertTrue(store.isDirty(item) == false);
                                doh.assertTrue(!store.isDirty());
                                store.setValue(item, "name", "Egypt 2");
                                doh.assertTrue(store.getValue(item, "name") == "Egypt 2");
                                doh.assertTrue(store.isDirty(item));
                                doh.assertTrue(store.isDirty());
                                store.revert();
                                
                                //Fetch again to see if it reset the state.
                                function onCompleteToo(itemsToo, requestToo){
                                        doh.assertEqual(1, itemsToo.length);
                                        var itemToo = itemsToo[0];
                                        doh.assertTrue(store.containsValue(itemToo, "name", "Egypt"));
                                        deferred.callback(true);
                                }
                                store.fetch({query:{name:"Egypt"}, onComplete: onCompleteToo, onError: onError});
                        }
                        function onError(error, request){
                                deferred.errback(error);
                        }
                        store.fetch({query:{name:"Egypt"}, onComplete: onComplete, onError: onError});
                        return deferred; //Object
                },
                function testWriteAPI_save(){
                        //      summary: 
                        //              Simple test of the save API
                        //      description:
                        //              Simple test of the save API
                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

                        var deferred = new doh.Deferred();
                        function onError(error){
                                deferred.errback(error);
                        }
                        function onItem(item){
                                store.setValue(item, "capital", "New Cairo");
                                function onComplete() {
                                        deferred.callback(true);
                                }
                                store.save({onComplete:onComplete, onError:onError});
                        }
                        store.fetchItemByIdentity({identity:"eg", onItem:onItem, onError:onError});
                        return deferred; //Object
                },
                function testWriteAPI_saveVerifyState(){
                        //      summary: 
                        //              Simple test of the save API
                        //      description:
                        //              Simple test of the save API
                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

                        var deferred = new doh.Deferred();
                        function onError(error){
                                deferred.errback(error);
                        }
                        function onItem(item){
                                store.setValue(item, "capital", "New Cairo");
                                function onComplete() {
                                        //Check internal state.  Note:  Users should NOT do this, this is a UT verification
                                        //of internals in this case.  Ref tracker: #4394
                                        doh.assertTrue(!store._saveInProgress);
                                        deferred.callback(true);
                                }
                                store.save({onComplete:onComplete, onError:onError});
                        }
                        store.fetchItemByIdentity({identity:"eg", onItem:onItem, onError:onError});
                        return deferred; //Object
                },
                function testWriteAPI_saveEverything(){
                        //      summary: 
                        //              Simple test of the save API
                        //      description:
                        //              Simple test of the save API
                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
                        var egypt;
                        store._saveEverything = function(saveCompleteCallback, saveFailedCallback, newFileContentString){
                                var struct = dojo.fromJson(newFileContentString);
                                doh.assertEqual(struct.identifier, store.getIdentityAttributes(egypt)[0]);
                                doh.assertEqual(struct.label, store.getLabelAttributes(egypt)[0]);
                                doh.assertEqual(struct.items.length, 7);
                                
                                var cloneStore = new dojo.data.ItemFileWriteStore({data:struct});
                                function onItemClone(itemClone){
                                        var egyptClone = itemClone;
                                        doh.assertEqual(store.getIdentityAttributes(egypt)[0], cloneStore.getIdentityAttributes(egyptClone)[0]);
                                        doh.assertEqual(store.getLabelAttributes(egypt)[0], cloneStore.getLabelAttributes(egyptClone)[0]);
                                        doh.assertEqual(store.getValue(egypt, "name"), cloneStore.getValue(egyptClone, "name"));
                                }
                                cloneStore.fetchItemByIdentity({identity:"eg", onItem:onItemClone, onError:onError});
                                
                                saveCompleteCallback();
                        };

                        var deferred = new doh.Deferred();
                        function onError(error){
                                deferred.errback(error);
                        }
                        function onItem(item){
                                egypt = item;
                                function onComplete() {
                                        deferred.callback(true);
                                }
                                store.setValue(egypt, "capital", "New Cairo");
                                store.save({onComplete:onComplete, onError:onError});
                        }
                        store.fetchItemByIdentity({identity:"eg", onItem:onItem, onError:onError});
                        return deferred; //Object
                },
                function testWriteAPI_saveEverything_withDateType(){
                        //      summary: 
                        //              Simple test of the save API     with a non-atomic type (Date) that has a type mapping.
                        //      description:
                        //              Simple test of the save API     with a non-atomic type (Date) that has a type mapping.
                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
                        store._saveEverything = function(saveCompleteCallback, saveFailedCallback, newFileContentString){

                                //Now load the new data into a datastore and validate that it stored the date right.
                                var dataset = dojo.fromJson(newFileContentString);
                                var newStore = new dojo.data.ItemFileWriteStore({data: dataset});

                                function gotItem(item){
                                        var independenceDate = newStore.getValue(item,"independence"); 
                                        doh.assertTrue(independenceDate instanceof Date);
                                        doh.assertTrue(dojo.date.compare(new Date(1993,04,24), independenceDate, "date") === 0);
                                        saveCompleteCallback();
                                }
                                function failed(error, request){
                                        deferred.errback(error);
                                        saveFailedCallback();
                                }
                                newStore.fetchItemByIdentity({identity:"eg", onItem:gotItem, onError:failed});
                        };

                        var deferred = new doh.Deferred();
                        function onError(error){
                                deferred.errback(error);
                        }
                        function onItem(item){
                                function onComplete() {
                                        deferred.callback(true);
                                }
                                store.setValue(item, "independence", new Date(1993,04,24));
                                store.save({onComplete:onComplete, onError:onError});
                        }
                        store.fetchItemByIdentity({identity:"eg", onItem:onItem, onError:onError});
                        return deferred; //Object
                },
                function testWriteAPI_saveEverything_withCustomColorTypeSimple(){
                        //      summary: 
                        //              Simple test of the save API     with a non-atomic type (dojo.Color) that has a type mapping.
                        //      description:
                        //              Simple test of the save API     with a non-atomic type (dojo.Color) that has a type mapping.

                        //Set up the store basics:  What data it has, and what to do when save is called for saveEverything
                        //And how to map the 'Color' type in and out of the format.
                        //(Test of saving all to a some location...)
                        var dataset = {
                                identifier:'name',
                                items: [
                                        { name:'Kermit', species:'frog', color:{_type:'Color', _value:'green'} },
                                        { name:'Beaker', hairColor:{_type:'Color', _value:'red'} }
                                ]
                        };

                        var customTypeMap = {'Color': dojo.Color };

                        var store = new dojo.data.ItemFileWriteStore({
                                        data:dataset,
                                        typeMap: customTypeMap
                        });
                        
                        store._saveEverything = function(saveCompleteCallback, saveFailedCallback, newFileContentString){
                                //Now load the new data into a datastore and validate that it stored the Color right.
                                var dataset = dojo.fromJson(newFileContentString);
                                var newStore = new dojo.data.ItemFileWriteStore({data: dataset, typeMap: customTypeMap});

                                function gotItem(item){
                                        var hairColor = newStore.getValue(item,"hairColor"); 
                                        doh.assertTrue(hairColor instanceof dojo.Color);
                                        doh.assertEqual("rgba(255, 255, 0, 1)", hairColor.toString());
                                        saveCompleteCallback();
                                }
                                function failed(error, request){
                                        deferred.errback(error);
                                        saveFailedCallback();
                                }
                                newStore.fetchItemByIdentity({identity:"Animal", onItem:gotItem, onError:failed});
                        };

                        //Add a new item with a color type, then save it.
                        var deferred = new doh.Deferred();
                        function onError(error){
                                deferred.errback(error);
                        }
                        function onComplete() {
                                deferred.callback(true);
                        }

                        var animal = store.newItem({name: "Animal", hairColor: new dojo.Color("yellow")});
                        store.save({onComplete:onComplete, onError:onError});
                        return deferred; //Object
                },
                function testWriteAPI_saveEverything_withCustomColorTypeGeneral(){
                        //      summary: 
                        //              Simple test of the save API     with a non-atomic type (dojo.Color) that has a type mapping.
                        //      description:
                        //              Simple test of the save API     with a non-atomic type (dojo.Color) that has a type mapping.

                        //Set up the store basics:  What data it has, and what to do when save is called for saveEverything
                        //And how to map the 'Color' type in and out of the format.
                        //(Test of saving all to a some location...)
                        var dataset = {
                                identifier:'name',
                                items: [
                                        { name:'Kermit', species:'frog', color:{_type:'Color', _value:'green'} },
                                        { name:'Beaker', hairColor:{_type:'Color', _value:'red'} }
                                ]
                        };

                        var customTypeMap = {'Color':   {       
                                                                                                type: dojo.Color,
                                                                                                deserialize: function(value){
                                                                                                        return new dojo.Color(value);
                                                                                                },
                                                                                                serialize: function(obj){
                                                                                                        return obj.toString();
                                                                                                }
                                                                                        }
                                                                }
                        var store = new dojo.data.ItemFileWriteStore({
                                        data:dataset,
                                        typeMap: customTypeMap
                        });
                        store._saveEverything = function(saveCompleteCallback, saveFailedCallback, newFileContentString){
                                //Now load the new data into a datastore and validate that it stored the Color right.
                                var dataset = dojo.fromJson(newFileContentString);
                                var newStore = new dojo.data.ItemFileWriteStore({data: dataset, typeMap: customTypeMap});

                                function gotItem(item){
                                        var hairColor = newStore.getValue(item,"hairColor"); 
                                        doh.assertTrue(hairColor instanceof dojo.Color);
                                        doh.assertEqual("rgba(255, 255, 0, 1)", hairColor.toString());
                                        saveCompleteCallback();
                                }
                                function failed(error, request){
                                        deferred.errback(error);
                                        saveFailedCallback();
                                }
                                newStore.fetchItemByIdentity({identity:"Animal", onItem:gotItem, onError:failed});
                        };

                        //Add a new item with a color type, then save it.
                        var deferred = new doh.Deferred();
                        function onError(error){
                                deferred.errback(error);
                        }
                        function onComplete() {
                                deferred.callback(true);
                        }

                        var animal = store.newItem({name: "Animal", hairColor: new dojo.Color("yellow")});
                        store.save({onComplete:onComplete, onError:onError});
                        return deferred; //Object
                },
                function testWriteAPI_newItem_revert(){
                        //      summary: 
                        //              Test for bug #5357.  Ensure that the revert properly nulls the identity position
                        //      for a new item after revert.
                        var args = {data: {
                                label:"name",
                                items:[
                                        {name:'Ecuador', capital:'Quito'},
                                        {name:'Egypt', capital:'Cairo'},
                                        {name:'El Salvador', capital:'San Salvador'},
                                        {name:'Equatorial Guinea', capital:'Malabo'},
                                        {name:'Eritrea', capital:'Asmara'},
                                        {name:'Estonia', capital:'Tallinn'},
                                        {name:'Ethiopia', capital:'Addis Ababa'}
                                ]
                        } }; 
                        var store = new dojo.data.ItemFileWriteStore(args);

                        var newCountry = store.newItem({name: "Utopia", capitol: "Perfect"});

                        //DO NOT ACCESS THIS WAY.  THESE ARE INTERNAL VARIABLES.  DOING THIS FOR TEST PURPOSES.
                        var itemEntryNum = newCountry[store._itemNumPropName];
                        doh.assertTrue(store._arrayOfAllItems[itemEntryNum] === newCountry);
                        store.revert();
                        doh.assertTrue(store._arrayOfAllItems[itemEntryNum] === null);
                },
                function testNotificationAPI_onSet(){
                        //      summary: 
                        //              Simple test of the onSet API
                        //      description:
                        //              Simple test of the onSet API
                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

                        var deferred = new doh.Deferred();
                        function onError(error){
                                deferred.errback(error);
                        }
                        function onItem(fetchedItem){
                                var egypt = fetchedItem;
                                var connectHandle = null;
                                function setValueHandler(item, attribute, oldValue, newValue){
                                        doh.assertTrue(store.isItem(item));
                                        doh.assertTrue(item == egypt);
                                        doh.assertTrue(attribute == "capital");
                                        doh.assertTrue(oldValue == "Cairo");
                                        doh.assertTrue(newValue == "New Cairo");
                                        deferred.callback(true);
                                        dojo.disconnect(connectHandle);
                                }
                                connectHandle = dojo.connect(store, "onSet", setValueHandler);
                                store.setValue(egypt, "capital", "New Cairo");
                        }
                        store.fetchItemByIdentity({identity:"eg", onItem:onItem, onError:onError});
                },
                function testNotificationAPI_onNew(){
                        //      summary: 
                        //              Simple test of the onNew API
                        //      description:
                        //              Simple test of the onNew API
                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

                        var deferred = new doh.Deferred();
                        var connectHandle = null;
                        function newItemHandler(item){
                                doh.assertTrue(store.isItem(item));
                                doh.assertTrue(store.getValue(item, "name") == "Canada");
                                deferred.callback(true);
                                dojo.disconnect(connectHandle);
                        }
                        connectHandle = dojo.connect(store, "onNew", newItemHandler);
                        var canada = store.newItem({name:"Canada", abbr:"ca", capital:"Ottawa"});
                },
                function testNotificationAPI_onDelete(){
                        //      summary: 
                        //              Simple test of the onDelete API
                        //      description:
                        //              Simple test of the onDelete API
                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

                        var deferred = new doh.Deferred();
                        function onError(error){
                                deferred.errback(error);
                        }
                        function onItem(fetchedItem){
                                var egypt = fetchedItem;
                                var connectHandle = null;
                                function deleteItemHandler(item){
                                        doh.assertTrue(store.isItem(item) == false);
                                        doh.assertTrue(item == egypt);
                                        deferred.callback(true);
                                        dojo.disconnect(connectHandle);
                                }
                                connectHandle = dojo.connect(store, "onDelete", deleteItemHandler);
                                store.deleteItem(egypt);
                        }
                        store.fetchItemByIdentity({identity:"eg", onItem:onItem, onError:onError});
                },
                function testReadAPI_functionConformanceToo(){
                        //      summary: 
                        //              Simple test read API conformance.  Checks to see all declared functions are actual functions on the instances.
                        //      description:
                        //              Simple test read API conformance.  Checks to see all declared functions are actual functions on the instances.
                        var testStore = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
                        var readApi = new dojo.data.api.Read();
                        var passed = true;

                        for(var functionName in readApi){
                                var member = readApi[functionName];
                                //Check that all the 'Read' defined functions exist on the test store.
                                if(typeof member === "function"){
                                        var testStoreMember = testStore[functionName];
                                        if(!(typeof testStoreMember === "function")){
                                                passed = false;
                                                break;
                                        }
                                }
                        }
                        doh.assertTrue(passed);
                },
                function testWriteAPI_functionConformance(){
                        //      summary: 
                        //              Simple test write API conformance.  Checks to see all declared functions are actual functions on the instances.
                        //      description:
                        //              Simple test write API conformance.  Checks to see all declared functions are actual functions on the instances.
                        var testStore = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
                        var writeApi = new dojo.data.api.Write();
                        var passed = true;

                        for(var functionName in writeApi){
                                var member = writeApi[functionName];
                                //Check that all the 'Write' defined functions exist on the test store.
                                if(typeof member === "function"){
                                        var testStoreMember = testStore[functionName];
                                        if(!(typeof testStoreMember === "function")){
                                                passed = false;
                                                break;
                                        }
                                }
                        }
                        doh.assertTrue(passed);
                },
                function testNotificationAPI_functionConformance(){
                        //      summary: 
                        //              Simple test Notification API conformance.  Checks to see all declared functions are actual functions on the instances.
                        //      description:
                        //              Simple test Notification API conformance.  Checks to see all declared functions are actual functions on the instances.
                        var testStore = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
                        var api = new dojo.data.api.Notification();
                        var passed = true;

                        for(var functionName in api){
                                var member = api[functionName];
                                //Check that all the 'Write' defined functions exist on the test store.
                                if(typeof member === "function"){
                                        var testStoreMember = testStore[functionName];
                                        if(!(typeof testStoreMember === "function")){
                                                passed = false;
                                                break;
                                        }
                                }
                        }
                        doh.assertTrue(passed);
                },
                function testIdentityAPI_noIdentifierSpecified(){
                        //      summary: 
                        //              Test for bug #3873. Given a datafile that does not specify an
                        //              identifier, make sure ItemFileWriteStore auto-creates identities 
                        //              that are unique even after calls to deleteItem() and newItem()
                        var args = {data: {
                                label:"name",
                                items:[
                                        {name:'Ecuador', capital:'Quito'},
                                        {name:'Egypt', capital:'Cairo'},
                                        {name:'El Salvador', capital:'San Salvador'},
                                        {name:'Equatorial Guinea', capital:'Malabo'},
                                        {name:'Eritrea', capital:'Asmara'},
                                        {name:'Estonia', capital:'Tallinn'},
                                        {name:'Ethiopia', capital:'Addis Ababa'}
                                ]
                        } }; 
                        var store = new dojo.data.ItemFileWriteStore(args);
                        var deferred = new doh.Deferred();
                        
                        var onError = function(error, request){
                                deferred.errback(error);
                        }
                        var onComplete = function(items, request){
                                doh.assertEqual(7, items.length);
                                
                                var lastItem = items[(items.length - 1)];
                                var idOfLastItem = store.getIdentity(lastItem);
                                store.deleteItem(lastItem);
                                store.newItem({name:'Canada', capital:'Ottawa'});
                                
                                var onCompleteAgain = function(itemsAgain, requestAgain){
                                        doh.assertEqual(7, itemsAgain.length);
                                        var identitiesInUse = {};
                                        for(var i = 0; i < itemsAgain.length; ++i){
                                                var item = itemsAgain[i];
                                                var id = store.getIdentity(item);
                                                if(identitiesInUse.hasOwnProperty(id)){
                                                        // there should not already be an entry for this id
                                                        doh.assertTrue(false);
                                                }else{
                                                        // we want to add the entry now
                                                        identitiesInUse[id] = item;
                                                }
                                        }
                                        deferred.callback(true);
                                }
                                store.fetch({onComplete:onCompleteAgain, onError:onError});
                        }
                        
                        store.fetch({onComplete:onComplete, onError:onError});
                        return deferred;
                },
                function testIdentityAPI_noIdentifierSpecified_revert(){
                        //      summary: 
                        //              Test for bug #4691  Given a datafile that does not specify an
                        //              identifier, make sure ItemFileWriteStore auto-creates identities 
                        //              that are unique even after calls to deleteItem() and newItem()
                        var args = {data: {
                                label:"name",
                                items:[
                                        {name:'Ecuador', capital:'Quito'},
                                        {name:'Egypt', capital:'Cairo'},
                                        {name:'El Salvador', capital:'San Salvador'},
                                        {name:'Equatorial Guinea', capital:'Malabo'},
                                        {name:'Eritrea', capital:'Asmara'},
                                        {name:'Estonia', capital:'Tallinn'},
                                        {name:'Ethiopia', capital:'Addis Ababa'}
                                ]
                        } }; 
                        var store = new dojo.data.ItemFileWriteStore(args);
                        var deferred = new doh.Deferred();
                        
                        var onError = function(error, request){
                                deferred.errback(error);
                        }
                        var onComplete = function(items, request){
                                doh.assertEqual(7, items.length);
                                
                                var lastItem = items[(items.length - 1)];
                                var idOfLastItem = store.getIdentity(lastItem);
                                store.deleteItem(lastItem);
                                store.newItem({name:'Canada', capital:'Ottawa'});
                                
                                var onCompleteAgain = function(itemsAgain, requestAgain){
                                        doh.assertEqual(7, itemsAgain.length);
                                        var identitiesInUse = {};
                                        for(var i = 0; i < itemsAgain.length; ++i){
                                                var item = itemsAgain[i];
                                                var id = store.getIdentity(item);
                                                if(identitiesInUse.hasOwnProperty(id)){
                                                        // there should not already be an entry for this id
                                                        doh.assertTrue(false);
                                                }else{
                                                        // we want to add the entry now
                                                        identitiesInUse[id] = item;
                                                }
                                        }
                                        //Last test, revert everything and check item sizes.
                                        store.revert();

                                        //Now call fetch again and verify store state.
                                        var revertComplete = function(itemsReverted, request){
                                                doh.assertEqual(7, itemsReverted.length);
                                                deferred.callback(true);
                                        }
                                        store.fetch({onComplete:revertComplete, onError:onError});
                                }
                                store.fetch({onComplete:onCompleteAgain, onError:onError});
                        }
                        store.fetch({onComplete:onComplete, onError:onError});
                        return deferred;
                }
        ]
);



}