Merge branch 'master' into test/add-tests-python-RegisterReceiveOperations-component

Author: Adi-204

packages/components/test/components/CoreMethods.test.js

@@ -0,0 +1,20 @@
+import { render } from '@asyncapi/generator-react-sdk';
+import { CoreMethods } from '../../src/components/readme/CoreMethods';
+
+describe('CoreMethods component', () => {
+  test('renders core methods for javascript', () => {
+    const result = render(<CoreMethods language="javascript" />);
+    expect(result.trim()).toMatchSnapshot();
+  });
+
+  test('renders core methods for python', () => {
+    const result = render(<CoreMethods language="python" />);
+    expect(result.trim()).toMatchSnapshot();
+  });
+
+  test('throws error for unsupported or missing language', () => {
+    expect(() => {
+      render(<CoreMethods />);
+    }).toThrow('Unsupported language');
+  });
+});

packages/components/test/components/Installation.test.js

@@ -0,0 +1,24 @@
+import { render } from '@asyncapi/generator-react-sdk';
+import { Installation } from '../../src/components/readme/Installation';
+
+describe('Installation component', () => {
+  test('renders javascript installation command', () => {
+    const result = render(<Installation language="javascript" />);
+    expect(result.trim()).toMatchSnapshot();
+  });
+
+  test('renders python installation command', () => {
+    const result = render(<Installation language="python" />);
+    expect(result.trim()).toMatchSnapshot();
+  });
+
+  test('renders installation section when language is undefined', () => {
+    const result = render(<Installation />);
+    const output = result.trim();
+
+    // Explicitly document current behavior
+    expect(output).toContain('## Installation');
+    expect(output).toContain('Install dependencies');
+    expect(output).toContain('undefined');
+  });
+});

packages/components/test/components/__snapshots__/CoreMethods.test.js.snap

@@ -0,0 +1,33 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`CoreMethods component renders core methods for javascript 1`] = `
+"## API
+
+### \`connect()\`
+Establishes a WebSocket connection.
+
+### \`registerMessageHandler(handlerFunction)\`
+Registers a callback for incoming messages.
+
+### \`registerErrorHandler(handlerFunction)\`
+Registers a callback for connection errors.
+
+### \`close()\`
+Closes the WebSocket connection."
+`;
+
+exports[`CoreMethods component renders core methods for python 1`] = `
+"## API
+
+### \`connect()\`
+Establishes a WebSocket connection.
+
+### \`register_message_handler(handler_function)\`
+Registers a callback for incoming messages.
+
+### \`register_error_handler(handler_function)\`
+Registers a callback for connection errors.
+
+### \`close()\`
+Closes the WebSocket connection."
+`;

packages/components/test/components/__snapshots__/Installation.test.js.snap

@@ -0,0 +1,21 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Installation component renders javascript installation command 1`] = `
+"## Installation
+
+Install dependencies:
+
+\`\`\`bash
+npm install
+\`\`\`"
+`;
+
+exports[`Installation component renders python installation command 1`] = `
+"## Installation
+
+Install dependencies:
+
+\`\`\`bash
+pip install -r requirements.txt
+\`\`\`"
+`;

packages/helpers/src/ModelsPresets.js

