mirror of
https://github.com/clusterio/clusterio.git
synced 2026-11-11 23:04:52 +09:00
586 lines
22 KiB
JavaScript
586 lines
22 KiB
JavaScript
"use strict";
|
|
const events = require("events");
|
|
const assert = require("assert").strict;
|
|
const lib = require("@clusterio/lib");
|
|
const { MockController, MockConnector, MockControl } = require("../mock");
|
|
|
|
const addr = lib.Address.fromShorthand;
|
|
|
|
describe("lib/subscriptions", function() {
|
|
class UnregisteredEvent {
|
|
static type = "event";
|
|
static src = ["controller", "control"];
|
|
static dst = ["controller", "control"];
|
|
static permission = null;
|
|
}
|
|
|
|
class RegisteredEvent {
|
|
static type = "event";
|
|
static src = ["controller", "control"];
|
|
static dst = ["controller", "control"];
|
|
static permission = null;
|
|
}
|
|
lib.Link.register(RegisteredEvent);
|
|
|
|
class ChannelEvent {
|
|
static type = "event";
|
|
static src = ["controller", "control"];
|
|
static dst = ["controller", "control"];
|
|
static permission = null;
|
|
|
|
get subscriptionChannel() {
|
|
return "channelOne";
|
|
}
|
|
}
|
|
lib.Link.register(ChannelEvent);
|
|
|
|
class StringPermissionEvent {
|
|
static type = "event";
|
|
static src = ["controller", "control"];
|
|
static dst = ["controller", "control"];
|
|
static permission = "StringPermission";
|
|
}
|
|
lib.Link.register(StringPermissionEvent);
|
|
|
|
class FunctionPermissionEvent {
|
|
static type = "event";
|
|
static src = ["controller", "control"];
|
|
static dst = ["controller", "control"];
|
|
static permission(user, message) {
|
|
user.checkPermission("FunctionPermission");
|
|
};
|
|
}
|
|
lib.Link.register(FunctionPermissionEvent);
|
|
|
|
class MockUser {
|
|
checkPermission(permission) {
|
|
this.lastPermissionCheck = permission;
|
|
}
|
|
}
|
|
|
|
describe("class SubscriptionResponse", function() {
|
|
it("should be round trip json serialisable without an event replay", function() {
|
|
const response = new lib.SubscriptionResponse();
|
|
const json = JSON.stringify(response);
|
|
assert.equal(typeof json, "string");
|
|
const reconstructed = lib.SubscriptionResponse.fromJSON(JSON.parse(json));
|
|
assert.deepEqual(reconstructed, response);
|
|
});
|
|
|
|
it("should be round trip json serialisable with an event replay", function() {
|
|
const response = new lib.SubscriptionResponse(new RegisteredEvent());
|
|
const json = JSON.stringify(response);
|
|
assert.equal(typeof json, "string");
|
|
const reconstructed = lib.SubscriptionResponse.fromJSON(JSON.parse(json));
|
|
assert.deepEqual(reconstructed, response);
|
|
});
|
|
|
|
it("should be round trip json serialisable with a null event replay", function() {
|
|
const response = new lib.SubscriptionResponse(null);
|
|
const json = JSON.stringify(response);
|
|
assert.equal(typeof json, "string");
|
|
const reconstructed = lib.SubscriptionResponse.fromJSON(JSON.parse(json));
|
|
assert.deepEqual(reconstructed, response);
|
|
});
|
|
|
|
it("should be throw when given an unregistered event in a json", function() {
|
|
assert.throws(
|
|
() => lib.SubscriptionResponse.fromJSON([UnregisteredEvent.name, {}]),
|
|
new Error(`Unregistered Event class ${UnregisteredEvent.name}`)
|
|
);
|
|
});
|
|
|
|
it("should be throw when given an unregistered event", function() {
|
|
assert.throws(
|
|
() => new lib.SubscriptionResponse(new UnregisteredEvent()),
|
|
new Error(`Unregistered Event class ${UnregisteredEvent.name}`)
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("class SubscriptionRequest", function() {
|
|
describe("permission()", function() {
|
|
function newSubscriptionRequestMessage(request) {
|
|
return new lib.MessageRequest(
|
|
0,
|
|
addr({ controlId: 0 }),
|
|
addr("controller"),
|
|
lib.SubscriptionRequest.name,
|
|
request.toJSON()
|
|
);
|
|
}
|
|
it("should do nothing when the event has no permission property", function() {
|
|
const mockUser = new MockUser();
|
|
const request = new lib.SubscriptionRequest(RegisteredEvent.name, true);
|
|
lib.SubscriptionRequest.permission(mockUser, newSubscriptionRequestMessage(request));
|
|
assert.equal(mockUser.lastPermissionCheck, undefined);
|
|
});
|
|
it("should check user permission when the permission property is a string", function() {
|
|
const mockUser = new MockUser();
|
|
const request = new lib.SubscriptionRequest(StringPermissionEvent.name, true);
|
|
lib.SubscriptionRequest.permission(mockUser, newSubscriptionRequestMessage(request));
|
|
assert.equal(mockUser.lastPermissionCheck, "StringPermission");
|
|
});
|
|
it("should call the permission property when it is a function", function() {
|
|
const mockUser = new MockUser();
|
|
const request = new lib.SubscriptionRequest(FunctionPermissionEvent.name, true);
|
|
lib.SubscriptionRequest.permission(mockUser, newSubscriptionRequestMessage(request));
|
|
assert.equal(mockUser.lastPermissionCheck, "FunctionPermission");
|
|
});
|
|
});
|
|
|
|
it("should be round trip json serialisable", function() {
|
|
const request = new lib.SubscriptionRequest(RegisteredEvent.name, true, ["channelOne"], 123);
|
|
const json = JSON.stringify(request);
|
|
assert.equal(typeof json, "string");
|
|
const reconstructed = lib.SubscriptionRequest.fromJSON(JSON.parse(json));
|
|
assert.deepEqual(reconstructed, request);
|
|
});
|
|
|
|
it("should be throw when given an unregistered event", function() {
|
|
assert.throws(
|
|
() => new lib.SubscriptionRequest(UnregisteredEvent.name, true),
|
|
new Error(`Unregistered Event class ${UnregisteredEvent.name}`)
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("class SubscriptionController", function() {
|
|
let mockController, subscriptions;
|
|
const connectorSetupDate = [{
|
|
id: 0,
|
|
request: new lib.SubscriptionRequest(RegisteredEvent.name, true),
|
|
src: addr({ controlId: 0 }),
|
|
dst: addr("controller"),
|
|
}, {
|
|
id: 1,
|
|
request: new lib.SubscriptionRequest(RegisteredEvent.name, true),
|
|
src: addr({ controlId: 1 }),
|
|
dst: addr("controller"),
|
|
}, {
|
|
id: 2,
|
|
request: new lib.SubscriptionRequest(ChannelEvent.name, true),
|
|
src: addr({ controlId: 2 }),
|
|
dst: addr("controller"),
|
|
}, {
|
|
id: 3,
|
|
request: new lib.SubscriptionRequest(ChannelEvent.name, false, ["channelOne"]),
|
|
src: addr({ controlId: 3 }),
|
|
dst: addr("controller"),
|
|
}, {
|
|
id: 4,
|
|
request: new lib.SubscriptionRequest(ChannelEvent.name, false, ["channelTwo"]),
|
|
src: addr({ controlId: 4 }),
|
|
dst: addr("controller"),
|
|
}];
|
|
|
|
function onceConnectorSend(id) {
|
|
const link = mockController.wsServer.controlConnections.get(id);
|
|
return events.once(link.connector, "send");
|
|
}
|
|
|
|
function assertLastEvent(connectorId, Event) {
|
|
const link = mockController.wsServer.controlConnections.get(connectorId);
|
|
const lastMessage = link.connector.sentMessages.at(-1);
|
|
const name = Event.plugin ? `${Event.plugin}:${Event.name}` : Event.name;
|
|
assert.equal(lastMessage.name, name);
|
|
}
|
|
|
|
function assertNoEvent(connectorId) {
|
|
const link = mockController.wsServer.controlConnections.get(connectorId);
|
|
assert.equal(link.connector.sentMessages.length, 0);
|
|
}
|
|
|
|
beforeEach(function() {
|
|
mockController = new MockController();
|
|
mockController.wsServer = {
|
|
controlConnections: new Map(connectorSetupDate.map(function (connectorData) {
|
|
return [connectorData.id, new lib.Link(new MockConnector(connectorData.src, connectorData.dst))];
|
|
})),
|
|
};
|
|
subscriptions = new lib.SubscriptionController(mockController);
|
|
});
|
|
|
|
it("should handle the SubscriptionRequest event", function() {
|
|
assert.equal(mockController.handles.has(lib.SubscriptionRequest), true);
|
|
});
|
|
|
|
describe("handle()", function() {
|
|
it("should accept registered events", function() {
|
|
subscriptions.handle(RegisteredEvent);
|
|
});
|
|
it("should not accept unregistered events", function() {
|
|
assert.throws(
|
|
() => subscriptions.handle(UnregisteredEvent),
|
|
new Error(`Unregistered Event class ${UnregisteredEvent.name}`)
|
|
);
|
|
});
|
|
it("should not accept events already handled by the class", function() {
|
|
subscriptions.handle(RegisteredEvent);
|
|
assert.throws(
|
|
() => subscriptions.handle(RegisteredEvent),
|
|
new Error(`Event ${RegisteredEvent.name} is already registered`)
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("broadcast()", function() {
|
|
beforeEach(function() {
|
|
subscriptions.handle(RegisteredEvent);
|
|
subscriptions.handle(ChannelEvent);
|
|
for (let connectorData of connectorSetupDate) {
|
|
subscriptions._handleRequest(connectorData.request, connectorData.src, connectorData.dst);
|
|
}
|
|
});
|
|
|
|
it("should not accept unregistered events", function() {
|
|
assert.throws(
|
|
() => subscriptions.broadcast(new UnregisteredEvent()),
|
|
new Error(`Unregistered Event class ${UnregisteredEvent.name}`)
|
|
);
|
|
});
|
|
it("should not accept events not handled by the class", function() {
|
|
assert.throws(
|
|
() => subscriptions.broadcast(new StringPermissionEvent()),
|
|
new Error(`Event ${StringPermissionEvent.name} is not a registered as subscribable`)
|
|
);
|
|
});
|
|
it("should notify all links who subscribed to all channels", async function() {
|
|
subscriptions.broadcast(new RegisteredEvent());
|
|
await Promise.all([onceConnectorSend(0), onceConnectorSend(1)]);
|
|
assertLastEvent(0, RegisteredEvent); // RegisteredEvent: All
|
|
assertLastEvent(1, RegisteredEvent); // RegisteredEvent: All
|
|
assertNoEvent(2); // ChannelEvent: All
|
|
assertNoEvent(3); // ChannelEvent: channelOne
|
|
assertNoEvent(4); // ChannelEvent: channelTwo
|
|
});
|
|
it("should not notify a link who unsubscribed from all all channels", async function() {
|
|
const connectorData = connectorSetupDate[0];
|
|
const request = new lib.SubscriptionRequest(RegisteredEvent.name, false);
|
|
await subscriptions._handleRequest(request, connectorData.src, connectorData.dst);
|
|
mockController.wsServer.controlConnections.get(0).connector.sentMessages.pop(); // Response to request
|
|
subscriptions.broadcast(new RegisteredEvent());
|
|
await onceConnectorSend(1);
|
|
assertNoEvent(0);
|
|
assertLastEvent(1, RegisteredEvent);
|
|
assertNoEvent(2);
|
|
assertNoEvent(3);
|
|
assertNoEvent(4);
|
|
});
|
|
it("should notify all links who subscribed the specific channel", async function() {
|
|
subscriptions.broadcast(new ChannelEvent());
|
|
await Promise.all([onceConnectorSend(2), onceConnectorSend(3)]);
|
|
assertNoEvent(0);
|
|
assertNoEvent(1);
|
|
assertLastEvent(2, ChannelEvent);
|
|
assertLastEvent(3, ChannelEvent);
|
|
assertNoEvent(4);
|
|
});
|
|
it("should not notify a link who unsubscribed from the specific channel", async function() {
|
|
const connectorData = connectorSetupDate[3];
|
|
const request = new lib.SubscriptionRequest(ChannelEvent.name, false, []);
|
|
await subscriptions._handleRequest(request, connectorData.src, connectorData.dst);
|
|
mockController.wsServer.controlConnections.get(3).connector.sentMessages.pop(); // Response to request
|
|
subscriptions.broadcast(new ChannelEvent());
|
|
await onceConnectorSend(2);
|
|
assertNoEvent(0);
|
|
assertNoEvent(1);
|
|
assertLastEvent(2, ChannelEvent);
|
|
assertNoEvent(3);
|
|
assertNoEvent(4);
|
|
});
|
|
it("should not notify links which are closed or closing", async function() {
|
|
const link = mockController.wsServer.controlConnections.get(0);
|
|
link.connector.closing = true;
|
|
subscriptions.broadcast(new RegisteredEvent());
|
|
await onceConnectorSend(1);
|
|
assertNoEvent(0);
|
|
assertLastEvent(1, RegisteredEvent);
|
|
assertNoEvent(2);
|
|
assertNoEvent(3);
|
|
assertNoEvent(4);
|
|
});
|
|
});
|
|
|
|
describe("_handleRequest()", function() {
|
|
beforeEach(function() {
|
|
subscriptions.handle(RegisteredEvent);
|
|
subscriptions.handle(ChannelEvent);
|
|
});
|
|
|
|
it("should not accept subscriptions to unregistered events", function() {
|
|
const request = new lib.SubscriptionRequest(RegisteredEvent.name, true);
|
|
request.eventName = UnregisteredEvent.name;
|
|
assert.rejects(
|
|
subscriptions._handleRequest(request, addr({ controlId: 0 }), addr("controller")),
|
|
new Error(`Unregistered Event class ${UnregisteredEvent.name}`)
|
|
);
|
|
});
|
|
it("should not accept subscriptions to events not handled by the class", function() {
|
|
const request = new lib.SubscriptionRequest(RegisteredEvent.name, true);
|
|
request.eventName = StringPermissionEvent.name;
|
|
assert.rejects(
|
|
subscriptions._handleRequest(request, addr({ controlId: 0 }), addr("controller")),
|
|
new Error(`Event ${StringPermissionEvent.eventName} is not a registered as subscribable`)
|
|
);
|
|
});
|
|
it("should accept a subscription to all channels", async function() {
|
|
const request = new lib.SubscriptionRequest(RegisteredEvent.name, true);
|
|
await subscriptions._handleRequest(request, connectorSetupDate[0].src, connectorSetupDate[0].dst);
|
|
subscriptions.broadcast(new RegisteredEvent());
|
|
await onceConnectorSend(0);
|
|
assertLastEvent(0, RegisteredEvent);
|
|
});
|
|
it("should accept a unsubscription from all channels", async function() {
|
|
const request = new lib.SubscriptionRequest(RegisteredEvent.name, true);
|
|
await subscriptions._handleRequest(request, connectorSetupDate[0].src, connectorSetupDate[0].dst);
|
|
subscriptions.broadcast(new RegisteredEvent());
|
|
await onceConnectorSend(0);
|
|
assertLastEvent(0, RegisteredEvent);
|
|
|
|
const link = mockController.wsServer.controlConnections.get(0);
|
|
link.connector.sentMessages.pop();
|
|
|
|
const unsubRequest = new lib.SubscriptionRequest(RegisteredEvent.name, false);
|
|
await subscriptions._handleRequest(unsubRequest, connectorSetupDate[0].src, connectorSetupDate[0].dst);
|
|
subscriptions.broadcast(new RegisteredEvent());
|
|
assertNoEvent(0);
|
|
});
|
|
it("should accept a subscription to a specific channel", async function() {
|
|
const request = new lib.SubscriptionRequest(ChannelEvent.name, false, ["channelOne"]);
|
|
await subscriptions._handleRequest(request, connectorSetupDate[0].src, connectorSetupDate[0].dst);
|
|
subscriptions.broadcast(new ChannelEvent());
|
|
await onceConnectorSend(0);
|
|
assertLastEvent(0, ChannelEvent);
|
|
});
|
|
it("should accept a unsubscription from a specific channel", async function() {
|
|
const request = new lib.SubscriptionRequest(ChannelEvent.name, false, ["channelOne"]);
|
|
await subscriptions._handleRequest(request, connectorSetupDate[0].src, connectorSetupDate[0].dst);
|
|
subscriptions.broadcast(new ChannelEvent());
|
|
await onceConnectorSend(0);
|
|
assertLastEvent(0, ChannelEvent);
|
|
|
|
const link = mockController.wsServer.controlConnections.get(0);
|
|
link.connector.sentMessages.pop();
|
|
|
|
const unsubRequest = new lib.SubscriptionRequest(ChannelEvent.name, false, []);
|
|
await subscriptions._handleRequest(unsubRequest, connectorSetupDate[0].src, connectorSetupDate[0].dst);
|
|
subscriptions.broadcast(new ChannelEvent());
|
|
assertNoEvent(0);
|
|
});
|
|
it("should accept a respond with an event replay when returned by the handler", async function() {
|
|
subscriptions.handle(StringPermissionEvent, undefined, async function() {
|
|
return new StringPermissionEvent();
|
|
});
|
|
|
|
const request = new lib.SubscriptionRequest(StringPermissionEvent.name, true);
|
|
await subscriptions._handleRequest(request, connectorSetupDate[0].src, connectorSetupDate[0].dst);
|
|
subscriptions.broadcast(new StringPermissionEvent());
|
|
await onceConnectorSend(0);
|
|
assertLastEvent(0, StringPermissionEvent);
|
|
|
|
const link = mockController.wsServer.controlConnections.get(0);
|
|
const lastMessage = link.connector.sentMessages.pop();
|
|
const eventEntry = lib.Link._eventsByClass.get(StringPermissionEvent);
|
|
const response = eventEntry.eventFromJSON(lastMessage.data);
|
|
assert.deepEqual(response, new StringPermissionEvent());
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("class EventSubscriber", function() {
|
|
let channelEvent, mockControl, registeredEvent;
|
|
beforeEach(function() {
|
|
mockControl = new MockControl(new MockConnector(
|
|
addr({ controlId: 0 }),
|
|
addr("controller"),
|
|
));
|
|
registeredEvent = new lib.EventSubscriber(RegisteredEvent, undefined, mockControl);
|
|
channelEvent = new lib.EventSubscriber(ChannelEvent, undefined, mockControl);
|
|
});
|
|
|
|
function assertLastRequest(request) {
|
|
const Request = request.constructor;
|
|
const lastMessage = mockControl.connector.sentMessages.at(-1);
|
|
const name = Request.plugin ? `${Request.plugin}:${Request.name}` : Request.name;
|
|
assert.equal(lastMessage.name, name);
|
|
assert.deepEqual(lastMessage.data, request);
|
|
}
|
|
|
|
describe("constructor()", function() {
|
|
it("should not accept unregistered events", function() {
|
|
assert.throws(
|
|
() => new lib.EventSubscriber(UnregisteredEvent),
|
|
new Error(`Unregistered Event class ${UnregisteredEvent.name}`)
|
|
);
|
|
});
|
|
it("should handle the provided event, if a control link is provided", function() {
|
|
assert.equal(mockControl._eventHandlers.has(RegisteredEvent), true);
|
|
assert.equal(mockControl._eventHandlers.has(ChannelEvent), true);
|
|
});
|
|
it("should call and use the return of a pre-handler, if provided", function() {
|
|
let calledWith = null;
|
|
function prehandler() { return "PreHandlerReturn"; }
|
|
const eventSubscriber = new lib.EventSubscriber(StringPermissionEvent, prehandler, mockControl);
|
|
eventSubscriber.subscribe(function(value) { calledWith = value; });
|
|
eventSubscriber._handle(new StringPermissionEvent());
|
|
assert.equal(calledWith, "PreHandlerReturn");
|
|
});
|
|
});
|
|
|
|
describe("connectControl()", function() {
|
|
it("should handle the provided event", function() {
|
|
const control = new MockControl(new MockConnector(addr({ controlId: 0 }), addr("controller")));
|
|
registeredEvent.connectControl(control);
|
|
assert.equal(control._eventHandlers.has(RegisteredEvent), true);
|
|
});
|
|
it("should do nothing if the control is already connected", function() {
|
|
assert.equal(mockControl._eventHandlers.has(RegisteredEvent), true);
|
|
registeredEvent.connectControl(mockControl);
|
|
assert.equal(mockControl._eventHandlers.has(RegisteredEvent), true);
|
|
});
|
|
});
|
|
|
|
describe("subscribe()", function() {
|
|
it("should allow subscriptions to an event", function() {
|
|
let calledWith = null;
|
|
let calledWithTwo = null;
|
|
const event = new RegisteredEvent();
|
|
registeredEvent.subscribe(function(value) { calledWith = value; });
|
|
registeredEvent.subscribe(function(value) { calledWithTwo = value; });
|
|
registeredEvent._handle(event);
|
|
assert.deepEqual(calledWith, event);
|
|
assert.deepEqual(calledWithTwo, event);
|
|
});
|
|
});
|
|
|
|
describe("subscribeToChannel()", function() {
|
|
it("should allow subscriptions to a channel for an event", function() {
|
|
let calledWith = null;
|
|
let calledWithTwo = null;
|
|
const event = new ChannelEvent();
|
|
channelEvent.subscribeToChannel("channelOne", function(value) { calledWith = value; });
|
|
channelEvent.subscribeToChannel("channelTwo", function(value) { calledWithTwo = value; });
|
|
channelEvent._handle(event);
|
|
assert.deepEqual(calledWith, event);
|
|
assert.deepEqual(calledWithTwo, null);
|
|
});
|
|
});
|
|
|
|
describe("unsubscribe()", function() {
|
|
it("should allow unsubscribing from an event", function() {
|
|
let calledWith = null;
|
|
let event = new RegisteredEvent();
|
|
function callback(value) { calledWith = value; }
|
|
registeredEvent.subscribe(callback);
|
|
registeredEvent._handle(event);
|
|
assert.deepEqual(calledWith, event);
|
|
|
|
calledWith = null;
|
|
event = new RegisteredEvent();
|
|
registeredEvent.unsubscribe(callback);
|
|
registeredEvent._handle(event);
|
|
assert.equal(calledWith, null);
|
|
});
|
|
it("should throw an error if the handler was not subscribed", function() {
|
|
function callback(value) { calledWith = value; }
|
|
assert.rejects(
|
|
() => registeredEvent.unsubscribe(callback),
|
|
new Error("handler is not registered")
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("unsubscribeFromChannel()", function() {
|
|
it("should allow unsubscribing from a channel for an event", function() {
|
|
let calledWith = null;
|
|
let event = new ChannelEvent();
|
|
function callback(value) { calledWith = value; }
|
|
channelEvent.subscribeToChannel("channelOne", callback);
|
|
channelEvent._handle(event);
|
|
assert.deepEqual(calledWith, event);
|
|
|
|
calledWith = null;
|
|
event = new ChannelEvent();
|
|
channelEvent.unsubscribeFromChannel("channelOne", callback);
|
|
channelEvent._handle(event);
|
|
assert.equal(calledWith, null);
|
|
|
|
let calledWithTwo = null;
|
|
function callbackTwo(value) { calledWithTwo = value; }
|
|
channelEvent.subscribeToChannel("channelOne", callback);
|
|
channelEvent.subscribeToChannel("channelOne", callbackTwo);
|
|
channelEvent._handle(event);
|
|
assert.equal(calledWith, event);
|
|
assert.equal(calledWithTwo, event);
|
|
|
|
calledWith = null;
|
|
calledWithTwo = null;
|
|
event = new ChannelEvent();
|
|
channelEvent.unsubscribeFromChannel("channelOne", callback);
|
|
channelEvent._handle(event);
|
|
assert.equal(calledWith, null);
|
|
assert.equal(calledWithTwo, event);
|
|
});
|
|
it("should throw an error if the handler was not subscribed", function() {
|
|
function callback() {}
|
|
assert.rejects(
|
|
() => channelEvent.unsubscribeFromChannel("channelOne", callback),
|
|
new Error("handler is not registered")
|
|
);
|
|
|
|
let calledWith = null;
|
|
function callbackTwo(value) { calledWith = value; }
|
|
channelEvent.subscribeToChannel("channelOne", callbackTwo);
|
|
assert.rejects(
|
|
() => channelEvent.unsubscribeFromChannel("channelOne", callback),
|
|
new Error("handler is not registered")
|
|
);
|
|
const event = new ChannelEvent();
|
|
channelEvent._handle(event);
|
|
assert.equal(calledWith, event);
|
|
});
|
|
});
|
|
|
|
describe("_updateSubscription()", function() {
|
|
it("should correctly request a subscription for all channels", async function() {
|
|
const expected = new lib.SubscriptionRequest(RegisteredEvent.name, true);
|
|
registeredEvent.subscribe(() => true);
|
|
await events.once(mockControl.connector, "send");
|
|
assertLastRequest(expected);
|
|
});
|
|
it("should correctly request a subscription for some channels", async function() {
|
|
const expected = new lib.SubscriptionRequest(ChannelEvent.name, false, ["channelOne"]);
|
|
channelEvent.subscribeToChannel("channelOne", () => true);
|
|
await events.once(mockControl.connector, "send");
|
|
assertLastRequest(expected);
|
|
});
|
|
it("should correctly request a subscription for no channels", async function() {
|
|
const expected = new lib.SubscriptionRequest(RegisteredEvent.name, false);
|
|
function callback() {}
|
|
registeredEvent.subscribe(callback);
|
|
await events.once(mockControl.connector, "send");
|
|
registeredEvent.unsubscribe(callback);
|
|
await events.once(mockControl.connector, "send");
|
|
assertLastRequest(expected);
|
|
});
|
|
it("should call handlers when a replay event is returned", async function() {
|
|
let calledWith = null;
|
|
const event = new RegisteredEvent();
|
|
const request = registeredEvent.subscribe(function(value) { calledWith = value; });
|
|
await events.once(mockControl.connector, "send");
|
|
|
|
mockControl.connector.emit("message", new lib.MessageResponse(
|
|
0,
|
|
mockControl.connector.dst,
|
|
new lib.Address(lib.Address.control, 0, mockControl._nextRequestId - 1),
|
|
new lib.SubscriptionResponse(event).toJSON()
|
|
));
|
|
|
|
await request;
|
|
assert.deepEqual(calledWith, event);
|
|
});
|
|
});
|
|
});
|
|
});
|