Ticket #6073: dojo.data.ItemFileStore_20080501.patch

File dojo.data.ItemFileStore_20080501.patch, 23.9 kB (added by jaredj, 8 months ago)

Patch to add in support for a clearOnClose option which flushes the store's internal cache fo the file and invalidates all open refs.

  • tests/data/readOnlyItemFileTestTemplates.js

     
    21932193                } 
    21942194        }, 
    21952195        { 
     2196                name: "Read API: close (clearOnClose: true)", 
     2197                runTest: function(datastore, t){ 
     2198                        //      summary:  
     2199                        //              Function to test the close api properly clears the store for reload when clearOnClose is set. 
     2200                        if (dojo.isBrowser) { 
     2201                                var params = tests.data.readOnlyItemFileTestTemplates.getTestData("countries"); 
     2202                                params.clearOnClose = true; 
     2203                                params.urlPreventCache = true; 
     2204                                var store = new datastore(params); 
     2205 
     2206                                var d = new doh.Deferred(); 
     2207                                function onItem(item){ 
     2208                                        var error = null; 
     2209                                        try { 
     2210                                                t.assertTrue(item !== null); 
     2211                                                var ec = item; 
     2212                                                var val = store.getValue(ec, "name"); 
     2213                                                t.assertEqual("Ecuador", val); 
     2214 
     2215                                                store.close(); 
     2216                                                //Check some internals here.  Do not normally access these! 
     2217                                                t.assertTrue(store._arrayOfAllItems.length === 0); 
     2218                                                t.assertTrue(store._loadFinished === false); 
     2219                                        }catch (e){ 
     2220                                                error = e; 
     2221                                        } 
     2222                                        if (error) { 
     2223                                                d.errback(error); 
     2224                                        }else{ 
     2225                                                d.callback(true); 
     2226                                        } 
     2227                                } 
     2228                                function onError(errData){ 
     2229                                        d.errback(errData); 
     2230                                } 
     2231                                store.fetchItemByIdentity({identity:"ec", onItem:onItem, onError:onError}); 
     2232                                return d; // Deferred 
     2233                        } 
     2234                } 
     2235        }, 
     2236        { 
     2237                name: "Read API: close (clearOnClose: false)", 
     2238                runTest: function(datastore, t){ 
     2239                        //      summary:  
     2240                        //              Function to test the close api properly clears the store for reload when clearOnClose is set. 
     2241                        if (dojo.isBrowser) { 
     2242                                var params = tests.data.readOnlyItemFileTestTemplates.getTestData("countries"); 
     2243                                params.urlPreventCache = true; 
     2244                                var store = new datastore(params); 
     2245 
     2246                                var d = new doh.Deferred(); 
     2247                                function onItem(item){ 
     2248                                        var error = null; 
     2249                                        try { 
     2250                                                t.assertTrue(item !== null); 
     2251                                                var ec = item; 
     2252                                                var val = store.getValue(ec, "name"); 
     2253                                                t.assertEqual("Ecuador", val); 
     2254 
     2255                                                store.close(); 
     2256                                                //Check some internals here.  Do not normally access these! 
     2257                                                t.assertTrue(store._arrayOfAllItems.length !== 0); 
     2258                                                t.assertTrue(store._loadFinished === true); 
     2259                                        }catch (e){ 
     2260                                                error = e; 
     2261                                        } 
     2262                                        if (error) { 
     2263                                                d.errback(error); 
     2264                                        }else{ 
     2265                                                d.callback(true); 
     2266                                        } 
     2267                                } 
     2268                                function onError(errData){ 
     2269                                        d.errback(errData); 
     2270                                } 
     2271                                store.fetchItemByIdentity({identity:"ec", onItem:onItem, onError:onError}); 
     2272                                return d; // Deferred 
     2273                        } 
     2274                } 
     2275        }, 
     2276        { 
    21962277                name: "Identity API: no_identifier_specified", 
    21972278                runTest: function(datastore, t){ 
    21982279                        var arrayOfItems = [ 

  • tests/data/ItemFileWriteStore.js

     
    4040                                                {"id": 15, "name": "item 15", "friends": [{"id": 16, "name": "Item 16"}]} 
    4141                                        ] 
    4242                                } 
    43                         } 
     43                        }; 
    4444                } 
    4545        } 
    4646        return data; 
    … …  
    6060                        var features = store.getFeatures();  
    6161 
    6262                        // make sure we have the expected features: 
    63                         doh.assertTrue(features["dojo.data.api.Read"] != null); 
    64                         doh.assertTrue(features["dojo.data.api.Identity"] != null); 
    65                         doh.assertTrue(features["dojo.data.api.Write"] != null); 
    66                         doh.assertTrue(features["dojo.data.api.Notification"] != null); 
     63                        doh.assertTrue(features["dojo.data.api.Read"] !== null); 
     64                        doh.assertTrue(features["dojo.data.api.Identity"] !== null); 
     65                        doh.assertTrue(features["dojo.data.api.Write"] !== null); 
     66                        doh.assertTrue(features["dojo.data.api.Notification"] !== null); 
    6767                        doh.assertFalse(features["iggy"]); 
    6868                         
    6969                        // and only the expected features: 
    … …  
    8585                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries")); 
    8686 
    8787                        var deferred = new doh.Deferred(); 
    88                         function onComplete(items, request){ 
     88                        var onComplete = function(items, request){ 
    8989                                doh.assertEqual(1, items.length); 
    9090                                var item = items[0]; 
    9191                                doh.assertTrue(store.containsValue(item, "capital", "Cairo")); 
    … …  
    9494                                //    Okay, so this seems very odd.  Maybe I'm just being dense. 
    9595                                //    These tests works: 
    9696                                doh.assertEqual(store.isDirty(item), false); 
    97                                 doh.assertTrue(store.isDirty(item) == false); 
     97                                doh.assertTrue(store.isDirty(item) === false); 
    9898                                //    But these seemingly equivalent tests will not work: 
    9999                                // doh.assertFalse(store.isDirty(item)); 
    100100                                // doh.assertTrue(!(store.isDirty(item))); 
    … …  
    102102                                //    All of which seems especially weird, given that this *does* work: 
    103103                                doh.assertFalse(store.isDirty()); 
    104104                                 
    105                                  
    106                                 doh.assertTrue(store.isDirty(item) == false); 
     105                                doh.assertTrue(store.isDirty(item) === false); 
    107106                                doh.assertTrue(!store.isDirty()); 
    108107                                store.setValue(item, "capital", "New Cairo"); 
    109108                                doh.assertTrue(store.isDirty(item)); 
    110109                                doh.assertTrue(store.isDirty()); 
    111110                                doh.assertEqual(store.getValue(item, "capital").toString(), "New Cairo"); 
    112111                                deferred.callback(true); 
    113                         } 
    114                         function onError(error, request){ 
     112                        }; 
     113                        var onError = function(error, request){ 
    115114                                deferred.errback(error); 
    116                         } 
     115                        }; 
    117116                        store.fetch({query:{name:"Egypt"}, onComplete: onComplete, onError: onError}); 
    118117                        return deferred; //Object 
    119118                }, 
    … …  
    129128                                doh.assertEqual(1, items.length); 
    130129                                var item = items[0]; 
    131130                                doh.assertTrue(store.containsValue(item, "name", "Egypt")); 
    132                                 doh.assertTrue(store.isDirty(item) == false); 
     131                                doh.assertTrue(store.isDirty(item) === false); 
    133132                                doh.assertTrue(!store.isDirty()); 
    134133                                store.setValues(item, "name", ["Egypt 1", "Egypt 2"]); 
    135134                                doh.assertTrue(store.isDirty(item)); 
    … …  
    157156                                doh.assertEqual(1, items.length); 
    158157                                var item = items[0]; 
    159158                                doh.assertTrue(store.containsValue(item, "name", "Egypt")); 
    160                                 doh.assertTrue(store.isDirty(item) == false); 
     159                                doh.assertTrue(store.isDirty(item) === false); 
    161160                                doh.assertTrue(!store.isDirty()); 
    162161                                store.unsetAttribute(item, "name"); 
    163162                                doh.assertTrue(store.isDirty(item)); 
    … …  
    216215 
    217216                        var deferred = new doh.Deferred(); 
    218217                        doh.assertTrue(!store.isDirty()); 
    219                         function onComplete(items, request){ 
     218 
     219                        var onError = function(error, request){ 
     220                                deferred.errback(error); 
     221                        }; 
     222 
     223                        var onComplete = function(items, request){ 
    220224                                doh.assertEqual(1, items.length); 
    221225                                var item = items[0]; 
    222226                                doh.assertTrue(store.containsValue(item, "name", "Egypt")); 
    … …  
    236240                                        doh.assertTrue(false); 
    237241                                }; 
    238242 
     243 
     244 
    239245                                //See if we can add in a new item representing the city of Cairo. 
    240246                                //This should also call the onNew set above.... 
    241247                                var newItem = store.newItem({name: "Cairo", abbr: "Cairo"}, {parent: item, attribute: "cities"}); 
    … …  
    254260                                } 
    255261                                //Do a shallow search first, should find nothing. 
    256262                                store.fetch({query:{name:"Cairo"}, onComplete: onCompleteNewItemShallow, onError: onError}); 
    257                         } 
    258                         function onError(error, request){ 
    259                                 deferred.errback(error); 
    260                         } 
     263                        }; 
    261264                        store.fetch({query:{name:"Egypt"}, onComplete: onComplete, onError: onError}); 
    262265                        return deferred; //Object 
    263266                }, 
    … …  
    335338                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries")); 
    336339 
    337340                        var deferred = new doh.Deferred(); 
    338                         function onComplete(items, request){ 
     341 
     342                        var onError = function(error, request){ 
     343                                deferred.errback(error); 
     344                        }; 
     345 
     346                        var onComplete = function(items, request){ 
    339347                                doh.assertEqual(1, items.length); 
    340348                                var item = items[0]; 
    341349                                doh.assertTrue(store.containsValue(item, "name", "Egypt")); 
    342                                 doh.assertTrue(store.isDirty(item) == false); 
     350                                doh.assertTrue(store.isDirty(item) === false); 
    343351                                doh.assertTrue(!store.isDirty()); 
    344352                                store.deleteItem(item); 
    345353                                doh.assertTrue(store.isDirty(item)); 
    346354                                doh.assertTrue(store.isDirty()); 
    347                                 function onCompleteToo(itemsToo, requestToo) { 
     355                                var onCompleteToo = function(itemsToo, requestToo) { 
    348356                                        doh.assertEqual(0, itemsToo.length); 
    349357                                        deferred.callback(true); 
    350                                 } 
     358                                }; 
    351359                                store.fetch({query:{name:"Egypt"}, onComplete: onCompleteToo, onError: onError}); 
    352                         } 
    353                         function onError(error, request){ 
    354                                 deferred.errback(error); 
    355                         } 
     360                        }; 
    356361                        store.fetch({query:{name:"Egypt"}, onComplete: onComplete, onError: onError}); 
    357362                        return deferred; //Object 
    358363                }, 
    … …  
    387392                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries")); 
    388393 
    389394                        var deferred = new doh.Deferred(); 
    390                         function onComplete(items, request) { 
     395 
     396                        var onError = function(error, request){ 
     397                                deferred.errback(error); 
     398                        }; 
     399 
     400                        var onComplete = function(items, request) { 
    391401                                doh.assertEqual(1, items.length); 
    392402                                var item = items[0]; 
    393403                                doh.assertTrue(store.containsValue(item, "name", "Egypt")); 
    394                                 doh.assertTrue(store.isDirty(item) == false); 
     404                                doh.assertTrue(store.isDirty(item) === false); 
    395405                                doh.assertTrue(!store.isDirty()); 
    396406                                store.setValue(item, "name", "Egypt 2"); 
    397407                                doh.assertTrue(store.getValue(item, "name") == "Egypt 2"); 
    … …  
    400410                                store.revert(); 
    401411                                 
    402412                                //Fetch again to see if it reset the state. 
    403                                 function onCompleteToo(itemsToo, requestToo){ 
     413                                var onCompleteToo = function(itemsToo, requestToo){ 
    404414                                        doh.assertEqual(1, itemsToo.length); 
    405415                                        var itemToo = itemsToo[0]; 
    406416                                        doh.assertTrue(store.containsValue(itemToo, "name", "Egypt")); 
    407417                                        deferred.callback(true); 
    408                                 } 
     418                                }; 
    409419                                store.fetch({query:{name:"Egypt"}, onComplete: onCompleteToo, onError: onError}); 
    410                         } 
    411                         function onError(error, request){ 
    412                                 deferred.errback(error); 
    413                         } 
     420                        }; 
    414421                        store.fetch({query:{name:"Egypt"}, onComplete: onComplete, onError: onError}); 
    415422                        return deferred; //Object 
    416423                }, 
    … …  
    466473                        //              Simple test of the save API 
    467474                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries")); 
    468475                        var egypt; 
     476 
     477                        var deferred = new doh.Deferred(); 
     478                        var onError = function(error){ 
     479                                deferred.errback(error); 
     480                        }; 
     481 
    469482                        store._saveEverything = function(saveCompleteCallback, saveFailedCallback, newFileContentString){ 
    470483                                var struct = dojo.fromJson(newFileContentString); 
    471484                                doh.assertEqual(struct.identifier, store.getIdentityAttributes(egypt)[0]); 
    … …  
    473486                                doh.assertEqual(struct.items.length, 7); 
    474487                                 
    475488                                var cloneStore = new dojo.data.ItemFileWriteStore({data:struct}); 
    476                                 function onItemClone(itemClone){ 
     489                                var onItemClone = function(itemClone){ 
    477490                                        var egyptClone = itemClone; 
    478491                                        doh.assertEqual(store.getIdentityAttributes(egypt)[0], cloneStore.getIdentityAttributes(egyptClone)[0]); 
    479492                                        doh.assertEqual(store.getLabelAttributes(egypt)[0], cloneStore.getLabelAttributes(egyptClone)[0]); 
    480493                                        doh.assertEqual(store.getValue(egypt, "name"), cloneStore.getValue(egyptClone, "name")); 
    481                                 } 
     494                                }; 
    482495                                cloneStore.fetchItemByIdentity({identity:"eg", onItem:onItemClone, onError:onError}); 
    483                                  
    484496                                saveCompleteCallback(); 
    485497                        }; 
    486  
    487                         var deferred = new doh.Deferred(); 
    488                         function onError(error){ 
    489                                 deferred.errback(error); 
    490                         } 
    491                         function onItem(item){ 
     498                        var onItem = function(item){ 
    492499                                egypt = item; 
    493                                 function onComplete() { 
     500                                var onComplete = function() { 
    494501                                        deferred.callback(true); 
    495                                 } 
     502                                }; 
    496503                                store.setValue(egypt, "capital", "New Cairo"); 
    497504                                store.save({onComplete:onComplete, onError:onError}); 
    498                         } 
     505                        }; 
    499506                        store.fetchItemByIdentity({identity:"eg", onItem:onItem, onError:onError}); 
    500507                        return deferred; //Object 
    501508                }, 
    … …  
    505512                        //      description: 
    506513                        //              Simple test of the save API     with a non-atomic type (Date) that has a type mapping. 
    507514                        var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries")); 
     515                         
     516                        var deferred = new doh.Deferred(); 
    508517                        store._saveEverything = function(saveCompleteCallback, saveFailedCallback, newFileContentString){ 
    509518 
    510519                                //Now load the new data into a datastore and validate that it stored the date right. 
    … …  
    514523                                function gotItem(item){ 
    515524                                        var independenceDate = newStore.getValue(item,"independence");  
    516525                                        doh.assertTrue(independenceDate instanceof Date); 
    517                                         doh.assertTrue(dojo.date.compare(new Date(1993,04,24), independenceDate, "date") === 0); 
     526                                        doh.assertTrue(dojo.date.compare(new Date(1993,4,24), independenceDate, "date") === 0); 
    518527                                        saveCompleteCallback(); 
    519528                                } 
    520529                                function failed(error, request){ 
    … …  
    524533                                newStore.fetchItemByIdentity({identity:"eg", onItem:gotItem, onError:failed}); 
    525534                        }; 
    526535 
    527                         var deferred = new doh.Deferred(); 
    528                         function onError(error){ 
     536                        var onError = function(error){ 
    529537                                deferred.errback(error); 
    530                         } 
    531                         function onItem(item){ 
    532                                 function onComplete() { 
     538                        }; 
     539                        var onItem = function(item){ 
     540                                var onComplete = function() { 
    533541                                        deferred.callback(true); 
    534                                 } 
    535                                 store.setValue(item, "independence", new Date(1993,04,24)); 
     542                                }; 
     543                                store.setValue(item, "independence", new Date(1993,4,24)); 
    536544                                store.save({onComplete:onComplete, onError:onError}); 
    537                         } 
     545                        }; 
    538546                        store.fetchItemByIdentity({identity:"eg", onItem:onItem, onError:onError}); 
    539547                        return deferred; //Object 
    540548                }, 
    … …  
    562570                                        typeMap: customTypeMap 
    563571                        }); 
    564572                         
     573                        var deferred = new doh.Deferred(); 
    565574                        store._saveEverything = function(saveCompleteCallback, saveFailedCallback, newFileContentString){ 
    566575                                //Now load the new data into a datastore and validate that it stored the Color right. 
    567576                                var dataset = dojo.fromJson(newFileContentString); 
    568577                                var newStore = new dojo.data.ItemFileWriteStore({data: dataset, typeMap: customTypeMap}); 
    569578 
     579                                var deferred = new doh.Deferred(); 
    570580                                function gotItem(item){ 
    571581                                        var hairColor = newStore.getValue(item,"hairColor");  
    572582                                        doh.assertTrue(hairColor instanceof dojo.Color); 
    … …  
    581591                        }; 
    582592 
    583593                        //Add a new item with a color type, then save it. 
    584                         var deferred = new doh.Deferred(); 
    585                         function onError(error){ 
     594            var onError = function(error){ 
    586595                                deferred.errback(error); 
    587                         } 
    588                         function onComplete() { 
     596                        }; 
     597                        var onComplete = function() { 
    589598                                deferred.callback(true); 
    590                         } 
     599                        }; 
    591600 
    592601                        var animal = store.newItem({name: "Animal", hairColor: new dojo.Color("yellow")}); 
    593602                        store.save({onComplete:onComplete, onError:onError}); 
    … …  
    619628                                                                                                        return obj.toString(); 
    620629                                                                                                } 
    621630                                                                                        } 
    622                                                                 } 
     631                                                                }; 
    623632                        var store = new dojo.data.ItemFileWriteStore({ 
    624633                                        data:dataset, 
    625634                                        typeMap: customTypeMap 
    626635                        }); 
     636                         
     637                        var deferred = new doh.Deferred(); 
    627638                        store._saveEverything = function(saveCompleteCallback, saveFailedCallback, newFileContentString){ 
    628639                                //Now load the new data into a datastore and validate that it stored the Color right. 
    629640                                var dataset = dojo.fromJson(newFileContentString); 
    630641                                var newStore = new dojo.data.ItemFileWriteStore({data: dataset, typeMap: customTypeMap}); 
    631642 
    632                                 function gotItem(item){ 
     643                                var gotItem = function(item){ 
    633644                                        var hairColor = newStore.getValue(item,"hairColor");  
    634645                                        doh.assertTrue(hairColor instanceof dojo.Color); 
    635646                                        doh.assertEqual("rgba(255, 255, 0, 1)", hairColor.toString()); 
    636647                                        saveCompleteCallback(); 
    637                                 } 
    638                                 function failed(error, request){ 
     648                                }; 
     649                                var failed = function(error, request){ 
    639650                                        deferred.errback(error); 
    640651                                        saveFailedCallback(); 
    641                                 } 
     652                                }; 
    642653                                newStore.fetchItemByIdentity({identity:"Animal", onItem:gotItem, onError:failed}); 
    643654                        }; 
    644655 
    645656                        //Add a new item with a color type, then save it. 
    646                         var deferred = new doh.Deferred(); 
    647                         function onError(error){ 
     657            var onError = function(error){ 
    648658                                deferred.errback(error); 
    649                         } 
    650                         function onComplete() { 
     659                        }; 
     660                        var onComplete = function() { 
    651661                                deferred.callback(true); 
    652                         } 
     662                        }; 
    653663 
    654664                        var animal = store.newItem({name: "Animal", hairColor: new dojo.Color("yellow")}); 
    655665                        store.save({onComplete:onComplete, onError:onError}); 
    … …  
    742752                                var egypt = fetchedItem; 
    743753                                var connectHandle = null; 
    744754                                function deleteItemHandler(item){ 
    745                                         doh.assertTrue(store.isItem(item) == false); 
     755                                        doh.assertTrue(store.isItem(item) === false); 
    746756                                        doh.assertTrue(item == egypt); 
    747757                                        deferred.callback(true); 
    748758                                        dojo.disconnect(connectHandle); 
    … …  
    840850                         
    841851                        var onError = function(error, request){ 
    842852                                deferred.errback(error); 
    843                         } 
     853                        }; 
    844854                        var onComplete = function(items, request){ 
    845855                                doh.assertEqual(7, items.length); 
    846856                                 
    … …  
    864874