diff --git a/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml b/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml index ab26b93f..c4571750 100644 --- a/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml +++ b/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml @@ -9,29 +9,30 @@ hamcrest = "3.0" junit-jupiter = "5.13.4" commons-cli = "1.10.0" -commons-collections4 = "4.5.0" -tinkergraph-gremlin = "4.0.0-beta.1" -gremlin-driver = "4.0.0-beta.1" +tinkergraph-gremlin = "3.7.7" antlr-runtime = "3.5.3" -log4j-api = "2.25.1" -log4j-core = "2.25.1" +log4j-api = "2.25.5" +log4j-core = "2.25.5" gson = "2.13.2" -guava = "33.4.8-jre" +guava = "33.8.0-jre" jsr305 = "3.0.2" json-simple = "1.1.1" reflections = "0.10.2" asm = "9.8" mockito-core = "5.19.0" mockito-junit-jupiter = "5.19.0" -netty-all = "4.1.127.Final" +# Versions below force patched releases of dependencies that arrive transitively (via gremlin-core). See sfge/build.gradle.kts. +commons-configuration2 = "2.15.1" +commons-beanutils = "1.11.0" +commons-lang3 = "3.21.0" +commons-text = "1.15.0" +snakeyaml = "2.7" [libraries] hamcrest = { module = "org.hamcrest:hamcrest", version.ref = "hamcrest" } junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit-jupiter" } commons-cli = { module = "commons-cli:commons-cli", version.ref = "commons-cli" } -commons-collections4 = { module = "org.apache.commons:commons-collections4", version.ref = "commons-collections4" } tinkergraph-gremlin = { module = "org.apache.tinkerpop:tinkergraph-gremlin", version.ref = "tinkergraph-gremlin" } -gremlin-driver = { module = "org.apache.tinkerpop:gremlin-driver", version.ref = "gremlin-driver" } antlr-runtime = { module = "org.antlr:antlr-runtime", version.ref = "antlr-runtime" } log4j-api = { module = "org.apache.logging.log4j:log4j-api", version.ref = "log4j-api" } log4j-core = { module = "org.apache.logging.log4j:log4j-core", version.ref = "log4j-core" } @@ -44,4 +45,8 @@ asm = { module = "org.ow2.asm:asm", version.ref = "asm" } junit-platform-launcher = { module = "org.junit.platform:junit-platform-launcher" } mockito-core = { module = "org.mockito:mockito-core", version.ref = "mockito-core" } mockito-junit-jupiter = { module = "org.mockito:mockito-junit-jupiter", version.ref = "mockito-junit-jupiter" } -netty-all = { module = "io.netty:netty-all", version.ref = "netty-all" } +commons-configuration2 = { module = "org.apache.commons:commons-configuration2", version.ref = "commons-configuration2" } +commons-beanutils = { module = "commons-beanutils:commons-beanutils", version.ref = "commons-beanutils" } +commons-lang3 = { module = "org.apache.commons:commons-lang3", version.ref = "commons-lang3" } +commons-text = { module = "org.apache.commons:commons-text", version.ref = "commons-text" } +snakeyaml = { module = "org.yaml:snakeyaml", version.ref = "snakeyaml" } diff --git a/packages/code-analyzer-sfge-engine/package.json b/packages/code-analyzer-sfge-engine/package.json index b9583ecc..2826a8d3 100644 --- a/packages/code-analyzer-sfge-engine/package.json +++ b/packages/code-analyzer-sfge-engine/package.json @@ -1,7 +1,7 @@ { "name": "@salesforce/code-analyzer-sfge-engine", "description": "Plugin package that adds 'Salesforce Graph Engine' as an engine into Salesforce Code Analyzer", - "version": "0.25.0", + "version": "0.26.0-SNAPSHOT", "author": "The Salesforce Code Analyzer Team", "license": "BSD-3-Clause", "homepage": "https://developer.salesforce.com/docs/platform/salesforce-code-analyzer/overview", diff --git a/packages/code-analyzer-sfge-engine/sfge/build.gradle.kts b/packages/code-analyzer-sfge-engine/sfge/build.gradle.kts index f5d29853..6f845512 100644 --- a/packages/code-analyzer-sfge-engine/sfge/build.gradle.kts +++ b/packages/code-analyzer-sfge-engine/sfge/build.gradle.kts @@ -21,9 +21,18 @@ repositories { // See https://docs.gradle.org/current/userguide/platforms.html#sub::toml-dependencies-format dependencies { implementation(libs.commons.cli) - implementation(libs.commons.collections4) - implementation(libs.tinkergraph.gremlin) - implementation(libs.gremlin.driver) + implementation(libs.tinkergraph.gremlin) { + // commons-collections 3.x (pulled in by commons-beanutils) has known vulnerabilities and no patched release. + // SFGE and the Gremlin graph layer do not use it, so it is removed from the classpath entirely. + exclude(group = "commons-collections", module = "commons-collections") + // gremlin-shaded bundles (relocated) copies of Jackson and Kryo that are only used for graph import/export + // (GraphSON/Gryo/GraphML). SFGE only builds and traverses an in-memory graph, and the bundled Jackson version + // contains known vulnerabilities that cannot be patched via dependency constraints, so we do not ship it. + exclude(group = "org.apache.tinkerpop", module = "gremlin-shaded") + } + // These are used directly by SFGE source (they previously arrived only transitively), so declare them explicitly. + implementation(libs.commons.lang3) + implementation(libs.commons.text) implementation(libs.antlr.runtime) implementation(libs.log4j.api) implementation(libs.log4j.core) @@ -35,9 +44,16 @@ dependencies { } implementation(libs.reflections) implementation(libs.asm) + // Force patched versions of transitive dependencies of gremlin-core (embedded in-memory graph). constraints { - implementation(libs.netty.all) { - because("Force specific version of transitive dependency") + implementation(libs.commons.configuration2) { + because("Patched version of a transitive dependency of gremlin-core") + } + implementation(libs.commons.beanutils) { + because("Patched version of a transitive dependency of gremlin-core") + } + implementation(libs.snakeyaml) { + because("Patched version of a transitive dependency of gremlin-core") } } implementation(files("lib/apex-jorje-lsp-sfge.jar")) @@ -71,11 +87,54 @@ tasks.jar { tasks.register("copyDependencies") { from(configurations.runtimeClasspath) // This includes all runtime dependencies into(javaLibDir) // Target directory for dependencies + // The directory is also the output of the jar task (sfge-*.jar), so we can't use Sync. Instead, remove any stale + // dependency jars left over from earlier builds (e.g. ones since removed from the runtime classpath) so that an + // incremental build packs exactly the same dependency set as a clean build. + doFirst { + delete(fileTree(javaLibDir) { exclude("sfge-*.jar") }) + } } tasks.build { dependsOn("copyDependencies") // Ensure dependencies are copied during the build process } +// Fail the build if a library that is known to carry unpatchable vulnerabilities (or that SFGE has no need for) sneaks +// back onto the runtime classpath, e.g., through a Gremlin upgrade. Everything on the runtime classpath gets shipped. +val bannedRuntimeDependencies = mapOf( + "io.netty" to "Only needed by gremlin-driver (remote Gremlin client), which SFGE does not use", + "software.amazon.awssdk" to "Only needed by gremlin-driver (remote Gremlin client), which SFGE does not use", + "org.apache.tinkerpop:gremlin-driver" to "SFGE only uses the embedded in-memory graph", + "org.apache.tinkerpop:gremlin-util" to "SFGE only uses the embedded in-memory graph", + "org.apache.tinkerpop:gremlin-shaded" to "Bundles Jackson/Kryo with known vulnerabilities that cannot be patched via constraints", + "commons-collections:commons-collections" to "3.x has known vulnerabilities and no patched release", + "org.apache.commons:commons-collections4" to "SFGE does not use it (the NonNull* collections are plain Java/Guava); sonatype-2024-3350 flags SetUniqueList in it" +) +tasks.register("verifyNoBannedDependencies") { + group = "verification" + description = "Fails if a banned dependency is on the runtime classpath (and therefore would be shipped)." + val resolvedModules = configurations.runtimeClasspath.map { config -> + config.incoming.resolutionResult.allComponents + .mapNotNull { it.moduleVersion } + .map { "${it.group}:${it.name}:${it.version}" } + } + doLast { + val violations = resolvedModules.get().flatMap { coordinates -> + val (group, name) = coordinates.split(":") + bannedRuntimeDependencies.filter { (banned, _) -> banned == group || banned == "$group:$name" } + .map { (_, reason) -> "$coordinates -> $reason" } + } + if (violations.isNotEmpty()) { + throw GradleException("Banned dependencies found on the runtime classpath:\n " + violations.joinToString("\n ")) + } + } +} +tasks.check { + dependsOn("verifyNoBannedDependencies") +} +tasks.build { + dependsOn("verifyNoBannedDependencies") +} + // ======== TEST RELATED TASKS ========================================================================================= jacoco { diff --git a/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullArrayList.java b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullArrayList.java index 0b597205..acb22027 100644 --- a/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullArrayList.java +++ b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullArrayList.java @@ -1,13 +1,11 @@ package com.salesforce.collections; import java.util.ArrayList; -import org.apache.commons.collections4.PredicateUtils; -import org.apache.commons.collections4.list.PredicatedList; /** An ArrayList that doesn't allow null values */ -public class NonNullArrayList extends PredicatedList { +public class NonNullArrayList extends NullRejectingList { private NonNullArrayList(ArrayList list) { - super(list, PredicateUtils.notNullPredicate()); + super(list); } static NonNullArrayList newInstance() { diff --git a/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullGuard.java b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullGuard.java new file mode 100644 index 00000000..dc61330a --- /dev/null +++ b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullGuard.java @@ -0,0 +1,20 @@ +package com.salesforce.collections; + +/** Rejects null values for the NonNull* collections. Throws the same exception type for every write path. */ +final class NonNullGuard { + private NonNullGuard() {} + + static T check(T item) { + if (item == null) { + throw new IllegalArgumentException("Null is not allowed in this collection"); + } + return item; + } + + /** Checks everything up front so that a rejected bulk operation leaves the collection unchanged. */ + static void checkAll(Iterable items) { + for (Object item : items) { + check(item); + } + } +} diff --git a/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullHashMap.java b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullHashMap.java index 9a8ca301..060f072c 100644 --- a/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullHashMap.java +++ b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullHashMap.java @@ -1,16 +1,96 @@ package com.salesforce.collections; +import com.google.common.collect.ForwardingMap; +import com.google.common.collect.ForwardingMapEntry; +import com.google.common.collect.ForwardingSet; +import com.google.common.collect.Iterators; import java.util.HashMap; -import org.apache.commons.collections4.PredicateUtils; -import org.apache.commons.collections4.map.PredicatedMap; +import java.util.Iterator; +import java.util.Map; +import java.util.Set; + +/** + * A HashMap that doesn't allow null keys or values. The default Map methods (putIfAbsent, merge, compute, replace, + * ...) write through {@link #put}, and replaceAll writes through the entries returned by {@link #entrySet()}, so + * guarding those two covers every write path. + */ +public class NonNullHashMap extends ForwardingMap { + private final HashMap delegate; -/** A HashMap that doesn't allow null keys or values */ -public class NonNullHashMap extends PredicatedMap { private NonNullHashMap(HashMap map) { - super(map, PredicateUtils.notNullPredicate(), PredicateUtils.notNullPredicate()); + this.delegate = map; } static NonNullHashMap newInstance() { return new NonNullHashMap<>(new HashMap<>()); } + + @Override + protected Map delegate() { + return delegate; + } + + @Override + public V put(K key, V value) { + return super.put(NonNullGuard.check(key), NonNullGuard.check(value)); + } + + @Override + public void putAll(Map map) { + NonNullGuard.checkAll(map.keySet()); + NonNullGuard.checkAll(map.values()); + super.putAll(map); + } + + @Override + public Set> entrySet() { + return new NullRejectingEntrySet<>(super.entrySet()); + } + + private static final class NullRejectingEntrySet extends ForwardingSet> { + private final Set> delegate; + + NullRejectingEntrySet(Set> delegate) { + this.delegate = delegate; + } + + @Override + protected Set> delegate() { + return delegate; + } + + @Override + public Iterator> iterator() { + return Iterators.transform(delegate.iterator(), NullRejectingEntry::new); + } + + // The inherited toArray methods would hand out the underlying (unguarded) entries. + @Override + public Object[] toArray() { + return standardToArray(); + } + + @Override + public T[] toArray(T[] array) { + return standardToArray(array); + } + } + + private static final class NullRejectingEntry extends ForwardingMapEntry { + private final Map.Entry delegate; + + NullRejectingEntry(Map.Entry delegate) { + this.delegate = delegate; + } + + @Override + protected Map.Entry delegate() { + return delegate; + } + + @Override + public V setValue(V value) { + return super.setValue(NonNullGuard.check(value)); + } + } } diff --git a/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullHashSet.java b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullHashSet.java index 99b725a4..41d84309 100644 --- a/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullHashSet.java +++ b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullHashSet.java @@ -1,16 +1,35 @@ package com.salesforce.collections; +import com.google.common.collect.ForwardingSet; +import java.util.Collection; import java.util.HashSet; -import org.apache.commons.collections4.PredicateUtils; -import org.apache.commons.collections4.set.PredicatedSet; +import java.util.Set; /** An HashSet that doesn't allow null values */ -public class NonNullHashSet extends PredicatedSet { +public class NonNullHashSet extends ForwardingSet { + private final HashSet delegate; + private NonNullHashSet(HashSet set) { - super(set, PredicateUtils.notNullPredicate()); + this.delegate = set; } static NonNullHashSet newInstance() { return new NonNullHashSet<>(new HashSet<>()); } + + @Override + protected Set delegate() { + return delegate; + } + + @Override + public boolean add(E element) { + return super.add(NonNullGuard.check(element)); + } + + @Override + public boolean addAll(Collection collection) { + NonNullGuard.checkAll(collection); + return super.addAll(collection); + } } diff --git a/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NullRejectingList.java b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NullRejectingList.java new file mode 100644 index 00000000..c9c4be51 --- /dev/null +++ b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NullRejectingList.java @@ -0,0 +1,89 @@ +package com.salesforce.collections; + +import com.google.common.collect.ForwardingList; +import com.google.common.collect.ForwardingListIterator; +import java.util.Collection; +import java.util.List; +import java.util.ListIterator; + +/** + * A List view that rejects nulls on every write path, including the ones that bypass add/set: list iterators (which + * is also what {@link List#replaceAll} and {@link List#sort} write through) and sub lists. + */ +class NullRejectingList extends ForwardingList { + private final List delegate; + + NullRejectingList(List delegate) { + this.delegate = delegate; + } + + @Override + protected List delegate() { + return delegate; + } + + @Override + public boolean add(E element) { + return super.add(NonNullGuard.check(element)); + } + + @Override + public void add(int index, E element) { + super.add(index, NonNullGuard.check(element)); + } + + @Override + public boolean addAll(Collection collection) { + NonNullGuard.checkAll(collection); + return super.addAll(collection); + } + + @Override + public boolean addAll(int index, Collection elements) { + NonNullGuard.checkAll(elements); + return super.addAll(index, elements); + } + + @Override + public E set(int index, E element) { + return super.set(index, NonNullGuard.check(element)); + } + + @Override + public ListIterator listIterator() { + return new NullRejectingListIterator<>(super.listIterator()); + } + + @Override + public ListIterator listIterator(int index) { + return new NullRejectingListIterator<>(super.listIterator(index)); + } + + @Override + public List subList(int fromIndex, int toIndex) { + return new NullRejectingList<>(super.subList(fromIndex, toIndex)); + } + + private static final class NullRejectingListIterator extends ForwardingListIterator { + private final ListIterator delegate; + + NullRejectingListIterator(ListIterator delegate) { + this.delegate = delegate; + } + + @Override + protected ListIterator delegate() { + return delegate; + } + + @Override + public void add(E element) { + super.add(NonNullGuard.check(element)); + } + + @Override + public void set(E element) { + super.set(NonNullGuard.check(element)); + } + } +} diff --git a/packages/code-analyzer-sfge-engine/sfge/src/main/java/org/apache/tinkerpop/shaded/jackson/core/JsonProcessingException.java b/packages/code-analyzer-sfge-engine/sfge/src/main/java/org/apache/tinkerpop/shaded/jackson/core/JsonProcessingException.java new file mode 100644 index 00000000..300ba775 --- /dev/null +++ b/packages/code-analyzer-sfge-engine/sfge/src/main/java/org/apache/tinkerpop/shaded/jackson/core/JsonProcessingException.java @@ -0,0 +1,23 @@ +package org.apache.tinkerpop.shaded.jackson.core; + +import java.io.IOException; + +/** + * Minimal stand-in for the relocated Jackson exception type that {@code TinkerGraph} references in a {@code catch} + * clause. + * + *

