gramps/namaste
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
main
namaste/tests/unit/writeBrokerMongoNonCachedTest.php
gramps 373ebc8c93 Archive: Namaste PHP AMQP framework v1.0 (2017-2020) 
952 days continuous production uptime, 40k+ tp/s single node.
Original corpo Bitbucket history not included — clean archive commit.
2026-04-05 09:49:30 -07:00

1151 lines
63 KiB
PHP
Raw Permalink Blame History

<?php
$_REDIRECT = false;
require(dirname(__DIR__) . '/../config/sneakerstrap.inc'); // and load the namaste environment
use PHPUnit\Framework\TestCase;
class writeBrokerMongoNonCachedTest extends TestCase
{
protected gacBrokerClient $readBrokerClient;
protected gacBrokerClient $writeBrokerClient;
protected gacBrokerClient $adminOutClient;
protected static ?array $meta = null;
protected static ?array $adminMeta = null;
protected static ?object $widget;
protected static string $cKey;
protected static array $testRecord;
protected static array $journalRecord;
protected static string $journalRecordToken;
protected static string $testRecordToken;
protected static string $auditRecordToken;
protected static string $eventRecordToken;
protected static array $originalTestRecord;
protected static array $auditRecord;
protected static string $jayne = "Ten percent of nothin' is ... let me do the math here ... nothin' into nothin' ... carry the nothin' ... ";
/**
* setUpBeforeClass() -- public static unit test method
*
* this method is called first, and once, on execution. This method calls the setUpBeforeClass() method and then
* established the meta data payloads we'll use for client and admin event requests.
*
* @author mike@givingassistant.org
* @version 1.0
*
*
* HISTORY:
* ========
* 05-28-19 mks original coding
* 01-21-20 mks DB-150: support for PHP7.4 class member types
*
*/
public static function setUpBeforeClass()
{
parent::setUpBeforeClass();
// meta data (for namaste)
static::$meta = [
META_CLIENT => CLIENT_UNIT,
META_CLIENT_IP => STRING_SESSION_HOME,
META_SYSTEM_NOTES => STRING_ORIGIN_UT,
META_TEMPLATE => TEMPLATE_CLASS_TEST_MONGO
];
// meta data for admin requests
static::$adminMeta = [
META_CLIENT => CLIENT_UNIT,
META_CLIENT_IP => STRING_SESSION_HOME,
META_SYSTEM_NOTES => STRING_ORIGIN_UT
];
}
/**
* setUp() -- unit test reserved method
*
* the setUp method is executed prior to each test, executing the following tasks:
*
* 1. validate that the meta data persisted across tests
* 2. validate that we successfully created a write-broker client
* 3. validate that we successfully created a read-broker client
* 4. validate the successful instantiation of a factory-class and assign to the widget static
*
*
* @author mike@givingassistant.org
* @version 1.0
*
*
* HISTORY:
* ========
* 05-28-19 mks original coding
*
*/
protected function setUp()
{
parent::setUp();
$errors = array();
// validate the meta data for the pending query
$this->assertTrue(!empty(static::$meta), __FILE__ . COLON . __LINE__ . COLON . ERROR_DATA_META_404);
$this->assertTrue(is_array(static::$meta), __FILE__ . COLON . __LINE__ . COLON . ERROR_META_INVALID_FORMAT_ARRAY);
$this->assertTrue(array_key_exists(META_TEMPLATE, static::$meta), __FILE__ . COLON . __LINE__ . COLON . ERROR_DATA_META_KEY_404 . META_TEMPLATE);
// create the write broker client
$this->writeBrokerClient = new gacBrokerClient(BROKER_QUEUE_W, basename(__FILE__) . COLON . __METHOD__ . COLON . __LINE__);
$this->assertTrue($this->writeBrokerClient->status, __METHOD__ . __LINE__ . ERROR_BROKER_QUEUE_DECLARE . BROKER_QUEUE_W);
// create the read broker client
$this->readBrokerClient = new gacBrokerClient(BROKER_QUEUE_R, basename(__FILE__) . COLON . __METHOD__ . COLON . __LINE__);
$this->assertTrue($this->readBrokerClient->status, __METHOD__ . __LINE__ . ERROR_BROKER_QUEUE_DECLARE . BROKER_QUEUE_R);
// create the admin broker client
$this->adminOutClient = new gacBrokerClient(BROKER_QUEUE_AO, basename(__FILE__) . COLON . __METHOD__ . COLON . __LINE__);
$this->assertTrue($this->adminOutClient->status, __FILE__ . COLON . __LINE__ . COLON . ERROR_BROKER_QUEUE_DECLARE . BROKER_QUEUE_AO);
// instantiate a new widget
$objFactory = new gacFactory(static::$meta, FACTORY_EVENT_NEW_CLASS, '', $errors);
$this->assertTrue($objFactory->status, __FILE__ . COLON . __LINE__ . COLON . ERROR_FAILED_TO_INSTANTIATE . static::$meta[META_TEMPLATE]);
// extract and assign the factory widget and deallocate the factory
static::$widget = $objFactory->widget;
if (is_object($objFactory)) $objFactory->__destruct();
unset($objFactory);
// ensure that caching, auditing, and journaling are enabled for the class and that deletes are set to false
$this->assertTrue(static::$widget->useCache, __FILE__ . COLON . __LINE__ . COLON . ERROR_UT_EXPECTING_TRUE . STRING_CACHE);
$this->assertGreaterThan(0, static::$widget->useAuditing, __FILE__ . COLON . __LINE__ . COLON . ERROR_UT_EXPECTING_NON_ZERO_INT . static::$widget->useAuditing);
$this->assertTrue(static::$widget->useJournaling, __FILE__ . COLON . __LINE__ . COLON . ERROR_UT_EXPECTING_TRUE . STRING_JOURNAL);
$this->assertFalse(static::$widget->useDeletes, __FILE__ . COLON . __LINE__ . ERROR_UT_EXPECTING_FALSE . STRING_DELETE);
}
/**
* tearDown() -- unit test method
*
* This is the (reserved) tearDown method which is executed at the end of every test. The method deletes the
* current broker client.
*
*
* @author mike@givingassistant.org
* @version 1.0
*
* HISTORY:
* ========
* 05-28-19 mks original coding
*
*/
protected function tearDown()
{
if (is_object($this->readBrokerClient)) $this->readBrokerClient->__destruct();
unset($this->readBrokerClient);
if (is_object($this->writeBrokerClient)) $this->writeBrokerClient->__destruct();
unset($this->writeBrokerClient);
if (is_object(static::$widget)) {
static::$widget->__destruct();
}
static::$widget = null;
}
/**
* testOneInsert() -- unit test method
*
* This unit test method starts the mongo testing by creating a new record in the gaTest collection. The point
* of the method is to create a record, then extract the newly-created record from the event return payload -
* this data is validated and then stored in the the unit-test statics for future access and queries.
*
* The following assertions are made:
*
* -- assert that we successfully created and fetched the new record
* -- assert that only one test record was created (prior to the insert)
* -- assert that the create request was successful (PAYLOAD_STATUS)
* -- assert the the create request returned a state-success (PAYLOAD_STATE)
* -- assert that the create event created one and only one new record (PAYLOAD_RESULTS)
*
* If the randomly generated record has the following, then do:
*
* -- if there's an integer field, confirm that the integer value matches the test record value
* -- if there's a double field, confirm that the floating-point value matches the test record value
* -- if there's a string field, confirm that the string value matches the test record value
*
* We'll finally test that injected fields exist in the record:
*
* -- assert that a token was created in the new record
* -- assert that the token passes GUID validation
* -- assert that the status column was created in the new record
* -- assert that the status value is active
* -- assert that an event guid was inserted into the record
* -- assert that the event guid passes token validation
* -- assert that the created field was inserted into the record
*
* If all assertions are created, then store the original test record, the test record token, and the event token.
*
*
* @author mike@givingassistant.org
* @version 1.0
*
*
* HISTORY:
* ========
* 06-06-19 mks DB-122: original coding
*
*/
public function testOneInsert()
{
$testRecord = null;
$this->assertTrue(is_object(static::$widget), __FILE__ . COLON . __LINE__ . COLON . ERROR_UT_WIDGET_404);
$thisMeta = static::$meta;
$thisMeta[META_DO_CACHE] = false;
// create one record
$testRecord = static::$widget->template->buildTestData(1);
$intVal = (isset($testRecord[0][CM_TST_FIELD_TEST_INT])) ? $testRecord[0][CM_TST_FIELD_TEST_INT] : null;
$doubleVal = (isset($testRecord[0][CM_TST_FIELD_TEST_DOUBLE])) ? $testRecord[0][CM_TST_FIELD_TEST_DOUBLE] : null;
$strVal = (isset($testRecord[0][CM_TST_FIELD_TEST_STRING])) ? $testRecord[0][CM_TST_FIELD_TEST_STRING] : null;
$this->assertTrue(is_array($testRecord), __FILE__ . COLON . __LINE__ . COLON . ERROR_UT_EXPECTING_TRUE . 'is_array($testRecord)');
$this->assertEquals(1, count($testRecord), __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_INTEGER_MISMATCH, 1, count($testRecord)));
static::$originalTestRecord = $testRecord; // store the original record before insertion
// create the query/broker-event payload
$request = [
BROKER_REQUEST => BROKER_REQUEST_CREATE,
BROKER_DATA => $testRecord,
BROKER_META_DATA => $thisMeta
];
// build the request payload and submit the request to the write broker
$payload = gzcompress(json_encode($request));
$response = $this->writeBrokerClient->call($payload);
$response = json_decode(gzuncompress($response), true);
// validate the response payload
$this->assertTrue($response[PAYLOAD_STATUS], __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_BROKER_EVENT_FAIL, BROKER_REQUEST_CREATE, $response[PAYLOAD_STATE]));
$this->assertEquals(STATE_SUCCESS, $response[PAYLOAD_STATE], __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_STRING_MISMATCH, STATE_SUCCESS, $response[PAYLOAD_STATE]));
$this->assertEquals(1, count($response[PAYLOAD_RESULTS]), __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_INTEGER_MISMATCH, 1, count($response[PAYLOAD_RESULTS])));
// validate that the record was obtained in the return payload and that specific values match the pre-create test record values
if (!is_null($intVal)) {
$iVal = $response[PAYLOAD_RESULTS][0][CM_TST_FIELD_TEST_INT]; // 2 long 2 type twice
$this->assertEquals($intVal, $iVal, (basename(__METHOD__) . AT . __LINE__ . COLON) . sprintf(ERROR_UT_VALS_NOT_EQUAL, $intVal, $iVal));
}
if (!is_null($doubleVal)) {
$dVal = $response[PAYLOAD_RESULTS][0][CM_TST_FIELD_TEST_DOUBLE];
$this->assertEquals($doubleVal, $dVal, (basename(__METHOD__) . AT . __LINE__ . COLON) . sprintf(ERROR_UT_VALS_NOT_EQUAL, $doubleVal, $dVal));
}
if (!is_null($strVal)) {
$sVal = $response[PAYLOAD_RESULTS][0][CM_TST_FIELD_TEST_STRING];
$this->assertEquals($strVal, $sVal, (basename(__METHOD__) . AT . __LINE__ . COLON) . sprintf(ERROR_UT_VALS_NOT_EQUAL, $strVal, $sVal));
}
// ensure we have the system-side injections
$this->assertArrayHasKey(STRING_KEY, $response[PAYLOAD_RESULTS][0], (basename(__METHOD__) . AT . __LINE__ . COLON) . sprintf(ERROR_UT_FIELD_404, STRING_KEY, PAYLOAD_RESULTS));
$this->assertTrue(validateGUID($response[PAYLOAD_RESULTS][0][STRING_KEY]), (basename(__METHOD__) . AT . __LINE__ . COLON) . ERROR_INVALID_GUID . $response[PAYLOAD_RESULTS][0][STRING_KEY]);
$this->assertArrayHasKey(CM_TST_FIELD_TEST_STATUS, $response[PAYLOAD_RESULTS][0], (basename(__METHOD__) . AT . __LINE__ . COLON) . sprintf(ERROR_UT_FIELD_404, CM_TST_FIELD_TEST_STATUS, PAYLOAD_RESULTS));
$status = $response[PAYLOAD_RESULTS][0][CM_TST_FIELD_TEST_STATUS];
$this->assertEquals(STATUS_ACTIVE, $status, (basename(__METHOD__) . AT . __LINE__ . COLON) . sprintf(ERROR_UT_VALS_NOT_EQUAL, STATUS_ACTIVE, $status));
$this->assertArrayHasKey(CM_TST_EVENT_GUID, $response[PAYLOAD_RESULTS][0], (basename(__METHOD__) . AT . __LINE__ . COLON) . sprintf(ERROR_UT_FIELD_404, CM_TST_EVENT_GUID, PAYLOAD_RESULTS));
$this->assertTrue(validateGUID($response[PAYLOAD_RESULTS][0][CM_TST_EVENT_GUID]), (basename(__METHOD__) . AT . __LINE__ . COLON) . ERROR_INVALID_GUID . $response[PAYLOAD_RESULTS][0][CM_TST_EVENT_GUID]);
$this->assertArrayHasKey(CM_TST_FIELD_TEST_CDATE, $response[PAYLOAD_RESULTS][0], (basename(__METHOD__) . AT . __LINE__ . COLON) . sprintf(ERROR_UT_FIELD_404, CM_TST_FIELD_TEST_CDATE, PAYLOAD_RESULTS));
$this->assertTrue(is_int($response[PAYLOAD_RESULTS][0][CM_TST_FIELD_TEST_CDATE]), (basename(__METHOD__) . AT . __LINE__ . COLON) . ERROR_UT_EXPECTING_NON_ZERO_INT . $response[PAYLOAD_RESULTS][0][CM_TST_FIELD_TEST_CDATE]);
// store copies of the data that will be used in subsequent methods...
static::$testRecord = $response[PAYLOAD_RESULTS][0]; // store the db-version of the record
static::$testRecordToken = static::$testRecord[STRING_KEY];
static::$eventRecordToken = static::$testRecord[CM_TST_EVENT_GUID];
}
/**
* testInsertAudit() -- unit test method
*
* This method first validates the statics that were stored previous to this method:
*
* -- assert that the original test record was saved
* -- assert that the (saved) test record was saved
* -- assert that test record token was saved
* -- assert that the event record token was saved
*
* Next, build a query and submit the query to the admin service that will fetch the audit record -- said query
* was based on the record's token and eventGUID -- this query makes the record returned unique.
*
* Once the data from the query is returned from the admin server, we make the following assertions:
*
* -- assert that there exists a token (for the audit record) in the return payload
* -- assert that the token is valid
*
* Store the auditRecordToken and the audit record into a class static.
*
*
* @author mike@givingassistant.org
* @version 1.0
*
*
* HISTORY:
* ========
* 06-06-19 mks DB-122: original coding
*
*/
public function testInsertAudit()
{
// sleep for a second to allow the audit record to be written to disk
sleep(1);
$this->assertNotEmpty(static::$originalTestRecord, (basename(__METHOD__) . AT . __LINE__ . COLON) . 'lost the original test record');
$this->assertNotEmpty(static::$testRecord, (basename(__METHOD__) . AT . __LINE__ . COLON) . 'lost the test record');
$this->assertNotEmpty(static::$testRecordToken, (basename(__METHOD__) . AT . __LINE__ . COLON) . 'lost the test record token');
$this->assertNotEmpty(static::$eventRecordToken, (basename(__METHOD__) . AT . __LINE__ . COLON) . 'lost the event token');
// build the query to fetch the audit record from the admin service based on the created-record token and the
// eventGUID assigned to the record...this implicitly validates the audit record for the create event.
$query = [
AUDIT_RECORD_TOKEN => [ OPERAND_NULL => [ OPERATOR_EQ => [ static::$testRecordToken ]]],
DB_EVENT_GUID => [ OPERAND_NULL => [ OPERATOR_EQ => [ static::$eventRecordToken ]]],
OPERAND_AND => null
];
static::$adminMeta[META_TEMPLATE] = TEMPLATE_CLASS_AUDIT;
$request = [
BROKER_REQUEST => BROKER_REQUEST_REMOTE_FETCH,
BROKER_DATA => [ STRING_QUERY_DATA => $query ],
BROKER_META_DATA => static::$adminMeta
];
$payload = gzcompress(json_encode($request));
$response = $this->adminOutClient->call($payload);
$response = json_decode(gzuncompress($response), true);
$this->assertTrue($response[PAYLOAD_STATUS], __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_BROKER_EVENT_FAIL, BROKER_REQUEST_REMOTE_FETCH, $response[PAYLOAD_STATE]));
// once we got the audit record, validate the operation, the status, and pull the audit record token
// for a future query against the journal record
$this->assertArrayHasKey((DB_TOKEN . COLLECTION_MONGO_AUDIT_EXT), $response[PAYLOAD_RESULTS][STRING_QUERY_RESULTS][0], (basename(__METHOD__) . AT . __LINE__ . COLON) . sprintf(ERROR_UT_FIELD_404, DB_TOKEN, STRING_QUERY_RESULTS));
static::$auditRecordToken = $response[PAYLOAD_RESULTS][STRING_QUERY_RESULTS][0][DB_TOKEN . COLLECTION_MONGO_AUDIT_EXT];
$this->assertTrue(validateGUID(static::$auditRecordToken), (basename(__METHOD__) . AT . __LINE__ . COLON) . ERROR_INVALID_GUID . static::$auditRecordToken);
static::$auditRecord = $response[PAYLOAD_RESULTS][STRING_QUERY_RESULTS][0];
}
/**
* testInsertJournal() - unit test method
*
* This method is used in conjunction with the insert method above. The previous two methods inserted a new record
* and validated that the audit record was created as a result of the insert, respectively. This method validates
* that the journal record was created for the insert event.
*
* The following assertions are made in this method:
*
* -- the test record token was successfully saved
* -- the event record token was successfully saved
* -- the audit record token was successfully saved
*
* We then submit a query to the admin-out broker to fetch the journal record based on the audit record and data
* record tokens and the event GUID we generated for the create event. (The event token locks down the request
* to the insert query.)
*
* -- the fetch-journal record returned with a true status
* -- the fetch event request returned one record
*
* We save the journal record into the static member so that, in the next method, we validate the content of
* the journal record by executing the journal rollback.
*
*
* @author mike@givingassistant.org
* @version 1.0
*
*
* HISTORY:
* ========
* 06-10-19 mks DB-122: original coding
*
*/
public function testInsertJournal()
{
$this->assertNotEmpty(static::$testRecordToken, (basename(__METHOD__) . AT . __LINE__ . COLON) . 'lost the test record token');
$this->assertNotEmpty(static::$eventRecordToken, (basename(__METHOD__) . AT . __LINE__ . COLON) . 'lost the event token');
$this->assertNotEmpty(static::$auditRecordToken, (basename(__METHOD__) . AT . __LINE__ . COLON) . 'lost the audit record token');
// implicitly test that we created the journal record off the insert event by querying the database by the
// data record token, the event guid, and the audit token together. This way, if the record has more than
// one journal record associated with the record guid, we're still filtering by the event guid.
// build the fetch query for the journaling collection
$query = [
JOURNAL_AUD_TOK => [ OPERAND_NULL => [ OPERATOR_EQ => [ static::$auditRecordToken ]]],
JOURNAL_SYSEV_TOK => [ OPERAND_NULL => [ OPERATOR_EQ => [ static::$eventRecordToken]]],
JOURNAL_RECORD_GUID => [ OPERAND_NULL => [ OPERATOR_EQ => [ static::$testRecordToken]]],
OPERAND_AND => null
];
$tmpMeta = static::$adminMeta;
$tmpMeta[META_TEMPLATE] = TEMPLATE_CLASS_JOURNAL;
$payload = [
BROKER_REQUEST => BROKER_REQUEST_REMOTE_FETCH,
BROKER_DATA => [
STRING_QUERY_DATA => $query
],
BROKER_META_DATA => $tmpMeta
];
$request = gzcompress(json_encode($payload));
$response = $this->adminOutClient->call($request);
$response = json_decode(gzuncompress($response), true);
$this->assertTrue($response[PAYLOAD_STATUS], __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_BROKER_EVENT_FAIL, BROKER_REQUEST_FETCH, $response[PAYLOAD_STATE]));
$this->assertEquals(1, count($response[PAYLOAD_RESULTS][STRING_QUERY_RESULTS]), __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_INTEGER_MISMATCH, 1, count($response[PAYLOAD_RESULTS][STRING_QUERY_RESULTS])));
// load the journal record into a static member for the next test
static::$journalRecord = $response[PAYLOAD_RESULTS][STRING_QUERY_RESULTS][0];
static::$journalRecordToken = static::$journalRecord[DB_TOKEN . COLLECTION_MONGO_JOURNAL_EXT];
$this->assertTrue(validateGUID(static::$journalRecordToken), (basename(__METHOD__) . AT . __LINE__ . COLON) . ERROR_INVALID_GUID . static::$journalRecordToken);
}
/**
* testInsertJournalRecovery() -- unit test method
*
* This unit test method is responsible for exec'ing the journal-recovery plan from the create event. First,
* however, we make the following checks:
*
* -- assert that the test record token is still stored in the static
* -- assert that the event record token is still stored in the static
* -- assert that the audit record token is still stored in the static
* -- assert that the journal record is still stored in the static
* -- assert that the journal token is still stored in the static
*
* Next, we build and publish the request to the adminOut broker - this event executes the restore query stored
* in the journal record which, in this case, should delete the record causing the subsequent fetch event to fail.
*
* -- assert that the request published returned with true status meaning that the event completed successfully
* -- assert that the subsequent fetch request failed (record should still exists albeit with a deleted status)
*
*
* @author mike@givingassistant.org
* @version 1.0
*
*
* HISTORY:
* ========
* 06-10-19 mks DB-122: original coding
*
*/
public function testInsertJournalRecovery()
{
$this->assertNotEmpty(static::$testRecordToken, (basename(__METHOD__) . AT . __LINE__ . COLON) . 'lost the test record token');
$this->assertNotEmpty(static::$eventRecordToken, (basename(__METHOD__) . AT . __LINE__ . COLON) . 'lost the event token');
$this->assertNotEmpty(static::$auditRecordToken, (basename(__METHOD__) . AT . __LINE__ . COLON) . 'lost the audit record token');
$this->assertNotEmpty(static::$journalRecord, (basename(__METHOD__) . AT . __LINE__ . COLON) . 'lost the journal record');
$this->assertNotEmpty(static::$journalRecordToken, (basename(__METHOD__) . AT . __LINE__ . COLON) . 'lost the journal record token');
// once we've confirmed that the statics are saved, construct the restore-audit query:
$query = [ STRING_KEY => static::$auditRecordToken ];
$meta = static::$adminMeta;
$meta[META_TEMPLATE] = TEMPLATE_CLASS_AUDIT;
$request = [
BROKER_REQUEST => BROKER_REQUEST_AUDIT_RESTORE,
BROKER_DATA => $query,
BROKER_META_DATA => $meta
];
$payload = gzcompress(json_encode($request));
$response = $this->adminOutClient->call($payload);
$response = json_decode(gzuncompress($response), true);
$this->assertTrue($response[PAYLOAD_STATUS], __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_BROKER_EVENT_FAIL, BROKER_REQUEST_AUDIT_RESTORE, $response[PAYLOAD_STATE]));
// if we're still executing, that the record was "restored" --- attempt to pull the record
$query = [ DB_TOKEN => [ OPERAND_NULL => [ OPERATOR_EQ => [static::$testRecordToken ]]]];
$request = [
BROKER_REQUEST => BROKER_REQUEST_FETCH,
BROKER_DATA => [
STRING_QUERY_DATA => $query
],
BROKER_META_DATA => static::$meta
];
$payload = gzcompress(json_encode($request));
$response = $this->readBrokerClient->call($payload);
$response = json_decode(gzuncompress($response), true);
$this->assertEquals(STATE_NOT_FOUND, $response[PAYLOAD_STATE], __FILE__ . COLON . __LINE__ . sprintf(ERROR_UT_VALS_NOT_EQUAL, STATE_NOT_FOUND, $response[PAYLOAD_STATE]));
}
/**
* testMultipleInserts() -- unit test method
*
* This is another insert test but we're testing insertion of more than one record in a single event. This test
* can be run as a stand-alone test as it's not predicated on any class-stored data.
*
* -- assert that the widget is still active in the static member
*
* We're going to generate a random number between 50 and 100 -- this will be the number of records we're going
* to create and pass into the event request as the data payload. Prior to submitting the request, we adjust
* the standard meta-data payload s.t. we'll disable a cached return payload.
*
* -- test that the create event return status was successful
* -- test that the number of inserted records requested matched the number of records returned
*
* Pull a random record from the return payload and make the following assertions/comparisons against the originally
* submitted record.
*
* -- assert that the test integer values match
* -- assert that the string value matches
* -- assert that the double value matches
* -- assert that the boolean value matched
*
* Also test that we have the injected fields:
*
* -- assert that date-created field is present in the random record
* -- assert that the token field is present in the random record
* -- assert that the status field is present in the random record
* -- assert that the token field is a valid token
* -- assert that the status field contains the value STATUS_ACTIVE
* -- assert that the date-created field is an integer value
*
*
* @author mike@givingassistant.org
* @version 1.0
*
*
* HISTORY:
* ========
* 06-10-19 mks DB-122: original coding
*
*/
public function testMultipleInserts()
{
$this->assertTrue(is_object(static::$widget), (basename(__METHOD__) . AT . __LINE__ . COLON) . ERROR_UT_WIDGET_404);
// create a random number of records between 50 and 100 and validate the numbers
$recCount = mt_rand(50,100);
$testRecords = static::$widget->template->buildTestData($recCount);
$this->assertTrue(is_array($testRecords), (basename(__METHOD__) . AT . __LINE__ . COLON) . ERROR_UT_EXPECTING_TRUE . 'is_array(testRecords)');
$this->assertEquals($recCount, count($testRecords), (basename(__METHOD__) . AT . __LINE__ . COLON) . sprintf(ERROR_UT_INTEGER_MISMATCH, $recCount, count($testRecords)));
// change the meta payload to ignore cache
$meta = static::$meta;
$meta[META_DO_CACHE] = false;
// build the create-event request
$request = [
BROKER_REQUEST => BROKER_REQUEST_CREATE,
BROKER_DATA => $testRecords,
BROKER_META_DATA => $meta
];
// build the request payload and submit the request to the write broker
$payload = gzcompress(json_encode($request));
$response = $this->writeBrokerClient->call($payload);
$response = json_decode(gzuncompress($response), true);
// evaluate the request response
$this->assertTrue($response[PAYLOAD_STATUS], (__FILE__ . COLON) . __LINE__ . COLON . ERROR_UT_EXPECTING_TRUE . PAYLOAD_STATUS);
// validate that the count of inserted records matches the number of records, or cache keys, returned
// first, fetch the referenced item from cache
$guidPayload = $response[PAYLOAD_RESULTS];
$this->assertTrue(is_array($guidPayload), basename(__METHOD__) . AT . __LINE__ . COLON . sprintf(ERROR_UT_FIELD_VALUE, 'guidPayload'));
$this->assertEquals(count($guidPayload), $recCount, basename(__METHOD__) . AT . __LINE__ . COLON . sprintf(ERROR_UT_VALS_NOT_EQUAL, count($guidPayload), ($recCount + 1)));
// fetch a random record from cache
$rr = mt_rand(0, ($recCount - 1));
$rec = $guidPayload[$rr];
$recCacheGUID = $rec[STRING_KEY];
$this->assertTrue(validateGUID($recCacheGUID), basename(__METHOD__) . AT . __LINE__ . COLON . ERROR_INVALID_GUID . $recCacheGUID);
// compare the random record base values to the same record still stored in the array we submitted to the broker
$this->assertEquals($testRecords[$rr][CM_TST_FIELD_TEST_INT], $rec[CM_TST_FIELD_TEST_INT], __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_SAME_FIELD_COMPARE_FAIL, CM_TST_FIELD_TEST_INT));
$this->assertEquals($testRecords[$rr][CM_TST_FIELD_TEST_STRING], $rec[CM_TST_FIELD_TEST_STRING], __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_SAME_FIELD_COMPARE_FAIL, CM_TST_FIELD_TEST_STRING));
$this->assertEquals($testRecords[$rr][CM_TST_FIELD_TEST_DOUBLE], $rec[CM_TST_FIELD_TEST_DOUBLE], __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_SAME_FIELD_COMPARE_FAIL, CM_TST_FIELD_TEST_DOUBLE));
$this->assertEquals($testRecords[$rr][CM_TST_FIELD_TEST_BOOL], $rec[CM_TST_FIELD_TEST_BOOL], __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_SAME_FIELD_COMPARE_FAIL, CM_TST_FIELD_TEST_BOOL));
// validate that we have dateCreated, key and status fields which were inserted by the framework
$this->assertTrue(array_key_exists(CM_TST_FIELD_TEST_CDATE, $rec), __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_FIELD_404, CM_TST_FIELD_TEST_CDATE, STRING_DATA));
$this->assertTrue(array_key_exists(STRING_KEY, $rec), __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_FIELD_404, STRING_KEY, STRING_DATA));
$this->assertTrue(array_key_exists(CM_TST_FIELD_TEST_STATUS, $rec), __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_FIELD_404, CM_TST_FIELD_TEST_STATUS, STRING_DATA));
// validate that these fields have content of the correct type or that the literals match
// validate the token guid
$this->assertTrue(validateGUID($rec[STRING_KEY]), __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_FIELD_VALUE, STRING_KEY));
// validate the status value
$this->assertEquals(STATUS_ACTIVE, $rec[CM_TST_FIELD_TEST_STATUS], __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_FIELD_VALUE, CM_TST_FIELD_TEST_STATUS));
// validate the createdData type
$this->assertTrue(is_int($rec[CM_TST_FIELD_TEST_CDATE]), __FILE__ . COLON . __LINE__ . COLON . sprintf(CM_TST_FIELD_TEST_CDATE, DB_CREATED));
}
/**
* testUpdateOneRecord() -- unit test method
*
* This unit test pulls any record where the test string does not equal to the Jayne string (member static) -
* store this test record into member statics for future testing. The query itself has meta fields added so that
* the event processing doesn't filter the return data, that we skip auditing for the query fetch, and that
* we limit the return payload to a single record.
*
* Once the fetch request has been submitted...
*
* -- assert that the query executed successfully (payload status is true)
* -- assert that the query returned only one record
* -- assert that the record has a token
* -- assert that the record token is valid
* -- assert that the event guid is valid
* -- assert that the string field does not equal $jayne
*
* We store the test record, the record token and the event guid in member statics.
*
* Next, we build an update query using the just-pulled record and submit the update-event query:
*
* -- assert that the update request successfully executed
*
* Store the event guid into a static member for subsequent tests.
*
*
* @author mike@givingassistant.org
* @version 1.0
*
*
* HISTORY:
* ========
* 06-11-19 mks DB-122: original coding
*
*/
public function testUpdateOneRecord()
{
// build a simple update query by pulling an active record that doesn't have the jayne string
$query = [CM_TST_FIELD_TEST_STRING => [ OPERAND_NULL => [ OPERATOR_DNE => [static::$jayne]]]];
// we need to fetch a "before" version of a record, before it's updated, for testing the audit later
$testRecord = null;
$adminMeta = static::$adminMeta;
$adminMeta[META_DONUT_FILTER] = 1;
$adminMeta[META_SKIP_AUDIT] = 1;
$adminMeta[META_TEMPLATE] = TEMPLATE_CLASS_TEST_MONGO;
$adminMeta[META_LIMIT] = 1;
// build and submit the event request
$request = [
BROKER_REQUEST => BROKER_REQUEST_FETCH,
BROKER_DATA => [ STRING_QUERY_DATA => $query ],
BROKER_META_DATA => $adminMeta
];
// this query, incidentally, implicitly tests the ability of namaste to return a non-mapped, non-cached record
$eventPayload = gzcompress(json_encode($request));
$response = $this->readBrokerClient->call($eventPayload);
$response = json_decode(gzuncompress($response), true);
$this->assertTrue($response[PAYLOAD_STATUS], (basename(__FILE__) . COLON . __LINE__ ) . COLON . sprintf(ERROR_UT_BROKER_EVENT_FAIL, BROKER_REQUEST_FETCH, $response[PAYLOAD_STATE]));
// ensure that META_LIMIT works by testing that we only returned one non-cached record
$recCount = intval($response[PAYLOAD_RESULTS][STRING_QUERY_DATA][STRING_REC_COUNT_RET]);
$this->assertEquals(1, $recCount, (basename(__FILE__) . COLON . __LINE__) . COLON . sprintf(ERROR_UT_INTEGER_MISMATCH, 1, $recCount) . MONGO_STRING_COUNT);
// pull the test record from the payload and validate important fields
$testRecord = $response[PAYLOAD_RESULTS][PAYLOAD_QUERY][0];
$this->assertEquals(STATUS_ACTIVE, $testRecord[(DB_STATUS . COLLECTION_MONGO_TEST_EXT)], (basename(__FILE__) . COLON . __FILE__) . COLON . sprintf(ERROR_UT_VALS_NOT_EQUAL, STATUS_ACTIVE, $testRecord[(DB_STATUS . COLLECTION_MONGO_TEST_EXT)]));
$this->assertArrayHasKey((STRING_TOKEN . COLLECTION_MONGO_TEST_EXT), $testRecord, (basename(__FILE__) . COLON . __LINE__) . COLON . sprintf(ERROR_UT_FIELD_404, STRING_TOKEN, 'testRecord'));
$guid = $testRecord[(STRING_TOKEN . COLLECTION_MONGO_TEST_EXT)];
$this->assertTrue(validateGUID($guid), (basename(__FILE__) . COLON . __LINE__) . COLON . ERROR_INVALID_GUID . $guid);
$this->assertTrue(validateGUID($testRecord[DB_EVENT_GUID . COLLECTION_MONGO_TEST_EXT]), (basename(__METHOD__) . AT . __LINE__ . COLON) . ERROR_INVALID_GUID . $testRecord[DB_EVENT_GUID . COLLECTION_MONGO_TEST_EXT]);
$tString = (isset($testRecord[TEST_FIELD_TEST_STRING . COLLECTION_MONGO_TEST_EXT])) ? $testRecord[TEST_FIELD_TEST_STRING . COLLECTION_MONGO_TEST_EXT] : '';
$this->assertNotEquals(static::$jayne, $tString, (basename(__METHOD__) . AT . __LINE__ . COLON) . sprintf(ERROR_UT_STRING_MATCH, static::$jayne, $tString));
// store the test record (and some guids) into the static containers
static::$testRecord = $testRecord;
static::$testRecordToken = $testRecord[(DB_TOKEN . COLLECTION_MONGO_TEST_EXT)];
static::$eventRecordToken = $testRecord[(DB_EVENT_GUID . COLLECTION_MONGO_TEST_EXT)];
// build the update query
$query = [ DB_TOKEN => [ OPERAND_NULL => [ OPERATOR_EQ => [$guid]]]];
$update = [ CM_TST_FIELD_TEST_STRING => static::$jayne ];
// build the broker-update-event payload
$payload = [
STRING_QUERY_DATA => $query,
STRING_UPDATE_DATA => $update
];
$eventGUID = guid(); // generate a known event guid for audit tracking
$meta = static::$meta;
$meta[META_EVENT_GUID] = $eventGUID;
// create the query/broker-event payload
$request = [
BROKER_REQUEST => BROKER_REQUEST_UPDATE,
BROKER_DATA => $payload,
BROKER_META_DATA => $meta
];
// submit the request and process the result payload
$eventPayload = gzcompress(json_encode($request));
$response = $this->writeBrokerClient->call($eventPayload);
$response = json_decode(gzuncompress($response), true);
// verify that the update was successful
$this->assertTrue($response[PAYLOAD_STATUS], (__FILE__ . COLON . __LINE__) . COLON . ERROR_UT_EXPECTING_TRUE . PAYLOAD_STATUS);
static::$eventRecordToken = $eventGUID;
}
/**
* testUpdateAudit() -- unit test method
*
* This unit test method validates the audit functionality that should have been triggered by the update event
* executed in the previous method.
*
* -- assert that the event record token was saved and is still available
* -- assert that the test record token was saved and is still available
* -- assert that the original test record was saved and is still available
*
* We build the query for the remote-fetch-event and submit the request to fetch the audit record and then we
* validate that key columns in the audit record are populated. (We'll need these values for the next unit test.)
*
* -- assert that the event request (status) executed successfully
* -- assert that the record token exists in the data payload
* -- assert that the record token is a valid GUID
* -- assert that the audit record is in array format
*
* Store the content of the audit record into a member static.
*
*
* @author mike@givingassistant.org
* @version 1.0
*
*
* HISTORY:
* ========
* 06-12-19 mks DB-122: original coding
*
*/
public function testUpdateAudit()
{
// verify that we have a eventGUID so we can fetch the audit token, and verify that we have a copy of
// the original record before it was updated in the previous method
$this->assertTrue(validateGUID(static::$eventRecordToken), (basename(__FILE__) . COLON . __LINE__) . ERROR_INVALID_GUID . static::$eventRecordToken);
$this->assertTrue(validateGUID(static::$testRecordToken), (basename(__FILE__) . COLON . __LINE__) . ERROR_INVALID_GUID . static::$testRecordToken);
$this->assertTrue(is_array(static::$originalTestRecord), (basename(__FILE__) . COLON . __LINE__) . ERROR_UT_LOST_VARIABLE . 'originalTestRecord');
// fetch the audit record based on the record and event guids, testing that we successfully created an audit
// record off the update operation in the previous method
$adminMeta = static::$adminMeta;
$adminMeta[META_TEMPLATE] = TEMPLATE_CLASS_AUDIT;
$query = [
AUDIT_RECORD_TOKEN => [ OPERAND_NULL => [ OPERATOR_EQ => [ static::$testRecordToken ]]],
DB_EVENT_GUID => [ OPERAND_NULL => [ OPERATOR_EQ => [ static::$eventRecordToken ]]],
OPERAND_AND => null
];
$request = [
BROKER_REQUEST => BROKER_REQUEST_REMOTE_FETCH,
BROKER_DATA => [ STRING_QUERY_DATA => $query ],
BROKER_META_DATA => $adminMeta
];
sleep(1);
$payload = gzcompress(json_encode($request));
$response = $this->adminOutClient->call($payload);
$response = json_decode(gzuncompress($response), true);
$this->assertTrue($response[PAYLOAD_STATUS], __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_BROKER_EVENT_FAIL, BROKER_REQUEST_REMOTE_FETCH, $response[PAYLOAD_STATE]));
static::$auditRecordToken = $response[PAYLOAD_RESULTS][PAYLOAD_QUERY][0][STRING_TOKEN . COLLECTION_MONGO_AUDIT_EXT];
$this->assertNotEmpty(static::$auditRecordToken, (basename(__FILE__) . COLON . __LINE__) . COLON . ERROR_UT_LOST_VARIABLE . 'audit record token');
$this->assertTrue(validateGUID(static::$auditRecordToken), (basename(__FILE__) . COLON . __LINE__) . COLON . ERROR_INVALID_GUID . static::$auditRecordToken);
static::$auditRecord = $response[PAYLOAD_RESULTS][PAYLOAD_QUERY][0];
$this->assertTrue(is_array(static::$auditRecord), (basename(__FILE__) . COLON . __LINE__) . COLON . ERROR_UT_GENERIC_FAIL . 'failed to fetch audit record');
}
/**
* testUpdateJournal() -- unit test method
*
* This function continues the previous two methods of testing by asserting that the previous update event created
* a journal record. We're only testing that the journal record exists, and through the query itself, validates
* the back-linking to the audit record via the eventGUID and the auditGUID.
*
* Once we've confirmed that the journal record was successfully created, then we'll store the journal token and
* the journal record for the final method/test: restoring the record to it's previous state.
*
*
* @author mike@givingassistant.org
* @version 1.0
*
*
* HISTORY:
* ========
* 06-12-19 mks DB-122: original coding
*
*/
public function testUpdateJournal()
{
// sleep for a second to give time for the journal record to be transferred to disk
sleep(1);
// validate that the carry-over data exists
$this->assertTrue(validateGUID(static::$eventRecordToken), (basename(__FILE__) . COLON . __LINE__) . ERROR_INVALID_GUID . static::$eventRecordToken);
$this->assertTrue(validateGUID(static::$testRecordToken), (basename(__FILE__) . COLON . __LINE__) . ERROR_INVALID_GUID . static::$testRecordToken);
$this->assertTrue(is_array(static::$originalTestRecord), (basename(__FILE__) . COLON . __LINE__) . ERROR_UT_LOST_VARIABLE . 'originalTestRecord');
$this->assertTrue(validateGUID(static::$auditRecordToken), (basename(__FILE__) . COLON . __LINE__) . COLON . ERROR_INVALID_GUID . static::$auditRecordToken);
$this->assertTrue(is_array(static::$auditRecord), (basename(__FILE__) . COLON . __LINE__) . ERROR_UT_LOST_VARIABLE . 'auditRecord');
// fetch the journal record based on the event guid and the audit guid
$query = [
JOURNAL_AUD_TOK => [ OPERAND_NULL => [ OPERATOR_EQ => [ static::$auditRecordToken ]]],
DB_EVENT_GUID => [ OPERAND_NULL => [ OPERATOR_EQ => [ static::$eventRecordToken]]],
OPERAND_AND => null
];
$adminMeta = static::$adminMeta;
$adminMeta[META_TEMPLATE] = TEMPLATE_CLASS_JOURNAL;
$request = [
BROKER_REQUEST => BROKER_REQUEST_REMOTE_FETCH,
BROKER_DATA => [ STRING_QUERY_DATA => $query ],
BROKER_META_DATA => $adminMeta
];
$payload = gzcompress(json_encode($request));
$response = $this->adminOutClient->call($payload);
$response = json_decode(gzuncompress($response), true);
$this->assertTrue($response[PAYLOAD_STATUS], (basename(__FILE__) . COLON . __LINE__) . COLON . sprintf(ERROR_UT_BROKER_EVENT_FAIL, BROKER_REQUEST_REMOTE_FETCH, $response[PAYLOAD_STATE]));
static::$journalRecord = $response[PAYLOAD_RESULTS][PAYLOAD_QUERY][0];
$this->assertTrue(is_array(static::$journalRecord), (basename(__FILE__) . COLON . __LINE__) . COLON . ERROR_UT_GENERIC_FAIL . 'failed to fetch journal record');
}
/**
* testUpdateJournalRecovery() -- unit test method
*
* This unit test will invoke the audit/journal-recovery event to restore the previously-updated record back to
* it's original state. In the previous update, we changed the string to "jayne" - this test will invoke the audit
* restore event and then validate that the update was reversed.
*
* Assertions:
* 1-6: static data persists
* 7: Audit-restore event completed successfully (via the broker event request)
* 8: That we were able to fetch the updated record
* 9: That the test-string in the original record matches the updated record
*
*
* @author mike@givingassistant.org
* @version 1.0
*
*
* HISTORY:
* ========
* 06-12-19 mks DB-122: original coding
*
*/
public function testUpdateJournalRecovery()
{
// validate that the carry-over data exists
$this->assertTrue(validateGUID(static::$eventRecordToken), (basename(__FILE__) . COLON . __LINE__) . ERROR_INVALID_GUID . static::$eventRecordToken);
$this->assertTrue(validateGUID(static::$testRecordToken), (basename(__FILE__) . COLON . __LINE__) . ERROR_INVALID_GUID . static::$testRecordToken);
$this->assertTrue(is_array(static::$originalTestRecord), (basename(__FILE__) . COLON . __LINE__) . ERROR_UT_LOST_VARIABLE . 'originalTestRecord');
$this->assertTrue(validateGUID(static::$auditRecordToken), (basename(__FILE__) . COLON . __LINE__) . COLON . ERROR_INVALID_GUID . static::$auditRecordToken);
$this->assertTrue(is_array(static::$auditRecord), (basename(__FILE__) . COLON . __LINE__) . ERROR_UT_LOST_VARIABLE . 'auditRecord');
$this->assertTrue(is_array(static::$journalRecord), (basename(__FILE__) . COLON . __LINE__) . ERROR_UT_LOST_VARIABLE . 'journalRecord');
// build the recovery query to restore the original record
$query = [ STRING_KEY => static::$auditRecordToken ];
$meta = static::$adminMeta;
$meta[META_TEMPLATE] = TEMPLATE_CLASS_AUDIT;
$request = [
BROKER_REQUEST => BROKER_REQUEST_AUDIT_RESTORE,
BROKER_DATA => $query,
BROKER_META_DATA => $meta
];
$payload = gzcompress(json_encode($request));
$response = $this->adminOutClient->call($payload);
$response = json_decode(gzuncompress($response), true);
$this->assertTrue($response[PAYLOAD_STATUS], __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_BROKER_EVENT_FAIL, BROKER_REQUEST_AUDIT_RESTORE, $response[PAYLOAD_STATE]));
// if we're still executing, that the record was "restored" --- attempt to pull the record
$query = [ DB_TOKEN => [ OPERAND_NULL => [ OPERATOR_EQ => [static::$testRecordToken ]]]];
$meta = static::$meta;
$meta[META_DONUT_FILTER] = 1;
$meta[META_DO_CACHE] = false;
$request = [
BROKER_REQUEST => BROKER_REQUEST_FETCH,
BROKER_DATA => [
STRING_QUERY_DATA => $query
],
BROKER_META_DATA => $meta
];
$payload = gzcompress(json_encode($request));
$response = $this->readBrokerClient->call($payload);
$response = json_decode(gzuncompress($response), true);
$this->assertEquals(STATE_SUCCESS, $response[PAYLOAD_STATE], __FILE__ . COLON . __LINE__ . sprintf(ERROR_UT_VALS_NOT_EQUAL, STATE_SUCCESS, $response[PAYLOAD_STATE]));
// compare the string field to the original record - they should be the same, or at least not jayne
$originalString = static::$testRecord[TEST_FIELD_TEST_STRING . COLLECTION_MONGO_TEST_EXT];
$updatedString = $response[PAYLOAD_RESULTS][STRING_QUERY_RESULTS][0][TEST_FIELD_TEST_STRING . COLLECTION_MONGO_TEST_EXT];
$this->assertEquals($originalString, $updatedString, (basename(__FILE__) . COLON . __LINE__) . COLON . sprintf(ERROR_UT_VALS_NOT_EQUAL, $originalString, $updatedString));
}
/**
* testDeleteOneRecord() -- unit test method
*
* This method test the delete record (one record) method - ensuring that a soft-delete status record is effectively
* removed from the collection.
*
* This method can be executed as a stand-alone method.
*
* First, we fetch the first active-status record from the collection:
*
* -- assert that the fetch request executed successfully
*
* Once we have the record fetched from the collection, save the record in a local static member, and also save the
* token (in a separate member variable) for later test use.
*
* -- assert that the record token is a valid guid
* -- assert that the record has an active status
*
* Next we build the query request payload for the delete event, first generating the event guid and copying it
* into the meta payload copy, after validating the guid.
*
* -- assert that the generated event guid is a valid guid
*
* Store the event guid in the static member and submit the delete event request:
*
* -- assert that the delete event request executed successfully
*
* Attempt to fetch the record based on the token by submitting a fetch event to the read broker:
*
* -- assert that the return status was true (query successfully executed)
* -- assert that the return STATE is STATE_NOT_FOUND for the event request
*
*
* @author mike@givingassistant.org
* @version 1.0
*
*
* HISTORY:
* ========
* 06-13-19 mks DB-122: original coding
*
*/
public function testDeleteOneRecord()
{
$meta = static::$meta;
$meta[META_DO_CACHE] = false;
$meta[META_LIMIT] = 1;
// fetch any record with an active status
$query = [
BROKER_REQUEST => BROKER_REQUEST_FETCH,
BROKER_DATA => [
STRING_QUERY_DATA => []
],
BROKER_META_DATA => $meta
];
$payload = gzcompress(json_encode($query));
$response = $this->readBrokerClient->call($payload);
$response = json_decode(gzuncompress($response), true);
$this->assertTrue($response[PAYLOAD_STATUS], __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_BROKER_EVENT_FAIL, BROKER_REQUEST_FETCH, $response[PAYLOAD_STATE]));
// extract and save portions of the payload we'll need for later testing
static::$testRecord = $response[PAYLOAD_RESULTS][STRING_QUERY_RESULTS][0];
static::$testRecordToken = static::$testRecord[STRING_KEY];
// validate the record guid and that the record has an active status
$this->assertTrue(validateGUID(static::$testRecordToken), (basename(__METHOD__) . AT . __LINE__ . COLON) . ERROR_INVALID_GUID . static::$testRecordToken);
$this->assertEquals(STATUS_ACTIVE, static::$testRecord[CM_TST_FIELD_TEST_STATUS], (basename(__METHOD__) . AT . __LINE__ . COLON) . sprintf(ERROR_UT_STRING_MATCH, STATUS_ACTIVE, static::$testRecord[CM_TST_FIELD_TEST_STATUS]));
// build the query and request to delete the just-fetched record
$query = [ CM_TST_TOKEN => [ OPERAND_NULL => [ OPERATOR_EQ => [ static::$testRecordToken ]]]];
$request = [ STRING_QUERY_DATA => $query ];
// generate and validate the event guid
$eventGUID = guid();
$this->assertTrue(validateGUID($eventGUID), (basename(__METHOD__) . AT . __LINE__ . COLON) . ERROR_INVALID_GUID . $eventGUID);
// build the meta-data payload; save the event guid in a member static
$meta = static::$meta;
$meta[META_EVENT_GUID] = $eventGUID;
// we'll need this later...
static::$eventRecordToken = $eventGUID;
// create the query/broker-event payload
$payload = [
BROKER_REQUEST => BROKER_REQUEST_DELETE,
BROKER_DATA => $request,
BROKER_META_DATA => $meta
];
// submit the request and unpack the results
$eventPayload = gzcompress(json_encode($payload));
$response = $this->writeBrokerClient->call($eventPayload);
$response = json_decode(gzuncompress($response), true);
// verify that the update was successful
$this->assertTrue($response[PAYLOAD_STATUS], (__FILE__ . COLON . __LINE__) . COLON . ERROR_UT_EXPECTING_TRUE . PAYLOAD_STATUS);
$query = [ CM_TST_TOKEN => [ OPERAND_NULL => [ OPERATOR_EQ => [ static::$testRecordToken ]]]];
$meta = static::$meta;
$meta[META_DO_CACHE] = false;
$meta[META_LIMIT] = 1;
$request = [
BROKER_REQUEST => BROKER_REQUEST_FETCH,
BROKER_DATA => [ STRING_QUERY_DATA => $query ],
BROKER_META_DATA => $meta
];
$response = json_decode(gzuncompress($this->readBrokerClient->call(gzcompress(json_encode($request)))), true);
$this->assertTrue($response[PAYLOAD_STATUS], __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_BROKER_EVENT_FAIL, BROKER_REQUEST_FETCH, $response[PAYLOAD_STATE]));
$this->assertEquals(STATE_NOT_FOUND, $response[PAYLOAD_STATE], (basename(__METHOD__) . AT . __LINE__ . COLON) . sprintf(ERROR_UT_STRING_MATCH, STATE_NOT_FOUND, $response[PAYLOAD_STATE]));
}
/**
* testDeleteAudit() -- unit test method
*
* This test validates that we created an audit record as a result of the delete event executing. We confirm that
* the audit was created by querying the audit collection using a combination of the test-record token and the event
* GUID used in the delete event request.
*
* --assert that the event-record guid is still stored in a member static and is still a valid guid
* --assert that the test record guid is still stored in a member static and is still a valid guid
* --assert that the test record is still stored in a member static and is in array format
*
* Next, build the query payload to submit a fetch event to the admin broker to request the delete-event audit rec:
*
* -- assert that the fetch request executed successfully
*
* Store the audit record into member statics:
* --assert that the audit record is not-null (successfully fetched)
* --assert that the audit record token is a valid guid
* --assert that the audit record is in array format
*
* Build the fetch query -- we're searching on the original (deleted) record token and the status being equal
* to deleted. If the class has soft-deletes enabled, this will fetch the record. Otherwise, we'll return a
* successful result but the state will set to NOT_FOUND. Test for this state as well. If the state of the fetch
* event is neither STATE_SUCCESS or STATE_NOT_FOUND, generate a test fail:
*
* --assert that the fetch request executed successfully
* --assert that the STATE of the request is either STATE_SUCCESS or STATE_NOT_FOUND
*
*
* @author mike@givingassistant.org
* @version 1.0
*
*
* HISTORY:
* ========
* 06-13-19 mks DB-122: original coding
*
*/
public function testDeleteAudit()
{
// pause to let stuffs get written
sleep(1);
$ext = COLLECTION_MONGO_AUDIT_EXT;
// ensure we've got the necessary saved data
$this->assertTrue(validateGUID(static::$eventRecordToken), (basename(__FILE__) . COLON . __LINE__) . COLON . ERROR_UT_LOST_VARIABLE . 'eventGUID');
$this->assertTrue(validateGUID(static::$testRecordToken), (basename(__FILE__) . COLON . __LINE__) . COLON . ERROR_UT_LOST_VARIABLE . 'testRecordToken');
$this->assertTrue(is_array(static::$testRecord), (basename(__FILE__) . COLON . __LINE__) . COLON . ERROR_UT_LOST_VARIABLE . 'testRecord');
// validate that we have an audit record for the delete operation that just occurred
$adminMeta = static::$adminMeta;
$adminMeta[META_TEMPLATE] = TEMPLATE_CLASS_AUDIT;
$adminMeta[META_DONUT_FILTER] = 1;
$query = [
AUDIT_RECORD_TOKEN => [ OPERAND_NULL => [ OPERATOR_EQ => [ static::$testRecordToken ]]],
DB_EVENT_GUID => [ OPERAND_NULL => [ OPERATOR_EQ => [ static::$eventRecordToken ]]],
OPERAND_AND => null
];
$request = [
BROKER_REQUEST => BROKER_REQUEST_REMOTE_FETCH,
BROKER_DATA => [ STRING_QUERY_DATA => $query ],
BROKER_META_DATA => $adminMeta
];
$response = $this->adminOutClient->call(gzcompress(json_encode($request)));
$response = json_decode(gzuncompress($response), true);
$this->assertTrue($response[PAYLOAD_STATUS], (basename(__FILE__) . COLON . __LINE__) . COLON . sprintf(ERROR_UT_BROKER_EVENT_FAIL, BROKER_REQUEST_REMOTE_FETCH, $response[PAYLOAD_STATE]));
// grab and save the audit record token, and the audit record, for the next method...
static::$auditRecord = $response[PAYLOAD_RESULTS][STRING_QUERY_RESULTS][0];
static::$auditRecordToken = static::$auditRecord[DB_TOKEN . $ext];
$this->assertNotNull(static::$auditRecord, basename(__METHOD__) . AT . __LINE__ . COLON . ERROR_UT_NULL_VALUE . STRING_GUID_KEY);
$this->assertTrue(validateGUID(static::$auditRecordToken), (basename(__FILE__) . COLON . __LINE__) . COLON . ERROR_INVALID_GUID . static::$auditRecordToken);
$this->assertTrue(is_array(static::$auditRecord), (basename(__FILE__) . COLON . __LINE__) . COLON . sprintf(ERROR_UT_FIELD_VALUE, 'auditRecord'));
// pull the original record and let's confirm that it's deleted or in a deleted state
$meta = static::$meta;
$meta[META_DONUT_FILTER] = 1;
$query = [
DB_TOKEN => [ OPERAND_NULL => [ OPERATOR_EQ => [ static::$testRecordToken]]],
DB_STATUS => [ OPERAND_NULL => [ OPERATOR_EQ => [ STATUS_DELETED ]]],
OPERAND_AND => null
];
$request = [
BROKER_REQUEST => BROKER_REQUEST_FETCH,
BROKER_DATA => [ STRING_QUERY_DATA => $query ],
BROKER_META_DATA => $meta
];
$response = $this->readBrokerClient->call(gzcompress(json_encode($request)));
$results = json_decode(gzuncompress($response), true);
$this->assertTrue($results[PAYLOAD_STATUS], (basename(__FILE__) . COLON . __LINE__) . COLON . sprintf(ERROR_UT_BROKER_EVENT_FAIL, BROKER_REQUEST_FETCH, $results[PAYLOAD_STATE]));
$oldStatus = $results[PAYLOAD_RESULTS][PAYLOAD_QUERY][0][DB_STATUS . COLLECTION_MONGO_TEST_EXT];
if ($results[PAYLOAD_STATE] == STATE_SUCCESS)
$this->assertEquals(STATUS_DELETED, $oldStatus, (basename(__METHOD__) . AT . __LINE__ . COLON) . sprintf(ERROR_UT_STRING_MATCH, STATUS_DELETED, $oldStatus));
elseif ($results[PAYLOAD_STATE] != STATE_NOT_FOUND)
$this->assertTrue(false, (basename(__METHOD__) . AT . __LINE__ . COLON) . ERROR_INVALID_STATE . $results[PAYLOAD_STATE]);
}
/**
* testDeleteJournalRecovery() -- unit test method
*
* This unit test validates that there's a journal record spawned off the delete event two methods ago and that
* we're able to restore (un-delete) the record. Initially, on starting, we need to validate and verify stored
* data availability:
*
* --assert that the eventRecordToken is present and valid as a guid
* --assert that the testRecordToken is present and valid as a guid
* --assert tha the testRecord record is present and valid as an array
* --assert that the auditRecordToken is present and valid as a guid
* --assert that the auditRecord is present and valid as an array
*
* Once we've verified, build the event for fetching the journal record from admin server and submit the request:
*
* --assert that the fetch (from admin) request executed successfully
*
* The fact that we fetched the journal record based on the audit token value, we've implicitly verified that
* the journal record was created as a result of the delete event. Using the same token value, we next build
* the event request query to restore (un-delete) the record.
*
* --assert that the request successfully executed
*
* Next, we pause, sleep for a second to allow the data to settle, and then we build a new event request to
* fetch the data record from appServer. The query submitted implies an ACTIVE status requirement was injected.
*
* --assert that the request successfully executed
* --assert that the state of the request is not STATE_NOT_FOUND
*
* The combination of the two (SUCCESS + !(STATE_NOT_FOUND)) means that the record was successfully un-deleted
*
*
* @author mike@givingassistant.org
* @version 1.0
*
*
* HISTORY:
* ========
* 06-13-19 mks DB-122: original coding
*
*/
public function testDeleteJournalRecovery()
{
// verify and validate the stored statics
$this->assertTrue(validateGUID(static::$eventRecordToken), (basename(__FILE__) . COLON . __LINE__) . COLON . ERROR_UT_LOST_VARIABLE . 'eventGUID');
$this->assertTrue(validateGUID(static::$testRecordToken), (basename(__FILE__) . COLON . __LINE__) . COLON . ERROR_UT_LOST_VARIABLE . 'testRecordToken');
$this->assertTrue(is_array(static::$testRecord), (basename(__FILE__) . COLON . __LINE__) . COLON . ERROR_UT_LOST_VARIABLE . 'originalTestRecord');
$this->assertTrue(validateGUID(static::$auditRecordToken), (basename(__FILE__) . COLON . __LINE__) . COLON . ERROR_INVALID_GUID . static::$auditRecordToken);
$this->assertTrue(is_array(static::$auditRecord), (basename(__FILE__) . COLON . __LINE__) . COLON . sprintf(ERROR_UT_FIELD_VALUE, 'auditRecord'));
// fetch the journal record based on the audit token
// build the request to fetch the journal record for the delete event
$meta = static::$adminMeta;
$meta[META_DONUT_FILTER] = 1;
$meta[META_TEMPLATE] = TEMPLATE_CLASS_JOURNAL;
$query = [ JOURNAL_AUD_TOK => [ OPERAND_NULL => [ OPERATOR_EQ => [ static::$auditRecordToken ]]]];
$request = [
BROKER_REQUEST => BROKER_REQUEST_REMOTE_FETCH,
BROKER_DATA => [ STRING_QUERY_DATA => $query ],
BROKER_META_DATA => $meta
];
$response = $this->adminOutClient->call(gzcompress(json_encode($request)));
$response = json_decode(gzuncompress($response), true);
$this->assertTrue($response[PAYLOAD_STATUS], (basename(__FILE__) . COLON . __LINE__) . COLON . sprintf(ERROR_UT_BROKER_EVENT_FAIL, BROKER_REQUEST_REMOTE_FETCH, $response[PAYLOAD_STATE]));
// now that we've confirmed that the journal record exists, invoke the recovery event to restore the
// original record back to it's non-deleted state
$query = [ STRING_KEY => static::$auditRecordToken ];
$meta = static::$adminMeta;
$meta[META_TEMPLATE] = TEMPLATE_CLASS_AUDIT;
$request = [
BROKER_REQUEST => BROKER_REQUEST_AUDIT_RESTORE,
BROKER_DATA => $query,
BROKER_META_DATA => $meta
];
$payload = gzcompress(json_encode($request));
$response = $this->adminOutClient->call($payload);
$response = json_decode(gzuncompress($response), true);
$this->assertTrue($response[PAYLOAD_STATUS], __FILE__ . COLON . __LINE__ . COLON . sprintf(ERROR_UT_BROKER_EVENT_FAIL, BROKER_REQUEST_AUDIT_RESTORE, $response[PAYLOAD_STATE]));
// if we're still executing, that the record was "restored" --- attempt to pull the record after a
// slightly-respectful delay to give time for the update to propagate...
sleep(1);
// and build the query for the fetch event and submit the request
$query = [ DB_TOKEN => [ OPERAND_NULL => [ OPERATOR_EQ => [static::$testRecordToken ]]]];
$meta = static::$meta;
$meta[META_DONUT_FILTER] = 1;
$request = [
BROKER_REQUEST => BROKER_REQUEST_FETCH,
BROKER_DATA => [
STRING_QUERY_DATA => $query
],
BROKER_META_DATA => $meta
];
$payload = gzcompress(json_encode($request));
$response = $this->readBrokerClient->call($payload);
$response = json_decode(gzuncompress($response), true);
$this->assertEquals(STATE_SUCCESS, $response[PAYLOAD_STATE], __FILE__ . COLON . __LINE__ . sprintf(ERROR_UT_VALS_NOT_EQUAL, STATE_SUCCESS, $response[PAYLOAD_STATE]));
$this->assertNotEquals(STATE_NOT_FOUND, $response[PAYLOAD_STATUS], (basename(__METHOD__) . AT . __LINE__ . COLON) . sprintf(ERROR_UT_STRING_MATCH, STATE_NOT_FOUND, $response[PAYLOAD_STATE]));
}
}
Reference in New Issue View Git Blame Copy Permalink