@reldens/storage 0.116.0 → 0.118.0

package/tests/integration/test-relations.js

@@ -10,6 +10,7 @@ const { TestHelpers } = require('../utils/test-helpers');
 const { CategoriesFixtures } = require('../fixtures/categories-fixtures');
 const { ProductsFixtures } = require('../fixtures/products-fixtures');
 const { ReviewsFixtures } = require('../fixtures/reviews-fixtures');
+const { ProductDetailsFixtures } = require('../fixtures/product-details-fixtures');
 
 class RelationsTest
 {
@@ -19,6 +20,7 @@ class RelationsTest
         this.dataServer = dataServer;
         this.categoriesRepo = repos.testCategories;
         this.productsRepo = repos.testProducts;
+        this.productDetailsRepo = repos.testProductDetails;
         this.driverName = driverName;
         this.runner = new TestRunner();
     }
@@ -36,9 +38,151 @@ class RelationsTest
         await this.testCreateWithRelations();
         await this.testNestedRelations();
         await this.testRelationStringParsing();
+        await this.testOneToOneRelations();
+        await this.testCamelCaseColumns();
         return this.runner.getResults();
     }
 
+    async testCamelCaseColumns()
+    {
+        this.runner.group('CamelCase Columns');
+        await TestHelpers.cleanDatabase(this.dataServer);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_categories', [
+            CategoriesFixtures.category_relations_1
+        ]);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_products', [
+            ProductsFixtures.product_relations_1
+        ]);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_product_details', [
+            ProductDetailsFixtures.product_details_relations_1
+        ]);
+        await this.runner.test('should read a camelCase column with the exact database column name', async () => {
+            let record = await this.productDetailsRepo.loadById(4600);
+            assert.ok(record);
+            assert.strictEqual(record.customData, ProductDetailsFixtures.product_details_relations_1.customData);
+            assert.strictEqual(record.useTimeOut, ProductDetailsFixtures.product_details_relations_1.useTimeOut);
+        });
+        await this.runner.test('should read a bigint column as a number', async () => {
+            let record = await this.productDetailsRepo.loadById(4600);
+            assert.strictEqual(typeof record.total_views, 'number');
+            assert.strictEqual(record.total_views, ProductDetailsFixtures.product_details_relations_1.total_views);
+            assert.strictEqual(record.total_views + 1, ProductDetailsFixtures.product_details_relations_1.total_views + 1);
+        });
+        await this.runner.test('should filter by a camelCase column', async () => {
+            let records = await this.productDetailsRepo.loadBy('useTimeOut', 45);
+            assert.strictEqual(records.length, 1);
+            assert.strictEqual(records[0].id, 4600);
+        });
+        await this.runner.test('should write a camelCase column', async () => {
+            await this.productDetailsRepo.updateById(4600, {useTimeOut: 90});
+            let updated = await this.productDetailsRepo.loadById(4600);
+            assert.strictEqual(updated.useTimeOut, 90);
+        });
+        await this.runner.test('should populate a relation whose target has camelCase columns', async () => {
+            let results = await this.productsRepo.loadWithRelations({id: 2600}, ['related_test_product_details']);
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(
+                results[0].related_test_product_details.customData,
+                ProductDetailsFixtures.product_details_relations_1.customData
+            );
+        });
+        await this.runner.test('should return an explicit null for an empty nullable foreign key', async () => {
+            let record = await this.productDetailsRepo.loadById(4600);
+            assert.strictEqual(record.category_id, null);
+        });
+        await this.runner.test('should keep the foreign key column value on a nested populated relation', async () => {
+            let results = await this.categoriesRepo.loadWithRelations(
+                {id: 1600},
+                ['related_test_products.related_test_product_details']
+            );
+            let product = results[0].related_test_products[0];
+            assert.strictEqual(product.category_id, 1600);
+            assert.strictEqual(product.related_test_product_details.product_id, 2600);
+        });
+        await this.runner.test('should keep a nullable foreign key on the leaf of a nested populate', async () => {
+            let results = await this.categoriesRepo.loadWithRelations(
+                {id: 1600},
+                ['related_test_products.related_test_product_details']
+            );
+            let details = results[0].related_test_products[0].related_test_product_details;
+            assert.strictEqual(details.category_id, null);
+        });
+        await this.runner.test('should keep the foreign key column value on a load without relations', async () => {
+            let record = await this.productDetailsRepo.loadById(4600);
+            assert.strictEqual(record.product_id, 2600);
+        });
+        await this.runner.test('should keep the foreign key column value on loadBy without relations', async () => {
+            let records = await this.productDetailsRepo.loadBy('id', 4600);
+            assert.strictEqual(records[0].product_id, 2600);
+        });
+        await this.runner.test('should accept an object written into a text column', async () => {
+            await this.productDetailsRepo.updateById(4600, {customData: {onlyCurrentPlayer: true}});
+            let updated = await this.productDetailsRepo.loadById(4600);
+            assert.ok(updated.customData);
+        });
+    }
+
+    async testOneToOneRelations()
+    {
+        this.runner.group('One To One Relations');
+        await TestHelpers.cleanDatabase(this.dataServer);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_categories', [
+            CategoriesFixtures.category_relations_1
+        ]);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_products', [
+            ProductsFixtures.product_relations_1,
+            {...ProductsFixtures.product_relations_2, category_id: 1600}
+        ]);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_product_details', [
+            ProductDetailsFixtures.product_details_relations_1
+        ]);
+        await this.runner.test('should load the one to one relation from the referenced side as a single object', async () => {
+            let results = await this.productsRepo.loadWithRelations({id: 2600}, ['related_test_product_details']);
+            assert.strictEqual(results.length, 1);
+            let details = results[0].related_test_product_details;
+            assert.ok(details);
+            assert.ok(!Array.isArray(details));
+            assert.strictEqual(details.id, 4600);
+        });
+        await this.runner.test('should load the one to one relation from the owning side as a single object', async () => {
+            let results = await this.productDetailsRepo.loadWithRelations({id: 4600}, ['related_test_products']);
+            assert.strictEqual(results.length, 1);
+            let product = results[0].related_test_products;
+            assert.ok(product);
+            assert.ok(!Array.isArray(product));
+            assert.strictEqual(product.id, 2600);
+        });
+        await this.runner.test('should return no related record on the one to one relation when none exists', async () => {
+            let result = await this.productsRepo.loadByIdWithRelations(2601, ['related_test_product_details']);
+            assert.ok(result);
+            assert.ok(!result.related_test_product_details);
+        });
+        await this.runner.test('should count records joining the one to one relation from the referenced side', async () => {
+            let count = await this.productsRepo.countWithRelations({}, ['related_test_product_details']);
+            assert.strictEqual(count, 2);
+        });
+        await this.runner.test('should count records joining the one to one relation from the owning side', async () => {
+            let count = await this.productDetailsRepo.countWithRelations({}, ['related_test_products']);
+            assert.strictEqual(count, 1);
+        });
+        await this.runner.test('should create a record with a nested one to one relation', async () => {
+            let productWithDetails = {
+                ...ProductsFixtures.product_create_nested,
+                category_id: 1600,
+                related_test_product_details: {...ProductDetailsFixtures.product_details_create_nested}
+            };
+            let created = await this.productsRepo.createWithRelations(
+                productWithDetails,
+                ['related_test_product_details']
+            );
+            assert.ok(created);
+            assert.ok(created.id);
+            let details = await this.productDetailsRepo.loadBy('product_id', created.id);
+            assert.strictEqual(details.length, 1);
+            assert.strictEqual(details[0].dimensions, ProductDetailsFixtures.product_details_create_nested.dimensions);
+        });
+    }
+
     async testLoadWithRelations()
     {
         this.runner.group('loadWithRelations');
@@ -70,6 +214,10 @@ class RelationsTest
             assert.ok(results.length > 0);
             let product = results[0];
             assert.ok(product.related_test_categories);
+            assert.strictEqual(
+                product.related_test_categories.name,
+                CategoriesFixtures.category_relations_1.name
+            );
             assert.ok(product.related_test_reviews);
             assert.ok(Array.isArray(product.related_test_reviews));
         });
