@ledgerhq/device-core 0.1.1-next.0

package/src/managerApi/entities/FirmwareUpdateContextEntity.ts

@@ -0,0 +1,44 @@
+import { Id } from "./Id";
+
+type BaseFirmware = {
+  id: Id;
+  name: string;
+  description: string | null | undefined;
+  display_name: string | null | undefined;
+  notes: string | null | undefined;
+  perso: string;
+  firmware: string;
+  firmware_key: string;
+  hash: string;
+  date_creation: string;
+  date_last_modified: string;
+  device_versions: Array<Id>;
+  providers: Array<Id>;
+};
+
+/**
+ *
+ */
+export type OsuFirmware = BaseFirmware & {
+  next_se_firmware_final_version: Id;
+  previous_se_firmware_final_version: Array<Id>;
+};
+
+/**
+ *
+ */
+export type FinalFirmware = BaseFirmware & {
+  version: string;
+  se_firmware: Id;
+  osu_versions: Array<OsuFirmware>;
+  mcu_versions: Array<Id>;
+  application_versions: Array<Id>;
+  bytes?: number;
+  updateAvailable?: FirmwareUpdateContextEntity | null | undefined;
+};
+
+export type FirmwareUpdateContextEntity = {
+  osu: OsuFirmware;
+  final: FinalFirmware;
+  shouldFlashMCU: boolean;
+};

package/src/managerApi/entities/Id.ts

@@ -0,0 +1 @@
+export type Id = number;

package/src/managerApi/entities/LanguagePackageEntity.ts

@@ -0,0 +1,21 @@
+export type Language = "french" | "english" | "spanish";
+
+export type LanguagePackageEntity = {
+  language: Language;
+  languagePackageVersionId: number;
+  version: string; // "0.0.1"
+  language_package_id: number;
+  apdu_install_url: string;
+  apdu_uninstall_url: string; // <= Useless
+  device_versions: number[];
+  se_firmware_final_versions: number[];
+  bytes: number;
+  date_creation: string;
+  date_last_modified: string;
+};
+
+export type LanguagePackageResponseEntity = {
+  id: number;
+  language: Language;
+  language_package_version: LanguagePackageEntity[];
+};

package/src/managerApi/entities/mocks/aDeviceInfo.ts

@@ -0,0 +1,16 @@
+import type { DeviceInfo } from "@ledgerhq/types-live";
+
+export const aDeviceInfoBuilder = (props?: Partial<DeviceInfo>): DeviceInfo => {
+  return {
+    mcuVersion: "A_MCU_VERSION",
+    version: "A_VERSION",
+    majMin: "A_MAJ_MIN",
+    targetId: "0.0",
+    isBootloader: false,
+    isOSU: true,
+    providerName: undefined,
+    managerAllowed: false,
+    pinValidated: true,
+    ...props,
+  };
+};

package/src/managerApi/entities/mocks/aDeviceVersion.ts

@@ -0,0 +1,22 @@
+import { DeviceVersionEntity } from "../DeviceVersionEntity";
+
+export const aDeviceVersionBuilder = (
+  props?: Partial<DeviceVersionEntity>,
+): DeviceVersionEntity => {
+  return {
+    name: "Ledger Nano S",
+    device: 3,
+    providers: [],
+    id: 5,
+    display_name: "Ledger Nano S",
+    target_id: "0x31100004",
+    description: "Ledger Nano S",
+    mcu_versions: [1.7],
+    se_firmware_final_versions: [1.2],
+    osu_versions: [],
+    application_versions: [],
+    date_creation: "2020-04-30T13:50:00.000Z",
+    date_last_modified: "2020-04-30T13:50:00.000Z",
+    ...props,
+  };
+};

package/src/managerApi/entities/mocks/aFinalFirmware.ts

@@ -0,0 +1,25 @@
+import { FinalFirmware } from "../FirmwareUpdateContextEntity";
+
+export const aFinalFirmwareBuilder = (props?: Partial<FinalFirmware>): FinalFirmware => {
+  return {
+    id: 1,
+    name: "FINAL",
+    description: null,
+    display_name: null,
+    notes: null,
+    perso: "",
+    firmware: "",
+    firmware_key: "",
+    hash: "",
+    date_creation: "",
+    date_last_modified: "",
+    device_versions: [],
+    providers: [],
+    version: "0",
+    se_firmware: 1,
+    osu_versions: [],
+    mcu_versions: [],
+    application_versions: [],
+    ...props,
+  };
+};

