@xapi-js/adaptor-nestjs 1.0.0

package/test/xapi-request-interceptor.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect, vi } from 'vitest';
+import { of, firstValueFrom } from 'rxjs';
+import { XapiRequestInterceptor } from '../src/xapi-request-interceptor';
+import { CallHandler, ExecutionContext } from '@nestjs/common';
+import { XapiRoot } from '@xapi-js/core';
+
+describe('XapiRequestInterceptor', () => {
+  let interceptor: XapiRequestInterceptor;
+
+  beforeEach(() => {
+    interceptor = new XapiRequestInterceptor();
+  });
+
+  it('should be defined', () => {
+    expect(interceptor).toBeDefined();
+  });
+
+  it('should deserialize Nexacro XAPI XML input to XapiRoot object', async () => {
+    const nexacroXmlInput = `<?xml version="1.0" encoding="UTF-8"?>
+<Root xmlns="http://www.tobesoft.com/platform/Dataset" ver="4000">
+  <Dataset id="test">
+    <ColumnInfo>
+      <Column id="intCol" size="10" type="INT" />
+      <Column id="stringCol" size="50" type="STRING" />
+    </ColumnInfo>
+    <Rows>
+      <Row>
+        <Col id="intCol">123</Col>
+        <Col id="stringCol">hello</Col>
+      </Row>
+      <Row>
+        <Col id="intCol">456</Col>
+        <Col id="stringCol">world</Col>
+      </Row>
+    </Rows>
+  </Dataset>
+</Root>`;
+
+    const mockRequest = {
+      body: nexacroXmlInput,
+      headers: { 'content-type': 'application/xml' },
+    };
+    const mockContext = {
+      switchToHttp: () => ({
+        getRequest: () => mockRequest,
+        getResponse: () => ({}),
+      }),
+    } as ExecutionContext;
+
+    const mockCallHandler = {
+      handle: () => of({}), // Mock a successful handler call
+    } as CallHandler;
+
+    const observableResult = await interceptor.intercept(mockContext, mockCallHandler);
+    await firstValueFrom(observableResult);
+    const request = mockContext.switchToHttp().getRequest();
+
+    expect(request.body).toBeInstanceOf(XapiRoot);
+    expect(request.body.datasets).toBeDefined();
+    expect(request.body.getDataset('test')).toBeDefined();
+    const dataset = request.body.getDataset('test');
+    expect(dataset.rows).toBeDefined();
+    expect(dataset.rows.length).toBe(2);
+    expect(dataset.getColumn(0, 'intCol')).toBe(123);
+    expect(dataset.getColumn(0, 'stringCol')).toBe('hello');
+    expect(dataset.getColumn(1, 'intCol')).toBe(456);
+    expect(dataset.getColumn(1, 'stringCol')).toBe('world');
+  });
+
+  it('should not deserialize non-XML input', async () => {
+    const jsonInput = `{ "data": "test" }`;
+    const mockRequest = {
+      body: jsonInput,
+      headers: { 'content-type': 'application/json' },
+    };
+    const mockContext = {
+      switchToHttp: () => ({
+        getRequest: () => mockRequest,
+        getResponse: () => ({}),
+      }),
+    } as ExecutionContext;
+
+    const mockCallHandler = {
+      handle: () => of({}),
+    } as CallHandler;
+
+    const observableResult = await interceptor.intercept(mockContext, mockCallHandler);
+    await firstValueFrom(observableResult);
+    const request = mockContext.switchToHttp().getRequest();
+    expect(request.body).toBe(jsonInput);
+    expect(request.body).not.toBeInstanceOf(XapiRoot);
+  });
+
+  it('should pass through if no body is present', async () => {
+    const mockRequest = {
+      headers: { 'content-type': 'application/xml' },
+    };
+    const mockContext = {
+      switchToHttp: () => ({
+        getRequest: () => mockRequest,
+        getResponse: () => ({}),
+      }),
+    } as ExecutionContext;
+
+    const mockCallHandler = {
+      handle: () => of({}),
+    } as CallHandler;
+
+    const observableResult = await interceptor.intercept(mockContext, mockCallHandler);
+    await firstValueFrom(observableResult);
+    const request = mockContext.switchToHttp().getRequest();
+    expect(request.body).toBeUndefined();
+  });
+});
+

