Qt/QML edition

dependencies/drivelist/tests/drivelist.spec.ts

@@ -0,0 +1,114 @@
+/*
+ * Copyright 2016 Balena.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ok } from 'assert';
+import { expect } from 'chai';
+import * as os from 'os';
+import { stub } from 'sinon';
+
+import { list } from '../lib';
+
+describe('Drivelist', () => {
+	describe('.list()', () => {
+		it('should yield results', async () => {
+			const devices = await list();
+			devices.forEach(device => {
+				ok(device.enumerator, `Invalid enumerator: ${device.enumerator}`);
+				ok(device.busType, `Invalid busType: ${device.busType}`);
+				ok(device.device, `Invalid device: ${device.device}`);
+				ok(device.raw, `Invalid raw: ${device.raw}`);
+				ok(device.description, `Invalid description: ${device.description}`);
+				ok(device.error === null, `Invalid error: ${device.error}`);
+				ok(
+					device.size === null || Number.isFinite(device.size),
+					`Invalid size: ${device.size}`,
+				);
+				ok(
+					Number.isFinite(device.blockSize),
+					`Invalid blockSize: ${device.blockSize}`,
+				);
+				ok(
+					Number.isFinite(device.logicalBlockSize),
+					`Invalid logicalBlockSize: ${device.logicalBlockSize}`,
+				);
+				ok(
+					Array.isArray(device.mountpoints),
+					`Invalid mountpoints: ${device.mountpoints}`,
+				);
+				ok(
+					device.isReadOnly === null || typeof device.isReadOnly === 'boolean',
+					`Invalid isReadOnly flag: ${device.isReadOnly}`,
+				);
+				ok(
+					device.isSystem === null || typeof device.isSystem === 'boolean',
+					`Invalid isSystem flag: ${device.isSystem}`,
+				);
+				ok(
+					device.isVirtual === null || typeof device.isVirtual === 'boolean',
+					`Invalid isVirtual flag: ${device.isVirtual}`,
+				);
+				ok(
+					device.isRemovable === null ||
+						typeof device.isRemovable === 'boolean',
+					`Invalid isRemovable flag: ${device.isRemovable}`,
+				);
+				ok(
+					device.isCard === null || typeof device.isCard === 'boolean',
+					`Invalid isCard flag: ${device.isCard}`,
+				);
+				ok(
+					device.isSCSI === null || typeof device.isSCSI === 'boolean',
+					`Invalid isSCSI flag: ${device.isSCSI}`,
+				);
+				ok(
+					device.isUSB === null || typeof device.isUSB === 'boolean',
+					`Invalid isUSB flag: ${device.isUSB}`,
+				);
+				ok(
+					device.isUAS === null || typeof device.isUAS === 'boolean',
+					`Invalid isUAS flag: ${device.isUAS}`,
+				);
+			});
+		});
+
+		describe('given an unsupported os', () => {
+			beforeEach(() => {
+				// @ts-ignore
+				this.osPlatformStub = stub(os, 'platform');
+				// @ts-ignore
+				this.osPlatformStub.returns('foobar');
+			});
+
+			afterEach(() => {
+				// @ts-ignore
+				this.osPlatformStub.restore();
+			});
+
+			it('should yield an unsupported error', async () => {
+				try {
+					await list();
+				} catch (error) {
+					expect(error).to.be.an.instanceof(Error);
+					expect(error.message).to.equal(
+						'Your OS is not supported by this module: foobar',
+					);
+					return;
+				}
+				ok(false, 'Expected error not thrown');
+			});
+		});
+	});
+});