@@ -300,6 +448,9 @@ class RelationsTest
         await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_reviews', [
             ReviewsFixtures.review_relations_1
         ]);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_product_details', [
+            ProductDetailsFixtures.product_details_relations_1
+        ]);
         await this.runner.test('should load nested relations (category > products > reviews)', async () => {
             let results = await this.categoriesRepo.loadWithRelations(
                 {id: 1600},
@@ -313,6 +464,50 @@ class RelationsTest
             let product = category.related_test_products[0];
             assert.ok(product.related_test_reviews);
         });
+        await this.runner.test('should load a relation whose foreign key references a non primary column', async () => {
+            let results = await this.categoriesRepo.loadWithRelations(
+                {id: 1600},
+                ['related_test_reviews']
+            );
+            let related = results[0].related_test_reviews;
+            assert.ok(Array.isArray(related));
+            assert.strictEqual(related.length, 1);
+            assert.strictEqual(related[0].reviewer_name, ReviewsFixtures.review_relations_1.reviewer_name);
+        });
+        await this.runner.test('should load a collection nested under an owning relation', async () => {
+            let results = await this.productDetailsRepo.loadAllWithRelations([
+                'related_test_products.related_test_reviews'
+            ]);
+            let product = results[0].related_test_products;
+            assert.strictEqual(typeof product, 'object');
+            assert.strictEqual(product.name, ProductsFixtures.product_relations_1.name);
+            assert.ok(Array.isArray(product.related_test_reviews));
+            assert.strictEqual(
+                product.related_test_reviews[0].reviewer_name,
+                ReviewsFixtures.review_relations_1.reviewer_name
+            );
+        });
+        await this.runner.test('should load a nested relation through an owning relation as an entity', async () => {
+            let results = await this.productDetailsRepo.loadWithRelations(
+                {id: 4600},
+                ['related_test_products.related_test_categories']
+            );
+            let product = results[0].related_test_products;
+            assert.strictEqual(product.name, ProductsFixtures.product_relations_1.name);
+            assert.strictEqual(
+                product.related_test_categories.name,
+                CategoriesFixtures.category_relations_1.name
+            );
+        });
+        await this.runner.test('should return the nested collection as an array on the deepest level', async () => {
+            let results = await this.categoriesRepo.loadWithRelations(
+                {id: 1600},
+                ['related_test_products.related_test_reviews']
+            );
+            let product = results[0].related_test_products[0];
+            assert.ok(Array.isArray(product.related_test_reviews));
+            assert.strictEqual(product.related_test_reviews.length, 1);
+        });
     }
 
     async testRelationStringParsing()