@@ -11,7 +11,7 @@ const websocketJavaPreset = {
       // Solution to handle imports dynamically
       const requiredImports = new Set();
       requiredImports.add('import java.util.Objects;');
-      Object.values(model.properties).forEach(property => {
+      Object.values(model.properties || {}).forEach(property => {
         const type = property.property.type;
 
         if (type === 'Map<String, Object>') {

packages/helpers/test/ModelsPresets.test.js

@@ -0,0 +1,141 @@
+const { JavaModelsPresets } = require('../src/ModelsPresets');
+const { JAVA_COMMON_PRESET } = require('@asyncapi/modelina');
+
+const PACKAGE_DECLARATION = 'package com.asyncapi.models;';
+const IMPORT_OBJECTS = 'import java.util.Objects;';
+const IMPORT_MAP = 'import java.util.Map;';
+const TEST_CLASS_CONTENT = 'public class TestClass {}';
+const MAP_STRING_OBJECT_TYPE = 'Map<String, Object>';
+const PACKAGE_WITH_NEWLINES = 'package com.asyncapi.models;\n\n';
+
+describe('ModelsPresets', () => {
+  describe('JavaModelsPresets structure', () => {
+    it('should export JavaModelsPresets as an array', () => {
+      expect(Array.isArray(JavaModelsPresets)).toBe(true);
+      expect(JavaModelsPresets).toHaveLength(2);
+    });
+
+    it('should contain JAVA_COMMON_PRESET with correct options', () => {
+      const commonPreset = JavaModelsPresets[0];
+      expect(commonPreset.preset).toBe(JAVA_COMMON_PRESET);
+      expect(commonPreset.options).toEqual({
+        equal: true,
+        hashCode: true,
+        classToString: true,
+        marshalling: false
+      });
+    });
+
+    it('should contain websocketJavaPreset as second element', () => {
+      const websocketPreset = JavaModelsPresets[1];
+      expect(websocketPreset).toBeDefined();
+      expect(websocketPreset.class).toBeDefined();
+      expect(websocketPreset.enum).toBeDefined();
+      expect(websocketPreset.union).toBeDefined();
+    });
+  });
+
+  describe('websocketJavaPreset class.self', () => {
+    const websocketPreset = JavaModelsPresets[1];
+
+    it('should add package and basic imports for class without Map properties', () => {
+      const mockModel = {
+        properties: {
+          prop1: { property: { type: 'String' } },
+          prop2: { property: { type: 'Integer' } }
+        }
+      };
+      const result = websocketPreset.class.self({ content: TEST_CLASS_CONTENT, model: mockModel });
+
+      expect(result).toContain(PACKAGE_DECLARATION);
+      expect(result).toContain(IMPORT_OBJECTS);
+      expect(result).toContain(TEST_CLASS_CONTENT);
+      expect(result).not.toContain(IMPORT_MAP);
+    });
+
+    it('should add Map import when property type is Map<String, Object>', () => {
+      const mockModel = {
+        properties: {
+          prop1: { property: { type: MAP_STRING_OBJECT_TYPE } },
+          prop2: { property: { type: 'String' } }
+        }
+      };
+      const result = websocketPreset.class.self({ content: TEST_CLASS_CONTENT, model: mockModel });
+
+      expect(result).toContain(PACKAGE_DECLARATION);
+      expect(result).toContain(IMPORT_OBJECTS);
+      expect(result).toContain(IMPORT_MAP);
+      expect(result).toContain(TEST_CLASS_CONTENT);
+    });
+
+    it('should add Map import only once for multiple Map properties', () => {
+      const mockModel = {
+        properties: {
+          prop1: { property: { type: MAP_STRING_OBJECT_TYPE } },
+          prop2: { property: { type: MAP_STRING_OBJECT_TYPE } },
+          prop3: { property: { type: MAP_STRING_OBJECT_TYPE } }
+        }
+      };
+      const result = websocketPreset.class.self({ content: TEST_CLASS_CONTENT, model: mockModel });
+
+      const mapImportCount = (result.match(/import java\.util\.Map;/g) || []).length;
+      expect(mapImportCount).toBe(1);
+    });
+
+    it('should handle model with no properties', () => {
+      const mockModel = { properties: {} };
+      const content = 'public class EmptyClass {}';
+      const result = websocketPreset.class.self({ content, model: mockModel });
+
+      expect(result).toContain(PACKAGE_DECLARATION);
+      expect(result).toContain(IMPORT_OBJECTS);
+      expect(result).toContain('public class EmptyClass {}');
+    });
+
+    it('should handle model with missing properties key', () => {
+      const mockModel = {};
+      const content = 'public class NoPropsClass {}';
+      const result = websocketPreset.class.self({ content, model: mockModel });
+
+      expect(result).toContain(PACKAGE_DECLARATION);
+      expect(result).toContain(IMPORT_OBJECTS);
+      expect(result).toContain('public class NoPropsClass {}');
+    });
+  });
+
+  describe('websocketJavaPreset enum.self', () => {
+    const websocketPreset = JavaModelsPresets[1];
+
+    it('should add package declaration to enum content', () => {
+      const content = 'public enum Status { ACTIVE, INACTIVE }';
+      const result = websocketPreset.enum.self({ content });
+
+      expect(result).toBe(`${PACKAGE_WITH_NEWLINES}public enum Status { ACTIVE, INACTIVE }`);
+    });
+
+    it('should handle empty enum content', () => {
+      const content = '';
+      const result = websocketPreset.enum.self({ content });
+
+      expect(result).toBe(PACKAGE_WITH_NEWLINES);
+    });
+  });
+
+  describe('websocketJavaPreset union.self', () => {
+    const websocketPreset = JavaModelsPresets[1];
+
+    it('should add package declaration to union content', () => {
+      const content = 'public class UnionType {}';
+      const result = websocketPreset.union.self({ content });
+
+      expect(result).toBe(`${PACKAGE_WITH_NEWLINES}public class UnionType {}`);
+    });
+
+    it('should handle empty union content', () => {
+      const content = '';
+      const result = websocketPreset.union.self({ content });
+
+      expect(result).toBe(PACKAGE_WITH_NEWLINES);
+    });
+  });
+});