@into-cps-association/libms 0.3.1

package/test/coverage/lcov.info

@@ -0,0 +1,52 @@
+TN:
+SF:test/testUtil.ts
+FN:51,sleep
+FN:58,(anonymous_1)
+FNF:2
+FNH:0
+FNDA:0,sleep
+FNDA:0,(anonymous_1)
+DA:1,1
+DA:2,1
+DA:4,1
+DA:7,1
+DA:9,1
+DA:11,1
+DA:27,1
+DA:28,1
+DA:29,1
+DA:30,1
+DA:37,1
+DA:51,1
+DA:52,0
+DA:53,0
+DA:56,1
+DA:59,0
+DA:61,0
+DA:63,0
+DA:65,0
+DA:67,0
+DA:69,0
+DA:70,0
+DA:72,0
+DA:73,0
+DA:75,0
+DA:78,0
+DA:83,1
+DA:102,1
+DA:142,1
+DA:160,1
+DA:178,1
+LF:31
+LH:18
+BRDA:59,0,0,0
+BRDA:59,0,1,0
+BRDA:59,0,2,0
+BRDA:59,0,3,0
+BRDA:59,0,4,0
+BRDA:59,0,5,0
+BRDA:69,1,0,0
+BRDA:72,2,0,0
+BRF:8
+BRH:0
+end_of_record

package/test/data/user2/tools/README.md

@@ -0,0 +1 @@
+content123

package/test/e2e/app.e2e.spec.ts

@@ -0,0 +1,79 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { INestApplication } from '@nestjs/common';
+import * as request from 'supertest';
+// import { execSync } from "child_process";
+import AppModule from '../../src/app.module';
+import {
+  e2eReadFile,
+  e2elistDirectory,
+  expectedFileContentResponse,
+  expectedListDirectoryResponse,
+} from '../testUtil';
+
+describe('End to End test for the application', () => {
+  let app: INestApplication;
+
+  beforeAll(async () => {
+    // execSync("test/starttraefik.bash");
+
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+    app = moduleFixture.createNestApplication();
+    await app.init(); // Initialize the application
+    await app.listen(process.env.PORT);
+
+    // eslint-disable-next-line no-promise-executor-return
+    await new Promise((resolve) => setTimeout(resolve, 4000));
+  }, 10000);
+
+  afterAll(async () => {
+    // execSync("test/stoptraefik.bash");
+    await app.close();
+  }, 10000);
+
+  it('should return the filename corresponding to the directory given in the query', async () => {
+    const query = e2elistDirectory;
+
+    const response = await request('http://localhost:4001')
+      .post(process.env.APOLLO_PATH)
+      .send({ query });
+    expect(response.body).toEqual(expectedListDirectoryResponse);
+  }, 10000);
+
+  it('should return the content of a file given in the query ', async () => {
+    const query = e2eReadFile;
+
+    const response = await request('http://localhost:4001')
+      .post(process.env.APOLLO_PATH)
+      .send({ query });
+    expect(response.body).toEqual(expectedFileContentResponse);
+  }, 10000);
+});
+
+/*
+  describe("End to End test for the application", () => {
+    it("should return the filename corresponding to the directory given in the query through the Traefik gateway", async () => {
+      const query = e2elistDirectory;
+
+      const response = await request("http://localhost")
+        .post("/lib")
+        .send({ query });
+
+      response;
+      expect(response.body).toEqual(expectedListDirectoryResponse);
+    }, 10000);
+
+    it("should return the content of a file given in the query through the Traefik gateway", async () => {
+      const query = e2eReadFile;
+
+      const response = await request("http://localhost")
+        .post("/lib")
+        .send({ query });
+
+      response;
+      expect(response.body).toEqual(expectedFileContentResponse);
+    }, 10000);
+  });
+}
+*/

package/test/integration/files.service.integration.spec.ts

