@reldens/storage 0.88.0 → 0.89.0

package/tests/integration/test-relations.js

@@ -0,0 +1,349 @@
+/**
+ *
+ * Reldens - Relations Test
+ * Tests relation loading across all three storage drivers
+ *
+ */
+
+const { TestRunner, assert } = require('../utils/test-runner');
+const { TestHelpers } = require('../utils/test-helpers');
+const { CategoriesFixtures } = require('../fixtures/categories-fixtures');
+const { ProductsFixtures } = require('../fixtures/products-fixtures');
+const { ReviewsFixtures } = require('../fixtures/reviews-fixtures');
+
+class RelationsTest
+{
+
+    constructor(dataServer, repos, driverName)
+    {
+        this.dataServer = dataServer;
+        this.categoriesRepo = repos.testCategories;
+        this.productsRepo = repos.testProducts;
+        this.driverName = driverName;
+        this.runner = new TestRunner();
+    }
+
+    async run()
+    {
+        this.runner.suite('Relations - Driver: '+this.driverName);
+        await this.testLoadWithRelations();
+        await this.testLoadAllWithRelations();
+        await this.testLoadByWithRelations();
+        await this.testLoadByIdWithRelations();
+        await this.testLoadOneWithRelations();
+        await this.testLoadOneByWithRelations();
+        await this.testCountWithRelations();
+        await this.testCreateWithRelations();
+        await this.testNestedRelations();
+        await this.testRelationStringParsing();
+        return this.runner.getResults();
+    }
+
+    async testLoadWithRelations()
+    {
+        this.runner.group('loadWithRelations');
+        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_reviews', [
+            ReviewsFixtures.review_relations_1
+        ]);
+        await this.runner.test('should load records with single relation', async () => {
+            let results = await this.categoriesRepo.loadWithRelations({id: 1600}, ['related_test_products']);
+            assert.ok(results);
+            assert.ok(results.length > 0);
+            let category = results[0];
+            assert.ok(category.related_test_products);
+            assert.ok(Array.isArray(category.related_test_products));
+            assert.strictEqual(category.related_test_products.length, 1);
+        });
+        await this.runner.test('should load records with multiple relations', async () => {
+            let results = await this.productsRepo.loadWithRelations(
+                {id: 2600},
+                ['related_test_categories', 'related_test_reviews']
+            );
+            assert.ok(results);
+            assert.ok(results.length > 0);
+            let product = results[0];
+            assert.ok(product.related_test_categories);
+            assert.ok(product.related_test_reviews);
+            assert.ok(Array.isArray(product.related_test_reviews));
+        });
+        await this.runner.test('should load with empty filters', async () => {
+            let results = await this.categoriesRepo.loadWithRelations({}, ['related_test_products']);
+            assert.ok(results);
+            assert.strictEqual(results.length, 1);
+        });
+        await this.runner.test('should filter by nested relation properties', async () => {
+            await TestHelpers.cleanDatabase(this.dataServer);
+            await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_categories', [
+                CategoriesFixtures.category_relations_1,
+                CategoriesFixtures.category_relations_2
+            ]);
+            await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_products', [
+                {...ProductsFixtures.product_relations_1, id: 2600, category_id: 1600, price: 149.99},
+                {...ProductsFixtures.product_relations_2, id: 2601, category_id: 1601, price: 49.99}
+            ]);
+            let results = await this.categoriesRepo.loadWithRelations({
+                related_test_products: {
+                    price: {operator: 'gt', value: 100}
+                }
+            }, ['related_test_products']);
+            assert.ok(results);
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].id, 1600);
+        });
+    }
+
+    async testLoadAllWithRelations()
+    {
+        this.runner.group('loadAllWithRelations');
+        await TestHelpers.cleanDatabase(this.dataServer);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_categories', [
+            CategoriesFixtures.category_relations_1,
+            CategoriesFixtures.category_relations_2
+        ]);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_products', [
+            ProductsFixtures.product_relations_1,
+            ProductsFixtures.product_relations_2
+        ]);
+        await this.runner.test('should load all records with relations', async () => {
+            let results = await this.categoriesRepo.loadAllWithRelations(['related_test_products']);
+            assert.ok(results);
+            assert.strictEqual(results.length, 2);
+            for(let category of results){
+                assert.ok(category.related_test_products);
+                assert.ok(Array.isArray(category.related_test_products));
+            }
+        });
+        await this.runner.test('should respect limit with relations', async () => {
+            this.categoriesRepo.limit = 1;
+            let results = await this.categoriesRepo.loadWithRelations({}, ['related_test_products']);
+            assert.strictEqual(results.length, 1);
+            assert.ok(results[0].related_test_products);
+            this.categoriesRepo.limit = 0;
+        });
+        await this.runner.test('should respect sortBy with relations', async () => {
+            this.categoriesRepo.sortBy = 'name';
+            this.categoriesRepo.sortDirection = 'DESC';
+            let results = await this.categoriesRepo.loadWithRelations({}, ['related_test_products']);
+            assert.ok(results.length > 0);
+            assert.ok(results[0].related_test_products);
+            this.categoriesRepo.sortBy = false;
+            this.categoriesRepo.sortDirection = 'ASC';
+        });
+    }
+
+    async testLoadByWithRelations()
+    {
+        this.runner.group('loadByWithRelations');
+        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 this.runner.test('should load records by field with relations', async () => {
+            let results = await this.categoriesRepo.loadByWithRelations('slug', 'relations-test-1', ['related_test_products']);
+            assert.ok(results);
+            assert.ok(results.length > 0);
+            let category = results[0];
+            assert.strictEqual(category.slug, 'relations-test-1');
+            assert.ok(category.related_test_products);
+            assert.ok(Array.isArray(category.related_test_products));
+        });
+        await this.runner.test('should return empty array when no match with relations', async () => {
+            let results = await this.categoriesRepo.loadByWithRelations('slug', 'nonexistent', ['related_test_products']);
+            assert.ok(results);
+            assert.strictEqual(results.length, 0);
+        });
+    }
+
+    async testLoadByIdWithRelations()
+    {
+        this.runner.group('loadByIdWithRelations');
+        await TestHelpers.cleanDatabase(this.dataServer);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_categories', [
+            CategoriesFixtures.category_relations_1,
+            CategoriesFixtures.category_relations_2
+        ]);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_products', [
+            ProductsFixtures.product_relations_1,
+            ProductsFixtures.product_relations_2
+        ]);
+        await this.runner.test('should load single record by ID with relations', async () => {
+            let result = await this.categoriesRepo.loadByIdWithRelations(1600, ['related_test_products']);
+            assert.ok(result);
+            assert.strictEqual(result.id, 1600);
+            assert.ok(result.related_test_products);
+            assert.ok(Array.isArray(result.related_test_products));
+            assert.strictEqual(result.related_test_products.length, 1);
+        });
+        await this.runner.test('should return null when ID not found with relations', async () => {
+            let result = await this.categoriesRepo.loadByIdWithRelations(99999, ['related_test_products']);
+            assert.ok(!result);
+        });
+    }
+
+    async testLoadOneWithRelations()
+    {
+        this.runner.group('loadOneWithRelations');
+        await TestHelpers.cleanDatabase(this.dataServer);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_categories', [
+            CategoriesFixtures.category_relations_1,
+            CategoriesFixtures.category_relations_2
+        ]);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_products', [
+            ProductsFixtures.product_relations_1
+        ]);
+        await this.runner.test('should load one record with relations', async () => {
+            let result = await this.categoriesRepo.loadOneWithRelations({is_active: 1}, ['related_test_products']);
+            assert.ok(result);
+            assert.strictEqual(result.is_active, 1);
+            assert.ok(result.related_test_products);
+            assert.ok(Array.isArray(result.related_test_products));
+        });
+        await this.runner.test('should return null when no match with relations', async () => {
+            let result = await this.categoriesRepo.loadOneWithRelations({slug: 'nonexistent'}, ['related_test_products']);
+            assert.ok(!result);
+        });
+    }
+
+    async testLoadOneByWithRelations()
+    {
+        this.runner.group('loadOneByWithRelations');
+        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 this.runner.test('should load one record by field with relations', async () => {
+            let result = await this.categoriesRepo.loadOneByWithRelations('slug', 'relations-test-1', ['related_test_products']);
+            assert.ok(result);
+            assert.strictEqual(result.slug, 'relations-test-1');
+            assert.ok(result.related_test_products);
+            assert.ok(Array.isArray(result.related_test_products));
+        });
+        await this.runner.test('should return null when no match by field with relations', async () => {
+            let result = await this.categoriesRepo.loadOneByWithRelations('slug', 'nonexistent', ['related_test_products']);
+            assert.ok(!result);
+        });
+    }
+
+    async testCountWithRelations()
+    {
+        this.runner.group('countWithRelations');
+        await TestHelpers.cleanDatabase(this.dataServer);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_categories', [
+            CategoriesFixtures.category_relations_1,
+            CategoriesFixtures.category_relations_2,
+            CategoriesFixtures.category_filters_3
+        ]);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_products', [
+            ProductsFixtures.product_relations_1
+        ]);
+        await this.runner.test('should count records with relation filter', async () => {
+            let count = await this.categoriesRepo.countWithRelations({is_active: 1}, ['related_test_products']);
+            assert.strictEqual(count, 2);
+        });
+        await this.runner.test('should count all records with relations', async () => {
+            let count = await this.categoriesRepo.countWithRelations({}, ['related_test_products']);
+            assert.strictEqual(count, 3);
+        });
+    }
+
+    async testCreateWithRelations()
+    {
+        this.runner.group('createWithRelations');
+        await TestHelpers.cleanDatabase(this.dataServer);
+        await this.runner.test('should create record with nested relations', async () => {
+            let categoryWithProducts = {
+                ...CategoriesFixtures.category_create_nested,
+                related_test_products: [ProductsFixtures.product_create_nested]
+            };
+            let created = await this.categoriesRepo.createWithRelations(categoryWithProducts, ['related_test_products']);
+            assert.ok(created);
+            assert.ok(created.id);
+            let loaded = await this.categoriesRepo.loadByIdWithRelations(created.id, ['related_test_products']);
+            assert.ok(loaded);
+            assert.ok(loaded.related_test_products);
+            assert.ok(loaded.related_test_products.length > 0);
+        });
+        await TestHelpers.cleanDatabase(this.dataServer);
+        await this.runner.test('should create record without relations when not provided', async () => {
+            let created = await this.categoriesRepo.createWithRelations(
+                CategoriesFixtures.category_create_nested,
+                ['related_test_products']
+            );
+            assert.ok(created);
+            assert.ok(created.id);
+        });
+    }
+
+    async testNestedRelations()
+    {
+        this.runner.group('Nested 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
+        ]);
+        await TestHelpers.insertFixturesViaRawSQL(this.dataServer, 'test_reviews', [
+            ReviewsFixtures.review_relations_1
+        ]);
+        await this.runner.test('should load nested relations (category > products > reviews)', async () => {
+            let results = await this.categoriesRepo.loadWithRelations(
+                {id: 1600},
+                ['related_test_products.related_test_reviews']
+            );
+            assert.ok(results);
+            assert.ok(results.length > 0);
+            let category = results[0];
+            assert.ok(category.related_test_products);
+            assert.ok(category.related_test_products.length > 0);
+            let product = category.related_test_products[0];
+            assert.ok(product.related_test_reviews);
+        });
+    }
+
+    async testRelationStringParsing()
+    {
+        this.runner.group('Relation String Parsing');
+        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 this.runner.test('should parse comma-separated relations string', async () => {
+            let results = await this.productsRepo.loadWithRelations(
+                {id: 2600},
+                'related_test_categories,related_test_reviews'
+            );
+            assert.ok(results);
+            assert.ok(results.length > 0);
+        });
+        await this.runner.test('should handle single relation as string', async () => {
+            let results = await this.productsRepo.loadWithRelations(
+                {id: 2600},
+                'related_test_categories'
+            );
+            assert.ok(results);
+            assert.ok(results.length > 0);
+            assert.ok(results[0].related_test_categories);
+        });
+    }
+
+}
+
+module.exports = RelationsTest;

