test+refactor(agent): 90% coverage

agent/connec.test.ts

@@ -41,21 +41,19 @@ export async function testHeight () {
 }
 
 export async function testCodes () {
-  const backend = new Stub.Backend()
-  backend.uploads.set("123", {
-    codeHash: "abc",
-    codeData: new Uint8Array()
-  } as any)
-  backend.instances.set("stub1abc", {
-    codeId: "123"
-  })
+
+  const backend = new Stub.Backend({})
+  backend.uploads.set("123", { codeHash: "abc", codeData: new Uint8Array() } as any)
+  backend.instances.set("stub1abc", { codeId: "123", address: 'stub1foo' })
+
   const connection = new Stub.Connection({ backend })
   assert.equal(
     await connection.getCodeId('stub1abc'), "123")
   assert.equal(
     await connection.getCodeHashOfAddress('stub1abc'), "abc")
   assert.equal(
     await connection.getCodeHashOfCodeId('123'), "abc")
+
 }
 
 export async function testAuth () {

agent/connec.ts

@@ -159,7 +159,7 @@ export abstract class Connection extends Endpoint {
     return timed(
       this.doGetCodeHashOfCodeId.bind(this, codeId),
       ({ elapsed, result }) => this.log.debug(
-        `Queried in ${bold(elapsed)}: code ID ${bold(codeId)} has hash ${bold(result)}`
+        `Queried in ${bold(elapsed)}: code ID ${bold(codeId)} has hash:\n  ${bold(result)}`
       )
     )
   }
@@ -175,7 +175,7 @@ export abstract class Connection extends Endpoint {
     return timed(
       this.doGetCodeHashOfAddress.bind( this, address),
       ({ elapsed, result }) => this.log.debug(
-        `Queried in ${bold(elapsed)}: code ID ${bold(address)} has hash ${bold(result)}`
+        `Queried in ${bold(elapsed)}: contract ${bold(address)} has hash:\n  ${bold(result)}`
       )
     )
   }

agent/deploy.ts

@@ -108,7 +108,6 @@ export class ContractCode extends Logged {
     }
     const compiled = await this.compile({ compiler, rebuild })
     const uploaded = await uploader.upload(compiled, uploadOptions)
-    console.log({uploaded})
     if (!uploaded.canInstantiate) {
       throw new Error("upload failed")
     }
@@ -309,7 +308,7 @@ export class CompiledCode {
   }
 
   async fetch (): Promise<Uint8Array> {
-    const console = new Console(`compiled(${bold(this[Symbol.toStringTag])})`)
+    const console = new Console(`CompiledCode(${bold(this[Symbol.toStringTag])})`)
     if (this.codeData) {
       console.debug("not fetching: codeData found; unset to refetch")
       return this.codeData
@@ -332,11 +331,10 @@ export class CompiledCode {
       }
     } else {
       this.codeHash = CompiledCode.toCodeHash(this.codeData)
-      console
-        .br()
-        .warn("TOFU: Computed code hash from fetched data:")
-        .warn(bold(this.codeHash))
-        .warn('Pin the expected code hash by setting the codeHash property.')
+      console.warn(
+        "\n  TOFU: Computed code hash from fetched data:" +
+        `\n  ${bold(this.codeHash)}` +
+        '\n  Pin the expected code hash by setting the codeHash property.')
     }
     return this.codeData
   }

agent/stub.ts

@@ -22,11 +22,8 @@ class StubConnection extends Connection {
   batch (): Batch<this> {
     return new StubBatch({ connection: this }) as Batch<this>
   }
-  get height (): Promise<number> {
-    return this.doGetBlockInfo().then(({height})=>height)
-  }
   doGetHeight () {
-    return Promise.resolve(+ new Date())
+    return this.doGetBlockInfo().then(({height})=>height)
   }
   doGetBlockInfo () {
     return Promise.resolve({ height: + new Date() })
@@ -100,10 +97,9 @@ class StubConnection extends Connection {
   doInstantiate (
     codeId: CodeId, options: Parameters<Connection["doInstantiate"]>[1]
   ): Promise<ContractInstance & { address: Address }> {
-    return Promise.resolve(new ContractInstance({
-      address: 'stub',
-      label: ''
-    }) as ContractInstance & { address: Address })
+    return Promise.resolve(new ContractInstance(this.backend.instantiate(codeId, options)) as ContractInstance & {
+      address: Address
+    })
   }
   doExecute (
     contract: { address: Address, codeHash: CodeHash },
@@ -128,7 +124,7 @@ class StubBackend extends Backend {
   uploads =
     new Map<CodeId, {chainId: ChainId, codeId: CodeId, codeHash: CodeHash, codeData: Uint8Array}>()
   instances =
-    new Map<Address, {codeId: CodeId}>()
+    new Map<Address, {codeId: CodeId, address: Address}>()
 
   constructor (properties?: Partial<StubBackend & {
     genesisAccounts: Record<string, string|number>
@@ -194,11 +190,12 @@ class StubBackend extends Backend {
     return upload
   }
 
-  async instantiate (...args: unknown[]): Promise<Partial<ContractInstance> & {
+  instantiate (codeId: CodeId, options: unknown): Partial<ContractInstance> & {
     address: Address
-  }> {
-    throw new Error('not implemented')
-    return { address: '' }
+  } {
+    const address = `stub1${Math.floor(Math.random()*1000000)}`
+    this.instances.set(address, { address, codeId })
+    return { address, codeId }
   }
 
   async execute (...args: unknown[]): Promise<unknown> {

agent/tester.ts

@@ -59,6 +59,7 @@ export async function testChainSupport <
 
   console.log('Querying code upload...')
   equal(await bob.getCodeHashOfCodeId(uploaded.codeId), uploaded.codeHash)
+  rejects(()=>bob.getCodeHashOfCodeId('missing'))
 
   console.log('Instantiating code...')
   const label = 'my-contract-label'

agent/token.test.ts

@@ -49,7 +49,7 @@ export async function testCoins () {
 
 export async function testFees () {
   // FIXME: new Fee(gas, amounts[])
-  new Fee(1000, 'utest', '100000')
+  new Fee(1000, 'utest', '100000')[Symbol.toStringTag]
 }
 
 export async function testFungible () {