Context Navigation

source: Dev/trunk/src/client/dojo/tests/data/readOnlyItemFileTestTemplates.js

Last change on this file was 483, checked in by hendrikvanantwerpen, 11 years ago
Added Dojo 1.9.3 release.
File size: 97.6 KB

Rev	Line
[483]	1	// FIXME: this test assumes the existence of the global object "tests"
	2	define(["dojo/main", "doh/main", "require", "dojo/data/api/Read", "dojo/data/api/Identity", "dojo/date", "dojo/date/stamp"], function(dojo, doh, require){
	3
	4	dojo.getObject("data.readOnlyItemFileTestTemplates", true, tests);
	5
	6	dojo.declare("tests.data.Wrapper", null, {
	7	// summary:
	8	// Simple class to use for typeMap in order to test out
	9	// 'falsy' values for _value.
	10	_wrapped: null,
	11
	12	constructor: function(obj){
	13	this._wrapped = obj;
	14	},
	15
	16	getValue: function(){
	17	return this._wrapped;
	18	},
	19
	20	setValue: function(obj){
	21	this._wrapped = obj;
	22	},
	23
	24	toString: function(){
	25	return "WRAPPER: [" + this._wrapped + "]";
	26	}
	27	});
	28
	29
	30	tests.data.readOnlyItemFileTestTemplates.registerTestsForDatastore = function(/* String */ datastoreClassName){
	31	// summary:
	32	// Given the name of a datastore class to use, this function creates
	33	// a set of unit tests for that datastore, and registers the new test
	34	// group with the doh test framework. The new unit tests are based
	35	// on a set of "template" unit tests.
	36	var datastoreClass = dojo.getObject(datastoreClassName);
	37	var testTemplates = tests.data.readOnlyItemFileTestTemplates.testTemplates;
	38	var testsForDatastore = [];
	39	var makeNewTestFunction = function(template){
	40	return function(t){return template.runTest(datastoreClass, t);};
	41	};
	42	for(var i = 0; i < testTemplates.length; ++i){
	43	var testTemplate = testTemplates[i];
	44	var test = {};
	45	test.name = testTemplate.name;
	46	test.runTest = makeNewTestFunction(testTemplate);
	47	testsForDatastore.push(test);
	48	}
	49	var testGroupName = "IFSCommonTests: " + datastoreClassName;
	50	doh.register(testGroupName, testsForDatastore);
	51	};
	52
	53
	54	//-----------------------------------------------------
	55	// testFile data-sets
	56	tests.data.readOnlyItemFileTestTemplates.getTestData = function(name){
	57	var data = null;
	58	if(name === "countries"){
	59	if(dojo.isBrowser){
	60	data = {url: require.toUrl("./countries.json")};
	61	}else{
	62	data = {data: {
	63	identifier:"abbr",
	64	label:"name",
	65	items:[
	66	{abbr:"ec", name:"Ecuador", capital:"Quito"},
	67	{abbr:'eg', name:'Egypt', capital:'Cairo'},
	68	{abbr:'sv', name:'El Salvador', capital:'San Salvador'},
	69	{abbr:'gq', name:'Equatorial Guinea', capital:'Malabo'},
	70	{abbr:'er', name:'Eritrea', capital:'Asmara'},
	71	{abbr:'ee', name:'Estonia', capital:'Tallinn'},
	72	{abbr:'et', name:'Ethiopia', capital:'Addis Ababa'}
	73	]
	74	} };
	75	}
	76	}else if(name === "countries_withNull"){
	77	if(dojo.isBrowser){
	78	data = {url: require.toUrl("./countries_withNull.json")};
	79	}else{
	80	data = {data: {
	81	identifier:"abbr",
	82	items:[
	83	{abbr:"ec", name:null, capital:"Quito"},
	84	{abbr:'eg', name:null, capital:'Cairo'},
	85	{abbr:'sv', name:'El Salvador', capital:'San Salvador'},
	86	{abbr:'gq', name:'Equatorial Guinea', capital:'Malabo'},
	87	{abbr:'er', name:'Eritrea', capital:'Asmara'},
	88	{abbr:'ee', name:null, capital:'Tallinn'},
	89	{abbr:'et', name:'Ethiopia', capital:'Addis Ababa'}
	90	]
	91	} };
	92	}
	93	}else if(name === "countries_withoutid"){
	94	if(dojo.isBrowser){
	95	data = {url: require.toUrl("./countries_withoutid.json")};
	96	}else{
	97	data = {data: {
	98	label: "name",
	99	items:[
	100	{abbr:"ec", name:null, capital:"Quito"},
	101	{abbr:'eg', name:null, capital:'Cairo'},
	102	{abbr:'sv', name:'El Salvador', capital:'San Salvador'},
	103	{abbr:'gq', name:'Equatorial Guinea', capital:'Malabo'},
	104	{abbr:'er', name:'Eritrea', capital:'Asmara'},
	105	{abbr:'ee', name:null, capital:'Tallinn'},
	106	{abbr:'et', name:'Ethiopia', capital:'Addis Ababa'}
	107	]
	108	} };
	109	}
	110	}else if (name === "countries_withBoolean"){
	111	if(dojo.isBrowser){
	112	data = {url: require.toUrl("./countries_withBoolean.json")};
	113	}else{
	114	data = {data: {
	115	identifier:"abbr",
	116	items:[
	117	{abbr:"ec", name:"Ecuador", capital:"Quito", real:true},
	118	{abbr:'eg', name:'Egypt', capital:'Cairo', real:true},
	119	{abbr:'sv', name:'El Salvador', capital:'San Salvador', real:true},
	120	{abbr:'gq', name:'Equatorial Guinea', capital:'Malabo', real:true},
	121	{abbr:'er', name:'Eritrea', capital:'Asmara', real:true},
	122	{abbr:'ee', name:'Estonia', capital:'Tallinn', real:true},
	123	{abbr:'et', name:'Ethiopia', capital:'Addis Ababa', real:true},
	124	{abbr:'ut', name:'Utopia', capital:'Paradise', real:false}
	125	]
	126	} };
	127	}
	128	}else if (name === "countries_withDates"){
	129	if(dojo.isBrowser){
	130	data = {url: require.toUrl("./countries_withDates.json")};
	131	}else{
	132	data = {data: {
	133	identifier:"abbr",
	134	items:[
	135	{abbr:"ec", name:"Ecuador", capital:"Quito"},
	136	{abbr:'eg', name:'Egypt', capital:'Cairo'},
	137	{abbr:'sv', name:'El Salvador', capital:'San Salvador'},
	138	{abbr:'gq', name:'Equatorial Guinea', capital:'Malabo'},
	139	{abbr:'er', name:'Eritrea', capital:'Asmara', independence:{_type:'Date', _value:"1993-05-24T00:00:00Z"}}, // May 24, 1993,
	140	{abbr:'ee', name:'Estonia', capital:'Tallinn', independence:{_type:'Date', _value:"1991-08-20T00:00:00Z"}}, // August 20, 1991
	141	{abbr:'et', name:'Ethiopia', capital:'Addis Ababa'}
	142	]
	143	} };
	144	}
	145	}else if (name === "geography_hierarchy_small"){
	146	if(dojo.isBrowser){
	147	data = {url: require.toUrl("./geography_hierarchy_small.json")};
	148	}else{
	149	data = {data: {
	150	items:[
	151	{ name:'Africa', countries:[
	152	{ name:'Egypt', capital:'Cairo' },
	153	{ name:'Kenya', capital:'Nairobi' },
	154	{ name:'Sudan', capital:'Khartoum' }]},
	155	{ name:'Australia', capital:'Canberra' },
	156	{ name:'North America', countries:[
	157	{ name:'Canada', population:'33 million', cities:[
	158	{ name:'Toronto', population:'2.5 million' },
	159	{ name:'Alberta', population:'1 million' }
	160	]},
	161	{ name: 'United States of America', capital: 'Washington DC', states:[
	162	{ name: 'Missouri'},
	163	{ name: 'Arkansas'}
	164	]}
	165	]}
	166	]
	167	}};
	168	}
	169	}else if (name === "data_multitype"){
	170	if(dojo.isBrowser){
	171	data = {url: require.toUrl("./data_multitype.json")};
	172	}else{
	173	data = {data: {
	174	"identifier": "count",
	175	"label": "count",
	176	items: [
	177	{ count: 1, value: "true" },
	178	{ count: 2, value: true },
	179	{ count: 3, value: "false"},
	180	{ count: 4, value: false },
	181	{ count: 5, value: true },
	182	{ count: 6, value: true },
	183	{ count: 7, value: "true" },
	184	{ count: 8, value: "true" },
	185	{ count: 9, value: "false"},
	186	{ count: 10, value: false },
	187	{ count: 11, value: [false, false]},
	188	{ count: "12", value: [false, "true"]}
	189	]
	190	}
	191	};
	192	}
	193	}else if (name === "countries_references"){
	194	if(dojo.isBrowser){
	195	data = {url: require.toUrl("./countries_references.json")};
	196	}else{
	197	data = {data: { identifier: 'name',
	198	label: 'name',
	199	items: [
	200	{ name:'Africa', type:'continent',
	201	children:[{_reference:'Egypt'}, {_reference:'Kenya'}, {_reference:'Sudan'}] },
	202	{ name:'Egypt', type:'country' },
	203	{ name:'Kenya', type:'country',
	204	children:[{_reference:'Nairobi'}, {_reference:'Mombasa'}] },
	205	{ name:'Nairobi', type:'city' },
	206	{ name:'Mombasa', type:'city' },
	207	{ name:'Sudan', type:'country',
	208	children:{_reference:'Khartoum'} },
	209	{ name:'Khartoum', type:'city' },
	210	{ name:'Asia', type:'continent',
	211	children:[{_reference:'China'}, {_reference:'India'}, {_reference:'Russia'}, {_reference:'Mongolia'}] },
	212	{ name:'China', type:'country' },
	213	{ name:'India', type:'country' },
	214	{ name:'Russia', type:'country' },
	215	{ name:'Mongolia', type:'country' },
	216	{ name:'Australia', type:'continent', population:'21 million',
	217	children:{_reference:'Commonwealth of Australia'}},
	218	{ name:'Commonwealth of Australia', type:'country', population:'21 million'},
	219	{ name:'Europe', type:'continent',
	220	children:[{_reference:'Germany'}, {_reference:'France'}, {_reference:'Spain'}, {_reference:'Italy'}] },
	221	{ name:'Germany', type:'country' },
	222	{ name:'France', type:'country' },
	223	{ name:'Spain', type:'country' },
	224	{ name:'Italy', type:'country' },
	225	{ name:'North America', type:'continent',
	226	children:[{_reference:'Mexico'}, {_reference:'Canada'}, {_reference:'United States of America'}] },
	227	{ name:'Mexico', type:'country', population:'108 million', area:'1,972,550 sq km',
	228	children:[{_reference:'Mexico City'}, {_reference:'Guadalajara'}] },
	229	{ name:'Mexico City', type:'city', population:'19 million', timezone:'-6 UTC'},
	230	{ name:'Guadalajara', type:'city', population:'4 million', timezone:'-6 UTC' },
	231	{ name:'Canada', type:'country', population:'33 million', area:'9,984,670 sq km',
	232	children:[{_reference:'Ottawa'}, {_reference:'Toronto'}] },
	233	{ name:'Ottawa', type:'city', population:'0.9 million', timezone:'-5 UTC'},
	234	{ name:'Toronto', type:'city', population:'2.5 million', timezone:'-5 UTC' },
	235	{ name:'United States of America', type:'country' },
	236	{ name:'South America', type:'continent',
	237	children:[{_reference:'Brazil'}, {_reference:'Argentina'}] },
	238	{ name:'Brazil', type:'country', population:'186 million' },
	239	{ name:'Argentina', type:'country', population:'40 million' }
	240	]
	241	}
	242	};
	243	}
	244	}
	245	return data;
	246	};
	247
	248	//-----------------------------------------------------
	249	// testTemplates
	250	tests.data.readOnlyItemFileTestTemplates.testTemplates = [
	251	{
	252	name: "Identity API: fetchItemByIdentity()",
	253	runTest: function(datastore, t){
	254	// summary:
	255	// Simple test of the fetchItemByIdentity function of the store.
	256	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	257
	258	var d = new doh.Deferred();
	259	function onItem(item){
	260	t.assertTrue(item !== null);
	261	if(item !== null){
	262	var name = store.getValue(item,"name");
	263	t.assertEqual(name, "El Salvador");
	264	}
	265	d.callback(true);
	266	}
	267	function onError(errData){
	268	t.assertTrue(false);
	269	d.errback(errData);
	270	}
	271	store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
	272	return d; // Deferred
	273	}
	274	},
	275	{
	276	name: "Identity API: fetchItemByIdentity() preventCache",
	277	runTest: function(datastore, t){
	278	// summary:
	279	// Simple test of the fetchItemByIdentity function of the store.
	280	var args = tests.data.readOnlyItemFileTestTemplates.getTestData("countries");
	281	args.urlPreventCache = true;
	282	var store = new datastore(args);
	283
	284	var d = new doh.Deferred();
	285	function onItem(item){
	286	t.assertTrue(item !== null);
	287	if(item !== null){
	288	var name = store.getValue(item,"name");
	289	t.assertEqual(name, "El Salvador");
	290	}
	291	d.callback(true);
	292	}
	293	function onError(errData){
	294	t.assertTrue(false);
	295	d.errback(errData);
	296	}
	297	store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
	298	return d; // Deferred
	299	}
	300	},
	301	{
	302	name: "Identity API: fetchItemByIdentity() notFound",
	303	runTest: function(datastore, t){
	304	// summary:
	305	// Simple test of the fetchItemByIdentity function of the store.
	306	// description:
	307	// Simple test of the fetchItemByIdentity function of the store.
	308	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	309
	310	var d = new doh.Deferred();
	311	function onItem(item){
	312	t.assertTrue(item === null);
	313	d.callback(true);
	314	}
	315	function onError(errData){
	316	t.assertTrue(false);
	317	d.errback(errData);
	318	}
	319	store.fetchItemByIdentity({identity: "sv_not", onItem: onItem, onError: onError});
	320	return d; // Deferred
	321	}
	322	},
	323	{
	324	name: "Identity API: getIdentityAttributes()",
	325	runTest: function(datastore, t){
	326	// summary:
	327	// Simple test of the getIdentityAttributes function.
	328	// description:
	329	// Simple test of the getIdentityAttributes function.
	330	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	331
	332	var d = new doh.Deferred();
	333	function onItem(item){
	334	t.assertTrue(item !== null);
	335	var identifiers = store.getIdentityAttributes(item);
	336	t.assertTrue(dojo.isArray(identifiers));
	337	t.assertEqual(1, identifiers.length);
	338	t.assertEqual("abbr", identifiers[0]);
	339	d.callback(true);
	340	}
	341	function onError(errData){
	342	t.assertTrue(false);
	343	d.errback(errData);
	344	}
	345	store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
	346	return d; // Deferred
	347	}
	348	},
	349	{
	350	name: "Identity API: fetchItemByIdentity() commentFilteredJson",
	351	runTest: function(datastore, t){
	352	// summary:
	353	// Simple test of the fetchItemByIdentity function of the store.
	354	// description:
	355	// Simple test of the fetchItemByIdentity function of the store.
	356	// This tests loading a comment-filtered json file so that people using secure
	357	// data with this store can bypass the JavaSceipt hijack noted in Fortify's
	358	// paper.
	359
	360	if(dojo.isBrowser){
	361	var store = new datastore({url: require.toUrl("./countries_commentFiltered.json")});
	362
	363	var d = new doh.Deferred();
	364	function onItem(item){
	365	t.assertTrue(item !== null);
	366	var name = store.getValue(item,"name");
	367	t.assertEqual(name, "El Salvador");
	368	d.callback(true);
	369	}
	370	function onError(errData){
	371	t.assertTrue(false);
	372	d.errback(errData);
	373	}
	374	store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
	375	return d; // Deferred
	376	}
	377	}
	378	},
	379	{
	380	name: "Identity API: fetchItemByIdentity() nullValue",
	381	runTest: function(datastore, t){
	382	// summary:
	383	// Simple test of the fetchItemByIdentity function of the store, checling a null value.
	384	// description:
	385	// Simple test of the fetchItemByIdentity function of the store, checking a null value.
	386	// This tests handling attributes in json that were defined as null properly.
	387	// Introduced because of tracker: #3153
	388	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries_withNull"));
	389
	390	var d = new doh.Deferred();
	391	function onItem(item){
	392	t.assertTrue(item !== null);
	393	var name = store.getValue(item,"name");
	394	t.assertEqual(name, null);
	395	d.callback(true);
	396	}
	397	function onError(errData){
	398	t.assertTrue(false);
	399	d.errback(errData);
	400	}
	401	store.fetchItemByIdentity({identity: "ec", onItem: onItem, onError: onError});
	402	return d; // Deferred
	403	}
	404	},
	405	{
	406	name: "Identity API: fetchItemByIdentity() booleanValue",
	407	runTest: function(datastore, t){
	408	// summary:
	409	// Simple test of the fetchItemByIdentity function of the store, checking a boolean value.
	410	// description:
	411	// Simple test of the fetchItemByIdentity function of the store, checking a boolean value.
	412	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries_withBoolean"));
	413
	414	var d = new doh.Deferred();
	415	function onItem(item){
	416	t.assertTrue(item !== null);
	417	var name = store.getValue(item,"name");
	418	t.assertEqual(name, "Utopia");
	419	var real = store.getValue(item,"real");
	420	t.assertEqual(real, false);
	421	d.callback(true);
	422	}
	423	function onError(errData){
	424	t.assertTrue(false);
	425	d.errback(errData);
	426	}
	427	store.fetchItemByIdentity({identity: "ut", onItem: onItem, onError: onError});
	428	return d; // Deferred
	429	}
	430	},
	431	{
	432	name: "Identity API: fetchItemByIdentity() withoutSpecifiedIdInData",
	433	runTest: function(datastore, t){
	434	// summary:
	435	// Simple test of bug #4691, looking up something by assigned id, not one specified in the JSON data.
	436	// description:
	437	// Simple test of bug #4691, looking up something by assigned id, not one specified in the JSON data.
	438	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries_withoutid"));
	439
	440	var d = new doh.Deferred();
	441	function onItem(item){
	442	t.assertTrue(item !== null);
	443	var name = store.getValue(item,"name");
	444	t.assertEqual(name, "El Salvador");
	445	d.callback(true);
	446	}
	447	function onError(errData){
	448	t.assertTrue(false);
	449	d.errback(errData);
	450	}
	451	store.fetchItemByIdentity({identity: "2", onItem: onItem, onError: onError});
	452	return d; // Deferred
	453	}
	454	},
	455	{
	456	name: "Identity API: fetchItemByIdentity() Object.prototype item identifier",
	457	runTest: function(datastore, t){
	458	// summary:
	459	// Simple test of bug where store would raise an error
	460	// if the item identifier was the same as an Object property name.
	461	var data = {identifier: 'id', items: [{id: 'toString', value: 'aha'}]};
	462	var store = new datastore({data: data});
	463	var d = new doh.Deferred();
	464	function onitem(item){
	465	t.assertTrue(item.value == 'aha');
	466	d.callback(true);
	467	}
	468	function onError(errData){
	469	t.assertTrue(false);
	470	d.errback(errData);
	471	}
	472	store.fetchItemByIdentity({identity: 'toString', onItem: onitem, onError: onError});
	473	return d; // Deferred
	474	}
	475	},
	476	{
	477	name: "Identity API: fetchItemByIdentity() Object.prototype item identifier 2",
	478	runTest: function(datastore, t){
	479	// summary:
	480	// Simple test of bug where store would raise an error
	481	// if the item identifier was the same as an Object property name.
	482	var data = {identifier: 'id', items: [{id: 'hasOwnProperty', value: 'yep'}]};
	483	var store = new datastore({data: data});
	484	var d = new doh.Deferred();
	485	function onitem(item){
	486	t.assertTrue(item.value == 'yep');
	487	d.callback(true);
	488	}
	489	function onError(errData){
	490	t.assertTrue(false);
	491	d.errback(errData);
	492	}
	493	store.fetchItemByIdentity({identity: 'hasOwnProperty', onItem: onitem, onError: onError});
	494	return d; // Deferred
	495	}
	496	},
	497	{
	498	name: "Identity API: fetchItemByIdentity() Object.prototype identity",
	499	runTest: function(datastore, t){
	500	// summary:
	501	// Simple test of bug where fetchItemByIdentity would return
	502	// an object property.
	503	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries_withoutid"));
	504	var d = new doh.Deferred();
	505	function onItem(item){
	506	t.assertTrue(item === null);
	507	d.callback(true);
	508	}
	509	function onError(errData){
	510	t.assertTrue(false);
	511	d.errback(errData);
	512	}
	513	store.fetchItemByIdentity({identity: 'toString', onItem: onItem, onError: onError});
	514	return d; // Deferred
	515	}
	516	},
	517	{
	518	name: "Identity API: fetchItemByIdentity() Object.prototype identity 2",
	519	runTest: function(datastore, t){
	520	// summary:
	521	// Simple test of bug where fetchItemByIdentity would return
	522	// an object property.
	523	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries_withoutid"));
	524	var d = new doh.Deferred();
	525	function onItem(item){
	526	t.assertTrue(item === null);
	527	d.callback(true);
	528	}
	529	function onError(errData){
	530	t.assertTrue(false);
	531	d.errback(errData);
	532	}
	533	store.fetchItemByIdentity({identity: 'hasOwnProperty', onItem: onItem, onError: onError});
	534	return d; // Deferred
	535	}
	536	},
	537	{
	538	name: "Identity API: getIdentity()",
	539	runTest: function(datastore, t){
	540	// summary:
	541	// Simple test of the getIdentity function of the store.
	542	// description:
	543	// Simple test of the getIdentity function of the store.
	544	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	545
	546	var d = new doh.Deferred();
	547	function onItem(item){
	548	t.assertTrue(item !== null);
	549	t.assertTrue(store.getIdentity(item) === "sv");
	550	d.callback(true);
	551	}
	552	function onError(errData){
	553	t.assertTrue(false);
	554	d.errback(errData);
	555	}
	556	store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
	557	return d; // Deferred
	558	}
	559	},
	560	{
	561	name: "Identity API: getIdentity() withoutSpecifiedId",
	562	runTest: function(datastore, t){
	563	// summary:
	564	// Simple test of the #4691 bug
	565	// description:
	566	// Simple test of the #4691 bug
	567	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries_withoutid"));
	568
	569	var d = new doh.Deferred();
	570	function onItem(item, request){
	571	t.assertTrue(item !== null);
	572	t.assertTrue(store.getIdentity(item) === 2);
	573	d.callback(true);
	574	}
	575	function onError(errData, request){
	576	t.assertTrue(false);
	577	d.errback(errData);
	578	}
	579	store.fetch({ query:{abbr: "sv"}, onItem: onItem, onError: onError});
	580	return d; // Deferred
	581	}
	582	},
	583	{
	584	name: "Read API: fetch() all",
	585	runTest: function(datastore, t){
	586	// summary:
	587	// Simple test of a basic fetch on ItemFileReadStore.
	588	// description:
	589	// Simple test of a basic fetch on ItemFileReadStore.
	590	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	591
	592	var d = new doh.Deferred();
	593	function completedAll(items, request){
	594	t.is(7, items.length);
	595	d.callback(true);
	596	}
	597	function error(errData, request){
	598	t.assertTrue(false);
	599	d.errback(errData);
	600	}
	601
	602	//Get everything...
	603	store.fetch({ onComplete: completedAll, onError: error});
	604	return d;
	605	}
	606	},
	607	{
	608	name: "Read API: fetch() all failOk",
	609	runTest: function(datastore, t){
	610	// summary:
	611	// Simple test of a basic fetch on ItemFileReadStore that fails quietly.
	612	// description:
	613	// Simple test of a basic fetch on ItemFileReadStore that fails quietly.
	614	if(dojo.isBrowser){
	615	var storeParams = {
	616	url: "noSuchUrl",
	617	failOk: true
	618	};
	619	var store = new datastore(storeParams);
	620	console.log(store);
	621
	622	var d = new doh.Deferred();
	623	var completedAll = function(items, request){
	624	d.errback(new Error("Should not be here, should have failed load."));
	625	};
	626	var error = function(errData, request){
	627	d.callback(true);
	628	};
	629
	630	//Get everything...
	631	store.fetch({ onComplete: completedAll, onError: error});
	632	return d;
	633	}
	634	}
	635	},
	636	{
	637	name: "Read API: fetch() abort",
	638	runTest: function(datastore, t){
	639	// summary:
	640	// Simple test of a basic fetch abort on ItemFileReadStore.
	641	// description:
	642	// Simple test of a basic fetch abort on ItemFileReadStore.
	643	//Can only async abort in a browser, so disable this test from rhino
	644	if(dojo.isBrowser){
	645	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	646
	647	var d = new doh.Deferred();
	648	var abortCalled = false;
	649	function completedAll(items, request){
	650	t.is(7, items.length);
	651	if(abortCalled){
	652	console.log("Made it to complete callback and abort was called. Problem.");
	653	d.errback(new Error("Should not be here."));
	654	}else{
	655	//We beat out calling abort, so this is okay. Timing.
	656	console.log("in onComplete and abort has not been called. Timing. This is okay.");
	657	d.callback(true);
	658	}
	659	}
	660	function error(errData, request){
	661	//An abort should throw a cancel error, so we should
	662	//reach this.
	663	t.assertTrue(true);
	664	d.callback(true);
	665	}
	666
	667	//Get everything...
	668	var req = store.fetch({ onComplete: completedAll, onError: error});
	669	abortCalled=true;
	670	console.log("Calling abort.");
	671	req.abort();
	672	return d;
	673	}
	674	}
	675	},
	676	{
	677	name: "Read API: fetch() all (count === Infinity)",
	678	runTest: function(datastore, t){
	679	// summary:
	680	// Simple test of a basic fetch on ItemFileReadStore and with a count of Infinity.
	681	// description:
	682	// Simple test of a basic fetch on ItemFileReadStore and with a count of Infinity.
	683	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	684
	685	var d = new doh.Deferred();
	686	function completedAll(items, request){
	687	t.is(7, items.length);
	688	d.callback(true);
	689	}
	690	function error(errData, request){
	691	t.assertTrue(false);
	692	d.errback(errData);
	693	}
	694
	695	//Get everything...
	696	store.fetch({ onComplete: completedAll, onError: error, start: 0, count: Infinity});
	697	return d;
	698	}
	699	},
	700	{
	701	name: "Read API: fetch() all PreventCache",
	702	runTest: function(datastore, t){
	703	// summary:
	704	// Simple test of a basic fetch on ItemFileReadStore.
	705	// description:
	706	// Simple test of a basic fetch on ItemFileReadStore.
	707	var args = tests.data.readOnlyItemFileTestTemplates.getTestData("countries");
	708	args.urlPreventCache = true;
	709	var store = new datastore(args);
	710
	711	var d = new doh.Deferred();
	712	function completedAll(items, request){
	713	t.is(7, items.length);
	714	d.callback(true);
	715	}
	716	function error(errData, request){
	717	t.assertTrue(false);
	718	d.errback(errData);
	719	}
	720
	721	//Get everything...
	722	store.fetch({ onComplete: completedAll, onError: error});
	723	return d;
	724	}
	725	},
	726	{
	727	name: "Read API: fetch() one",
	728	runTest: function(datastore, t){
	729	// summary:
	730	// Simple test of a basic fetch on ItemFileReadStore of a single item.
	731	// description:
	732	// Simple test of a basic fetch on ItemFileReadStore of a single item.
	733	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	734
	735	var d = new doh.Deferred();
	736	function onComplete(items, request){
	737	t.assertEqual(items.length, 1);
	738	d.callback(true);
	739	}
	740	function onError(errData, request){
	741	t.assertTrue(false);
	742	d.errback(errData);
	743	}
	744	store.fetch({ query: {abbr: "ec"},
	745	onComplete: onComplete,
	746	onError: onError
	747	});
	748	return d;
	749	}
	750	},
	751	{
	752	name: "Read API: fetch() shallow",
	753	runTest: function(datastore, t){
	754	// summary:
	755	// Simple test of a basic fetch on ItemFileReadStore of only toplevel items
	756	// description:
	757	// Simple test of a basic fetch on ItemFileReadStore of only toplevel items.
	758	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("geography_hierarchy_small"));
	759
	760	var d = new doh.Deferred();
	761	function onComplete(items, request){
	762	t.assertEqual(items.length, 2);
	763	d.callback(true);
	764	}
	765	function onError(errData, request){
	766	t.assertTrue(false);
	767	d.errback(errData);
	768	}
	769	//Find all items starting with A, only toplevel (root) items.
	770	store.fetch({ query: {name: "A*"},
	771	onComplete: onComplete,
	772	onError: onError
	773	});
	774	return d;
	775	}
	776	},
	777	{
	778	name: "Read API: fetch() Multiple",
	779	runTest: function(datastore, t){
	780	// summary:
	781	// Tests that multiple fetches at the same time queue up properly and do not clobber each other on initial load.
	782	// description:
	783	// Tests that multiple fetches at the same time queue up properly and do not clobber each other on initial load.
	784	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("geography_hierarchy_small"));
	785
	786	var d = new doh.Deferred();
	787	var done = [false, false];
	788
	789	function onCompleteOne(items, request){
	790	done[0] = true;
	791	t.assertEqual(items.length, 2);
	792	if(done[0] && done[1]){
	793	d.callback(true);
	794	}
	795	}
	796	function onCompleteTwo(items, request){
	797	done[1] = true;
	798	if(done[0] && done[1]){
	799	d.callback(true);
	800	}
	801	}
	802	function onError(errData, request){
	803	t.assertTrue(false);
	804	d.errback(errData);
	805	}
	806	//Find all items starting with A, only toplevel (root) items.
	807	store.fetch({ query: {name: "A*"},
	808	onComplete: onCompleteOne,
	809	onError: onError
	810	});
	811
	812	//Find all items starting with A, only toplevel (root) items.
	813	store.fetch({ query: {name: "N*"},
	814	onComplete: onCompleteTwo,
	815	onError: onError
	816	});
	817
	818	return d;
	819	}
	820	},
	821	{
	822	name: "Read API: fetch() MultipleMixedFetch",
	823	runTest: function(datastore, t){
	824	// summary:
	825	// Tests that multiple fetches at the same time queue up properly and do not clobber each other on initial load.
	826	// description:
	827	// Tests that multiple fetches at the same time queue up properly and do not clobber each other on initial load.
	828	// Tests an item fetch and an identity fetch.
	829	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	830
	831	var d = new doh.Deferred();
	832	var done = [false, false];
	833
	834	function onComplete(items, request){
	835	done[0] = true;
	836	t.assertEqual(items.length, 1);
	837	if(done[0] && done[1]){
	838	d.callback(true);
	839	}
	840	}
	841	function onItem(item){
	842	done[1] = true;
	843	t.assertTrue(item !== null);
	844	var name = store.getValue(item,"name");
	845	t.assertEqual(name, "El Salvador");
	846
	847	if(done[0] && done[1]){
	848	d.callback(true);
	849	}
	850	}
	851	function onError(errData){
	852	t.assertTrue(false);
	853	d.errback(errData);
	854	}
	855
	856	//Find all items starting with A, only toplevel (root) items.
	857	store.fetch({ query: {name: "El*"},
	858	onComplete: onComplete,
	859	onError: onError
	860	});
	861
	862	store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
	863	return d;
	864	}
	865	},
	866	{
	867	name: "Read API: fetch() deep",
	868	runTest: function(datastore, t){
	869	// summary:
	870	// Simple test of a basic fetch on ItemFileReadStore of all items (including children (nested))
	871	// description:
	872	// Simple test of a basic fetch on ItemFileReadStore of all items (including children (nested))
	873	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("geography_hierarchy_small"));
	874
	875	var d = new doh.Deferred();
	876	function onComplete(items, request){
	877	t.assertEqual(items.length, 4);
	878	d.callback(true);
	879	}
	880	function onError(errData, request){
	881	t.assertTrue(false);
	882	d.errback(errData);
	883	}
	884	//Find all items starting with A, including child (nested) items.
	885	store.fetch({ query: {name: "A*"},
	886	onComplete: onComplete,
	887	onError: onError,
	888	queryOptions: {deep:true}
	889	});
	890	return d;
	891	}
	892	},
	893	{
	894	name: "Read API: fetch() hierarchy off",
	895	runTest: function(datastore, t){
	896	// summary:
	897	// Simple test of a basic fetch on ItemFileReadStore of all items with hierarchy disabled
	898	// This should turn off processing child objects as data store items. It will still process
	899	// references and type maps.
	900	// description:
	901	// Simple test of a basic fetch on ItemFileReadStore of all items with hierarchy disabled
	902	// This should turn off processing child objects as data store items. It will still process
	903	// references and type maps.
	904	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("geography_hierarchy_small"));
	905
	906	//Set this as hierarchy off before fetch to make sure it traps and configs right.
	907	store.hierarchical = false;
	908
	909	var d = new doh.Deferred();
	910	function onComplete(items, request){
	911	//With hierarchy off, this should only match 2, as only two data store items
	912	//will be quertied
	913	t.assertEqual(items.length, 2);
	914	var i;
	915	var passed = true;
	916	for(i = 0; i < items.length; i++){
	917	var countries = store.getValues(items[i], "countries");
	918	if(countries){
	919	var j;
	920	//Make sure none of the child objects were processed into items.
	921	for(j = 0; j<countries.length; j++){
	922	passed = !store.isItem(countries[j]);
	923	if(!passed){
	924	break;
	925	}
	926	}
	927	}
	928	if(!passed){
	929	break;
	930	}
	931	}
	932	if(!passed){
	933	d.errback(new Error("Located a child item with hierarchy off and no references in the data. Error."));
	934	}else{
	935	d.callback(true);
	936	}
	937	}
	938	function onError(errData, request){
	939	t.assertTrue(false);
	940	d.errback(errData);
	941	}
	942	//Find all items starting with A, including child (nested) items.
	943	store.fetch({ query: {name: "A*"},
	944	onComplete: onComplete,
	945	onError: onError,
	946	queryOptions: {deep:true}
	947	});
	948	return d;
	949	}
	950	},
	951	{
	952	name: "Read API: fetch() hierarchy off refs still parse",
	953	runTest: function(datastore, t){
	954	// summary:
	955	// Simple test of a basic fetch on ItemFileReadStore of all items with hierarchy disabled
	956	// This should turn off processing child objects as data store items. It will still process
	957	// references and type maps.
	958	// description:
	959	// Simple test of a basic fetch on ItemFileReadStore of all items with hierarchy disabled
	960	// This should turn off processing child objects as data store items. It will still process
	961	// references and type maps.
	962	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries_references"));
	963
	964	//Set this as hierarchy off before fetch to make sure it traps and configs right.
	965	store.hierarchical = false;
	966
	967	var d = new doh.Deferred();
	968	function onComplete(items, request){
	969	//With hierarchy off, this should only match 2, as only two data store items
	970	//will be quertied
	971	t.assertEqual(items.length, 4);
	972	var i;
	973	var passed = true;
	974	for(i = 0; i < items.length; i++){
	975	var countries = store.getValues(items[i], "children");
	976	if(countries){
	977	var j;
	978	//Make sure none of the child objects were processed into items.
	979	for(j = 0; j<countries.length; j++){
	980	passed = store.isItem(countries[j]);
	981	if(!passed){
	982	break;
	983	}
	984	}
	985	}
	986	if(!passed){
	987	break;
	988	}
	989	}
	990	if(!passed){
	991	d.errback(new Error("Found a non-child item in a reference list in a references based input. Error."));
	992	}else{
	993	d.callback(true);
	994	}
	995	}
	996	function onError(errData, request){
	997	t.assertTrue(false);
	998	d.errback(errData);
	999	}
	1000	//Find all items starting with A, including child (nested) items.
	1001	store.fetch({ query: {name: "A*"},
	1002	onComplete: onComplete,
	1003	onError: onError,
	1004	queryOptions: {deep:true}
	1005	});
	1006	return d;
	1007	}
	1008	},
	1009	{
	1010	name: "Read API: fetch() one_commentFilteredJson",
	1011	runTest: function(datastore, t){
	1012	// summary:
	1013	// Simple test of a basic fetch on ItemFileReadStore of a single item.
	1014	// description:
	1015	// Simple test of a basic fetch on ItemFileReadStore of a single item.
	1016	// This tests loading a comment-filtered json file so that people using secure
	1017	// data with this store can bypass the JavaSceipt hijack noted in Fortify's
	1018	// paper.
	1019	if(dojo.isBrowser){
	1020	var store = new datastore({url: require.toUrl("./countries_commentFiltered.json")});
	1021
	1022	var d = new doh.Deferred();
	1023	function onComplete(items, request){
	1024	t.assertEqual(items.length, 1);
	1025	d.callback(true);
	1026	}
	1027	function onError(errData, request){
	1028	t.assertTrue(false);
	1029	d.errback(errData);
	1030	}
	1031	store.fetch({ query: {abbr: "ec"},
	1032	onComplete: onComplete,
	1033	onError: onError
	1034	});
	1035	return d;
	1036	}
	1037	}
	1038	},
	1039	{
	1040	name: "Read API: fetch() withNull",
	1041	runTest: function(datastore, t){
	1042	// summary:
	1043	// Simple test of a basic fetch on ItemFileReadStore of a single item where some attributes are null.
	1044	// description:
	1045	// Simple test of a basic fetch on ItemFileReadStore of a single item where some attributes are null.
	1046	// Introduced because of tracker: #3153
	1047	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries_withNull"));
	1048
	1049	var d = new doh.Deferred();
	1050	function onComplete(items, request){
	1051	t.assertEqual(4, items.length);
	1052	d.callback(true);
	1053	}
	1054	function onError(errData, request){
	1055	t.assertTrue(false);
	1056	d.errback(errData);
	1057	}
	1058	store.fetch({ query: {name: "E*"},
	1059	onComplete: onComplete,
	1060	onError: onError
	1061	});
	1062	return d;
	1063	}
	1064	},
	1065	{
	1066	name: "Read API: fetch() all_streaming",
	1067	runTest: function(datastore, t){
	1068	// summary:
	1069	// Simple test of a basic fetch on ItemFileReadStore.
	1070	// description:
	1071	// Simple test of a basic fetch on ItemFileReadStore.
	1072	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	1073
	1074	var d = new doh.Deferred();
	1075	count = 0;
	1076
	1077	function onBegin(size, requestObj){
	1078	t.assertEqual(size, 7);
	1079	}
	1080	function onItem(item, requestObj){
	1081	t.assertTrue(store.isItem(item));
	1082	count++;
	1083	}
	1084	function onComplete(items, request){
	1085	t.assertEqual(count, 7);
	1086	t.assertTrue(items === null);
	1087	d.callback(true);
	1088	}
	1089	function onError(errData, request){
	1090	t.assertTrue(false);
	1091	d.errback(errData);
	1092	}
	1093
	1094	//Get everything...
	1095	store.fetch({ onBegin: onBegin,
	1096	onItem: onItem,
	1097	onComplete: onComplete,
	1098	onError: onError
	1099	});
	1100	return d;
	1101	}
	1102	},
	1103	{
	1104	name: "Read API: fetch() paging",
	1105	runTest: function(datastore, t){
	1106	// summary:
	1107	// Test of multiple fetches on a single result. Paging, if you will.
	1108	// description:
	1109	// Test of multiple fetches on a single result. Paging, if you will.
	1110	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	1111
	1112	var d = new doh.Deferred();
	1113	function dumpFirstFetch(items, request){
	1114	t.assertEqual(items.length, 5);
	1115	request.start = 3;
	1116	request.count = 1;
	1117	request.onComplete = dumpSecondFetch;
	1118	store.fetch(request);
	1119	}
	1120
	1121	function dumpSecondFetch(items, request){
	1122	t.assertEqual(items.length, 1);
	1123	request.start = 0;
	1124	request.count = 5;
	1125	request.onComplete = dumpThirdFetch;
	1126	store.fetch(request);
	1127	}
	1128
	1129	function dumpThirdFetch(items, request){
	1130	t.assertEqual(items.length, 5);
	1131	request.start = 2;
	1132	request.count = 20;
	1133	request.onComplete = dumpFourthFetch;
	1134	store.fetch(request);
	1135	}
	1136
	1137	function dumpFourthFetch(items, request){
	1138	t.assertEqual(items.length, 5);
	1139	request.start = 9;
	1140	request.count = 100;
	1141	request.onComplete = dumpFifthFetch;
	1142	store.fetch(request);
	1143	}
	1144
	1145	function dumpFifthFetch(items, request){
	1146	t.assertEqual(items.length, 0);
	1147	request.start = 2;
	1148	request.count = 20;
	1149	request.onComplete = dumpSixthFetch;
	1150	store.fetch(request);
	1151	}
	1152
	1153	function dumpSixthFetch(items, request){
	1154	t.assertEqual(items.length, 5);
	1155	d.callback(true);
	1156	}
	1157
	1158	function completed(items, request){
	1159	t.assertEqual(items.length, 7);
	1160	request.start = 1;
	1161	request.count = 5;
	1162	request.onComplete = dumpFirstFetch;
	1163	store.fetch(request);
	1164	}
	1165
	1166	function error(errData, request){
	1167	t.assertTrue(false);
	1168	d.errback(errData);
	1169	}
	1170	store.fetch({onComplete: completed, onError: error});
	1171	return d;
	1172	}
	1173	},
	1174	{
	1175	name: "Read API: fetch() with MultiType Match",
	1176	runTest: function(datastore, t){
	1177	// summary:
	1178	// Simple test of a basic fetch againct an attribute that has different types for the value across items
	1179	// description:
	1180	// Simple test of a basic fetch againct an attribute that has different types for the value across items
	1181	// Introduced because of tracker: #4931
	1182	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("data_multitype"));
	1183
	1184	var d = new doh.Deferred();
	1185	function onComplete(items, request){
	1186	t.assertEqual(4, items.length);
	1187	d.callback(true);
	1188	}
	1189	function onError(errData, request){
	1190	t.assertTrue(false);
	1191	d.errback(errData);
	1192	}
	1193	store.fetch({ query: {count: "1*"},
	1194	onComplete: onComplete,
	1195	onError: onError
	1196	});
	1197	return d;
	1198	}
	1199	},
	1200	{
	1201	name: "Read API: fetch() with RegExp Match",
	1202	runTest: function(datastore, t){
	1203	// summary:
	1204	// Simple test of a basic fetch using a RegExp works with IFRS
	1205	// description:
	1206	// Simple test of a basic fetch using a RegExp works with IFRS
	1207	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("data_multitype"));
	1208
	1209	var d = new doh.Deferred();
	1210	function onComplete(items, request){
	1211	t.assertEqual(4, items.length);
	1212	d.callback(true);
	1213	}
	1214	function onError(errData, request){
	1215	t.assertTrue(false);
	1216	d.errback(errData);
	1217	}
	1218	store.fetch({ query: {count: new RegExp("^1.*$", "gi")},
	1219	onComplete: onComplete,
	1220	onError: onError
	1221	});
	1222	return d;
	1223	}
	1224	},
	1225	{
	1226	name: "Read API: fetch() with RegExp Match Inline",
	1227	runTest: function(datastore, t){
	1228	// summary:
	1229	// Simple test of a basic fetch using a RegExp works with IFRS
	1230	// description:
	1231	// Simple test of a basic fetch using a RegExp works with IFRS
	1232	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("data_multitype"));
	1233
	1234	var d = new doh.Deferred();
	1235	function onComplete(items, request){
	1236	t.assertEqual(4, items.length);
	1237	d.callback(true);
	1238	}
	1239	function onError(errData, request){
	1240	t.assertTrue(false);
	1241	d.errback(errData);
	1242	}
	1243	store.fetch({ query: {count: /^1.*$/gi},
	1244	onComplete: onComplete,
	1245	onError: onError
	1246	});
	1247	return d;
	1248	}
	1249	},
	1250	{
	1251	name: "Read API: fetch() with MultiType, MultiValue Match",
	1252	runTest: function(datastore, t){
	1253	// summary:
	1254	// Simple test of a basic fetch againct an attribute that has different types for the value across items
	1255	// description:
	1256	// Simple test of a basic fetch againct an attribute that has different types for the value across items
	1257	// Introduced because of tracker: #4931
	1258	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("data_multitype"));
	1259
	1260	var d = new doh.Deferred();
	1261	function onComplete(items, request){
	1262	t.assertEqual(7, items.length);
	1263	d.callback(true);
	1264	}
	1265	function onError(errData, request){
	1266	t.assertTrue(false);
	1267	d.errback(errData);
	1268	}
	1269	store.fetch({ query: {value: "true"},
	1270	onComplete: onComplete,
	1271	onError: onError
	1272	});
	1273	return d;
	1274	}
	1275	},
	1276	{
	1277	name: "Read API: getLabel()",
	1278	runTest: function(datastore, t){
	1279	// summary:
	1280	// Simple test of the getLabel function against a store set that has a label defined.
	1281	// description:
	1282	// Simple test of the getLabel function against a store set that has a label defined.
	1283	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	1284
	1285	var d = new doh.Deferred();
	1286	function onComplete(items, request){
	1287	t.assertEqual(items.length, 1);
	1288	var label = store.getLabel(items[0]);
	1289	t.assertTrue(label !== null);
	1290	t.assertEqual("Ecuador", label);
	1291	d.callback(true);
	1292	}
	1293	function onError(errData, request){
	1294	t.assertTrue(false);
	1295	d.errback(errData);
	1296	}
	1297	store.fetch({ query: {abbr: "ec"},
	1298	onComplete: onComplete,
	1299	onError: onError
	1300	});
	1301	return d;
	1302	}
	1303	},
	1304	{
	1305	name: "Read API: getLabelAttributes()",
	1306	runTest: function(datastore, t){
	1307	// summary:
	1308	// Simple test of the getLabelAttributes function against a store set that has a label defined.
	1309	// description:
	1310	// Simple test of the getLabelAttributes function against a store set that has a label defined.
	1311	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	1312
	1313	var d = new doh.Deferred();
	1314	function onComplete(items, request){
	1315	t.assertEqual(items.length, 1);
	1316	var labelList = store.getLabelAttributes(items[0]);
	1317	t.assertTrue(dojo.isArray(labelList));
	1318	t.assertEqual("name", labelList[0]);
	1319	d.callback(true);
	1320	}
	1321	function onError(errData, request){
	1322	t.assertTrue(false);
	1323	d.errback(errData);
	1324	}
	1325	store.fetch({ query: {abbr: "ec"},
	1326	onComplete: onComplete,
	1327	onError: onError
	1328	});
	1329	return d;
	1330	}
	1331	},
	1332	{
	1333	name: "Read API: getValue()",
	1334	runTest: function(datastore, t){
	1335	// summary:
	1336	// Simple test of the getValue function of the store.
	1337	// description:
	1338	// Simple test of the getValue function of the store.
	1339	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	1340
	1341	var d = new doh.Deferred();
	1342	function onItem(item){
	1343	t.assertTrue(item !== null);
	1344	var name = store.getValue(item,"name");
	1345	t.assertTrue(name === "El Salvador");
	1346	d.callback(true);
	1347	}
	1348	function onError(errData){
	1349	t.assertTrue(false);
	1350	d.errback(errData);
	1351	}
	1352	store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
	1353	return d; // Deferred
	1354	}
	1355	},
	1356	{
	1357	name: "Read API: getValues()",
	1358	runTest: function(datastore, t){
	1359	// summary:
	1360	// Simple test of the getValues function of the store.
	1361	// description:
	1362	// Simple test of the getValues function of the store.
	1363	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	1364
	1365	var d = new doh.Deferred();
	1366	function onItem(item){
	1367	t.assertTrue(item !== null);
	1368	var names = store.getValues(item,"name");
	1369	t.assertTrue(dojo.isArray(names));
	1370	t.assertEqual(names.length, 1);
	1371	t.assertEqual(names[0], "El Salvador");
	1372	d.callback(true);
	1373	}
	1374	function onError(errData){
	1375	t.assertTrue(false);
	1376	d.errback(errData);
	1377	}
	1378	store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
	1379	return d; // Deferred
	1380	}
	1381	},
	1382	{
	1383	name: "Read API: isItem()",
	1384	runTest: function(datastore, t){
	1385	// summary:
	1386	// Simple test of the isItem function of the store
	1387	// description:
	1388	// Simple test of the isItem function of the store
	1389	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	1390
	1391	var d = new doh.Deferred();
	1392	function onItem(item){
	1393	t.assertTrue(item !== null);
	1394	t.assertTrue(store.isItem(item));
	1395	t.assertTrue(!store.isItem({}));
	1396	d.callback(true);
	1397	}
	1398	function onError(errData){
	1399	t.assertTrue(false);
	1400	d.errback(errData);
	1401	}
	1402	store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
	1403	return d; // Deferred
	1404	}
	1405	},
	1406	{
	1407	name: "Read API: isItem() multistore",
	1408	runTest: function(datastore, t){
	1409	// summary:
	1410	// Simple test of the isItem function of the store
	1411	// to verify two different store instances do not accept
	1412	// items from each other.
	1413	// description:
	1414	// Simple test of the isItem function of the store
	1415	// to verify two different store instances do not accept
	1416	// items from each other.
	1417
	1418	// Two different instances, even if they read from the same URL
	1419	// should not accept items between each other!
	1420	var store1 = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	1421	var store2 = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	1422
	1423	var d = new doh.Deferred();
	1424	function onItem1(item1){
	1425	t.assertTrue(item1 !== null);
	1426
	1427	function onItem2(item2){
	1428	t.assertTrue(item1 !== null);
	1429	t.assertTrue(item2 !== null);
	1430	t.assertTrue(store1.isItem(item1));
	1431	t.assertTrue(store2.isItem(item2));
	1432	t.assertTrue(!store1.isItem(item2));
	1433	t.assertTrue(!store2.isItem(item1));
	1434	d.callback(true);
	1435	}
	1436	store2.fetchItemByIdentity({identity: "sv", onItem: onItem2, onError: onError});
	1437
	1438	}
	1439	function onError(errData){
	1440	t.assertTrue(false);
	1441	d.errback(errData);
	1442	}
	1443	store1.fetchItemByIdentity({identity: "sv", onItem: onItem1, onError: onError});
	1444	return d; // Deferred
	1445	}
	1446	},
	1447	{
	1448	name: "Read API: hasAttribute()",
	1449	runTest: function(datastore, t){
	1450	// summary:
	1451	// Simple test of the hasAttribute function of the store
	1452	// description:
	1453	// Simple test of the hasAttribute function of the store
	1454	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	1455
	1456	var d = new doh.Deferred();
	1457	function onItem(item){
	1458	try{
	1459	t.assertTrue(item !== null);
	1460
	1461	t.assertTrue(store.hasAttribute(item, "abbr"));
	1462	t.assertTrue(!store.hasAttribute(item, "abbr_not"));
	1463
	1464	//Test that null attributes throw an exception
	1465	var passed = false;
	1466	try{
	1467	store.hasAttribute(item, null);
	1468	}catch (e){
	1469	passed = true;
	1470	}
	1471	t.assertTrue(passed);
	1472	d.callback(true);
	1473	}catch(e){
	1474	d.errback(e);
	1475	}
	1476	}
	1477	function onError(errData){
	1478	t.assertTrue(false);
	1479	d.errback(errData);
	1480	}
	1481	store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
	1482	return d; // Deferred
	1483	}
	1484	},
	1485	{
	1486	name: "Read API: containsValue()",
	1487	runTest: function(datastore, t){
	1488	// summary:
	1489	// Simple test of the containsValue function of the store
	1490	// description:
	1491	// Simple test of the containsValue function of the store
	1492	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	1493
	1494	var d = new doh.Deferred();
	1495	function onItem(item){
	1496	t.assertTrue(item !== null);
	1497	t.assertTrue(store.containsValue(item, "abbr", "sv"));
	1498	t.assertTrue(!store.containsValue(item, "abbr", "sv1"));
	1499	t.assertTrue(!store.containsValue(item, "abbr", null));
	1500
	1501	//Test that null attributes throw an exception
	1502	var passed = false;
	1503	try{
	1504	store.containsValue(item, null, "foo");
	1505	}catch (e){
	1506	passed = true;
	1507	}
	1508	t.assertTrue(passed);
	1509	d.callback(true);
	1510	}
	1511	function onError(errData){
	1512	t.assertTrue(false);
	1513	d.errback(errData);
	1514	}
	1515	store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
	1516	return d; // Deferred
	1517	}
	1518	},
	1519	{
	1520	name: "Read API: getAttributes()",
	1521	runTest: function(datastore, t){
	1522	// summary:
	1523	// Simple test of the getAttributes function of the store
	1524	// description:
	1525	// Simple test of the getAttributes function of the store
	1526	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	1527
	1528	var d = new doh.Deferred();
	1529	function onItem(item){
	1530	t.assertTrue(item !== null);
	1531	t.assertTrue(store.isItem(item));
	1532
	1533	var attributes = store.getAttributes(item);
	1534	t.assertEqual(attributes.length, 3);
	1535	for(var i = 0; i < attributes.length; i++){
	1536	t.assertTrue((attributes[i] === "name" \|\| attributes[i] === "abbr" \|\| attributes[i] === "capital"));
	1537	}
	1538	d.callback(true);
	1539	}
	1540	function onError(errData){
	1541	t.assertTrue(false);
	1542	d.errback(errData);
	1543	}
	1544	store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
	1545	return d; // Deferred
	1546	}
	1547	},
	1548	{
	1549	name: "Read API: getFeatures()",
	1550	runTest: function(datastore, t){
	1551	// summary:
	1552	// Simple test of the getFeatures function of the store
	1553	// description:
	1554	// Simple test of the getFeatures function of the store
	1555	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	1556
	1557	var features = store.getFeatures();
	1558	t.assertTrue(features["dojo.data.api.Read"] != null);
	1559	t.assertTrue(features["dojo.data.api.Identity"] != null);
	1560	}
	1561	},
	1562	{
	1563	name: "Read API: fetch() patternMatch0",
	1564	runTest: function(datastore, t){
	1565	// summary:
	1566	// Function to test pattern matching of everything starting with lowercase e
	1567	// description:
	1568	// Function to test pattern matching of everything starting with lowercase e
	1569	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	1570
	1571	var d = new doh.Deferred();
	1572	function completed(items, request){
	1573	t.assertEqual(items.length, 5);
	1574	var passed = true;
	1575	for(var i = 0; i < items.length; i++){
	1576	var value = store.getValue(items[i], "abbr");
	1577	if(!(value === "ec" \|\| value === "eg" \|\| value === "er" \|\| value === "ee" \|\| value === "et")){
	1578	passed=false;
	1579	break;
	1580	}
	1581	}
	1582	t.assertTrue(passed);
	1583	if (passed){
	1584	d.callback(true);
	1585	}else{
	1586	d.errback(new Error("Unexpected abbreviation found, match failure."));
	1587	}
	1588	}
	1589	function error(error, request){
	1590	t.assertTrue(false);
	1591	d.errback(error);
	1592	}
	1593	store.fetch({query: {abbr: "e*"}, onComplete: completed, onError: error});
	1594	return d;
	1595	}
	1596	},
	1597	{
	1598	name: "Read API: fetch() patternMatch1",
	1599	runTest: function(datastore, t){
	1600	// summary:
	1601	// Function to test pattern matching of everything with $ in it.
	1602	// description:
	1603	// Function to test pattern matching of everything with $ in it.
	1604
	1605	var store = new datastore({data: { identifier: "uniqueId",
	1606	items: [ {uniqueId: 1, value:"foo*bar"},
	1607	{uniqueId: 2, value:"bar*foo"},
	1608	{uniqueId: 3, value:"boomBam"},
	1609	{uniqueId: 4, value:"bit$Bite"},
	1610	{uniqueId: 5, value:"ouagadogou"},
	1611	{uniqueId: 6, value:"BaBaMaSaRa***Foo"},
	1612	{uniqueId: 7, value:"squawl"},
	1613	{uniqueId: 8, value:"seaweed"},
	1614	{uniqueId: 9, value:"jfq4@#!$!@Rf14r14i5u"}
	1615	]
	1616	}
	1617	});
	1618
	1619	var d = new doh.Deferred();
	1620	function completed(items, request){
	1621	t.assertEqual(items.length, 2);
	1622	var passed = true;
	1623	for(var i = 0; i < items.length; i++){
	1624	var value = store.getValue(items[i], "value");
	1625	if(!(value === "bit$Bite" \|\| value === "jfq4@#!$!@Rf14r14i5u")){
	1626	passed=false;
	1627	break;
	1628	}
	1629	}
	1630	t.assertTrue(passed);
	1631	if (passed){
	1632	d.callback(true);
	1633	}else{
	1634	d.errback(new Error("Unexpected pattern matched. Filter failure."));
	1635	}
	1636	}
	1637	function error(error, request){
	1638	t.assertTrue(false);
	1639	d.errback(error);
	1640	}
	1641	store.fetch({query: {value: "$"}, onComplete: completed, onError: error});
	1642	return d;
	1643	}
	1644	},
	1645	{
	1646	name: "Read API: fetch() patternMatch2",
	1647	runTest: function(datastore, t){
	1648	// summary:
	1649	// Function to test exact pattern match
	1650	// description:
	1651	// Function to test exact pattern match
	1652
	1653	var store = new datastore({data: { identifier: "uniqueId",
	1654	items: [ {uniqueId: 1, value:"foo*bar"},
	1655	{uniqueId: 2, value:"bar*foo"},
	1656	{uniqueId: 3, value:"boomBam"},
	1657	{uniqueId: 4, value:"bit$Bite"},
	1658	{uniqueId: 5, value:"ouagadogou"},
	1659	{uniqueId: 6, value:"BaBaMaSaRa***Foo"},
	1660	{uniqueId: 7, value:"squawl"},
	1661	{uniqueId: 8, value:"seaweed"},
	1662	{uniqueId: 9, value:"jfq4@#!$!@Rf14r14i5u"}
	1663	]
	1664	}
	1665	});
	1666
	1667	var d = new doh.Deferred();
	1668	function completed(items, request){
	1669	t.assertEqual(items.length, 1);
	1670	var passed = true;
	1671	for(var i = 0; i < items.length; i++){
	1672	var value = store.getValue(items[i], "value");
	1673	if(!(value === "bar*foo")){
	1674	passed=false;
	1675	break;
	1676	}
	1677	}
	1678	t.assertTrue(passed);
	1679	if (passed){
	1680	d.callback(true);
	1681	}else{
	1682	d.errback(new Error("Unexpected abbreviation found, match failure."));
	1683	}
	1684	}
	1685	function error(error, request){
	1686	t.assertTrue(false);
	1687	d.errback(error);
	1688	}
	1689	store.fetch({query: {value: "bar\*foo"}, onComplete: completed, onError: error});
	1690	return d;
	1691	}
	1692	},
	1693	{
	1694	name: "Read API: fetch() patternMatch_caseSensitive",
	1695	runTest: function(datastore, t){
	1696	// summary:
	1697	// Function to test pattern matching of a pattern case-sensitively
	1698	// description:
	1699	// Function to test pattern matching of a pattern case-sensitively
	1700
	1701	var store = new datastore({data: { identifier: "uniqueId",
	1702	items: [ {uniqueId: 1, value:"foo*bar"},
	1703	{uniqueId: 2, value:"bar*foo"},
	1704	{uniqueId: 3, value:"BAR*foo"},
	1705	{uniqueId: 4, value:"BARBananafoo"}
	1706	]
	1707	}
	1708	});
	1709
	1710	var d = new doh.Deferred();
	1711	function completed(items, request){
	1712	t.assertEqual(1, items.length);
	1713	var passed = true;
	1714	for(var i = 0; i < items.length; i++){
	1715	var value = store.getValue(items[i], "value");
	1716	if(!(value === "bar*foo")){
	1717	passed=false;
	1718	break;
	1719	}
	1720	}
	1721	t.assertTrue(passed);
	1722	if (passed){
	1723	d.callback(true);
	1724	}else{
	1725	d.errback(new Error("Unexpected pattern matched. Filter failure."));
	1726	}
	1727	}
	1728	function error(error, request){
	1729	t.assertTrue(false);
	1730	d.errback(error);
	1731	}
	1732	store.fetch({query: {value: "bar\\*foo"}, queryOptions: {ignoreCase: false} , onComplete: completed, onError: error});
	1733	return d;
	1734	}
	1735	},
	1736	{
	1737	name: "Read API: fetch() patternMatch_caseInsensitive",
	1738	runTest: function(datastore, t){
	1739	// summary:
	1740	// Function to test pattern matching of a pattern case-insensitively
	1741	// description:
	1742	// Function to test pattern matching of a pattern case-insensitively
	1743
	1744	var store = new datastore({data: { identifier: "uniqueId",
	1745	items: [ {uniqueId: 1, value:"foo*bar"},
	1746	{uniqueId: 2, value:"bar*foo"},
	1747	{uniqueId: 3, value:"BAR*foo"},
	1748	{uniqueId: 4, value:"BARBananafoo"}
	1749	]
	1750	}
	1751	});
	1752
	1753	var d = new doh.Deferred();
	1754	function completed(items, request){
	1755	t.assertEqual(items.length, 2);
	1756	var passed = true;
	1757	for(var i = 0; i < items.length; i++){
	1758	var value = store.getValue(items[i], "value");
	1759	if(!(value === "BARfoo" \|\| value === "barfoo")){
	1760	passed=false;
	1761	break;
	1762	}
	1763	}
	1764	t.assertTrue(passed);
	1765	if (passed){
	1766	d.callback(true);
	1767	}else{
	1768	d.errback(new Error("Unexpected pattern matched. Filter failure."));
	1769	}
	1770	}
	1771	function error(error, request){
	1772	t.assertTrue(false);
	1773	d.errback(error);
	1774	}
	1775	store.fetch({query: {value: "bar\\*foo"}, queryOptions: {ignoreCase: true}, onComplete: completed, onError: error});
	1776	return d;
	1777	}
	1778	},
	1779	{
	1780	name: "Read API: fetch() sortNumeric",
	1781	runTest: function(datastore, t){
	1782	// summary:
	1783	// Function to test sorting numerically.
	1784	// description:
	1785	// Function to test sorting numerically.
	1786
	1787	var store = new datastore({data: { identifier: "uniqueId",
	1788	items: [ {uniqueId: 0, value:"fo\|o*b.ar"},
	1789	{uniqueId: 1, value:"ba\|r*foo"},
	1790	{uniqueId: 2, value:"boomBam"},
	1791	{uniqueId: 3, value:"bit$Bite"},
	1792	{uniqueId: 4, value:"ouagadogou"},
	1793	{uniqueId: 5, value:"jfq4@#!$!@\|f1.$4r14i5u"},
	1794	{uniqueId: 6, value:"BaB{aMa\|SaRa***F}oo"},
	1795	{uniqueId: 7, value:"squawl"},
	1796	{uniqueId: 9, value:"seaweed"},
	1797	{uniqueId: 10, value:"zulu"},
	1798	{uniqueId: 8, value:"seaweed"}
	1799	]
	1800	}
	1801	});
	1802
	1803	var d = new doh.Deferred();
	1804	function completed(items, request){
	1805	t.assertEqual(items.length, 11);
	1806	var passed = true;
	1807	for(var i = 0; i < items.length; i++){
	1808	var value = store.getValue(items[i], "value");
	1809	if(!(store.getValue(items[i], "uniqueId") === i)){
	1810	passed=false;
	1811	break;
	1812	}
	1813	}
	1814	t.assertTrue(passed);
	1815	if (passed){
	1816	d.callback(true);
	1817	}else{
	1818	d.errback(new Error("Unexpected sorting order found, sort failure."));
	1819	}
	1820	}
	1821
	1822	function error(error, request){
	1823	t.assertTrue(false);
	1824	d.errback(error);
	1825	}
	1826
	1827	var sortAttributes = [{attribute: "uniqueId"}];
	1828	store.fetch({onComplete: completed, onError: error, sort: sortAttributes});
	1829	return d;
	1830	}
	1831	},
	1832	{
	1833	name: "Read API: fetch() sortNumericDescending",
	1834	runTest: function(datastore, t){
	1835	// summary:
	1836	// Function to test sorting numerically.
	1837	// description:
	1838	// Function to test sorting numerically.
	1839
	1840	var store = new datastore({data: { identifier: "uniqueId",
	1841	items: [ {uniqueId: 0, value:"fo\|o*b.ar"},
	1842	{uniqueId: 1, value:"ba\|r*foo"},
	1843	{uniqueId: 2, value:"boomBam"},
	1844	{uniqueId: 3, value:"bit$Bite"},
	1845	{uniqueId: 4, value:"ouagadogou"},
	1846	{uniqueId: 5, value:"jfq4@#!$!@\|f1.$4r14i5u"},
	1847	{uniqueId: 6, value:"BaB{aMa\|SaRa***F}oo"},
	1848	{uniqueId: 7, value:"squawl"},
	1849	{uniqueId: 9, value:"seaweed"},
	1850	{uniqueId: 10, value:"zulu"},
	1851	{uniqueId: 8, value:"seaweed"}
	1852	]
	1853	}
	1854	});
	1855	var d = new doh.Deferred();
	1856	function completed(items, request){
	1857	t.assertEqual(items.length, 11);
	1858	var passed = true;
	1859	for(var i = 0; i < items.length; i++){
	1860	var value = store.getValue(items[i], "value");
	1861	if(!((items.length - (store.getValue(items[i], "uniqueId") + 1)) === i)){
	1862	passed=false;
	1863	break;
	1864	}
	1865	}
	1866	t.assertTrue(passed);
	1867	if (passed){
	1868	d.callback(true);
	1869	}else{
	1870	d.errback(new Error("Unexpected sorting order found, sort failure."));
	1871	}
	1872	}
	1873
	1874	function error(error, request){
	1875	t.assertTrue(false);
	1876	d.errback(error);
	1877	}
	1878
	1879	var sortAttributes = [{attribute: "uniqueId", descending: true}];
	1880	store.fetch({onComplete: completed, onError: error, sort: sortAttributes});
	1881	return d;
	1882	}
	1883	},
	1884	{
	1885	name: "Read API: fetch() sortNumericWithCount",
	1886	runTest: function(datastore, t){
	1887	// summary:
	1888	// Function to test sorting numerically in descending order, returning only a specified number of them.
	1889	// description:
	1890	// Function to test sorting numerically in descending order, returning only a specified number of them.
	1891
	1892	var store = new datastore({data: { identifier: "uniqueId",
	1893	items: [ {uniqueId: 0, value:"fo\|o*b.ar"},
	1894	{uniqueId: 1, value:"ba\|r*foo"},
	1895	{uniqueId: 2, value:"boomBam"},
	1896	{uniqueId: 3, value:"bit$Bite"},
	1897	{uniqueId: 4, value:"ouagadogou"},
	1898	{uniqueId: 5, value:"jfq4@#!$!@\|f1.$4r14i5u"},
	1899	{uniqueId: 6, value:"BaB{aMa\|SaRa***F}oo"},
	1900	{uniqueId: 7, value:"squawl"},
	1901	{uniqueId: 9, value:"seaweed"},
	1902	{uniqueId: 10, value:"zulu"},
	1903	{uniqueId: 8, value:"seaweed"}
	1904	]
	1905	}
	1906	});
	1907
	1908	var d = new doh.Deferred();
	1909	function completed(items, request){
	1910	t.assertEqual(items.length, 5);
	1911	var itemId = 10;
	1912	var passed = true;
	1913	for(var i = 0; i < items.length; i++){
	1914	var value = store.getValue(items[i], "value");
	1915	if(!(store.getValue(items[i], "uniqueId") === itemId)){
	1916	passed=false;
	1917	break;
	1918	}
	1919	itemId--; // Decrement the item id. We are descending sorted, so it should go 10, 9, 8, etc.
	1920	}
	1921	t.assertTrue(passed);
	1922	if (passed){
	1923	d.callback(true);
	1924	}else{
	1925	d.errback(new Error("Unexpected sorting order found, sort failure."));
	1926	}
	1927	}
	1928
	1929	function error(error, request){
	1930	t.assertTrue(false);
	1931	d.errback(error);
	1932	}
	1933
	1934	var sortAttributes = [{attribute: "uniqueId", descending: true}];
	1935	store.fetch({onComplete: completed, onError: error, sort: sortAttributes, count: 5});
	1936	return d;
	1937	}
	1938	},
	1939	{
	1940	name: "Read API: fetch() sortAlphabetic",
	1941	runTest: function(datastore, t){
	1942	// summary:
	1943	// Function to test sorting alphabetic ordering.
	1944	// description:
	1945	// Function to test sorting alphabetic ordering.
	1946
	1947	var store = new datastore({data: { identifier: "uniqueId",
	1948	items: [ {uniqueId: 0, value:"abc"},
	1949	{uniqueId: 1, value:"bca"},
	1950	{uniqueId: 2, value:"abcd"},
	1951	{uniqueId: 3, value:"abcdefg"},
	1952	{uniqueId: 4, value:"lmnop"},
	1953	{uniqueId: 5, value:"foghorn"},
	1954	{uniqueId: 6, value:"qberty"},
	1955	{uniqueId: 7, value:"qwerty"},
	1956	{uniqueId: 8, value:""},
	1957	{uniqueId: 9, value:"seaweed"},
	1958	{uniqueId: 10, value:"123abc"}
	1959
	1960	]
	1961	}
	1962	});
	1963
	1964	var d = new doh.Deferred();
	1965	function completed(items, request){
	1966	//Output should be in this order...
	1967	var orderedArray = [ "",
	1968	"123abc",
	1969	"abc",
	1970	"abcd",
	1971	"abcdefg",
	1972	"bca",
	1973	"foghorn",
	1974	"lmnop",
	1975	"qberty",
	1976	"qwerty",
	1977	"seaweed"
	1978	];
	1979	t.assertEqual(items.length, 11);
	1980	var passed = true;
	1981	for(var i = 0; i < items.length; i++){
	1982	var value = store.getValue(items[i], "value");
	1983	if(!(store.getValue(items[i], "value") === orderedArray[i])){
	1984	passed=false;
	1985	break;
	1986	}
	1987	}
	1988	t.assertTrue(passed);
	1989	if (passed){
	1990	d.callback(true);
	1991	}else{
	1992	d.errback(new Error("Unexpected sorting order found, sort failure."));
	1993	}
	1994	}
	1995
	1996	function error(error, request){
	1997	t.assertTrue(false);
	1998	d.errback(error);
	1999	}
	2000
	2001	var sortAttributes = [{attribute: "value"}];
	2002	store.fetch({onComplete: completed, onError: error, sort: sortAttributes});
	2003	return d;
	2004	}
	2005	},
	2006	{
	2007	name: "Read API: fetch() sortAlphabeticDescending",
	2008	runTest: function(datastore, t){
	2009	// summary:
	2010	// Function to test sorting alphabetic ordering in descending mode.
	2011	// description:
	2012	// Function to test sorting alphabetic ordering in descending mode.
	2013
	2014	var store = new datastore({data: { identifier: "uniqueId",
	2015	items: [ {uniqueId: 0, value:"abc"},
	2016	{uniqueId: 1, value:"bca"},
	2017	{uniqueId: 2, value:"abcd"},
	2018	{uniqueId: 3, value:"abcdefg"},
	2019	{uniqueId: 4, value:"lmnop"},
	2020	{uniqueId: 5, value:"foghorn"},
	2021	{uniqueId: 6, value:"qberty"},
	2022	{uniqueId: 7, value:"qwerty"},
	2023	{uniqueId: 8, value:""},
	2024	{uniqueId: 9, value:"seaweed"},
	2025	{uniqueId: 10, value:"123abc"}
	2026
	2027	]
	2028	}
	2029	});
	2030	var d = new doh.Deferred();
	2031	function completed(items, request){
	2032	//Output should be in this order...
	2033	var orderedArray = [ "",
	2034	"123abc",
	2035	"abc",
	2036	"abcd",
	2037	"abcdefg",
	2038	"bca",
	2039	"foghorn",
	2040	"lmnop",
	2041	"qberty",
	2042	"qwerty",
	2043	"seaweed"
	2044	];
	2045	orderedArray = orderedArray.reverse();
	2046	t.assertEqual(items.length, 11);
	2047
	2048	var passed = true;
	2049	for(var i = 0; i < items.length; i++){
	2050	var value = store.getValue(items[i], "value");
	2051	if(!(store.getValue(items[i], "value") === orderedArray[i])){
	2052	passed=false;
	2053	break;
	2054	}
	2055	}
	2056	t.assertTrue(passed);
	2057	if (passed){
	2058	d.callback(true);
	2059	}else{
	2060	d.errback(new Error("Unexpected sorting order found, sort failure."));
	2061	}
	2062	}
	2063
	2064	function error(error, request){
	2065	t.assertTrue(false);
	2066	d.errback(error);
	2067	}
	2068
	2069	var sortAttributes = [{attribute: "value", descending: true}];
	2070	store.fetch({onComplete: completed, onError: error, sort: sortAttributes});
	2071	return d;
	2072	}
	2073	},
	2074	{
	2075	name: "Read API: fetch() sortDate",
	2076	runTest: function(datastore, t){
	2077	// summary:
	2078	// Function to test sorting date.
	2079	// description:
	2080	// Function to test sorting date.
	2081
	2082	var store = new datastore({data: { identifier: "uniqueId",
	2083	items: [ {uniqueId: 0, value: new Date(0)},
	2084	{uniqueId: 1, value: new Date(100)},
	2085	{uniqueId: 2, value:new Date(1000)},
	2086	{uniqueId: 3, value:new Date(2000)},
	2087	{uniqueId: 4, value:new Date(3000)},
	2088	{uniqueId: 5, value:new Date(4000)},
	2089	{uniqueId: 6, value:new Date(5000)},
	2090	{uniqueId: 7, value:new Date(6000)},
	2091	{uniqueId: 8, value:new Date(7000)},
	2092	{uniqueId: 9, value:new Date(8000)},
	2093	{uniqueId: 10, value:new Date(9000)}
	2094
	2095	]
	2096	}
	2097	});
	2098
	2099	var d = new doh.Deferred();
	2100	function completed(items,request){
	2101	var orderedArray = [0,100,1000,2000,3000,4000,5000,6000,7000,8000,9000];
	2102	t.assertEqual(items.length, 11);
	2103	var passed = true;
	2104	for(var i = 0; i < items.length; i++){
	2105	var value = store.getValue(items[i], "value");
	2106	if(!(store.getValue(items[i], "value").getTime() === orderedArray[i])){
	2107	passed=false;
	2108	break;
	2109	}
	2110	}
	2111	t.assertTrue(passed);
	2112	if (passed){
	2113	d.callback(true);
	2114	}else{
	2115	d.errback(new Error("Unexpected sorting order found, sort failure."));
	2116	}
	2117	}
	2118
	2119	function error(error, request){
	2120	t.assertTrue(false);
	2121	d.errback(error);
	2122	}
	2123
	2124	var sortAttributes = [{attribute: "value"}];
	2125	store.fetch({onComplete: completed, onError: error, sort: sortAttributes});
	2126	return d;
	2127	}
	2128	},
	2129	{
	2130	name: "Read API: fetch() sortDateDescending",
	2131	runTest: function(datastore, t){
	2132	// summary:
	2133	// Function to test sorting date in descending order.
	2134	// description:
	2135	// Function to test sorting date in descending order.
	2136
	2137	var store = new datastore({data: { identifier: "uniqueId",
	2138	items: [ {uniqueId: 0, value: new Date(0)},
	2139	{uniqueId: 1, value: new Date(100)},
	2140	{uniqueId: 2, value:new Date(1000)},
	2141	{uniqueId: 3, value:new Date(2000)},
	2142	{uniqueId: 4, value:new Date(3000)},
	2143	{uniqueId: 5, value:new Date(4000)},
	2144	{uniqueId: 6, value:new Date(5000)},
	2145	{uniqueId: 7, value:new Date(6000)},
	2146	{uniqueId: 8, value:new Date(7000)},
	2147	{uniqueId: 9, value:new Date(8000)},
	2148	{uniqueId: 10, value:new Date(9000)}
	2149
	2150	]
	2151	}
	2152	});
	2153
	2154	var d = new doh.Deferred();
	2155	function completed(items,request){
	2156	var orderedArray = [0,100,1000,2000,3000,4000,5000,6000,7000,8000,9000];
	2157	orderedArray = orderedArray.reverse();
	2158	t.assertEqual(items.length, 11);
	2159	var passed = true;
	2160	for(var i = 0; i < items.length; i++){
	2161	var value = store.getValue(items[i], "value");
	2162	if(!(store.getValue(items[i], "value").getTime() === orderedArray[i])){
	2163	passed=false;
	2164	break;
	2165	}
	2166	}
	2167	t.assertTrue(passed);
	2168	if (passed){
	2169	d.callback(true);
	2170	}else{
	2171	d.errback(new Error("Unexpected sorting order found, sort failure."));
	2172	}
	2173	}
	2174
	2175	function error(error, request){
	2176	t.assertTrue(false);
	2177	d.errback(error);
	2178	}
	2179
	2180	var sortAttributes = [{attribute: "value", descending: true}];
	2181	store.fetch({onComplete: completed, onError: error, sort: sortAttributes});
	2182	return d;
	2183	}
	2184	},
	2185	{
	2186	name: "Read API: fetch() sortMultiple",
	2187	runTest: function(datastore, t){
	2188	// summary:
	2189	// Function to test sorting on multiple attributes.
	2190	// description:
	2191	// Function to test sorting on multiple attributes.
	2192
	2193	var store = new datastore({data: { identifier: "uniqueId",
	2194	items: [ {uniqueId: 1, value:"fo\|o*b.ar"},
	2195	{uniqueId: 2, value:"ba\|r*foo"},
	2196	{uniqueId: 3, value:"boomBam"},
	2197	{uniqueId: 4, value:"bit$Bite"},
	2198	{uniqueId: 5, value:"ouagadogou"},
	2199	{uniqueId: 6, value:"jfq4@#!$!@\|f1.$4r14i5u"},
	2200	{uniqueId: 7, value:"BaB{aMa\|SaRa***F}oo"},
	2201	{uniqueId: 8, value:"squawl"},
	2202	{uniqueId: 10, value:"seaweed"},
	2203	{uniqueId: 12, value:"seaweed"},
	2204	{uniqueId: 11, value:"zulu"},
	2205	{uniqueId: 9, value:"seaweed"}
	2206	]
	2207	}
	2208	});
	2209
	2210	var d = new doh.Deferred();
	2211	function completed(items, request){
	2212	var orderedArray0 = [7,2,4,3,1,6,5,12,10,9,8,11];
	2213	var orderedArray1 = [ "BaB{aMa\|SaRa***F}oo",
	2214	"ba\|r*foo",
	2215	"bit$Bite",
	2216	"boomBam",
	2217	"fo\|o*b.ar",
	2218	"jfq4@#!$!@\|f1.$4r14i5u",
	2219	"ouagadogou",
	2220	"seaweed",
	2221	"seaweed",
	2222	"seaweed",
	2223	"squawl",
	2224	"zulu"
	2225	];
	2226	var passed = true;
	2227	for(var i = 0; i < items.length; i++){
	2228	var value = store.getValue(items[i], "value");
	2229	if(!( (store.getValue(items[i], "uniqueId") === orderedArray0[i])&&
	2230	(store.getValue(items[i], "value") === orderedArray1[i]))
	2231	){
	2232	passed=false;
	2233	break;
	2234	}
	2235	}
	2236	t.assertTrue(passed);
	2237	if (passed){
	2238	d.callback(true);
	2239	}else{
	2240	d.errback(new Error("Unexpected sorting order found, sort failure."));
	2241	}
	2242	}
	2243
	2244	function error(error, request){
	2245	t.assertTrue(false);
	2246	d.errback(error);
	2247	}
	2248
	2249	var sortAttributes = [{ attribute: "value"}, { attribute: "uniqueId", descending: true}];
	2250	store.fetch({onComplete: completed, onError: error, sort: sortAttributes});
	2251	return d;
	2252	}
	2253	},
	2254	{
	2255	name: "Read API: fetch() sortMultipleSpecialComparator",
	2256	runTest: function(datastore, t){
	2257	// summary:
	2258	// Function to test sorting on multiple attributes with a custom comparator.
	2259	// description:
	2260	// Function to test sorting on multiple attributes with a custom comparator.
	2261
	2262	var store = new datastore({data: { identifier: "uniqueId",
	2263	items: [ {uniqueId: 1, status:"CLOSED"},
	2264	{uniqueId: 2, status:"OPEN"},
	2265	{uniqueId: 3, status:"PENDING"},
	2266	{uniqueId: 4, status:"BLOCKED"},
	2267	{uniqueId: 5, status:"CLOSED"},
	2268	{uniqueId: 6, status:"OPEN"},
	2269	{uniqueId: 7, status:"PENDING"},
	2270	{uniqueId: 8, status:"PENDING"},
	2271	{uniqueId: 10, status:"BLOCKED"},
	2272	{uniqueId: 12, status:"BLOCKED"},
	2273	{uniqueId: 11, status:"OPEN"},
	2274	{uniqueId: 9, status:"CLOSED"}
	2275	]
	2276	}
	2277	});
	2278
	2279
	2280	store.comparatorMap = {};
	2281	store.comparatorMap["status"] = function(a,b){
	2282	var ret = 0;
	2283	// We want to map these by what the priority of these items are, not by alphabetical.
	2284	// So, custom comparator.
	2285	var enumMap = { OPEN: 3, BLOCKED: 2, PENDING: 1, CLOSED: 0};
	2286	if (enumMap[a] > enumMap[b]){
	2287	ret = 1;
	2288	}
	2289	if (enumMap[a] < enumMap[b]){
	2290	ret = -1;
	2291	}
	2292	return ret;
	2293	};
	2294
	2295	var sortAttributes = [{attribute: "status", descending: true}, { attribute: "uniqueId", descending: true}];
	2296
	2297	var d = new doh.Deferred();
	2298	function completed(items, findResult){
	2299	var orderedArray = [11,6,2,12,10,4,8,7,3,9,5,1];
	2300	var passed = true;
	2301	for(var i = 0; i < items.length; i++){
	2302	var value = store.getValue(items[i], "value");
	2303	if(!(store.getValue(items[i], "uniqueId") === orderedArray[i])){
	2304	passed=false;
	2305	break;
	2306	}
	2307	}
	2308	t.assertTrue(passed);
	2309	if (passed){
	2310	d.callback(true);
	2311	}else{
	2312	d.errback(new Error("Unexpected sorting order found, sort failure."));
	2313	}
	2314	}
	2315
	2316	function error(errData, request){
	2317	t.assertTrue(false);
	2318	d.errback(errData);
	2319	}
	2320	store.fetch({onComplete: completed, onError: error, sort: sortAttributes});
	2321	return d;
	2322	}
	2323	},
	2324	{
	2325	name: "Read API: fetch() sortAlphabeticWithUndefined",
	2326	runTest: function(datastore, t){
	2327	// summary:
	2328	// Function to test sorting alphabetic ordering.
	2329	// description:
	2330	// Function to test sorting alphabetic ordering.
	2331
	2332	var store = new datastore({data: { identifier: "uniqueId",
	2333	items: [ {uniqueId: 0, value:"abc"},
	2334	{uniqueId: 1, value:"bca"},
	2335	{uniqueId: 2, value:"abcd"},
	2336	{uniqueId: 3, value:"abcdefg"},
	2337	{uniqueId: 4, value:"lmnop"},
	2338	{uniqueId: 5, value:"foghorn"},
	2339	{uniqueId: 6, value:"qberty"},
	2340	{uniqueId: 7, value:"qwerty"},
	2341	{uniqueId: 8 }, //Deliberate undefined value
	2342	{uniqueId: 9, value:"seaweed"},
	2343	{uniqueId: 10, value:"123abc"}
	2344
	2345	]
	2346	}
	2347	});
	2348
	2349	var d = new doh.Deferred();
	2350	function completed(items, request){
	2351	//Output should be in this order...
	2352	var orderedArray = [10,0,2,3,1,5,4,6,7,9,8];
	2353	t.assertEqual(items.length, 11);
	2354	var passed = true;
	2355	for(var i = 0; i < items.length; i++){
	2356	if(!(store.getValue(items[i], "uniqueId") === orderedArray[i])){
	2357	passed=false;
	2358	break;
	2359	}
	2360	}
	2361	t.assertTrue(passed);
	2362	if (passed){
	2363	d.callback(true);
	2364	}else{
	2365	d.errback(new Error("Unexpected sorting order found, sort failure."));
	2366	}
	2367	}
	2368
	2369	function error(error, request){
	2370	t.assertTrue(false);
	2371	d.errback(error);
	2372	}
	2373
	2374	var sortAttributes = [{attribute: "value"}];
	2375	store.fetch({onComplete: completed, onError: error, sort: sortAttributes});
	2376	return d;
	2377	}
	2378	},
	2379	{
	2380	name: "Read API: errorCondition_idCollision_inMemory",
	2381	runTest: function(datastore, t){
	2382	// summary:
	2383	// Simple test of the errors thrown when there is an id collision in the data.
	2384	// Added because of tracker: #2546
	2385	// description:
	2386	// Simple test of the errors thrown when there is an id collision in the data.
	2387	// Added because of tracker: #2546
	2388
	2389	var store = new datastore({ data: { identifier: "uniqueId",
	2390	items: [{uniqueId: 12345, value:"foo"},
	2391	{uniqueId: 123456, value:"bar"},
	2392	{uniqueId: 12345, value:"boom"},
	2393	{uniqueId: 123457, value:"bit"}
	2394	]
	2395	}
	2396	});
	2397	var d = new doh.Deferred();
	2398	function onComplete(items, request){
	2399	//This is bad if this fires, this case should fail and not call onComplete.
	2400	t.assertTrue(false);
	2401	d.callback(false);
	2402	}
	2403
	2404	function reportError(errData, request){
	2405	//This is good if this fires, it is expected.
	2406	t.assertTrue(true);
	2407	d.callback(true);
	2408	}
	2409	store.fetch({onComplete: onComplete, onError: reportError});
	2410	return d;
	2411	}
	2412	},
	2413	{
	2414	name: "Read API: errorCondition_idCollision_xhr",
	2415	runTest: function(datastore, t){
	2416	// summary:
	2417	// Simple test of the errors thrown when there is an id collision in the data.
	2418	// Added because of tracker: #2546
	2419	// description:
	2420	// Simple test of the errors thrown when there is an id collision in the data.
	2421	// Added because of tracker: #2546
	2422
	2423	if(dojo.isBrowser){
	2424	var store = new datastore({url: require.toUrl("./countries_idcollision.json")});
	2425	var d = new doh.Deferred();
	2426	function onComplete(items, request){
	2427	//This is bad if this fires, this case should fail and not call onComplete.
	2428	t.assertTrue(false);
	2429	d.callback(false);
	2430	}
	2431
	2432	function reportError(errData, request){
	2433	//This is good if this fires, it is expected.
	2434	t.assertTrue(true);
	2435	d.callback(true);
	2436	}
	2437	store.fetch({onComplete: onComplete, onError: reportError});
	2438	return d;
	2439	}
	2440	}
	2441	},
	2442	{
	2443	name: "Read API: Date_datatype",
	2444	runTest: function(datastore, t){
	2445	//var store = new datastore(tests.data.readOnlyItemFileTestTemplates.testFile["countries_withDates"]);
	2446	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries_withDates"));
	2447
	2448	var d = new doh.Deferred();
	2449	function onItem(item){
	2450	t.assertTrue(item !== null);
	2451	var independenceDate = store.getValue(item, "independence");
	2452	t.assertTrue(independenceDate instanceof Date);
	2453	//Check to see if the value was deserialized properly. Since the store stores in UTC/GMT, it
	2454	//should also be compared in the UTC/GMT mode
	2455	t.assertTrue(dojo.date.stamp.toISOString(independenceDate, {zulu:true}) === "1993-05-24T00:00:00Z");
	2456	d.callback(true);
	2457	}
	2458	function onError(errData){
	2459	t.assertTrue(false);
	2460	d.errback(errData);
	2461	}
	2462	store.fetchItemByIdentity({identity:"er", onItem:onItem, onError:onError});
	2463	return d; // Deferred
	2464	}
	2465	},
	2466	{
	2467	name: "Read API: custom_datatype_Color_SimpleMapping",
	2468	runTest: function(datastore, t){
	2469	// summary:
	2470	// Function to test using literal values with custom datatypes
	2471	var dataset = {
	2472	identifier:'name',
	2473	items: [
	2474	{ name:'Kermit', species:'frog', color:{_type:'Color', _value:'green'} },
	2475	{ name:'Beaker', hairColor:{_type:'Color', _value:'red'} }
	2476	]
	2477	};
	2478	var store = new datastore({
	2479	data:dataset,
	2480	typeMap:{'Color': dojo.Color}
	2481	});
	2482	var d = new doh.Deferred();
	2483	function onItem(item){
	2484	t.assertTrue(item !== null);
	2485	var beaker = item;
	2486	var hairColor = store.getValue(beaker, "hairColor");
	2487	t.assertTrue(hairColor instanceof dojo.Color);
	2488	t.assertTrue(hairColor.toHex() == "#ff0000");
	2489	d.callback(true);
	2490	}
	2491	function onError(errData){
	2492	d.errback(errData);
	2493	}
	2494	store.fetchItemByIdentity({identity:"Beaker", onItem:onItem, onError:onError});
	2495	return d; // Deferred
	2496	}
	2497	},
	2498	{
	2499	name: "Read API: custom_datatype_Color_GeneralMapping",
	2500	runTest: function(datastore, t){
	2501	// summary:
	2502	// Function to test using literal values with custom datatypes
	2503	var dataset = {
	2504	identifier:'name',
	2505	items: [
	2506	{ name:'Kermit', species:'frog', color:{_type:'Color', _value:'green'} },
	2507	{ name:'Beaker', hairColor:{_type:'Color', _value:'red'} }
	2508	]
	2509	};
	2510	var store = new datastore({
	2511	data:dataset,
	2512	typeMap:{'Color': {
	2513	type: dojo.Color,
	2514	deserialize: function(value){
	2515	return new dojo.Color(value);
	2516	}
	2517	}
	2518	}
	2519	});
	2520	var d = new doh.Deferred();
	2521	function onItem(item){
	2522	t.assertTrue(item !== null);
	2523	var beaker = item;
	2524	var hairColor = store.getValue(beaker, "hairColor");
	2525	t.assertTrue(hairColor instanceof dojo.Color);
	2526	t.assertTrue(hairColor.toHex() == "#ff0000");
	2527	d.callback(true);
	2528	}
	2529	function onError(errData){
	2530	d.errback(errData);
	2531	}
	2532	store.fetchItemByIdentity({identity:"Beaker", onItem:onItem, onError:onError});
	2533	return d; // Deferred
	2534	}
	2535	},
	2536	{
	2537	name: "Read API: custom_datatype_CustomObject 0 (False) value",
	2538	runTest: function(datastore, t){
	2539	// summary:
	2540	// Function to test type mapping and _values that are false-like
	2541	var dataset = {
	2542	identifier:'name',
	2543	items: [
	2544	{ name:'Bob', species:'human', age: {_type:'tests.data.Wrapper', _value:0} },
	2545	{ name:'Nancy', species:'human', age: {_type:'tests.data.Wrapper', _value:32} }
	2546	]
	2547	};
	2548	var store = new datastore({
	2549	data:dataset,
	2550	typeMap:{'tests.data.Wrapper': {
	2551	type: tests.data.Wrapper,
	2552	deserialize: function(value){
	2553	return new tests.data.Wrapper(value);
	2554	}
	2555	}
	2556	}
	2557	});
	2558	var d = new doh.Deferred();
	2559	function onItem(item){
	2560	t.assertTrue(item !== null);
	2561	var bob = item;
	2562	var age = store.getValue(item, "age");
	2563	t.assertTrue(age instanceof tests.data.Wrapper);
	2564	t.assertTrue(age.toString() == "WRAPPER: [0]");
	2565	d.callback(true);
	2566	}
	2567	function onError(errData){
	2568	d.errback(errData);
	2569	}
	2570	store.fetchItemByIdentity({identity:"Bob", onItem:onItem, onError:onError});
	2571	return d; // Deferred
	2572	}
	2573	},
	2574	{
	2575	name: "Read API: custom_datatype_CustomObject Boolean False values",
	2576	runTest: function(datastore, t){
	2577	// summary:
	2578	// Function to test type mapping and _values that are false-like
	2579	var dataset = {
	2580	identifier:'name',
	2581	items: [
	2582	{ name:'Bob', isHuman: {_type:'tests.data.Wrapper', _value:false} },
	2583	{ name:'Nancy', isHuman: {_type:'tests.data.Wrapper', _value: true} }
	2584	]
	2585	};
	2586	var store = new datastore({
	2587	data:dataset,
	2588	typeMap:{'tests.data.Wrapper': {
	2589	type: tests.data.Wrapper,
	2590	deserialize: function(value){
	2591	return new tests.data.Wrapper(value);
	2592	}
	2593	}
	2594	}
	2595	});
	2596	var d = new doh.Deferred();
	2597	function onItem(item){
	2598	t.assertTrue(item !== null);
	2599	var bob = item;
	2600	var isHuman = store.getValue(item, "isHuman");
	2601	t.assertTrue(isHuman instanceof tests.data.Wrapper);
	2602	t.assertTrue(isHuman.toString() == "WRAPPER: [false]");
	2603	d.callback(true);
	2604	}
	2605	function onError(errData){
	2606	d.errback(errData);
	2607	}
	2608	store.fetchItemByIdentity({identity:"Bob", onItem:onItem, onError:onError});
	2609	return d; // Deferred
	2610	}
	2611	},
	2612	{
	2613	name: "Read API: custom_datatype_CustomObject Empty String values",
	2614	runTest: function(datastore, t){
	2615	// summary:
	2616	// Function to test type mapping and _values that are false-like
	2617	var dataset = {
	2618	identifier:'name',
	2619	items: [
	2620	{ name:'Bob', lastName: {_type:'tests.data.Wrapper', _value:""} },
	2621	{ name:'Nancy', lastName: {_type:'tests.data.Wrapper', _value: "Doe"} }
	2622	]
	2623	};
	2624	var store = new datastore({
	2625	data:dataset,
	2626	typeMap:{'tests.data.Wrapper': {
	2627	type: tests.data.Wrapper,
	2628	deserialize: function(value){
	2629	return new tests.data.Wrapper(value);
	2630	}
	2631	}
	2632	}
	2633	});
	2634	var d = new doh.Deferred();
	2635	function onItem(item){
	2636	t.assertTrue(item !== null);
	2637	var bob = item;
	2638	var lastName = store.getValue(item, "lastName");
	2639	t.assertTrue(lastName instanceof tests.data.Wrapper);
	2640	t.assertTrue(lastName.toString() == "WRAPPER: []");
	2641	d.callback(true);
	2642	}
	2643	function onError(errData){
	2644	d.errback(errData);
	2645	}
	2646	store.fetchItemByIdentity({identity:"Bob", onItem:onItem, onError:onError});
	2647	return d; // Deferred
	2648	}
	2649	},
	2650	{
	2651	name: "Read API: custom_datatype_CustomObject explicit null values",
	2652	runTest: function(datastore, t){
	2653	// summary:
	2654	// Function to test type mapping and _values that are false-like
	2655	var dataset = {
	2656	identifier:'name',
	2657	items: [
	2658	{ name:'Bob', lastName: {_type:'tests.data.Wrapper', _value:null} },
	2659	{ name:'Nancy', lastName: {_type:'tests.data.Wrapper', _value: "Doe"} }
	2660	]
	2661	};
	2662	var store = new datastore({
	2663	data:dataset,
	2664	typeMap:{'tests.data.Wrapper': {
	2665	type: tests.data.Wrapper,
	2666	deserialize: function(value){
	2667	return new tests.data.Wrapper(value);
	2668	}
	2669	}
	2670	}
	2671	});
	2672	var d = new doh.Deferred();
	2673	function onItem(item){
	2674	t.assertTrue(item !== null);
	2675	var bob = item;
	2676	var lastName = store.getValue(item, "lastName");
	2677	t.assertTrue(lastName instanceof tests.data.Wrapper);
	2678	t.assertTrue(lastName.toString() == "WRAPPER: [null]");
	2679	d.callback(true);
	2680	}
	2681	function onError(errData){
	2682	d.errback(errData);
	2683	}
	2684	store.fetchItemByIdentity({identity:"Bob", onItem:onItem, onError:onError});
	2685	return d; // Deferred
	2686	}
	2687	},
	2688	{
	2689	name: "Read API: custom_datatype_CustomObject explicit undefined value",
	2690	runTest: function(datastore, t){
	2691	// summary:
	2692	// Function to test type mapping and _values that are false-like
	2693	var dataset = {
	2694	identifier:'name',
	2695	items: [
	2696	{ name:'Bob', lastName: {_type:'tests.data.Wrapper', _value: undefined} },
	2697	{ name:'Nancy', lastName: {_type:'tests.data.Wrapper', _value: "Doe"} }
	2698	]
	2699	};
	2700	var store = new datastore({
	2701	data:dataset,
	2702	typeMap:{'tests.data.Wrapper': {
	2703	type: tests.data.Wrapper,
	2704	deserialize: function(value){
	2705	return new tests.data.Wrapper(value);
	2706	}
	2707	}
	2708	}
	2709	});
	2710	var d = new doh.Deferred();
	2711	function onItem(item){
	2712	t.assertTrue(item !== null);
	2713	var bob = item;
	2714	var lastName = store.getValue(item, "lastName");
	2715	t.assertTrue(lastName instanceof tests.data.Wrapper);
	2716	t.assertTrue(lastName.toString() == "WRAPPER: [undefined]");
	2717	d.callback(true);
	2718	}
	2719	function onError(errData){
	2720	d.errback(errData);
	2721	}
	2722	store.fetchItemByIdentity({identity:"Bob", onItem:onItem, onError:onError});
	2723	return d; // Deferred
	2724	}
	2725	},
	2726	{
	2727	name: "Read API: hierarchical_data",
	2728	runTest: function(datastore, t){
	2729	//var store = new datastore(tests.data.readOnlyItemFileTestTemplates.testFile["geography_hierarchy_small"]);
	2730	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("geography_hierarchy_small"));
	2731	var d = new doh.Deferred();
	2732	function onComplete(items, request){
	2733	t.assertEqual(items.length, 1);
	2734	var northAmerica = items[0];
	2735	var canada = store.getValue(northAmerica, "countries");
	2736	var toronto = store.getValue(canada, "cities");
	2737	t.assertEqual(store.getValue(canada, "name"), "Canada");
	2738	t.assertEqual(store.getValue(toronto, "name"), "Toronto");
	2739	d.callback(true);
	2740	}
	2741	function onError(errData){
	2742	d.errback(errData);
	2743	}
	2744	store.fetch({
	2745	query: {name: "North America"},
	2746	onComplete: onComplete,
	2747	onError: onError
	2748	});
	2749
	2750	return d; // Deferred
	2751	}
	2752	},
	2753	{
	2754	name: "Read API: close (clearOnClose: true)",
	2755	runTest: function(datastore, t){
	2756	// summary:
	2757	// Function to test the close api properly clears the store for reload when clearOnClose is set.
	2758	if (dojo.isBrowser){
	2759	var params = tests.data.readOnlyItemFileTestTemplates.getTestData("countries");
	2760	params.clearOnClose = true;
	2761	params.urlPreventCache = true;
	2762	var store = new datastore(params);
	2763
	2764	var d = new doh.Deferred();
	2765	function onItem(item){
	2766	var error = null;
	2767	try {
	2768	t.assertTrue(item !== null);
	2769	var ec = item;
	2770	var val = store.getValue(ec, "name");
	2771	t.assertEqual("Ecuador", val);
	2772
	2773	store.close();
	2774	//Check some internals here. Do not normally access these!
	2775	t.assertTrue(store._arrayOfAllItems.length === 0);
	2776	t.assertTrue(store._loadFinished === false);
	2777	}catch (e){
	2778	error = e;
	2779	}
	2780	if (error){
	2781	d.errback(error);
	2782	}else{
	2783	d.callback(true);
	2784	}
	2785	}
	2786	function onError(errData){
	2787	d.errback(errData);
	2788	}
	2789	store.fetchItemByIdentity({identity:"ec", onItem:onItem, onError:onError});
	2790	return d; // Deferred
	2791	}
	2792	}
	2793	},
	2794	{
	2795	name: "Read API: close (clearOnClose: true, reset url.)",
	2796	runTest: function(datastore, t){
	2797	// summary:
	2798	// Function to test the close api properly clears the store for reload when clearOnClose is set.
	2799	if (dojo.isBrowser){
	2800	var params = tests.data.readOnlyItemFileTestTemplates.getTestData("countries");
	2801	params.clearOnClose = true;
	2802	params.urlPreventCache = true;
	2803	var store = new datastore(params);
	2804
	2805	var d = new doh.Deferred();
	2806	function onItem(item){
	2807	var error = null;
	2808	try {
	2809	t.assertTrue(item !== null);
	2810	var ec = item;
	2811	var val = store.getValue(ec, "name");
	2812	t.assertEqual("Ecuador", val);
	2813
	2814	store.close();
	2815	//Check some internals here. Do not normally access these!
	2816	t.assertTrue(store._arrayOfAllItems.length === 0);
	2817	t.assertTrue(store._loadFinished === false);
	2818
	2819	store.url = require.toUrl("./countries_withNull.json");
	2820	function onItem2 (item){
	2821	var err;
	2822	try{
	2823	t.assertTrue(item !== null);
	2824	var val = store.getValue(item, "name");
	2825	t.assertEqual(null, val);
	2826	}catch(e){
	2827	err = e;
	2828	}
	2829	if(err){
	2830	d.errback(err);
	2831	}else{
	2832	d.callback(true);
	2833	}
	2834	}
	2835	store.fetchItemByIdentity({identity:"ec", onItem:onItem2, onError:onError});
	2836	}catch (e){
	2837	error = e;
	2838	}
	2839	if (error){
	2840	d.errback(error);
	2841	}
	2842	}
	2843	function onError(errData){
	2844	d.errback(errData);
	2845	}
	2846	store.fetchItemByIdentity({identity:"ec", onItem:onItem, onError:onError});
	2847	return d; // Deferred
	2848	}
	2849	}
	2850	},
	2851	{
	2852	name: "Read API: fetch, close (clearOnClose: true, reset url.)",
	2853	runTest: function(datastore, t){
	2854	// summary:
	2855	// Function to test the close api properly clears the store for reload when clearOnClose is set.
	2856	if (dojo.isBrowser){
	2857	var params = tests.data.readOnlyItemFileTestTemplates.getTestData("countries");
	2858	params.clearOnClose = true;
	2859	params.urlPreventCache = true;
	2860	var store = new datastore(params);
	2861
	2862	var d = new doh.Deferred();
	2863	function onItem(item){
	2864	var error = null;
	2865	try {
	2866	t.assertTrue(item !== null);
	2867	var ec = item;
	2868	var val = store.getValue(ec, "name");
	2869	t.assertEqual("Ecuador", val);
	2870
	2871	store.close();
	2872	//Check some internals here. Do not normally access these!
	2873	t.assertTrue(store._arrayOfAllItems.length === 0);
	2874	t.assertTrue(store._loadFinished === false);
	2875
	2876	store.url = require.toUrl("./countries_withNull.json");
	2877	function onComplete (items){
	2878	var err;
	2879	try{
	2880	t.assertEqual(1, items.length);
	2881	var item = items[0];
	2882	t.assertTrue(item !== null);
	2883	var val = store.getValue(item, "name");
	2884	t.assertEqual(null, val);
	2885	}catch(e){
	2886	err = e;
	2887	}
	2888	if(err){
	2889	d.errback(err);
	2890	}else{
	2891	d.callback(true);
	2892	}
	2893	}
	2894	store.fetch({query: {abbr:"ec"}, onComplete:onComplete, onError:onError});
	2895	}catch (e){
	2896	error = e;
	2897	}
	2898	if (error){
	2899	d.errback(error);
	2900	}
	2901	}
	2902	function onError(errData){
	2903	d.errback(errData);
	2904	}
	2905	store.fetchItemByIdentity({identity:"ec", onItem:onItem, onError:onError});
	2906	return d; // Deferred
	2907	}
	2908	}
	2909	},
	2910	{
	2911	name: "Read API: close (clearOnClose: true, reset _jsonFileUrl.)",
	2912	runTest: function(datastore, t){
	2913	// summary:
	2914	// Function to test the close api properly clears the store for reload when clearOnClose is set.
	2915	if (dojo.isBrowser){
	2916	var params = tests.data.readOnlyItemFileTestTemplates.getTestData("countries");
	2917	params.clearOnClose = true;
	2918	params.urlPreventCache = true;
	2919	var store = new datastore(params);
	2920
	2921	var d = new doh.Deferred();
	2922	function onItem(item){
	2923	var error = null;
	2924	try {
	2925	t.assertTrue(item !== null);
	2926	var ec = item;
	2927	var val = store.getValue(ec, "name");
	2928	t.assertEqual("Ecuador", val);
	2929
	2930	store.close();
	2931	//Check some internals here. Do not normally access these!
	2932	t.assertTrue(store._arrayOfAllItems.length === 0);
	2933	t.assertTrue(store._loadFinished === false);
	2934
	2935	store._jsonFileUrl = require.toUrl("./countries_withNull.json");
	2936	function onItem2 (item){
	2937	var err;
	2938	try{
	2939	t.assertTrue(item !== null);
	2940	var val = store.getValue(item, "name");
	2941	t.assertEqual(null, val);
	2942	}catch(e){
	2943	err = e;
	2944	}
	2945	if(err){
	2946	d.errback(err);
	2947	}else{
	2948	d.callback(true);
	2949	}
	2950	}
	2951	store.fetchItemByIdentity({identity:"ec", onItem:onItem2, onError:onError});
	2952	}catch (e){
	2953	error = e;
	2954	}
	2955	if (error){
	2956	d.errback(error);
	2957	}
	2958	}
	2959	function onError(errData){
	2960	d.errback(errData);
	2961	}
	2962	store.fetchItemByIdentity({identity:"ec", onItem:onItem, onError:onError});
	2963	return d; // Deferred
	2964	}
	2965	}
	2966	},
	2967	{
	2968	name: "Read API: close (clearOnClose: false)",
	2969	runTest: function(datastore, t){
	2970	// summary:
	2971	// Function to test the close api properly clears the store for reload when clearOnClose is set.
	2972	if (dojo.isBrowser){
	2973	var params = tests.data.readOnlyItemFileTestTemplates.getTestData("countries");
	2974	params.urlPreventCache = true;
	2975	var store = new datastore(params);
	2976
	2977	var d = new doh.Deferred();
	2978	function onItem(item){
	2979	var error = null;
	2980	try {
	2981	t.assertTrue(item !== null);
	2982	var ec = item;
	2983	var val = store.getValue(ec, "name");
	2984	t.assertEqual("Ecuador", val);
	2985
	2986	store.close();
	2987	//Check some internals here. Do not normally access these!
	2988	t.assertTrue(store._arrayOfAllItems.length !== 0);
	2989	t.assertTrue(store._loadFinished === true);
	2990	}catch (e){
	2991	error = e;
	2992	}
	2993	if (error){
	2994	d.errback(error);
	2995	}else{
	2996	d.callback(true);
	2997	}
	2998	}
	2999	function onError(errData){
	3000	d.errback(errData);
	3001	}
	3002	store.fetchItemByIdentity({identity:"ec", onItem:onItem, onError:onError});
	3003	return d; // Deferred
	3004	}
	3005	}
	3006	},
	3007	{
	3008	name: "Read API: close (clearOnClose: true, reset data.)",
	3009	runTest: function(datastore, t){
	3010	// summary:
	3011	// Function to test that clear on close and reset of data works.
	3012	// description:
	3013	// Function to test that clear on close and reset of data works.
	3014	var store = new datastore({data: { identifier: "uniqueId",
	3015	items: [ {uniqueId: 1, value:"foo*bar"},
	3016	{uniqueId: 2, value:"bar*foo"},
	3017	{uniqueId: 3, value:"boomBam"},
	3018	{uniqueId: 4, value:"bit$Bite"},
	3019	{uniqueId: 5, value:"ouagadogou"},
	3020	{uniqueId: 6, value:"BaBaMaSaRa***Foo"},
	3021	{uniqueId: 7, value:"squawl"},
	3022	{uniqueId: 8, value:"seaweed"},
	3023	{uniqueId: 9, value:"jfq4@#!$!@Rf14r14i5u"}
	3024	]
	3025	}
	3026	});
	3027
	3028	var d = new doh.Deferred();
	3029	var firstComplete = function(items, request){
	3030	t.assertEqual(items.length, 1);
	3031	var firstItem = items[0];
	3032
	3033	//Set the store clearing options and the new data
	3034	store.clearOnClose = true;
	3035	store.data = { identifier: "uniqueId",
	3036	items: [
	3037	{uniqueId: 1, value:"foo*bar"},
	3038	{uniqueId: 2, value:"bar*foo"},
	3039	{uniqueId: 3, value:"boomBam"},
	3040	{uniqueId: 4, value:"bit$Bite"},
	3041	{uniqueId: 5, value:"ouagadogou"},
	3042	{uniqueId: 6, value:"BaBaMaSaRa***Foo"},
	3043	{uniqueId: 7, value:"squawl"},
	3044	{uniqueId: 8, value:"seaweed"},
	3045	{uniqueId: 9, value:"jfq4@#!$!@Rf14r14i5u"}
	3046	]
	3047	};
	3048	store.close();
	3049
	3050	//Do the next fetch and verify that the next item you get is not
	3051	//a reference to the same item (data cleared and reloaded.
	3052	var secondComplete = function(items, request){
	3053	try{
	3054	t.assertEqual(items.length, 1);
	3055	var secondItem = items[0];
	3056	t.assertTrue(firstItem != null);
	3057	t.assertTrue(secondItem != null);
	3058	t.assertTrue(firstItem != secondItem);
	3059	d.callback(true);
	3060	}catch(e){
	3061	d.errback(e);
	3062	}
	3063	};
	3064	store.fetch({query: {value: "bar\*foo"}, onComplete: secondComplete, onError: error});
	3065	};
	3066	function error(error, request){
	3067	t.assertTrue(false);
	3068	d.errback(error);
	3069	}
	3070	store.fetch({query: {value: "bar\*foo"}, onComplete: firstComplete, onError: error});
	3071	return d;
	3072	}
	3073	},
	3074	{
	3075	name: "Identity API: no_identifier_specified",
	3076	runTest: function(datastore, t){
	3077	var arrayOfItems = [
	3078	{name:"Kermit", color:"green"},
	3079	{name:"Miss Piggy", likes:"Kermit"},
	3080	{name:"Beaker", hairColor:"red"}
	3081	];
	3082	var store = new datastore({data:{items:arrayOfItems}});
	3083	var d = new doh.Deferred();
	3084	function onComplete(items, request){
	3085	var features = store.getFeatures();
	3086	var hasIdentityFeature = Boolean(features['dojo.data.api.Identity']);
	3087	t.assertTrue(hasIdentityFeature);
	3088	for(var i = 0; i < items.length; ++i){
	3089	var item = items[i];
	3090	var identifier = store.getIdentityAttributes(item);
	3091	t.assertTrue(identifier === null);
	3092	var identity = store.getIdentity(item);
	3093	t.assertTrue(typeof identity == "number");
	3094	}
	3095	d.callback(true);
	3096	}
	3097	function reportError(errData, request){
	3098	d.errback(true);
	3099	}
	3100	store.fetch({onComplete: onComplete, onError: reportError});
	3101	return d; // Deferred
	3102	}
	3103	},
	3104	{
	3105	name: "Identity API: hierarchical_data",
	3106	runTest: function(datastore, t){
	3107	var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("geography_hierarchy_small"));
	3108	var d = new doh.Deferred();
	3109	function onComplete(items, request){
	3110	var features = store.getFeatures();
	3111	var hasIdentityFeature = Boolean(features['dojo.data.api.Identity']);
	3112	t.assertTrue(hasIdentityFeature);
	3113	for(var i = 0; i < items.length; ++i){
	3114	var item = items[i];
	3115	var identifier = store.getIdentityAttributes(item);
	3116	t.assertTrue(identifier === null);
	3117	var identity = store.getIdentity(item);
	3118	t.assertTrue(typeof identity == "number");
	3119	}
	3120	d.callback(true);
	3121	}
	3122	function reportError(errData, request){
	3123	d.errback(true);
	3124	}
	3125	store.fetch({onComplete: onComplete, onError: reportError});
	3126	return d; // Deferred
	3127	}
	3128	},
	3129	{
	3130	name: "Read API: functionConformance",
	3131	runTest: function(datastore, t){
	3132	// summary:
	3133	// Simple test read API conformance. Checks to see all declared functions are actual functions on the instances.
	3134	// description:
	3135	// Simple test read API conformance. Checks to see all declared functions are actual functions on the instances.
	3136	var testStore = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	3137	var readApi = new dojo.data.api.Read();
	3138	var passed = true;
	3139
	3140	for(i in readApi){
	3141	if(i.toString().charAt(0) !== '_')
	3142	{
	3143	var member = readApi[i];
	3144	//Check that all the 'Read' defined functions exist on the test store.
	3145	if(typeof member === "function"){
	3146	var testStoreMember = testStore[i];
	3147	if(!(typeof testStoreMember === "function")){
	3148	passed = false;
	3149	break;
	3150	}
	3151	}
	3152	}
	3153	}
	3154	t.assertTrue(passed);
	3155	}
	3156	},
	3157	{
	3158	name: "Identity API: functionConformance",
	3159	runTest: function(datastore, t){
	3160	// summary:
	3161	// Simple test identity API conformance. Checks to see all declared functions are actual functions on the instances.
	3162	// description:
	3163	// Simple test identity API conformance. Checks to see all declared functions are actual functions on the instances.
	3164	var testStore = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
	3165	var identityApi = new dojo.data.api.Identity();
	3166	var passed = true;
	3167
	3168	for(i in identityApi){
	3169
	3170	if(i.toString().charAt(0) !== '_')
	3171	{
	3172	var member = identityApi[i];
	3173	//Check that all the 'Read' defined functions exist on the test store.
	3174	if(typeof member === "function"){
	3175	var testStoreMember = testStore[i];
	3176	if(!(typeof testStoreMember === "function")){
	3177	passed = false;
	3178	break;
	3179	}
	3180	}
	3181	}
	3182	}
	3183	t.assertTrue(passed);
	3184	}
	3185	}
	3186	];
	3187
	3188	});

Note: See TracBrowser for help on using the repository browser.

Download in other formats: