How to use the testdouble.object function in testdouble

t.test('should fetch', async (t) => {
    const fetcher = new BlockFetcher({pool: new PeerPool()})
    const peer = {eth: td.object()}
    td.when(peer.eth.getBlockHeaders({block: ONE, max: 2})).thenResolve([])
    td.when(peer.eth.getBlockHeaders({block: ONE, max: 128})).thenResolve([])
    td.when(peer.eth.getBlockBodies(td.matchers.anything())).thenResolve([])
    const blocks = await fetcher.fetch({first: ONE, last: TWO}, peer)
    t.deepEquals(blocks, {blocks: []}, 'got blocks')
    await fetcher.fetch({first: ONE, last: new BN(1000)}, peer)
    t.end()
  })

t.test('should start/stop server and test banning', async (t) => {
    t.plan(11)
    const server = new Libp2pServer({ multiaddrs: 'ma0' })
    const protos = [{ name: 'proto', versions: [1] }, { name: 'proto', versions: [2] }]
    const peer = td.object()
    const peer2 = td.object({ id: 'id2', bindProtocols: td.func() })
    const peerInfo2 = { id: { toB58String: () => 'id2' }, multiaddrs: { toArray: () => [] } }
    protos.forEach(p => {
      p.open = td.func()
      td.when(p.open()).thenResolve()
    })
    server.getPeerInfo = td.func()
    server.createPeer = td.func()
    td.when(server.getPeerInfo('conn0')).thenResolve(peerInfo)
    td.when(server.getPeerInfo('conn1')).thenReject('err0')
    td.when(server.createPeer(peerInfo2)).thenReturn(peer2)
    td.when(peer.accept(protos[0], 'conn0', server)).thenResolve()
    server.peers.set('id', peer)
    server.addProtocols(protos)
    server.on('listening', (info) => t.deepEquals(info, { transport: 'libp2p', url: 'ma0' }, 'listening'))
    server.once('connected', (p) => t.equals(p, peer, 'peer connected'))

t.test('should timeout request', async (t) => {
    const sender = td.object('Sender')
    const bound = new BoundProtocol({ protocol, peer, sender })
    try {
      await bound.testMessage(1)
    } catch (err) {
      t.ok(/timed out/.test(err.message), 'got error')
    }
    t.end()
  })

t.test('should be a libp2p bundle', t => {
    const peerInfo = td.object('PeerInfo')
    const node = new Libp2pNode({ peerInfo })
    t.ok(node instanceof libp2p, 'is libp2p bundle')
    t.end()
  })

it('should render template to body as a stream', () => {
      let tpl = td.object(['stream']);
      ctx.render(tpl, { status: 1 });
      td.verify(tpl.stream(td.matchers.isA(Object)));
    });
  });

test.cb('invokes sse.send() when handler is called', t => {
  const sse = td.object({
    send: () => {}
  })
  const db = td.object({
    storeEvent: () => {}
  })
  const broadcast = createSubscriptions(sse, db)
  const data = 'wowowowwww'
  broadcast.setState(data)
  td.verify(sse.send({ event: 'fair-analytics-event', data }))
  td.verify(db.storeEvent(data))
  t.end()
})

beforeEach( function() {
		userProps = td.object( [ 'getProperty', 'setProperty' ] )
		docProps = td.object( [ 'getProperty', 'setProperty' ] )

		const propService = {
			getUserProperties: () => userProps,
			getDocumentProperties: () => docProps
		}

		store = Persistance( propService )
	} )

test.cb('invokes sse.send() when handler is called', t => {
  const sse = td.object({
    send: () => {}
  })
  const db = td.object({
    storeEvent: () => {}
  })
  const broadcast = createSubscriptions(sse, db)
  const data = 'wowowowwww'
  broadcast.setState(data)
  td.verify(sse.send({ event: 'fair-analytics-event', data }))
  td.verify(db.storeEvent(data))
  t.end()
})

function stubDB (viewName, lookup, response) {
  const db = td.object({
    get: () => {},
    view: () => {},
    insert: () => {}
  })
  const key = 'org.couchdb.user:' + lookup
  const error = response ? null : new Error('Not found')
  const viewOpts = { keys: [lookup], include_docs: true }
  td.when(db.view('users', viewName, viewOpts)).thenCallback(error, response)
  td.when(db.get(key)).thenCallback(error, response)
  td.when(db.insert(td.matchers.isA(Object))).thenCallback()
  return db
}

function containerOf( ...elements ) {
	const container = td.object( ['getNumChildren', 'getChild', 'getType', 'getPreviousSibling', 'getNextSibling', 'getAttributes', 'getPositionedImages'] )

	elements.forEach( ( el, i ) => {
		td.when( container.getChild( i ) ).thenReturn( el )
		td.when( el.getPreviousSibling() ).thenReturn( elements[i - 1] )
		td.when( el.getNextSibling() ).thenReturn( elements[i + 1] )
	} )
	td.when( container.getNumChildren() ).thenReturn( elements.length )
	td.when( container.getPositionedImages() ).thenReturn( [] )

	return container
}