Plato - dojo/testsDOH/data/ItemFileWriteStore.js

// FIXME: this test assumes the existence of the global object "tests"
define([
  "dojo/main",
  "doh/main",
  "require",
  "./readOnlyItemFileTestTemplates",
  "dojo/data/ItemFileWriteStore",
  "dojo/data/api/Read",
  "dojo/data/api/Identity",
  "dojo/data/api/Write",
  "dojo/data/api/Notification"], function(dojo, doh, require){

dojo.getObject("data.ItemFileWriteStore", true, tests);

// 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");

tests.data.ItemFileWriteStore.getTestData = function(name){
	var data = {};
	if(name === "reference_integrity"){
		if(dojo.isBrowser){
			data = {url: require.toUrl("./reference_integrity.json")};
		}else{
			data =
				{ data: {
					"identifier": "id",
					"label": "name",
					"items": [
						{"id": 1, "name": "Item 1"},
						{"id": 2, "name": "Item 2"},
						{"id": 3, "name": "Item 3"},
						{"id": 4, "name": "Item 4"},
						{"id": 5, "name": "Item 5"},
						{"id": 6, "name": "Item 6"},
						{"id": 7, "name": "Item 7"},
						{"id": 8, "name": "Item 8"},
						{"id": 9, "name": "Item 9"},
						{"id": 10, "name": "Item 10", "friends": [{"_reference": 1},{"_reference": 3},{"_reference": 5}]},
						{"id": 11, "name": "Item 11", "friends": [{"_reference": 10}], "siblings": [{"_reference": 10}]},
						{"id": 12, "name": "Item 12", "friends": [{"_reference": 3},{"_reference": 7}], "enemies": [{"_reference": 10}]},
						{"id": 13, "name": "Item 13", "friends": [{"_reference": 10}]},
						{"id": 14, "name": "Item 14", "friends": [{"_reference": 11}]},
						{"id": 15, "name": "item 15", "friends": [{"id": 16, "name": "Item 16"}]}
					]
				}
			};
		}
	}
	return data;
};

// Now run some tests that are specific to the write-access features:
doh.register("testsDOH.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();
			var onComplete = function(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);
			};
			var onError = function(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();
			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());

var onError = function(error, request){
				deferred.errback(error);
			};

var onComplete = function(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 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"});

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();

var onError = function(error, request){
				deferred.errback(error);
			};

var deferred = new doh.Deferred();

var onError = function(error, request){
				deferred.errback(error);
			};

//Fetch again to see if it reset the state.
				var onCompleteToo = function(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});
			};
			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();
			var onError = function(error){
				deferred.errback(error);
			};

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 deferred = new doh.Deferred();
			var onError = function(error){
				deferred.errback(error);
			};

store._saveEverything = function(saveCompleteCallback, saveFailedCallback, newFileContentString){
				var struct = dojo.fromJson(newFileContentString);
				doh.assertEqual(struct.items.length, 3);
				var cloneStore = new dojo.data.ItemFileWriteStore({data:struct, hierarchical: false});
				var onItemClone = function(items, request){
					var africaClone = items[0];
					doh.assertEqual(store.getValue(africa, "name"), cloneStore.getValue(africaClone, "name"));
				};
				cloneStore.fetch({query: {name:"Africa"}, onComplete:onItemClone, onError:onError, queryOptions: {deep: true}});
				saveCompleteCallback();
			};
			var onComplete = function(items, request){
				africa = items[0];
				var onComplete = function(){
					deferred.callback(true);
				};
				store.setValue(africa, "size", "HUGE!");
				store.save({onComplete:onComplete, onError:onError});
			};
			store.fetch({query: {name:"Africa"}, onComplete:onComplete, onError:onError, queryOptions: {deep: true}});
			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"));

var deferred = new doh.Deferred();
			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});

//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
			});

