isy-nodejs 1.0.9-alpha.1 → 1.3.24

package/test/testsuite.js

@@ -62,546 +62,605 @@ var testServerUserName = 'admin';
 var testServerPassword = 'password';
 
 var sampleBaseDeviceList = [
-    {address: sampleDimmableLight, type: 'DimmableLight'}, 
-    {address: sampleKeypadDimmableButton, type: 'DimmableLight'}, 
-    {address: sampleZWaveLock, type: 'SecureLock'},
-    {address: sampleMotionSensorSensor, type: 'MotionSensor'},
-    {address: sampleMorningLincLock, type: 'DoorLock'},
-    {address: sampleIOLincSensor, type: 'DoorWindowSensor'}, 
-    {address: sampleFanLincFan, type: 'Fan'}, 
-    {address: sampleFanLincLight, type: 'DimmableLight'}, 
-    {address: sampleOutletLinc, type: 'Light'},
-    {address: sampleOnOffLight, type: 'Light'},
-    {address: sampleApplianceLinc, type: 'Outlet'},
-    {address: sampleLightFromMotionLightKit, type: 'Light'},
-    {address: sampleDoorWindowSensor, type: 'DoorWindowSensor'},
-    {address: sampleGenericDevice, type: 'Unknown'}
-    ];
+	{ address: sampleDimmableLight, type: 'DimmableLight' },
+	{ address: sampleKeypadDimmableButton, type: 'DimmableLight' },
+	{ address: sampleZWaveLock, type: 'SecureLock' },
+	{ address: sampleMotionSensorSensor, type: 'MotionSensor' },
+	{ address: sampleMorningLincLock, type: 'DoorLock' },
+	{ address: sampleIOLincSensor, type: 'DoorWindowSensor' },
+	{ address: sampleFanLincFan, type: 'Fan' },
+	{ address: sampleFanLincLight, type: 'DimmableLight' },
+	{ address: sampleOutletLinc, type: 'Light' },
+	{ address: sampleOnOffLight, type: 'Light' },
+	{ address: sampleApplianceLinc, type: 'Outlet' },
+	{ address: sampleLightFromMotionLightKit, type: 'Light' },
+	{ address: sampleDoorWindowSensor, type: 'DoorWindowSensor' },
+	{ address: sampleGenericDevice, type: 'Unknown' },
+];
 
 function countDevices(done, elkEnabled, scenesEnabled) {
-    var isy = new ISY(testServerAddress, testServerUserName, testServerPassword, true, function() {}, false, true);        
-    assert.doesNotThrow(function() { 
-        isy.initialize(function() {
-            var deviceList = isy.getDeviceList();
-            var lightCount = 0;
-            var lockCount = 0;
-            var doorWindowCount = 0;
-            var motionCount = 0;
-            var fanCount = 0;
-            var outletCount = 0;
-            var sceneCount = 0;
-            var elkAlarmCount = 0;
-            var elkSensorCount = 0;
-            var genericCount = 0;
-            var dimmableLightCount = 0;
-            for(var deviceIndex = 0; deviceIndex < deviceList.length; deviceIndex++) {
-                var device = deviceList[deviceIndex];
-                assert(device.address != sampleDisabledDevice, 'Should not enumerate a disabled device');
-                if(device instanceof ISYLightDevice) {
-                    lightCount++;
-                    if(device.isDimmable) {
-                        dimmableLightCount++;
-                    }
-                } else if(device instanceof ISYLockDevice) {
-                    lockCount++;
-                } else if(device instanceof ISYOutletDevice) {
-                    outletCount++;
-                } else if(device instanceof ISYDoorWindowDevice) {
-                    doorWindowCount++;
-                } else if(device instanceof ISYFanDevice) {
-                    fanCount++;
-                } else if(device instanceof ISYMotionSensorDevice) {
-                    motionCount++;
-                } else if(device instanceof ISYScene) {
-                    sceneCount++;
-                } else if(device instanceof ELKAlarmPanelDevice) {
-                    elkAlarmCount++;
-                } else if(device instanceof ElkAlarmSensor) {
-                    elkSensorCount++;
-                } else if(device instanceof ISYBaseDevice) {
-                    genericCount++;
-                }
-            }
-            assert.equal(lightCount, expectedLightCount, "Light count is incorrect");
-            assert.equal(lockCount, expectedLockCount, "Lock count incorrect");
-            assert.equal(doorWindowCount, expectedDoorWindowCount, "Door window sensor count is incorrect");
-            assert.equal(motionCount, expectedMotionCount, "Motion sensor count is incorrect");
-            assert.equal(fanCount, expectedFanCount, "Fan count is incorrect");
-            assert.equal(outletCount, expectedOutletCount, "Outlet count is incorrect");
-            assert.equal(sceneCount, (scenesEnabled) ? expectedSceneCount : 0, "Scene count is incorrect"); 
-            assert.equal(elkAlarmCount, (elkEnabled) ? expectedElkAlarmCount : 0, "Elk alarm panel count is incorrect");
-            assert.equal(elkSensorCount, (elkEnabled) ? expectedElkSensorCount : 0, "Elk sensor count is incorrect");
-            assert.equal(genericCount, expectedGenericCount, 'Generic device count is incorrect');
-            assert.equal(dimmableLightCount, expectedDimmableLightCount, 'Dimmable light count is incorrect');
-            var panel = isy.getElkAlarmPanel();
-            if(elkEnabled) {
-                assert(panel instanceof ELKAlarmPanelDevice, "Should have a panel");
-            } else {
-                assert(panel == null, "Should have no panel when elk disabled");
-            }
-            if(scenesEnabled) {
-                assert.equal(isy.getSceneList().length, sceneCount, 'Should have scenes in the scene list');
-            }
-            done();
-        });
-    });
+	var isy = new ISY(testServerAddress, testServerUserName, testServerPassword, true, function () {}, false, true);
+	assert.doesNotThrow(function () {
+		isy.initialize(function () {
+			var deviceList = isy.getDeviceList();
+			var lightCount = 0;
+			var lockCount = 0;
+			var doorWindowCount = 0;
+			var motionCount = 0;
+			var fanCount = 0;
+			var outletCount = 0;
+			var sceneCount = 0;
+			var elkAlarmCount = 0;
+			var elkSensorCount = 0;
+			var genericCount = 0;
+			var dimmableLightCount = 0;
+			for (var deviceIndex = 0; deviceIndex < deviceList.length; deviceIndex++) {
+				var device = deviceList[deviceIndex];
+				assert(device.address != sampleDisabledDevice, 'Should not enumerate a disabled device');
+				if (device instanceof ISYLightDevice) {
+					lightCount++;
+					if (device.isDimmable) {
+						dimmableLightCount++;
+					}
+				} else if (device instanceof ISYLockDevice) {
+					lockCount++;
+				} else if (device instanceof ISYOutletDevice) {
+					outletCount++;
+				} else if (device instanceof ISYDoorWindowDevice) {
+					doorWindowCount++;
+				} else if (device instanceof ISYFanDevice) {
+					fanCount++;
+				} else if (device instanceof ISYMotionSensorDevice) {
+					motionCount++;
+				} else if (device instanceof ISYScene) {
+					sceneCount++;
+				} else if (device instanceof ELKAlarmPanelDevice) {
+					elkAlarmCount++;
+				} else if (device instanceof ElkAlarmSensor) {
+					elkSensorCount++;
+				} else if (device instanceof ISYBaseDevice) {
+					genericCount++;
+				}
+			}
+			assert.equal(lightCount, expectedLightCount, 'Light count is incorrect');
+			assert.equal(lockCount, expectedLockCount, 'Lock count incorrect');
+			assert.equal(doorWindowCount, expectedDoorWindowCount, 'Door window sensor count is incorrect');
+			assert.equal(motionCount, expectedMotionCount, 'Motion sensor count is incorrect');
+			assert.equal(fanCount, expectedFanCount, 'Fan count is incorrect');
+			assert.equal(outletCount, expectedOutletCount, 'Outlet count is incorrect');
+			assert.equal(sceneCount, scenesEnabled ? expectedSceneCount : 0, 'Scene count is incorrect');
+			assert.equal(elkAlarmCount, elkEnabled ? expectedElkAlarmCount : 0, 'Elk alarm panel count is incorrect');
+			assert.equal(elkSensorCount, elkEnabled ? expectedElkSensorCount : 0, 'Elk sensor count is incorrect');
+			assert.equal(genericCount, expectedGenericCount, 'Generic device count is incorrect');
+			assert.equal(dimmableLightCount, expectedDimmableLightCount, 'Dimmable light count is incorrect');
+			var panel = isy.getElkAlarmPanel();
+			if (elkEnabled) {
+				assert(panel instanceof ELKAlarmPanelDevice, 'Should have a panel');
+			} else {
+				assert(panel == null, 'Should have no panel when elk disabled');
+			}
+			if (scenesEnabled) {
+				assert.equal(isy.getSceneList().length, sceneCount, 'Should have scenes in the scene list');
+			}
+			done();
+		});
+	});
 }
 
 function checkDevice(testParam, device) {
-    assert(device != null && device != undefined, 'Should have found the specified device for address '+testParam.address);
-    assert.equal(device.address, testParam.address, 'Should have expected address for address '+testParam.address);
-    assert.equal(device.deviceType, testParam.type, 'Should have expected type for address '+testParam.address);
-        
+	assert(
+		device != null && device != undefined,
+		'Should have found the specified device for address ' + testParam.address
+	);
+	assert.equal(device.address, testParam.address, 'Should have expected address for address ' + testParam.address);
+	assert.equal(device.deviceType, testParam.type, 'Should have expected type for address ' + testParam.address);
 }
 
 function checkForExpectedDevices(done, elkEnabled, scenesEnabled) {
-    var isy = new ISY(testServerAddress, testServerUserName, testServerPassword, true, function() {}, false, true);        
-    assert.doesNotThrow(function() { 
-        isy.initialize(function() {
-            for(var addressIndex = 0; addressIndex < sampleBaseDeviceList.length; addressIndex++) {
-                checkDevice(sampleBaseDeviceList[addressIndex], isy.getDevice(sampleBaseDeviceList[addressIndex].address));
-            } 
-            if(elkEnabled) {
-                checkDevice({address: sampleElkZone, type: 'AlarmDoorWindowSensor'}, isy.getDevice(sampleElkZone));
-            }
-            if(scenesEnabled) {
-                checkDevice({address: sampleSceneId, type: 'Scene'}, isy.getDevice(sampleSceneId));
-            }
-            if(!elkEnabled) {
-                assert(isy.getDevice(sampleElkZone)==null, "Elk disabled, shouldn't have an elk device");
-            }
-            if(!scenesEnabled) {
-                assert(isy.getDevice(sampleSceneId)==null, 'Scenes disabled should not have scene in device list');
-            }
-            done();
-        });
-    });
+	var isy = new ISY(testServerAddress, testServerUserName, testServerPassword, true, function () {}, false, true);
+	assert.doesNotThrow(function () {
+		isy.initialize(function () {
+			for (var addressIndex = 0; addressIndex < sampleBaseDeviceList.length; addressIndex++) {
+				checkDevice(sampleBaseDeviceList[addressIndex], isy.getDevice(sampleBaseDeviceList[addressIndex].address));
+			}
+			if (elkEnabled) {
+				checkDevice({ address: sampleElkZone, type: 'AlarmDoorWindowSensor' }, isy.getDevice(sampleElkZone));
+			}
+			if (scenesEnabled) {
+				checkDevice({ address: sampleSceneId, type: 'Scene' }, isy.getDevice(sampleSceneId));
+			}
+			if (!elkEnabled) {
+				assert(isy.getDevice(sampleElkZone) == null, "Elk disabled, shouldn't have an elk device");
+			}
+			if (!scenesEnabled) {
+				assert(isy.getDevice(sampleSceneId) == null, 'Scenes disabled should not have scene in device list');
+			}
+			done();
+		});
+	});
 }
 
 function resetServerState(done) {
-    restler.get('http://'+testServerAddress+'/config/reset').on('complete', function(result, response) { done(); });
+	restler.get('http://' + testServerAddress + '/config/reset').on('complete', function (result, response) {
+		done();
+	});
 }
 
