czech-data-box 0.1.0

package/test/ISDSBox.test.js

@@ -0,0 +1,129 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+import ISDSBox from '../src/lib/ISDSBox.js';
+import ISDSSoapClient from '../src/lib/ISDSSoapClient.js';
+import DataBox from '../src/models/DataBox.js';
+
+describe('ISDSBox', function () {
+  let sandbox;
+  let soapClientMock;
+  let isdsBox;
+
+  beforeEach(function () {
+    sandbox = sinon.createSandbox();
+    soapClientMock = sandbox.stub(ISDSSoapClient.prototype, 'request');
+    isdsBox = new ISDSBox(0, 'loginname', 'password', '', '', '');
+  });
+
+  afterEach(function () {
+    sandbox.restore();
+  });
+
+  it('should create a message', async function () {
+    const dataMessageFiles = [
+      {
+        dmFilePath: './test/communication_test.pdf',
+        dmMimeType: 'application/pdf',
+        dmFileMetaType: 'main',
+        dmFileDescr: 'file1.pdf',
+      },
+    ];
+
+    const params = {
+      dmSenderOrgUnit: null,
+      dmSenderOrgUnitNum: null,
+      dbIDRecipient: 'fdjklz2',
+      dmRecipientOrgUnit: null,
+      dmRecipientOrgUnitNum: null,
+      dmToHands: 'MK',
+      dmAnnotation: 'MK Communication test (ignore)',
+      dmRecipientRefNumber: null,
+      dmSenderRefNumber: null,
+      dmRecipientIdent: '',
+      dmSenderIdent: '',
+      dmLegalTitleLaw: '',
+      dmLegalTitleYear: '',
+      dmLegalTitleSect: 'f',
+      dmLegalTitlePar: '',
+      dmLegalTitlePoint: '',
+      dmPersonalDelivery: true,
+      dmAllowSubstDelivery: true,
+      dmOVM: false,
+      dmPublishOwnID: false,
+    };
+
+    soapClientMock.withArgs('CreateMessage', sinon.match.any).resolves({
+      dmID: 'messageID',
+      dmStatus: { dmStatusCode: '0000', dmStatusMessage: 'OK' },
+    });
+
+    const result = await isdsBox.createMessage(params, dataMessageFiles);
+    expect(result).to.have.property('dmID', 'messageID');
+  });
+
+  it('should find a data box based on the provided input', async function () {
+    const dataBox = new DataBox();
+    dataBox.setDbId('e26gfgu');
+    dataBox.setDbType('FO');
+    // Add other search criteria as needed
+
+    const mockResponse = {
+      // Mock response that matches the expected structure from the SOAP service
+      dbStatus: { dbStatusCode: '0000', dbStatusMessage: 'OK' },
+      dbResults: [{ dbID: 'e26gfgu', dbType: 'FO' }],
+    };
+
+    soapClientMock
+      .withArgs('FindDataBox', sinon.match.any)
+      .resolves(mockResponse);
+
+    const result = await isdsBox.findDataBox(dataBox);
+    expect(result).to.deep.equal(mockResponse);
+  });
+
+  it('should throw an error if the SOAP request fails', async function () {
+    const dataBox = new DataBox();
+    dataBox.setDbId('e26gfgu');
+    dataBox.setDbType('FO');
+    // Add other search criteria as needed
+
+    const mockError = new Error('SOAP request failed');
+    soapClientMock.withArgs('FindDataBox', sinon.match.any).rejects(mockError);
+
+    try {
+      await isdsBox.findDataBox(dataBox);
+      throw new Error('Expected findDataBox to throw an error');
+    } catch (error) {
+      expect(error.message).to.equal('Error: SOAP request failed');
+    }
+  });
+
+  it('should get owner info from login', async function () {
+    const mockResponse = {
+      dbStatus: { dbStatusCode: '0000', dbStatusMessage: 'OK' },
+      ownerInfo: { ownerId: 'owner123', ownerName: 'Owner Name' },
+    };
+
+    soapClientMock
+      .withArgs('GetOwnerInfoFromLogin', { dbDummy: '' })
+      .resolves(mockResponse);
+
+    const result = await isdsBox.getOwnerInfoFromLogin();
+    expect(result).to.deep.equal(mockResponse);
+  });
+
+  it('should throw an error if the SOAP request fails', async function () {
+    const mockError = new Error('SOAP request failed');
+    soapClientMock
+      .withArgs('GetOwnerInfoFromLogin', { dbDummy: '' })
+      .rejects(mockError);
+
+    try {
+      await isdsBox.getOwnerInfoFromLogin();
+      throw new Error('Expected getOwnerInfoFromLogin to throw an error');
+    } catch (error) {
+      expect(error.message).to.equal('Error: SOAP request failed');
+    }
+  });
+  // Add more test cases for other methods
+});

package/test/ISDSSentOutFiles.test.js

