@reldens/storage 0.116.0 → 0.118.0

package/tests/utils/relations-shape-support.js

@@ -0,0 +1,104 @@
+/**
+ *
+ * Reldens - Relations Shape Support
+ * Reusable fixtures setup and relation/foreign-key assertions for the child -> parent -> grandparent chain
+ * (test_reviews -> test_products -> test_categories), both links being NOT NULL m:1 foreign keys.
+ * Every assertion reports the observed value so a failure states what the driver actually returned.
+ *
+ */
+
+const { TestHelpers } = require('./test-helpers');
+const { ObservedValue } = require('./observed-value');
+const { assert } = require('./test-runner');
+const { CategoriesFixtures } = require('../fixtures/categories-fixtures');
+const { ProductsFixtures } = require('../fixtures/products-fixtures');
+const { ReviewsFixtures } = require('../fixtures/reviews-fixtures');
+
+class RelationsShapeSupport
+{
+
+    constructor(dataServer, repos)
+    {
+        this.dataServer = dataServer;
+        this.repos = {
+            child: repos.testReviews,
+            parent: repos.testProducts,
+            grandParent: repos.testCategories
+        };
+    }
+
+    async insertChainFixtures()
+    {
+        await TestHelpers.cleanDatabase(this.dataServer);
+        let fixturesByTable = {
+            test_categories: [CategoriesFixtures.category_relations_1, CategoriesFixtures.category_relations_2],
+            test_products: [ProductsFixtures.product_relations_1, ProductsFixtures.product_relations_2],
+            test_reviews: [ReviewsFixtures.review_relations_1, ReviewsFixtures.review_relations_2]
+        };
+        for(let tableName of Object.keys(fixturesByTable)){
+            await TestHelpers.insertFixturesViaRawSQL(this.dataServer, tableName, fixturesByTable[tableName]);
+        }
+        return true;
+    }
+
+    cleared(repoKey)
+    {
+        if(this.dataServer.orm && this.dataServer.orm.em){
+            this.dataServer.orm.em.clear();
+        }
+        return this.repos[repoKey];
+    }
+
+    async loadChildWithHint(relationsHint)
+    {
+        return await this.cleared('child').loadOneByWithRelations(
+            'product_id',
+            ProductsFixtures.product_relations_1.id,
+            relationsHint
+        );
+    }
+
+    assertEntityColumns(entityValue, expectedColumns, label)
+    {
+        let described = ObservedValue.log(label, entityValue);
+        assert.ok(entityValue, label+' is falsy, the relation was not populated, observed: '+described);
+        assert.notStrictEqual('number', typeof entityValue, label+' is a RAW NUMBER, observed: '+described);
+        assert.strictEqual('object', typeof entityValue, label+' is not an entity, observed: '+described);
+        for(let columnName of Object.keys(expectedColumns)){
+            assert.strictEqual(
+                entityValue[columnName],
+                expectedColumns[columnName],
+                label+'.'+columnName+' observed: '+ObservedValue.describe(entityValue[columnName])
+                +' - expected: '+String(expectedColumns[columnName])
+            );
+        }
+        return true;
+    }
+
+    assertNumericColumn(actualValue, expectedValue, label)
+    {
+        let described = ObservedValue.log(label, actualValue);
+        assert.ok(null !== actualValue, label+' is null, observed: '+described);
+        assert.strictEqual(Number(actualValue), expectedValue, label+' observed: '+described);
+        return true;
+    }
+
+    async assertStoredColumn(repoKey, id, columnName, expectedValue, label)
+    {
+        let record = await this.cleared(repoKey).loadOneBy('id', id);
+        assert.ok(record, label+' row was not found in the database, id: '+id);
+        this.assertNumericColumn(record[columnName], expectedValue, label+'.'+columnName+' re-read from database');
+        let filtered = await this.cleared(repoKey).loadBy(columnName, expectedValue);
+        let filteredIds = filtered.map((row) => Number(row.id));
+        ObservedValue.log(label+' ids where '+columnName+' = '+expectedValue, filteredIds);
+        assert.ok(
+            filteredIds.includes(Number(id)),
+            label+' id '+id+' was not returned when filtering by '+columnName+' = '+expectedValue
+            +', so that column value is not stored in the database; observed ids: '+filteredIds.join(',')
+        );
+        return true;
+    }
+
+}
+
+module.exports.RelationsShapeSupport = RelationsShapeSupport;

