emissions-api-sdk 1.0.4 → 1.0.6

package/test/apiTest.test.ts

@@ -5,6 +5,8 @@ import * as mobileApi from "../src/api/Mobile";
 import * as stationaryApi from "../src/api/Stationary";
 import * as GenericCalculation from "../src/api/Calculation";
 import * as TransportationDistributionApi from "../src/api/TransportationAndDistribution";
+import * as economicActivityApi from "../src/api/EconomicActivity";
+import * as realEstateApi from "../src/api/RealEstate";
 import * as UsageApi from "../src/api/Usage";
 import * as Factors from "../src/api/Factor";
 import * as FactorSets from "../src/api/FactorSets";
@@ -19,29 +21,9 @@ import {
   FACTOR_API_PATH,
   FACTOR_SET_API_PATH,
   SEARCH_API_PATH,
-  LOCATION_TYPES,
-  FUGITIVE_API_TYPES,
-  MOBILE_API_TYPES,
-  STATIONARY_API_TYPES,
-  CALCULATION_TYPES,
-  FACTOR_API_TYPES,
-  TRANSPORTATION_AND_DISTRIBUTION_API_TYPES,
-  LOCATION_API_AREA,
-  FUGITIVE_API_AREA,
-  MOBILE_API_AREA,
-  STATIONARY_API_AREA,
-  GENERAL_API_AREA,
-  FACTOR_API_AREA,
-  TRANSPORTATION_AND_DISTRIBUTION_API_AREA,
-  LOCATION_API_UNITS,
-  SEARCH_API_AREA,
-  FUGITIVE_API_UNITS,
-  MOBILE_API_UNITS,
-  STATIONARY_API_UNITS,
-  GENERAL_API_UNITS,
-  FACTOR_API_UNITS,
-  TRANSPORTATION_AND_DISTRIBUTION_API_UNITS,
-  USAGE_API
+  USAGE_API,
+  ECONOMIC_ACTIVITY_API_PATH,
+  REAL_ESTATE_API_PATH,
 } from "../src/Constants";
 import locationPayload from "./mocks/LocationRequest";
 import commonpayload from "./mocks/CommonRequest";
@@ -112,6 +94,20 @@ const testCases: ApiTestCase[] = [
     payload: GenericCalculationPayload,
     method: "POST",
   },
