@oanda/labs-crowd-view-widget 1.0.44 → 1.0.46

package/test/utils/instrumentUtils.test.ts

@@ -14,11 +14,13 @@ describe('instrumentUtils', () => {
       expect(Array.isArray(result)).toBe(true);
       expect(result.length).toBeGreaterThan(0);
 
-      // Check that the first instrument has the expected OC format
+      // Check that the first instrument has the expected structure
       const firstInstrument = result[0];
       expect(firstInstrument).toHaveProperty('id');
       expect(firstInstrument).toHaveProperty('label');
-      expect(firstInstrument.id).toMatch(/^[A-Z]{3}_[A-Z]{3}$/); // OC format: EUR_USD
+      // Instrument IDs are now enum values like 'EURAUD', not 'EUR_AUD'
+      expect(typeof firstInstrument.id).toBe('string');
+      expect(firstInstrument.id.length).toBeGreaterThan(0);
     });
 
     it('should return OAP instrument config for OAP division', () => {
@@ -28,11 +30,13 @@ describe('instrumentUtils', () => {
       expect(Array.isArray(result)).toBe(true);
       expect(result.length).toBeGreaterThan(0);
 
-      // Check that the first instrument has the expected OAP format
+      // Check that the first instrument has the expected structure
       const firstInstrument = result[0];
       expect(firstInstrument).toHaveProperty('id');
       expect(firstInstrument).toHaveProperty('label');
-      expect(firstInstrument.id).toMatch(/^[A-Z]{6}$/); // OAP format: EURUSD
+      // Instrument IDs are now enum values like 'EURAUD', not 'EURUSD'
+      expect(typeof firstInstrument.id).toBe('string');
+      expect(firstInstrument.id.length).toBeGreaterThan(0);
     });
 
     it('should return different configs for different divisions', () => {
@@ -41,12 +45,14 @@ describe('instrumentUtils', () => {
 
       expect(ocConfig).not.toEqual(oapConfig);
 
-      // Check that the instrument IDs have different formats
+      // Both configs should have valid instrument IDs
       const ocFirstId = ocConfig[0].id;
       const oapFirstId = oapConfig[0].id;
 
-      expect(ocFirstId).toMatch(/^[A-Z]{3}_[A-Z]{3}$/);
-      expect(oapFirstId).toMatch(/^[A-Z]{6}$/);
+      expect(typeof ocFirstId).toBe('string');
+      expect(typeof oapFirstId).toBe('string');
+      // OAP config includes XAU_USD and XAG_USD which OC doesn't have
+      expect(oapConfig.length).toBeGreaterThan(ocConfig.length);
     });
   });
 });

package/test/utils/processBuckets.test.ts

