agents.test.ts

import { Subject } from 'rxjs'
import { Agent } from '..'
import {
  toBeConnectedWith,
  SubjectInboundTransporter,
  SubjectOutboundTransporter,
  waitForBasicMessage,
} from './helpers'
import { InitConfig } from '../types'
import indy from 'indy-sdk'
import { ConnectionRecord } from '../modules/connections'
import testLogger from './logger'

expect.extend({ toBeConnectedWith })

const aliceConfig: InitConfig = {
  label: 'Alice',
  walletConfig: { id: 'alice' },
  walletCredentials: { key: '00000000000000000000000000000Test01' },
  autoAcceptConnections: true,
  logger: testLogger,
  indy,
}

const bobConfig: InitConfig = {
  label: 'Bob',
  walletConfig: { id: 'bob' },
  walletCredentials: { key: '00000000000000000000000000000Test02' },
  autoAcceptConnections: true,
  logger: testLogger,
  indy,
}

describe('agents', () => {
  let aliceAgent: Agent
  let bobAgent: Agent
  let aliceConnection: ConnectionRecord
  let bobConnection: ConnectionRecord

  afterAll(async () => {
    await aliceAgent.closeAndDeleteWallet()
    await bobAgent.closeAndDeleteWallet()
  })

  test('make a connection between agents', async () => {
    const aliceMessages = new Subject()
    const bobMessages = new Subject()

    const aliceAgentInbound = new SubjectInboundTransporter(aliceMessages)
    const aliceAgentOutbound = new SubjectOutboundTransporter(bobMessages)
    const bobAgentInbound = new SubjectInboundTransporter(bobMessages)
    const bobAgentOutbound = new SubjectOutboundTransporter(aliceMessages)

    aliceAgent = new Agent(aliceConfig, aliceAgentInbound, aliceAgentOutbound)
    await aliceAgent.init()

    bobAgent = new Agent(bobConfig, bobAgentInbound, bobAgentOutbound)
    await bobAgent.init()

    const aliceConnectionAtAliceBob = await aliceAgent.connections.createConnection()
    const bobConnectionAtBobAlice = await bobAgent.connections.receiveInvitation(aliceConnectionAtAliceBob.invitation)

    aliceConnection = await aliceAgent.connections.returnWhenIsConnected(aliceConnectionAtAliceBob.connectionRecord.id)
    bobConnection = await bobAgent.connections.returnWhenIsConnected(bobConnectionAtBobAlice.id)

    expect(aliceConnection).toBeConnectedWith(bobConnection)
    expect(bobConnection).toBeConnectedWith(aliceConnection)
  })

  test('send a message to connection', async () => {
    const message = 'hello, world'
    await aliceAgent.basicMessages.sendMessage(aliceConnection, message)

    const basicMessage = await waitForBasicMessage(bobAgent, {
      content: message,
    })

    expect(basicMessage.content).toBe(message)
  })
})