meadow 2.0.41 → 2.0.43

package/test/Meadow-Provider-Oracle_tests.js

@@ -0,0 +1,877 @@
+/**
+* Unit tests for the Meadow "Oracle" Provider
+*
+* These tests expect an Oracle database (see scripts/oracle-test-db.sh —
+* gvenzl/oracle-free on port 21521).  If meadow-connection-oracle is not
+* installed, or no Oracle is reachable, the whole suite self-skips so a bare
+* `npm test` (or test-all-providers without Oracle) doesn't hard-fail.
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+var Chai = require("chai");
+var Expect = Chai.expect;
+
+// Tolerate the connection module (and its oracledb dependency) being absent —
+// the suite self-skips in that case rather than breaking the whole test run.
+var libMeadowConnectionOracle = null;
+try
+{
+	libMeadowConnectionOracle = require('meadow-connection-oracle');
+}
+catch (pRequireError)
+{
+	libMeadowConnectionOracle = null;
+}
+
+var tmpFableSettings = (
+	{
+		"Product": "MeadowOracleTestBookstore",
+		"ProductVersion": "1.0.0",
+
+		"UUID":
+		{
+			"DataCenter": 0,
+			"Worker": 0
+		},
+		"LogStreams":
+			[
+				{
+					"streamtype": "console"
+				}
+			],
+
+		"Oracle":
+		{
+			"Server": "127.0.0.1",
+			"Port": 21521,
+			"User": "bookstore",
+			"Password": "Retold1234567890!",
+			"connectionType": "ServiceName",
+			"serviceName": "FREEPDB1",
+			"ConnectionPoolLimit": 5,
+			// Fail fast into a self-skip when no Oracle is reachable.
+			"ConnectRetryOptions": { "MaxAttempts": 1 },
+			"ConnectionTimeoutMs": 8000
+		}
+	});
+
+var libFable = new (require('fable'))(tmpFableSettings);
+
+if (libMeadowConnectionOracle)
+{
+	libFable.serviceManager.addServiceType('MeadowOracleProvider', libMeadowConnectionOracle);
+	libFable.serviceManager.instantiateServiceProvider('MeadowOracleProvider');
+}
+
+var _AnimalJsonSchema = (
+	{
+		title: "Animal",
+		description: "A creature that lives in a meadow.",
+		type: "object",
+		properties: {
+			IDAnimal: {
+				description: "The unique identifier for an animal",
+				type: "integer"
+			},
+			Name: {
+				description: "The animal's name",
+				type: "string"
+			},
+			Type: {
+				description: "The type of the animal",
+				type: "string"
+			}
+		},
+		required: ["IDAnimal", "Name", "CreatingIDUser"]
+	});
+var _AnimalSchema = (
+	[
+		{ Column: "IDAnimal", Type: "AutoIdentity" },
+		{ Column: "GUIDAnimal", Type: "AutoGUID" },
+		{ Column: "CreateDate", Type: "CreateDate" },
+		{ Column: "CreatingIDUser", Type: "CreateIDUser" },
+		{ Column: "UpdateDate", Type: "UpdateDate" },
+		{ Column: "UpdatingIDUser", Type: "UpdateIDUser" },
+		{ Column: "Deleted", Type: "Deleted" },
+		{ Column: "DeletingIDUser", Type: "DeleteIDUser" },
+		{ Column: "DeleteDate", Type: "DeleteDate" },
+		{ Column: "Name", Type: "String" },
+		{ Column: "Type", Type: "String" },
+		{ Column: "Metadata",  Type:"JSON" },
+		{ Column: "ExtraData", Type:"JSONProxy", StorageColumn:"ExtraDataJSON" }
+	]);
+var _AnimalDefault = (
+	{
+		IDAnimal: null,
+		GUIDAnimal: '',
+
+		CreateDate: false,
+		CreatingIDUser: 0,
+		UpdateDate: false,
+		UpdatingIDUser: 0,
+		Deleted: 0,
+		DeleteDate: false,
+		DeletingIDUser: 0,
+
+		Name: 'Unknown',
+		Type: 'Unclassified',
+
+		Metadata: {},
+		ExtraData: {}
+	});
+
+suite
+	(
+		'Meadow-Provider-Oracle',
+		function ()
+		{
+			var _SpooledUp = false;
+
+			// Oracle has no DROP TABLE IF EXISTS — swallow ORA-00942.
+			var _DropTableStatement = "BEGIN EXECUTE IMMEDIATE 'DROP TABLE FableTest CASCADE CONSTRAINTS'; EXCEPTION WHEN OTHERS THEN IF SQLCODE != -942 THEN RAISE; END IF; END;";
+
+			var _CreateTableStatement = 'CREATE TABLE FableTest ('
+				+ ' IDAnimal NUMBER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,'
+				+ " GUIDAnimal VARCHAR2(36) DEFAULT '00000000-0000-0000-0000-000000000000' NOT NULL,"
+				+ ' CreateDate TIMESTAMP,'
+				+ ' CreatingIDUser NUMBER DEFAULT 0 NOT NULL,'
+				+ ' UpdateDate TIMESTAMP,'
+				+ ' UpdatingIDUser NUMBER DEFAULT 0 NOT NULL,'
+				+ ' Deleted NUMBER(1) DEFAULT 0 NOT NULL,'
+				+ ' DeleteDate TIMESTAMP,'
+				+ ' DeletingIDUser NUMBER DEFAULT 0 NOT NULL,'
+				+ " Name VARCHAR2(128) DEFAULT ' ' NOT NULL,"
+				+ " Type VARCHAR2(128) DEFAULT ' ' NOT NULL,"
+				+ ' Metadata CLOB,'
+				+ ' ExtraDataJSON CLOB'
+				+ ' )';
+
+			var getAnimalInsert = function (pName, pType)
+			{
+				return "INSERT INTO FableTest (GUIDAnimal, CreateDate, CreatingIDUser, UpdateDate, UpdatingIDUser, Deleted, DeleteDate, DeletingIDUser, Name, Type, Metadata, ExtraDataJSON)"
+					+ " VALUES ('00000000-0000-0000-0000-000000000000', SYS_EXTRACT_UTC(SYSTIMESTAMP), 1, SYS_EXTRACT_UTC(SYSTIMESTAMP), 1, 0, NULL, 0, '"
+					+ pName + "', '" + pType + "', '{}', '{}')";
+			};
+
+			// Acquire a pooled connection, run a statement with autoCommit, and
+			// always release the connection (oracledb has no pool.query()).
+			var execOnPool = function (pSQL, fCallback)
+			{
+				var tmpProvider = libFable.MeadowOracleProvider;
+				tmpProvider.getConnection(function (pConnectionError, pConnection)
+				{
+					if (pConnectionError) { return fCallback(pConnectionError); }
+					pConnection.execute(pSQL, [], { autoCommit: true })
+						.then(function () { pConnection.close().then(() => fCallback()).catch(() => fCallback()); })
+						.catch(function (pError) { pConnection.close().then(() => fCallback(pError)).catch(() => fCallback(pError)); });
+				});
+			};
+
+			var newMeadow = function ()
+			{
+				return require('../source/Meadow.js')
+					.new(libFable, 'FableTest')
+					.setProvider('Oracle')
+					.setSchema(_AnimalSchema)
+					.setJsonSchema(_AnimalJsonSchema)
+					.setDefaultIdentifier('IDAnimal')
+					.setDefault(_AnimalDefault)
+			};
+
+			suiteSetup
+				(
+					function (fDone)
+					{
+						var tmpSelf = this;
+
+						// No connection module installed → skip the whole suite.
+						if (!libMeadowConnectionOracle)
+						{
+							return tmpSelf.skip();
+						}
+
+						if (_SpooledUp)
+						{
+							return fDone();
+						}
+
+						libFable.MeadowOracleProvider.connectAsync(
+							(pConnectError) =>
+							{
+								if (pConnectError)
+								{
+									// No reachable Oracle → skip the whole suite.
+									libFable.log.warn(`Oracle not reachable, skipping Meadow-Provider-Oracle suite: ${pConnectError}`);
+									return tmpSelf.skip();
+								}
+
+								libFable.log.info('Connection opened!');
+								libFable.Utility.waterfall(
+									[
+										function (fStageComplete)
+										{
+											execOnPool(_DropTableStatement, () => fStageComplete());
+										},
+										function (fStageComplete)
+										{
+											execOnPool(_CreateTableStatement, fStageComplete);
+										},
+										function (fStageComplete)
+										{
+											execOnPool(getAnimalInsert('Foo Foo', 'Bunny'), fStageComplete);
+										},
+										function (fStageComplete)
+										{
+											execOnPool(getAnimalInsert('Red Riding Hood', 'Girl'), fStageComplete);
+										},
+										function (fStageComplete)
+										{
+											execOnPool(getAnimalInsert('Red', 'Dog'), fStageComplete);
+										},
+										function (fStageComplete)
+										{
+											execOnPool(getAnimalInsert('Spot', 'Dog'), fStageComplete);
+										},
+										function (fStageComplete)
+										{
+											execOnPool(getAnimalInsert('Gertrude', 'Frog'), fStageComplete);
+										}
+									],
+									function (pError)
+									{
+										if (pError)
+										{
+											libFable.log.error(`Error preparing Oracle test data: ${pError}`);
+											return fDone(pError);
+										}
+										_SpooledUp = true;
+										fDone();
+									}
+								);
+							}
+						);
+					}
+				);
+
+			suiteTeardown((fDone) =>
+			{
+				if (libFable.MeadowOracleProvider && libFable.MeadowOracleProvider.pool)
+				{
+					try
+					{
+						libFable.MeadowOracleProvider.pool.close(0).then(() => fDone()).catch(() => fDone());
+					}
+					catch (pError)
+					{
+						return fDone();
+					}
+				}
+				else
+				{
+					fDone();
+				}
+			});
+
+			suite
+				(
+					'Object Sanity',
+					function ()
+					{
+						test
+							(
+								'The Oracle class should initialize itself into a happy little object.',
+								function ()
+								{
+									var testMeadow = require('../source/Meadow.js').new(libFable).setProvider('Oracle');
+									Expect(testMeadow).to.be.an('object', 'Meadow should initialize as an object directly from the require statement.');
+								}
+							);
+					}
+				);
+			suite
+				(
+					'Query Processing',
+					function ()
+					{
+						test
+							(
+								'Create a record in the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow().setIDUser(90210);
+
+									var tmpQuery = testMeadow.query.clone().setLogLevel(5)
+										.addRecord({ Name: 'Blastoise', Type: 'Pokemon' });
+
+									testMeadow.doCreate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pRecord.Name)
+												.to.equal('Blastoise');
+											Expect(pRecord.CreatingIDUser)
+												.to.equal(90210);
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Create a record with JSON data',
+								function (fDone)
+								{
+									var testMeadow = newMeadow().setIDUser(90210);
+
+									var tmpQuery = testMeadow.query.clone().setLogLevel(5)
+										.addRecord({ Name: 'Moose', Type: 'Mammal', Metadata: { habitat: 'forest', weight: 500 }, ExtraData: { endangered: false, population: 'stable' } });
+
+									testMeadow.doCreate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pRecord.Name)
+												.to.equal('Moose');
+											Expect(pRecord.Metadata)
+												.to.be.an('object');
+											Expect(pRecord.Metadata.habitat)
+												.to.equal('forest');
+											Expect(pRecord.ExtraData)
+												.to.be.an('object');
+											Expect(pRecord.ExtraData.endangered)
+												.to.equal(false);
+											// The storage column should not be exposed on the marshaled record
+											Expect(pRecord).to.not.have.property('ExtraDataJSON');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Read a record from the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.addFilter('IDAnimal', 1);
+
+									testMeadow.doRead(tmpQuery,
+										function (pError, pQuery, pRecord)
+										{
+											Expect(pRecord.IDAnimal)
+												.to.equal(1);
+											Expect(pRecord.Name)
+												.to.equal('Foo Foo');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Read all records from the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									testMeadow.doReads(testMeadow.query.addSort({Column: 'IDAnimal'}),
+										function (pError, pQuery, pRecords)
+										{
+											Expect(pRecords[0].IDAnimal)
+												.to.equal(1);
+											Expect(pRecords[0].Name)
+												.to.equal('Foo Foo');
+											Expect(pRecords[1].IDAnimal)
+												.to.equal(2);
+											Expect(pRecords[1].Name)
+												.to.equal('Red Riding Hood');
+											Expect(pRecords[1].Type)
+												.to.equal('Girl');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Update a record in the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.addRecord({ IDAnimal: 2, Type: 'Human' });
+
+									testMeadow.doUpdate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pRecord.Type)
+												.to.equal('Human');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Delete a record in the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query.addFilter('IDAnimal', 3);
+
+									testMeadow.doDelete(tmpQuery,
+										function (pError, pQuery, pRecord)
+										{
+											// It returns the number of rows deleted
+											Expect(pRecord)
+												.to.equal(1);
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Undelete a record in the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpDeleteQuery = testMeadow.query.addFilter('IDAnimal', 5);
+
+									// Make sure the record is deleted!
+									testMeadow.doDelete(tmpDeleteQuery,
+										function (pDeleteError, pDeleteQuery, pDeleteRecord)
+										{
+											var tmpQuery = testMeadow.query.addFilter('IDAnimal', 5);
+											testMeadow.doUndelete(tmpQuery,
+												function (pError, pQuery, pRecord)
+												{
+													// It returns the number of rows undeleted
+													Expect(pRecord)
+														.to.equal(1);
+													fDone();
+												});
+										});
+								}
+							);
+						test
+							(
+								'Count all records from the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									Expect(testMeadow.query.parameters.result.executed)
+										.to.equal(false);
+									testMeadow.doCount(testMeadow.query,
+										function (pError, pQuery, pRecord)
+										{
+											// There should be 6 records
+											Expect(pRecord)
+												.to.equal(6);
+											Expect(pQuery.parameters.result.executed)
+												.to.equal(true);
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Perform operations with a schema-based instantiation',
+								function (fDone)
+								{
+									var testMeadow = require('../source/Meadow.js').new(libFable)
+										.loadFromPackage(__dirname + '/Animal.json').setProvider('Oracle');
+
+									// Make sure the authentication stuff got loaded
+									Expect(testMeadow.schemaFull.authorizer.User)
+										.to.be.an('object');
+									Expect(testMeadow.schemaFull.authorizer.User.Create)
+										.to.equal('Allow');
+
+									var tmpQuery = testMeadow.query
+										.addRecord({ Name: 'Grommet', Type: 'Dog' });
+
+									testMeadow.doCreate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pRecord.Name)
+												.to.equal('Grommet');
+											fDone();
+										}
+									)
+								}
+							);
+					}
+				);
+			suite
+				(
+					'Logged Query Processing',
+					function ()
+					{
+						test
+							(
+								'Create a record in the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.setLogLevel(5)
+										.addRecord({ Name: 'MewTwo', Type: 'Pokemon' });
+
+									testMeadow.doCreate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pRecord.Name)
+												.to.equal('MewTwo');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Create a record in the database with a predefined GUID',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.setLogLevel(5)
+										.addRecord({ Name: 'MewThree', GUIDAnimal: '0x12345', Type: 'Pokemon' });
+
+									testMeadow.doCreate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pRecord.Name)
+												.to.equal('MewThree');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Create a record in the database with a previously predefined GUID -- expect failure',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.setLogLevel(5)
+										.addRecord({ Name: 'MewThree', GUIDAnimal: '0x12345', Type: 'Pokemon' });
+
+									testMeadow.doCreate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pError)
+												.to.equal("Record with GUID 0x12345 already exists!");
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Read a record from the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.setLogLevel(5)
+										.addFilter('IDAnimal', 1);
+
+									testMeadow.doRead(tmpQuery,
+										function (pError, pQuery, pRecord)
+										{
+											Expect(pRecord.IDAnimal)
+												.to.equal(1);
+											Expect(pRecord.Name)
+												.to.equal('Foo Foo');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Read all records from the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									testMeadow.doReads(testMeadow.query.setLogLevel(5).addSort({Column: 'IDAnimal'}),
+										function (pError, pQuery, pRecords)
+										{
+											Expect(pRecords[0].IDAnimal)
+												.to.equal(1);
+											Expect(pRecords[0].Name)
+												.to.equal('Foo Foo');
+											Expect(pRecords[1].IDAnimal)
+												.to.equal(2);
+											Expect(pRecords[1].Name)
+												.to.equal('Red Riding Hood');
+											Expect(pRecords[1].Type)
+												.to.equal('Human');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Update a record in the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.setLogLevel(5)
+										.addRecord({ IDAnimal: 2, Type: 'HumanGirl' });
+
+									testMeadow.doUpdate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pRecord.Type)
+												.to.equal('HumanGirl');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Delete a record in the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.setLogLevel(5)
+										.addFilter('IDAnimal', 4);
+
+									testMeadow.doDelete(tmpQuery,
+										function (pError, pQuery, pRecord)
+										{
+											// It returns the number of rows deleted
+											Expect(pRecord)
+												.to.equal(1);
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Count all records from the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									testMeadow.doCount(testMeadow.query.setLogLevel(5),
+										function (pError, pQuery, pRecord)
+										{
+											// There should be 8 records
+											Expect(pRecord)
+												.to.equal(8);
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Read a record from the database that had a defined GUID',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.addFilter('GUIDAnimal', '0x12345');
+
+									testMeadow.doRead(tmpQuery,
+										function (pError, pQuery, pRecord)
+										{
+											Expect(pRecord.Name)
+												.to.equal('MewThree');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Create a record in the database with a defined creating user',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+									var tmpQuery = testMeadow.query
+										.setIDUser(800)
+										.addRecord({ Name: 'MewSix', GUIDAnimal: '0x123456', Type: 'Pokemon' });
+
+									testMeadow.doCreate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pRecord.Name)
+												.to.equal('MewSix');
+											Expect(pRecord.CreatingIDUser)
+												.to.equal(800);
+											fDone();
+										}
+									)
+								}
+							);
+					}
+				);
+			suite
+				(
+					'The Bad Kind of Query Processing',
+					function ()
+					{
+						test
+							(
+								'Create a record in the database with no record',
+								function (fDone)
+								{
+									var testMeadow = newMeadow().setDefaultIdentifier('Type');
+
+									testMeadow.doCreate(testMeadow.query,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pError)
+												.to.equal('No record submitted');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Read a record from the database with no data returned',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.addFilter('IDAnimal', 5000);
+									testMeadow.doRead(tmpQuery,
+										function (pError, pQuery, pRecord)
+										{
+											Expect(pRecord)
+												.to.equal(false);
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Read records from the database with no data returned',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.addFilter('IDAnimal', 5000);
+
+									testMeadow.doReads(tmpQuery,
+										function (pError, pQuery, pRecord)
+										{
+											Expect(pRecord.length)
+												.to.equal(0);
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Update a record in the database with a bad filter',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.setLogLevel(5)
+										.addRecord({ IDAnimal: undefined, Type: 'HumanGirl' });
+
+									testMeadow.doUpdate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pError)
+												.to.equal('Automated update missing filters... aborting!');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Update a record in the database without passing a record in',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									testMeadow.doUpdate(testMeadow.query,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pError)
+												.to.equal('No record submitted');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Update a record in the database with a bad record passed in (no default identifier)',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.addRecord({ Name: 'Bill' });
+
+									testMeadow.doUpdate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pError)
+												.to.equal('Automated update missing default identifier');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Update a record in the database that does not exist',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.addRecord({ IDAnimal: 983924 });
+
+									testMeadow.doUpdate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pError)
+												.to.equal('No record found to update!');
+											fDone();
+										}
+									)
+								}
+							);
+					}
+				);
+		}
+	);