@xenon-device-management/xenon 1.1.0

package/lib/test/unit/AndroidDeviceManager.spec.js

@@ -0,0 +1,178 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const sinon_1 = __importDefault(require("sinon"));
+const adbkit_1 = __importDefault(require("@devicefarmer/adbkit"));
+const appium_adb_1 = require("appium-adb");
+const chai_1 = require("chai");
+const test_container_1 = require("../helpers/test-container");
+const GetAdbOriginal_1 = require("./GetAdbOriginal");
+const sandbox = sinon_1.default.createSandbox();
+describe('Android Device Manager', () => {
+    let adb;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        sandbox.restore();
+        adb = yield (0, GetAdbOriginal_1.getAdbOriginal)();
+        // Neutralize real ADB discovery
+        sandbox.stub(appium_adb_1.ADB, 'createADB').returns(Promise.resolve(adb));
+        sandbox.stub(adbkit_1.default, 'createClient').returns({
+            trackDevices: () => {
+                const tracker = {
+                    on: sandbox.stub(),
+                };
+                return tracker;
+            },
+        });
+    }));
+    afterEach(function () {
+        sandbox.restore();
+    });
+    it('Android Device List to have added state', () => __awaiter(void 0, void 0, void 0, function* () {
+        const androidDevices = (0, test_container_1.createTestAndroidManager)({ platform: 'android' });
+        // @ts-expect-error - Accessing private member for testing
+        androidDevices.adbAvailable = true;
+        sandbox.stub(androidDevices, 'getConnectedDevices').returns(Promise.resolve(new Map([
+            [
+                adb,
+                [
+                    { udid: 'emulator-5554', state: 'device' },
+                    { udid: 'emulator-5555', state: 'device' },
+                ],
+            ],
+        ])));
+        sandbox.stub(androidDevices, 'getDeviceVersion').returns(Promise.resolve('9'));
+        sandbox.stub(androidDevices, 'getDeviceName').returns(Promise.resolve('sdk_phone_x86'));
+        sandbox.stub(androidDevices, 'isRealDevice').returns(Promise.resolve(false));
+        const devices = yield androidDevices.getDevices({ androidDeviceType: 'both' }, []);
+        (0, chai_1.expect)(devices.length).to.be.equal(2);
+        (0, chai_1.expect)(devices[0]).to.have.property('state', 'device');
+        (0, chai_1.expect)(devices[1]).to.have.property('state', 'device');
+    }));
+    it('Android Device List to have added state - Only emulators', () => __awaiter(void 0, void 0, void 0, function* () {
+        const androidDevices = (0, test_container_1.createTestAndroidManager)({
+            platform: 'android',
+            androidDeviceType: 'simulated',
+        });
+        // @ts-expect-error - Accessing private member for testing
+        androidDevices.adbAvailable = true;
+        sandbox.stub(androidDevices, 'getConnectedDevices').returns(Promise.resolve(new Map([
+            [
+                adb,
+                [
+                    { udid: 'emulator-5554', state: 'device' },
+                    { udid: 'emulator-5555', state: 'device' },
+                ],
+            ],
+        ])));
+        sandbox.stub(androidDevices, 'getDeviceVersion').returns(Promise.resolve('9'));
+        sandbox.stub(androidDevices, 'getDeviceName').returns(Promise.resolve('sdk_phone_x86'));
+        sandbox.stub(androidDevices, 'isRealDevice').returns(Promise.resolve(false));
+        const devices = yield androidDevices.getDevices({ androidDeviceType: 'simulated' }, []);
+        (0, chai_1.expect)(devices.length).to.be.equal(2);
+        (0, chai_1.expect)(devices[0]).to.have.property('state', 'device');
+        (0, chai_1.expect)(devices[1]).to.have.property('state', 'device');
+    }));
+    it('Android Device List to have added state - Only real devices', () => __awaiter(void 0, void 0, void 0, function* () {
+        const androidDevices = (0, test_container_1.createTestAndroidManager)({
+            platform: 'android',
+            androidDeviceType: 'real',
+        });
+        // @ts-expect-error - Accessing private member for testing
+        androidDevices.adbAvailable = true;
+        sandbox.stub(androidDevices, 'getConnectedDevices').returns(Promise.resolve(new Map([
+            [
+                adb,
+                [
+                    { udid: 'emulator-5554', state: 'device' },
+                    { udid: 'YOGAA1BBB4124', state: 'device' },
+                ],
+            ],
+        ])));
+        sandbox.stub(androidDevices, 'getDeviceVersion').returns(Promise.resolve('9'));
+        sandbox.stub(androidDevices, 'getDeviceName').returns(Promise.resolve('sdk_phone_x86'));
+        sandbox.stub(androidDevices, 'isRealDevice').callsFake((...args) => __awaiter(void 0, void 0, void 0, function* () {
+            const udid = args[1];
+            return udid === 'YOGAA1BBB4124';
+        }));
+        const devices = yield androidDevices.getDevices({ androidDeviceType: 'real' }, []);
+        (0, chai_1.expect)(devices.length).to.be.equal(1);
+        (0, chai_1.expect)(devices[0]).to.have.property('udid', 'YOGAA1BBB4124');
+    }));
+    it('Android Device List to have host as remoteMachineProxyIP if provided', () => __awaiter(void 0, void 0, void 0, function* () {
+        const androidDevices = (0, test_container_1.createTestAndroidManager)({
+            platform: 'android',
+            remoteMachineProxyIP: '192.168.0.104',
+        });
+        // @ts-expect-error - Accessing private member for testing
+        androidDevices.adbAvailable = true;
+        sandbox.stub(androidDevices, 'getConnectedDevices').returns(Promise.resolve(new Map([
+            [
+                adb,
+                [
+                    { udid: 'emulator-5554', state: 'device' },
+                    { udid: 'YOGAA1BBB4124', state: 'device' },
+                ],
+            ],
+        ])));
+        sandbox.stub(androidDevices, 'getDeviceVersion').returns(Promise.resolve('9'));
+        sandbox.stub(androidDevices, 'getDeviceName').returns(Promise.resolve('sdk_phone_x86'));
+        sandbox.stub(androidDevices, 'isRealDevice').returns(Promise.resolve(true));
+        const devices = yield androidDevices.getDevices({ androidDeviceType: 'both' }, []);
+        (0, chai_1.expect)(devices.length).to.be.equal(2);
+        (0, chai_1.expect)(devices[0]).to.have.property('host', 'http://192.168.0.104:4723');
+        (0, chai_1.expect)(devices[1]).to.have.property('host', 'http://192.168.0.104:4723');
+    }));
+    it("Should handle error when adb doesn't respond", () => __awaiter(void 0, void 0, void 0, function* () {
+        const androidDevices = (0, test_container_1.createTestAndroidManager)({ platform: 'android' });
+        // @ts-expect-error - Accessing private member for testing
+        androidDevices.adbAvailable = true;
+        sandbox.stub(androidDevices, 'getConnectedDevices').returns(Promise.resolve(new Map([
+            [
+                adb,
+                [
+                    { udid: 'emulator-9999', state: 'device' },
+                    { udid: 'emulator-7777', state: 'device' },
+                ],
+            ],
+        ])));
+        sandbox.stub(androidDevices, 'deviceInfo').callsFake((device) => __awaiter(void 0, void 0, void 0, function* () {
+            if (device.udid === 'emulator-9999') {
+                throw new Error('Adb timeout');
+            }
+            return { udid: device.udid, state: device.state, host: 'Local' };
+        }));
+        const devices = yield androidDevices.getDevices({ androidDeviceType: 'both' }, []);
+        // check that emulator-7777 is returned and emulator-9999 is not
+        (0, chai_1.expect)(devices.length).to.be.equal(1);
+        (0, chai_1.expect)(devices[0]).to.have.property('udid', 'emulator-7777');
+    }));
+    it('should handle device never completing boot', () => __awaiter(void 0, void 0, void 0, function* () {
+        const androidDevices = (0, test_container_1.createTestAndroidManager)({ platform: 'android' });
+        // @ts-expect-error - Accessing private member for testing
+        androidDevices.adbAvailable = true;
+        sandbox.stub(androidDevices, 'getAdb').returns(Promise.resolve({ adbInstance: adb }));
+        sandbox
+            .stub(adb, 'shell')
+            .withArgs(['getprop', 'sys.boot_completed'])
+            .throwsException(new Error('Adb timeout'));
+        (0, chai_1.expect)(() => {
+            androidDevices.onDeviceAdded(adb, {
+                udid: 'emulator-9999',
+                state: 'device',
+                host: 'Local',
+            });
+        }).to.not.throw();
+    }));
+});

