fix: Enable gradle9 wrapper test

Author: calhar-snyk

.circleci/config.yml

@@ -30,14 +30,14 @@ windows_defaults: &windows_defaults
 test_matrix_unix: &test_matrix_unix
   matrix:
     parameters:
-      node_version: [ '16.18', '18.18', '20.9' ]
+      node_version: [ '20.19', '22.19', '24.8' ]
       jdk_version: [ '8.0.292.j9-adpt' ]
       gradle_version: [ '4.10', '5.6.4', '6.9.4']
 
 test_matrix_unix_new_versions: &test_matrix_unix_new_versions
   matrix:
     parameters:
-      node_version: [ '16.18', '18.18', '20.9' ]
+      node_version: [ '20.19', '22.19', '24.8' ]
       jdk_version: [ '17.0.9-jbr' ]
       gradle_version: [ '7.6', '8.14', '9.0.0', '9.1.0-rc-3' ]
 
@@ -47,15 +47,15 @@ test_matrix_win: &test_matrix_win
       node_version: [ '20', '22', '24' ]
       jdk_version: [ '8' ]
       jdk_path: [ 'C:\Program Files\Eclipse Adoptium\jdk-8.0.442.6-hotspot' ]
-      gradle_version: [ '4.10', '5.6', '6.9.4' ]
+      gradle_version: [ '4.10', '5.6', '6.8.3' ]
 
 test_matrix_win_new_versions: &test_matrix_win_new_versions
   matrix:
     parameters:
       node_version: [ '20', '22', '24' ]
       jdk_version: [ '17.0.2' ]
       jdk_path: [ 'C:\Program Files\OpenJDK\jdk-17.0.2' ]
-      gradle_version: [ '7.6', '8.14', '9.0.0', '9.1.0-rc-3' ]
+      gradle_version: [ '7.6', '8.14', '9.0.0' ]
 
 filters_branches_only_main: &filters_branches_only_main
   filters:
@@ -261,6 +261,7 @@ jobs:
     docker:
       - image: cimg/node:<< parameters.node_version >>
     environment:
+      JDK: << parameters.jdk_version >>
       GRADLE_VERSION: << parameters.gradle_version >>
     steps:
       - checkout

test/common.ts

@@ -20,3 +20,19 @@ export function createDepGraph(depGraph: DepGraphData, fixturePath: string) {
     { encoding: 'utf8' },
   );
 }
+
+/**
+ * Check if the current JDK version is at least the specified minimum version
+ * @param minVersion - The minimum version to check against (e.g., 8, 11, 17, 21)
+ * @returns true if current JDK version >= minVersion, or if version is unknown (lets test run and fail naturally)
+ */
+export function jdkVersionAtLeast(minVersion: number): boolean {
+  const jdkVersionFromProcess = process.env.JDK || '';
+  if (!jdkVersionFromProcess) {
+    return true; // If unknown, don't skip - let the test run and fail if incompatible
+  }
+
+  const jdkVersionInUse: number = parseInt(jdkVersionFromProcess.split('.')[0]);
+
+  return jdkVersionInUse >= minVersion;
+}

test/system/android.test.ts

@@ -7,18 +7,25 @@ const gradleVersionInUse: number = parseInt(
   gradleVersionFromProcess.split('.')[0],
 );
 const isAndroidSupported: boolean = gradleVersionInUse > 7 ? true : false;
-if (isAndroidSupported) {
-  describe('android version 8 build', () => {
-    test('we can inspect naively', async () => {
+describe('android version 8 build', () => {
+  const testOrSkip = isAndroidSupported ? test : test.skip;
+
+  testOrSkip(
+    'we can inspect naively',
+    async () => {
       const data = await inspect(
         '.',
         path.join(fixtureDir('modern-android'), 'build.gradle'),
         { allSubProjects: true },
       );
       expect(data.scannedProjects.length).toEqual(2);
-    }, 90000);
+    },
+    90000,
+  );
 
-    test('we can inspect with configuration attribute selector', async () => {
+  testOrSkip(
+    'we can inspect with configuration attribute selector',
+    async () => {
       const data = await inspect(
         '.',
         path.join(fixtureDir('modern-android'), 'build.gradle'),
@@ -29,9 +36,7 @@ if (isAndroidSupported) {
         },
       );
       expect(data.scannedProjects.length).toEqual(2);
-    }, 90000);
-  });
-} else {
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  test('minimum gradle version for modern android project is 8', () => {});
-}
+    },
+    90000,
+  );
+});

test/system/fixtures-with-wrappers.test.ts

@@ -2,10 +2,11 @@ import * as path from 'path';
 import * as fs from 'fs';
 import { NeedleResponse } from 'needle';
 
-import { getPathToFixture } from '../common';
+import { getPathToFixture, jdkVersionAtLeast } from '../common';
 import { inspect } from '../../lib';
 import * as search from '../../lib/search';
 import type { PomCoords, SnykHttpClient } from '../../lib/types';
