homebridge-fujitsu-airstage
Version:
A Homebridge plugin to control devices that use the Fujitsu Airstage API.
1,667 lines (1,537 loc) • 47.2 kB
JavaScript
;
const assert = require('node:assert');
const { mock, test } = require('node:test');
const hap = require('hap-nodejs');
const MockHomebridge = require('../src/test/mock-homebridge');
const Platform = require('../src/platform');
const mockHomebridge = new MockHomebridge();
test('Platform#constructor configures classes using platform config', (context) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm'
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
assert.strictEqual(mockHomebridge.platform.log.success, mockHomebridge.platform.log.info);
assert.strictEqual(platform.airstageCloudClient.email, platformConfig.email);
assert.strictEqual(platform.airstageCloudClient.password, platformConfig.password);
assert.strictEqual(platform.airstageCloudClient._apiClient.region, platformConfig.region);
assert.strictEqual(platform.airstageCloudClient._apiClient.country, platformConfig.country);
assert.strictEqual(platform.airstageCloudClient._apiClient.language, platformConfig.language);
assert.strictEqual(platform.configManager.config, platformConfig);
assert.strictEqual(platform.configManager.api, mockHomebridge.platform.api);
assert.strictEqual(platform.accessoryManager.platform, platform);
assert.strictEqual(mockHomebridge.platform.api.on.mock.calls.length, 1);
assert.strictEqual(
mockHomebridge.platform.api.on.mock.calls[0].arguments[0],
'didFinishLaunching'
);
assert.strictEqual(
mockHomebridge.platform.api.on.mock.calls[0].arguments[1].name,
platform.discoverDevices.bind(platform).name
);
});
test('Platform#configureAccessory pushes accessory to accessories', (context) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm'
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
platform.configureAccessory('foo');
assert.strictEqual(platform.accessories.length, 1);
assert.strictEqual(platform.accessories[0], 'foo');
});
test('Platform#discoverDevices when airstageCloudClient.refreshTokenOrAuthenticate returns error', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm'
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback('refreshTokenOrAuthenticate error');
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, 'refreshTokenOrAuthenticate error');
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices updates platform config with access token', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm'
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
platform.airstageCloudClient._apiClient.accessToken = 'testAccessToken';
platform.airstageCloudClient._apiClient.accessTokenExpiry = new Date('2022-01-01');
platform.airstageCloudClient._apiClient.refreshToken = 'testRefreshToken';
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {'metadata': {}, 'parameters': {}});
}
);
// Mock configManager.saveTokens to verify correct values are saved
let savedTokens = null;
context.mock.method(
platform.configManager,
'saveTokens',
(accessToken, accessTokenExpiry, refreshToken) => {
savedTokens = {
accessToken,
accessTokenExpiry,
refreshToken
};
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
// Check that saveTokens was called with the correct values
assert.ok(savedTokens, 'saveTokens should be called');
assert.strictEqual(savedTokens.accessToken, 'testAccessToken');
assert.strictEqual(savedTokens.accessTokenExpiry.toISOString(), '2022-01-01T00:00:00.000Z');
assert.strictEqual(savedTokens.refreshToken, 'testRefreshToken');
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices registers accessory when enableHeaterCooler is true', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'enableHeaterCooler': true
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 1);
const accessory = platform.accessories[0];
assert.strictEqual(accessory.name, 'Test Device Heater Cooler');
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices does not register accessory when enableHeaterCooler is false', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'enableHeaterCooler': false
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 0);
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices registers accessory when enableThermostat is true', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enableThermostat': true
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 1);
const accessory = platform.accessories[0];
assert.strictEqual(accessory.name, 'Test Device Thermostat');
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices does not register accessory when enableThermostat is false', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enableThermostat': false
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 0);
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices registers accessory when enableFan is true', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enableFan': true
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 1);
const accessory = platform.accessories[0];
assert.strictEqual(accessory.name, 'Test Device Fan');
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices does not register accessory when enableFan is false', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enableFan': false
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 0);
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices registers accessory when enableVerticalAirflowDirection is true', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enableVerticalAirflowDirection': true
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 1);
const accessory = platform.accessories[0];
assert.strictEqual(accessory.name, 'Test Device Vertical Airflow Direction');
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices does not register accessory when enableVerticalAirflowDirection is false', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enableVerticalAirflowDirection': false
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 0);
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices registers accessory when enableAutoFanSpeedSwitch is true', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enableAutoFanSpeedSwitch': true
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 1);
const accessory = platform.accessories[0];
assert.strictEqual(accessory.name, 'Test Device Auto Fan Speed Switch');
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices does not register accessory when enableAutoFanSpeedSwitch is false', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enableAutoFanSpeedSwitch': false
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 0);
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices registers accessory when enableDryModeSwitch is true', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enableDryModeSwitch': true
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 1);
const accessory = platform.accessories[0];
assert.strictEqual(accessory.name, 'Test Device Dry Mode Switch');
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices does not register accessory when enableDryModeSwitch is false', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enableDryModeSwitch': false
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 0);
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices registers accessory when enableEconomySwitch is true', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enableEconomySwitch': true
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 1);
const accessory = platform.accessories[0];
assert.strictEqual(accessory.name, 'Test Device Economy Switch');
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices does not register accessory when enableEconomySwitch is false', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enableEconomySwitch': false
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 0);
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices registers accessory when enableEnergySavingFanSwitch is true', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enableEnergySavingFanSwitch': true
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 1);
const accessory = platform.accessories[0];
assert.strictEqual(accessory.name, 'Test Device Energy Saving Fan Switch');
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices does not register accessory when enableEnergySavingFanSwitch is false', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enableEnergySavingFanSwitch': false
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 0);
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices registers accessory when enableFanModeSwitch is true', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enableFanModeSwitch': true
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 1);
const accessory = platform.accessories[0];
assert.strictEqual(accessory.name, 'Test Device Fan Mode Switch');
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices does not register accessory when enableFanModeSwitch is false', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enableFanModeSwitch': false
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 0);
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices registers accessory when enableMinimumHeatModeSwitch is true', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enableMinimumHeatModeSwitch': true
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 1);
const accessory = platform.accessories[0];
assert.strictEqual(accessory.name, 'Test Device Minimum Heat Mode Switch');
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices does not register accessory when enableMinimumHeatModeSwitch is false', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enableMinimumHeatModeSwitch': false
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 0);
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices registers accessory when enablePowerfulSwitch is true', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enablePowerfulSwitch': true
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 1);
const accessory = platform.accessories[0];
assert.strictEqual(accessory.name, 'Test Device Powerful Switch');
mockHomebridge.resetMocks();
done();
});
});
test('Platform#discoverDevices does not register accessory when enablePowerfulSwitch is false', (context, done) => {
const platformConfig = {
'platform': 'fujitsu-airstage',
'enableCloudControl': true,
'region': 'us',
'country': 'United States',
'language': 'en',
'email': 'test@example.com',
'password': 'test1234',
'cloudPollingInterval': 30,
'lanDevices': [],
'lanTemperatureScale': 'C',
'lanPollingInterval': 30,
'lanPollingIntervalUnits': 'm',
'enablePowerfulSwitch': false
};
const platform = new Platform(
mockHomebridge.platform.log,
platformConfig,
mockHomebridge.platform.api,
false
);
context.mock.method(
platform.airstageCloudClient,
'refreshTokenOrAuthenticate',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getUserMetadata',
(callback) => {
callback(null);
}
);
context.mock.method(
platform.airstageCloudClient,
'getDevices',
(limit, callback) => {
callback(null, {
'metadata': {
'testDevice': {
'deviceName': 'Test Device'
}
},
'parameters': {
'testDevice': {
'iu_model': 'Fujitsu Mini Split'
}
}
});
}
);
platform.discoverDevices(function(error) {
assert.strictEqual(error, null);
assert.strictEqual(platform.accessories.length, 0);
mockHomebridge.resetMocks();
done();
});
});