package/lib/test/unit/ChromeDriverManager.spec.js

@@ -0,0 +1,26 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ChromeDriverManager_1 = __importDefault(require("../../src/device-managers/ChromeDriverManager"));
+const support_1 = require("@appium/support");
+const chromeUtils_1 = require("../../src/chromeUtils");
+describe('Chrome Driver Manager', function () {
+    this.timeout(500000);
+    it.skip('Should fetch chrome driver for given version', () => __awaiter(this, void 0, void 0, function* () {
+        const chromeDriverManager = yield ChromeDriverManager_1.default.getInstance();
+        yield chromeDriverManager.downloadChromeDriver(83);
+        yield chromeDriverManager.downloadChromeDriver(84);
+        (yield support_1.fs.readdir(yield (0, chromeUtils_1.getChromedriverBinaryPath)((0, chromeUtils_1.getModuleRoot)()))).length.should.be.eql(3);
+    }));
+});

package/lib/test/unit/CleanupService.spec.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const CleanupService_1 = require("../../src/services/CleanupService");
+const typedi_1 = require("typedi");
+require("reflect-metadata");
+describe('CleanupService Unit Tests', () => {
+    let cleanupService;
+    beforeEach(() => {
+        cleanupService = typedi_1.Container.get(CleanupService_1.CleanupService);
+    });
+    it('should be instantiable via TypeDI', () => {
+        (0, chai_1.expect)(cleanupService).to.be.an.instanceOf(CleanupService_1.CleanupService);
+    });
+    it('should have runCleanup method', () => {
+        (0, chai_1.expect)(cleanupService.runCleanup).to.be.a('function');
+    });
+    it('should have purgeBuild method', () => {
+        (0, chai_1.expect)(cleanupService.purgeBuild).to.be.a('function');
+    });
+});

