feat(java): package management used practice (#213)

feat(java): package management used practice

src/detectors/Java/JavaComponentDetector.ts

@@ -15,7 +15,6 @@ export class JavaComponentDetector implements IProjectComponentDetector {
   }
 
   async detectComponent(langAtPath: LanguageAtPath): Promise<ProjectComponent[]> {
-    // @todo: add framework recognition => need an XML or GRADLE reader to determine the framework
     return [
       {
         framework: ProjectComponentFramework.UNKNOWN,

src/practices/Java/JavaPackageManagementUsed.spec.ts

@@ -0,0 +1,63 @@
+import { JavaPackageManagementUsedPractice } from './JavaPackageManagementUsed';
+import { PracticeEvaluationResult, ProgrammingLanguage } from '../../model';
+import { TestContainerContext, createTestContainer } from '../../inversify.config';
+import { pomXMLContents } from '../../detectors/__MOCKS__/Java/pomXMLContents.mock';
+import { buildGRADLEContents } from '../../detectors/__MOCKS__/Java/buildGRADLEContents.mock';
+
+describe('JavaPackageManagementUsedPractice', () => {
+  let practice: JavaPackageManagementUsedPractice;
+  let containerCtx: TestContainerContext;
+
+  beforeAll(() => {
+    containerCtx = createTestContainer();
+    containerCtx.container.bind('JavaPackageManagementUsedPractice').to(JavaPackageManagementUsedPractice);
+    practice = containerCtx.container.get('JavaPackageManagementUsedPractice');
+  });
+
+  afterEach(async () => {
+    containerCtx.virtualFileSystemService.clearFileSystem();
+    containerCtx.practiceContext.fileInspector!.purgeCache();
+  });
+
+  it('Returns practicing if there is a pom.xml', async () => {
+    containerCtx.virtualFileSystemService.setFileSystem({
+      'pom.xml': pomXMLContents,
+    });
+    const evaluated = await practice.evaluate(containerCtx.practiceContext);
+    expect(evaluated).toEqual(PracticeEvaluationResult.practicing);
+  });
+
+  it('Returns practicing if there is a build.gradle', async () => {
+    containerCtx.virtualFileSystemService.setFileSystem({
+      'build.gradle': buildGRADLEContents,
+    });
+    const evaluated = await practice.evaluate(containerCtx.practiceContext);
+    expect(evaluated).toEqual(PracticeEvaluationResult.practicing);
+  });
+
+  it('Returns notPracticing if there is NO pom.xml or build.gradle', async () => {
+    containerCtx.virtualFileSystemService.setFileSystem({
+      'not.exists': '...',
+    });
+
+    const evaluated = await practice.evaluate(containerCtx.practiceContext);
+    expect(evaluated).toEqual(PracticeEvaluationResult.notPracticing);
+  });
+
+  it('Returns unknown if there is no fileInspector', async () => {
+    const evaluated = await practice.evaluate({ ...containerCtx.practiceContext, fileInspector: undefined });
+    expect(evaluated).toEqual(PracticeEvaluationResult.unknown);
+  });
+
+  it('Is applicable to Java', async () => {
+    containerCtx.practiceContext.projectComponent.language = ProgrammingLanguage.Java;
+    const result = await practice.isApplicable(containerCtx.practiceContext);
+    expect(result).toEqual(true);
+  });
+
+  it('Is not applicable to other languages', async () => {
+    containerCtx.practiceContext.projectComponent.language = ProgrammingLanguage.Python;
+    const result = await practice.isApplicable(containerCtx.practiceContext);
+    expect(result).toEqual(false);
+  });
+});

src/practices/Java/JavaPackageManagementUsed.ts

@@ -0,0 +1,32 @@
+import { IPractice } from '../IPractice';
+import { PracticeEvaluationResult, PracticeImpact, ProgrammingLanguage } from '../../model';
+import { DxPractice } from '../DxPracticeDecorator';
+import { PracticeContext } from '../../contexts/practice/PracticeContext';
+
+@DxPractice({
+  id: 'Java.PackageManagementUsed',
+  name: 'Use Java Package Management',
+  impact: PracticeImpact.high,
+  suggestion: 'Use pom.xml or build.gradle to keep track of packages that are being used in your application.',
+  reportOnlyOnce: true,
+  url: 'https://maven.apache.org/',
+})
+export class JavaPackageManagementUsedPractice implements IPractice {
+  async isApplicable(ctx: PracticeContext): Promise<boolean> {
+    return ctx.projectComponent.language === ProgrammingLanguage.Java;
+  }
+
+  async evaluate(ctx: PracticeContext): Promise<PracticeEvaluationResult> {
+    if (!ctx.fileInspector) {
+      return PracticeEvaluationResult.unknown;
+    }
+
+    if (await ctx.fileInspector.exists('pom.xml')) {
+      return PracticeEvaluationResult.practicing;
+    } else if (await ctx.fileInspector.exists('build.gradle')) {
+      return PracticeEvaluationResult.practicing;
+    }
+
+    return PracticeEvaluationResult.notPracticing;
+  }
+}

src/practices/JavaScript/JsPackageManagementUsedPractice.spec.ts

@@ -1,5 +1,5 @@
 import { JsPackageManagementUsedPractice } from './JsPackageManagementUsedPractice';
-import { PracticeEvaluationResult } from '../../model';
+import { PracticeEvaluationResult, ProgrammingLanguage } from '../../model';
 import { TestContainerContext, createTestContainer } from '../../inversify.config';
 
 describe('JsPackageManagementUsedPractice', () => {
@@ -36,8 +36,21 @@ describe('JsPackageManagementUsedPractice', () => {
     expect(evaluated).toEqual(PracticeEvaluationResult.unknown);
   });
 
-  it('Is always applicable', async () => {
-    const result = await practice.isApplicable();
+  it('Is applicable to JS', async () => {
+    containerCtx.practiceContext.projectComponent.language = ProgrammingLanguage.JavaScript;
+    const result = await practice.isApplicable(containerCtx.practiceContext);
     expect(result).toEqual(true);
   });
+
+  it('Is applicable to TS', async () => {
+    containerCtx.practiceContext.projectComponent.language = ProgrammingLanguage.TypeScript;
+    const result = await practice.isApplicable(containerCtx.practiceContext);
+    expect(result).toEqual(true);
+  });
+
+  it('Is not applicable to other languages', async () => {
+    containerCtx.practiceContext.projectComponent.language = ProgrammingLanguage.Python;
+    const result = await practice.isApplicable(containerCtx.practiceContext);
+    expect(result).toEqual(false);
+  });
 });

src/practices/JavaScript/JsPackageManagementUsedPractice.ts

@@ -1,5 +1,5 @@
 import { IPractice } from '../IPractice';
-import { PracticeEvaluationResult, PracticeImpact } from '../../model';
+import { PracticeEvaluationResult, PracticeImpact, ProgrammingLanguage } from '../../model';
 import { DxPractice } from '../DxPracticeDecorator';
 import { PracticeContext } from '../../contexts/practice/PracticeContext';
 
@@ -12,8 +12,10 @@ import { PracticeContext } from '../../contexts/practice/PracticeContext';
   url: 'https://docs.npmjs.com/files/package.json',
 })
 export class JsPackageManagementUsedPractice implements IPractice {
-  async isApplicable(): Promise<boolean> {
-    return true;
+  async isApplicable(ctx: PracticeContext): Promise<boolean> {
+    return (
+      ctx.projectComponent.language === ProgrammingLanguage.JavaScript || ctx.projectComponent.language === ProgrammingLanguage.TypeScript
+    );
   }
 
   async evaluate(ctx: PracticeContext): Promise<PracticeEvaluationResult> {

src/practices/index.ts

@@ -30,6 +30,7 @@ import { TimeToSolveIssuesPractice } from './LanguageIndependent/TimeToSolveIssu
 import { ThinPullRequestsPractice } from './LanguageIndependent/ThinPullRequestsPractice';
 import { SecurityVulnerabilitiesPractice } from './JavaScript/SecurityVulnerabilitiesPractice';
 import { FirstTestPractice, SecondTestPractice, InvalidTestPractice } from '../scanner';
+import { JavaPackageManagementUsedPractice } from './Java/JavaPackageManagementUsed';
 
 // register practices here
 export const practices = [
@@ -64,4 +65,5 @@ export const practices = [
   TimeToSolveIssuesPractice,
   ThinPullRequestsPractice,
   SecurityVulnerabilitiesPractice,
+  JavaPackageManagementUsedPractice,
 ];