manyfest 1.0.1 → 1.0.3

package/test/Data-Yahoo-Weather.json

@@ -0,0 +1,115 @@
+{
+    "location": {
+        "woeid": 2502265,
+        "city": "Sunnyvale",
+        "region": " CA",
+        "country": "United States",
+        "lat": 37.371609,
+        "long": -122.038254,
+        "timezone_id": "America/Los_Angeles"
+    },
+    "current_observation": {
+        "wind": {
+            "chill": 59,
+            "direction": 165,
+            "speed": 8.7
+        },
+        "atmosphere": {
+            "humidity": 76,
+            "visibility": 10,
+            "pressure": 29.68
+        },
+        "astronomy": {
+            "sunrise": "7:23 am",
+            "sunset": "5:7 pm"
+        },
+        "condition": {
+            "text": "Scattered Showers",
+            "code": 39,
+            "temperature": 60
+        },
+        "pubDate": 1546992000
+    },
+    "forecasts": [
+        {
+            "day": "Tue",
+            "date": 1546934400,
+            "low": 52,
+            "high": 61,
+            "text": "Rain",
+            "code": 12
+        },
+        {
+            "day": "Wed",
+            "date": 1547020800,
+            "low": 51,
+            "high": 62,
+            "text": "Scattered Showers",
+            "code": 39
+        },
+        {
+            "day": "Thu",
+            "date": 1547107200,
+            "low": 46,
+            "high": 60,
+            "text": "Mostly Cloudy",
+            "code": 28
+        },
+        {
+            "day": "Fri",
+            "date": 1547193600,
+            "low": 48,
+            "high": 61,
+            "text": "Showers",
+            "code": 11
+        },
+        {
+            "day": "Sat",
+            "date": 1547280000,
+            "low": 47,
+            "high": 62,
+            "text": "Rain",
+            "code": 12
+        },
+        {
+            "day": "Sun",
+            "date": 1547366400,
+            "low": 48,
+            "high": 58,
+            "text": "Rain",
+            "code": 12
+        },
+        {
+            "day": "Mon",
+            "date": 1547452800,
+            "low": 47,
+            "high": 58,
+            "text": "Rain",
+            "code": 12
+        },
+        {
+            "day": "Tue",
+            "date": 1547539200,
+            "low": 46,
+            "high": 59,
+            "text": "Scattered Showers",
+            "code": 39
+        },
+        {
+            "day": "Wed",
+            "date": 1547625600,
+            "low": 49,
+            "high": 56,
+            "text": "Rain",
+            "code": 12
+        },
+        {
+            "day": "Thu",
+            "date": 1547712000,
+            "low": 49,
+            "high": 59,
+            "text": "Scattered Showers",
+            "code": 39
+        }
+    ]
+}

package/test/Manyfest_Object_CheckExistence_tests.js

@@ -0,0 +1,70 @@
+/**
+* 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 _SampleDataArchiveOrgFrankenberry = require('./Data-Archive-org-Frankenberry.json');
+
+suite
+(
+	'Manyfest Object Check Element Existence',
+	function()
+	{
+		setup (()=> {} );
+
+		suite
+		(
+			'Basic Check Existence',
+			()=>
+			{
+				test
+				(
+					'It should be easy to check if an element exists by address.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest({ Scope:'Archive.org', Descriptors: {'metadata.creator': {Name:'Creator', Hash:'Creator'}}});
+						// Property not in schema:
+						let tmpTitleExists = _Manyfest.checkAddressExists(_SampleDataArchiveOrgFrankenberry, 'metadata.title');
+						Expect(tmpTitleExists)
+							.to.equal(true);
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'If an element does not exist, checkAddressExists should return false.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest({ Scope:'Archive.org', Descriptors: {'metadata.creator': {Name:'Creator', Hash:'Creator'}}});
+						// Property not in schema:
+						let tmpTitleExists = _Manyfest.checkAddressExists(_SampleDataArchiveOrgFrankenberry, 'metadata.someStrangeProperty');
+						Expect(tmpTitleExists)
+							.to.equal(false);
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'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 schema, accessed by hash:
+						let tmpCreator = _Manyfest.checkAddressExistsByHash(_SampleDataArchiveOrgFrankenberry, 'Creator');
+						Expect(tmpCreator)
+							.to.equal(true);
+						fTestComplete();
+					}
+				);
+			}
+		);
+	}
+);

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_Object_Read_tests.js

@@ -0,0 +1,166 @@
+/**
+* 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 _SampleDataArchiveOrgFrankenberry = require('./Data-Archive-org-Frankenberry.json');
+
+suite
+(
+	'Manyfest Object Read',
+	function()
+	{
+		setup (()=> {} );
+
+		suite
+		(
+			'Basic Read',
+			()=>
+			{
+				test
+				(
+					'It should be trivial to access subproperties without a schema.',
+					(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');
+						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 a schema by hash.',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest({ Scope:'Archive.org', Descriptors: {'metadata.creator': {Name:'Creator', Hash:'Creator'}}});
+						// Property not schema, accessed by hash:
+						let tmpCreator = _Manyfest.getValueByHash(_SampleDataArchiveOrgFrankenberry, 'Creator');
+						Expect(_SampleDataArchiveOrgFrankenberry.metadata.creator)
+							.to.equal(tmpCreator);
+						Expect(tmpCreator)
+							.to.equal('General Mills');
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Exercise more hash accesss scenarios..',
+					(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": { "Description":"The animal's colloquial species name (e.g. Rabbit, Dog, Bear, Mongoose)." },
+										"Type": { "Description":"Whether or not the animal is wild, domesticated, agricultural, in a research lab or a part of a zoo.." },
+										"MedicalStats": 
+											{
+												"Name":"Medical Statistics", "Description":"Basic medical statistics for this animal"
+											},
+										"MedicalStats.Temps.MinET": { "Name":"Minimum Environmental Temperature", "NameShort":"MinET", "Description":"Safest minimum temperature for this animal to survive in."},
+										"MedicalStats.Temps.MaxET": { "Name":"Maximum Environmental Temperature", "NameShort":"MaxET", "Description":"Safest maximum temperature for this animal to survive in."},
+										"MedicalStats.Temps.CET":
+											{
+												"Name":"Comfortable Environmental Temperature",
+												"NameShort":"Comf Env Temp",
+												"Hash":"ComfET",
+												"Description":"The most comfortable temperature for this animal to survive in."
+											}
+									}
+							});
+
+						Expect(animalManyfest.getValueByHash({MedicalStats: { Temps: { CET:200 }},Name:'Froggy'}, 'ComfET'))
+							.to.equal(200);
+
+						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
+				(
+					'Access specific boxed properties',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest();
+						let tmpDog = _Manyfest.getValueAtAddress({Dogs:{RunnerUp:'Fido',Loser:'Spot',Winner:'Trinity'}}, 'Dogs["Winner"]');
+						Expect(tmpDog)
+							.to.equal('Trinity');
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Attempt to access specific boxed properties that do not exist',
+					(fTestComplete)=>
+					{
+						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();
+					}
+				);
+
+			}
+		);
+	}
+);