package/tests/utils/reldens-schema-loader.js

@@ -0,0 +1,274 @@
+/**
+ *
+ * Reldens - ReldensSchemaLoader
+ *
+ */
+
+const { TestHelpers } = require('./test-helpers');
+const { Logger, sc } = require('@reldens/utils');
+const { FileHandler } = require('@reldens/server-utils');
+
+class ReldensSchemaLoader
+{
+
+    static migrationsPath()
+    {
+        return process.env.RELDENS_TEST_MIGRATIONS_PATH || '';
+    }
+
+    static sqlFileNames()
+    {
+        return ['reldens-install-v4.0.0.sql', 'reldens-basic-config-v4.0.0.sql', 'reldens-sample-data-v4.0.0.sql'];
+    }
+
+    static isAvailable()
+    {
+        let migrationsPath = this.migrationsPath();
+        if('' === migrationsPath){
+            return false;
+        }
+        for(let fileName of this.sqlFileNames()){
+            if(!FileHandler.exists(FileHandler.joinPaths(migrationsPath, fileName))){
+                Logger.warning('Reldens schema file not found: '+fileName);
+                return false;
+            }
+        }
+        return true;
+    }
+
+    static databaseName()
+    {
+        return process.env.RELDENS_TEST_RELDENS_DB_NAME || 'reldens_storage_test_full';
+    }
+
+    static generationPath()
+    {
+        return FileHandler.joinPaths(process.cwd(), 'tests', 'generated-reldens-schema');
+    }
+
+    static async ensureDatabase()
+    {
+        let BootstrapServerClass = TestHelpers.getDataServerClass('knex');
+        if(!BootstrapServerClass){
+            Logger.critical('Reldens schema bootstrap data server class not found.');
+            return false;
+        }
+        let bootstrapServer = new BootstrapServerClass({
+            client: TestHelpers.driverClient('knex'),
+            config: {...TestHelpers.getTestDbConfig(), multipleStatements: true},
+            rawEntities: {},
+            multipleStatements: true,
+            poolConfig: {min: 0, max: 2}
+        });
+        await bootstrapServer.connect();
+        if(!bootstrapServer.initialized){
+            Logger.critical('Reldens schema bootstrap connection failed.');
+            return false;
+        }
+        await TestHelpers.executeRawSQL(bootstrapServer, 'DROP DATABASE IF EXISTS '+this.databaseName()+';');
+        await TestHelpers.executeRawSQL(bootstrapServer, 'CREATE DATABASE '+this.databaseName()+';');
+        await bootstrapServer.disconnect();
+        Logger.info('Reldens schema database is ready: '+this.databaseName());
+        return true;
+    }
+
+    static async regeneratedPrismaModules(config)
+    {
+        let prismaConfig = Object.assign({}, config, {client: 'mysql'});
+        if(!await TestHelpers.generatePrismaSchema(prismaConfig)){
+            Logger.critical('Reldens schema Prisma schema generation failed.');
+            return false;
+        }
+        if(!await TestHelpers.generatePrismaClient()){
+            Logger.critical('Reldens schema Prisma client generation failed.');
+            return false;
+        }
+        delete require.cache[require.resolve(FileHandler.joinPaths(process.cwd(), 'prisma', 'client'))];
+        return await TestHelpers.loadPrismaModules(process.cwd(), config);
+    }
+
+    static async refreshPrismaClient(dataServer, driverName)
+    {
+        if('prisma' !== driverName){
+            return true;
+        }
+        let config = TestHelpers.getTestDbConfig();
+        config.database = this.databaseName();
+        let prismaModules = await this.regeneratedPrismaModules(config);
+        if(!prismaModules){
+            return false;
+        }
+        await dataServer.disconnect();
+        dataServer.prismaModules = prismaModules;
+        dataServer.prisma = prismaModules.client;
+        dataServer.initialized = Date.now();
+        return true;
+    }
+
+    static async setupDataServer(driverName)
+    {
+        let DataServerClass = TestHelpers.getDataServerClass(driverName);
+        if(!DataServerClass){
+            Logger.critical('Reldens schema data server class not found for '+driverName);
+            return false;
+        }
+        let config = TestHelpers.getTestDbConfig();
+        config.database = this.databaseName();
+        let serverConfig = {
+            client: TestHelpers.driverClient(driverName),
+            config: {...config, multipleStatements: true},
+            rawEntities: {},
+            multipleStatements: true,
+            poolConfig: {min: 0, max: 2}
+        };
+        TestHelpers.appendDriverModules(serverConfig, driverName);
+        if('prisma' === driverName){
+            serverConfig.prismaModules = await TestHelpers.loadPrismaModules(process.cwd(), config);
+            if(!serverConfig.prismaModules){
+                return false;
+            }
+        }
+        let dataServer = new DataServerClass(serverConfig);
+        await dataServer.connect();
+        if(!dataServer.initialized){
+            Logger.critical('Reldens schema data server failed to initialize for '+driverName);
+            return false;
+        }
+        return dataServer;
+    }
+
+    static async loadSchemaAndData(dataServer)
+    {
+        for(let fileName of this.sqlFileNames()){
+            let sql = FileHandler.readFile(FileHandler.joinPaths(this.migrationsPath(), fileName));
+            if(!sql){
+                Logger.critical('Could not read reldens schema file: '+fileName);
+                return false;
+            }
+            await TestHelpers.executeRawSQL(dataServer, sql);
+            Logger.info('Loaded reldens schema file: '+fileName);
+        }
+        return true;
+    }
+
+    static async generateEntities(dataServer, driverName)
+    {
+        let { EntitiesGenerator } = require('../../lib/entities-generator');
+        let config = TestHelpers.getTestDbConfig();
+        let generator = new EntitiesGenerator({
+            connectionData: {
+                driver: driverName,
+                client: TestHelpers.driverClient(driverName),
+                user: config.user,
+                password: config.password,
+                host: config.host,
+                database: this.databaseName(),
+                port: config.port
+            },
+            projectPath: this.generationPath(),
+            isOverride: true,
+            server: dataServer
+        });
+        if(!await generator.generate()){
+            Logger.critical('Reldens schema entities generation failed for '+driverName);
+            return false;
+        }
+        return this.fixGeneratedRequirePaths(driverName);
+    }
+
+    static modelsFolderDepth = 5;
+
+    static entitiesFolderDepth = 4;
+
+    static packageRequirePath(folderDepth)
+    {
+        return '..'+'/..'.repeat(folderDepth - 1)+'/index';
+    }
+
+    static fixGeneratedRequirePaths(driverName)
+    {
+        let modelsFolder = FileHandler.joinPaths(this.generationPath(), 'generated-entities', 'models', driverName);
+        if(!this.replacePackageRequire(modelsFolder, this.packageRequirePath(this.modelsFolderDepth))){
+            return false;
+        }
+        return this.replacePackageRequire(
+            FileHandler.joinPaths(this.generationPath(), 'generated-entities', 'entities'),
+            this.packageRequirePath(this.entitiesFolderDepth)
+        );
+    }
+
+    static replacePackageRequire(folderPath, packagePath)
+    {
+        let fileNames = FileHandler.getFilesInFolder(folderPath, ['.js']);
+        if(!sc.isArray(fileNames) || 0 === fileNames.length){
+            Logger.critical('No reldens schema files were generated at: '+folderPath);
+            return false;
+        }
+        for(let fileName of fileNames){
+            let filePath = FileHandler.joinPaths(folderPath, fileName);
+            let content = FileHandler.readFile(filePath);
+            FileHandler.writeFile(
+                filePath,
+                content.replace("require('@reldens/storage')", "require('"+packagePath+"')")
+            );
+        }
+        Logger.info('Fixed the require paths on '+fileNames.length+' reldens schema files at: '+folderPath);
+        return true;
+    }
+
+    static async loadEntities(dataServer, driverName)
+    {
+        let modelsFolder = FileHandler.joinPaths(this.generationPath(), 'generated-entities', 'models', driverName);
+        let modelsPath = FileHandler.joinPaths(modelsFolder, 'registered-models-'+driverName+'.js');
+        if(!FileHandler.exists(modelsPath)){
+            Logger.critical('Reldens schema registered models not found: '+modelsPath);
+            return false;
+        }
+        dataServer.rawEntities = require(modelsPath).rawRegisteredEntities;
+        if('mikro-orm' === driverName){
+            await dataServer.disconnect();
+            await dataServer.connect();
+        }
+        dataServer.generateEntities();
+        if(0 === Object.keys(dataServer.entities).length){
+            Logger.critical('No reldens schema entities generated for '+driverName);
+            return false;
+        }
+        Logger.info('Loaded '+Object.keys(dataServer.entities).length+' reldens schema entities for '+driverName);
+        return true;
+    }
+
+    static async setup(driverName)
+    {
+        if(!await this.ensureDatabase()){
+            return false;
+        }
+        let dataServer = await this.setupDataServer(driverName);
+        if(!dataServer){
+            return false;
+        }
+        if(!await this.loadSchemaAndData(dataServer)){
+            return false;
+        }
+        if(!await this.refreshPrismaClient(dataServer, driverName)){
+            return false;
+        }
+        if(!await this.generateEntities(dataServer, driverName)){
+            return false;
+        }
+        if(!await this.loadEntities(dataServer, driverName)){
+            return false;
+        }
+        return dataServer;
+    }
+
+    static async teardown(dataServer)
+    {
+        await TestHelpers.teardownDriver(dataServer);
+        FileHandler.remove(this.generationPath());
+        return true;
+    }
+
+}
+
+module.exports.ReldensSchemaLoader = ReldensSchemaLoader;

