Plato - dojo/testsDOH/data/readOnlyItemFileTestTemplates.js

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

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

dojo.declare("tests.data.Wrapper", null, {
	// summary:
	//		Simple class to use for typeMap in order to	test out
	//		'falsy' values for _value.
	_wrapped: null,

constructor: function(obj){
		this._wrapped = obj;
	},

getValue: function(){
		return this._wrapped;
	},

setValue: function(obj){
		this._wrapped = obj;
	},

toString: function(){
		 return "WRAPPER: [" + this._wrapped + "]";
	}
});

tests.data.readOnlyItemFileTestTemplates.registerTestsForDatastore = function(/* String */ datastoreClassName){
	// summary:
	//		Given the name of a datastore class to use, this function creates
	//		a set of unit tests for that datastore, and registers the new test
	//		group with the doh test framework.  The new unit tests are based
	//		on a set of "template" unit tests.
	var datastoreClass = dojo.getObject(datastoreClassName);
	var testTemplates = tests.data.readOnlyItemFileTestTemplates.testTemplates;
	var testsForDatastore = [];
	var makeNewTestFunction = function(template){
		return function(t){return template.runTest(datastoreClass, t);};
	};
	for(var i = 0; i < testTemplates.length; ++i){
		var testTemplate = testTemplates[i];
		var test = {};
		test.name = testTemplate.name;
		test.runTest = makeNewTestFunction(testTemplate);
		testsForDatastore.push(test);
	}
	var testGroupName = "IFSCommonTests: " + datastoreClassName;
	doh.register(testGroupName, testsForDatastore);
};

