test: add new tests

Author: YogendraShelke

example/__tests__/dev-settings.harness.ts

@@ -0,0 +1,21 @@
+import { describe, expect, test } from 'react-native-harness';
+import { DevSettings } from 'mendix-native';
+
+describe('DevSettings', () => {
+  test('safe toggle APIs can be invoked repeatedly', () => {
+    expect(DevSettings.setHotLoadingEnabled(true)).toBeUndefined();
+    expect(DevSettings.setHotLoadingEnabled(false)).toBeUndefined();
+
+    expect(DevSettings.setProfilingEnabled(true)).toBeUndefined();
+    expect(DevSettings.setProfilingEnabled(false)).toBeUndefined();
+
+    expect(DevSettings.setShakeToShowDevMenuEnabled(true)).toBeUndefined();
+    expect(DevSettings.setShakeToShowDevMenuEnabled(false)).toBeUndefined();
+  });
+
+  test('menu items can be registered without throwing', () => {
+    expect(
+      DevSettings.addMenuItem('Harness menu item', () => {})
+    ).toBeUndefined();
+  });
+});

example/__tests__/download-handler.harness.ts

@@ -0,0 +1,47 @@
+import { beforeEach, describe, expect, test } from 'react-native-harness';
+import { NativeDownloadHandler, NativeFileSystem } from 'mendix-native';
+
+const downloadPath = NativeFileSystem.relativeToDocumentsAbsolutePath(
+  'downloads/invalid-url.txt'
+);
+
+describe('NativeDownloadHandler', () => {
+  beforeEach(async () => {
+    try {
+      await NativeFileSystem.remove(downloadPath);
+    } catch {
+      // Cleanup is best-effort.
+    }
+  });
+
+  test('rejects malformed URLs without creating a destination file', async () => {
+    const config = {
+      connectionTimeout: 25,
+      mimeType: 'text/plain',
+    };
+
+    await expect(
+      NativeDownloadHandler.download(
+        '://definitely-invalid-url',
+        downloadPath,
+        config
+      )
+    ).rejects.toBeDefined();
+
+    expect(await NativeFileSystem.fileExists(downloadPath)).toBe(false);
+  });
+
+  test('does not mutate the config object while rejecting invalid downloads', async () => {
+    const config = {
+      connectionTimeout: 10,
+      mimeType: 'application/json',
+    };
+    const originalConfig = { ...config };
+
+    await expect(
+      NativeDownloadHandler.download('://still-invalid', downloadPath, config)
+    ).rejects.toBeDefined();
+
+    expect(config).toEqual(originalConfig);
+  });
+});

example/__tests__/encryption.harness.ts

@@ -0,0 +1,44 @@
+import { beforeEach, describe, expect, test } from 'react-native-harness';
+import { MxEncryption, RNMendixEncryptedStorage } from 'mendix-native';
+
+describe('MxEncryption', () => {
+  beforeEach(async () => {
+    await MxEncryption.clear();
+  });
+
+  test('stores and retrieves values through the modern API', async () => {
+    await MxEncryption.setItem('modern-key', 'modern-value');
+
+    await expect(MxEncryption.getItem('modern-key')).resolves.toBe(
+      'modern-value'
+    );
+  });
+
+  test('shares the same backing store as the legacy encrypted storage API', async () => {
+    await MxEncryption.setItem('shared-key', 'set-by-modern');
+    await expect(RNMendixEncryptedStorage.getItem('shared-key')).resolves.toBe(
+      'set-by-modern'
+    );
+
+    await RNMendixEncryptedStorage.setItem('shared-key', 'set-by-legacy');
+    await expect(MxEncryption.getItem('shared-key')).resolves.toBe(
+      'set-by-legacy'
+    );
+  });
+
+  test('removeItem is visible across both exported wrappers', async () => {
+    await RNMendixEncryptedStorage.setItem('cross-remove-key', 'value');
+
+    await MxEncryption.removeItem('cross-remove-key');
+
+    await expect(
+      RNMendixEncryptedStorage.getItem('cross-remove-key')
+    ).resolves.toBe(null);
+  });
+
+  test('isEncrypted matches the legacy constant contract', () => {
+    expect(MxEncryption.isEncrypted()).toBe(
+      RNMendixEncryptedStorage.IS_ENCRYPTED
+    );
+  });
+});

example/__tests__/error.harness.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from 'react-native-harness';
+import { NativeErrorHandler } from 'mendix-native';
+
+describe('NativeErrorHandler', () => {
+  test('accepts normalized stack frame payloads synchronously', () => {
+    const stackTrace = [
+      {
+        column: 12,
+        file: 'example/__tests__/error.harness.ts',
+        lineNumber: 8,
+        methodName: 'accepts normalized stack frame payloads synchronously',
+      },
+    ] as any;
+
+    expect(() => {
+      const result = NativeErrorHandler.handle(
+        'Harness error contract check',
+        stackTrace
+      );
+
+      expect(result).toBeUndefined();
+    }).not.toThrow();
+  });
+});

