laplace-api 4.0.0 → 4.2.0

package/src/test/stocks.test.ts

@@ -5,9 +5,180 @@ import {
   HistoricalPricePeriod,
   HistoricalPriceInterval,
   AssetClass,
+  Stock,
+  AssetType,
+  Market,
+  StockPriceGraph,
+  MarketState,
+  EarningsTranscriptWithSummary,
+  EarningsTranscriptListItem
 } from "../client/stocks";
 import "./client_test_suite";
 import { Region, Locale } from "../client/collections";
+import { PaginatedResponse } from "../client/capital_increase";
+
+const mockStocksResponse: Stock[] = [
+  {
+    id: "61dd0d6f0ec2114146342fd0",
+    assetType: AssetType.Stock,
+    name: "Tüpraş",
+    symbol: "TUPRS",
+    sectorId: "sector123",
+    industryId: "industry456",
+    updatedDate: "2024-03-14T10:00:00Z",
+    dailyChange: 2.5,
+    active: true
+  },
+  {
+    id: "61dd0d6f0ec2114146342fd1",
+    assetType: AssetType.Stock,
+    name: "Garanti Bankası",
+    symbol: "GARAN",
+    sectorId: "sector789",
+    industryId: "industry101",
+    updatedDate: "2024-03-14T10:00:00Z",
+    dailyChange: -1.2,
+    active: true
+  }
+];
+
+const mockStockDetailResponse = {
+  id: "61dd0d6f0ec2114146342fd0",
+  assetType: AssetType.Stock,
+  assetClass: AssetClass.Equity,
+  name: "Tüpraş",
+  symbol: "TUPRS",
+  sectorId: "sector123",
+  industryId: "industry456",
+  updatedDate: "2024-03-14T10:00:00Z",
+  dailyChange: 2.5,
+  active: true,
+  description: "Türkiye'nin en büyük rafineri şirketi",
+  shortDescription: "Rafineri şirketi",
+  region: Region.Tr,
+  localized_description: {
+    tr: "Türkiye'nin en büyük rafineri şirketi",
+    en: "Turkey's largest refinery company"
+  },
+  localizedShortDescription: {
+    tr: "Rafineri şirketi",
+    en: "Refinery company"
+  },
+  markets: [Market.Yildiz]
+};
+
+const mockHistoricalPricesResponse: StockPriceGraph[] = [
+  {
+    symbol: "TUPRS",
+    "1D": [
+      { d: 1710374400000, c: 425.5, h: 428.0, l: 422.0, o: 423.0 },
+      { d: 1710378000000, c: 426.8, h: 427.5, l: 425.0, o: 425.5 }
+    ],
+    "1W": [
+      { d: 1709856000000, c: 420.5, h: 422.0, l: 419.0, o: 419.5 },
+      { d: 1709942400000, c: 423.0, h: 424.5, l: 420.0, o: 420.5 }
+    ],
+    "1M": [
+      { d: 1707436800000, c: 415.0, h: 416.5, l: 414.0, o: 414.5 },
+      { d: 1707523200000, c: 417.2, h: 418.0, l: 415.0, o: 415.0 }
+    ],
+    "3M": [],
+    "1Y": [],
+    "2Y": [],
+    "3Y": [],
+    "5Y": []
+  }
+];
+
+const mockStockRestrictionsResponse = [
+  {
+    id: 1,
+    title: "Bedelli Sermaye Artırımı",
+    description: "Şirket bedelli sermaye artırımı yapacaktır",
+    symbol: "TUPRS",
+    startDate: "2024-03-15T00:00:00Z",
+    endDate: "2024-03-20T00:00:00Z",
+    market: Market.Yildiz
+  },
+  {
+    id: 2,
+    title: "Temettü Ödemesi",
+    description: "Şirket temettü ödemesi yapacaktır",
+    symbol: "TUPRS",
+    startDate: "2024-04-01T00:00:00Z",
+    endDate: "2024-04-01T00:00:00Z",
+    market: Market.Yildiz
+  }
+];
+
+const mockTickRulesResponse = {
+  basePrice: 425.5,
+  additionalPrice: 0.1,
+  lowerPriceLimit: 382.95,
+  upperPriceLimit: 468.05,
+  rules: [
+    { priceFrom: 0, priceTo: 20, tickSize: 0.01 },
+    { priceFrom: 20, priceTo: 50, tickSize: 0.02 },
+    { priceFrom: 50, priceTo: 100, tickSize: 0.05 }
+  ]
+};
+
+const mockEarningsTranscriptList: EarningsTranscriptListItem[] = [
+  {
+    symbol: "TUPRS",
+    year: 2024,
+    quarter: 1,
+    date: "2024-05-15",
+    fiscal_year: 2024
+  },
+  {
+    symbol: "TUPRS",
+    year: 2023,
+    quarter: 4,
+    date: "2024-02-20",
+    fiscal_year: 2023
+  }
+];
+
+const mockEarningsTranscriptDetail: EarningsTranscriptWithSummary = {
+  symbol: "TUPRS",
+  year: 2024,
+  quarter: 1,
+  date: "2024-05-15",
+  content: "Q1 2024 earnings call transcript content...",
+  summary: "Strong Q1 performance with 15% revenue growth",
+  has_summary: true
+};
+
+const mockMarketStates: MarketState[] = [
+  {
+    id: 1,
+    marketSymbol: "XIST",
+    state: "OPEN",
+    lastTimestamp: "2024-03-14T10:00:00Z",
+    stockSymbol: "TUPRS"
+  },
+  {
+    id: 2,
+    marketSymbol: "XIST",
+    state: "CLOSED",
+    lastTimestamp: "2024-03-14T18:00:00Z",
+    stockSymbol: "GARAN"
+  }
+];
+
+const mockPaginatedMarketStates: PaginatedResponse<MarketState> = {
+  recordCount: 2,
+  items: mockMarketStates
+};
+
+const mockSingleMarketState: MarketState = {
+  id: 1,
+  marketSymbol: "XIST",
+  state: "OPEN",
+  lastTimestamp: "2024-03-14T10:00:00Z",
+  stockSymbol: "TUPRS"
+};
 
 describe("Stocks Client", () => {
   let client: StockClient;
@@ -24,192 +195,633 @@ describe("Stocks Client", () => {
     client = new StockClient(config, logger);
   });
 
-  describe("getAllStocks", () => {
-    test("should return stocks list for TR region", async () => {
-      const resp = await client.getAllStocks(Region.Tr);
-
-      expect(resp).not.toBeEmpty();
+  describe("Integration Tests", () => {
+    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");
+        }
+      });
 
-      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");
+      test("should handle pagination correctly", async () => {
+        const resp = await client.getAllStocks(Region.Tr, 10, 10);
 
-      if (firstStock.dailyChange !== undefined) {
-        expect(typeof firstStock.dailyChange).toBe("number");
-      }
+        expect(resp).not.toBeEmpty();
+        expect(resp.length).toBeLessThanOrEqual(10);
+      });
     });
 
-    test("should handle pagination correctly", async () => {
-      const resp = await client.getAllStocks(Region.Tr, 10, 10);
-
-      expect(resp).not.toBeEmpty();
-      expect(resp.length).toBeLessThanOrEqual(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);
+        }
+      });
     });
