@icure/api 7.1.6 → 7.1.7

package/test/icc-x-api/icc-time-table-x-api.ts

@@ -1,113 +0,0 @@
-import 'isomorphic-fetch'
-
-import { before } from 'mocha'
-import { getEnvironmentInitializer, hcp1Username, hcp2Username, setLocalStorage, TestUtils } from '../utils/test_utils'
-import { IccTimeTableXApi } from '../../icc-x-api'
-import initApi = TestUtils.initApi
-import { User } from '../../icc-api/model/User'
-import { randomUUID } from 'crypto'
-import { TimeTable } from '../../icc-api/model/TimeTable'
-import { Code } from '../../icc-api/model/Code'
-import { TimeTableItem } from '../../icc-api/model/TimeTableItem'
-import { TimeTableHour } from '../../icc-api/model/TimeTableHour'
-import { expect } from 'chai'
-import { getEnvVariables, TestVars } from '@icure/test-setup/types'
-import { PropertyStub } from '../../icc-api/model/PropertyStub'
-import { PropertyTypeStub } from '../../icc-api/model/PropertyTypeStub'
-import { TypedValueObject } from '../../icc-api/model/TypedValueObject'
-
-setLocalStorage(fetch)
-let env: TestVars
-
-async function instanceTimeTableFor(timeTableApi: IccTimeTableXApi, user: User): Promise<TimeTable> {
-  return timeTableApi.newInstance(
-    user,
-    new TimeTable({
-      id: randomUUID(),
-      tags: [
-        new Code({
-          id: 'ICURE|MY-CODE|1',
-          code: 'MY-CODE',
-          type: 'ICURE',
-          version: '1',
-        }),
-      ],
-      name: 'Main TimeTable',
-      startTime: 20221101000,
-      endTime: 20221128000,
-      items: [
-        new TimeTableItem({
-          id: randomUUID(),
-          rrule: 'RRULE:FREQ=WEEKLY;BYDAY=TU;COUNT=10',
-          days: ['monday', 'tuesday', 'thursday'],
-          hours: [
-            new TimeTableHour({
-              startHour: 1000,
-              endHour: 1800,
-            }),
-          ],
-        }),
-      ],
-    })
-  )
-}
-
-describe('icc-x-time-table-api Tests', () => {
-  before(async function () {
-    this.timeout(600000)
-    const initializer = await getEnvironmentInitializer()
-    env = await initializer.execute(getEnvVariables())
-  })
-
-  it('Create TimeTable Success', async () => {
-    // Given
-    const { userApi: userApiForHcp, timetableApi: timeTableApiForHcp } = await initApi(env, hcp1Username)
-
-    const hcpUser = await userApiForHcp.getCurrentUser()
-
-    const baseTimeTable = await instanceTimeTableFor(timeTableApiForHcp, hcpUser)
-    expect(Object.keys(baseTimeTable.delegations!).length).to.equals(1)
-    // TODO old test, now we want to always create encryption keys on all entities, right?
-    // expect(baseTimeTable.encryptionKeys).to.be.undefined
-
-    // When
-    const createdTimeTable = await timeTableApiForHcp.createTimeTable(baseTimeTable)
-
-    // Then
-    expect(createdTimeTable.id).to.equals(baseTimeTable.id)
-    expect(createdTimeTable.name).to.equals(baseTimeTable.name)
-    expect(createdTimeTable.startTime).to.equals(baseTimeTable.startTime)
-    expect(createdTimeTable.items!.length).to.equals(1)
-  })
-
-  it('Share with should work as expected', async () => {
-    const api1 = await initApi(env!, hcp1Username)
-    const user1 = await api1.userApi.getCurrentUser()
-    const api2 = await initApi(env!, hcp2Username)
-    const user2 = await api2.userApi.getCurrentUser()
-    const entity = (await api1.timetableApi.createTimeTable(await api1.timetableApi.newInstance(user1, {})))!
-    await api2.timetableApi
-      .getTimeTable(entity.id!)
-      .then(() => {
-        throw new Error('Should not be able to get the entity')
-      })
-      .catch(() => {
-        /* expected */
-      })
-    await api1.timetableApi.shareWith(user2.healthcarePartyId!, entity)
-    const retrieved = await api2.timetableApi.getTimeTable(entity.id!)
-    expect(retrieved.id).to.equal(entity.id)
-  })
-
-  it('newInstance should honor non-default values unless they are undefined', async () => {
-    const api = await initApi(env!, hcp1Username)
-    const user = await api.userApi.getCurrentUser()
-    const timeTableUndefinedId = await api.timetableApi.newInstance(user, { id: undefined })
-    const customId = 'customId'
-    const timeTableCustomId = await api.timetableApi.newInstance(user, { id: customId })
-    const timeTableWithUndefinedInit = await api.timetableApi.newInstance(user, undefined as any)
-    expect(timeTableUndefinedId.id).to.not.be.undefined
-    expect(timeTableWithUndefinedInit.id).to.not.be.undefined
-    expect(timeTableCustomId.id).to.equal(customId)
-  })
-})

