@neuralinnovations/dataisland-sdk 0.0.1-dev3 → 0.0.1-dev5

package/test/organization.test.ts

@@ -0,0 +1,57 @@
+import { dataIslandApp, DebugCredential } from "../src"
+import { HOST, randomHash, TOKEN } from "./setup"
+import { OrganizationImpl } from "../src/storages/organization.impl"
+
+test("Organization", async () => {
+  // make random name
+  const randomName = `org-test-${randomHash()}`
+
+  // create app
+  const app = await dataIslandApp(randomName, async builder => {
+    builder.useHost(HOST)
+    builder.useCredential(new DebugCredential(TOKEN))
+  })
+
+  // save init length
+  const initLength = app.organizations.collection.length
+
+  // create organization
+  const org = await app.organizations.create(
+    randomName,
+    "this is a unitTest description"
+  )
+
+  // check organization
+  expect(org).not.toBeUndefined()
+  expect(org).not.toBeNull()
+  expect(org).toBeInstanceOf(OrganizationImpl)
+
+  expect(org.id).not.toBeUndefined()
+  expect(org.id).not.toBeNull()
+  expect(org.id.trim()).not.toBe("")
+
+  // check name
+  expect(org.name).not.toBeUndefined()
+  expect(org.name).not.toBeNull()
+  expect(org.name.trim()).not.toBe("")
+
+  // check description
+  expect(org.description).not.toBeUndefined()
+  expect(org.description).not.toBeNull()
+  expect(org.description.trim()).not.toBe("")
+
+  // check organizations
+  expect(app.organizations.get(org.id)).toBe(org)
+  expect(app.organizations.tryGet(org.id)).toBe(org)
+  expect(app.organizations.collection.length).toBe(initLength + 1)
+
+  // delete organization
+  await expect(app.organizations.delete(org.id)).resolves.not.toThrow()
+  expect((<OrganizationImpl>org).isDisposed).toBe(true)
+
+  // check init length
+  expect(app.organizations.collection.length).toBe(initLength)
+
+  // check organization must be undefined because it was deleted
+  expect(app.organizations.tryGet(org.id)).toBeUndefined()
+})

package/test/services.test.ts

@@ -1,11 +1,11 @@
-import { appSdk, BasicCredential, DefaultCredential } from "../src"
+import { dataIslandApp, BasicCredential, DefaultCredential } from "../src"
 import { CredentialService } from "../src/services/credentialService"
 import { MiddlewareService } from "../src/services/middlewareService"
