ItemFileWriteStore.js
No OneTemporary
Actions

Size

33 KB

Subscribers

None

ItemFileWriteStore.js
View Options

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



	}

File Metadata

Mime Type: text/plain
Expires: Sat, Feb 22, 20:21 (20 h, 41 m ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 27354
Default Alt Text: ItemFileWriteStore.js (33 KB)

ItemFileWriteStore.jsNo OneTemporaryActions

ItemFileWriteStore.jsView Options

File Metadata

Event Timeline

ItemFileWriteStore.js
No OneTemporary
Actions

ItemFileWriteStore.js
View Options