-  });
 
-  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);
-      }
+    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");
+      });
     });
-  });
 
-  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");
+    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");
+        }
+      });
     });
-  });
-
-  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();
+    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
+        );
 
-      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);
+        expect(resp).not.toBeEmpty();
 
-      if (firstPriceGraph["1D"].length > 0) {
-        const firstDataPoint = firstPriceGraph["1D"][0];
+        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();
+      });
     });
-  });
 
-  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();
+    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");
+          }
+        }
+      });
     });
-  });
 
-  describe("getStockRestrictions", () => {
-    test("should return stock restrictions for specific symbol", async () => {
-      const resp = await client.getStockRestrictions("TUPRS", Region.Tr);
+    describe("getAllStockRestrictions", () => {
+      test("should return all stock restrictions for region", async () => {
+        const resp = await client.getAllStockRestrictions(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");
+        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");
+        }
+      });
+    });
+
+    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);
+        }
+      });
+    });
+
+    describe("getEarningsTranscripts", () => {
+      test("should return earnings transcript list", async () => {
+        const resp = await client.getEarningsTranscripts("TUPRS", Region.Tr);
+
+        expect(Array.isArray(resp)).toBe(true);
+
+        if (resp.length > 0) {
+          const firstTranscript = resp[0];
+          expect(typeof firstTranscript.symbol).toBe("string");
+          expect(typeof firstTranscript.year).toBe("number");
+          expect(typeof firstTranscript.quarter).toBe("number");
+          expect(typeof firstTranscript.date).toBe("string");
+          expect(typeof firstTranscript.fiscal_year).toBe("number");
+        }
+      });
+    });
+
+    describe("getEarningsTranscript", () => {
+      test("should return earnings transcript detail", async () => {
+        const resp = await client.getEarningsTranscript("TUPRS", 2023, 4);
+
+        expect(resp).toBeDefined();
+        expect(typeof resp.symbol).toBe("string");
+        expect(typeof resp.year).toBe("number");
+        expect(typeof resp.quarter).toBe("number");
+        expect(typeof resp.date).toBe("string");
+        expect(typeof resp.content).toBe("string");
+        expect(typeof resp.has_summary).toBe("boolean");
+
+        if (resp.summary) {
+          expect(typeof resp.summary).toBe("string");
+        }
+      });
+    });
+
+    describe("getStockStateAll", () => {
+      test("should return paginated stock states", async () => {
+        const resp = await client.getStockStateAll(0, 10, Region.Tr);
+
+        expect(resp).toBeDefined();
+        expect(Array.isArray(resp.items)).toBe(true);
+        expect(typeof resp.recordCount).toBe("number");
+
+        if (resp.items.length > 0) {
+          const firstState = resp.items[0];
+          expect(typeof firstState.id).toBe("number");
+          expect(typeof firstState.state).toBe("string");
+          expect(typeof firstState.lastTimestamp).toBe("string");
+        }
+      });
+    });
+
+    describe("getStockState", () => {
+      test("should return single stock state", async () => {
+        const resp = await client.getStockState("TUPRS");
+
+        expect(resp).toBeDefined();
+        expect(typeof resp.id).toBe("number");
+        expect(typeof resp.state).toBe("string");
+        expect(typeof resp.lastTimestamp).toBe("string");
+
+        if (resp.stockSymbol) {
+          expect(typeof resp.stockSymbol).toBe("string");
+        }
+        if (resp.marketSymbol) {
+          expect(typeof resp.marketSymbol).toBe("string");
         }
-        if (firstRestriction.market) {
-          expect(typeof firstRestriction.market).toBe("string");
+      });
+    });
+
+    describe("getStateAll", () => {
+      test("should return paginated market states", async () => {
+        const resp = await client.getStateAll(0, 10, Region.Tr);
+
+        expect(resp).toBeDefined();
+        expect(Array.isArray(resp.items)).toBe(true);
+        expect(typeof resp.recordCount).toBe("number");
+
+        if (resp.items.length > 0) {
+          const firstState = resp.items[0];
+          expect(typeof firstState.id).toBe("number");
+          expect(typeof firstState.state).toBe("string");
+          expect(typeof firstState.lastTimestamp).toBe("string");
+        }
+      });
+    });
+
+    describe("getState", () => {
+      test("should return single market state", async () => {
+        const resp = await client.getState("XIST");
+
+        expect(resp).toBeDefined();
+        expect(typeof resp.id).toBe("number");
+        expect(typeof resp.state).toBe("string");
+        expect(typeof resp.lastTimestamp).toBe("string");
+
+        if (resp.marketSymbol) {
+          expect(typeof resp.marketSymbol).toBe("string");
         }
-      }
+      });
     });
   });
 
