manyfest 1.0.2 → 1.0.3

package/test/Manyfest_Object_Populate_tests.js

@@ -0,0 +1,140 @@
+/**
+* Unit tests for Meadow
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+var Chai = require("chai");
+var Expect = Chai.expect;
+
+let libManyfest = require('../source/Manyfest.js');
+
+suite
+(
+	'Manyfest Object Population',
+	function()
+	{
+		setup (()=> {} );
+
+		suite
+		(
+			'Basic Population',
+			()=>
+			{
+				test
+				(
+					'Default properties should be auto created on populateDefaults.',
+					(fTestComplete)=>
+					{
+						let animalManyfest = new libManyfest(
+							{
+								"Scope": "Animal",
+								"Descriptors":
+									{
+										"IDAnimal": { "Name":"Database ID", "Description":"The unique integer-based database identifier for an Animal record.", "DataType":"Integer" },
+										"Name": { "Required":true, "Description":"The animal's colloquial species name (e.g. Rabbit, Dog, Bear, Mongoose).", "Default":"Jane Doe" }
+									}
+							});
+
+						let tmpDefaultObject = animalManyfest.populateDefaults();
+
+						Expect(tmpDefaultObject.Name)
+							.to.equal('Jane Doe');
+						Expect(tmpDefaultObject.hasOwnProperty('IDAnimal'))
+							.to.equal(false);
+
+						fTestComplete();
+					}
+				);				
+				test
+				(
+					'All properties should be auto created on Populate.',
+					(fTestComplete)=>
+					{
+						let animalManyfest = new libManyfest(
+							{
+								"Scope": "Animal",
+								"Descriptors":
+									{
+										"IDAnimal": { "Name":"Database ID", "Description":"The unique integer-based database identifier for an Animal record.", "DataType":"Integer" },
+										"Name": { "Required":true, "Description":"The animal's colloquial species name (e.g. Rabbit, Dog, Bear, Mongoose).", "Default":"Jane Doe" }
+									}
+							});
+
+						let tmpDefaultObject = animalManyfest.populateObject();
+
+						Expect(tmpDefaultObject.Name)
+							.to.equal('Jane Doe');
+						Expect(tmpDefaultObject.hasOwnProperty('IDAnimal'))
+							.to.equal(true);
+						Expect(tmpDefaultObject.IDAnimal)
+							.to.equal(0);
+
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'We should be able to pass a custom filter to populate the object.',
+					(fTestComplete)=>
+					{
+						let animalManyfest = new libManyfest(
+							{
+								"Scope": "Animal",
+								"Descriptors":
+									{
+										"IDAnimal": { "Name":"Database ID", "Description":"The unique integer-based database identifier for an Animal record.", "DataType":"Integer" },
+										"Name": { "Required":true, "Description":"The animal's colloquial species name (e.g. Rabbit, Dog, Bear, Mongoose).", "Default":"Jane Doe" }
+									}
+							});
+
+						let tmpDefaultObject = animalManyfest.populateObject(undefined, false, (pDescriptor) => { return pDescriptor.Name == 'Database ID' });
+
+						Expect(tmpDefaultObject.Name)
+							.to.equal(undefined);
+						Expect(tmpDefaultObject.hasOwnProperty('IDAnimal'))
+							.to.equal(true);
+						Expect(tmpDefaultObject.IDAnimal)
+							.to.equal(0);
+
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'We should be able to force overwrites on properties.',
+					(fTestComplete)=>
+					{
+						let tmpObject = { "Name": "Jennifer" };
+						let animalManyfest = new libManyfest(
+							{
+								"Scope": "Animal",
+								"Descriptors":
+									{
+										"IDAnimal": { "Name":"Database ID", "Description":"The unique integer-based database identifier for an Animal record.", "DataType":"Integer" },
+										"Name": { "Required":true, "Description":"The animal's colloquial species name (e.g. Rabbit, Dog, Bear, Mongoose).", "Default":"Jane Doe" }
+									}
+							});
+
+						Expect(tmpObject.Name)
+							.to.equal("Jennifer");
+
+						animalManyfest.populateDefaults(tmpObject, true);
+
+						Expect(tmpObject.hasOwnProperty('IDAnimal'))
+							.to.equal(false);
+
+						// Because we told it to force overwrites, it should overwrite the Name.
+						Expect(tmpObject.Name)
+							.to.equal("Jane Doe");
+
+
+						fTestComplete();
+					}
+				);	
+			}
+		);
+	}
+);

package/test/{Manyfest_ObjectAccess_tests.js → Manyfest_Object_Read_tests.js}

@@ -15,43 +15,41 @@ let _SampleDataArchiveOrgFrankenberry = require('./Data-Archive-org-Frankenberry
 
 suite
 (
-	'Manyfest Object Access',
+	'Manyfest Object Read',
 	function()
 	{
 		setup (()=> {} );
 
 		suite
 		(
-			'Object Property Manipulation',
+			'Basic Read',
 			()=>
 			{
 				test
 				(
-					'Properties should be gettable and settable without a schema.',
+					'It should be trivial to access subproperties without a schema.',
 					(fTestComplete)=>
 					{
-						let _Manyfest = new libManyfest({});
-						let _SimpleObject = {Name:'Bob',Age:31,Pets:{Fido:'Dog',Spot:'Cat'}};
-						Expect(_Manyfest.getValueAtAddress(_SimpleObject,'Name'))
-							.to.equal('Bob');
-						_Manyfest.setValueAtAddress(_SimpleObject,'Name','Jim');
-						Expect(_Manyfest.getValueAtAddress(_SimpleObject,'Name'))
-							.to.equal('Jim');
+						let _Manyfest = new libManyfest({ Scope:'Archive.org', Descriptors: {'metadata.creator': {Name:'Creator', Hash:'Creator'}}});
+						// Property not in schema:
+						let tmpTitle = _Manyfest.getValueAtAddress(_SampleDataArchiveOrgFrankenberry, 'metadata.title');
+						Expect(tmpTitle)
+							.to.equal('Franken Berry / Count Chocula : Tevevision Commercial 1971');
+						Expect(tmpTitle)
+							.to.equal(_SampleDataArchiveOrgFrankenberry.metadata.title);
 						fTestComplete();
 					}
 				);
 				test
 				(
-					'It should be trivial to access subproperties with or without schema.',
+					'It should be trivial to access subproperties with a schema by hash.',
 					(fTestComplete)=>
 					{
 						let _Manyfest = new libManyfest({ Scope:'Archive.org', Descriptors: {'metadata.creator': {Name:'Creator', Hash:'Creator'}}});
-						// Property not in schema:
-						let tmpTitle = _Manyfest.getValueAtAddress(_SampleDataArchiveOrgFrankenberry, 'metadata.title');
-						// Property in schema
+						// Property not schema, accessed by hash:
 						let tmpCreator = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Creator');
-						Expect(tmpTitle)
-							.to.equal('Franken Berry / Count Chocula : Tevevision Commercial 1971');
+						Expect(_SampleDataArchiveOrgFrankenberry.metadata.creator)
+							.to.equal(tmpCreator);
 						Expect(tmpCreator)
 							.to.equal('General Mills');
 						fTestComplete();
@@ -59,7 +57,7 @@ suite
 				);
 				test
 				(
-					'Properties should be accessible via Hash.',
+					'Exercise more hash accesss scenarios..',
 					(fTestComplete)=>
 					{
 						let animalManyfest = new libManyfest(
@@ -91,53 +89,77 @@ suite
 
 						fTestComplete();
 					}
+				);			
+			}
+		);
+		suite
+		(
+			'Advanced Read (with Arrays and Boxed Property addresses)',
+			()=>
+			{
+				test
+				(
+					'Access specific array elements',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest();
+						let tmpDog = _Manyfest.getValueAtAddress({Dogs:['Fido','Spot','Trinity']}, 'Dogs[1]');
+						Expect(tmpDog)
+							.to.equal('Spot');
+						fTestComplete();
+					}
 				);
 				test
 				(
-					'Validate should check that required elements exist',
+					'Access specific boxed properties',
 					(fTestComplete)=>
 					{
-						let animalManyfest = new libManyfest(
-							{
-								"Scope": "Animal",
-								"Descriptors":
-									{
-										"IDAnimal": { "Name":"Database ID", "Description":"The unique integer-based database identifier for an Animal record.", "DataType":"Integer" },
-										"Name": { "Required":true, "Description":"The animal's colloquial species name (e.g. Rabbit, Dog, Bear, Mongoose)." }
-									}
-							});
-
-						let tmpValidationResults = animalManyfest.validate({MedicalStats: { Temps: { CET:200 }},Name:'Froggy'});
-
-						Expect(tmpValidationResults.Error)
-							.to.equal(null);
-
+						let _Manyfest = new libManyfest();
+						let tmpDog = _Manyfest.getValueAtAddress({Dogs:{RunnerUp:'Fido',Loser:'Spot',Winner:'Trinity'}}, 'Dogs["Winner"]');
+						Expect(tmpDog)
+							.to.equal('Trinity');
 						fTestComplete();
 					}
-				);				
+				);
 				test
 				(
-					'Validate should error when required elements do not exist',
+					'Attempt to access specific boxed properties that do not exist',
 					(fTestComplete)=>
 					{
-						let animalManyfest = new libManyfest(
-							{
-								"Scope": "Animal",
-								"Descriptors":
-									{
-										"IDAnimal": { "Name":"Database ID", "Description":"The unique integer-based database identifier for an Animal record.", "DataType":"Integer" },
-										"Name": { "Required":true, "Description":"The animal's colloquial species name (e.g. Rabbit, Dog, Bear, Mongoose)." }
-									}
-							});
-
-						let tmpValidationResults = animalManyfest.validate({MedicalStats: { Temps: { CET:200 }}});
-
-						Expect(tmpValidationResults.Error)
-							.to.equal(true);
-
+						let _Manyfest = new libManyfest();
+						let tmpDog = _Manyfest.getValueAtAddress({Dogs:{RunnerUp:'Fido',Loser:'Spot',Winner:'Trinity'}}, 'Dogs["Disqualified"]');
+						Expect(tmpDog)
+							.to.be.an('undefined');
+						let tmpWinner = _Manyfest.getValueAtAddress({Dogs:{RunnerUp:'Fido',Loser:'Spot',Winner:'Trinity'}}, 'Dogs["Winner"]');
+						Expect(tmpWinner)
+							.to.equal('Trinity');
 						fTestComplete();
 					}
-				);				
+				);
+				test
+				(
+					'Access nested box properties',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest();
+						let tmpDog = _Manyfest.getValueAtAddress({Dogs:{RunnerUp:{Name:'Fido',Speed:100},Loser:{Name:'Spot'},Winner:{Name:'Trinity'}}}, 'Dogs["RunnerUp"].Name');
+						Expect(tmpDog)
+							.to.equal('Fido');
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Access nested array properties',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest();
+						let tmpDog = _Manyfest.getValueAtAddress({Kennel:[{Name:'Fido',Speed:100},{Name:'Spot'},{Name:'Trinity'}]}, 'Kennel[1].Name');
+						Expect(tmpDog)
+							.to.equal('Spot');
+						fTestComplete();
+					}
+				);
 			}
 		);
 	}

package/test/Manyfest_Object_Validate_tests.js

@@ -0,0 +1,82 @@
+/**
+* Unit tests for Meadow
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+var Chai = require("chai");
+var Expect = Chai.expect;
+
+let libManyfest = require('../source/Manyfest.js');
+
+let _AnimalManyfestSchema = (
+	{
+		"Scope": "Animal",
+		"Descriptors":
+			{
+				"IDAnimal": { "Name":"Database ID", "Description":"The unique integer-based database identifier for an Animal record.", "DataType":"Integer" },
+				"Name": { "Required":true, "Description":"The animal's colloquial species name (e.g. Rabbit, Dog, Bear, Mongoose)." }
+			}
+	});
+
+suite
+(
+	'Manyfest Object Validation',
+	function()
+	{
+		setup (()=> {} );
+
+		suite
+		(
+			'Basic Validation',
+			()=>
+			{
+				test
+				(
+					'Validate should not error when all required elements exist.',
+					(fTestComplete)=>
+					{
+						let animalManyfest = new libManyfest(_AnimalManyfestSchema);
+						let tmpValidationResults = animalManyfest.validate({IDAnimal: 100, MedicalStats: { Temps: { CET:200 }},Name:'Froggy'});
+
+						Expect(tmpValidationResults.Error)
+							.to.equal(null);
+
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Validate should error when required elements do not exist.',
+					(fTestComplete)=>
+					{
+						let animalManyfest = new libManyfest(_AnimalManyfestSchema);
+						let tmpValidationResults = animalManyfest.validate({MedicalStats: { Temps: { CET:200 }}});
+
+						Expect(tmpValidationResults.Error)
+							.to.equal(true);
+
+						fTestComplete();
+					}
+				);				
+				test
+				(
+					'Validate should be able to test for dates.',
+					(fTestComplete)=>
+					{
+						let animalManyfest = new libManyfest(_AnimalManyfestSchema);
+						let tmpValidationResults = animalManyfest.validate({IDAnimal: 100, MedicalStats: { Temps: { CET:200 }}});
+
+						Expect(tmpValidationResults.Error)
+							.to.equal(true);
+
+						fTestComplete();
+					}
+				);
+
+			}
+		);
+	}
+);

package/test/Manyfest_Object_Write_tests.js

@@ -0,0 +1,161 @@
+/**
+* Unit tests for Meadow
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+var Chai = require("chai");
+var Expect = Chai.expect;
+
+let libManyfest = require('../source/Manyfest.js');
+
+suite
+(
+	'Manyfest Object Write',
+	function()
+	{
+		setup (()=> {} );
+
+		suite
+		(
+			'Basic Write',
+			()=>
+			{
+				test
+				(
+					'Properties should be settable without a schema.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest({});
+						let _SimpleObject = {Name:'Bob',Age:31,Pets:{Fido:'Dog',Spot:'Cat'}};
+						Expect(_Manyfest.getValueAtAddress(_SimpleObject,'Name'))
+							.to.equal('Bob');
+						_Manyfest.setValueAtAddress(_SimpleObject,'Name','Jim');
+						Expect(_Manyfest.getValueAtAddress(_SimpleObject,'Name'))
+							.to.equal('Jim');
+						Expect(_SimpleObject.Name)
+							.to.equal('Jim');
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Properties should be settable with a schema by hash.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest({ Scope:'BobsPets', Descriptors: {'Pets.Fido': {Name:'Favorite Pet', Hash:'Favorite'}}});
+						let _SimpleObject = {Name:'Bob',Age:31,Pets:{Fido:'Dog',Spot:'Cat'}};
+						Expect(_Manyfest.getValueAtAddress(_SimpleObject,'Pets.Fido'))
+							.to.equal('Dog');
+						// Set the favorite pet to be a Monkey because Monkeys rule
+						_Manyfest.setValueByHash(_SimpleObject,'Favorite','Monkey');
+						Expect(_Manyfest.getValueAtAddress(_SimpleObject,'Pets.Fido'))
+							.to.equal('Monkey');
+						Expect(_SimpleObject.Pets.Fido)
+							.to.equal('Monkey');
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Properties should be settable with a schema by address.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest({ Scope:'BobsPets', Descriptors: {'Pets.Fido': {Name:'Favorite Pet', Hash:'Favorite'}}});
+						let _SimpleObject = {Name:'Bob',Age:31,Pets:{Fido:'Dog',Spot:'Cat'}};
+						Expect(_Manyfest.getValueAtAddress(_SimpleObject,'Pets.Fido'))
+							.to.equal('Dog');
+						// Set fido to be a Lemur
+						_Manyfest.setValueAtAddress(_SimpleObject,'Pets.Fido','Lemur');
+						Expect(_Manyfest.getValueAtAddress(_SimpleObject,'Pets.Fido'))
+							.to.equal('Lemur');
+						Expect(_SimpleObject.Pets.Fido)
+							.to.equal('Lemur');
+						fTestComplete();
+					}
+				);
+			}
+		);
+
+		suite
+		(
+			'Advanced Write (with Arrays and Boxed Property addresses)',
+			()=>
+			{
+				test
+				(
+					'Write specific array elements.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest();
+						let _Object = {Dogs:['Fido','Spot','Trinity']};
+						_Manyfest.setValueAtAddress(_Object, 'Dogs[1]', 'Spotty')
+						Expect(_Object.Dogs[1])
+							.to.equal('Spotty');
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Write specific boxed properties.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest();
+						let _Object = {Dogs:{RunnerUp:'Fido',Loser:'Spot',Winner:'Trinity'}};
+						_Manyfest.setValueAtAddress(_Object, 'Dogs["Loser"]', 'Jimbo');
+						Expect(_Object.Dogs.Loser)
+							.to.equal('Jimbo');
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Write to specific boxed properties that do not exist.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest();
+						let _Object = {Dogs:{RunnerUp:'Fido',Loser:'Spot',Winner:'Trinity'}};
+						Expect(_Object.Dogs.Judge)
+							.to.be.an('undefined');
+						_Manyfest.setValueAtAddress(_Object, 'Dogs.Judge', 'Judgy Judy');
+						Expect(_Object.Dogs.Judge)
+							.to.equal('Judgy Judy');
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Write to nested box properties.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest();
+						let _Object = {Dogs:{RunnerUp:{Name:'Fido',Speed:100},Loser:{Name:'Spot'},Winner:{Name:'Trinity'}}};
+						_Manyfest.setValueAtAddress(_Object, 'Dogs[`RunnerUp`].Speed', 300);
+						Expect(_Object.Dogs.RunnerUp.Speed)
+							.to.equal(300);
+						// Set a value for an address that doesn't exist.
+						_Manyfest.setValueAtAddress(_Object, 'Dogs[`Loser`].Speed', 10);
+						Expect(_Object.Dogs.Loser.Speed)
+							.to.equal(10);
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Write nested array properties',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest();
+						let _Object = {Kennel:[{Name:'Fido',Speed:100},{Name:'Spot'},{Name:'Trinity'}]};
+						_Manyfest.setValueAtAddress(_Object, 'Kennel[1].Name', 'Billy');
+						Expect(_Object.Kennel[1].Name)
+							.to.equal('Billy');
+						fTestComplete();
+					}
+				);
+			}
+		);
+	}
+);

package/test/Manyfest_tests.js

@@ -35,6 +35,17 @@ suite
 					}
 				);
 				test
+				(
+					'The class should print an error message with a bad manifest.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest({Scope:'BadManifest', Descriptors:'BadDescriptors'});
+						Expect(_Manyfest)
+							.to.be.an('object', 'Manyfest should initialize as an object with no parameters.');
+						fTestComplete();
+					}
+				);
+				test
 				(
 					'Default properties should be automatically set.',
 					(fTestComplete)=>
@@ -47,6 +58,44 @@ suite
 						fTestComplete();
 					}
 				);
+				test
+				(
+					'Exercise the default logging.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest();
+						_Manyfest.logError('Error...');
+						_Manyfest.logInfo('Info...');
+						_Manyfest.logInfo();
+
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Pass in a custom logger.',
+					(fTestComplete)=>
+					{
+						let tmpLogState = [];
+						let fWriteLog = (pLogLine, pLogObject) =>
+						{
+							tmpLogState.push(pLogLine);
+						};
+
+						let _Manyfest = new libManyfest(undefined, fWriteLog, fWriteLog);
+						_Manyfest.logError('Error...');
+						Expect(tmpLogState.length)
+							.to.equal(1);
+						Expect(tmpLogState[0])
+							.to.equal('Error...');
+						_Manyfest.logInfo('Info...');
+						_Manyfest.logInfo();
+						Expect(tmpLogState.length)
+							.to.equal(3);
+
+						fTestComplete();
+					}
+				);
 			}
 		);
 	}