chore: add some tests and align provider implementation

Signed-off-by: Ruben Romero Montes <rromerom@redhat.com>

Author: ruromero

src/providers/golang_gomodules.js

@@ -35,10 +35,12 @@ function isSupported(manifestName) {
 }
 
 /**
+ * Go modules have no standard license field in go.mod
  * @param {string} manifestPath - path to go.mod
  * @returns {string|null}
 */
-function readLicenseFromManifest() { return null }
+// eslint-disable-next-line no-unused-vars
+function readLicenseFromManifest(manifestPath) { return null }
 
 /**
  * @param {string} manifestDir - the directory where the manifest lies

src/providers/java_gradle.js

@@ -69,6 +69,14 @@ export default class Java_gradle extends Base_java {
  	 */
 	validateLockFile() { return true; }
 
+	/**
+	 * Gradle manifests (build.gradle, build.gradle.kts) have no standard license field.
+	 * @param {string} manifestPath - path to manifest
+	 * @returns {null}
+	 */
+	// eslint-disable-next-line no-unused-vars
+	readLicenseFromManifest(manifestPath) { return null; }
+
 	/**
 	 * Provide content and content type for stack analysis.
 	 * @param {string} manifest - the manifest path or name
@@ -100,13 +108,6 @@ export default class Java_gradle extends Base_java {
 		}
 	}
 
-	/**
-	 * Gradle manifests (build.gradle, build.gradle.kts) have no standard license field.
-	 * @param {string} manifestPath - path to manifest (unused)
-	 * @returns {null}
-	 */
-	readLicenseFromManifest() { return null }
-
 	/**
 	 * @param {string} line - the line to parse
 	 * @returns {number} the depth of the dependency in the tree starting from 1. -1 if the line is not a dependency.
@@ -198,7 +199,7 @@ export default class Java_gradle extends Base_java {
 		let sbom = new Sbom();
 		let root = `${properties.group}:${properties[ROOT_PROJECT_KEY_NAME].match(/Root project '(.+)'/)[1]}:jar:${properties.version}`
 		let rootPurl = this.parseDep(root)
-		const license = null; // Gradle has no standard license field in manifest
+		const license = this.readLicenseFromManifest(manifestPath);
 		sbom.addRoot(rootPurl, license)
 		let ignoredDeps = this.#getIgnoredDeps(manifestPath);
 
@@ -353,7 +354,7 @@ export default class Java_gradle extends Base_java {
 		let sbom = new Sbom();
 		let root = `${properties.group}:${properties[ROOT_PROJECT_KEY_NAME].match(/Root project '(.+)'/)[1]}:jar:${properties.version}`
 		let rootPurl = this.parseDep(root)
-		const license = null; // Gradle has no standard license field in manifest
+		const license = this.readLicenseFromManifest(manifestPath);
 		sbom.addRoot(rootPurl, license)
 		let ignoredDeps = this.#getIgnoredDeps(manifestPath);
 

src/providers/java_maven.js

@@ -65,6 +65,11 @@ export default class Java_maven extends Base_java {
 		}
 	}
 
+	/**
+	 * Read license from pom.xml manifest
+	 * @param {string} manifestPath - path to pom.xml
+	 * @returns {string|null}
+	 */
 	readLicenseFromManifest(manifestPath) {
 		try {
 			const xml = fs.readFileSync(manifestPath, 'utf-8');

src/providers/python_pip.js

@@ -32,10 +32,12 @@ function isSupported(manifestName) {
 }
 
 /**
+ * Python requirements.txt has no standard license field
  * @param {string} manifestPath - path to requirements.txt
  * @returns {string|null}
  */
-function readLicenseFromManifest() { return null }
+// eslint-disable-next-line no-unused-vars
+function readLicenseFromManifest(manifestPath) { return null }
 
 /**
  * @param {string} manifestDir - the directory where the manifest lies

test/provider.test.js

@@ -1,6 +1,6 @@
 import { expect } from 'chai'
 
-import { match } from "../src/provider.js"
+import { match, matchForLicense, availableProviders } from "../src/provider.js"
 
 suite('testing the provider utility function', () => {
 	// create a dummy provider for 'dummy_file.typ'
@@ -21,3 +21,123 @@ suite('testing the provider utility function', () => {
 			.to.throw('unknown.manifest is not supported')
 	})
 });
+
+suite('testing the matchForLicense utility function', () => {
+	// create dummy providers with different manifest types
+	const pomProvider = {
+		isSupported: nameType => 'pom.xml' === nameType,
+		validateLockFile: () => true,
+		readLicenseFromManifest: () => 'Apache-2.0',
+		provideComponent: () => {},
+		provideStack: () => {}
+	};
+
+	const packageJsonProvider = {
+		isSupported: nameType => 'package.json' === nameType,
+		validateLockFile: () => false, // No lock file - should still match for license
+		readLicenseFromManifest: () => 'MIT',
+		provideComponent: () => {},
+		provideStack: () => {}
+	};
+
+	const goModProvider = {
+		isSupported: nameType => 'go.mod' === nameType,
+		validateLockFile: () => true,
+		readLicenseFromManifest: () => null,
+		provideComponent: () => {},
+		provideStack: () => {}
+	};
+
+	const testProviders = [pomProvider, packageJsonProvider, goModProvider];
+
+	test('should match pom.xml provider by manifest name', () => {
+		const provider = matchForLicense('/path/to/pom.xml', testProviders);
+		expect(provider).to.equal(pomProvider);
+	});
+
+	test('should match package.json provider by manifest name', () => {
+		const provider = matchForLicense('/path/to/package.json', testProviders);
+		expect(provider).to.equal(packageJsonProvider);
+	});
+
+	test('should match go.mod provider by manifest name', () => {
+		const provider = matchForLicense('/path/to/go.mod', testProviders);
+		expect(provider).to.equal(goModProvider);
+	});
+
+	test('should match provider even when lock file does not exist', () => {
+		// packageJsonProvider has validateLockFile returning false
+		// but matchForLicense should not check lock file
+		const provider = matchForLicense('/no/lock/here/package.json', testProviders);
+		expect(provider).to.equal(packageJsonProvider);
+	});
+
+	test('should match provider with just filename (no full path)', () => {
+		const provider = matchForLicense('pom.xml', testProviders);
+		expect(provider).to.equal(pomProvider);
+	});
+
+	test('should throw error when no provider matches manifest type', () => {
+		expect(() => matchForLicense('/path/to/unknown.txt', testProviders))
+			.to.throw('unknown.txt is not supported');
+	});
+
+	test('should throw error for empty manifest name', () => {
+		expect(() => matchForLicense('', testProviders))
+			.to.throw('is not supported');
+	});
+
+	suite('real provider matching', () => {
+		test('should match Java Maven provider for pom.xml', () => {
+			const provider = matchForLicense('/some/path/pom.xml', availableProviders);
+			expect(provider).to.exist;
+			expect(provider.isSupported('pom.xml')).to.be.true;
+		});
+
+		test('should match Java Gradle Groovy provider for build.gradle', () => {
+			const provider = matchForLicense('/some/path/build.gradle', availableProviders);
+			expect(provider).to.exist;
+			expect(provider.isSupported('build.gradle')).to.be.true;
+		});
+
+		test('should match Java Gradle Kotlin provider for build.gradle.kts', () => {
+			const provider = matchForLicense('/some/path/build.gradle.kts', availableProviders);
+			expect(provider).to.exist;
+			expect(provider.isSupported('build.gradle.kts')).to.be.true;
+		});
+
+		test('should match JavaScript provider for package.json', () => {
+			const provider = matchForLicense('/some/path/package.json', availableProviders);
+			expect(provider).to.exist;
+			expect(provider.isSupported('package.json')).to.be.true;
+		});
+
+		test('should match Golang provider for go.mod', () => {
+			const provider = matchForLicense('/some/path/go.mod', availableProviders);
+			expect(provider).to.exist;
+			expect(provider.isSupported('go.mod')).to.be.true;
+		});
+
+		test('should match Python provider for requirements.txt', () => {
+			const provider = matchForLicense('/some/path/requirements.txt', availableProviders);
+			expect(provider).to.exist;
+			expect(provider.isSupported('requirements.txt')).to.be.true;
+		});
+
+		test('all matched providers should have readLicenseFromManifest method', () => {
+			const manifests = [
+				'pom.xml',
+				'build.gradle',
+				'build.gradle.kts',
+				'package.json',
+				'go.mod',
+				'requirements.txt'
+			];
+
+			manifests.forEach(manifest => {
+				const provider = matchForLicense(`/test/${manifest}`, availableProviders);
+				expect(provider.readLicenseFromManifest).to.be.a('function');
+			});
+		});
+	});
+});

test/providers/license.test.js

@@ -0,0 +1,136 @@
+import path from 'path'
+
+import { expect } from 'chai'
+
+import golangGomodulesProvider from '../../src/providers/golang_gomodules.js'
+import Java_gradle_groovy from '../../src/providers/java_gradle_groovy.js'
+import Java_gradle_kotlin from '../../src/providers/java_gradle_kotlin.js'
+import Java_maven from '../../src/providers/java_maven.js'
+import Javascript_npm from '../../src/providers/javascript_npm.js'
+import Javascript_pnpm from '../../src/providers/javascript_pnpm.js'
+import Javascript_yarn from '../../src/providers/javascript_yarn.js'
+import pythonPipProvider from '../../src/providers/python_pip.js'
+
+suite('testing readLicenseFromManifest with existing test manifests', () => {
+
+	suite('Java Maven provider', () => {
+		const provider = new Java_maven();
+
+		test('should read Apache-2.0 license when found', () => {
+			const pomPath = path.resolve('test/providers/tst_manifests/maven/pom_deps_with_ignore_version_from_property/pom.xml');
+			const license = provider.readLicenseFromManifest(pomPath);
+			expect(license).to.equal('Apache-2.0');
+		});
+
+		test('should return null when license not present', () => {
+			const pomPath = path.resolve('test/providers/tst_manifests/maven/pom_deps_with_no_ignore/pom.xml');
+			const license = provider.readLicenseFromManifest(pomPath);
+			expect(license).to.be.null;
+		});
+	});
+
+	suite('Java Gradle Groovy provider', () => {
+		const provider = new Java_gradle_groovy();
+
+		test('should always return null (no standard license field)', () => {
+			const gradlePath = path.resolve('test/providers/tst_manifests/gradle/deps_with_no_ignore_common_paths/build.gradle');
+			const license = provider.readLicenseFromManifest(gradlePath);
+			expect(license).to.be.null;
+		});
+	});
+
+	suite('Java Gradle Kotlin provider', () => {
+		const provider = new Java_gradle_kotlin();
+
+		test('should always return null (no standard license field)', () => {
+			const gradlePath = path.resolve('test/providers/tst_manifests/gradle/deps_with_no_ignore_common_paths/build.gradle.kts');
+			const license = provider.readLicenseFromManifest(gradlePath);
+			expect(license).to.be.null;
+		});
+	});
+
+	suite('JavaScript npm provider', () => {
+		const provider = new Javascript_npm();
+
+		test('should read ISC license when found', () => {
+			const packagePath = path.resolve('test/providers/tst_manifests/npm/package_json_deps_with_exhortignore_object/package.json');
+			const license = provider.readLicenseFromManifest(packagePath);
+			expect(license).to.equal('ISC');
+		});
+
+		test('should return null for non-existent file', () => {
+			const license = provider.readLicenseFromManifest('/fake/path/package.json');
+			expect(license).to.be.null;
+		});
+	});
+
+	suite('JavaScript pnpm provider', () => {
+		const provider = new Javascript_pnpm();
+
+		test('should read ISC license when found', () => {
+			const packagePath = path.resolve('test/providers/tst_manifests/pnpm/package_json_deps_with_exhortignore_object/package.json');
+			const license = provider.readLicenseFromManifest(packagePath);
+			expect(license).to.equal('ISC');
+		});
+
+		test('should return null for non-existent file', () => {
+			const license = provider.readLicenseFromManifest('/fake/path/package.json');
+			expect(license).to.be.null;
+		});
+	});
+
+	suite('JavaScript yarn provider', () => {
+		const provider = new Javascript_yarn();
+
+		test('should read ISC license when found', () => {
+			const packagePath = path.resolve('test/providers/tst_manifests/yarn-classic/package_json_deps_with_exhortignore_object/package.json');
+			const license = provider.readLicenseFromManifest(packagePath);
+			expect(license).to.equal('ISC');
+		});
+
+		test('should return null for non-existent file', () => {
+			const license = provider.readLicenseFromManifest('/fake/path/package.json');
+			expect(license).to.be.null;
+		});
+	});
+
+	suite('Golang go.mod provider', () => {
+		test('should always return null (no standard license field)', () => {
+			const goModPath = path.resolve('test/providers/tst_manifests/golang/go_mod_no_ignore/go.mod');
+			const license = golangGomodulesProvider.readLicenseFromManifest(goModPath);
+			expect(license).to.be.null;
+		});
+	});
+
+	suite('Python requirements.txt provider', () => {
+		test('should always return null (no standard license field)', () => {
+			const reqPath = path.resolve('test/providers/tst_manifests/pip/pip_requirements_txt_no_ignore/requirements.txt');
+			const license = pythonPipProvider.readLicenseFromManifest(reqPath);
+			expect(license).to.be.null;
+		});
+	});
+
+	suite('All providers have readLicenseFromManifest method', () => {
+		const allProviders = [
+			{ name: 'Java Maven', instance: new Java_maven() },
+			{ name: 'Java Gradle Groovy', instance: new Java_gradle_groovy() },
+			{ name: 'Java Gradle Kotlin', instance: new Java_gradle_kotlin() },
+			{ name: 'JavaScript npm', instance: new Javascript_npm() },
+			{ name: 'JavaScript pnpm', instance: new Javascript_pnpm() },
+			{ name: 'JavaScript yarn', instance: new Javascript_yarn() },
+			{ name: 'Golang', instance: golangGomodulesProvider },
+			{ name: 'Python', instance: pythonPipProvider }
+		];
+
+		allProviders.forEach(({ name, instance }) => {
+			test(`${name} provider exports readLicenseFromManifest`, () => {
+				expect(instance.readLicenseFromManifest).to.be.a('function');
+			});
+
+			test(`${name} provider readLicenseFromManifest accepts manifestPath parameter`, () => {
+				// Should not throw when called with a path argument
+				expect(() => instance.readLicenseFromManifest('/test/path')).to.not.throw();
+			});
+		});
+	});
+});