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;

		}

	]

);

}