How to use the fabric-client/lib/EventHub.js function in fabric-client

test('\n\n** EventHub transaction callback \n\n', (t) => {
	var eh = new EventHub({ getUserContext: function() { return 'dummyUser'; } });
	eh.setPeerAddr('grpc://localhost:7053');
	eh._connected = true; //force this into connected state
	eh._force_reconnect = false;

	eh.registerTxEvent('txid1', () => {
		// empty method body
	}, () =>{
		// empty method body
	});
	t.pass('successfully registered transaction callbacks');
	t.equal(Object.keys(eh._transactionOnEvents).length, 1, 'Check the size of the transactionOnEvents hash table');
	t.equal(Object.keys(eh._transactionOnErrors).length, 1, 'Check the size of the transactionOnErrors hash table');

	eh.registerTxEvent('txid1', () => {
		t.fail('Should not have called success callback');
		t.end();

// send proposal to endorser
		var request = {
			chainId: options.channel_id,
			chaincodeId: options.chaincode_id,
			chaincodeVersion: options.chaincode_version,
			fcn: options.cc_function,
			args: options.cc_args,
			txId: chain.buildTransactionID(nonce, obj.submitter),
			nonce: nonce,
		};
		logger.debug('[fcw] Sending invoke req', request);

		// Setup EventHub
		if (options.event_url) {
			logger.debug('[fcw] listening to event url', options.event_url);
			eventhub = new EventHub();
			eventhub.setPeerAddr(options.event_url, {
				pem: options.peer_tls_opts.pem,
				'ssl-target-name-override': options.peer_tls_opts.common_name		//can be null if cert matches hostname
			});
			eventhub.connect();
		} else {
			logger.debug('[fcw] will not use tx event');
		}

		// Send Proposal
		chain.sendTransactionProposal(request).then(function (results) {

			// Check Response
			var request = common.check_proposal_res(results, options.endorsed_hook);
			//console.log("Results from sendTransactionProposal invoke_cc: "+ request);
			//console.log(util.inspect(request, {showHidden: false, depth: null}));

_assembleTargetEventSources(channel, targetPeers) {
        let eventSources = [];
        if (this.networkUtil.isInCompatibilityMode()) {
            // NOTE: for old event hubs we have a single connection to every peer set as an event source
            const EventHub = require('fabric-client/lib/EventHub.js');

            for (let peer of targetPeers) {
                let org = this.networkUtil.getOrganizationOfPeer(peer);
                let admin = this.adminProfiles.get(org);

                let eventHub = new EventHub(admin);
                eventHub.setPeerAddr(this.networkUtil.getPeerEventUrl(peer),
                    this.networkUtil.getGrpcOptionsOfPeer(peer));

                eventSources.push({
                    channel: [channel], // unused during chaincode instantiation
                    peer: peer,
                    eventHub: eventHub
                });
            }
        } else {
            for (let peer of targetPeers) {
                let org = this.networkUtil.getOrganizationOfPeer(peer);
                let admin = this.adminProfiles.get(org);

                let eventHub = admin.getChannel(channel, true).newChannelEventHub(peer);

for (let channel of this.networkUtil.getChannels()) {
                // initialize the channels by getting the config from the orderer
                //await this._initializeChannel(this.registrarProfiles, channel);
                await this._initializeChannel(this.adminProfiles, channel);
                await this._initializeChannel(this.clientProfiles, channel);
            }

            if (this.networkUtil.isInCompatibilityMode()) {
                // NOTE: for old event hubs we have a single connection to every peer set as an event source
                const EventHub = require('fabric-client/lib/EventHub.js');

                for (let peer of this.networkUtil.getAllEventSources()) {
                    let org = this.networkUtil.getOrganizationOfPeer(peer);
                    let admin = this.adminProfiles.get(org);

                    let eventHub = new EventHub(admin);
                    eventHub.setPeerAddr(this.networkUtil.getPeerEventUrl(peer),
                        this.networkUtil.getGrpcOptionsOfPeer(peer));

                    // we can use the same peer for multiple channels in case of peer-level eventing
                    this.eventSources.push({
                        channel: this.networkUtil.getChannelsOfPeer(peer),
                        peer: peer,
                        eventHub: eventHub
                    });
                }
            } else {
                // NOTE: for channel event hubs we might have multiple connections to a peer,
                // so connect to the defined event sources of every org in every channel
                for (let channel of this.networkUtil.getChannels()) {
                    for (let org of this.networkUtil.getOrganizationsOfChannel(channel)) {
                        let admin = this.adminProfiles.get(org);

pem: Buffer.from(data).toString(),
                            'ssl-target-name-override': ORGS[key].peer1['server-hostname']
                        }
                    );
                    targets.push(peerTmp);
                    chain.addPeer(peerTmp);
                } else {
                    console.log('[Nid:id:chan:org=%d:%d:%s:%s channelAddAnchorPeer] key: %s, peer1: %s', Nid, pid, channelName, org, key, ORGS[org].peer1.requests);
                    peerTmp = client.newPeer( ORGS[key].peer1.requests);
                    targets.push(peerTmp);
                    chain.addPeer(peerTmp);
                }
                }

                if ( (invokeType.toUpperCase() == 'MOVE') && ( key == org ) ) {
                    eh=new EventHub(client);
                    if (TLS.toUpperCase() == 'ENABLED') {
                        eh.setPeerAddr(
                            ORGS[key].peer1.events,
                            {
                                pem: Buffer.from(data).toString(),
                                'ssl-target-name-override': ORGS[key].peer1['server-hostname']
                            }
                        );
                    } else {
                        eh.setPeerAddr(ORGS[key].peer1.events);
                    }
                    eh.connect();
                    eventHubs.push(eh);
                    console.log('[Nid:id:chan:org=%d:%d:%s:%s channelAddAnchorPeer] requests: %s, events: %s ', Nid, pid, channelName, org, ORGS[key].peer1.requests, ORGS[key].peer1.events);
                }
        }

test('\n\n** EventHub tests\n\n', (t) => {
	var eh = new EventHub();

	t.throws(
		() => {
			eh.connect();
		},
		/Must set peer address before connecting/,
		'Must not allow connect() when peer address has not been set'
	);

	t.throws(
		() => {
			eh.setPeerAddr('badUrl');
		},
		/InvalidProtocol: Invalid protocol: undefined/,
		'Must not allow a bad url without protocol to be set'
	);

function init() {
	chain = client.newChain(config.chainName);
	chain.addOrderer(new Orderer(config.orderer.orderer_url));
	eventhub = new EventHub();
	eventhub.setPeerAddr(config.events[0].event_url);
	eventhub.connect();
	for (var i = 0; i < config.peers.length; i++) {
		chain.addPeer(new Peer(config.peers[i].peer_url));
	}
}

function init() {
    chain = client.newChain(config.chainName)
    chain.addOrderer(new Orderer(config.orderer.orderer_url))
    eventhub = new EventHub()
    eventhub.setPeerAddr(config.events[0].event_url)
    eventhub.connect()
    for (var i = 0; i < config.peers.length; i++) {
        chain.addPeer(new Peer(config.peers[i].peer_url))
    }
}

for (let key in ORGS[org]) {
		if (ORGS[org].hasOwnProperty(key)) {
			if (key.indexOf('peer') === 0) {
				data = fs.readFileSync(path.join(__dirname, ORGS[org][key]['tls_cacerts']));
				targets.push(
					new Peer(
						ORGS[org][key].requests,
						{
							pem: Buffer.from(data).toString(),
							'ssl-target-name-override': ORGS[org][key]['server-hostname']
						}
					)
				);

				let eh = new EventHub();
				eh.setPeerAddr(
					ORGS[org][key].events,
					{
						pem: Buffer.from(data).toString(),
						'ssl-target-name-override': ORGS[org][key]['server-hostname']
					}
				);
				eh.connect();
				eventhubs.push(eh);
				allEventhubs.push(eh);
			}
		}
	}

	return hfc.newDefaultKeyValueStore({
        path: helper.getKeyStoreForOrg(orgName)

function init () {
  chain = client.newChain(config.chainName)
  chain.addOrderer(new Orderer(config.orderer.orderer_url))
  eventhub = new EventHub()
  eventhub.setPeerAddr(config.events[0].event_url)
  eventhub.connect()
  for (var i = 0; i < config.peers.length; i++) {
    chain.addPeer(new Peer(config.peers[i].peer_url))
  }
}