@@ -0,0 +1,67 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ConfigService } from '@nestjs/config';
+import FilesResolver from '../../src/files/resolvers/files.resolver';
+import FilesServiceFactory from '../../src/files/services/files-service.factory';
+import LocalFilesService from '../../src/files/services/local-files.service';
+import GitlabFilesService from '../../src/files/services/gitlab-files.service';
+import {
+  pathToTestDirectory,
+  pathToTestFileContent,
+  testDirectory,
+  testFileContent,
+  MockConfigService,
+} from '../testUtil';
+
+describe('Integration tests for FilesResolver', () => {
+  let filesResolver: FilesResolver;
+  let mockConfigService: MockConfigService;
+
+  beforeEach(async () => {
+    mockConfigService = new MockConfigService();
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        FilesResolver,
+        FilesServiceFactory,
+        LocalFilesService,
+        GitlabFilesService,
+        { provide: ConfigService, useClass: MockConfigService },
+      ],
+    }).compile();
+
+    filesResolver = module.get<FilesResolver>(FilesResolver);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  const modes = ['local', 'gitlab'];
+
+  // eslint-disable-next-line no-restricted-syntax
+  for (const mode of modes) {
+    // eslint-disable-next-line no-loop-func
+    describe(`when MODE is ${mode}`, () => {
+      beforeEach(() => {
+        jest.spyOn(mockConfigService, 'get').mockReturnValue(mode);
+      });
+
+      it('should be defined', () => {
+        expect(filesResolver).toBeDefined();
+      });
+
+      describe('listDirectory', () => {
+        it('should list files', async () => {
+          const files = await filesResolver.listDirectory(pathToTestDirectory);
+          expect(files).toEqual(testDirectory);
+        });
+      });
+
+      describe('readFile', () => {
+        it('should read file', async () => {
+          const content = await filesResolver.readFile(pathToTestFileContent);
+          expect(content).toEqual(testFileContent);
+        });
+      });
+    });
+  }
+});

package/test/jest-e2e.json

@@ -0,0 +1,9 @@
+{
+  "moduleFileExtensions": ["js", "json", "ts"],
+  "rootDir": ".",
+  "testEnvironment": "node",
+  "testRegex": ".e2e.spec.ts$",
+  "transform": {
+    "^.+\\.(t|j)s$": "ts-jest"
+  }
+}

package/test/starttraefik.bash

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+echo "Starting the Traefik gateway"
+cd ../../servers/config/gateway || exit 1
+docker run -d \
+  --name "traefik-gateway" \
+  --network=host -v "$PWD/traefik.yml":/etc/traefik/traefik.yml \
+  -v "$PWD/dynamic":/etc/traefik/dynamic \
+  -v /var/run/docker.sock:/var/run/docker.sock \
+  --restart always \
+  traefik:v2.10

package/test/stoptraefik.bash

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+cd ../../servers/config/gateway || exit 1
+
+echo "Stopping the Traefik gateway"
+docker stop traefik-gateway
+
+echo "Removing the Traefik gateway container"
+docker rm traefik-gateway

package/test/testUtil.ts