package/test/icc-x-api/icc-user-x-api-test.ts

@@ -1,22 +0,0 @@
-import { getEnvironmentInitializer, hcp1Username, setLocalStorage } from '../utils/test_utils'
-import { before } from 'mocha'
-import { crypto } from '../../node-compat'
-import { TestApi } from '../utils/TestApi'
-import { getEnvVariables, TestVars } from '@icure/test-setup/types'
-
-setLocalStorage(fetch)
-let env: TestVars
-
-describe('icc-x-user-api Tests', () => {
-  before(async function () {
-    this.timeout(600000)
-    const initializer = await getEnvironmentInitializer()
-    env = await initializer.execute(getEnvVariables())
-  })
-
-  it('Can instantiate an API and get the current user', async () => {
-    // Given
-    const api = await TestApi(env.iCureUrl, env.dataOwnerDetails[hcp1Username].user, env.dataOwnerDetails[hcp1Username].password, crypto)
-    await api.userApi.getCurrentUser()
-  })
-})

package/test/icc-x-api/icureapi-group-test.ts

@@ -1,154 +0,0 @@
-import { getEnvironmentInitializer, setLocalStorage } from '../utils/test_utils'
-import { getEnvVariables, TestVars } from '@icure/test-setup/types'
-import { webcrypto } from 'crypto'
-import 'isomorphic-fetch'
-import { BasicApis, IcureApi, retry, ua2hex } from '../../icc-x-api'
-import { CryptoPrimitives } from '../../icc-x-api/crypto/CryptoPrimitives'
-import { IccUserApi } from '../../icc-api'
-import { BasicAuthenticationProvider } from '../../icc-x-api/auth/AuthenticationProvider'
-import { expect, use as chaiUse } from 'chai'
-import * as chaiAsPromised from 'chai-as-promised'
-import { KeyPair } from '../../icc-x-api/crypto/RSA'
-import { TestCryptoStrategies } from '../utils/TestCryptoStrategies'
-import { TestKeyStorage, TestStorage } from '../utils/TestStorage'
-chaiUse(chaiAsPromised)
-
-setLocalStorage(fetch)
-
-describe('Icure api', function () {
-  let env: TestVars
-  const primitives = new CryptoPrimitives(webcrypto as any)
-  const userGroup1Id: string = primitives.randomUuid() // Same username-pw as group 2
-  const userGroup2Id: string = primitives.randomUuid() // Same username-pw as group 1
-  const userGroup3Id: string = primitives.randomUuid() // Same username as group 1/2, different pw
-  const userLogin: string = `maria-${primitives.randomUuid()}@pompei.it`
-  const userPw12: string = `geppetto-${primitives.randomUuid()}`
-  const userPw3: string = `pinocchio-${primitives.randomUuid()}`
-  let user1Id: string
-  let user2Id: string
-  let user3Id: string
-  const hcp1Id: string = primitives.randomUuid()
-  const hcp2Id: string = primitives.randomUuid()
-  const hcp3Id: string = primitives.randomUuid()
-  let dataOwner1Pair: KeyPair<CryptoKey>
-  let dataOwner2Pair: KeyPair<CryptoKey>
-  let dataOwner3Pair: KeyPair<CryptoKey>
-  before(async function () {
-    this.timeout(600000)
-    const initializer = await getEnvironmentInitializer()
-    env = await initializer.execute(getEnvVariables())
-    const api = await BasicApis(env.iCureUrl, 'john', 'LetMeIn', webcrypto as any, fetch)
-    async function newGroupWithHcpUser(groupId: string, groupPrefix: string, userLogin: string, userPw: string, hcpId: string): Promise<string> {
-      await api.groupApi.createGroup(
-        groupId,
-        `${groupPrefix}-${primitives.randomUuid()}`,
-        primitives.randomUuid(),
-        undefined,
-        undefined,
-        undefined,
-        undefined,
-        undefined,
-        {}
-      )
-      const res = await api.healthcarePartyApi.registerHealthcareParty(groupId, undefined, userPw, false, {
-        id: hcpId,
-        name: `${groupPrefix}-hcp-${primitives.randomUuid()}`,
-        addresses: [
-          {
-            telecoms: [
-              {
-                telecomType: 'email',
-                telecomNumber: userLogin,
-              },
-            ],
-          },
-        ],
-      })
-      expect(res.userId).to.not.be.undefined
-      return res.userId!
-    }
-    user1Id = await newGroupWithHcpUser(userGroup1Id, 'group1', userLogin, userPw12, hcp1Id)
-    user2Id = await newGroupWithHcpUser(userGroup2Id, 'group2', userLogin, userPw12, hcp2Id)
-    user3Id = await newGroupWithHcpUser(userGroup3Id, 'group3', userLogin, userPw3, hcp3Id)
-    dataOwner1Pair = await primitives.RSA.generateKeyPair()
-    dataOwner2Pair = await primitives.RSA.generateKeyPair()
-    dataOwner3Pair = await primitives.RSA.generateKeyPair()
-    console.log(`Waiting for user to be replicated - ${userLogin}`)
-    await retry(
-      async () => {
-        await new IccUserApi(env.iCureUrl, {}, new BasicAuthenticationProvider(`${userGroup1Id}/${user1Id}`, userPw12), fetch).getCurrentUser()
-        await new IccUserApi(env.iCureUrl, {}, new BasicAuthenticationProvider(`${userGroup2Id}/${user2Id}`, userPw12), fetch).getCurrentUser()
-        await new IccUserApi(env.iCureUrl, {}, new BasicAuthenticationProvider(`${userGroup3Id}/${user3Id}`, userPw3), fetch).getCurrentUser()
-      },
-      10,
-      5_000,
-      1
-    )
-    console.log('Users created')
-  })
-
-  it('if a user has only one group should be initialised on that group', async () => {
-    const api = await IcureApi.initialise(
-      env.iCureUrl,
-      { username: userLogin, password: userPw3 },
-      new TestCryptoStrategies(dataOwner3Pair),
-      webcrypto as any,
-      fetch,
-      {
-        storage: new TestStorage(),
-        keyStorage: new TestKeyStorage(),
-      }
-    )
-    expect((await api.userApi.getCurrentUser()).id).to.equal(user3Id)
-  })
-
-  it('if a user has more than one group should be initialised on different groups depending on the parameters passed values, and the api should be switchable to the other group after initialisation', async () => {
-    const storage = new TestStorage()
-    const keyStorage = new TestKeyStorage()
-    const api1 = await IcureApi.initialise(
-      env.iCureUrl,
-      { username: userLogin, password: userPw12 },
-      new TestCryptoStrategies(dataOwner1Pair),
-      webcrypto as any,
-      fetch,
-      {
-        storage,
-        keyStorage,
-        groupSelector: async (groups) => {
-          expect(groups.map((x) => x.groupId)).to.have.members([userGroup1Id, userGroup2Id])
-          return userGroup1Id
-        },
-      }
-    )
-    expect((await api1.userApi.getCurrentUser()).id).to.equal(user1Id)
-    const key1PubHex = ua2hex(await primitives.RSA.exportKey(dataOwner1Pair.publicKey, 'spki'))
-    expect(Object.keys(api1.cryptoApi.userKeysManager.getDecryptionKeys())).to.have.members([key1PubHex.slice(-32)])
-    const api2 = await IcureApi.initialise(
-      env.iCureUrl,
-      { username: userLogin, password: userPw12 },
-      new TestCryptoStrategies(dataOwner2Pair),
-      webcrypto as any,
-      fetch,
-      {
-        storage,
-        keyStorage,
-        groupSelector: async (groups) => {
-          expect(groups.map((x) => x.groupId)).to.have.members([userGroup1Id, userGroup2Id])
-          return userGroup2Id
-        },
-      }
-    )
-    expect((await api2.userApi.getCurrentUser()).id).to.equal(user2Id)
-    const key2PubHex = ua2hex(await primitives.RSA.exportKey(dataOwner2Pair.publicKey, 'spki'))
-    expect(Object.keys(api2.cryptoApi.userKeysManager.getDecryptionKeys())).to.have.members([key2PubHex.slice(-32)])
-    const api1GroupsInfo = await api1.getGroupsInfo()
-    expect(api1GroupsInfo.availableGroups.map((x) => x.groupId)).to.have.members([userGroup1Id, userGroup2Id])
-    expect(api1GroupsInfo.currentGroup.groupId).to.equal(userGroup1Id)
-    const api1SwitchedTo2 = await api1.switchGroup(userGroup2Id)
-    expect((await api1SwitchedTo2.userApi.getCurrentUser()).id).to.equal(user2Id)
-    expect(Object.keys(api1SwitchedTo2.cryptoApi.userKeysManager.getDecryptionKeys())).to.have.members([key2PubHex.slice(-32)])
-    const api1switchedTo2GroupsInfo = await api1SwitchedTo2.getGroupsInfo()
-    expect(api1switchedTo2GroupsInfo.availableGroups.map((x) => x.groupId)).to.have.members([userGroup1Id, userGroup2Id])
-    expect(api1switchedTo2GroupsInfo.currentGroup.groupId).to.equal(userGroup2Id)
-  })
-})