@@ -0,0 +1,153 @@
+import { processBuckets } from '../../src/CrowdViewWidget/components';
+import type { GetOrderPositionBooksQuery } from '../../src/gql/types/graphql';
+
+describe('processBuckets', () => {
+  const DEFAULT_BUCKET_WIDTH = 0.0005;
+  const OPTIMIZED_BUCKET_WIDTH = 0.002; // DEFAULT_BUCKET_WIDTH * 4
+
+  const createMockOrderPositionBook = (
+    time: string,
+    buckets: Array<{ price: number; sentiment: number | null } | null>,
+    bucketWidth: number = DEFAULT_BUCKET_WIDTH
+  ) => ({
+    bucketWidth,
+    price: 1.0,
+    time,
+    buckets,
+  });
+
+  it('should return empty array when orderPositionData is undefined', () => {
+    expect(processBuckets(undefined, DEFAULT_BUCKET_WIDTH)).toEqual([]);
+  });
+
+  it('should return empty array when orderPositionBooks is empty', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [],
+    };
+    expect(processBuckets(mockData, DEFAULT_BUCKET_WIDTH)).toEqual([]);
+  });
+
+  it('should filter out null books', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [null, createMockOrderPositionBook('2025-01-01', [])],
+    };
+    expect(processBuckets(mockData, DEFAULT_BUCKET_WIDTH)).toEqual([]);
+  });
+
+  it('should filter out books with no buckets', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        createMockOrderPositionBook('2025-01-01', []),
+        createMockOrderPositionBook('2025-01-02', [
+          { price: 1.0, sentiment: 0.2 },
+        ]),
+      ],
+    };
+    const result = processBuckets(mockData, DEFAULT_BUCKET_WIDTH);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual([{ price: 1.0, sentiment: 0.2 }]);
+  });
+
+  it('should filter out null buckets and buckets with missing price or sentiment', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        createMockOrderPositionBook('2025-01-01', [
+          null,
+          { price: 1.0, sentiment: null },
+          { price: undefined as any, sentiment: 0.2 },
+          { price: 1.1, sentiment: 0.2 },
+        ]),
+      ],
+    };
+    const result = processBuckets(mockData, DEFAULT_BUCKET_WIDTH);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual([{ price: 1.1, sentiment: 0.2 }]);
+  });
+
+  it('should filter out buckets below sentiment threshold', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        createMockOrderPositionBook('2025-01-01', [
+          { price: 1.0, sentiment: 0.1 }, // below threshold
+          { price: 1.1, sentiment: 0.15 }, // at threshold
+          { price: 1.2, sentiment: 0.2 }, // above threshold
+          { price: 1.3, sentiment: -0.1 }, // below threshold (absolute)
+          { price: 1.4, sentiment: -0.15 }, // at threshold (absolute)
+          { price: 1.5, sentiment: -0.2 }, // above threshold (absolute)
+        ]),
+      ],
+    };
+    const result = processBuckets(mockData, DEFAULT_BUCKET_WIDTH);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual([
+      { price: 1.1, sentiment: 0.15 },
+      { price: 1.2, sentiment: 0.2 },
+      { price: 1.4, sentiment: -0.15 },
+      { price: 1.5, sentiment: -0.2 },
+    ]);
+  });
+
+  it('should aggregate buckets when using optimized width', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        createMockOrderPositionBook(
+          '2025-01-01',
+          [
+            { price: 1.0, sentiment: 0.2 },
+            { price: 1.0003, sentiment: 0.3 },
+            { price: 1.0007, sentiment: 0.1 },
+            { price: 1.0012, sentiment: 0.25 },
+          ],
+          DEFAULT_BUCKET_WIDTH
+        ),
+      ],
+    };
+    const result = processBuckets(mockData, OPTIMIZED_BUCKET_WIDTH);
+    expect(result).toHaveLength(1);
+    // Buckets should be aggregated: 1.0 + 1.0003 + 1.0007 = 1.0 bucket (0.6 sentiment)
+    // 1.0012 = 1.001 bucket (0.25 sentiment)
+    expect(result[0].length).toBeGreaterThan(0);
+    const aggregatedSentiments = result[0].reduce(
+      (acc, bucket) => acc + bucket.sentiment,
+      0
+    );
+    expect(aggregatedSentiments).toBeCloseTo(0.85, 2);
+  });
+
+  it('should not aggregate buckets when using default width', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        createMockOrderPositionBook('2025-01-01', [
+          { price: 1.0, sentiment: 0.2 },
+          { price: 1.0003, sentiment: 0.3 },
+          { price: 1.0012, sentiment: 0.25 },
+        ]),
+      ],
+    };
+    const result = processBuckets(mockData, DEFAULT_BUCKET_WIDTH);
+    expect(result).toHaveLength(1);
+    // Should have same number of buckets as input (assuming all pass threshold)
+    expect(result[0].length).toBeGreaterThanOrEqual(3);
+  });
+
+  it('should process multiple books correctly', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        createMockOrderPositionBook('2025-01-01', [
+          { price: 1.0, sentiment: 0.2 },
+        ]),
+        createMockOrderPositionBook('2025-01-02', [
+          { price: 1.1, sentiment: 0.3 },
+          { price: 1.2, sentiment: 0.4 },
+        ]),
+      ],
+    };
+    const result = processBuckets(mockData, DEFAULT_BUCKET_WIDTH);
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual([{ price: 1.0, sentiment: 0.2 }]);
+    expect(result[1]).toEqual([
+      { price: 1.1, sentiment: 0.3 },
+      { price: 1.2, sentiment: 0.4 },
+    ]);
+  });
+});