@@ -0,0 +1,190 @@
+import * as dotenv from 'dotenv';
+import { setTimeout } from 'timers/promises';
+
+dotenv.config({ path: '.env' });
+
+// actual data for integration and e2e tests
+export const readFileActualContent = ['content123'];
+
+export const pathToTestDirectory = 'user2';
+
+export const testDirectory = {
+  repository: {
+    tree: {
+      blobs: { edges: [] },
+      trees: {
+        edges: [
+          { node: { name: 'data', type: 'tree' } },
+          { node: { name: 'digital_twins', type: 'tree' } },
+          { node: { name: 'functions', type: 'tree' } },
+          { node: { name: 'models', type: 'tree' } },
+          { node: { name: 'tools', type: 'tree' } },
+        ],
+      },
+    },
+  },
+};
+export const testFileName = 'README.md';
+export const fstestFileContent = 'content123';
+export const pathToTestFileContent = 'user2/tools/README.md';
+export const testFileArray = [
+  'data',
+  'digital_twins',
+  'functions',
+  'models',
+  'tools',
+];
+export const testFileContent = {
+  repository: {
+    blobs: {
+      nodes: [
+        {
+          name: 'README.md',
+          rawBlob: 'content123',
+          rawTextBlob: 'content123',
+        },
+      ],
+    },
+  },
+};
+
+export function sleep(ms) {
+  const timer = setTimeout(ms);
+  Promise.resolve(timer);
+}
+
+export class MockConfigService {
+  // eslint-disable-next-line class-methods-use-this
+  get(key: string): string {
+    switch (key) {
+      case 'TOKEN':
+        return process.env.TOKEN;
+      case 'LOCAL_PATH':
+        return process.env.TEST_PATH;
+      case 'GITLAB_URL':
+        return process.env.GITLAB_URL;
+      case 'GITLAB_GROUP':
+        return 'dtaas';
+      case 'MODE':
+        if (process.env.MODE === 'gitlab') {
+          return 'gitlab';
+        }
+        if (process.env.MODE === 'local') {
+          return 'local';
+        }
+        return 'unknown';
+
+      default:
+        return undefined;
+    }
+  }
+}
+
+export const mockReadFileResponseData = {
+  project: {
+    __typename: 'Project',
+    repository: {
+      __typename: 'Repository',
+      blobs: {
+        nodes: [
+          {
+            __typename: 'Blob',
+            name: 'README.md',
+            rawBlob: 'content123',
+            rawTextBlob: 'content123',
+          },
+        ],
+      },
+    },
+  },
+};
+
+export const expectedListDirectoryResponse = {
+  data: {
+    listDirectory: {
+      repository: {
+        tree: {
+          trees: {
+            edges: [
+              {
+                node: {
+                  name: 'data',
+                },
+              },
+              {
+                node: {
+                  name: 'digital_twins',
+                },
+              },
+              {
+                node: {
+                  name: 'functions',
+                },
+              },
+              {
+                node: {
+                  name: 'models',
+                },
+              },
+              {
+                node: {
+                  name: 'tools',
+                },
+              },
+            ],
+          },
+        },
+      },
+    },
+  },
+};
+
+export const expectedFileContentResponse = {
+  data: {
+    readFile: {
+      repository: {
+        blobs: {
+          nodes: [
+            {
+              name: 'README.md',
+              rawBlob: 'content123',
+              rawTextBlob: 'content123',
+            },
+          ],
+        },
+      },
+    },
+  },
+};
+
+export const e2elistDirectory = `query {
+  listDirectory(path:"user2")
+  {
+    repository{
+      tree{
+        trees{
+          edges{
+            node{
+              name
+              
+            }
+          }
+        }
+      }
+    }
+  }
+}`;
+
+export const e2eReadFile = `query {
+  readFile(path:"user2/tools/README.md") {
+    repository {
+      blobs {
+        nodes {
+          name
+          rawBlob
+          rawTextBlob
+        }
+      }
+    }
+  }
+}`;

package/test/unit/files-service.factory.unit.spec.ts

@@ -0,0 +1,46 @@
+// files-service.factory.spec.ts
+import { Test, TestingModule } from '@nestjs/testing';
+import { ConfigService } from '@nestjs/config';
+import FilesServiceFactory from '../../src/files/services/files-service.factory';
+import LocalFilesService from '../../src/files/services/local-files.service';
+import GitlabFilesService from '../../src/files/services/gitlab-files.service';
+import { IFilesService } from '../../src/files/interfaces/files.service.interface';
+
+describe('FilesServiceFactory', () => {
+  let serviceFactory: FilesServiceFactory;
+  let configService: ConfigService;
+  let localFilesService: IFilesService;
+  let gitlabFilesService: IFilesService;
+
+  beforeEach(async () => {
+    localFilesService = new LocalFilesService(configService as ConfigService);
+    gitlabFilesService = new GitlabFilesService(configService as ConfigService);
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        FilesServiceFactory,
+        { provide: ConfigService, useValue: { get: jest.fn() } },
+        { provide: LocalFilesService, useValue: localFilesService },
+        { provide: GitlabFilesService, useValue: gitlabFilesService },
+      ],
+    }).compile();
+
+    serviceFactory = module.get<FilesServiceFactory>(FilesServiceFactory);
+    configService = module.get<ConfigService>(ConfigService);
+  });
+
+  it('should create a local files service when MODE is local', () => {
+    jest.spyOn(configService, 'get').mockReturnValue('local');
+    expect(serviceFactory.create()).toBe(localFilesService);
+  });
+
+  it('should create a gitlab files service when MODE is gitlab', () => {
+    jest.spyOn(configService, 'get').mockReturnValue('gitlab');
+    expect(serviceFactory.create()).toBe(gitlabFilesService);
+  });
+
+  it('should throw an error when MODE is invalid', () => {
+    jest.spyOn(configService, 'get').mockReturnValue('invalid');
+    expect(() => serviceFactory.create()).toThrowError(`Invalid MODE: invalid`);
+  });
+});