@@ -341,6 +536,10 @@ class RelationsTest
             assert.ok(results);
             assert.ok(results.length > 0);
             assert.ok(results[0].related_test_categories);
+            assert.strictEqual(
+                results[0].related_test_categories.name,
+                CategoriesFixtures.category_relations_1.name
+            );
         });
     }
 

package/tests/integration/test-reldens-sample-data.js

@@ -0,0 +1,255 @@
+/**
+ *
+ * Reldens - Reldens Sample Data Test
+ * Runs the relation assertions against the real Reldens database: the schema from reldens-install-v4.0.0.sql
+ * and the rows inserted by reldens-basic-config-v4.0.0.sql and reldens-sample-data-v4.0.0.sql. Every expected
+ * count below is the amount of rows those files insert, so the assertions describe the shipped sample data.
+ *
+ */
+
+const { TestRunner, assert } = require('../utils/test-runner');
+const { ReldensSchemaLoader } = require('../utils/reldens-schema-loader');
+const { ObservedValue } = require('../utils/observed-value');
+
+class ReldensSampleDataTest
+{
+
+    constructor(dataServer, repos, driverName)
+    {
+        this.driverName = driverName;
+        this.runner = new TestRunner();
+        this.dataServer = false;
+        this.repos = {};
+        this.entityNames = ['itemsItem', 'skillsClassPath', 'rooms', 'playersState'];
+        this.itemRelationCases = {
+            'the coins requirements from the required item foreign key':
+                {itemId: 1, relationKey: 'related_objects_items_requirements_required_item_key', expectedRows: 4},
+            'the coins rewards from the reward item foreign key':
+                {itemId: 1, relationKey: 'related_objects_items_rewards_reward_item_key', expectedRows: 5},
+            'no coins requirement from the item foreign key':
+                {itemId: 1, relationKey: 'related_objects_items_requirements_item_key', expectedRows: 0},
+            'the axe requirement from the item foreign key':
+                {itemId: 4, relationKey: 'related_objects_items_requirements_item_key', expectedRows: 1},
+            'no axe requirement from the required item foreign key':
+                {itemId: 4, relationKey: 'related_objects_items_requirements_required_item_key', expectedRows: 0},
+            'the axe reward from the item foreign key':
+                {itemId: 4, relationKey: 'related_objects_items_rewards_item_key', expectedRows: 1}
+        };
+        this.levelsSetKey = 'related_skills_levels_set';
+        this.levelsKey = 'related_skills_levels';
+        this.levelsModifiersKey = 'related_skills_levels_modifiers';
+        this.changePointsKey = 'related_rooms_change_points_room';
+        this.nextRoomKey = 'related_rooms_next_room';
+        this.skillsLevelsChain = this.levelsSetKey+'.'+this.levelsKey+'.'+this.levelsModifiersKey;
+        this.changePointsChain = this.changePointsKey+'.'+this.nextRoomKey;
+        this.journeymanClassPathId = 1;
+        this.journeymanLevelsSetId = 1;
+        this.journeymanLevelsRows = 4;
+        this.journeymanModifiersByLevelId = {1: 0, 2: 8, 3: 8, 4: 8};
+        this.botsForestRoomId = 9;
+        this.botsForestChangePointsRows = 1;
+        this.botsForestNextRoomId = 10;
+        this.botsForestNextRoomName = 'reldens-bots-forest-house-01-n0';
+        this.playersStateId = 1;
+        this.playersStatePlayerId = 1;
+        this.playersStateRoomId = 5;
+    }
+
+    async run()
+    {
+        this.runner.suite('Reldens Sample Data - Driver: '+this.driverName);
+        if(!ReldensSchemaLoader.isAvailable()){
+            return this.runner.fail(
+                'reldens migrations must be available for '+this.driverName,
+                'RELDENS_TEST_MIGRATIONS_PATH does not point to a folder containing the reldens migrations.'
+            );
+        }
+        this.dataServer = await ReldensSchemaLoader.setup(this.driverName);
+        if(!this.dataServer){
+            return this.runner.fail(
+                'reldens sample data server must connect for '+this.driverName,
+                'The '+this.driverName+' data server could not be set up.'
+            );
+        }
+        for(let entityName of this.entityNames){
+            this.repos[entityName] = this.dataServer.getEntity(entityName);
+        }
+        try {
+            await this.testGeneratedRepositories();
+            await this.testItemsItemSameTableForeignKeys();
+            await this.testSkillsClassPathLevelsChain();
+            await this.testRoomsChangePointsNestedRoom();
+            await this.testForeignKeyScalarWithoutRelations();
+        } finally {
+            await ReldensSchemaLoader.teardown(this.dataServer);
+        }
+        return this.runner.getResults();
+    }
+
+    clearedRepo(entityName)
+    {
+        if(this.dataServer.orm && this.dataServer.orm.em){
+            this.dataServer.orm.em.clear();
+        }
+        return this.repos[entityName];
+    }
+
+    assertRelationRows(record, relationKey, expectedRows, label)
+    {
+        let related = record[relationKey];
+        ObservedValue.log(label+'.'+relationKey, related);
+        assert.ok(
+            Array.isArray(related),
+            label+'.'+relationKey+' is not an array, observed: '+ObservedValue.describe(related)
+        );
+        assert.strictEqual(
+            related.length,
+            expectedRows,
+            label+'.'+relationKey+' rows observed: '+related.length+' - expected: '+expectedRows
+        );
+        return related;
+    }
+
+    async testGeneratedRepositories()
+    {
+        this.runner.group('Reldens Schema Repositories');
+        await this.runner.test('should expose a repository for every asserted entity', async () => {
+            for(let entityName of this.entityNames){
+                assert.ok(this.repos[entityName], 'entity "'+entityName+'" missing from the reldens schema');
+            }
+        });
+    }
+
+    async testItemsItemSameTableForeignKeys()
+    {
+        this.runner.group('Items Item Two Foreign Keys To The Same Table');
+        for(let caseName of Object.keys(this.itemRelationCases)){
+            let testCase = this.itemRelationCases[caseName];
+            await this.runner.test('should return '+caseName, async () => {
+                let record = await this.clearedRepo('itemsItem').loadByIdWithRelations(
+                    testCase.itemId,
+                    [testCase.relationKey]
+                );
+                assert.ok(record, 'items_item '+testCase.itemId+' not loaded: '+ObservedValue.describe(record));
+                this.assertRelationRows(record, testCase.relationKey, testCase.expectedRows, caseName);
+            });
+        }
+    }
+
+    async testSkillsClassPathLevelsChain()
+    {
+        this.runner.group('Skills Class Path Levels Chain');
+        await this.runner.test('should load the levels set with every level of the journeyman path', async () => {
+            let record = await this.clearedRepo('skillsClassPath').loadByIdWithRelations(
+                this.journeymanClassPathId,
+                [this.skillsLevelsChain]
+            );
+            assert.ok(record, 'journeyman class path not loaded: '+ObservedValue.describe(record));
+            let levelsSet = record[this.levelsSetKey];
+            ObservedValue.log('journeyman.'+this.levelsSetKey, levelsSet);
+            assert.strictEqual(
+                'object',
+                typeof levelsSet,
+                'the levels set was not populated, observed: '+ObservedValue.describe(levelsSet)
+            );
+            assert.strictEqual(
+                Number(levelsSet.id),
+                this.journeymanLevelsSetId,
+                'the levels set id observed: '+ObservedValue.describe(levelsSet.id)
+            );
+            this.assertRelationRows(levelsSet, this.levelsKey, this.journeymanLevelsRows, 'journeyman levels set');
+        });
+        await this.runner.test('should load the modifiers of every journeyman level', async () => {
+            let record = await this.clearedRepo('skillsClassPath').loadByIdWithRelations(
+                this.journeymanClassPathId,
+                [this.skillsLevelsChain]
+            );
+            assert.ok(record, 'journeyman class path not loaded: '+ObservedValue.describe(record));
+            let levels = this.assertRelationRows(
+                record[this.levelsSetKey],
+                this.levelsKey,
+                this.journeymanLevelsRows,
+                'journeyman levels set'
+            );
+            for(let level of levels){
+                this.assertRelationRows(
+                    level,
+                    this.levelsModifiersKey,
+                    this.journeymanModifiersByLevelId[level.id],
+                    'journeyman level '+level.id
+                );
+            }
+        });
+    }
+
+    async testRoomsChangePointsNestedRoom()
+    {
+        this.runner.group('Rooms Change Points Nested Room');
+        await this.runner.test('should load the change points of the bots forest room', async () => {
+            let record = await this.clearedRepo('rooms').loadByIdWithRelations(
+                this.botsForestRoomId,
+                [this.changePointsChain]
+            );
+            assert.ok(record, 'bots forest room not loaded: '+ObservedValue.describe(record));
+            this.assertRelationRows(record, this.changePointsKey, this.botsForestChangePointsRows, 'bots forest');
+        });
+        await this.runner.test('should load the change point next room as an entity', async () => {
+            let record = await this.clearedRepo('rooms').loadByIdWithRelations(
+                this.botsForestRoomId,
+                [this.changePointsChain]
+            );
+            assert.ok(record, 'bots forest room not loaded: '+ObservedValue.describe(record));
+            let changePoints = this.assertRelationRows(
+                record,
+                this.changePointsKey,
+                this.botsForestChangePointsRows,
+                'bots forest'
+            );
+            let nextRoom = [...changePoints].shift()[this.nextRoomKey];
+            ObservedValue.log('bots forest change point.'+this.nextRoomKey, nextRoom);
+            assert.strictEqual(
+                'object',
+                typeof nextRoom,
+                'the next room was not populated, observed: '+ObservedValue.describe(nextRoom)
+            );
+            assert.strictEqual(
+                Number(nextRoom.id),
+                this.botsForestNextRoomId,
+                'the next room id observed: '+ObservedValue.describe(nextRoom.id)
+            );
+            assert.strictEqual(
+                nextRoom.name,
+                this.botsForestNextRoomName,
+                'the next room name observed: '+ObservedValue.describe(nextRoom.name)
+            );
+        });
+    }
+
+    async testForeignKeyScalarWithoutRelations()
+    {
+        this.runner.group('Foreign Key Scalar Without Relations');
+        await this.runner.test('should return the players state room id as a scalar', async () => {
+            let record = await this.clearedRepo('playersState').loadById(this.playersStateId);
+            assert.ok(record, 'players state row not loaded: '+ObservedValue.describe(record));
+            ObservedValue.log('players state room_id', record.room_id);
+            assert.notStrictEqual(
+                'object',
+                typeof record.room_id,
+                'the room_id was hydrated as an entity, observed: '+ObservedValue.describe(record.room_id)
+            );
+            assert.strictEqual(
+                Number(record.room_id),
+                this.playersStateRoomId,
+                'the room_id observed: '+ObservedValue.describe(record.room_id)
+            );
+            assert.strictEqual(
+                Number(record.player_id),
+                this.playersStatePlayerId,
+                'the player_id observed: '+ObservedValue.describe(record.player_id)
+            );
+        });
+    }
+
+}
+
+module.exports = ReldensSampleDataTest;