test: migrate event and remote-proxy tests

Refs: #145
Refs: #146
Refs: #53
PR-URL: #199
Reviewed-By: Denys Otrishko <shishugi@gmail.com>
Reviewed-By: Mykola Bilochub <nbelochub@gmail.com>
Reviewed-By: Alexey Orlenko <eaglexrlnk@gmail.com>

test/node/connection-event.js

@@ -0,0 +1,111 @@
+'use strict';
+
+const test = require('tap');
+
+const jstp = require('../..');
+
+const name = 'testApp';
+
+const interfaces = {
+  iface: {}
+};
+
+const app = {
+  name,
+  interfaces
+};
+
+const application = new jstp.Application(app.name, app.interfaces);
+let server;
+let client;
+
+test.beforeEach((done) => {
+  server = jstp.tcp.createServer(0, [application], app.authCallback);
+  server.listen(() => {
+    const port = server.address().port;
+    client = jstp.tcp.createClient({ host: 'localhost', port });
+    done();
+  });
+});
+
+test.afterEach((done) => {
+  client.disconnect();
+  server.close();
+  done();
+});
+
+const iface = 'iface';
+const eventName = 'someEvent';
+const args = ['firstArgument', 'secondArgument'];
+
+test.test('server must process an event', (test) => {
+  client.connectAndHandshake(app.name, null, null, (error, connection) => {
+    test.assertNot(error, 'must connect to server');
+
+    server.getClients()[0].on('event', (event) => {
+      test.strictEqual(event.interfaceName, iface,
+        'event interface must match');
+      test.strictEqual(event.remoteEventName, eventName,
+        'event name must be equal to the emitted one');
+      test.strictDeepEqual(event.remoteEventArgs, args,
+        'event arguments must be equal to the passed ones');
+
+      test.end();
+    });
+
+    connection.emitRemoteEvent(iface, eventName, args);
+  });
+});
+
+test.test('client must process an event', (test) => {
+  client.connectAndHandshake(app.name, null, null, (error, connection) => {
+    test.assertNot(error, 'must connect to server');
+
+    connection.on('event', (event) => {
+      test.strictEqual(event.interfaceName, iface,
+        'event interface must match');
+      test.strictEqual(event.remoteEventName, eventName,
+        'event name must be equal to the emitted one');
+      test.strictDeepEqual(event.remoteEventArgs, args,
+        'event arguments must be equal to the passed ones');
+      test.end();
+    });
+
+    server.getClients()[0].emitRemoteEvent(iface, eventName, args);
+  });
+});
+
+test.test('remote proxy must emit an event', (test) => {
+  client.connectAndInspect(app.name, null, null, [iface],
+    (error, connection, api) => {
+      test.assertNot(error, 'must connect to server');
+
+      server.getClients()[0].on('event', (event) => {
+        test.strictEqual(event.interfaceName, iface,
+          'event interface must match');
+        test.strictEqual(event.remoteEventName, eventName,
+          'event name must be equal to the emitted one');
+        test.strictDeepEqual(event.remoteEventArgs, args,
+          'event arguments must be equal to the passed ones');
+        test.end();
+      });
+
+      api.iface.emit(eventName, ...args);
+    }
+  );
+});
+
+test.test('remote proxy must process an event', (test) => {
+  client.connectAndInspect(app.name, null, null, [iface],
+    (error, connection, api) => {
+      test.assertNot(error, 'must connect to server');
+
+      api.iface.on(eventName, (...eventArgs) => {
+        test.strictDeepEqual(eventArgs, args,
+          'event arguments must be equal to the passed ones');
+        test.end();
+      });
+      server.getClients()[0].emitRemoteEvent(iface, eventName, args);
+    }
+  );
+});

test/unit/connection.test.js

@@ -135,53 +135,6 @@ describe('JSTP Connection', () => {
     });
   });
 
-  describe('event', () => {
-    testPacketSending('event', (connection, transport) => {
-      const eventArgs = [ 'value' ];
-
-      const sendSpy = chai.spy((data) => {
-        const packet = jstp.parse(data);
-        expect(packet).to.have.all.keys(['event', constants.TEST_EVENT]);
-
-        expect(packet.event).to.be.an('array');
-        expect(packet.event[0]).to.be.a('number');
-        expect(packet.event[1]).to.equal(constants.TEST_INTERFACE);
-
-        expect(packet[constants.TEST_EVENT]).to.eql(eventArgs);
-      });
-
-      transport.on('dataSent', sendSpy);
-
-      connection.emitRemoteEvent(constants.TEST_INTERFACE,
-        constants.TEST_EVENT, eventArgs);
-
-      expect(sendSpy).to.have.been.called();
-    });
-
-    it('must process event packets', () => {
-      const payload = { key: 'value' };
-
-      const event = {
-        event: [-1, constants.TEST_INTERFACE]
-      };
-
-      event[constants.TEST_EVENT] = payload;
-
-      const handler = chai.spy((eventArgs) => {
-        expect(eventArgs.interfaceName).to.equal(constants.TEST_INTERFACE);
-        expect(eventArgs.remoteEventName).to.equal(constants.TEST_EVENT);
-        expect(eventArgs.remoteEventArgs).to.eql(payload);
-      });
-
-      clientConnection.on('event', handler);
-
-      performHandshakeFromClient(() => {
-        clientTransportMock.emitPacket(event);
-        expect(handler).to.be.called();
-      });
-    });
-  });
-
   describe('state', () => {
     testPacketSending('state', (connection, transport) => {
       const sendSpy = chai.spy((data) => {

test/unit/remote-proxy.test.js

@@ -60,26 +60,4 @@ describe('RemoteProxy', () => {
     expect(callback2).to.have.been.called.exactly(1);
     expect(callback2).to.have.been.called.with('result2');
   });
-
-  it('must emit events through the network and locally', () => {
-    const handler = chai.spy();
-    proxy.on('testEvent', handler);
-    proxy.emit('testEvent', 'payload1', 'payload2');
-
-    expect(eventSpy).to.have.been.called.exactly(1);
-    expect(eventSpy).to.have.been.called.with(
-      'testInterface', 'testEvent', ['payload1', 'payload2']);
-
-    expect(handler).to.have.been.called.exactly(1);
-    expect(handler).to.have.been.called.with('payload1', 'payload2');
-  });
-
-  it('must not re-emit events back', () => {
-    const handler = chai.spy();
-    proxy.on('testEvent', handler);
-    connectionMock.processEventPacket();
-
-    expect(handler).to.have.been.called.with('payload1', 'payload2');
-    expect(eventSpy).to.not.have.been.called();
-  });
 });