Changeset 12277

Timestamp:

02/04/08 09:09:27 (11 months ago)

Author:

jaredj

Message:

Backport of fix to revert code. fixes #5743 \!strict

Location:

branches/1.0/dojo/trunk

Files:

• data/ItemFileWriteStore.js (modified) (1 diff)
• tests/data/countries_references.json (added)
• tests/data/ItemFileWriteStore.js (modified) (1 diff)
• tests/data/readOnlyItemFileTestTemplates.js (modified) (1 diff)

branches/1.0/dojo/trunk/data/ItemFileWriteStore.js

@@ -463 +463 @@
                         
                         if(modifiedItem[this._rootItemPropName]){
-                                arrayIndex = modifiedItem[this._itemNumPropName];
-                                this._arrayOfTopLevelItems[arrayIndex] = originalItem;
+                                var i;
+                                for (i = 0; i < this._arrayOfTopLevelItems.length; i++) {
+                                        var possibleMatch = this._arrayOfTopLevelItems[i];
+                                        if (this.getIdentity(possibleMatch) == identity){
+                                                this._arrayOfTopLevelItems[i] = originalItem;
+                                                break;
+                                        }
+                                }
                         }
                         if(this._itemsByIdentity){

branches/1.0/dojo/trunk/tests/data/ItemFileWriteStore.js

@@ -380 +380 @@
                         store.fetch({query:{name:"Egypt"}, onComplete: onComplete, onError: onError});
                         return deferred; //Object
+                },
+                function testWriteAPI_deleteAndModifyMultipleItemsAndRevert(){
+                        //      summary: 
+                        //              Simple test to verify that a flow of deleting items and modifying items does not damage the internal structure.
+                        //              Created for tracker bug: #5743
+                        //      description:
+                        //              Simple test to verify that a flow of deleting items and modifying items does not damage the internal structure.
+                        //              Created for tracker bug: #5743
+                
+                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries_references"));
+
+                        var deferred = new doh.Deferred();
+                        var passed = true;
+                        function onError(error, request){
+                                deferred.errback(error);
+                                doh.assertTrue(false);
+                        }
+                        function onItem(item, request){
+                                //Save off the located item, then locate another one (peer to Egypt)
+                                doh.assertTrue(store.isItem(item));
+                                var egypt = item;
+
+                                function onItem2(item, request){
+                                        doh.assertTrue(store.isItem(item));
+                                        var nairobi = item;
+
+                                        function onItem3(item, request){
+                                                doh.assertTrue(store.isItem(item));
+                                                var kenya = item;
+
+                                                //Remove the reference to nairobi before we delete the Narobi item.
+                                                //Basically, force Kenya to be modified top-level.  Since the
+                                                //current impl doesn't 
+                                                var children = store.getValues(kenya, "children");
+                                                var newChildren = [];
+                                                var i;
+                                                for(i = 0; i < children.length; i++){
+                                                        var value = children[i];
+                                                        if(store.isItem(value)){
+                                                                if (store.getIdentity(value) != store.getIdentity(nairobi)){
+                                                                        newChildren.push(value);
+                                                                }
+                                                        }else{
+                                                                newChildren.push(value);
+                                                        }
+                                                }
+                                                store.setValues(kenya, "children", newChildren);
+                                                store.deleteItem(nairobi);
+                                                store.deleteItem(egypt);
+
+                                                try{
+                                                        //Revert, then do a fetch.  If the internals have been damaged, this will generally
+                                                        //cause onError to fire instead of onComplete.
+                                                        store.revert();
+                                                        function onComplete(items, request){
+                                                                deferred.callback(true);
+                                                        }
+                                                        store.fetch({query: {name: "*"}, start: 0, count: 20, onComplete: onComplete, onError: onError});
+                                                }catch(e){
+                                                        deferred.errback(e)
+                                                }
+                                        }
+                                        store.fetchItemByIdentity({identity: "Kenya", onError: onError, onItem: onItem3});
+                                }
+                                store.fetchItemByIdentity({identity: "Nairobi", onError: onError, onItem: onItem2});
+                        }
+                        store.fetchItemByIdentity({identity: "Egypt", onError: onError, onItem: onItem});
+                        return deferred;
                 },
                 function testWriteAPI_save(){

branches/1.0/dojo/trunk/tests/data/readOnlyItemFileTestTemplates.js

@@ -169 +169 @@
                                         };
                 }
