@into-cps-association/libms 0.5.0 → 0.5.1

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

@@ -17,14 +17,11 @@ import {
   expectedFileContentResponse,
   expectedListDirectoryResponse,
 } from '../testUtil';
+import { CONFIG_SERVICE, IConfig } from 'src/config/config.interface';
+import Config from 'src/config/config.service';
 
-const client = new ApolloClient({
-  link: new HttpLink({
-    uri: `http://localhost:${process.env.PORT}${process.env.APOLLO_PATH}`,
-    fetch,
-  }),
-  cache: new InMemoryCache({ addTypename: false }),
-});
+let client;
+let configService: IConfig;
 
 describe('End to End test for the application', () => {
   let app: INestApplication;
@@ -33,13 +30,24 @@ describe('End to End test for the application', () => {
     const moduleFixture: TestingModule = await Test.createTestingModule({
       imports: [AppModule],
     }).compile();
+    configService = moduleFixture.get<Config>(CONFIG_SERVICE);
     app = moduleFixture.createNestApplication();
+    client = new ApolloClient({
+      link: new HttpLink({
+        uri: `http://localhost:${configService.getPort()}${configService.getApolloPath()}`,
+        fetch,
+      }),
+      cache: new InMemoryCache({ addTypename: false }),
+    });
     await app.init(); // Initialize the application
-    await app.listen(process.env.PORT);
+    await app.listen(configService.getPort());
 
-    // eslint-disable-next-line no-promise-executor-return
-    await new Promise((resolve) => setTimeout(resolve, 4000));
-  }, 10000);
+    // Check if the port is available
+
+    while (!app.getHttpServer().listening) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }, 15000);
 
   afterAll(async () => {
     await app.close();
@@ -49,8 +57,10 @@ describe('End to End test for the application', () => {
     query: string,
     expectedResponse: unknown,
   ): Promise<void> {
-    const response = await request(`http://localhost:${process.env.PORT}`)
-      .post(process.env.APOLLO_PATH)
+    const response = await request(
+      `http://localhost:${configService.getPort()}`,
+    )
+      .post(configService.getApolloPath())
       .send({ query });
     expect(response.body).toEqual(expectedResponse);
   }

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

@@ -1,43 +1,44 @@
 import { describe, it, expect, jest } from '@jest/globals';
 import { Test, TestingModule } from '@nestjs/testing';
-import { ConfigService } from '@nestjs/config';
 import FilesResolver from '../../src/files/files.resolver';
 import LocalFilesService from '../../src/files/local/local-files.service';
 import {
+  jestMockConfigService,
   pathToTestDirectory,
   pathToTestFileContent,
   testDirectory,
   testFileContent,
-  MockConfigService,
 } from '../testUtil';
 import GitFilesService from '../../src/files/git/git-files.service';
 import { FILE_SERVICE } from '../../src/files/interfaces/files.service.interface';
 import FilesServiceFactory from '../../src/files/files-service.factory';
+import { CONFIG_SERVICE, IConfig } from 'src/config/config.interface';
 
 describe('Integration tests for FilesResolver', () => {
   let filesResolver: FilesResolver;
-  let mockConfigService: MockConfigService;
+  let mockConfigService: IConfig;
 
   beforeEach(async () => {
-    mockConfigService = new MockConfigService();
+    mockConfigService = jestMockConfigService();
+
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         FilesResolver,
         {
           provide: FILE_SERVICE,
           useFactory: (
-            configService: ConfigService,
+            configService: IConfig,
             localFilesService: LocalFilesService,
             gitFilesService: GitFilesService,
           ) => {
             const fileServices = [localFilesService, gitFilesService];
             return FilesServiceFactory.create(configService, fileServices);
           },
-          inject: [ConfigService, LocalFilesService, GitFilesService],
+          inject: [CONFIG_SERVICE, LocalFilesService, GitFilesService],
         },
         LocalFilesService,
         GitFilesService,
-        { provide: ConfigService, useClass: MockConfigService },
+        { provide: CONFIG_SERVICE, useValue: mockConfigService },
       ],
     }).compile();
 
@@ -50,12 +51,10 @@ describe('Integration tests for FilesResolver', () => {
 
   const modes = ['local'];
 
-  // 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);
+        jest.spyOn(mockConfigService, 'getMode').mockImplementation(() => mode);
       });
 
       it('should be defined', () => {

package/test/jest-e2e.json

@@ -5,5 +5,8 @@
   "testRegex": ".e2e.spec.ts$",
   "transform": {
     "^.+\\.(t|j)s$": "ts-jest"
+  },
+  "moduleNameMapper": {
+    "^(\\.\\.?\\/.+)\\.jsx?$": "$1"
   }
 }

package/test/libms.test.yaml

@@ -0,0 +1,6 @@
+port: '4001'
+local-path: 'test/data'
+mode: 'local'
+log-level: 'debug'
+apollo-path: '/lib'
+graphql-playground: 'true'

package/test/testUtil.ts

@@ -1,7 +1,8 @@
-import * as dotenv from 'dotenv';
+import { IConfig } from 'src/config/config.interface';
 import { setTimeout } from 'timers/promises';
-
-dotenv.config({ path: '.env' });
+import { jest } from '@jest/globals';
+import { GitRepo } from 'src/config/config.model';
+import { CONFIG_MODE } from 'src/enums/config-mode.enum';
 
 // actual data for integration and e2e tests
 export const readFileActualContent = ['content123'];
@@ -26,7 +27,10 @@ export const testDirectory = {
 };
 export const testFileName = 'README.md';
 export const fstestFileContent = 'content123';
+export const largeTestFileName = 'large_file.md';
+export const largeFstestFileContent = 'a'.repeat(500 * 1000);
 export const pathToTestFileContent = 'user2/tools/README.md';
+export const pathToLargeTestFileContent = 'user2/tools/large_file.md';
 export const testFileArray = [
   'data',
   'digital_twins',
@@ -54,26 +58,26 @@ export function sleep(ms) {
 }
 
 export class MockConfigService {
-  // eslint-disable-next-line class-methods-use-this
-  get(key: string): string {
-    switch (key) {
-      case 'LOCAL_PATH':
-        return process.env.LOCAL_PATH;
-      case 'MODE':
-        if (process.env.MODE === 'local') {
-          return 'local';
-        }
-        if (process.env.MODE === 'git') {
-          return 'git';
-        }
-        return 'unknown';
+  getMode(): string {
+    return '';
+  }
 
-      default:
-        return undefined;
-    }
+  getLocalPath(): string {
+    return 'test/data';
   }
 }
 
+export const jestMockConfigService = (): IConfig => ({
+  getMode: jest.fn<() => string>().mockReturnValue(CONFIG_MODE.LOCAL),
+  getLocalPath: jest.fn<() => string>().mockReturnValue('test/data'),
+  getApolloPath: jest.fn<() => string>(),
+  getGitRepos: jest.fn<() => { [key: string]: GitRepo }[]>(),
+  getGraphqlPlayground: jest.fn<() => string>(),
+  getLogLevel: jest.fn<() => string>(),
+  getPort: jest.fn<() => number>(),
+  loadConfig: jest.fn<() => Promise<void>>(),
+});
+
 export const mockReadFileResponseData = {
   project: {
     __typename: 'Project',

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

@@ -1,51 +1,62 @@
 // files-service.factory.spec.ts
 import { describe, it, expect, jest } from '@jest/globals';
 import { Test, TestingModule } from '@nestjs/testing';
-import { ConfigService } from '@nestjs/config';
 import FilesServiceFactory from '../../src/files/files-service.factory';
 import LocalFilesService from '../../src/files/local/local-files.service';
 import { IFilesService } from '../../src/files/interfaces/files.service.interface';
 import GitFilesService from '../../src/files/git/git-files.service';
+import { CONFIG_SERVICE, IConfig } from 'src/config/config.interface';
+import { jestMockConfigService } from 'test/testUtil';
+import { CONFIG_MODE } from 'src/enums/config-mode.enum';
 
 describe('FilesServiceFactory', () => {
-  let configService: ConfigService;
+  let configService: IConfig;
   let localFilesService: IFilesService;
   let gitFilesService: IFilesService;
   let fileServices: IFilesService[];
 
   beforeEach(async () => {
+    configService = jestMockConfigService();
+    gitFilesService = {
+      getMode: jest.fn<() => CONFIG_MODE>().mockReturnValue(CONFIG_MODE.GIT),
+      init: jest.fn<() => Promise<void>>(),
+    } as unknown as IFilesService;
+
     const module: TestingModule = await Test.createTestingModule({
       providers: [
-        GitFilesService,
-        { provide: ConfigService, useValue: { get: jest.fn() } },
+        { provide: GitFilesService, useValue: gitFilesService },
+        {
+          provide: CONFIG_SERVICE,
+          useValue: configService,
+        },
         LocalFilesService,
       ],
     }).compile();
 
-    configService = module.get<ConfigService>(ConfigService);
     localFilesService = module.get<LocalFilesService>(LocalFilesService);
     gitFilesService = module.get<GitFilesService>(GitFilesService);
     fileServices = [gitFilesService, localFilesService];
   });
 
   it('should create a local files service when MODE is local', () => {
-    jest.spyOn(configService, 'get').mockReturnValue('local');
+    jest.spyOn(configService, 'getMode').mockReturnValue('local');
     expect(FilesServiceFactory.create(configService, fileServices)).toBe(
       localFilesService,
     );
   });
 
   it('should create a git files service when MODE is git', () => {
-    jest.spyOn(configService, 'get').mockReturnValue('git');
+    jest.spyOn(configService, 'getMode').mockReturnValue(CONFIG_MODE.GIT);
     expect(FilesServiceFactory.create(configService, fileServices)).toBe(
       gitFilesService,
     );
   });
 
   it('should throw an error when MODE is invalid', () => {
-    jest.spyOn(configService, 'get').mockReturnValue('invalid');
-    expect(() =>
-      FilesServiceFactory.create(configService, fileServices),
-    ).toThrow(`Invalid MODE: invalid`);
+    const invalidMode = 'invalid';
+    jest.spyOn(configService, 'getMode').mockReturnValue(invalidMode);
+    expect(() => {
+      FilesServiceFactory.create(configService, fileServices);
+    }).toThrow(`Invalid MODE: ${invalidMode}`);
   });
 });

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

@@ -27,6 +27,7 @@ describe('Unit tests for FilesResolver', () => {
         .fn<() => Promise<Project>>()
         .mockImplementation(() => Promise.resolve(testFileContent)),
       getMode: jest.fn<() => CONFIG_MODE>().mockReturnValue(CONFIG_MODE.LOCAL),
+      init: jest.fn<() => Promise<void>>(),
     };
 
     const module: TestingModule = await Test.createTestingModule({

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

@@ -1,16 +1,16 @@
 import { describe, it, expect, jest } from '@jest/globals';
 import { Test, TestingModule } from '@nestjs/testing';
-import { ConfigService } from '@nestjs/config';
 import LocalFileService from 'src/files/local/local-files.service';
 import { Project } from 'src/types';
 import {
-  MockConfigService,
+  jestMockConfigService,
   testDirectory,
   testFileContent,
 } from 'test/testUtil';
 import GitFilesService from 'src/files/git/git-files.service';
 import { CONFIG_MODE } from 'src/enums/config-mode.enum';
 import { IFilesService } from 'src/files/interfaces/files.service.interface';
+import { CONFIG_SERVICE } from 'src/config/config.interface';
 
 jest.mock('fs', () => ({
   promises: {
@@ -22,7 +22,7 @@ jest.mock('fs', () => ({
 
 describe('GitFilesService', () => {
   let service: GitFilesService;
-  const mockConfigService = new MockConfigService();
+  const mockConfigService = jestMockConfigService();
   const mockLocalFilesService: IFilesService = {
     listDirectory: jest
       .fn<() => Promise<Project>>()
@@ -31,13 +31,14 @@ describe('GitFilesService', () => {
       .fn<() => Promise<Project>>()
       .mockImplementation(() => Promise.resolve(testFileContent)),
     getMode: jest.fn<() => CONFIG_MODE>().mockReturnValue(CONFIG_MODE.LOCAL),
+    init: jest.fn<() => Promise<void>>(),
   };
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         GitFilesService,
-        { provide: ConfigService, useValue: mockConfigService },
+        { provide: CONFIG_SERVICE, useValue: mockConfigService },
         { provide: LocalFileService, useValue: mockLocalFilesService },
       ],
     }).compile();
@@ -76,6 +77,6 @@ describe('GitFilesService', () => {
     await service.readFile('/some/path/file.txt');
 
     // Assert
-    expect(mockReadFile).toBeCalledTimes(1);
+    expect(mockReadFile).toHaveBeenCalledTimes(1);
   });
 });

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

@@ -1,6 +1,5 @@
 import { describe, it, expect, jest } from '@jest/globals';
 import { Test, TestingModule } from '@nestjs/testing';
-import { ConfigService } from '@nestjs/config';
 import * as fs from 'fs';
 import { join } from 'path';
 import LocalFilesService from '../../src/files/local/local-files.service';
@@ -8,11 +7,15 @@ import {
   fstestFileContent,
   pathToTestDirectory,
   pathToTestFileContent,
-  testFileArray,
-  MockConfigService,
   testFileName,
+  pathToLargeTestFileContent,
+  largeFstestFileContent,
+  largeTestFileName,
+  jestMockConfigService,
+  testFileArray,
 } from '../testUtil';
 import { Dirent } from 'fs';
+import { CONFIG_SERVICE } from 'src/config/config.interface';
 
 jest.mock('fs', () => ({
   promises: {
@@ -24,13 +27,14 @@ jest.mock('fs', () => ({
 
 describe('LocalFilesService', () => {
   let service: LocalFilesService;
-  const mockConfigService = new MockConfigService();
+  let mockConfigService;
 
   beforeEach(async () => {
+    mockConfigService = jestMockConfigService();
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         LocalFilesService,
-        { provide: ConfigService, useValue: mockConfigService },
+        { provide: CONFIG_SERVICE, useValue: mockConfigService },
       ],
     }).compile();
 
@@ -47,7 +51,7 @@ describe('LocalFilesService', () => {
 
   it('should list directory', async () => {
     const fullPath = join(
-      mockConfigService.get('LOCAL_PATH'),
+      mockConfigService.getLocalPath(),
       pathToTestDirectory,
     );
 
@@ -83,28 +87,40 @@ describe('LocalFilesService', () => {
     expect(fs.promises.lstat).toHaveBeenCalledTimes(testFileArray.length);
   });
 
-  it('should read file', async () => {
-    const fullPath = join(
-      mockConfigService.get('LOCAL_PATH'),
-      pathToTestFileContent,
-    );
+  const readTestFile = [
+    {
+      name: largeTestFileName,
+      filePath: pathToLargeTestFileContent,
+      expectedContent: largeFstestFileContent,
+    },
+    {
+      name: testFileName,
+      filePath: pathToTestFileContent,
+      expectedContent: fstestFileContent,
+    },
+  ];
 
-    jest.spyOn(fs.promises, 'readFile').mockResolvedValue(fstestFileContent);
+  readTestFile.forEach(({ name, filePath, expectedContent }) => {
+    it(`should read file ${name}`, async () => {
+      const fullPath = join(mockConfigService.getLocalPath(), filePath);
 
-    const result = await service.readFile(pathToTestFileContent);
-    expect(result).toEqual({
-      repository: {
-        blobs: {
-          nodes: [
-            {
-              name: testFileName,
-              rawBlob: fstestFileContent,
-              rawTextBlob: fstestFileContent,
-            },
-          ],
+      jest.spyOn(fs.promises, 'readFile').mockResolvedValue(expectedContent);
+
+      const result = await service.readFile(filePath);
+      expect(result).toEqual({
+        repository: {
+          blobs: {
+            nodes: [
+              {
+                name: name,
+                rawBlob: expectedContent,
+                rawTextBlob: expectedContent,
+              },
+            ],
+          },
         },
-      },
+      });
+      expect(fs.promises.readFile).toHaveBeenCalledWith(fullPath, 'utf8');
     });
-    expect(fs.promises.readFile).toHaveBeenCalledWith(fullPath, 'utf8');
   });
 });

package/test/update-config.js

@@ -0,0 +1,25 @@
+import * as fs from 'fs';
+import * as yaml from 'js-yaml';
+import * as path from 'path';
+
+// Load environment variables
+const env = process.env;
+
+const yamlFilePath = path.join(process.env.LIBMS_CONFIG_PATH || 'test/libms.test.yaml');
+const fileContents = fs.readFileSync(yamlFilePath, 'utf8');
+const config = yaml.load(fileContents);
+
+if (env.LIBMS_LOCAL_PATH) {
+  console.log('Updating local-path to '+ env.LIBMS_LOCAL_PATH);
+  config['local-path'] = env.LIBMS_LOCAL_PATH;
+}
+
+if (env.LIBMS_PORT) {
+  console.log('Updating PORT to '+ env.LIBMS_PORT);
+  config['port'] = env.LIBMS_PORT;
+}
+
+const updatedYaml = yaml.dump(config);
+fs.writeFileSync(yamlFilePath, updatedYaml, 'utf8');
+
+console.log( yamlFilePath + ' updated successfully.');