Why this exists: {@code gremlin-shaded} bundles (relocated) copies of Jackson and Kryo. The Jackson version it + * bundles contains known vulnerabilities that cannot be fixed with dependency constraints, and SFGE does not use it + * since SFGE only builds and traverses an in-memory graph (no GraphSON/Gryo/GraphML import or export). So we exclude + * {@code gremlin-shaded} from the runtime classpath (see {@code build.gradle.kts}). However, the JVM must still be able + * to load this one exception class when it verifies {@code TinkerGraph}, even though no Jackson code ever runs. + * + *

This class intentionally contains no Jackson code. Remove it (and re-evaluate the {@code gremlin-shaded} exclusion) + * when upgrading to a Gremlin release whose bundled Jackson is patched. {@code NoVulnerableBundledLibrariesTest} + * guards this behavior. + */ +public class JsonProcessingException extends IOException { + public JsonProcessingException(String message) { + super(message); + } +} diff --git a/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullArrayListTest.java b/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullArrayListTest.java new file mode 100644 index 00000000..484d5aec --- /dev/null +++ b/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullArrayListTest.java @@ -0,0 +1,105 @@ +package com.salesforce.collections; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.*; +import java.util.stream.Collectors; +import org.junit.jupiter.api.Test; + +/** Pins the behavior callers rely on: nulls are rejected with IllegalArgumentException on every path. */ +public class NonNullArrayListTest { + private static NonNullArrayList listOf(String... items) { + NonNullArrayList list = NonNullArrayList.newInstance(); + list.addAll(Arrays.asList(items)); + return list; + } + + @Test + public void nullsAreRejectedOnEveryMutatingPath() { + NonNullArrayList list = listOf("a", "b"); + assertThrows(IllegalArgumentException.class, () -> list.add(null)); + assertThrows(IllegalArgumentException.class, () -> list.add(1, null)); + assertThrows(IllegalArgumentException.class, () -> list.set(0, null)); + assertThrows(IllegalArgumentException.class, () -> list.addAll(Arrays.asList("c", null))); + assertThrows(IllegalArgumentException.class, () -> list.addAll(1, Arrays.asList("c", null))); + assertThrows(IllegalArgumentException.class, () -> list.replaceAll(s -> null)); + assertThrows(IllegalArgumentException.class, () -> list.listIterator().add(null)); + assertThrows( + IllegalArgumentException.class, + () -> { + ListIterator it = list.listIterator(); + it.next(); + it.set(null); + }); + assertThrows(IllegalArgumentException.class, () -> list.subList(0, 1).add(null)); + assertThrows(IllegalArgumentException.class, () -> list.subList(0, 1).set(0, null)); + assertEquals(Arrays.asList("a", "b"), list, "a rejected write must not change the list"); + } + + @Test + public void rejectedAddAllLeavesListUnchanged() { + NonNullArrayList list = listOf("a"); + assertThrows(IllegalArgumentException.class, () -> list.addAll(Arrays.asList("b", null, "c"))); + assertEquals(Collections.singletonList("a"), list); + } + + @Test + public void validOperationsBehaveLikeArrayList() { + NonNullArrayList list = listOf("b", "a"); + list.add("c"); + list.add(0, "z"); + list.set(1, "y"); + assertEquals(Arrays.asList("z", "y", "a", "c"), list); + assertEquals(4, list.size()); + assertFalse(list.isEmpty()); + assertTrue(list.contains("a")); + assertEquals(2, list.indexOf("a")); + assertEquals("a", list.get(2)); + assertEquals("a", list.remove(2)); + assertTrue(list.remove("z")); + list.sort(Comparator.naturalOrder()); + assertEquals(Arrays.asList("c", "y"), list); + list.replaceAll(String::toUpperCase); + assertEquals(Arrays.asList("C", "Y"), list); + list.removeIf(s -> s.equals("C")); + assertEquals(Collections.singletonList("Y"), list); + assertEquals(Collections.singletonList("Y"), list.stream().collect(Collectors.toList())); + list.clear(); + assertTrue(list.isEmpty()); + } + + @Test + public void nullQueriesDoNotThrow() { + NonNullArrayList list = listOf("a"); + assertFalse(list.contains(null)); + assertEquals(-1, list.indexOf(null)); + assertFalse(list.remove(null)); + } + + @Test + public void equalsHashCodeAndToStringMatchPlainList() { + NonNullArrayList list = listOf("a", "b"); + List plain = new ArrayList<>(Arrays.asList("a", "b")); + assertEquals(plain, list); + assertEquals(list, plain); + assertEquals(list, listOf("a", "b")); + assertNotEquals(list, listOf("a")); + assertEquals(plain.hashCode(), list.hashCode()); + assertEquals(plain.toString(), list.toString()); + } + + @Test + public void iteratorRemoveAndUnmodifiableViewWork() { + NonNullArrayList list = listOf("a", "b", "c"); + Iterator it = list.iterator(); + it.next(); + it.remove(); + assertEquals(Arrays.asList("b", "c"), list); + List view = Collections.unmodifiableList(list); + assertThrows(UnsupportedOperationException.class, () -> view.add("d")); + assertEquals(Arrays.asList("b", "c"), view); + List sub = list.subList(0, 1); + sub.add("x"); + assertEquals(Arrays.asList("b", "x", "c"), list); + } +} diff --git a/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullHashMapTest.java b/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullHashMapTest.java new file mode 100644 index 00000000..46240aee --- /dev/null +++ b/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullHashMapTest.java @@ -0,0 +1,91 @@ +package com.salesforce.collections; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.*; +import org.junit.jupiter.api.Test; + +public class NonNullHashMapTest { + private static NonNullHashMap mapOf(String... kvs) { + NonNullHashMap map = NonNullHashMap.newInstance(); + for (int i = 0; i < kvs.length; i += 2) { + map.put(kvs[i], kvs[i + 1]); + } + return map; + } + + @Test + public void nullKeysAndValuesAreRejectedOnEveryMutatingPath() { + NonNullHashMap map = mapOf("a", "1"); + assertThrows(IllegalArgumentException.class, () -> map.put(null, "x")); + assertThrows(IllegalArgumentException.class, () -> map.put("x", null)); + assertThrows(IllegalArgumentException.class, () -> map.put("a", null)); + assertThrows(IllegalArgumentException.class, () -> map.putIfAbsent("x", null)); + assertThrows(IllegalArgumentException.class, () -> map.putIfAbsent(null, "x")); + assertThrows(IllegalArgumentException.class, () -> map.replace("a", null)); + assertThrows(IllegalArgumentException.class, () -> map.replaceAll((k, v) -> null)); + assertThrows(IllegalArgumentException.class, () -> map.computeIfAbsent(null, k -> "x")); + assertThrows(IllegalArgumentException.class, () -> map.compute(null, (k, v) -> "x")); + assertThrows(IllegalArgumentException.class, () -> map.merge(null, "x", (o, n) -> n)); + assertThrows( + IllegalArgumentException.class, + () -> map.entrySet().iterator().next().setValue(null)); + Map bad = new HashMap<>(); + bad.put("ok", "1"); + bad.put("bad", null); + assertThrows(IllegalArgumentException.class, () -> map.putAll(bad)); + assertEquals(Collections.singletonMap("a", "1"), map, "a rejected write must not change the map"); + } + + @Test + public void validOperationsBehaveLikeHashMap() { + NonNullHashMap map = mapOf("a", "1", "b", "2"); + assertEquals("1", map.put("a", "10")); + assertNull(map.put("c", "3")); + assertEquals(3, map.size()); + assertEquals("10", map.get("a")); + assertTrue(map.containsKey("c")); + assertTrue(map.containsValue("3")); + assertEquals("3", map.remove("c")); + assertEquals(new HashSet<>(Arrays.asList("a", "b")), map.keySet()); + assertEquals(new HashSet<>(Arrays.asList("10", "2")), new HashSet<>(map.values())); + map.putAll(Collections.singletonMap("d", "4")); + assertEquals("4", map.get("d")); + map.entrySet().stream().filter(e -> e.getKey().equals("d")).forEach(e -> e.setValue("40")); + assertEquals("40", map.get("d")); + map.replaceAll((k, v) -> v + "!"); + assertEquals("10!", map.get("a")); + assertEquals("99", map.computeIfAbsent("z", k -> "99")); + assertEquals("98", map.merge("z", "98", (o, n) -> n)); + assertNull(map.compute("z", (k, v) -> null)); + assertFalse(map.containsKey("z")); + assertNull(map.putIfAbsent("p", "q")); + assertEquals("q", map.putIfAbsent("p", "r")); + map.clear(); + assertTrue(map.isEmpty()); + } + + @Test + public void nullQueriesDoNotThrow() { + NonNullHashMap map = mapOf("a", "1"); + assertNull(map.get(null)); + assertFalse(map.containsKey(null)); + assertFalse(map.containsValue(null)); + assertNull(map.remove(null)); + } + + @Test + public void equalsHashCodeAndToStringMatchPlainMap() { + NonNullHashMap map = mapOf("a", "1", "b", "2"); + Map plain = new HashMap<>(); + plain.put("a", "1"); + plain.put("b", "2"); + assertEquals(plain, map); + assertEquals(map, plain); + assertEquals(map, mapOf("b", "2", "a", "1")); + assertNotEquals(map, mapOf("a", "1")); + assertEquals(plain.hashCode(), map.hashCode()); + assertEquals(plain.toString(), map.toString()); + assertThrows(UnsupportedOperationException.class, () -> Collections.unmodifiableMap(map).put("x", "y")); + } +} diff --git a/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullHashSetTest.java b/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullHashSetTest.java new file mode 100644 index 00000000..9bb21db1 --- /dev/null +++ b/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullHashSetTest.java @@ -0,0 +1,63 @@ +package com.salesforce.collections; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.*; +import java.util.stream.Collectors; +import org.junit.jupiter.api.Test; + +public class NonNullHashSetTest { + private static NonNullHashSet setOf(String... items) { + NonNullHashSet set = NonNullHashSet.newInstance(); + set.addAll(Arrays.asList(items)); + return set; + } + + @Test + public void nullsAreRejectedOnEveryMutatingPath() { + NonNullHashSet set = setOf("a", "b"); + assertThrows(IllegalArgumentException.class, () -> set.add(null)); + assertThrows(IllegalArgumentException.class, () -> set.addAll(Arrays.asList("c", null))); + assertEquals(new HashSet<>(Arrays.asList("a", "b")), set, "a rejected write must not change the set"); + } + + @Test + public void validOperationsBehaveLikeHashSet() { + NonNullHashSet set = setOf("a", "b"); + assertFalse(set.add("a")); + assertTrue(set.add("c")); + assertEquals(3, set.size()); + assertTrue(set.contains("c")); + assertFalse(set.isEmpty()); + assertTrue(set.remove("c")); + set.removeIf(s -> s.equals("a")); + assertEquals(Collections.singleton("b"), set); + assertEquals(Collections.singletonList("b"), set.stream().collect(Collectors.toList())); + Iterator it = set.iterator(); + it.next(); + it.remove(); + assertTrue(set.isEmpty()); + set.add("x"); + set.clear(); + assertTrue(set.isEmpty()); + } + + @Test + public void nullQueriesDoNotThrow() { + NonNullHashSet set = setOf("a"); + assertFalse(set.contains(null)); + assertFalse(set.remove(null)); + } + + @Test + public void equalsHashCodeAndToStringMatchPlainSet() { + NonNullHashSet set = setOf("a", "b"); + Set plain = new HashSet<>(Arrays.asList("a", "b")); + assertEquals(plain, set); + assertEquals(set, plain); + assertEquals(set, setOf("b", "a")); + assertNotEquals(set, setOf("a")); + assertEquals(plain.hashCode(), set.hashCode()); + assertEquals(plain.toString(), set.toString()); + } +} diff --git a/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/graph/ops/NoVulnerableBundledLibrariesTest.java b/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/graph/ops/NoVulnerableBundledLibrariesTest.java new file mode 100644 index 00000000..679f3532 --- /dev/null +++ b/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/graph/ops/NoVulnerableBundledLibrariesTest.java @@ -0,0 +1,43 @@ +package com.salesforce.graph.ops; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.junit.jupiter.api.Test; + +/** + * Guards the dependency-hygiene decisions documented in {@code build.gradle.kts}: SFGE only needs an in-memory + * TinkerGraph, and must not ship libraries that carry known vulnerabilities. + */ +public class NoVulnerableBundledLibrariesTest { + @Test + public void inMemoryGraphWorksWithoutGremlinShaded() { + // Fails with NoClassDefFoundError if TinkerGraph needs anything from gremlin-shaded beyond what we provide. + assertNotNull(GraphUtil.getGraph()); + } + + @Test + public void gremlinShadedJacksonImplementationIsNotOnClasspath() { + assertThrows( + ClassNotFoundException.class, + () -> Class.forName("org.apache.tinkerpop.shaded.jackson.databind.ObjectMapper")); + assertThrows( + ClassNotFoundException.class, + () -> Class.forName("org.apache.tinkerpop.shaded.jackson.core.JsonFactory")); + } + + @Test + public void commonsCollections3IsNotOnClasspath() { + assertThrows( + ClassNotFoundException.class, + () -> Class.forName("org.apache.commons.collections.FastHashMap")); + } + + @Test + public void nettyAndGremlinDriverAreNotOnClasspath() { + assertThrows(ClassNotFoundException.class, () -> Class.forName("io.netty.channel.Channel")); + assertThrows( + ClassNotFoundException.class, + () -> Class.forName("org.apache.tinkerpop.gremlin.driver.Cluster")); + } +}