package/test/xapi-response-interceptor.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect, vi } from 'vitest';
+import { of, firstValueFrom } from 'rxjs';
+import { XapiResponseInterceptor } from '../src/xapi-response-interceptor';
+import { CallHandler, ExecutionContext } from '@nestjs/common';
+import { XapiRoot, Dataset, Column, writeString } from '@xapi-js/core';
+
+// Mock the writeString function from @xapi-js/core
+vi.mock('@xapi-js/core', async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    writeString: vi.fn(actual.writeString), // Use the actual implementation for mocking
+  };
+});
+
+describe('XapiResponseInterceptor', () => {
+  let interceptor: XapiResponseInterceptor;
+
+  beforeEach(() => {
+    interceptor = new XapiResponseInterceptor();
+    // Reset the mock before each test
+    vi.mocked(writeString).mockClear(); // Use writeString directly
+  });
+
+  it('should be defined', () => {
+    expect(interceptor).toBeDefined();
+  });
+
+  it('should serialize XapiRoot output to Nexacro XAPI XML string', async () => {
+    const xapiRootOutput = new XapiRoot();
+    const dataset = new Dataset('test');
+    dataset.addColumn({ id: 'intCol', size: 10, type: 'INT' });
+    dataset.addColumn({ id: 'stringCol', size: 50, type: 'STRING' });
+
+    dataset.newRow();
+    dataset.setColumn(0, 'intCol', 123);
+    dataset.setColumn(0, 'stringCol', 'hello');
+
+    dataset.newRow();
+    dataset.setColumn(1, 'intCol', 456);
+    dataset.setColumn(1, 'stringCol', 'world');
+
+    xapiRootOutput.addDataset(dataset);
+
+    const mockContext = {
+      switchToHttp: () => ({
+        getRequest: () => ({}),
+        getResponse: () => ({}),
+      }),
+    } as ExecutionContext;
+
+    const mockCallHandler = {
+      handle: () => of(xapiRootOutput),
+    } as CallHandler;
+
+    const observableResult = interceptor.intercept(mockContext, mockCallHandler);
+    const result = await firstValueFrom(observableResult);
+    expect(typeof result).toBe('string');
+    expect(result).toContain('<Root xmlns="http://www.nexacroplatform.com/platform/dataset" version="4000">');
+    expect(result).toContain('<Dataset id="test">');
+    expect(result).toMatch(/<Column id="intCol" size="10" type="INT"\s*\/>/);
+    expect(result).toMatch(/<Column id="stringCol" size="50" type="STRING"\s*\/>/);
+    expect(result).toContain('<Rows>');
+    expect(result).toContain('<Row>');
+    expect(result).toContain('<Col id="intCol">123</Col>');
+    expect(result).toContain('<Col id="stringCol">hello</Col>');
+    expect(result).toContain('<Col id="intCol">456</Col>');
+    expect(result).toContain('<Col id="stringCol">world</Col>');
+    expect(result).toContain('</Row>');
+    expect(result).toContain('</Rows>');
+    expect(result).toContain('</Dataset>');
+    expect(result).toContain('</Root>');
+  });
+
+  it('should throw an error if handler does not return XapiRoot', async () => {
+    const nonXapiRootOutput = { message: 'hello' };
+
+    const mockContext = {
+      switchToHttp: () => ({
+        getRequest: () => ({}),
+        getResponse: () => ({}),
+      }),
+    } as ExecutionContext;
+
+    const mockCallHandler = {
+      handle: () => of(nonXapiRootOutput),
+    } as CallHandler;
+
+    const observableResult = interceptor.intercept(mockContext, mockCallHandler);
+    await expect(firstValueFrom(observableResult)).rejects.toThrow('Handler did not return an XapiRoot instance');
+  });
+
+  it('should re-throw error from writeString', async () => {
+    const xapiRootOutput = new XapiRoot();
+
+    const mockContext = {
+      switchToHttp: () => ({
+        getRequest: () => ({}),
+        getResponse: () => ({}),
+      }),
+    } as ExecutionContext;
+
+    const mockCallHandler = {
+      handle: () => of(xapiRootOutput),
+    } as CallHandler;
+
+    const testError = new Error('Test writeString error');
+    vi.mocked(writeString).mockRejectedValue(testError);
+
+    const observableResult = interceptor.intercept(mockContext, mockCallHandler);
+    await expect(firstValueFrom(observableResult)).rejects.toThrow(testError);
+  });
+});

package/vitest.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    pool: "threads",
+    exclude: [
+      "**/node_modules/**",
+      "**/coverage/**",
+      "**/dist/**",
+      '**/.{idea,git,cache,output,temp}/**',
+      '**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build}.config.*',
+    ],
+  include: ['test/**/*.test.ts'],
+  },
+})