laplace-api 3.1.0 → 4.0.0

package/src/test/search.test.ts

@@ -1,11 +1,10 @@
-import { Logger } from 'winston';
-import { LaplaceConfiguration } from '../utilities/configuration';
-import { SearchClient, SearchType } from '../client/search';
-import { Region, Locale } from '../client/collections';
-import './client_test_suite';
+import { Logger } from "winston";
+import { LaplaceConfiguration } from "../utilities/configuration";
+import { SearchClient, SearchType } from "../client/search";
+import "./client_test_suite";
+import { Region, Locale } from "../client/collections";
 
-
-describe('Search', () => {
+describe("Search", () => {
   let client: SearchClient;
 
   beforeAll(() => {
@@ -21,23 +20,73 @@ describe('Search', () => {
     client = new SearchClient(config, logger);
   });
 
-  test('SearchStock', async () => {
-    const resp = await client.search("TUPRS", [SearchType.Stock], Region.Tr, Locale.Tr);
-    expect(resp).not.toBeEmpty();
+  test("SearchStock", async () => {
+    const resp = await client.search(
+      "TUPRS",
+      [SearchType.Stock],
+      Region.Tr,
+      Locale.Tr
+    );
+    expect(resp.stocks).not.toBeEmpty();
+
+    const firstResult = resp.stocks[0];
+    expect(typeof firstResult.id).toBe("string");
+    expect(typeof firstResult.name).toBe("string");
+    expect(typeof firstResult.title).toBe("string");
+    expect(typeof firstResult.region).toBe("string");
+    expect(typeof firstResult.assetType).toBe("string");
+    expect(typeof firstResult.type).toBe("string");
   });
 
-  test('SearchIndustry', async () => {
-    const resp = await client.search("Hava Taşımacılığı", [SearchType.Industry], Region.Tr, Locale.Tr);
-    expect(resp).not.toBeEmpty();
+  test("SearchIndustry", async () => {
+    const resp = await client.search(
+      "Hava",
+      [SearchType.Industry],
+      Region.Tr,
+      Locale.Tr
+    );
+    expect(resp.industries).not.toBeEmpty();
+
+    const firstResult = resp.industries[0];
+    expect(typeof firstResult.id).toBe("string");
+    expect(typeof firstResult.title).toBe("string");
+    expect(Array.isArray(firstResult.region)).toBe(true);
+    expect(firstResult.region.length).toBeGreaterThan(0);
+    firstResult.region.forEach((region) => {
+      expect(typeof region).toBe("string");
+    });
+
+    expect(typeof firstResult.assetClass).toBe("string");
+    expect(typeof firstResult.imageUrl).toBe("string");
+    expect(typeof firstResult.avatarUrl).toBe("string");
   });
+  test("SearchAllTypes", async () => {
+    const resp = await client.search(
+      "Ab",
+      [
+        SearchType.Stock,
+        SearchType.Industry,
+        SearchType.Sector,
+        SearchType.Collection,
+      ],
+      Region.Us,
+      Locale.Tr
+    );
+
+    expect(typeof resp).toBe("object");
+    expect(resp).not.toBeNull();
+
+    const hasResults =
+      (resp.stocks && resp.stocks.length > 0) ||
+      (resp.industries && resp.industries.length > 0) ||
+      (resp.sectors && resp.sectors.length > 0) ||
+      (resp.collections && resp.collections.length > 0);
+
+    expect(hasResults).toBe(true);
 
-  test('SearchAllTypes', async () => {
-    const resp = await client.search("Ab", [
-      SearchType.Stock,
-      SearchType.Industry,
-      SearchType.Sector,
-      SearchType.Collection
-    ], Region.Us, Locale.Tr);
-    expect(resp).not.toBeEmpty();
+    if (resp.stocks) expect(Array.isArray(resp.stocks)).toBe(true);
+    if (resp.industries) expect(Array.isArray(resp.industries)).toBe(true);
+    if (resp.sectors) expect(Array.isArray(resp.sectors)).toBe(true);
+    if (resp.collections) expect(Array.isArray(resp.collections)).toBe(true);
   });
-});
+});

package/src/test/stocks.test.ts

@@ -1,15 +1,18 @@
-import { Logger } from 'winston';
-import { LaplaceConfiguration } from '../utilities/configuration';
-import { StockClient, AssetClass, HistoricalPricePeriod, HistoricalPriceInterval } from '../client/stocks';
-import { Region, Locale } from '../client/collections';
-import './client_test_suite';
-
-
-describe('Stocks', () => {
+import { Logger } from "winston";
+import { LaplaceConfiguration } from "../utilities/configuration";
+import {
+  StockClient,
+  HistoricalPricePeriod,
+  HistoricalPriceInterval,
+  AssetClass,
+} from "../client/stocks";
+import "./client_test_suite";
+import { Region, Locale } from "../client/collections";
+
+describe("Stocks Client", () => {
   let client: StockClient;
 
   beforeAll(() => {
-    // Assuming global.testSuite is set up as in the previous example
     const config = (global as any).testSuite.config as LaplaceConfiguration;
     const logger: Logger = {
       info: jest.fn(),
@@ -21,77 +24,192 @@ describe('Stocks', () => {
     client = new StockClient(config, logger);
   });
 
-  test('GetAllStocks', async () => {
-    const resp = await client.getAllStocks(Region.Tr);
-    expect(resp).not.toBeEmpty();
+  describe("getAllStocks", () => {
+    test("should return stocks list for TR region", async () => {
+      const resp = await client.getAllStocks(Region.Tr);
+
+      expect(resp).not.toBeEmpty();
+
+      const firstStock = resp[0];
+      expect(typeof firstStock.id).toBe("string");
+      expect(typeof firstStock.assetType).toBe("string");
+      expect(typeof firstStock.name).toBe("string");
+      expect(typeof firstStock.symbol).toBe("string");
+      expect(typeof firstStock.sectorId).toBe("string");
+      expect(typeof firstStock.industryId).toBe("string");
+      expect(typeof firstStock.updatedDate).toBe("string");
+      expect(typeof firstStock.active).toBe("boolean");
+
+      if (firstStock.dailyChange !== undefined) {
+        expect(typeof firstStock.dailyChange).toBe("number");
+      }
+    });
+
+    test("should handle pagination correctly", async () => {
+      const resp = await client.getAllStocks(Region.Tr, 10, 10);
+
+      expect(resp).not.toBeEmpty();
+      expect(resp.length).toBeLessThanOrEqual(10);
+    });
   });
 
-
-  test('GetAllStocksWithPagination', async () => {
-    const resp = await client.getAllStocks(Region.Tr, 10, 10);
-    expect(resp).not.toBeEmpty();
-    expect(resp.length).toBe(10);
+  describe("getStockDetailById", () => {
+    test("should return stock detail by ID", async () => {
+      const resp = await client.getStockDetailById(
+        "61dd0d6f0ec2114146342fd0",
+        Locale.Tr
+      );
+
+      expect(resp).toBeDefined();
+      expect(typeof resp.id).toBe("string");
+      expect(typeof resp.assetClass).toBe("string");
+      expect(typeof resp.description).toBe("string");
+      expect(typeof resp.shortDescription).toBe("string");
+      expect(typeof resp.region).toBe("string");
+      expect(typeof resp.localized_description).toBe("object");
+      expect(typeof resp.localizedShortDescription).toBe("object");
+
+      if (resp.markets) {
+        expect(Array.isArray(resp.markets)).toBe(true);
+      }
+    });
   });
 
-  test('GetStockDetailByID', async () => {
-    const resp = await client.getStockDetailById("61dd0d6f0ec2114146342fd0", Locale.Tr);
-    expect(resp).not.toBeEmpty();
+  describe("getStockDetailBySymbol", () => {
+    test("should return stock detail by symbol", async () => {
+      const resp = await client.getStockDetailBySymbol(
+        "TUPRS",
+        AssetClass.Equity,
+        Region.Tr,
+        Locale.Tr
+      );
+
+      expect(resp).toBeDefined();
+      expect(resp.symbol).toBe("TUPRS");
+      expect(typeof resp.assetClass).toBe("string");
+      expect(typeof resp.description).toBe("string");
+      expect(typeof resp.region).toBe("string");
+    });
   });
 
-  test('GetStockDetailBySymbol', async () => {
-    const resp = await client.getStockDetailBySymbol("TUPRS", AssetClass.Equity, Region.Tr, Locale.Tr);
-    expect(resp).not.toBeEmpty();
+  describe("getHistoricalPrices", () => {
+    test("should return historical prices for multiple symbols", async () => {
+      const resp = await client.getHistoricalPrices(
+        ["TUPRS", "SASA"],
+        Region.Tr,
+        [
+          HistoricalPricePeriod.OneDay,
+          HistoricalPricePeriod.OneWeek,
+          HistoricalPricePeriod.OneMonth,
+        ]
+      );
+
+      expect(resp).not.toBeEmpty();
+
+      const firstPriceGraph = resp[0];
+      expect(typeof firstPriceGraph.symbol).toBe("string");
+      expect(Array.isArray(firstPriceGraph["1D"])).toBe(true);
+      expect(Array.isArray(firstPriceGraph["1W"])).toBe(true);
+      expect(Array.isArray(firstPriceGraph["1M"])).toBe(true);
+
+      if (firstPriceGraph["1D"].length > 0) {
+        const firstDataPoint = firstPriceGraph["1D"][0];
+        expect(typeof firstDataPoint.d).toBe("number");
+        expect(typeof firstDataPoint.c).toBe("number");
+        expect(typeof firstDataPoint.h).toBe("number");
+        expect(typeof firstDataPoint.l).toBe("number");
+        expect(typeof firstDataPoint.o).toBe("number");
+      }
+    });
   });
 
-  test('GetHistoricalPrices', async () => {
-    const resp = await client.getHistoricalPrices(
-      ["TUPRS", "SASA"],
-      Region.Tr,
-      [HistoricalPricePeriod.OneDay, HistoricalPricePeriod.OneWeek, HistoricalPricePeriod.OneMonth]
-    );
-    expect(resp).not.toBeEmpty();
-
-    for (const price of resp) {
-      expect(price).not.toBeEmpty();
-    }
+  describe("getCustomHistoricalPrices", () => {
+    test("should return custom historical prices", async () => {
+      const resp = await client.getCustomHistoricalPrices(
+        "TUPRS",
+        Region.Tr,
+        "2024-01-01",
+        "2024-03-01",
+        HistoricalPriceInterval.OneDay,
+        false
+      );
+
+      expect(resp).not.toBeEmpty();
+
+      const firstDataPoint = resp[0];
+      expect(typeof firstDataPoint.d).toBe("number");
+      expect(typeof firstDataPoint.c).toBe("number");
+      expect(typeof firstDataPoint.h).toBe("number");
+      expect(typeof firstDataPoint.l).toBe("number");
+      expect(typeof firstDataPoint.o).toBe("number");
+    });
+
+    test("should handle detailed historical prices", async () => {
+      const resp = await client.getCustomHistoricalPrices(
+        "SASA",
+        Region.Tr,
+        "2024-01-01 10:00:00",
+        "2024-01-05 10:00:00",
+        HistoricalPriceInterval.OneHour,
+        true
+      );
+
+      expect(resp).not.toBeEmpty();
+    });
   });
 
-  test('GetCustomHistoricalPrices', async () => {
-    let resp = await client.getCustomHistoricalPrices(
-      "TUPRS",
-      Region.Tr,
-      "2024-01-01",
-      "2024-03-01",
-      HistoricalPriceInterval.OneDay,
-      false
-    );
-    expect(resp).not.toBeEmpty();
-
-    for (const price of resp) {
-      expect(price).not.toBeEmpty();
-    }
-
-    resp = await client.getCustomHistoricalPrices(
-      "SASA",
-      Region.Tr,
-      "2024-01-01 10:00:00",
-      "2024-01-05 10:00:00",
-      HistoricalPriceInterval.OneHour,
-      true
-    );
-    expect(resp).not.toBeEmpty();
-
-    for (const price of resp) {
-      expect(price).not.toBeEmpty();
-    }
+  describe("getStockRestrictions", () => {
+    test("should return stock restrictions for specific symbol", async () => {
+      const resp = await client.getStockRestrictions("TUPRS", Region.Tr);
+
+      if (resp && resp.length > 0) {
+        const firstRestriction = resp[0];
+        expect(typeof firstRestriction.id).toBe("number");
+        expect(typeof firstRestriction.title).toBe("string");
+        expect(typeof firstRestriction.description).toBe("string");
+        expect(typeof firstRestriction.startDate).toBe("string");
+        expect(typeof firstRestriction.endDate).toBe("string");
+
+        if (firstRestriction.symbol) {
+          expect(typeof firstRestriction.symbol).toBe("string");
+        }
+        if (firstRestriction.market) {
+          expect(typeof firstRestriction.market).toBe("string");
+        }
+      }
+    });
   });
 
-  test('GetStockRestrictions', async () => {
-    await client.getStockRestrictions("TUPRS", Region.Tr);
+  describe("getAllStockRestrictions", () => {
+    test("should return all stock restrictions for region", async () => {
+      const resp = await client.getAllStockRestrictions(Region.Tr);
+
+      expect(Array.isArray(resp)).toBe(true);
+
+      if (resp.length > 0) {
+        const firstRestriction = resp[0];
+        expect(typeof firstRestriction.id).toBe("number");
+        expect(typeof firstRestriction.title).toBe("string");
+        expect(typeof firstRestriction.description).toBe("string");
+        expect(typeof firstRestriction.startDate).toBe("string");
+        expect(typeof firstRestriction.endDate).toBe("string");
+      }
+    });
   });
 
-  test('GetTickRules', async () => {
-    const resp = await client.getTickRules("TUPRS", Region.Tr);
-    expect(resp).not.toBeEmpty();
+  describe("getTickRules", () => {
+    test("should return tick rules for symbol", async () => {
+      const resp = await client.getTickRules("TUPRS", Region.Tr);
+
+      expect(resp).toBeDefined();
+      expect(typeof resp.basePrice).toBe("number");
+      expect(typeof resp.additionalPrice).toBe("number");
+      expect(typeof resp.lowerPriceLimit).toBe("number");
+      expect(typeof resp.upperPriceLimit).toBe("number");
+
+      if (resp.rules !== null) {
+        expect(Array.isArray(resp.rules)).toBe(true);
+      }
+    });
   });
 });