EDSM unit tests.

.idea/dictionaries/marley.xml

@@ -0,0 +1,7 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="marley">
+    <words>
+      <w>edsm</w>
+    </words>
+  </dictionary>
+</component>

.idea/inspectionProfiles/Project_Default.xml

@@ -1,6 +1,12 @@
 <component name="InspectionProjectProfileManager">
   <profile version="1.0">
     <option name="myName" value="Project Default" />
+    <inspection_tool class="ExceptionCaughtLocallyJS" enabled="false" level="WARNING" enabled_by_default="false" />
     <inspection_tool class="JSIgnoredPromiseFromCall" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
+    <inspection_tool class="SpellCheckingInspection" enabled="true" level="TYPO" enabled_by_default="true">
+      <option name="processCode" value="false" />
+      <option name="processLiterals" value="true" />
+      <option name="processComments" value="true" />
+    </inspection_tool>
   </profile>
 </component>

src/models/EDSM.ts

@@ -1,51 +1,56 @@
-import type { systemEstimatedValue } from '../@types/edsmResponses';
+import type {systemEstimatedValue} from '../@types/edsmResponses';
 
 const EventEmitter = require('node:events');
 
-import { Log } from './Log';
-import { System } from './System';
+import {Log} from './Log';
+import {System} from './System';
 
 export class EDSM extends EventEmitter {
-    static #instance: EDSM;
+  static #instance: EDSM;
 
-    private constructor() {
-        super();
+  private constructor() {
+    super();
+  }
+
+  static connect(): EDSM {
+    if (!EDSM.#instance) {
+      EDSM.#instance = new EDSM();
     }
 
-    static connect(): EDSM {
-        if (!EDSM.#instance) {
-            EDSM.#instance = new EDSM();
-        }
+    return EDSM.#instance;
+  }
 
-        return EDSM.#instance;
+  /* ---------------------------------------------------------------------------- #request ---- */
+
+  // Submit a request to EDSM and return the response as an object
+  static async #request(
+      url: string,
+      options: { [x: string]: string },
+  ): Promise<object | undefined> {
+    let data: object | undefined = undefined;
+
+    try {
+      const response = await fetch(url + '?' + new URLSearchParams(options));
+
+      if (!response.ok) {
+        throw new Error(`Network error - ${response}`);
+      }
+
+      data = await response.json();
+    } catch (err) {
+      Log.write(`ERROR - EDSM.request(): ${err}`);
     }
 
-    /* ---------------------------------------------------------------------------- #request ---- */
+    return data;
+  }
 
-    // Submit a request to EDSM and return the response as an object
-    static async #request(url: string, options: {[x: string]: string}): Promise<object|undefined> {
-        let data: object|undefined = undefined;
+  /* ---------------------------------------------------------------------- getSystemValue ---- */
 
-        try {
-            const response = await fetch(url + '?' + new URLSearchParams(options));
-
-            if (!response.ok) {
-                throw new Error(`Network error - ${response}`);
-            }
-
-            data = await response.json();
-        } catch (err) {
-            Log.write(`ERROR - EDSM.request(): ${err}`);
-        }
-
-        return data;
-    }
-
-    /* ---------------------------------------------------------------------- getSystemValue ---- */
-
-    static async getSystemValue(system: System): Promise<systemEstimatedValue|undefined> {
-        const url = 'https://www.edsm.net/api-system-v1/estimated-value';
-        const response = await EDSM.#request(url, {systemName: system.name});
-        return (response as systemEstimatedValue);
-    }
-}
+  static async getSystemValue(system: System): Promise<systemEstimatedValue | undefined> {
+    const url = 'https://www.edsm.net/api-system-v1/estimated-value';
+    const response = await EDSM.#request(url, {systemName: system.name});
+    return (
+        response as systemEstimatedValue
+    );
+  }
+}

src/models/System.ts

@@ -1,81 +1,79 @@
-import type { completeFsdJump, location, navRouteSystem } from '../@types/journalLines';
+import type {completeFsdJump, location, navRouteSystem} from '../@types/journalLines';
 
 import * as _ from 'lodash-es';
 