package/test/utils/processOrderPositionBooks.test.ts

@@ -0,0 +1,127 @@
+import { processOrderPositionBooks } from '../../src/CrowdViewWidget/components';
+import type { GetOrderPositionBooksQuery } from '../../src/gql/types/graphql';
+
+describe('processOrderPositionBooks', () => {
+  const createMockOrderPositionBook = (time: string) => ({
+    bucketWidth: 0.0005,
+    price: 1.0,
+    time,
+    buckets: [{ price: 1.0, sentiment: 0.2 }],
+  });
+
+  it('should return empty array when orderPositionData is undefined', () => {
+    const candleMap = new Map();
+    expect(processOrderPositionBooks(undefined, candleMap)).toEqual([]);
+  });
+
+  it('should return empty array when orderPositionBooks is empty', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [],
+    };
+    const candleMap = new Map();
+    expect(processOrderPositionBooks(mockData, candleMap)).toEqual([]);
+  });
+
+  it('should filter out null books', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [null, createMockOrderPositionBook('2025-01-01')],
+    };
+    const candleMap = new Map();
+    const result = processOrderPositionBooks(mockData, candleMap);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual(['2025-01-01', null, 0]);
+  });
+
+  it('should filter out books with no buckets', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        {
+          bucketWidth: 0.0005,
+          price: 1.0,
+          time: '2025-01-01',
+          buckets: [],
+        },
+        createMockOrderPositionBook('2025-01-02'),
+      ],
+    };
+    const candleMap = new Map();
+    const result = processOrderPositionBooks(mockData, candleMap);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual(['2025-01-02', null, 0]);
+  });
+
+  it('should use candle high price when available in map', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        createMockOrderPositionBook('2025-01-01'),
+        createMockOrderPositionBook('2025-01-02'),
+      ],
+    };
+    const candleMap = new Map([
+      ['2025-01-01', { high: 1.1234 }],
+      ['2025-01-02', { high: 1.5678 }],
+    ]);
+    const result = processOrderPositionBooks(mockData, candleMap);
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual(['2025-01-01', 1.1234, 0]);
+    expect(result[1]).toEqual(['2025-01-02', 1.5678, 1]);
+  });
+
+  it('should use null when candle is not in map', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [createMockOrderPositionBook('2025-01-01')],
+    };
+    const candleMap = new Map();
+    const result = processOrderPositionBooks(mockData, candleMap);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual(['2025-01-01', null, 0]);
+  });
+
+  it('should use null when candle high is undefined', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [createMockOrderPositionBook('2025-01-01')],
+    };
+    const candleMap = new Map([
+      ['2025-01-01', { low: 1.0 }], // no high property
+    ]);
+    const result = processOrderPositionBooks(mockData, candleMap);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual(['2025-01-01', null, 0]);
+  });
+
+  it('should correctly assign index to each book', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        createMockOrderPositionBook('2025-01-01'),
+        createMockOrderPositionBook('2025-01-02'),
+        createMockOrderPositionBook('2025-01-03'),
+      ],
+    };
+    const candleMap = new Map();
+    const result = processOrderPositionBooks(mockData, candleMap);
+    expect(result).toHaveLength(3);
+    expect(result[0][2]).toBe(0);
+    expect(result[1][2]).toBe(1);
+    expect(result[2][2]).toBe(2);
+  });
+
+  it('should handle mixed cases with and without candles', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        createMockOrderPositionBook('2025-01-01'),
+        createMockOrderPositionBook('2025-01-02'),
+        createMockOrderPositionBook('2025-01-03'),
+      ],
+    };
+    const candleMap = new Map([
+      ['2025-01-01', { high: 1.1111 }],
+      // 2025-01-02 missing from map
+      ['2025-01-03', { high: 1.3333 }],
+    ]);
+    const result = processOrderPositionBooks(mockData, candleMap);
+    expect(result).toHaveLength(3);
+    expect(result[0]).toEqual(['2025-01-01', 1.1111, 0]);
+    expect(result[1]).toEqual(['2025-01-02', null, 1]);
+    expect(result[2]).toEqual(['2025-01-03', 1.3333, 2]);
+  });
+});