@@ -0,0 +1,124 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+import fs from 'fs';
+import ISDSSentOutFiles from '../src/lib/ISDSSentOutFiles.js';
+import DataMessageFile from '../src/models/DataMessageFile.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+describe('ISDSSentOutFiles', function () {
+  let sentOutFiles;
+  let readFileStub;
+  let existsSyncStub;
+
+  beforeEach(function () {
+    sentOutFiles = new ISDSSentOutFiles();
+    readFileStub = sinon.stub(fs.promises, 'readFile');
+    existsSyncStub = sinon.stub(fs, 'existsSync');
+  });
+
+  afterEach(function () {
+    sinon.restore();
+  });
+
+  it('should add file from memory', function () {
+    const fileContent = Buffer.from('file content').toString('base64');
+    sentOutFiles.addFileFromMemory(
+      fileContent,
+      'application/pdf',
+      'main',
+      'description',
+    );
+
+    const builtFiles = sentOutFiles.build();
+    expect(builtFiles.dmFile).to.have.lengthOf(1);
+    expect(builtFiles.dmFile[0]).to.deep.include({
+      attributes: {
+        dmMimeType: 'application/pdf',
+        dmFileMetaType: 'main',
+        dmFileDescr: 'description',
+        dmFileGuid: '',
+        dmUpFileGuid: '',
+        dmFormat: '',
+      },
+      dmEncodedContent: fileContent,
+    });
+  });
+
+  it('should add file from file system', async function () {
+    const testFilePath = path.join(__dirname, 'testfile.txt');
+    const fileContent = Buffer.from('file content').toString('base64');
+
+    existsSyncStub.withArgs(testFilePath).returns(true);
+    readFileStub
+      .withArgs(testFilePath, { encoding: 'base64' })
+      .resolves(fileContent);
+
+    const result = await sentOutFiles.addFileFromFilePath(
+      testFilePath,
+      'application/pdf',
+      'main',
+      'description',
+    );
+
+    expect(result).to.be.true;
+    const builtFiles = sentOutFiles.build();
+    expect(builtFiles.dmFile).to.have.lengthOf(1);
+    expect(builtFiles.dmFile[0]).to.deep.include({
+      attributes: {
+        dmMimeType: 'application/pdf',
+        dmFileMetaType: 'main',
+        dmFileDescr: 'description',
+        dmFileGuid: '',
+        dmUpFileGuid: '',
+        dmFormat: '',
+      },
+      dmEncodedContent: fileContent,
+    });
+  });
+
+  it('should handle file not found error', async function () {
+    const testFilePath = path.join(__dirname, 'nonexistentfile.txt');
+
+    existsSyncStub.withArgs(testFilePath).returns(false);
+
+    const result = await sentOutFiles.addFileFromFilePath(
+      testFilePath,
+      'application/pdf',
+      'main',
+      'description',
+    );
+
+    expect(result).to.be.false;
+    const builtFiles = sentOutFiles.build();
+    expect(builtFiles.dmFile).to.be.empty;
+  });
+
+  it('should build files correctly', function () {
+    const file = new DataMessageFile();
+    file.setDmEncodedContent('encodedContent');
+    file.setDmMimeType('application/pdf');
+    file.setDmFileMetaType('main');
+    file.setDmFileDescr('description');
+
+    sentOutFiles.dataMessageFiles.addFile(file);
+
+    const builtFiles = sentOutFiles.build();
+    expect(builtFiles.dmFile).to.have.lengthOf(1);
+    expect(builtFiles.dmFile[0]).to.deep.include({
+      attributes: {
+        dmMimeType: 'application/pdf',
+        dmFileMetaType: 'main',
+        dmFileDescr: 'description',
+        dmFileGuid: '',
+        dmUpFileGuid: '',
+        dmFormat: '',
+      },
+      dmEncodedContent: 'encodedContent',
+    });
+  });
+});

package/test/ISDSSoapClient.test.js

@@ -0,0 +1,81 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import ISDSSoapClient from "../src/lib/ISDSSoapClient.js";
+import soap from "soap";
+
+describe("ISDSSoapClient", function () {
+  let soapClient;
+  let createClientAsyncStub;
+  let soapClientInstance;
+
+  beforeEach(function () {
+    createClientAsyncStub = sinon.stub(soap, "createClientAsync");
+    soapClientInstance = {
+      CreateMessageAsync: sinon.stub().resolves([
+        {
+          dmID: "messageID",
+          dmStatus: { dmStatusCode: "0000", dmStatusMessage: "OK" },
+        },
+      ]),
+      on: sinon.stub(),
+      addHttpHeader: sinon.stub(),
+      setEndpoint: sinon.stub(),
+    };
+    createClientAsyncStub.resolves(soapClientInstance);
+
+    soapClient = new ISDSSoapClient(
+      "wsdl_url",
+      { login: "test", password: "test", location: "test_location" },
+      false // Set debug to false for tests
+    );
+  });
+
+  afterEach(function () {
+    sinon.restore();
+  });
+
+  it("should initialize and make a request", async function () {
+    await soapClient.init();
+    const result = await soapClient.request("CreateMessage", {});
+
+    expect(result).to.deep.equal([
+      {
+        dmID: "messageID",
+        dmStatus: { dmStatusCode: "0000", dmStatusMessage: "OK" },
+      },
+    ]);
+    expect(createClientAsyncStub.calledOnce).to.be.true;
+    expect(soapClientInstance.CreateMessageAsync.calledOnceWith({})).to.be.true;
+  });
+
+  it("should not reinitialize the client if already initialized", async function () {
+    await soapClient.init();
+    await soapClient.request("CreateMessage", {});
+
+    expect(createClientAsyncStub.calledOnce).to.be.true;
+    expect(soapClientInstance.CreateMessageAsync.calledOnceWith({})).to.be.true;
+
+    await soapClient.request("CreateMessage", {});
+    expect(createClientAsyncStub.calledOnce).to.be.true; // Should still be called only once
+    expect(soapClientInstance.CreateMessageAsync.calledTwice).to.be.true;
+  });
+
+  it("should throw an error if SOAP client initialization fails", async function () {
+    createClientAsyncStub.rejects(
+      new Error("SOAP client initialization failed")
+    );
+
+    try {
+      await soapClient.init();
+    } catch (error) {
+      expect(error).to.be.an.instanceOf(Error);
+      expect(error.message).to.equal("SOAP client initialization failed");
+      return;
+    }
+
+    // If the code reaches here, the test should fail
+    expect.fail("Expected an error but none was thrown");
+  });
+
+  // Add more test cases as needed
+});