@reldens/storage 0.117.0 → 0.119.0

package/tests/integration/test-reldens-shape-relations.js

@@ -0,0 +1,292 @@
+/**
+ *
+ * Reldens - Reldens Shape Relations Test
+ * Reproduces the real Reldens data shape against the generated test models:
+ * test_reviews.product_id (NOT NULL FK) -> test_products.id, plus test_products.category_id (NOT NULL FK)
+ * -> test_categories.id, mirroring skills_owners_class_path.class_path_id -> skills_class_path.id and
+ * skills_class_path.levels_set_id -> skills_levels_set.id.
+ * The relation hint is passed exactly as lib/actions/server/models-manager.js does it: a bare string.
+ *
+ */
+
+const { TestRunner, assert } = require('../utils/test-runner');
+const { ObservedValue } = require('../utils/observed-value');
+const { RelationsShapeSupport } = require('../utils/relations-shape-support');
+const { CategoriesFixtures } = require('../fixtures/categories-fixtures');
+const { ProductsFixtures } = require('../fixtures/products-fixtures');
+const { ReviewsFixtures } = require('../fixtures/reviews-fixtures');
+
+class ReldensShapeRelationsTest
+{
+
+    constructor(dataServer, repos, driverName)
+    {
+        this.driverName = driverName;
+        this.support = new RelationsShapeSupport(dataServer, repos);
+        this.runner = new TestRunner();
+        this.createdChildId = false;
+        this.createdParentId = false;
+        this.child = ReviewsFixtures.review_relations_1;
+        this.parent = ProductsFixtures.product_relations_1;
+        this.otherParent = ProductsFixtures.product_relations_2;
+        this.grandParent = CategoriesFixtures.category_relations_1;
+        this.otherGrandParent = CategoriesFixtures.category_relations_2;
+        this.parentColumns = {sku: this.parent.sku, name: this.parent.name};
+        this.grandParentColumns = {name: this.grandParent.name, slug: this.grandParent.slug};
+        this.parentKey = 'related_test_products';
+        this.grandParentKey = 'related_test_categories';
+    }
+
+    async run()
+    {
+        this.runner.suite('Reldens Shape Relations - Driver: '+this.driverName);
+        await this.prepareShapeFixtures();
+        await this.testSingleLevelHints();
+        await this.testTwoLevelHints();
+        await this.testNonPrimaryColumnForeignKey();
+        await this.testForeignKeyScalarWithoutRelations();
+        await this.testForeignKeyOnCreate();
+        await this.testForeignKeyOnUpdate();
+        return this.runner.getResults();
+    }
+
+    async prepareShapeFixtures()
+    {
+        this.runner.group('Reldens Shape Fixtures');
+        await this.support.insertChainFixtures();
+        await this.runner.test('should have the child, parent and grandparent rows in place', async () => {
+            let childRow = await this.support.cleared('child').loadOneBy('id', this.child.id);
+            let parentRow = await this.support.cleared('parent').loadOneBy('id', this.parent.id);
+            let grandParentRow = await this.support.cleared('grandParent').loadOneBy('id', this.grandParent.id);
+            assert.ok(childRow && parentRow && grandParentRow, 'not every fixture row was inserted');
+            this.support.assertNumericColumn(childRow.product_id, this.parent.id, 'child row product_id');
+            this.support.assertNumericColumn(parentRow.category_id, this.grandParent.id, 'parent row category_id');
+            this.support.assertEntityColumns(grandParentRow, this.grandParentColumns, 'grandparent row');
+        });
+    }
+
+    async testSingleLevelHints()
+    {
+        this.runner.group('Single Level Relation Hint - models-manager.js shape');
+        let hintForms = {'a bare string': this.parentKey, 'an array': [this.parentKey]};
+        for(let hintLabel of Object.keys(hintForms)){
+            await this.runner.test('should hydrate the parent entity from '+hintLabel+' hint', async () => {
+                let record = await this.support.loadChildWithHint(hintForms[hintLabel]);
+                ObservedValue.log('loadOneByWithRelations('+hintLabel+') result', record);
+                assert.ok(record, 'loadOneByWithRelations returned: '+ObservedValue.describe(record));
+                this.support.assertEntityColumns(record[this.parentKey], this.parentColumns, 'record.'+this.parentKey);
+                this.support.assertNumericColumn(record[this.parentKey].id, this.parent.id, 'the parent entity id');
+                this.support.assertNumericColumn(record.product_id, this.parent.id, 'the child product_id scalar');
+            });
+        }
+        await this.runner.test('should hydrate the parent on loadByWithRelations with a bare string hint', async () => {
+            let records = await this.support.cleared('child').loadByWithRelations(
+                'product_id',
+                this.parent.id,
+                this.parentKey
+            );
+            ObservedValue.log('loadByWithRelations result', records);
+            assert.ok(Array.isArray(records), 'loadByWithRelations returned: '+ObservedValue.describe(records));
+            assert.strictEqual(records.length, 1, 'records.length observed: '+records.length);
+            this.support.assertEntityColumns(records[0][this.parentKey], this.parentColumns, 'records[0] parent');
+        });
+        await this.runner.test('should hydrate the parent on loadOneWithRelations with an array hint', async () => {
+            let record = await this.support.cleared('child').loadOneWithRelations({id: this.child.id}, [this.parentKey]);
+            assert.ok(record, 'loadOneWithRelations returned: '+ObservedValue.describe(record));
+            this.support.assertEntityColumns(record[this.parentKey], this.parentColumns, 'loadOneWithRelations parent');
+        });
+        await this.runner.test('should hydrate the parent on loadByIdWithRelations with a bare string hint', async () => {
+            let record = await this.support.cleared('child').loadByIdWithRelations(this.child.id, this.parentKey);
+            assert.ok(record, 'loadByIdWithRelations returned: '+ObservedValue.describe(record));
+            this.support.assertEntityColumns(record[this.parentKey], this.parentColumns, 'loadByIdWithRelations parent');
+        });
+    }
+
+    async testTwoLevelHints()
+    {
+        this.runner.group('Two Level Relation Hint');
+        let nestedPath = this.parentKey+'.'+this.grandParentKey;
+        let hintForms = {'an array': [nestedPath], 'a bare string': nestedPath};
+        for(let hintLabel of Object.keys(hintForms)){
+            await this.runner.test('should hydrate the grandparent from '+hintLabel+' two level hint', async () => {
+                let record = await this.support.loadChildWithHint(hintForms[hintLabel]);
+                assert.ok(record, 'loadOneByWithRelations returned: '+ObservedValue.describe(record));
+                let parentValue = record[this.parentKey];
+                this.support.assertEntityColumns(parentValue, this.parentColumns, 'record.'+this.parentKey);
+                this.support.assertEntityColumns(
+                    parentValue[this.grandParentKey],
+                    this.grandParentColumns,
+                    'record.'+nestedPath
+                );
+                this.support.assertNumericColumn(parentValue.category_id, this.grandParent.id, 'parent category_id');
+            });
+        }
+    }
+
+    async testNonPrimaryColumnForeignKey()
+    {
+        this.runner.group('Non Primary Column Foreign Key');
+        await this.runner.test('should hydrate a parent whose foreign key targets a unique column', async () => {
+            let record = await this.support.cleared('child').loadOneByWithRelations(
+                'id',
+                this.child.id,
+                this.grandParentKey
+            );
+            assert.ok(record, 'loadOneByWithRelations returned: '+ObservedValue.describe(record));
+            this.support.assertEntityColumns(
+                record[this.grandParentKey],
+                this.grandParentColumns,
+                'record.'+this.grandParentKey
+            );
+            assert.strictEqual(
+                record.category_slug,
+                this.grandParent.slug,
+                'record.category_slug observed: '+ObservedValue.describe(record.category_slug)
+            );
+        });
+    }
+
+    async testForeignKeyScalarWithoutRelations()
+    {
+        this.runner.group('Foreign Key Scalar Without Relations');
+        await this.runner.test('should return the child foreign key scalar on a plain loadOneBy', async () => {
+            let record = await this.support.cleared('child').loadOneBy('product_id', this.parent.id);
+            ObservedValue.log('plain loadOneBy result', record);
+            assert.ok(record, 'loadOneBy returned: '+ObservedValue.describe(record));
+            this.support.assertNumericColumn(record.product_id, this.parent.id, 'plain loadOneBy product_id');
+            let relationStub = record[this.parentKey];
+            let describedStub = ObservedValue.log('plain loadOneBy '+this.parentKey, relationStub);
+            assert.ok(
+                !relationStub || !relationStub[Object.keys(this.parentColumns)[0]],
+                'the relation was hydrated without being requested, observed: '+describedStub
+            );
+        });
+        await this.runner.test('should return the parent foreign key scalar on a plain loadById', async () => {
+            let record = await this.support.cleared('parent').loadById(this.parent.id);
+            assert.ok(record, 'loadById returned: '+ObservedValue.describe(record));
+            this.support.assertNumericColumn(record.category_id, this.grandParent.id, 'plain loadById category_id');
+        });
+        await this.runner.test('should return the child foreign key scalar on a plain loadBy', async () => {
+            let records = await this.support.cleared('child').loadBy('id', this.child.id);
+            assert.ok(Array.isArray(records), 'loadBy returned: '+ObservedValue.describe(records));
+            this.support.assertNumericColumn(records[0].product_id, this.parent.id, 'plain loadBy product_id');
+        });
+    }
+
+    async testForeignKeyOnCreate()
+    {
+        this.runner.group('Foreign Key Persisted On Create');
+        await this.runner.test('should persist the child not null foreign key column on create', async () => {
+            let created = await this.support.repos.child.create({
+                product_id: this.otherParent.id,
+                reviewer_name: 'Foreign Key Create',
+                reviewer_email: 'fk-create@example.com',
+                rating: 5,
+                title: 'Foreign key create',
+                comment: 'Created to verify the foreign key column is persisted',
+                is_verified: 1,
+                helpful_count: 0
+            });
+            ObservedValue.log('child create result', created);
+            assert.ok(created, 'create returned: '+ObservedValue.describe(created));
+            assert.ok(created.id, 'created.id observed: '+ObservedValue.describe(created.id));
+            this.createdChildId = created.id;
+            ObservedValue.log('product_id on the instance returned by create', created.product_id);
+            await this.support.assertStoredColumn(
+                'child',
+                created.id,
+                'product_id',
+                this.otherParent.id,
+                'created child'
+            );
+        });
+        await this.runner.test('should persist the parent not null foreign key column on create', async () => {
+            let created = await this.support.repos.parent.create({
+                category_id: this.otherGrandParent.id,
+                name: 'Foreign Key Create Product',
+                sku: 'FK-CREATE-PROD-1',
+                description: 'Created to verify the parent foreign key column is persisted',
+                price: 12.34,
+                stock_quantity: 3,
+                is_featured: 0,
+                tags: 'test,fk',
+                status: 'draft'
+            });
+            ObservedValue.log('parent create result', created);
+            assert.ok(created, 'create returned: '+ObservedValue.describe(created));
+            assert.ok(created.id, 'created.id observed: '+ObservedValue.describe(created.id));
+            this.createdParentId = created.id;
+            await this.support.assertStoredColumn(
+                'parent',
+                created.id,
+                'category_id',
+                this.otherGrandParent.id,
+                'created parent'
+            );
+        });
+    }
+
+    async testForeignKeyOnUpdate()
+    {
+        this.runner.group('Foreign Key Persisted On Update');
+        await this.runner.test('should persist the child foreign key column on updateById', async () => {
+            assert.ok(this.createdChildId, 'no created child id is available from the create group');
+            let updated = await this.support.repos.child.updateById(this.createdChildId, {product_id: this.parent.id});
+            ObservedValue.log('child updateById result', updated);
+            await this.support.assertStoredColumn(
+                'child',
+                this.createdChildId,
+                'product_id',
+                this.parent.id,
+                'child after updateById'
+            );
+        });
+        await this.runner.test('should persist the child foreign key column on updateBy', async () => {
+            assert.ok(this.createdChildId, 'no created child id is available from the create group');
+            let updated = await this.support.repos.child.updateBy(
+                'id',
+                this.createdChildId,
+                {product_id: this.otherParent.id}
+            );
+            ObservedValue.log('child updateBy result', updated);
+            await this.support.assertStoredColumn(
+                'child',
+                this.createdChildId,
+                'product_id',
+                this.otherParent.id,
+                'child after updateBy'
+            );
+        });
+        await this.runner.test('should persist the parent foreign key column on updateById', async () => {
+            assert.ok(this.createdParentId, 'no created parent id is available from the create group');
+            let updated = await this.support.repos.parent.updateById(
+                this.createdParentId,
+                {category_id: this.grandParent.id}
+            );
+            ObservedValue.log('parent updateById result', updated);
+            await this.support.assertStoredColumn(
+                'parent',
+                this.createdParentId,
+                'category_id',
+                this.grandParent.id,
+                'parent after updateById'
+            );
+        });
+        await this.runner.test('should hydrate the reassigned parent after the foreign key update', async () => {
+            assert.ok(this.createdChildId, 'no created child id is available from the create group');
+            let record = await this.support.cleared('child').loadByIdWithRelations(
+                this.createdChildId,
+                this.parentKey
+            );
+            assert.ok(record, 'loadByIdWithRelations returned: '+ObservedValue.describe(record));
+            this.support.assertEntityColumns(
+                record[this.parentKey],
+                {sku: this.otherParent.sku, name: this.otherParent.name},
+                'reassigned record.'+this.parentKey
+            );
+        });
+    }
+
+}
+
+module.exports = ReldensShapeRelationsTest;

