laplace-api 3.0.1 → 4.0.0

package/src/test/financial_ratios.test.ts

@@ -1,6 +1,5 @@
 import { Logger } from "winston";
 import { LaplaceConfiguration } from "../utilities/configuration";
-import { Client, createClient } from "../client/client";
 import {
   FinancialClient,
   HistoricalRatiosKey,
@@ -8,12 +7,13 @@ import {
   FinancialSheetPeriod,
   Currency,
   HistoricalFinancialSheetRow,
+  RatioComparisonPeerType,
 } from "../client/financial_ratios";
-import { Region, Locale } from "../client/collections";
 import "./client_test_suite";
 import { equal } from "assert";
+import { Locale, Region } from "../client/collections";
 
-describe('FinancialRatios', () => {
+describe("FinancialRatios", () => {
   let financialClient: FinancialClient;
 
   beforeAll(() => {
@@ -28,46 +28,78 @@ describe('FinancialRatios', () => {
     financialClient = new FinancialClient(config, logger);
   });
 
-  test('GetFinancialRatioComparison', async () => {
-    const resp = await financialClient.getFinancialRatioComparison('TUPRS', Region.Tr);
-    expect(resp).not.toBeEmpty();
-  });
-
-  test("GetHistoricalRatios", async () => {
-    const resp = await financialClient.getHistoricalRatios(
+  test("GetFinancialRatioComparison", async () => {
+    const resp = await financialClient.getFinancialRatioComparison(
       "TUPRS",
-      Object.values(HistoricalRatiosKey).flat(),
       Region.Tr,
-      Locale.Tr
+      RatioComparisonPeerType.Sector
     );
     expect(resp).not.toBeEmpty();
-    for (const ratio of resp) {
-      expect(typeof ratio.finalValue).toBe("number");
-      expect(typeof ratio.threeYearGrowth).toBe("number");
-      expect(typeof ratio.yearGrowth).toBe("number");
-      expect(typeof ratio.finalSectorValue).toBe("number");
-      expect(equal(ratio.currency, Currency.TRY));
-      expect(typeof ratio.format).toBe("string");
-      expect(typeof ratio.name).toBe("string");
-      expect(ratio.items).not.toBeEmpty();
-      expect(ratio.items.at(0)).toBeTruthy();
-      expect(typeof ratio.items.at(0)?.period).toBe("string");
-      expect(typeof ratio.items.at(0)?.sectorMean).toBe("number");
-      expect(typeof ratio.items.at(0)?.value).toBe("number");
-    }
+
+    const comparison = resp[0];
+    expect(typeof comparison.metricName).toBe("string");
+    expect(typeof comparison.normalizedValue).toBe("number");
+
+    const comparisonData = comparison.data;
+    expect(Array.isArray(comparisonData)).toBe(true);
+    expect(comparisonData).not.toBeEmpty();
+    expect(typeof comparisonData[0].slug).toBe("string");
+    expect(typeof comparisonData[0].value).toBe("number");
+    expect(typeof comparisonData[0].average).toBe("number");
   });
 
-  test("GetHistoricalRatiosDescriptions", async () => {
-    const resp = await financialClient.getHistoricalRatiosDescriptions(
-      Locale.Tr,
-      Region.Tr
-    );
-    expect(resp).not.toBeEmpty();
+  describe("GetHistoricalRatios", () => {
+    test("GetHistoricalRatios", async () => {
+      const resp = await financialClient.getHistoricalRatios(
+        "TUPRS",
+        Object.values(HistoricalRatiosKey).flat(),
+        Region.Tr,
+        Locale.Tr
+      );
+      expect(resp).not.toBeEmpty();
+
+      const firstRatio = resp[0];
+      expect(typeof firstRatio.finalValue).toBe("number");
+      expect(typeof firstRatio.threeYearGrowth).toBe("number");
+      expect(typeof firstRatio.yearGrowth).toBe("number");
+      expect(typeof firstRatio.finalSectorValue).toBe("number");
+      expect(equal(firstRatio.currency, Currency.TRY));
+      expect(typeof firstRatio.format).toBe("string");
+      expect(typeof firstRatio.name).toBe("string");
+
+      expect(firstRatio.items).not.toBeEmpty();
+      const firstItem = firstRatio.items[0];
+      expect(typeof firstItem.period).toBe("string");
+      expect(typeof firstItem.sectorMean).toBe("number");
+      expect(typeof firstItem.value).toBe("number");
+    });
+  });
+
+  describe("GetHistoricalRatiosDescriptions", () => {
+    test("GetHistoricalRatiosDescriptions", async () => {
+      const resp = await financialClient.getHistoricalRatiosDescriptions(
+        Locale.Tr,
+        Region.Tr
+      );
+      expect(resp).not.toBeEmpty();
+
+      const firstDescription = resp[0];
+      expect(typeof firstDescription.id).toBe("number");
+      expect(typeof firstDescription.format).toBe("string");
+      expect(typeof firstDescription.currency).toBe("string");
+      expect(typeof firstDescription.slug).toBe("string");
+      expect(typeof firstDescription.createdAt).toBe("string");
+      expect(typeof firstDescription.updatedAt).toBe("string");
+      expect(typeof firstDescription.name).toBe("string");
+      expect(typeof firstDescription.description).toBe("string");
+      expect(typeof firstDescription.locale).toBe("string");
+      expect(typeof firstDescription.isRealtime).toBe("boolean");
+    });
   });
 
-  test('GetHistoricalFinancialSheets', async () => {
+  test("GetHistoricalFinancialSheets", async () => {
     const resp = await financialClient.getHistoricalFinancialSheets(
-      'TUPRS',
+      "TUPRS",
       { year: 2022, month: 1, day: 1 },
       { year: 2025, month: 1, day: 1 },
       FinancialSheetType.CashFlow,
@@ -88,7 +120,7 @@ describe('FinancialRatios', () => {
     expect(firstSheet).toBeDefined();
 
     expect(firstSheet.period).toBeDefined();
-    expect(typeof firstSheet.period).toBe("string")
+    expect(typeof firstSheet.period).toBe("string");
 
     expect(firstSheet.items).toBeDefined();
     expect(Array.isArray(firstSheet.items)).toBe(true);
@@ -102,8 +134,6 @@ describe('FinancialRatios', () => {
       value: expect.any(Number),
       lineCodeId: expect.any(Number),
       indentLevel: expect.any(Number),
-      firstAncestorLineCodeId: expect.any(Number),
-      sectionLineCodeId: expect.any(Number),
     });
   });
 });

package/src/test/funds.test.ts

@@ -0,0 +1,110 @@
+import { Logger } from "winston";
+import { LaplaceConfiguration } from "../utilities/configuration";
+import "./client_test_suite";
+import {
+  FundsClient,
+  FundType,
+  HistoricalFundPricePeriod,
+} from "../client/funds";
+import { Region } from "../client/collections";
+
+describe("Funds Client", () => {
+  let client: FundsClient;
+
+  beforeAll(() => {
+    const config = (global as any).testSuite.config as LaplaceConfiguration;
+    const logger: Logger = {
+      info: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn(),
+      debug: jest.fn(),
+    } as unknown as Logger;
+
+    client = new FundsClient(config, logger);
+  });
+
+  describe("getFunds", () => {
+    test("should return funds list for TR region", async () => {
+      const resp = await client.getFunds(Region.Tr, 1, 10);
+
+      expect(resp).toBeDefined();
+      expect(Array.isArray(resp)).toBe(true);
+      expect(resp.length).toBeGreaterThan(0);
+
+      const fund = resp[0];
+      expect(typeof fund.symbol).toBe("string");
+      expect(typeof fund.name).toBe("string");
+      expect(typeof fund.assetType).toBe("string");
+      expect(typeof fund.managementFee).toBe("number");
+      expect(typeof fund.riskLevel).toBe("number");
+      expect(typeof fund.ownerSymbol).toBe("string");
+      expect(Object.values(FundType)).toContain(fund.fundType);
+    });
+
+    test("should handle pagination correctly", async () => {
+      const page1 = await client.getFunds(Region.Tr, 1, 5);
+
+      expect(page1.length).toBeLessThanOrEqual(5);
+    });
+  });
+
+  describe("getFundStats", () => {
+    test("should return fund statistics", async () => {
+      const resp = await client.getFundStats("SPP", Region.Tr);
+
+      expect(resp).toBeDefined();
+      expect(typeof resp.yearBeta).toBe("number");
+      expect(typeof resp.yearStdev).toBe("number");
+      expect(typeof resp.ytdReturn).toBe("number");
+      expect(typeof resp.yearMomentum).toBe("number");
+      expect(typeof resp.yearlyReturn).toBe("number");
+      expect(typeof resp.monthlyReturn).toBe("number");
+      expect(typeof resp.fiveYearReturn).toBe("number");
+      expect(typeof resp.sixMonthReturn).toBe("number");
+      expect(typeof resp.threeYearReturn).toBe("number");
+      expect(typeof resp.threeMonthReturn).toBe("number");
+    });
+
+    test("should handle invalid fund symbol", async () => {
+      await expect(
+        client.getFundStats("INVALID_FUND", Region.Tr)
+      ).rejects.toThrow();
+    });
+  });
+
+  describe("getFundDistribution", () => {
+    test("should return fund asset distribution", async () => {
+      const resp = await client.getFundDistribution("SPP", Region.Tr);
+
+      expect(resp).toBeDefined();
+      expect(Array.isArray(resp.categories)).toBe(true);
+
+      if (resp.categories.length > 0) {
+        const distribution = resp.categories[0];
+        expect(distribution.category).toBeDefined();
+        expect(typeof distribution.percentage).toBe("number");
+      }
+    });
+  });
+
+  describe("getHistoricalFundPrices", () => {
+    test("should return historical prices", async () => {
+      const resp = await client.getHistoricalFundPrices(
+        "SPP",
+        Region.Tr,
+        HistoricalFundPricePeriod.OneMonth
+      );
+
+      expect(resp).toBeDefined();
+      expect(Array.isArray(resp)).toBe(true);
+      expect(resp.length).toBeGreaterThan(0);
+
+      const pricePoint = resp[0];
+      expect(typeof pricePoint.price).toBe("number");
+      expect(typeof pricePoint.aum).toBe("number");
+      expect(pricePoint.date).toBeDefined();
+      expect(typeof pricePoint.shareCount).toBe("number");
+      expect(typeof pricePoint.investorCount).toBe("number");
+    });
+  });
+});

package/src/test/helpers.ts

@@ -0,0 +1,58 @@
+import { Collection, CollectionDetail } from "../client/collections";
+
+export const validateCollection = (collection: Collection) => {
+    expect(typeof collection.id).toBe("string");
+    expect(typeof collection.title).toBe("string");
+    expect(typeof collection.imageUrl).toBe("string");
+    expect(typeof collection.avatarUrl).toBe("string");
+    expect(typeof collection.numStocks).toBe("number");
+  
+    if (collection.description !== undefined) {
+      expect(typeof collection.description).toBe("string");
+    }
+    
+    if (collection.region !== undefined) {
+      expect(Array.isArray(collection.region)).toBe(true);
+      collection.region.forEach(region => {
+        expect(typeof region).toBe("string");
+      });
+    }
+    
+    if (collection.assetClass !== undefined) {
+      expect(typeof collection.assetClass).toBe("string");
+    }
+    
+    if (collection.image !== undefined) {
+      expect(typeof collection.image).toBe("string");
+    }
+    
+    if (collection.order !== undefined) {
+      expect(typeof collection.order).toBe("number");
+    }
+    
+    if (collection.status !== undefined) {
+      expect(typeof collection.status).toBe("string");
+    }
+    
+    if (collection.metaData !== undefined) {
+      expect(typeof collection.metaData).toBe("object");
+      expect(collection.metaData).not.toBeNull();
+    }
+  };
+  
+  export const validateCollectionDetail = (collectionDetail: CollectionDetail) => {
+    validateCollection(collectionDetail);
+    
+    expect(Array.isArray(collectionDetail.stocks)).toBe(true);
+    expect(collectionDetail.stocks.length).toBeGreaterThan(0);
+    
+    const firstStock = collectionDetail.stocks[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");
+  };

package/src/test/key-insight.test.ts

@@ -0,0 +1,48 @@
+import { Logger } from "winston";
+import { LaplaceConfiguration } from "../utilities/configuration";
+import "./client_test_suite";
+import { KeyInsightClient } from "../client/key-insights";
+import { Region } from "../client/collections";
+
+describe("Key Insight", () => {
+  let client: KeyInsightClient;
+
+  beforeAll(() => {
+    const config = (global as any).testSuite.config as LaplaceConfiguration;
+    const logger: Logger = {
+      info: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn(),
+      debug: jest.fn(),
+    } as unknown as Logger;
+
+    client = new KeyInsightClient(config, logger);
+  });
+
+  describe("getKeyInsights", () => {
+    test("should return key insights for valid symbol", async () => {
+      const resp = await client.getKeyInsights("TOASO", Region.Tr);
+
+      expect(resp).toBeDefined();
+      expect(resp.insight).toBeDefined();
+      expect(resp.insight.length).toBeGreaterThan(0);
+      expect(resp.symbol).toBe("TOASO");
+    });
+
+    test("should handle invalid symbol gracefully", async () => {
+      await expect(
+        client.getKeyInsights("INVALID_SYMBOL", Region.Tr)
+      ).rejects.toThrow();
+    });
+
+    test("should work with US region", async () => {
+      const resp = await client.getKeyInsights("AAPL", Region.Us);
+      expect(resp).toBeDefined();
+      expect(resp.symbol).toBe("AAPL");
+    });
+
+    test("should handle empty symbol", async () => {
+      await expect(client.getKeyInsights("", Region.Tr)).rejects.toThrow();
+    });
+  });
+});

package/src/test/live-price.test.ts

@@ -1,6 +1,5 @@
 import { Logger } from "winston";
 import { LaplaceConfiguration } from "../utilities/configuration";
-import { Region } from "../client/collections";
 import "./client_test_suite";
 import { LivePriceClient } from "../client/live-price";
 import {
@@ -16,8 +15,8 @@ describe("LivePrice", () => {
   let ws: LivePriceWebSocketClient;
 
   const TEST_CONSTANTS = {
-    JEST_TIMEOUT: 30000,
-    MAIN_TIMEOUT: 25000,
+    JEST_TIMEOUT: 15000,
+    MAIN_TIMEOUT: 10000,
   };
 
   beforeAll(async () => {
@@ -67,7 +66,7 @@ describe("LivePrice", () => {
             }
           );
 
-        await new Promise((resolve) => setTimeout(resolve, 20000));
+        await new Promise((resolve) => setTimeout(resolve, TEST_CONSTANTS.MAIN_TIMEOUT));
 
         for (const symbol of symbols) {
           const symbolData = receivedData.filter(
@@ -100,7 +99,7 @@ describe("LivePrice", () => {
             }
           );
 
-        await new Promise((resolve) => setTimeout(resolve, 20000));
+        await new Promise((resolve) => setTimeout(resolve, TEST_CONSTANTS.MAIN_TIMEOUT));
 
         for (const symbol of symbols) {
           const symbolData = receivedData.filter(

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);
   });
-});
+});