package/lib/test/unit/DeviceModel.spec.js

@@ -0,0 +1,157 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const db_1 = require("../../src/data-service/db");
+const device_service_1 = require("../../src/data-service/device-service");
+const devices_1 = require("./fixtures/devices");
+const chai_1 = require("chai");
+const device_service_2 = require("../../src/data-service/device-service");
+const sinon_1 = __importDefault(require("sinon"));
+const sandbox = sinon_1.default.createSandbox();
+const test_container_1 = require("../helpers/test-container");
+describe('Model Test', () => __awaiter(void 0, void 0, void 0, function* () {
+    before('Add device collection', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, test_container_1.resetTestContainer)();
+        (0, chai_1.expect)((yield db_1.XenonDatabase.DeviceModel).chain().find().data().length).to.be.equal(0);
+        (0, chai_1.expect)(devices_1.deviceMock.length).to.be.greaterThanOrEqual(1);
+        // console.log(`deviceMock length: ${deviceMock.length}`);
+        (yield db_1.XenonDatabase.DeviceModel).insert(devices_1.deviceMock);
+        (yield db_1.XenonDatabase.db).saveDatabase();
+        // console.log(`result: ${result}`);
+        // console.log(`device model length: ${deviceModel.find().length}`);
+        (yield db_1.XenonDatabase.DeviceModel)
+            .chain()
+            .find()
+            .data()
+            .length.should.be.equal(devices_1.deviceMock.length);
+    }));
+    after('clean', () => {
+        sandbox.restore();
+    });
+    it('Should remove device from old pool when new poll call does not have the device', () => __awaiter(void 0, void 0, void 0, function* () {
+        const findDevice = (yield db_1.XenonDatabase.DeviceModel)
+            .chain()
+            .find({ udid: 'emulator-5570' })
+            .data();
+        (0, chai_1.expect)(findDevice.length).to.be.equal(1);
+        yield (0, device_service_2.removeDevice)([{ udid: 'emulator-5570', host: '127.0.0.1' }]);
+        const updatedDeviceList = (yield db_1.XenonDatabase.DeviceModel)
+            .chain()
+            .find({ udid: 'emulator-5570' })
+            .data();
+        (0, chai_1.expect)(updatedDeviceList).to.deep.equal([]);
+    }));
+    it('Should update new device polled into the existing device list', () => __awaiter(void 0, void 0, void 0, function* () {
+        const newDeviceList = [
+            {
+                busy: false,
+                state: 'device',
+                udid: 'emulator-9994',
+                platform: 'android',
+                host: '127.0.0.1',
+            },
+        ];
+        yield (0, device_service_2.addNewDevice)(newDeviceList);
+        const updatedDeviceList = (yield db_1.XenonDatabase.DeviceModel)
+            .chain()
+            .find({ udid: 'emulator-9994' })
+            .data();
+        (0, chai_1.expect)(updatedDeviceList.length).to.be.greaterThanOrEqual(1);
+    }));
+    it('Should update the ios simulator state from shutdown to booted', () => __awaiter(void 0, void 0, void 0, function* () {
+        const newDeviceList = [
+            {
+                busy: false,
+                state: 'device',
+                udid: 'emulator-5554',
+                platform: 'android',
+                offline: false,
+                host: '127.0.0.1',
+            },
+            {
+                busy: false,
+                state: 'device',
+                udid: 'emulator-5556',
+                platform: 'android',
+                offline: false,
+                host: '127.0.0.1',
+            },
+            {
+                name: 'iPad Air',
+                udid: '0FBCBDCC-2FF1-4FCA-B034-60ABC86ED888',
+                state: 'Shutdown',
+                deviceType: 'simulator',
+                sdk: '13.5',
+                platform: 'ios',
+                busy: true,
+                realDevice: false,
+                offline: false,
+                host: '127.0.0.1',
+            },
+            {
+                name: 'iPad Air (3rd generation)',
+                udid: '0FBCBDCC-2FF1-4FCA-B034-60ABC86ED866',
+                state: 'Shutdown',
+                deviceType: 'simulator',
+                sdk: '13.5',
+                platform: 'ios',
+                busy: false,
+                realDevice: false,
+                offline: false,
+                host: '127.0.0.1',
+            },
+        ];
+        yield (0, device_service_2.setSimulatorState)(newDeviceList);
+        const updatedDeviceList = (yield db_1.XenonDatabase.DeviceModel)
+            .chain()
+            .find({ udid: '0FBCBDCC-2FF1-4FCA-B034-60ABC86ED888' })
+            .data();
+        (0, chai_1.expect)(updatedDeviceList[0].state).to.be.equal('Shutdown');
+    }));
+    it('Should handle concurrent update to device list', () => __awaiter(void 0, void 0, void 0, function* () {
+        // create bunch of devices using loop
+        const newDeviceList = [];
+        for (let i = 0; i < 10; i++) {
+            newDeviceList.push({
+                busy: false,
+                state: 'device',
+                udid: `emulator-${i}`,
+                platform: 'android',
+                offline: false,
+                host: '127.0.0.1',
+            });
+        }
+        // create a function to add new device with random delay to simulate concurrent calls from multiple nodes
+        const delayedAddDevice = (newDeviceList) => __awaiter(void 0, void 0, void 0, function* () {
+            yield new Promise((resolve) => setTimeout(resolve, Math.random() * 1000));
+            for (const device of newDeviceList) {
+                yield new Promise((resolve) => setTimeout(resolve, Math.random() * 1000));
+                yield (0, device_service_2.addNewDevice)([device]);
+            }
+        });
+        const existingDevices = yield (0, device_service_1.getAllDevices)();
+        // create some parallel calls to addNewDevice
+        yield Promise.all([delayedAddDevice(newDeviceList), delayedAddDevice(existingDevices)]);
+        // verify that all devices are added to the db
+        const updatedDeviceList = (yield db_1.XenonDatabase.DeviceModel)
+            .chain()
+            .find({ platform: 'android' })
+            .data();
+        // every newDeviceList should be listed under updatedDeviceList
+        // map udid only to make it simple
+        const addedDeviceUdids = newDeviceList.map((device) => device.udid);
+        const updatedDeviceUdids = updatedDeviceList.map((device) => device.udid);
+        addedDeviceUdids.forEach((udid) => updatedDeviceUdids.includes(udid).should.be.true);
+    }));
+}));