//-----------------------------------------------------
// testFile data-sets
tests.data.readOnlyItemFileTestTemplates.getTestData = function(name){
	var data = null;
	if(name === "countries"){
		if(dojo.isBrowser){
			data = {url: require.toUrl("./countries.json")};
		}else{
			data = {data: {
				identifier:"abbr",
				label:"name",
				items:[
					{abbr:"ec", name:"Ecuador", capital:"Quito"},
					{abbr:'eg', name:'Egypt', capital:'Cairo'},
					{abbr:'sv', name:'El Salvador', capital:'San Salvador'},
					{abbr:'gq', name:'Equatorial Guinea', capital:'Malabo'},
					{abbr:'er', name:'Eritrea', capital:'Asmara'},
					{abbr:'ee', name:'Estonia', capital:'Tallinn'},
					{abbr:'et', name:'Ethiopia', capital:'Addis Ababa'}
				]
			} };
		}
	}else if(name === "countries_withNull"){
		if(dojo.isBrowser){
			data = {url: require.toUrl("./countries_withNull.json")};
		}else{
			data = {data: {
				identifier:"abbr",
				items:[
					{abbr:"ec", name:null, capital:"Quito"},
					{abbr:'eg', name:null, capital:'Cairo'},
					{abbr:'sv', name:'El Salvador', capital:'San Salvador'},
					{abbr:'gq', name:'Equatorial Guinea', capital:'Malabo'},
					{abbr:'er', name:'Eritrea', capital:'Asmara'},
					{abbr:'ee', name:null, capital:'Tallinn'},
					{abbr:'et', name:'Ethiopia', capital:'Addis Ababa'}
				]
			} };
		}
	}else if(name === "countries_withoutid"){
		if(dojo.isBrowser){
			data = {url: require.toUrl("./countries_withoutid.json")};
		}else{
			data = {data: {
				label: "name",
				items:[
					{abbr:"ec", name:null, capital:"Quito"},
					{abbr:'eg', name:null, capital:'Cairo'},
					{abbr:'sv', name:'El Salvador', capital:'San Salvador'},
					{abbr:'gq', name:'Equatorial Guinea', capital:'Malabo'},
					{abbr:'er', name:'Eritrea', capital:'Asmara'},
					{abbr:'ee', name:null, capital:'Tallinn'},
					{abbr:'et', name:'Ethiopia', capital:'Addis Ababa'}
				]
			} };
		}
	}else if (name === "countries_withBoolean"){
		if(dojo.isBrowser){
			data = {url: require.toUrl("./countries_withBoolean.json")};
		}else{
			data = {data: {
				identifier:"abbr",
				items:[
					{abbr:"ec", name:"Ecuador", capital:"Quito", real:true},
					{abbr:'eg', name:'Egypt', capital:'Cairo', real:true},
					{abbr:'sv', name:'El Salvador', capital:'San Salvador', real:true},
					{abbr:'gq', name:'Equatorial Guinea', capital:'Malabo', real:true},
					{abbr:'er', name:'Eritrea', capital:'Asmara', real:true},
					{abbr:'ee', name:'Estonia', capital:'Tallinn', real:true},
					{abbr:'et', name:'Ethiopia', capital:'Addis Ababa', real:true},
					{abbr:'ut', name:'Utopia', capital:'Paradise', real:false}
				]
			} };
		}
	}else if (name === "countries_withDates"){
		if(dojo.isBrowser){
			data = {url: require.toUrl("./countries_withDates.json")};
		}else{
			data = {data: {
				identifier:"abbr",
				items:[
					{abbr:"ec", name:"Ecuador", capital:"Quito"},
					{abbr:'eg', name:'Egypt', capital:'Cairo'},
					{abbr:'sv', name:'El Salvador', capital:'San Salvador'},
					{abbr:'gq', name:'Equatorial Guinea', capital:'Malabo'},
					{abbr:'er', name:'Eritrea', capital:'Asmara', independence:{_type:'Date', _value:"1993-05-24T00:00:00Z"}}, // May 24, 1993,
					{abbr:'ee', name:'Estonia', capital:'Tallinn', independence:{_type:'Date', _value:"1991-08-20T00:00:00Z"}}, // August 20, 1991
					{abbr:'et', name:'Ethiopia', capital:'Addis Ababa'}
				]
			} };
		}
	}else if (name === "geography_hierarchy_small"){
		if(dojo.isBrowser){
			data = {url: require.toUrl("./geography_hierarchy_small.json")};
		}else{
			data = {data: {
				items:[
					{ name:'Africa', countries:[
						{ name:'Egypt', capital:'Cairo' },
						{ name:'Kenya', capital:'Nairobi' },
						{ name:'Sudan', capital:'Khartoum' }]},
					{ name:'Australia', capital:'Canberra' },
					{ name:'North America', countries:[
						{ name:'Canada', population:'33 million', cities:[
							{ name:'Toronto', population:'2.5 million' },
							{ name:'Alberta', population:'1 million' }
							]},
						{ name: 'United States of America', capital: 'Washington DC', states:[
							{ name: 'Missouri'},
							{ name: 'Arkansas'}
							]}
						]}
				]
			}};
		}
	}else if (name === "data_multitype"){
		if(dojo.isBrowser){
			data = {url: require.toUrl("./data_multitype.json")};
		}else{
			data = {data: {
							"identifier": "count",
							"label": "count",
							items: [
								{ count: 1,    value: "true" },
								{ count: 2,    value: true   },
								{ count: 3,    value: "false"},
								{ count: 4,    value: false  },
								{ count: 5,    value: true   },
								{ count: 6,    value: true   },
								{ count: 7,    value: "true" },
								{ count: 8,    value: "true" },
								{ count: 9,    value: "false"},
								{ count: 10,   value: false  },
								{ count: 11,   value: [false, false]},
								{ count: "12", value: [false, "true"]}
						   ]
						}
					};
		}
	}else if (name === "countries_references"){
		if(dojo.isBrowser){
			data = {url: require.toUrl("./countries_references.json")};
		}else{
			data = {data: { identifier: 'name',
							label: 'name',
							items: [
								{ name:'Africa', type:'continent',
									children:[{_reference:'Egypt'}, {_reference:'Kenya'}, {_reference:'Sudan'}] },
								{ name:'Egypt', type:'country' },
								{ name:'Kenya', type:'country',
									children:[{_reference:'Nairobi'}, {_reference:'Mombasa'}] },
								{ name:'Nairobi', type:'city' },
								{ name:'Mombasa', type:'city' },
								{ name:'Sudan', type:'country',
									children:{_reference:'Khartoum'} },
								{ name:'Khartoum', type:'city' },
								{ name:'Asia', type:'continent',
									children:[{_reference:'China'}, {_reference:'India'}, {_reference:'Russia'}, {_reference:'Mongolia'}] },
								{ name:'China', type:'country' },
								{ name:'India', type:'country' },
								{ name:'Russia', type:'country' },
								{ name:'Mongolia', type:'country' },
								{ name:'Australia', type:'continent', population:'21 million',
									children:{_reference:'Commonwealth of Australia'}},
								{ name:'Commonwealth of Australia', type:'country', population:'21 million'},
								{ name:'Europe', type:'continent',
									children:[{_reference:'Germany'}, {_reference:'France'}, {_reference:'Spain'}, {_reference:'Italy'}] },
								{ name:'Germany', type:'country' },
								{ name:'France', type:'country' },
								{ name:'Spain', type:'country' },
								{ name:'Italy', type:'country' },
								{ name:'North America', type:'continent',
									children:[{_reference:'Mexico'}, {_reference:'Canada'}, {_reference:'United States of America'}] },
								{ name:'Mexico', type:'country',  population:'108 million', area:'1,972,550 sq km',
									children:[{_reference:'Mexico City'}, {_reference:'Guadalajara'}] },
								{ name:'Mexico City', type:'city', population:'19 million', timezone:'-6 UTC'},
								{ name:'Guadalajara', type:'city', population:'4 million', timezone:'-6 UTC' },
								{ name:'Canada', type:'country',  population:'33 million', area:'9,984,670 sq km',
									children:[{_reference:'Ottawa'}, {_reference:'Toronto'}] },
								{ name:'Ottawa', type:'city', population:'0.9 million', timezone:'-5 UTC'},
								{ name:'Toronto', type:'city', population:'2.5 million', timezone:'-5 UTC' },
								{ name:'United States of America', type:'country' },
								{ name:'South America', type:'continent',
									children:[{_reference:'Brazil'}, {_reference:'Argentina'}] },
								{ name:'Brazil', type:'country', population:'186 million' },
								{ name:'Argentina', type:'country', population:'40 million' }
							]
						}
					};
		}
	}
	return data;
};

