emissions-api-sdk 1.0.5 → 1.0.6

package/test/apiTest.test.ts

@@ -21,37 +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,
   ECONOMIC_ACTIVITY_API_PATH,
-  ECONOMIC_ACTIVITY_API_TYPES,
   REAL_ESTATE_API_PATH,
-  REAL_ESTATE_API_TYPES,
-  ECONOMIC_ACTIVITY_API_AREA,
-  REAL_ESTATE_API_AREA,
-  ECONOMIC_ACTIVITY_API_UNITS,
-  REAL_ESTATE_API_UNITS
 } from "../src/Constants";
 import locationPayload from "./mocks/LocationRequest";
 import commonpayload from "./mocks/CommonRequest";
@@ -149,183 +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: "Economic activity API - getTypes",
-    func: economicActivityApi.getTypes,
-    path: ECONOMIC_ACTIVITY_API_TYPES,
-    method: "GET",
-  },
-  {
-    name: "Real estate API - getTypes",
-    func: realEstateApi.getTypes,
-    path: REAL_ESTATE_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: "Economic activity API - getArea",
-    func: economicActivityApi.getArea,
-    path: ECONOMIC_ACTIVITY_API_AREA,
-    method: "GET",
-  },
-  {
-    name: "Real estate API - getArea",
-    func: realEstateApi.getArea,
-    path: REAL_ESTATE_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: "Economic activity API - getUnits",
-    func: economicActivityApi.getUnits,
-    path: ECONOMIC_ACTIVITY_API_UNITS,
-    queryParams: { type: "accomodation" },
-    method: "GET",
-  },
-  {
-    name: "Real estate API - getUnits",
-    func: realEstateApi.getUnits,
-    path: REAL_ESTATE_API_UNITS,
-    queryParams: { type: "Commercial Real Estate:Hotel" },
-    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");

package/sphinx-build/.secrets.baseline

@@ -1,150 +0,0 @@
-{
-  "exclude": {
-    "files": "^.secrets.baseline$",
-    "lines": null
-  },
-  "generated_at": "2026-02-16T08:57:50Z",
-  "plugins_used": [
-    {
-      "name": "AWSKeyDetector"
-    },
-    {
-      "name": "ArtifactoryDetector"
-    },
-    {
-      "name": "AzureStorageKeyDetector"
-    },
-    {
-      "base64_limit": 4.5,
-      "name": "Base64HighEntropyString"
-    },
-    {
-      "name": "BasicAuthDetector"
-    },
-    {
-      "name": "BoxDetector"
-    },
-    {
-      "name": "CloudantDetector"
-    },
-    {
-      "ghe_instance": "github.ibm.com",
-      "name": "GheDetector"
-    },
-    {
-      "name": "GitHubTokenDetector"
-    },
-    {
-      "hex_limit": 3,
-      "name": "HexHighEntropyString"
-    },
-    {
-      "name": "IbmCloudIamDetector"
-    },
-    {
-      "name": "IbmCosHmacDetector"
-    },
-    {
-      "name": "JwtTokenDetector"
-    },
-    {
-      "keyword_exclude": null,
-      "name": "KeywordDetector"
-    },
-    {
-      "name": "MailchimpDetector"
-    },
-    {
-      "name": "NpmDetector"
-    },
-    {
-      "name": "PrivateKeyDetector"
-    },
-    {
-      "name": "SlackDetector"
-    },
-    {
-      "name": "SoftlayerDetector"
-    },
-    {
-      "name": "SquareOAuthDetector"
-    },
-    {
-      "name": "StripeDetector"
-    },
-    {
-      "name": "TwilioKeyDetector"
-    }
-  ],
-  "results": {
-    "source/authentication.rst": [
-      {
-        "hashed_secret": "d92258e9826f7923e5fa45241420653a89db10b0",
-        "is_secret": false,
-        "is_verified": false,
-        "line_number": 41,
-        "type": "Secret Keyword",
-        "verified_result": null
-      },
-      {
-        "hashed_secret": "9eddf3741c2ec20058940c3225b3e387cf6166dd",
-        "is_secret": false,
-        "is_verified": false,
-        "line_number": 152,
-        "type": "Secret Keyword",
-        "verified_result": null
-      }
-    ],
-    "source/client.rst": [
-      {
-        "hashed_secret": "9eddf3741c2ec20058940c3225b3e387cf6166dd",
-        "is_secret": false,
-        "is_verified": false,
-        "line_number": 108,
-        "type": "Secret Keyword",
-        "verified_result": null
-      }
-    ],
-    "source/getting_started.rst": [
-      {
-        "hashed_secret": "11fa7c37d697f30e6aee828b4426a10f83ab2380",
-        "is_secret": false,
-        "is_verified": false,
-        "line_number": 122,
-        "type": "Secret Keyword",
-        "verified_result": null
-      }
-    ],
-    "source/troubleshooting.rst": [
-      {
-        "hashed_secret": "ade7ae7ec3dcbc8e6efab2ad366fd59b4be60bda",
-        "is_secret": false,
-        "is_verified": false,
-        "line_number": 129,
-        "type": "Secret Keyword",
-        "verified_result": null
-      },
-      {
-        "hashed_secret": "24de2a83c833555a5931a357cb9a639830db7851",
-        "is_secret": false,
-        "is_verified": false,
-        "line_number": 191,
-        "type": "Secret Keyword",
-        "verified_result": null
-      },
-      {
-        "hashed_secret": "11fa7c37d697f30e6aee828b4426a10f83ab2380",
-        "is_secret": false,
-        "is_verified": false,
-        "line_number": 224,
-        "type": "Secret Keyword",
-        "verified_result": null
-      }
-    ]
-  },
-  "version": "0.13.1+ibm.64.dss",
-  "word_list": {
-    "file": null,
-    "hash": null
-  }
-}