+        }else if(name === "countries_references"){
+                if(dojo.isBrowser){
+                        data = {url: dojo.moduleUrl("tests", "data/countries_references.json").toString() };
+                }else{
+                        data = {data: { identifier: 'name',
+                                                        label: 'name',
+                                                        items: [
+                                                                { name:'Africa', type:'continent',
+                                                                        children:[{_reference:'Egypt'}, {_reference:'Kenya'}, {_reference:'Sudan'}] },
+                                                                { name:'Egypt', type:'country' },
+                                                                { name:'Kenya', type:'country',
+                                                                        children:[{_reference:'Nairobi'}, {_reference:'Mombasa'}] },
+                                                                { name:'Nairobi', type:'city' },
+                                                                { name:'Mombasa', type:'city' },
+                                                                { name:'Sudan', type:'country',
+                                                                        children:{_reference:'Khartoum'} },
+                                                                { name:'Khartoum', type:'city' },
+                                                                { name:'Asia', type:'continent',
+                                                                        children:[{_reference:'China'}, {_reference:'India'}, {_reference:'Russia'}, {_reference:'Mongolia'}] },
+                                                                { name:'China', type:'country' },
+                                                                { name:'India', type:'country' },
+                                                                { name:'Russia', type:'country' },
+                                                                { name:'Mongolia', type:'country' },
+                                                                { name:'Australia', type:'continent', population:'21 million',
+                                                                        children:{_reference:'Commonwealth of Australia'}},
+                                                                { name:'Commonwealth of Australia', type:'country', population:'21 million'},
+                                                                { name:'Europe', type:'continent',
+                                                                        children:[{_reference:'Germany'}, {_reference:'France'}, {_reference:'Spain'}, {_reference:'Italy'}] },
+                                                                { name:'Germany', type:'country' },
+                                                                { name:'France', type:'country' },
+                                                                { name:'Spain', type:'country' },
+                                                                { name:'Italy', type:'country' },
+                                                                { name:'North America', type:'continent',
+                                                                        children:[{_reference:'Mexico'}, {_reference:'Canada'}, {_reference:'United States of America'}] },
+                                                                { name:'Mexico', type:'country',  population:'108 million', area:'1,972,550 sq km',
+                                                                        children:[{_reference:'Mexico City'}, {_reference:'Guadalajara'}] },
+                                                                { name:'Mexico City', type:'city', population:'19 million', timezone:'-6 UTC'},
+                                                                { name:'Guadalajara', type:'city', population:'4 million', timezone:'-6 UTC' },
+                                                                { name:'Canada', type:'country',  population:'33 million', area:'9,984,670 sq km',
+                                                                        children:[{_reference:'Ottawa'}, {_reference:'Toronto'}] },
+                                                                { name:'Ottawa', type:'city', population:'0.9 million', timezone:'-5 UTC'},
+                                                                { name:'Toronto', type:'city', population:'2.5 million', timezone:'-5 UTC' },
+                                                                { name:'United States of America', type:'country' },
+                                                                { name:'South America', type:'continent',
+                                                                        children:[{_reference:'Brazil'}, {_reference:'Argentina'}] },
+                                                                { name:'Brazil', type:'country', population:'186 million' },
+                                                                { name:'Argentina', type:'country', population:'40 million' }
+                                                        ]
+                                                }
+                                        };
+                }
         }
         return data;