-import { Body } from './Body';
-import { EDSM } from './EDSM';
+import {Body} from './Body';
+import {EDSM} from './EDSM';
 
 export class System {
-    name: string;
-    SystemAddress?: number;
-    StarClass?: string;
-    charted: boolean;
-    bodies: Body[];
+  name: string;
+  SystemAddress?: number;
+  StarClass?: string;
+  charted: boolean;
+  bodies: Body[];
 
-    // ESDM data
-    estimatedValue?: number;
-    estimatedValueMapped?: number;
-    valuableBodies?: Body[];
+  // EDSM data
+  estimatedValue?: number;
+  estimatedValueMapped?: number;
+  valuableBodies?: Body[];
 
-    constructor(line?: navRouteSystem|completeFsdJump|location) {
-        // In future, this is where we preform EDSM lookup
+  constructor(line?: navRouteSystem | completeFsdJump | location) {
+    if (!line) {
+      this.name = 'Unknown';
+    } else {
+      this.name = line.StarSystem;
+      this.SystemAddress = line.SystemAddress;
 
-        if (!line) {
-            this.name = 'Unknown';
-        } else {
-            this.name = line.StarSystem;
-            this.SystemAddress = line.SystemAddress;
+      if ('StarClass' in line) {
+        this.StarClass = line.StarClass;
+      }
 
-            if ('StarClass' in line) {
-                this.StarClass = line.StarClass;
-            }
-
-        }
-
-        // Set this to true initially, since it likely is and the system is technically inserted
-        // into the UI before it's appraised.
-        this.charted = true;
-        this.bodies = [];
-
-        if (this.name !== 'Unknown') {
-            this.#getValue();
-        }
     }
 
-    /* --------------------------------------------------------------------------- #getValue ---- */
+    // Set this to true initially, since it likely is and the system is technically inserted
+    // into the UI before it's appraised.
+    this.charted = true;
+    this.bodies = [];
 
-    async #getValue() {
-        // display estimatedValueMapped
-        const data = await EDSM.getSystemValue(this);
-
-        if (data) {
-            this.estimatedValue = data.estimatedValue;
-            this.estimatedValueMapped = data.estimatedValueMapped;
-
-            // If EDSM doesn't have an estimate, then it's likely undiscovered.
-            this.charted = this.estimatedValue > 0;
-
-            // Save valuable bodies in system, if any.
-            if (data.valuableBodies.length > 0) {
-                this.valuableBodies = [];
-
-                data.valuableBodies.forEach((body) => {
-                    this.valuableBodies?.push(new Body(body));
-                });
-            }
-
-            // Let the UI know it needs to update.
-            EDSM.connect().emit('SYSTEM_APPRAISED', this);
-        }
+    if (this.name !== 'Unknown') {
+      this.#getValue();
     }
+  }
 
-    /* -------------------------------------------------------------------------- sortBodies ---- */
+  /* --------------------------------------------------------------------------- #getValue ---- */
 
-    sortBodies(): void {
-        this.bodies = _.orderBy(
-            this.bodies,
-            ['mappedValue', 'DistanceFromArrivalLS'],
-            ['desc', 'desc'],
-        );
+  async #getValue() {
+    // display estimatedValueMapped
+    const data = await EDSM.getSystemValue(this);
+
+    if (data) {
+      this.estimatedValue = data.estimatedValue;
+      this.estimatedValueMapped = data.estimatedValueMapped;
+
+      // If EDSM doesn't have an estimate, then it's likely undiscovered.
+      this.charted = this.estimatedValue > 0;
+
+      // Save valuable bodies in system, if any.
+      if (data.valuableBodies.length > 0) {
+        this.valuableBodies = [];
+
+        data.valuableBodies.forEach((body) => {
+          this.valuableBodies?.push(new Body(body));
+        });
+      }
+
+      // Let the UI know it needs to update.
+      EDSM.connect().emit('SYSTEM_APPRAISED', this);
     }
-}
+  }
+
+  /* -------------------------------------------------------------------------- sortBodies ---- */
+
+  sortBodies(): void {
+    this.bodies = _.orderBy(
+        this.bodies,
+        ['mappedValue', 'DistanceFromArrivalLS'],
+        ['desc', 'desc'],
+    );
+  }
+}

test/EDSM.test.ts

@@ -0,0 +1,72 @@
+import {expect, jest} from '@jest/globals';
+import {EDSM} from '../src/models/EDSM';
+import {System} from '../src/models/System';
+
+describe('EDSM', () => {
+  describe('connect()', () => {
+    it('should create new instance', () => {
+      expect(EDSM.connect()).toBeInstanceOf(EDSM);
+    });
+
+    it('should get previously created instance', () => {
+      const edsm = EDSM.connect();
+      expect(EDSM.connect()).toBeInstanceOf(EDSM);
+    });
+  });
+
+  describe('getSystemValue()', () => {
+    const mockFetch = (data?: {[i: string]: any}, ok: boolean = true) => {
+      global.fetch = jest.fn(() =>
+          Promise.resolve({
+            ok: ok,
+            json: () => Promise.resolve(data),
+          } as Response),
+      );
+    };
+
+    it('should get system info', async () => {
+      const system = new System({ "StarSystem":"LHS 3447", "SystemAddress":0, "StarPos":[0,0,0], "StarClass":"M" });
+      const data = {
+        "id": 13153,
+        "id64": 5306465653474,
+        "name": "LHS 3447",
+        "url": "https://www.edsm.net/en/system/bodies/id/13153/name/LHS+3447",
+        "estimatedValue": 353968,
+        "estimatedValueMapped": 1164029,
+        "valuableBodies": [
+          {
+            "bodyId": 3195879,
+            "bodyName": "LHS 3447 A 5",
+            "distance": 92282,
+            "valueMax": 879114
+          }
+        ]
+      };
+      mockFetch(data);
+
+      const result = await EDSM.getSystemValue(system);
+      expect(result).toEqual(data);
+    });
+
+    it('should not get system info if system name is invalid', async () => {
+      const system = new System();
+      const data = {};
+      mockFetch({});
+
+      const result = await EDSM.getSystemValue(system);
+      expect(result).toEqual(data);
+    });
+
+    it('should return undefined if response is not ok', async () => {
+      const system = new System();
+      mockFetch({}, false);
+
+      const result = await EDSM.getSystemValue(system);
+      expect(result).toBeUndefined();
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+  });
+});