package/tests/run-tests.js

@@ -0,0 +1,213 @@
+/**
+ *
+ * Reldens - Storage Test Runner
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+const { FileHandler } = require('@reldens/server-utils');
+const { TestHelpers } = require('./utils/test-helpers');
+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 EntityManagerTest = require('./unit/test-entity-manager');
+const TypeMapperTest = require('./unit/test-type-mapper');
+const DriversUnitTest = require('./unit/test-drivers');
+
+if(!process.env.RELDENS_TEST_DB_HOST){
+    let envPath = FileHandler.joinPaths(__dirname, '.env.test');
+    if(FileHandler.exists(envPath)){
+        require('dotenv').config({path: envPath});
+    }
+}
+
+class RunTests
+{
+
+    constructor()
+    {
+        this.allCounts = {total: 0, passed: 0, failed: 0};
+        this.filter = null;
+        this.suite = null;
+        this.driver = null;
+        this.skipCleanup = false;
+        this.skipGeneration = false;
+        this.driverRegistry = new DriverRegistry();
+    }
+
+    parseCommandLineArgs()
+    {
+        for(let arg of process.argv){
+            if(arg.startsWith('--filter=')){
+                this.filter = arg.split('=')[1];
+                Logger.info('Filter applied: '+this.filter+'\n');
+            }
+            if(arg.startsWith('--suite=')){
+                this.suite = arg.split('=')[1];
+                Logger.info('Suite: '+this.suite+'\n');
+            }
+            if(arg.startsWith('--driver=')){
+                this.driver = arg.split('=')[1];
+                Logger.info('Driver: '+this.driver+'\n');
+            }
+            if('--skip-cleanup' === arg){
+                this.skipCleanup = true;
+                Logger.info('Skipping cleanup: YES\n');
+            }
+            if('--skip-generation' === arg){
+                this.skipGeneration = true;
+                Logger.info('Skipping entity generation: YES\n');
+            }
+        }
+    }
+
+    async run()
+    {
+        Logger.info('='.repeat(60));
+        Logger.info('@RELDENS/STORAGE - TEST SUITE');
+        Logger.info('='.repeat(60));
+        Logger.info('Test execution started: '+sc.formatDate(new Date()));
+        Logger.info('');
+        this.parseCommandLineArgs();
+        let config = TestHelpers.getTestDbConfig();
+        if(!this.skipCleanup){
+            TestHelpers.cleanupGeneratedFiles();
+        }
+        await this.runPreFlightChecks(config);
+        let hasIntegrationTests = !this.suite || this.suite === 'integration';
+        let hasUnitTests = !this.suite || this.suite === 'unit';
+        if(this.filter){
+            if(this.filter.includes('integration')){
+                hasUnitTests = false;
+            }
+            if(this.filter.includes('unit')){
+                hasIntegrationTests = false;
+            }
+        }
+        Logger.info('Integration tests: '+(hasIntegrationTests ? 'YES' : 'NO'));
+        Logger.info('Unit tests: '+(hasUnitTests ? 'YES' : 'NO'));
+        Logger.info('');
+        if(hasIntegrationTests){
+            this.driverRegistry.skipGeneration = this.skipGeneration;
+            await this.driverRegistry.initialize();
+            await this.runIntegrationTests();
+        }
+        if(hasUnitTests){
+            await this.runUnitTests();
+        }
+        Logger.info('');
+        Logger.info('='.repeat(60));
+        Logger.info('FINAL TEST RESULTS');
+        Logger.info('='.repeat(60));
+        Logger.info('Total tests executed: '+this.allCounts.total);
+        Logger.info('Tests passed: '+this.allCounts.passed);
+        Logger.info('Tests failed: '+this.allCounts.failed);
+        Logger.info('='.repeat(60));
+        if(hasIntegrationTests){
+            await this.driverRegistry.cleanup();
+        }
+        if(0 < this.allCounts.failed){
+            process.exitCode = 1;
+        }
+        return this.allCounts;
+    }
+
+    async runIntegrationTests()
+    {
+        let driverNames = ['objection-js', 'mikro-orm', 'prisma'];
+        if(this.driver){
+            driverNames = [this.driver];
+        }
+        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');
+                continue;
+            }
+            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);
+            }
+        }
+    }
+
+    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;
+    }
+
+    async runPreFlightChecks(config)
+    {
+        Logger.info('='.repeat(60));
+        Logger.info('Pre-Flight Checks');
+        Logger.info('='.repeat(60));
+        if(!TestHelpers.verifyAllPackages()){
+            Logger.critical('Package verification failed');
+            process.exit(1);
+        }
+        Logger.info('All pre-flight checks passed');
+        Logger.info('='.repeat(60));
+    }
+
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+    Logger.info('Unhandled Rejection at: '+promise+' reason: '+reason+'\n');
+    Logger.info('(Test suite will continue)\n');
+});
+
+process.on('uncaughtException', (error) => {
+    Logger.info('Uncaught Exception: '+error.message+'\n');
+    Logger.info(error.stack+'\n');
+    Logger.info('(Test suite will continue)\n');
+});
+
+let runner = new RunTests();
+runner.run().catch(error => {
+    Logger.info('CATASTROPHIC ERROR: Test runner failed completely\n');
+    Logger.info('Error: '+error.message+'\n');
+    Logger.info(error.stack+'\n');
+    process.exit(1);
+});

package/tests/unit/test-drivers.js

@@ -0,0 +1,89 @@
+/**
+ *
+ * Reldens - Drivers Test
+ * Tests shared public methods across all storage drivers
+ *
+ */
+
+const { TestRunner, assert } = require('../utils/test-runner');
+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');
+
+class DriversUnitTest
+{
+
+    constructor()
+    {
+        this.runner = new TestRunner();
+        this.DRIVERS = [
+            {name: 'objection-js', class: ObjectionJsDriver},
+            {name: 'mikro-orm', class: MikroOrmDriver},
+            {name: 'prisma', class: PrismaDriver}
+        ];
+        this.SHARED_PUBLIC_METHODS = [
+            'databaseName',
+            'id',
+            'name',
+            'tableName',
+            'property',
+            'create',
+            'createWithRelations',
+            'update',
+            'updateBy',
+            'updateById',
+            'upsert',
+            'delete',
+            'deleteById',
+            'count',
+            'countWithRelations',
+            'loadAll',
+            'loadAllWithRelations',
+            'load',
+            'loadWithRelations',
+            'loadBy',
+            'loadByWithRelations',
+            'loadById',
+            'loadByIdWithRelations',
+            'loadByIds',
+            'loadOne',
+            'loadOneWithRelations',
+            'loadOneBy',
+            'loadOneByWithRelations',
+            'rawQuery',
+            'executeCustomQuery',
+            'isJsonField',
+            'parseRelationsString',
+            'applyQueryOptions',
+            'preserveEntityState',
+            'restoreEntityState',
+            'loadEntityData'
+        ];
+    }
+
+    async run()
+    {
+        this.runner.suite('Drivers Unit Test');
+        for(let driver of this.DRIVERS){
+            await this.testDriverMethods(driver);
+        }
+        return this.runner.getResults();
+    }
+
+    async testDriverMethods(driver)
+    {
+        this.runner.group('Driver: '+driver.name+' - Shared public methods');
+        for(let methodName of this.SHARED_PUBLIC_METHODS){
+            await this.runner.test('should have method '+methodName, async () => {
+                assert.strictEqual(
+                    typeof driver.class.prototype[methodName],
+                    'function',
+                    driver.name+' should implement '+methodName
+                );
+            });
+        }
+    }
+
+}
+
+module.exports = DriversUnitTest;