package/test/unit/files.resolver.unit.spec.ts

@@ -0,0 +1,70 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import FilesResolver from '../../src/files/resolvers/files.resolver';
+import {
+  testDirectory,
+  pathToTestDirectory,
+  pathToTestFileContent,
+  testFileContent,
+} from '../testUtil';
+import { IFilesService } from '../../src/files/interfaces/files.service.interface';
+import FilesServiceFactory from '../../src/files/services/files-service.factory';
+
+describe('Unit tests for FilesResolver', () => {
+  let filesResolver: FilesResolver;
+  let filesService: IFilesService;
+
+  beforeEach(async () => {
+    const mockFilesService: IFilesService = {
+      listDirectory: jest.fn().mockImplementation(() => testDirectory),
+      readFile: jest.fn().mockImplementation(() => testFileContent),
+    };
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        FilesResolver,
+        FilesServiceFactory,
+        {
+          provide: FilesServiceFactory,
+          useValue: {
+            create: () => mockFilesService,
+          },
+        },
+      ],
+    }).compile();
+
+    filesResolver = module.get<FilesResolver>(FilesResolver);
+    filesService = module
+      .get<FilesServiceFactory>(FilesServiceFactory)
+      .create();
+  });
+
+  it('should be defined', () => {
+    expect(filesResolver).toBeDefined();
+  });
+
+  describe('listDirectory', () => {
+    it('should be defined', () => {
+      expect(filesResolver.listDirectory).toBeDefined();
+    });
+
+    it('should list files in directory', async () => {
+      const result = await filesResolver.listDirectory(pathToTestDirectory);
+      expect(result).toEqual(testDirectory);
+      expect(filesService.listDirectory).toHaveBeenCalledWith(
+        pathToTestDirectory,
+      );
+    });
+  });
+
+  describe('readFile', () => {
+    it('should be defined', () => {
+      expect(filesResolver.readFile).toBeDefined();
+    });
+
+    it('should read file', async () => {
+      const result = await filesResolver.readFile(pathToTestFileContent);
+      expect(result).toEqual(testFileContent);
+      expect(filesService.readFile).toHaveBeenCalledWith(pathToTestFileContent);
+    });
+  });
+});

package/test/unit/gitlab-files.service.unit.spec.ts

@@ -0,0 +1,46 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ConfigService } from '@nestjs/config';
+import axios from 'axios';
+import GitlabFilesService from '../../src/files/services/gitlab-files.service';
+import {
+  pathToTestFileContent,
+  testFileContent,
+  MockConfigService,
+  testDirectory,
+} from '../testUtil';
+
+describe('GitlabFilesService', () => {
+  let filesService: GitlabFilesService;
+  const mockConfigService = new MockConfigService();
+  jest.mock('axios');
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        GitlabFilesService,
+        { provide: ConfigService, useValue: mockConfigService },
+      ],
+    })
+      .overrideProvider(ConfigService)
+      .useValue(mockConfigService)
+      .compile();
+
+    filesService = module.get<GitlabFilesService>(GitlabFilesService);
+  });
+
+  it('should list directory', async () => {
+    jest.spyOn(axios, 'post').mockResolvedValue({ data: testDirectory });
+
+    const result = await filesService.listDirectory('user2');
+    expect(result).toEqual(testDirectory);
+  });
+
+  it('should read file', async () => {
+    jest
+      .spyOn(axios, 'post')
+      .mockResolvedValue({ data: { data: testFileContent } });
+
+    const result = await filesService.readFile(pathToTestFileContent);
+    expect(result).toEqual(testFileContent);
+  });
+});