-function setVariableFailureMode(shouldFail,done) {
-    restler.get('http://'+testServerAddress+'/config/failVariableCalls/'+shouldFail.toString()).on('complete', function(result, response) { done(); });
+function setVariableFailureMode(shouldFail, done) {
+	restler
+		.get('http://' + testServerAddress + '/config/failVariableCalls/' + shouldFail.toString())
+		.on('complete', function (result, response) {
+			done();
+		});
 }
 
 // Used to send set to on command for sensors. Doesn't work on real ISY.
-function sendServerOnCommand(isy, deviceAddress,done) {
-    isy.sendRestCommand(deviceAddress, 'DON', null, function() { done(); });
+function sendServerOnCommand(isy, deviceAddress, done) {
+	isy.sendRestCommand(deviceAddress, 'DON', null, function () {
+		done();
+	});
 }
 
 function sendServerZoneCommand(isy, zoneId, command, done) {
-    isy.sendRestCommand(zoneId, command, null, function() { done(); });
+	isy.sendRestCommand(zoneId, command, null, function () {
+		done();
+	});
 }
 
-describe('ISY Device and scene Enumeration and Creation', function() {
-  describe('Device enumeration (scenes=true,elk=true)', function() {
-      it('Basic startup should work and right number of devices should be enumerated ', function(done) {
-          var isy = new ISY(testServerAddress, testServerUserName, testServerPassword, true, function() {}, false, true);
-          assert.doesNotThrow(function() {
-              isy.initialize(function() {
-                  assert.equal(isy.getDeviceList().length, expectedDeviceCountWithElkWithScenes, 'Device count incorrect');
-                  done();
-              });
-          });
-      });
-    it('Right device count and types are present', function(done) {
-        countDevices(done,true,true);
-    });    
-    it('Device lookup works and expected variety of devices present', function(done) {
-        checkForExpectedDevices(done,true,true);
-    });    
-  });
-  describe('Device enumeration(scenes=true,elk=false)', function() {
-    it('Basic startup should work and right number of devices should be enumerated ', function(done) {
-        var isy = new ISY(testServerAddress, testServerUserName, testServerPassword, false, function() {}, false, true);
-            assert.doesNotThrow(function() {
-            isy.initialize(function() {
-                assert.equal(isy.getDeviceList().length, expectedDeviceCountWithoutElkWithScenes, 'Device count incorrect');
-                done();
-            });
-        });
-    });
-    it('Right device count and types are present', function(done) {
-        countDevices(done,true,true);
-    });    
-    it('Device lookup works and expected variety of devices present', function(done) {
-        checkForExpectedDevices(done,true,true);
-    });      
-  });  
-  describe('Device enumeration (scenes=false,elk=false)', function() {
-    it('Basic startup should work and right number of devices should be enumerated ', function(done) {
-      var isy = new ISY(testServerAddress, testServerUserName, testServerPassword, false, function() {}, false, false);        
-      assert.doesNotThrow(function() { 
-        isy.initialize(function() {
-            assert.equal(isy.getDeviceList().length, expectedDeviceCountWithoutElkNoScenes, 'Device count incorrect');
-            done();
-        });
-      });
-    });
-    it('Right device count and types are present', function(done) {
-        countDevices(done,true,true);
-    });    
-    it('Device lookup works and expected variety of devices present', function(done) {
-        checkForExpectedDevices(done,true,true);
-    });      
-  }); 
-  describe('Device enumeration (scenes=false,elk=true)', function() {
-    it('Basic startup should work and right number of devices should be enumerated ', function(done) {
-      var isy = new ISY(testServerAddress, testServerUserName, testServerPassword, true, function() {}, false, false);        
-      assert.doesNotThrow(function() { 
-        isy.initialize(function() {
-            assert.equal(isy.getDeviceList().length, expectedDeviceCountWithElkNoScenes, 'Device count incorrect');
-            done();
-        });
-      });
-    });
-    it('Right device count and types are present', function(done) {
-        countDevices(done,true,true);
-    });    
-    it('Device lookup works and expected variety of devices present', function(done) {
-        checkForExpectedDevices(done,true,true);
-    });      
-  }); 
-  describe('#check scene indexing', function() {
-    it('Basic scene lookup', function(done) {
-      var isy = new ISY(testServerAddress, testServerUserName, testServerPassword, true, function() {}, false, false);        
-      assert.doesNotThrow(function() { 
-        isy.initialize(function() {
-            assert.equal(isy.getSceneList().length, expectedSceneCount, 'Scene count incorrect');
-            assert(isy.getScene(sampleSceneId) instanceof ISYScene, 'Scene lookup working');
-            assert.equal(isy.getScene(sampleSceneId).address, sampleSceneId, 'The right scene object is returned' )
-            done();
-        });
-      });
-    });      
-  }); 
+describe('ISY Device and scene Enumeration and Creation', function () {
+	describe('Device enumeration (scenes=true,elk=true)', function () {
+		it('Basic startup should work and right number of devices should be enumerated ', function (done) {
+			var isy = new ISY(testServerAddress, testServerUserName, testServerPassword, true, function () {}, false, true);
+			assert.doesNotThrow(function () {
+				isy.initialize(function () {
+					assert.equal(isy.getDeviceList().length, expectedDeviceCountWithElkWithScenes, 'Device count incorrect');
+					done();
+				});
+			});
+		});
+		it('Right device count and types are present', function (done) {
+			countDevices(done, true, true);
+		});
+		it('Device lookup works and expected variety of devices present', function (done) {
+			checkForExpectedDevices(done, true, true);
+		});
+	});
+	describe('Device enumeration(scenes=true,elk=false)', function () {
+		it('Basic startup should work and right number of devices should be enumerated ', function (done) {
+			var isy = new ISY(testServerAddress, testServerUserName, testServerPassword, false, function () {}, false, true);
+			assert.doesNotThrow(function () {
+				isy.initialize(function () {
+					assert.equal(isy.getDeviceList().length, expectedDeviceCountWithoutElkWithScenes, 'Device count incorrect');
+					done();
+				});
+			});
+		});
+		it('Right device count and types are present', function (done) {
+			countDevices(done, true, true);
+		});
+		it('Device lookup works and expected variety of devices present', function (done) {
+			checkForExpectedDevices(done, true, true);
+		});
+	});
+	describe('Device enumeration (scenes=false,elk=false)', function () {
+		it('Basic startup should work and right number of devices should be enumerated ', function (done) {
+			var isy = new ISY(testServerAddress, testServerUserName, testServerPassword, false, function () {}, false, false);
+			assert.doesNotThrow(function () {
+				isy.initialize(function () {
+					assert.equal(isy.getDeviceList().length, expectedDeviceCountWithoutElkNoScenes, 'Device count incorrect');
+					done();
+				});
+			});
+		});
+		it('Right device count and types are present', function (done) {
+			countDevices(done, true, true);
+		});
+		it('Device lookup works and expected variety of devices present', function (done) {
+			checkForExpectedDevices(done, true, true);
+		});
+	});
+	describe('Device enumeration (scenes=false,elk=true)', function () {
+		it('Basic startup should work and right number of devices should be enumerated ', function (done) {
+			var isy = new ISY(testServerAddress, testServerUserName, testServerPassword, true, function () {}, false, false);
+			assert.doesNotThrow(function () {
+				isy.initialize(function () {
+					assert.equal(isy.getDeviceList().length, expectedDeviceCountWithElkNoScenes, 'Device count incorrect');
+					done();
+				});
+			});
+		});
+		it('Right device count and types are present', function (done) {
+			countDevices(done, true, true);
+		});
+		it('Device lookup works and expected variety of devices present', function (done) {
+			checkForExpectedDevices(done, true, true);
+		});
+	});
+	describe('#check scene indexing', function () {
+		it('Basic scene lookup', function (done) {
+			var isy = new ISY(testServerAddress, testServerUserName, testServerPassword, true, function () {}, false, false);
+			assert.doesNotThrow(function () {
+				isy.initialize(function () {
+					assert.equal(isy.getSceneList().length, expectedSceneCount, 'Scene count incorrect');
+					assert(isy.getScene(sampleSceneId) instanceof ISYScene, 'Scene lookup working');
+					assert.equal(isy.getScene(sampleSceneId).address, sampleSceneId, 'The right scene object is returned');
+					done();
+				});
+			});
+		});
+	});
 });
 
 function runTrueFalseTest(isy, deviceId, stateFunctionToTest, sendFunctionToTest, done) {
-    var deviceToCheck = isy.getDevice(deviceId);
-    var startingChangedTimestamp = deviceToCheck.lastChanged;
-    var stateToExpect = !deviceToCheck[stateFunctionToTest]();
-    var testRunIndex = 0;
-    isy.changeCallback = function (isy, changedDevice) {
-        if(changedDevice.address == deviceToCheck.address) {
-            assert.equal(stateToExpect, deviceToCheck[stateFunctionToTest](), 'Should have expected state for device: '+deviceToCheck.address);
-            assert(changedDevice.lastChanged > startingChangedTimestamp, 'lastChanged property should have changed.')
-            if(testRunIndex == 0) {
-                stateToExpect = !deviceToCheck[stateFunctionToTest]();
-                deviceToCheck[sendFunctionToTest](stateToExpect, function() {});
-                testRunIndex++;
-            } else {
-                done();
-            }
-        }
-    }
-    deviceToCheck[sendFunctionToTest](stateToExpect, function() {});    
+	var deviceToCheck = isy.getDevice(deviceId);
+	var startingChangedTimestamp = deviceToCheck.lastChanged;
+	var stateToExpect = !deviceToCheck[stateFunctionToTest]();
+	var testRunIndex = 0;
+	isy.changeCallback = function (isy, changedDevice) {
+		if (changedDevice.address == deviceToCheck.address) {
+			assert.equal(
+				stateToExpect,
+				deviceToCheck[stateFunctionToTest](),
+				'Should have expected state for device: ' + deviceToCheck.address
+			);
+			assert(changedDevice.lastChanged > startingChangedTimestamp, 'lastChanged property should have changed.');
+			if (testRunIndex == 0) {
+				stateToExpect = !deviceToCheck[stateFunctionToTest]();
+				deviceToCheck[sendFunctionToTest](stateToExpect, function () {});
+				testRunIndex++;
+			} else {
+				done();
+			}
+		}
+	};
+	deviceToCheck[sendFunctionToTest](stateToExpect, function () {});
 }
 
 function runFanTest(isy, deviceId, fanSpeed, done) {
-    var deviceToCheck = isy.getDevice(deviceId);
-    var startingChangedTimestamp = deviceToCheck.lastChanged;
-    isy.changeCallback = function (isy, changedDevice) {
-        if (deviceId == changedDevice.address) {
-            assert.equal(fanSpeed, deviceToCheck.getCurrentFanState(), 'Should have expected fan speed for device: ' + deviceToCheck.address);
-            assert(changedDevice.lastChanged > startingChangedTimestamp, 'lastChanged property should have changed.')
-            done();
-        }
-    }
-    deviceToCheck.sendFanCommand(fanSpeed, function () {});
+	var deviceToCheck = isy.getDevice(deviceId);
+	var startingChangedTimestamp = deviceToCheck.lastChanged;
+	isy.changeCallback = function (isy, changedDevice) {
+		if (deviceId == changedDevice.address) {
+			assert.equal(
+				fanSpeed,
+				deviceToCheck.getCurrentFanState(),
+				'Should have expected fan speed for device: ' + deviceToCheck.address
+			);
+			assert(changedDevice.lastChanged > startingChangedTimestamp, 'lastChanged property should have changed.');
+			done();
+		}
+	};
+	deviceToCheck.sendFanCommand(fanSpeed, function () {});
 }
 
-
 function runSensorTest(isy, deviceId, stateFunctionToTest, done) {
-    var deviceToCheck = isy.getDevice(deviceId);
-    var startingChangedDate = deviceToCheck.lastChanged;
-    isy.changeCallback = function (isy, changedDevice) {
-        if(changedDevice.address == deviceToCheck.address) {
-            assert(deviceToCheck[stateFunctionToTest](), 'Sensor should show true state: '+deviceToCheck.address);
-            assert(deviceToCheck.lastChanged > startingChangedDate, 'Sesnor last changed data should have updated');
-            done();
-        }
-    }    
-    sendServerOnCommand(isy, deviceId, function() {});
+	var deviceToCheck = isy.getDevice(deviceId);
+	var startingChangedDate = deviceToCheck.lastChanged;
+	isy.changeCallback = function (isy, changedDevice) {
+		if (changedDevice.address == deviceToCheck.address) {
+			assert(deviceToCheck[stateFunctionToTest](), 'Sensor should show true state: ' + deviceToCheck.address);
+			assert(deviceToCheck.lastChanged > startingChangedDate, 'Sesnor last changed data should have updated');
+			done();
+		}
+	};
+	sendServerOnCommand(isy, deviceId, function () {});
 }
 
 function runSceneTest(isy, sceneId, lightStateToSet, impactedDeviceList, done) {
-    var sceneToCheck = isy.getDevice(sceneId);
-    var startingChangedDate = sceneToCheck.lastChanged;
-    var devicesToCheck = [];
-    var doneCalled = false;
-    for(var index = 0; index < impactedDeviceList.length; index++) {
-        devicesToCheck.push(impactedDeviceList[index]);
-    }
-    isy.changeCallback = function (isy,changedDevice) {
-        for(var deviceIndex = 0; deviceIndex < devicesToCheck.length; deviceIndex++) {
-            if(devicesToCheck[deviceIndex] == changedDevice.address) {
-                if(sceneToCheck.address != devicesToCheck[deviceIndex]) {
-                    assert.equal(changedDevice.getCurrentLightState(), lightStateToSet, "Should be setting devices to the state we expect");
-                }
-                devicesToCheck.splice(deviceIndex, 1);
-                break;
-            }
-        }
-        if(devicesToCheck.length == 0) {
-            if(!doneCalled) {
-                assert.equal(sceneToCheck.getCurrentLightState(), lightStateToSet, 'Scene should now be set to the desired state');
-                assert(sceneToCheck.getAreAllLightsInSpecifiedState(lightStateToSet), "Once all lights are accounted for getAreAllLightsInSpecifiedState() should be true" );
-                assert(sceneToCheck.lastChanged > startingChangedDate, 'Scene last changed data should have updated');
-                done();
-                doneCalled = true;
-            }
-        } else if (devicesToCheck.length > 1) {
-            assert(!sceneToCheck.getAreAllLightsInSpecifiedState(lightStateToSet), "Until all lights are accounted for getAreAllLightsInSpecifiedState() should be false" );
-        }
-    }
-    sceneToCheck.sendLightCommand(lightStateToSet, function() {});
+	var sceneToCheck = isy.getDevice(sceneId);
+	var startingChangedDate = sceneToCheck.lastChanged;
+	var devicesToCheck = [];
+	var doneCalled = false;
+	for (var index = 0; index < impactedDeviceList.length; index++) {
+		devicesToCheck.push(impactedDeviceList[index]);
+	}
+	isy.changeCallback = function (isy, changedDevice) {
+		for (var deviceIndex = 0; deviceIndex < devicesToCheck.length; deviceIndex++) {
+			if (devicesToCheck[deviceIndex] == changedDevice.address) {
+				if (sceneToCheck.address != devicesToCheck[deviceIndex]) {
+					assert.equal(
+						changedDevice.getCurrentLightState(),
+						lightStateToSet,
+						'Should be setting devices to the state we expect'
+					);
+				}
+				devicesToCheck.splice(deviceIndex, 1);
+				break;
+			}
+		}
+		if (devicesToCheck.length == 0) {
+			if (!doneCalled) {
+				assert.equal(
+					sceneToCheck.getCurrentLightState(),
+					lightStateToSet,
+					'Scene should now be set to the desired state'
+				);
+				assert(
+					sceneToCheck.getAreAllLightsInSpecifiedState(lightStateToSet),
+					'Once all lights are accounted for getAreAllLightsInSpecifiedState() should be true'
+				);
+				assert(sceneToCheck.lastChanged > startingChangedDate, 'Scene last changed data should have updated');
+				done();
+				doneCalled = true;
+			}
+		} else if (devicesToCheck.length > 1) {
+			assert(
+				!sceneToCheck.getAreAllLightsInSpecifiedState(lightStateToSet),
+				'Until all lights are accounted for getAreAllLightsInSpecifiedState() should be false'
+			);
+		}
+	};
+	sceneToCheck.sendLightCommand(lightStateToSet, function () {});
 }
 
 function runElkZoneTest(isy, zoneId, command, expectedCount, expectedResult, stateFunctionToTest, done) {
-    var callbackCount = 0;
-    var deviceId = "ElkZone"+zoneId;
-    var deviceToCheck = isy.getDevice(deviceId);
-    var startingChangedTimestamp = new Date();
-    isy.changeCallback = function (isy, changedDevice) {
-        if(changedDevice.address == deviceToCheck.address) {
-            callbackCount++;
-            if(callbackCount == expectedCount) {
-                assert.equal(deviceToCheck[stateFunctionToTest](), expectedResult, 'Elk Sensor should show expected state: '+deviceToCheck.address);
-                assert(deviceToCheck.lastChanged > startingChangedTimestamp, 'lastChanged property should have changed.')
-                done();
-            }
-        }
-    }
-    sendServerZoneCommand(isy, zoneId, command, function() {});
+	var callbackCount = 0;
+	var deviceId = 'ElkZone' + zoneId;
+	var deviceToCheck = isy.getDevice(deviceId);
+	var startingChangedTimestamp = new Date();
+	isy.changeCallback = function (isy, changedDevice) {
+		if (changedDevice.address == deviceToCheck.address) {
+			callbackCount++;
+			if (callbackCount == expectedCount) {
+				assert.equal(
+					deviceToCheck[stateFunctionToTest](),
+					expectedResult,
+					'Elk Sensor should show expected state: ' + deviceToCheck.address
+				);
+				assert(deviceToCheck.lastChanged > startingChangedTimestamp, 'lastChanged property should have changed.');
+				done();
+			}
+		}
+	};
+	sendServerZoneCommand(isy, zoneId, command, function () {});
 }
 
+describe('ISY Device change notifications', function () {
+	var notifyFunc = null;
+	function testChangeCallback(isy, device) {
+		if (notifyFunc != null) {
+			notifyFunc(device);
+		}
+	}
+	var isy = null;
+	beforeEach(function (done) {
+		resetServerState(function () {
+			isy = new ISY(testServerAddress, testServerUserName, testServerPassword, true, testChangeCallback, false, true);
+			isy.initialize(done);
+		});
+	});
+	describe('Dimmable light change notifications', function () {
+		it('Light on and off state (non-dimmable)', function (done) {
+			runTrueFalseTest(isy, sampleOnOffLight, 'getCurrentLightState', 'sendLightCommand', done);
+			assert(!isy.getDevice(sampleOnOffLight).isDimmable, 'On off light should not be dimmable');
+		});
+		it('Light on and off state (dimmable)', function (done) {
+			runTrueFalseTest(isy, sampleDimmableLight, 'getCurrentLightState', 'sendLightCommand', done);
+			assert(isy.getDevice(sampleDimmableLight).isDimmable, 'On off light should not be dimmable');
+		});
+		it('Light on and off state (keybad dimmable button)', function (done) {
+			runTrueFalseTest(isy, sampleKeypadDimmableButton, 'getCurrentLightState', 'sendLightCommand', done);
+		});
+		it('Light on and off state (fanlinc light)', function (done) {
+			runTrueFalseTest(isy, sampleKeypadDimmableButton, 'getCurrentLightState', 'sendLightCommand', done);
+		});
+		it('Light on and off state (motion light)', function (done) {
+			runTrueFalseTest(isy, sampleKeypadDimmableButton, 'getCurrentLightState', 'sendLightCommand', done);
+		});
+		it('Light dim state change notification to 50%', function (done) {
+			var deviceToCheck = isy.getDevice(sampleDimmableLight);
+			var dimStateToExpect = 50;
+			deviceToCheck.sendLightCommand(false, function () {});
+			notifyFunc = function (changedDevice) {
+				if (changedDevice.address == deviceToCheck.address) {
+					assert.equal(
+						dimStateToExpect,
+						deviceToCheck.getCurrentLightDimState(),
+						'Should have expected state for device: ' + deviceToCheck.address
+					);
+					assert(deviceToCheck.getCurrentLightState(), 'Ensure light is on');
+					done();
+				}
+			};
+			deviceToCheck.sendLightDimCommand(dimStateToExpect, function () {});
+		});
 
-describe('ISY Device change notifications', function() {
-    var notifyFunc = null;
-    function testChangeCallback(isy,device) {
-        if(notifyFunc != null) {
-            notifyFunc(device);
-        }
-    }
-    var isy = null;
-    beforeEach(function(done) {
-        resetServerState(function() { 
-            isy = new ISY(testServerAddress, testServerUserName, testServerPassword, true, testChangeCallback, false, true);         
-            isy.initialize(done);
-        });                
-    });
-    describe('Dimmable light change notifications', function() {
-        it('Light on and off state (non-dimmable)', function(done) {
-            runTrueFalseTest(isy, sampleOnOffLight, 'getCurrentLightState', 'sendLightCommand', done);
-            assert(!isy.getDevice(sampleOnOffLight).isDimmable, 'On off light should not be dimmable');
-        });
-        it('Light on and off state (dimmable)', function(done) {
-            runTrueFalseTest(isy, sampleDimmableLight, 'getCurrentLightState', 'sendLightCommand', done);
-            assert(isy.getDevice(sampleDimmableLight).isDimmable, 'On off light should not be dimmable');
-        });
-        it('Light on and off state (keybad dimmable button)', function(done) {
-            runTrueFalseTest(isy, sampleKeypadDimmableButton, 'getCurrentLightState', 'sendLightCommand', done);
-        });
-        it('Light on and off state (fanlinc light)', function(done) {
-            runTrueFalseTest(isy, sampleKeypadDimmableButton, 'getCurrentLightState', 'sendLightCommand', done);
-        });        
-        it('Light on and off state (motion light)', function(done) {
-            runTrueFalseTest(isy, sampleKeypadDimmableButton, 'getCurrentLightState', 'sendLightCommand', done);
-        });        
-        it('Light dim state change notification to 50%', function(done) {
-            var deviceToCheck = isy.getDevice(sampleDimmableLight);
-            var dimStateToExpect = 50;
-            deviceToCheck.sendLightCommand(false, function() {});                        
-            notifyFunc = function (changedDevice) {
-                if(changedDevice.address == deviceToCheck.address) {
-                    assert.equal(dimStateToExpect, deviceToCheck.getCurrentLightDimState(), 'Should have expected state for device: '+deviceToCheck.address);
-                    assert(deviceToCheck.getCurrentLightState(), 'Ensure light is on');
-                    done();
-                }
-            }
-            deviceToCheck.sendLightDimCommand(dimStateToExpect, function() {});
-        });
-        
-        it('Light dim state change notification to on has 100 dim level', function(done) {
-            var deviceToCheck = isy.getDevice(sampleDimmableLight);
-            notifyFunc = function (changedDevice) {
-                if(changedDevice.address == deviceToCheck.address) {
-                    assert.equal(100, deviceToCheck.getCurrentLightDimState(), 'Should have expected state for device: '+deviceToCheck.address);
-                    assert(deviceToCheck.getCurrentLightState(), 'Ensure light is on');
-                    done();
-                }
-            }
-            deviceToCheck.sendLightCommand(true, function() {});
-        });      
-        it('Light dim state change notification to off has 0 dim level', function(done) {
-            var deviceToCheck = isy.getDevice(sampleDimmableLight);
-            var notifyCount = 0;
-            notifyFunc = function (changedDevice) {
-                if(changedDevice.address == deviceToCheck.address) {
-                    // Need to skip first notification as it is to turn the light on
-                    if(notifyCount > 0) {
-                        assert.equal(0, deviceToCheck.getCurrentLightDimState(), 'Should have expected state for device: '+deviceToCheck.address);
-                        assert(!deviceToCheck.getCurrentLightState(), 'Ensure light is on');
-                        done();
-                    } else {
-                        notifyCount++;
-                    }
-                }
-            }
-            // Need to turn it on first as default state for this light is off
-            deviceToCheck.sendLightCommand(true, function() {});
-            deviceToCheck.sendLightCommand(false, function() {});            
-        });          
-    });  
-    describe('Locks', function() {
-        it('Secure Lock locked and unlocked state', function(done) {
-            runTrueFalseTest(isy, sampleZWaveLock, 'getCurrentLockState', 'sendLockCommand', done);
-        });
-        it('MorningLinc Lock locked and unlocked state', function(done) {
-            runTrueFalseTest(isy, sampleMorningLincLock, 'getCurrentLockState', 'sendLockCommand', done);
-        });        
-    });
-    describe('Sensors', function() {
-        it('Insteon Motion Sensor Triggered', function(done) {
-            runSensorTest(isy, sampleMotionSensorSensor, 'getCurrentMotionSensorState', done);            
-        });
-        it('Insteon Door Window Sensor from IOLinc', function(done) {
-            runSensorTest(isy, sampleIOLincSensor, 'getCurrentDoorWindowState', done);            
-        });        
-         it('Insteon Door Window Sensor', function(done) {
-            runSensorTest(isy, sampleDoorWindowSensor, 'getCurrentDoorWindowState', done);            
-        });        
-    });    
-    describe('Outlets on and off2', function() {
-        it('ApplianceLinc on and off', function(done) {
-            assert.equal(isy.getDevice(sampleApplianceLinc).deviceType, 'Outlet', 'ApplianceLinc Should be an outlet');            
-            runTrueFalseTest(isy, sampleApplianceLinc, 'getCurrentOutletState', 'sendOutletCommand', done);
-        });        
-    });
-    describe('Fan levels', function() {
-        it('Set fan to low', function(done) {
-            var deviceToCheck = isy.getDevice(sampleFanLincFan);
-            runFanTest(isy, sampleFanLincFan, deviceToCheck.FAN_LEVEL_LOW, done);
-        });
-        it('Set fan to med', function(done) {
-            var deviceToCheck = isy.getDevice(sampleFanLincFan);
-            runFanTest(isy, sampleFanLincFan, deviceToCheck.FAN_LEVEL_MEDIUM, done);
-        });
-        it('Set fan to high', function(done) {
-            var deviceToCheck = isy.getDevice(sampleFanLincFanOffState);
-            runFanTest(isy, sampleFanLincFanOffState, deviceToCheck.FAN_LEVEL_HIGH, done);
-        });
-    });
-    describe('Scenes', function() {
-        it('Scene with all lights off turns them all on when scene is turned on and then turns them all off', function(done) {
-            runSceneTest(isy, sampleSceneWithAllLightsOff, true, sampleSceneWithAllLightsOffAllImpacted, function() {
-                runSceneTest(isy, sampleSceneWithAllLightsOff, false, sampleSceneWithAllLightsOffAllImpacted, done);
-            });
-        });
-    });
-    describe('Elk Sensors', function() {
-        it('Logical state change when you open then close', function(done) {
-            runElkZoneTest(isy, "1", "OPEN", 1, 2, 'getLogicalState', function() {
-                runElkZoneTest(isy, "1", "CLOSE", 1, 0,'getLogicalState', done);
-            });
-
-        });
-        it('Physical state change when you open then close', function(done) {
-            runElkZoneTest(isy, "1", "OPEN", 1, 1, 'getPhysicalState', function() {
-                runElkZoneTest(isy, "1", "CLOSE", 1, 2, 'getPhysicalState', done);
-            });
-        });
-    });
+		it('Light dim state change notification to on has 100 dim level', function (done) {
+			var deviceToCheck = isy.getDevice(sampleDimmableLight);
+			notifyFunc = function (changedDevice) {
+				if (changedDevice.address == deviceToCheck.address) {
+					assert.equal(
+						100,
+						deviceToCheck.getCurrentLightDimState(),
+						'Should have expected state for device: ' + deviceToCheck.address
+					);
+					assert(deviceToCheck.getCurrentLightState(), 'Ensure light is on');
+					done();
+				}
+			};
+			deviceToCheck.sendLightCommand(true, function () {});
+		});
+		it('Light dim state change notification to off has 0 dim level', function (done) {
+			var deviceToCheck = isy.getDevice(sampleDimmableLight);
+			var notifyCount = 0;
+			notifyFunc = function (changedDevice) {
+				if (changedDevice.address == deviceToCheck.address) {
+					// Need to skip first notification as it is to turn the light on
+					if (notifyCount > 0) {
+						assert.equal(
+							0,
+							deviceToCheck.getCurrentLightDimState(),
+							'Should have expected state for device: ' + deviceToCheck.address
+						);
+						assert(!deviceToCheck.getCurrentLightState(), 'Ensure light is on');
+						done();
+					} else {
+						notifyCount++;
+					}
+				}
+			};
+			// Need to turn it on first as default state for this light is off
+			deviceToCheck.sendLightCommand(true, function () {});
+			deviceToCheck.sendLightCommand(false, function () {});
+		});
+	});
+	describe('Locks', function () {
+		it('Secure Lock locked and unlocked state', function (done) {
+			runTrueFalseTest(isy, sampleZWaveLock, 'getCurrentLockState', 'sendLockCommand', done);
+		});
+		it('MorningLinc Lock locked and unlocked state', function (done) {
+			runTrueFalseTest(isy, sampleMorningLincLock, 'getCurrentLockState', 'sendLockCommand', done);
+		});
+	});
+	describe('Sensors', function () {
+		it('Insteon Motion Sensor Triggered', function (done) {
+			runSensorTest(isy, sampleMotionSensorSensor, 'getCurrentMotionSensorState', done);
+		});
+		it('Insteon Door Window Sensor from IOLinc', function (done) {
+			runSensorTest(isy, sampleIOLincSensor, 'getCurrentDoorWindowState', done);
+		});
+		it('Insteon Door Window Sensor', function (done) {
+			runSensorTest(isy, sampleDoorWindowSensor, 'getCurrentDoorWindowState', done);
+		});
+	});
+	describe('Outlets on and off2', function () {
+		it('ApplianceLinc on and off', function (done) {
+			assert.equal(isy.getDevice(sampleApplianceLinc).deviceType, 'Outlet', 'ApplianceLinc Should be an outlet');
+			runTrueFalseTest(isy, sampleApplianceLinc, 'getCurrentOutletState', 'sendOutletCommand', done);
+		});
+	});
+	describe('Fan levels', function () {
+		it('Set fan to low', function (done) {
+			var deviceToCheck = isy.getDevice(sampleFanLincFan);
+			runFanTest(isy, sampleFanLincFan, deviceToCheck.FAN_LEVEL_LOW, done);
+		});
+		it('Set fan to med', function (done) {
+			var deviceToCheck = isy.getDevice(sampleFanLincFan);
+			runFanTest(isy, sampleFanLincFan, deviceToCheck.FAN_LEVEL_MEDIUM, done);
+		});
+		it('Set fan to high', function (done) {
+			var deviceToCheck = isy.getDevice(sampleFanLincFanOffState);
+			runFanTest(isy, sampleFanLincFanOffState, deviceToCheck.FAN_LEVEL_HIGH, done);
+		});
+	});
+	describe('Scenes', function () {
+		it('Scene with all lights off turns them all on when scene is turned on and then turns them all off', function (done) {
+			runSceneTest(isy, sampleSceneWithAllLightsOff, true, sampleSceneWithAllLightsOffAllImpacted, function () {
+				runSceneTest(isy, sampleSceneWithAllLightsOff, false, sampleSceneWithAllLightsOffAllImpacted, done);
+			});
+		});
+	});
+	describe('Elk Sensors', function () {
+		it('Logical state change when you open then close', function (done) {
+			runElkZoneTest(isy, '1', 'OPEN', 1, 2, 'getLogicalState', function () {
+				runElkZoneTest(isy, '1', 'CLOSE', 1, 0, 'getLogicalState', done);
+			});
+		});
+		it('Physical state change when you open then close', function (done) {
+			runElkZoneTest(isy, '1', 'OPEN', 1, 1, 'getPhysicalState', function () {
+				runElkZoneTest(isy, '1', 'CLOSE', 1, 2, 'getPhysicalState', done);
+			});
+		});
+	});
 });
 
 function runVariableTest(variableType, variableId, variableValue, done) {
-    var initialTimeStamp = new Date();
-    function variableCheckCallback(isy, variable) {
-        if(variable.id == variableId && variable.type == variableType) {
-            assert.equal(variable.value, variableValue, "Variable should have been updated to expected value");
-            assert(variable.lastChanged > initialTimeStamp, "Variable last changed should have changed. Before: "+initialTimeStamp.toString()+" lastChanged: "+variable.lastChanged);
-            done();
-        }
-    }
-    resetServerState(function() {
-        var isy = new ISY(testServerAddress, testServerUserName, testServerPassword, true, function () {
-        }, false, true, false, variableCheckCallback);
-        isy.initialize(function() {
-            var variable = isy.getVariable(variableType, variableId);
-            assert(variable != null, "Should have found expected variable");
-            // Cheat and push back last changed date as this may run quick enough seconds haven't changed.
-            variable.lastChanged.setFullYear(2012);
-            initialTimeStamp = variable.lastChanged;
-            setTimeout(function() {
-                variable.sendSetValue(variableValue, function() {});
-            }, 2);
-
-        });
-    });
+	var initialTimeStamp = new Date();
+	function variableCheckCallback(isy, variable) {
+		if (variable.id == variableId && variable.type == variableType) {
+			assert.equal(variable.value, variableValue, 'Variable should have been updated to expected value');
+			assert(
+				variable.lastChanged > initialTimeStamp,
+				'Variable last changed should have changed. Before: ' +
+					initialTimeStamp.toString() +
+					' lastChanged: ' +
+					variable.lastChanged
+			);
+			done();
+		}
+	}
+	resetServerState(function () {
+		var isy = new ISY(
+			testServerAddress,
+			testServerUserName,
+			testServerPassword,
+			true,
+			function () {},
+			false,
+			true,
+			false,
+			variableCheckCallback
+		);
+		isy.initialize(function () {
+			var variable = isy.getVariable(variableType, variableId);
+			assert(variable != null, 'Should have found expected variable');
+			// Cheat and push back last changed date as this may run quick enough seconds haven't changed.
+			variable.lastChanged.setFullYear(2012);
+			initialTimeStamp = variable.lastChanged;
+			setTimeout(function () {
+				variable.sendSetValue(variableValue, function () {});
+			}, 2);
+		});
+	});
 }
-describe('ISY Variables', function() {
-    describe('Variable enumeration', function () {
-        it('Basic startup should work and right number of variables should be enumerated ', function (done) {
-            var isy = new ISY(testServerAddress, testServerUserName, testServerPassword, true, function () {
-            }, false, true);
-            assert.doesNotThrow(function () {
-                var type1Found = false;
-                var type2Found = false;
-                isy.initialize(function () {
-                    var type1Count = 0;
-                    var type2Count = 0;
-                    for(var index = 0; index < isy.getVariableList().length; index++) {
-                        var variable = isy.getVariableList()[index];
-                        if(variable.type == '1' && sampleType1VariableId == variable.id) {
-                            assert.equal(variable.name, sampleType1VariableName, "Type 1 variable should have expected name");
-                            type1Found = true;
-                        }
-                        if(variable.type == '2' && sampleType2VariableId == variable.id) {
-                            assert.equal(variable.name, sampleType2VariableName, "Type 2 variable name should have expected name");
-                            type2Found = true;
-                        }
-                        if(variable.type == '1') {
-                            type1Count++;
-                        } else if(variable.type == '2') {
-                            type2Count++;
-                        } else {
-                            assert(false, "Should not have any non type 1 or type 2 variables" );
-                        }
-                    }
-                    assert(type1Found, "Should have found expected type 1 variable");
-                    assert(type2Found, "Should have found expected type 2 variable");
-                    assert.equal(type1Count, expectedType1VariablesCount, "Variable type 1 count is not correct");
-                    assert.equal(type2Count, expectedType2VariablesCount, "Variable type 2 count is not correct");
-                    done();
-                });
-            });
-        });
-    });
-    describe('Handle no variables', function () {
-        it('Basic startup should still work when no variables defined ', function (done) {
-            setVariableFailureMode(true, function () {
-                var isy = new ISY(testServerAddress, testServerUserName, testServerPassword, true, function () {}, false, true);
-                assert.doesNotThrow(function () {
-                    isy.initialize(function () {
-                        assert(isy.getVariableList().length == 0, "Should have empty variable list");
-                        setVariableFailureMode(false, function () {
-                            done();
-                        });
-                    });
-                });
-            });
-
-        });
-    });
-    describe('Variable roundtrip + notifications', function () {
-        it('Type 1 variable roundtrip + notifications', function (done) {
-            runVariableTest('1', sampleType1VariableId, 5, done);
-        });
-        it('Type 2 variable roundtrip + notifications', function (done) {
-            runVariableTest('2', sampleType1VariableId, 5, done);
-        });
-    });
+describe('ISY Variables', function () {
+	describe('Variable enumeration', function () {
+		it('Basic startup should work and right number of variables should be enumerated ', function (done) {
+			var isy = new ISY(testServerAddress, testServerUserName, testServerPassword, true, function () {}, false, true);
+			assert.doesNotThrow(function () {
+				var type1Found = false;
+				var type2Found = false;
+				isy.initialize(function () {
+					var type1Count = 0;
+					var type2Count = 0;
+					for (var index = 0; index < isy.getVariableList().length; index++) {
+						var variable = isy.getVariableList()[index];
+						if (variable.type == '1' && sampleType1VariableId == variable.id) {
+							assert.equal(variable.name, sampleType1VariableName, 'Type 1 variable should have expected name');
+							type1Found = true;
+						}
+						if (variable.type == '2' && sampleType2VariableId == variable.id) {
+							assert.equal(variable.name, sampleType2VariableName, 'Type 2 variable name should have expected name');
+							type2Found = true;
+						}
+						if (variable.type == '1') {
+							type1Count++;
+						} else if (variable.type == '2') {
+							type2Count++;
+						} else {
+							assert(false, 'Should not have any non type 1 or type 2 variables');
+						}
+					}
+					assert(type1Found, 'Should have found expected type 1 variable');
+					assert(type2Found, 'Should have found expected type 2 variable');
+					assert.equal(type1Count, expectedType1VariablesCount, 'Variable type 1 count is not correct');
+					assert.equal(type2Count, expectedType2VariablesCount, 'Variable type 2 count is not correct');
+					done();
+				});
+			});
+		});
+	});
+	describe('Handle no variables', function () {
+		it('Basic startup should still work when no variables defined ', function (done) {
+			setVariableFailureMode(true, function () {
+				var isy = new ISY(testServerAddress, testServerUserName, testServerPassword, true, function () {}, false, true);
+				assert.doesNotThrow(function () {
+					isy.initialize(function () {
+						assert(isy.getVariableList().length == 0, 'Should have empty variable list');
+						setVariableFailureMode(false, function () {
+							done();
+						});
+					});
+				});
+			});
+		});
+	});
+	describe('Variable roundtrip + notifications', function () {
+		it('Type 1 variable roundtrip + notifications', function (done) {
+			runVariableTest('1', sampleType1VariableId, 5, done);
+		});
+		it('Type 2 variable roundtrip + notifications', function (done) {
+			runVariableTest('2', sampleType1VariableId, 5, done);
+		});
+	});
 });