package/test/icc-x-api/patient-user.ts

@@ -1,136 +0,0 @@
-import 'isomorphic-fetch'
-import { expect } from 'chai'
-import 'mocha'
-import { Apis } from '../../icc-x-api'
-import { IccPatientApi } from '../../icc-api'
-import { User } from '../../icc-api/model/User'
-import { crypto } from '../../node-compat'
-import { ua2hex } from '../../icc-x-api'
-import { Patient } from '../../icc-api/model/Patient'
-import { before } from 'mocha'
-import { getEnvironmentInitializer, hcp1Username, patUsername, setLocalStorage, TestUtils } from '../utils/test_utils'
-import { BasicAuthenticationProvider } from '../../icc-x-api/auth/AuthenticationProvider'
-import initApi = TestUtils.initApi
-import { TestApi } from '../utils/TestApi'
-import { RSAUtils } from '../../icc-x-api/crypto/RSA'
-import { getEnvVariables, TestVars } from '@icure/test-setup/types'
-
-setLocalStorage(fetch)
-let env: TestVars
-let api: Apis
-let hcpUser: User
-
-describe('Patient', () => {
-  before(async function () {
-    this.timeout(600000)
-    const initializer = await getEnvironmentInitializer()
-    env = await initializer.execute(getEnvVariables())
-    api = await initApi(env, hcp1Username)
-    hcpUser = await api.userApi.getCurrentUser()
-  })
-
-  it('should be capable of creating a patient from scratch', async () => {
-    const rawPatientApiForHcp = new IccPatientApi(
-      env.iCureUrl,
-      {},
-      new BasicAuthenticationProvider(env.dataOwnerDetails[hcp1Username].user, env.dataOwnerDetails[hcp1Username].password)
-    )
-    const patient = await rawPatientApiForHcp.createPatient(
-      new Patient({ id: api.cryptoApi.primitives.randomUuid(), firstName: 'Tasty', lastName: 'Test' })
-    )
-    const pwd = api.cryptoApi.primitives.randomUuid()
-    const tmpUser = await api.userApi.createUser(
-      new User({
-        id: api.cryptoApi.primitives.randomUuid(),
-        login: api.cryptoApi.primitives.randomUuid(),
-        passwordHash: pwd,
-        patientId: patient.id,
-      })
-    )
-
-    const rsa = new RSAUtils(crypto)
-    const keyPair = await rsa.generateKeyPair()
-    const { publicKey, privateKey } = keyPair
-    const publicKeyHex = ua2hex(await rsa.exportKey(publicKey, 'spki'))
-    const rawPatientApi = new IccPatientApi(env.iCureUrl, {}, new BasicAuthenticationProvider(tmpUser.id!, pwd))
-    await rawPatientApi.modifyPatient({ ...patient, publicKey: publicKeyHex })
-
-    const { userApi, patientApi, cryptoApi } = await TestApi(env.iCureUrl, tmpUser.id!, pwd!, crypto, keyPair)
-    const user = await userApi.getCurrentUser()
-    let me: Patient = await patientApi.getPatientWithUser(user, user.patientId!)
-    let updatedRev = me.rev
-    updatedRev = (await cryptoApi.exchangeKeys.getOrCreateEncryptionExchangeKeysTo(user.patientId!)).updatedDelegator?.stub.rev ?? updatedRev
-    me = updatedRev == me.rev ? me : await patientApi.getPatientWithUser(user, user.patientId!)
-    expect((await patientApi.getPatientWithUser(user, user.patientId!)).rev).to.equal(me.rev)
-    updatedRev =
-      (await cryptoApi.exchangeKeys.getOrCreateEncryptionExchangeKeysTo(hcpUser.healthcarePartyId!)).updatedDelegator?.stub.rev ?? updatedRev
-    me = updatedRev == me.rev ? me : await patientApi.getPatientWithUser(user, user.patientId!)
-    expect((await patientApi.getPatientWithUser(user, user.patientId!)).rev).to.equal(me.rev)
-    const mySecretIds = await cryptoApi.entities.secretIdsOf(me)
-    const myEncryptionKeys = await cryptoApi.entities.encryptionKeysOf(me)
-    expect(mySecretIds).to.have.length(1)
-    expect(myEncryptionKeys).to.have.length(1)
-
-    me = (await patientApi.modifyPatientWithUser(
-      user,
-      await cryptoApi.entities.entityWithExtendedEncryptedMetadata(me, hcpUser.healthcarePartyId!, mySecretIds, myEncryptionKeys, [], [])
-    ))!
-    await patientApi.modifyPatientWithUser(user, new Patient({ ...me, note: 'This is secret' }))
-
-    const pat2 = await api.patientApi.getPatientWithUser(hcpUser, patient.id!)
-    expect(pat2 != null)
-    expect(pat2.note != null)
-  }).timeout(60000)
-
-  it('should be capable of logging in and encryption', async () => {
-    const { userApi } = await initApi(env, patUsername)
-    const rawPatientApi = new IccPatientApi(
-      env.iCureUrl,
-      {},
-      new BasicAuthenticationProvider(env.dataOwnerDetails[patUsername].user, env.dataOwnerDetails[patUsername].password)
-    )
-
-    const user = await userApi.getCurrentUser()
-    const patient = await rawPatientApi.getPatient(user.patientId!)
-
-    const { calendarItemApi, patientApi, cryptoApi } = await initApi(env, patUsername)
-
-    const patNote = 'Secret note'
-    const pat = await patientApi.modifyPatientWithUser(user, {
-      ...(await patientApi.getPatientWithUser(user, user.patientId!)),
-      note: patNote,
-    })
-    const ciTitle = 'Secret title'
-    const ciDetails = 'Important and private information'
-    const ci = await calendarItemApi.createCalendarItemWithHcParty(
-      user,
-      await calendarItemApi.newInstancePatient(user, patient, { patientId: patient.id, title: ciTitle, details: ciDetails })
-    )
-
-    let failed = false
-    try {
-      await api.patientApi.getPatientWithUser(hcpUser, patient.id!)
-    } catch {
-      failed = true
-    }
-    expect(failed).to.be.true
-    failed = false
-    try {
-      await api.calendarItemApi.getCalendarItemWithUser(hcpUser, ci.id)
-    } catch {
-      failed = true
-    }
-    expect(failed).to.be.true
-
-    await patientApi.shareWith(hcpUser.healthcarePartyId!, pat!, await patientApi.decryptSecretIdsOf(pat!))
-    await calendarItemApi.shareWith(hcpUser.healthcarePartyId!, ci!)
-    await api.cryptoApi.forceReload()
-    const pat3 = await api.patientApi.getPatientWithUser(hcpUser, patient.id!)
-    const ci3 = await api.calendarItemApi.getCalendarItemWithUser(hcpUser, ci.id)
-    expect(pat3).to.not.be.null
-    expect(pat3.note).to.equal(patNote)
-    expect(ci3).to.not.be.null
-    expect(ci3.title).to.equal(ciTitle)
-    expect(ci3.details).to.equal(ciDetails)
-  }).timeout(60000)
-})