package/src/managerApi/entities/mocks/aOsuFirmware.ts

@@ -0,0 +1,22 @@
+import { OsuFirmware } from "../FirmwareUpdateContextEntity";
+
+export function aOsuFirmwareBuilder(props?: Partial<OsuFirmware>) {
+  return {
+    id: 0,
+    name: "",
+    display_name: "",
+    notes: "",
+    perso: "",
+    firmware: "",
+    firmware_key: "",
+    hash: "",
+    device_versions: [],
+    next_se_firmware_final_version: 0,
+    providers: [],
+    date_creation: "",
+    date_last_modified: "",
+    description: "",
+    previous_se_firmware_final_version: [],
+    ...props,
+  };
+}

package/src/managerApi/repositories/HttpManagerApiRepository.test.ts

@@ -0,0 +1,494 @@
+import { FirmwareNotRecognized, NetworkDown } from "@ledgerhq/errors";
+import { FinalFirmware } from "@ledgerhq/types-live";
+import { DeviceInfoEntity } from "../entities/DeviceInfoEntity";
+import { DeviceVersionEntity } from "../entities/DeviceVersionEntity";
+import {
+  LanguagePackageEntity,
+  LanguagePackageResponseEntity,
+} from "../entities/LanguagePackageEntity";
+import { HttpManagerApiRepository } from "./HttpManagerApiRepository";
+
+const getUserHashesModule = jest.requireActual("../use-cases/getUserHashes");
+const networkModule = jest.requireActual("@ledgerhq/live-network/network");
+
+describe("HttpManagerApiRepository", () => {
+  let httpManagerApiRepository: HttpManagerApiRepository;
+  let getUserHashesSpy: jest.SpyInstance;
+  let networkSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    httpManagerApiRepository = new HttpManagerApiRepository("http://managerApiBase.com", "1.2.3");
+    getUserHashesSpy = jest.spyOn(getUserHashesModule, "getUserHashes");
+    networkSpy = jest.spyOn(networkModule, "default");
+    networkSpy.mockImplementation(jest.fn());
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  test("fetchLatestFirmware should call network() with the correct parameters", async () => {
+    getUserHashesSpy.mockReturnValue({
+      firmwareSalt: "mockedFirmwareSalt",
+    });
+    const params: Parameters<typeof httpManagerApiRepository.fetchLatestFirmware>[0] = {
+      current_se_firmware_final_version: 888,
+      device_version: 123,
+      providerId: 12,
+      userId: "userId",
+    };
+
+    await httpManagerApiRepository.fetchLatestFirmware(params).catch(() => {
+      // ignore the error in this test case
+    });
+
+    expect(networkSpy).toHaveBeenCalledWith({
+      method: "POST",
+      url: "http://managerApiBase.com/get_latest_firmware?livecommonversion=1.2.3&salt=mockedFirmwareSalt",
+      data: {
+        current_se_firmware_final_version: 888,
+        device_version: 123,
+        provider: 12,
+      },
+    });
+  });
+
+  test("fetchLatestFirmware should return null if data.result is null", async () => {
+    getUserHashesSpy.mockReturnValue({
+      firmwareSalt: "mockedFirmwareSalt",
+    });
+    const params: Parameters<typeof httpManagerApiRepository.fetchLatestFirmware>[0] = {
+      current_se_firmware_final_version: 888,
+      device_version: 123,
+      providerId: 12,
+      userId: "userId",
+    };
+    networkSpy.mockResolvedValue({
+      data: {
+        result: "null",
+      },
+    });
+
+    const result = await httpManagerApiRepository.fetchLatestFirmware(params);
+
+    expect(result).toBeNull();
+  });
+
+  test("fetchLatestFirmware should return data.se_firmware_osu_version", async () => {
+    getUserHashesSpy.mockReturnValue({
+      firmwareSalt: "mockedFirmwareSalt",
+    });
+    const params: Parameters<typeof httpManagerApiRepository.fetchLatestFirmware>[0] = {
+      current_se_firmware_final_version: 888,
+      device_version: 123,
+      providerId: 12,
+      userId: "userId",
+    };
+    networkSpy.mockResolvedValue({
+      data: {
+        result: "mockedResult",
+        se_firmware_osu_version: "mockedOsuFirmware",
+      },
+    });
+
+    const result = await httpManagerApiRepository.fetchLatestFirmware(params);
+
+    expect(result).toBe("mockedOsuFirmware");
+  });
+
+  test("fetchMcus should call network() with the correct parameters", async () => {
+    await httpManagerApiRepository.fetchMcus().catch(() => {
+      // ignore the error in this test case
+    });
+
+    expect(networkSpy).toHaveBeenCalledWith({
+      method: "GET",
+      url: "http://managerApiBase.com/mcu_versions?livecommonversion=1.2.3",
+    });
+  });
+
+  test("fetchMcus should return data", async () => {
+    networkSpy.mockResolvedValue({
+      data: "mockedData",
+    });
+
+    const result = await httpManagerApiRepository.fetchMcus();
+
+    expect(result).toBe("mockedData");
+  });
+
+  test("getDeviceVersion should call network() with the correct parameters", async () => {
+    const params: Parameters<typeof httpManagerApiRepository.getDeviceVersion>[0] = {
+      targetId: 123,
+      providerId: 12,
+    };
+
+    await httpManagerApiRepository.getDeviceVersion(params).catch(() => {
+      // ignore the error in this test case
+    });
+
+    expect(networkSpy).toHaveBeenCalledWith({
+      method: "POST",
+      url: "http://managerApiBase.com/get_device_version?livecommonversion=1.2.3",
+      data: {
+        target_id: 123,
+        provider: 12,
+      },
+    });
+  });
+
+  test("getDeviceVersion should throw a FirmwareNotRecognized error if status is 404", async () => {
+    networkSpy.mockRejectedValue({
+      status: 404,
+    });
+
+    await expect(
+      httpManagerApiRepository.getDeviceVersion({
+        targetId: 123,
+        providerId: 12,
+      }),
+    ).rejects.toThrow(FirmwareNotRecognized);
+  });
+
+  test("getDeviceVersion should throw a FirmwareNotRecognized error if response.status is 404", async () => {
+    networkSpy.mockRejectedValue({
+      response: {
+        status: 404,
+      },
+    });
+
+    await expect(
+      httpManagerApiRepository.getDeviceVersion({
+        targetId: 123,
+        providerId: 12,
+      }),
+    ).rejects.toThrow(FirmwareNotRecognized);
+  });
+
+  test("getDeviceVersion should return data", async () => {
+    networkSpy.mockResolvedValue({
+      data: "mockedData",
+    });
+
+    const result = await httpManagerApiRepository.getDeviceVersion({
+      targetId: 123,
+      providerId: 12,
+    });
+
+    expect(result).toBe("mockedData");
+  });
+
+  test("getCurrentOSU should call network() with the correct parameters", async () => {
+    const params: Parameters<typeof httpManagerApiRepository.getCurrentOSU>[0] = {
+      deviceId: 123,
+      providerId: 12,
+      version: "mockedVersion",
+    };
+
+    await httpManagerApiRepository.getCurrentOSU(params).catch(() => {
+      // ignore the error in this test case
+    });
+
+    expect(networkSpy).toHaveBeenCalledWith({
+      method: "POST",
+      url: "http://managerApiBase.com/get_osu_version?livecommonversion=1.2.3",
+      data: {
+        device_version: 123,
+        provider: 12,
+        version_name: "mockedVersion-osu",
+      },
+    });
+  });
+
+  test("getCurrentOSU should return data", async () => {
+    networkSpy.mockResolvedValue({
+      data: "mockedData",
+    });
+
+    const result = await httpManagerApiRepository.getCurrentOSU({
+      deviceId: 123,
+      providerId: 12,
+      version: "mockedVersion",
+    });
+
+    expect(result).toBe("mockedData");
+  });
+
+  test("getCurrentFirmware should call network() with the correct parameters", async () => {
+    const params: Parameters<typeof httpManagerApiRepository.getCurrentFirmware>[0] = {
+      deviceId: 123,
+      providerId: 12,
+      version: "mockedVersion",
+    };
+
+    await httpManagerApiRepository.getCurrentFirmware(params).catch(() => {
+      // ignore the error in this test case
+    });
+
+    expect(networkSpy).toHaveBeenCalledWith({
+      method: "POST",
+      url: "http://managerApiBase.com/get_firmware_version?livecommonversion=1.2.3",
+      data: {
+        device_version: 123,
+        provider: 12,
+        version_name: "mockedVersion",
+      },
+    });
+  });
+
+  test("getCurrentFirmware should throw a FirmwareNotRecognized error if status is 404", async () => {
+    networkSpy.mockRejectedValue({
+      status: 404,
+    });
+
+    await expect(
+      httpManagerApiRepository.getCurrentFirmware({
+        deviceId: 123,
+        providerId: 12,
+        version: "mockedVersion",
+      }),
+    ).rejects.toThrow(FirmwareNotRecognized);
+  });
+
+  test("getCurrentFirmware should throw a FirmwareNotRecognized error if response.status is 404", async () => {
+    networkSpy.mockRejectedValue({
+      response: {
+        status: 404,
+      },
+    });
+
+    await expect(
+      httpManagerApiRepository.getCurrentFirmware({
+        deviceId: 123,
+        providerId: 12,
+        version: "mockedVersion",
+      }),
+    ).rejects.toThrow(FirmwareNotRecognized);
+  });
+
+  test("getCurrentFirmware should return data", async () => {
+    networkSpy.mockResolvedValue({
+      data: "mockedData",
+    });
+
+    const result = await httpManagerApiRepository.getCurrentFirmware({
+      deviceId: 123,
+      providerId: 12,
+      version: "mockedVersion",
+    });
+
+    expect(result).toBe("mockedData");
+  });
+
+  test("getFinalFirmwareById should call network() with the correct parameters", async () => {
+    await httpManagerApiRepository.getFinalFirmwareById(123).catch(() => {
+      // ignore the error in this test case
+    });
+
+    expect(networkSpy).toHaveBeenCalledWith({
+      method: "GET",
+      url: "http://managerApiBase.com/firmware_final_versions/123?livecommonversion=1.2.3",
+    });
+  });
+
+  test("getFinalFirmwareById should return data", async () => {
+    networkSpy.mockResolvedValue({
+      data: "mockedData",
+    });
+
+    const result = await httpManagerApiRepository.getFinalFirmwareById(123);
+
+    expect(result).toBe("mockedData");
+  });
+
+  test("getAppsByHash should call network() with the correct parameters", async () => {
+    const mockHashes = ["mockedHash1", "mockedHash2"];
+    await httpManagerApiRepository.getAppsByHash(mockHashes).catch(() => {
+      // ignore the error in this test case
+    });
+
+    expect(networkSpy).toHaveBeenCalledWith({
+      method: "POST",
+      url: "http://managerApiBase.com/v2/apps/hash?livecommonversion=1.2.3",
+      data: mockHashes,
+    });
+  });
+
+  test("getAppsByHash should throw a NetworkDown error if data is null", async () => {
+    networkSpy.mockResolvedValue({
+      data: null,
+    });
+
+    await expect(httpManagerApiRepository.getAppsByHash(["mockedHash"])).rejects.toThrow(
+      NetworkDown,
+    );
+  });
+
+  test("getAppsByHash should throw a NetworkDown error if data is not an array", async () => {
+    networkSpy.mockResolvedValue({
+      data: "mockedData",
+    });
+
+    await expect(httpManagerApiRepository.getAppsByHash(["mockedHash"])).rejects.toThrow(
+      NetworkDown,
+    );
+  });
+
+  test("getAppsByHash should return data if it's an array", async () => {
+    networkSpy.mockResolvedValue({
+      data: ["mockedData"],
+    });
+
+    const result = await httpManagerApiRepository.getAppsByHash(["mockedHash"]);
+
+    expect(result).toEqual(["mockedData"]);
+  });
+
+  test("catalogForDevice should call network() with the correct parameters", async () => {
+    await httpManagerApiRepository
+      .catalogForDevice({
+        targetId: 123,
+        provider: 12,
+        firmwareVersion: "mockedFirmwareVersion",
+      })
+      .catch(() => {
+        // ignore the error in this test case
+      });
+
+    expect(networkSpy).toHaveBeenCalledWith({
+      method: "GET",
+      url: "http://managerApiBase.com/v2/apps/by-target?livecommonversion=1.2.3&provider=12&target_id=123&firmware_version_name=mockedFirmwareVersion",
+    });
+  });
+
+  test("catalogForDevice should throw a NetworkDown error if data is null", async () => {
+    networkSpy.mockResolvedValue({
+      data: null,
+    });
+
+    await expect(
+      httpManagerApiRepository.catalogForDevice({
+        targetId: 123,
+        provider: 12,
+        firmwareVersion: "mockedFirmwareVersion",
+      }),
+    ).rejects.toThrow(NetworkDown);
+  });
+
+  test("catalogForDevice should throw a NetworkDown error if data is not an array", async () => {
+    networkSpy.mockResolvedValue({
+      data: "mockedData",
+    });
+
+    await expect(
+      httpManagerApiRepository.catalogForDevice({
+        targetId: 123,
+        provider: 12,
+        firmwareVersion: "mockedFirmwareVersion",
+      }),
+    ).rejects.toThrow(NetworkDown);
+  });
+
+  test("catalogForDevice should return data if it's an array", async () => {
+    networkSpy.mockResolvedValue({
+      data: ["mockedData"],
+    });
+
+    const result = await httpManagerApiRepository.catalogForDevice({
+      targetId: 123,
+      provider: 12,
+      firmwareVersion: "mockedFirmwareVersion",
+    });
+
+    expect(result).toEqual(["mockedData"]);
+  });
+
+  test("getLanguagePackagesForDevice should call network() and other methods with the correct parameters", async () => {
+    const getDeviceVersionSpy = jest
+      .spyOn(httpManagerApiRepository, "getDeviceVersion")
+      .mockReturnValue(Promise.resolve({ id: 4 } as DeviceVersionEntity));
+    const getCurrentFirmwareSpy = jest
+      .spyOn(httpManagerApiRepository, "getCurrentFirmware")
+      .mockImplementation(jest.fn());
+
+    await httpManagerApiRepository
+      .getLanguagePackagesForDevice(
+        {
+          version: 1,
+          targetId: 2,
+          id: 3,
+        } as unknown as DeviceInfoEntity,
+        12,
+      )
+      .catch(() => {
+        // ignore the error in this test case
+      });
+
+    expect(getDeviceVersionSpy).toHaveBeenCalledWith({ targetId: 2, providerId: 12 });
+    expect(getCurrentFirmwareSpy).toHaveBeenCalledWith({ deviceId: 4, providerId: 12, version: 1 });
+
+    expect(networkSpy).toHaveBeenCalledWith({
+      method: "GET",
+      url: "http://managerApiBase.com/language-package?livecommonversion=1.2.3",
+    });
+  });
+
+  test("getLanguagePackagesForDevice should return language packages", async () => {
+    const mockedDeviceVersionId = 123;
+    const mockedCurrentFirmwareId = 456;
+
+    jest
+      .spyOn(httpManagerApiRepository, "getDeviceVersion")
+      .mockReturnValue(Promise.resolve({ id: mockedDeviceVersionId } as DeviceVersionEntity));
+    jest
+      .spyOn(httpManagerApiRepository, "getCurrentFirmware")
+      .mockReturnValue(Promise.resolve({ id: mockedCurrentFirmwareId } as FinalFirmware));
+
+    networkSpy.mockResolvedValue({
+      data: [
+        {
+          language: "french",
+          language_package_version: [
+            {
+              device_versions: [mockedDeviceVersionId, 8888],
+              language: "french",
+              se_firmware_final_versions: [mockedCurrentFirmwareId, 9999],
+            } as LanguagePackageEntity,
+          ],
+        },
+        {
+          language: "spanish",
+          language_package_version: [
+            {
+              device_versions: [mockedDeviceVersionId],
+              language: "spanish",
+              se_firmware_final_versions: [9999], // this excludes the package from the result
+            } as LanguagePackageEntity,
+          ],
+        },
+        {
+          language: "english",
+          language_package_version: [
+            {
+              device_versions: [8888], // this excludes the package from the result
+              language: "spanish",
+              se_firmware_final_versions: [mockedCurrentFirmwareId],
+            } as LanguagePackageEntity,
+          ],
+        },
+      ] as LanguagePackageResponseEntity[],
+    });
+
+    const result = await httpManagerApiRepository.getLanguagePackagesForDevice(
+      {} as unknown as DeviceInfoEntity,
+    );
+
+    expect(result).toEqual([
+      {
+        device_versions: [mockedDeviceVersionId, 8888],
+        language: "french",
+        se_firmware_final_versions: [mockedCurrentFirmwareId, 9999],
+      },
+    ]);
+  });
+});