//-----------------------------------------------------
// testTemplates
tests.data.readOnlyItemFileTestTemplates.testTemplates = [
	{
		name: "Identity API: fetchItemByIdentity()",
		runTest: function(datastore, t){
			// summary:
			//		Simple test of the fetchItemByIdentity function of the store.
			var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

if(dojo.isBrowser){
                var store = new datastore({url: require.toUrl("./countries_commentFiltered.json")});

var d = new doh.Deferred();
			function completedAll(items, request){
				t.is(7, items.length);
				d.callback(true);
			}
			function error(errData, request){
				t.assertTrue(false);
				d.errback(errData);
			}

//Get everything...
			store.fetch({ onComplete: completedAll, onError: error});
			return d;
		}
	},
	{
		name: "Read API: fetch() all failOk",
 		runTest: function(datastore, t){
			// summary:
			//		Simple test of a basic fetch on ItemFileReadStore that fails quietly.
			// description:
			//		Simple test of a basic fetch on ItemFileReadStore that fails quietly.
			if(dojo.isBrowser){
				var storeParams = {
					url: "noSuchUrl",
					failOk: true
				};
				var store = new datastore(storeParams);
				console.log(store);

var d = new doh.Deferred();
				var completedAll = function(items, request){
					d.errback(new Error("Should not be here, should have failed load."));
				};
				var error = function(errData, request){
					d.callback(true);
				};

//Get everything...
				store.fetch({ onComplete: completedAll, onError: error});
				return d;
			}
		}
	},
	{
		name: "Read API: fetch() abort",
 		runTest: function(datastore, t){
			// summary:
			//		Simple test of a basic fetch abort on ItemFileReadStore.
			// description:
			//		Simple test of a basic fetch abort on ItemFileReadStore.
			//Can only async abort in a browser, so disable this test from rhino
			if(dojo.isBrowser){
				var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

//Get everything...
				var req = store.fetch({ onComplete: completedAll, onError: error});
				abortCalled=true;
				console.log("Calling abort.");
				req.abort();
				return d;
			}
		}
	},
	{
		name: "Read API: fetch() all (count === Infinity)",
 		runTest: function(datastore, t){
			// summary:
			//		Simple test of a basic fetch on ItemFileReadStore and with a count of Infinity.
			// description:
			//		Simple test of a basic fetch on ItemFileReadStore and with a count of Infinity.
			var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

//Get everything...
			store.fetch({ onComplete: completedAll, onError: error, start: 0, count: Infinity});
			return d;
		}
	},
	{
		name: "Read API: fetch() all PreventCache",
 		runTest: function(datastore, t){
			// summary:
			//		Simple test of a basic fetch on ItemFileReadStore.
			// description:
			//		Simple test of a basic fetch on ItemFileReadStore.
			var args = tests.data.readOnlyItemFileTestTemplates.getTestData("countries");
			args.urlPreventCache = true;
			var store = new datastore(args);

//Get everything...
			store.fetch({ onComplete: completedAll, onError: error});
			return d;
		}
	},
	{
		name: "Read API: fetch() one",
 		runTest: function(datastore, t){
			// summary:
			//		Simple test of a basic fetch on ItemFileReadStore of a single item.
			// description:
			//		Simple test of a basic fetch on ItemFileReadStore of a single item.
			var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

var d = new doh.Deferred();
			var done = [false, false];

//Find all items starting with A, only toplevel (root) items.
			store.fetch({ 	query: {name: "N*"},
									onComplete: onCompleteTwo,
									onError: onError
								});

return d;
		}
	},
	{
		name: "Read API: fetch() MultipleMixedFetch",
 		runTest: function(datastore, t){
			// summary:
			//		Tests that multiple fetches at the same time queue up properly and do not clobber each other on initial load.
			// description:
			//		Tests that multiple fetches at the same time queue up properly and do not clobber each other on initial load.
			//		Tests an item fetch and an identity fetch.
			var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

var d = new doh.Deferred();
			var done = [false, false];

function onComplete(items, request){
				done[0] = true;
				t.assertEqual(items.length, 1);
				if(done[0] && done[1]){
					d.callback(true);
				}
			}
			function onItem(item){
				done[1] = true;
				t.assertTrue(item !== null);
				var name = store.getValue(item,"name");
				t.assertEqual(name, "El Salvador");

if(done[0] && done[1]){
					d.callback(true);
				}
			}
			function onError(errData){
				t.assertTrue(false);
				d.errback(errData);
			}

//Find all items starting with A, only toplevel (root) items.
			store.fetch({ 	query: {name: "El*"},
									onComplete: onComplete,
									onError: onError
								});

store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
			return d;
		}
	},
	{
		name: "Read API: fetch() deep",
 		runTest: function(datastore, t){
			// summary:
			//		Simple test of a basic fetch on ItemFileReadStore of all items (including children (nested))
			// description:
			//		Simple test of a basic fetch on ItemFileReadStore of all items (including children (nested))
			var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("geography_hierarchy_small"));

//Set this as hierarchy off before fetch to make sure it traps and configs right.
			store.hierarchical = false;

//Set this as hierarchy off before fetch to make sure it traps and configs right.
			store.hierarchical = false;

var d = new doh.Deferred();
			count = 0;

//Get everything...
			store.fetch({	onBegin: onBegin,
									onItem: onItem,
									onComplete: onComplete,
									onError: onError
								});
			return d;
		}
	},
	{
		name: "Read API: fetch() paging",
 		runTest: function(datastore, t){
			// summary:
			//		Test of multiple fetches on a single result.  Paging, if you will.
			// description:
			//		Test of multiple fetches on a single result.  Paging, if you will.
			var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

var d = new doh.Deferred();
			function dumpFirstFetch(items, request){
				t.assertEqual(items.length, 5);
				request.start = 3;
				request.count = 1;
				request.onComplete = dumpSecondFetch;
				store.fetch(request);
			}

function dumpSecondFetch(items, request){
				t.assertEqual(items.length, 1);
				request.start = 0;
				request.count = 5;
				request.onComplete = dumpThirdFetch;
				store.fetch(request);
			}

function dumpThirdFetch(items, request){
				t.assertEqual(items.length, 5);
				request.start = 2;
				request.count = 20;
				request.onComplete = dumpFourthFetch;
				store.fetch(request);
			}

function dumpFourthFetch(items, request){
				t.assertEqual(items.length, 5);
				request.start = 9;
				request.count = 100;
				request.onComplete = dumpFifthFetch;
				store.fetch(request);
			}

function dumpFifthFetch(items, request){
				t.assertEqual(items.length, 0);
				request.start = 2;
				request.count = 20;
				request.onComplete = dumpSixthFetch;
				store.fetch(request);
			}

function dumpSixthFetch(items, request){
				t.assertEqual(items.length, 5);
				d.callback(true);
			}

function completed(items, request){
				t.assertEqual(items.length, 7);
				request.start = 1;
				request.count = 5;
				request.onComplete = dumpFirstFetch;
				store.fetch(request);
			}

// Two different instances, even  if they read from the same URL
			// should not accept items between each other!
			var store1 = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
			var store2 = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

var d = new doh.Deferred();
			function onItem1(item1){
				t.assertTrue(item1 !== null);

function onItem2(item2){
					t.assertTrue(item1 !== null);
					t.assertTrue(item2 !== null);
					t.assertTrue(store1.isItem(item1));
					t.assertTrue(store2.isItem(item2));
					t.assertTrue(!store1.isItem(item2));
					t.assertTrue(!store2.isItem(item1));
					d.callback(true);
				}
				store2.fetchItemByIdentity({identity: "sv", onItem: onItem2, onError: onError});

}
			function onError(errData){
				t.assertTrue(false);
				d.errback(errData);
			}
			store1.fetchItemByIdentity({identity: "sv", onItem: onItem1, onError: onError});
			return d; // Deferred
		}
	},
	{
		name: "Read API: hasAttribute()",
 		runTest: function(datastore, t){
			// summary:
			//		Simple test of the hasAttribute function of the store
			// description:
			//		Simple test of the hasAttribute function of the store
			var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

var d = new doh.Deferred();
			function onItem(item){
				try{
					t.assertTrue(item !== null);

t.assertTrue(store.hasAttribute(item, "abbr"));
					t.assertTrue(!store.hasAttribute(item, "abbr_not"));

//Test that null attributes throw an exception
					var passed = false;
					try{
						store.hasAttribute(item, null);
					}catch (e){
						passed = true;
					}
					t.assertTrue(passed);
					d.callback(true);
				}catch(e){
					d.errback(e);
				}
			}
			function onError(errData){
				t.assertTrue(false);
				d.errback(errData);
			}
			store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
			return d; // Deferred
		}
	},
	{
		name: "Read API: containsValue()",
 		runTest: function(datastore, t){
			// summary:
			//		Simple test of the containsValue function of the store
			// description:
			//		Simple test of the containsValue function of the store
			var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

var d = new doh.Deferred();
			function onItem(item){
				t.assertTrue(item !== null);
				t.assertTrue(store.containsValue(item, "abbr", "sv"));
				t.assertTrue(!store.containsValue(item, "abbr", "sv1"));
				t.assertTrue(!store.containsValue(item, "abbr", null));

//Test that null attributes throw an exception
				var passed = false;
				try{
					store.containsValue(item, null, "foo");
				}catch (e){
					passed = true;
				}
				t.assertTrue(passed);
				d.callback(true);
			}
			function onError(errData){
				t.assertTrue(false);
				d.errback(errData);
			}
			store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
			return d; // Deferred
		}
	},
	{
		name: "Read API: getAttributes()",
 		runTest: function(datastore, t){
			// summary:
			//		Simple test of the getAttributes function of the store
			// description:
			//		Simple test of the getAttributes function of the store
			var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

var d = new doh.Deferred();
			function onItem(item){
				t.assertTrue(item !== null);
				t.assertTrue(store.isItem(item));

var features = store.getFeatures();
			t.assertTrue(features["dojo.data.api.Read"] != null);
			t.assertTrue(features["dojo.data.api.Identity"] != null);
		}
	},
	{
		name: "Read API: fetch() patternMatch0",
 		runTest: function(datastore, t){
			// summary:
			//		Function to test pattern matching of everything starting with lowercase e
			// description:
			//		Function to test pattern matching of everything starting with lowercase e
			var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));

var store = new datastore({data: { identifier: "uniqueId",
											  items: [ {uniqueId: 1, value:"foo*bar"},
												   {uniqueId: 2, value:"bar*foo"},
												   {uniqueId: 3, value:"boomBam"},
												   {uniqueId: 4, value:"bit$Bite"},
												   {uniqueId: 5, value:"ouagadogou"},
												   {uniqueId: 6, value:"BaBaMaSaRa***Foo"},
												   {uniqueId: 7, value:"squawl"},
												   {uniqueId: 8, value:"seaweed"},
												   {uniqueId: 9, value:"jfq4@#!$!@Rf14r14i5u"}
												 ]
										}
								 });

var store = new datastore({data: { identifier: "uniqueId",
											  items: [ {uniqueId: 1, value:"foo*bar"},
												   {uniqueId: 2, value:"bar*foo"},
												   {uniqueId: 3, value:"BAR*foo"},
												   {uniqueId: 4, value:"BARBananafoo"}
												 ]
										}
								 });