package/test/icc-x-api/storage/storage.ts

@@ -1,41 +0,0 @@
-import { expect } from 'chai'
-import { LocalStorageImpl } from '../../../icc-x-api/storage/LocalStorageImpl'
-import { tmpdir } from 'os'
-import 'isomorphic-fetch'
-import { TextDecoder, TextEncoder } from 'util'
-import { KeyStorageImpl } from '../../../icc-x-api'
-;(global as any).localStorage = new (require('node-localstorage').LocalStorage)(tmpdir(), 5 * 1024 * 1024 * 1024)
-;(global as any).fetch = fetch
-;(global as any).Storage = ''
-;(global as any).TextDecoder = TextDecoder
-;(global as any).TextEncoder = TextEncoder
-const testStorage = new LocalStorageImpl()
-const testKeyStorage = new KeyStorageImpl(testStorage)
-
-describe('Test LocalStorageFacade abstraction', () => {
-  it('should store and retrieve a keypair', async () => {
-    const key = 'key'
-    const keyPair = {
-      publicKey: 'publicKey',
-      privateKey: 'privateKey', // pragma: allowlist secret
-    }
-    await testStorage.setItem(key, JSON.stringify(keyPair))
-    expect(await testStorage.getItem(key)).to.eq(JSON.stringify(keyPair))
-  })
-
-  it('should store and retrieve a string', async () => {
-    const key = 'key'
-    const value = 'value'
-    await testStorage.setItem(key, value)
-    expect(await testStorage.getItem(key)).to.eq(value)
-  })
-
-  it('should remove a key', async () => {
-    const key = 'key'
-    const value = 'value'
-    await testStorage.setItem(key, value)
-    expect(await testStorage.getItem(key)).to.eq(value)
-    await testStorage.removeItem(key)
-    expect(await testStorage.getItem(key)).to.be.undefined
-  })
-})