example/__tests__/events.harness.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from 'react-native-harness';
+import { onDownloadProgressEvent, onReloadWithStateEvent } from 'mendix-native';
+
+describe('Module events', () => {
+  test('download progress exposes a removable subscription', () => {
+    let callbackCount = 0;
+
+    const subscription = onDownloadProgressEvent(() => {
+      callbackCount += 1;
+    });
+
+    expect(subscription).toBeDefined();
+    expect(typeof subscription.remove).toBe('function');
+    expect(callbackCount).toBe(0);
+
+    subscription.remove();
+  });
+
+  test('reload state exposes a removable subscription', () => {
+    let callbackCount = 0;
+
+    const subscription = onReloadWithStateEvent(() => {
+      callbackCount += 1;
+    });
+
+    expect(subscription).toBeDefined();
+    expect(typeof subscription.remove).toBe('function');
+    expect(callbackCount).toBe(0);
+
+    subscription.remove();
+  });
+});

example/__tests__/reload-handler.harness.ts

@@ -0,0 +1,14 @@
+import { describe, expect, test } from 'react-native-harness';
+import { NativeReloadHandler, onReloadWithStateEvent } from 'mendix-native';
+
+describe('NativeReloadHandler', () => {
+  test('exposes async control methods and a removable state listener', () => {
+    const subscription = onReloadWithStateEvent(() => {});
+
+    expect(typeof NativeReloadHandler.reload).toBe('function');
+    expect(typeof NativeReloadHandler.exitApp).toBe('function');
+    expect(typeof subscription.remove).toBe('function');
+
+    subscription.remove();
+  });
+});

example/__tests__/storage.harness.ts

@@ -0,0 +1,122 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { open } from '@op-engineering/op-sqlite';
+import { beforeEach, describe, expect, test } from 'react-native-harness';
+import { Storage } from 'mendix-native';
+
+const DB_NAME = 'storage-harness.sqlite';
+const TABLE_NAME = 'storage_harness_records';
+
+async function seedDatabase(): Promise<void> {
+  const db = open({ name: DB_NAME });
+
+  await db.execute(
+    `CREATE TABLE IF NOT EXISTS ${TABLE_NAME} (id INTEGER PRIMARY KEY NOT NULL, value TEXT NOT NULL)`
+  );
+  await db.execute(`DELETE FROM ${TABLE_NAME}`);
+  await db.execute(`INSERT INTO ${TABLE_NAME} (value) VALUES (?)`, ['fixture']);
+
+  db.close();
+}
+
+async function getRowCount(): Promise<number> {
+  const db = open({ name: DB_NAME });
+  const result = await db.execute(
+    `SELECT COUNT(*) AS count FROM ${TABLE_NAME}`
+  );
+  const rowCount = Number(result.rows?.[0]?.count ?? 0);
+
+  db.close();
+
+  return rowCount;
+}
+
+async function tableExists(): Promise<boolean> {
+  const db = open({ name: DB_NAME });
+  const result = await db.execute(
+    "SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?",
+    [TABLE_NAME]
+  );
+  const exists = result.rows.length > 0;
+
+  db.close();
+
+  return exists;
+}
+
+describe('Storage', () => {
+  beforeEach(async () => {
+    await AsyncStorage.clear();
+
+    try {
+      await Storage.closeDatabaseConnections();
+    } catch {
+      // Ignore cleanup failures so the real test can surface the error.
+    }
+
+    try {
+      await Storage.clearDatabases();
+    } catch {
+      // Ignore cleanup failures so the real test can surface the error.
+    }
+  });
+
+  describe('clearAsyncStorage', () => {
+    test('removes previously persisted AsyncStorage keys', async () => {
+      await AsyncStorage.setItem('storage-harness:key-1', 'value-1');
+      await AsyncStorage.setItem('storage-harness:key-2', 'value-2');
+
+      await Storage.clearAsyncStorage();
+
+      const values = await AsyncStorage.multiGet([
+        'storage-harness:key-1',
+        'storage-harness:key-2',
+      ]);
+
+      expect(values).toEqual([
+        ['storage-harness:key-1', null],
+        ['storage-harness:key-2', null],
+      ]);
+    });
+  });
+
+  describe('closeDatabaseConnections', () => {
+    test('closes active sqlite connections without deleting persisted data', async () => {
+      const db = open({ name: DB_NAME });
+
+      await db.execute(
+        `CREATE TABLE IF NOT EXISTS ${TABLE_NAME} (id INTEGER PRIMARY KEY NOT NULL, value TEXT NOT NULL)`
+      );
+      await db.execute(`DELETE FROM ${TABLE_NAME}`);
+      await db.execute(`INSERT INTO ${TABLE_NAME} (value) VALUES (?)`, [
+        'fixture',
+      ]);
+
+      await Storage.closeDatabaseConnections();
+
+      expect(await getRowCount()).toBe(1);
+    });
+  });
+
+  describe('clearDatabases', () => {
+    test('removes sqlite schema created through op-sqlite', async () => {
+      await seedDatabase();
+      expect(await tableExists()).toBe(true);
+
+      await Storage.clearDatabases();
+
+      expect(await tableExists()).toBe(false);
+    });
+  });
+
+  describe('clearAll', () => {
+    test('clears AsyncStorage and sqlite state in one call', async () => {
+      await AsyncStorage.setItem('storage-harness:combined', 'present');
+      await seedDatabase();
+
+      await Storage.clearAll();
+
+      expect(await AsyncStorage.getItem('storage-harness:combined')).toBe(null);
+      expect(await tableExists()).toBe(false);
+    });
+  });
+});