package/tests/utils/test-helpers.js

@@ -5,6 +5,11 @@
  */
 
 const { FileHandler } = require('@reldens/server-utils');
+const { KyselyModulesLoader } = require('../../lib/kysely/kysely-modules-loader');
+const { DrizzleModulesLoader } = require('../../lib/drizzle/drizzle-modules-loader');
+const { MikroOrmModulesLoader } = require('../../lib/mikro-orm/mikro-orm-modules-loader');
+const { ObjectionModulesLoader } = require('../../lib/objection-js/objection-modules-loader');
+const { KnexModulesLoader } = require('../../lib/knex/knex-modules-loader');
 const { Logger, sc } = require('@reldens/utils');
 const { exec, execSync } = require('child_process');
 const { promisify } = require('util');
@@ -22,7 +27,8 @@ class TestHelpers
             user: process.env.RELDENS_TEST_DB_USER || 'test_user',
             password: process.env.RELDENS_TEST_DB_PASSWORD || 'test_password',
             database: process.env.RELDENS_TEST_DB_NAME || 'reldens_storage_test',
-            client: process.env.RELDENS_TEST_DB_CLIENT || 'mysql'
+            client: process.env.RELDENS_TEST_DB_CLIENT || 'mysql',
+            connectionLimit: Number(process.env.RELDENS_TEST_DB_CONNECTION_LIMIT || 2)
         };
     }
 