package/test/utils/processPriceCandles.test.ts

@@ -0,0 +1,245 @@
+import { processPriceCandles } from '../../src/CrowdViewWidget/components';
+import type { GetPriceCandlesQuery } from '../../src/gql/types/graphql';
+
+describe('processPriceCandles', () => {
+  it('should return default values when priceCandlesData is undefined', () => {
+    const result = processPriceCandles(undefined);
+    expect(result).toEqual({
+      minPrice: 0,
+      maxPrice: 0,
+      hasValidCandles: false,
+      candleMap: new Map(),
+      candles: [],
+    });
+  });
+
+  it('should return default values when priceCandles is undefined', () => {
+    const mockData: GetPriceCandlesQuery = {
+      priceCandles: {} as any,
+    };
+    const result = processPriceCandles(mockData);
+    expect(result).toEqual({
+      minPrice: 0,
+      maxPrice: 0,
+      hasValidCandles: false,
+      candleMap: new Map(),
+      candles: [],
+    });
+  });
+
+  it('should return default values when candle array is empty', () => {
+    const mockData: GetPriceCandlesQuery = {
+      priceCandles: {
+        candle: [],
+      },
+    };
+    const result = processPriceCandles(mockData);
+    expect(result).toEqual({
+      minPrice: 0,
+      maxPrice: 0,
+      hasValidCandles: false,
+      candleMap: new Map(),
+      candles: [],
+    });
+  });
+
+  it('should process valid candles and calculate min/max prices', () => {
+    const mockData: GetPriceCandlesQuery = {
+      priceCandles: {
+        candle: [
+          {
+            point: '2025-01-01T00:00:00Z',
+            high: 1.5,
+            low: 1.0,
+            open: 1.2,
+            close: 1.3,
+          },
+          {
+            point: '2025-01-01T01:00:00Z',
+            high: 1.8,
+            low: 1.1,
+            open: 1.4,
+            close: 1.6,
+          },
+          {
+            point: '2025-01-01T02:00:00Z',
+            high: 1.3,
+            low: 0.9,
+            open: 1.1,
+            close: 1.2,
+          },
+        ],
+      },
+    };
+    const result = processPriceCandles(mockData);
+    expect(result.hasValidCandles).toBe(true);
+    expect(result.minPrice).toBe(0.9);
+    expect(result.maxPrice).toBe(1.8);
+    expect(result.candles).toHaveLength(3);
+    expect(result.candleMap.size).toBe(3);
+  });
+
+  it('should filter out null candles', () => {
+    const mockData: GetPriceCandlesQuery = {
+      priceCandles: {
+        candle: [
+          null,
+          {
+            point: '2025-01-01T00:00:00Z',
+            high: 1.5,
+            low: 1.0,
+            open: 1.2,
+            close: 1.3,
+          },
+          null,
+          {
+            point: '2025-01-01T01:00:00Z',
+            high: 1.8,
+            low: 1.1,
+            open: 1.4,
+            close: 1.6,
+          },
+        ],
+      },
+    };
+    const result = processPriceCandles(mockData);
+    expect(result.hasValidCandles).toBe(true);
+    expect(result.minPrice).toBe(1.0);
+    expect(result.maxPrice).toBe(1.8);
+    expect(result.candles).toHaveLength(4); // nulls are still in the array
+    expect(result.candleMap.size).toBe(2); // but not in the map
+  });
+
+  it('should populate candleMap with point as key', () => {
+    const mockData: GetPriceCandlesQuery = {
+      priceCandles: {
+        candle: [
+          {
+            point: '2025-01-01T00:00:00Z',
+            high: 1.5,
+            low: 1.0,
+            open: 1.2,
+            close: 1.3,
+          },
+          {
+            point: '2025-01-01T01:00:00Z',
+            high: 1.8,
+            low: 1.1,
+            open: 1.4,
+            close: 1.6,
+          },
+        ],
+      },
+    };
+    const result = processPriceCandles(mockData);
+    expect(result.candleMap.has('2025-01-01T00:00:00Z')).toBe(true);
+    expect(result.candleMap.has('2025-01-01T01:00:00Z')).toBe(true);
+    expect(result.candleMap.get('2025-01-01T00:00:00Z')).toEqual({
+      point: '2025-01-01T00:00:00Z',
+      high: 1.5,
+      low: 1.0,
+      open: 1.2,
+      close: 1.3,
+    });
+  });
+
+  it('should not add candles without point to candleMap', () => {
+    const mockData: GetPriceCandlesQuery = {
+      priceCandles: {
+        candle: [
+          {
+            point: '2025-01-01T00:00:00Z',
+            high: 1.5,
+            low: 1.0,
+            open: 1.2,
+            close: 1.3,
+          },
+          {
+            point: undefined as any,
+            high: 1.8,
+            low: 1.1,
+            open: 1.4,
+            close: 1.6,
+          },
+        ],
+      },
+    };
+    const result = processPriceCandles(mockData);
+    expect(result.candleMap.size).toBe(1);
+    expect(result.candleMap.has('2025-01-01T00:00:00Z')).toBe(true);
+  });
+
+  it('should handle candles with extreme price values', () => {
+    const mockData: GetPriceCandlesQuery = {
+      priceCandles: {
+        candle: [
+          {
+            point: '2025-01-01T00:00:00Z',
+            high: 1000.0,
+            low: 0.001,
+            open: 500.0,
+            close: 750.0,
+          },
+        ],
+      },
+    };
+    const result = processPriceCandles(mockData);
+    expect(result.minPrice).toBe(0.001);
+    expect(result.maxPrice).toBe(1000.0);
+  });
+
+  it('should handle single candle correctly', () => {
+    const mockData: GetPriceCandlesQuery = {
+      priceCandles: {
+        candle: [
+          {
+            point: '2025-01-01T00:00:00Z',
+            high: 1.5,
+            low: 1.0,
+            open: 1.2,
+            close: 1.3,
+          },
+        ],
+      },
+    };
+    const result = processPriceCandles(mockData);
+    expect(result.hasValidCandles).toBe(true);
+    expect(result.minPrice).toBe(1.0);
+    expect(result.maxPrice).toBe(1.5);
+    expect(result.candles).toHaveLength(1);
+    expect(result.candleMap.size).toBe(1);
+  });
+
+  it('should update min/max when processing candles in sequence', () => {
+    const mockData: GetPriceCandlesQuery = {
+      priceCandles: {
+        candle: [
+          {
+            point: '2025-01-01T00:00:00Z',
+            high: 2.0,
+            low: 1.5,
+            open: 1.7,
+            close: 1.8,
+          },
+          {
+            point: '2025-01-01T01:00:00Z',
+            high: 3.0, // new max
+            low: 0.5, // new min
+            open: 2.0,
+            close: 2.5,
+          },
+          {
+            point: '2025-01-01T02:00:00Z',
+            high: 1.8,
+            low: 1.2,
+            open: 1.5,
+            close: 1.6,
+          },
+        ],
+      },
+    };
+    const result = processPriceCandles(mockData);
+    expect(result.minPrice).toBe(0.5);
+    expect(result.maxPrice).toBe(3.0);
+  });
+});