@restforgejs/platform 4.1.1 → 4.3.1

package/generators/tests/unit/lib/dbschema-kit/apply-executor.test.js

@@ -1,437 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const { applyStatements } = require('../../../../lib/dbschema-kit/apply-executor');
-
-function makeMockPgDriver({ failOnQuery } = {}) {
-  const calls = [];
-  let connected = false;
-  let ended = false;
-
-  class MockClient {
-    constructor(config) {
-      this.config = config;
-    }
-    async connect() {
-      connected = true;
-    }
-    async query(sql) {
-      calls.push(sql);
-      if (failOnQuery && failOnQuery.match.test(sql)) {
-        throw new Error(failOnQuery.message);
-      }
-      return { rows: [] };
-    }
-    async end() {
-      ended = true;
-    }
-  }
-
-  return {
-    driver: { Client: MockClient },
-    state: () => ({ calls, connected, ended })
-  };
-}
-
-function makeMockMysqlDriver({ failOnQuery } = {}) {
-  const calls = [];
-  let ended = false;
-
-  return {
-    driver: {
-      createConnection: async (config) => ({
-        config,
-        query: async (sql) => {
-          calls.push(sql);
-          if (failOnQuery && failOnQuery.match.test(sql)) {
-            throw new Error(failOnQuery.message);
-          }
-          return [[], []];
-        },
-        end: async () => {
-          ended = true;
-        }
-      })
-    },
-    state: () => ({ calls, ended: () => ended })
-  };
-}
-
-function makeMockOracleDriver({ failOnQuery } = {}) {
-  const calls = [];
-  let closed = false;
-
-  return {
-    driver: {
-      getConnection: async (config) => ({
-        config,
-        execute: async (sql) => {
-          calls.push(sql);
-          if (failOnQuery && failOnQuery.match.test(sql)) {
-            throw new Error(failOnQuery.message);
-          }
-          return { rowsAffected: 1 };
-        },
-        close: async () => {
-          closed = true;
-        }
-      })
-    },
-    state: () => ({ calls, closed: () => closed })
-  };
-}
-
-function makeMockSqliteDriver({ failOnQuery } = {}) {
-  const calls = [];
-  let closed = false;
-
-  function MockDb(file) {
-    this.file = file;
-  }
-  MockDb.prototype.exec = function exec(sql) {
-    calls.push(sql);
-    if (failOnQuery && failOnQuery.match.test(sql)) {
-      throw new Error(failOnQuery.message);
-    }
-  };
-  MockDb.prototype.close = function close() {
-    closed = true;
-  };
-
-  return {
-    driver: MockDb,
-    state: () => ({ calls, closed: () => closed })
-  };
-}
-
-const PG_CONFIG = {
-  dialect: 'postgres',
-  host: 'localhost',
-  port: 5432,
-  database: 'test',
-  user: 'postgres',
-  password: 'secret'
-};
-
-const MYSQL_CONFIG = {
-  dialect: 'mysql',
-  host: 'localhost',
-  port: 3306,
-  database: 'test',
-  user: 'root',
-  password: 'secret'
-};
-
-const ORACLE_CONFIG = {
-  dialect: 'oracle',
-  host: 'localhost',
-  port: 1521,
-  serviceName: 'XEPDB1',
-  user: 'system',
-  password: 'secret'
-};
-
-const SQLITE_CONFIG = {
-  dialect: 'sqlite',
-  file: ':memory:'
-};
-
-test('apply-executor: dryRun=true return summary tanpa connect', async () => {
-  const mock = makeMockPgDriver();
-  const result = await applyStatements({
-    statements: ['CREATE TABLE a()', 'CREATE TABLE b()'],
-    dialect: 'postgres',
-    config: PG_CONFIG,
-    dryRun: true,
-    _driver: mock.driver
-  });
-
-  assert.strictEqual(result.status, 'DRY_RUN');
-  assert.strictEqual(result.applied, 2);
-  assert.strictEqual(result.failed, 0);
-  assert.strictEqual(typeof result.durationMs, 'number');
-  assert.strictEqual(mock.state().connected, false, 'driver tidak boleh dipakai saat dryRun');
-});
-
-test('apply-executor: PG happy path BEGIN → execute → COMMIT, status SUCCESS', async () => {
-  const mock = makeMockPgDriver();
-  const result = await applyStatements({
-    statements: ['CREATE TABLE a()', 'CREATE TABLE b()'],
-    dialect: 'postgres',
-    config: PG_CONFIG,
-    _driver: mock.driver
-  });
-
-  assert.strictEqual(result.status, 'SUCCESS');
-  assert.strictEqual(result.applied, 2);
-  assert.strictEqual(result.failed, 0);
-
-  const state = mock.state();
-  assert.strictEqual(state.connected, true);
-  assert.strictEqual(state.ended, true, 'connection harus ditutup di finally');
-  assert.deepStrictEqual(state.calls, [
-    'BEGIN',
-    'CREATE TABLE a()',
-    'CREATE TABLE b()',
-    'COMMIT'
-  ]);
-});
-
-test('apply-executor: PG error mid-way → ROLLBACK, throw error, status ROLLBACK', async () => {
-  const mock = makeMockPgDriver({
-    failOnQuery: { match: /CREATE TABLE b/, message: 'duplicate table b' }
-  });
-
-  let caught;
-  try {
-    await applyStatements({
-      statements: ['CREATE TABLE a()', 'CREATE TABLE b()', 'CREATE TABLE c()'],
-      dialect: 'postgres',
-      config: PG_CONFIG,
-      _driver: mock.driver
-    });
-  } catch (err) {
-    caught = err;
-  }
-
-  assert.ok(caught, 'harus throw error');
-  assert.strictEqual(caught.status, 'ROLLBACK');
-  assert.strictEqual(caught.applied, 1);
-  assert.strictEqual(caught.failed, 1);
-  assert.strictEqual(caught.failedIndex, 2);
-  assert.match(caught.message, /duplicate table b/);
-
-  const state = mock.state();
-  assert.ok(state.calls.includes('ROLLBACK'), 'ROLLBACK harus dipanggil');
-  assert.ok(!state.calls.includes('COMMIT'), 'COMMIT tidak boleh dipanggil');
-  assert.ok(!state.calls.includes('CREATE TABLE c()'), 'statement berikut harus skip');
-  assert.strictEqual(state.ended, true, 'connection tetap ditutup walau error');
-});
-
-test('apply-executor: SQLite happy path transaction wrap, status SUCCESS', async () => {
-  const mock = makeMockSqliteDriver();
-  const result = await applyStatements({
-    statements: ['CREATE TABLE a(id INT)', 'CREATE TABLE b(id INT)'],
-    dialect: 'sqlite',
-    config: SQLITE_CONFIG,
-    _driver: mock.driver
-  });
-
-  assert.strictEqual(result.status, 'SUCCESS');
-  assert.strictEqual(result.applied, 2);
-
-  const state = mock.state();
-  assert.deepStrictEqual(state.calls, [
-    'BEGIN',
-    'CREATE TABLE a(id INT)',
-    'CREATE TABLE b(id INT)',
-    'COMMIT'
-  ]);
-  assert.strictEqual(state.closed(), true);
-});
-
-test('apply-executor: SQLite error mid-way → ROLLBACK, throw, status ROLLBACK', async () => {
-  const mock = makeMockSqliteDriver({
-    failOnQuery: { match: /CREATE TABLE b/, message: 'sqlite syntax error' }
-  });
-
-  let caught;
-  try {
-    await applyStatements({
-      statements: ['CREATE TABLE a(id INT)', 'CREATE TABLE b(id INT)'],
-      dialect: 'sqlite',
-      config: SQLITE_CONFIG,
-      _driver: mock.driver
-    });
-  } catch (err) {
-    caught = err;
-  }
-
-  assert.ok(caught, 'harus throw');
-  assert.strictEqual(caught.status, 'ROLLBACK');
-  assert.strictEqual(caught.applied, 1);
-  assert.ok(mock.state().calls.includes('ROLLBACK'));
-  assert.strictEqual(mock.state().closed(), true);
-});
-
-test('apply-executor: MySQL happy path no transaction, sequential execute', async () => {
-  const mock = makeMockMysqlDriver();
-  const result = await applyStatements({
-    statements: ['CREATE TABLE a(id INT)', 'CREATE TABLE b(id INT)'],
-    dialect: 'mysql',
-    config: MYSQL_CONFIG,
-    _driver: mock.driver
-  });
-
-  assert.strictEqual(result.status, 'SUCCESS');
-  assert.strictEqual(result.applied, 2);
-
-  const state = mock.state();
-  assert.deepStrictEqual(state.calls, ['CREATE TABLE a(id INT)', 'CREATE TABLE b(id INT)']);
-  assert.ok(!state.calls.some((s) => /^BEGIN$|^COMMIT$/.test(s)),
-    'MySQL non-transactional: tidak ada BEGIN/COMMIT');
-  assert.strictEqual(state.ended(), true);
-});
-
-test('apply-executor: MySQL error mid-way → stop, return PARTIAL dengan applied count', async () => {
-  const mock = makeMockMysqlDriver({
-    failOnQuery: { match: /CREATE TABLE b/, message: 'Table already exists' }
-  });
-
-  const result = await applyStatements({
-    statements: ['CREATE TABLE a(id INT)', 'CREATE TABLE b(id INT)', 'CREATE TABLE c(id INT)'],
-    dialect: 'mysql',
-    config: MYSQL_CONFIG,
-    _driver: mock.driver
-  });
-
-  assert.strictEqual(result.status, 'PARTIAL');
-  assert.strictEqual(result.applied, 1);
-  assert.strictEqual(result.failed, 1);
-  assert.strictEqual(result.failedIndex, 2);
-  assert.match(result.error.message, /Table already exists/);
-
-  const state = mock.state();
-  assert.ok(!state.calls.includes('CREATE TABLE c(id INT)'),
-    'statement setelah error tidak boleh dieksekusi');
-  assert.strictEqual(state.ended(), true);
-});
-
-test('apply-executor: Oracle error mid-way → status PARTIAL (non-transactional)', async () => {
-  const mock = makeMockOracleDriver({
-    failOnQuery: { match: /CREATE TABLE b/, message: 'ORA-00955 name already used' }
-  });
-
-  const result = await applyStatements({
-    statements: ['CREATE TABLE a(id INT)', 'CREATE TABLE b(id INT)'],
-    dialect: 'oracle',
-    config: ORACLE_CONFIG,
-    _driver: mock.driver
-  });
-
-  assert.strictEqual(result.status, 'PARTIAL');
-  assert.strictEqual(result.applied, 1);
-  assert.strictEqual(mock.state().closed(), true);
-});
-
-test('apply-executor: onProgress callback dipanggil per statement (running → success)', async () => {
-  const mock = makeMockPgDriver();
-  const events = [];
-
-  await applyStatements({
-    statements: ['CREATE TABLE a()', 'CREATE TABLE b()'],
-    dialect: 'postgres',
-    config: PG_CONFIG,
-    onProgress: (evt) => events.push({ ...evt, error: undefined }),
-    _driver: mock.driver
-  });
-
-  // 2 statement × 2 event (running, success) = 4 event
-  assert.strictEqual(events.length, 4);
-  assert.deepStrictEqual(
-    events.map((e) => `${e.index}:${e.status}`),
-    ['1:running', '1:success', '2:running', '2:success']
-  );
-  assert.strictEqual(events[0].total, 2);
-  assert.strictEqual(events[0].statement, 'CREATE TABLE a()');
-});
-
-test('apply-executor: onProgress menerima event status:error saat statement gagal', async () => {
-  const mock = makeMockPgDriver({
-    failOnQuery: { match: /CREATE TABLE bad/, message: 'syntax error' }
-  });
-  const events = [];
-
-  try {
-    await applyStatements({
-      statements: ['CREATE TABLE bad()'],
-      dialect: 'postgres',
-      config: PG_CONFIG,
-      onProgress: (evt) => events.push(evt),
-      _driver: mock.driver
-    });
-  } catch (_err) {
-    // expected
-  }
-
-  const errorEvent = events.find((e) => e.status === 'error');
-  assert.ok(errorEvent, 'harus ada event status: error');
-  assert.match(errorEvent.error.message, /syntax error/);
-});
-
-test('apply-executor: connection.close selalu dipanggil walau error sebelum loop', async () => {
-  const mock = makeMockPgDriver({
-    failOnQuery: { match: /^BEGIN$/, message: 'cannot start transaction' }
-  });
-
-  try {
-    await applyStatements({
-      statements: ['CREATE TABLE a()'],
-      dialect: 'postgres',
-      config: PG_CONFIG,
-      _driver: mock.driver
-    });
-  } catch (_err) {
-    // expected
-  }
-
-  assert.strictEqual(mock.state().ended, true, 'finally harus tetap close connection');
-});
-
-test('apply-executor: throw bila statements bukan array atau kosong', async () => {
-  await assert.rejects(
-    () => applyStatements({
-      statements: [],
-      dialect: 'postgres',
-      config: PG_CONFIG
-    }),
-    /statements must be a non-empty array/
-  );
-  await assert.rejects(
-    () => applyStatements({
-      statements: 'CREATE TABLE a()',
-      dialect: 'postgres',
-      config: PG_CONFIG
-    }),
-    /statements must be a non-empty array/
-  );
-});
-
-test('apply-executor: throw bila dialect invalid', async () => {
-  await assert.rejects(
-    () => applyStatements({
-      statements: ['CREATE TABLE a()'],
-      dialect: 'mssql',
-      config: PG_CONFIG
-    }),
-    /invalid dialect 'mssql'/
-  );
-});
-
-test('apply-executor: throw bila config tidak ada', async () => {
-  await assert.rejects(
-    () => applyStatements({
-      statements: ['CREATE TABLE a()'],
-      dialect: 'postgres'
-    }),
-    /config object is required/
-  );
-});
-
-test('apply-executor: progress callback yang throw tidak menggagalkan migration', async () => {
-  const mock = makeMockPgDriver();
-  const result = await applyStatements({
-    statements: ['CREATE TABLE a()'],
-    dialect: 'postgres',
-    config: PG_CONFIG,
-    onProgress: () => {
-      throw new Error('reporter bug');
-    },
-    _driver: mock.driver
-  });
-
-  assert.strictEqual(result.status, 'SUCCESS');
-  assert.strictEqual(result.applied, 1);
-});