package/tests/run-tests.js

@@ -11,6 +11,9 @@ const { DriverRegistry } = require('./utils/driver-registry');
 const DriversTest = require('./integration/test-drivers');
 const NestedFiltersTest = require('./integration/test-nested-filters');
 const RelationsTest = require('./integration/test-relations');
+const ReldensShapeRelationsTest = require('./integration/test-reldens-shape-relations');
+const ReldensSampleDataTest = require('./integration/test-reldens-sample-data');
+const { CrossDriverEquivalenceTest } = require('./integration/test-cross-driver-equivalence');
 const RawQueriesTest = require('./integration/test-raw-queries');
 const EntityManagerTest = require('./unit/test-entity-manager');
 const TypeMapperTest = require('./unit/test-type-mapper');
@@ -31,6 +34,7 @@ class RunTests
     constructor()
     {
         this.allCounts = {total: 0, passed: 0, failed: 0};
+        this.driverBenchmarks = {};
         this.filter = null;
         this.suite = null;
         this.driver = null;
@@ -78,8 +82,8 @@ class RunTests
             TestHelpers.cleanupGeneratedFiles();
         }
         await this.runPreFlightChecks(config);
-        let hasIntegrationTests = !this.suite || this.suite === 'integration';
-        let hasUnitTests = !this.suite || this.suite === 'unit';
+        let hasIntegrationTests = !this.suite || 'integration' === this.suite;
+        let hasUnitTests = !this.suite || 'unit' === this.suite;
         if(this.filter){
             if(this.filter.includes('integration')){
                 hasUnitTests = false;
@@ -107,6 +111,7 @@ class RunTests
         Logger.info('Tests passed: '+this.allCounts.passed);
         Logger.info('Tests failed: '+this.allCounts.failed);
         Logger.info('='.repeat(60));
+        this.logDriverBenchmarks();
         if(hasIntegrationTests){
             await this.driverRegistry.cleanup();
         }
@@ -122,83 +127,122 @@ class RunTests
         if(this.driver){
             driverNames = [this.driver];
         }
+        await this.runCrossDriverTests(driverNames);
         for(let driverName of driverNames){
             let dataServer = this.driverRegistry.getDriver(driverName);
             let repos = this.driverRegistry.getRepos(driverName);
             if(!dataServer){
-                Logger.warning('Driver '+driverName+' not available, skipping tests');
+                Logger.error('Driver '+driverName+' is not available, counted as a failure.');
+                this.allCounts.total++;
+                this.allCounts.failed++;
                 continue;
             }
+            await this.runDriverTests(driverName, dataServer, repos);
+        }
+    }
+
+    async runCrossDriverTests(driverNames)
+    {
+        if(2 > driverNames.length){
+            Logger.info('Cross driver equivalence needs two active drivers, only '+driverNames.join(', ')+' is.');
+            return this.allCounts;
+        }
+        try {
+            return this.appendCounts(
+                await (new CrossDriverEquivalenceTest(this.driverRegistry, driverNames)).run(),
+                false
+            );
+        } catch(error) {
+            Logger.critical('Cross driver equivalence tests crashed: '+error.message);
+            Logger.critical(error.stack);
+            this.allCounts.total++;
+            this.allCounts.failed++;
+        }
+        return this.allCounts;
+    }
+
+    integrationTestClasses()
+    {
+        return [
+            {label: 'drivers', testClass: DriversTest, isBenchmarked: true},
+            {label: 'nested filters', testClass: NestedFiltersTest, isBenchmarked: true},
+            {label: 'relations', testClass: RelationsTest, isBenchmarked: true},
+            {label: 'raw queries', testClass: RawQueriesTest, isBenchmarked: true},
+            {label: 'reldens shape relations', testClass: ReldensShapeRelationsTest, isBenchmarked: false},
+            {label: 'reldens sample data', testClass: ReldensSampleDataTest, isBenchmarked: false}
+        ];
+    }
+
+    async runDriverTests(driverName, dataServer, repos)
+    {
+        for(let testDefinition of this.integrationTestClasses()){
             try {
-                let driversTest = new DriversTest(dataServer, repos, driverName);
-                let driversResult = await driversTest.run();
-                this.allCounts.total += driversResult.total;
-                this.allCounts.passed += driversResult.passed;
-                this.allCounts.failed += driversResult.failed;
-            } catch(error) {
-                Logger.critical('Driver '+driverName+' tests crashed: '+error.message);
-                Logger.critical(error.stack);
-            }
-            try {
-                let nestedFiltersTest = new NestedFiltersTest(dataServer, repos, driverName);
-                let nestedFiltersResult = await nestedFiltersTest.run();
-                this.allCounts.total += nestedFiltersResult.total;
-                this.allCounts.passed += nestedFiltersResult.passed;
-                this.allCounts.failed += nestedFiltersResult.failed;
-            } catch(error) {
-                Logger.critical('Driver '+driverName+' nested filters tests crashed: '+error.message);
-                Logger.critical(error.stack);
-            }
-            try {
-                let relationsTest = new RelationsTest(dataServer, repos, driverName);
-                let relationsResult = await relationsTest.run();
-                this.allCounts.total += relationsResult.total;
-                this.allCounts.passed += relationsResult.passed;
-                this.allCounts.failed += relationsResult.failed;
-            } catch(error) {
-                Logger.critical('Driver '+driverName+' relations tests crashed: '+error.message);
-                Logger.critical(error.stack);
-            }
-            try {
-                let rawQueriesTest = new RawQueriesTest(dataServer, repos, driverName);
-                let rawQueriesResult = await rawQueriesTest.run();
-                this.allCounts.total += rawQueriesResult.total;
-                this.allCounts.passed += rawQueriesResult.passed;
-                this.allCounts.failed += rawQueriesResult.failed;
+                let testInstance = new testDefinition.testClass(dataServer, repos, driverName);
+                this.appendCounts(await testInstance.run(), testDefinition.isBenchmarked ? driverName : false);
             } catch(error) {
-                Logger.critical('Driver '+driverName+' raw queries tests crashed: '+error.message);
+                Logger.critical(
+                    'Driver '+driverName+' '+testDefinition.label+' tests crashed: '+error.message
+                );
                 Logger.critical(error.stack);
+                this.allCounts.total++;
+                this.allCounts.failed++;
             }
         }
+        return this.driverBenchmarks;
+    }
+
+    appendCounts(result, driverName)
+    {
+        this.allCounts.total += result.total;
+        this.allCounts.passed += result.passed;
+        this.allCounts.failed += result.failed;
+        if(!driverName){
+            return result;
+        }
+        if(!sc.hasOwn(this.driverBenchmarks, driverName)){
+            this.driverBenchmarks[driverName] = {total: 0, duration: 0};
+        }
+        this.driverBenchmarks[driverName].total += result.total;
+        this.driverBenchmarks[driverName].duration += sc.get(result, 'duration', 0);
+        return result;
+    }
+
+    logDriverBenchmarks()
+    {
+        let driverNames = Object.keys(this.driverBenchmarks);
+        if(0 === driverNames.length){
+            return false;
+        }
+        Logger.info('='.repeat(60));
+        Logger.info('DRIVER BENCHMARKS - INTEGRATION TESTS');
+        Logger.info('='.repeat(60));
+        for(let driverName of driverNames){
+            let benchmark = this.driverBenchmarks[driverName];
+            let average = 0 === benchmark.total ? 0 : (benchmark.duration / benchmark.total).toFixed(2);
+            Logger.info(
+                driverName+' - tests: '+benchmark.total
+                +' - total: '+benchmark.duration+'ms'
+                +' - average: '+average+'ms'
+            );
+        }
+        Logger.info('='.repeat(60));
+        return true;
     }
 
     async runUnitTests()
     {
-        let entityManagerTest = new EntityManagerTest();
-        let entityManagerResult = await entityManagerTest.run();
-        this.allCounts.total += entityManagerResult.total;
-        this.allCounts.passed += entityManagerResult.passed;
-        this.allCounts.failed += entityManagerResult.failed;
-        let typeMapperTest = new TypeMapperTest();
-        let typeMapperResult = await typeMapperTest.run();
-        this.allCounts.total += typeMapperResult.total;
-        this.allCounts.passed += typeMapperResult.passed;
-        this.allCounts.failed += typeMapperResult.failed;
-        let driversUnitTest = new DriversUnitTest();
-        let driversUnitResult = await driversUnitTest.run();
-        this.allCounts.total += driversUnitResult.total;
-        this.allCounts.passed += driversUnitResult.passed;
-        this.allCounts.failed += driversUnitResult.failed;
-        let entitiesGenerationTest = new EntitiesGenerationTest();
-        let entitiesGenerationResult = await entitiesGenerationTest.run();
-        this.allCounts.total += entitiesGenerationResult.total;
-        this.allCounts.passed += entitiesGenerationResult.passed;
-        this.allCounts.failed += entitiesGenerationResult.failed;
-        let modelsGenerationTest = new ModelsGenerationTest();
-        let modelsGenerationResult = await modelsGenerationTest.run();
-        this.allCounts.total += modelsGenerationResult.total;
-        this.allCounts.passed += modelsGenerationResult.passed;
-        this.allCounts.failed += modelsGenerationResult.failed;
+        let unitTestClasses = [
+            EntityManagerTest,
+            TypeMapperTest,
+            DriversUnitTest,
+            EntitiesGenerationTest,
+            ModelsGenerationTest
+        ];
+        for(let UnitTestClass of unitTestClasses){
+            let unitTest = new UnitTestClass();
+            this.appendCounts(await unitTest.run(), false);
+        }
+        return this.allCounts;
     }
 
     async runPreFlightChecks(config)
@@ -228,7 +272,9 @@ process.on('uncaughtException', (error) => {
 });
 
 let runner = new RunTests();
-runner.run().catch(error => {
+runner.run().then(counts => {
+    process.exit(0 < counts.failed ? 1 : 0);
+}).catch(error => {
     Logger.info('CATASTROPHIC ERROR: Test runner failed completely\n');
     Logger.info('Error: '+error.message+'\n');
     Logger.info(error.stack+'\n');

package/tests/unit/test-drivers.js

@@ -10,6 +10,9 @@ const { TestHelpers } = require('../utils/test-helpers');
 const { ObjectionJsDriver } = require('../../lib/objection-js/objection-js-driver');
 const { MikroOrmDriver } = require('../../lib/mikro-orm/mikro-orm-driver');
 const { PrismaDriver } = require('../../lib/prisma/prisma-driver');
+const { KnexDriver } = require('../../lib/knex/knex-driver');
+const { KyselyDriver } = require('../../lib/kysely/kysely-driver');
+const { DrizzleDriver } = require('../../lib/drizzle/drizzle-driver');
 
 class DriversUnitTest
 {
@@ -19,7 +22,10 @@ class DriversUnitTest
         this.runner = new TestRunner();
         this.DRIVERS = [
             {name: 'objection-js', class: ObjectionJsDriver},
-            {name: 'mikro-orm', class: MikroOrmDriver}
+            {name: 'mikro-orm', class: MikroOrmDriver},
+            {name: 'knex', class: KnexDriver},
+            {name: 'kysely', class: KyselyDriver},
+            {name: 'drizzle', class: DrizzleDriver}
         ];
         if(TestHelpers.isPrismaEnabled()){
             this.DRIVERS.push({name: 'prisma', class: PrismaDriver});

package/tests/unit/test-models-generation.js

@@ -5,7 +5,8 @@
  */
 
 const { TestRunner, assert } = require('../utils/test-runner');
-const { ModelsGeneration } = require('../../lib/generators/models-generation');
+const { RelationsDetection } = require('../../lib/generators/relations-detection');
+const { MikroOrmModelsGeneration } = require('../../lib/mikro-orm/mikro-orm-models-generation');
 
 class ModelsGenerationTest
 {
@@ -70,46 +71,52 @@ class ModelsGenerationTest
         };
     }
 
+    createRelationsDetection()
+    {
+        let relationsDetection = new RelationsDetection({});
+        relationsDetection.allTablesData = this.createTables();
+        return relationsDetection;
+    }
+
     createGeneration()
     {
-        let generation = new ModelsGeneration({});
-        generation.setAllTablesData(this.createTables());
-        return generation;
+        return new MikroOrmModelsGeneration(this.createRelationsDetection());
     }
 
     mikroOrmDefinition(generation, tableName)
     {
-        let tableData = generation.allTablesData[tableName];
-        return generation.getEntityPropertiesDefinition(tableData.columns, 'mikro-orm', tableName, tableData);
+        let tableData = generation.relationsDetection.allTablesData[tableName];
+        return generation.generateEntityProperties(tableData.columns, tableName, tableData);
     }
 
     async run()
     {
         this.runner.suite('ModelsGeneration');
-        await this.testDetermineMikroOrmForwardKind();
+        await this.testForwardRelationKind();
         await this.testMikroOrmOneToOneDefinitions();
         await this.testObjectionJsRelationTypes();
         return this.runner.getResults();
     }
 
-    async testDetermineMikroOrmForwardKind()
+    async testForwardRelationKind()
     {
-        this.runner.group('determineMikroOrmForwardKind');
+        this.runner.group('forwardRelationKind');
         let generation = this.createGeneration();
         await this.runner.test('should return 1:1 for a unique foreign key column', async () => {
-            let kind = generation.determineMikroOrmForwardKind(this.createColumn({key: 'UNI'}));
+            let kind = generation.forwardRelationKind(this.createColumn({key: 'UNI'}));
             assert.strictEqual(kind, '1:1');
         });
         await this.runner.test('should return 1:1 for a primary foreign key column', async () => {
-            let kind = generation.determineMikroOrmForwardKind(this.createColumn({key: 'PRI'}));
+            let kind = generation.forwardRelationKind(this.createColumn({key: 'PRI'}));
             assert.strictEqual(kind, '1:1');
         });
         await this.runner.test('should return m:1 for an indexed foreign key column', async () => {
-            let kind = generation.determineMikroOrmForwardKind(this.createColumn({key: 'MUL'}));
+            let kind = generation.forwardRelationKind(this.createColumn({key: 'MUL'}));
+            // @possible-hallucinated-undefined-method
             assert.strictEqual(kind, 'm:1');
         });
         await this.runner.test('should return m:1 for a non indexed foreign key column', async () => {
-            let kind = generation.determineMikroOrmForwardKind(this.createColumn({key: ''}));
+            let kind = generation.forwardRelationKind(this.createColumn({key: ''}));
             assert.strictEqual(kind, 'm:1');
         });
     }
@@ -143,18 +150,21 @@ class ModelsGenerationTest
     async testObjectionJsRelationTypes()
     {
         this.runner.group('ObjectionJS relation types for unique foreign keys');
-        let generation = this.createGeneration();
-        let tables = generation.allTablesData;
+        let relationsDetection = this.createRelationsDetection();
+        let tables = relationsDetection.allTablesData;
         await this.runner.test('should keep BelongsToOneRelation on the owning side', async () => {
-            let relations = generation.detectObjectionJsRelations('test_product_details', tables.test_product_details);
+            let relations = relationsDetection.detectForwardRelations(
+                'test_product_details',
+                tables.test_product_details
+            );
             assert.strictEqual(relations.related_test_products.relationType, 'BelongsToOneRelation');
         });
         await this.runner.test('should use HasOneRelation on the referenced side of a unique foreign key', async () => {
-            let reverseRelations = generation.detectReverseObjectionJsRelations('test_products');
+            let reverseRelations = relationsDetection.detectReverseRelations('test_products');
             assert.strictEqual(reverseRelations.related_test_product_details.relationType, 'HasOneRelation');
         });
         await this.runner.test('should use HasManyRelation on the referenced side of a non unique foreign key', async () => {
-            let reverseRelations = generation.detectReverseObjectionJsRelations('test_products');
+            let reverseRelations = relationsDetection.detectReverseRelations('test_products');
             assert.strictEqual(reverseRelations.related_test_reviews.relationType, 'HasManyRelation');
         });
     }