chore: introduce jest tests

Author: nistei

Diff for: jest.config.js

@@ -0,0 +1,6 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  collectCoverage: true
+};

Diff for: src/airport.spec.ts

@@ -0,0 +1,6 @@
+describe('Airport', () => {
+    // API currently out of order
+    test('API', () => {
+
+    });
+});

Diff for: src/atc.spec.ts

@@ -0,0 +1,14 @@
+import { ATC } from './index';
+
+describe('ATC', () => {
+    test('should return an ATC response', async () => {
+        await expect(ATC.get('vatsim'))
+            .resolves.toMatchObject(expect.any(Array));
+    });
+
+    describe('error handling', () => {
+        test('should require a valid source', async () => {
+            await expect(ATC.get('')).rejects.toThrow('No source provided');
+        });
+    });
+});

Diff for: src/atis.spec.ts

@@ -0,0 +1,29 @@
+import { Atis } from './index';
+
+describe('ATIS', () => {
+    test('should return an ATIS response', async () => {
+        const res = await Atis.get('KJFK');
+        console.log(res);
+
+        expect(res.icao).toEqual('KJFK');
+        expect(res.source).toEqual('FAA');
+    });
+
+    test('should allow selection of sources', async () => {
+        const res = await Atis.get('KJFK', 'FAA');
+        console.log(res);
+
+        expect(res.icao).toEqual('KJFK');
+        expect(res.source).toEqual('FAA');
+    });
+
+    describe('error handling', () => {
+        test('should require an ICAO', async () => {
+            await expect(Atis.get('')).rejects.toThrow('No ICAO provided');
+        });
+
+        test('should 404 on unknown ICAOs', async () => {
+            await expect(Atis.get('NONEXISTING')).rejects.toThrow('Request failed with status code 404');
+        });
+    });
+});

Diff for: src/charts.spec.ts

@@ -0,0 +1,15 @@
+import { Charts } from './index';
+
+describe('Charts', () => {
+    test('should return a charts response', async () => {
+        await expect(Charts.get('KJFK')).resolves.toMatchObject({
+            icao: 'KJFK',
+        });
+    });
+
+    describe('error handling', () => {
+        test('should require an ICAO', async () => {
+            await expect(Charts.get('')).rejects.toThrow('No ICAO provided');
+        });
+    });
+});

Diff for: src/git-versions.spec.ts

@@ -0,0 +1,70 @@
+import { GitVersions } from './index';
+
+describe('GitVersions', () => {
+    describe('Get newest commit', () => {
+        test('should return return newest commit', async () => {
+            await expect(GitVersions.getNewestCommit('flybywiresim', 'a32nx', 'master'))
+                .resolves.toMatchObject({
+                    sha: expect.any(String),
+                    shortSha: expect.any(String),
+                    timestamp: expect.any(Date),
+                });
+        });
+
+        test('should require all arguments', async () => {
+            await expect(GitVersions.getNewestCommit('', '', ''))
+                .rejects.toThrow('Missing argument');
+        });
+    });
+
+    describe('Get releases', () => {
+        test('should return return all releases', async () => {
+            await expect(GitVersions.getReleases('flybywiresim', 'a32nx'))
+                .resolves.toEqual(expect.arrayContaining([
+                    expect.objectContaining({
+                        name: expect.any(String),
+                        publishedAt: expect.any(Date),
+                        htmlUrl: expect.any(String),
+                        body: expect.any(String),
+                    }),
+                ]));
+        });
+
+        test('should require all arguments', async () => {
+            await expect(GitVersions.getReleases('', ''))
+                .rejects.toThrow('Missing argument');
+        });
+    });
+
+    describe('Get pulls', () => {
+        test('should return return all pulls', async () => {
+            await expect(GitVersions.getPulls('flybywiresim', 'a32nx'))
+                .resolves.toEqual(expect.arrayContaining([
+                    expect.objectContaining({
+                        number: expect.any(Number),
+                        title: expect.any(String),
+                        author: expect.any(String),
+                        labels: expect.any(Array),
+                        isDraft: expect.any(Boolean),
+                    }),
+                ]));
+        });
+
+        test('should require all arguments', async () => {
+            await expect(GitVersions.getPulls('', ''))
+                .rejects.toThrow('Missing argument');
+        });
+    });
+
+    describe('Get artifact', () => {
+        test('should return return an artifact for a PR', async () => {
+            await expect(GitVersions.getArtifact('flybywiresim', 'a32nx', '1'))
+                .resolves.toMatchObject({ artifactUrl: '' });
+        });
+
+        test('should require all arguments', async () => {
+            await expect(GitVersions.getArtifact('', '', ''))
+                .rejects.toThrow('Missing argument');
+        });
+    });
+});

Diff for: src/gnss.spec.ts

@@ -0,0 +1,7 @@
+import { GNSS } from './index';
+
+describe('GNSS', () => {
+    test('should return a GNSS response array', async () => {
+        await expect(GNSS.get()).resolves.toMatchObject(expect.any(Array));
+    });
+});

Diff for: src/metar.spec.ts

@@ -0,0 +1,31 @@
+import { Metar } from './index';
+
+describe('METAR', () => {
+    test('should return a METAR response', async () => {
+        const res = await Metar.get('KJFK');
+        console.log(res);
+
+        expect(res.icao).toEqual('KJFK');
+        expect(res.source).toEqual('Vatsim');
+        expect(res.metar).not.toEqual('');
+    });
+
+    test('should allow selection of sources', async () => {
+        const res = await Metar.get('KJFK', 'MS');
+        console.log(res);
+
+        expect(res.icao).toEqual('KJFK');
+        expect(res.source).toEqual('MS');
+        expect(res.metar).not.toEqual('');
+    });
+
+    describe('error handling', () => {
+        test('should require an ICAO', async () => {
+            await expect(Metar.get('')).rejects.toThrow('No ICAO provided');
+        });
+
+        test('should 404 on unknown ICAOs', async () => {
+            await expect(Metar.get('NONEXISTING')).rejects.toThrow('Request failed with status code 404');
+        });
+    });
+});

Diff for: src/taf.spec.ts

@@ -0,0 +1,29 @@
+import { Taf } from './index';
+
+describe('TAF', () => {
+    test('should return a TAF response', async () => {
+        const res = await Taf.get('KJFK');
+        console.log(res);
+
+        expect(res.icao).toEqual('KJFK');
+        expect(res.source).toEqual('AviationWeather');
+    });
+
+    test('should allow selection of sources', async () => {
+        const res = await Taf.get('KJFK', 'FAA');
+        console.log(res);
+
+        expect(res.icao).toEqual('KJFK');
+        expect(res.source).toEqual('FAA');
+    });
+
+    describe('error handling', () => {
+        test('should require an ICAO', async () => {
+            await expect(Taf.get('')).rejects.toThrow('No ICAO provided');
+        });
+
+        test('should 404 on unknown ICAOs', async () => {
+            await expect(Taf.get('NONEXISTING')).rejects.toThrow('Request failed with status code 404');
+        });
+    });
+});