+  {
+    name: "Economic activity API",
+    func: economicActivityApi.calculate,
+    path: ECONOMIC_ACTIVITY_API_PATH,
+    payload: commonpayload,
+    method: "POST",
+  },
+  {
+    name: "Real estate API",
+    func: realEstateApi.calculate,
+    path: REAL_ESTATE_API_PATH,
+    payload: commonpayload,
+    method: "POST",
+  },
   {
     name: "FactorSet API",
     func: FactorSets.get,
@@ -125,145 +121,6 @@ const testCases: ApiTestCase[] = [
     payload: SearchPayload,
     method: "POST",
   },
-  {
-    name: "Location API - getTypes",
-    func: locationApi.getTypes,
-    path: LOCATION_TYPES,
-    method: "GET",
-  },
-  {
-    name: "Fugitive API - getTypes",
-    func: fugitiveApi.getTypes,
-    path: FUGITIVE_API_TYPES,
-    method: "GET",
-  },
-  {
-    name: "Mobile API - getTypes",
-    func: mobileApi.getTypes,
-    path: MOBILE_API_TYPES,
-    method: "GET",
-  },
-  {
-    name: "Stationary API - getTypes",
-    func: stationaryApi.getTypes,
-    path: STATIONARY_API_TYPES,
-    method: "GET",
-  },
-  {
-    name: "GenericCalculation API - getTypes",
-    func: GenericCalculation.getTypes,
-    path: CALCULATION_TYPES,
-    method: "GET",
-  },
-  {
-    name: "Factor API - getTypes",
-    func: Factors.getTypes,
-    path: FACTOR_API_TYPES,
-    method: "GET",
-  },
-  {
-    name: "Transportation and Distribution API - getTypes",
-    func: TransportationDistributionApi.getTypes,
-    path: TRANSPORTATION_AND_DISTRIBUTION_API_TYPES,
-    method: "GET",
-  },
-  {
-    name: "Location API - getArea",
-    func: locationApi.getArea,
-    path: LOCATION_API_AREA,
-    method: "GET",
-  },
-  {
-    name: "Fugitive API - getArea",
-    func: fugitiveApi.getArea,
-    path: FUGITIVE_API_AREA,
-    method: "GET",
-  },
-  {
-    name: "Mobile API - getArea",
-    func: mobileApi.getArea,
-    path: MOBILE_API_AREA,
-    method: "GET",
-  },
-  {
-    name: "Stationary API - getArea",
-    func: stationaryApi.getArea,
-    path: STATIONARY_API_AREA,
-    method: "GET",
-  },
-  {
-    name: "GenericCalculation API - getArea",
-    func: GenericCalculation.getArea,
-    path: GENERAL_API_AREA,
-    method: "GET",
-  },
-  {
-    name: "Factor API - getArea",
-    func: Factors.getArea,
-    path: FACTOR_API_AREA,
-    method: "GET",
-  },
-  {
-    name: "Factor SEARCH API - getArea",
-    func: Factors.getSearchArea,
-    path: SEARCH_API_AREA,
-    method: "GET",
-  },
-  {
-    name: "Transportation and Distribution API - getArea",
-    func: TransportationDistributionApi.getArea,
-    path: TRANSPORTATION_AND_DISTRIBUTION_API_AREA,
-    method: "GET",
-  },
-  {
-    name: "Location API - getUnits",
-    func: locationApi.getUnits,
-    path: LOCATION_API_UNITS,
-    queryParams: { type: "electricity" },
-    method: "GET",
-  },
-  {
-    name: "Fugitive API - getUnits",
-    func: fugitiveApi.getUnits,
-    path: FUGITIVE_API_UNITS,
-    queryParams: { type: "Natural Gas - Scope 3:AAA" },
-    method: "GET",
-  },
-  {
-    name: "Mobile API - getUnits",
-    func: mobileApi.getUnits,
-    path: MOBILE_API_UNITS,
-    queryParams: { type: "Cars:B20:(NE)" },
-    method: "GET",
-  },
-  {
-    name: "Stationary API - getUnits",
-    func: stationaryApi.getUnits,
-    path: STATIONARY_API_UNITS,
-    queryParams: { type: "Jet Kerosene" },
-    method: "GET",
-  },
-  {
-    name: "GenericCalculation API - getUnits",
-    func: GenericCalculation.getUnits,
-    path: GENERAL_API_UNITS,
-    queryParams: { type: "Natural Gas - Scope 3:AAA" },
-    method: "GET",
-  },
-  {
-    name: "Factor API - getUnits",
-    func: Factors.getUnits,
-    path: FACTOR_API_UNITS,
-    queryParams: { type: "HFC-263fb" },
-    method: "GET",
-  },
-  {
-    name: "Transportation and Distribution API - getUnits",
-    func: TransportationDistributionApi.getUnits,
-    path: TRANSPORTATION_AND_DISTRIBUTION_API_UNITS,
-    queryParams: { type: "Business Travel - Cars:Diesel - Small" },
-    method: "GET",
-  },
   {
     name: "Usage API - getUsage with history false",
     func: UsageApi.getUsage,

package/test/metadata.test.ts

@@ -0,0 +1,224 @@
+import * as MetadataApi from "../src/api/Metadata";
+import { Client } from "../src/Client";
+import {
+    METADATA_AREA_ENDPOINT,
+    METADATA_TYPES_ENDPOINT,
+    METADATA_UNITS_ENDPOINT,
+} from "../src/Constants";
+import * as requestModule from "../src/request";
+
+type MetadataTestCase = {
+  name: string;
+  func: (arg?: string) => Promise<any>;
+  path: string;
+  endpoint?: string;
+  type?: string;
+  queryParams?: Record<string, string>;
+  requestBody?: Record<string, string>;
+  method: "GET" | "POST";
+};
+
+const mockResp = "mock-success-response";
+
+const testCases: MetadataTestCase[] = [
+  // GET Types Tests
+  {
+    name: "Metadata API - getTypes (default)",
+    func: MetadataApi.getTypes,
+    path: METADATA_TYPES_ENDPOINT,
+    method: "GET",
+  },
+  {
+    name: "Metadata API - getTypes with endpoint",
+    func: MetadataApi.getTypes,
+    path: METADATA_TYPES_ENDPOINT,
+    endpoint: "location",
+    queryParams: { endpoint: "location" },
+    method: "GET",
+  },
+  {
+    name: "Metadata API - getTypes with stationary endpoint",
+    func: MetadataApi.getTypes,
+    path: METADATA_TYPES_ENDPOINT,
+    endpoint: "stationary",
+    queryParams: { endpoint: "stationary" },
+    method: "GET",
+  },
+  // POST Types Tests
+  {
+    name: "Metadata API - postTypes (default)",
+    func: MetadataApi.postTypes,
+    path: METADATA_TYPES_ENDPOINT,
+    requestBody: {},
+    method: "POST",
+  },
+  {
+    name: "Metadata API - postTypes with endpoint",
+    func: MetadataApi.postTypes,
+    path: METADATA_TYPES_ENDPOINT,
+    endpoint: "mobile",
+    requestBody: { endpoint: "mobile" },
+    method: "POST",
+  },
+  {
+    name: "Metadata API - postTypes with fugitive endpoint",
+    func: MetadataApi.postTypes,
+    path: METADATA_TYPES_ENDPOINT,
+    endpoint: "fugitive",
+    requestBody: { endpoint: "fugitive" },
+    method: "POST",
+  },
+  // GET Area Tests
+  {
+    name: "Metadata API - getArea (default)",
+    func: MetadataApi.getArea,
+    path: METADATA_AREA_ENDPOINT,
+    method: "GET",
+  },
+  {
+    name: "Metadata API - getArea with endpoint",
+    func: MetadataApi.getArea,
+    path: METADATA_AREA_ENDPOINT,
+    endpoint: "calculation",
+    queryParams: { endpoint: "calculation" },
+    method: "GET",
+  },
+  {
+    name: "Metadata API - getArea with transportation endpoint",
+    func: MetadataApi.getArea,
+    path: METADATA_AREA_ENDPOINT,
+    endpoint: "transportation-and-distribution",
+    queryParams: { endpoint: "transportation-and-distribution" },
+    method: "GET",
+  },
+  // POST Area Tests
+  {
+    name: "Metadata API - postArea (default)",
+    func: MetadataApi.postArea,
+    path: METADATA_AREA_ENDPOINT,
+    requestBody: {},
+    method: "POST",
+  },
+  {
+    name: "Metadata API - postArea with endpoint",
+    func: MetadataApi.postArea,
+    path: METADATA_AREA_ENDPOINT,
+    endpoint: "real-estate",
+    requestBody: { endpoint: "real-estate" },
+    method: "POST",
+  },
+  {
+    name: "Metadata API - postArea with economic-activity endpoint",
+    func: MetadataApi.postArea,
+    path: METADATA_AREA_ENDPOINT,
+    endpoint: "economic-activity",
+    requestBody: { endpoint: "economic-activity" },
+    method: "POST",
+  },
+  // GET Units Tests
+  {
+    name: "Metadata API - getUnits (default)",
+    func: MetadataApi.getUnits,
+    path: METADATA_UNITS_ENDPOINT,
+    method: "GET",
+  },
+  {
+    name: "Metadata API - getUnits with type",
+    func: MetadataApi.getUnits,
+    path: METADATA_UNITS_ENDPOINT,
+    type: "Natural Gas",
+    queryParams: { type: "Natural Gas" },
+    method: "GET",
+  },
+  {
+    name: "Metadata API - getUnits with type with subtype",
+    func: MetadataApi.getUnits,
+    path: METADATA_UNITS_ENDPOINT,
+    type: "Natural Gas - Scope 3:AAA",
+    queryParams: { type: "Natural Gas - Scope 3:AAA" },
+    method: "GET",
+  },
+  // POST Units Tests
+  {
+    name: "Metadata API - postUnits (default)",
+    func: MetadataApi.postUnits,
+    path: METADATA_UNITS_ENDPOINT,
+    requestBody: {},
+    method: "POST",
+  },
+  {
+    name: "Metadata API - postUnits with type",
+    func: MetadataApi.postUnits,
+    path: METADATA_UNITS_ENDPOINT,
+    type: "electricity",
+    requestBody: { type: "electricity" },
+    method: "POST",
+  },
+  {
+    name: "Metadata API - postUnits with complex type",
+    func: MetadataApi.postUnits,
+    path: METADATA_UNITS_ENDPOINT,
+    type: "Business Travel - Cars:Diesel - Small",
+    requestBody: { type: "Business Travel - Cars:Diesel - Small" },
+    method: "POST",
+  },
+];
+
+describe("Metadata API Tests", () => {
+  let spy: jest.SpyInstance;
+  let tokenSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    tokenSpy = jest
+      .spyOn(Client as any, "requestToken")
+      .mockResolvedValue(
+        "eyJpzGciOiJIUzI1NlIsInR5cCI6IkplVCJ9." +
+          Buffer.from(
+            JSON.stringify({ exp: Math.floor(Date.now() / 1000) + 3600 })
+          ).toString("base64") +
+          ".signature"
+      );
+
+    Client.getClient({
+      apiKey: "mock-api-key",
+      clientId: "mock-client-id",
+      orgId: "mock-org-id",
+    });
+    spy = jest
+      .spyOn(requestModule, "makeApiRequest")
+      .mockResolvedValue(mockResp);
+  });
+
+  afterEach(() => {
+    tokenSpy.mockRestore();
+    spy.mockRestore();
+  });
+
+  describe.each(testCases)(
+    "$name",
+    ({ func, path, endpoint, type, queryParams, requestBody, method }) => {
+      it("Should call makeApiRequest with correct parameters", async () => {
+        // For units tests, pass type; for types/area tests, pass endpoint
+        const result = await func(endpoint ?? type);
+
+        const clientDomain = Client.getInstance().getDomain();
+        const expectedUrl = `${clientDomain}${path}`;
+
+        const expectedRequest: any = {
+          method,
+          url: expectedUrl,
+        };
+
+        if (method === "POST") {
+          expectedRequest.data = requestBody;
+        } else if (method === "GET" && queryParams) {
+          expectedRequest.params = queryParams;
+        }
+
+        expect(spy).toHaveBeenCalledWith(expectedRequest);
+        expect(result).toBe(mockResp);
+      });
+    }
+  );
+});

package/test/request.test.ts

@@ -2,7 +2,6 @@ import axios, { Method } from "axios";
 import { makeApiRequest } from "../src/request";
 import { Client } from "../src/Client";
 import { RequestConfig } from "../src/interfaces/Config";
-import { get } from "http";
 import { CLIENT_SOURCE_HEADER } from "../src/Constants";
 
 jest.mock("axios");