var deferred = new doh.Deferred();
			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});

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

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

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 testWriteAPI_new_modify_revert(){
			// summary:
			//		Test of a new item, modify it, then revert, to ensure the state remains consistent.  Added due to #9022.
			// description:
			//		Test of a new item, modify it, then revert, to ensure the state remains consistent.  Added due to #9022.
			var store = new dojo.data.ItemFileWriteStore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

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

var onError = function(error, request){
				deferred.errback(error);
			};

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

var onError = function(error, request){
				deferred.errback(error);
			};

// check that after new and modify, the total items count goes up by one.
				var afterNewFetch = function(items, request){
					var afterNewCount = items.length;
					doh.assertEqual(afterNewCount, (initialCount + 1));
					store.deleteItem(canada);

//Check that after delete, the total items count goes back to initial count.
					//Also verify the item with abbr of ca is gone.
					var afterDeleteFetch = function(items, request){
						var afterDeleteCount = items.length;
						doh.assertEqual(initialCount, afterDeleteCount);

for(i=0; i < items.length; i++){
							found = (store.getIdentity(items[i]) === "ca");
							if(found){
								break;
							}
						}
						if(found){
							deferred.errback(new Error("Error: Found the supposedly deleted item!"));
						}else{
							store.revert();
							//Check that after revert, we still have the same item count as the
							//original fetch.  Also verify the item with abbr of ca is gone.
							var afterRevertFetch = function(items, request){
								var afterRevertCount = items.length;
								doh.assertEqual(afterRevertCount, initialCount);
								for(i=0; i < items.length; i++){
									found = (store.getIdentity(items[i]) === "ca");
									if(found){
										break;
									}
								}
								if(found){
									deferred.errback(new Error("Error: Found the 'new' item after revert!"));
								}else{
									deferred.callback(true);
								}
							};
							store.fetch({onComplete: afterRevertFetch, onError: onError});
						}
					};
					store.fetch({onComplete: afterDeleteFetch, onError: onError});
				};
				store.fetch({onComplete: afterNewFetch, onError: onError});
			};
			store.fetch({onComplete: initialFetch, onError: onError});
			return deferred; //Object
		},
		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"));

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'});

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'});

