refactor: dummy and fyo tests use tape

dummy/tests/testDummy.spec.ts

@@ -1,49 +1,27 @@
-import * as assert from 'assert';
-import { DatabaseManager } from 'backend/database/manager';
 import { assertDoesNotThrow } from 'backend/database/tests/helpers';
 import { purchaseItemPartyMap } from 'dummy/helpers';
-import { Fyo } from 'fyo';
-import { DummyAuthDemux } from 'fyo/tests/helpers';
-import 'mocha';
-import { getTestDbPath } from 'tests/helpers';
+import test from 'tape';
+import { getTestDbPath, getTestFyo } from 'tests/helpers';
 import { setupDummyInstance } from '..';
 
-describe('dummy', function () {
 const dbPath = getTestDbPath();
+const fyo = getTestFyo();
 
-  let fyo: Fyo;
-
-  this.beforeAll(function () {
-    fyo = new Fyo({
-      DatabaseDemux: DatabaseManager,
-      AuthDemux: DummyAuthDemux,
-      isTest: true,
-      isElectron: false,
-    });
-  });
-
-  this.afterAll(async function () {
-    await fyo.close();
-  });
-
-  specify('setupDummyInstance', async function () {
+test('setupDummyInstance', async () => {
   await assertDoesNotThrow(async () => {
     await setupDummyInstance(dbPath, fyo, 1, 25);
   }, 'setup instance failed');
+});
 
+test('purchaseItemParty Existance', async (t) => {
   for (const item in purchaseItemPartyMap) {
-      assert.strictEqual(
-        await fyo.db.exists('Item', item),
-        true,
-        `not found ${item}`
-      );
+    t.ok(await fyo.db.exists('Item', item), `item exists: ${item}`);
 
     const party = purchaseItemPartyMap[item];
-      assert.strictEqual(
-        await fyo.db.exists('Party', party),
-        true,
-        `not found ${party}`
-      );
+    t.ok(await fyo.db.exists('Party', party), `party exists: ${party}`);
   }
-  }).timeout(120_000);
+});
+
+test.onFinish(async () => {
+  await fyo.close();
 });

fyo/tests/testFyo.spec.ts

@@ -1,64 +1,27 @@
-import * as assert from 'assert';
-import 'mocha';
 import { getRegionalModels, models } from 'models';
 import { getSchemas } from 'schemas';
-import { Fyo } from '..';
-import { DatabaseManager } from '../../backend/database/manager';
-import { DummyAuthDemux } from './helpers';
+import test from 'tape';
+import { getTestFyo } from 'tests/helpers';
 
-describe('Fyo Init', function () {
-  const fyo = new Fyo({
-    DatabaseDemux: DatabaseManager,
-    AuthDemux: DummyAuthDemux,
-    isTest: true,
-    isElectron: false,
-  });
-
-  specify('Init', async function () {
-    assert.strictEqual(
-      Object.keys(fyo.schemaMap).length,
-      0,
-      'zero schemas one'
-    );
-
-    assert.strictEqual(
-      Object.keys(fyo.schemaMap).length,
-      0,
-      'zero schemas two'
-    );
+test('Fyo Init', async (t) => {
+  const fyo = getTestFyo();
+  t.equal(Object.keys(fyo.schemaMap).length, 0, 'zero schemas');
 
   await fyo.db.createNewDatabase(':memory:', 'in');
   await fyo.initializeAndRegister({}, {});
-    assert.strictEqual(
-      Object.keys(fyo.schemaMap).length > 0,
-      true,
-      'non zero schemas'
-    );
-    await fyo.db.purgeCache();
-  });
-});
 
-describe('Fyo Docs', function () {
-  const countryCode = 'in';
-  let fyo: Fyo;
-  const schemaMap = getSchemas(countryCode);
-  this.beforeEach(async function () {
-    fyo = new Fyo({
-      DatabaseDemux: DatabaseManager,
-      isTest: true,
-      isElectron: false,
-    });
-
-    const regionalModels = await getRegionalModels(countryCode);
-    await fyo.db.createNewDatabase(':memory:', countryCode);
-    await fyo.initializeAndRegister(models, regionalModels);
-  });
-
-  this.afterEach(async function () {
+  t.equal(Object.keys(fyo.schemaMap).length > 0, true, 'non zero schemas');
   await fyo.close();
 });
 
-  specify('getNewDoc', async function () {
+test('Fyo Docs', async (t) => {
+  const countryCode = 'in';
+  const fyo = getTestFyo();
+  const schemaMap = getSchemas(countryCode);
+  const regionalModels = await getRegionalModels(countryCode);
+  await fyo.db.createNewDatabase(':memory:', countryCode);
+  await fyo.initializeAndRegister(models, regionalModels);
+
   for (const schemaName in schemaMap) {
     const schema = schemaMap[schemaName];
     if (schema?.isSingle) {
@@ -66,6 +29,8 @@ describe('Fyo Docs', function () {
     }
 
     const doc = fyo.doc.getNewDoc(schemaName);
+    t.equal(doc.schemaName, schemaName, `equal schemaNames: ${schemaName}`);
   }
-  });
+
+  await fyo.close();
 });

fyo/tests/testObservable.spec.ts

@@ -1,26 +1,25 @@
-import * as assert from 'assert';
+import { strictEqual } from 'assert';
 import Observable from 'fyo/utils/observable';
-import 'mocha';
+import test from 'tape';
 
 enum ObsEvent {
   A = 'event-a',
   B = 'event-b',
 }
 
-describe('Observable', function () {
 const obs = new Observable();
 let counter = 0;
 const params = { aOne: 18, aTwo: 21, b: 42 };
 
 const listenerAOnce = (value: number) => {
-    assert.strictEqual(params.aOne, value, 'listenerAOnce');
+  strictEqual(params.aOne, value, 'listenerAOnce');
 };
 
 const listenerAEvery = (value: number) => {
   if (counter === 0) {
-      assert.strictEqual(params.aOne, value, 'listenerAEvery 0');
+    strictEqual(params.aOne, value, 'listenerAEvery 0');
   } else if (counter === 1) {
-      assert.strictEqual(params.aTwo, value, 'listenerAEvery 1');
+    strictEqual(params.aTwo, value, 'listenerAEvery 1');
   } else {
     throw new Error("this shouldn't run");
   }
@@ -28,104 +27,58 @@ describe('Observable', function () {
 };
 
 const listenerBOnce = (value: number) => {
-    assert.strictEqual(params.b, value, 'listenerBOnce');
+  strictEqual(params.b, value, 'listenerBOnce');
 };
 
-  specify('set A One', function () {
-    assert.strictEqual(obs.hasListener(ObsEvent.A), false, 'pre');
+test('set A One', function (t) {
+  t.equal(obs.hasListener(ObsEvent.A), false, 'pre');
 
   obs.once(ObsEvent.A, listenerAOnce);
-    assert.strictEqual(obs.hasListener(ObsEvent.A), true, 'non specific');
-    assert.strictEqual(
-      obs.hasListener(ObsEvent.A, listenerAOnce),
-      true,
-      'specific once'
-    );
-    assert.strictEqual(
-      obs.hasListener(ObsEvent.A, listenerAEvery),
-      false,
-      'specific every'
-    );
+  t.equal(obs.hasListener(ObsEvent.A), true, 'non specific');
+  t.equal(obs.hasListener(ObsEvent.A, listenerAOnce), true, 'specific once');
+  t.equal(obs.hasListener(ObsEvent.A, listenerAEvery), false, 'specific every');
+  t.end()
 });
 
-  specify('set A Two', function () {
+test('set A Two', function (t) {
   obs.on(ObsEvent.A, listenerAEvery);
-    assert.strictEqual(obs.hasListener(ObsEvent.A), true, 'non specific');
-    assert.strictEqual(
-      obs.hasListener(ObsEvent.A, listenerAOnce),
-      true,
-      'specific once'
-    );
-    assert.strictEqual(
-      obs.hasListener(ObsEvent.A, listenerAEvery),
-      true,
-      'specific every'
-    );
+  t.equal(obs.hasListener(ObsEvent.A), true, 'non specific');
+  t.equal(obs.hasListener(ObsEvent.A, listenerAOnce), true, 'specific once');
+  t.equal(obs.hasListener(ObsEvent.A, listenerAEvery), true, 'specific every');
+  t.end()
 });
 
-  specify('set B', function () {
-    assert.strictEqual(obs.hasListener(ObsEvent.B), false, 'pre');
+test('set B', function (t) {
+  t.equal(obs.hasListener(ObsEvent.B), false, 'pre');
 
   obs.once(ObsEvent.B, listenerBOnce);
-    assert.strictEqual(
-      obs.hasListener(ObsEvent.A, listenerBOnce),
-      false,
-      'specific false'
-    );
-    assert.strictEqual(
-      obs.hasListener(ObsEvent.B, listenerBOnce),
-      true,
-      'specific true'
-    );
+  t.equal(obs.hasListener(ObsEvent.A, listenerBOnce), false, 'specific false');
+  t.equal(obs.hasListener(ObsEvent.B, listenerBOnce), true, 'specific true');
+  t.end()
 });
 
-  specify('trigger A 0', async function () {
+test('trigger A 0', async function (t) {
   await obs.trigger(ObsEvent.A, params.aOne);
-    assert.strictEqual(obs.hasListener(ObsEvent.A), true, 'non specific');
-    assert.strictEqual(
-      obs.hasListener(ObsEvent.A, listenerAOnce),
-      false,
-      'specific'
-    );
+  t.equal(obs.hasListener(ObsEvent.A), true, 'non specific');
+  t.equal(obs.hasListener(ObsEvent.A, listenerAOnce), false, 'specific');
 });
 
-  specify('trigger A 1', async function () {
-    assert.strictEqual(
-      obs.hasListener(ObsEvent.A, listenerAEvery),
-      true,
-      'specific pre'
-    );
+test('trigger A 1', async function (t) {
+  t.equal(obs.hasListener(ObsEvent.A, listenerAEvery), true, 'specific pre');
   await obs.trigger(ObsEvent.A, params.aTwo);
-    assert.strictEqual(
-      obs.hasListener(ObsEvent.A, listenerAEvery),
-      true,
-      'specific post'
-    );
+  t.equal(obs.hasListener(ObsEvent.A, listenerAEvery), true, 'specific post');
 });
 
-  specify('trigger B', async function () {
-    assert.strictEqual(
-      obs.hasListener(ObsEvent.B, listenerBOnce),
-      true,
-      'specific pre'
-    );
+test('trigger B', async function (t) {
+  t.equal(obs.hasListener(ObsEvent.B, listenerBOnce), true, 'specific pre');
   await obs.trigger(ObsEvent.B, params.b);
-    assert.strictEqual(
-      obs.hasListener(ObsEvent.B, listenerBOnce),
-      false,
-      'specific post'
-    );
+  t.equal(obs.hasListener(ObsEvent.B, listenerBOnce), false, 'specific post');
 });
 
-  specify('remove A', async function () {
+test('remove A', async function (t) {
   obs.off(ObsEvent.A, listenerAEvery);
-    assert.strictEqual(
-      obs.hasListener(ObsEvent.A, listenerAEvery),
-      false,
-      'specific pre'
-    );
+  t.equal(obs.hasListener(ObsEvent.A, listenerAEvery), false, 'specific pre');
 
-    assert.strictEqual(counter, 2, 'incorrect counter');
+  t.equal(counter, 2, 'incorrect counter');
   await obs.trigger(ObsEvent.A, 777);
 });
-});

tests/testSetupInstance.spec.ts

@@ -1,40 +1,25 @@
-import * as assert from 'assert';
-import { DatabaseManager } from 'backend/database/manager';
 import { assertDoesNotThrow } from 'backend/database/tests/helpers';
-import { Fyo } from 'fyo';
-import { DummyAuthDemux } from 'fyo/tests/helpers';
-import 'mocha';
 import setupInstance from 'src/setup/setupInstance';
 import { SetupWizardOptions } from 'src/setup/types';
+import test from 'tape';
 import { getValueMapFromList } from 'utils';
-import { getTestDbPath, getTestSetupWizardOptions } from './helpers';
+import {
+  getTestDbPath,
+  getTestFyo,
+  getTestSetupWizardOptions
+} from './helpers';
 
-describe('setupInstance', function () {
 const dbPath = getTestDbPath();
 const setupOptions = getTestSetupWizardOptions();
+const fyo = getTestFyo();
 
-  let fyo: Fyo;
-
-  this.beforeAll(function () {
-    fyo = new Fyo({
-      DatabaseDemux: DatabaseManager,
-      AuthDemux: DummyAuthDemux,
-      isTest: true,
-      isElectron: false,
-    });
-  });
-
-  this.afterAll(async function () {
-    await fyo.close();
-  });
-
-  specify('setupInstance', async function () {
+test('setupInstance', async () => {
   await assertDoesNotThrow(async () => {
     await setupInstance(dbPath, setupOptions, fyo);
   }, 'setup instance failed');
 });
 
-  specify('check setup Singles', async function () {
+test('check setup Singles', async (t) => {
   const setupFields = [
     'companyName',
     'country',
@@ -57,22 +42,25 @@ describe('setupInstance', function () {
       dbValue = dbValue.toISOString().split('T')[0];
     }
 
-      assert.strictEqual(
+    t.equal(
       dbValue as string,
       optionsValue,
-        `${field} mismatch (${dbValue},${optionsValue})`
+      `${field}: (${dbValue}, ${optionsValue})`
     );
   }
 });
 
-  specify('check null singles', async function () {
+test('check null singles', async (t) => {
   const nullFields = ['gstin', 'logo', 'phone', 'address'];
   const nullSingles = await fyo.db.getSingleValues(...nullFields);
 
-    assert.strictEqual(
+  t.equal(
     nullSingles.length,
     0,
-      `null singles found ${JSON.stringify(nullSingles)}`
+    `null singles: ${JSON.stringify(nullSingles)}`
   );
 });
+
+test.onFinish(async () => {
+  await fyo.close();
 });