@@ -41,10 +47,11 @@ class TestHelpers
                 }
             }
             let serverConfig = {
-                client: driverName === 'objection-js' ? 'mysql2' : 'mysql',
+                client: this.driverClient(driverName),
                 config: {...config, multipleStatements: true},
                 rawEntities: rawEntities,
-                multipleStatements: true
+                multipleStatements: true,
+                poolConfig: {min: 0, max: 2}
             };
             if('prisma' === driverName){
                 let prismaModules = await this.loadPrismaModules(process.cwd(), config);
@@ -53,6 +60,7 @@ class TestHelpers
                 }
                 serverConfig.prismaModules = prismaModules;
             }
+            this.appendDriverModules(serverConfig, driverName);
             let DataServerClass = this.getDataServerClass(driverName);
             let dataServer = new DataServerClass(serverConfig);
             let connected = await dataServer.connect();
@@ -81,16 +89,67 @@ class TestHelpers
             let { PrismaDataServer } = require('../../lib/prisma/prisma-data-server');
             return PrismaDataServer;
         }
+        if('knex' === driverName){
+            let { KnexDataServer } = require('../../lib/knex/knex-data-server');
+            return KnexDataServer;
+        }
+        if('kysely' === driverName){
+            let { KyselyDataServer } = require('../../lib/kysely/kysely-data-server');
+            return KyselyDataServer;
+        }
+        if('drizzle' === driverName){
+            let { DrizzleDataServer } = require('../../lib/drizzle/drizzle-data-server');
+            return DrizzleDataServer;
+        }
         Logger.critical('Unknown driver: '+driverName);
         return false;
     }
 