+import { DepGraphData } from '@snyk/dep-graph';
 
 // specify fixtures to test, or leave empty to test all fixtures
 let fixtures: string[] = [];
@@ -156,4 +157,107 @@ describe('inspect() fixtures', () => {
 
     expect(result.dependencyGraph?.toJSON()).toEqual(expectedDepGraphJson);
   });
+
+  describe('kts-basic-gradle9 fixture tests - requires JDK 17+', () => {
+    const isGradle9Compatible = jdkVersionAtLeast(17);
+    const testOrSkip = isGradle9Compatible ? test : test.skip;
+
+    // Sanitizes DepGraph data to normalize platform-specific dependencies
+    // Specifically converts kotlin-native-prebuilt entries with any architecture
+    // to use macos-aarch64 for consistent test expectations
+    const sanitizeDepGraphForPlatform = (depGraphData: DepGraphData): any => {
+      if (!depGraphData) return depGraphData;
+
+      const sanitized = JSON.parse(JSON.stringify(depGraphData)); // deep clone
+
+      // Sanitize graph nodes
+      if (sanitized.graph?.nodes) {
+        sanitized.graph.nodes = sanitized.graph.nodes.map((node: any) => {
+          if (node.nodeId && node.nodeId.includes('kotlin-native-prebuilt::')) {
+            // Replace any architecture with macos-aarch64
+            node.nodeId = node.nodeId.replace(
+              /kotlin-native-prebuilt::[^@]+/,
+              'kotlin-native-prebuilt::macos-aarch64',
+            );
+          }
+          return node;
+        });
+      }
+
+      // Sanitize dependencies within nodes
+      if (sanitized.graph?.nodes) {
+        sanitized.graph.nodes.forEach((node: any) => {
+          if (node.deps) {
+            node.deps = node.deps.map((dep: any) => {
+              if (
+                dep.nodeId &&
+                dep.nodeId.includes('kotlin-native-prebuilt::')
+              ) {
+                dep.nodeId = dep.nodeId.replace(
+                  /kotlin-native-prebuilt::[^@]+/,
+                  'kotlin-native-prebuilt::macos-aarch64',
+                );
+              }
+              return dep;
+            });
+          }
+        });
+      }
+
+      return sanitized;
+    };
+
+    const expectSanitizedResult = (result: any, expectedDepGraphJson: any) => {
+      const sanitizedResult = sanitizeDepGraphForPlatform(
+        result.dependencyGraph?.toJSON() as DepGraphData,
+      );
+      expect(sanitizedResult).toEqual(expectedDepGraphJson);
+    };
+
+    testOrSkip(
+      'basic inspection',
+      async () => {
+        const fixturePath = getPathToFixture('kts-basic-gradle9');
+        const pathToBuildConfig = path.join(fixturePath, 'build.gradle.kts');
+        const expectedDepGraphJson = JSON.parse(
+          fs.readFileSync(`${fixturePath}/dep-graph.json`, 'utf8'),
+        );
+
+        const result = await inspect('.', pathToBuildConfig);
+        expectSanitizedResult(result, expectedDepGraphJson);
+      },
+      140000,
+    );
+
+    testOrSkip(
+      'gradleNormalizeDeps',
+      async () => {
+        jest.spyOn(search, 'getMavenPackageInfo').mockImplementation(
+          async (
+            _sha1: string,
+            depCoords: Partial<PomCoords>,
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _snykHttpClient: SnykHttpClient,
+          ) => {
+            const type = depCoords.type ?? '';
+            const classifier = depCoords.classifier
+              ? `:${depCoords.classifier}`
+              : '';
+            return `${depCoords.groupId}:${depCoords.artifactId}:${type}${classifier}@${depCoords.version}`;
+          },
+        );
+        const fixturePath = getPathToFixture('kts-basic-gradle9');
+        const pathToBuildConfig = path.join(fixturePath, 'build.gradle.kts');
+        const expectedDepGraphJson = JSON.parse(
+          fs.readFileSync(`${fixturePath}/dep-graph.json`, 'utf8'),
+        );
+
+        const result = await inspect('.', pathToBuildConfig, {
+          gradleNormalizeDeps: true,
+        });
+        expectSanitizedResult(result, expectedDepGraphJson);
+      },
+      140000,
+    );
+  });
 });

test/system/kotlin.test.ts

@@ -62,7 +62,7 @@ if (gradleVersionInUse < 5) {
     expectedDirectDependencies.forEach((expectedDependency) => {
       expect(directDependencies).toContainEqual(expectedDependency);
     });
-  }, 200000);
+  }, 220000);
 } else {
   test('build.gradle.kts files are supported with Gradle version >= 9', async () => {
     const result = await inspect(
@@ -113,5 +113,5 @@ if (gradleVersionInUse < 5) {
     expectedDirectDependencies.forEach((expectedDependency) => {
       expect(directDependencies).toContainEqual(expectedDependency);
     });
-  }, 200000);
+  }, 220000);
 }