test: add tests for bindings.js#getQueryParams

packages/helpers/src/bindings.js

@@ -18,14 +18,14 @@ function getQueryParams(channels) {
 
   const queryMap = new Map();
 
-  const hasWsBinding = channel?.bindings?.().has('ws');
+  const bindings = channel?.bindings?.();
+  const hasWsBinding = bindings?.has('ws');
 
   if (!hasWsBinding) {
     return null;
   }
 
-  const wsBinding = channel.bindings().get('ws');
-
+  const wsBinding = bindings.get('ws');
   const query = wsBinding.value()?.query;
   //we do not throw error, as user do not have to use query params, we just exit with null as it doesn't make sense to continue with query building
   if (!query) {

packages/helpers/test/__fixtures__/asyncapi-websocket-query.yml

@@ -74,6 +74,19 @@ channels:
             payload: false
           - name: number
             payload: 123
+  wsBindingNoQuery:
+    address: '/no-query'
+    bindings:
+      ws:
+        bindingVersion: 0.1.0
+  wsBindingEmptyQuery:
+    address: '/empty-query'
+    bindings:
+      ws:
+        bindingVersion: 0.1.0
+        query:
+          type: object
+
   emptyChannel: {}
 
   marketDataV1NoBinding:

packages/helpers/test/bindings.test.js

@@ -0,0 +1,89 @@
+const path = require('path');
+const { Parser, fromFile } = require('@asyncapi/parser');
+const { getQueryParams } = require('../src/bindings');
+
+const parser = new Parser();
+const asyncapi_v3_path = path.resolve(__dirname, './__fixtures__/asyncapi-websocket-query.yml');
+
+function createChannelsWithOnly(keysToKeep, originalChannels) {
+  const channelsMap = new Map(originalChannels.all());  
+  for (const key of channelsMap.keys()) {
+    if (!keysToKeep.includes(key)) {
+      channelsMap.delete(key);
+    }
+  }
+  return {
+    isEmpty: () => channelsMap.size === 0,
+    all: () => channelsMap
+  };
+}
+
+describe('getQueryParams integration test with AsyncAPI', () => {
+  let parsedAsyncAPIDocument;
+
+  beforeAll(async () => {
+    const parseResult = await fromFile(parser, asyncapi_v3_path).parse();
+    parsedAsyncAPIDocument = parseResult.document;
+  });
+
+  it('should extract query parameters from WebSocket binding with properties', () => {
+    const channels = parsedAsyncAPIDocument.channels();
+    const params = getQueryParams(channels);
+
+    expect(params).not.toBeNull();
+    expect(params.get('heartbeat')).toBe('false');
+    expect(params.get('top_of_book')).toBe('false');
+    expect(params.get('bids')).toBe('true');
+    expect(params.get('offers')).toBe('');
+  });
+
+  it('should return null for channel without WebSocket binding', () => {
+    const channels = parsedAsyncAPIDocument.channels();
+    const filteredChannels = createChannelsWithOnly(['marketDataV1NoBinding'], channels);
+    const params = getQueryParams(filteredChannels);
+    expect(params).toBeNull();
+  });
+
+  it('should return null for empty channels map', () => {
+    const emptyChannels = {
+      isEmpty: () => true,
+      all: () => new Map()
+    };
+    const params = getQueryParams(emptyChannels);
+    expect(params).toBeNull();
+  });
+
+  it('should return null for channel with empty binding', () => {
+    const channels = parsedAsyncAPIDocument.channels();
+    const filteredChannels = createChannelsWithOnly(['emptyChannel'], channels);
+    const params = getQueryParams(filteredChannels);
+    expect(params).toBeNull();
+  });
+
+  it('should return null if WebSocket binding exists but has no query parameters', () => {
+    const channels = parsedAsyncAPIDocument.channels();
+    const filteredChannels = createChannelsWithOnly(['wsBindingNoQuery'], channels);
+    const params = getQueryParams(filteredChannels);
+    expect(params).toBeNull();
+  });
+
+  it('should return null if WebSocket binding query exists but has no properties', () => {
+    const channels = parsedAsyncAPIDocument.channels();
+    const filteredChannels = createChannelsWithOnly(['wsBindingEmptyQuery'], channels);
+    const params = getQueryParams(filteredChannels);
+    expect(params).toBeNull();
+  });
+
+  it('should return null if channel bindings is undefined', () => {
+    const channelsMap = new Map();
+    channelsMap.set('test', { bindings: () => undefined });
+
+    const testChannels = {
+      isEmpty: () => channelsMap.size === 0,
+      all: () => channelsMap
+    };
+
+    const params = getQueryParams(testChannels);
+    expect(params).toBeNull();
+  });
+});