-  describe("getAllStockRestrictions", () => {
-    test("should return all stock restrictions for region", async () => {
-      const resp = await client.getAllStockRestrictions(Region.Tr);
+  describe("Mock Tests", () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    describe("getAllStocks", () => {
+      test("should handle getAllStocks response correctly with mock data", async () => {
+        jest.spyOn(client, 'getAllStocks').mockResolvedValue(mockStocksResponse);
+
+        const resp = await client.getAllStocks(Region.Tr);
+
+        expect(resp).toHaveLength(2);
+        
+        const firstStock = resp[0];
+        expect(firstStock.id).toBe("61dd0d6f0ec2114146342fd0");
+        expect(firstStock.assetType).toBe(AssetType.Stock);
+        expect(firstStock.name).toBe("Tüpraş");
+        expect(firstStock.symbol).toBe("TUPRS");
+        expect(firstStock.sectorId).toBe("sector123");
+        expect(firstStock.industryId).toBe("industry456");
+        expect(firstStock.updatedDate).toBe("2024-03-14T10:00:00Z");
+        expect(firstStock.dailyChange).toBe(2.5);
+        expect(firstStock.active).toBe(true);
+
+        const secondStock = resp[1];
+        expect(secondStock.id).toBe("61dd0d6f0ec2114146342fd1");
+        expect(secondStock.symbol).toBe("GARAN");
+        expect(secondStock.dailyChange).toBe(-1.2);
+        
+        expect(client.getAllStocks).toHaveBeenCalledWith(Region.Tr);
+      });
+
+      test("should handle pagination correctly with mock data", async () => {
+        jest.spyOn(client, 'getAllStocks').mockResolvedValue([mockStocksResponse[0]]);
+
+        const resp = await client.getAllStocks(Region.Tr, 1, 0);
+
+        expect(resp).toHaveLength(1);
+        expect(resp[0].symbol).toBe("TUPRS");
+        
+        expect(client.getAllStocks).toHaveBeenCalledWith(Region.Tr, 1, 0);
+      });
+
+      test("should handle API errors correctly", async () => {
+        jest.spyOn(client, 'getAllStocks').mockRejectedValue(new Error("API Error"));
+
+        await expect(client.getAllStocks(Region.Tr)).rejects.toThrow("API Error");
+      });
+    });
+
+    describe("getStockDetailById", () => {
+      test("should return stock detail by ID with mock data", async () => {
+        jest.spyOn(client, 'getStockDetailById').mockResolvedValue(mockStockDetailResponse);
+
+        const resp = await client.getStockDetailById("61dd0d6f0ec2114146342fd0", Locale.Tr);
+
+        expect(resp).toBeDefined();
+        expect(resp.id).toBe("61dd0d6f0ec2114146342fd0");
+        expect(resp.assetType).toBe(AssetType.Stock);
+        expect(resp.assetClass).toBe(AssetClass.Equity);
+        expect(resp.description).toBe("Türkiye'nin en büyük rafineri şirketi");
+        expect(resp.shortDescription).toBe("Rafineri şirketi");
+        expect(resp.region).toBe(Region.Tr);
+        expect(resp.localized_description).toEqual({
+          tr: "Türkiye'nin en büyük rafineri şirketi",
+          en: "Turkey's largest refinery company"
+        });
+        expect(resp.localizedShortDescription).toEqual({
+          tr: "Rafineri şirketi",
+          en: "Refinery company"
+        });
+        expect(resp.markets).toEqual([Market.Yildiz]);
+
+        expect(client.getStockDetailById).toHaveBeenCalledWith("61dd0d6f0ec2114146342fd0", Locale.Tr);
+      });
+
+      test("should handle API errors for stock detail", async () => {
+        jest.spyOn(client, 'getStockDetailById').mockRejectedValue(new Error("Stock not found"));
+
+        await expect(client.getStockDetailById("invalid_id", Locale.Tr))
+          .rejects.toThrow("Stock not found");
+      });
+    });
 
-      expect(Array.isArray(resp)).toBe(true);
+    describe("getHistoricalPrices", () => {
+      test("should return historical prices for multiple symbols with mock data", async () => {
+        jest.spyOn(client, 'getHistoricalPrices').mockResolvedValue(mockHistoricalPricesResponse);
 
-      if (resp.length > 0) {
+        const symbols = ["TUPRS"];
+        const periods = [
+          HistoricalPricePeriod.OneDay,
+          HistoricalPricePeriod.OneWeek,
+          HistoricalPricePeriod.OneMonth
+        ];
+
+        const resp = await client.getHistoricalPrices(symbols, Region.Tr, periods);
+
+        expect(resp).toHaveLength(1);
+        
+        const firstPriceGraph = resp[0];
+        expect(firstPriceGraph.symbol).toBe("TUPRS");
+
+        expect(firstPriceGraph["1D"]).toHaveLength(2);
+        const firstDayPoint = firstPriceGraph["1D"][0];
+        expect(firstDayPoint.d).toBe(1710374400000);
+        expect(firstDayPoint.c).toBe(425.5);
+        expect(firstDayPoint.h).toBe(428.0);
+        expect(firstDayPoint.l).toBe(422.0);
+        expect(firstDayPoint.o).toBe(423.0);
+        expect(firstPriceGraph["1W"]).toHaveLength(2);
+        expect(firstPriceGraph["1M"]).toHaveLength(2);
+
+        expect(client.getHistoricalPrices).toHaveBeenCalledWith(
+          symbols,
+          Region.Tr,
+          periods
+        );
+      });
+
+      test("should handle API errors for historical prices", async () => {
+        jest.spyOn(client, 'getHistoricalPrices').mockRejectedValue(new Error("Failed to fetch historical prices"));
+
+        await expect(client.getHistoricalPrices(
+          ["TUPRS"],
+          Region.Tr,
+          [HistoricalPricePeriod.OneDay]
+        )).rejects.toThrow("Failed to fetch historical prices");
+      });
+    });
+
+    describe("getStockRestrictions", () => {
+      test("should return stock restrictions with mock data", async () => {
+        jest.spyOn(client, 'getStockRestrictions').mockResolvedValue(mockStockRestrictionsResponse);
+
+        const resp = await client.getStockRestrictions("TUPRS", Region.Tr);
+
+        expect(resp).toHaveLength(2);
+        
         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");
-      }
+        expect(firstRestriction.id).toBe(1);
+        expect(firstRestriction.title).toBe("Bedelli Sermaye Artırımı");
+        expect(firstRestriction.description).toBe("Şirket bedelli sermaye artırımı yapacaktır");
+        expect(firstRestriction.symbol).toBe("TUPRS");
+        expect(firstRestriction.startDate).toBe("2024-03-15T00:00:00Z");
+        expect(firstRestriction.endDate).toBe("2024-03-20T00:00:00Z");
+        expect(firstRestriction.market).toBe(Market.Yildiz);
+
+        expect(client.getStockRestrictions).toHaveBeenCalledWith("TUPRS", Region.Tr);
+      });
+
+      test("should handle API errors for stock restrictions", async () => {
+        jest.spyOn(client, 'getStockRestrictions').mockRejectedValue(new Error("Failed to fetch restrictions"));
+
+        await expect(client.getStockRestrictions("TUPRS", Region.Tr))
+          .rejects.toThrow("Failed to fetch restrictions");
+      });
     });
-  });
 
-  describe("getTickRules", () => {
-    test("should return tick rules for symbol", async () => {
-      const resp = await client.getTickRules("TUPRS", Region.Tr);
+    describe("getTickRules", () => {
+      test("should return tick rules with mock data", async () => {
+        jest.spyOn(client, 'getTickRules').mockResolvedValue(mockTickRulesResponse);
+
+        const resp = await client.getTickRules("TUPRS", Region.Tr);
+
+        expect(resp.basePrice).toBe(425.5);
+        expect(resp.additionalPrice).toBe(0.1);
+        expect(resp.lowerPriceLimit).toBe(382.95);
+        expect(resp.upperPriceLimit).toBe(468.05);
+        expect(resp.rules).toHaveLength(3);
+        
+        const firstRule = resp.rules![0];
+        expect(firstRule.priceFrom).toBe(0);
+        expect(firstRule.priceTo).toBe(20);
+        expect(firstRule.tickSize).toBe(0.01);
+
+        expect(client.getTickRules).toHaveBeenCalledWith("TUPRS", Region.Tr);
+      });
+
+      test("should handle API errors for tick rules", async () => {
+        jest.spyOn(client, 'getTickRules').mockRejectedValue(new Error("Failed to fetch tick rules"));
+
+        await expect(client.getTickRules("TUPRS", Region.Tr))
+          .rejects.toThrow("Failed to fetch tick rules");
+      });
+    });
+
+    describe("getEarningsTranscripts", () => {
+      test("should return earnings transcript list with mock data", async () => {
+        jest.spyOn(client, 'getEarningsTranscripts').mockResolvedValue(mockEarningsTranscriptList);
+
+        const resp = await client.getEarningsTranscripts("TUPRS", Region.Tr);
+
+        expect(resp).toHaveLength(2);
+        
+        const firstTranscript = resp[0];
+        expect(firstTranscript.symbol).toBe("TUPRS");
+        expect(firstTranscript.year).toBe(2024);
+        expect(firstTranscript.quarter).toBe(1);
+        expect(firstTranscript.date).toBe("2024-05-15");
+        expect(firstTranscript.fiscal_year).toBe(2024);
+
+        const secondTranscript = resp[1];
+        expect(secondTranscript.year).toBe(2023);
+        expect(secondTranscript.quarter).toBe(4);
+
+        expect(client.getEarningsTranscripts).toHaveBeenCalledWith("TUPRS", Region.Tr);
+      });
+
+      test("should handle API errors for earnings transcripts", async () => {
+        jest.spyOn(client, 'getEarningsTranscripts').mockRejectedValue(new Error("Transcripts not found"));
+
+        await expect(client.getEarningsTranscripts("INVALID", Region.Tr))
+          .rejects.toThrow("Transcripts not found");
+      });
+    });
+
+    describe("getEarningsTranscript", () => {
+      test("should return earnings transcript detail with mock data", async () => {
+        jest.spyOn(client, 'getEarningsTranscript').mockResolvedValue(mockEarningsTranscriptDetail);
+
+        const resp = await client.getEarningsTranscript("TUPRS", 2024, 1);
+
+        expect(resp.symbol).toBe("TUPRS");
+        expect(resp.year).toBe(2024);
+        expect(resp.quarter).toBe(1);
+        expect(resp.date).toBe("2024-05-15");
+        expect(resp.content).toBe("Q1 2024 earnings call transcript content...");
+        expect(resp.summary).toBe("Strong Q1 performance with 15% revenue growth");
+        expect(resp.has_summary).toBe(true);
+
+        expect(client.getEarningsTranscript).toHaveBeenCalledWith("TUPRS", 2024, 1);
+      });
+
+      test("should handle API errors for earnings transcript detail", async () => {
+        jest.spyOn(client, 'getEarningsTranscript').mockRejectedValue(new Error("Transcript not found"));
+
+        await expect(client.getEarningsTranscript("TUPRS", 2020, 1))
+          .rejects.toThrow("Transcript not found");
+      });
+    });
+
+    describe("getStockStateAll", () => {
+      test("should return paginated stock states with mock data", async () => {
+        jest.spyOn(client, 'getStockStateAll').mockResolvedValue(mockPaginatedMarketStates);
+
+        const resp = await client.getStockStateAll(0, 10, Region.Tr);
+
+        expect(resp.items).toHaveLength(2);
+        expect(resp.recordCount).toBe(2);
+
+        const firstState = resp.items[0];
+        expect(firstState.id).toBe(1);
+        expect(firstState.marketSymbol).toBe("XIST");
+        expect(firstState.state).toBe("OPEN");
+        expect(firstState.stockSymbol).toBe("TUPRS");
+
+        expect(client.getStockStateAll).toHaveBeenCalledWith(0, 10, Region.Tr);
+      });
+
+      test("should handle API errors for stock state all", async () => {
+        jest.spyOn(client, 'getStockStateAll').mockRejectedValue(new Error("Failed to fetch stock states"));
+
+        await expect(client.getStockStateAll(0, 10, Region.Tr))
+          .rejects.toThrow("Failed to fetch stock states");
+      });
+    });
+
+    describe("getStockState", () => {
+      test("should return single stock state with mock data", async () => {
+        jest.spyOn(client, 'getStockState').mockResolvedValue(mockSingleMarketState);
+
+        const resp = await client.getStockState("TUPRS");
+
+        expect(resp.id).toBe(1);
+        expect(resp.marketSymbol).toBe("XIST");
+        expect(resp.state).toBe("OPEN");
+        expect(resp.lastTimestamp).toBe("2024-03-14T10:00:00Z");
+        expect(resp.stockSymbol).toBe("TUPRS");
+
+        expect(client.getStockState).toHaveBeenCalledWith("TUPRS");
+      });
+
+      test("should handle API errors for single stock state", async () => {
+        jest.spyOn(client, 'getStockState').mockRejectedValue(new Error("Stock state not found"));
+
+        await expect(client.getStockState("INVALID"))
+          .rejects.toThrow("Stock state not found");
+      });
+    });
+
+    describe("getStateAll", () => {
+      test("should return paginated market states with mock data", async () => {
+        jest.spyOn(client, 'getStateAll').mockResolvedValue(mockPaginatedMarketStates);
+
+        const resp = await client.getStateAll(0, 10, Region.Tr);
+
+        expect(resp.items).toHaveLength(2);
+        expect(resp.recordCount).toBe(2);
+
+        const firstState = resp.items[0];
+        expect(firstState.state).toBe("OPEN");
+        expect(firstState.lastTimestamp).toBe("2024-03-14T10:00:00Z");
+
+        expect(client.getStateAll).toHaveBeenCalledWith(0, 10, Region.Tr);
+      });
+
+      test("should handle API errors for state all", async () => {
+        jest.spyOn(client, 'getStateAll').mockRejectedValue(new Error("Failed to fetch states"));
+
+        await expect(client.getStateAll(0, 10, Region.Tr))
+          .rejects.toThrow("Failed to fetch states");
+      });
+    });
+
+    describe("getState", () => {
+      test("should return single market state with mock data", async () => {
+        jest.spyOn(client, 'getState').mockResolvedValue(mockSingleMarketState);
+
+        const resp = await client.getState("XIST");
+
+        expect(resp.id).toBe(1);
+        expect(resp.marketSymbol).toBe("XIST");
+        expect(resp.state).toBe("OPEN");
+        expect(resp.lastTimestamp).toBe("2024-03-14T10:00:00Z");
+
+        expect(client.getState).toHaveBeenCalledWith("XIST");
+      });
 
-      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");
+      test("should handle API errors for single state", async () => {
+        jest.spyOn(client, 'getState').mockRejectedValue(new Error("Market state not found"));
 
-      if (resp.rules !== null) {
-        expect(Array.isArray(resp.rules)).toBe(true);
-      }
+        await expect(client.getState("INVALID"))
+          .rejects.toThrow("Market state not found");
+      });
     });
   });
 });