+    static driverClient(driverName)
+    {
+        if('objection-js' === driverName){
+            return 'mysql2';
+        }
+        if('knex' === driverName){
+            return 'mysql2';
+        }
+        return 'mysql';
+    }
+
+    static appendDriverModules(serverConfig, driverName)
+    {
+        this.registerNpmGlobalPaths();
+        if('kysely' === driverName){
+            serverConfig.kyselyModules = KyselyModulesLoader.load(false);
+            return serverConfig;
+        }
+        if('drizzle' === driverName){
+            serverConfig.drizzleModules = DrizzleModulesLoader.load(false);
+            return serverConfig;
+        }
+        if('mikro-orm' === driverName){
+            serverConfig.mikroOrmModules = MikroOrmModulesLoader.load(false, serverConfig.client);
+            return serverConfig;
+        }
+        if('objection-js' === driverName){
+            serverConfig.objectionModules = ObjectionModulesLoader.load(false);
+            return serverConfig;
+        }
+        if('knex' === driverName){
+            serverConfig.knexModules = KnexModulesLoader.load(false);
+        }
+        return serverConfig;
+    }
+
     static async teardownDriver(dataServer)
     {
         if(!dataServer){
             return;
         }
         try {
+            if(dataServer.db){
+                await dataServer.disconnect();
+            }
             if(dataServer.knex){
                 await dataServer.knex.destroy();
             }
@@ -156,6 +215,7 @@ class TestHelpers
         try {
             await dataServer.rawQuery('SET FOREIGN_KEY_CHECKS=0;');
             await dataServer.rawQuery('DELETE FROM test_reviews;');
+            await dataServer.rawQuery('DELETE FROM test_product_details;');
             await dataServer.rawQuery('DELETE FROM test_products;');
             await dataServer.rawQuery('DELETE FROM test_categories;');
             await dataServer.rawQuery('SET FOREIGN_KEY_CHECKS=1;');
@@ -210,6 +270,7 @@ class TestHelpers
         try {
             await dataServer.rawQuery('SET FOREIGN_KEY_CHECKS=0;');
             await dataServer.rawQuery('DROP TABLE IF EXISTS test_reviews;');
+            await dataServer.rawQuery('DROP TABLE IF EXISTS test_product_details;');
             await dataServer.rawQuery('DROP TABLE IF EXISTS test_products;');
             await dataServer.rawQuery('DROP TABLE IF EXISTS test_categories;');
             await dataServer.rawQuery('SET FOREIGN_KEY_CHECKS=1;');
@@ -292,14 +353,16 @@ class TestHelpers
     static verifyAllPackages()
     {
         let required = [
-            {name: '@mikro-orm/core', version: '7.2.0'},
-            {name: '@mikro-orm/mongodb', version: '7.2.0'},
-            {name: '@mikro-orm/mysql', version: '7.2.0'},
             {name: 'knex', version: '3.3.0'},
-            {name: 'mysql', version: '2.18.1'},
-            {name: 'mysql2', version: '3.24.3'},
-            {name: 'objection', version: '3.1.5'}
+            {name: 'mysql2', version: '3.24.4'}
         ];
+        if(this.isObjectionFlagEnabled()){
+            required.push({name: 'objection', version: '3.1.5', optional: true});
+        }
+        if(this.isMikroOrmFlagEnabled()){
+            required.push({name: '@mikro-orm/core', version: '7.2.0', optional: true});
+            required.push({name: '@mikro-orm/mysql', version: '7.2.0', optional: true});
+        }
         if(this.isPrismaFlagEnabled()){
             required.push({name: 'prisma', version: '7.9.1', optional: true});
             required.push({name: '@prisma/client', version: '7.9.1', optional: true});
@@ -359,7 +422,11 @@ class TestHelpers
             Logger.warning('Could not resolve the npm global root: '+error.message);
             return '';
         }
-        let extraPaths = [globalRoot, FileHandler.joinPaths(globalRoot, '@prisma', 'client', 'node_modules')];
+        let extraPaths = [
+            globalRoot,
+            FileHandler.joinPaths(globalRoot, '@prisma', 'client', 'node_modules'),
+            FileHandler.joinPaths(process.cwd(), 'node_modules')
+        ];
         let currentPaths = process.env.NODE_PATH ? process.env.NODE_PATH.split(delimiter) : [];
         process.env.NODE_PATH = [...currentPaths, ...extraPaths].join(delimiter);
         NodeModule._initPaths();
@@ -381,12 +448,66 @@ class TestHelpers
         return this.isPrismaAvailable();
     }
 
+    static isObjectionFlagEnabled()
+    {
+        return '1' === String(process.env.RELDENS_TEST_OBJECTION_ENABLED);
+    }
+
+    static isObjectionEnabled()
+    {
+        if(!this.isObjectionFlagEnabled()){
+            return false;
+        }
+        return this.canResolvePackage('objection');
+    }
+
+    static isMikroOrmFlagEnabled()
+    {
+        return '1' === String(process.env.RELDENS_TEST_MIKRO_ORM_ENABLED);
+    }
+
+    static isMikroOrmEnabled()
+    {
+        if(!this.isMikroOrmFlagEnabled()){
+            return false;
+        }
+        return this.canResolvePackage('@mikro-orm/core') && this.canResolvePackage('@mikro-orm/mysql');
+    }
+
+    static isKyselyEnabled()
+    {
+        if('1' !== String(process.env.RELDENS_TEST_KYSELY_ENABLED)){
+            return false;
+        }
+        return this.canResolvePackage('kysely');
+    }
+
+    static isDrizzleEnabled()
+    {
+        if('1' !== String(process.env.RELDENS_TEST_DRIZZLE_ENABLED)){
+            return false;
+        }
+        return this.canResolvePackage('drizzle-orm');
+    }
+
     static activeDriverNames()
     {
-        let driverNames = ['objection-js', 'mikro-orm'];
+        let driverNames = ['knex'];
+        if(this.isObjectionEnabled()){
+            driverNames.push('objection-js');
+        }
+        if(this.isMikroOrmEnabled()){
+            driverNames.push('mikro-orm');
+        }
         if(this.isPrismaEnabled()){
             driverNames.push('prisma');
         }
+        if(this.isKyselyEnabled()){
+            driverNames.push('kysely');
+        }
+        if(this.isDrizzleEnabled()){
+            driverNames.push('drizzle');
+        }
         return driverNames;
     }
 
@@ -479,7 +600,14 @@ class TestHelpers
             }
             let adapterModule = require('@prisma/adapter-mariadb');
             let adapterConfig = config
-                ? { host: config.host, port: config.port, user: config.user, password: config.password, database: config.database }
+                ? {
+                    host: config.host,
+                    port: config.port,
+                    user: config.user,
+                    password: config.password,
+                    database: config.database,
+                    connectionLimit: sc.get(config, 'connectionLimit', 2)
+                }
                 : process.env.RELDENS_DB_URL;
             let client = new prismaModule.PrismaClient({ adapter: new adapterModule.PrismaMariaDb(adapterConfig) });
             await client.$connect();
@@ -507,6 +635,10 @@ class TestHelpers
             Logger.info('Cleaning up Prisma config file: '+prismaConfigPath);
             FileHandler.remove(prismaConfigPath);
         }
+        if('1' === process.env.RELDENS_TEST_KEEP_GENERATED){
+            Logger.info('Keeping generated entities folder, RELDENS_TEST_KEEP_GENERATED is active.');
+            return;
+        }
         let entitiesPath = FileHandler.joinPaths(process.cwd(), 'generated-entities');
         if(FileHandler.exists(entitiesPath)){
             Logger.info('Cleaning up generated entities folder: '+entitiesPath);
@@ -719,9 +851,7 @@ class TestHelpers
             for(let filename of expectedFiles){
                 let expectedContent = FileHandler.readFile(FileHandler.joinPaths(expectedPath, filename));
                 let generatedContent = FileHandler.readFile(FileHandler.joinPaths(generatedPath, filename));
-                let normalizedExpected = expectedContent.replace(/\r\n/g, '\n');
-                let normalizedGenerated = generatedContent.replace(/\r\n/g, '\n');
-                if(normalizedExpected !== normalizedGenerated){
+                if(this.normalizeGeneratedContent(expectedContent) !== this.normalizeGeneratedContent(generatedContent)){
                     Logger.warning('File content mismatch: '+filename);
                     Logger.warning('Expected: '+FileHandler.joinPaths(expectedPath, filename));
                     Logger.warning('Generated: '+FileHandler.joinPaths(generatedPath, filename));
@@ -735,9 +865,7 @@ class TestHelpers
         if(!isExpectedDir && !isGeneratedDir){
             let expectedContent = FileHandler.readFile(expectedPath);
             let generatedContent = FileHandler.readFile(generatedPath);
-            let normalizedExpected = expectedContent.replace(/\r\n/g, '\n');
-            let normalizedGenerated = generatedContent.replace(/\r\n/g, '\n');
-            if(normalizedExpected !== normalizedGenerated){
+            if(this.normalizeGeneratedContent(expectedContent) !== this.normalizeGeneratedContent(generatedContent)){
                 Logger.warning('File content mismatch: '+relativePath);
             }
             Logger.info('File '+relativePath+' matches expected output');
@@ -746,6 +874,11 @@ class TestHelpers
         throw new Error('Path type mismatch for: '+relativePath);
     }
 
+    static normalizeGeneratedContent(content)
+    {
+        return content.replace(/\r\n/g, '\n').replace(/[ \t]+\n/g, '\n');
+    }
+
     static async loadGeneratedEntities(dataServer, driverName)
     {
         let modelsPath = FileHandler.joinPaths(
@@ -795,7 +928,7 @@ class TestHelpers
         this.fixGeneratedRequirePaths();
         this.compareGeneratedWithExpected(driverName, 'entities');
         this.compareGeneratedWithExpected(driverName, 'models/'+driverName);
-        if('objection-js' === driverName){
+        if('knex' === driverName){
             this.compareGeneratedWithExpected(driverName, 'entities-config.js');
             this.compareGeneratedWithExpected(driverName, 'entities-translations.js');
         }