added tests for discovery

Author: AlCalzone

build/lib/discovery.js

@@ -13,7 +13,7 @@ function discoverGateway(timeout = 10000) {
     let timer;
     return new Promise((resolve, reject) => {
         const mdnsBrowser = bonjour.findOne({ type: "coap", protocol: "udp" }, (service) => {
-            if (!service || !service.txt || !service.name.startsWith("gw-"))
+            if (!service || !service.txt || !service.name || !service.name.startsWith("gw-"))
                 return;
             if (timer != null)
                 clearTimeout(timer);

src/lib/discovery.test.ts

@@ -0,0 +1,156 @@
+// tslint:disable:no-console
+// tslint:disable:no-unused-expression
+// tslint:disable:variable-name
+
+import { assert, expect, should, use } from "chai";
+import { SinonFakeTimers, spy, stub, useFakeTimers } from "sinon";
+import * as sinonChai from "sinon-chai";
+
+// enable the should interface with sinon
+should();
+use(sinonChai);
+
+let findOneCalled: DeferredPromise<void>;
+let findOneCallback: (service: any) => void;
+const fakeBrowser = {
+	start: stub(),
+	stop: stub(),
+};
+const fakeBonjour = {
+	findOne: stub()
+		// remember the given callback
+		.callsFake((opts, cb) => {
+			findOneCallback = cb;
+			if (findOneCalled != null) findOneCalled.resolve();
+			return fakeBrowser;
+		}),
+};
+const fakeBonjourPackage = stub().returns(fakeBonjour);
+
+// stub out the bonjour package for discovery
+import * as proxyquire from "proxyquire";
+import { createDeferredPromise, DeferredPromise } from "./defer-promise";
+import { wait } from "./promises";
+const { discoverGateway, DiscoveredGateway } = proxyquire("./discovery", {
+	bonjour: fakeBonjourPackage,
+});
+
+describe("lib/discovery => ", () => {
+
+	let clock: SinonFakeTimers;
+	beforeEach(() => {
+		clock = useFakeTimers();
+	});
+
+	afterEach(() => {
+		fakeBonjourPackage.resetHistory();
+		fakeBonjour.findOne.resetHistory();
+		fakeBrowser.start.resetHistory();
+		fakeBrowser.stop.resetHistory();
+
+		clock.restore();
+	});
+
+	it("discoverGateway lazily creates a bonjour instance", () => {
+		discoverGateway(false);
+		fakeBonjourPackage.should.have.been.calledOnce;
+		discoverGateway(false);
+		fakeBonjourPackage.should.have.been.calledOnce;
+	});
+
+	it("discoverGateway creates an mDNS browser and starts the discovery", () => {
+		discoverGateway(false);
+		fakeBonjour.findOne.should.have.been.calledOnce;
+		fakeBrowser.start.should.have.been.calledOnce;
+	});
+
+	it("without a service response, discoverGateway() should fulfill with null after the default timeout has elapsed", (done) => {
+		const timeout = 10000;
+
+		const leSpy = spy();
+		discoverGateway().then(leSpy);
+		wait(timeout - 1).then(() => {
+			leSpy.should.not.have.been.called;
+			wait(1).then(() => {
+				leSpy.should.have.been.calledWith(null);
+				done();
+			});
+			clock.tick(1);
+		});
+		clock.tick(timeout - 1);
+	});
+
+	it("without a service response, discoverGateway(timeout) should fulfill with null after the passed timeout has elapsed", (done) => {
+		const timeout = 5000;
+
+		const leSpy = spy();
+		discoverGateway(timeout).then(leSpy);
+		wait(timeout - 1).then(() => {
+			leSpy.should.not.have.been.called;
+			wait(1).then(() => {
+				leSpy.should.have.been.calledWith(null);
+				done();
+			});
+			clock.tick(1);
+		});
+		clock.tick(timeout - 1);
+	});
+
+	it("without a service response, discoverGateway should never fulfill with the timeout disabled", (done) => {
+		const spy1 = spy();
+		const spy2 = spy();
+		const oneDay = 1000 * 3600 * 24;
+
+		discoverGateway(false).then(spy1);
+		wait(oneDay).then(() => {
+			spy1.should.not.have.been.called;
+
+			discoverGateway(-1).then(spy2);
+			wait(oneDay).then(() => {
+				spy2.should.not.have.been.called;
+				done();
+			});
+			clock.tick(oneDay);
+		});
+		clock.tick(oneDay);
+	});
+
+	it("discoverGateway should check the received responses if they represent a tradfri gateway", (done) => {
+		const leSpy = spy();
+		findOneCalled = createDeferredPromise();
+		const retVal = discoverGateway(false);
+		retVal.then(leSpy);
+
+		// wait until we have a findOne callback
+		findOneCalled.then(() => {
+			// no service response
+			findOneCallback(null);
+			leSpy.should.not.have.been.called;
+
+			// service response without txt property
+			findOneCallback({});
+			leSpy.should.not.have.been.called;
+
+			// service response without name property
+			findOneCallback({ txt: "foo" });
+			leSpy.should.not.have.been.called;
+
+			// service response with wrong name property
+			findOneCallback({ txt: "foo", name: "wrong" });
+			leSpy.should.not.have.been.called;
+
+			// correct service response
+			findOneCallback({
+				name: "gw-abcdef123456",
+				txt: { version: "1.2.3" },
+				addresses: ["localhost"],
+			});
+			retVal.should.become({
+				name: "gw-abcdef123456",
+				version: "1.2.3",
+				addresses: ["localhost"],
+			}).then(() => done());
+		});
+	});
+
+});

src/lib/discovery.ts

@@ -9,7 +9,7 @@ export interface DiscoveredGateway {
 
 /**
  * Auto-discover a tradfri gateway on the network.
- * @param timeout (optional) Time in milliseconds to wait for a response. Default 10000. 
+ * @param timeout (optional) Time in milliseconds to wait for a response. Default 10000.
  * Pass false or a negative number to explicitly wait forever.
  */
 export function discoverGateway(timeout: number | false = 10000): Promise<DiscoveredGateway> {
@@ -20,7 +20,7 @@ export function discoverGateway(timeout: number | false = 10000): Promise<Discov
 		const mdnsBrowser = bonjour.findOne(
 			{ type: "coap", protocol: "udp" },
 			(service: any) => {
-				if (!service || !service.txt || !service.name.startsWith("gw-")) return;
+				if (!service || !service.txt || !service.name || !service.name.startsWith("gw-")) return;
 
 				if (timer != null) clearTimeout(timer);
 				const foundDevice = {
@@ -38,7 +38,7 @@ export function discoverGateway(timeout: number | false = 10000): Promise<Discov
 				resolve(null);
 			}, timeout);
 		}
-		
+
 		mdnsBrowser.start();
 	});
 }

test/mocks.ts

@@ -4,11 +4,6 @@
 
 import { assert, expect, should, use } from "chai";
 import { spy, stub } from "sinon";
-import * as sinonChai from "sinon-chai";
-
-// enable the should interface with sinon
-should();
-use(sinonChai);
 
 import { CoapClient as coap, CoapResponse } from "node-coap-client";
 import { ContentFormats } from "node-coap-client/build/ContentFormats";