//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;
		},
		function testReferenceIntegrity_checkReferences(){
			// summary:
			//		Simple test to verify the references were properly resolved.
			// description:
			//		Simple test to verify the references were properly resolved.

var store = new dojo.data.ItemFileWriteStore(tests.data.ItemFileWriteStore.getTestData("reference_integrity"));

var deferred = new doh.Deferred();
			var onError = function(error, request){
				deferred.errback(error);
			};
			var onComplete = function(items, request){

var item10 = null;
				var item1  = null;
				var item3  = null;
				var item5  = null;

var i;
				for (i = 0; i < items.length; i++){
					var ident = store.getIdentity(items[i]);
					if (ident === 10){
						item10 = items[i];
					}else if (ident === 1){
						item1 = items[i];
					}else if (ident === 3){
						item3 = items[i];
					}else if (ident === 5){
						item5 = items[i];
					}
				}
				var friends = store.getValues(item10, "friends");
				doh.assertTrue(friends !== null);
				doh.assertTrue(friends !== undefined);

doh.assertTrue(store.isItem(item10));
				doh.assertTrue(store.isItem(item1));
				doh.assertTrue(store.isItem(item3));
				doh.assertTrue(store.isItem(item5));
				var found = 0;
				try{
					for (i = 0; i < friends.length; i++){
						if (i === 0){
							doh.assertTrue(store.isItem(friends[i]));
							doh.assertEqual(friends[i], item1);
							doh.assertEqual(store.getIdentity(friends[i]), 1);
							found++;
						}else if (i === 1){
							doh.assertTrue(store.isItem(friends[i]));
							doh.assertEqual(friends[i], item3);
							doh.assertEqual(store.getIdentity(friends[i]), 3);
							found++;
						}else if (i === 2){
							doh.assertTrue(store.isItem(friends[i]));
							doh.assertEqual(friends[i], item5);
							doh.assertEqual(store.getIdentity(friends[i]), 5);
							found++;
						}
					}
				}catch(e){
					doh.errback(e);
				}
				doh.assertEqual(3, found);
				deferred.callback(true);
			};
			store.fetch({onError: onError, onComplete: onComplete});
			return deferred;
		},
		function testReferenceIntegrity_deleteReferencedItem(){
			// summary:
			//		Simple test to verify the references were properly deleted.
			// description:
			//		Simple test to verify the references were properly deleted.

var store = new dojo.data.ItemFileWriteStore(tests.data.ItemFileWriteStore.getTestData("reference_integrity"));

var store = new dojo.data.ItemFileWriteStore(tests.data.ItemFileWriteStore.getTestData("reference_integrity"));

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;

//Delete them
					store.deleteItem(egypt);
					store.deleteItem(nairobi);
					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: "Nairobi", onError: onError, onItem: onItem2});
			}
			store.fetchItemByIdentity({identity: "Egypt", onError: onError, onItem: onItem});
			return deferred;
		},
		function testReferenceIntegrity_removeReferenceFromAttribute(){
			// summary:
			//		Simple test to verify the reference removal updates the internal map.
			// description:
			//		Simple test to verify the reference removal updates the internal map.

var store = new dojo.data.ItemFileWriteStore(tests.data.ItemFileWriteStore.getTestData("reference_integrity"));

function onItem2(item10, request){
						//DO NOT EVER ACCESS THESE VARIABLES LIKE THIS!
						//THIS IS FOR TESTING INTERNAL STATE!
						var refMap = item10[store._reverseRefMap];
						store._dumpReferenceMap();

console.log("MAP for Item 10 is: " + dojo.toJson(refMap));

//Assert there is no reference to item 10 in item 11's attribute 'friends'.
						doh.assertTrue(!refMap["11"]["friends"]);
						store.setValues(item, "siblings", [0, 1, 2]);
						//Assert there are no more references to 10 in 11.  Ergo, "11"  should be a 'undefined' attribute for the map of items referencing '10'..
						doh.assertTrue(!refMap["11"]);
						deferred.callback(true);
					}
					store.fetchItemByIdentity({identity: 10, onError: onError, onItem: onItem2});

}catch(e){
					console.debug(e);
					deferred.errback(e);
					doh.assertTrue(false);
				}
			}
			store.fetchItemByIdentity({identity: 11, onError: onError, onItem: onItem});
			return deferred;
		},
		function testReferenceIntegrity_deleteReferencedItemNonParent(){
			// summary:
			//		Simple test to verify the references to a non-parent item was properly deleted.
			// description:
			//		Simple test to verify the references to a non-parent item was properly deleted.

var store = new dojo.data.ItemFileWriteStore(tests.data.ItemFileWriteStore.getTestData("reference_integrity"));

var store = new dojo.data.ItemFileWriteStore(tests.data.ItemFileWriteStore.getTestData("reference_integrity"));

var deferred = new doh.Deferred();
			var passed = true;
			function onError(error, request){
				deferred.errback(error);
				doh.assertTrue(false);
			}
			function onComplete(items, request){

doh.assertTrue(items.length > 2);

var item1 = items[0];
				var item2 = items[1];

//DO NOT EVER ACCESS THESE VARIABLES LIKE THIS!
				//THIS IS FOR TESTING INTERNAL STATE!
				console.log("Map state for Item 1 is: " + dojo.toJson(item1[store._reverseRefMap]));
				console.log("Map state for Item 2 is: " + dojo.toJson(item2[store._reverseRefMap]));

store.setValue(item1, "siblings", item2);

//Emit the current map state for inspection.
				console.log("Map state for Item 1 is: " + dojo.toJson(item1[store._reverseRefMap]));
				console.log("Map state for Item 2 is: " + dojo.toJson(item2[store._reverseRefMap]));

doh.assertTrue(item2[store._reverseRefMap] !== null);

//Assert there is a recorded reference to item 2 in item 1's attribute 'sibling'.
				doh.assertTrue(item2[store._reverseRefMap][store.getIdentity(item1)]["siblings"]);

deferred.callback(true);
			}
			store.fetch({onError: onError, onComplete: onComplete});
			return deferred;
		},
		function testReferenceIntegrity_newItemWithParentReference(){
			// summary:
			//		Simple test to verify that newItems with a parent properly record the parent's reference in the map.
			// description:
			//		Simple test to verify that newItems with a parent properly record the parent's reference in the map.

var store = new dojo.data.ItemFileWriteStore(tests.data.ItemFileWriteStore.getTestData("reference_integrity"));

//DO NOT EVER ACCESS THESE VARIABLES LIKE THIS!
					//THIS IS FOR TESTING INTERNAL STATE!
					//Look up the references to 17, as item 10 has one now on attribute 'uncles'
					var refs = newItem[store._reverseRefMap];

//Assert there is a reference from 10 to item 17, on attribute uncle
					doh.assertTrue(refs["10"]["uncles"]);

console.log("State of map of item 17 after newItem: " + dojo.toJson(refs));
				}catch(e){
					console.debug(e);
					deferred.errback(e);
					doh.assertTrue(false);
					passed = false;
				}
				if(passed){
					deferred.callback(true);
				}
			}
			store.fetchItemByIdentity({identity: 10, onError: onError, onItem: onItem});
			return deferred;
		},
		function testReferenceIntegrity_newItemWithReferenceToExistingItem(){
			// summary:
			//		Simple test to verify that a new item with references to existing items properly record the references in the map.
			// description:
			//		Simple test to verify that a new item with references to existing items properly record the references in the map.

var store = new dojo.data.ItemFileWriteStore(tests.data.ItemFileWriteStore.getTestData("reference_integrity"));

var deferred = new doh.Deferred();
			var passed = true;
			function onError(error, request){
				deferred.errback(error);
				doh.assertTrue(false);
			}
			function onItem(item, request){
				try{
					//DO NOT EVER ACCESS THESE VARIABLES LIKE THIS!
					//THIS IS FOR TESTING INTERNAL STATE!
					console.log("State of reference map to item 10 before newItem: " + dojo.toJson(item[store._reverseRefMap]));

//Create a new item and set its parent to item 10's uncle attribute.
					var newItem = store.newItem({id: 17, name: "Item 17", friends: [item]});

//DO NOT EVER ACCESS THESE VARIABLES LIKE THIS!
					//THIS IS FOR TESTING INTERNAL STATE!
					//Look up the references to 10, as item 17 has one on friends now.
					var refs = item[store._reverseRefMap];

//Assert there is a reference from 15 to item 10, on attribute friends
					doh.assertTrue(refs["17"]["friends"]);

console.log("State of reference map to item 10 after newItem: " + dojo.toJson(refs));
				}catch(e){
					console.debug(e);
					deferred.errback(e);
					doh.assertTrue(false);
					passed = false;
				}
				if(passed){
					deferred.callback(true);
				}
			}
			store.fetchItemByIdentity({identity: 10, onError: onError, onItem: onItem});
			return deferred;
		},
		function testReferenceIntegrity_disableReferenceIntegrity(){
			// summary:
			//		Simple test to verify reference integrity can be disabled.
			// description:
			//		Simple test to verify reference integrity can be disabled.

var params = tests.data.ItemFileWriteStore.getTestData("reference_integrity");
			params.referenceIntegrity = false;
			var store = new dojo.data.ItemFileWriteStore(params);

var d = new doh.Deferred();
				var onItem = function(item){
					var error = null;
					try {
						doh.assertTrue(item !== null);
						var ec = item;
						var val = store.getValue(ec, "name");
						doh.assertEqual("Ecuador", val);
						var newItem = store.newItem({abbr: "foo", name: "bar"});

//Should throw an error...
						store.close();
					}catch (e){
						error = e;
					}
					if (error === null){
						d.errback(new Error("Store was dirty, should have thrown an error on close!"));
					}else{
						d.callback(true);
					}
				};
				var onError = function(errData){
					d.errback(errData);
				};
				store.fetchItemByIdentity({identity:"ec", onItem:onItem, onError:onError});
				return d; // Deferred
			}
		}
	]
);

});

dojo/testsDOH/data/ItemFileWriteStore.js

Maintainability

Lines of code

Difficulty

Estimated Errors

Function weight

By Complexity

By SLOC