-import { UnitTest, AppSdkUnitTest } from "../src/unitTest"
+import { UnitTest, appTest } from "../src/unitTest"
 
 test("CredentialService", async () => {
-  await AppSdkUnitTest.test(UnitTest.DEFAULT, async () => {
-    const app = await appSdk("test-services", async builder => {
+  await appTest(UnitTest.DEFAULT, async () => {
+    const app = await dataIslandApp("test-services", async builder => {
       builder.env.unitTest = UnitTest.DO_NOT_START
     })
     const credentialService = app.resolve(CredentialService)

package/test/setup.ts

@@ -1,2 +1,54 @@
+import { dataIslandApp, DataIslandApp, DebugCredential } from "../src"
+import { Organization } from "../src"
+import { Workspace } from "../src"
+
 export const HOST = <string>process.env.HOST
 export const TOKEN = <string>process.env.TOKEN
+
+export const randomHash = (length: number = 5) => {
+  if (length <= 0) length = 1
+  return `name-${((Math.random() * Math.pow(10, length)) | 0).toString(16)}`
+}
+
+export const testInOrganization = async (func: (app: DataIslandApp, org: Organization) => Promise<void>, config ?: {
+    host: string,
+    token: string
+  }
+): Promise<void> => {
+  const randomName = `org-name-${randomHash()}`
+  const app = await dataIslandApp(randomName, async builder => {
+    builder.useHost(config?.host ?? HOST)
+    builder.useCredential(new DebugCredential(config?.token ?? TOKEN))
+  })
+  const org = await app.organizations.create(
+    randomName,
+    "this is a unitTest description"
+  )
+  try {
+    await func(app, org)
+  } finally {
+    if (app
+      .organizations.tryGet(org.id)
+    ) {
+      await app.organizations.delete(org.id)
+    }
+  }
+}
+
+export const testInWorkspace = async (func: (app: DataIslandApp, org: Organization, workspace: Workspace)
+  => Promise<void>, config?: {
+  host: string,
+  token: string,
+}): Promise<void> => {
+  await testInOrganization(async (app, org) => {
+    const randomName = `workspace-${randomHash()}`
+    const workspace = await org.workspaces.create(randomName, `description of ${randomName}`)
+    try {
+      await func(app, org, workspace)
+    } finally {
+      if (org.workspaces.tryGet(workspace.id)) {
+        await org.workspaces.delete(workspace.id)
+      }
+    }
+  }, config)
+}

package/test/unitTest.test.ts

@@ -1,21 +1,21 @@
-import { AppSdkUnitTest, UnitTest } from "../src/unitTest"
+import { appTest, appTestCurrent, UnitTest } from "../src/unitTest"
 
 test("SDK, unitTest", async () => {
-  expect(AppSdkUnitTest.current).toBe(UnitTest.DO_NOTHING)
+  expect(appTestCurrent()).toBe(UnitTest.DO_NOTHING)
   expect(
-    await AppSdkUnitTest.test(UnitTest.DO_NOT_PRINT_INITIALIZED_LOG, () => {
-      expect(AppSdkUnitTest.current).toBe(UnitTest.DO_NOT_PRINT_INITIALIZED_LOG)
+    await appTest(UnitTest.DO_NOT_PRINT_INITIALIZED_LOG, () => {
+      expect(appTestCurrent()).toBe(UnitTest.DO_NOT_PRINT_INITIALIZED_LOG)
     })
   )
   expect(
-    await AppSdkUnitTest.test(
+    await appTest(
       UnitTest.DO_NOT_PRINT_INITIALIZED_LOG,
       async () => {
-        expect(AppSdkUnitTest.current).toBe(
+        expect(appTestCurrent()).toBe(
           UnitTest.DO_NOT_PRINT_INITIALIZED_LOG
         )
       }
     )
   )
-  expect(AppSdkUnitTest.current).toBe(UnitTest.DO_NOTHING)
+  expect(appTestCurrent()).toBe(UnitTest.DO_NOTHING)
 })

package/test/workspace.test.ts

@@ -0,0 +1,71 @@
+import { testInOrganization, testInWorkspace } from "./setup"
+
+test("Workspace create / delete", async () => {
+  await testInOrganization(async (app, org) => {
+    // save init length
+    const initWorkspaceCount = org.workspaces.collection.length
+
+    // create workspace
+    const wsPromise = org.workspaces.create(
+      "test-workspace",
+      "test-workspace-description"
+    )
+
+    // check not throw
+    await expect(wsPromise).resolves.not.toThrow()
+
+    // get workspace
+    const ws = await wsPromise
+
+    // check exists
+    expect(ws).not.toBeUndefined()
+
+    // check exists
+    expect(ws).not.toBeNull()
+
+    // check name
+    expect(ws.name).toBe("test-workspace")
+
+    // check description
+    expect(ws.description).toBe("test-workspace-description")
+
+    // check collection length
+    expect(app.organizations.get(org.id).workspaces.collection.length).toBe(
+      initWorkspaceCount + 1
+    )
+
+    // check collection length
+    expect(org.workspaces.collection.length).toBe(initWorkspaceCount + 1)
+
+    // check get
+    expect(org.workspaces.get(ws.id)).toBe(ws)
+
+    // check tryGet
+    expect(org.workspaces.tryGet(ws.id)).toBe(ws)
+
+    // check contains
+    expect(org.workspaces.contains(ws.id)).toBe(true)
+
+    // check delete
+    await expect(org.workspaces.delete(ws.id)).resolves.not.toThrow()
+  })
+})
+
+test("Workspace, change", async () => {
+  await testInWorkspace(async (app, org, ws) => {
+
+    expect(ws.name).not.toBe("new-name")
+
+    // rename
+    await ws.change("new-name", "new-description")
+
+    // check name
+    expect(ws.name).toBe("new-name")
+
+    // check description
+    expect(ws.description).toBe("new-description")
+
+    // check name
+    expect(ws.name).toBe("new-name")
+  })
+})