From dd4ee72491895ea3eba9ef385025ba52cb5c9a81 Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Fri, 13 Feb 2026 14:38:37 +0000 Subject: [PATCH 01/26] Revert "Fix double in" This reverts commit 986d878a6f07483326b256baa3556aaecffc632f. --- .../da/listings/impl/dao/ArtifactDAOImpl.java | 2 +- .../listings/AbstractRestApiListingTest.java | 2 +- .../test/client/rest/lookup/LookupTestIT.java | 4 +-- .../rest/lookup/LookupTestITBlocklist.java | 34 ------------------- .../lookup/maven/guava13Blocklist.json | 8 ----- .../lookup/maven/guava13Blocklist.json | 11 ------ 6 files changed, 3 insertions(+), 58 deletions(-) delete mode 100644 testsuite/src/test/java/org/jboss/da/test/client/rest/lookup/LookupTestITBlocklist.java delete mode 100644 testsuite/src/test/rest/v-1/expectedResponse/lookup/maven/guava13Blocklist.json delete mode 100644 testsuite/src/test/rest/v-1/request/lookup/maven/guava13Blocklist.json diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ArtifactDAOImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ArtifactDAOImpl.java index 663d18f32..8a8f25830 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ArtifactDAOImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ArtifactDAOImpl.java @@ -51,7 +51,7 @@ public List findArtifact(Set gas) { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery cq = cb.createQuery(type); Root artifact = cq.from(type); - cq.select(artifact).where(artifact.get("ga").in(gas)); + cq.select(artifact).where(cb.in(artifact.get("ga").in(gas))); TypedQuery q = em.createQuery(cq); return q.getResultList(); } diff --git a/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/AbstractRestApiListingTest.java b/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/AbstractRestApiListingTest.java index 142d7f768..979b95a64 100644 --- a/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/AbstractRestApiListingTest.java +++ b/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/AbstractRestApiListingTest.java @@ -34,7 +34,7 @@ protected enum OperationType { protected static final String PATH_BLACK_LIST = "/listings/blacklist"; - public static final String PATH_BLACK_LISTINGS_GAV = "/listings/blacklist/gav"; + protected static final String PATH_BLACK_LISTINGS_GAV = "/listings/blacklist/gav"; protected static final String PATH_BLACK_LISTINGS_GA = "/listings/blacklist/ga"; diff --git a/testsuite/src/test/java/org/jboss/da/test/client/rest/lookup/LookupTestIT.java b/testsuite/src/test/java/org/jboss/da/test/client/rest/lookup/LookupTestIT.java index 3326655e6..ad371d202 100644 --- a/testsuite/src/test/java/org/jboss/da/test/client/rest/lookup/LookupTestIT.java +++ b/testsuite/src/test/java/org/jboss/da/test/client/rest/lookup/LookupTestIT.java @@ -1,17 +1,15 @@ package org.jboss.da.test.client.rest.lookup; -import javax.ws.rs.client.Entity; import javax.ws.rs.core.Response; import org.jboss.da.test.client.rest.AbstractRestReportsTest; import org.junit.Test; -import static org.jboss.da.test.client.rest.listings.AbstractRestApiListingTest.PATH_BLACK_LISTINGS_GAV; import static org.junit.Assert.assertEquals; public class LookupTestIT extends AbstractRestReportsTest { - static final String PATH_LOOKUP_MAVEN = "/lookup/maven"; + private static final String PATH_LOOKUP_MAVEN = "/lookup/maven"; private static final String PATH_LATEST_MAVEN = "/lookup/maven/latest"; private static final String PATH_MAVEN_VERSIONS = "/lookup/maven/versions"; diff --git a/testsuite/src/test/java/org/jboss/da/test/client/rest/lookup/LookupTestITBlocklist.java b/testsuite/src/test/java/org/jboss/da/test/client/rest/lookup/LookupTestITBlocklist.java deleted file mode 100644 index c61efa0c2..000000000 --- a/testsuite/src/test/java/org/jboss/da/test/client/rest/lookup/LookupTestITBlocklist.java +++ /dev/null @@ -1,34 +0,0 @@ -package org.jboss.da.test.client.rest.lookup; - -import org.jboss.da.test.client.rest.AbstractRestReportsTest; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; - -import javax.ws.rs.client.Entity; -import javax.ws.rs.core.Response; - -import static org.jboss.da.test.client.rest.listings.AbstractRestApiListingTest.PATH_BLACK_LISTINGS_GAV; -import static org.jboss.da.test.client.rest.lookup.LookupTestIT.PATH_LOOKUP_MAVEN; -import static org.junit.Assert.assertEquals; - -public class LookupTestITBlocklist extends AbstractRestReportsTest { - - @Before - public void prepareBlocklist() { - String blocklist = "{\"groupId\":\"com.google.guava\",\"artifactId\":\"guava\",\"version\":\"13.0.1-redhat-2\"}"; - createClientRequest(PATH_BLACK_LISTINGS_GAV).post(Entity.json(blocklist)).close(); - } - - @Test - public void testGavLookupSingleWithBlocklist() throws Exception { - Response response = assertResponseForRequest(PATH_LOOKUP_MAVEN, "guava13Blocklist"); - assertEquals(200, response.getStatus()); - } - - @After - public void cleanBlocklist() { - String blocklist = "{\"groupId\":\"com.google.guava\",\"artifactId\":\"guava\",\"version\":\"13.0.1-redhat-2\"}"; - createClientRequest(PATH_BLACK_LISTINGS_GAV).method("DELTE", Entity.json(blocklist)).close(); - } -} diff --git a/testsuite/src/test/rest/v-1/expectedResponse/lookup/maven/guava13Blocklist.json b/testsuite/src/test/rest/v-1/expectedResponse/lookup/maven/guava13Blocklist.json deleted file mode 100644 index 65771305a..000000000 --- a/testsuite/src/test/rest/v-1/expectedResponse/lookup/maven/guava13Blocklist.json +++ /dev/null @@ -1,8 +0,0 @@ -[ - { - "bestMatchVersion": "13.0.1-redhat-1", - "groupId": "com.google.guava", - "artifactId": "guava", - "version": "13.0.1" - } -] diff --git a/testsuite/src/test/rest/v-1/request/lookup/maven/guava13Blocklist.json b/testsuite/src/test/rest/v-1/request/lookup/maven/guava13Blocklist.json deleted file mode 100644 index 2e1c5db7f..000000000 --- a/testsuite/src/test/rest/v-1/request/lookup/maven/guava13Blocklist.json +++ /dev/null @@ -1,11 +0,0 @@ -{ - "artifacts": [ - { - "groupId": "com.google.guava", - "artifactId": "guava", - "version": "13.0.1" - } - ], - "mode": "PERSISTENT", - "brewPullActive": true -} \ No newline at end of file From 7dc94134fb3a6eebeb1aeaf3bdbc7c579c331472 Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Fri, 13 Feb 2026 14:38:44 +0000 Subject: [PATCH 02/26] Revert "Update Javadoc" This reverts commit 444a43693749b5dcaaf95686da7a8975b4e788e6. --- .../jboss/da/listings/api/dao/ArtifactDAO.java | 6 ------ .../org/jboss/da/listings/api/dao/GADAO.java | 7 ++++--- .../api/service/BlackArtifactService.java | 16 ---------------- 3 files changed, 4 insertions(+), 25 deletions(-) diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ArtifactDAO.java b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ArtifactDAO.java index 27262f125..f5334d186 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ArtifactDAO.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ArtifactDAO.java @@ -24,12 +24,6 @@ public interface ArtifactDAO extends GenericDAO { */ Optional findArtifact(String groupId, String artifactId, String version); - /** - * Find all artifacts that have group id and artifact id matching one from the provided set. - * - * @param gas Set of Group ids and artifact ids of desired artifacts. - * @return List of found artifacts. - */ List findArtifact(Set gas); /** diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/GADAO.java b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/GADAO.java index 4184ef9d5..06301530b 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/GADAO.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/GADAO.java @@ -27,10 +27,11 @@ public interface GADAO extends GenericDAO { Optional findGA(String groupId, String artifactId); /** - * Finds GA with specific groupId and artifactId from the provided set. + * Finds GA with specific groupId and artifactId * - * @param gas Set of group ids and artifact ids to search. - * @return List of found GAss. + * @param groupId + * @param artifactId + * @return Optional of GA */ Set findGAs(Set gas); diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/service/BlackArtifactService.java b/reports-backend/src/main/java/org/jboss/da/listings/api/service/BlackArtifactService.java index 35ad91a09..378fec974 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/service/BlackArtifactService.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/service/BlackArtifactService.java @@ -71,23 +71,7 @@ public interface BlackArtifactService extends ArtifactService { public Set getArtifacts(String groupId, String artifactId); - /** - * Fetches all artifacts from blocklist, that have GA matching one of the provided GAs. - * - * @param gas Set of GAs to find in blocklist. - * @return Set of blocklisted artifacts. - */ Set prefetchGAs(Set gas); - /** - * Checks if given GA + version is blocklisted in the provided set of GAVs (obtained using - * {@link BlackArtifactService#prefetchGAs(Set)}). The same transformations as in - * {@link BlackArtifactService#getArtifact(GAV)} are performed with the version when looking for the artifact. - * - * @param cache Cache of blocklisted GAVs, obtained using {@link BlackArtifactService#prefetchGAs(Set)} - * @param ga Group Id + Artifact Id to check in the blocklist. - * @param version Version to check in the blocklist. - * @return True, if the GA + version is present in the blocklist. - */ boolean isBlocklisted(Set cache, GA ga, QualifiedVersion version); } From 6f2079370882f0882124a461726856579a782fc0 Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Fri, 13 Feb 2026 14:38:45 +0000 Subject: [PATCH 03/26] Revert "[NCLSUP-1016] Optimize blocklist querying" This reverts commit bf4d80a6ad804eac469781b68269f8fa8049c6d5. --- .../da/listings/api/dao/ArtifactDAO.java | 4 -- .../org/jboss/da/listings/api/dao/GADAO.java | 10 ----- .../jboss/da/listings/api/model/Artifact.java | 5 --- .../api/service/BlackArtifactService.java | 6 --- .../da/listings/impl/dao/ArtifactDAOImpl.java | 11 ------ .../jboss/da/listings/impl/dao/GADAOImpl.java | 39 ------------------- .../service/BlackArtifactServiceImpl.java | 26 ------------- .../da/reports/impl/LookupGeneratorImpl.java | 10 ++--- 8 files changed, 5 insertions(+), 106 deletions(-) diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ArtifactDAO.java b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ArtifactDAO.java index f5334d186..8322ba09f 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ArtifactDAO.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ArtifactDAO.java @@ -2,10 +2,8 @@ import java.util.List; import java.util.Optional; -import java.util.Set; import org.jboss.da.listings.api.model.Artifact; -import org.jboss.da.listings.api.model.GA; /** * @@ -24,8 +22,6 @@ public interface ArtifactDAO extends GenericDAO { */ Optional findArtifact(String groupId, String artifactId, String version); - List findArtifact(Set gas); - /** * Finds and return all artifacts. * diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/GADAO.java b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/GADAO.java index 06301530b..6574e9a39 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/GADAO.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/GADAO.java @@ -4,7 +4,6 @@ import java.util.List; import java.util.Optional; -import java.util.Set; public interface GADAO extends GenericDAO { @@ -26,15 +25,6 @@ public interface GADAO extends GenericDAO { */ Optional findGA(String groupId, String artifactId); - /** - * Finds GA with specific groupId and artifactId - * - * @param groupId - * @param artifactId - * @return Optional of GA - */ - Set findGAs(Set gas); - /** * Finds all GA * diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/model/Artifact.java b/reports-backend/src/main/java/org/jboss/da/listings/api/model/Artifact.java index a4dd9730e..e2107307b 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/model/Artifact.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/model/Artifact.java @@ -11,7 +11,6 @@ import lombok.RequiredArgsConstructor; import lombok.Setter; import lombok.ToString; -import org.jboss.da.model.rest.GAV; /** * @author Jozef Mrazek <jmrazek@redhat.com> @@ -43,8 +42,4 @@ public class Artifact extends GenericEntity { public String gav() { return ga.getGroupId() + ":" + ga.getArtifactId() + ":" + version; } - - public GAV toGAV() { - return new GAV(ga.getGroupId(), ga.getArtifactId(), version); - } } diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/service/BlackArtifactService.java b/reports-backend/src/main/java/org/jboss/da/listings/api/service/BlackArtifactService.java index 378fec974..fce24b35a 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/service/BlackArtifactService.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/service/BlackArtifactService.java @@ -3,9 +3,7 @@ import java.util.Optional; import org.jboss.da.listings.api.model.BlackArtifact; -import org.jboss.da.model.rest.GA; import org.jboss.da.model.rest.GAV; -import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; import java.util.Set; @@ -70,8 +68,4 @@ public interface BlackArtifactService extends ArtifactService { public boolean removeArtifact(String groupId, String artifactId, String version); public Set getArtifacts(String groupId, String artifactId); - - Set prefetchGAs(Set gas); - - boolean isBlocklisted(Set cache, GA ga, QualifiedVersion version); } diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ArtifactDAOImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ArtifactDAOImpl.java index 8a8f25830..170bcf5fc 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ArtifactDAOImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ArtifactDAOImpl.java @@ -2,7 +2,6 @@ import java.util.List; import java.util.Optional; -import java.util.Set; import javax.persistence.NoResultException; import javax.persistence.TypedQuery; @@ -46,16 +45,6 @@ public Optional findArtifact(String groupId, String artifactId, String versio } } - @Override - public List findArtifact(Set gas) { - CriteriaBuilder cb = em.getCriteriaBuilder(); - CriteriaQuery cq = cb.createQuery(type); - Root artifact = cq.from(type); - cq.select(artifact).where(cb.in(artifact.get("ga").in(gas))); - TypedQuery q = em.createQuery(cq); - return q.getResultList(); - } - @Override public List findAll() { CriteriaBuilder cb = em.getCriteriaBuilder(); diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/GADAOImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/GADAOImpl.java index 2cdf15c12..127de1229 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/GADAOImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/GADAOImpl.java @@ -8,20 +8,14 @@ import javax.persistence.TypedQuery; import javax.persistence.criteria.CriteriaBuilder; import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Predicate; import javax.persistence.criteria.Root; -import java.util.ArrayList; -import java.util.HashSet; import java.util.List; import java.util.Optional; -import java.util.Set; @Stateless public class GADAOImpl extends GenericDAOImpl implements GADAO { - public static final int BATCH_SIZE = 100; - public GADAOImpl() { super(GA.class); } @@ -41,39 +35,6 @@ public Optional findGA(String groupId, String artifactId) { } } - @Override - public Set findGAs(Set gas) { - ArrayList listOfGAs = new ArrayList<>(gas); - Set ret = new HashSet<>(); - for (int i = 0; i <= gas.size(); i += BATCH_SIZE) { - int to = i + BATCH_SIZE; - if (to > gas.size()) { - to = gas.size(); - } - ret.addAll(findGAs(listOfGAs.subList(i, to))); - } - return ret; - } - - private List findGAs(List gas) { - CriteriaBuilder cb = em.getCriteriaBuilder(); - CriteriaQuery cq = cb.createQuery(type); - Root gaTable = cq.from(type); - - ArrayList ands = new ArrayList<>(); - for (org.jboss.da.model.rest.GA ga : gas) { - Predicate and = cb.and( - cb.equal(gaTable.get("groupId"), ga.getGroupId()), - cb.equal(gaTable.get("artifactId"), ga.getArtifactId())); - ands.add(and); - } - cq.select(gaTable).where(cb.or(ands.toArray(Predicate[]::new))); - - TypedQuery q = em.createQuery(cq); - - return q.getResultList(); - } - @Override public List findAll() { CriteriaBuilder cb = em.getCriteriaBuilder(); diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java index 8d610d67d..8c3075cdb 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java @@ -8,19 +8,15 @@ import org.jboss.da.listings.api.dao.ArtifactDAO; import org.jboss.da.listings.api.dao.BlackArtifactDAO; import org.jboss.da.listings.api.dao.GADAO; -import org.jboss.da.listings.api.model.Artifact; import org.jboss.da.listings.api.model.BlackArtifact; import org.jboss.da.listings.api.model.GA; import org.jboss.da.listings.api.service.BlackArtifactService; import org.jboss.da.model.rest.GAV; import java.util.Comparator; -import java.util.Set; import java.util.SortedSet; import java.util.TreeSet; -import java.util.stream.Collectors; -import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; import org.jboss.pnc.common.version.SuffixedVersion; import org.jboss.pnc.common.version.VersionParser; @@ -43,28 +39,6 @@ protected ArtifactDAO getDAO() { return blackArtifactDAO; } - @Override - public Set prefetchGAs(Set gaToPrefetch) { - if (gaToPrefetch.isEmpty()) { - return Set.of(); - } - Set blocklistedGAs = gaDAO.findGAs(gaToPrefetch); - if (blocklistedGAs.isEmpty()) { - return Set.of(); - } - return blackArtifactDAO.findArtifact(blocklistedGAs).stream().map(Artifact::toGAV).collect(Collectors.toSet()); - } - - @Override - public boolean isBlocklisted(Set cache, org.jboss.da.model.rest.GA ga, QualifiedVersion version) { - SuffixedVersion parsedVersion = versionParser.parse(version); - - GAV unsuffixedGAV = new GAV(ga, parsedVersion.unsuffixedVersion()); - GAV osgiGAV = new GAV(ga, VersionParser.getOSGiVersion(version.getVersion())); - - return cache.contains(unsuffixedGAV) || cache.contains(osgiGAV); - } - @Override public org.jboss.da.listings.api.service.ArtifactService.ArtifactStatus addArtifact( String groupId, diff --git a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java index 7670aaf37..d28d1c4e8 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java @@ -194,12 +194,11 @@ private Map>> getArtifactVersions( boolean filterBlacklisted) { Map>> ret = new HashMap<>(); Set distinctGAs = gavs.stream().map(GAV::getGA).collect(Collectors.toSet()); - Set cache = blackArtifactService.prefetchGAs(distinctGAs); for (GA ga : distinctGAs) { MavenArtifact mavenArtifact = new MavenArtifact(new GAV(ga, "0.0.0")); CompletableFuture> versions = productProvider.getAllVersions(mavenArtifact); if (filterBlacklisted) { - versions = filterBlacklistedArtifacts(versions, cache, ga); + versions = filterBlacklistedArtifacts(versions, ga); } ret.put(ga, versions); } @@ -216,10 +215,11 @@ private Map>> getArtifactVersion private CompletableFuture> filterBlacklistedArtifacts( CompletableFuture> versions, - Set cache, GA ga) { - Predicate isNotBlacklisted = version -> !blackArtifactService - .isBlocklisted(cache, ga, version); + Predicate isNotBlacklisted = version -> { + GAV gav = new GAV(ga, version.getVersion()); + return !blackArtifactService.isArtifactPresent(gav); + }; return versions.thenApply(v -> v.stream().filter(isNotBlacklisted).collect(Collectors.toSet())); } From 20fa3341ab3bd9eb46c7e54e1b05c8af7afa537a Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Fri, 13 Feb 2026 16:57:58 +0000 Subject: [PATCH 04/26] Revert "Remove Whitelist" This reverts commit c300858e639cab7188adb80519b0fb893f0e2d0d. --- .../jboss/da/listings/api/dao/ProductDAO.java | 32 + .../listings/api/dao/ProductVersionDAO.java | 114 ++++ .../da/listings/api/dao/WhiteArtifactDAO.java | 11 + .../jboss/da/listings/api/model/Product.java | 30 + .../da/listings/api/model/ProductVersion.java | 55 ++ .../ProductVersionArtifactRelationship.java | 26 + .../da/listings/api/model/WhiteArtifact.java | 39 ++ .../listings/api/service/ProductService.java | 42 ++ .../api/service/ProductVersionService.java | 108 ++++ .../da/listings/api/service/WLFiller.java | 19 + .../service/WhiteArtifactFilterService.java | 90 +++ .../api/service/WhiteArtifactService.java | 65 +++ .../da/listings/impl/dao/ProductDAOImpl.java | 55 ++ .../impl/dao/ProductVersionDAOImpl.java | 205 +++++++ .../impl/dao/WhiteArtifactDAOImpl.java | 32 + .../service/BlackArtifactServiceImpl.java | 22 +- .../impl/service/ProductServiceImpl.java | 57 ++ .../service/ProductVersionServiceImpl.java | 78 +++ .../listings/impl/service/WLFillerImpl.java | 130 +++++ .../WhiteArtifactFilterServiceImpl.java | 92 +++ .../service/WhiteArtifactServiceImpl.java | 144 +++++ .../da/products/api/ProductsService.java | 12 + .../impl/AggregatedProductProvider.java | 6 + .../impl/DatabaseProductProvider.java | 164 ++++++ .../da/products/impl/ProductsServiceImpl.java | 67 +++ .../reports/backend/impl/ProductAdapter.java | 104 ++++ .../da/reports/impl/ReportsGeneratorImpl.java | 50 +- .../impl/ReportsGeneratorImplTest.java | 13 + .../jboss/da/products/model/rest/GADiff.java | 82 +++ .../da/products/model/rest/ProductDiff.java | 54 ++ .../model/response/striped/WLStripper.java | 1 + .../model/rest/BackwardCompatibilityTest.java | 8 + .../jboss/da/rest/ReportsRestActivator.java | 4 + .../org/jboss/da/rest/listings/Artifacts.java | 416 +++++++++++++ .../jboss/da/rest/listings/RestConvert.java | 61 ++ .../org/jboss/da/rest/products/Products.java | 111 ++++ .../listings/AbstractRestApiListingTest.java | 61 +- .../rest/listings/RestApiListingsTestIT.java | 236 ++++++++ .../rest/products/RestApiProductsTestIT.java | 83 +++ ...tifactBlackWhitelistTransitionsTestIT.java | 237 ++++++++ ...sWithWhitelistedArtifactsRemoteTestIT.java | 552 ++++++++++++++++++ .../listings/WhiteArtifactServiceTestIT.java | 47 ++ 42 files changed, 3798 insertions(+), 17 deletions(-) create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/dao/ProductDAO.java create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/dao/ProductVersionDAO.java create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/dao/WhiteArtifactDAO.java create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/model/Product.java create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/model/ProductVersion.java create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/model/ProductVersionArtifactRelationship.java create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/model/WhiteArtifact.java create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/service/ProductService.java create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/service/ProductVersionService.java create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/service/WLFiller.java create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/service/WhiteArtifactFilterService.java create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/service/WhiteArtifactService.java create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ProductDAOImpl.java create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ProductVersionDAOImpl.java create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/impl/dao/WhiteArtifactDAOImpl.java create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/impl/service/ProductServiceImpl.java create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/impl/service/ProductVersionServiceImpl.java create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/impl/service/WLFillerImpl.java create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactFilterServiceImpl.java create mode 100644 reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactServiceImpl.java create mode 100644 reports-backend/src/main/java/org/jboss/da/products/api/ProductsService.java create mode 100644 reports-backend/src/main/java/org/jboss/da/products/impl/DatabaseProductProvider.java create mode 100644 reports-backend/src/main/java/org/jboss/da/products/impl/ProductsServiceImpl.java create mode 100644 reports-backend/src/main/java/org/jboss/da/reports/backend/impl/ProductAdapter.java create mode 100644 reports-model/src/main/java/org/jboss/da/products/model/rest/GADiff.java create mode 100644 reports-model/src/main/java/org/jboss/da/products/model/rest/ProductDiff.java create mode 100644 reports-rest/src/main/java/org/jboss/da/rest/listings/Artifacts.java create mode 100644 reports-rest/src/main/java/org/jboss/da/rest/products/Products.java create mode 100644 testsuite/src/test/java/org/jboss/da/test/client/rest/products/RestApiProductsTestIT.java create mode 100644 testsuite/src/test/java/org/jboss/da/test/server/ArtifactBlackWhitelistTransitionsTestIT.java create mode 100644 testsuite/src/test/java/org/jboss/da/test/server/ReportsWithWhitelistedArtifactsRemoteTestIT.java create mode 100644 testsuite/src/test/java/org/jboss/da/test/server/listings/WhiteArtifactServiceTestIT.java diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ProductDAO.java b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ProductDAO.java new file mode 100644 index 000000000..a610086ef --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ProductDAO.java @@ -0,0 +1,32 @@ +package org.jboss.da.listings.api.dao; + +import org.jboss.da.listings.api.model.Product; + +import java.util.List; +import java.util.Optional; + +public interface ProductDAO extends GenericDAO { + + /** + * Finds all Products + * + * @return List of products + */ + List findAll(); + + /** + * Finds all products matching the supplied product names. + * + * @return List of products as if findProduct() was called once for each name in the list. + */ + List findAllWithNames(List productNames); + + /** + * Finds Product with specific name + * + * @param name + * @return Optional of product or empty + */ + Optional findProduct(String name); + +} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ProductVersionDAO.java b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ProductVersionDAO.java new file mode 100644 index 000000000..95e8aa1f3 --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ProductVersionDAO.java @@ -0,0 +1,114 @@ +package org.jboss.da.listings.api.dao; + +import org.jboss.da.listings.api.model.ProductVersionArtifactRelationship; +import org.jboss.da.listings.api.model.ProductVersion; +import org.jboss.da.listings.model.ProductSupportStatus; + +import java.util.List; +import java.util.NoSuchElementException; +import java.util.Optional; + +public interface ProductVersionDAO extends GenericDAO { + + /** + * Change support status of ProductVersion with specific product name and version + * + * @param name + * @param version + * @param newStatus + * @return True if change was successful otherwise false + * @throws NoSuchElementException + */ + boolean changeProductVersionStatus(String name, String version, ProductSupportStatus newStatus); + + /** + * Finds ProductVersion with specific product name and version + * + * @param name + * @param version + * @return Optional of productVersion or empty + */ + Optional findProductVersion(String name, String version); + + /** + * Finds ProductVersions with specific product name + * + * @param name + * @return List of productVersions + */ + List findProductVersionsWithProduct(String name); + + /** + * Finds all ProductVersions + * + * @return List of productVersions + */ + List findAll(); + + /** + * Finds all ProductVersions with the specified IDs. + * + * @return List of productVersions + */ + List findAllWithIds(List productVersionIds); + + /** + * Find ProductsVersions that contains Artifact with specific groupId, artifactId and version + * + * @param groupId + * @param artifactId + * @param version + * @return List of productVersions + */ + List findProductVersionsWithArtifact( + String groupId, + String artifactId, + String version, + boolean preciseVersion); + + /** + * Finds ProductVersions with specific product id, product name, version or support status. All parameters are + * optional. + * + * @param id product id optional + * @param name product name optional + * @param version optional + * @param status optional + * @return List of productVersions with specified parameters + */ + List findProductVersions(Long id, String name, String version, ProductSupportStatus status); + + /** + * Finds Artifacts of ProductVersions with specific support status + * + * @param status + * @return List of products with their artifacts + */ + List findProductVersionsWithArtifactsByStatus(ProductSupportStatus status); + + /** + * Find ProductVersions that contains Artifact with specific groupId, artifactId and version + * + * @param groupId + * @param artifactId + * @param version + * @return List of products with artifacts + */ + List findProductVersionsWithArtifactByGAV( + String groupId, + String artifactId, + String version); + + /** + * Find ProductVersions with specific status that contains Artifact with specific groupId, artifactId + * + * @param groupId + * @param artifactId + * @param status + * @return + */ + List findProductVersionsWithArtifactsByGAStatus( + String groupId, + String artifactId, + Optional status); +} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/WhiteArtifactDAO.java b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/WhiteArtifactDAO.java new file mode 100644 index 000000000..b67c197d0 --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/WhiteArtifactDAO.java @@ -0,0 +1,11 @@ +package org.jboss.da.listings.api.dao; + +import org.jboss.da.listings.api.model.WhiteArtifact; + +/** + * + * @author Jozef Mrazek <jmrazek@redhat.com> + * + */ +public interface WhiteArtifactDAO extends ArtifactDAO { +} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/model/Product.java b/reports-backend/src/main/java/org/jboss/da/listings/api/model/Product.java new file mode 100644 index 000000000..619c1287d --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/model/Product.java @@ -0,0 +1,30 @@ +package org.jboss.da.listings.api.model; + +import javax.persistence.Entity; +import lombok.AccessLevel; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.NonNull; +import lombok.Setter; +import lombok.ToString; + +/** + * + * @author Jozef Mrazek <jmrazek@redhat.com> + * + */ +@NoArgsConstructor(access = AccessLevel.PROTECTED) +@ToString +@Entity +public class Product extends GenericEntity { + + @Setter + @Getter + @NonNull + private String name; + + public Product(String name) { + this.name = name; + } + +} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/model/ProductVersion.java b/reports-backend/src/main/java/org/jboss/da/listings/api/model/ProductVersion.java new file mode 100644 index 000000000..3f44249e7 --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/model/ProductVersion.java @@ -0,0 +1,55 @@ +package org.jboss.da.listings.api.model; + +import org.jboss.da.listings.model.ProductSupportStatus; + +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.ManyToMany; +import javax.persistence.ManyToOne; + +import java.util.HashSet; +import java.util.Set; + +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.NonNull; +import lombok.Setter; + +@NoArgsConstructor +@Entity +public class ProductVersion extends GenericEntity { + + @Setter + @Getter + @ManyToOne + private Product product; + + @Setter + @Getter + @NonNull + private String productVersion; + + @Setter + @Getter + private ProductSupportStatus support; + + @Getter + @Setter + @ManyToMany(fetch = FetchType.EAGER) + private Set whiteArtifacts; + + public ProductVersion(Product p, String productVersion, ProductSupportStatus support) { + this.product = p; + this.productVersion = productVersion; + this.support = support; + whiteArtifacts = new HashSet<>(); + } + + public void addArtifact(WhiteArtifact artifact) { + whiteArtifacts.add(artifact); + } + + public void removeArtifact(WhiteArtifact artifact) { + whiteArtifacts.remove(artifact); + } +} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/model/ProductVersionArtifactRelationship.java b/reports-backend/src/main/java/org/jboss/da/listings/api/model/ProductVersionArtifactRelationship.java new file mode 100644 index 000000000..051996bce --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/model/ProductVersionArtifactRelationship.java @@ -0,0 +1,26 @@ +package org.jboss.da.listings.api.model; + +import lombok.AccessLevel; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import lombok.ToString; + +@NoArgsConstructor(access = AccessLevel.PUBLIC) +@ToString +public class ProductVersionArtifactRelationship { + + @Getter + @Setter + private WhiteArtifact artifact; + + @Getter + @Setter + private ProductVersion productVersion; + + public ProductVersionArtifactRelationship(ProductVersion productVersion, WhiteArtifact artifact) { + this.artifact = artifact; + this.productVersion = productVersion; + } + +} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/model/WhiteArtifact.java b/reports-backend/src/main/java/org/jboss/da/listings/api/model/WhiteArtifact.java new file mode 100644 index 000000000..790a4096d --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/model/WhiteArtifact.java @@ -0,0 +1,39 @@ +package org.jboss.da.listings.api.model; + +import javax.persistence.Entity; + +import lombok.AccessLevel; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.NonNull; +import lombok.Setter; +import lombok.ToString; + +/** + * + * @author Jozef Mrazek <jmrazek@redhat.com> + * + */ +@NoArgsConstructor(access = AccessLevel.PUBLIC) +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Entity +public class WhiteArtifact extends Artifact { + + @Setter + @Getter + private boolean is3rdParty; + + @Setter + @Getter + @NonNull + private String osgiVersion; + + public WhiteArtifact(GA ga, String version, User insertedBy, String osgiVersion, boolean is3rdParty) { + super(ga, version, insertedBy); + this.is3rdParty = is3rdParty; + this.osgiVersion = osgiVersion; + } + +} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/service/ProductService.java b/reports-backend/src/main/java/org/jboss/da/listings/api/service/ProductService.java new file mode 100644 index 000000000..6553946cd --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/service/ProductService.java @@ -0,0 +1,42 @@ +package org.jboss.da.listings.api.service; + +import org.jboss.da.listings.model.ProductSupportStatus; + +import javax.persistence.EntityNotFoundException; + +import java.util.NoSuchElementException; + +public interface ProductService { + + /** + * Adds Product into whitelist products + * + * @param name + * @param version + * @param status + * @return true if operation was successful + */ + boolean addProduct(String name, String version, ProductSupportStatus status); + + /** + * Remove Product from whitelist products + * + * @param name + * @param version + * @return true if operation was successful + * @throws EntityNotFoundException + */ + boolean removeProduct(String name, String version) throws EntityNotFoundException; + + /** + * Change support status of Product with specific name and version + * + * @param name + * @param version + * @param newStatus + * @return True if change was successful otherwise false + * @throws NoSuchElementException + */ + boolean changeProductStatus(String name, String version, ProductSupportStatus newStatus); + +} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/service/ProductVersionService.java b/reports-backend/src/main/java/org/jboss/da/listings/api/service/ProductVersionService.java new file mode 100644 index 000000000..3dcb331fd --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/service/ProductVersionService.java @@ -0,0 +1,108 @@ +package org.jboss.da.listings.api.service; + +import org.jboss.da.listings.api.model.ProductVersion; +import org.jboss.da.listings.api.model.ProductVersionArtifactRelationship; +import org.jboss.da.listings.model.ProductSupportStatus; + +import java.util.List; +import java.util.Optional; + +public interface ProductVersionService { + + /** + * Get ProductVersion with specific product name and version + * + * @param name + * @param version + * @return Optional of productVersion or empty + */ + Optional getProductVersion(String name, String version); + + /** + * Get ProductVersion with specific id + * + * @param id + * @return Optional of productVersion or empty + */ + Optional getProductVersion(long id); + + /** + * Get all ProductVersions + * + * @return List of productVersions + */ + List getAll(); + + /** + * Get all ProductVersions for a product name + * + * @return List of productVersions + */ + List getAllForProduct(String productName); + + /** + * Get ProductVersions that contains Artifact with specific groupId, artifactId and version + * + * @param groupId + * @param artifactId + * @param version + * @return List of products + */ + List getProductVersionsOfArtifact(String groupId, String artifactId, String version); + + /** + * Finds ProductVersion with specific product id, product name, version or support status. All parameters are + * optional. + * + * @param id optional + * @param name optional + * @param version optional + * @param status optional + * @return List of productVersions with specified parameters + */ + List getProductVersions(Long id, String name, String version, ProductSupportStatus status); + + /** + * Finds Artifacts of ProductVersions with specific support status + * + * @param status + * @return List of productVersions with their artifacts + */ + List getProductVersionsWithArtifactsByStatus(ProductSupportStatus status); + + /** + * Find ProductVersions that contains Artifact with specific groupId, artifactId and version + * + * @param groupId + * @param artifactId + * @param version + * @return List of productVersions with artifacts + */ + List getProductVersionsWithArtifactByGAV( + String groupId, + String artifactId, + String version); + + /** + * Find ProductVersions with specific status that contains Artifact with specific groupId, artifactId + * + * @param groupId + * @param artifactId + * @param status + * @return + */ + List getProductVersionsWithArtifactsByGAStatus( + String groupId, + String artifactId, + ProductSupportStatus status); + + /** + * Find ProductVersions with any status that contains Artifact with specific groupId, artifactId + * + * @param groupId + * @param artifactId + * @return + */ + List getProductVersionsWithArtifactsByGA(String groupId, String artifactId); + +} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/service/WLFiller.java b/reports-backend/src/main/java/org/jboss/da/listings/api/service/WLFiller.java new file mode 100644 index 000000000..858aa927e --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/service/WLFiller.java @@ -0,0 +1,19 @@ +package org.jboss.da.listings.api.service; + +import java.util.List; + +public interface WLFiller { + + public enum WLStatus { + PRODUCT_NOT_FOUND, FILLED, ANALYSER_ERROR, POM_NOT_FOUND; + } + + WLStatus fillWhitelistFromPom( + String scmUrl, + String revision, + String pomPath, + List repositories, + long productId); + + WLStatus fillWhitelistFromGAV(String groupId, String artifactId, String version, long productId); +} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/service/WhiteArtifactFilterService.java b/reports-backend/src/main/java/org/jboss/da/listings/api/service/WhiteArtifactFilterService.java new file mode 100644 index 000000000..476dd4b80 --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/service/WhiteArtifactFilterService.java @@ -0,0 +1,90 @@ +package org.jboss.da.listings.api.service; + +import java.util.List; +import java.util.Optional; + +import org.jboss.da.listings.api.model.ProductVersion; +import org.jboss.da.listings.api.model.ProductVersionArtifactRelationship; +import org.jboss.da.listings.model.ProductSupportStatus; + +/** + * + * Provides access to white artifacts by applying the required filtering - taking into consideration artifacts listed + * against ProductVersions, white list and black list. + * + * @author fkujikis + * + */ +public interface WhiteArtifactFilterService { + + /** + * Remove all blacklisted artifacts from the provided list of ProductVersion instances. + * + * @return List of ProductVersion instances such that for each instance, instance.getWhiteArtifacts() contains only + * whitelisted artifacts, with the blacklisted artifacts filtered out. + */ + public List toProductsContainingOnlyWhiteArtifacts(List products); + + /** + * Remove all blacklisted artifacts from the provided list of ProductVersionArtifactRelationship instances. + * + * @return List of ProductVersionArtifactRelationship instances such that for each instance, + * instance.getProductVersion().getWhiteArtifacts() contains only whitelisted artifacts, with the + * blacklisted artifacts filtered out. + */ + public List toProductRelsContainingOnlyWhiteArtifacts( + List products); + + /** + * Get ProductVersion with specific product name and version, such that it contains only white artifacts. + * + * @param name + * @param version + * @return Optional of productVersion or empty + */ + Optional getProductVersionWithWhiteArtifacts(String name, String version); + + /** + * Get all ProductVersions containing only White artifacts. + * + * @return List of productVersions with white artifacts + */ + List getAllWithWhiteArtifacts(); + + /** + * Finds Artifacts of ProductVersions with specific support status, only containing white artifacts + * + * @param status + * @return List of productVersions with their artifacts + */ + List getProductVersionsWithWhiteArtifactsByStatus(ProductSupportStatus status); + + /** + * Find ProductVersions that contains Artifact with specific groupId, artifactId and version such that it contains + * only white artifacts. + * + * @param groupId + * @param artifactId + * @param version + * @return List of productVersions with artifacts + */ + List getProductVersionsWithWhiteArtifactsByGAV( + String groupId, + String artifactId, + String version); + + /** + * Find ProductVersions with specific status that contains Artifact with specific groupId, artifactId such that it + * contains only white artifacts. + * + * @param groupId + * @param artifactId + * @param status + * @return + */ + List getProductVersionsWithWhiteArtifactsByGAStatus( + String groupId, + String artifactId, + ProductSupportStatus status); + +} \ No newline at end of file diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/service/WhiteArtifactService.java b/reports-backend/src/main/java/org/jboss/da/listings/api/service/WhiteArtifactService.java new file mode 100644 index 000000000..5f4ad6cfc --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/service/WhiteArtifactService.java @@ -0,0 +1,65 @@ +package org.jboss.da.listings.api.service; + +import java.util.List; + +import org.jboss.da.listings.api.model.WhiteArtifact; +import org.jboss.da.model.rest.GAV; + +/** + * + * @author Jozef Mrazek <jmrazek@redhat.com> + * + */ +public interface WhiteArtifactService extends ArtifactService { + + /** + * Add artifact to whitelist. The version must contain redhat suffix. + * + * @throws IllegalArgumentException when version doesn't have redhat suffix. + */ + public ArtifactStatus addArtifact(String groupId, String artifactId, String version, Long productVersionId) + throws IllegalArgumentException; + + /** + * + * @param groupId + * @param artifactId + * @param version + * @param productVersionId + * @return + */ + public boolean removeArtifractFromProductVersion( + String groupId, + String artifactId, + String version, + Long productVersionId); + + /** + * Checks if whitelist contains artifact with specific groupId, artifactId and version. If the version have redhat + * suffix, find exact match. If the version doesn't have redhat suffix, converts the version to OSGi version and + * finds any redhat suffixed versions in whitelist. + * + * @return List of found artifacts. + */ + public List getArtifacts(GAV gav); + + /** + * Checks if whitelist contains artifact with specific groupId, artifactId and version. If the version have redhat + * suffix, find exact match. If the version doesn't have redhat suffix, converts the version to OSGi version and + * finds any redhat suffixed versions in whitelist. + * + * @return List of found artifacts. + */ + public List getArtifacts(String groupId, String artifactId, String version); + + /** + * Remove artifact from list and from product versions. Removes only exact match of artifact. + * + * @param groupId + * @param artifactId + * @param version + * @return True if artifact was deleted. + */ + public boolean removeArtifact(String groupId, String artifactId, String version); + +} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ProductDAOImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ProductDAOImpl.java new file mode 100644 index 000000000..1f67663e9 --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ProductDAOImpl.java @@ -0,0 +1,55 @@ +package org.jboss.da.listings.impl.dao; + +import org.jboss.da.listings.api.dao.ProductDAO; +import org.jboss.da.listings.api.model.Product; +import javax.ejb.Stateless; +import javax.persistence.NoResultException; +import javax.persistence.TypedQuery; +import javax.persistence.criteria.CriteriaBuilder; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; + +import java.util.List; +import java.util.Optional; + +@Stateless +public class ProductDAOImpl extends GenericDAOImpl implements ProductDAO { + + public ProductDAOImpl() { + super(Product.class); + } + + @Override + public List findAll() { + CriteriaBuilder cb = em.getCriteriaBuilder(); + CriteriaQuery cq = cb.createQuery(type); + Root product = cq.from(type); + cq.select(product); + TypedQuery q = em.createQuery(cq); + return q.getResultList(); + } + + @Override + public List findAllWithNames(List productNames) { + CriteriaBuilder cb = em.getCriteriaBuilder(); + CriteriaQuery cq = cb.createQuery(type); + Root product = cq.from(type); + cq.select(product).where(product.get("name").in(productNames)); + TypedQuery q = em.createQuery(cq); + return q.getResultList(); + } + + @Override + public Optional findProduct(String name) { + try { + CriteriaBuilder cb = em.getCriteriaBuilder(); + CriteriaQuery cq = cb.createQuery(type); + Root product = cq.from(type); + cq.select(product).where(cb.equal(product.get("name"), name)); + TypedQuery q = em.createQuery(cq); + return Optional.of(q.getSingleResult()); + } catch (NoResultException e) { + return Optional.empty(); + } + } +} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ProductVersionDAOImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ProductVersionDAOImpl.java new file mode 100644 index 000000000..774b0c5f9 --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ProductVersionDAOImpl.java @@ -0,0 +1,205 @@ +package org.jboss.da.listings.impl.dao; + +import org.jboss.da.listings.api.dao.ProductVersionDAO; +import org.jboss.da.listings.api.model.Artifact; +import org.jboss.da.listings.api.model.GA; +import org.jboss.da.listings.api.model.Product; +import org.jboss.da.listings.api.model.ProductVersionArtifactRelationship; +import org.jboss.da.listings.api.model.ProductVersion; +import org.jboss.da.listings.api.model.WhiteArtifact; +import org.jboss.da.listings.model.ProductSupportStatus; + +import javax.ejb.Stateless; +import javax.persistence.NoResultException; +import javax.persistence.TypedQuery; +import javax.persistence.criteria.CriteriaBuilder; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Expression; +import javax.persistence.criteria.Join; +import javax.persistence.criteria.Predicate; +import javax.persistence.criteria.Root; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Optional; + +@Stateless +public class ProductVersionDAOImpl extends GenericDAOImpl implements ProductVersionDAO { + + public ProductVersionDAOImpl() { + super(ProductVersion.class); + } + + @Override + public boolean changeProductVersionStatus(String name, String version, ProductSupportStatus newStatus) { + Optional pv = findProductVersion(name, version); + if (!pv.isPresent()) + return false; + pv.get().setSupport(newStatus); + update(pv.get()); + return true; + } + + @Override + public Optional findProductVersion(String name, String version) { + try { + CriteriaBuilder cb = em.getCriteriaBuilder(); + CriteriaQuery cq = cb.createQuery(type); + Root productVersion = cq.from(type); + Join product = productVersion.join("product"); + cq.select(productVersion) + .where( + cb.and( + cb.equal(product.get("name"), name), + cb.equal(productVersion.get("productVersion"), version))); + TypedQuery q = em.createQuery(cq); + return Optional.of(q.getSingleResult()); + } catch (NoResultException e) { + return Optional.empty(); + } + } + + @Override + public List findProductVersionsWithProduct(String name) { + CriteriaBuilder cb = em.getCriteriaBuilder(); + CriteriaQuery cq = cb.createQuery(type); + Root productVersion = cq.from(type); + Join product = productVersion.join("product"); + cq.select(productVersion).where(cb.equal(product.get("name"), name)); + TypedQuery q = em.createQuery(cq); + return q.getResultList(); + } + + @Override + public List findAll() { + CriteriaBuilder cb = em.getCriteriaBuilder(); + CriteriaQuery cq = cb.createQuery(type); + Root productVersion = cq.from(type); + cq.select(productVersion); + TypedQuery q = em.createQuery(cq); + return q.getResultList(); + } + + @Override + public List findAllWithIds(List productVersionIds) { + CriteriaBuilder cb = em.getCriteriaBuilder(); + CriteriaQuery cq = cb.createQuery(type); + Root product = cq.from(type); + cq.select(product).where(product.get("id").in(productVersionIds)); + TypedQuery q = em.createQuery(cq); + return q.getResultList(); + } + + @Override + public List findProductVersionsWithArtifact( + String groupId, + String artifactId, + String version, + boolean preciseVersion) { + CriteriaBuilder cb = em.getCriteriaBuilder(); + CriteriaQuery cq = cb.createQuery(type); + Root productVersion = cq.from(type); + Root artifact = cq.from(WhiteArtifact.class); + Join ga = artifact.join("ga"); + if (!preciseVersion) + version += '%'; + cq.select(productVersion) + .where( + cb.and( + cb.equal(ga.get("groupId"), groupId), + cb.equal(ga.get("artifactId"), artifactId), + cb.or( + cb.like(artifact.get("version"), version), + cb.like(artifact.get("osgiVersion"), version)))); + TypedQuery q = em.createQuery(cq); + List list = q.getResultList(); + return list; + } + + @Override + public List findProductVersions(Long id, String name, String version, ProductSupportStatus status) { + CriteriaBuilder cb = em.getCriteriaBuilder(); + CriteriaQuery cq = cb.createQuery(type); + Root productVersion = cq.from(type); + Join product = productVersion.join("product"); + List predicates = new ArrayList<>(); + if (id != null) { + predicates.add(cb.equal(productVersion.get("id"), id)); + } + if (name != null) { + predicates.add(cb.equal(product.get("name"), name)); + } + if (version != null) { + predicates.add(cb.equal(productVersion.get("productVersion"), version)); + } + if (status != null) { + predicates.add(cb.equal(productVersion.get("support"), status)); + } + cq.select(productVersion).where(cb.and(cb.and(predicates.toArray(new Predicate[predicates.size()])))); + TypedQuery q = em.createQuery(cq); + return q.getResultList(); + } + + @Override + public List findProductVersionsWithArtifactsByStatus(ProductSupportStatus status) { + CriteriaBuilder cb = em.getCriteriaBuilder(); + CriteriaQuery cq = cb.createQuery(type); + Root productVersion = cq.from(ProductVersion.class); + cq.select(productVersion).where(cb.and(cb.equal(productVersion.get("support"), status))); + TypedQuery q = em.createQuery(cq); + List pv = q.getResultList(); + return pv; + } + + @Override + public List findProductVersionsWithArtifactByGAV( + String groupId, + String artifactId, + String version) { + CriteriaBuilder cb = em.getCriteriaBuilder(); + CriteriaQuery cq = cb.createQuery(ProductVersionArtifactRelationship.class); + Root productVersion = cq.from(type); + Root artifact = cq.from(WhiteArtifact.class); + Join ga = artifact.join("ga"); + Expression> artifacts = productVersion.get("whiteArtifacts"); + cq.multiselect(productVersion, artifact); + cq.where( + cb.and( + cb.isMember(artifact, artifacts), + cb.equal(ga.get("artifactId"), artifactId), + cb.equal(ga.get("groupId"), groupId), + cb.or( + cb.equal(artifact.get("version"), version), + cb.equal(artifact.get("osgiVersion"), version)))); + TypedQuery q = em.createQuery(cq); + List l = q.getResultList(); + return l; + } + + @Override + public List findProductVersionsWithArtifactsByGAStatus( + String groupId, + String artifactId, + Optional status) { + CriteriaBuilder cb = em.getCriteriaBuilder(); + CriteriaQuery cq = cb.createQuery(ProductVersionArtifactRelationship.class); + Root productVersion = cq.from(type); + Root artifact = cq.from(WhiteArtifact.class); + Join ga = artifact.join("ga"); + Expression> artifacts = productVersion.get("whiteArtifacts"); + cq.multiselect(productVersion, artifact); + + final Predicate gaRestriction = cb.and( + cb.isMember(artifact, artifacts), + cb.equal(ga.get("artifactId"), artifactId), + cb.equal(ga.get("groupId"), groupId)); + Predicate restriction = status.map(x -> cb.and(gaRestriction, cb.equal(productVersion.get("support"), x))) + .orElse(gaRestriction); + + cq.where(restriction); + TypedQuery q = em.createQuery(cq); + List l = q.getResultList(); + return l; + } +} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/WhiteArtifactDAOImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/WhiteArtifactDAOImpl.java new file mode 100644 index 000000000..49874dac0 --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/WhiteArtifactDAOImpl.java @@ -0,0 +1,32 @@ +package org.jboss.da.listings.impl.dao; + +import javax.ejb.Stateless; +import javax.inject.Inject; + +import org.jboss.da.common.logging.AuditLogger; +import org.jboss.da.listings.api.dao.WhiteArtifactDAO; +import org.jboss.da.listings.api.model.WhiteArtifact; + +/** + * + * @author Jozef Mrazek <jmrazek@redhat.com> + * + */ +@Stateless +public class WhiteArtifactDAOImpl extends ArtifactDAOImpl implements WhiteArtifactDAO { + + @Override + public void create(WhiteArtifact entity) { + try { + super.create(entity); + } catch (RuntimeException ex) { + AuditLogger.LOG.info("Adding allowlisted artifact " + entity.gav() + " failed."); + throw ex; + } + AuditLogger.LOG.info("Added allowlisted artifact " + entity.gav() + "."); + } + + public WhiteArtifactDAOImpl() { + super(WhiteArtifact.class); + } +} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java index 8c3075cdb..363867440 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java @@ -1,6 +1,8 @@ package org.jboss.da.listings.impl.service; +import java.util.HashSet; import java.util.Optional; +import java.util.Set; import javax.enterprise.context.ApplicationScoped; import javax.inject.Inject; @@ -8,8 +10,10 @@ import org.jboss.da.listings.api.dao.ArtifactDAO; import org.jboss.da.listings.api.dao.BlackArtifactDAO; import org.jboss.da.listings.api.dao.GADAO; +import org.jboss.da.listings.api.dao.WhiteArtifactDAO; import org.jboss.da.listings.api.model.BlackArtifact; import org.jboss.da.listings.api.model.GA; +import org.jboss.da.listings.api.model.WhiteArtifact; import org.jboss.da.listings.api.service.BlackArtifactService; import org.jboss.da.model.rest.GAV; @@ -31,6 +35,9 @@ public class BlackArtifactServiceImpl extends ArtifactServiceImpl @Inject private BlackArtifactDAO blackArtifactDAO; + @Inject + private WhiteArtifactDAO whiteArtifactDAO; + @Inject private GADAO gaDAO; @@ -54,8 +61,21 @@ public org.jboss.da.listings.api.service.ArtifactService.ArtifactStatus addArtif if (blackArtifactDAO.findArtifact(groupId, artifactId, osgiVersion).isPresent()) { return ArtifactStatus.NOT_MODIFIED; } + + Set whites = new HashSet<>(); + Optional rhA = whiteArtifactDAO.findArtifact(groupId, artifactId, osgiVersion); + rhA.ifPresent(x -> whites.add(rhA.get())); + Optional a = whiteArtifactDAO.findArtifact(groupId, artifactId, version); + a.ifPresent(x -> whites.add(a.get())); + + ArtifactStatus status = ArtifactStatus.ADDED; + + if (!whites.isEmpty()) { + status = ArtifactStatus.WAS_WHITELISTED; + } + blackArtifactDAO.create(artifact); - return ArtifactStatus.ADDED; + return status; } @Override diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ProductServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ProductServiceImpl.java new file mode 100644 index 000000000..10163d802 --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ProductServiceImpl.java @@ -0,0 +1,57 @@ +package org.jboss.da.listings.impl.service; + +import org.jboss.da.listings.api.dao.ProductDAO; +import org.jboss.da.listings.api.dao.ProductVersionDAO; +import org.jboss.da.listings.api.model.Product; +import org.jboss.da.listings.api.model.ProductVersion; +import org.jboss.da.listings.api.service.ProductService; +import org.jboss.da.listings.model.ProductSupportStatus; + +import javax.enterprise.context.ApplicationScoped; +import javax.inject.Inject; +import javax.persistence.EntityNotFoundException; + +import java.util.Optional; + +@ApplicationScoped +public class ProductServiceImpl implements ProductService { + + @Inject + private ProductDAO productDAO; + + @Inject + private ProductVersionDAO productVersionDAO; + + @Override + public boolean addProduct(String name, String version, ProductSupportStatus status) { + if (productVersionDAO.findProductVersion(name, version).isPresent()) { + return false; + } + Optional p = productDAO.findProduct(name); + if (!p.isPresent()) { + Product pr = new Product(name); + productDAO.create(pr); + p = productDAO.findProduct(name); + } + productVersionDAO.create(new ProductVersion(p.get(), version, status)); + return true; + } + + @Override + public boolean removeProduct(String name, String version) throws EntityNotFoundException { + Optional pv = productVersionDAO.findProductVersion(name, version); + if (pv.isPresent()) { + productVersionDAO.delete(pv.get()); + if (productVersionDAO.findProductVersionsWithProduct(name).isEmpty()) { + productDAO.delete(productDAO.findProduct(name).get()); + } + return true; + } + throw new EntityNotFoundException("Product with this name and version is not in database"); + } + + @Override + public boolean changeProductStatus(String name, String version, ProductSupportStatus newStatus) { + return productVersionDAO.changeProductVersionStatus(name, version, newStatus); + } +} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ProductVersionServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ProductVersionServiceImpl.java new file mode 100644 index 000000000..b48154dfa --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ProductVersionServiceImpl.java @@ -0,0 +1,78 @@ +package org.jboss.da.listings.impl.service; + +import org.jboss.da.listings.api.dao.ProductVersionDAO; +import org.jboss.da.listings.api.model.ProductVersion; +import org.jboss.da.listings.api.model.ProductVersionArtifactRelationship; +import org.jboss.da.listings.api.service.ProductVersionService; +import org.jboss.da.listings.model.ProductSupportStatus; + +import javax.enterprise.context.ApplicationScoped; +import javax.inject.Inject; + +import java.util.List; +import java.util.Optional; + +@ApplicationScoped +public class ProductVersionServiceImpl implements ProductVersionService { + + @Inject + private ProductVersionDAO productVersionDAO; + + @Override + public List getAll() { + return productVersionDAO.findAll(); + } + + @Override + public Optional getProductVersion(String name, String version) { + return productVersionDAO.findProductVersion(name, version); + } + + @Override + public Optional getProductVersion(long id) { + return Optional.ofNullable(productVersionDAO.read(id)); + } + + @Override + public List getProductVersionsOfArtifact(String groupId, String artifactId, String version) { + return productVersionDAO.findProductVersionsWithArtifact(groupId, artifactId, version, false); + } + + @Override + public List getProductVersions(Long id, String name, String version, ProductSupportStatus status) { + return productVersionDAO.findProductVersions(id, name, version, status); + } + + @Override + public List getProductVersionsWithArtifactsByStatus(ProductSupportStatus status) { + return productVersionDAO.findProductVersionsWithArtifactsByStatus(status); + } + + @Override + public List getProductVersionsWithArtifactByGAV( + String groupId, + String artifactId, + String version) { + return productVersionDAO.findProductVersionsWithArtifactByGAV(groupId, artifactId, version); + } + + @Override + public List getProductVersionsWithArtifactsByGAStatus( + String groupId, + String artifactId, + ProductSupportStatus status) { + return productVersionDAO.findProductVersionsWithArtifactsByGAStatus(groupId, artifactId, Optional.of(status)); + } + + @Override + public List getProductVersionsWithArtifactsByGA( + String groupId, + String artifactId) { + return productVersionDAO.findProductVersionsWithArtifactsByGAStatus(groupId, artifactId, Optional.empty()); + } + + @Override + public List getAllForProduct(String productName) { + return productVersionDAO.findProductVersionsWithProduct(productName); + } +} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WLFillerImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WLFillerImpl.java new file mode 100644 index 000000000..713887bf8 --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WLFillerImpl.java @@ -0,0 +1,130 @@ +package org.jboss.da.listings.impl.service; + +import org.apache.maven.scm.ScmException; +import org.commonjava.maven.galley.maven.GalleyMavenException; +import org.commonjava.maven.galley.maven.model.view.DependencyView; +import org.commonjava.maven.galley.maven.model.view.MavenPomView; +import org.jboss.da.common.CommunicationException; +import org.jboss.da.common.util.ConfigurationParseException; +import org.jboss.da.communication.indy.api.IndyConnector; +import org.jboss.da.communication.pom.PomAnalysisException; +import org.jboss.da.communication.pom.api.PomAnalyzer; +import org.jboss.da.listings.api.model.Artifact; +import org.jboss.da.listings.api.model.GA; +import org.jboss.da.listings.api.model.ProductVersion; +import org.jboss.da.listings.api.service.WLFiller; +import org.jboss.da.model.rest.GAV; +import org.jboss.da.scm.api.SCM; +import org.jboss.da.scm.api.SCMType; +import org.slf4j.Logger; + +import javax.enterprise.context.ApplicationScoped; +import javax.inject.Inject; + +import java.io.File; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +import org.jboss.da.listings.api.service.ArtifactService.ArtifactStatus; + +@ApplicationScoped +public class WLFillerImpl implements WLFiller { + + @Inject + private Logger log; + + @Inject + private PomAnalyzer analyzer; + + @Inject + private WhiteArtifactServiceImpl whiteService; + + @Inject + private ProductVersionServiceImpl productVersionService; + + @Inject + private IndyConnector indyConnector; + + @Inject + private SCM scmManager; + + @Override + public WLStatus fillWhitelistFromPom( + String scmUrl, + String revision, + String pomPath, + List repositories, + long productId) { + if (!checkProduct(productId)) { + return WLStatus.PRODUCT_NOT_FOUND; + } + try { + fillWLFromPom(getPomListFromGit(scmUrl, revision, pomPath, repositories), productId); + } catch (ScmException | GalleyMavenException | PomAnalysisException e) { + log.error(e.getMessage()); + return WLStatus.ANALYSER_ERROR; + } + return WLStatus.FILLED; + } + + @Override + public WLStatus fillWhitelistFromGAV(String groupId, String artifactId, String version, long productId) { + if (!checkProduct(productId)) { + return WLStatus.PRODUCT_NOT_FOUND; + } + try { + final GAV gav = new GAV(groupId, artifactId, version); + Optional is = indyConnector.getPomStream(gav); + if (is.isPresent()) { + MavenPomView view = analyzer.getMavenPomView(is.get()); + fillWLFromPom(view, productId); + } else { + log.error("POM with given GAV not found in indy " + gav); + return WLStatus.POM_NOT_FOUND; + } + } catch (CommunicationException | ConfigurationParseException | GalleyMavenException e) { + log.error(e.getMessage()); + return WLStatus.ANALYSER_ERROR; + } + return WLStatus.FILLED; + } + + private MavenPomView getPomListFromGit(String scmUrl, String revision, String pomPath, List repositories) + throws GalleyMavenException, PomAnalysisException, ScmException { + + if (repositories == null) { + repositories = new ArrayList<>(); + } + + File clonedDir = scmManager.cloneRepository(SCMType.GIT, scmUrl, revision); + + MavenPomView pom = analyzer.getGitPomView(clonedDir, pomPath, repositories); + + return pom; + } + + private void fillWLFromPom(MavenPomView v, long productId) throws GalleyMavenException { + List dependencies = v.getAllManagedDependencies(); + for (DependencyView d : dependencies) { + GA ga = new GA(d.getGroupId(), d.getArtifactId()); + Artifact a = new Artifact(ga, d.getVersion(), whiteService.currentUser()); + ArtifactStatus status = whiteService + .addArtifact(a.getGa().getGroupId(), a.getGa().getArtifactId(), a.getVersion(), productId); + switch (status) { + case ADDED: + case NOT_MODIFIED: + break; // ok + default: + throw new IllegalStateException( + "Adition of artifact to product list failed. This shouldn't happen and is probably programming bug."); + } + } + } + + private boolean checkProduct(long productId) { + Optional pv = productVersionService.getProductVersion(productId); + return pv.isPresent(); + } +} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactFilterServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactFilterServiceImpl.java new file mode 100644 index 000000000..411e49cc7 --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactFilterServiceImpl.java @@ -0,0 +1,92 @@ +package org.jboss.da.listings.impl.service; + +import java.util.Arrays; +import java.util.List; +import java.util.Optional; +import java.util.stream.Collectors; + +import javax.enterprise.context.ApplicationScoped; +import javax.inject.Inject; + +import org.jboss.da.listings.api.model.BlackArtifact; +import org.jboss.da.listings.api.model.ProductVersion; +import org.jboss.da.listings.api.model.ProductVersionArtifactRelationship; +import org.jboss.da.listings.api.service.BlackArtifactService; +import org.jboss.da.listings.api.service.ProductVersionService; +import org.jboss.da.listings.api.service.WhiteArtifactFilterService; +import org.jboss.da.listings.model.ProductSupportStatus; + +@ApplicationScoped +public class WhiteArtifactFilterServiceImpl implements WhiteArtifactFilterService { + + @Inject + private BlackArtifactService blackArtifactService; + + @Inject + private ProductVersionService productVersionService; + + @Override + public List toProductsContainingOnlyWhiteArtifacts(List products) { + // Get all black artifacts + List allBlackArtifacts = blackArtifactService.getAll(); + + // Remove every blacklisted artifact from a whitelist + for (BlackArtifact ba : allBlackArtifacts) { + for (ProductVersion pv : products) { + pv.getWhiteArtifacts() + .removeIf(x -> x.getGa().equals(ba.getGa()) && x.getVersion().equals(ba.getVersion())); + } + } + return products; + } + + @Override + public List toProductRelsContainingOnlyWhiteArtifacts( + List products) { + List productVersions = products.stream() + .map(ProductVersionArtifactRelationship::getProductVersion) + .collect(Collectors.toList()); + + toProductsContainingOnlyWhiteArtifacts(productVersions); + return products; + } + + @Override + public List getAllWithWhiteArtifacts() { + return toProductsContainingOnlyWhiteArtifacts(productVersionService.getAll()); + } + + @Override + public Optional getProductVersionWithWhiteArtifacts(String name, String version) { + Optional pv = productVersionService.getProductVersion(name, version); + if (pv.isPresent()) { + toProductsContainingOnlyWhiteArtifacts(Arrays.asList(pv.get())); + } + return pv; + } + + @Override + public List getProductVersionsWithWhiteArtifactsByStatus(ProductSupportStatus status) { + return toProductsContainingOnlyWhiteArtifacts( + productVersionService.getProductVersionsWithArtifactsByStatus(status)); + } + + @Override + public List getProductVersionsWithWhiteArtifactsByGAV( + String groupId, + String artifactId, + String version) { + return toProductRelsContainingOnlyWhiteArtifacts( + productVersionService.getProductVersionsWithArtifactByGAV(groupId, artifactId, version)); + } + + @Override + public List getProductVersionsWithWhiteArtifactsByGAStatus( + String groupId, + String artifactId, + ProductSupportStatus status) { + return toProductRelsContainingOnlyWhiteArtifacts( + productVersionService.getProductVersionsWithArtifactsByGAStatus(groupId, artifactId, status)); + } + +} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactServiceImpl.java new file mode 100644 index 000000000..7f77daada --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactServiceImpl.java @@ -0,0 +1,144 @@ +package org.jboss.da.listings.impl.service; + +import java.util.ArrayList; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Optional; + +import javax.enterprise.context.ApplicationScoped; +import javax.inject.Inject; + +import org.jboss.da.listings.api.dao.ArtifactDAO; +import org.jboss.da.listings.api.dao.GADAO; +import org.jboss.da.listings.api.dao.ProductVersionDAO; +import org.jboss.da.listings.api.dao.WhiteArtifactDAO; +import org.jboss.da.listings.api.model.GA; +import org.jboss.da.listings.api.model.ProductVersion; +import org.jboss.da.listings.api.model.WhiteArtifact; +import org.jboss.da.listings.api.service.BlackArtifactService; +import org.jboss.da.listings.api.service.WhiteArtifactService; +import org.jboss.da.model.rest.GAV; +import org.jboss.pnc.common.version.SuffixedVersion; +import org.jboss.pnc.common.version.VersionParser; + +/** + * + * @author Jozef Mrazek <jmrazek@redhat.com> + * + */ +@ApplicationScoped +public class WhiteArtifactServiceImpl extends ArtifactServiceImpl implements WhiteArtifactService { + + @Inject + private BlackArtifactService blackArtifactService; + + @Inject + private WhiteArtifactDAO whiteArtifactDAO; + + @Inject + private GADAO gaDAO; + + @Inject + private ProductVersionDAO productVersionDAO; + + @Override + protected ArtifactDAO getDAO() { + return whiteArtifactDAO; + } + + @Override + public org.jboss.da.listings.api.service.ArtifactService.ArtifactStatus addArtifact( + String groupId, + String artifactId, + String version, + Long productVersionId) { + Optional dbArtifact = whiteArtifactDAO.findArtifact(groupId, artifactId, version); + WhiteArtifact artifact = dbArtifact.orElseGet(() -> createArtifact(groupId, artifactId, version)); + + ProductVersion p = productVersionDAO.read(productVersionId); + + if (p == null) { + throw new IllegalArgumentException("Wrong productId, product with this id not found"); + } + + if (p.getWhiteArtifacts().contains(artifact)) { + return ArtifactStatus.NOT_MODIFIED; + } + final GA ga = artifact.getGa(); + + p.addArtifact(artifact); + productVersionDAO.update(p); + return ArtifactStatus.ADDED; + } + + private WhiteArtifact createArtifact(String groupId, String artifactId, String version) { + SuffixedVersion parsedVersion = versionParser.parse(version); + final boolean is3rdParty = !parsedVersion.isSuffixed(); + final String osgiVersion = VersionParser.getOSGiVersion(version); + + GA ga = gaDAO.findOrCreate(groupId, artifactId); + WhiteArtifact a = new WhiteArtifact(ga, version, currentUser(), osgiVersion, is3rdParty); + whiteArtifactDAO.create(a); + return a; + } + + @Override + public boolean removeArtifractFromProductVersion( + String groupId, + String artifactId, + String version, + Long productVersionId) { + ProductVersion pv = productVersionDAO.read(productVersionId); + if (pv == null) { + return false; + } + Optional a = whiteArtifactDAO.findArtifact(groupId, artifactId, version); + if (a.isPresent()) { + pv.removeArtifact(a.get()); + productVersionDAO.update(pv); + return true; + } + return false; + } + + @Override + public List getArtifacts(String groupId, String artifactId, String version) { + + // Black listed artifacts can't be queried + if (blackArtifactService.isArtifactPresent(groupId, artifactId, version)) { + return new ArrayList<>(); + } + String osgi = VersionParser.getOSGiVersion(version); + + List whites = new ArrayList<>(); + Optional origArtifact = whiteArtifactDAO.findArtifact(groupId, artifactId, version); + Optional normArtifact = whiteArtifactDAO.findArtifact(groupId, artifactId, osgi); + origArtifact.ifPresent(x -> whites.add(x)); + if (!normArtifact.equals(origArtifact)) { + normArtifact.ifPresent(x -> whites.add(x)); + } + List nonDupWhites = new ArrayList<>(new LinkedHashSet<>(whites)); + return nonDupWhites; + } + + @Override + public List getArtifacts(GAV gav) { + return getArtifacts(gav.getGroupId(), gav.getArtifactId(), gav.getVersion()); + } + + @Override + public boolean removeArtifact(String groupId, String artifactId, String version) { + Optional artifact = whiteArtifactDAO.findArtifact(groupId, artifactId, version); + if (artifact.isPresent()) { + List productVersions = productVersionDAO + .findProductVersionsWithArtifact(groupId, artifactId, version, true); + for (ProductVersion pv : productVersions) { + pv.removeArtifact(artifact.get()); + productVersionDAO.update(pv); + } + whiteArtifactDAO.delete(artifact.get()); + return true; + } + return false; + } +} diff --git a/reports-backend/src/main/java/org/jboss/da/products/api/ProductsService.java b/reports-backend/src/main/java/org/jboss/da/products/api/ProductsService.java new file mode 100644 index 000000000..39bb059a6 --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/products/api/ProductsService.java @@ -0,0 +1,12 @@ +package org.jboss.da.products.api; + +import java.util.Set; + +/** + * + * @author Honza Brázdil <jbrazdil@redhat.com> + */ +public interface ProductsService { + + Set difference(long leftProduct, long rightProduct); +} diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/AggregatedProductProvider.java b/reports-backend/src/main/java/org/jboss/da/products/impl/AggregatedProductProvider.java index f74c47e59..b0e39bfa0 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/impl/AggregatedProductProvider.java +++ b/reports-backend/src/main/java/org/jboss/da/products/impl/AggregatedProductProvider.java @@ -6,6 +6,7 @@ import org.jboss.da.products.api.Product; import org.jboss.da.products.api.ProductArtifacts; import org.jboss.da.products.api.ProductProvider; +import org.jboss.da.products.impl.DatabaseProductProvider.Database; import org.jboss.da.products.impl.RepositoryProductProvider.Repository; import org.jboss.da.products.impl.PncProductProvider.Pnc; import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; @@ -65,6 +66,10 @@ public static CompletableFuture> filterProducts( // TODO: filter unknown products, so that when there is artifact both in unknown product and in // known product, it's removed from the unknown + @Inject + @Database + ProductProvider databaseProductProvider; + @Inject @Repository RepositoryProductProvider repositoryProductProvider; @@ -121,6 +126,7 @@ private CompletableFuture aggregate( Collector collector) { final List> results = new ArrayList<>(); + results.add(getter.apply(databaseProductProvider)); results.add(getter.apply(repositoryProductProvider)); results.add(getter.apply(pncProductProvider)); diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/DatabaseProductProvider.java b/reports-backend/src/main/java/org/jboss/da/products/impl/DatabaseProductProvider.java new file mode 100644 index 000000000..44d84fbce --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/products/impl/DatabaseProductProvider.java @@ -0,0 +1,164 @@ +package org.jboss.da.products.impl; + +import org.jboss.da.listings.api.dao.ProductVersionDAO; +import org.jboss.da.listings.api.model.ProductVersion; +import org.jboss.da.listings.api.model.ProductVersionArtifactRelationship; +import org.jboss.da.listings.api.model.WhiteArtifact; +import org.jboss.da.listings.model.ProductSupportStatus; +import org.jboss.da.model.rest.GA; +import org.jboss.da.model.rest.GAV; +import org.jboss.da.products.api.Artifact; +import org.jboss.da.products.api.ArtifactType; +import org.jboss.da.products.api.MavenArtifact; +import org.jboss.da.products.api.Product; +import org.jboss.da.products.api.ProductArtifacts; +import org.jboss.da.products.api.ProductProvider; +import org.jboss.da.products.impl.DatabaseProductProvider.Database; +import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; + +import javax.inject.Inject; +import javax.inject.Qualifier; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE; +import java.lang.annotation.Retention; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import java.lang.annotation.Target; +import java.util.Collection; +import java.util.Collections; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.function.Supplier; +import java.util.stream.Collectors; + +/** + * + * @author Honza Brázdil <jbrazdil@redhat.com> + */ +@Database +public class DatabaseProductProvider implements ProductProvider { + + @Inject + private ProductVersionDAO productVersionDAO; + + @Override + public CompletableFuture> getAllProducts() { + return getProductsAsync(() -> productVersionDAO.findAll()); + } + + @Override + public CompletableFuture> getProductsByName(String name) { + return getProductsAsync(() -> productVersionDAO.findProductVersionsWithProduct(name)); + } + + @Override + public CompletableFuture> getProductsByStatus(ProductSupportStatus status) { + return getProductsAsync(() -> productVersionDAO.findProductVersionsWithArtifactsByStatus(status)); + } + + @Override + public CompletableFuture> getArtifacts(Product product) { + return CompletableFuture.supplyAsync(() -> _getArtifacts(product)); + } + + private Set _getArtifacts(Product product) { + return productVersionDAO.findProductVersion(product.getName(), product.getVersion()) + .map(ProductVersion::getWhiteArtifacts) + .orElseGet(Collections::emptySet) + .stream() + .map(DatabaseProductProvider::toArtifact) + .collect(Collectors.toSet()); + } + + @Override + public CompletableFuture> getArtifacts(Artifact artifact) { + if (artifact.getType() != ArtifactType.MAVEN) { + return CompletableFuture.completedFuture(Collections.emptySet()); + } + GA ga = ((MavenArtifact) artifact).getGav().getGA(); + return CompletableFuture.supplyAsync(() -> getArtifacts(ga.getGroupId(), ga.getArtifactId(), Optional.empty())); + } + + @Override + public CompletableFuture> getArtifacts(Artifact artifact, ProductSupportStatus status) { + if (artifact.getType() != ArtifactType.MAVEN) { + return CompletableFuture.completedFuture(Collections.emptySet()); + } + GA ga = ((MavenArtifact) artifact).getGav().getGA(); + return CompletableFuture + .supplyAsync(() -> getArtifacts(ga.getGroupId(), ga.getArtifactId(), Optional.of(status))); + } + + @Override + public CompletableFuture>> getVersions(Artifact artifact) { + if (artifact.getType() != ArtifactType.MAVEN) { + return CompletableFuture.completedFuture(Collections.emptyMap()); + } + GA ga = ((MavenArtifact) artifact).getGav().getGA(); + return CompletableFuture.supplyAsync( + () -> getArtifacts(ga.getGroupId(), ga.getArtifactId(), Optional.empty()).stream() + .collect( + Collectors.toMap( + ProductArtifacts::getProduct, + x -> x.getArtifacts() + .stream() + .map(Artifact::getVersion) + .map(QualifiedVersion::new) + .collect(Collectors.toSet())))); + } + + @Override + public CompletableFuture> getAllVersions(Artifact artifact) { + if (artifact.getType() != ArtifactType.MAVEN) { + return CompletableFuture.completedFuture(Collections.emptySet()); + } + GA ga = ((MavenArtifact) artifact).getGav().getGA(); + return CompletableFuture.supplyAsync( + () -> getArtifacts(ga.getGroupId(), ga.getArtifactId(), Optional.empty()).stream() + .flatMap(a -> a.getArtifacts().stream()) + .map(Artifact::getVersion) + .map(QualifiedVersion::new) + .collect(Collectors.toSet())); + } + + private Set getArtifacts( + final String groupId, + final String artifactId, + final Optional st) { + return productVersionDAO.findProductVersionsWithArtifactsByGAStatus(groupId, artifactId, st) + .stream() + .map(DatabaseProductProvider::toProductArtifacts) + .collect(Collectors.toSet()); + } + + private CompletableFuture> getProductsAsync( + final Supplier> productsSupplier) { + return CompletableFuture.supplyAsync(productsSupplier) + .thenApply(pvs -> pvs.stream().map(DatabaseProductProvider::toProduct).collect(Collectors.toSet())); + } + + private static Product toProduct(ProductVersion p) { + return new Product(p.getProduct().getName(), p.getProductVersion(), p.getSupport()); + } + + private static ProductArtifacts toProductArtifacts(ProductVersionArtifactRelationship pvar) { + return new ProductArtifacts( + toProduct(pvar.getProductVersion()), + Collections.singleton(toArtifact(pvar.getArtifact()))); + } + + private static Artifact toArtifact(WhiteArtifact a) { + final org.jboss.da.listings.api.model.GA ga = a.getGa(); + return new MavenArtifact(new GAV(a.getGa().getGroupId(), ga.getArtifactId(), a.getVersion())); + } + + @Qualifier + @Retention(RUNTIME) + @Target({ TYPE, METHOD, FIELD, PARAMETER }) + public static @interface Database { + } +} diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/ProductsServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/products/impl/ProductsServiceImpl.java new file mode 100644 index 000000000..de424b9ed --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/products/impl/ProductsServiceImpl.java @@ -0,0 +1,67 @@ +package org.jboss.da.products.impl; + +import org.jboss.da.listings.api.dao.ProductVersionDAO; +import org.jboss.da.listings.api.model.GA; +import org.jboss.da.listings.api.model.ProductVersion; +import org.jboss.da.listings.api.model.WhiteArtifact; +import org.jboss.da.products.api.ArtifactDiff; +import org.jboss.da.products.api.ProductsService; +import org.jboss.pnc.common.version.VersionComparator; +import org.jboss.pnc.common.version.VersionComparator.VersionDifference; +import org.jboss.pnc.common.version.VersionParser; + +import javax.inject.Inject; + +import java.util.HashSet; +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; + +import static org.jboss.da.reports.impl.ReportsGeneratorImpl.DEFAULT_SUFFIX; + +/** + * + * @author Honza Brázdil <jbrazdil@redhat.com> + */ +public class ProductsServiceImpl implements ProductsService { + + @Inject + private ProductVersionDAO productVersionDAO; + + @Override + public Set difference(long leftProduct, long rightProduct) { + ProductVersion left = productVersionDAO.read(leftProduct); + ProductVersion right = productVersionDAO.read(rightProduct); + if (left == null || right == null) { + throw new IllegalArgumentException( + "One or both of the products (" + leftProduct + ", " + rightProduct + ") doesn't exists."); + } + Set leftArtifacts = left.getWhiteArtifacts(); + Set rightArtifacts = right.getWhiteArtifacts(); + Set allGAs = new HashSet<>(); + Map leftGAs = leftArtifacts.stream() + .peek(o -> allGAs.add(o.getGa())) + .collect(Collectors.toMap(WhiteArtifact::getGa, WhiteArtifact::getOsgiVersion)); + Map rightGAs = rightArtifacts.stream() + .peek(o -> allGAs.add(o.getGa())) + .collect(Collectors.toMap(WhiteArtifact::getGa, WhiteArtifact::getOsgiVersion)); + Set ret = new HashSet<>(); + + VersionComparator comparator = new VersionComparator(new VersionParser(DEFAULT_SUFFIX)); + for (GA ga : allGAs) { + String leftVersion = leftGAs.get(ga); + String rightVersion = rightGAs.get(ga); + VersionDifference difference = null; + if (leftVersion != null && rightVersion != null) { + difference = comparator.difference(leftVersion, rightVersion); + } + ArtifactDiff ad = new ArtifactDiff( + leftVersion, + new org.jboss.da.model.rest.GA(ga.getGroupId(), ga.getArtifactId()), + rightVersion, + difference); + ret.add(ad); + } + return ret; + } +} diff --git a/reports-backend/src/main/java/org/jboss/da/reports/backend/impl/ProductAdapter.java b/reports-backend/src/main/java/org/jboss/da/reports/backend/impl/ProductAdapter.java new file mode 100644 index 000000000..57ce64c26 --- /dev/null +++ b/reports-backend/src/main/java/org/jboss/da/reports/backend/impl/ProductAdapter.java @@ -0,0 +1,104 @@ +/* + * Copyright 2018 Honza Brázdil <jbrazdil@redhat.com>. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jboss.da.reports.backend.impl; + +import org.jboss.da.listings.api.dao.ProductDAO; +import org.jboss.da.listings.api.dao.ProductVersionDAO; +import org.jboss.da.listings.api.model.ProductVersion; +import org.jboss.da.listings.api.service.ProductVersionService; +import org.jboss.da.products.api.Product; +import org.jboss.da.products.api.ProductProvider; + +import javax.enterprise.context.ApplicationScoped; +import javax.inject.Inject; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; + +/** + * This bean is used to translate products identified by the DB identifiers to abstract product objects used by Product + * Providers. + * + * @see Product + * @see ProductProvider + * @author Honza Brázdil <jbrazdil@redhat.com> + */ +@ApplicationScoped +public class ProductAdapter { + + @Inject + private ProductDAO productDao; + + @Inject + private ProductVersionDAO productVersionDao; + + @Inject + private ProductVersionService productVersionService; + + public Set toProducts(Set productNames, Set productVersionIds) { + Set productVersions = new HashSet<>(); + StringBuilder errorMsg = new StringBuilder(); + + if (productNames != null && !productNames.isEmpty()) { + List productsByName = productDao + .findAllWithNames(new ArrayList<>(productNames)); + if (productNames.size() == productsByName.size()) { + for (String productName : productNames) { + List prodVers = productVersionService.getAllForProduct(productName); + productVersions.addAll(prodVers); + } + } else { + // Error + Set unexistingProductNames = new HashSet<>(productNames); + productsByName.stream().forEach(x -> unexistingProductNames.remove(x.getName())); + errorMsg.append("Product names do not exist: "); + errorMsg.append(joinMissing(unexistingProductNames)); + } + } + + if (productVersionIds != null && !productVersionIds.isEmpty()) { + List prodVersionsById = productVersionDao + .findAllWithIds(new ArrayList<>(productVersionIds)); + if (productVersionIds.size() == prodVersionsById.size()) { + productVersions.addAll(prodVersionsById); + } else { + // Error + Set unexistingProductVersionIds = new HashSet<>(productVersionIds); + prodVersionsById.stream().forEach(x -> unexistingProductVersionIds.remove(x.getId())); + errorMsg.append("Product Versions do not exist: "); + errorMsg.append(joinMissing(unexistingProductVersionIds)); + } + } + + if (errorMsg.length() > 0) { + throw new IllegalArgumentException(errorMsg.toString()); + } + + return productVersions.stream().map(ProductAdapter::toProduct).collect(Collectors.toSet()); + } + + private String joinMissing(Collection invalidItems) { + return invalidItems.stream().map(Object::toString).collect(Collectors.joining(",", "[", "];")); + } + + private static Product toProduct(ProductVersion pv) { + return new Product(pv.getProduct().getName(), pv.getProductVersion()); + } +} diff --git a/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java b/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java index 088e4187b..7371ad31f 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java @@ -37,6 +37,7 @@ import org.jboss.da.reports.api.ProductArtifact; import org.jboss.da.reports.api.ReportsGenerator; import org.jboss.da.reports.backend.api.DependencyTreeGenerator; +import org.jboss.da.reports.backend.impl.ProductAdapter; import org.jboss.da.reports.model.api.SCMLocator; import org.jboss.da.reports.model.request.LookupGAVsRequest; import org.jboss.da.reports.model.request.LookupNPMRequest; @@ -125,6 +126,9 @@ public class ReportsGeneratorImpl implements ReportsGenerator { @Repository private RepositoryProductProvider repositoryProductProvider; + @Inject + private ProductAdapter productAdapter; + private Map modes; @Inject @@ -142,11 +146,14 @@ public Optional getReportFromSCM(SCMReportRequest scml) throw new IllegalArgumentException("SCM information can't be null"); } + Set products = productAdapter.toProducts(scml.getProductNames(), scml.getProductVersionIds()); GAVDependencyTree dt = dependencyTreeGenerator.getDependencyTree(scml.getScml()); - return createReport(dt); + + return createReport(dt, products); } - private Optional createReport(GAVDependencyTree dt) throws CommunicationException { + private Optional createReport(GAVDependencyTree dt, Set products) + throws CommunicationException { ArtifactReport report = new ArtifactReport(dt.getGav()); Set nodesVisited = new HashSet<>(); @@ -154,7 +161,7 @@ private Optional createReport(GAVDependencyTree dt) throws Commu addDependencyReports(report, dt.getDependencies(), nodesVisited); List> futures = new ArrayList<>(); - traverseAndFill(report, futures); + traverseAndFill(report, products, futures); FuturesUtil.joinFutures(futures); @@ -179,18 +186,18 @@ private void addDependencyReports( } } - private void traverseAndFill(ArtifactReport report, List> futures) { - futures.add(fillArtifactReport(report)); + private void traverseAndFill(ArtifactReport report, Set products, List> futures) { + futures.add(fillArtifactReport(report, products)); for (ArtifactReport dep : report.getDependencies()) { - traverseAndFill(dep, futures); + traverseAndFill(dep, products, futures); } } - private CompletableFuture fillArtifactReport(ArtifactReport report) { + private CompletableFuture fillArtifactReport(ArtifactReport report, Set products) { GAV gav = report.getGav(); CompletableFuture> artifacts = aggProductProvider.getArtifacts(new MavenArtifact(gav)); - artifacts = filterProductArtifacts(artifacts); + artifacts = filterProductArtifacts(products, artifacts); report.setBlacklisted(blackArtifactService.isArtifactPresent(gav)); List suffixes = Collections.singletonList(DEFAULT_SUFFIX); @@ -236,9 +243,10 @@ public Optional getAdvancedReportFromSCM(SCMReportReques throws ScmException, PomAnalysisException, CommunicationException { SCMLocator scml = request.getScml(); + Set products = productAdapter.toProducts(request.getProductNames(), request.getProductVersionIds()); GAVDependencyTree dt = dependencyTreeGenerator.getDependencyTree(scml); - Optional artifactReport = createReport(dt); + Optional artifactReport = createReport(dt, products); // TODO: hardcoded to git // hopefully we'll get the cached cloned folder for this repo File repoFolder = scmManager.cloneRepository(SCMType.GIT, scml.getScmUrl(), scml.getRevision()); @@ -315,6 +323,7 @@ public Set getAligmentReport( scml.getRevision(), scml.getPomPath(), scml.getRepositories()); + Set products = productAdapter.toProducts(Collections.emptySet(), productIds); List> futures = new ArrayList<>(); Set ret = new TreeSet<>(Comparator.comparing(x -> x.getModule())); @@ -341,6 +350,7 @@ public Set getAligmentReport( CompletableFuture> artifacts = filterProducts( useUnknownProduct, + products, aggProductProvider.getArtifacts(new MavenArtifact(gav))); CompletableFuture versions = analyzeVersions( Collections.singletonList(DEFAULT_SUFFIX), @@ -384,14 +394,18 @@ private static Set getBuilt(Set a, VersionAn private CompletableFuture> filterProducts( boolean useUnknownProduct, + Set products, CompletableFuture> artifacts) { - Predicate pred = p -> p.getStatus() == SUPPORTED || p.getStatus() == SUPERSEDED; - if (useUnknownProduct) { - pred = pred.or(p -> UNKNOWN.equals(p)); + Predicate pred = (x) -> true; + if (products.isEmpty()) { + pred = pred.and(p -> p.getStatus() == SUPPORTED || p.getStatus() == SUPERSEDED); + if (useUnknownProduct) { + pred = pred.or(p -> UNKNOWN.equals(p)); + } } - artifacts = filterProductArtifacts(artifacts, pred); + artifacts = filterProductArtifacts(products, artifacts, pred); return artifacts; } @@ -624,12 +638,13 @@ private Map>> getProductArtifactsPer ProductProvider productProvider, LookupGAVsRequest request, Set uniqueGAs) throws CommunicationException { + Set products = productAdapter.toProducts(request.getProductNames(), request.getProductVersionIds()); Map>> gaProductArtifactsMap = new HashMap<>(); for (GA ga : uniqueGAs) { CompletableFuture> artifacts = productProvider .getArtifacts(new MavenArtifact(new GAV(ga, "0.0.0"))); - artifacts = filterProductArtifacts(artifacts); + artifacts = filterProductArtifacts(products, artifacts); gaProductArtifactsMap.put(ga, artifacts); } @@ -691,13 +706,18 @@ private static ProductArtifact toProductArtifact( } private CompletableFuture> filterProductArtifacts( + Set products, CompletableFuture> artifacts) { - return filterProductArtifacts(artifacts, x -> true); + return filterProductArtifacts(products, artifacts, x -> true); } private CompletableFuture> filterProductArtifacts( + Set products, CompletableFuture> artifacts, Predicate pred) { + if (!products.isEmpty()) { + pred = pred.and(p -> products.contains(p)); + } artifacts = AggregatedProductProvider.filterProducts(artifacts, pred); artifacts = filterBuiltArtifacts(artifacts); return artifacts; diff --git a/reports-backend/src/test/java/org/jboss/da/reports/impl/ReportsGeneratorImplTest.java b/reports-backend/src/test/java/org/jboss/da/reports/impl/ReportsGeneratorImplTest.java index 31ea17275..e6933d94d 100644 --- a/reports-backend/src/test/java/org/jboss/da/reports/impl/ReportsGeneratorImplTest.java +++ b/reports-backend/src/test/java/org/jboss/da/reports/impl/ReportsGeneratorImplTest.java @@ -21,6 +21,8 @@ import org.jboss.da.communication.indy.api.IndyConnector; import org.jboss.da.communication.indy.model.GAVDependencyTree; import org.jboss.da.listings.api.service.BlackArtifactService; +import org.jboss.da.listings.api.service.ProductVersionService; +import org.jboss.da.listings.api.service.WhiteArtifactService; import org.jboss.da.listings.model.ProductSupportStatus; import org.jboss.da.model.rest.GA; import org.jboss.da.model.rest.GAV; @@ -35,6 +37,7 @@ import org.jboss.da.reports.api.ArtifactReport; import org.jboss.da.reports.backend.api.DependencyTreeGenerator; import org.jboss.da.reports.backend.impl.DependencyTreeGeneratorImpl; +import org.jboss.da.reports.backend.impl.ProductAdapter; import org.jboss.da.reports.model.request.GAVRequest; import org.jboss.da.reports.model.request.LookupGAVsRequest; import org.jboss.da.reports.model.response.LookupReport; @@ -70,6 +73,12 @@ public class ReportsGeneratorImplTest { @Mock private BlackArtifactService blackArtifactService; + @Mock + private WhiteArtifactService whiteArtifactService; + + @Mock + private ProductVersionService productVersionService; + @Mock private AggregatedProductProvider productProvider; @@ -85,6 +94,10 @@ public class ReportsGeneratorImplTest { @UserLog private Logger userLog; + @InjectMocks + @Spy + private final ProductAdapter productAdapter = new ProductAdapter(); + @InjectMocks @Spy private final DependencyTreeGenerator dependencyTreeGenerator = new DependencyTreeGeneratorImpl(); diff --git a/reports-model/src/main/java/org/jboss/da/products/model/rest/GADiff.java b/reports-model/src/main/java/org/jboss/da/products/model/rest/GADiff.java new file mode 100644 index 000000000..b825d5f9f --- /dev/null +++ b/reports-model/src/main/java/org/jboss/da/products/model/rest/GADiff.java @@ -0,0 +1,82 @@ +package org.jboss.da.products.model.rest; + +import org.jboss.da.model.rest.GA; +import org.jboss.da.model.rest.DummyVersionComparator; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonProperty; + +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.NonNull; + +/** + * + * @author jbrazdil + */ +@EqualsAndHashCode +public class GADiff implements Comparable { + + @NonNull + private final GA ga; + + @Getter + @NonNull + private final String leftVersion; + + @Getter + @NonNull + private final String rightVersion; + + @Getter + @NonNull + private final String differenceType; + + @JsonCreator + public GADiff( + @JsonProperty("groupId") String groupId, + @JsonProperty("artifactId") String artifactId, + @JsonProperty("leftVersion") String leftVersion, + @JsonProperty("rightVersion") String rightVersion, + @JsonProperty("differenceType") String differenceType) { + this.ga = new GA(groupId, artifactId); + this.leftVersion = leftVersion; + this.rightVersion = rightVersion; + this.differenceType = differenceType; + } + + public GADiff(GA ga, String leftVersion, String rightVersion, String differenceType) { + this.ga = ga; + this.leftVersion = leftVersion; + this.rightVersion = rightVersion; + this.differenceType = differenceType; + } + + @JsonIgnore + public GA getGA() { + return ga; + } + + public String getGroupId() { + return ga.getGroupId(); + } + + public String getArtifactId() { + return ga.getArtifactId(); + } + + @Override + public int compareTo(GADiff o) { + int gaCmp = this.ga.compareTo(o.ga); + if (gaCmp != 0) { + return gaCmp; + } + gaCmp = DummyVersionComparator.compareVersions(this.leftVersion, o.leftVersion); + if (gaCmp != 0) { + return gaCmp; + } + return DummyVersionComparator.compareVersions(this.rightVersion, o.rightVersion); + } + +} diff --git a/reports-model/src/main/java/org/jboss/da/products/model/rest/ProductDiff.java b/reports-model/src/main/java/org/jboss/da/products/model/rest/ProductDiff.java new file mode 100644 index 000000000..985746c7e --- /dev/null +++ b/reports-model/src/main/java/org/jboss/da/products/model/rest/ProductDiff.java @@ -0,0 +1,54 @@ +package org.jboss.da.products.model.rest; + +import org.jboss.da.listings.model.rest.RestProduct; +import org.jboss.da.model.rest.GAV; + +import java.util.Set; +import java.util.TreeSet; + +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.NonNull; +import lombok.Setter; +import lombok.ToString; + +/** + * + * @author Honza Brázdil <jbrazdil@redhat.com> + */ +@NoArgsConstructor +@EqualsAndHashCode +@ToString +public class ProductDiff { + + @Getter + @Setter + @NonNull + private RestProduct leftProduct; + + @Getter + @Setter + @NonNull + private RestProduct rightProduct; + + @Getter + @Setter + @NonNull + private Set added = new TreeSet<>(); + + @Getter + @Setter + @NonNull + private Set removed = new TreeSet<>(); + + @Getter + @Setter + @NonNull + private Set changed = new TreeSet<>(); + + @Getter + @Setter + @NonNull + private Set unchanged = new TreeSet<>(); +} diff --git a/reports-model/src/main/java/org/jboss/da/reports/model/response/striped/WLStripper.java b/reports-model/src/main/java/org/jboss/da/reports/model/response/striped/WLStripper.java index 6a48a649c..0058a88a0 100644 --- a/reports-model/src/main/java/org/jboss/da/reports/model/response/striped/WLStripper.java +++ b/reports-model/src/main/java/org/jboss/da/reports/model/response/striped/WLStripper.java @@ -1,5 +1,6 @@ package org.jboss.da.reports.model.response.striped; +import lombok.extern.slf4j.Slf4j; import org.jboss.da.reports.model.response.*; import org.jboss.da.reports.model.response.RestVersionProduct; diff --git a/reports-model/src/test/java/org/jboss/da/model/rest/BackwardCompatibilityTest.java b/reports-model/src/test/java/org/jboss/da/model/rest/BackwardCompatibilityTest.java index 0929dadcb..7bcbef965 100644 --- a/reports-model/src/test/java/org/jboss/da/model/rest/BackwardCompatibilityTest.java +++ b/reports-model/src/test/java/org/jboss/da/model/rest/BackwardCompatibilityTest.java @@ -11,6 +11,7 @@ import org.jboss.da.listings.model.rest.RestProductInput; import org.jboss.da.listings.model.rest.SuccessResponse; import org.jboss.da.listings.model.rest.WLFill; +import org.jboss.da.products.model.rest.GADiff; import org.jboss.da.reports.model.request.GAVRequest; import org.jboss.da.reports.model.response.LookupReport; import org.jboss.da.reports.model.response.Report; @@ -139,6 +140,13 @@ public void testGAV() throws IOException { compare(gav, "GAV"); } + @Test + public void testGADiff() throws IOException { + GADiff gadiff = new GADiff(new GA("g", "a"), "1.0.0", "1.0.1", "MICRO"); + + compare(gadiff, "GADiff"); + } + @Test public void testGAVRequest() throws IOException { GAVRequest gavRequest = new GAVRequest("g", "a", "v", new HashSet<>(), new HashSet<>()); diff --git a/reports-rest/src/main/java/org/jboss/da/rest/ReportsRestActivator.java b/reports-rest/src/main/java/org/jboss/da/rest/ReportsRestActivator.java index d7bfcc74e..a991b5f72 100644 --- a/reports-rest/src/main/java/org/jboss/da/rest/ReportsRestActivator.java +++ b/reports-rest/src/main/java/org/jboss/da/rest/ReportsRestActivator.java @@ -18,7 +18,9 @@ import org.jboss.da.rest.exceptions.AllExceptionsMapper; import org.jboss.da.rest.filter.MDCLoggingFilter; +import org.jboss.da.rest.listings.Artifacts; import org.jboss.da.rest.listings.BlackListImpl; +import org.jboss.da.rest.products.Products; import org.jboss.da.rest.reports.Reports; import org.jboss.pnc.pncmetrics.rest.GeneralRestMetricsFilter; import org.jboss.pnc.pncmetrics.rest.TimedMetric; @@ -78,8 +80,10 @@ public void addSwaggerResources(Set> resources) { */ public void addProjectResources(Set> resources) { resources.add(Root.class); + resources.add(Artifacts.class); resources.add(Reports.class); resources.add(LookupImpl.class); + resources.add(Products.class); resources.add(BlackListImpl.class); resources.add(VersionEndpointImpl.class); } diff --git a/reports-rest/src/main/java/org/jboss/da/rest/listings/Artifacts.java b/reports-rest/src/main/java/org/jboss/da/rest/listings/Artifacts.java new file mode 100644 index 000000000..a60221c2f --- /dev/null +++ b/reports-rest/src/main/java/org/jboss/da/rest/listings/Artifacts.java @@ -0,0 +1,416 @@ +package org.jboss.da.rest.listings; + +import io.opentelemetry.instrumentation.annotations.SpanAttribute; +import io.opentelemetry.instrumentation.annotations.WithSpan; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.tags.Tag; +import org.jboss.da.listings.api.model.ProductVersion; +import org.jboss.da.listings.api.service.ArtifactService.ArtifactStatus; +import org.jboss.da.listings.api.service.BlackArtifactService; +import org.jboss.da.listings.api.service.ProductService; +import org.jboss.da.listings.api.service.ProductVersionService; +import org.jboss.da.listings.api.service.WLFiller; +import org.jboss.da.listings.api.service.WhiteArtifactFilterService; +import org.jboss.da.listings.api.service.WhiteArtifactService; +import org.jboss.da.listings.model.ProductSupportStatus; +import org.jboss.da.listings.model.rest.RestArtifact; +import org.jboss.da.listings.model.rest.RestProduct; +import org.jboss.da.listings.model.rest.RestProductArtifact; +import org.jboss.da.listings.model.rest.RestProductGAV; +import org.jboss.da.listings.model.rest.RestProductInput; +import org.jboss.da.listings.model.rest.SuccessResponse; +import org.jboss.da.listings.model.rest.WLFill; +import org.jboss.da.model.rest.ErrorMessage; +import org.jboss.da.validation.Validation; +import org.jboss.da.validation.ValidationException; + +import javax.inject.Inject; +import javax.persistence.EntityNotFoundException; +import javax.ws.rs.Consumes; +import javax.ws.rs.DELETE; +import javax.ws.rs.GET; +import javax.ws.rs.POST; +import javax.ws.rs.PUT; +import javax.ws.rs.Path; +import javax.ws.rs.Produces; +import javax.ws.rs.QueryParam; +import javax.ws.rs.core.MediaType; +import javax.ws.rs.core.Response; +import javax.ws.rs.core.Response.Status; + +import java.util.Collection; +import java.util.Optional; + +/** + * + * @author Jozef Mrazek <jmrazek@redhat.com> + * @author Jakub Bartecek <jbartece@redhat.com> + * + */ +@Path("/listings") +@Tag(name = "deprecated") +public class Artifacts { + + @Inject + private RestConvert convert; + + @Inject + private WLFiller filler; + + @Inject + private WhiteArtifactService whiteService; + + @Inject + private BlackArtifactService blackService; + + @Inject + private ProductService productService; + + @Inject + private ProductVersionService productVersionService; + + @Inject + private WhiteArtifactFilterService whiteArtifactFilterService; + + @Inject + private Validation validation; + + // ////////////////////////////////// + // Whitelist endpoints + + @GET + @Path("/whitelist") + @Produces(MediaType.APPLICATION_JSON) + @Operation(deprecated = true) + @WithSpan() + public Collection getAllWhiteArtifacts() { + return convert.toRestProductGAVList(whiteArtifactFilterService.getAllWithWhiteArtifacts()); + } + + @POST + @Path("/whitelist/fill/scm") + @Consumes(MediaType.APPLICATION_JSON) + @Produces(MediaType.APPLICATION_JSON) + @Operation(deprecated = true) + @WithSpan() + public Response fillFromGitBom(@SpanAttribute(value = "wlFill") WLFill wlFill) { + + SuccessResponse response = new SuccessResponse(); + try { + validation.validation(wlFill, "Filling product from GIT POM failed"); + } catch (ValidationException e) { + return e.getResponse(); + } + WLFiller.WLStatus result = filler.fillWhitelistFromPom( + wlFill.getScmUrl(), + wlFill.getRevision(), + wlFill.getPomPath(), + wlFill.getRepositories(), + wlFill.getProductId()); + switch (result) { + case PRODUCT_NOT_FOUND: + response.setSuccess(false); + response.setMessage("Product with this id not found"); + return Response.status(Status.NOT_FOUND).entity(response).build(); + case FILLED: + response.setSuccess(true); + return Response.ok().entity(response).build(); + case ANALYSER_ERROR: + response.setSuccess(false); + response.setMessage("Error while analysing pom file"); + return Response.status(Status.BAD_REQUEST).entity(response).build(); + default: + return Response.status(Status.INTERNAL_SERVER_ERROR) + .entity( + new ErrorMessage( + ErrorMessage.ErrorType.UNEXPECTED_SERVER_ERR, + "Unexpected server error occurred", + "Result was " + result)) + .build(); + } + } + + @POST + @Path("/whitelist/fill/gav") + @Consumes(MediaType.APPLICATION_JSON) + @Produces(MediaType.APPLICATION_JSON) + @Operation(deprecated = true) + @WithSpan() + public Response fillFromGAVBom(@SpanAttribute(value = "a") RestProductArtifact a) { + SuccessResponse response = new SuccessResponse(); + WLFiller.WLStatus result = filler + .fillWhitelistFromGAV(a.getGroupId(), a.getArtifactId(), a.getVersion(), a.getProductId()); + switch (result) { + case PRODUCT_NOT_FOUND: + response.setSuccess(false); + response.setMessage("Product with this id not found"); + return Response.status(Status.NOT_FOUND).entity(response).build(); + case FILLED: + response.setSuccess(true); + return Response.ok().entity(response).build(); + case ANALYSER_ERROR: + response.setSuccess(false); + response.setMessage("Error while analysing pom file"); + return Response.status(Status.BAD_REQUEST).entity(response).build(); + case POM_NOT_FOUND: + response.setSuccess(false); + response.setMessage("Could not found pom file in repository"); + return Response.status(Status.NOT_FOUND).entity(response).build(); + default: + return Response.status(Status.INTERNAL_SERVER_ERROR) + .entity( + new ErrorMessage( + ErrorMessage.ErrorType.UNEXPECTED_SERVER_ERR, + "Unexpected server error occurred", + "Result was " + result)) + .build(); + } + } + + @POST + @Path("/whitelist/gav") + @Consumes(MediaType.APPLICATION_JSON) + @Produces(MediaType.APPLICATION_JSON) + @Operation(deprecated = true) + @WithSpan() + public Response addWhiteArtifact(@SpanAttribute(value = "artifact") RestProductArtifact artifact) { + SuccessResponse response = new SuccessResponse(); + try { + ArtifactStatus result = whiteService.addArtifact( + artifact.getGroupId(), + artifact.getArtifactId(), + artifact.getVersion(), + artifact.getProductId()); + switch (result) { + case ADDED: + response.setSuccess(true); + return Response.ok(response).build(); + case IS_BLACKLISTED: + return Response.status(Response.Status.CONFLICT) + .entity( + new ErrorMessage( + ErrorMessage.ErrorType.BLACKLIST, + "Can't add artifact to whitelist, artifact is blacklisted", + null)) + .build(); + case NOT_MODIFIED: + response.setSuccess(false); + return Response.ok(response).build(); + default: + return Response.status(Response.Status.INTERNAL_SERVER_ERROR) + .entity( + new ErrorMessage( + ErrorMessage.ErrorType.UNEXPECTED_SERVER_ERR, + "Unexpected server error occurred.", + "Result was " + result)) + .build(); + } + } catch (IllegalArgumentException ex) { + return Response.status(Response.Status.BAD_REQUEST).entity(ex.getMessage()).build(); + } + } + + @DELETE + @Path("/whitelist/gav") + @Consumes(MediaType.APPLICATION_JSON) + @Produces(MediaType.APPLICATION_JSON) + @Operation(deprecated = true) + @WithSpan() + public SuccessResponse removeWhiteArtifact(@SpanAttribute(value = "artifact") RestArtifact artifact) { + SuccessResponse response = new SuccessResponse(); + response.setSuccess( + whiteService.removeArtifact(artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion())); + return response; + } + + @DELETE + @Path("/whitelist/gavproduct") + @Consumes(MediaType.APPLICATION_JSON) + @Produces(MediaType.APPLICATION_JSON) + @Operation(deprecated = true) + @WithSpan() + public SuccessResponse removeWhiteArtifactFromProduct( + @SpanAttribute(value = "artifact") RestProductArtifact artifact) { + SuccessResponse response = new SuccessResponse(); + response.setSuccess( + whiteService.removeArtifractFromProductVersion( + artifact.getGroupId(), + artifact.getArtifactId(), + artifact.getVersion(), + artifact.getProductId())); + return response; + } + + // ////////////////////////////// + // whitelist products endpoints + + @POST + @Path("/whitelist/product") + @Consumes(MediaType.APPLICATION_JSON) + @Produces(MediaType.APPLICATION_JSON) + @Operation(deprecated = true) + @WithSpan() + public Response addProduct(@SpanAttribute(value = "product") RestProductInput product) { + SuccessResponse response = new SuccessResponse(); + if (product.getName().isEmpty() || product.getVersion().isEmpty()) { + return Response.status(Response.Status.BAD_REQUEST) + .entity( + new ErrorMessage( + ErrorMessage.ErrorType.PARAMS_REQUIRED, + "Name and version parameters are required", + null)) + .build(); + } + if (product.getSupportStatus() == null) { + product.setSupportStatus(ProductSupportStatus.SUPPORTED); + } + response.setSuccess( + productService.addProduct(product.getName(), product.getVersion(), product.getSupportStatus())); + Long id = productVersionService.getProductVersion(product.getName(), product.getVersion()).get().getId(); + response.setId(id); + return Response.ok(response).build(); + } + + @DELETE + @Path("/whitelist/product") + @Consumes(MediaType.APPLICATION_JSON) + @Produces(MediaType.APPLICATION_JSON) + @Operation(deprecated = true) + @WithSpan() + public Response removeProduct(@SpanAttribute(value = "product") RestProductInput product) { + SuccessResponse response = new SuccessResponse(); + try { + response.setSuccess(productService.removeProduct(product.getName(), product.getVersion())); + } catch (EntityNotFoundException e) { + return Response.status(Response.Status.NOT_FOUND) + .entity( + new ErrorMessage( + ErrorMessage.ErrorType.PRODUCT_NOT_FOUND, + "Product not found", + e.getMessage())) + .build(); + } + return Response.ok(response).build(); + } + + @PUT + @Path("/whitelist/product") + @Consumes(MediaType.APPLICATION_JSON) + @Produces(MediaType.APPLICATION_JSON) + @Operation(deprecated = true) + @WithSpan() + public Response changeProductStatus(@SpanAttribute(value = "product") RestProductInput product) { + SuccessResponse response = new SuccessResponse(); + if (product.getSupportStatus() == null) { + return Response.status(Response.Status.BAD_REQUEST) + .entity( + new ErrorMessage( + ErrorMessage.ErrorType.PARAMS_REQUIRED, + "All parameters are required", + "Parameter support status is required")) + .build(); + } + if (!productService.changeProductStatus(product.getName(), product.getVersion(), product.getSupportStatus())) { + return Response.status(Response.Status.NOT_FOUND) + .entity(new ErrorMessage(ErrorMessage.ErrorType.PRODUCT_NOT_FOUND, "Product not found", null)) + .build(); + } + response.setSuccess(true); + return Response.ok(response).build(); + } + + @GET + @Path("/whitelist/products") + @Produces(MediaType.APPLICATION_JSON) + @Operation(deprecated = true) + @WithSpan() + public Collection getProducts() { + return convert.toRestProductList(productVersionService.getAll()); + } + + @GET + @Path("/whitelist/product") + @Produces(MediaType.APPLICATION_JSON) + @Operation(deprecated = true) + @WithSpan() + public Collection getProduct( + @SpanAttribute(value = "id") @QueryParam("id") Long id, + @SpanAttribute(value = "name") @QueryParam("name") String name, + @SpanAttribute(value = "version") @QueryParam("version") String version, + @SpanAttribute(value = "supportStatus") @QueryParam("supportStatus") ProductSupportStatus supportStatus) { + return convert.toRestProductList(productVersionService.getProductVersions(id, name, version, supportStatus)); + } + + // ////////////////////////////// + // whitelist search endpoints + + @GET + @Path("/whitelist/artifacts/product") + @Produces(MediaType.APPLICATION_JSON) + @Operation(deprecated = true) + @WithSpan() + public Response artifactsOfProduct( + @SpanAttribute(value = "name") @QueryParam("name") String name, + @SpanAttribute(value = "version") @QueryParam("version") String version) { + Optional pv = whiteArtifactFilterService.getProductVersionWithWhiteArtifacts(name, version); + if (pv.isPresent()) { + return Response.ok(convert.toRestProductGAV(pv.get())).build(); + } + return Response.status(Response.Status.NOT_FOUND) + .entity(new ErrorMessage(ErrorMessage.ErrorType.PRODUCT_NOT_FOUND, "Product not found", null)) + .build(); + + } + + @GET + @Path("/whitelist/artifacts/gav") + @Produces(MediaType.APPLICATION_JSON) + @Operation(deprecated = true) + @WithSpan() + public Response productsWithArtifactGAV( + @SpanAttribute(value = "groupId") @QueryParam("groupid") String groupId, + @SpanAttribute(value = "artifactId") @QueryParam("artifactid") String artifactId, + @SpanAttribute(value = "version") @QueryParam("version") String version) { + + return Response + .ok( + convert.fromRelationshipToRestProductGAVList( + whiteArtifactFilterService + .getProductVersionsWithWhiteArtifactsByGAV(groupId, artifactId, version))) + .build(); + } + + @GET + @Path("/whitelist/artifacts/status") + @Produces(MediaType.APPLICATION_JSON) + @Operation(deprecated = true) + @WithSpan() + public Response productsWithArtifactStatus( + @SpanAttribute(value = "status") @QueryParam("status") ProductSupportStatus status) { + + return Response + .ok( + convert.toRestProductGAVList( + whiteArtifactFilterService.getProductVersionsWithWhiteArtifactsByStatus(status))) + .build(); + } + + @GET + @Path("/whitelist/artifacts/gastatus") + @Produces(MediaType.APPLICATION_JSON) + @Operation(deprecated = true) + @WithSpan() + public Response productsWithArtifactGAAndStatus( + @SpanAttribute(value = "groupId") @QueryParam("groupid") String groupId, + @SpanAttribute(value = "artifactId") @QueryParam("artifactid") String artifactId, + @SpanAttribute(value = "status") @QueryParam("status") ProductSupportStatus status) { + + return Response + .ok( + convert.fromRelationshipToRestProductGAVList( + whiteArtifactFilterService + .getProductVersionsWithWhiteArtifactsByGAStatus(groupId, artifactId, status))) + .build(); + } + +} diff --git a/reports-rest/src/main/java/org/jboss/da/rest/listings/RestConvert.java b/reports-rest/src/main/java/org/jboss/da/rest/listings/RestConvert.java index a0758aa94..12c8e0508 100644 --- a/reports-rest/src/main/java/org/jboss/da/rest/listings/RestConvert.java +++ b/reports-rest/src/main/java/org/jboss/da/rest/listings/RestConvert.java @@ -1,6 +1,8 @@ package org.jboss.da.rest.listings; import org.jboss.da.listings.api.model.Artifact; +import org.jboss.da.listings.api.model.ProductVersion; +import org.jboss.da.listings.api.model.ProductVersionArtifactRelationship; import org.jboss.da.listings.model.rest.RestArtifact; import org.jboss.da.listings.model.rest.RestProduct; import org.jboss.da.listings.model.rest.RestProductGAV; @@ -24,6 +26,65 @@ public List toRestArtifacts(Collection art return artifacts.stream().map(RestConvert::toRestArtifact).collect(Collectors.toList()); } + public List toRestProductGAV(ProductVersion pv) { + List rpgList = new ArrayList<>(); + for (Artifact a : pv.getWhiteArtifacts()) { + RestProductGAV rpg = new RestProductGAV(); + rpg.setName(pv.getProduct().getName()); + rpg.setVersion(pv.getProductVersion()); + rpg.setSupportStatus(pv.getSupport()); + RestArtifact ra = new RestArtifact(); + ra.setArtifactId(a.getGa().getArtifactId()); + ra.setGroupId(a.getGa().getGroupId()); + ra.setVersion(a.getVersion()); + rpg.setGav(ra); + rpgList.add(rpg); + } + return rpgList; + } + + public List toRestProductGAVList(List productVersions) { + List rpgl = new ArrayList<>(); + for (ProductVersion p : productVersions) { + rpgl.addAll(toRestProductGAV(p)); + } + return rpgl; + } + + public List toRestProductList(List productVersions) { + List lrp = new ArrayList<>(); + for (ProductVersion p : productVersions) { + lrp.add(toRestProduct(p)); + } + return lrp; + } + + public RestProduct toRestProduct(ProductVersion productVersion) { + RestProduct rp = new RestProduct(); + rp.setId(productVersion.getId()); + rp.setName(productVersion.getProduct().getName()); + rp.setVersion(productVersion.getProductVersion()); + rp.setSupportStatus(productVersion.getSupport()); + return rp; + } + + public List fromRelationshipToRestProductGAVList(List rl) { + List rpgList = new ArrayList<>(); + for (ProductVersionArtifactRelationship r : rl) { + RestProductGAV rpg = new RestProductGAV(); + rpg.setName(r.getProductVersion().getProduct().getName()); + rpg.setVersion(r.getProductVersion().getProductVersion()); + rpg.setSupportStatus(r.getProductVersion().getSupport()); + RestArtifact ra = new RestArtifact(); + ra.setArtifactId(r.getArtifact().getGa().getArtifactId()); + ra.setGroupId(r.getArtifact().getGa().getGroupId()); + ra.setVersion(r.getArtifact().getVersion()); + rpg.setGav(ra); + rpgList.add(rpg); + } + return rpgList; + } + private static RestArtifact toRestArtifact(Artifact a) { RestArtifact ra = new RestArtifact(); ra.setArtifactId(a.getGa().getArtifactId()); diff --git a/reports-rest/src/main/java/org/jboss/da/rest/products/Products.java b/reports-rest/src/main/java/org/jboss/da/rest/products/Products.java new file mode 100644 index 000000000..3ef71c0ac --- /dev/null +++ b/reports-rest/src/main/java/org/jboss/da/rest/products/Products.java @@ -0,0 +1,111 @@ +package org.jboss.da.rest.products; + +import io.opentelemetry.instrumentation.annotations.SpanAttribute; +import io.opentelemetry.instrumentation.annotations.WithSpan; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.tags.Tag; +import org.jboss.da.listings.api.model.ProductVersion; +import org.jboss.da.listings.api.service.ProductVersionService; +import org.jboss.da.model.rest.ErrorMessage; +import org.jboss.da.model.rest.GAV; +import org.jboss.da.products.api.ArtifactDiff; + +import javax.inject.Inject; +import javax.ws.rs.GET; +import javax.ws.rs.Path; +import javax.ws.rs.Produces; +import javax.ws.rs.QueryParam; +import javax.ws.rs.core.MediaType; + +import org.jboss.da.products.api.ProductsService; +import org.jboss.da.products.model.rest.GADiff; +import org.jboss.da.products.model.rest.ProductDiff; +import org.jboss.da.rest.listings.RestConvert; + +import javax.ws.rs.core.Response; +import static javax.ws.rs.core.Response.Status.NOT_FOUND; + +import java.util.Optional; +import java.util.Set; +import java.util.stream.Collectors; + +import java.util.TreeSet; + +/** + * + * @author Honza Brázdil <jbrazdil@redhat.com> + */ +@Path("/products") +@Tag(name = "deprecated") +public class Products { + + @Inject + private ProductsService products; + + @Inject + private ProductVersionService productService; + + @Inject + private RestConvert convert; + + @GET + @Path("/diff") + @Produces(MediaType.APPLICATION_JSON) + @Operation(deprecated = true) + @WithSpan() + public Response getProduct( + @SpanAttribute(value = "leftProduct") @QueryParam("leftProduct") Long leftProduct, + @SpanAttribute(value = "rightProduct") @QueryParam("rightProduct") Long rightProduct) { + Optional left = productService.getProductVersion(leftProduct); + if (!left.isPresent()) { + return Response.status(NOT_FOUND) + .entity( + new ErrorMessage( + ErrorMessage.ErrorType.PRODUCT_NOT_FOUND, + "Product " + leftProduct + " doesn't exist.", + null)) + .build(); + } + Optional right = productService.getProductVersion(rightProduct); + if (!right.isPresent()) { + return Response.status(NOT_FOUND) + .entity( + new ErrorMessage( + ErrorMessage.ErrorType.PRODUCT_NOT_FOUND, + "Product " + rightProduct + " doesn't exist.", + null)) + .build(); + } + Set diff = products.difference(leftProduct, rightProduct); + + ProductDiff ret = new ProductDiff(); + ret.setLeftProduct(convert.toRestProduct(left.get())); + ret.setRightProduct(convert.toRestProduct(right.get())); + ret.setAdded( + diff.stream() + .filter(ArtifactDiff::isAdded) + .map(d -> new GAV(d.getGa(), d.getRightVersion())) + .collect(Collectors.toCollection(TreeSet::new))); + ret.setRemoved( + diff.stream() + .filter(ArtifactDiff::isRemoved) + .map(d -> new GAV(d.getGa(), d.getLeftVersion())) + .collect(Collectors.toCollection(TreeSet::new))); + ret.setChanged( + diff.stream() + .filter(ArtifactDiff::isChanged) + .map( + d -> new GADiff( + d.getGa(), + d.getLeftVersion(), + d.getRightVersion(), + d.getDifference().toString())) + .collect(Collectors.toCollection(TreeSet::new))); + ret.setUnchanged( + diff.stream() + .filter(ArtifactDiff::isUnchanged) + .map(d -> new GAV(d.getGa(), d.getLeftVersion())) + .collect(Collectors.toCollection(TreeSet::new))); + return Response.ok().entity(ret).build(); + } +} diff --git a/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/AbstractRestApiListingTest.java b/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/AbstractRestApiListingTest.java index 979b95a64..90c90c437 100644 --- a/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/AbstractRestApiListingTest.java +++ b/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/AbstractRestApiListingTest.java @@ -6,6 +6,7 @@ import java.io.File; import java.io.IOException; +import java.util.ArrayList; import java.util.List; import static org.junit.Assert.assertEquals; @@ -23,7 +24,7 @@ public abstract class AbstractRestApiListingTest extends AbstractRestReportsTest { protected enum ListEntityType { - BLACK; + BLACK, WHITE, PRODUCT; } protected enum OperationType { @@ -32,16 +33,33 @@ protected enum OperationType { protected static final String PATH_FILES_LISTINGS_GAV = "/listings"; + protected static final String PATH_WHITE_LIST = "/listings/whitelist"; + protected static final String PATH_BLACK_LIST = "/listings/blacklist"; + protected static final String PATH_WHITE_LISTINGS_GAV = "/listings/whitelist/gav"; + + protected static final String PATH_WHITE_ARTIFACTS = "/listings/whitelist/artifacts/gav"; + protected static final String PATH_BLACK_LISTINGS_GAV = "/listings/blacklist/gav"; protected static final String PATH_BLACK_LISTINGS_GA = "/listings/blacklist/ga"; + protected static final String PATH_PRODUCT = "/listings/whitelist/product"; + + protected static final String PATH_PRODUCTS = "/listings/whitelist/products"; + @After public void dropTables() throws Exception { + List whitelistedArtifacts = getAllWhiteArtifactsFromList(PATH_WHITE_LIST); + List artifacts = whiteToRestArtifactList(whitelistedArtifacts); + artifacts.forEach(gav -> removeGavFromList(PATH_WHITE_LISTINGS_GAV, gav)); + List blacklistedArtifacts = getAllArtifactsFromList(PATH_BLACK_LIST); blacklistedArtifacts.forEach(gav -> removeGavFromList(PATH_BLACK_LISTINGS_GAV, gav)); + + List products = getAllProductsFromList(PATH_PRODUCTS); + products.forEach(product -> removeProductFromList(PATH_PRODUCT, product)); } private void removeGavFromList(String listUrl, RestArtifact gav) { @@ -52,6 +70,15 @@ private void removeGavFromList(String listUrl, RestArtifact gav) { } } + private void removeProductFromList(String url, RestProduct product) { + try { + createClientRequest(url).method("DELETE", Entity.json(toRestProductRequest(product)), String.class); + } catch (Exception e) { + fail("Failed to remove product from the list using URL " + url); + } + + } + private String toRestProductRequest(RestProduct p) { return "{" + "\"name\":" + "\"" + p.getName() + "\"," + "\"version\":" + "\"" + p.getVersion() + "\"" + "}"; } @@ -61,6 +88,16 @@ protected List getAllArtifactsFromList(String listUrl) throws Exce }, listUrl); } + private List getAllWhiteArtifactsFromList(String listUrl) throws Exception { + return processGetRequest(new GenericType>() { + }, listUrl); + } + + private List getAllProductsFromList(String listUrl) throws Exception { + return processGetRequest(new GenericType>() { + }, listUrl); + } + private T processGetRequest(GenericType type, String url) throws Exception { Response response = createClientRequest(url).get(); @@ -92,9 +129,15 @@ protected Response manipulateEntityString( Boolean checkSuccess) throws Exception { String path = null; switch (entity) { + case WHITE: + path = PATH_WHITE_LISTINGS_GAV; + break; case BLACK: path = PATH_BLACK_LISTINGS_GAV; break; + case PRODUCT: + path = PATH_PRODUCT; + break; } Invocation.Builder request = createClientRequest(path); @@ -118,4 +161,20 @@ protected Response manipulateEntityString( return response; } + private List whiteToRestArtifactList(List whites) { + List artifacts = new ArrayList<>(); + for (RestWhiteArtifact w : whites) { + RestArtifact a = new RestArtifact(); + a.setArtifactId(w.getGav().artifactId); + a.setGroupId(w.getGav().getGroupId()); + a.setVersion(w.getGav().getVersion()); + artifacts.add(a); + } + return artifacts; + } + + protected long getIdOfProduct(String name, String version) throws Exception { + return createClientRequest(PATH_PRODUCT + "?name=" + name + "&version=" + version).get(RestProduct[].class)[0] + .getId(); + } } diff --git a/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/RestApiListingsTestIT.java b/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/RestApiListingsTestIT.java index 949e1c3c0..9d419ada3 100644 --- a/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/RestApiListingsTestIT.java +++ b/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/RestApiListingsTestIT.java @@ -17,6 +17,33 @@ public class RestApiListingsTestIT extends AbstractRestApiListingTest { private final RequestGenerator generator = new RequestGenerator(); + @Test + public void testAddProduct() throws Exception { + Response response = manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); + + checkExpectedResponse(response, "success"); + } + + @Test + public void testChangeProduct() throws Exception { + Response response = manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); + + checkExpectedResponse(response, "success"); + + manipulateEntityFile(ListEntityType.PRODUCT, OperationType.PUT, "productChangeStatus", true); + } + + @Test + public void testDeleteProduct() throws Exception { + Response response = manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); + + checkExpectedResponse(response, "success"); + + response = manipulateEntityFile(ListEntityType.PRODUCT, OperationType.DELETE, "productAdd", true); + + checkExpectedResponse(response, "success"); + } + @Test public void testAddBlackArtifact() throws Exception { Response response = manipulateEntityFile(ListEntityType.BLACK, OperationType.POST, "gav", true); @@ -120,6 +147,172 @@ public void testAlreadyAddedBlackArtifact() throws Exception { checkExpectedResponse(response, "successFalse"); } + @Test + public void testAddWhiteArtifact() throws Exception { + Response response = manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); + + checkExpectedResponse(response, "success"); + + String artifact = generator.returnWhiteArtifactString( + "org.jboss.da", + "dependency-analyzer", + "0.3.0", + getIdOfProduct("test", "1.0.0")); + + response = manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); + + checkExpectedResponse(response, "success"); + } + + @Test + public void testDeleteWhiteArtifact() throws Exception { + Response response = manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); + + checkExpectedResponse(response, "success"); + + String artifact = generator.returnWhiteArtifactString( + "org.jboss.da", + "dependency-analyzer", + "0.3.0", + getIdOfProduct("test", "1.0.0")); + + response = manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); + + checkExpectedResponse(response, "success"); + + // delete artifact + response = manipulateEntityFile(ListEntityType.WHITE, OperationType.DELETE, "gav", true); + + checkExpectedResponse(response, "success"); + } + + @Test + public void testDeleteNonExistingWhiteArtifact() throws Exception { + Response response = manipulateEntityFile(ListEntityType.WHITE, OperationType.DELETE, "gav", true); + + checkExpectedResponse(response, "successFalse"); + } + + @Test + public void testAddBlacklistedArtifactToWhitelist() throws Exception { + // Add artifact to blacklist + Response response = manipulateEntityFile(ListEntityType.BLACK, OperationType.POST, "gav", true); + checkExpectedResponse(response, "success"); + + // Try to add artifact to whitelist + response = manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); + + checkExpectedResponse(response, "success"); + + String artifact = generator.returnWhiteArtifactString( + "org.jboss.da", + "dependency-analyzer", + "0.3.0", + getIdOfProduct("test", "1.0.0")); + + response = manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, false); + + assertEquals(200, response.getStatus()); + } + + @Test + public void testAddWhitelistedArtifactToBlacklist() throws Exception { + manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); + + // Add artifact to whitelist + String artifact = generator.returnWhiteArtifactString( + "org.jboss.da", + "dependency-analyzer", + "0.3.0", + getIdOfProduct("test", "1.0.0")); + + manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); + + // Add artifact to blacklist + Response response = manipulateEntityFile(ListEntityType.BLACK, OperationType.POST, "gav", true); + + checkExpectedResponse(response, "successMessage"); + + assertEquals(0, getAllArtifactsFromList(PATH_WHITE_LIST).size()); + } + + @Test + public void testAddMultipleTimeWhitelistedArtifactToBlacklist() throws Exception { + manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); + manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd2", true); + + // Add artifacts to whitelist + String artifact; + artifact = generator.returnWhiteArtifactString( + "org.jboss.da", + "dependency-analyzer", + "0.3.0", + getIdOfProduct("test", "1.0.0")); + + manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); + + artifact = generator.returnWhiteArtifactString( + "org.jboss.da", + "dependency-analyzer", + "0.3.0", + getIdOfProduct("test", "2.0.0")); + + manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); + // Add artifact to blacklist + Response response = manipulateEntityFile(ListEntityType.BLACK, OperationType.POST, "gav", true); + + checkExpectedResponse(response, "successMessage"); + } + + @Test + public void testAlreadyAddedWhiteArtifact() throws Exception { + manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); + + String artifact = generator.returnWhiteArtifactString( + "org.jboss.da", + "dependency-analyzer", + "0.3.0", + getIdOfProduct("test", "1.0.0")); + + manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); + + // add second white artifact + Response response = manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); + + checkExpectedResponse(response, "successFalse"); + } + + @Test + public void testGetAllWhiteArtifacts() throws Exception { + // Add artifacts to whitelist + manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); + manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd2", true); + + // Add artifacts to whitelist + String artifact; + artifact = generator.returnWhiteArtifactString( + "org.jboss.da", + "dependency-analyzer", + "0.3.0", + getIdOfProduct("test", "1.0.0")); + + manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); + + artifact = generator.returnWhiteArtifactString( + "org.jboss.da", + "dependency-analyzer", + "0.3.0", + getIdOfProduct("test", "2.0.0")); + + manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); + + // Get list + Response response = createClientRequest(PATH_WHITE_LIST).get(); + assertEquals(200, response.getStatus()); + + checkExpectedResponse(response, "gavWhiteList"); + } + @Test public void testGetAllBlackArtifacts() throws Exception { // Add artifacts to blacklist @@ -210,6 +403,49 @@ public void testCheckNonRHNonOSGiBlackArtifact() throws Exception { checkExpectedResponse(response, "gavResponse"); } + @Test + public void testCheckRHWhiteArtifact() throws Exception { + manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); + + String artifact = generator.returnWhiteArtifactString( + "org.jboss.da", + "dependency-analyzer", + "0.3.0.redhat-1", + getIdOfProduct("test", "1.0.0")); + + manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); + + Response response = createClientRequest( + PATH_WHITE_LIST + "?groupid=org.jboss.da&artifactid=dependency-analyzer&version=0.3.0.redhat-1").get(); + assertEquals(200, response.getStatus()); + + checkExpectedResponse(response, "gavRhResponse"); + } + + /** + * Non RedHat but OSGi compliant white artifact test + * + * @throws Exception + */ + @Test + public void testCheckNonRHWhiteArtifact() throws Exception { + manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); + + String artifact = generator.returnWhiteArtifactString( + "org.jboss.da", + "dependency-analyzer", + "0.3.0.redhat-1", + getIdOfProduct("test", "1.0.0")); + + manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); + + Response response = createClientRequest( + PATH_WHITE_LIST + "?groupid=org.jboss.da&artifactid=dependency-analyzer&version=0.3.0").get(); + assertEquals(200, response.getStatus()); + + checkExpectedResponse(response, "gavRhResponse"); + } + @Override protected void assertEqualsJson(String expected, String actual) { try { diff --git a/testsuite/src/test/java/org/jboss/da/test/client/rest/products/RestApiProductsTestIT.java b/testsuite/src/test/java/org/jboss/da/test/client/rest/products/RestApiProductsTestIT.java new file mode 100644 index 000000000..cb7c51057 --- /dev/null +++ b/testsuite/src/test/java/org/jboss/da/test/client/rest/products/RestApiProductsTestIT.java @@ -0,0 +1,83 @@ +package org.jboss.da.test.client.rest.products; + +import org.jboss.da.test.client.rest.listings.AbstractRestApiListingTest; +import org.jboss.da.test.client.rest.listings.RequestGenerator; +import org.json.JSONException; +import org.junit.Test; +import org.skyscreamer.jsonassert.JSONAssert; +import org.skyscreamer.jsonassert.JSONCompareMode; + +import java.io.File; +import java.io.IOException; + +import static org.apache.commons.io.FileUtils.readFileToString; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; + +import javax.ws.rs.core.Response; + +/** + * + * @author Honza Brázdil <jbrazdil@redhat.com> + */ +public class RestApiProductsTestIT extends AbstractRestApiListingTest { + + protected static final String PATH_FILES_PRODUCTS = "/products"; + + protected static final String PATH_PRODUCTS_DIFF = "/products/diff"; + + private final RequestGenerator generator = new RequestGenerator(); + + @Test + public void testProductsDiff() throws Exception { + String artifact; + + // Add whitelists + manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); + long p1 = getIdOfProduct("test", "1.0.0"); + manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd2", true); + long p2 = getIdOfProduct("test", "2.0.0"); + + // Add artifacts to whitelist + artifact = generator.returnWhiteArtifactString("com.example", "added", "1.0.0", p2); + manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); + + artifact = generator.returnWhiteArtifactString("com.example", "removed", "1.0.0", p1); + manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); + + artifact = generator.returnWhiteArtifactString("com.example", "changed", "1.0.0", p1); + manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); + artifact = generator.returnWhiteArtifactString("com.example", "changed", "1.2.0", p2); + manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); + + artifact = generator.returnWhiteArtifactString("com.example", "unchanged", "1.0.0", p1); + manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); + artifact = generator.returnWhiteArtifactString("com.example", "unchanged", "1.0.0", p2); + manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); + + // Get diff + Response response = createClientRequest(PATH_PRODUCTS_DIFF + "?leftProduct=" + p1 + "&rightProduct=" + p2) + .get(); + assertEquals(200, response.getStatus()); + + checkExpectedResponse(response, "diff"); + } + + private void checkExpectedResponse(Response response, String expectedFile) throws IOException { + File expectedResponseFile = getJsonResponseFile(PATH_FILES_PRODUCTS, expectedFile); + final String expected = readFileToString(expectedResponseFile); + final String actual = response.readEntity(String.class); + System.out.println("Expected: " + expected); + System.out.println("Actual: " + actual); + assertEqualsJson(expected, actual); + } + + @Override + protected void assertEqualsJson(String expected, String actual) { + try { + JSONAssert.assertEquals(expected, actual, JSONCompareMode.LENIENT); + } catch (JSONException ex) { + fail("The test wasn't able to compare JSON strings" + ex); + } + } +} diff --git a/testsuite/src/test/java/org/jboss/da/test/server/ArtifactBlackWhitelistTransitionsTestIT.java b/testsuite/src/test/java/org/jboss/da/test/server/ArtifactBlackWhitelistTransitionsTestIT.java new file mode 100644 index 000000000..0f7b861d5 --- /dev/null +++ b/testsuite/src/test/java/org/jboss/da/test/server/ArtifactBlackWhitelistTransitionsTestIT.java @@ -0,0 +1,237 @@ +package org.jboss.da.test.server; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import java.util.List; +import java.util.Optional; + +import javax.inject.Inject; + +import org.jboss.arquillian.junit.Arquillian; +import org.jboss.da.communication.auth.impl.JAASAuthenticatorService; +import org.jboss.da.listings.api.dao.ProductVersionDAO; +import org.jboss.da.listings.api.model.BlackArtifact; +import org.jboss.da.listings.api.model.ProductVersion; +import org.jboss.da.listings.api.model.WhiteArtifact; +import org.jboss.da.listings.api.service.ArtifactService.ArtifactStatus; +import org.jboss.da.listings.api.service.BlackArtifactService; +import org.jboss.da.listings.api.service.ProductService; +import org.jboss.da.listings.api.service.WhiteArtifactService; +import org.jboss.da.listings.model.ProductSupportStatus; +import org.jboss.da.listings.model.rest.RestProductArtifact; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +/** + * + * @author fkujikis + */ +@RunWith(Arquillian.class) +public class ArtifactBlackWhitelistTransitionsTestIT extends AbstractServerTest { + + @Inject + private BlackArtifactService blackService; + + @Inject + private WhiteArtifactService whiteService; + + @Inject + private ProductVersionDAO productVersionDao; + + @Inject + private ProductService productService; + + private RestProductArtifact whiteArtifact1; + + private RestProductArtifact whiteArtifact2; + + private RestProductArtifact blackArtifact1; + + private RestProductArtifact whiteToBlackArtifact; + + private ProductVersion product1; + + private ProductVersion product2; + + @Before + public void setUp() { + JAASAuthenticatorService.setUser(null); + + whiteArtifact1 = new RestProductArtifact(); + whiteArtifact1.setArtifactId("white1"); + whiteArtifact1.setGroupId("org.test"); + whiteArtifact1.setVersion("1.0.0"); + + whiteArtifact2 = new RestProductArtifact(); + whiteArtifact2.setArtifactId("white2"); + whiteArtifact2.setGroupId("org.test"); + whiteArtifact2.setVersion("1.0.0"); + + blackArtifact1 = new RestProductArtifact(); + blackArtifact1.setArtifactId("black1"); + blackArtifact1.setGroupId("org.test"); + blackArtifact1.setVersion("1.0.0"); + + whiteToBlackArtifact = new RestProductArtifact(); + whiteToBlackArtifact.setArtifactId("whiteToBlack"); + whiteToBlackArtifact.setGroupId("org.test"); + whiteToBlackArtifact.setVersion("1.0.0"); + + // Add product1 and product2 + productService.addProduct("Product1", "1.0.0", ProductSupportStatus.UNKNOWN); + product1 = productVersionDao.findProductVersion("Product1", "1.0.0").get(); + productService.addProduct("Product2", "1.0.0", ProductSupportStatus.UNKNOWN); + product2 = productVersionDao.findProductVersion("Product2", "1.0.0").get(); + + JAASAuthenticatorService.setUser("user"); + + // Add whiteArtifact1 and whiteToBlackArtifact to Product1 + whiteService.addArtifact( + whiteArtifact1.getGroupId(), + whiteArtifact1.getArtifactId(), + whiteArtifact1.getVersion(), + product1.getId()); + whiteService.addArtifact( + whiteToBlackArtifact.getGroupId(), + whiteToBlackArtifact.getArtifactId(), + whiteToBlackArtifact.getVersion(), + product1.getId()); + + // Add whiteArtifact2 and whiteToBlackArtifact to Product2 + whiteService.addArtifact( + whiteArtifact2.getGroupId(), + whiteArtifact2.getArtifactId(), + whiteArtifact2.getVersion(), + product2.getId()); + whiteService.addArtifact( + whiteToBlackArtifact.getGroupId(), + whiteToBlackArtifact.getArtifactId(), + whiteToBlackArtifact.getVersion(), + product2.getId()); + + blackService + .addArtifact(blackArtifact1.getGroupId(), blackArtifact1.getArtifactId(), blackArtifact1.getVersion()); + + } + + @After + public void tearDown() { + // Remove all artifacts + whiteService.removeArtifact( + whiteArtifact1.getGroupId(), + whiteArtifact1.getArtifactId(), + whiteArtifact1.getVersion()); + whiteService.removeArtifact( + whiteArtifact2.getGroupId(), + whiteArtifact2.getArtifactId(), + whiteArtifact2.getVersion()); + whiteService.removeArtifact( + whiteToBlackArtifact.getGroupId(), + whiteToBlackArtifact.getArtifactId(), + whiteToBlackArtifact.getVersion()); + blackService.removeArtifact( + whiteToBlackArtifact.getGroupId(), + whiteToBlackArtifact.getArtifactId(), + whiteToBlackArtifact.getVersion()); + blackService.removeArtifact( + blackArtifact1.getGroupId(), + blackArtifact1.getArtifactId(), + blackArtifact1.getVersion()); + + // Remove all products + productService.removeProduct("Product1", "1.0.0"); + productService.removeProduct("Product2", "1.0.0"); + + JAASAuthenticatorService.setUser(null); + } + + private void refreshProducts() { + product1 = productVersionDao.read(product1.getId()); + product2 = productVersionDao.read(product2.getId()); + } + + @Test + public void testBlacklistWhitelistedArtifact() { + + // Check original artifacts for product are set + refreshProducts(); + assertEquals(2, product1.getWhiteArtifacts().size()); + assertEquals(2, product2.getWhiteArtifacts().size()); + + // Check artifact was previously white listed + ArtifactStatus as = blackService.addArtifact( + whiteToBlackArtifact.getGroupId(), + whiteToBlackArtifact.getArtifactId(), + whiteToBlackArtifact.getVersion()); + assertEquals(ArtifactStatus.WAS_WHITELISTED, as); + + // Check the artifact was blacklisted + Optional artifact = blackService.getArtifact( + whiteToBlackArtifact.getGroupId(), + whiteToBlackArtifact.getArtifactId(), + whiteToBlackArtifact.getVersion()); + assertTrue(artifact.isPresent()); + + // Check artifact is no longer in whitelist DB + List whiteArtifactsMatchingGav = whiteService.getArtifacts( + whiteToBlackArtifact.getGroupId(), + whiteToBlackArtifact.getArtifactId(), + whiteToBlackArtifact.getVersion()); + assertTrue(whiteArtifactsMatchingGav.isEmpty()); + + // Check artifact is still on product white lists + // Demonstrates issue NCL-1883: + // - correct behaviour is as above asserts in test plus + // - blacklisted artifact shouldn't be removed from ProductVersion whiteArtifact lists + refreshProducts(); + assertEquals(2, product1.getWhiteArtifacts().size()); + assertEquals(2, product2.getWhiteArtifacts().size()); + } + + @Test + public void testAddBlacklistedArtifactToProductWhitelist() { + + // Check original artifacts for product are set + refreshProducts(); + assertEquals(2, product1.getWhiteArtifacts().size()); + + // Add the blacklisted artifact to a product + ArtifactStatus as = whiteService.addArtifact( + blackArtifact1.getGroupId(), + blackArtifact1.getArtifactId(), + blackArtifact1.getVersion(), + product1.getId()); + assertEquals(as, ArtifactStatus.ADDED); + + // Check blackArtifact1 artifact has been added to product 1 + refreshProducts(); + assertEquals(3, product1.getWhiteArtifacts().size()); + + // Confirm blackArtifact1 still on blacklist + boolean artifactOnBlacklist = blackService.isArtifactPresent( + blackArtifact1.getGroupId(), + blackArtifact1.getArtifactId(), + blackArtifact1.getVersion()); + assertTrue(artifactOnBlacklist); + + // Confirm artifact not on whitelist + List whiteArtifacts = whiteService + .getArtifacts(blackArtifact1.getGroupId(), blackArtifact1.getArtifactId(), blackArtifact1.getVersion()); + assertTrue(whiteArtifacts.isEmpty()); + + // Check artifact can be removed as before + boolean artifactRemovedFromProduct = whiteService.removeArtifractFromProductVersion( + blackArtifact1.getGroupId(), + blackArtifact1.getArtifactId(), + blackArtifact1.getVersion(), + product1.getId()); + assertTrue(artifactRemovedFromProduct); + + // Check blackArtifact1 artifact has been removed from product 1 + refreshProducts(); + assertEquals(2, product1.getWhiteArtifacts().size()); + } +} diff --git a/testsuite/src/test/java/org/jboss/da/test/server/ReportsWithWhitelistedArtifactsRemoteTestIT.java b/testsuite/src/test/java/org/jboss/da/test/server/ReportsWithWhitelistedArtifactsRemoteTestIT.java new file mode 100644 index 000000000..59acbae22 --- /dev/null +++ b/testsuite/src/test/java/org/jboss/da/test/server/ReportsWithWhitelistedArtifactsRemoteTestIT.java @@ -0,0 +1,552 @@ +package org.jboss.da.test.server; + +import static org.junit.Assert.*; + +import org.apache.maven.scm.ScmException; +import org.jboss.arquillian.junit.Arquillian; +import org.jboss.da.common.CommunicationException; +import org.jboss.da.communication.auth.impl.JAASAuthenticatorService; +import org.jboss.da.communication.indy.FindGAVDependencyException; +import org.jboss.da.communication.pom.PomAnalysisException; +import org.jboss.da.listings.api.dao.ProductVersionDAO; +import org.jboss.da.listings.api.model.ProductVersion; +import org.jboss.da.listings.api.service.ProductService; +import org.jboss.da.listings.api.service.WhiteArtifactService; +import org.jboss.da.listings.model.ProductSupportStatus; +import org.jboss.da.listings.model.rest.RestProductArtifact; +import org.jboss.da.model.rest.GAV; +import org.jboss.da.reports.api.ArtifactReport; +import org.jboss.da.reports.api.ReportsGenerator; +import org.jboss.da.reports.model.api.SCMLocator; +import org.jboss.da.reports.model.request.GAVRequest; +import org.jboss.da.reports.model.request.LookupGAVsRequest; +import org.jboss.da.reports.model.request.SCMReportRequest; +import org.jboss.da.reports.model.response.LookupReport; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +import javax.inject.Inject; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Optional; +import java.util.Set; + +/** + * + * @author fkujikis + */ +@RunWith(Arquillian.class) +public class ReportsWithWhitelistedArtifactsRemoteTestIT extends AbstractServerTest { + + @Inject + private ReportsGenerator reportGenerator; + + @Inject + private WhiteArtifactService whiteService; + + @Inject + private ProductVersionDAO productVersionDao; + + @Inject + private ProductService productService; + + private ProductVersion prodVer1_1; + + private RestProductArtifact whiteArtifact1_1_1; + + private RestProductArtifact whiteArtifact1_1_2; + + private ProductVersion prodVer1_2; + + private RestProductArtifact whiteArtifact1_2_1; + + private RestProductArtifact whiteArtifact1_2_2; + + private ProductVersion prodVer2_1; + + private RestProductArtifact whiteArtifact2_1_a; + + private RestProductArtifact whiteArtifact2_1_b; + + private RestProductArtifact whiteArtifact2_1_c; + + private GAV hibernateGav; + + private GAV daGav; + + private GAV jacksonGav; + + @Before + public void workaroundNoHttpResponseException() throws InterruptedException { + Thread.sleep(2000); + } + + @Before + public void setUp() { + JAASAuthenticatorService.setUser("user"); + + whiteArtifact1_1_1 = new RestProductArtifact(); + whiteArtifact1_1_1.setGroupId("org.jboss.da"); + whiteArtifact1_1_1.setArtifactId("common"); + whiteArtifact1_1_1.setVersion("0.1.0-redhat-1"); + + whiteArtifact1_1_2 = new RestProductArtifact(); + whiteArtifact1_1_2.setGroupId("org.hibernate"); + whiteArtifact1_1_2.setArtifactId("hibernate-core"); + whiteArtifact1_1_2.setVersion("4.2.28.Final-redhat-1"); + + whiteArtifact1_2_1 = new RestProductArtifact(); + whiteArtifact1_2_1.setGroupId("org.jboss.da"); + whiteArtifact1_2_1.setArtifactId("common"); + whiteArtifact1_2_1.setVersion("0.1.1-redhat-1"); + + whiteArtifact1_2_2 = new RestProductArtifact(); + whiteArtifact1_2_2.setGroupId("org.hibernate"); + whiteArtifact1_2_2.setArtifactId("hibernate-core"); + whiteArtifact1_2_2.setVersion("4.2.29.Final-redhat-1"); + + productService.addProduct("Product1", "1.0.0", ProductSupportStatus.UNKNOWN); + prodVer1_1 = productVersionDao.findProductVersion("Product1", "1.0.0").get(); + productService.addProduct("Product1", "2.0.0", ProductSupportStatus.UNKNOWN); + prodVer1_2 = productVersionDao.findProductVersion("Product1", "2.0.0").get(); + + whiteService.addArtifact( + whiteArtifact1_1_1.getGroupId(), + whiteArtifact1_1_1.getArtifactId(), + whiteArtifact1_1_1.getVersion(), + prodVer1_1.getId()); + whiteService.addArtifact( + whiteArtifact1_1_2.getGroupId(), + whiteArtifact1_1_2.getArtifactId(), + whiteArtifact1_1_2.getVersion(), + prodVer1_1.getId()); + + whiteService.addArtifact( + whiteArtifact1_2_1.getGroupId(), + whiteArtifact1_2_1.getArtifactId(), + whiteArtifact1_2_1.getVersion(), + prodVer1_2.getId()); + whiteService.addArtifact( + whiteArtifact1_2_2.getGroupId(), + whiteArtifact1_2_2.getArtifactId(), + whiteArtifact1_2_2.getVersion(), + prodVer1_2.getId()); + + whiteArtifact2_1_a = new RestProductArtifact(); + whiteArtifact2_1_a.setGroupId("org.jboss.da"); + whiteArtifact2_1_a.setArtifactId("common"); + whiteArtifact2_1_a.setVersion("0.2.0-redhat-1"); + + whiteArtifact2_1_b = new RestProductArtifact(); + whiteArtifact2_1_b.setGroupId("com.fasterxml.jackson.core"); + whiteArtifact2_1_b.setArtifactId("jackson-databind"); + whiteArtifact2_1_b.setVersion("2.4.4-redhat-1"); + + whiteArtifact2_1_c = new RestProductArtifact(); + whiteArtifact2_1_c.setGroupId("org.hibernate"); + whiteArtifact2_1_c.setArtifactId("hibernate-core"); + whiteArtifact2_1_c.setVersion("4.2.30.Final-redhat-1"); + + productService.addProduct("Product2", "1.0.0", ProductSupportStatus.UNKNOWN); + prodVer2_1 = productVersionDao.findProductVersion("Product2", "1.0.0").get(); + + whiteService.addArtifact( + whiteArtifact2_1_a.getGroupId(), + whiteArtifact2_1_a.getArtifactId(), + whiteArtifact2_1_a.getVersion(), + prodVer2_1.getId()); + whiteService.addArtifact( + whiteArtifact2_1_b.getGroupId(), + whiteArtifact2_1_b.getArtifactId(), + whiteArtifact2_1_b.getVersion(), + prodVer2_1.getId()); + whiteService.addArtifact( + whiteArtifact2_1_c.getGroupId(), + whiteArtifact2_1_c.getArtifactId(), + whiteArtifact2_1_c.getVersion(), + prodVer2_1.getId()); + + hibernateGav = artifactToGAV(whiteArtifact1_1_2); + daGav = artifactToGAV(whiteArtifact1_1_1); + jacksonGav = artifactToGAV(whiteArtifact2_1_b); + } + + @After + public void tearDown() { + + // Remove artifacts + whiteService.removeArtifact( + whiteArtifact1_1_1.getGroupId(), + whiteArtifact1_1_1.getArtifactId(), + whiteArtifact1_1_1.getVersion()); + whiteService.removeArtifact( + whiteArtifact1_1_2.getGroupId(), + whiteArtifact1_1_2.getArtifactId(), + whiteArtifact1_1_2.getVersion()); + whiteService.removeArtifact( + whiteArtifact1_2_1.getGroupId(), + whiteArtifact1_2_1.getArtifactId(), + whiteArtifact1_2_1.getVersion()); + whiteService.removeArtifact( + whiteArtifact1_2_2.getGroupId(), + whiteArtifact1_2_2.getArtifactId(), + whiteArtifact1_2_2.getVersion()); + + whiteService.removeArtifact( + whiteArtifact2_1_a.getGroupId(), + whiteArtifact2_1_a.getArtifactId(), + whiteArtifact2_1_a.getVersion()); + whiteService.removeArtifact( + whiteArtifact2_1_b.getGroupId(), + whiteArtifact2_1_b.getArtifactId(), + whiteArtifact2_1_b.getVersion()); + whiteService.removeArtifact( + whiteArtifact2_1_c.getGroupId(), + whiteArtifact2_1_c.getArtifactId(), + whiteArtifact2_1_c.getVersion()); + + // Remove products + productService.removeProduct("Product1", "1.0.0"); + productService.removeProduct("Product1", "2.0.0"); + productService.removeProduct("Product2", "1.0.0"); + + JAASAuthenticatorService.setUser(null); + } + + // This allows to test: + // - whitelist lookup by product + // - whitelist lookup by product version + // - whitelist lookup without either (get all - 3 additions to top level) + // - whitelist addition to top level + // - whitelist addition to top-1 level + + private SCMReportRequest getDefaultSCMRequest() { + SCMLocator locator = SCMLocator + .generic("https://github.com/project-ncl/dependency-analysis.git", "05a878", "common"); + + SCMReportRequest request = new SCMReportRequest(); + request.setScml(locator); + + return request; + } + + @Test + public void testScmAllWhiteArtifactsPresent() throws ScmException, PomAnalysisException, CommunicationException { + + SCMReportRequest request = getDefaultSCMRequest(); + + Optional ar = reportGenerator.getReportFromSCM(request); + + // Ensure we got an artifact report back + assertTrue(ar.isPresent()); + ArtifactReport artifactReport = ar.get(); + + // Ensure all dependencies from whitelist are present + assertTrue(artifactReport.getAvailableVersions().contains(whiteArtifact1_1_1.getVersion())); + assertTrue(artifactReport.getAvailableVersions().contains(whiteArtifact1_2_1.getVersion())); + assertTrue(artifactReport.getAvailableVersions().contains(whiteArtifact2_1_a.getVersion())); + + // These have different GA so shouldn't be there + assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact1_1_2.getVersion())); + assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact1_2_2.getVersion())); + assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact2_1_b.getVersion())); + assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact2_1_c.getVersion())); + + // Find jackson artifactReport and check it contains the jackson version + Optional dependencyJacksonDatabind = artifactReport.getDependencies() + .stream() + .filter( + x -> x.getArtifactId().equals(whiteArtifact2_1_b.getArtifactId()) + && x.getGroupId().equals(whiteArtifact2_1_b.getGroupId())) + .findFirst(); + + assertTrue(dependencyJacksonDatabind.isPresent()); + assertTrue(dependencyJacksonDatabind.get().getAvailableVersions().contains(whiteArtifact2_1_b.getVersion())); + } + + @Test + public void testScmWhiteArtifactsPresentForDependenciesWithSingleProduct() + throws ScmException, PomAnalysisException, CommunicationException { + + SCMReportRequest request = getDefaultSCMRequest(); + + // Only use artifacts from the single product Product2 : version "1.0.0" + request.getProductNames().add(prodVer2_1.getProduct().getName()); + + Optional ar = reportGenerator.getReportFromSCM(request); + + assertTrue(ar.isPresent()); + ArtifactReport artifactReport = ar.get(); + + // Artifacts from Product2 version "1.0.0" expected + assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact1_1_1.getVersion())); + assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact1_2_1.getVersion())); + assertTrue(artifactReport.getAvailableVersions().contains(whiteArtifact2_1_a.getVersion())); + assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact2_1_b.getVersion())); + + // Find jackson artifactReport and check it contains the jackson version + Optional dependencyJacksonDatabind = artifactReport.getDependencies() + .stream() + .filter( + x -> x.getArtifactId().equals(whiteArtifact2_1_b.getArtifactId()) + && x.getGroupId().equals(whiteArtifact2_1_b.getGroupId())) + .findFirst(); + + assertTrue(dependencyJacksonDatabind.isPresent()); + assertTrue(dependencyJacksonDatabind.get().getAvailableVersions().contains(whiteArtifact2_1_b.getVersion())); + + } + + @Test + public void testScmWhiteArtifactsPresentForSingleProduct() + throws ScmException, PomAnalysisException, CommunicationException { + + SCMReportRequest request = getDefaultSCMRequest(); + // Only use artifacts from the single product Product1 : versions "1.0.0" and "2.0.0" should be included + request.getProductNames().add(prodVer1_1.getProduct().getName()); + + Optional ar = reportGenerator.getReportFromSCM(request); + + assertTrue(ar.isPresent()); + ArtifactReport artifactReport = ar.get(); + + // Artifacts from Product1 (product versions "1.0.0", "2.0.0" expected) + assertTrue(artifactReport.getAvailableVersions().contains(whiteArtifact1_1_1.getVersion())); + assertTrue(artifactReport.getAvailableVersions().contains(whiteArtifact1_2_1.getVersion())); + assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact2_1_a.getVersion())); + assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact2_1_b.getVersion())); + } + + @Test + public void testScmWhiteArtifactsPresentForSingleProductVersion() + throws ScmException, PomAnalysisException, CommunicationException { + + SCMReportRequest request = getDefaultSCMRequest(); + // Only use artifacts from the single product version : "Product1", "1.0.0" + request.getProductVersionIds().add(prodVer1_1.getId()); + + Optional ar = reportGenerator.getReportFromSCM(request); + + assertTrue(ar.isPresent()); + ArtifactReport artifactReport = ar.get(); + + // Artifacts from the single product version : "Product1", "1.0.0" : expect 1 only + assertTrue(artifactReport.getAvailableVersions().contains(whiteArtifact1_1_1.getVersion())); + assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact1_2_1.getVersion())); + assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact2_1_a.getVersion())); + assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact2_1_b.getVersion())); + } + + private GAVRequest getDefaultGAVRequest() { + Set productNames = new HashSet<>(); + Set productVersionIds = new HashSet<>(); + GAVRequest gavRequest = new GAVRequest( + "org.hibernate", + "hibernate-core", + "4.2.21.Final", + productNames, + productVersionIds); + return gavRequest; + } + + private GAV artifactToGAV(RestProductArtifact art) { + return new GAV(art.getGroupId(), art.getArtifactId(), art.getVersion()); + } + + private LookupGAVsRequest getDefaultLookupRequest() { + List gavs = new ArrayList<>(); + gavs.add(hibernateGav); + gavs.add(daGav); + gavs.add(jacksonGav); + + LookupGAVsRequest req = new LookupGAVsRequest(gavs); + + return req; + } + + @Test + public void testGavsLookupAllWhiteArtifactsPresent() throws CommunicationException, FindGAVDependencyException { + + LookupGAVsRequest req = getDefaultLookupRequest(); + + // Query all white artifacts from all products + + List lookupReports = reportGenerator.getLookupReportsForGavs(req); + + assertTrue(lookupReports != null); + assertEquals(3, lookupReports.size()); + + // Expecting to see all whitelist versions included + for (LookupReport lr : lookupReports) { + if (hibernateGav.equals(lr.getGav())) { + assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_1_2.getVersion())); + assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_2_2.getVersion())); + assertTrue(lr.getAvailableVersions().contains(whiteArtifact2_1_c.getVersion())); + assertTrue(lr.getBestMatchVersion().equals(hibernateGav.getVersion())); + } else if (daGav.equals(lr.getGav())) { + assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_1_1.getVersion())); + assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_2_1.getVersion())); + assertTrue(lr.getAvailableVersions().contains(whiteArtifact2_1_a.getVersion())); + assertTrue(lr.getBestMatchVersion().equals(daGav.getVersion())); + } else if (jacksonGav.equals(lr.getGav())) { + assertTrue(lr.getAvailableVersions().contains(whiteArtifact2_1_b.getVersion())); + assertTrue(lr.getBestMatchVersion().equals(jacksonGav.getVersion())); + } + } + } + + @Test + public void testGavsLookupAllWhiteArtifactsPresentForSingleProduct() + throws CommunicationException, FindGAVDependencyException { + + LookupGAVsRequest req = getDefaultLookupRequest(); + + // Query all white artifacts from Product 1 + req.getProductNames().add(prodVer1_1.getProduct().getName()); + + List lookupReports = reportGenerator.getLookupReportsForGavs(req); + + assertTrue(lookupReports != null); + assertEquals(3, lookupReports.size()); + + // Expecting to see whitelist versions included for Product 1 + for (LookupReport lr : lookupReports) { + if (hibernateGav.equals(lr.getGav())) { + assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_1_2.getVersion())); + assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_2_2.getVersion())); + assertFalse(lr.getAvailableVersions().contains(whiteArtifact2_1_c.getVersion())); + assertTrue(lr.getBestMatchVersion().equals(hibernateGav.getVersion())); + } else if (daGav.equals(lr.getGav())) { + assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_1_1.getVersion())); + assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_2_1.getVersion())); + assertFalse(lr.getAvailableVersions().contains(whiteArtifact2_1_a.getVersion())); + assertTrue(lr.getBestMatchVersion().equals(daGav.getVersion())); + } else if (jacksonGav.equals(lr.getGav())) { + assertFalse(lr.getAvailableVersions().contains(whiteArtifact2_1_b.getVersion())); + assertTrue(lr.getBestMatchVersion() == null); + } + } + } + + @Test + public void testGavsLookupAllWhiteArtifactsPresentForSingleProductVersion() + throws CommunicationException, FindGAVDependencyException { + + LookupGAVsRequest req = getDefaultLookupRequest(); + + // Query all white artifacts from Product 1 version 2 + req.getProductVersionIds().add(prodVer1_2.getId()); + + List lookupReports = reportGenerator.getLookupReportsForGavs(req); + + assertTrue(lookupReports != null); + assertEquals(3, lookupReports.size()); + + // Expecting to see whitelist versions included for Product 1 version 2 + for (LookupReport lr : lookupReports) { + if (hibernateGav.equals(lr.getGav())) { + assertFalse(lr.getAvailableVersions().contains(whiteArtifact1_1_2.getVersion())); + assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_2_2.getVersion())); + assertFalse(lr.getAvailableVersions().contains(whiteArtifact2_1_c.getVersion())); + } else if (daGav.equals(lr.getGav())) { + assertFalse(lr.getAvailableVersions().contains(whiteArtifact1_1_1.getVersion())); + assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_2_1.getVersion())); + assertFalse(lr.getAvailableVersions().contains(whiteArtifact2_1_a.getVersion())); + } else if (jacksonGav.equals(lr.getGav())) { + assertFalse(lr.getAvailableVersions().contains(whiteArtifact2_1_b.getVersion())); + assertTrue(lr.getBestMatchVersion() == null); + } + } + } + + @Test + public void testGavsLookupAllWhiteArtifactsErroneousInput() + throws CommunicationException, FindGAVDependencyException { + + LookupGAVsRequest productsNamesReq = getDefaultLookupRequest(); + + // Test with product that doesn't exist + // Inputs : productNames [Product3] + productsNamesReq.getProductNames().add("Product3"); + try { + reportGenerator.getLookupReportsForGavs(productsNamesReq); + fail(); + } catch (IllegalArgumentException e) { + assertTrue(e.getMessage().contains("Product3")); + } + + // Test combination of existing / in-existing products + // Inputs : productNames [Product1, Product3] + productsNamesReq.getProductNames().add("Product1"); + try { + reportGenerator.getLookupReportsForGavs(productsNamesReq); + fail(); + } catch (IllegalArgumentException e) { + assertTrue(e.getMessage().contains("Product3")); + } + + LookupGAVsRequest productVersionsReq = getDefaultLookupRequest(); + + // Test with product version ID that doesn't exist + // Inputs : productVersionIds [5555] + productVersionsReq.getProductVersionIds().add(5555L); + try { + reportGenerator.getLookupReportsForGavs(productVersionsReq); + fail(); + } catch (IllegalArgumentException e) { + assertTrue(e.getMessage().contains("5555")); + } + + // Test combination of existing / in-existing product version IDs + // Inputs : productVersionIds [5555, prodVer1_2.getId()] + productVersionsReq.getProductVersionIds().add(prodVer1_2.getId()); + try { + reportGenerator.getLookupReportsForGavs(productVersionsReq); + fail(); + } catch (IllegalArgumentException e) { + assertTrue(e.getMessage().contains("5555")); + } + + // Test valid product name request with invalid product version id + LookupGAVsRequest validNameRequest = getDefaultLookupRequest(); + validNameRequest.getProductNames().add("Product1"); + validNameRequest.getProductVersionIds().add(5555L); + try { + reportGenerator.getLookupReportsForGavs(validNameRequest); + fail(); + } catch (IllegalArgumentException e) { + assertTrue(e.getMessage().contains("5555")); + } + + // Test valid product version id request with invalid product name + LookupGAVsRequest validProdVerRequest = getDefaultLookupRequest(); + validProdVerRequest.getProductNames().add("NoSuchProduct"); + validProdVerRequest.getProductVersionIds().add(prodVer1_2.getId()); + try { + reportGenerator.getLookupReportsForGavs(validProdVerRequest); + fail(); + } catch (IllegalArgumentException e) { + assertTrue(e.getMessage().contains("NoSuchProduct")); + } + + // Test combination of valid/invalid inputs for both name/ids + LookupGAVsRequest combinedValidAndInvalidRequest = getDefaultLookupRequest(); + combinedValidAndInvalidRequest.getProductNames().add("NoSuchProduct"); + combinedValidAndInvalidRequest.getProductNames().add("Product1"); + combinedValidAndInvalidRequest.getProductVersionIds().add(5555L); + combinedValidAndInvalidRequest.getProductVersionIds().add(prodVer1_2.getId()); + try { + reportGenerator.getLookupReportsForGavs(combinedValidAndInvalidRequest); + fail(); + } catch (IllegalArgumentException e) { + e.printStackTrace(); + assertTrue(e.getMessage().contains("NoSuchProduct")); + assertTrue(e.getMessage().contains("5555")); + } + } + +} diff --git a/testsuite/src/test/java/org/jboss/da/test/server/listings/WhiteArtifactServiceTestIT.java b/testsuite/src/test/java/org/jboss/da/test/server/listings/WhiteArtifactServiceTestIT.java new file mode 100644 index 000000000..56ab3b80d --- /dev/null +++ b/testsuite/src/test/java/org/jboss/da/test/server/listings/WhiteArtifactServiceTestIT.java @@ -0,0 +1,47 @@ +package org.jboss.da.test.server.listings; + +import org.jboss.arquillian.junit.Arquillian; +import org.jboss.da.communication.auth.impl.JAASAuthenticatorService; +import org.jboss.da.listings.api.model.ProductVersion; +import org.jboss.da.listings.api.service.ArtifactService.ArtifactStatus; +import org.jboss.da.listings.api.service.ProductService; +import org.jboss.da.listings.api.service.ProductVersionService; +import org.jboss.da.listings.api.service.WhiteArtifactService; +import org.jboss.da.listings.model.ProductSupportStatus; +import org.jboss.da.test.server.AbstractServerTest; +import static org.junit.Assert.assertEquals; +import org.junit.Test; +import org.junit.runner.RunWith; + +import javax.inject.Inject; + +/** + * + * @author Honza Brázdil + */ +@RunWith(Arquillian.class) +public class WhiteArtifactServiceTestIT extends AbstractServerTest { + + @Inject + ProductVersionService pvs; + + @Inject + ProductService ps; + + @Inject + WhiteArtifactService was; + + @Test + public void testAddDuplicateGA() { + JAASAuthenticatorService.setUser("user"); + ps.addProduct("EAP", "9.4.6", ProductSupportStatus.UNKNOWN); + ProductVersion pv = pvs.getProductVersion("EAP", "9.4.6").get(); + ArtifactStatus ret1 = was.addArtifact("foo", "bar", "1.0.0", pv.getId()); + assertEquals(ArtifactStatus.ADDED, ret1); + ArtifactStatus ret2 = was.addArtifact("foo", "bar", "1.0.0", pv.getId()); + assertEquals(ArtifactStatus.NOT_MODIFIED, ret2); + ArtifactStatus ret3 = was.addArtifact("foo", "bar", "2.0.0", pv.getId()); + assertEquals(ArtifactStatus.ADDED, ret3); + } + +} From 0b48f597e68c277f458b786ce972c1830c556dd4 Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Fri, 13 Feb 2026 16:58:13 +0000 Subject: [PATCH 05/26] Revert "Move Version code to pnc-api and pnc-common" This reverts commit ddc58a22a807aae33a933c3000c5152ebfe54a12. --- common/pom.xml | 4 + .../org/jboss/da/common/ScopedStrategy.java | 2 +- .../da/common/version/SuffixedVersion.java | 181 +++ .../da/common/version/VersionAnalyzer.java | 191 +++ .../da/common/version/VersionComparator.java | 277 +++++ .../da/common/version/VersionParser.java | 179 +++ .../da/common/version/VersionStrategy.java | 45 + .../common/version/SuffixedVersionTest.java | 61 + .../common/version/VersionAnalyzerTest.java | 1108 +++++++++++++++++ .../common/version/VersionComparatorTest.java | 288 +++++ .../da/common/version/VersionParserTest.java | 172 +++ pom.xml | 11 + .../impl/service/ArtifactServiceImpl.java | 2 +- .../service/BlackArtifactServiceImpl.java | 6 +- .../service/WhiteArtifactServiceImpl.java | 4 +- .../jboss/da/products/api/ArtifactDiff.java | 2 +- .../impl/AbstractProductProvider.java | 2 +- .../da/products/impl/ProductsServiceImpl.java | 6 +- .../jboss/da/reports/api/LookupGenerator.java | 4 +- .../da/reports/impl/LookupGeneratorImpl.java | 8 +- .../da/reports/impl/ReportsGeneratorImpl.java | 8 +- reports-model/pom.xml | 4 - .../da/lookup/model/MavenVersionsRequest.java | 2 - .../da/lookup/model/NPMVersionsRequest.java | 3 +- .../da/lookup/model/VersionDistanceRule.java | 37 + .../jboss/da/lookup/model/VersionFilter.java | 5 + reports-rest/pom.xml | 8 + 27 files changed, 2590 insertions(+), 30 deletions(-) create mode 100644 common/src/main/java/org/jboss/da/common/version/SuffixedVersion.java create mode 100644 common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java create mode 100644 common/src/main/java/org/jboss/da/common/version/VersionComparator.java create mode 100644 common/src/main/java/org/jboss/da/common/version/VersionParser.java create mode 100644 common/src/main/java/org/jboss/da/common/version/VersionStrategy.java create mode 100644 common/src/test/java/org/jboss/da/common/version/SuffixedVersionTest.java create mode 100644 common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java create mode 100644 common/src/test/java/org/jboss/da/common/version/VersionComparatorTest.java create mode 100644 common/src/test/java/org/jboss/da/common/version/VersionParserTest.java create mode 100644 reports-model/src/main/java/org/jboss/da/lookup/model/VersionDistanceRule.java create mode 100644 reports-model/src/main/java/org/jboss/da/lookup/model/VersionFilter.java diff --git a/common/pom.xml b/common/pom.xml index c36adec1d..fcacb56dd 100644 --- a/common/pom.xml +++ b/common/pom.xml @@ -45,6 +45,10 @@ jakarta.enterprise jakarta.enterprise.cdi-api + + org.commonjava.maven.ext + pom-manipulation-core + org.slf4j slf4j-api diff --git a/common/src/main/java/org/jboss/da/common/ScopedStrategy.java b/common/src/main/java/org/jboss/da/common/ScopedStrategy.java index edbabeb59..595bafd76 100644 --- a/common/src/main/java/org/jboss/da/common/ScopedStrategy.java +++ b/common/src/main/java/org/jboss/da/common/ScopedStrategy.java @@ -2,7 +2,7 @@ import lombok.Getter; import lombok.experimental.SuperBuilder; -import org.jboss.pnc.common.alignment.ranking.VersionStrategy; +import org.jboss.da.common.version.VersionStrategy; import java.util.Comparator; diff --git a/common/src/main/java/org/jboss/da/common/version/SuffixedVersion.java b/common/src/main/java/org/jboss/da/common/version/SuffixedVersion.java new file mode 100644 index 000000000..1c34860d4 --- /dev/null +++ b/common/src/main/java/org/jboss/da/common/version/SuffixedVersion.java @@ -0,0 +1,181 @@ +/* + * Copyright 2018 Honza Brázdil <jbrazdil@redhat.com>. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jboss.da.common.version; + +import lombok.EqualsAndHashCode; +import lombok.Getter; +import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; + +import java.util.Objects; +import java.util.Optional; + +/** + * + * @author Honza Brázdil <jbrazdil@redhat.com> + */ +@EqualsAndHashCode(exclude = { "originalVersionWithMeta" }) +@Getter +public class SuffixedVersion implements Comparable { + + private final int major; + + private final int minor; + + private final int micro; + + private final String qualifier; + + private final String suffix; + + private final Integer suffixVersion; + + private final QualifiedVersion originalVersionWithMeta; + + public SuffixedVersion(int major, int minor, int micro, String qualifier, String originalVersion) { + this(major, minor, micro, qualifier, new QualifiedVersion(originalVersion)); + } + + public SuffixedVersion( + int major, + int minor, + int micro, + String qualifier, + String suffix, + int suffixVersion, + String originalVersion) { + this(major, minor, micro, qualifier, suffix, suffixVersion, new QualifiedVersion(originalVersion)); + } + + public SuffixedVersion( + int major, + int minor, + int micro, + String qualifier, + QualifiedVersion originalVersionWithMeta) { + this.major = major; + this.minor = minor; + this.micro = micro; + this.qualifier = Objects.requireNonNull(qualifier); + this.suffix = null; + this.suffixVersion = null; + this.originalVersionWithMeta = originalVersionWithMeta; + } + + public SuffixedVersion( + int major, + int minor, + int micro, + String qualifier, + String suffix, + int suffixVersion, + QualifiedVersion originalVersionWithMeta) { + if (suffix == null || suffix.isEmpty()) { + throw new IllegalArgumentException("Suffix must be provided in this constructor."); + } + this.major = major; + this.minor = minor; + this.micro = micro; + this.qualifier = Objects.requireNonNull(qualifier); + this.suffix = Objects.requireNonNull(suffix); + this.suffixVersion = suffixVersion; + this.originalVersionWithMeta = originalVersionWithMeta; + } + + public String getOriginalVersion() { + return originalVersionWithMeta.getVersion(); + } + + public Optional getSuffix() { + return Optional.ofNullable(suffix); + } + + public Optional getSuffixVersion() { + return Optional.ofNullable(suffixVersion); + } + + public boolean isSuffixed() { + return suffix != null; + } + + @Override + public int compareTo(SuffixedVersion other) { + int r = Integer.compare(this.major, other.major); + if (r != 0) { + return r; + } + r = Integer.compare(this.minor, other.minor); + if (r != 0) { + return r; + } + r = Integer.compare(this.micro, other.micro); + if (r != 0) { + return r; + } + r = this.qualifier.compareToIgnoreCase(other.qualifier); + if (r != 0) { + return r; + } + if (this.suffix == null) { + if (other.suffix == null) { + return 0; + } else { + return -1; + } + } else if (other.suffix == null) { + return 1; + } + r = this.suffix.compareToIgnoreCase(other.suffix); + if (r != 0) { + return r; + } + r = Integer.compare(this.suffixVersion, other.suffixVersion); + if (r != 0) { + return r; + } + if (this.isOsgiVersion() && !other.isOsgiVersion()) { + return 1; + } else if (!this.isOsgiVersion() && other.isOsgiVersion()) { + return -1; + } + return 0; + } + + private boolean isOsgiVersion() { + var osgi = new org.commonjava.maven.ext.manip.impl.Version(getOriginalVersion()); + return getOriginalVersion().equals(osgi.getOSGiVersionString()); + } + + public final String normalizedVesion() { + String q = qualifier.isEmpty() ? "" : '.' + qualifier; + String s = ""; + if (suffix != null && !suffix.isEmpty()) { + s = q.isEmpty() ? "." : "-"; + s += suffix + '-' + suffixVersion; + } + return major + "." + minor + "." + micro + q + s; + } + + public final String unsuffixedVesion() { + String q = qualifier.isEmpty() ? "" : '.' + qualifier; + return major + "." + minor + "." + micro + q; + } + + @Override + public String toString() { + return normalizedVesion(); + } + +} diff --git a/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java b/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java new file mode 100644 index 000000000..c6770874b --- /dev/null +++ b/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java @@ -0,0 +1,191 @@ +/* + * Copyright 2018 Honza Brázdil <jbrazdil@redhat.com>. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jboss.da.common.version; + +import org.jboss.da.lookup.model.VersionDistanceRule; +import org.jboss.da.lookup.model.VersionFilter; +import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.EnumSet; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import java.util.stream.Collectors; + +import static org.jboss.da.common.version.VersionComparator.VersionDifference.EQUAL; +import static org.jboss.da.common.version.VersionComparator.VersionDifference.MICRO; +import static org.jboss.da.common.version.VersionComparator.VersionDifference.MINOR; +import static org.jboss.da.common.version.VersionComparator.VersionDifference.QUALIFIER; +import static org.jboss.da.common.version.VersionComparator.VersionDifference.RH_SUFFIX; +import static org.jboss.da.common.version.VersionComparator.VersionDifference.SUFFIX; + +/** + * @author Honza Brázdil <jbrazdil@redhat.com> + */ +public class VersionAnalyzer { + + public static final Map> ALLOWED_DIFFERENCE = new HashMap<>(); + static { + ALLOWED_DIFFERENCE.put(VersionFilter.ALL, EnumSet.allOf(VersionComparator.VersionDifference.class)); + ALLOWED_DIFFERENCE.put(VersionFilter.MAJOR, EnumSet.of(MINOR, MICRO, QUALIFIER, SUFFIX, RH_SUFFIX, EQUAL)); + ALLOWED_DIFFERENCE.put(VersionFilter.MAJOR_MINOR, EnumSet.of(MICRO, QUALIFIER, SUFFIX, RH_SUFFIX, EQUAL)); + ALLOWED_DIFFERENCE.put(VersionFilter.MAJOR_MINOR_MICRO, EnumSet.of(QUALIFIER, SUFFIX, RH_SUFFIX, EQUAL)); + ALLOWED_DIFFERENCE.put(VersionFilter.MAJOR_MINOR_MICRO_QUALIFIER, EnumSet.of(SUFFIX, RH_SUFFIX, EQUAL)); + } + + private static final Pattern VERSION_PATTERN = Pattern + .compile("^" + VersionParser.RE_MMM + VersionParser.RE_QUALIFIER_WITH_SEPARATOR + "?"); + + private final VersionParser versionParser; + private final List suffixes = new ArrayList<>(); + private final VersionDistanceRule distanceRule; + private final VersionStrategy strategies; + + public VersionAnalyzer(List suffixes) { + this(suffixes, VersionDistanceRule.RECOMMENDED_REPLACEMENT); + } + + public VersionAnalyzer(List suffixes, VersionStrategy strategies) { + this(suffixes, VersionDistanceRule.RECOMMENDED_REPLACEMENT, strategies); + } + + public VersionAnalyzer(List suffixes, VersionDistanceRule distanceRule) { + this(suffixes, distanceRule, VersionStrategy.none()); + } + + public VersionAnalyzer(List suffixes, VersionDistanceRule distanceRule, VersionStrategy strategies) { + this.suffixes.addAll(suffixes); + this.versionParser = new VersionParser(suffixes); + this.distanceRule = Objects.requireNonNull(distanceRule); + this.strategies = Objects.requireNonNull(strategies); + + strategies.getRanks().overrideVersionComparator(this::compareByBuildNumber); + } + + // TECHNICALLY NOT NEEDED, THIS IS FOR OLD MAVEN/NPM LOOKUP STUFF ENDPOINTS + public List sortVersions(String querry, Collection versions) { + VersionComparator comparator = new VersionComparator(querry, distanceRule, versionParser); + List sortedVersions = versions.stream().sorted(comparator).distinct().collect(Collectors.toList()); + return sortedVersions; + } + + // NO NEED, USED FOR VERSIONS' ENDPOINTS + public List filterVersions(String query, VersionFilter vf, Collection versions) { + VersionComparator vc = new VersionComparator(query, distanceRule, versionParser); + + return versions.stream() + .map(versionParser::parseSuffixed) + .flatMap(Set::stream) + .filter(v -> matches(vc, v, vf)) + .map(SuffixedVersion::getOriginalVersion) + .sorted(vc) + .distinct() + .collect(Collectors.toList()); + } + + private boolean matches(VersionComparator vc, SuffixedVersion v, VersionFilter vf) { + VersionComparator.VersionDifference difference = vc.difference(v); + return ALLOWED_DIFFERENCE.get(vf).contains(difference); + } + + public Optional findBiggestMatchingVersion(String query, Collection versions) { + String unsuffixedQuery = versionParser.parse(query).unsuffixedVesion(); + + // IF QUERY==2.3.4.REDHAT-00001 then FILTER ALL versions in 'versions' to have 2.3.4 + List candidateSuffixedVersions = versions.stream() + .map(versionParser::parseSuffixed) + .flatMap(Set::stream) + // apply strategy filters earlier because they might filter out an entire suffix + .filter(sv -> strategies.getAllowList().test(sv.getOriginalVersionWithMeta())) + .filter(sv -> strategies.getDenyList().negate().test(sv.getOriginalVersionWithMeta())) + .filter(v -> unsuffixedQuery.equals(v.unsuffixedVesion())) + .collect(Collectors.toList()); + + List versionsToSearch = Collections.emptyList(); + for (String suffix : suffixes) { + versionsToSearch = candidateSuffixedVersions.stream() + .filter(v -> suffix.equals(v.getSuffix().get())) + .collect(Collectors.toList()); + if (!versionsToSearch.isEmpty()) { + break; + } + } + + return versionsToSearch.stream() + .map(SuffixedVersion::getOriginalVersionWithMeta) + .max(strategies.getRanks()) + .map(QualifiedVersion::getVersion); + } + + private int compareByBuildNumber(String first, String second) { + SuffixedVersion firstSuffixed = versionParser.parse(first); + SuffixedVersion secondSuffixed = versionParser.parse(second); + + int firstBuildNum = firstSuffixed.getSuffixVersion().get(); + int secondBuildNum = secondSuffixed.getSuffixVersion().get(); + + if (firstBuildNum > secondBuildNum) { + return 1; + } + if (firstBuildNum == secondBuildNum) { + return getMoreSpecificVersion(first, second); + } + + return -1; + } + + private static int getMoreSpecificVersion(String first, String second) { + Matcher firstMatcher = VERSION_PATTERN.matcher(first); + Matcher secondMatcher = VERSION_PATTERN.matcher(second); + if (!firstMatcher.matches()) { + throw new IllegalArgumentException("Couldn't parse version " + first); + } + if (!secondMatcher.matches()) { + throw new IllegalArgumentException("Couldn't parse version " + second); + } + boolean firstIsOSGi = first.equals(VersionParser.getOSGiVersion(first)); + boolean secondIsOSGi = second.equals(VersionParser.getOSGiVersion(second)); + String firstMinor = firstMatcher.group("minor"); + String firstMicro = firstMatcher.group("micro"); + boolean returnFirst; + + if (firstIsOSGi != secondIsOSGi) { + returnFirst = firstIsOSGi; // One of the version is not OSGi, prefer the OSGi version + } else if (!Objects.equals(firstMinor, secondMatcher.group("minor"))) { + returnFirst = firstMinor != null; // One of the versions is missing minor number, prefer the one with it + } else if (!Objects.equals(firstMicro, secondMatcher.group("micro"))) { + returnFirst = firstMicro != null; // One of the versions is missing micro number, prefer the one with it + } else { + // Prefer the version that separates qualifier with '.', not something else like '-' + // If both are the same, prefer first + returnFirst = firstMatcher.group("qualifier").startsWith(".") + || !secondMatcher.group("qualifier").startsWith("."); + } + if (returnFirst) { + return 1; + } else { + return -1; + } + } +} diff --git a/common/src/main/java/org/jboss/da/common/version/VersionComparator.java b/common/src/main/java/org/jboss/da/common/version/VersionComparator.java new file mode 100644 index 000000000..35eb98854 --- /dev/null +++ b/common/src/main/java/org/jboss/da/common/version/VersionComparator.java @@ -0,0 +1,277 @@ +package org.jboss.da.common.version; + +import org.jboss.da.lookup.model.VersionDistanceRule; + +import java.io.Serializable; +import java.util.Arrays; +import java.util.Comparator; +import java.util.Objects; + +import static org.jboss.da.common.version.VersionComparator.VersionDifference.MAJOR; +import static org.jboss.da.common.version.VersionComparator.VersionDifference.MICRO; +import static org.jboss.da.common.version.VersionComparator.VersionDifference.MINOR; +import static org.jboss.da.common.version.VersionComparator.VersionDifference.QUALIFIER; +import static org.jboss.da.common.version.VersionComparator.VersionDifference.RH_SUFFIX; +import static org.jboss.da.common.version.VersionComparator.VersionDifference.SUFFIX; + +/** + * + * @author Honza Brázdil <jbrazdil@redhat.com> + */ +public class VersionComparator implements Comparator, Serializable { + + private final VersionDistanceRule distanceRule; + + public enum VersionDifference { + MAJOR, MINOR, MICRO, QUALIFIER, SUFFIX, RH_SUFFIX, EQUAL; + } + + private final SuffixedVersion base; + + private final VersionParser versionParser; + + /** + * Returns classic comparator for versions. + * + * @param versionParser Parser that will be used to parse the version. + */ + public VersionComparator(VersionParser versionParser) { + this.base = null; + this.distanceRule = null; + this.versionParser = Objects.requireNonNull(versionParser); + } + + /** + * Returns comparator that compares versions by distance to the base version. The + * {@link VersionDistanceRule#RECOMMENDED_REPLACEMENT} rule for computing the distance to base version is used. + * + * @param base The base version. + * @param versionParser Parser that will be used to parse the version. + */ + public VersionComparator(String base, VersionParser versionParser) { + this(base, VersionDistanceRule.RECOMMENDED_REPLACEMENT, versionParser); + } + + /** + * Returns comparator that compares versions by distance to the base version. + * + * @param base The base version. + * @param distanceRule The rule that is used to compute the distance to base version. + * @param versionParser Parser that will be used to parse the version. + */ + public VersionComparator(String base, VersionDistanceRule distanceRule, VersionParser versionParser) { + this.versionParser = Objects.requireNonNull(versionParser); + this.base = versionParser.parse(Objects.requireNonNull(base)); + this.distanceRule = Objects.requireNonNull(distanceRule); + } + + /** + * Return information about first part of version that is different. + */ + public VersionDifference difference(String version1, String version2) { + SuffixedVersion v1 = versionParser.parse(version1); + SuffixedVersion v2 = versionParser.parse(version2); + return difference(v1, v2); + } + + /** + * Return information about first part of version that is different. + */ + public VersionDifference difference(SuffixedVersion v1, SuffixedVersion v2) { + if (v1.getMajor() != v2.getMajor()) { + return MAJOR; + } + if (v1.getMinor() != v2.getMinor()) { + return MINOR; + } + if (v1.getMicro() != v2.getMicro()) { + return VersionDifference.MICRO; + } + if (!v1.getQualifier().equals(v2.getQualifier())) { + return QUALIFIER; + } + if (!v1.getSuffix().equals(v2.getSuffix())) { + return SUFFIX; + } + if (!v1.getSuffixVersion().equals(v2.getSuffixVersion())) { + return RH_SUFFIX; + } + return VersionDifference.EQUAL; + } + + /** + * Return information about first part of version that is different, compared to the base version. + */ + public VersionDifference difference(SuffixedVersion version) { + return difference(base, version); + } + + @Override + public int compare(String version1, String version2) { + SuffixedVersion v1 = versionParser.parse(version1); + SuffixedVersion v2 = versionParser.parse(version2); + int r = v1.compareTo(v2); + if (r == 0 || base == null) { + return r; + } else { + switch (distanceRule) { + case RECOMMENDED_REPLACEMENT: + return compareAsRecommendedReplacement(v1, v2); + case CLOSEST_BY_PARTS: + return compareAsClosestByParts(v1, v2); + default: + throw new UnsupportedOperationException("Unknown distance rule " + distanceRule); + } + } + } + + // Assuming different versions + // Return -1 - v1 is closer to the base version + // Return 1 - v2 is closer to the base version + private int compareAsRecommendedReplacement(SuffixedVersion v1, SuffixedVersion v2) { + // If one of the versions is the same as base, it is closer. + if (base.equals(v1)) { + return -1; + } + if (base.equals(v2)) { + return 1; + } + + // If one version differs from the base in major, the other is closer no matter what + if (v1.getMajor() != v2.getMajor()) { + if (v1.getMajor() == base.getMajor()) { + return -1; + } + if (v2.getMajor() == base.getMajor()) { + return 1; + } + } + + // Sort the 3 versions + SuffixedVersion[] versions = { base, v1, v2 }; + Arrays.sort(versions); + + if (versions[0] == base) { // v1 and v2 are greater than base, use the lowest of them + int candidate; + if (versions[1] == v1) { + candidate = -1; + } else { + candidate = 1; + } + + // if differs only in qualifier, higher qualifier preferred + if (v1.getMajor() == v2.getMajor() && v1.getMinor() == v2.getMinor() && v1.getMicro() == v2.getMicro()) { + candidate *= -1; + } + return candidate; + } else if (versions[2] == base) { // v1 and v2 are lower than base, use the greatest of them + if (versions[1] == v1) { + return -1; + } else { + return 1; + } + } else { // one is lower than base, second is greater than base. Use the greater. + if (versions[2] == v1) { + return -1; + } else { + return 1; + } + } + } + + // Assuming different versions + // Return -1 - v1 is closer to the base version + // Return 1 - v2 is closer to the base version + private int compareAsClosestByParts(SuffixedVersion v1, SuffixedVersion v2) { + // If one of the versions is the same as base, it is closer. + if (base.equals(v1)) { + return -1; + } + if (base.equals(v2)) { + return 1; + } + + VersionDifference difference = difference(v1, v2); + VersionDifference differenceV1ToBase = difference(base, v1); + VersionDifference differenceV2ToBase = difference(base, v2); + + // Rule 1 + if (differenceV1ToBase != differenceV2ToBase) { + switch (difference) { + case MAJOR: + return differenceV1ToBase == MAJOR ? 1 : -1; + case MINOR: + return differenceV1ToBase == MINOR ? 1 : -1; + case MICRO: + return differenceV1ToBase == MICRO ? 1 : -1; + case QUALIFIER: + return differenceV1ToBase == QUALIFIER ? 1 : -1; + case SUFFIX: + return differenceV1ToBase == SUFFIX ? 1 : -1; + case RH_SUFFIX: + return differenceV1ToBase == RH_SUFFIX ? 1 : -1; + default: + throw new IllegalStateException("Unknown difference " + difference); + } + } + + // Rule 2 + if (differenceV1ToBase == differenceV2ToBase && differenceV1ToBase == difference) { + switch (difference) { + case MAJOR: + return comparePart(base.getMajor(), v1.getMajor(), v2.getMajor()); + case MINOR: + return comparePart(base.getMinor(), v1.getMinor(), v2.getMinor()); + case MICRO: + return comparePart(base.getMicro(), v1.getMicro(), v2.getMicro()); + } + } + + // Rule 3 + SuffixedVersion[] versions = { base, v1, v2 }; + Arrays.sort(versions); + + if (versions[0] == base) { // v1 and v2 are greater than base, use the lowest of them + int candidate; + if (versions[1] == v1) { + candidate = -1; + } else { + candidate = 1; + } + + // if differs only in qualifier, higher qualifier preferred + if (difference != MAJOR && difference != MINOR && difference != MICRO) { + candidate *= -1; + } + return candidate; + } else if (versions[2] == base) { // v1 and v2 are lower than base, use the greatest of them + if (versions[1] == v1) { + return -1; + } else { + return 1; + } + } else { // one is lower than base, second is greater than base. They MUST differ in qualifier, so use greater + if (difference == MAJOR || difference == MINOR || difference == MICRO) { + throw new IllegalStateException("Broken rule 2"); + } + if (versions[2] == v1) { + return -1; + } else { + return 1; + } + } + } + + private int comparePart(int base, int v1, int v2) { + int v1diff = Math.abs(base - v1); + int v2diff = Math.abs(base - v2); + if (v1diff == v2diff) { + if (v1 > v2) { + return -1; + } else { + return 1; + } + } + return v1diff - v2diff; + } +} diff --git a/common/src/main/java/org/jboss/da/common/version/VersionParser.java b/common/src/main/java/org/jboss/da/common/version/VersionParser.java new file mode 100644 index 000000000..a5cbd34b6 --- /dev/null +++ b/common/src/main/java/org/jboss/da/common/version/VersionParser.java @@ -0,0 +1,179 @@ +package org.jboss.da.common.version; + +import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public class VersionParser { + + private final Map versionPatterns = new HashMap<>(); + + // single dot at the end of the version indicates ommited micro "0" + // NCLSUP-132 asks to allow dash instead of dot before micro + static final String RE_MICRO = "(\\.$|[.-](?[0-9]{1,9}))"; + + // major.minor.micro.qualifier-suffix-X + // numbers limited to max 9 digits, beacuse of integer limitatations + static final String RE_MMM = "((?[0-9]{1,9})?(\\.(?[0-9]{1,9})" + RE_MICRO + "?)?)"; + + static final String RE_QUALIFIER = "([.-]?(?.+?))"; + // this differs from RE_QUALIFIER only in that the group also contains the [.-] separator + static final String RE_QUALIFIER_WITH_SEPARATOR = "(?[.-]?(.+?))"; + + private static final String RE_SUFFIX_S = "([.-]"; + + private static final String RE_SUFFIX_E = "-(?[0-9]{1,9}))?"; + + private static final Pattern UNSUFFIXED_PATTERN = Pattern.compile("^" + RE_MMM + RE_QUALIFIER + "?" + "$"); + + public VersionParser(String... suffix) { + this(Arrays.asList(suffix)); + } + + public VersionParser(List suffixes) { + for (String suffix : suffixes) { + this.versionPatterns.put( + suffix, + Pattern.compile("^" + RE_MMM + RE_QUALIFIER + "??" + RE_SUFFIX_S + suffix + RE_SUFFIX_E + "$")); + } + } + + public static SuffixedVersion parseUnsuffixed(String version) { + return parseVersion(UNSUFFIXED_PATTERN.matcher(version), new QualifiedVersion(version)); + } + + /** + * Parses the version string and returns the normalized version. + * + * @see #parse(QualifiedVersion) for details + * @param version the original string version + * @return The normalized version + */ + public SuffixedVersion parse(String version) { + return parse(new QualifiedVersion(version)); + } + + public static SuffixedVersion parseUnsuffixed(QualifiedVersion version) { + return parseVersion(UNSUFFIXED_PATTERN.matcher(version.getVersion()), version); + } + + /** + * Returns suffixed versions that can be parsed from the provided version string. + * + * @param version The version string to parse + * @return Set of suffixed versions parsable from the version string. + */ + public Set parseSuffixed(String version) { + return parseSuffixed(new QualifiedVersion(version)); + } + + /** + * Parses the version string and returns the normalized version (with longest suffix). Because the version may have + * any of the suffixes (ore none) the normalized version is the one with the longest suffix (or in other words with + * shortest version string after removing the suffix). + * + * @param versionWithMeta The original version string with metadata. + * @return The normalized version + */ + public SuffixedVersion parse(QualifiedVersion versionWithMeta) { + SuffixedVersion normalized = parseUnsuffixed(versionWithMeta); + int length = normalized.getQualifier().length(); + for (SuffixedVersion suffixedVersion : parseSuffixed(versionWithMeta)) { + if (suffixedVersion.getQualifier().length() < length) { + normalized = suffixedVersion; + length = suffixedVersion.getQualifier().length(); + } + } + return normalized; + } + + /** + * Returns suffixed versions that can be parsed from the provided version string. + * + * @param versionWithMeta The version to parse + * @return Set of suffixed versions parsable from the version string. + */ + public Set parseSuffixed(QualifiedVersion versionWithMeta) { + Set ret = new HashSet<>(); + for (Map.Entry entry : versionPatterns.entrySet()) { + String suffix = entry.getKey(); + Pattern versionPattern = entry.getValue(); + SuffixedVersion suffixedVersion = parseVersion( + versionPattern.matcher(versionWithMeta.getVersion()), + versionWithMeta, + suffix); + if (suffixedVersion.isSuffixed()) { + ret.add(suffixedVersion); + } + } + return ret; + } + + private static SuffixedVersion parseVersion(Matcher versionMatcher, QualifiedVersion versionWithMeta) + throws NumberFormatException, IllegalArgumentException { + String version = versionWithMeta.getVersion(); + + if (!versionMatcher.matches()) { + throw new IllegalArgumentException("Version " + version + "is unparsable"); + } + String majorString = versionMatcher.group("major"); + String minorString = versionMatcher.group("minor"); + String microString = versionMatcher.group("micro"); + String qualifierString = versionMatcher.group("qualifier"); + + int major = parseNumberString(majorString); + int minor = parseNumberString(minorString); + int micro = parseNumberString(microString); + String qualifier = qualifierString == null ? "" : qualifierString.replace('.', '-').replace(',', '-'); + return new SuffixedVersion(major, minor, micro, qualifier, versionWithMeta); + } + + private static SuffixedVersion parseVersion( + Matcher versionMatcher, + QualifiedVersion versionWithMeta, + String parseSuffix) throws NumberFormatException, IllegalArgumentException { + if (!versionMatcher.matches()) { + throw new IllegalArgumentException("Version " + versionWithMeta.getVersion() + "is unparsable"); + } + String majorString = versionMatcher.group("major"); + String minorString = versionMatcher.group("minor"); + String microString = versionMatcher.group("micro"); + String qualifierString = versionMatcher.group("qualifier"); + String suffixVersionString = versionMatcher.group("suffixversion"); + + int major = parseNumberString(majorString); + int minor = parseNumberString(minorString); + int micro = parseNumberString(microString); + String qualifier = qualifierString == null ? "" : qualifierString.replace('.', '-').replace(',', '-'); + if (suffixVersionString == null) { + return new SuffixedVersion(major, minor, micro, qualifier, versionWithMeta); + } else { + int suffixVersion = Integer.parseInt(suffixVersionString); + return new SuffixedVersion(major, minor, micro, qualifier, parseSuffix, suffixVersion, versionWithMeta); + } + } + + private static int parseNumberString(String segmentString) { + return segmentString == null ? 0 : Integer.parseInt(segmentString); + } + + /** + * Converts version to osgi compliant + * + * @param version + * @return + */ + public static String getOSGiVersion(String version) { + String osgiS = (new org.commonjava.maven.ext.manip.impl.Version(version + ".foo")).getOSGiVersionString(); + int len = osgiS.length(); + return osgiS.substring(0, len - 4); + } + +} diff --git a/common/src/main/java/org/jboss/da/common/version/VersionStrategy.java b/common/src/main/java/org/jboss/da/common/version/VersionStrategy.java new file mode 100644 index 000000000..0b994adcb --- /dev/null +++ b/common/src/main/java/org/jboss/da/common/version/VersionStrategy.java @@ -0,0 +1,45 @@ +package org.jboss.da.common.version; + +import lombok.AccessLevel; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.experimental.SuperBuilder; +import org.jboss.pnc.common.alignment.ranking.AlignmentPredicate; +import org.jboss.pnc.common.alignment.ranking.AlignmentRanking; + +import java.util.List; + +@SuperBuilder +@AllArgsConstructor(access = AccessLevel.PUBLIC) +public class VersionStrategy { + + @Getter + private final AlignmentRanking ranks; + + @Getter + private final AlignmentPredicate denyList; + + @Getter + private final AlignmentPredicate allowList; + + /** + * Returns such strategy that does not alter behaviour of version analysis + * + * @return strategy that does not affect version analysis + */ + public static VersionStrategy none() { + return VersionStrategy.builder() + .ranks(new AlignmentRanking(null, null)) + .allowList(new AlignmentPredicate(null, ver -> true)) + .denyList(new AlignmentPredicate(null, ver -> false)) + .build(); + } + + public static VersionStrategy from(List ranks, String allowList, String denyList) { + return VersionStrategy.builder() + .ranks(new AlignmentRanking(ranks, null)) + .allowList(new AlignmentPredicate(allowList, ver -> true)) + .denyList(new AlignmentPredicate(denyList, ver -> false)) + .build(); + } +} diff --git a/common/src/test/java/org/jboss/da/common/version/SuffixedVersionTest.java b/common/src/test/java/org/jboss/da/common/version/SuffixedVersionTest.java new file mode 100644 index 000000000..e6bee105e --- /dev/null +++ b/common/src/test/java/org/jboss/da/common/version/SuffixedVersionTest.java @@ -0,0 +1,61 @@ +/* + * Copyright 2018 Honza Brázdil <jbrazdil@redhat.com>. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jboss.da.common.version; + +import org.junit.Assert; +import org.junit.Test; + +/** + * + * @author Honza Brázdil <jbrazdil@redhat.com> + */ +public class SuffixedVersionTest { + + @Test + public void testSimpleVersions() { + SuffixedVersion v1 = new SuffixedVersion(1, 2, 3, "", "1.2.3"); + SuffixedVersion v2 = new SuffixedVersion(1, 2, 3, "", "1.2.3"); + SuffixedVersion v3 = new SuffixedVersion(1, 2, 4, "", "1.2.4"); + SuffixedVersion v4 = new SuffixedVersion(2, 3, 4, "foobar", "2.3.4.foobar"); + Assert.assertEquals(1, v1.getMajor()); + Assert.assertEquals(2, v1.getMinor()); + Assert.assertEquals(3, v1.getMicro()); + Assert.assertEquals("", v1.getQualifier()); + Assert.assertEquals("foobar", v4.getQualifier()); + Assert.assertTrue(v1.equals(v2)); + Assert.assertFalse(v1.equals(v3)); + Assert.assertEquals("1.2.3", v1.toString()); + Assert.assertEquals("2.3.4.foobar", v4.toString()); + } + + @Test + public void testSuffixedVersions() { + SuffixedVersion v1 = new SuffixedVersion(1, 2, 3, "", "suffix", 1, "1.2.3.suffix-1"); + SuffixedVersion v2 = new SuffixedVersion(1, 2, 3, "", "suffix", 1, "1.2.3.suffix-1"); + SuffixedVersion v3a = new SuffixedVersion(1, 2, 3, "", "suffix", 2, "1.2.3.suffix-2"); + SuffixedVersion v3b = new SuffixedVersion(1, 2, 3, "", "xiffus", 1, "1.2.3.xiffus-1"); + SuffixedVersion v4 = new SuffixedVersion(2, 3, 4, "foobar", "suffix", 1, "2.3.4.foobar-suffix-1"); + Assert.assertEquals("suffix", v1.getSuffix().get()); + Assert.assertEquals(Integer.valueOf(1), v1.getSuffixVersion().get()); + Assert.assertEquals(Integer.valueOf(2), v3a.getSuffixVersion().get()); + Assert.assertEquals("", v1.getQualifier()); + Assert.assertTrue(v1.equals(v2)); + Assert.assertFalse(v1.equals(v3a)); + Assert.assertFalse(v1.equals(v3b)); + Assert.assertEquals("1.2.3.suffix-1", v1.toString()); + Assert.assertEquals("2.3.4.foobar-suffix-1", v4.toString()); + } +} diff --git a/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java b/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java new file mode 100644 index 000000000..4ac9610fb --- /dev/null +++ b/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java @@ -0,0 +1,1108 @@ +package org.jboss.da.common.version; + +import org.jboss.da.common.CommunicationException; +import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; +import org.jboss.pnc.api.enums.Qualifier; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.stream.Collectors; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +/** + * + * @author Jakub Bartecek <jbartece@redhat.com> + * + */ +public class VersionAnalyzerTest { + + private VersionAnalyzer versionFinder = new VersionAnalyzer(Collections.singletonList("redhat")); + + private static final String NO_BUILT_VERSION = "1.1.3"; + + private static final String NO_BUILT_VERSION_2 = "1.0.20"; + + private static final String BUILT_VERSION = "1.1.4"; + + private static final String BUILT_VERSION_RH = BUILT_VERSION + "-redhat-20"; + + private static final String BUILT_VERSION_2 = "1.1.4.Final"; + + private static final String BUILT_VERSION_2_RH = BUILT_VERSION_2 + "-redhat-10"; + + private static final String MULTI_BUILT_VERSION = "1.1.5"; + + private static final String MULTI_BUILT_VERSION_RH1 = MULTI_BUILT_VERSION + ".redhat-5"; + + private static final String MULTI_BUILT_VERSION_RH2 = MULTI_BUILT_VERSION + ".redhat-3"; + + private static final String MULTI_BUILT_VERSION_RH_BEST = MULTI_BUILT_VERSION + ".redhat-18"; + + private static final String MULTI_BUILT_VERSION_RH4 = MULTI_BUILT_VERSION + ".redhat-16"; + + private static final String OTHER_RH_VERSION_1 = "1.0.0.redhat-1"; + + private static final String OTHER_RH_VERSION_2 = "1.0.0.redhat-18"; + + private static final String OTHER_RH_VERSION_3 = "1.1.1.redhat-15"; + + private static final String NON_OSGI_VERSION = "1.3"; + + private static final String NON_OSGI_VERSION_RHT = "1.3.redhat-4"; + + private static final String NON_OSGI_VERSION_2 = "1.3-Final"; + + private static final String NON_OSGI_VERSION_2_RHT = "1.3.0.Final-redhat-7"; + + private static final String NON_OSGI_VERSION_3 = "1.2.3.foo.bar.baz"; + + private static final String NON_OSGI_VERSION_3_RHT = "1.2.3.foo-bar-baz-redhat-5"; + + private static final String NON_OSGI_VERSION_4 = "1.5.9.foo,bar,baz"; + + private static final String NON_OSGI_VERSION_4_RHT = "1.5.9.foo-bar-baz-redhat-8"; + + private static final List All_VERSIONS = Arrays.asList( + OTHER_RH_VERSION_1, + OTHER_RH_VERSION_2, + NO_BUILT_VERSION_2, + NO_BUILT_VERSION, + OTHER_RH_VERSION_3, + MULTI_BUILT_VERSION_RH2, + BUILT_VERSION_RH, + MULTI_BUILT_VERSION_RH1, + BUILT_VERSION_2_RH, + MULTI_BUILT_VERSION_RH_BEST, + MULTI_BUILT_VERSION_RH4, + NON_OSGI_VERSION, + NON_OSGI_VERSION_RHT, + BUILT_VERSION_2, + NON_OSGI_VERSION_2, + NON_OSGI_VERSION_2_RHT, + NON_OSGI_VERSION_3, + NON_OSGI_VERSION_3_RHT, + NON_OSGI_VERSION_4, + NON_OSGI_VERSION_4_RHT); + + private static final List BUILT_VERSIONS = Arrays.asList( + OTHER_RH_VERSION_1, + OTHER_RH_VERSION_2, + OTHER_RH_VERSION_3, + MULTI_BUILT_VERSION_RH2, + BUILT_VERSION_RH, + MULTI_BUILT_VERSION_RH1, + BUILT_VERSION_2_RH, + MULTI_BUILT_VERSION_RH_BEST, + MULTI_BUILT_VERSION_RH4, + NON_OSGI_VERSION_RHT, + NON_OSGI_VERSION_2_RHT, + NON_OSGI_VERSION_3_RHT, + NON_OSGI_VERSION_4_RHT); + + @Test + public void getBestMatchVersionForNonExistingGAV() throws CommunicationException { + Optional bmv = versionFinder.findBiggestMatchingVersion("0.0.1", Collections.EMPTY_LIST); + assertFalse("Best match version expected to not be present", bmv.isPresent()); + } + + @Test + public void getBestMatchVersionForNotBuiltGAV() throws CommunicationException { + Optional bmv = versionFinder.findBiggestMatchingVersion( + NO_BUILT_VERSION, + All_VERSIONS.stream().map(QualifiedVersion::new).collect(Collectors.toList())); + assertFalse("Best match version expected to not be present", bmv.isPresent()); + } + + @Test + public void getBestMatchVersionForBuiltGAV() throws CommunicationException { + checkBMV(BUILT_VERSION_RH, BUILT_VERSION, All_VERSIONS.toArray(new String[All_VERSIONS.size()])); + checkBMV(BUILT_VERSION_2_RH, BUILT_VERSION_2, All_VERSIONS.toArray(new String[All_VERSIONS.size()])); + } + + @Test + public void getBestMatchVersionForMultipleBuiltGAV() throws CommunicationException { + checkBMV( + MULTI_BUILT_VERSION_RH_BEST, + MULTI_BUILT_VERSION, + All_VERSIONS.toArray(new String[All_VERSIONS.size()])); + } + + @Test + public void getBestMatchVersionForNoOSGIGAV() throws CommunicationException { + checkBMV(NON_OSGI_VERSION_RHT, NON_OSGI_VERSION, All_VERSIONS.toArray(new String[All_VERSIONS.size()])); + checkBMV(NON_OSGI_VERSION_2_RHT, NON_OSGI_VERSION_2, All_VERSIONS.toArray(new String[All_VERSIONS.size()])); + checkBMV(NON_OSGI_VERSION_3_RHT, NON_OSGI_VERSION_3, All_VERSIONS.toArray(new String[All_VERSIONS.size()])); + checkBMV(NON_OSGI_VERSION_4_RHT, NON_OSGI_VERSION_4, All_VERSIONS.toArray(new String[All_VERSIONS.size()])); + } + + @Test + public void NCL2931ReproducerTest() { + String[] avaliableVersions = { + "1.4.0.redhat-4", + "1.4.redhat-3", + "1.4-redhat-2", + "1.4-redhat-1", + "1.6.0.redhat-5", + "1.6.0.redhat-4", + "1.6.0.redhat-3", + "1.6.redhat-2", + "1.6.redhat-1", + "1.9.0.redhat-1", + "1.10.0.redhat-5", + "1.10.0.redhat-4", + "1.10.0.redhat-3", + "1.10.0.redhat-2", + "1.10.0.redhat-1" }; + checkBMV("1.4.0.redhat-4", "1.4", avaliableVersions); + } + + @Test + public void ambiguousNonOSGIVersionsTest() { + String[] avaliableVersionsWithOSGI = { "1.0.0.redhat-1", "1.0.redhat-1", "1.redhat-1" }; + checkBMV("1.0.0.redhat-1", "1.0.0", avaliableVersionsWithOSGI); + checkBMV("1.0.0.redhat-1", "1.0", avaliableVersionsWithOSGI); + checkBMV("1.0.0.redhat-1", "1", avaliableVersionsWithOSGI); + + String[] avaliableVersionsWithOSGIRev = { "1.redhat-1", "1.0.redhat-1", "1.0.0.redhat-1" }; + checkBMV("1.0.0.redhat-1", "1.0.0", avaliableVersionsWithOSGIRev); + checkBMV("1.0.0.redhat-1", "1.0", avaliableVersionsWithOSGIRev); + checkBMV("1.0.0.redhat-1", "1", avaliableVersionsWithOSGIRev); + + String[] avaliableVersionsWithoutOSGI = { "1.0.redhat-1", "1.redhat-1" }; + checkBMV("1.0.redhat-1", "1.0.0", avaliableVersionsWithoutOSGI); + checkBMV("1.0.redhat-1", "1.0", avaliableVersionsWithoutOSGI); + checkBMV("1.0.redhat-1", "1", avaliableVersionsWithoutOSGI); + + String[] avaliableVersionsWithoutOSGI2 = { "1.redhat-1" }; + checkBMV("1.redhat-1", "1.0.0", avaliableVersionsWithoutOSGI2); + checkBMV("1.redhat-1", "1.0", avaliableVersionsWithoutOSGI2); + checkBMV("1.redhat-1", "1", avaliableVersionsWithoutOSGI2); + } + + @Test + public void nonOSGIVersionsTest() { + String[] avaliableVersions1 = { "1.0.0.redhat-1", "1.0.redhat-2", "1.redhat-3" }; + checkBMV("1.redhat-3", "1.0.0", avaliableVersions1); + checkBMV("1.redhat-3", "1.0", avaliableVersions1); + checkBMV("1.redhat-3", "1", avaliableVersions1); + + String[] avaliableVersions10 = { "1.0.0.redhat-1", "1.0.redhat-3", "1.redhat-2" }; + checkBMV("1.0.redhat-3", "1.0.0", avaliableVersions10); + checkBMV("1.0.redhat-3", "1.0", avaliableVersions10); + checkBMV("1.0.redhat-3", "1", avaliableVersions10); + + String[] avaliableVersions100 = { "1.0.0.redhat-3", "1.0.redhat-2", "1.redhat-1" }; + checkBMV("1.0.0.redhat-3", "1.0.0", avaliableVersions100); + checkBMV("1.0.0.redhat-3", "1.0", avaliableVersions100); + checkBMV("1.0.0.redhat-3", "1", avaliableVersions100); + } + + @Test + public void NCL4266ReproducerTest() { + String[] avaliableVersions1 = { + "2.2.3.redhat-00001", + "2.2.0.temporary-redhat-00001", + "2.2.0.redhat-00001", + "2.1.16.redhat-00001", + "2.1.9.redhat-1", + "2.1.9.redhat-001", + "2.1.3.redhat-001" }; + checkBMV( + new VersionAnalyzer(Arrays.asList("temporary-redhat", "redhat")), + "2.2.3.redhat-00001", + "2.2.3", + avaliableVersions1); + } + + @Test + public void preferOSGiVersionFormatTest() { + // as 3.0.0-redhat-2 and 3.0.0.redhat-2 are the same version then ordering in the array matters + // (if they were in opposite direction test would pass even without OSGi preference) + String[] availableVersions = { + "3-redhat-2", + "3.0.0-redhat-2", + "3.0.0.redhat-2", + "3.0.0.redhat-1", + "2.1.1.redhat-3", + "2.1.16-redhat-9", + "2.9.9-redhat-00001" }; + checkBMV("3.0.0.redhat-2", "3", availableVersions); + Collections.reverse(Arrays.asList(availableVersions)); + checkBMV("3.0.0.redhat-2", "3", availableVersions); + String[] availableVersions2 = { + "2.1.1.redhat-3", + "2.1.16-redhat-9", + "3-redhat-2", + "3.0-redhat-2", + "3.0.redhat-2", + "3.0.-redhat-2", + "3.0.0-redhat-2", + "3.0.0.redhat-1", + "3.0.0.redhat-2", + "2.9.9-redhat-00001" }; + checkBMV("3.0.0.redhat-2", "3", availableVersions2); + Collections.reverse(Arrays.asList(availableVersions2)); + checkBMV("3.0.0.redhat-2", "3", availableVersions2); + String[] availableVersions3 = { + "2.1.1.redhat-3", + "2.1.16-redhat-9", + "3-redhat-2", + "3.0-redhat-2", + "3.0.redhat-2", + "3.0.-redhat-2", + "3.0.0-redhat-2", + "3.0.0.redhat-1", + "2.9.9-redhat-00001" }; + checkBMV("3.0.0-redhat-2", "3", availableVersions3); + Collections.reverse(Arrays.asList(availableVersions3)); + checkBMV("3.0.0-redhat-2", "3", availableVersions3); + String[] availableVersions4 = { + "2.1.1.redhat-3", + "2.1.16-redhat-9", + "3-redhat-2", + "3.0-redhat-2", + "3.0.redhat-2", + "3.0.0.redhat-1", + "2.9.9-redhat-00001" }; + checkBMV("3.0.redhat-2", "3", availableVersions4); + Collections.reverse(Arrays.asList(availableVersions4)); + checkBMV("3.0.redhat-2", "3", availableVersions4); + } + + private void checkBMV(String expectedVersion, String version, String[] versions) { + checkBMV(versionFinder, expectedVersion, version, versions); + } + + private void checkBMV(VersionAnalyzer versionAnalyzer, String expectedVersion, String version, String[] versions) { + Optional bmv = versionAnalyzer.findBiggestMatchingVersion( + version, + Arrays.stream(versions).map(QualifiedVersion::new).collect(Collectors.toList())); + + assertTrue("Best match version expected to be present", bmv.isPresent()); + assertEquals(expectedVersion, bmv.get()); + } + + private void checkBMV( + VersionAnalyzer versionAnalyzer, + String expectedVersion, + String version, + QualifiedVersion[] versions) { + Optional bmv = versionAnalyzer + .findBiggestMatchingVersion(version, Arrays.stream(versions).collect(Collectors.toList())); + + assertTrue("Best match version expected to be present", bmv.isPresent()); + assertEquals(expectedVersion, bmv.get()); + } + + @Test + public void testDifferentSuffix() { + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(Arrays.asList("temporary-redhat", "redhat")); + String version = "1.4.0"; + String expectedVersion = "1.4.0.temporary-redhat-1"; + + String[] avaliableVersionsOrder1 = { "1.4.0.redhat-1", "1.4.0.temporary-redhat-1" }; + checkBMV(versionAnalyzer, expectedVersion, version, avaliableVersionsOrder1); + + String[] avaliableVersionsOrder2 = { "1.4.0.temporary-redhat-1", "1.4.0.redhat-1" }; + checkBMV(versionAnalyzer, expectedVersion, version, avaliableVersionsOrder2); + + String[] avaliableVersionsMultiple = { + "1.4.0.redhat-4", + "1.4.0.redhat-3", + "1.4.0.redhat-2", + "1.4.0.redhat-1", + "1.4.0.temporary-redhat-1", }; + checkBMV(versionAnalyzer, expectedVersion, version, avaliableVersionsMultiple); + } + + @Test + public void testDifferentSuffixWithOnlyDefaultVersions() { + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(Arrays.asList("t20180522-115319-991-redhat", "redhat")); + String version = "1.4.0"; + + String[] avaliableVersionsOrder1 = { "1.4.0.redhat-1", "1.4.0.temporary-redhat-1" }; + checkBMV(versionAnalyzer, "1.4.0.redhat-1", version, avaliableVersionsOrder1); + + String[] avaliableVersionsOrder2 = { "1.4.0.temporary-redhat-1", "1.4.0.redhat-1" }; + checkBMV(versionAnalyzer, "1.4.0.redhat-1", version, avaliableVersionsOrder2); + + String[] avaliableVersionsMultiple = { + "1.4.0.redhat-4", + "1.4.0.redhat-3", + "1.4.0.redhat-2", + "1.4.0.redhat-1", + "1.4.0.temporary-redhat-1", }; + checkBMV(versionAnalyzer, "1.4.0.redhat-4", version, avaliableVersionsMultiple); + } + + @Test + public void testSingleRankOfQuality() { + VersionStrategy strat = VersionStrategy.from(List.of("QUALITY:RELEASED"), null, null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.QUALITY, Set.of("TESTED"))), + new QualifiedVersion("1.4.0.redhat-3", Map.of(Qualifier.PRODUCT_ID, Set.of("1"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))))); + + String[] expectedOrder = { "1.4.0.redhat-2", "1.4.0.redhat-1", "1.4.0.redhat-4" }; + + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testSingleRankOfProduct() { + VersionStrategy strat = VersionStrategy.from(List.of("PRODUCT_ID:1"), null, null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.QUALITY, Set.of("TESTED"))), + new QualifiedVersion("1.4.0.redhat-3", Map.of(Qualifier.PRODUCT_ID, Set.of("1"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))))); + + String[] expectedOrder = { "1.4.0.redhat-3", "1.4.0.redhat-4", "1.4.0.redhat-2" }; + + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testSingleRankWithNoMatch() { + VersionStrategy strat = VersionStrategy.from(List.of("QUALITY:RELEASED"), null, null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.QUALITY, Set.of("TESTED"))), + new QualifiedVersion("1.4.0.redhat-3", Map.of(Qualifier.PRODUCT_ID, Set.of("1"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of("NEW"))), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("BLACKLISTED"))))); + + String[] expectedOrder = { "1.4.0.redhat-4", "1.4.0.redhat-3", "1.4.0.redhat-2" }; + + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testTwoSimilarRanks() { + VersionStrategy strat = VersionStrategy.from(List.of("QUALITY:RELEASED", "QUALITY:TESTED"), null, null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT_ID, Set.of("1"))), + new QualifiedVersion("1.4.0.redhat-3", Map.of(Qualifier.QUALITY, Set.of("TESTED"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))))); + + String[] expectedOrder = { "1.4.0.redhat-2", "1.4.0.redhat-1", "1.4.0.redhat-3" }; + + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testTwoSimilarRanksReversed() { + VersionStrategy strat = VersionStrategy.from(List.of("QUALITY:TESTED", "QUALITY:RELEASED"), null, null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT_ID, Set.of("1"))), + new QualifiedVersion("1.4.0.redhat-3", Map.of(Qualifier.QUALITY, Set.of("TESTED"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))))); + + String[] expectedOrder = { "1.4.0.redhat-3", "1.4.0.redhat-2", "1.4.0.redhat-1" }; + + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testTwoDistinctRanks() { + /** + * Ranks: 1st: PRODUCT:EAP 2nd: QUALITY:RELEASED 3rd: SUFFIX-VERSION + */ + VersionStrategy strat = VersionStrategy.from(List.of("PRODUCT:EAP", "QUALITY:RELEASED"), null, null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.redhat-3", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of()), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); + + String[] expectedOrder = { + "1.4.0.redhat-3", + "1.4.0.redhat-6", + "1.4.0.redhat-5", + "1.4.0.redhat-4", + "1.4.0.redhat-2" }; + + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testTwoSimilarRanksInOr() { + /** + * Ranks: 1st: PRODUCT:EAP or PRODUCT:RHSSO 2nd: QUALITY:RELEASED 3rd: SUFFIX-VERSION + */ + VersionStrategy strat = VersionStrategy + .from(List.of("PRODUCT:EAP or PRODUCT:RHSSO", "QUALITY:RELEASED"), null, null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.redhat-3", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of("TESTED"))), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))))); + + String[] expectedOrder = { + "1.4.0.redhat-5", + "1.4.0.redhat-3", + "1.4.0.redhat-6", + "1.4.0.redhat-4", + "1.4.0.redhat-1" }; + + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testMultiValueRanksInOr() { + /** + * Ranks: 1st: QUALITY:RELEASED or QUALITY:TESTED 2nd: PRODUCT:EAP 3rd: SUFFIX-VERSION + */ + VersionStrategy strat = VersionStrategy + .from(List.of("QUALITY:RELEASED or QUALITY:TESTED", "PRODUCT:EAP"), null, null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of( + Qualifier.QUALITY, + Set.of("RELEASED", "TESTED"), + Qualifier.PRODUCT, + Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.redhat-3", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of()), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); + + String[] expectedOrder = { + "1.4.0.redhat-3", + "1.4.0.redhat-5", + "1.4.0.redhat-1", + "1.4.0.redhat-6", + "1.4.0.redhat-4" }; + + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testMultiValueRanksInOrder() { + /** + * Ranks: 1st: QUALITY:RELEASED 2nd: QUALITY:TESTED 3rd: PRODUCT:EAP 4th: SUFFIX-VERSION + */ + VersionStrategy strat = VersionStrategy + .from(List.of("QUALITY:RELEASED", "QUALITY:TESTED", "PRODUCT:EAP"), null, null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of( + Qualifier.QUALITY, + Set.of("RELEASED", "TESTED"), + Qualifier.PRODUCT, + Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.redhat-3", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of()), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); + + String[] expectedOrder = { + "1.4.0.redhat-5", + "1.4.0.redhat-3", + "1.4.0.redhat-1", + "1.4.0.redhat-6", + "1.4.0.redhat-4" }; + + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testLogicOperatorPriorities() { + /** + * Ranks: 1st: PRODUCT:EAP or QUALITY:TESTED and QUALITY:RELEASED 2nd: SUFFIX-VERSION + *

+ * With explicit parentheses, Ranks would look like this: 1st: PRODUCT:EAP or (QUALITY:TESTED and + * QUALITY:RELEASED) 2nd: SUFFIX-VERSION + */ + VersionStrategy strat = VersionStrategy + .from(List.of("PRODUCT:EAP or QUALITY:TESTED and QUALITY:RELEASED"), null, null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of( + Qualifier.QUALITY, + Set.of("RELEASED", "TESTED"), + Qualifier.PRODUCT, + Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.redhat-3", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of()), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); + + String[] expectedOrder = { + "1.4.0.redhat-6", + "1.4.0.redhat-5", + "1.4.0.redhat-3", + "1.4.0.redhat-4", + "1.4.0.redhat-2" }; + + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testLogicOperatorOverridePrecedence() { + /** + * Ranks: 1st: (PRODUCT:EAP or QUALITY:TESTED) and QUALITY:RELEASED 2nd: SUFFIX-VERSION + */ + VersionStrategy strat = VersionStrategy + .from(List.of("(PRODUCT:EAP or QUALITY:TESTED) and QUALITY:RELEASED"), null, null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of( + Qualifier.QUALITY, + Set.of("RELEASED", "TESTED"), + Qualifier.PRODUCT, + Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.redhat-3", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of()), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); + + String[] expectedOrder = { + "1.4.0.redhat-5", + "1.4.0.redhat-3", + "1.4.0.redhat-6", + "1.4.0.redhat-4", + "1.4.0.redhat-2" }; + + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testHardSorting() { + /** + * Ranks: 1st: PRODUCT:EAP sort-by SUFFIX-VERSION 2nd: QUALITY:RELEASED sort-by SUFFIX-VERSION 3rd: + * SUFFIX-VERSION + */ + VersionStrategy strat = VersionStrategy.from( + List.of("PRODUCT:EAP sort-by SUFFIX-VERSION", "QUALITY:RELEASED sort-by SUFFIX-VERSION"), + null, + null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.redhat-3", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of())), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); + + String[] expectedOrder = { + "1.4.0.redhat-6", + "1.4.0.redhat-3", + "1.4.0.redhat-5", + "1.4.0.redhat-4", + "1.4.0.redhat-2" }; + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testHardSortingWithOr() { + /** + * Ranks: 1st: PRODUCT:EAP or QUALITY:TESTED sort-by SUFFIX-VERSION 2nd: QUALITY:RELEASED sort-by SUFFIX-VERSION + * 3rd: SUFFIX-VERSION + */ + VersionStrategy strat = VersionStrategy.from( + List.of( + "PRODUCT:EAP or QUALITY:TESTED sort-by SUFFIX-VERSION", + "QUALITY:RELEASED sort-by SUFFIX-VERSION"), + null, + null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.redhat-3", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of())), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); + + String[] expectedOrder = { + "1.4.0.redhat-6", + "1.4.0.redhat-3", + "1.4.0.redhat-1", + "1.4.0.redhat-5", + "1.4.0.redhat-4" }; + + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testHardSortingWithAnd() { + /** + * Ranks: 1st: PRODUCT:EAP and QUALITY:TESTED sort-by SUFFIX-VERSION 2nd: QUALITY:RELEASED sort-by + * SUFFIX-VERSION 3rd: SUFFIX-VERSION + */ + VersionStrategy strat = VersionStrategy.from( + List.of( + "PRODUCT:EAP and QUALITY:TESTED sort-by SUFFIX-VERSION", + "QUALITY:RELEASED sort-by SUFFIX-VERSION"), + null, + null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.redhat-3", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of())), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); + + String[] expectedOrder = { + "1.4.0.redhat-5", + "1.4.0.redhat-3", + "1.4.0.redhat-6", + "1.4.0.redhat-4", + "1.4.0.redhat-2" }; + + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testSortingCombination() { + /** + * Ranks: 1st: PRODUCT:EAP 2nd: QUALITY:RELEASED sort-by SUFFIX-VERSION 3rd: QUALITY:TESTED 4th: SUFFIX-VERSION + */ + VersionStrategy strat = VersionStrategy + .from(List.of("PRODUCT:EAP", "QUALITY:RELEASED sort-by SUFFIX-VERSION", "QUALITY:TESTED"), null, null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.redhat-3", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-2", + Map.of( + Qualifier.QUALITY, + Set.of("RELEASED", "TESTED"), + Qualifier.PRODUCT, + Set.of("EAP"))), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); + + String[] expectedOrder = { + "1.4.0.redhat-3", + "1.4.0.redhat-2", + "1.4.0.redhat-6", + "1.4.0.redhat-5", + "1.4.0.redhat-1" }; + + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testSortingCombinationWithoutHard() { + // DEMONSTRATES distinction against #testSortingCombination() + /** + * Ranks: 1st: PRODUCT:EAP 2nd: QUALITY:RELEASED 3rd: QUALITY:TESTED 4th: SUFFIX-VERSION + */ + VersionStrategy strat = VersionStrategy + .from(List.of("PRODUCT:EAP", "QUALITY:RELEASED", "QUALITY:TESTED"), null, null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.redhat-3", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-2", + Map.of( + Qualifier.QUALITY, + Set.of("RELEASED", "TESTED"), + Qualifier.PRODUCT, + Set.of("EAP"))), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); + + String[] expectedOrder = { + "1.4.0.redhat-2", + "1.4.0.redhat-3", + "1.4.0.redhat-6", + "1.4.0.redhat-5", + "1.4.0.redhat-1" }; + + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testSimpleDenyList() { + /** + * Deny list: QUALITY:RELEASED + */ + VersionStrategy strat = VersionStrategy.from(null, null, "QUALITY:RELEASED"); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.redhat-3", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of())), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); + + String[] expectedOrder = { "1.4.0.redhat-6", "1.4.0.redhat-4", "1.4.0.redhat-2", "1.4.0.redhat-1" }; + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testMultipleDenyList() { + /** + * Deny list: QUALITY:RELEASED, PRODUCT:RHSSO + */ + VersionStrategy strat = VersionStrategy.from(null, null, "QUALITY:RELEASED, PRODUCT:RHSSO"); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.redhat-3", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of())), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); + + String[] expectedOrder = { "1.4.0.redhat-6", "1.4.0.redhat-2", "1.4.0.redhat-1" }; + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testAllowList() { + /** + * Allow list: QUALITY:RELEASED + */ + VersionStrategy strat = VersionStrategy.from(null, "QUALITY:RELEASED", null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.redhat-3", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of())), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); + + String[] expectedOrder = { "1.4.0.redhat-5", "1.4.0.redhat-3" }; + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testMultipleAllowList() { + /** + * Allow list: QUALITY:RELEASED, PRODUCT:EAP + */ + VersionStrategy strat = VersionStrategy.from(null, "QUALITY:RELEASED, PRODUCT:EAP", null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.redhat-3", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of())), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); + + String[] expectedOrder = { "1.4.0.redhat-6", "1.4.0.redhat-5", "1.4.0.redhat-3" }; + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testAllowAndDenyAtTheSameTime() { + /** + * Allow list: QUALITY:RELEASED Deny list: PRODUCT:RHSSO + */ + VersionStrategy strat = VersionStrategy.from(null, "QUALITY:RELEASED", "PRODUCT:RHSSO"); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.redhat-3", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); + + String[] expectedOrder = { "1.4.0.redhat-3", "1.4.0.redhat-2" }; + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testAllowWithRanking() { + /** + * Allow list: QUALITY:RELEASED, PRODUCT:RHSSO + * + * Ranks: 1st: PRODUCT:EAP 2nd: SUFFIX-VERSION + */ + VersionStrategy strat = VersionStrategy.from(List.of("PRODUCT:EAP"), "QUALITY:RELEASED, PRODUCT:RHSSO", null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.redhat-3", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))), + new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); + + String[] expectedOrder = { "1.4.0.redhat-3", "1.4.0.redhat-5", "1.4.0.redhat-4", "1.4.0.redhat-2" }; + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testRankingWithSuffixes() { + /** + * Ranks: 1st: PRODUCT:RHSSO 2nd: PRODUCT:EAP 3rd: SUFFIX-VERSION + */ + VersionStrategy strat = VersionStrategy.from(List.of("PRODUCT:RHSSO", "PRODUCT:EAP"), null, null); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("temporary-redhat", "redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.temporary-redhat-3", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion("1.4.0.temporary-redhat-2", Map.of(Qualifier.QUALITY, Set.of())), + new QualifiedVersion( + "1.4.0.temporary-redhat-1", + Map.of(Qualifier.QUALITY, Set.of("TESTED"), Qualifier.PRODUCT, Set.of("RHSSO"))))); + + String[] expectedOrder = { + "1.4.0.temporary-redhat-1", + "1.4.0.temporary-redhat-3", + "1.4.0.temporary-redhat-2", + "1.4.0.redhat-5", + "1.4.0.redhat-4", + "1.4.0.redhat-6" }; + + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testDenyListFullRemovingSuffixes() { + /** + * Deny list: QUALITY:DELETE + */ + VersionStrategy strat = VersionStrategy.from(null, null, "QUALITY:DELETE"); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("temporary-redhat", "redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.temporary-redhat-3", + Map.of(Qualifier.QUALITY, Set.of("DELETE"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion("1.4.0.temporary-redhat-2", Map.of(Qualifier.QUALITY, Set.of("DELETE"))), + new QualifiedVersion( + "1.4.0.temporary-redhat-1", + Map.of(Qualifier.QUALITY, Set.of("DELETE"), Qualifier.PRODUCT, Set.of("RHSSO"))))); + + String[] expectedOrder = { "1.4.0.redhat-6", "1.4.0.redhat-5", "1.4.0.redhat-4" }; + + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + @Test + public void testDenyRemovingVersionsFromBothSuffixes() { + /** + * Deny list: QUALITY:DELETE + */ + VersionStrategy strat = VersionStrategy.from(null, null, "QUALITY:DELETE"); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("temporary-redhat", "redhat"), strat); + String version = "1.4.0"; + + List versions = new ArrayList<>( + List.of( + new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion( + "1.4.0.redhat-5", + Map.of(Qualifier.QUALITY, Set.of("DELETE"), Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), + new QualifiedVersion( + "1.4.0.temporary-redhat-3", + Map.of(Qualifier.QUALITY, Set.of("DELETE"), Qualifier.PRODUCT, Set.of("EAP"))), + new QualifiedVersion("1.4.0.temporary-redhat-2", Map.of()), + new QualifiedVersion( + "1.4.0.temporary-redhat-1", + Map.of(Qualifier.QUALITY, Set.of("DELETE"), Qualifier.PRODUCT, Set.of("RHSSO"))))); + + String[] expectedOrder = { "1.4.0.temporary-redhat-2", "1.4.0.redhat-6", "1.4.0.redhat-4" }; + + expectOrder(versionAnalyzer, expectedOrder, version, versions); + } + + private void expectOrder( + VersionAnalyzer versionAnalyzer, + String[] expectedOrder, + String version, + List versions) { + for (String expected : expectedOrder) { + checkBMV(versionAnalyzer, expected, version, versions.toArray(new QualifiedVersion[0])); + + // remove best version from list to verify the next one + var expectedInList = versions.stream().filter(qv -> qv.getVersion().equals(expected)).findFirst().get(); + versions.remove(expectedInList); + } + } + +} diff --git a/common/src/test/java/org/jboss/da/common/version/VersionComparatorTest.java b/common/src/test/java/org/jboss/da/common/version/VersionComparatorTest.java new file mode 100644 index 000000000..dc3fd9363 --- /dev/null +++ b/common/src/test/java/org/jboss/da/common/version/VersionComparatorTest.java @@ -0,0 +1,288 @@ +package org.jboss.da.common.version; + +import org.jboss.da.lookup.model.VersionDistanceRule; +import org.junit.Test; + +import static org.jboss.da.common.version.VersionComparator.VersionDifference.EQUAL; +import static org.jboss.da.common.version.VersionComparator.VersionDifference.MAJOR; +import static org.jboss.da.common.version.VersionComparator.VersionDifference.MICRO; +import static org.jboss.da.common.version.VersionComparator.VersionDifference.MINOR; +import static org.jboss.da.common.version.VersionComparator.VersionDifference.QUALIFIER; +import static org.jboss.da.common.version.VersionComparator.VersionDifference.RH_SUFFIX; +import static org.jboss.da.common.version.VersionComparator.VersionDifference.SUFFIX; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +/** + * + * @author Honza Brázdil <jbrazdil@redhat.com> + */ +public class VersionComparatorTest { + + private static final VersionParser VERSION_PARSER = new VersionParser("redhat"); + + @Test + public void testCompareVersion() { + VersionComparator vc = new VersionComparator(VERSION_PARSER); + + assertTrue(vc.compare("3.4.2.Final", "2.4.2.Final") > 0); + assertTrue(vc.compare("3.4.2.Final", "3.3.2.Final") > 0); + assertTrue(vc.compare("3.4.2.Final", "3.4.1.Final") > 0); + assertTrue(vc.compare("3.4.2.Final", "3.4.2.Beta") > 0); + + assertTrue(vc.compare("3.0.0.Final", "3.Final") == 0); + assertTrue(vc.compare("3.0.0.Final", "3.0.Final") == 0); + assertTrue(vc.compare("3.0.0.Final", "3.0.0.Final") == 0); + + assertTrue(vc.compare("3.0.0", "3") == 0); + assertTrue(vc.compare("3.0.0", "3.0") == 0); + assertTrue(vc.compare("3.0.0", "3.0.0") == 0); + + assertTrue(vc.compare("b10", "0.0.0.b10") == 0); + + assertTrue(vc.compare("3.4.2.Final", "4.4.2.Final") < 0); + assertTrue(vc.compare("3.4.2.Final", "3.5.2.Final") < 0); + assertTrue(vc.compare("3.4.2.Final", "3.4.3.Final") < 0); + + assertTrue(vc.compare("3.4.2.Alpha", "3.4.2.Beta") < 0); + + assertTrue(vc.compare("3.4.2.Final", "3.4.2.Final-redhat-1") < 0); + assertTrue(vc.compare("3.4.2", "3.4.2.redhat-1") < 0); + + assertTrue(vc.compare("3.4.2.Final-redhat-1", "3.4.2.Final-redhat-2") < 0); + assertTrue(vc.compare("3.4.2.redhat-1", "3.4.2.redhat-2") < 0); + + // These are equivalent, but OSGI version is preferred (NCL-4532) + assertTrue(vc.compare("3-redhat-2", "3.0.0.redhat-2") < 0); + assertTrue(vc.compare("3.redhat-2", "3.0.0.redhat-2") < 0); + assertTrue(vc.compare("3.0-redhat-2", "3.0.0.redhat-2") < 0); + assertTrue(vc.compare("3.0.redhat-2", "3.0.0.redhat-2") < 0); + assertTrue(vc.compare("3.0.0-redhat-2", "3.0.0.redhat-2") < 0); + } + + @Test + public void testCompareVersionWithMultipleSuffixes() { + VersionComparator vc1 = new VersionComparator(new VersionParser("temporary-redhat", "redhat")); + VersionComparator vc2 = new VersionComparator(new VersionParser("redhat", "temporary-redhat")); + + assertTrue(vc1.compare("3.0.0.Final", "3.0.0.Final-redhat-1") < 0); + assertTrue(vc1.compare("3.0.0.Final", "3.0.0.Final-temporary-redhat-1") < 0); + assertTrue(vc1.compare("3.0.0.Final-redhat-1", "3.0.0.Final-temporary-redhat-1") < 0); + assertTrue(vc2.compare("3.0.0.Final-redhat-1", "3.0.0.Final-temporary-redhat-1") < 0); + } + + @Test + public void testBaseVersion() { + VersionComparator vc = new VersionComparator("3.4.2.Final", VERSION_PARSER); + + assertTrue(vc.compare("3.4.3.Final", "3.4.4.Final") < 0); + assertTrue(vc.compare("3.4.3.Final", "3.4.1.Final") < 0); + assertTrue(vc.compare("3.4.99.Final", "3.5.0.Final") < 0); + assertTrue(vc.compare("3.4.3.Final", "3.4.3.Alpha") < 0); + assertTrue(vc.compare("3.4.3.Beta", "3.4.3.Alpha") < 0); + assertTrue(vc.compare("3.4.3.Final", "3.4.2.CR1") < 0); + assertTrue(vc.compare("3.5.0.Final", "3.4.2.Beta") < 0); + assertTrue(vc.compare("3.4.2.Alpha", "4.2.3.Final") < 0); + assertTrue(vc.compare("3.4.4.Final", "4.4.1.Final") < 0); + assertTrue(vc.compare("3.4.2.Alpha", "4.4.1.Final") < 0); + + vc = new VersionComparator("2.2.2.Beta2", VERSION_PARSER); + + assertTrue(vc.compare("2.2.2.Beta4", "2.2.2.Beta3") < 0); + assertTrue(vc.compare("2.2.2.Beta3", "2.2.2.Beta1") < 0); + assertTrue(vc.compare("2.2.2.Final", "2.2.2.Alpha") < 0); + assertTrue(vc.compare("2.3.3.Final", "2.2.2.Alpha") < 0); + assertTrue(vc.compare("2.2.3.Alpha", "2.2.2.Alpha") < 0); + assertTrue(vc.compare("2.2.2.Beta3", "2.2.1.Final") < 0); + assertTrue(vc.compare("2.2.2.CR1", "2.2.1.Final") < 0); + assertTrue(vc.compare("2.2.2.Final", "2.2.1.Final") < 0); + assertTrue(vc.compare("2.2.2.Alpha", "2.2.1.Final") < 0); + + vc = new VersionComparator("2.2", VERSION_PARSER); + + assertTrue(vc.compare("2.2", "2.2.0") == 0); + + assertTrue(vc.compare("2.2", "2.2-beta-5") < 0); + assertTrue(vc.compare("2.2", "2.2.0-b21") < 0); + assertTrue(vc.compare("2.2", "2.2.0-b10") < 0); + assertTrue(vc.compare("2.2", "2.2.SP4") < 0); + assertTrue(vc.compare("2.2", "2.2.0.SP1") < 0); + assertTrue(vc.compare("2.2", "2.2.Final") < 0); + assertTrue(vc.compare("2.2", "2.2.0.Final") < 0); + assertTrue(vc.compare("2.2", "2.2.0.CR1") < 0); + + assertTrue(vc.compare("2.2.0", "2.2-beta-5") < 0); + assertTrue(vc.compare("2.2.0", "2.2.0-b21") < 0); + assertTrue(vc.compare("2.2.0", "2.2.0-b10") < 0); + assertTrue(vc.compare("2.2.0", "2.2.SP4") < 0); + assertTrue(vc.compare("2.2.0", "2.2.0.SP1") < 0); + assertTrue(vc.compare("2.2.0", "2.2.Final") < 0); + assertTrue(vc.compare("2.2.0", "2.2.0.Final") < 0); + assertTrue(vc.compare("2.2.0", "2.2.0.CR1") < 0); + + assertTrue(vc.compare("2.2.0.b21", "2.2.0.b10") < 0); + assertTrue(vc.compare("2.2.0.SP4", "2.2.0.b21") < 0); + assertTrue(vc.compare("2.2.0.Final", "2.2.0.SP4") > 0); // Too difficult to implement correctly - the list of + // special + // qualifiers (like Final, GA, ...) would be needed + assertTrue(vc.compare("2.2.0.Final", "2.2.0.CR1") < 0); + assertTrue(vc.compare("2.2.0.GA", "2.2.0.SP4") > 0); // Too difficult to implement correctly + assertTrue(vc.compare("2.2.0.GA", "2.2.0.CR1") < 0); + assertTrue(vc.compare("2.2.0.MR1", "2.2.0.SP4") > 0); // Too difficult to implement correctly + assertTrue(vc.compare("2.2.0.MR1", "2.2.0.CR1") < 0); + } + + @Test + public void testBaseVersionWithClosestByPartsRule() { + VersionComparator vc = new VersionComparator("2.0.0", VersionDistanceRule.CLOSEST_BY_PARTS, VERSION_PARSER); + + assertTrue(vc.compare("2.0.1", "3.0.0") < 0); // Rule 1 - less different parts + assertTrue(vc.compare("3.0.0", "4.0.0") < 0); // Rule 2a - lesser difference in differing part + assertTrue(vc.compare("1.0.0", "0.0.0") < 0); + assertTrue(vc.compare("3.0.0", "1.0.0") < 0); // Rule 2b - same difference in differing part, but higher + assertTrue(vc.compare("3.0.0", "3.0.1") < 0); // Rule 3 - closer to base by order + assertTrue(vc.compare("1.0.1", "1.0.0") < 0); // Rule 3 - closer to base by order + + vc = new VersionComparator("3.4.2.Final", VersionDistanceRule.CLOSEST_BY_PARTS, VERSION_PARSER); + + assertTrue(vc.compare("3.4.3.Final", "3.4.4.Final") < 0); + assertTrue(vc.compare("3.4.3.Final", "3.4.1.Final") < 0); + assertTrue(vc.compare("3.4.4.Final", "3.4.1.Final") > 0); // 1 is close to 2 then 4 + assertTrue(vc.compare("3.4.99.Final", "3.5.0.Final") < 0); + assertTrue(vc.compare("3.4.3.Final", "3.4.3.Alpha") < 0); + assertTrue(vc.compare("3.4.3.Beta", "3.4.3.Alpha") < 0); + assertTrue(vc.compare("3.4.3.Final", "3.4.2.CR1") > 0); // Right one matches in micro + assertTrue(vc.compare("3.5.0.Final", "3.4.2.Beta") > 0); // Right one matches in minor + assertTrue(vc.compare("3.4.2.Alpha", "4.2.3.Final") < 0); + assertTrue(vc.compare("3.4.4.Final", "4.4.1.Final") < 0); + assertTrue(vc.compare("3.4.2.Alpha", "4.4.1.Final") < 0); + + vc = new VersionComparator("2.2.2.Beta2", VersionDistanceRule.CLOSEST_BY_PARTS, VERSION_PARSER); + + assertTrue(vc.compare("2.2.2.Beta4", "2.2.2.Beta3") < 0); + assertTrue(vc.compare("2.2.2.Beta3", "2.2.2.Beta1") < 0); + assertTrue(vc.compare("2.2.2.Final", "2.2.2.Alpha") < 0); + assertTrue(vc.compare("2.3.3.Final", "2.2.2.Alpha") > 0); // Right one matches in minor + assertTrue(vc.compare("2.2.3.Alpha", "2.2.2.Alpha") > 0); // Right one matches in micro + assertTrue(vc.compare("2.2.2.Beta3", "2.2.1.Final") < 0); + assertTrue(vc.compare("2.2.2.CR1", "2.2.1.Final") < 0); + assertTrue(vc.compare("2.2.2.Final", "2.2.1.Final") < 0); + assertTrue(vc.compare("2.2.2.Alpha", "2.2.1.Final") < 0); + + assertTrue(vc.compare("3.3.3.Final", "3.3.3.Final") == 0); + assertTrue(vc.compare("3.3.3.Final", "3.3.3.Alpha") < 0); + assertTrue(vc.compare("3.3.2.Final", "3.3.3.Final") < 0); + assertTrue(vc.compare("3.3.0.Final", "3.3.2.Final") < 0); + assertTrue(vc.compare("3.3.1.Final", "3.3.3.Final") < 0); + assertTrue(vc.compare("3.3.0.Final", "3.3.0.Final") == 0); + assertTrue(vc.compare("3.2.0.Final", "3.3.0.Final") < 0); + assertTrue(vc.compare("3.0.0.Final", "3.3.0.Final") < 0); + assertTrue(vc.compare("3.1.0.Final", "3.3.0.Final") < 0); + assertTrue(vc.compare("13.0.0.Final", "13.0.0.Final") == 0); + assertTrue(vc.compare("12.0.0.Final", "13.0.0.Final") < 0); + assertTrue(vc.compare("2.0.0.Final", "13.0.0.Final") < 0); + assertTrue(vc.compare("1.0.0.Final", "3.0.0.Final") > 0); + assertTrue(vc.compare("1.1.1.Final", "1.1.1.Final") == 0); + assertTrue(vc.compare("1.1.1.Final", "1.1.1.Alpha") < 0); + assertTrue(vc.compare("1.1.1.Final", "1.1.2.Final") > 0); + assertTrue(vc.compare("1.1.1.Final", "1.1.3.Final") > 0); + assertTrue(vc.compare("1.1.1.Final", "1.1.4.Final") > 0); + assertTrue(vc.compare("1.1.0.Final", "1.1.0.Final") == 0); + assertTrue(vc.compare("1.1.0.Final", "1.2.0.Final") > 0); + assertTrue(vc.compare("1.1.0.Final", "1.3.0.Final") > 0); + assertTrue(vc.compare("1.1.0.Final", "1.4.0.Final") > 0); + + vc = new VersionComparator("2.2", VersionDistanceRule.CLOSEST_BY_PARTS, VERSION_PARSER); + + assertTrue(vc.compare("2.2", "2.2.0") == 0); + + assertTrue(vc.compare("2.2", "2.2-beta-5") < 0); + assertTrue(vc.compare("2.2", "2.2.0-b21") < 0); + assertTrue(vc.compare("2.2", "2.2.0-b10") < 0); + assertTrue(vc.compare("2.2", "2.2.SP4") < 0); + assertTrue(vc.compare("2.2", "2.2.0.SP1") < 0); + assertTrue(vc.compare("2.2", "2.2.Final") < 0); + assertTrue(vc.compare("2.2", "2.2.0.Final") < 0); + assertTrue(vc.compare("2.2", "2.2.0.CR1") < 0); + + assertTrue(vc.compare("2.2.0", "2.2-beta-5") < 0); + assertTrue(vc.compare("2.2.0", "2.2.0-b21") < 0); + assertTrue(vc.compare("2.2.0", "2.2.0-b10") < 0); + assertTrue(vc.compare("2.2.0", "2.2.SP4") < 0); + assertTrue(vc.compare("2.2.0", "2.2.0.SP1") < 0); + assertTrue(vc.compare("2.2.0", "2.2.Final") < 0); + assertTrue(vc.compare("2.2.0", "2.2.0.Final") < 0); + assertTrue(vc.compare("2.2.0", "2.2.0.CR1") < 0); + + assertTrue(vc.compare("2.2.0.b21", "2.2.0.b10") < 0); + assertTrue(vc.compare("2.2.0.SP4", "2.2.0.b21") < 0); + assertTrue(vc.compare("2.2.0.Final", "2.2.0.SP4") > 0); // Too difficult to implement correctly - the list of + // special + // qualifiers (like Final, GA, ...) would be needed + assertTrue(vc.compare("2.2.0.Final", "2.2.0.CR1") < 0); + assertTrue(vc.compare("2.2.0.GA", "2.2.0.SP4") > 0); // Too difficult to implement correctly + assertTrue(vc.compare("2.2.0.GA", "2.2.0.CR1") < 0); + assertTrue(vc.compare("2.2.0.MR1", "2.2.0.SP4") > 0); // Too difficult to implement correctly + assertTrue(vc.compare("2.2.0.MR1", "2.2.0.CR1") < 0); + } + + @Test + public void testBaseVersionWithMultipleSuffixes() { + VersionComparator vc1 = new VersionComparator("3.4.2.Final", new VersionParser("temporary-redhat", "redhat")); + + assertTrue(vc1.compare("3.4.2.Final", "3.4.2.Final-redhat-1") < 0); + assertTrue(vc1.compare("3.4.2.Final-redhat-2", "3.4.2.Final-redhat-1") < 0); + assertTrue(vc1.compare("3.4.2.Final", "3.4.2.Final-temporary-redhat-1") < 0); + assertTrue(vc1.compare("3.4.2.Final-temporary-redhat-2", "3.4.2.Final-temporary-redhat-1") < 0); + assertTrue(vc1.compare("3.4.3.Final", "3.4.1.Final") < 0); + assertTrue(vc1.compare("3.4.99.Final", "3.5.0.Final") < 0); + assertTrue(vc1.compare("3.4.3.Final", "3.4.3.Alpha") < 0); + } + + @Test + public void testVersionDifference() { + VersionComparator vc = new VersionComparator(VERSION_PARSER); + assertEquals(MAJOR, vc.difference("3.4.2.Final", "2.4.2.Final")); + assertEquals(MINOR, vc.difference("3.4.2.Final", "3.3.2.Final")); + assertEquals(MICRO, vc.difference("3.4.2.Final", "3.4.1.Final")); + assertEquals(QUALIFIER, vc.difference("3.4.2.Final", "3.4.2.Beta")); + + assertEquals(EQUAL, vc.difference("3.0.0.Final", "3.Final")); + assertEquals(EQUAL, vc.difference("3.0.0.Final", "3.0.Final")); + assertEquals(EQUAL, vc.difference("3.0.0.Final", "3.0.0.Final")); + + assertEquals(EQUAL, vc.difference("3.0.0", "3")); + assertEquals(EQUAL, vc.difference("3.0.0", "3.0")); + assertEquals(EQUAL, vc.difference("3.0.0", "3.0.0")); + + assertEquals(MAJOR, vc.difference("3.4.2.Final", "4.4.2.Final")); + assertEquals(MINOR, vc.difference("3.4.2.Final", "3.5.2.Final")); + assertEquals(MICRO, vc.difference("3.4.2.Final", "3.4.3.Final")); + + assertEquals(QUALIFIER, vc.difference("3.4.2.Alpha", "3.4.2.Beta")); + + assertEquals(SUFFIX, vc.difference("3.4.2.Final", "3.4.2.Final-redhat-1")); + assertEquals(SUFFIX, vc.difference("3.4.2", "3.4.2.redhat-1")); + + assertEquals(RH_SUFFIX, vc.difference("3.4.2.Final-redhat-1", "3.4.2.Final-redhat-2")); + assertEquals(RH_SUFFIX, vc.difference("3.4.2.redhat-1", "3.4.2.redhat-2")); + + assertEquals(QUALIFIER, vc.difference("1.1.0.SP18-redhat-1", "1.1.0.SP17-redhat-1")); // NCL-3208 + } + + @Test + public void testBaseVersionWithClosestByPartsRuleReproduceNCLSUP898() { + VersionComparator vc = new VersionComparator( + "8.34.0.Final", + VersionDistanceRule.CLOSEST_BY_PARTS, + VERSION_PARSER); + + assertTrue(vc.compare("8.24.1.Beta-redhat-00006", "8.24.1.Beta-redhat-00005") < 0); + assertTrue(vc.compare("8.24.1.Beta-redhat-00006", "8.24.0.Beta-redhat-00004") < 0); + assertTrue(vc.compare("8.27.0.Beta-redhat-00005", "8.24.1.Beta-redhat-00006") < 0); + assertTrue(vc.compare("8.32.0.Final-redhat-00004", "8.24.1.Beta-redhat-00006") < 0); + assertTrue(vc.compare("8.33.0.Final-redhat-00003", "8.24.1.Beta-redhat-00006") < 0); + assertTrue(vc.compare("8.24.1.Beta-redhat-00006", "6.5.0.Final-redhat-27") < 0); + + } +} diff --git a/common/src/test/java/org/jboss/da/common/version/VersionParserTest.java b/common/src/test/java/org/jboss/da/common/version/VersionParserTest.java new file mode 100644 index 000000000..f04f6788e --- /dev/null +++ b/common/src/test/java/org/jboss/da/common/version/VersionParserTest.java @@ -0,0 +1,172 @@ +package org.jboss.da.common.version; + +import org.junit.Test; + +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; + +import static java.util.Collections.singleton; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +public class VersionParserTest { + + @Test + public void testOSGIParser() { + assertEquals("1.1.0.Final", VersionParser.getOSGiVersion("1.1.Final")); + assertEquals("1.1.0", VersionParser.getOSGiVersion("1.1")); + assertEquals("1.1.0.redhat-1", VersionParser.getOSGiVersion("1.1.redhat-1")); + assertEquals("1.1.0.redhat-1", VersionParser.getOSGiVersion("1.1-redhat-1")); + assertEquals("1.1.0.Final", VersionParser.getOSGiVersion("1.1Final")); + assertEquals("1.1.5.CR4", VersionParser.getOSGiVersion("1.1.5CR4")); + assertEquals("1.1.0", VersionParser.getOSGiVersion("1.1.")); + assertEquals("1.1.0.CR4", VersionParser.getOSGiVersion("1.1.CR4")); + assertEquals("1.1.0.final", VersionParser.getOSGiVersion("1.1-final")); + assertEquals("1.1.0.final-redhat-1", VersionParser.getOSGiVersion("1.1.0.final-redhat-1")); + assertEquals("1.1.2", VersionParser.getOSGiVersion("1.1-2")); + assertEquals("1.1.2.Final", VersionParser.getOSGiVersion("1.1-2.Final")); + assertEquals("1.1.2.Final", VersionParser.getOSGiVersion("1.1-2-Final")); + assertEquals("1.1.2.Final-redhat-2", VersionParser.getOSGiVersion("1.1-2.Final-redhat-2")); + assertEquals("1.1.2.Final-redhat-2", VersionParser.getOSGiVersion("1.1-2-Final-redhat-2")); + } + + @Test + public void testVersionParser() { + VersionParser versionParser = new VersionParser("redhat"); + assertEquals(new SuffixedVersion(1, 1, 0, "Final", "1.1.Final"), versionParser.parse("1.1.Final")); + assertEquals(new SuffixedVersion(1, 1, 0, "", "1.1"), versionParser.parse("1.1")); + assertEquals( + new SuffixedVersion(1, 1, 0, "", "redhat", 1, "1.1.redhat-1"), + versionParser.parse("1.1.redhat-1")); + assertEquals( + new SuffixedVersion(1, 1, 0, "", "redhat", 1, "1.1-redhat-1"), + versionParser.parse("1.1-redhat-1")); + assertEquals(new SuffixedVersion(1, 1, 0, "Final", "1.1Final"), versionParser.parse("1.1Final")); + assertEquals(new SuffixedVersion(1, 1, 5, "CR4", "1.1.5CR4"), versionParser.parse("1.1.5CR4")); + assertEquals(new SuffixedVersion(1, 1, 0, "", "1.1."), versionParser.parse("1.1.")); + assertEquals(new SuffixedVersion(1, 1, 0, "CR4", "1.1.CR4"), versionParser.parse("1.1.CR4")); + assertEquals(new SuffixedVersion(1, 1, 0, "final", "1.1-final"), versionParser.parse("1.1-final")); + assertEquals( + new SuffixedVersion(1, 1, 0, "final", "redhat", 1, "1.1.0.final-redhat-1"), + versionParser.parse("1.1.0.final-redhat-1")); + assertEquals(new SuffixedVersion(1, 1, 2, "", "1.1-2"), versionParser.parse("1.1-2")); + assertEquals(new SuffixedVersion(1, 1, 2, "Final", "1.1-2.Final"), versionParser.parse("1.1-2.Final")); + assertEquals(new SuffixedVersion(1, 1, 2, "Final", "1.1-2-Final"), versionParser.parse("1.1-2-Final")); + assertEquals( + new SuffixedVersion(1, 1, 2, "Final", "redhat", 2, "1.1-2.Final-redhat-2"), + versionParser.parse("1.1-2.Final-redhat-2")); + assertEquals( + new SuffixedVersion(1, 1, 2, "Final", "redhat", 2, "1.1-2-Final-redhat-2"), + versionParser.parse("1.1-2-Final-redhat-2")); + } + + @Test + public void testRedhatVersion() { + VersionParser versionParser = new VersionParser("redhat"); + assertFalse(versionParser.parse("1.1.Final").isSuffixed()); + assertFalse(versionParser.parse("1.1").isSuffixed()); + assertTrue(versionParser.parse("1.1.redhat-1").isSuffixed()); + assertTrue(versionParser.parse("1.1-redhat-1").isSuffixed()); + assertFalse(versionParser.parse("1.1").isSuffixed()); + assertFalse(versionParser.parse("1.1Final").isSuffixed()); + assertFalse(versionParser.parse("1.1.5CR4").isSuffixed()); + assertFalse(versionParser.parse("1.1.").isSuffixed()); + assertFalse(versionParser.parse("1.1.CR4").isSuffixed()); + assertFalse(versionParser.parse("1.1-final").isSuffixed()); + assertTrue(versionParser.parse("1.1.0.final-redhat-1").isSuffixed()); + assertTrue(versionParser.parse("1.1-redhat-001").isSuffixed()); + } + + @Test + public void testTemporarySuffix() { + List versions = Arrays + .asList("1.5.8", "1.5.8-patch-01", "1.6.1", "1.7.21.t20180522-115319-991-redhat-1"); + + VersionParser vp = new VersionParser("t20180522-115319-991-redhat"); + List filtered = versions.stream().filter(v -> vp.parse(v).isSuffixed()).collect(Collectors.toList()); + assertEquals(1, filtered.size()); + assertTrue(filtered.contains("1.7.21.t20180522-115319-991-redhat-1")); + } + + @Test + public void testTemporaryAndRedhatSuffix() { + List versions = Arrays.asList( + "1.5.8", + "1.5.8-patch-01", + "1.6.1", + "1.6.1-redhat-1", + "1.6.1-redhat-2", + "1.6.4.redhat-2", + "1.7.21.t20180417-125043-536-redhat-1", + "1.7.21.t20180425-112559-465-redhat-1", + "1.7.21.temporary-redhat-1"); + + VersionParser vp = new VersionParser("temporary-redhat", "redhat"); + List filtered = versions.stream().filter(v -> vp.parse(v).isSuffixed()).collect(Collectors.toList()); + assertEquals(6, filtered.size()); + assertTrue(filtered.contains("1.7.21.temporary-redhat-1")); + assertTrue(filtered.contains("1.6.4.redhat-2")); + assertTrue(filtered.contains("1.7.21.t20180425-112559-465-redhat-1")); + assertFalse(filtered.contains("1.5.8-patch-01")); + } + + @Test + public void shuldNormalizeVersionWhenParsing() { + VersionParser vp1 = new VersionParser("A", "B-A", "B-C-A"); + assertEquals(new SuffixedVersion(1, 5, 8, "", "1.5.8"), vp1.parse("1.5.8")); + assertEquals(new SuffixedVersion(1, 5, 8, "", "A", 2, "1.5.8.A-2"), vp1.parse("1.5.8.A-2")); + assertEquals(new SuffixedVersion(1, 5, 8, "B-2", "1.5.8.B-2"), vp1.parse("1.5.8.B-2")); + assertEquals(new SuffixedVersion(1, 5, 8, "", "B-A", 2, "1.5.8.B-A-2"), vp1.parse("1.5.8.B-A-2")); + assertEquals(new SuffixedVersion(1, 5, 8, "C", "A", 2, "1.5.8.B-A-2"), vp1.parse("1.5.8.C-A-2")); + assertEquals(new SuffixedVersion(1, 5, 8, "", "B-C-A", 2, "1.5.8.B-C-A-2"), vp1.parse("1.5.8.B-C-A-2")); + + VersionParser vp2 = new VersionParser("B-C-A", "B-A", "A"); + assertEquals(new SuffixedVersion(1, 5, 8, "", "1.5.8"), vp2.parse("1.5.8")); + assertEquals(new SuffixedVersion(1, 5, 8, "", "A", 2, "1.5.8.A-2"), vp2.parse("1.5.8.A-2")); + assertEquals(new SuffixedVersion(1, 5, 8, "B-2", "1.5.8.B-2"), vp2.parse("1.5.8.B-2")); + assertEquals(new SuffixedVersion(1, 5, 8, "", "B-A", 2, "1.5.8.B-A-2"), vp2.parse("1.5.8.B-A-2")); + assertEquals(new SuffixedVersion(1, 5, 8, "C", "A", 2, "1.5.8.B-A-2"), vp2.parse("1.5.8.C-A-2")); + assertEquals(new SuffixedVersion(1, 5, 8, "", "B-C-A", 2, "1.5.8.B-C-A-2"), vp2.parse("1.5.8.B-C-A-2")); + } + + @Test + public void shouldParseMultipleSuffixes() { + VersionParser vp1 = new VersionParser("A", "B-A", "B-C-A"); + + assertTrue(vp1.parseSuffixed("1.5.8").isEmpty()); + + String version1 = "1.5.8.A-2"; + Set set1 = vp1.parseSuffixed(version1); + assertEquals(1, set1.size()); + assertEquals(singleton(new SuffixedVersion(1, 5, 8, "", "A", 2, version1)), set1); + + assertTrue(vp1.parseSuffixed("1.5.8.B-2").isEmpty()); + + String version2 = "1.5.8.B-A-2"; + Set set2 = vp1.parseSuffixed(version2); + assertEquals(2, set2.size()); + Set expected2 = new HashSet<>( + Arrays.asList( + new SuffixedVersion(1, 5, 8, "B", "A", 2, version2), + new SuffixedVersion(1, 5, 8, "", "B-A", 2, version2))); + assertEquals(expected2, set2); + + String version3 = "1.5.8.C-A-2"; + Set set3 = vp1.parseSuffixed(version3); + assertEquals(1, set3.size()); + assertEquals(singleton(new SuffixedVersion(1, 5, 8, "C", "A", 2, version3)), set3); + + String version4 = "1.5.8.B-C-A-2"; + Set set4 = vp1.parseSuffixed(version4); + assertEquals(2, set4.size()); + Set expected4 = new HashSet<>( + Arrays.asList( + new SuffixedVersion(1, 5, 8, "B-C", "A", 2, version4), + new SuffixedVersion(1, 5, 8, "", "B-C-A", 2, version4))); + assertEquals(expected4, set4); + } +} diff --git a/pom.xml b/pom.xml index fa903841a..7dc215fd5 100644 --- a/pom.xml +++ b/pom.xml @@ -254,6 +254,17 @@ galley-cache-partyline ${version.galley} + + org.commonjava.maven.ext + pom-manipulation-core + 1.6 + + + * + * + + + diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ArtifactServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ArtifactServiceImpl.java index 4e0a8f992..14ef6b593 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ArtifactServiceImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ArtifactServiceImpl.java @@ -1,12 +1,12 @@ package org.jboss.da.listings.impl.service; +import org.jboss.da.common.version.VersionParser; import org.jboss.da.communication.auth.AuthenticatorService; import org.jboss.da.listings.api.dao.ArtifactDAO; import org.jboss.da.listings.api.dao.UserDAO; import org.jboss.da.listings.api.model.Artifact; import org.jboss.da.listings.api.model.User; import org.jboss.da.listings.api.service.ArtifactService; -import org.jboss.pnc.common.version.VersionParser; import javax.inject.Inject; diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java index 363867440..1fecd8c42 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java @@ -21,8 +21,8 @@ import java.util.SortedSet; import java.util.TreeSet; -import org.jboss.pnc.common.version.SuffixedVersion; -import org.jboss.pnc.common.version.VersionParser; +import org.jboss.da.common.version.SuffixedVersion; +import org.jboss.da.common.version.VersionParser; /** * @@ -82,7 +82,7 @@ public org.jboss.da.listings.api.service.ArtifactService.ArtifactStatus addArtif public Optional getArtifact(String groupId, String artifactId, String version) { SuffixedVersion parsedVersion = versionParser.parse(version); Optional artifact = blackArtifactDAO - .findArtifact(groupId, artifactId, parsedVersion.unsuffixedVersion()); + .findArtifact(groupId, artifactId, parsedVersion.unsuffixedVesion()); if (parsedVersion.isSuffixed() && !artifact.isPresent()) { artifact = blackArtifactDAO.findArtifact(groupId, artifactId, VersionParser.getOSGiVersion(version)); } diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactServiceImpl.java index 7f77daada..a84e16e1a 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactServiceImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactServiceImpl.java @@ -7,6 +7,8 @@ import javax.enterprise.context.ApplicationScoped; import javax.inject.Inject; +import org.jboss.da.common.version.SuffixedVersion; +import org.jboss.da.common.version.VersionParser; import org.jboss.da.listings.api.dao.ArtifactDAO; import org.jboss.da.listings.api.dao.GADAO; @@ -18,8 +20,6 @@ import org.jboss.da.listings.api.service.BlackArtifactService; import org.jboss.da.listings.api.service.WhiteArtifactService; import org.jboss.da.model.rest.GAV; -import org.jboss.pnc.common.version.SuffixedVersion; -import org.jboss.pnc.common.version.VersionParser; /** * diff --git a/reports-backend/src/main/java/org/jboss/da/products/api/ArtifactDiff.java b/reports-backend/src/main/java/org/jboss/da/products/api/ArtifactDiff.java index 7f44f430c..c6503b19d 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/api/ArtifactDiff.java +++ b/reports-backend/src/main/java/org/jboss/da/products/api/ArtifactDiff.java @@ -1,10 +1,10 @@ package org.jboss.da.products.api; +import org.jboss.da.common.version.VersionComparator.VersionDifference; import org.jboss.da.model.rest.GA; import lombok.Getter; import lombok.NonNull; -import org.jboss.pnc.common.version.VersionComparator.VersionDifference; /** * diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/AbstractProductProvider.java b/reports-backend/src/main/java/org/jboss/da/products/impl/AbstractProductProvider.java index db4749eac..97fe84f25 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/impl/AbstractProductProvider.java +++ b/reports-backend/src/main/java/org/jboss/da/products/impl/AbstractProductProvider.java @@ -13,6 +13,7 @@ import org.jboss.da.common.json.LookupMode; import org.jboss.da.common.util.UserLog; +import org.jboss.da.common.version.VersionParser; import org.jboss.da.listings.model.ProductSupportStatus; import org.jboss.da.model.rest.GA; import org.jboss.da.model.rest.GAV; @@ -23,7 +24,6 @@ import org.jboss.da.products.api.ProductArtifacts; import org.jboss.da.products.api.ProductProvider; import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; -import org.jboss.pnc.common.version.VersionParser; import org.jboss.pnc.enums.ArtifactQuality; import org.jboss.pnc.enums.BuildCategory; import org.slf4j.Logger; diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/ProductsServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/products/impl/ProductsServiceImpl.java index de424b9ed..975585a8a 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/impl/ProductsServiceImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/products/impl/ProductsServiceImpl.java @@ -1,14 +1,14 @@ package org.jboss.da.products.impl; +import org.jboss.da.common.version.VersionComparator; +import org.jboss.da.common.version.VersionComparator.VersionDifference; +import org.jboss.da.common.version.VersionParser; import org.jboss.da.listings.api.dao.ProductVersionDAO; import org.jboss.da.listings.api.model.GA; import org.jboss.da.listings.api.model.ProductVersion; import org.jboss.da.listings.api.model.WhiteArtifact; import org.jboss.da.products.api.ArtifactDiff; import org.jboss.da.products.api.ProductsService; -import org.jboss.pnc.common.version.VersionComparator; -import org.jboss.pnc.common.version.VersionComparator.VersionDifference; -import org.jboss.pnc.common.version.VersionParser; import javax.inject.Inject; diff --git a/reports-backend/src/main/java/org/jboss/da/reports/api/LookupGenerator.java b/reports-backend/src/main/java/org/jboss/da/reports/api/LookupGenerator.java index 3a2073edb..9d29f6556 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/api/LookupGenerator.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/api/LookupGenerator.java @@ -8,8 +8,8 @@ import org.jboss.da.lookup.model.MavenVersionsResult; import org.jboss.da.lookup.model.NPMLookupResult; import org.jboss.da.lookup.model.NPMVersionsResult; -import org.jboss.pnc.api.constants.versions.VersionDistanceRule; -import org.jboss.pnc.api.constants.versions.VersionFilter; +import org.jboss.da.lookup.model.VersionDistanceRule; +import org.jboss.da.lookup.model.VersionFilter; import org.jboss.da.model.rest.Strategy; import org.jboss.da.model.rest.GAV; import org.jboss.da.model.rest.NPMPackage; diff --git a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java index d28d1c4e8..7371f0bdd 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java @@ -6,14 +6,16 @@ import org.jboss.da.common.json.LookupMode; import org.jboss.da.common.util.Configuration; import org.jboss.da.common.util.ConfigurationParseException; +import org.jboss.da.common.version.VersionAnalyzer; +import org.jboss.da.common.version.VersionStrategy; import org.jboss.da.listings.api.service.BlackArtifactService; import org.jboss.da.lookup.model.MavenLatestResult; import org.jboss.da.lookup.model.MavenLookupResult; import org.jboss.da.lookup.model.MavenVersionsResult; import org.jboss.da.lookup.model.NPMLookupResult; import org.jboss.da.lookup.model.NPMVersionsResult; -import org.jboss.pnc.api.constants.versions.VersionDistanceRule; -import org.jboss.pnc.api.constants.versions.VersionFilter; +import org.jboss.da.lookup.model.VersionDistanceRule; +import org.jboss.da.lookup.model.VersionFilter; import org.jboss.da.model.rest.Strategy; import org.jboss.da.model.rest.GA; import org.jboss.da.model.rest.GAV; @@ -29,11 +31,9 @@ import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; import org.jboss.pnc.common.alignment.ranking.AlignmentPredicate; import org.jboss.pnc.common.alignment.ranking.AlignmentRanking; -import org.jboss.pnc.common.alignment.ranking.VersionStrategy; import org.jboss.pnc.common.alignment.ranking.exception.ValidationException; import org.jboss.pnc.common.alignment.ranking.tokenizer.QualifierToken; import org.jboss.pnc.common.alignment.ranking.tokenizer.Token; -import org.jboss.pnc.common.version.VersionAnalyzer; import org.jboss.pnc.dto.requests.QValue; import org.jboss.pnc.enums.ArtifactQuality; diff --git a/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java b/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java index 7371ad31f..5103ea8db 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java @@ -10,6 +10,10 @@ import org.jboss.da.common.util.Configuration; import org.jboss.da.common.util.ConfigurationParseException; import org.jboss.da.common.util.UserLog; +import org.jboss.da.common.version.SuffixedVersion; +import org.jboss.da.common.version.VersionAnalyzer; +import org.jboss.da.common.version.VersionComparator; +import org.jboss.da.common.version.VersionParser; import org.jboss.da.communication.indy.model.GAVDependencyTree; import org.jboss.da.communication.pom.PomAnalysisException; import org.jboss.da.communication.pom.api.PomAnalyzer; @@ -49,10 +53,6 @@ import org.jboss.da.scm.api.SCM; import org.jboss.da.scm.api.SCMType; import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; -import org.jboss.pnc.common.version.SuffixedVersion; -import org.jboss.pnc.common.version.VersionAnalyzer; -import org.jboss.pnc.common.version.VersionComparator; -import org.jboss.pnc.common.version.VersionParser; import org.jboss.pnc.enums.ArtifactQuality; import org.jboss.pnc.enums.BuildCategory; import org.slf4j.Logger; diff --git a/reports-model/pom.xml b/reports-model/pom.xml index 456a755bc..39e55c9fc 100644 --- a/reports-model/pom.xml +++ b/reports-model/pom.xml @@ -14,10 +14,6 @@ 1.8 - - org.jboss.pnc - pnc-api - com.fasterxml.jackson.core jackson-annotations diff --git a/reports-model/src/main/java/org/jboss/da/lookup/model/MavenVersionsRequest.java b/reports-model/src/main/java/org/jboss/da/lookup/model/MavenVersionsRequest.java index e71de03e4..0d973f33d 100644 --- a/reports-model/src/main/java/org/jboss/da/lookup/model/MavenVersionsRequest.java +++ b/reports-model/src/main/java/org/jboss/da/lookup/model/MavenVersionsRequest.java @@ -21,8 +21,6 @@ import lombok.NonNull; import lombok.extern.jackson.Jacksonized; import org.jboss.da.model.rest.GAV; -import org.jboss.pnc.api.constants.versions.VersionDistanceRule; -import org.jboss.pnc.api.constants.versions.VersionFilter; import javax.validation.constraints.NotNull; import java.util.Set; diff --git a/reports-model/src/main/java/org/jboss/da/lookup/model/NPMVersionsRequest.java b/reports-model/src/main/java/org/jboss/da/lookup/model/NPMVersionsRequest.java index baa583034..ff5032c59 100644 --- a/reports-model/src/main/java/org/jboss/da/lookup/model/NPMVersionsRequest.java +++ b/reports-model/src/main/java/org/jboss/da/lookup/model/NPMVersionsRequest.java @@ -16,13 +16,12 @@ package org.jboss.da.lookup.model; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; import lombok.Builder; import lombok.Data; import lombok.NonNull; import lombok.extern.jackson.Jacksonized; import org.jboss.da.model.rest.NPMPackage; -import org.jboss.pnc.api.constants.versions.VersionDistanceRule; -import org.jboss.pnc.api.constants.versions.VersionFilter; import javax.validation.constraints.NotNull; import java.util.Set; diff --git a/reports-model/src/main/java/org/jboss/da/lookup/model/VersionDistanceRule.java b/reports-model/src/main/java/org/jboss/da/lookup/model/VersionDistanceRule.java new file mode 100644 index 000000000..9f224ee65 --- /dev/null +++ b/reports-model/src/main/java/org/jboss/da/lookup/model/VersionDistanceRule.java @@ -0,0 +1,37 @@ +package org.jboss.da.lookup.model; + +/** + * Rules for determining comparative distance of two versions toward a base version. + */ +public enum VersionDistanceRule { + /** + * This rule tries to suggest the best replacement version. + * + * Rule 1: Version with the same major part as base is closer than version with major part different to base. + *

+ * Rule 2: Version higher than base is considered closer than version lower than base. + *

+ * Rule 3: Version closer to base version by standard order is considered closer. + *

+ * Note: Higher qualifier (e.g. Final) considered better and thus closer than otherwise the same version with lower + * qualifier (e.g. Alpha). This may not be correct for all qualifiers. + */ + RECOMMENDED_REPLACEMENT, + /** + * This rule orders the version by closeness of their parts. + * + * Rule 1: Version which differs in less significant part (major, minor, micro, qualifier, suffix) from the base + * version is considered closer than version with differs in more significant part. + *

+ * Rule 2: If both version differs in the same most significant numerical part (major, minor, micro) to base + * version:
+ * a) version which has the part numerically closer to base is considered closer.
+ * b) if they are the same numerical distance to base, the higher number is considered closer. + *

+ * Rule 3: Version closer to base version by standard order is considered closer. + *

+ * Note: Higher qualifier (e.g. Final) considered better and thus closer than otherwise the same version with lower + * qualifier (e.g. Alpha). This may not be correct for all qualifiers. + */ + CLOSEST_BY_PARTS +} diff --git a/reports-model/src/main/java/org/jboss/da/lookup/model/VersionFilter.java b/reports-model/src/main/java/org/jboss/da/lookup/model/VersionFilter.java new file mode 100644 index 000000000..d955c0ea9 --- /dev/null +++ b/reports-model/src/main/java/org/jboss/da/lookup/model/VersionFilter.java @@ -0,0 +1,5 @@ +package org.jboss.da.lookup.model; + +public enum VersionFilter { + ALL, MAJOR, MAJOR_MINOR, MAJOR_MINOR_MICRO, MAJOR_MINOR_MICRO_QUALIFIER +} diff --git a/reports-rest/pom.xml b/reports-rest/pom.xml index 75a8963cf..495a8e23b 100644 --- a/reports-rest/pom.xml +++ b/reports-rest/pom.xml @@ -21,6 +21,10 @@ pncmetrics provided + + org.jboss.pnc + pnc-common + org.slf4j slf4j-api @@ -84,6 +88,10 @@ provided + + io.opentelemetry.instrumentation + opentelemetry-instrumentation-annotations + From 15d8863ac6a2d0a4153ae3ed11fb1c4306a18f69 Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Fri, 13 Feb 2026 16:58:45 +0000 Subject: [PATCH 06/26] Revert "[NCL-7877] decouple version functionality from ScopedStrategy" This reverts commit 9dc67421acb14ff904fdfebb9bc28c4c4d33fe28. --- ...Strategy.java => CompiledGAVStrategy.java} | 12 +- ...pedStrategy.java => CompiledStrategy.java} | 33 ++-- .../da/common/version/VersionAnalyzer.java | 9 +- .../da/common/version/VersionStrategy.java | 45 ------ .../common/version/VersionAnalyzerTest.java | 143 +++++++++--------- .../da/reports/impl/LookupGeneratorImpl.java | 24 +-- 6 files changed, 119 insertions(+), 147 deletions(-) rename common/src/main/java/org/jboss/da/common/{ScopedGAVStrategy.java => CompiledGAVStrategy.java} (74%) rename common/src/main/java/org/jboss/da/common/{ScopedStrategy.java => CompiledStrategy.java} (61%) delete mode 100644 common/src/main/java/org/jboss/da/common/version/VersionStrategy.java diff --git a/common/src/main/java/org/jboss/da/common/ScopedGAVStrategy.java b/common/src/main/java/org/jboss/da/common/CompiledGAVStrategy.java similarity index 74% rename from common/src/main/java/org/jboss/da/common/ScopedGAVStrategy.java rename to common/src/main/java/org/jboss/da/common/CompiledGAVStrategy.java index 34d552810..10ad3462c 100644 --- a/common/src/main/java/org/jboss/da/common/ScopedGAVStrategy.java +++ b/common/src/main/java/org/jboss/da/common/CompiledGAVStrategy.java @@ -8,7 +8,7 @@ import org.jboss.pnc.common.alignment.ranking.exception.ValidationException; @SuperBuilder -public class ScopedGAVStrategy extends ScopedStrategy { +public class CompiledGAVStrategy extends CompiledStrategy { @Override public int matchSignificance(GAV gav) { @@ -40,11 +40,11 @@ public int matchSignificance(GAV gav) { return 0; } - public static ScopedGAVStrategy from(Strategy restStrategy) throws ValidationException { - return builder().artifactScope(restStrategy.getArtifactScope()) - .ranks(new AlignmentRanking(restStrategy.getRanks(), null)) - .allowList(new AlignmentPredicate(restStrategy.getAllowList(), ver -> true)) - .denyList(new AlignmentPredicate(restStrategy.getDenyList(), ver -> false)) + public static CompiledGAVStrategy from(Strategy strategy) throws ValidationException { + return builder().artifactScope(strategy.getArtifactScope()) + .ranks(new AlignmentRanking(strategy.getRanks(), null)) + .allowList(new AlignmentPredicate(strategy.getAllowList(), ver -> true)) + .denyList(new AlignmentPredicate(strategy.getDenyList(), ver -> false)) .build(); } } diff --git a/common/src/main/java/org/jboss/da/common/ScopedStrategy.java b/common/src/main/java/org/jboss/da/common/CompiledStrategy.java similarity index 61% rename from common/src/main/java/org/jboss/da/common/ScopedStrategy.java rename to common/src/main/java/org/jboss/da/common/CompiledStrategy.java index 595bafd76..1174a7afd 100644 --- a/common/src/main/java/org/jboss/da/common/ScopedStrategy.java +++ b/common/src/main/java/org/jboss/da/common/CompiledStrategy.java @@ -1,16 +1,29 @@ package org.jboss.da.common; +import lombok.AccessLevel; +import lombok.AllArgsConstructor; import lombok.Getter; import lombok.experimental.SuperBuilder; -import org.jboss.da.common.version.VersionStrategy; +import org.jboss.pnc.common.alignment.ranking.AlignmentPredicate; +import org.jboss.pnc.common.alignment.ranking.AlignmentRanking; import java.util.Comparator; @SuperBuilder -public abstract class ScopedStrategy extends VersionStrategy implements Comparator { +@AllArgsConstructor(access = AccessLevel.PROTECTED) +public abstract class CompiledStrategy implements Comparator { @Getter private final String artifactScope; + @Getter + private final AlignmentRanking ranks; + + @Getter + private final AlignmentPredicate denyList; + + @Getter + private final AlignmentPredicate allowList; + /** * Returns a number that conveys how much does an artifact identifier conform to an artifactScope. Higher number * suggests a better match. The method returns 0 if the identifier doesn't match the artifactScope at all. @@ -25,24 +38,22 @@ public abstract class ScopedStrategy extends VersionStrategy implements Compa * * @return strategy that do not affect version analysis */ - public static ScopedStrategy none() { - return DefaultScopedStrategy.get(); + public static CompiledStrategy none() { + return DefaultCompiledStrategy.get(); } @SuperBuilder - private static class DefaultScopedStrategy extends ScopedStrategy { + private static class DefaultCompiledStrategy extends CompiledStrategy { @Override public int matchSignificance(Object artifactIdentifier) { return 0; } - private static DefaultScopedStrategy get() { - var vStrategy = VersionStrategy.none(); - + private static DefaultCompiledStrategy get() { return builder().artifactScope(null) - .ranks(vStrategy.getRanks()) - .allowList(vStrategy.getAllowList()) - .denyList(vStrategy.getDenyList()) + .ranks(new AlignmentRanking(null, null)) + .allowList(new AlignmentPredicate(null, ver -> true)) + .denyList(new AlignmentPredicate(null, ver -> false)) .build(); } } diff --git a/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java b/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java index c6770874b..ee66116f1 100644 --- a/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java +++ b/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java @@ -15,6 +15,7 @@ */ package org.jboss.da.common.version; +import org.jboss.da.common.CompiledStrategy; import org.jboss.da.lookup.model.VersionDistanceRule; import org.jboss.da.lookup.model.VersionFilter; import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; @@ -60,21 +61,21 @@ public class VersionAnalyzer { private final VersionParser versionParser; private final List suffixes = new ArrayList<>(); private final VersionDistanceRule distanceRule; - private final VersionStrategy strategies; + private final CompiledStrategy strategies; public VersionAnalyzer(List suffixes) { this(suffixes, VersionDistanceRule.RECOMMENDED_REPLACEMENT); } - public VersionAnalyzer(List suffixes, VersionStrategy strategies) { + public VersionAnalyzer(List suffixes, CompiledStrategy strategies) { this(suffixes, VersionDistanceRule.RECOMMENDED_REPLACEMENT, strategies); } public VersionAnalyzer(List suffixes, VersionDistanceRule distanceRule) { - this(suffixes, distanceRule, VersionStrategy.none()); + this(suffixes, distanceRule, CompiledStrategy.none()); } - public VersionAnalyzer(List suffixes, VersionDistanceRule distanceRule, VersionStrategy strategies) { + public VersionAnalyzer(List suffixes, VersionDistanceRule distanceRule, CompiledStrategy strategies) { this.suffixes.addAll(suffixes); this.versionParser = new VersionParser(suffixes); this.distanceRule = Objects.requireNonNull(distanceRule); diff --git a/common/src/main/java/org/jboss/da/common/version/VersionStrategy.java b/common/src/main/java/org/jboss/da/common/version/VersionStrategy.java deleted file mode 100644 index 0b994adcb..000000000 --- a/common/src/main/java/org/jboss/da/common/version/VersionStrategy.java +++ /dev/null @@ -1,45 +0,0 @@ -package org.jboss.da.common.version; - -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.experimental.SuperBuilder; -import org.jboss.pnc.common.alignment.ranking.AlignmentPredicate; -import org.jboss.pnc.common.alignment.ranking.AlignmentRanking; - -import java.util.List; - -@SuperBuilder -@AllArgsConstructor(access = AccessLevel.PUBLIC) -public class VersionStrategy { - - @Getter - private final AlignmentRanking ranks; - - @Getter - private final AlignmentPredicate denyList; - - @Getter - private final AlignmentPredicate allowList; - - /** - * Returns such strategy that does not alter behaviour of version analysis - * - * @return strategy that does not affect version analysis - */ - public static VersionStrategy none() { - return VersionStrategy.builder() - .ranks(new AlignmentRanking(null, null)) - .allowList(new AlignmentPredicate(null, ver -> true)) - .denyList(new AlignmentPredicate(null, ver -> false)) - .build(); - } - - public static VersionStrategy from(List ranks, String allowList, String denyList) { - return VersionStrategy.builder() - .ranks(new AlignmentRanking(ranks, null)) - .allowList(new AlignmentPredicate(allowList, ver -> true)) - .denyList(new AlignmentPredicate(denyList, ver -> false)) - .build(); - } -} diff --git a/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java b/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java index 4ac9610fb..88f73662a 100644 --- a/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java +++ b/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java @@ -1,6 +1,7 @@ package org.jboss.da.common.version; import org.jboss.da.common.CommunicationException; +import org.jboss.da.model.rest.Strategy; import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; import org.jboss.pnc.api.enums.Qualifier; import org.junit.Test; @@ -14,6 +15,7 @@ import java.util.Set; import java.util.stream.Collectors; +import static org.jboss.da.common.CompiledGAVStrategy.from; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; @@ -346,8 +348,8 @@ public void testDifferentSuffixWithOnlyDefaultVersions() { @Test public void testSingleRankOfQuality() { - VersionStrategy strat = VersionStrategy.from(List.of("QUALITY:RELEASED"), null, null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder().ranks(List.of("QUALITY:RELEASED")).build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -364,8 +366,8 @@ public void testSingleRankOfQuality() { @Test public void testSingleRankOfProduct() { - VersionStrategy strat = VersionStrategy.from(List.of("PRODUCT_ID:1"), null, null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder().ranks(List.of("PRODUCT_ID:1")).build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -382,8 +384,8 @@ public void testSingleRankOfProduct() { @Test public void testSingleRankWithNoMatch() { - VersionStrategy strat = VersionStrategy.from(List.of("QUALITY:RELEASED"), null, null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder().ranks(List.of("QUALITY:RELEASED")).build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -400,8 +402,8 @@ public void testSingleRankWithNoMatch() { @Test public void testTwoSimilarRanks() { - VersionStrategy strat = VersionStrategy.from(List.of("QUALITY:RELEASED", "QUALITY:TESTED"), null, null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder().ranks(List.of("QUALITY:RELEASED", "QUALITY:TESTED")).build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -418,8 +420,8 @@ public void testTwoSimilarRanks() { @Test public void testTwoSimilarRanksReversed() { - VersionStrategy strat = VersionStrategy.from(List.of("QUALITY:TESTED", "QUALITY:RELEASED"), null, null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder().ranks(List.of("QUALITY:TESTED", "QUALITY:RELEASED")).build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -439,8 +441,8 @@ public void testTwoDistinctRanks() { /** * Ranks: 1st: PRODUCT:EAP 2nd: QUALITY:RELEASED 3rd: SUFFIX-VERSION */ - VersionStrategy strat = VersionStrategy.from(List.of("PRODUCT:EAP", "QUALITY:RELEASED"), null, null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder().ranks(List.of("PRODUCT:EAP", "QUALITY:RELEASED")).build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -471,9 +473,8 @@ public void testTwoSimilarRanksInOr() { /** * Ranks: 1st: PRODUCT:EAP or PRODUCT:RHSSO 2nd: QUALITY:RELEASED 3rd: SUFFIX-VERSION */ - VersionStrategy strat = VersionStrategy - .from(List.of("PRODUCT:EAP or PRODUCT:RHSSO", "QUALITY:RELEASED"), null, null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder().ranks(List.of("PRODUCT:EAP or PRODUCT:RHSSO", "QUALITY:RELEASED")).build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -504,9 +505,8 @@ public void testMultiValueRanksInOr() { /** * Ranks: 1st: QUALITY:RELEASED or QUALITY:TESTED 2nd: PRODUCT:EAP 3rd: SUFFIX-VERSION */ - VersionStrategy strat = VersionStrategy - .from(List.of("QUALITY:RELEASED or QUALITY:TESTED", "PRODUCT:EAP"), null, null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder().ranks(List.of("QUALITY:RELEASED or QUALITY:TESTED", "PRODUCT:EAP")).build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -541,9 +541,8 @@ public void testMultiValueRanksInOrder() { /** * Ranks: 1st: QUALITY:RELEASED 2nd: QUALITY:TESTED 3rd: PRODUCT:EAP 4th: SUFFIX-VERSION */ - VersionStrategy strat = VersionStrategy - .from(List.of("QUALITY:RELEASED", "QUALITY:TESTED", "PRODUCT:EAP"), null, null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder().ranks(List.of("QUALITY:RELEASED", "QUALITY:TESTED", "PRODUCT:EAP")).build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -581,9 +580,10 @@ public void testLogicOperatorPriorities() { * With explicit parentheses, Ranks would look like this: 1st: PRODUCT:EAP or (QUALITY:TESTED and * QUALITY:RELEASED) 2nd: SUFFIX-VERSION */ - VersionStrategy strat = VersionStrategy - .from(List.of("PRODUCT:EAP or QUALITY:TESTED and QUALITY:RELEASED"), null, null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder() + .ranks(List.of("PRODUCT:EAP or QUALITY:TESTED and QUALITY:RELEASED")) + .build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -618,9 +618,10 @@ public void testLogicOperatorOverridePrecedence() { /** * Ranks: 1st: (PRODUCT:EAP or QUALITY:TESTED) and QUALITY:RELEASED 2nd: SUFFIX-VERSION */ - VersionStrategy strat = VersionStrategy - .from(List.of("(PRODUCT:EAP or QUALITY:TESTED) and QUALITY:RELEASED"), null, null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder() + .ranks(List.of("(PRODUCT:EAP or QUALITY:TESTED) and QUALITY:RELEASED")) + .build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -656,11 +657,10 @@ public void testHardSorting() { * Ranks: 1st: PRODUCT:EAP sort-by SUFFIX-VERSION 2nd: QUALITY:RELEASED sort-by SUFFIX-VERSION 3rd: * SUFFIX-VERSION */ - VersionStrategy strat = VersionStrategy.from( - List.of("PRODUCT:EAP sort-by SUFFIX-VERSION", "QUALITY:RELEASED sort-by SUFFIX-VERSION"), - null, - null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder() + .ranks(List.of("PRODUCT:EAP sort-by SUFFIX-VERSION", "QUALITY:RELEASED sort-by SUFFIX-VERSION")) + .build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -691,13 +691,13 @@ public void testHardSortingWithOr() { * Ranks: 1st: PRODUCT:EAP or QUALITY:TESTED sort-by SUFFIX-VERSION 2nd: QUALITY:RELEASED sort-by SUFFIX-VERSION * 3rd: SUFFIX-VERSION */ - VersionStrategy strat = VersionStrategy.from( - List.of( - "PRODUCT:EAP or QUALITY:TESTED sort-by SUFFIX-VERSION", - "QUALITY:RELEASED sort-by SUFFIX-VERSION"), - null, - null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder() + .ranks( + List.of( + "PRODUCT:EAP or QUALITY:TESTED sort-by SUFFIX-VERSION", + "QUALITY:RELEASED sort-by SUFFIX-VERSION")) + .build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -729,13 +729,13 @@ public void testHardSortingWithAnd() { * Ranks: 1st: PRODUCT:EAP and QUALITY:TESTED sort-by SUFFIX-VERSION 2nd: QUALITY:RELEASED sort-by * SUFFIX-VERSION 3rd: SUFFIX-VERSION */ - VersionStrategy strat = VersionStrategy.from( - List.of( - "PRODUCT:EAP and QUALITY:TESTED sort-by SUFFIX-VERSION", - "QUALITY:RELEASED sort-by SUFFIX-VERSION"), - null, - null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder() + .ranks( + List.of( + "PRODUCT:EAP and QUALITY:TESTED sort-by SUFFIX-VERSION", + "QUALITY:RELEASED sort-by SUFFIX-VERSION")) + .build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -766,9 +766,10 @@ public void testSortingCombination() { /** * Ranks: 1st: PRODUCT:EAP 2nd: QUALITY:RELEASED sort-by SUFFIX-VERSION 3rd: QUALITY:TESTED 4th: SUFFIX-VERSION */ - VersionStrategy strat = VersionStrategy - .from(List.of("PRODUCT:EAP", "QUALITY:RELEASED sort-by SUFFIX-VERSION", "QUALITY:TESTED"), null, null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder() + .ranks(List.of("PRODUCT:EAP", "QUALITY:RELEASED sort-by SUFFIX-VERSION", "QUALITY:TESTED")) + .build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -806,9 +807,8 @@ public void testSortingCombinationWithoutHard() { /** * Ranks: 1st: PRODUCT:EAP 2nd: QUALITY:RELEASED 3rd: QUALITY:TESTED 4th: SUFFIX-VERSION */ - VersionStrategy strat = VersionStrategy - .from(List.of("PRODUCT:EAP", "QUALITY:RELEASED", "QUALITY:TESTED"), null, null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder().ranks(List.of("PRODUCT:EAP", "QUALITY:RELEASED", "QUALITY:TESTED")).build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -845,8 +845,8 @@ public void testSimpleDenyList() { /** * Deny list: QUALITY:RELEASED */ - VersionStrategy strat = VersionStrategy.from(null, null, "QUALITY:RELEASED"); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder().denyList("QUALITY:RELEASED").build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -871,8 +871,8 @@ public void testMultipleDenyList() { /** * Deny list: QUALITY:RELEASED, PRODUCT:RHSSO */ - VersionStrategy strat = VersionStrategy.from(null, null, "QUALITY:RELEASED, PRODUCT:RHSSO"); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder().denyList("QUALITY:RELEASED, PRODUCT:RHSSO").build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -897,8 +897,8 @@ public void testAllowList() { /** * Allow list: QUALITY:RELEASED */ - VersionStrategy strat = VersionStrategy.from(null, "QUALITY:RELEASED", null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder().allowList("QUALITY:RELEASED").build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -923,8 +923,8 @@ public void testMultipleAllowList() { /** * Allow list: QUALITY:RELEASED, PRODUCT:EAP */ - VersionStrategy strat = VersionStrategy.from(null, "QUALITY:RELEASED, PRODUCT:EAP", null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder().allowList("QUALITY:RELEASED, PRODUCT:EAP").build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -949,8 +949,8 @@ public void testAllowAndDenyAtTheSameTime() { /** * Allow list: QUALITY:RELEASED Deny list: PRODUCT:RHSSO */ - VersionStrategy strat = VersionStrategy.from(null, "QUALITY:RELEASED", "PRODUCT:RHSSO"); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder().allowList("QUALITY:RELEASED").denyList("PRODUCT:RHSSO").build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -977,8 +977,11 @@ public void testAllowWithRanking() { * * Ranks: 1st: PRODUCT:EAP 2nd: SUFFIX-VERSION */ - VersionStrategy strat = VersionStrategy.from(List.of("PRODUCT:EAP"), "QUALITY:RELEASED, PRODUCT:RHSSO", null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), strat); + Strategy strat = Strategy.builder() + .allowList("QUALITY:RELEASED, PRODUCT:RHSSO") + .ranks(List.of("PRODUCT:EAP")) + .build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -1003,8 +1006,8 @@ public void testRankingWithSuffixes() { /** * Ranks: 1st: PRODUCT:RHSSO 2nd: PRODUCT:EAP 3rd: SUFFIX-VERSION */ - VersionStrategy strat = VersionStrategy.from(List.of("PRODUCT:RHSSO", "PRODUCT:EAP"), null, null); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("temporary-redhat", "redhat"), strat); + Strategy strat = Strategy.builder().ranks(List.of("PRODUCT:RHSSO", "PRODUCT:EAP")).build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("temporary-redhat", "redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -1038,8 +1041,8 @@ public void testDenyListFullRemovingSuffixes() { /** * Deny list: QUALITY:DELETE */ - VersionStrategy strat = VersionStrategy.from(null, null, "QUALITY:DELETE"); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("temporary-redhat", "redhat"), strat); + Strategy strat = Strategy.builder().denyList("QUALITY:DELETE").build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("temporary-redhat", "redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( @@ -1067,8 +1070,8 @@ public void testDenyRemovingVersionsFromBothSuffixes() { /** * Deny list: QUALITY:DELETE */ - VersionStrategy strat = VersionStrategy.from(null, null, "QUALITY:DELETE"); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("temporary-redhat", "redhat"), strat); + Strategy strat = Strategy.builder().denyList("QUALITY:DELETE").build(); + VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("temporary-redhat", "redhat"), from(strat)); String version = "1.4.0"; List versions = new ArrayList<>( diff --git a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java index 7371f0bdd..c96b72b10 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java @@ -1,13 +1,12 @@ package org.jboss.da.reports.impl; import org.jboss.da.common.CommunicationException; -import org.jboss.da.common.ScopedStrategy; -import org.jboss.da.common.ScopedGAVStrategy; +import org.jboss.da.common.CompiledStrategy; +import org.jboss.da.common.CompiledGAVStrategy; import org.jboss.da.common.json.LookupMode; import org.jboss.da.common.util.Configuration; import org.jboss.da.common.util.ConfigurationParseException; import org.jboss.da.common.version.VersionAnalyzer; -import org.jboss.da.common.version.VersionStrategy; import org.jboss.da.listings.api.service.BlackArtifactService; import org.jboss.da.lookup.model.MavenLatestResult; import org.jboss.da.lookup.model.MavenLookupResult; @@ -90,7 +89,7 @@ public Set lookupBestMatchMaven( boolean brewPullActive, Set strategies) throws CommunicationException, ValidationException { LookupMode lookupMode = getMode(mode, false); - Set compiledStrategies = compileMavenStrategies(strategies); + Set compiledStrategies = compileMavenStrategies(strategies); ProductProvider productProvider = setupProductProvider( brewPullActive, @@ -103,14 +102,14 @@ public Set lookupBestMatchMaven( return createLookupResult(gavs, lookupMode, productArtifacts, compiledStrategies); } - private static Set compileMavenStrategies(Set strategies) { + private static Set compileMavenStrategies(Set strategies) { if (strategies == null) { return Collections.emptySet(); } - return strategies.stream().map(ScopedGAVStrategy::from).collect(Collectors.toSet()); + return strategies.stream().map(CompiledGAVStrategy::from).collect(Collectors.toSet()); } - private static Set extractQualifiers(Set> strategies) { + private static Set extractQualifiers(Set> strategies) { Set allTokens = new HashSet<>(); for (var strategy : strategies) { AlignmentRanking ranks = strategy.getRanks(); @@ -227,11 +226,11 @@ private Set createLookupResult( Set gavs, LookupMode mode, Map>> artifactsMap, - Set compiledStrategies) throws CommunicationException { + Set compiledStrategies) throws CommunicationException { - Map, VersionAnalyzer> vas = compiledStrategies.stream() + Map, VersionAnalyzer> vas = compiledStrategies.stream() .collect(Collectors.toMap(Function.identity(), con -> new VersionAnalyzer(mode.getSuffixes(), con))); - VersionAnalyzer def = new VersionAnalyzer(mode.getSuffixes(), VersionStrategy.none()); + VersionAnalyzer def = new VersionAnalyzer(mode.getSuffixes(), CompiledStrategy.none()); Set> futures = gavs.stream() .map( @@ -252,7 +251,10 @@ private Set createLookupResult( * @return closest VA or default VA on empty map or no match * @param GAV or NPM */ - private VersionAnalyzer chooseVa(T artifact, Map, VersionAnalyzer> vas, VersionAnalyzer def) { + private VersionAnalyzer chooseVa( + T artifact, + Map, VersionAnalyzer> vas, + VersionAnalyzer def) { var max = vas.keySet().stream().max((cc1, cc2) -> { int sim1 = cc1.matchSignificance(artifact); int sim2 = cc2.matchSignificance(artifact); From 9b730564147ba67cc700f7f8e1dc1b2a238a273e Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Fri, 13 Feb 2026 16:59:35 +0000 Subject: [PATCH 07/26] Revert "[Alignment 2.0] implement VersionAnalyzer tests regarding Qualifiers" This reverts commit cc5ae7c00d7c897033915a8d7cef78bd5277b7b4. --- .../common/version/VersionAnalyzerTest.java | 780 ------------------ 1 file changed, 780 deletions(-) diff --git a/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java b/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java index 88f73662a..542cd3cce 100644 --- a/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java +++ b/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java @@ -1,21 +1,15 @@ package org.jboss.da.common.version; import org.jboss.da.common.CommunicationException; -import org.jboss.da.model.rest.Strategy; import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; -import org.jboss.pnc.api.enums.Qualifier; import org.junit.Test; -import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; -import java.util.Map; import java.util.Optional; -import java.util.Set; import java.util.stream.Collectors; -import static org.jboss.da.common.CompiledGAVStrategy.from; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; @@ -293,18 +287,6 @@ private void checkBMV(VersionAnalyzer versionAnalyzer, String expectedVersion, S assertEquals(expectedVersion, bmv.get()); } - private void checkBMV( - VersionAnalyzer versionAnalyzer, - String expectedVersion, - String version, - QualifiedVersion[] versions) { - Optional bmv = versionAnalyzer - .findBiggestMatchingVersion(version, Arrays.stream(versions).collect(Collectors.toList())); - - assertTrue("Best match version expected to be present", bmv.isPresent()); - assertEquals(expectedVersion, bmv.get()); - } - @Test public void testDifferentSuffix() { VersionAnalyzer versionAnalyzer = new VersionAnalyzer(Arrays.asList("temporary-redhat", "redhat")); @@ -346,766 +328,4 @@ public void testDifferentSuffixWithOnlyDefaultVersions() { checkBMV(versionAnalyzer, "1.4.0.redhat-4", version, avaliableVersionsMultiple); } - @Test - public void testSingleRankOfQuality() { - Strategy strat = Strategy.builder().ranks(List.of("QUALITY:RELEASED")).build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.QUALITY, Set.of("TESTED"))), - new QualifiedVersion("1.4.0.redhat-3", Map.of(Qualifier.PRODUCT_ID, Set.of("1"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))))); - - String[] expectedOrder = { "1.4.0.redhat-2", "1.4.0.redhat-1", "1.4.0.redhat-4" }; - - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testSingleRankOfProduct() { - Strategy strat = Strategy.builder().ranks(List.of("PRODUCT_ID:1")).build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.QUALITY, Set.of("TESTED"))), - new QualifiedVersion("1.4.0.redhat-3", Map.of(Qualifier.PRODUCT_ID, Set.of("1"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))))); - - String[] expectedOrder = { "1.4.0.redhat-3", "1.4.0.redhat-4", "1.4.0.redhat-2" }; - - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testSingleRankWithNoMatch() { - Strategy strat = Strategy.builder().ranks(List.of("QUALITY:RELEASED")).build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.QUALITY, Set.of("TESTED"))), - new QualifiedVersion("1.4.0.redhat-3", Map.of(Qualifier.PRODUCT_ID, Set.of("1"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of("NEW"))), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("BLACKLISTED"))))); - - String[] expectedOrder = { "1.4.0.redhat-4", "1.4.0.redhat-3", "1.4.0.redhat-2" }; - - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testTwoSimilarRanks() { - Strategy strat = Strategy.builder().ranks(List.of("QUALITY:RELEASED", "QUALITY:TESTED")).build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT_ID, Set.of("1"))), - new QualifiedVersion("1.4.0.redhat-3", Map.of(Qualifier.QUALITY, Set.of("TESTED"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))))); - - String[] expectedOrder = { "1.4.0.redhat-2", "1.4.0.redhat-1", "1.4.0.redhat-3" }; - - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testTwoSimilarRanksReversed() { - Strategy strat = Strategy.builder().ranks(List.of("QUALITY:TESTED", "QUALITY:RELEASED")).build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT_ID, Set.of("1"))), - new QualifiedVersion("1.4.0.redhat-3", Map.of(Qualifier.QUALITY, Set.of("TESTED"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))))); - - String[] expectedOrder = { "1.4.0.redhat-3", "1.4.0.redhat-2", "1.4.0.redhat-1" }; - - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testTwoDistinctRanks() { - /** - * Ranks: 1st: PRODUCT:EAP 2nd: QUALITY:RELEASED 3rd: SUFFIX-VERSION - */ - Strategy strat = Strategy.builder().ranks(List.of("PRODUCT:EAP", "QUALITY:RELEASED")).build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.redhat-3", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of()), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); - - String[] expectedOrder = { - "1.4.0.redhat-3", - "1.4.0.redhat-6", - "1.4.0.redhat-5", - "1.4.0.redhat-4", - "1.4.0.redhat-2" }; - - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testTwoSimilarRanksInOr() { - /** - * Ranks: 1st: PRODUCT:EAP or PRODUCT:RHSSO 2nd: QUALITY:RELEASED 3rd: SUFFIX-VERSION - */ - Strategy strat = Strategy.builder().ranks(List.of("PRODUCT:EAP or PRODUCT:RHSSO", "QUALITY:RELEASED")).build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.redhat-3", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of("TESTED"))), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))))); - - String[] expectedOrder = { - "1.4.0.redhat-5", - "1.4.0.redhat-3", - "1.4.0.redhat-6", - "1.4.0.redhat-4", - "1.4.0.redhat-1" }; - - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testMultiValueRanksInOr() { - /** - * Ranks: 1st: QUALITY:RELEASED or QUALITY:TESTED 2nd: PRODUCT:EAP 3rd: SUFFIX-VERSION - */ - Strategy strat = Strategy.builder().ranks(List.of("QUALITY:RELEASED or QUALITY:TESTED", "PRODUCT:EAP")).build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of( - Qualifier.QUALITY, - Set.of("RELEASED", "TESTED"), - Qualifier.PRODUCT, - Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.redhat-3", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of()), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); - - String[] expectedOrder = { - "1.4.0.redhat-3", - "1.4.0.redhat-5", - "1.4.0.redhat-1", - "1.4.0.redhat-6", - "1.4.0.redhat-4" }; - - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testMultiValueRanksInOrder() { - /** - * Ranks: 1st: QUALITY:RELEASED 2nd: QUALITY:TESTED 3rd: PRODUCT:EAP 4th: SUFFIX-VERSION - */ - Strategy strat = Strategy.builder().ranks(List.of("QUALITY:RELEASED", "QUALITY:TESTED", "PRODUCT:EAP")).build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of( - Qualifier.QUALITY, - Set.of("RELEASED", "TESTED"), - Qualifier.PRODUCT, - Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.redhat-3", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of()), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); - - String[] expectedOrder = { - "1.4.0.redhat-5", - "1.4.0.redhat-3", - "1.4.0.redhat-1", - "1.4.0.redhat-6", - "1.4.0.redhat-4" }; - - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testLogicOperatorPriorities() { - /** - * Ranks: 1st: PRODUCT:EAP or QUALITY:TESTED and QUALITY:RELEASED 2nd: SUFFIX-VERSION - *

- * With explicit parentheses, Ranks would look like this: 1st: PRODUCT:EAP or (QUALITY:TESTED and - * QUALITY:RELEASED) 2nd: SUFFIX-VERSION - */ - Strategy strat = Strategy.builder() - .ranks(List.of("PRODUCT:EAP or QUALITY:TESTED and QUALITY:RELEASED")) - .build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of( - Qualifier.QUALITY, - Set.of("RELEASED", "TESTED"), - Qualifier.PRODUCT, - Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.redhat-3", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of()), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); - - String[] expectedOrder = { - "1.4.0.redhat-6", - "1.4.0.redhat-5", - "1.4.0.redhat-3", - "1.4.0.redhat-4", - "1.4.0.redhat-2" }; - - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testLogicOperatorOverridePrecedence() { - /** - * Ranks: 1st: (PRODUCT:EAP or QUALITY:TESTED) and QUALITY:RELEASED 2nd: SUFFIX-VERSION - */ - Strategy strat = Strategy.builder() - .ranks(List.of("(PRODUCT:EAP or QUALITY:TESTED) and QUALITY:RELEASED")) - .build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of( - Qualifier.QUALITY, - Set.of("RELEASED", "TESTED"), - Qualifier.PRODUCT, - Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.redhat-3", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of()), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); - - String[] expectedOrder = { - "1.4.0.redhat-5", - "1.4.0.redhat-3", - "1.4.0.redhat-6", - "1.4.0.redhat-4", - "1.4.0.redhat-2" }; - - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testHardSorting() { - /** - * Ranks: 1st: PRODUCT:EAP sort-by SUFFIX-VERSION 2nd: QUALITY:RELEASED sort-by SUFFIX-VERSION 3rd: - * SUFFIX-VERSION - */ - Strategy strat = Strategy.builder() - .ranks(List.of("PRODUCT:EAP sort-by SUFFIX-VERSION", "QUALITY:RELEASED sort-by SUFFIX-VERSION")) - .build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.redhat-3", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of())), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); - - String[] expectedOrder = { - "1.4.0.redhat-6", - "1.4.0.redhat-3", - "1.4.0.redhat-5", - "1.4.0.redhat-4", - "1.4.0.redhat-2" }; - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testHardSortingWithOr() { - /** - * Ranks: 1st: PRODUCT:EAP or QUALITY:TESTED sort-by SUFFIX-VERSION 2nd: QUALITY:RELEASED sort-by SUFFIX-VERSION - * 3rd: SUFFIX-VERSION - */ - Strategy strat = Strategy.builder() - .ranks( - List.of( - "PRODUCT:EAP or QUALITY:TESTED sort-by SUFFIX-VERSION", - "QUALITY:RELEASED sort-by SUFFIX-VERSION")) - .build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.redhat-3", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of())), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); - - String[] expectedOrder = { - "1.4.0.redhat-6", - "1.4.0.redhat-3", - "1.4.0.redhat-1", - "1.4.0.redhat-5", - "1.4.0.redhat-4" }; - - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testHardSortingWithAnd() { - /** - * Ranks: 1st: PRODUCT:EAP and QUALITY:TESTED sort-by SUFFIX-VERSION 2nd: QUALITY:RELEASED sort-by - * SUFFIX-VERSION 3rd: SUFFIX-VERSION - */ - Strategy strat = Strategy.builder() - .ranks( - List.of( - "PRODUCT:EAP and QUALITY:TESTED sort-by SUFFIX-VERSION", - "QUALITY:RELEASED sort-by SUFFIX-VERSION")) - .build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.redhat-3", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of())), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); - - String[] expectedOrder = { - "1.4.0.redhat-5", - "1.4.0.redhat-3", - "1.4.0.redhat-6", - "1.4.0.redhat-4", - "1.4.0.redhat-2" }; - - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testSortingCombination() { - /** - * Ranks: 1st: PRODUCT:EAP 2nd: QUALITY:RELEASED sort-by SUFFIX-VERSION 3rd: QUALITY:TESTED 4th: SUFFIX-VERSION - */ - Strategy strat = Strategy.builder() - .ranks(List.of("PRODUCT:EAP", "QUALITY:RELEASED sort-by SUFFIX-VERSION", "QUALITY:TESTED")) - .build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.redhat-3", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-2", - Map.of( - Qualifier.QUALITY, - Set.of("RELEASED", "TESTED"), - Qualifier.PRODUCT, - Set.of("EAP"))), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); - - String[] expectedOrder = { - "1.4.0.redhat-3", - "1.4.0.redhat-2", - "1.4.0.redhat-6", - "1.4.0.redhat-5", - "1.4.0.redhat-1" }; - - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testSortingCombinationWithoutHard() { - // DEMONSTRATES distinction against #testSortingCombination() - /** - * Ranks: 1st: PRODUCT:EAP 2nd: QUALITY:RELEASED 3rd: QUALITY:TESTED 4th: SUFFIX-VERSION - */ - Strategy strat = Strategy.builder().ranks(List.of("PRODUCT:EAP", "QUALITY:RELEASED", "QUALITY:TESTED")).build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.redhat-3", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-2", - Map.of( - Qualifier.QUALITY, - Set.of("RELEASED", "TESTED"), - Qualifier.PRODUCT, - Set.of("EAP"))), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); - - String[] expectedOrder = { - "1.4.0.redhat-2", - "1.4.0.redhat-3", - "1.4.0.redhat-6", - "1.4.0.redhat-5", - "1.4.0.redhat-1" }; - - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testSimpleDenyList() { - /** - * Deny list: QUALITY:RELEASED - */ - Strategy strat = Strategy.builder().denyList("QUALITY:RELEASED").build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.redhat-3", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of())), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); - - String[] expectedOrder = { "1.4.0.redhat-6", "1.4.0.redhat-4", "1.4.0.redhat-2", "1.4.0.redhat-1" }; - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testMultipleDenyList() { - /** - * Deny list: QUALITY:RELEASED, PRODUCT:RHSSO - */ - Strategy strat = Strategy.builder().denyList("QUALITY:RELEASED, PRODUCT:RHSSO").build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.redhat-3", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of())), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); - - String[] expectedOrder = { "1.4.0.redhat-6", "1.4.0.redhat-2", "1.4.0.redhat-1" }; - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testAllowList() { - /** - * Allow list: QUALITY:RELEASED - */ - Strategy strat = Strategy.builder().allowList("QUALITY:RELEASED").build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.redhat-3", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of())), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); - - String[] expectedOrder = { "1.4.0.redhat-5", "1.4.0.redhat-3" }; - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testMultipleAllowList() { - /** - * Allow list: QUALITY:RELEASED, PRODUCT:EAP - */ - Strategy strat = Strategy.builder().allowList("QUALITY:RELEASED, PRODUCT:EAP").build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.redhat-3", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of())), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); - - String[] expectedOrder = { "1.4.0.redhat-6", "1.4.0.redhat-5", "1.4.0.redhat-3" }; - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testAllowAndDenyAtTheSameTime() { - /** - * Allow list: QUALITY:RELEASED Deny list: PRODUCT:RHSSO - */ - Strategy strat = Strategy.builder().allowList("QUALITY:RELEASED").denyList("PRODUCT:RHSSO").build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.redhat-3", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); - - String[] expectedOrder = { "1.4.0.redhat-3", "1.4.0.redhat-2" }; - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testAllowWithRanking() { - /** - * Allow list: QUALITY:RELEASED, PRODUCT:RHSSO - * - * Ranks: 1st: PRODUCT:EAP 2nd: SUFFIX-VERSION - */ - Strategy strat = Strategy.builder() - .allowList("QUALITY:RELEASED, PRODUCT:RHSSO") - .ranks(List.of("PRODUCT:EAP")) - .build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.redhat-3", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion("1.4.0.redhat-2", Map.of(Qualifier.QUALITY, Set.of("RELEASED"))), - new QualifiedVersion("1.4.0.redhat-1", Map.of(Qualifier.QUALITY, Set.of("TESTED"))))); - - String[] expectedOrder = { "1.4.0.redhat-3", "1.4.0.redhat-5", "1.4.0.redhat-4", "1.4.0.redhat-2" }; - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testRankingWithSuffixes() { - /** - * Ranks: 1st: PRODUCT:RHSSO 2nd: PRODUCT:EAP 3rd: SUFFIX-VERSION - */ - Strategy strat = Strategy.builder().ranks(List.of("PRODUCT:RHSSO", "PRODUCT:EAP")).build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("temporary-redhat", "redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.temporary-redhat-3", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion("1.4.0.temporary-redhat-2", Map.of(Qualifier.QUALITY, Set.of())), - new QualifiedVersion( - "1.4.0.temporary-redhat-1", - Map.of(Qualifier.QUALITY, Set.of("TESTED"), Qualifier.PRODUCT, Set.of("RHSSO"))))); - - String[] expectedOrder = { - "1.4.0.temporary-redhat-1", - "1.4.0.temporary-redhat-3", - "1.4.0.temporary-redhat-2", - "1.4.0.redhat-5", - "1.4.0.redhat-4", - "1.4.0.redhat-6" }; - - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testDenyListFullRemovingSuffixes() { - /** - * Deny list: QUALITY:DELETE - */ - Strategy strat = Strategy.builder().denyList("QUALITY:DELETE").build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("temporary-redhat", "redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of(Qualifier.QUALITY, Set.of("RELEASED"), Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.temporary-redhat-3", - Map.of(Qualifier.QUALITY, Set.of("DELETE"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion("1.4.0.temporary-redhat-2", Map.of(Qualifier.QUALITY, Set.of("DELETE"))), - new QualifiedVersion( - "1.4.0.temporary-redhat-1", - Map.of(Qualifier.QUALITY, Set.of("DELETE"), Qualifier.PRODUCT, Set.of("RHSSO"))))); - - String[] expectedOrder = { "1.4.0.redhat-6", "1.4.0.redhat-5", "1.4.0.redhat-4" }; - - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - @Test - public void testDenyRemovingVersionsFromBothSuffixes() { - /** - * Deny list: QUALITY:DELETE - */ - Strategy strat = Strategy.builder().denyList("QUALITY:DELETE").build(); - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(List.of("temporary-redhat", "redhat"), from(strat)); - String version = "1.4.0"; - - List versions = new ArrayList<>( - List.of( - new QualifiedVersion("1.4.0.redhat-6", Map.of(Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion( - "1.4.0.redhat-5", - Map.of(Qualifier.QUALITY, Set.of("DELETE"), Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion("1.4.0.redhat-4", Map.of(Qualifier.PRODUCT, Set.of("RHSSO"))), - new QualifiedVersion( - "1.4.0.temporary-redhat-3", - Map.of(Qualifier.QUALITY, Set.of("DELETE"), Qualifier.PRODUCT, Set.of("EAP"))), - new QualifiedVersion("1.4.0.temporary-redhat-2", Map.of()), - new QualifiedVersion( - "1.4.0.temporary-redhat-1", - Map.of(Qualifier.QUALITY, Set.of("DELETE"), Qualifier.PRODUCT, Set.of("RHSSO"))))); - - String[] expectedOrder = { "1.4.0.temporary-redhat-2", "1.4.0.redhat-6", "1.4.0.redhat-4" }; - - expectOrder(versionAnalyzer, expectedOrder, version, versions); - } - - private void expectOrder( - VersionAnalyzer versionAnalyzer, - String[] expectedOrder, - String version, - List versions) { - for (String expected : expectedOrder) { - checkBMV(versionAnalyzer, expected, version, versions.toArray(new QualifiedVersion[0])); - - // remove best version from list to verify the next one - var expectedInList = versions.stream().filter(qv -> qv.getVersion().equals(expected)).findFirst().get(); - versions.remove(expectedInList); - } - } - } From d7334a54f8a77f82d31a6962eab138b9130cee09 Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Fri, 13 Feb 2026 17:03:13 +0000 Subject: [PATCH 08/26] Revert "[Alignment 2.0] changes after review" This reverts commit f4f99815eaf0b364b24128bf50c576d7f2ce10b0. --- .../jboss/da/common/CompiledGAVStrategy.java | 10 ++--- .../org/jboss/da/common/CompiledStrategy.java | 23 ++-------- .../da/common/version/VersionAnalyzer.java | 43 +++++++++++++++++-- .../communication/pnc/PncConnectorImpl.java | 1 - .../da/reports/impl/LookupGeneratorImpl.java | 8 ++-- .../org/jboss/da/model/rest/Strategy.java | 10 ++++- 6 files changed, 59 insertions(+), 36 deletions(-) diff --git a/common/src/main/java/org/jboss/da/common/CompiledGAVStrategy.java b/common/src/main/java/org/jboss/da/common/CompiledGAVStrategy.java index 10ad3462c..881114feb 100644 --- a/common/src/main/java/org/jboss/da/common/CompiledGAVStrategy.java +++ b/common/src/main/java/org/jboss/da/common/CompiledGAVStrategy.java @@ -11,16 +11,16 @@ public class CompiledGAVStrategy extends CompiledStrategy { @Override - public int matchSignificance(GAV gav) { + public int matchSignificance(GAV toMatch) { if (getArtifactScope() == null) { - // Null signifies a global scope for a strategy. It has the least non-zero significance. + // Null signifies global scope for a strategy. It has the least significance. return 1; } String[] scopeSplit = getArtifactScope().split(":"); - String group = gav.getGroupId(); - String artifact = gav.getArtifactId(); - String version = gav.getVersion(); + String group = toMatch.getGroupId(); + String artifact = toMatch.getArtifactId(); + String version = toMatch.getVersion(); if (scopeSplit.length == 1 && group.equals(scopeSplit[0])) { // gav matched groupID diff --git a/common/src/main/java/org/jboss/da/common/CompiledStrategy.java b/common/src/main/java/org/jboss/da/common/CompiledStrategy.java index 1174a7afd..c5fecfb9e 100644 --- a/common/src/main/java/org/jboss/da/common/CompiledStrategy.java +++ b/common/src/main/java/org/jboss/da/common/CompiledStrategy.java @@ -24,14 +24,7 @@ public abstract class CompiledStrategy implements Comparator { @Getter private final AlignmentPredicate allowList; - /** - * Returns a number that conveys how much does an artifact identifier conform to an artifactScope. Higher number - * suggests a better match. The method returns 0 if the identifier doesn't match the artifactScope at all. - * - * @param artifactIdentifier artifact identifier - * @return an integer. Higher value means higher match. No match return 0. - */ - public abstract int matchSignificance(T artifactIdentifier); + public abstract int matchSignificance(T match); /** * Returns such strategy that do not alter behaviour of version analysis @@ -45,7 +38,7 @@ public static CompiledStrategy none() { @SuperBuilder private static class DefaultCompiledStrategy extends CompiledStrategy { @Override - public int matchSignificance(Object artifactIdentifier) { + public int matchSignificance(Object match) { return 0; } @@ -58,18 +51,8 @@ private static DefaultCompiledStrategy get() { } } - /** - * Compare objects of Type T on how significant they match against this strategy's scope. T is usually a GAV. - * - * @param o1 the first object to be compared. - * @param o2 the second object to be compared. - * @return - */ @Override public int compare(T o1, T o2) { - int s1 = matchSignificance(o1); - int s2 = matchSignificance(o2); - - return Integer.compare(s1, s2); + return Comparator.comparingInt(this::matchSignificance).compare(o1, o2); } } diff --git a/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java b/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java index ee66116f1..50c07151e 100644 --- a/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java +++ b/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java @@ -117,9 +117,6 @@ public Optional findBiggestMatchingVersion(String query, Collection candidateSuffixedVersions = versions.stream() .map(versionParser::parseSuffixed) .flatMap(Set::stream) - // apply strategy filters earlier because they might filter out an entire suffix - .filter(sv -> strategies.getAllowList().test(sv.getOriginalVersionWithMeta())) - .filter(sv -> strategies.getDenyList().negate().test(sv.getOriginalVersionWithMeta())) .filter(v -> unsuffixedQuery.equals(v.unsuffixedVesion())) .collect(Collectors.toList()); @@ -135,6 +132,8 @@ public Optional findBiggestMatchingVersion(String query, Collection getMavenVersions(GA ga, LookupMode mode, Set lookupBestMatchMaven( } private static Set compileMavenStrategies(Set strategies) { - if (strategies == null) { - return Collections.emptySet(); - } - return strategies.stream().map(CompiledGAVStrategy::from).collect(Collectors.toSet()); + return strategies == null ? Set.of() + : strategies.stream().map(CompiledGAVStrategy::from).collect(Collectors.toSet()); } private static Set extractQualifiers(Set> strategies) { @@ -261,7 +259,7 @@ private VersionAnalyzer chooseVa( return Integer.compare(sim1, sim2); }); - if (max.map(k -> k.matchSignificance(artifact)).orElse(0) != 0) { + if (max.isPresent() && max.get().matchSignificance(artifact) != 0) { return vas.get(max.get()); } diff --git a/reports-model/src/main/java/org/jboss/da/model/rest/Strategy.java b/reports-model/src/main/java/org/jboss/da/model/rest/Strategy.java index b007742d2..edede17d8 100644 --- a/reports-model/src/main/java/org/jboss/da/model/rest/Strategy.java +++ b/reports-model/src/main/java/org/jboss/da/model/rest/Strategy.java @@ -1,14 +1,20 @@ package org.jboss.da.model.rest; +import lombok.AllArgsConstructor; import lombok.Builder; -import lombok.Value; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.ToString; import lombok.extern.jackson.Jacksonized; import java.util.List; +@AllArgsConstructor +@Getter @Builder @Jacksonized -@Value +@ToString +@EqualsAndHashCode public class Strategy { private final String artifactScope; From 11beb927dc8496c08d4b224391ab21303fd728b0 Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Fri, 13 Feb 2026 17:03:15 +0000 Subject: [PATCH 09/26] Revert "[Alignment 2.0] rename Constraints to Strategy for consistency" This reverts commit ec0423489caccbaa39050db7a0c92fb37d5ee8c2. --- ...Strategy.java => CompiledConstraints.java} | 14 +++---- ...ategy.java => CompiledGAVConstraints.java} | 16 ++++---- .../da/common/version/VersionAnalyzer.java | 22 +++++----- .../jboss/da/reports/api/LookupGenerator.java | 4 +- .../da/reports/impl/LookupGeneratorImpl.java | 40 +++++++++---------- .../da/lookup/model/MavenLookupRequest.java | 4 +- .../rest/{Strategy.java => Constraints.java} | 2 +- .../java/org/jboss/da/rest/LookupImpl.java | 2 +- 8 files changed, 52 insertions(+), 52 deletions(-) rename common/src/main/java/org/jboss/da/common/{CompiledStrategy.java => CompiledConstraints.java} (73%) rename common/src/main/java/org/jboss/da/common/{CompiledGAVStrategy.java => CompiledGAVConstraints.java} (67%) rename reports-model/src/main/java/org/jboss/da/model/rest/{Strategy.java => Constraints.java} (94%) diff --git a/common/src/main/java/org/jboss/da/common/CompiledStrategy.java b/common/src/main/java/org/jboss/da/common/CompiledConstraints.java similarity index 73% rename from common/src/main/java/org/jboss/da/common/CompiledStrategy.java rename to common/src/main/java/org/jboss/da/common/CompiledConstraints.java index c5fecfb9e..541135550 100644 --- a/common/src/main/java/org/jboss/da/common/CompiledStrategy.java +++ b/common/src/main/java/org/jboss/da/common/CompiledConstraints.java @@ -11,7 +11,7 @@ @SuperBuilder @AllArgsConstructor(access = AccessLevel.PROTECTED) -public abstract class CompiledStrategy implements Comparator { +public abstract class CompiledConstraints implements Comparator { @Getter private final String artifactScope; @@ -27,22 +27,22 @@ public abstract class CompiledStrategy implements Comparator { public abstract int matchSignificance(T match); /** - * Returns such strategy that do not alter behaviour of version analysis + * Returns such constraints that do not alter behaviour of version analysis * - * @return strategy that do not affect version analysis + * @return constraint that do not affect version analysis */ - public static CompiledStrategy none() { - return DefaultCompiledStrategy.get(); + public static CompiledConstraints none() { + return DefaultCompiledConstraints.get(); } @SuperBuilder - private static class DefaultCompiledStrategy extends CompiledStrategy { + private static class DefaultCompiledConstraints extends CompiledConstraints { @Override public int matchSignificance(Object match) { return 0; } - private static DefaultCompiledStrategy get() { + private static DefaultCompiledConstraints get() { return builder().artifactScope(null) .ranks(new AlignmentRanking(null, null)) .allowList(new AlignmentPredicate(null, ver -> true)) diff --git a/common/src/main/java/org/jboss/da/common/CompiledGAVStrategy.java b/common/src/main/java/org/jboss/da/common/CompiledGAVConstraints.java similarity index 67% rename from common/src/main/java/org/jboss/da/common/CompiledGAVStrategy.java rename to common/src/main/java/org/jboss/da/common/CompiledGAVConstraints.java index 881114feb..349c458b6 100644 --- a/common/src/main/java/org/jboss/da/common/CompiledGAVStrategy.java +++ b/common/src/main/java/org/jboss/da/common/CompiledGAVConstraints.java @@ -1,19 +1,19 @@ package org.jboss.da.common; import lombok.experimental.SuperBuilder; -import org.jboss.da.model.rest.Strategy; +import org.jboss.da.model.rest.Constraints; import org.jboss.da.model.rest.GAV; import org.jboss.pnc.common.alignment.ranking.AlignmentPredicate; import org.jboss.pnc.common.alignment.ranking.AlignmentRanking; import org.jboss.pnc.common.alignment.ranking.exception.ValidationException; @SuperBuilder -public class CompiledGAVStrategy extends CompiledStrategy { +public class CompiledGAVConstraints extends CompiledConstraints { @Override public int matchSignificance(GAV toMatch) { if (getArtifactScope() == null) { - // Null signifies global scope for a strategy. It has the least significance. + // null signifies global scope and constraints, has the least significance return 1; } @@ -40,11 +40,11 @@ public int matchSignificance(GAV toMatch) { return 0; } - public static CompiledGAVStrategy from(Strategy strategy) throws ValidationException { - return builder().artifactScope(strategy.getArtifactScope()) - .ranks(new AlignmentRanking(strategy.getRanks(), null)) - .allowList(new AlignmentPredicate(strategy.getAllowList(), ver -> true)) - .denyList(new AlignmentPredicate(strategy.getDenyList(), ver -> false)) + public static CompiledGAVConstraints from(Constraints constraints) throws ValidationException { + return builder().artifactScope(constraints.getArtifactScope()) + .ranks(new AlignmentRanking(constraints.getRanks(), null)) + .allowList(new AlignmentPredicate(constraints.getAllowList(), ver -> true)) + .denyList(new AlignmentPredicate(constraints.getDenyList(), ver -> false)) .build(); } } diff --git a/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java b/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java index 50c07151e..05959e6bb 100644 --- a/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java +++ b/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java @@ -15,7 +15,7 @@ */ package org.jboss.da.common.version; -import org.jboss.da.common.CompiledStrategy; +import org.jboss.da.common.CompiledConstraints; import org.jboss.da.lookup.model.VersionDistanceRule; import org.jboss.da.lookup.model.VersionFilter; import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; @@ -61,27 +61,27 @@ public class VersionAnalyzer { private final VersionParser versionParser; private final List suffixes = new ArrayList<>(); private final VersionDistanceRule distanceRule; - private final CompiledStrategy strategies; + private final CompiledConstraints constraints; public VersionAnalyzer(List suffixes) { this(suffixes, VersionDistanceRule.RECOMMENDED_REPLACEMENT); } - public VersionAnalyzer(List suffixes, CompiledStrategy strategies) { - this(suffixes, VersionDistanceRule.RECOMMENDED_REPLACEMENT, strategies); + public VersionAnalyzer(List suffixes, CompiledConstraints constraints) { + this(suffixes, VersionDistanceRule.RECOMMENDED_REPLACEMENT, constraints); } public VersionAnalyzer(List suffixes, VersionDistanceRule distanceRule) { - this(suffixes, distanceRule, CompiledStrategy.none()); + this(suffixes, distanceRule, CompiledConstraints.none()); } - public VersionAnalyzer(List suffixes, VersionDistanceRule distanceRule, CompiledStrategy strategies) { + public VersionAnalyzer(List suffixes, VersionDistanceRule distanceRule, CompiledConstraints constraints) { this.suffixes.addAll(suffixes); this.versionParser = new VersionParser(suffixes); this.distanceRule = Objects.requireNonNull(distanceRule); - this.strategies = Objects.requireNonNull(strategies); + this.constraints = Objects.requireNonNull(constraints); - strategies.getRanks().overrideVersionComparator(this::compareByBuildNumber); + constraints.getRanks().overrideVersionComparator(this::compareByBuildNumber); } // TECHNICALLY NOT NEEDED, THIS IS FOR OLD MAVEN/NPM LOOKUP STUFF ENDPOINTS @@ -132,9 +132,9 @@ public Optional findBiggestMatchingVersion(String query, Collection lookupBestMatchMaven( Set gavs, String mode, boolean brewPullActive, - Set strategies) throws CommunicationException; + Set constraints) throws CommunicationException; Set lookupVersionsMaven( Set gavs, diff --git a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java index 3352f0e91..7753aa890 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java @@ -1,8 +1,8 @@ package org.jboss.da.reports.impl; import org.jboss.da.common.CommunicationException; -import org.jboss.da.common.CompiledStrategy; -import org.jboss.da.common.CompiledGAVStrategy; +import org.jboss.da.common.CompiledConstraints; +import org.jboss.da.common.CompiledGAVConstraints; import org.jboss.da.common.json.LookupMode; import org.jboss.da.common.util.Configuration; import org.jboss.da.common.util.ConfigurationParseException; @@ -15,7 +15,7 @@ import org.jboss.da.lookup.model.NPMVersionsResult; import org.jboss.da.lookup.model.VersionDistanceRule; import org.jboss.da.lookup.model.VersionFilter; -import org.jboss.da.model.rest.Strategy; +import org.jboss.da.model.rest.Constraints; import org.jboss.da.model.rest.GA; import org.jboss.da.model.rest.GAV; import org.jboss.da.model.rest.NPMPackage; @@ -87,32 +87,32 @@ public Set lookupBestMatchMaven( Set gavs, String mode, boolean brewPullActive, - Set strategies) throws CommunicationException, ValidationException { + Set constraints) throws CommunicationException, ValidationException { LookupMode lookupMode = getMode(mode, false); - Set compiledStrategies = compileMavenStrategies(strategies); + Set compiledConstraints = compileMavenConstraints(constraints); ProductProvider productProvider = setupProductProvider( brewPullActive, lookupMode, - extractQualifiers(compiledStrategies)); + extractQualifiers(compiledConstraints)); Map>> productArtifacts = getArtifactVersions( productProvider, gavs, true); - return createLookupResult(gavs, lookupMode, productArtifacts, compiledStrategies); + return createLookupResult(gavs, lookupMode, productArtifacts, compiledConstraints); } - private static Set compileMavenStrategies(Set strategies) { - return strategies == null ? Set.of() - : strategies.stream().map(CompiledGAVStrategy::from).collect(Collectors.toSet()); + private static Set compileMavenConstraints(Set constraints) { + return constraints == null ? Set.of() + : constraints.stream().map(CompiledGAVConstraints::from).collect(Collectors.toSet()); } - private static Set extractQualifiers(Set> strategies) { + private static Set extractQualifiers(Set> constraints) { Set allTokens = new HashSet<>(); - for (var strategy : strategies) { - AlignmentRanking ranks = strategy.getRanks(); - AlignmentPredicate allow = strategy.getAllowList(); - AlignmentPredicate deny = strategy.getDenyList(); + for (var constraint : constraints) { + AlignmentRanking ranks = constraint.getRanks(); + AlignmentPredicate allow = constraint.getAllowList(); + AlignmentPredicate deny = constraint.getDenyList(); allTokens.addAll(ranks.getRanksAsTokens().stream().flatMap(Collection::stream).collect(Collectors.toSet())); allTokens.addAll(allow.getTokens()); allTokens.addAll(deny.getTokens()); @@ -224,11 +224,11 @@ private Set createLookupResult( Set gavs, LookupMode mode, Map>> artifactsMap, - Set compiledStrategies) throws CommunicationException { + Set compiledConstraints) throws CommunicationException { - Map, VersionAnalyzer> vas = compiledStrategies.stream() + Map, VersionAnalyzer> vas = compiledConstraints.stream() .collect(Collectors.toMap(Function.identity(), con -> new VersionAnalyzer(mode.getSuffixes(), con))); - VersionAnalyzer def = new VersionAnalyzer(mode.getSuffixes(), CompiledStrategy.none()); + VersionAnalyzer def = new VersionAnalyzer(mode.getSuffixes(), CompiledConstraints.none()); Set> futures = gavs.stream() .map( @@ -244,14 +244,14 @@ private Set createLookupResult( * (matchSignificance is 0), return a default VersionAnalyzer. * * @param artifact an artifact (GAV or NPM) - * @param vas Map of Strategies and VAs + * @param vas Map of Constraints and VAs * @param def default VA to return * @return closest VA or default VA on empty map or no match * @param GAV or NPM */ private VersionAnalyzer chooseVa( T artifact, - Map, VersionAnalyzer> vas, + Map, VersionAnalyzer> vas, VersionAnalyzer def) { var max = vas.keySet().stream().max((cc1, cc2) -> { int sim1 = cc1.matchSignificance(artifact); diff --git a/reports-model/src/main/java/org/jboss/da/lookup/model/MavenLookupRequest.java b/reports-model/src/main/java/org/jboss/da/lookup/model/MavenLookupRequest.java index b167b3260..4f0bd6a06 100644 --- a/reports-model/src/main/java/org/jboss/da/lookup/model/MavenLookupRequest.java +++ b/reports-model/src/main/java/org/jboss/da/lookup/model/MavenLookupRequest.java @@ -8,7 +8,7 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; -import org.jboss.da.model.rest.Strategy; +import org.jboss.da.model.rest.Constraints; import org.jboss.da.model.rest.GAV; import java.util.Set; @@ -25,7 +25,7 @@ public class MavenLookupRequest { @NonNull private final String mode; - private final Set strategies; + private final Set constraints; @JsonProperty(defaultValue = "false") private final boolean brewPullActive; diff --git a/reports-model/src/main/java/org/jboss/da/model/rest/Strategy.java b/reports-model/src/main/java/org/jboss/da/model/rest/Constraints.java similarity index 94% rename from reports-model/src/main/java/org/jboss/da/model/rest/Strategy.java rename to reports-model/src/main/java/org/jboss/da/model/rest/Constraints.java index edede17d8..cb4cb716d 100644 --- a/reports-model/src/main/java/org/jboss/da/model/rest/Strategy.java +++ b/reports-model/src/main/java/org/jboss/da/model/rest/Constraints.java @@ -15,7 +15,7 @@ @Jacksonized @ToString @EqualsAndHashCode -public class Strategy { +public class Constraints { private final String artifactScope; diff --git a/reports-rest/src/main/java/org/jboss/da/rest/LookupImpl.java b/reports-rest/src/main/java/org/jboss/da/rest/LookupImpl.java index 4f35d4c4b..ee83e6417 100644 --- a/reports-rest/src/main/java/org/jboss/da/rest/LookupImpl.java +++ b/reports-rest/src/main/java/org/jboss/da/rest/LookupImpl.java @@ -41,7 +41,7 @@ public Set lookupMaven(@SpanAttribute(value = "request") Mave request.getArtifacts(), request.getMode(), request.isBrewPullActive(), - request.getStrategies()); + request.getConstraints()); log.info("Request to /lookup/maven completed successfully. Payload: " + request.toString()); return result; } From 3e51bf6c3c6d161ba30405d7b2d4bbb7499432fa Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Fri, 13 Feb 2026 17:03:16 +0000 Subject: [PATCH 10/26] Revert "bump pnc-api to 2.5.0-SNAPSHOT" This reverts commit 56f0d3d40dbfacdaa8b8fcc003148c36a7f8a4ed. --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 7dc215fd5..b78663c50 100644 --- a/pom.xml +++ b/pom.xml @@ -83,7 +83,7 @@ 1 2.5.0-SNAPSHOT 2.4.0-SNAPSHOT - 2.5.0-SNAPSHOT + 2.4.5-SNAPSHOT 0.13.4 0.12.2 11 From 6b275968ca8a873f17fc0143ba37e7ce381f31e3 Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Fri, 13 Feb 2026 17:03:17 +0000 Subject: [PATCH 11/26] Revert "[Alignment 2.0] rename Version pnc-api dto to QualifiedVersion" This reverts commit 897464ab6d6ac7fb1eca689920dc0da4613c9d5b. --- .../da/common/version/SuffixedVersion.java | 17 ++---- .../da/common/version/VersionAnalyzer.java | 6 +- .../da/common/version/VersionParser.java | 24 ++++---- .../common/version/VersionAnalyzerTest.java | 6 +- .../da/communication/pnc/PncConnector.java | 6 +- .../communication/pnc/PncConnectorImpl.java | 15 +++-- pom.xml | 2 +- .../da/products/api/ProductProvider.java | 6 +- .../impl/AbstractProductProvider.java | 17 +++--- .../impl/AggregatedProductProvider.java | 6 +- .../impl/DatabaseProductProvider.java | 10 ++-- .../da/products/impl/PncProductProvider.java | 10 ++-- .../impl/RepositoryProductProvider.java | 10 ++-- .../da/reports/impl/LookupGeneratorImpl.java | 56 ++++++++----------- .../da/reports/impl/ReportsGeneratorImpl.java | 6 +- .../da/reports/impl/LookupGeneratorTest.java | 8 +-- .../org/jboss/da/model/rest/Constraints.java | 4 -- 17 files changed, 94 insertions(+), 115 deletions(-) diff --git a/common/src/main/java/org/jboss/da/common/version/SuffixedVersion.java b/common/src/main/java/org/jboss/da/common/version/SuffixedVersion.java index 1c34860d4..4fad5faa2 100644 --- a/common/src/main/java/org/jboss/da/common/version/SuffixedVersion.java +++ b/common/src/main/java/org/jboss/da/common/version/SuffixedVersion.java @@ -17,7 +17,7 @@ import lombok.EqualsAndHashCode; import lombok.Getter; -import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; +import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import java.util.Objects; import java.util.Optional; @@ -42,10 +42,10 @@ public class SuffixedVersion implements Comparable { private final Integer suffixVersion; - private final QualifiedVersion originalVersionWithMeta; + private final Version originalVersionWithMeta; public SuffixedVersion(int major, int minor, int micro, String qualifier, String originalVersion) { - this(major, minor, micro, qualifier, new QualifiedVersion(originalVersion)); + this(major, minor, micro, qualifier, new Version(originalVersion)); } public SuffixedVersion( @@ -56,15 +56,10 @@ public SuffixedVersion( String suffix, int suffixVersion, String originalVersion) { - this(major, minor, micro, qualifier, suffix, suffixVersion, new QualifiedVersion(originalVersion)); + this(major, minor, micro, qualifier, suffix, suffixVersion, new Version(originalVersion)); } - public SuffixedVersion( - int major, - int minor, - int micro, - String qualifier, - QualifiedVersion originalVersionWithMeta) { + public SuffixedVersion(int major, int minor, int micro, String qualifier, Version originalVersionWithMeta) { this.major = major; this.minor = minor; this.micro = micro; @@ -81,7 +76,7 @@ public SuffixedVersion( String qualifier, String suffix, int suffixVersion, - QualifiedVersion originalVersionWithMeta) { + Version originalVersionWithMeta) { if (suffix == null || suffix.isEmpty()) { throw new IllegalArgumentException("Suffix must be provided in this constructor."); } diff --git a/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java b/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java index 05959e6bb..c26208de5 100644 --- a/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java +++ b/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java @@ -18,7 +18,7 @@ import org.jboss.da.common.CompiledConstraints; import org.jboss.da.lookup.model.VersionDistanceRule; import org.jboss.da.lookup.model.VersionFilter; -import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; +import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import java.util.ArrayList; import java.util.Collection; @@ -110,7 +110,7 @@ private boolean matches(VersionComparator vc, SuffixedVersion v, VersionFilter v return ALLOWED_DIFFERENCE.get(vf).contains(difference); } - public Optional findBiggestMatchingVersion(String query, Collection versions) { + public Optional findBiggestMatchingVersion(String query, Collection versions) { String unsuffixedQuery = versionParser.parse(query).unsuffixedVesion(); // IF QUERY==2.3.4.REDHAT-00001 then FILTER ALL versions in 'versions' to have 2.3.4 @@ -135,7 +135,7 @@ public Optional findBiggestMatchingVersion(String query, Collection suffixes) { } public static SuffixedVersion parseUnsuffixed(String version) { - return parseVersion(UNSUFFIXED_PATTERN.matcher(version), new QualifiedVersion(version)); + return parseVersion(UNSUFFIXED_PATTERN.matcher(version), new Version(version)); } /** * Parses the version string and returns the normalized version. * - * @see #parse(QualifiedVersion) for details + * @see #parse(Version) for details * @param version the original string version * @return The normalized version */ public SuffixedVersion parse(String version) { - return parse(new QualifiedVersion(version)); + return parse(new Version(version)); } - public static SuffixedVersion parseUnsuffixed(QualifiedVersion version) { + public static SuffixedVersion parseUnsuffixed(Version version) { return parseVersion(UNSUFFIXED_PATTERN.matcher(version.getVersion()), version); } @@ -71,7 +71,7 @@ public static SuffixedVersion parseUnsuffixed(QualifiedVersion version) { * @return Set of suffixed versions parsable from the version string. */ public Set parseSuffixed(String version) { - return parseSuffixed(new QualifiedVersion(version)); + return parseSuffixed(new Version(version)); } /** @@ -82,7 +82,7 @@ public Set parseSuffixed(String version) { * @param versionWithMeta The original version string with metadata. * @return The normalized version */ - public SuffixedVersion parse(QualifiedVersion versionWithMeta) { + public SuffixedVersion parse(Version versionWithMeta) { SuffixedVersion normalized = parseUnsuffixed(versionWithMeta); int length = normalized.getQualifier().length(); for (SuffixedVersion suffixedVersion : parseSuffixed(versionWithMeta)) { @@ -100,7 +100,7 @@ public SuffixedVersion parse(QualifiedVersion versionWithMeta) { * @param versionWithMeta The version to parse * @return Set of suffixed versions parsable from the version string. */ - public Set parseSuffixed(QualifiedVersion versionWithMeta) { + public Set parseSuffixed(Version versionWithMeta) { Set ret = new HashSet<>(); for (Map.Entry entry : versionPatterns.entrySet()) { String suffix = entry.getKey(); @@ -116,7 +116,7 @@ public Set parseSuffixed(QualifiedVersion versionWithMeta) { return ret; } - private static SuffixedVersion parseVersion(Matcher versionMatcher, QualifiedVersion versionWithMeta) + private static SuffixedVersion parseVersion(Matcher versionMatcher, Version versionWithMeta) throws NumberFormatException, IllegalArgumentException { String version = versionWithMeta.getVersion(); @@ -135,10 +135,8 @@ private static SuffixedVersion parseVersion(Matcher versionMatcher, QualifiedVer return new SuffixedVersion(major, minor, micro, qualifier, versionWithMeta); } - private static SuffixedVersion parseVersion( - Matcher versionMatcher, - QualifiedVersion versionWithMeta, - String parseSuffix) throws NumberFormatException, IllegalArgumentException { + private static SuffixedVersion parseVersion(Matcher versionMatcher, Version versionWithMeta, String parseSuffix) + throws NumberFormatException, IllegalArgumentException { if (!versionMatcher.matches()) { throw new IllegalArgumentException("Version " + versionWithMeta.getVersion() + "is unparsable"); } diff --git a/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java b/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java index 542cd3cce..958d25e06 100644 --- a/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java +++ b/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java @@ -1,7 +1,7 @@ package org.jboss.da.common.version; import org.jboss.da.common.CommunicationException; -import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; +import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import org.junit.Test; import java.util.Arrays; @@ -114,7 +114,7 @@ public void getBestMatchVersionForNonExistingGAV() throws CommunicationException public void getBestMatchVersionForNotBuiltGAV() throws CommunicationException { Optional bmv = versionFinder.findBiggestMatchingVersion( NO_BUILT_VERSION, - All_VERSIONS.stream().map(QualifiedVersion::new).collect(Collectors.toList())); + All_VERSIONS.stream().map(Version::new).collect(Collectors.toList())); assertFalse("Best match version expected to not be present", bmv.isPresent()); } @@ -281,7 +281,7 @@ private void checkBMV(String expectedVersion, String version, String[] versions) private void checkBMV(VersionAnalyzer versionAnalyzer, String expectedVersion, String version, String[] versions) { Optional bmv = versionAnalyzer.findBiggestMatchingVersion( version, - Arrays.stream(versions).map(QualifiedVersion::new).collect(Collectors.toList())); + Arrays.stream(versions).map(Version::new).collect(Collectors.toList())); assertTrue("Best match version expected to be present", bmv.isPresent()); assertEquals(expectedVersion, bmv.get()); diff --git a/communication/src/main/java/org/jboss/da/communication/pnc/PncConnector.java b/communication/src/main/java/org/jboss/da/communication/pnc/PncConnector.java index beb7c8f29..1b19d2241 100644 --- a/communication/src/main/java/org/jboss/da/communication/pnc/PncConnector.java +++ b/communication/src/main/java/org/jboss/da/communication/pnc/PncConnector.java @@ -3,7 +3,7 @@ import org.jboss.da.common.json.LookupMode; import org.jboss.da.communication.repository.api.RepositoryException; import org.jboss.da.model.rest.GA; -import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; +import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import org.jboss.pnc.dto.requests.QValue; import java.util.List; @@ -18,7 +18,7 @@ public interface PncConnector { * @return list of available versions for given groupId:artifactId in repository, never {@code null} * @throws RepositoryException When there is problem with communication. */ - List getMavenVersions(GA ga, LookupMode mode, Set qualifiers) throws RepositoryException; + List getMavenVersions(GA ga, LookupMode mode, Set qualifiers) throws RepositoryException; /** * Finds available versions for given npm package. @@ -28,7 +28,7 @@ public interface PncConnector { * @return list of available versions for package in repository, never {@code null} * @throws RepositoryException When there is problem with communication. */ - List getNpmVersions(String packageName, LookupMode mode, Set qualifiers) + List getNpmVersions(String packageName, LookupMode mode, Set qualifiers) throws RepositoryException; } diff --git a/communication/src/main/java/org/jboss/da/communication/pnc/PncConnectorImpl.java b/communication/src/main/java/org/jboss/da/communication/pnc/PncConnectorImpl.java index 77e5493e0..e20b48515 100644 --- a/communication/src/main/java/org/jboss/da/communication/pnc/PncConnectorImpl.java +++ b/communication/src/main/java/org/jboss/da/communication/pnc/PncConnectorImpl.java @@ -5,7 +5,7 @@ import org.jboss.da.common.util.ConfigurationParseException; import org.jboss.da.communication.repository.api.RepositoryException; import org.jboss.da.model.rest.GA; -import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; +import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import org.jboss.pnc.client.ArtifactClient; import org.jboss.pnc.client.Configuration; import org.jboss.pnc.client.RemoteCollection; @@ -76,17 +76,16 @@ private Collection getArtifacts( } @Override - public List getMavenVersions(GA ga, LookupMode mode, Set qualifiers) - throws RepositoryException { + public List getMavenVersions(GA ga, LookupMode mode, Set qualifiers) throws RepositoryException { String identifierPattern = ga.getGroupId() + ':' + ga.getArtifactId() + ":pom:*"; Collection arts = getArtifacts(identifierPattern, RepositoryType.MAVEN, mode, qualifiers); - List versions = new ArrayList<>(arts.size()); + List versions = new ArrayList<>(arts.size()); for (ArtifactInfo art : arts) { String[] parts = art.getIdentifier().split(":"); if (parts.length == 4) { // TODO filtering by target repository if necessary - versions.add(new QualifiedVersion(parts[3], art.getQualifiers())); + versions.add(new Version(parts[3], art.getQualifiers())); log.error("Cannot read version for artifact with identifier {}", art.getIdentifier()); } } @@ -94,17 +93,17 @@ public List getMavenVersions(GA ga, LookupMode mode, Set getNpmVersions(String packageName, LookupMode mode, Set qualifiers) + public List getNpmVersions(String packageName, LookupMode mode, Set qualifiers) throws RepositoryException { String identifierPattern = packageName + ":*"; Collection arts = getArtifacts(identifierPattern, RepositoryType.NPM, mode, qualifiers); - List versions = new ArrayList<>(arts.size()); + List versions = new ArrayList<>(arts.size()); for (ArtifactInfo art : arts) { String[] parts = art.getIdentifier().split(":"); if (parts.length == 2) { // TODO filtering by target repository if necessary - versions.add(new QualifiedVersion(parts[1], art.getQualifiers())); + versions.add(new Version(parts[1], art.getQualifiers())); } else { log.error("Cannot read version for artifact with identifier {}", art.getIdentifier()); } diff --git a/pom.xml b/pom.xml index b78663c50..e8c58592e 100644 --- a/pom.xml +++ b/pom.xml @@ -82,7 +82,7 @@ 1 1 2.5.0-SNAPSHOT - 2.4.0-SNAPSHOT + 2.3.0-SNAPSHOT 2.4.5-SNAPSHOT 0.13.4 0.12.2 diff --git a/reports-backend/src/main/java/org/jboss/da/products/api/ProductProvider.java b/reports-backend/src/main/java/org/jboss/da/products/api/ProductProvider.java index e91452e1e..885dca6e8 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/api/ProductProvider.java +++ b/reports-backend/src/main/java/org/jboss/da/products/api/ProductProvider.java @@ -1,7 +1,7 @@ package org.jboss.da.products.api; import org.jboss.da.listings.model.ProductSupportStatus; -import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; +import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import java.util.Map; import java.util.Set; @@ -73,7 +73,7 @@ public interface ProductProvider { * @param artifact artifact which name and type will be used for searching. * @return Set of products and their artifacts versions. */ - CompletableFuture>> getVersions(Artifact artifact); + CompletableFuture>> getVersions(Artifact artifact); /** * Get all artifacts versions with the same name and type as given artifact regardless if they are from product or @@ -82,5 +82,5 @@ public interface ProductProvider { * @param artifact artifact which name and type will be used for searching. * @return Set of artifacts versions. */ - CompletableFuture> getAllVersions(Artifact artifact); + CompletableFuture> getAllVersions(Artifact artifact); } diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/AbstractProductProvider.java b/reports-backend/src/main/java/org/jboss/da/products/impl/AbstractProductProvider.java index 97fe84f25..fd68bcf58 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/impl/AbstractProductProvider.java +++ b/reports-backend/src/main/java/org/jboss/da/products/impl/AbstractProductProvider.java @@ -23,7 +23,8 @@ import org.jboss.da.products.api.Product; import org.jboss.da.products.api.ProductArtifacts; import org.jboss.da.products.api.ProductProvider; -import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; +import org.jboss.pnc.api.dependencyanalyzer.dto.Version; +import org.jboss.pnc.dto.requests.QValue; import org.jboss.pnc.enums.ArtifactQuality; import org.jboss.pnc.enums.BuildCategory; import org.slf4j.Logger; @@ -110,18 +111,18 @@ public CompletableFuture> getArtifacts(Artifact artifact, } @Override - public CompletableFuture>> getVersions(Artifact artifact) { + public CompletableFuture>> getVersions(Artifact artifact) { switch (artifact.getType()) { case MAVEN: { GA ga = ((MavenArtifact) artifact).getGav().getGA(); - CompletableFuture> versions = supplyAsync( + CompletableFuture> versions = supplyAsync( () -> getVersionsStreamMaven(ga).filter(v -> versionParser.parse(v.getVersion()).isSuffixed()) .distinct() .collect(Collectors.toSet())); return versions.thenApply(rv -> Collections.singletonMap(Product.UNKNOWN, rv)); } case NPM: { - CompletableFuture> versions = supplyAsync( + CompletableFuture> versions = supplyAsync( () -> getVersionsStreamNPM(artifact.getName()) .filter(v -> versionParser.parse(v.getVersion()).isSuffixed()) .distinct() @@ -135,7 +136,7 @@ public CompletableFuture>> getVersions(Artifa } @Override - public CompletableFuture> getAllVersions(Artifact artifact) { + public CompletableFuture> getAllVersions(Artifact artifact) { switch (artifact.getType()) { case MAVEN: { GA ga = ((MavenArtifact) artifact).getGav().getGA(); @@ -166,7 +167,7 @@ private CompletableFuture> getArtifacts0(Artifact artifact } private Set getArtifactsMaven(GA ga) { - Set allArtifacts = getVersionsStreamMaven(ga).map(QualifiedVersion::getVersion) + Set allArtifacts = getVersionsStreamMaven(ga).map(Version::getVersion) .filter(v -> versionParser.parse(v).isSuffixed()) .distinct() .map(x -> new GAV(ga, x)) @@ -189,8 +190,8 @@ private Set getArtifactsNPM(String name) { return Collections.singleton(new ProductArtifacts(Product.UNKNOWN, allArtifacts)); } - abstract Stream getVersionsStreamMaven(GA ga); + abstract Stream getVersionsStreamMaven(GA ga); - abstract Stream getVersionsStreamNPM(String name); + abstract Stream getVersionsStreamNPM(String name); } diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/AggregatedProductProvider.java b/reports-backend/src/main/java/org/jboss/da/products/impl/AggregatedProductProvider.java index b0e39bfa0..c7965dbf7 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/impl/AggregatedProductProvider.java +++ b/reports-backend/src/main/java/org/jboss/da/products/impl/AggregatedProductProvider.java @@ -9,7 +9,7 @@ import org.jboss.da.products.impl.DatabaseProductProvider.Database; import org.jboss.da.products.impl.RepositoryProductProvider.Repository; import org.jboss.da.products.impl.PncProductProvider.Pnc; -import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; +import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import javax.annotation.Resource; import javax.enterprise.concurrent.ManagedScheduledExecutorService; @@ -112,12 +112,12 @@ public CompletableFuture> getArtifacts(Artifact artifact, } @Override - public CompletableFuture>> getVersions(Artifact artifact) { + public CompletableFuture>> getVersions(Artifact artifact) { return aggregate(x -> x.getVersions(artifact), new MapCol<>(AggregatedProductProvider::combineSets)); } @Override - public CompletableFuture> getAllVersions(Artifact artifact) { + public CompletableFuture> getAllVersions(Artifact artifact) { return aggregate(x -> x.getAllVersions(artifact), new SetCollector<>()); } diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/DatabaseProductProvider.java b/reports-backend/src/main/java/org/jboss/da/products/impl/DatabaseProductProvider.java index 44d84fbce..74c4b6b82 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/impl/DatabaseProductProvider.java +++ b/reports-backend/src/main/java/org/jboss/da/products/impl/DatabaseProductProvider.java @@ -14,7 +14,7 @@ import org.jboss.da.products.api.ProductArtifacts; import org.jboss.da.products.api.ProductProvider; import org.jboss.da.products.impl.DatabaseProductProvider.Database; -import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; +import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import javax.inject.Inject; import javax.inject.Qualifier; @@ -94,7 +94,7 @@ public CompletableFuture> getArtifacts(Artifact artifact, } @Override - public CompletableFuture>> getVersions(Artifact artifact) { + public CompletableFuture>> getVersions(Artifact artifact) { if (artifact.getType() != ArtifactType.MAVEN) { return CompletableFuture.completedFuture(Collections.emptyMap()); } @@ -107,12 +107,12 @@ public CompletableFuture>> getVersions(Artifa x -> x.getArtifacts() .stream() .map(Artifact::getVersion) - .map(QualifiedVersion::new) + .map(Version::new) .collect(Collectors.toSet())))); } @Override - public CompletableFuture> getAllVersions(Artifact artifact) { + public CompletableFuture> getAllVersions(Artifact artifact) { if (artifact.getType() != ArtifactType.MAVEN) { return CompletableFuture.completedFuture(Collections.emptySet()); } @@ -121,7 +121,7 @@ public CompletableFuture> getAllVersions(Artifact artifact () -> getArtifacts(ga.getGroupId(), ga.getArtifactId(), Optional.empty()).stream() .flatMap(a -> a.getArtifacts().stream()) .map(Artifact::getVersion) - .map(QualifiedVersion::new) + .map(Version::new) .collect(Collectors.toSet())); } diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/PncProductProvider.java b/reports-backend/src/main/java/org/jboss/da/products/impl/PncProductProvider.java index b0163a683..a22f75675 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/impl/PncProductProvider.java +++ b/reports-backend/src/main/java/org/jboss/da/products/impl/PncProductProvider.java @@ -4,7 +4,7 @@ import org.jboss.da.communication.pnc.PncConnector; import org.jboss.da.model.rest.GA; import org.jboss.da.products.impl.PncProductProvider.Pnc; -import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; +import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import org.jboss.pnc.dto.requests.QValue; import javax.ejb.TransactionAttribute; @@ -48,14 +48,14 @@ public void setQualifiers(Set qualifiers) { } @Override - Stream getVersionsStreamMaven(GA ga) { + Stream getVersionsStreamMaven(GA ga) { if (!ga.isValid()) { userLog.warn("Received nonvalid GA " + ga + ", using empty list of versions."); log.warn("Received nonvalid GA: " + ga); return Stream.empty(); } try { - List versionsOfGA; + List versionsOfGA; versionsOfGA = pncConnector.getMavenVersions(ga, mode, qualifiers); log.debug("Got versions of " + ga + " from PNC: " + versionsOfGA); return versionsOfGA.stream(); @@ -65,9 +65,9 @@ Stream getVersionsStreamMaven(GA ga) { } @Override - Stream getVersionsStreamNPM(String name) { + Stream getVersionsStreamNPM(String name) { try { - List versionsOfGA; + List versionsOfGA; versionsOfGA = pncConnector.getNpmVersions(name, mode, qualifiers); log.debug("Got versions of " + name + " from PNC: " + versionsOfGA); return versionsOfGA.stream(); diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/RepositoryProductProvider.java b/reports-backend/src/main/java/org/jboss/da/products/impl/RepositoryProductProvider.java index af99c62f9..6120b30e3 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/impl/RepositoryProductProvider.java +++ b/reports-backend/src/main/java/org/jboss/da/products/impl/RepositoryProductProvider.java @@ -4,7 +4,7 @@ import org.jboss.da.communication.indy.api.IndyConnector; import org.jboss.da.model.rest.GA; import org.jboss.da.products.impl.RepositoryProductProvider.Repository; -import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; +import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import javax.ejb.TransactionAttribute; import javax.ejb.TransactionAttributeType; @@ -36,7 +36,7 @@ public class RepositoryProductProvider extends AbstractProductProvider { private IndyConnector indyConnector; @Override - Stream getVersionsStreamMaven(GA ga) { + Stream getVersionsStreamMaven(GA ga) { if (!ga.isValid()) { userLog.warn("Received nonvalid GA " + ga + ", using empty list of versions."); log.warn("Received nonvalid GA: " + ga); @@ -46,19 +46,19 @@ Stream getVersionsStreamMaven(GA ga) { List versionsOfGA; versionsOfGA = indyConnector.getVersionsOfGA(ga); log.debug("Got versions of " + ga + " from repository: " + versionsOfGA); - return versionsOfGA.stream().map(QualifiedVersion::new); + return versionsOfGA.stream().map(Version::new); } catch (CommunicationException ex) { throw new ProductException(ex); } } @Override - Stream getVersionsStreamNPM(String name) { + Stream getVersionsStreamNPM(String name) { try { List versionsOfGA; versionsOfGA = indyConnector.getVersionsOfNpm(name); log.debug("Got versions of " + name + " from repository: " + versionsOfGA); - return versionsOfGA.stream().map(QualifiedVersion::new); + return versionsOfGA.stream().map(Version::new); } catch (CommunicationException ex) { throw new ProductException(ex); } diff --git a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java index 7753aa890..ac0cd6990 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java @@ -27,7 +27,7 @@ import org.jboss.da.products.impl.PncProductProvider; import org.jboss.da.products.impl.RepositoryProductProvider; import org.jboss.da.reports.api.LookupGenerator; -import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; +import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import org.jboss.pnc.common.alignment.ranking.AlignmentPredicate; import org.jboss.pnc.common.alignment.ranking.AlignmentRanking; import org.jboss.pnc.common.alignment.ranking.exception.ValidationException; @@ -95,10 +95,7 @@ public Set lookupBestMatchMaven( brewPullActive, lookupMode, extractQualifiers(compiledConstraints)); - Map>> productArtifacts = getArtifactVersions( - productProvider, - gavs, - true); + Map>> productArtifacts = getArtifactVersions(productProvider, gavs, true); return createLookupResult(gavs, lookupMode, productArtifacts, compiledConstraints); } @@ -134,7 +131,7 @@ public Set lookupVersionsMaven( boolean includeBad) throws CommunicationException { LookupMode lookupMode = getMode(mode, includeBad); ProductProvider productProvider = setupProductProvider(brewPullActive, lookupMode, Set.of()); - Map>> productArtifacts = getArtifactVersions( + Map>> productArtifacts = getArtifactVersions( productProvider, gavs, !includeBad); @@ -145,10 +142,7 @@ public Set lookupVersionsMaven( public Set lookupLatestMaven(Set gavs, String mode) throws CommunicationException { LookupMode lookupMode = getMode(mode, true); ProductProvider productProvider = setupProductProvider(true, lookupMode, Set.of()); - Map>> productArtifacts = getArtifactVersions( - productProvider, - gavs, - false); + Map>> productArtifacts = getArtifactVersions(productProvider, gavs, false); return createLatestResult(gavs, lookupMode, productArtifacts); } @@ -157,7 +151,7 @@ public Set lookupBestMatchNPM(Set packages, String throws CommunicationException { LookupMode lookupMode = getMode(mode, false); pncProductProvider.setLookupMode(lookupMode); - Map>> productArtifacts = getArtifactVersions(packages); + Map>> productArtifacts = getArtifactVersions(packages); return createLookupResultNpm(packages, lookupMode, productArtifacts); } @@ -170,7 +164,7 @@ public Set lookupVersionsNPM( boolean includeBad) throws CommunicationException { LookupMode lookupMode = getMode(mode, includeBad); pncProductProvider.setLookupMode(lookupMode); - Map>> productArtifacts = getArtifactVersions(packages); + Map>> productArtifacts = getArtifactVersions(packages); return createVersionsResultNpm(packages, lookupMode, vf, distanceRule, productArtifacts); } @@ -185,15 +179,15 @@ private ProductProvider setupProductProvider(boolean brewPullActive, LookupMode } } - private Map>> getArtifactVersions( + private Map>> getArtifactVersions( ProductProvider productProvider, Set gavs, boolean filterBlacklisted) { - Map>> ret = new HashMap<>(); + Map>> ret = new HashMap<>(); Set distinctGAs = gavs.stream().map(GAV::getGA).collect(Collectors.toSet()); for (GA ga : distinctGAs) { MavenArtifact mavenArtifact = new MavenArtifact(new GAV(ga, "0.0.0")); - CompletableFuture> versions = productProvider.getAllVersions(mavenArtifact); + CompletableFuture> versions = productProvider.getAllVersions(mavenArtifact); if (filterBlacklisted) { versions = filterBlacklistedArtifacts(versions, ga); } @@ -202,7 +196,7 @@ private Map>> getArtifactVersions( return ret; } - private Map>> getArtifactVersions(Set packages) { + private Map>> getArtifactVersions(Set packages) { return packages.stream() .map(NPMPackage::getName) .distinct() @@ -210,10 +204,10 @@ private Map>> getArtifactVersion .collect(Collectors.toMap(Artifact::getName, pncProductProvider::getAllVersions)); } - private CompletableFuture> filterBlacklistedArtifacts( - CompletableFuture> versions, + private CompletableFuture> filterBlacklistedArtifacts( + CompletableFuture> versions, GA ga) { - Predicate isNotBlacklisted = version -> { + Predicate isNotBlacklisted = version -> { GAV gav = new GAV(ga, version.getVersion()); return !blackArtifactService.isArtifactPresent(gav); }; @@ -223,7 +217,7 @@ private CompletableFuture> filterBlacklistedArtifacts( private Set createLookupResult( Set gavs, LookupMode mode, - Map>> artifactsMap, + Map>> artifactsMap, Set compiledConstraints) throws CommunicationException { Map, VersionAnalyzer> vas = compiledConstraints.stream() @@ -271,17 +265,14 @@ private Set createVersionsResult( LookupMode mode, VersionFilter vf, VersionDistanceRule distanceRule, - Map>> artifactsMap) throws CommunicationException { + Map>> artifactsMap) throws CommunicationException { VersionAnalyzer va = new VersionAnalyzer(mode.getSuffixes(), distanceRule); Set> futures = gavs.stream() .map( gav -> artifactsMap.get(gav.getGA()) - .thenApply( - pas -> pas.stream() - .map(QualifiedVersion::getVersion) - .collect(Collectors.toSet())) + .thenApply(pas -> pas.stream().map(Version::getVersion).collect(Collectors.toSet())) .thenApply(pas -> getMatchingVersions(va, vf, gav, pas))) .collect(Collectors.toSet()); @@ -291,7 +282,7 @@ private Set createVersionsResult( private Set createLatestResult( Set gavs, LookupMode mode, - Map>> artifactsMap) throws CommunicationException { + Map>> artifactsMap) throws CommunicationException { VersionAnalyzer va = new VersionAnalyzer(Collections.singletonList(mode.getIncrementSuffix())); @@ -305,7 +296,7 @@ private Set createLatestResult( private Set createLookupResultNpm( Set packages, LookupMode mode, - Map>> artifactsMap) throws CommunicationException { + Map>> artifactsMap) throws CommunicationException { VersionAnalyzer va = new VersionAnalyzer(mode.getSuffixes()); Set> futures = packages.stream() @@ -320,26 +311,25 @@ private Set createVersionsResultNpm( LookupMode mode, VersionFilter vf, VersionDistanceRule distanceRule, - Map>> artifactsMap) throws CommunicationException { + Map>> artifactsMap) throws CommunicationException { VersionAnalyzer va = new VersionAnalyzer(mode.getSuffixes(), distanceRule); Set> futures = packages.stream() .map( pkg -> artifactsMap.get(pkg.getName()) - .thenApply( - f -> f.stream().map(QualifiedVersion::getVersion).collect(Collectors.toSet())) + .thenApply(f -> f.stream().map(Version::getVersion).collect(Collectors.toSet())) .thenApply(f -> getMatchingVersions(va, vf, pkg, f))) .collect(Collectors.toSet()); return joinFutures(futures); } - private MavenLookupResult getLookupResult(VersionAnalyzer va, GAV gav, Set versions) { + private MavenLookupResult getLookupResult(VersionAnalyzer va, GAV gav, Set versions) { Optional bmv = va.findBiggestMatchingVersion(gav.getVersion(), versions); return new MavenLookupResult(gav, bmv.orElse(null)); } - private MavenLatestResult getLatestResult(VersionAnalyzer va, GAV gav, Set versions) { + private MavenLatestResult getLatestResult(VersionAnalyzer va, GAV gav, Set versions) { Optional bmv = va.findBiggestMatchingVersion(gav.getVersion(), versions); return new MavenLatestResult(gav, bmv.orElse(null)); } @@ -362,7 +352,7 @@ private NPMVersionsResult getMatchingVersions( return new NPMVersionsResult(pkg, availableVersions); } - private NPMLookupResult getLookupResult(VersionAnalyzer va, NPMPackage pkg, Set versions) { + private NPMLookupResult getLookupResult(VersionAnalyzer va, NPMPackage pkg, Set versions) { Optional bmv = va.findBiggestMatchingVersion(pkg.getVersion(), versions); return new NPMLookupResult(pkg, bmv.orElse(null)); } diff --git a/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java b/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java index 5103ea8db..3073fb7dc 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java @@ -52,7 +52,7 @@ import org.jboss.da.reports.model.response.NPMVersionsReport; import org.jboss.da.scm.api.SCM; import org.jboss.da.scm.api.SCMType; -import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; +import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import org.jboss.pnc.enums.ArtifactQuality; import org.jboss.pnc.enums.BuildCategory; import org.slf4j.Logger; @@ -231,7 +231,7 @@ private CompletableFuture analyzeVersions( Optional bmv = va.findBiggestMatchingVersion( version, - versions.stream().map(QualifiedVersion::new).collect(Collectors.toList())); + versions.stream().map(Version::new).collect(Collectors.toList())); List sortedVersions = va.sortVersions(version, versions); return new VersionAnalysisResult(bmv, sortedVersions); @@ -534,7 +534,7 @@ public List getVersionsReports(VersionsNPMRequest request) th Map>> artifactsMap = new HashMap<>(); for (String name : uniqueNames) { CompletableFuture> artifacts = productProvider.getAllVersions(new NPMArtifact(name, "0.0.0")) - .thenApply(s -> s.stream().map(QualifiedVersion::getVersion).collect(Collectors.toSet())); + .thenApply(s -> s.stream().map(Version::getVersion).collect(Collectors.toSet())); artifactsMap.put(name, artifacts); } diff --git a/reports-backend/src/test/java/org/jboss/da/reports/impl/LookupGeneratorTest.java b/reports-backend/src/test/java/org/jboss/da/reports/impl/LookupGeneratorTest.java index bd87cd372..905a88c42 100644 --- a/reports-backend/src/test/java/org/jboss/da/reports/impl/LookupGeneratorTest.java +++ b/reports-backend/src/test/java/org/jboss/da/reports/impl/LookupGeneratorTest.java @@ -17,7 +17,7 @@ import org.jboss.da.products.impl.PncProductProvider; import org.jboss.da.products.impl.RepositoryProductProvider; import org.jboss.da.reports.api.LookupGenerator; -import org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion; +import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; @@ -32,7 +32,7 @@ import java.util.Set; import java.util.concurrent.CompletableFuture; -import static org.jboss.pnc.api.dependencyanalyzer.dto.QualifiedVersion.of; +import static org.jboss.pnc.api.dependencyanalyzer.dto.Version.of; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNull; import static org.mockito.Matchers.eq; @@ -114,12 +114,12 @@ public void testNpm() throws CommunicationException { assertNull(result2.getBestMatchVersion()); } - private void preparePnc(GA ga, List versions) { + private void preparePnc(GA ga, List versions) { when(pncProductProvider.getAllVersions(eq(new MavenArtifact(new GAV(ga, "0.0.0"))))) .thenReturn(CompletableFuture.completedFuture(new HashSet<>(versions))); } - private void preparePnc(String name, List versions) { + private void preparePnc(String name, List versions) { when(pncProductProvider.getAllVersions(eq(new NPMArtifact(name, "0.0.0")))) .thenReturn(CompletableFuture.completedFuture(new HashSet<>(versions))); } diff --git a/reports-model/src/main/java/org/jboss/da/model/rest/Constraints.java b/reports-model/src/main/java/org/jboss/da/model/rest/Constraints.java index cb4cb716d..2efa18eb6 100644 --- a/reports-model/src/main/java/org/jboss/da/model/rest/Constraints.java +++ b/reports-model/src/main/java/org/jboss/da/model/rest/Constraints.java @@ -2,9 +2,7 @@ import lombok.AllArgsConstructor; import lombok.Builder; -import lombok.EqualsAndHashCode; import lombok.Getter; -import lombok.ToString; import lombok.extern.jackson.Jacksonized; import java.util.List; @@ -13,8 +11,6 @@ @Getter @Builder @Jacksonized -@ToString -@EqualsAndHashCode public class Constraints { private final String artifactScope; From f941c6e04b3ef06976f925a483e8681271ac16d0 Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Fri, 13 Feb 2026 17:03:19 +0000 Subject: [PATCH 12/26] Revert "rollback reports-model module to Java 8" This reverts commit 372a71e62acd8ad51bec75feba694a1dffdac031. --- reports-model/pom.xml | 5 ----- 1 file changed, 5 deletions(-) diff --git a/reports-model/pom.xml b/reports-model/pom.xml index 39e55c9fc..b31d6011a 100644 --- a/reports-model/pom.xml +++ b/reports-model/pom.xml @@ -8,11 +8,6 @@ reports-model reports-model ejb - - - 1.8 - 1.8 - com.fasterxml.jackson.core From 96057fac75ad9a8cd227931a394ab5023da10850 Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Fri, 13 Feb 2026 17:03:20 +0000 Subject: [PATCH 13/26] Revert "remove unnecessary API change" This reverts commit 3eb562b62abe1a6224bae418ad594fdb01b99fbd. --- .../main/java/org/jboss/da/reports/api/LookupGenerator.java | 3 ++- .../java/org/jboss/da/reports/impl/LookupGeneratorImpl.java | 2 +- .../java/org/jboss/da/reports/impl/LookupGeneratorTest.java | 2 +- reports-rest/src/main/java/org/jboss/da/rest/LookupImpl.java | 3 ++- 4 files changed, 6 insertions(+), 4 deletions(-) diff --git a/reports-backend/src/main/java/org/jboss/da/reports/api/LookupGenerator.java b/reports-backend/src/main/java/org/jboss/da/reports/api/LookupGenerator.java index 062d340b9..3841d7b0f 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/api/LookupGenerator.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/api/LookupGenerator.java @@ -32,7 +32,8 @@ Set lookupVersionsMaven( Set lookupLatestMaven(Set gavs, String mode) throws CommunicationException; - Set lookupBestMatchNPM(Set packages, String mode) throws CommunicationException; + Set lookupBestMatchNPM(Set packages, String mode, Set constraints) + throws CommunicationException; Set lookupVersionsNPM( Set packages, diff --git a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java index ac0cd6990..626d0ad26 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java @@ -147,7 +147,7 @@ public Set lookupLatestMaven(Set gavs, String mode) thro } @Override - public Set lookupBestMatchNPM(Set packages, String mode) + public Set lookupBestMatchNPM(Set packages, String mode, Set constraints) throws CommunicationException { LookupMode lookupMode = getMode(mode, false); pncProductProvider.setLookupMode(lookupMode); diff --git a/reports-backend/src/test/java/org/jboss/da/reports/impl/LookupGeneratorTest.java b/reports-backend/src/test/java/org/jboss/da/reports/impl/LookupGeneratorTest.java index 905a88c42..8f62f16fc 100644 --- a/reports-backend/src/test/java/org/jboss/da/reports/impl/LookupGeneratorTest.java +++ b/reports-backend/src/test/java/org/jboss/da/reports/impl/LookupGeneratorTest.java @@ -105,7 +105,7 @@ public void testNpm() throws CommunicationException { gavs.add(gav1); gavs.add(gav2); - Set results = lookupGenerator.lookupBestMatchNPM(gavs, PERSISTENT); + Set results = lookupGenerator.lookupBestMatchNPM(gavs, PERSISTENT, Set.of()); assertEquals(2, results.size()); NPMLookupResult result1 = results.stream().filter(r -> gav1.equals(r.getNpmPackage())).findFirst().get(); diff --git a/reports-rest/src/main/java/org/jboss/da/rest/LookupImpl.java b/reports-rest/src/main/java/org/jboss/da/rest/LookupImpl.java index ee83e6417..4aed654c4 100644 --- a/reports-rest/src/main/java/org/jboss/da/rest/LookupImpl.java +++ b/reports-rest/src/main/java/org/jboss/da/rest/LookupImpl.java @@ -78,7 +78,8 @@ public Set lookupMaven(@SpanAttribute(value = "request") Mave public Set lookupNPM(@SpanAttribute(value = "request") NPMLookupRequest request) throws CommunicationException { log.info("Incoming request to /lookup/npm. Payload: " + request.toString()); - Set result = lookupGenerator.lookupBestMatchNPM(request.getPackages(), request.getMode()); + Set result = lookupGenerator + .lookupBestMatchNPM(request.getPackages(), request.getMode(), Set.of()); log.info("Request to /lookup/npm completed successfully. Payload: " + request.toString()); return result; } From 952a4f32ef6800c4e862169b3754270fa072bb36 Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Fri, 13 Feb 2026 17:03:21 +0000 Subject: [PATCH 14/26] Revert "[Alignment 2.0] use Qualifiers for Version ranking and filtering" This reverts commit d2cf31b7719ba1173d92c717508b33d30b5bacf3. --- .../jboss/da/common/CompiledConstraints.java | 58 ---------- .../da/common/CompiledGAVConstraints.java | 50 --------- .../da/common/version/VersionAnalyzer.java | 88 +++------------ .../da/products/impl/PncProductProvider.java | 13 --- .../jboss/da/reports/api/LookupGenerator.java | 11 +- .../da/reports/impl/LookupGeneratorImpl.java | 102 +++--------------- .../da/lookup/model/MavenLookupRequest.java | 3 - .../org/jboss/da/model/rest/Constraints.java | 23 ---- .../java/org/jboss/da/rest/LookupImpl.java | 10 +- .../rest/exceptions/AllExceptionsMapper.java | 3 - 10 files changed, 33 insertions(+), 328 deletions(-) delete mode 100644 common/src/main/java/org/jboss/da/common/CompiledConstraints.java delete mode 100644 common/src/main/java/org/jboss/da/common/CompiledGAVConstraints.java delete mode 100644 reports-model/src/main/java/org/jboss/da/model/rest/Constraints.java diff --git a/common/src/main/java/org/jboss/da/common/CompiledConstraints.java b/common/src/main/java/org/jboss/da/common/CompiledConstraints.java deleted file mode 100644 index 541135550..000000000 --- a/common/src/main/java/org/jboss/da/common/CompiledConstraints.java +++ /dev/null @@ -1,58 +0,0 @@ -package org.jboss.da.common; - -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.experimental.SuperBuilder; -import org.jboss.pnc.common.alignment.ranking.AlignmentPredicate; -import org.jboss.pnc.common.alignment.ranking.AlignmentRanking; - -import java.util.Comparator; - -@SuperBuilder -@AllArgsConstructor(access = AccessLevel.PROTECTED) -public abstract class CompiledConstraints implements Comparator { - @Getter - private final String artifactScope; - - @Getter - private final AlignmentRanking ranks; - - @Getter - private final AlignmentPredicate denyList; - - @Getter - private final AlignmentPredicate allowList; - - public abstract int matchSignificance(T match); - - /** - * Returns such constraints that do not alter behaviour of version analysis - * - * @return constraint that do not affect version analysis - */ - public static CompiledConstraints none() { - return DefaultCompiledConstraints.get(); - } - - @SuperBuilder - private static class DefaultCompiledConstraints extends CompiledConstraints { - @Override - public int matchSignificance(Object match) { - return 0; - } - - private static DefaultCompiledConstraints get() { - return builder().artifactScope(null) - .ranks(new AlignmentRanking(null, null)) - .allowList(new AlignmentPredicate(null, ver -> true)) - .denyList(new AlignmentPredicate(null, ver -> false)) - .build(); - } - } - - @Override - public int compare(T o1, T o2) { - return Comparator.comparingInt(this::matchSignificance).compare(o1, o2); - } -} diff --git a/common/src/main/java/org/jboss/da/common/CompiledGAVConstraints.java b/common/src/main/java/org/jboss/da/common/CompiledGAVConstraints.java deleted file mode 100644 index 349c458b6..000000000 --- a/common/src/main/java/org/jboss/da/common/CompiledGAVConstraints.java +++ /dev/null @@ -1,50 +0,0 @@ -package org.jboss.da.common; - -import lombok.experimental.SuperBuilder; -import org.jboss.da.model.rest.Constraints; -import org.jboss.da.model.rest.GAV; -import org.jboss.pnc.common.alignment.ranking.AlignmentPredicate; -import org.jboss.pnc.common.alignment.ranking.AlignmentRanking; -import org.jboss.pnc.common.alignment.ranking.exception.ValidationException; - -@SuperBuilder -public class CompiledGAVConstraints extends CompiledConstraints { - - @Override - public int matchSignificance(GAV toMatch) { - if (getArtifactScope() == null) { - // null signifies global scope and constraints, has the least significance - return 1; - } - - String[] scopeSplit = getArtifactScope().split(":"); - String group = toMatch.getGroupId(); - String artifact = toMatch.getArtifactId(); - String version = toMatch.getVersion(); - - if (scopeSplit.length == 1 && group.equals(scopeSplit[0])) { - // gav matched groupID - return 2; - } - if (scopeSplit.length == 2 && group.equals(scopeSplit[0]) && artifact.equals(scopeSplit[1])) { - // gav matched groupID and artifactID - return 3; - } - if (scopeSplit.length == 3 && group.equals(scopeSplit[0]) && artifact.equals(scopeSplit[1]) - && version.equals(scopeSplit[2])) { - // gav matched groupID, artifactID and version - return 4; - } - - // no match - return 0; - } - - public static CompiledGAVConstraints from(Constraints constraints) throws ValidationException { - return builder().artifactScope(constraints.getArtifactScope()) - .ranks(new AlignmentRanking(constraints.getRanks(), null)) - .allowList(new AlignmentPredicate(constraints.getAllowList(), ver -> true)) - .denyList(new AlignmentPredicate(constraints.getDenyList(), ver -> false)) - .build(); - } -} diff --git a/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java b/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java index c26208de5..624064991 100644 --- a/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java +++ b/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java @@ -15,10 +15,8 @@ */ package org.jboss.da.common.version; -import org.jboss.da.common.CompiledConstraints; import org.jboss.da.lookup.model.VersionDistanceRule; import org.jboss.da.lookup.model.VersionFilter; -import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import java.util.ArrayList; import java.util.Collection; @@ -61,37 +59,23 @@ public class VersionAnalyzer { private final VersionParser versionParser; private final List suffixes = new ArrayList<>(); private final VersionDistanceRule distanceRule; - private final CompiledConstraints constraints; public VersionAnalyzer(List suffixes) { this(suffixes, VersionDistanceRule.RECOMMENDED_REPLACEMENT); } - public VersionAnalyzer(List suffixes, CompiledConstraints constraints) { - this(suffixes, VersionDistanceRule.RECOMMENDED_REPLACEMENT, constraints); - } - public VersionAnalyzer(List suffixes, VersionDistanceRule distanceRule) { - this(suffixes, distanceRule, CompiledConstraints.none()); - } - - public VersionAnalyzer(List suffixes, VersionDistanceRule distanceRule, CompiledConstraints constraints) { this.suffixes.addAll(suffixes); this.versionParser = new VersionParser(suffixes); this.distanceRule = Objects.requireNonNull(distanceRule); - this.constraints = Objects.requireNonNull(constraints); - - constraints.getRanks().overrideVersionComparator(this::compareByBuildNumber); } - // TECHNICALLY NOT NEEDED, THIS IS FOR OLD MAVEN/NPM LOOKUP STUFF ENDPOINTS public List sortVersions(String querry, Collection versions) { VersionComparator comparator = new VersionComparator(querry, distanceRule, versionParser); List sortedVersions = versions.stream().sorted(comparator).distinct().collect(Collectors.toList()); return sortedVersions; } - // NO NEED, USED FOR VERSIONS' ENDPOINTS public List filterVersions(String query, VersionFilter vf, Collection versions) { VersionComparator vc = new VersionComparator(query, distanceRule, versionParser); @@ -113,7 +97,6 @@ private boolean matches(VersionComparator vc, SuffixedVersion v, VersionFilter v public Optional findBiggestMatchingVersion(String query, Collection versions) { String unsuffixedQuery = versionParser.parse(query).unsuffixedVesion(); - // IF QUERY==2.3.4.REDHAT-00001 then FILTER ALL versions in 'versions' to have 2.3.4 List candidateSuffixedVersions = versions.stream() .map(versionParser::parseSuffixed) .flatMap(Set::stream) @@ -130,70 +113,26 @@ public Optional findBiggestMatchingVersion(String query, Collection secondBuildNum) { - return 1; - } - if (firstBuildNum == secondBuildNum) { - return getMoreSpecificVersion(first, second); - } - - return -1; - } - - private static int getMoreSpecificVersion(String first, String second) { - Matcher firstMatcher = VERSION_PATTERN.matcher(first); - Matcher secondMatcher = VERSION_PATTERN.matcher(second); - if (!firstMatcher.matches()) { - throw new IllegalArgumentException("Couldn't parse version " + first); - } - if (!secondMatcher.matches()) { - throw new IllegalArgumentException("Couldn't parse version " + second); + String bestMatchVersion = null; + int biggestBuildNumber = 0; + for (SuffixedVersion ver : versionsToSearch) { + int foundBuildNumber = ver.getSuffixVersion().get(); + if (bestMatchVersion == null || foundBuildNumber > biggestBuildNumber) { + bestMatchVersion = ver.getOriginalVersion(); + biggestBuildNumber = foundBuildNumber; + } else if (foundBuildNumber == biggestBuildNumber) { + bestMatchVersion = getMoreSpecificVersion(bestMatchVersion, ver.getOriginalVersion()); + } } - boolean firstIsOSGi = first.equals(VersionParser.getOSGiVersion(first)); - boolean secondIsOSGi = second.equals(VersionParser.getOSGiVersion(second)); - String firstMinor = firstMatcher.group("minor"); - String firstMicro = firstMatcher.group("micro"); - boolean returnFirst; - if (firstIsOSGi != secondIsOSGi) { - returnFirst = firstIsOSGi; // One of the version is not OSGi, prefer the OSGi version - } else if (!Objects.equals(firstMinor, secondMatcher.group("minor"))) { - returnFirst = firstMinor != null; // One of the versions is missing minor number, prefer the one with it - } else if (!Objects.equals(firstMicro, secondMatcher.group("micro"))) { - returnFirst = firstMicro != null; // One of the versions is missing micro number, prefer the one with it - } else { - // Prefer the version that separates qualifier with '.', not something else like '-' - // If both are the same, prefer first - returnFirst = firstMatcher.group("qualifier").startsWith(".") - || !secondMatcher.group("qualifier").startsWith("."); - } - if (returnFirst) { - return 1; - } else { - return -1; - } + return Optional.ofNullable(bestMatchVersion); } /** * Assuming the two versions have the same OSGi representation, returns the more specific version. That means * X.Y.Z.something is preffered to X.Y.something which is preffered to X.something. */ - private static String getMoreSpecificVersionString(String first, String second) { + private String getMoreSpecificVersion(String first, String second) { Matcher firstMatcher = VERSION_PATTERN.matcher(first); Matcher secondMatcher = VERSION_PATTERN.matcher(second); if (!firstMatcher.matches()) { @@ -203,12 +142,11 @@ private static String getMoreSpecificVersionString(String first, String second) throw new IllegalArgumentException("Couldn't parse version " + second); } boolean firstIsOSGi = first.equals(VersionParser.getOSGiVersion(first)); - boolean secondIsOSGi = second.equals(VersionParser.getOSGiVersion(second)); String firstMinor = firstMatcher.group("minor"); String firstMicro = firstMatcher.group("micro"); boolean returnFirst; - if (firstIsOSGi != secondIsOSGi) { + if (firstIsOSGi != second.equals(VersionParser.getOSGiVersion(second))) { returnFirst = firstIsOSGi; // One of the version is not OSGi, prefer the OSGi version } else if (!Objects.equals(firstMinor, secondMatcher.group("minor"))) { returnFirst = firstMinor != null; // One of the versions is missing minor number, prefer the one with it diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/PncProductProvider.java b/reports-backend/src/main/java/org/jboss/da/products/impl/PncProductProvider.java index a22f75675..e64b11674 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/impl/PncProductProvider.java +++ b/reports-backend/src/main/java/org/jboss/da/products/impl/PncProductProvider.java @@ -4,8 +4,6 @@ import org.jboss.da.communication.pnc.PncConnector; import org.jboss.da.model.rest.GA; import org.jboss.da.products.impl.PncProductProvider.Pnc; -import org.jboss.pnc.api.dependencyanalyzer.dto.Version; -import org.jboss.pnc.dto.requests.QValue; import javax.ejb.TransactionAttribute; import javax.ejb.TransactionAttributeType; @@ -36,17 +34,6 @@ public class PncProductProvider extends AbstractProductProvider { @Inject private PncConnector pncConnector; - private Set qualifiers = Set.of(); - - /** - * Sets what qualifiers should be retrieved from PNC on a request. - * - * @param qualifiers to fetch - */ - public void setQualifiers(Set qualifiers) { - this.qualifiers = qualifiers; - } - @Override Stream getVersionsStreamMaven(GA ga) { if (!ga.isValid()) { diff --git a/reports-backend/src/main/java/org/jboss/da/reports/api/LookupGenerator.java b/reports-backend/src/main/java/org/jboss/da/reports/api/LookupGenerator.java index 3841d7b0f..0479abe29 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/api/LookupGenerator.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/api/LookupGenerator.java @@ -10,17 +10,13 @@ import org.jboss.da.lookup.model.NPMVersionsResult; import org.jboss.da.lookup.model.VersionDistanceRule; import org.jboss.da.lookup.model.VersionFilter; -import org.jboss.da.model.rest.Constraints; import org.jboss.da.model.rest.GAV; import org.jboss.da.model.rest.NPMPackage; public interface LookupGenerator { - Set lookupBestMatchMaven( - Set gavs, - String mode, - boolean brewPullActive, - Set constraints) throws CommunicationException; + Set lookupBestMatchMaven(Set gavs, String mode, boolean brewPullActive) + throws CommunicationException; Set lookupVersionsMaven( Set gavs, @@ -32,8 +28,7 @@ Set lookupVersionsMaven( Set lookupLatestMaven(Set gavs, String mode) throws CommunicationException; - Set lookupBestMatchNPM(Set packages, String mode, Set constraints) - throws CommunicationException; + Set lookupBestMatchNPM(Set packages, String mode) throws CommunicationException; Set lookupVersionsNPM( Set packages, diff --git a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java index 626d0ad26..1404e62a7 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java @@ -1,8 +1,6 @@ package org.jboss.da.reports.impl; import org.jboss.da.common.CommunicationException; -import org.jboss.da.common.CompiledConstraints; -import org.jboss.da.common.CompiledGAVConstraints; import org.jboss.da.common.json.LookupMode; import org.jboss.da.common.util.Configuration; import org.jboss.da.common.util.ConfigurationParseException; @@ -15,7 +13,6 @@ import org.jboss.da.lookup.model.NPMVersionsResult; import org.jboss.da.lookup.model.VersionDistanceRule; import org.jboss.da.lookup.model.VersionFilter; -import org.jboss.da.model.rest.Constraints; import org.jboss.da.model.rest.GA; import org.jboss.da.model.rest.GAV; import org.jboss.da.model.rest.NPMPackage; @@ -27,13 +24,6 @@ import org.jboss.da.products.impl.PncProductProvider; import org.jboss.da.products.impl.RepositoryProductProvider; import org.jboss.da.reports.api.LookupGenerator; -import org.jboss.pnc.api.dependencyanalyzer.dto.Version; -import org.jboss.pnc.common.alignment.ranking.AlignmentPredicate; -import org.jboss.pnc.common.alignment.ranking.AlignmentRanking; -import org.jboss.pnc.common.alignment.ranking.exception.ValidationException; -import org.jboss.pnc.common.alignment.ranking.tokenizer.QualifierToken; -import org.jboss.pnc.common.alignment.ranking.tokenizer.Token; -import org.jboss.pnc.dto.requests.QValue; import org.jboss.pnc.enums.ArtifactQuality; import javax.enterprise.context.ApplicationScoped; @@ -83,42 +73,12 @@ public LookupGeneratorImpl(Configuration config) throws ConfigurationParseExcept } @Override - public Set lookupBestMatchMaven( - Set gavs, - String mode, - boolean brewPullActive, - Set constraints) throws CommunicationException, ValidationException { + public Set lookupBestMatchMaven(Set gavs, String mode, boolean brewPullActive) + throws CommunicationException { LookupMode lookupMode = getMode(mode, false); - Set compiledConstraints = compileMavenConstraints(constraints); - - ProductProvider productProvider = setupProductProvider( - brewPullActive, - lookupMode, - extractQualifiers(compiledConstraints)); - Map>> productArtifacts = getArtifactVersions(productProvider, gavs, true); - return createLookupResult(gavs, lookupMode, productArtifacts, compiledConstraints); - } - - private static Set compileMavenConstraints(Set constraints) { - return constraints == null ? Set.of() - : constraints.stream().map(CompiledGAVConstraints::from).collect(Collectors.toSet()); - } - - private static Set extractQualifiers(Set> constraints) { - Set allTokens = new HashSet<>(); - for (var constraint : constraints) { - AlignmentRanking ranks = constraint.getRanks(); - AlignmentPredicate allow = constraint.getAllowList(); - AlignmentPredicate deny = constraint.getDenyList(); - allTokens.addAll(ranks.getRanksAsTokens().stream().flatMap(Collection::stream).collect(Collectors.toSet())); - allTokens.addAll(allow.getTokens()); - allTokens.addAll(deny.getTokens()); - } - return allTokens.stream() - .filter(token -> token instanceof QualifierToken) - .map(token -> (QualifierToken) token) - .map(qToken -> QValue.valueOf(qToken.toString())) - .collect(Collectors.toSet()); + ProductProvider productProvider = setupProductProvider(brewPullActive, lookupMode); + Map>> productArtifacts = getArtifactVersions(productProvider, gavs, true); + return createLookupResult(gavs, lookupMode, productArtifacts); } @Override @@ -147,7 +107,7 @@ public Set lookupLatestMaven(Set gavs, String mode) thro } @Override - public Set lookupBestMatchNPM(Set packages, String mode, Set constraints) + public Set lookupBestMatchNPM(Set packages, String mode) throws CommunicationException { LookupMode lookupMode = getMode(mode, false); pncProductProvider.setLookupMode(lookupMode); @@ -168,9 +128,8 @@ public Set lookupVersionsNPM( return createVersionsResultNpm(packages, lookupMode, vf, distanceRule, productArtifacts); } - private ProductProvider setupProductProvider(boolean brewPullActive, LookupMode mode, Set qualifiers) { + private ProductProvider setupProductProvider(boolean brewPullActive, LookupMode mode) { pncProductProvider.setLookupMode(mode); - pncProductProvider.setQualifiers(qualifiers); if (brewPullActive) { repositoryProductProvider.setLookupMode(mode); return aggProductProvider; @@ -217,49 +176,17 @@ private CompletableFuture> filterBlacklistedArtifacts( private Set createLookupResult( Set gavs, LookupMode mode, - Map>> artifactsMap, - Set compiledConstraints) throws CommunicationException { + Map>> artifactsMap) throws CommunicationException { - Map, VersionAnalyzer> vas = compiledConstraints.stream() - .collect(Collectors.toMap(Function.identity(), con -> new VersionAnalyzer(mode.getSuffixes(), con))); - VersionAnalyzer def = new VersionAnalyzer(mode.getSuffixes(), CompiledConstraints.none()); + VersionAnalyzer va = new VersionAnalyzer(mode.getSuffixes()); Set> futures = gavs.stream() - .map( - gav -> artifactsMap.get(gav.getGA()) - .thenApply(pas -> getLookupResult(chooseVa(gav, vas, def), gav, pas))) + .map(gav -> artifactsMap.get(gav.getGA()).thenApply(pas -> getLookupResult(va, gav, pas))) .collect(Collectors.toSet()); return joinFutures(futures); } - /** - * Returns VersionAnalyzer with the closest match based on artifact. If map is empty or there was no match - * (matchSignificance is 0), return a default VersionAnalyzer. - * - * @param artifact an artifact (GAV or NPM) - * @param vas Map of Constraints and VAs - * @param def default VA to return - * @return closest VA or default VA on empty map or no match - * @param GAV or NPM - */ - private VersionAnalyzer chooseVa( - T artifact, - Map, VersionAnalyzer> vas, - VersionAnalyzer def) { - var max = vas.keySet().stream().max((cc1, cc2) -> { - int sim1 = cc1.matchSignificance(artifact); - int sim2 = cc2.matchSignificance(artifact); - return Integer.compare(sim1, sim2); - }); - - if (max.isPresent() && max.get().matchSignificance(artifact) != 0) { - return vas.get(max.get()); - } - - return def; - } - private Set createVersionsResult( Set gavs, LookupMode mode, @@ -270,8 +197,7 @@ private Set createVersionsResult( VersionAnalyzer va = new VersionAnalyzer(mode.getSuffixes(), distanceRule); Set> futures = gavs.stream() - .map( - gav -> artifactsMap.get(gav.getGA()) + .map(gav -> artifactsMap.get(gav.getGA()) .thenApply(pas -> pas.stream().map(Version::getVersion).collect(Collectors.toSet())) .thenApply(pas -> getMatchingVersions(va, vf, gav, pas))) .collect(Collectors.toSet()); @@ -315,16 +241,16 @@ private Set createVersionsResultNpm( VersionAnalyzer va = new VersionAnalyzer(mode.getSuffixes(), distanceRule); Set> futures = packages.stream() - .map( - pkg -> artifactsMap.get(pkg.getName()) + .map(pkg -> artifactsMap.get(pkg.getName()) .thenApply(f -> f.stream().map(Version::getVersion).collect(Collectors.toSet())) - .thenApply(f -> getMatchingVersions(va, vf, pkg, f))) + .thenApply(f -> getMatchingVersions(va, vf,pkg,f))) .collect(Collectors.toSet()); return joinFutures(futures); } private MavenLookupResult getLookupResult(VersionAnalyzer va, GAV gav, Set versions) { + // TODO here will be the version stuffs Optional bmv = va.findBiggestMatchingVersion(gav.getVersion(), versions); return new MavenLookupResult(gav, bmv.orElse(null)); } diff --git a/reports-model/src/main/java/org/jboss/da/lookup/model/MavenLookupRequest.java b/reports-model/src/main/java/org/jboss/da/lookup/model/MavenLookupRequest.java index 4f0bd6a06..901cbf100 100644 --- a/reports-model/src/main/java/org/jboss/da/lookup/model/MavenLookupRequest.java +++ b/reports-model/src/main/java/org/jboss/da/lookup/model/MavenLookupRequest.java @@ -8,7 +8,6 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; -import org.jboss.da.model.rest.Constraints; import org.jboss.da.model.rest.GAV; import java.util.Set; @@ -25,8 +24,6 @@ public class MavenLookupRequest { @NonNull private final String mode; - private final Set constraints; - @JsonProperty(defaultValue = "false") private final boolean brewPullActive; diff --git a/reports-model/src/main/java/org/jboss/da/model/rest/Constraints.java b/reports-model/src/main/java/org/jboss/da/model/rest/Constraints.java deleted file mode 100644 index 2efa18eb6..000000000 --- a/reports-model/src/main/java/org/jboss/da/model/rest/Constraints.java +++ /dev/null @@ -1,23 +0,0 @@ -package org.jboss.da.model.rest; - -import lombok.AllArgsConstructor; -import lombok.Builder; -import lombok.Getter; -import lombok.extern.jackson.Jacksonized; - -import java.util.List; - -@AllArgsConstructor -@Getter -@Builder -@Jacksonized -public class Constraints { - - private final String artifactScope; - - private final List ranks; - - private final String denyList; - - private final String allowList; -} diff --git a/reports-rest/src/main/java/org/jboss/da/rest/LookupImpl.java b/reports-rest/src/main/java/org/jboss/da/rest/LookupImpl.java index 4aed654c4..2a39bbb84 100644 --- a/reports-rest/src/main/java/org/jboss/da/rest/LookupImpl.java +++ b/reports-rest/src/main/java/org/jboss/da/rest/LookupImpl.java @@ -37,11 +37,8 @@ public class LookupImpl implements Lookup { public Set lookupMaven(@SpanAttribute(value = "request") MavenLookupRequest request) throws CommunicationException { log.info("Incoming request to /lookup/maven. Payload: " + request.toString()); - Set result = lookupGenerator.lookupBestMatchMaven( - request.getArtifacts(), - request.getMode(), - request.isBrewPullActive(), - request.getConstraints()); + Set result = lookupGenerator + .lookupBestMatchMaven(request.getArtifacts(), request.getMode(), request.isBrewPullActive()); log.info("Request to /lookup/maven completed successfully. Payload: " + request.toString()); return result; } @@ -78,8 +75,7 @@ public Set lookupMaven(@SpanAttribute(value = "request") Mave public Set lookupNPM(@SpanAttribute(value = "request") NPMLookupRequest request) throws CommunicationException { log.info("Incoming request to /lookup/npm. Payload: " + request.toString()); - Set result = lookupGenerator - .lookupBestMatchNPM(request.getPackages(), request.getMode(), Set.of()); + Set result = lookupGenerator.lookupBestMatchNPM(request.getPackages(), request.getMode()); log.info("Request to /lookup/npm completed successfully. Payload: " + request.toString()); return result; } diff --git a/reports-rest/src/main/java/org/jboss/da/rest/exceptions/AllExceptionsMapper.java b/reports-rest/src/main/java/org/jboss/da/rest/exceptions/AllExceptionsMapper.java index 01aa5d5d6..28d6535c4 100644 --- a/reports-rest/src/main/java/org/jboss/da/rest/exceptions/AllExceptionsMapper.java +++ b/reports-rest/src/main/java/org/jboss/da/rest/exceptions/AllExceptionsMapper.java @@ -17,7 +17,6 @@ import static org.jboss.da.model.rest.ErrorMessage.ErrorType.COMMUNICATION_FAIL; import static org.jboss.da.model.rest.ErrorMessage.ErrorType.ILLEGAL_ARGUMENTS; -import static org.jboss.da.model.rest.ErrorMessage.ErrorType.INPUT_VALIDATION; import static org.jboss.da.model.rest.ErrorMessage.ErrorType.NO_RELATIONSHIP_FOUND; import static org.jboss.da.model.rest.ErrorMessage.ErrorType.POM_ANALYSIS; import static org.jboss.da.model.rest.ErrorMessage.ErrorType.SCM_ENDPOINT; @@ -31,8 +30,6 @@ public class AllExceptionsMapper implements ExceptionMapper { public Response toResponse(Exception e) { if (e instanceof ValidationException) { // order of tests is important return ((ValidationException) e).getResponse(); - } else if (e instanceof org.jboss.pnc.common.alignment.ranking.exception.ValidationException) { - return handleException("Constraint validation failed.", INPUT_VALIDATION, Response.Status.BAD_REQUEST, e); } else if (e instanceof NoSuchElementException) { return handleException("No relationship found", NO_RELATIONSHIP_FOUND, Response.Status.NOT_FOUND, e); } else if (e instanceof RepositoryException) { From e35ca64652c8c2eee2873a5984268299b95cf98b Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Fri, 13 Feb 2026 17:03:23 +0000 Subject: [PATCH 15/26] Revert "[Alignment 2.0] migrate DA to retrieve qualifier-enhanced versions" This reverts commit 87eee82e97e280c1914e0ecf6d359cbe0822e52b. --- common/pom.xml | 5 -- .../da/common/version/SuffixedVersion.java | 35 +++-------- .../da/common/version/VersionAnalyzer.java | 2 +- .../da/common/version/VersionParser.java | 62 +++++-------------- .../common/version/VersionAnalyzerTest.java | 10 +-- .../da/communication/pnc/PncConnector.java | 9 +-- .../communication/pnc/PncConnectorImpl.java | 53 ++++++---------- pom.xml | 2 +- .../da/products/api/ProductProvider.java | 5 +- .../impl/AbstractProductProvider.java | 24 +++---- .../impl/AggregatedProductProvider.java | 5 +- .../impl/DatabaseProductProvider.java | 7 +-- .../da/products/impl/PncProductProvider.java | 13 ++-- .../impl/RepositoryProductProvider.java | 9 ++- .../da/reports/impl/LookupGeneratorImpl.java | 53 +++++++--------- .../da/reports/impl/ReportsGeneratorImpl.java | 11 +--- .../da/reports/impl/LookupGeneratorTest.java | 18 +++--- .../main/java/org/jboss/da/model/rest/GA.java | 4 +- 18 files changed, 110 insertions(+), 217 deletions(-) diff --git a/common/pom.xml b/common/pom.xml index fcacb56dd..c5a4a76ea 100644 --- a/common/pom.xml +++ b/common/pom.xml @@ -32,11 +32,6 @@ constants - - org.jboss.pnc - pnc-common - - junit junit diff --git a/common/src/main/java/org/jboss/da/common/version/SuffixedVersion.java b/common/src/main/java/org/jboss/da/common/version/SuffixedVersion.java index 4fad5faa2..f8fb89672 100644 --- a/common/src/main/java/org/jboss/da/common/version/SuffixedVersion.java +++ b/common/src/main/java/org/jboss/da/common/version/SuffixedVersion.java @@ -17,7 +17,7 @@ import lombok.EqualsAndHashCode; import lombok.Getter; -import org.jboss.pnc.api.dependencyanalyzer.dto.Version; +import org.commonjava.maven.ext.manip.impl.Version; import java.util.Objects; import java.util.Optional; @@ -26,7 +26,7 @@ * * @author Honza Brázdil <jbrazdil@redhat.com> */ -@EqualsAndHashCode(exclude = { "originalVersionWithMeta" }) +@EqualsAndHashCode(exclude = { "originalVersion" }) @Getter public class SuffixedVersion implements Comparable { @@ -42,31 +42,16 @@ public class SuffixedVersion implements Comparable { private final Integer suffixVersion; - private final Version originalVersionWithMeta; + private final String originalVersion; public SuffixedVersion(int major, int minor, int micro, String qualifier, String originalVersion) { - this(major, minor, micro, qualifier, new Version(originalVersion)); - } - - public SuffixedVersion( - int major, - int minor, - int micro, - String qualifier, - String suffix, - int suffixVersion, - String originalVersion) { - this(major, minor, micro, qualifier, suffix, suffixVersion, new Version(originalVersion)); - } - - public SuffixedVersion(int major, int minor, int micro, String qualifier, Version originalVersionWithMeta) { this.major = major; this.minor = minor; this.micro = micro; this.qualifier = Objects.requireNonNull(qualifier); this.suffix = null; this.suffixVersion = null; - this.originalVersionWithMeta = originalVersionWithMeta; + this.originalVersion = originalVersion; } public SuffixedVersion( @@ -76,7 +61,7 @@ public SuffixedVersion( String qualifier, String suffix, int suffixVersion, - Version originalVersionWithMeta) { + String originalVersion) { if (suffix == null || suffix.isEmpty()) { throw new IllegalArgumentException("Suffix must be provided in this constructor."); } @@ -86,11 +71,7 @@ public SuffixedVersion( this.qualifier = Objects.requireNonNull(qualifier); this.suffix = Objects.requireNonNull(suffix); this.suffixVersion = suffixVersion; - this.originalVersionWithMeta = originalVersionWithMeta; - } - - public String getOriginalVersion() { - return originalVersionWithMeta.getVersion(); + this.originalVersion = originalVersion; } public Optional getSuffix() { @@ -149,8 +130,8 @@ public int compareTo(SuffixedVersion other) { } private boolean isOsgiVersion() { - var osgi = new org.commonjava.maven.ext.manip.impl.Version(getOriginalVersion()); - return getOriginalVersion().equals(osgi.getOSGiVersionString()); + Version osgi = new Version(originalVersion); + return originalVersion.equals(osgi.getOSGiVersionString()); } public final String normalizedVesion() { diff --git a/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java b/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java index 624064991..3c25c8867 100644 --- a/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java +++ b/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java @@ -94,7 +94,7 @@ private boolean matches(VersionComparator vc, SuffixedVersion v, VersionFilter v return ALLOWED_DIFFERENCE.get(vf).contains(difference); } - public Optional findBiggestMatchingVersion(String query, Collection versions) { + public Optional findBiggestMatchingVersion(String query, Collection versions) { String unsuffixedQuery = versionParser.parse(query).unsuffixedVesion(); List candidateSuffixedVersions = versions.stream() diff --git a/common/src/main/java/org/jboss/da/common/version/VersionParser.java b/common/src/main/java/org/jboss/da/common/version/VersionParser.java index a3afa8e73..985a3a1cd 100644 --- a/common/src/main/java/org/jboss/da/common/version/VersionParser.java +++ b/common/src/main/java/org/jboss/da/common/version/VersionParser.java @@ -1,6 +1,6 @@ package org.jboss.da.common.version; -import org.jboss.pnc.api.dependencyanalyzer.dto.Version; +import org.commonjava.maven.ext.manip.impl.Version; import java.util.Arrays; import java.util.HashMap; @@ -46,32 +46,7 @@ public VersionParser(List suffixes) { } public static SuffixedVersion parseUnsuffixed(String version) { - return parseVersion(UNSUFFIXED_PATTERN.matcher(version), new Version(version)); - } - - /** - * Parses the version string and returns the normalized version. - * - * @see #parse(Version) for details - * @param version the original string version - * @return The normalized version - */ - public SuffixedVersion parse(String version) { - return parse(new Version(version)); - } - - public static SuffixedVersion parseUnsuffixed(Version version) { - return parseVersion(UNSUFFIXED_PATTERN.matcher(version.getVersion()), version); - } - - /** - * Returns suffixed versions that can be parsed from the provided version string. - * - * @param version The version string to parse - * @return Set of suffixed versions parsable from the version string. - */ - public Set parseSuffixed(String version) { - return parseSuffixed(new Version(version)); + return parseVersion(UNSUFFIXED_PATTERN.matcher(version), version); } /** @@ -79,13 +54,13 @@ public Set parseSuffixed(String version) { * any of the suffixes (ore none) the normalized version is the one with the longest suffix (or in other words with * shortest version string after removing the suffix). * - * @param versionWithMeta The original version string with metadata. + * @param version The original version string. * @return The normalized version */ - public SuffixedVersion parse(Version versionWithMeta) { - SuffixedVersion normalized = parseUnsuffixed(versionWithMeta); + public SuffixedVersion parse(String version) { + SuffixedVersion normalized = parseUnsuffixed(version); int length = normalized.getQualifier().length(); - for (SuffixedVersion suffixedVersion : parseSuffixed(versionWithMeta)) { + for (SuffixedVersion suffixedVersion : parseSuffixed(version)) { if (suffixedVersion.getQualifier().length() < length) { normalized = suffixedVersion; length = suffixedVersion.getQualifier().length(); @@ -97,18 +72,15 @@ public SuffixedVersion parse(Version versionWithMeta) { /** * Returns suffixed versions that can be parsed from the provided version string. * - * @param versionWithMeta The version to parse + * @param version The version string to parse * @return Set of suffixed versions parsable from the version string. */ - public Set parseSuffixed(Version versionWithMeta) { + public Set parseSuffixed(String version) { Set ret = new HashSet<>(); for (Map.Entry entry : versionPatterns.entrySet()) { String suffix = entry.getKey(); Pattern versionPattern = entry.getValue(); - SuffixedVersion suffixedVersion = parseVersion( - versionPattern.matcher(versionWithMeta.getVersion()), - versionWithMeta, - suffix); + SuffixedVersion suffixedVersion = parseVersion(versionPattern.matcher(version), version, suffix); if (suffixedVersion.isSuffixed()) { ret.add(suffixedVersion); } @@ -116,10 +88,8 @@ public Set parseSuffixed(Version versionWithMeta) { return ret; } - private static SuffixedVersion parseVersion(Matcher versionMatcher, Version versionWithMeta) + private static SuffixedVersion parseVersion(Matcher versionMatcher, String version) throws NumberFormatException, IllegalArgumentException { - String version = versionWithMeta.getVersion(); - if (!versionMatcher.matches()) { throw new IllegalArgumentException("Version " + version + "is unparsable"); } @@ -132,13 +102,13 @@ private static SuffixedVersion parseVersion(Matcher versionMatcher, Version vers int minor = parseNumberString(minorString); int micro = parseNumberString(microString); String qualifier = qualifierString == null ? "" : qualifierString.replace('.', '-').replace(',', '-'); - return new SuffixedVersion(major, minor, micro, qualifier, versionWithMeta); + return new SuffixedVersion(major, minor, micro, qualifier, version); } - private static SuffixedVersion parseVersion(Matcher versionMatcher, Version versionWithMeta, String parseSuffix) + private static SuffixedVersion parseVersion(Matcher versionMatcher, String version, String parseSuffix) throws NumberFormatException, IllegalArgumentException { if (!versionMatcher.matches()) { - throw new IllegalArgumentException("Version " + versionWithMeta.getVersion() + "is unparsable"); + throw new IllegalArgumentException("Version " + version + "is unparsable"); } String majorString = versionMatcher.group("major"); String minorString = versionMatcher.group("minor"); @@ -151,10 +121,10 @@ private static SuffixedVersion parseVersion(Matcher versionMatcher, Version vers int micro = parseNumberString(microString); String qualifier = qualifierString == null ? "" : qualifierString.replace('.', '-').replace(',', '-'); if (suffixVersionString == null) { - return new SuffixedVersion(major, minor, micro, qualifier, versionWithMeta); + return new SuffixedVersion(major, minor, micro, qualifier, version); } else { int suffixVersion = Integer.parseInt(suffixVersionString); - return new SuffixedVersion(major, minor, micro, qualifier, parseSuffix, suffixVersion, versionWithMeta); + return new SuffixedVersion(major, minor, micro, qualifier, parseSuffix, suffixVersion, version); } } @@ -169,7 +139,7 @@ private static int parseNumberString(String segmentString) { * @return */ public static String getOSGiVersion(String version) { - String osgiS = (new org.commonjava.maven.ext.manip.impl.Version(version + ".foo")).getOSGiVersionString(); + String osgiS = (new Version(version + ".foo")).getOSGiVersionString(); int len = osgiS.length(); return osgiS.substring(0, len - 4); } diff --git a/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java b/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java index 958d25e06..1cce2f4df 100644 --- a/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java +++ b/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java @@ -1,14 +1,12 @@ package org.jboss.da.common.version; import org.jboss.da.common.CommunicationException; -import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import org.junit.Test; import java.util.Arrays; import java.util.Collections; import java.util.List; import java.util.Optional; -import java.util.stream.Collectors; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; @@ -112,9 +110,7 @@ public void getBestMatchVersionForNonExistingGAV() throws CommunicationException @Test public void getBestMatchVersionForNotBuiltGAV() throws CommunicationException { - Optional bmv = versionFinder.findBiggestMatchingVersion( - NO_BUILT_VERSION, - All_VERSIONS.stream().map(Version::new).collect(Collectors.toList())); + Optional bmv = versionFinder.findBiggestMatchingVersion(NO_BUILT_VERSION, All_VERSIONS); assertFalse("Best match version expected to not be present", bmv.isPresent()); } @@ -279,9 +275,7 @@ private void checkBMV(String expectedVersion, String version, String[] versions) } private void checkBMV(VersionAnalyzer versionAnalyzer, String expectedVersion, String version, String[] versions) { - Optional bmv = versionAnalyzer.findBiggestMatchingVersion( - version, - Arrays.stream(versions).map(Version::new).collect(Collectors.toList())); + Optional bmv = versionAnalyzer.findBiggestMatchingVersion(version, Arrays.asList(versions)); assertTrue("Best match version expected to be present", bmv.isPresent()); assertEquals(expectedVersion, bmv.get()); diff --git a/communication/src/main/java/org/jboss/da/communication/pnc/PncConnector.java b/communication/src/main/java/org/jboss/da/communication/pnc/PncConnector.java index 1b19d2241..52743530a 100644 --- a/communication/src/main/java/org/jboss/da/communication/pnc/PncConnector.java +++ b/communication/src/main/java/org/jboss/da/communication/pnc/PncConnector.java @@ -3,11 +3,8 @@ import org.jboss.da.common.json.LookupMode; import org.jboss.da.communication.repository.api.RepositoryException; import org.jboss.da.model.rest.GA; -import org.jboss.pnc.api.dependencyanalyzer.dto.Version; -import org.jboss.pnc.dto.requests.QValue; import java.util.List; -import java.util.Set; public interface PncConnector { @@ -18,17 +15,15 @@ public interface PncConnector { * @return list of available versions for given groupId:artifactId in repository, never {@code null} * @throws RepositoryException When there is problem with communication. */ - List getMavenVersions(GA ga, LookupMode mode, Set qualifiers) throws RepositoryException; + List getMavenVersions(GA ga, LookupMode mode) throws RepositoryException; /** * Finds available versions for given npm package. * * @param packageName Name of the npm package - * @param qualifiers * @return list of available versions for package in repository, never {@code null} * @throws RepositoryException When there is problem with communication. */ - List getNpmVersions(String packageName, LookupMode mode, Set qualifiers) - throws RepositoryException; + List getNpmVersions(String packageName, LookupMode mode) throws RepositoryException; } diff --git a/communication/src/main/java/org/jboss/da/communication/pnc/PncConnectorImpl.java b/communication/src/main/java/org/jboss/da/communication/pnc/PncConnectorImpl.java index e20b48515..1c550b5e8 100644 --- a/communication/src/main/java/org/jboss/da/communication/pnc/PncConnectorImpl.java +++ b/communication/src/main/java/org/jboss/da/communication/pnc/PncConnectorImpl.java @@ -5,13 +5,11 @@ import org.jboss.da.common.util.ConfigurationParseException; import org.jboss.da.communication.repository.api.RepositoryException; import org.jboss.da.model.rest.GA; -import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import org.jboss.pnc.client.ArtifactClient; import org.jboss.pnc.client.Configuration; import org.jboss.pnc.client.RemoteCollection; import org.jboss.pnc.client.RemoteResourceException; import org.jboss.pnc.common.logging.MDCUtils; -import org.jboss.pnc.dto.requests.QValue; import org.jboss.pnc.dto.response.ArtifactInfo; import org.jboss.pnc.enums.RepositoryType; import org.slf4j.Logger; @@ -22,8 +20,8 @@ import java.net.URI; import java.util.ArrayList; import java.util.Collection; +import java.util.Collections; import java.util.List; -import java.util.Set; /** * @author Petr Kocandrle @@ -45,29 +43,16 @@ public PncConnectorImpl(org.jboss.da.common.util.Configuration configuration) { } } - private Collection getArtifacts( - String identifierPattern, - RepositoryType repoType, - LookupMode mode, - Set qualifiers) throws RepositoryException { + private Collection getArtifacts(String identifierPattern, RepositoryType repoType, LookupMode mode) + throws RepositoryException { ArtifactClient artifactClient = getArtifactClient(); RemoteCollection artCollection; try { - if (qualifiers.isEmpty()) { - artCollection = artifactClient.getAllFiltered( - identifierPattern, - mode.getArtifactQualities(), - repoType, - mode.getBuildCategories(), - null); - } else { - artCollection = artifactClient.getAllFiltered( - identifierPattern, - mode.getArtifactQualities(), - repoType, - mode.getBuildCategories(), - qualifiers); - } + artCollection = artifactClient.getAllFiltered( + identifierPattern, + mode.getArtifactQualities(), + repoType, + mode.getBuildCategories()); } catch (RemoteResourceException ex) { log.debug("Error when reading artifacts from PNC: " + ex, ex); throw new RepositoryException("Error when reading artifacts from PNC: " + ex, ex); @@ -76,36 +61,36 @@ private Collection getArtifacts( } @Override - public List getMavenVersions(GA ga, LookupMode mode, Set qualifiers) throws RepositoryException { + public List getMavenVersions(GA ga, LookupMode mode) throws RepositoryException { String identifierPattern = ga.getGroupId() + ':' + ga.getArtifactId() + ":pom:*"; - Collection arts = getArtifacts(identifierPattern, RepositoryType.MAVEN, mode, qualifiers); + Collection arts = getArtifacts(identifierPattern, RepositoryType.MAVEN, mode); - List versions = new ArrayList<>(arts.size()); + List versions = new ArrayList<>(arts.size()); for (ArtifactInfo art : arts) { String[] parts = art.getIdentifier().split(":"); if (parts.length == 4) { // TODO filtering by target repository if necessary - versions.add(new Version(parts[3], art.getQualifiers())); - log.error("Cannot read version for artifact with identifier {}", art.getIdentifier()); + versions.add(parts[3]); + } else { + log.error("Cannot read version for artifact with identifier %s", art.getIdentifier()); } } return versions; } @Override - public List getNpmVersions(String packageName, LookupMode mode, Set qualifiers) - throws RepositoryException { + public List getNpmVersions(String packageName, LookupMode mode) throws RepositoryException { String identifierPattern = packageName + ":*"; - Collection arts = getArtifacts(identifierPattern, RepositoryType.NPM, mode, qualifiers); + Collection arts = getArtifacts(identifierPattern, RepositoryType.NPM, mode); - List versions = new ArrayList<>(arts.size()); + List versions = new ArrayList<>(arts.size()); for (ArtifactInfo art : arts) { String[] parts = art.getIdentifier().split(":"); if (parts.length == 2) { // TODO filtering by target repository if necessary - versions.add(new Version(parts[1], art.getQualifiers())); + versions.add(parts[1]); } else { - log.error("Cannot read version for artifact with identifier {}", art.getIdentifier()); + log.error("Cannot read version for artifact with identifier %s", art.getIdentifier()); } } return versions; diff --git a/pom.xml b/pom.xml index e8c58592e..479389952 100644 --- a/pom.xml +++ b/pom.xml @@ -82,7 +82,7 @@ 1 1 2.5.0-SNAPSHOT - 2.3.0-SNAPSHOT + 2.2.1-SNAPSHOT 2.4.5-SNAPSHOT 0.13.4 0.12.2 diff --git a/reports-backend/src/main/java/org/jboss/da/products/api/ProductProvider.java b/reports-backend/src/main/java/org/jboss/da/products/api/ProductProvider.java index 885dca6e8..11548e6e2 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/api/ProductProvider.java +++ b/reports-backend/src/main/java/org/jboss/da/products/api/ProductProvider.java @@ -1,7 +1,6 @@ package org.jboss.da.products.api; import org.jboss.da.listings.model.ProductSupportStatus; -import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import java.util.Map; import java.util.Set; @@ -73,7 +72,7 @@ public interface ProductProvider { * @param artifact artifact which name and type will be used for searching. * @return Set of products and their artifacts versions. */ - CompletableFuture>> getVersions(Artifact artifact); + CompletableFuture>> getVersions(Artifact artifact); /** * Get all artifacts versions with the same name and type as given artifact regardless if they are from product or @@ -82,5 +81,5 @@ public interface ProductProvider { * @param artifact artifact which name and type will be used for searching. * @return Set of artifacts versions. */ - CompletableFuture> getAllVersions(Artifact artifact); + CompletableFuture> getAllVersions(Artifact artifact); } diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/AbstractProductProvider.java b/reports-backend/src/main/java/org/jboss/da/products/impl/AbstractProductProvider.java index fd68bcf58..cd67a1322 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/impl/AbstractProductProvider.java +++ b/reports-backend/src/main/java/org/jboss/da/products/impl/AbstractProductProvider.java @@ -23,8 +23,6 @@ import org.jboss.da.products.api.Product; import org.jboss.da.products.api.ProductArtifacts; import org.jboss.da.products.api.ProductProvider; -import org.jboss.pnc.api.dependencyanalyzer.dto.Version; -import org.jboss.pnc.dto.requests.QValue; import org.jboss.pnc.enums.ArtifactQuality; import org.jboss.pnc.enums.BuildCategory; import org.slf4j.Logger; @@ -111,20 +109,19 @@ public CompletableFuture> getArtifacts(Artifact artifact, } @Override - public CompletableFuture>> getVersions(Artifact artifact) { + public CompletableFuture>> getVersions(Artifact artifact) { switch (artifact.getType()) { case MAVEN: { GA ga = ((MavenArtifact) artifact).getGav().getGA(); - CompletableFuture> versions = supplyAsync( - () -> getVersionsStreamMaven(ga).filter(v -> versionParser.parse(v.getVersion()).isSuffixed()) + CompletableFuture> versions = supplyAsync( + () -> getVersionsStreamMaven(ga).filter(v -> versionParser.parse(v).isSuffixed()) .distinct() .collect(Collectors.toSet())); return versions.thenApply(rv -> Collections.singletonMap(Product.UNKNOWN, rv)); } case NPM: { - CompletableFuture> versions = supplyAsync( - () -> getVersionsStreamNPM(artifact.getName()) - .filter(v -> versionParser.parse(v.getVersion()).isSuffixed()) + CompletableFuture> versions = supplyAsync( + () -> getVersionsStreamNPM(artifact.getName()).filter(v -> versionParser.parse(v).isSuffixed()) .distinct() .collect(Collectors.toSet())); return versions.thenApply(rv -> Collections.singletonMap(Product.UNKNOWN, rv)); @@ -136,7 +133,7 @@ public CompletableFuture>> getVersions(Artifact artifa } @Override - public CompletableFuture> getAllVersions(Artifact artifact) { + public CompletableFuture> getAllVersions(Artifact artifact) { switch (artifact.getType()) { case MAVEN: { GA ga = ((MavenArtifact) artifact).getGav().getGA(); @@ -167,8 +164,7 @@ private CompletableFuture> getArtifacts0(Artifact artifact } private Set getArtifactsMaven(GA ga) { - Set allArtifacts = getVersionsStreamMaven(ga).map(Version::getVersion) - .filter(v -> versionParser.parse(v).isSuffixed()) + Set allArtifacts = getVersionsStreamMaven(ga).filter(v -> versionParser.parse(v).isSuffixed()) .distinct() .map(x -> new GAV(ga, x)) .map(MavenArtifact::new) @@ -182,7 +178,7 @@ private Set getArtifactsMaven(GA ga) { private Set getArtifactsNPM(String name) { Set allArtifacts = getVersionsStreamNPM(name).filter(v -> versionParser.parse(v).isSuffixed()) .distinct() - .map(v -> new NPMArtifact(name, v.getVersion())) + .map(v -> new NPMArtifact(name, v)) .collect(Collectors.toSet()); if (allArtifacts.isEmpty()) { return Collections.emptySet(); @@ -190,8 +186,8 @@ private Set getArtifactsNPM(String name) { return Collections.singleton(new ProductArtifacts(Product.UNKNOWN, allArtifacts)); } - abstract Stream getVersionsStreamMaven(GA ga); + abstract Stream getVersionsStreamMaven(GA ga); - abstract Stream getVersionsStreamNPM(String name); + abstract Stream getVersionsStreamNPM(String name); } diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/AggregatedProductProvider.java b/reports-backend/src/main/java/org/jboss/da/products/impl/AggregatedProductProvider.java index c7965dbf7..e0aa8636a 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/impl/AggregatedProductProvider.java +++ b/reports-backend/src/main/java/org/jboss/da/products/impl/AggregatedProductProvider.java @@ -9,7 +9,6 @@ import org.jboss.da.products.impl.DatabaseProductProvider.Database; import org.jboss.da.products.impl.RepositoryProductProvider.Repository; import org.jboss.da.products.impl.PncProductProvider.Pnc; -import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import javax.annotation.Resource; import javax.enterprise.concurrent.ManagedScheduledExecutorService; @@ -112,12 +111,12 @@ public CompletableFuture> getArtifacts(Artifact artifact, } @Override - public CompletableFuture>> getVersions(Artifact artifact) { + public CompletableFuture>> getVersions(Artifact artifact) { return aggregate(x -> x.getVersions(artifact), new MapCol<>(AggregatedProductProvider::combineSets)); } @Override - public CompletableFuture> getAllVersions(Artifact artifact) { + public CompletableFuture> getAllVersions(Artifact artifact) { return aggregate(x -> x.getAllVersions(artifact), new SetCollector<>()); } diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/DatabaseProductProvider.java b/reports-backend/src/main/java/org/jboss/da/products/impl/DatabaseProductProvider.java index 74c4b6b82..e60884d3c 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/impl/DatabaseProductProvider.java +++ b/reports-backend/src/main/java/org/jboss/da/products/impl/DatabaseProductProvider.java @@ -14,7 +14,6 @@ import org.jboss.da.products.api.ProductArtifacts; import org.jboss.da.products.api.ProductProvider; import org.jboss.da.products.impl.DatabaseProductProvider.Database; -import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import javax.inject.Inject; import javax.inject.Qualifier; @@ -94,7 +93,7 @@ public CompletableFuture> getArtifacts(Artifact artifact, } @Override - public CompletableFuture>> getVersions(Artifact artifact) { + public CompletableFuture>> getVersions(Artifact artifact) { if (artifact.getType() != ArtifactType.MAVEN) { return CompletableFuture.completedFuture(Collections.emptyMap()); } @@ -107,12 +106,11 @@ public CompletableFuture>> getVersions(Artifact artifa x -> x.getArtifacts() .stream() .map(Artifact::getVersion) - .map(Version::new) .collect(Collectors.toSet())))); } @Override - public CompletableFuture> getAllVersions(Artifact artifact) { + public CompletableFuture> getAllVersions(Artifact artifact) { if (artifact.getType() != ArtifactType.MAVEN) { return CompletableFuture.completedFuture(Collections.emptySet()); } @@ -121,7 +119,6 @@ public CompletableFuture> getAllVersions(Artifact artifact) { () -> getArtifacts(ga.getGroupId(), ga.getArtifactId(), Optional.empty()).stream() .flatMap(a -> a.getArtifacts().stream()) .map(Artifact::getVersion) - .map(Version::new) .collect(Collectors.toSet())); } diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/PncProductProvider.java b/reports-backend/src/main/java/org/jboss/da/products/impl/PncProductProvider.java index e64b11674..d37c82a6e 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/impl/PncProductProvider.java +++ b/reports-backend/src/main/java/org/jboss/da/products/impl/PncProductProvider.java @@ -14,7 +14,6 @@ import java.lang.annotation.Retention; import java.lang.annotation.Target; import java.util.List; -import java.util.Set; import java.util.stream.Stream; import static java.lang.annotation.ElementType.FIELD; @@ -35,15 +34,15 @@ public class PncProductProvider extends AbstractProductProvider { private PncConnector pncConnector; @Override - Stream getVersionsStreamMaven(GA ga) { + Stream getVersionsStreamMaven(GA ga) { if (!ga.isValid()) { userLog.warn("Received nonvalid GA " + ga + ", using empty list of versions."); log.warn("Received nonvalid GA: " + ga); return Stream.empty(); } try { - List versionsOfGA; - versionsOfGA = pncConnector.getMavenVersions(ga, mode, qualifiers); + List versionsOfGA; + versionsOfGA = pncConnector.getMavenVersions(ga, mode); log.debug("Got versions of " + ga + " from PNC: " + versionsOfGA); return versionsOfGA.stream(); } catch (CommunicationException ex) { @@ -52,10 +51,10 @@ Stream getVersionsStreamMaven(GA ga) { } @Override - Stream getVersionsStreamNPM(String name) { + Stream getVersionsStreamNPM(String name) { try { - List versionsOfGA; - versionsOfGA = pncConnector.getNpmVersions(name, mode, qualifiers); + List versionsOfGA; + versionsOfGA = pncConnector.getNpmVersions(name, mode); log.debug("Got versions of " + name + " from PNC: " + versionsOfGA); return versionsOfGA.stream(); } catch (CommunicationException ex) { diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/RepositoryProductProvider.java b/reports-backend/src/main/java/org/jboss/da/products/impl/RepositoryProductProvider.java index 6120b30e3..10633db6c 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/impl/RepositoryProductProvider.java +++ b/reports-backend/src/main/java/org/jboss/da/products/impl/RepositoryProductProvider.java @@ -4,7 +4,6 @@ import org.jboss.da.communication.indy.api.IndyConnector; import org.jboss.da.model.rest.GA; import org.jboss.da.products.impl.RepositoryProductProvider.Repository; -import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import javax.ejb.TransactionAttribute; import javax.ejb.TransactionAttributeType; @@ -36,7 +35,7 @@ public class RepositoryProductProvider extends AbstractProductProvider { private IndyConnector indyConnector; @Override - Stream getVersionsStreamMaven(GA ga) { + Stream getVersionsStreamMaven(GA ga) { if (!ga.isValid()) { userLog.warn("Received nonvalid GA " + ga + ", using empty list of versions."); log.warn("Received nonvalid GA: " + ga); @@ -46,19 +45,19 @@ Stream getVersionsStreamMaven(GA ga) { List versionsOfGA; versionsOfGA = indyConnector.getVersionsOfGA(ga); log.debug("Got versions of " + ga + " from repository: " + versionsOfGA); - return versionsOfGA.stream().map(Version::new); + return versionsOfGA.stream(); } catch (CommunicationException ex) { throw new ProductException(ex); } } @Override - Stream getVersionsStreamNPM(String name) { + Stream getVersionsStreamNPM(String name) { try { List versionsOfGA; versionsOfGA = indyConnector.getVersionsOfNpm(name); log.debug("Got versions of " + name + " from repository: " + versionsOfGA); - return versionsOfGA.stream().map(Version::new); + return versionsOfGA.stream(); } catch (CommunicationException ex) { throw new ProductException(ex); } diff --git a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java index 1404e62a7..51e58c8a2 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java @@ -29,11 +29,9 @@ import javax.enterprise.context.ApplicationScoped; import javax.inject.Inject; -import java.util.Collection; import java.util.Collections; import java.util.EnumSet; import java.util.HashMap; -import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Optional; @@ -90,8 +88,8 @@ public Set lookupVersionsMaven( boolean brewPullActive, boolean includeBad) throws CommunicationException { LookupMode lookupMode = getMode(mode, includeBad); - ProductProvider productProvider = setupProductProvider(brewPullActive, lookupMode, Set.of()); - Map>> productArtifacts = getArtifactVersions( + ProductProvider productProvider = setupProductProvider(brewPullActive, lookupMode); + Map>> productArtifacts = getArtifactVersions( productProvider, gavs, !includeBad); @@ -101,8 +99,8 @@ public Set lookupVersionsMaven( @Override public Set lookupLatestMaven(Set gavs, String mode) throws CommunicationException { LookupMode lookupMode = getMode(mode, true); - ProductProvider productProvider = setupProductProvider(true, lookupMode, Set.of()); - Map>> productArtifacts = getArtifactVersions(productProvider, gavs, false); + ProductProvider productProvider = setupProductProvider(true, lookupMode); + Map>> productArtifacts = getArtifactVersions(productProvider, gavs, false); return createLatestResult(gavs, lookupMode, productArtifacts); } @@ -111,7 +109,7 @@ public Set lookupBestMatchNPM(Set packages, String throws CommunicationException { LookupMode lookupMode = getMode(mode, false); pncProductProvider.setLookupMode(lookupMode); - Map>> productArtifacts = getArtifactVersions(packages); + Map>> productArtifacts = getArtifactVersions(packages); return createLookupResultNpm(packages, lookupMode, productArtifacts); } @@ -124,7 +122,7 @@ public Set lookupVersionsNPM( boolean includeBad) throws CommunicationException { LookupMode lookupMode = getMode(mode, includeBad); pncProductProvider.setLookupMode(lookupMode); - Map>> productArtifacts = getArtifactVersions(packages); + Map>> productArtifacts = getArtifactVersions(packages); return createVersionsResultNpm(packages, lookupMode, vf, distanceRule, productArtifacts); } @@ -138,15 +136,15 @@ private ProductProvider setupProductProvider(boolean brewPullActive, LookupMode } } - private Map>> getArtifactVersions( + private Map>> getArtifactVersions( ProductProvider productProvider, Set gavs, boolean filterBlacklisted) { - Map>> ret = new HashMap<>(); + Map>> ret = new HashMap<>(); Set distinctGAs = gavs.stream().map(GAV::getGA).collect(Collectors.toSet()); for (GA ga : distinctGAs) { MavenArtifact mavenArtifact = new MavenArtifact(new GAV(ga, "0.0.0")); - CompletableFuture> versions = productProvider.getAllVersions(mavenArtifact); + CompletableFuture> versions = productProvider.getAllVersions(mavenArtifact); if (filterBlacklisted) { versions = filterBlacklistedArtifacts(versions, ga); } @@ -155,7 +153,7 @@ private Map>> getArtifactVersions( return ret; } - private Map>> getArtifactVersions(Set packages) { + private Map>> getArtifactVersions(Set packages) { return packages.stream() .map(NPMPackage::getName) .distinct() @@ -163,11 +161,9 @@ private Map>> getArtifactVersions(Set> filterBlacklistedArtifacts( - CompletableFuture> versions, - GA ga) { - Predicate isNotBlacklisted = version -> { - GAV gav = new GAV(ga, version.getVersion()); + private CompletableFuture> filterBlacklistedArtifacts(CompletableFuture> versions, GA ga) { + Predicate isNotBlacklisted = version -> { + GAV gav = new GAV(ga, version); return !blackArtifactService.isArtifactPresent(gav); }; return versions.thenApply(v -> v.stream().filter(isNotBlacklisted).collect(Collectors.toSet())); @@ -192,14 +188,12 @@ private Set createVersionsResult( LookupMode mode, VersionFilter vf, VersionDistanceRule distanceRule, - Map>> artifactsMap) throws CommunicationException { + Map>> artifactsMap) throws CommunicationException { VersionAnalyzer va = new VersionAnalyzer(mode.getSuffixes(), distanceRule); Set> futures = gavs.stream() - .map(gav -> artifactsMap.get(gav.getGA()) - .thenApply(pas -> pas.stream().map(Version::getVersion).collect(Collectors.toSet())) - .thenApply(pas -> getMatchingVersions(va, vf, gav, pas))) + .map(gav -> artifactsMap.get(gav.getGA()).thenApply(pas -> getMatchingVersions(va, vf, gav, pas))) .collect(Collectors.toSet()); return joinFutures(futures); @@ -208,7 +202,7 @@ private Set createVersionsResult( private Set createLatestResult( Set gavs, LookupMode mode, - Map>> artifactsMap) throws CommunicationException { + Map>> artifactsMap) throws CommunicationException { VersionAnalyzer va = new VersionAnalyzer(Collections.singletonList(mode.getIncrementSuffix())); @@ -222,7 +216,7 @@ private Set createLatestResult( private Set createLookupResultNpm( Set packages, LookupMode mode, - Map>> artifactsMap) throws CommunicationException { + Map>> artifactsMap) throws CommunicationException { VersionAnalyzer va = new VersionAnalyzer(mode.getSuffixes()); Set> futures = packages.stream() @@ -237,25 +231,22 @@ private Set createVersionsResultNpm( LookupMode mode, VersionFilter vf, VersionDistanceRule distanceRule, - Map>> artifactsMap) throws CommunicationException { + Map>> artifactsMap) throws CommunicationException { VersionAnalyzer va = new VersionAnalyzer(mode.getSuffixes(), distanceRule); Set> futures = packages.stream() - .map(pkg -> artifactsMap.get(pkg.getName()) - .thenApply(f -> f.stream().map(Version::getVersion).collect(Collectors.toSet())) - .thenApply(f -> getMatchingVersions(va, vf,pkg,f))) + .map(pkg -> artifactsMap.get(pkg.getName()).thenApply(f -> getMatchingVersions(va, vf, pkg, f))) .collect(Collectors.toSet()); return joinFutures(futures); } - private MavenLookupResult getLookupResult(VersionAnalyzer va, GAV gav, Set versions) { - // TODO here will be the version stuffs + private MavenLookupResult getLookupResult(VersionAnalyzer va, GAV gav, Set versions) { Optional bmv = va.findBiggestMatchingVersion(gav.getVersion(), versions); return new MavenLookupResult(gav, bmv.orElse(null)); } - private MavenLatestResult getLatestResult(VersionAnalyzer va, GAV gav, Set versions) { + private MavenLatestResult getLatestResult(VersionAnalyzer va, GAV gav, Set versions) { Optional bmv = va.findBiggestMatchingVersion(gav.getVersion(), versions); return new MavenLatestResult(gav, bmv.orElse(null)); } @@ -278,7 +269,7 @@ private NPMVersionsResult getMatchingVersions( return new NPMVersionsResult(pkg, availableVersions); } - private NPMLookupResult getLookupResult(VersionAnalyzer va, NPMPackage pkg, Set versions) { + private NPMLookupResult getLookupResult(VersionAnalyzer va, NPMPackage pkg, Set versions) { Optional bmv = va.findBiggestMatchingVersion(pkg.getVersion(), versions); return new NPMLookupResult(pkg, bmv.orElse(null)); } diff --git a/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java b/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java index 3073fb7dc..9680e30e2 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java @@ -23,7 +23,6 @@ import org.jboss.da.model.rest.GA; import org.jboss.da.model.rest.GAV; import org.jboss.da.model.rest.NPMPackage; -import org.jboss.da.products.api.Artifact; import org.jboss.da.products.api.MavenArtifact; import org.jboss.da.products.api.NPMArtifact; import org.jboss.da.products.api.Product; @@ -52,7 +51,6 @@ import org.jboss.da.reports.model.response.NPMVersionsReport; import org.jboss.da.scm.api.SCM; import org.jboss.da.scm.api.SCMType; -import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import org.jboss.pnc.enums.ArtifactQuality; import org.jboss.pnc.enums.BuildCategory; import org.slf4j.Logger; @@ -226,12 +224,10 @@ private CompletableFuture analyzeVersions( return availableArtifacts.thenApply(pas -> { List versions = pas.stream() .flatMap(as -> as.getArtifacts().stream()) - .map(Artifact::getVersion) + .map(a -> a.getVersion()) .collect(Collectors.toList()); - Optional bmv = va.findBiggestMatchingVersion( - version, - versions.stream().map(Version::new).collect(Collectors.toList())); + Optional bmv = va.findBiggestMatchingVersion(version, versions); List sortedVersions = va.sortVersions(version, versions); return new VersionAnalysisResult(bmv, sortedVersions); @@ -533,8 +529,7 @@ public List getVersionsReports(VersionsNPMRequest request) th Map>> artifactsMap = new HashMap<>(); for (String name : uniqueNames) { - CompletableFuture> artifacts = productProvider.getAllVersions(new NPMArtifact(name, "0.0.0")) - .thenApply(s -> s.stream().map(Version::getVersion).collect(Collectors.toSet())); + CompletableFuture> artifacts = productProvider.getAllVersions(new NPMArtifact(name, "0.0.0")); artifactsMap.put(name, artifacts); } diff --git a/reports-backend/src/test/java/org/jboss/da/reports/impl/LookupGeneratorTest.java b/reports-backend/src/test/java/org/jboss/da/reports/impl/LookupGeneratorTest.java index 8f62f16fc..c12a68cf9 100644 --- a/reports-backend/src/test/java/org/jboss/da/reports/impl/LookupGeneratorTest.java +++ b/reports-backend/src/test/java/org/jboss/da/reports/impl/LookupGeneratorTest.java @@ -17,7 +17,6 @@ import org.jboss.da.products.impl.PncProductProvider; import org.jboss.da.products.impl.RepositoryProductProvider; import org.jboss.da.reports.api.LookupGenerator; -import org.jboss.pnc.api.dependencyanalyzer.dto.Version; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; @@ -32,7 +31,6 @@ import java.util.Set; import java.util.concurrent.CompletableFuture; -import static org.jboss.pnc.api.dependencyanalyzer.dto.Version.of; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNull; import static org.mockito.Matchers.eq; @@ -79,14 +77,14 @@ public static void initMocks() throws ConfigurationParseException { @Test public void testMaven() throws CommunicationException { GAV gav1 = new GAV("foo.bar", "baz", "1.0.0"); - preparePnc(gav1.getGA(), Arrays.asList(of("1.0.0.redhat-1"), of("1.2.3.redhat-4"), of("1.0.0.redhat-2"))); + preparePnc(gav1.getGA(), Arrays.asList("1.0.0.redhat-1", "1.2.3.redhat-4", "1.0.0.redhat-2")); GAV gav2 = new GAV("foo.bar", "buz", "2.3.4"); - preparePnc(gav2.getGA(), Arrays.asList(of("1.0.0.redhat-1"), of("1.2.3.redhat-4"), of("1.0.0.redhat-2"))); + preparePnc(gav2.getGA(), Arrays.asList("1.0.0.redhat-1", "1.2.3.redhat-4", "1.0.0.redhat-2")); Set gavs = new HashSet<>(); gavs.add(gav1); gavs.add(gav2); - Set results = lookupGenerator.lookupBestMatchMaven(gavs, PERSISTENT, false, Set.of()); + Set results = lookupGenerator.lookupBestMatchMaven(gavs, PERSISTENT, false); assertEquals(2, results.size()); MavenLookupResult result1 = results.stream().filter(r -> gav1.equals(r.getGav())).findFirst().get(); @@ -98,14 +96,14 @@ public void testMaven() throws CommunicationException { @Test public void testNpm() throws CommunicationException { NPMPackage gav1 = new NPMPackage("foo-bar", "1.0.0"); - preparePnc(gav1.getName(), Arrays.asList(of("1.0.0.redhat-1"), of("1.2.3.redhat-4"), of("1.0.0.redhat-2"))); + preparePnc(gav1.getName(), Arrays.asList("1.0.0.redhat-1", "1.2.3.redhat-4", "1.0.0.redhat-2")); NPMPackage gav2 = new NPMPackage("foo-baz", "2.3.4"); - preparePnc(gav2.getName(), Arrays.asList(of("1.0.0.redhat-1"), of("1.2.3.redhat-4"), of("1.0.0.redhat-2"))); + preparePnc(gav2.getName(), Arrays.asList("1.0.0.redhat-1", "1.2.3.redhat-4", "1.0.0.redhat-2")); Set gavs = new HashSet<>(); gavs.add(gav1); gavs.add(gav2); - Set results = lookupGenerator.lookupBestMatchNPM(gavs, PERSISTENT, Set.of()); + Set results = lookupGenerator.lookupBestMatchNPM(gavs, PERSISTENT); assertEquals(2, results.size()); NPMLookupResult result1 = results.stream().filter(r -> gav1.equals(r.getNpmPackage())).findFirst().get(); @@ -114,12 +112,12 @@ public void testNpm() throws CommunicationException { assertNull(result2.getBestMatchVersion()); } - private void preparePnc(GA ga, List versions) { + private void preparePnc(GA ga, List versions) { when(pncProductProvider.getAllVersions(eq(new MavenArtifact(new GAV(ga, "0.0.0"))))) .thenReturn(CompletableFuture.completedFuture(new HashSet<>(versions))); } - private void preparePnc(String name, List versions) { + private void preparePnc(String name, List versions) { when(pncProductProvider.getAllVersions(eq(new NPMArtifact(name, "0.0.0")))) .thenReturn(CompletableFuture.completedFuture(new HashSet<>(versions))); } diff --git a/reports-model/src/main/java/org/jboss/da/model/rest/GA.java b/reports-model/src/main/java/org/jboss/da/model/rest/GA.java index 33773a42e..6f8545924 100644 --- a/reports-model/src/main/java/org/jboss/da/model/rest/GA.java +++ b/reports-model/src/main/java/org/jboss/da/model/rest/GA.java @@ -13,9 +13,9 @@ @EqualsAndHashCode public class GA implements Comparable { - public static final Pattern GROUP_ID_PATTERN = Pattern.compile("(\\w[\\w-]*\\.)*\\w[\\w-]*"); + private static final Pattern GROUP_ID_PATTERN = Pattern.compile("(\\w[\\w-]*\\.)*\\w[\\w-]*"); - public static final Pattern ARTIFACT_ID_PATTERN = Pattern.compile("[a-zA-Z0-9_.-]+"); + private static final Pattern ARTIFACT_ID_PATTERN = Pattern.compile("[a-zA-Z0-9_.-]+"); @Getter @NonNull From b0b80d05ff84de8869020a0edfa4503fe4194c6b Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Mon, 16 Feb 2026 11:27:25 +0000 Subject: [PATCH 16/26] Use released versions of PNC components --- pom.xml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pom.xml b/pom.xml index 479389952..96cda14ea 100644 --- a/pom.xml +++ b/pom.xml @@ -81,9 +81,9 @@ UTF-8 1 1 - 2.5.0-SNAPSHOT - 2.2.1-SNAPSHOT - 2.4.5-SNAPSHOT + 2.5.0 + 2.2.1 + 2.4.5 0.13.4 0.12.2 11 From 2b599db247192db1a8598ab1cb83118f07b3b927 Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Tue, 17 Feb 2026 12:29:23 +0000 Subject: [PATCH 17/26] Reapply "Move Version code to pnc-api and pnc-common" This reverts commit 0b48f597e68c277f458b786ce972c1830c556dd4. --- common/pom.xml | 4 - .../da/common/version/SuffixedVersion.java | 157 --------- .../da/common/version/VersionAnalyzer.java | 167 --------- .../da/common/version/VersionComparator.java | 277 --------------- .../da/common/version/VersionParser.java | 147 -------- .../common/version/SuffixedVersionTest.java | 61 ---- .../common/version/VersionAnalyzerTest.java | 325 ------------------ .../common/version/VersionComparatorTest.java | 288 ---------------- .../da/common/version/VersionParserTest.java | 172 --------- pom.xml | 11 - .../impl/service/ArtifactServiceImpl.java | 2 +- .../service/BlackArtifactServiceImpl.java | 6 +- .../service/WhiteArtifactServiceImpl.java | 4 +- .../jboss/da/products/api/ArtifactDiff.java | 2 +- .../impl/AbstractProductProvider.java | 2 +- .../da/products/impl/ProductsServiceImpl.java | 6 +- .../jboss/da/reports/api/LookupGenerator.java | 4 +- .../da/reports/impl/LookupGeneratorImpl.java | 6 +- .../da/reports/impl/ReportsGeneratorImpl.java | 8 +- reports-model/pom.xml | 4 + .../da/lookup/model/MavenVersionsRequest.java | 2 + .../da/lookup/model/NPMVersionsRequest.java | 3 +- .../da/lookup/model/VersionDistanceRule.java | 37 -- .../jboss/da/lookup/model/VersionFilter.java | 5 - reports-rest/pom.xml | 8 - 25 files changed, 28 insertions(+), 1680 deletions(-) delete mode 100644 common/src/main/java/org/jboss/da/common/version/SuffixedVersion.java delete mode 100644 common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java delete mode 100644 common/src/main/java/org/jboss/da/common/version/VersionComparator.java delete mode 100644 common/src/main/java/org/jboss/da/common/version/VersionParser.java delete mode 100644 common/src/test/java/org/jboss/da/common/version/SuffixedVersionTest.java delete mode 100644 common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java delete mode 100644 common/src/test/java/org/jboss/da/common/version/VersionComparatorTest.java delete mode 100644 common/src/test/java/org/jboss/da/common/version/VersionParserTest.java delete mode 100644 reports-model/src/main/java/org/jboss/da/lookup/model/VersionDistanceRule.java delete mode 100644 reports-model/src/main/java/org/jboss/da/lookup/model/VersionFilter.java diff --git a/common/pom.xml b/common/pom.xml index c5a4a76ea..6d48d6a1f 100644 --- a/common/pom.xml +++ b/common/pom.xml @@ -40,10 +40,6 @@ jakarta.enterprise jakarta.enterprise.cdi-api - - org.commonjava.maven.ext - pom-manipulation-core - org.slf4j slf4j-api diff --git a/common/src/main/java/org/jboss/da/common/version/SuffixedVersion.java b/common/src/main/java/org/jboss/da/common/version/SuffixedVersion.java deleted file mode 100644 index f8fb89672..000000000 --- a/common/src/main/java/org/jboss/da/common/version/SuffixedVersion.java +++ /dev/null @@ -1,157 +0,0 @@ -/* - * Copyright 2018 Honza Brázdil <jbrazdil@redhat.com>. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.jboss.da.common.version; - -import lombok.EqualsAndHashCode; -import lombok.Getter; -import org.commonjava.maven.ext.manip.impl.Version; - -import java.util.Objects; -import java.util.Optional; - -/** - * - * @author Honza Brázdil <jbrazdil@redhat.com> - */ -@EqualsAndHashCode(exclude = { "originalVersion" }) -@Getter -public class SuffixedVersion implements Comparable { - - private final int major; - - private final int minor; - - private final int micro; - - private final String qualifier; - - private final String suffix; - - private final Integer suffixVersion; - - private final String originalVersion; - - public SuffixedVersion(int major, int minor, int micro, String qualifier, String originalVersion) { - this.major = major; - this.minor = minor; - this.micro = micro; - this.qualifier = Objects.requireNonNull(qualifier); - this.suffix = null; - this.suffixVersion = null; - this.originalVersion = originalVersion; - } - - public SuffixedVersion( - int major, - int minor, - int micro, - String qualifier, - String suffix, - int suffixVersion, - String originalVersion) { - if (suffix == null || suffix.isEmpty()) { - throw new IllegalArgumentException("Suffix must be provided in this constructor."); - } - this.major = major; - this.minor = minor; - this.micro = micro; - this.qualifier = Objects.requireNonNull(qualifier); - this.suffix = Objects.requireNonNull(suffix); - this.suffixVersion = suffixVersion; - this.originalVersion = originalVersion; - } - - public Optional getSuffix() { - return Optional.ofNullable(suffix); - } - - public Optional getSuffixVersion() { - return Optional.ofNullable(suffixVersion); - } - - public boolean isSuffixed() { - return suffix != null; - } - - @Override - public int compareTo(SuffixedVersion other) { - int r = Integer.compare(this.major, other.major); - if (r != 0) { - return r; - } - r = Integer.compare(this.minor, other.minor); - if (r != 0) { - return r; - } - r = Integer.compare(this.micro, other.micro); - if (r != 0) { - return r; - } - r = this.qualifier.compareToIgnoreCase(other.qualifier); - if (r != 0) { - return r; - } - if (this.suffix == null) { - if (other.suffix == null) { - return 0; - } else { - return -1; - } - } else if (other.suffix == null) { - return 1; - } - r = this.suffix.compareToIgnoreCase(other.suffix); - if (r != 0) { - return r; - } - r = Integer.compare(this.suffixVersion, other.suffixVersion); - if (r != 0) { - return r; - } - if (this.isOsgiVersion() && !other.isOsgiVersion()) { - return 1; - } else if (!this.isOsgiVersion() && other.isOsgiVersion()) { - return -1; - } - return 0; - } - - private boolean isOsgiVersion() { - Version osgi = new Version(originalVersion); - return originalVersion.equals(osgi.getOSGiVersionString()); - } - - public final String normalizedVesion() { - String q = qualifier.isEmpty() ? "" : '.' + qualifier; - String s = ""; - if (suffix != null && !suffix.isEmpty()) { - s = q.isEmpty() ? "." : "-"; - s += suffix + '-' + suffixVersion; - } - return major + "." + minor + "." + micro + q + s; - } - - public final String unsuffixedVesion() { - String q = qualifier.isEmpty() ? "" : '.' + qualifier; - return major + "." + minor + "." + micro + q; - } - - @Override - public String toString() { - return normalizedVesion(); - } - -} diff --git a/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java b/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java deleted file mode 100644 index 3c25c8867..000000000 --- a/common/src/main/java/org/jboss/da/common/version/VersionAnalyzer.java +++ /dev/null @@ -1,167 +0,0 @@ -/* - * Copyright 2018 Honza Brázdil <jbrazdil@redhat.com>. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.jboss.da.common.version; - -import org.jboss.da.lookup.model.VersionDistanceRule; -import org.jboss.da.lookup.model.VersionFilter; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.EnumSet; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Objects; -import java.util.Optional; -import java.util.Set; -import java.util.regex.Matcher; -import java.util.regex.Pattern; -import java.util.stream.Collectors; - -import static org.jboss.da.common.version.VersionComparator.VersionDifference.EQUAL; -import static org.jboss.da.common.version.VersionComparator.VersionDifference.MICRO; -import static org.jboss.da.common.version.VersionComparator.VersionDifference.MINOR; -import static org.jboss.da.common.version.VersionComparator.VersionDifference.QUALIFIER; -import static org.jboss.da.common.version.VersionComparator.VersionDifference.RH_SUFFIX; -import static org.jboss.da.common.version.VersionComparator.VersionDifference.SUFFIX; - -/** - * @author Honza Brázdil <jbrazdil@redhat.com> - */ -public class VersionAnalyzer { - - public static final Map> ALLOWED_DIFFERENCE = new HashMap<>(); - static { - ALLOWED_DIFFERENCE.put(VersionFilter.ALL, EnumSet.allOf(VersionComparator.VersionDifference.class)); - ALLOWED_DIFFERENCE.put(VersionFilter.MAJOR, EnumSet.of(MINOR, MICRO, QUALIFIER, SUFFIX, RH_SUFFIX, EQUAL)); - ALLOWED_DIFFERENCE.put(VersionFilter.MAJOR_MINOR, EnumSet.of(MICRO, QUALIFIER, SUFFIX, RH_SUFFIX, EQUAL)); - ALLOWED_DIFFERENCE.put(VersionFilter.MAJOR_MINOR_MICRO, EnumSet.of(QUALIFIER, SUFFIX, RH_SUFFIX, EQUAL)); - ALLOWED_DIFFERENCE.put(VersionFilter.MAJOR_MINOR_MICRO_QUALIFIER, EnumSet.of(SUFFIX, RH_SUFFIX, EQUAL)); - } - - private static final Pattern VERSION_PATTERN = Pattern - .compile("^" + VersionParser.RE_MMM + VersionParser.RE_QUALIFIER_WITH_SEPARATOR + "?"); - - private final VersionParser versionParser; - private final List suffixes = new ArrayList<>(); - private final VersionDistanceRule distanceRule; - - public VersionAnalyzer(List suffixes) { - this(suffixes, VersionDistanceRule.RECOMMENDED_REPLACEMENT); - } - - public VersionAnalyzer(List suffixes, VersionDistanceRule distanceRule) { - this.suffixes.addAll(suffixes); - this.versionParser = new VersionParser(suffixes); - this.distanceRule = Objects.requireNonNull(distanceRule); - } - - public List sortVersions(String querry, Collection versions) { - VersionComparator comparator = new VersionComparator(querry, distanceRule, versionParser); - List sortedVersions = versions.stream().sorted(comparator).distinct().collect(Collectors.toList()); - return sortedVersions; - } - - public List filterVersions(String query, VersionFilter vf, Collection versions) { - VersionComparator vc = new VersionComparator(query, distanceRule, versionParser); - - return versions.stream() - .map(versionParser::parseSuffixed) - .flatMap(Set::stream) - .filter(v -> matches(vc, v, vf)) - .map(SuffixedVersion::getOriginalVersion) - .sorted(vc) - .distinct() - .collect(Collectors.toList()); - } - - private boolean matches(VersionComparator vc, SuffixedVersion v, VersionFilter vf) { - VersionComparator.VersionDifference difference = vc.difference(v); - return ALLOWED_DIFFERENCE.get(vf).contains(difference); - } - - public Optional findBiggestMatchingVersion(String query, Collection versions) { - String unsuffixedQuery = versionParser.parse(query).unsuffixedVesion(); - - List candidateSuffixedVersions = versions.stream() - .map(versionParser::parseSuffixed) - .flatMap(Set::stream) - .filter(v -> unsuffixedQuery.equals(v.unsuffixedVesion())) - .collect(Collectors.toList()); - - List versionsToSearch = Collections.emptyList(); - for (String suffix : suffixes) { - versionsToSearch = candidateSuffixedVersions.stream() - .filter(v -> suffix.equals(v.getSuffix().get())) - .collect(Collectors.toList()); - if (!versionsToSearch.isEmpty()) { - break; - } - } - - String bestMatchVersion = null; - int biggestBuildNumber = 0; - for (SuffixedVersion ver : versionsToSearch) { - int foundBuildNumber = ver.getSuffixVersion().get(); - if (bestMatchVersion == null || foundBuildNumber > biggestBuildNumber) { - bestMatchVersion = ver.getOriginalVersion(); - biggestBuildNumber = foundBuildNumber; - } else if (foundBuildNumber == biggestBuildNumber) { - bestMatchVersion = getMoreSpecificVersion(bestMatchVersion, ver.getOriginalVersion()); - } - } - - return Optional.ofNullable(bestMatchVersion); - } - - /** - * Assuming the two versions have the same OSGi representation, returns the more specific version. That means - * X.Y.Z.something is preffered to X.Y.something which is preffered to X.something. - */ - private String getMoreSpecificVersion(String first, String second) { - Matcher firstMatcher = VERSION_PATTERN.matcher(first); - Matcher secondMatcher = VERSION_PATTERN.matcher(second); - if (!firstMatcher.matches()) { - throw new IllegalArgumentException("Couldn't parse version " + first); - } - if (!secondMatcher.matches()) { - throw new IllegalArgumentException("Couldn't parse version " + second); - } - boolean firstIsOSGi = first.equals(VersionParser.getOSGiVersion(first)); - String firstMinor = firstMatcher.group("minor"); - String firstMicro = firstMatcher.group("micro"); - boolean returnFirst; - - if (firstIsOSGi != second.equals(VersionParser.getOSGiVersion(second))) { - returnFirst = firstIsOSGi; // One of the version is not OSGi, prefer the OSGi version - } else if (!Objects.equals(firstMinor, secondMatcher.group("minor"))) { - returnFirst = firstMinor != null; // One of the versions is missing minor number, prefer the one with it - } else if (!Objects.equals(firstMicro, secondMatcher.group("micro"))) { - returnFirst = firstMicro != null; // One of the versions is missing micro number, prefer the one with it - } else { - // Prefer the version that separates qualifier with '.', not something else like '-' - // If both are the same, prefer first - returnFirst = firstMatcher.group("qualifier").startsWith(".") - || !secondMatcher.group("qualifier").startsWith("."); - } - if (returnFirst) { - return first; - } else { - return second; - } - } -} diff --git a/common/src/main/java/org/jboss/da/common/version/VersionComparator.java b/common/src/main/java/org/jboss/da/common/version/VersionComparator.java deleted file mode 100644 index 35eb98854..000000000 --- a/common/src/main/java/org/jboss/da/common/version/VersionComparator.java +++ /dev/null @@ -1,277 +0,0 @@ -package org.jboss.da.common.version; - -import org.jboss.da.lookup.model.VersionDistanceRule; - -import java.io.Serializable; -import java.util.Arrays; -import java.util.Comparator; -import java.util.Objects; - -import static org.jboss.da.common.version.VersionComparator.VersionDifference.MAJOR; -import static org.jboss.da.common.version.VersionComparator.VersionDifference.MICRO; -import static org.jboss.da.common.version.VersionComparator.VersionDifference.MINOR; -import static org.jboss.da.common.version.VersionComparator.VersionDifference.QUALIFIER; -import static org.jboss.da.common.version.VersionComparator.VersionDifference.RH_SUFFIX; -import static org.jboss.da.common.version.VersionComparator.VersionDifference.SUFFIX; - -/** - * - * @author Honza Brázdil <jbrazdil@redhat.com> - */ -public class VersionComparator implements Comparator, Serializable { - - private final VersionDistanceRule distanceRule; - - public enum VersionDifference { - MAJOR, MINOR, MICRO, QUALIFIER, SUFFIX, RH_SUFFIX, EQUAL; - } - - private final SuffixedVersion base; - - private final VersionParser versionParser; - - /** - * Returns classic comparator for versions. - * - * @param versionParser Parser that will be used to parse the version. - */ - public VersionComparator(VersionParser versionParser) { - this.base = null; - this.distanceRule = null; - this.versionParser = Objects.requireNonNull(versionParser); - } - - /** - * Returns comparator that compares versions by distance to the base version. The - * {@link VersionDistanceRule#RECOMMENDED_REPLACEMENT} rule for computing the distance to base version is used. - * - * @param base The base version. - * @param versionParser Parser that will be used to parse the version. - */ - public VersionComparator(String base, VersionParser versionParser) { - this(base, VersionDistanceRule.RECOMMENDED_REPLACEMENT, versionParser); - } - - /** - * Returns comparator that compares versions by distance to the base version. - * - * @param base The base version. - * @param distanceRule The rule that is used to compute the distance to base version. - * @param versionParser Parser that will be used to parse the version. - */ - public VersionComparator(String base, VersionDistanceRule distanceRule, VersionParser versionParser) { - this.versionParser = Objects.requireNonNull(versionParser); - this.base = versionParser.parse(Objects.requireNonNull(base)); - this.distanceRule = Objects.requireNonNull(distanceRule); - } - - /** - * Return information about first part of version that is different. - */ - public VersionDifference difference(String version1, String version2) { - SuffixedVersion v1 = versionParser.parse(version1); - SuffixedVersion v2 = versionParser.parse(version2); - return difference(v1, v2); - } - - /** - * Return information about first part of version that is different. - */ - public VersionDifference difference(SuffixedVersion v1, SuffixedVersion v2) { - if (v1.getMajor() != v2.getMajor()) { - return MAJOR; - } - if (v1.getMinor() != v2.getMinor()) { - return MINOR; - } - if (v1.getMicro() != v2.getMicro()) { - return VersionDifference.MICRO; - } - if (!v1.getQualifier().equals(v2.getQualifier())) { - return QUALIFIER; - } - if (!v1.getSuffix().equals(v2.getSuffix())) { - return SUFFIX; - } - if (!v1.getSuffixVersion().equals(v2.getSuffixVersion())) { - return RH_SUFFIX; - } - return VersionDifference.EQUAL; - } - - /** - * Return information about first part of version that is different, compared to the base version. - */ - public VersionDifference difference(SuffixedVersion version) { - return difference(base, version); - } - - @Override - public int compare(String version1, String version2) { - SuffixedVersion v1 = versionParser.parse(version1); - SuffixedVersion v2 = versionParser.parse(version2); - int r = v1.compareTo(v2); - if (r == 0 || base == null) { - return r; - } else { - switch (distanceRule) { - case RECOMMENDED_REPLACEMENT: - return compareAsRecommendedReplacement(v1, v2); - case CLOSEST_BY_PARTS: - return compareAsClosestByParts(v1, v2); - default: - throw new UnsupportedOperationException("Unknown distance rule " + distanceRule); - } - } - } - - // Assuming different versions - // Return -1 - v1 is closer to the base version - // Return 1 - v2 is closer to the base version - private int compareAsRecommendedReplacement(SuffixedVersion v1, SuffixedVersion v2) { - // If one of the versions is the same as base, it is closer. - if (base.equals(v1)) { - return -1; - } - if (base.equals(v2)) { - return 1; - } - - // If one version differs from the base in major, the other is closer no matter what - if (v1.getMajor() != v2.getMajor()) { - if (v1.getMajor() == base.getMajor()) { - return -1; - } - if (v2.getMajor() == base.getMajor()) { - return 1; - } - } - - // Sort the 3 versions - SuffixedVersion[] versions = { base, v1, v2 }; - Arrays.sort(versions); - - if (versions[0] == base) { // v1 and v2 are greater than base, use the lowest of them - int candidate; - if (versions[1] == v1) { - candidate = -1; - } else { - candidate = 1; - } - - // if differs only in qualifier, higher qualifier preferred - if (v1.getMajor() == v2.getMajor() && v1.getMinor() == v2.getMinor() && v1.getMicro() == v2.getMicro()) { - candidate *= -1; - } - return candidate; - } else if (versions[2] == base) { // v1 and v2 are lower than base, use the greatest of them - if (versions[1] == v1) { - return -1; - } else { - return 1; - } - } else { // one is lower than base, second is greater than base. Use the greater. - if (versions[2] == v1) { - return -1; - } else { - return 1; - } - } - } - - // Assuming different versions - // Return -1 - v1 is closer to the base version - // Return 1 - v2 is closer to the base version - private int compareAsClosestByParts(SuffixedVersion v1, SuffixedVersion v2) { - // If one of the versions is the same as base, it is closer. - if (base.equals(v1)) { - return -1; - } - if (base.equals(v2)) { - return 1; - } - - VersionDifference difference = difference(v1, v2); - VersionDifference differenceV1ToBase = difference(base, v1); - VersionDifference differenceV2ToBase = difference(base, v2); - - // Rule 1 - if (differenceV1ToBase != differenceV2ToBase) { - switch (difference) { - case MAJOR: - return differenceV1ToBase == MAJOR ? 1 : -1; - case MINOR: - return differenceV1ToBase == MINOR ? 1 : -1; - case MICRO: - return differenceV1ToBase == MICRO ? 1 : -1; - case QUALIFIER: - return differenceV1ToBase == QUALIFIER ? 1 : -1; - case SUFFIX: - return differenceV1ToBase == SUFFIX ? 1 : -1; - case RH_SUFFIX: - return differenceV1ToBase == RH_SUFFIX ? 1 : -1; - default: - throw new IllegalStateException("Unknown difference " + difference); - } - } - - // Rule 2 - if (differenceV1ToBase == differenceV2ToBase && differenceV1ToBase == difference) { - switch (difference) { - case MAJOR: - return comparePart(base.getMajor(), v1.getMajor(), v2.getMajor()); - case MINOR: - return comparePart(base.getMinor(), v1.getMinor(), v2.getMinor()); - case MICRO: - return comparePart(base.getMicro(), v1.getMicro(), v2.getMicro()); - } - } - - // Rule 3 - SuffixedVersion[] versions = { base, v1, v2 }; - Arrays.sort(versions); - - if (versions[0] == base) { // v1 and v2 are greater than base, use the lowest of them - int candidate; - if (versions[1] == v1) { - candidate = -1; - } else { - candidate = 1; - } - - // if differs only in qualifier, higher qualifier preferred - if (difference != MAJOR && difference != MINOR && difference != MICRO) { - candidate *= -1; - } - return candidate; - } else if (versions[2] == base) { // v1 and v2 are lower than base, use the greatest of them - if (versions[1] == v1) { - return -1; - } else { - return 1; - } - } else { // one is lower than base, second is greater than base. They MUST differ in qualifier, so use greater - if (difference == MAJOR || difference == MINOR || difference == MICRO) { - throw new IllegalStateException("Broken rule 2"); - } - if (versions[2] == v1) { - return -1; - } else { - return 1; - } - } - } - - private int comparePart(int base, int v1, int v2) { - int v1diff = Math.abs(base - v1); - int v2diff = Math.abs(base - v2); - if (v1diff == v2diff) { - if (v1 > v2) { - return -1; - } else { - return 1; - } - } - return v1diff - v2diff; - } -} diff --git a/common/src/main/java/org/jboss/da/common/version/VersionParser.java b/common/src/main/java/org/jboss/da/common/version/VersionParser.java deleted file mode 100644 index 985a3a1cd..000000000 --- a/common/src/main/java/org/jboss/da/common/version/VersionParser.java +++ /dev/null @@ -1,147 +0,0 @@ -package org.jboss.da.common.version; - -import org.commonjava.maven.ext.manip.impl.Version; - -import java.util.Arrays; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.regex.Matcher; -import java.util.regex.Pattern; - -public class VersionParser { - - private final Map versionPatterns = new HashMap<>(); - - // single dot at the end of the version indicates ommited micro "0" - // NCLSUP-132 asks to allow dash instead of dot before micro - static final String RE_MICRO = "(\\.$|[.-](?[0-9]{1,9}))"; - - // major.minor.micro.qualifier-suffix-X - // numbers limited to max 9 digits, beacuse of integer limitatations - static final String RE_MMM = "((?[0-9]{1,9})?(\\.(?[0-9]{1,9})" + RE_MICRO + "?)?)"; - - static final String RE_QUALIFIER = "([.-]?(?.+?))"; - // this differs from RE_QUALIFIER only in that the group also contains the [.-] separator - static final String RE_QUALIFIER_WITH_SEPARATOR = "(?[.-]?(.+?))"; - - private static final String RE_SUFFIX_S = "([.-]"; - - private static final String RE_SUFFIX_E = "-(?[0-9]{1,9}))?"; - - private static final Pattern UNSUFFIXED_PATTERN = Pattern.compile("^" + RE_MMM + RE_QUALIFIER + "?" + "$"); - - public VersionParser(String... suffix) { - this(Arrays.asList(suffix)); - } - - public VersionParser(List suffixes) { - for (String suffix : suffixes) { - this.versionPatterns.put( - suffix, - Pattern.compile("^" + RE_MMM + RE_QUALIFIER + "??" + RE_SUFFIX_S + suffix + RE_SUFFIX_E + "$")); - } - } - - public static SuffixedVersion parseUnsuffixed(String version) { - return parseVersion(UNSUFFIXED_PATTERN.matcher(version), version); - } - - /** - * Parses the version string and returns the normalized version (with longest suffix). Because the version may have - * any of the suffixes (ore none) the normalized version is the one with the longest suffix (or in other words with - * shortest version string after removing the suffix). - * - * @param version The original version string. - * @return The normalized version - */ - public SuffixedVersion parse(String version) { - SuffixedVersion normalized = parseUnsuffixed(version); - int length = normalized.getQualifier().length(); - for (SuffixedVersion suffixedVersion : parseSuffixed(version)) { - if (suffixedVersion.getQualifier().length() < length) { - normalized = suffixedVersion; - length = suffixedVersion.getQualifier().length(); - } - } - return normalized; - } - - /** - * Returns suffixed versions that can be parsed from the provided version string. - * - * @param version The version string to parse - * @return Set of suffixed versions parsable from the version string. - */ - public Set parseSuffixed(String version) { - Set ret = new HashSet<>(); - for (Map.Entry entry : versionPatterns.entrySet()) { - String suffix = entry.getKey(); - Pattern versionPattern = entry.getValue(); - SuffixedVersion suffixedVersion = parseVersion(versionPattern.matcher(version), version, suffix); - if (suffixedVersion.isSuffixed()) { - ret.add(suffixedVersion); - } - } - return ret; - } - - private static SuffixedVersion parseVersion(Matcher versionMatcher, String version) - throws NumberFormatException, IllegalArgumentException { - if (!versionMatcher.matches()) { - throw new IllegalArgumentException("Version " + version + "is unparsable"); - } - String majorString = versionMatcher.group("major"); - String minorString = versionMatcher.group("minor"); - String microString = versionMatcher.group("micro"); - String qualifierString = versionMatcher.group("qualifier"); - - int major = parseNumberString(majorString); - int minor = parseNumberString(minorString); - int micro = parseNumberString(microString); - String qualifier = qualifierString == null ? "" : qualifierString.replace('.', '-').replace(',', '-'); - return new SuffixedVersion(major, minor, micro, qualifier, version); - } - - private static SuffixedVersion parseVersion(Matcher versionMatcher, String version, String parseSuffix) - throws NumberFormatException, IllegalArgumentException { - if (!versionMatcher.matches()) { - throw new IllegalArgumentException("Version " + version + "is unparsable"); - } - String majorString = versionMatcher.group("major"); - String minorString = versionMatcher.group("minor"); - String microString = versionMatcher.group("micro"); - String qualifierString = versionMatcher.group("qualifier"); - String suffixVersionString = versionMatcher.group("suffixversion"); - - int major = parseNumberString(majorString); - int minor = parseNumberString(minorString); - int micro = parseNumberString(microString); - String qualifier = qualifierString == null ? "" : qualifierString.replace('.', '-').replace(',', '-'); - if (suffixVersionString == null) { - return new SuffixedVersion(major, minor, micro, qualifier, version); - } else { - int suffixVersion = Integer.parseInt(suffixVersionString); - return new SuffixedVersion(major, minor, micro, qualifier, parseSuffix, suffixVersion, version); - } - } - - private static int parseNumberString(String segmentString) { - return segmentString == null ? 0 : Integer.parseInt(segmentString); - } - - /** - * Converts version to osgi compliant - * - * @param version - * @return - */ - public static String getOSGiVersion(String version) { - String osgiS = (new Version(version + ".foo")).getOSGiVersionString(); - int len = osgiS.length(); - return osgiS.substring(0, len - 4); - } - -} diff --git a/common/src/test/java/org/jboss/da/common/version/SuffixedVersionTest.java b/common/src/test/java/org/jboss/da/common/version/SuffixedVersionTest.java deleted file mode 100644 index e6bee105e..000000000 --- a/common/src/test/java/org/jboss/da/common/version/SuffixedVersionTest.java +++ /dev/null @@ -1,61 +0,0 @@ -/* - * Copyright 2018 Honza Brázdil <jbrazdil@redhat.com>. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.jboss.da.common.version; - -import org.junit.Assert; -import org.junit.Test; - -/** - * - * @author Honza Brázdil <jbrazdil@redhat.com> - */ -public class SuffixedVersionTest { - - @Test - public void testSimpleVersions() { - SuffixedVersion v1 = new SuffixedVersion(1, 2, 3, "", "1.2.3"); - SuffixedVersion v2 = new SuffixedVersion(1, 2, 3, "", "1.2.3"); - SuffixedVersion v3 = new SuffixedVersion(1, 2, 4, "", "1.2.4"); - SuffixedVersion v4 = new SuffixedVersion(2, 3, 4, "foobar", "2.3.4.foobar"); - Assert.assertEquals(1, v1.getMajor()); - Assert.assertEquals(2, v1.getMinor()); - Assert.assertEquals(3, v1.getMicro()); - Assert.assertEquals("", v1.getQualifier()); - Assert.assertEquals("foobar", v4.getQualifier()); - Assert.assertTrue(v1.equals(v2)); - Assert.assertFalse(v1.equals(v3)); - Assert.assertEquals("1.2.3", v1.toString()); - Assert.assertEquals("2.3.4.foobar", v4.toString()); - } - - @Test - public void testSuffixedVersions() { - SuffixedVersion v1 = new SuffixedVersion(1, 2, 3, "", "suffix", 1, "1.2.3.suffix-1"); - SuffixedVersion v2 = new SuffixedVersion(1, 2, 3, "", "suffix", 1, "1.2.3.suffix-1"); - SuffixedVersion v3a = new SuffixedVersion(1, 2, 3, "", "suffix", 2, "1.2.3.suffix-2"); - SuffixedVersion v3b = new SuffixedVersion(1, 2, 3, "", "xiffus", 1, "1.2.3.xiffus-1"); - SuffixedVersion v4 = new SuffixedVersion(2, 3, 4, "foobar", "suffix", 1, "2.3.4.foobar-suffix-1"); - Assert.assertEquals("suffix", v1.getSuffix().get()); - Assert.assertEquals(Integer.valueOf(1), v1.getSuffixVersion().get()); - Assert.assertEquals(Integer.valueOf(2), v3a.getSuffixVersion().get()); - Assert.assertEquals("", v1.getQualifier()); - Assert.assertTrue(v1.equals(v2)); - Assert.assertFalse(v1.equals(v3a)); - Assert.assertFalse(v1.equals(v3b)); - Assert.assertEquals("1.2.3.suffix-1", v1.toString()); - Assert.assertEquals("2.3.4.foobar-suffix-1", v4.toString()); - } -} diff --git a/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java b/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java deleted file mode 100644 index 1cce2f4df..000000000 --- a/common/src/test/java/org/jboss/da/common/version/VersionAnalyzerTest.java +++ /dev/null @@ -1,325 +0,0 @@ -package org.jboss.da.common.version; - -import org.jboss.da.common.CommunicationException; -import org.junit.Test; - -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import java.util.Optional; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -/** - * - * @author Jakub Bartecek <jbartece@redhat.com> - * - */ -public class VersionAnalyzerTest { - - private VersionAnalyzer versionFinder = new VersionAnalyzer(Collections.singletonList("redhat")); - - private static final String NO_BUILT_VERSION = "1.1.3"; - - private static final String NO_BUILT_VERSION_2 = "1.0.20"; - - private static final String BUILT_VERSION = "1.1.4"; - - private static final String BUILT_VERSION_RH = BUILT_VERSION + "-redhat-20"; - - private static final String BUILT_VERSION_2 = "1.1.4.Final"; - - private static final String BUILT_VERSION_2_RH = BUILT_VERSION_2 + "-redhat-10"; - - private static final String MULTI_BUILT_VERSION = "1.1.5"; - - private static final String MULTI_BUILT_VERSION_RH1 = MULTI_BUILT_VERSION + ".redhat-5"; - - private static final String MULTI_BUILT_VERSION_RH2 = MULTI_BUILT_VERSION + ".redhat-3"; - - private static final String MULTI_BUILT_VERSION_RH_BEST = MULTI_BUILT_VERSION + ".redhat-18"; - - private static final String MULTI_BUILT_VERSION_RH4 = MULTI_BUILT_VERSION + ".redhat-16"; - - private static final String OTHER_RH_VERSION_1 = "1.0.0.redhat-1"; - - private static final String OTHER_RH_VERSION_2 = "1.0.0.redhat-18"; - - private static final String OTHER_RH_VERSION_3 = "1.1.1.redhat-15"; - - private static final String NON_OSGI_VERSION = "1.3"; - - private static final String NON_OSGI_VERSION_RHT = "1.3.redhat-4"; - - private static final String NON_OSGI_VERSION_2 = "1.3-Final"; - - private static final String NON_OSGI_VERSION_2_RHT = "1.3.0.Final-redhat-7"; - - private static final String NON_OSGI_VERSION_3 = "1.2.3.foo.bar.baz"; - - private static final String NON_OSGI_VERSION_3_RHT = "1.2.3.foo-bar-baz-redhat-5"; - - private static final String NON_OSGI_VERSION_4 = "1.5.9.foo,bar,baz"; - - private static final String NON_OSGI_VERSION_4_RHT = "1.5.9.foo-bar-baz-redhat-8"; - - private static final List All_VERSIONS = Arrays.asList( - OTHER_RH_VERSION_1, - OTHER_RH_VERSION_2, - NO_BUILT_VERSION_2, - NO_BUILT_VERSION, - OTHER_RH_VERSION_3, - MULTI_BUILT_VERSION_RH2, - BUILT_VERSION_RH, - MULTI_BUILT_VERSION_RH1, - BUILT_VERSION_2_RH, - MULTI_BUILT_VERSION_RH_BEST, - MULTI_BUILT_VERSION_RH4, - NON_OSGI_VERSION, - NON_OSGI_VERSION_RHT, - BUILT_VERSION_2, - NON_OSGI_VERSION_2, - NON_OSGI_VERSION_2_RHT, - NON_OSGI_VERSION_3, - NON_OSGI_VERSION_3_RHT, - NON_OSGI_VERSION_4, - NON_OSGI_VERSION_4_RHT); - - private static final List BUILT_VERSIONS = Arrays.asList( - OTHER_RH_VERSION_1, - OTHER_RH_VERSION_2, - OTHER_RH_VERSION_3, - MULTI_BUILT_VERSION_RH2, - BUILT_VERSION_RH, - MULTI_BUILT_VERSION_RH1, - BUILT_VERSION_2_RH, - MULTI_BUILT_VERSION_RH_BEST, - MULTI_BUILT_VERSION_RH4, - NON_OSGI_VERSION_RHT, - NON_OSGI_VERSION_2_RHT, - NON_OSGI_VERSION_3_RHT, - NON_OSGI_VERSION_4_RHT); - - @Test - public void getBestMatchVersionForNonExistingGAV() throws CommunicationException { - Optional bmv = versionFinder.findBiggestMatchingVersion("0.0.1", Collections.EMPTY_LIST); - assertFalse("Best match version expected to not be present", bmv.isPresent()); - } - - @Test - public void getBestMatchVersionForNotBuiltGAV() throws CommunicationException { - Optional bmv = versionFinder.findBiggestMatchingVersion(NO_BUILT_VERSION, All_VERSIONS); - assertFalse("Best match version expected to not be present", bmv.isPresent()); - } - - @Test - public void getBestMatchVersionForBuiltGAV() throws CommunicationException { - checkBMV(BUILT_VERSION_RH, BUILT_VERSION, All_VERSIONS.toArray(new String[All_VERSIONS.size()])); - checkBMV(BUILT_VERSION_2_RH, BUILT_VERSION_2, All_VERSIONS.toArray(new String[All_VERSIONS.size()])); - } - - @Test - public void getBestMatchVersionForMultipleBuiltGAV() throws CommunicationException { - checkBMV( - MULTI_BUILT_VERSION_RH_BEST, - MULTI_BUILT_VERSION, - All_VERSIONS.toArray(new String[All_VERSIONS.size()])); - } - - @Test - public void getBestMatchVersionForNoOSGIGAV() throws CommunicationException { - checkBMV(NON_OSGI_VERSION_RHT, NON_OSGI_VERSION, All_VERSIONS.toArray(new String[All_VERSIONS.size()])); - checkBMV(NON_OSGI_VERSION_2_RHT, NON_OSGI_VERSION_2, All_VERSIONS.toArray(new String[All_VERSIONS.size()])); - checkBMV(NON_OSGI_VERSION_3_RHT, NON_OSGI_VERSION_3, All_VERSIONS.toArray(new String[All_VERSIONS.size()])); - checkBMV(NON_OSGI_VERSION_4_RHT, NON_OSGI_VERSION_4, All_VERSIONS.toArray(new String[All_VERSIONS.size()])); - } - - @Test - public void NCL2931ReproducerTest() { - String[] avaliableVersions = { - "1.4.0.redhat-4", - "1.4.redhat-3", - "1.4-redhat-2", - "1.4-redhat-1", - "1.6.0.redhat-5", - "1.6.0.redhat-4", - "1.6.0.redhat-3", - "1.6.redhat-2", - "1.6.redhat-1", - "1.9.0.redhat-1", - "1.10.0.redhat-5", - "1.10.0.redhat-4", - "1.10.0.redhat-3", - "1.10.0.redhat-2", - "1.10.0.redhat-1" }; - checkBMV("1.4.0.redhat-4", "1.4", avaliableVersions); - } - - @Test - public void ambiguousNonOSGIVersionsTest() { - String[] avaliableVersionsWithOSGI = { "1.0.0.redhat-1", "1.0.redhat-1", "1.redhat-1" }; - checkBMV("1.0.0.redhat-1", "1.0.0", avaliableVersionsWithOSGI); - checkBMV("1.0.0.redhat-1", "1.0", avaliableVersionsWithOSGI); - checkBMV("1.0.0.redhat-1", "1", avaliableVersionsWithOSGI); - - String[] avaliableVersionsWithOSGIRev = { "1.redhat-1", "1.0.redhat-1", "1.0.0.redhat-1" }; - checkBMV("1.0.0.redhat-1", "1.0.0", avaliableVersionsWithOSGIRev); - checkBMV("1.0.0.redhat-1", "1.0", avaliableVersionsWithOSGIRev); - checkBMV("1.0.0.redhat-1", "1", avaliableVersionsWithOSGIRev); - - String[] avaliableVersionsWithoutOSGI = { "1.0.redhat-1", "1.redhat-1" }; - checkBMV("1.0.redhat-1", "1.0.0", avaliableVersionsWithoutOSGI); - checkBMV("1.0.redhat-1", "1.0", avaliableVersionsWithoutOSGI); - checkBMV("1.0.redhat-1", "1", avaliableVersionsWithoutOSGI); - - String[] avaliableVersionsWithoutOSGI2 = { "1.redhat-1" }; - checkBMV("1.redhat-1", "1.0.0", avaliableVersionsWithoutOSGI2); - checkBMV("1.redhat-1", "1.0", avaliableVersionsWithoutOSGI2); - checkBMV("1.redhat-1", "1", avaliableVersionsWithoutOSGI2); - } - - @Test - public void nonOSGIVersionsTest() { - String[] avaliableVersions1 = { "1.0.0.redhat-1", "1.0.redhat-2", "1.redhat-3" }; - checkBMV("1.redhat-3", "1.0.0", avaliableVersions1); - checkBMV("1.redhat-3", "1.0", avaliableVersions1); - checkBMV("1.redhat-3", "1", avaliableVersions1); - - String[] avaliableVersions10 = { "1.0.0.redhat-1", "1.0.redhat-3", "1.redhat-2" }; - checkBMV("1.0.redhat-3", "1.0.0", avaliableVersions10); - checkBMV("1.0.redhat-3", "1.0", avaliableVersions10); - checkBMV("1.0.redhat-3", "1", avaliableVersions10); - - String[] avaliableVersions100 = { "1.0.0.redhat-3", "1.0.redhat-2", "1.redhat-1" }; - checkBMV("1.0.0.redhat-3", "1.0.0", avaliableVersions100); - checkBMV("1.0.0.redhat-3", "1.0", avaliableVersions100); - checkBMV("1.0.0.redhat-3", "1", avaliableVersions100); - } - - @Test - public void NCL4266ReproducerTest() { - String[] avaliableVersions1 = { - "2.2.3.redhat-00001", - "2.2.0.temporary-redhat-00001", - "2.2.0.redhat-00001", - "2.1.16.redhat-00001", - "2.1.9.redhat-1", - "2.1.9.redhat-001", - "2.1.3.redhat-001" }; - checkBMV( - new VersionAnalyzer(Arrays.asList("temporary-redhat", "redhat")), - "2.2.3.redhat-00001", - "2.2.3", - avaliableVersions1); - } - - @Test - public void preferOSGiVersionFormatTest() { - // as 3.0.0-redhat-2 and 3.0.0.redhat-2 are the same version then ordering in the array matters - // (if they were in opposite direction test would pass even without OSGi preference) - String[] availableVersions = { - "3-redhat-2", - "3.0.0-redhat-2", - "3.0.0.redhat-2", - "3.0.0.redhat-1", - "2.1.1.redhat-3", - "2.1.16-redhat-9", - "2.9.9-redhat-00001" }; - checkBMV("3.0.0.redhat-2", "3", availableVersions); - Collections.reverse(Arrays.asList(availableVersions)); - checkBMV("3.0.0.redhat-2", "3", availableVersions); - String[] availableVersions2 = { - "2.1.1.redhat-3", - "2.1.16-redhat-9", - "3-redhat-2", - "3.0-redhat-2", - "3.0.redhat-2", - "3.0.-redhat-2", - "3.0.0-redhat-2", - "3.0.0.redhat-1", - "3.0.0.redhat-2", - "2.9.9-redhat-00001" }; - checkBMV("3.0.0.redhat-2", "3", availableVersions2); - Collections.reverse(Arrays.asList(availableVersions2)); - checkBMV("3.0.0.redhat-2", "3", availableVersions2); - String[] availableVersions3 = { - "2.1.1.redhat-3", - "2.1.16-redhat-9", - "3-redhat-2", - "3.0-redhat-2", - "3.0.redhat-2", - "3.0.-redhat-2", - "3.0.0-redhat-2", - "3.0.0.redhat-1", - "2.9.9-redhat-00001" }; - checkBMV("3.0.0-redhat-2", "3", availableVersions3); - Collections.reverse(Arrays.asList(availableVersions3)); - checkBMV("3.0.0-redhat-2", "3", availableVersions3); - String[] availableVersions4 = { - "2.1.1.redhat-3", - "2.1.16-redhat-9", - "3-redhat-2", - "3.0-redhat-2", - "3.0.redhat-2", - "3.0.0.redhat-1", - "2.9.9-redhat-00001" }; - checkBMV("3.0.redhat-2", "3", availableVersions4); - Collections.reverse(Arrays.asList(availableVersions4)); - checkBMV("3.0.redhat-2", "3", availableVersions4); - } - - private void checkBMV(String expectedVersion, String version, String[] versions) { - checkBMV(versionFinder, expectedVersion, version, versions); - } - - private void checkBMV(VersionAnalyzer versionAnalyzer, String expectedVersion, String version, String[] versions) { - Optional bmv = versionAnalyzer.findBiggestMatchingVersion(version, Arrays.asList(versions)); - - assertTrue("Best match version expected to be present", bmv.isPresent()); - assertEquals(expectedVersion, bmv.get()); - } - - @Test - public void testDifferentSuffix() { - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(Arrays.asList("temporary-redhat", "redhat")); - String version = "1.4.0"; - String expectedVersion = "1.4.0.temporary-redhat-1"; - - String[] avaliableVersionsOrder1 = { "1.4.0.redhat-1", "1.4.0.temporary-redhat-1" }; - checkBMV(versionAnalyzer, expectedVersion, version, avaliableVersionsOrder1); - - String[] avaliableVersionsOrder2 = { "1.4.0.temporary-redhat-1", "1.4.0.redhat-1" }; - checkBMV(versionAnalyzer, expectedVersion, version, avaliableVersionsOrder2); - - String[] avaliableVersionsMultiple = { - "1.4.0.redhat-4", - "1.4.0.redhat-3", - "1.4.0.redhat-2", - "1.4.0.redhat-1", - "1.4.0.temporary-redhat-1", }; - checkBMV(versionAnalyzer, expectedVersion, version, avaliableVersionsMultiple); - } - - @Test - public void testDifferentSuffixWithOnlyDefaultVersions() { - VersionAnalyzer versionAnalyzer = new VersionAnalyzer(Arrays.asList("t20180522-115319-991-redhat", "redhat")); - String version = "1.4.0"; - - String[] avaliableVersionsOrder1 = { "1.4.0.redhat-1", "1.4.0.temporary-redhat-1" }; - checkBMV(versionAnalyzer, "1.4.0.redhat-1", version, avaliableVersionsOrder1); - - String[] avaliableVersionsOrder2 = { "1.4.0.temporary-redhat-1", "1.4.0.redhat-1" }; - checkBMV(versionAnalyzer, "1.4.0.redhat-1", version, avaliableVersionsOrder2); - - String[] avaliableVersionsMultiple = { - "1.4.0.redhat-4", - "1.4.0.redhat-3", - "1.4.0.redhat-2", - "1.4.0.redhat-1", - "1.4.0.temporary-redhat-1", }; - checkBMV(versionAnalyzer, "1.4.0.redhat-4", version, avaliableVersionsMultiple); - } - -} diff --git a/common/src/test/java/org/jboss/da/common/version/VersionComparatorTest.java b/common/src/test/java/org/jboss/da/common/version/VersionComparatorTest.java deleted file mode 100644 index dc3fd9363..000000000 --- a/common/src/test/java/org/jboss/da/common/version/VersionComparatorTest.java +++ /dev/null @@ -1,288 +0,0 @@ -package org.jboss.da.common.version; - -import org.jboss.da.lookup.model.VersionDistanceRule; -import org.junit.Test; - -import static org.jboss.da.common.version.VersionComparator.VersionDifference.EQUAL; -import static org.jboss.da.common.version.VersionComparator.VersionDifference.MAJOR; -import static org.jboss.da.common.version.VersionComparator.VersionDifference.MICRO; -import static org.jboss.da.common.version.VersionComparator.VersionDifference.MINOR; -import static org.jboss.da.common.version.VersionComparator.VersionDifference.QUALIFIER; -import static org.jboss.da.common.version.VersionComparator.VersionDifference.RH_SUFFIX; -import static org.jboss.da.common.version.VersionComparator.VersionDifference.SUFFIX; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; - -/** - * - * @author Honza Brázdil <jbrazdil@redhat.com> - */ -public class VersionComparatorTest { - - private static final VersionParser VERSION_PARSER = new VersionParser("redhat"); - - @Test - public void testCompareVersion() { - VersionComparator vc = new VersionComparator(VERSION_PARSER); - - assertTrue(vc.compare("3.4.2.Final", "2.4.2.Final") > 0); - assertTrue(vc.compare("3.4.2.Final", "3.3.2.Final") > 0); - assertTrue(vc.compare("3.4.2.Final", "3.4.1.Final") > 0); - assertTrue(vc.compare("3.4.2.Final", "3.4.2.Beta") > 0); - - assertTrue(vc.compare("3.0.0.Final", "3.Final") == 0); - assertTrue(vc.compare("3.0.0.Final", "3.0.Final") == 0); - assertTrue(vc.compare("3.0.0.Final", "3.0.0.Final") == 0); - - assertTrue(vc.compare("3.0.0", "3") == 0); - assertTrue(vc.compare("3.0.0", "3.0") == 0); - assertTrue(vc.compare("3.0.0", "3.0.0") == 0); - - assertTrue(vc.compare("b10", "0.0.0.b10") == 0); - - assertTrue(vc.compare("3.4.2.Final", "4.4.2.Final") < 0); - assertTrue(vc.compare("3.4.2.Final", "3.5.2.Final") < 0); - assertTrue(vc.compare("3.4.2.Final", "3.4.3.Final") < 0); - - assertTrue(vc.compare("3.4.2.Alpha", "3.4.2.Beta") < 0); - - assertTrue(vc.compare("3.4.2.Final", "3.4.2.Final-redhat-1") < 0); - assertTrue(vc.compare("3.4.2", "3.4.2.redhat-1") < 0); - - assertTrue(vc.compare("3.4.2.Final-redhat-1", "3.4.2.Final-redhat-2") < 0); - assertTrue(vc.compare("3.4.2.redhat-1", "3.4.2.redhat-2") < 0); - - // These are equivalent, but OSGI version is preferred (NCL-4532) - assertTrue(vc.compare("3-redhat-2", "3.0.0.redhat-2") < 0); - assertTrue(vc.compare("3.redhat-2", "3.0.0.redhat-2") < 0); - assertTrue(vc.compare("3.0-redhat-2", "3.0.0.redhat-2") < 0); - assertTrue(vc.compare("3.0.redhat-2", "3.0.0.redhat-2") < 0); - assertTrue(vc.compare("3.0.0-redhat-2", "3.0.0.redhat-2") < 0); - } - - @Test - public void testCompareVersionWithMultipleSuffixes() { - VersionComparator vc1 = new VersionComparator(new VersionParser("temporary-redhat", "redhat")); - VersionComparator vc2 = new VersionComparator(new VersionParser("redhat", "temporary-redhat")); - - assertTrue(vc1.compare("3.0.0.Final", "3.0.0.Final-redhat-1") < 0); - assertTrue(vc1.compare("3.0.0.Final", "3.0.0.Final-temporary-redhat-1") < 0); - assertTrue(vc1.compare("3.0.0.Final-redhat-1", "3.0.0.Final-temporary-redhat-1") < 0); - assertTrue(vc2.compare("3.0.0.Final-redhat-1", "3.0.0.Final-temporary-redhat-1") < 0); - } - - @Test - public void testBaseVersion() { - VersionComparator vc = new VersionComparator("3.4.2.Final", VERSION_PARSER); - - assertTrue(vc.compare("3.4.3.Final", "3.4.4.Final") < 0); - assertTrue(vc.compare("3.4.3.Final", "3.4.1.Final") < 0); - assertTrue(vc.compare("3.4.99.Final", "3.5.0.Final") < 0); - assertTrue(vc.compare("3.4.3.Final", "3.4.3.Alpha") < 0); - assertTrue(vc.compare("3.4.3.Beta", "3.4.3.Alpha") < 0); - assertTrue(vc.compare("3.4.3.Final", "3.4.2.CR1") < 0); - assertTrue(vc.compare("3.5.0.Final", "3.4.2.Beta") < 0); - assertTrue(vc.compare("3.4.2.Alpha", "4.2.3.Final") < 0); - assertTrue(vc.compare("3.4.4.Final", "4.4.1.Final") < 0); - assertTrue(vc.compare("3.4.2.Alpha", "4.4.1.Final") < 0); - - vc = new VersionComparator("2.2.2.Beta2", VERSION_PARSER); - - assertTrue(vc.compare("2.2.2.Beta4", "2.2.2.Beta3") < 0); - assertTrue(vc.compare("2.2.2.Beta3", "2.2.2.Beta1") < 0); - assertTrue(vc.compare("2.2.2.Final", "2.2.2.Alpha") < 0); - assertTrue(vc.compare("2.3.3.Final", "2.2.2.Alpha") < 0); - assertTrue(vc.compare("2.2.3.Alpha", "2.2.2.Alpha") < 0); - assertTrue(vc.compare("2.2.2.Beta3", "2.2.1.Final") < 0); - assertTrue(vc.compare("2.2.2.CR1", "2.2.1.Final") < 0); - assertTrue(vc.compare("2.2.2.Final", "2.2.1.Final") < 0); - assertTrue(vc.compare("2.2.2.Alpha", "2.2.1.Final") < 0); - - vc = new VersionComparator("2.2", VERSION_PARSER); - - assertTrue(vc.compare("2.2", "2.2.0") == 0); - - assertTrue(vc.compare("2.2", "2.2-beta-5") < 0); - assertTrue(vc.compare("2.2", "2.2.0-b21") < 0); - assertTrue(vc.compare("2.2", "2.2.0-b10") < 0); - assertTrue(vc.compare("2.2", "2.2.SP4") < 0); - assertTrue(vc.compare("2.2", "2.2.0.SP1") < 0); - assertTrue(vc.compare("2.2", "2.2.Final") < 0); - assertTrue(vc.compare("2.2", "2.2.0.Final") < 0); - assertTrue(vc.compare("2.2", "2.2.0.CR1") < 0); - - assertTrue(vc.compare("2.2.0", "2.2-beta-5") < 0); - assertTrue(vc.compare("2.2.0", "2.2.0-b21") < 0); - assertTrue(vc.compare("2.2.0", "2.2.0-b10") < 0); - assertTrue(vc.compare("2.2.0", "2.2.SP4") < 0); - assertTrue(vc.compare("2.2.0", "2.2.0.SP1") < 0); - assertTrue(vc.compare("2.2.0", "2.2.Final") < 0); - assertTrue(vc.compare("2.2.0", "2.2.0.Final") < 0); - assertTrue(vc.compare("2.2.0", "2.2.0.CR1") < 0); - - assertTrue(vc.compare("2.2.0.b21", "2.2.0.b10") < 0); - assertTrue(vc.compare("2.2.0.SP4", "2.2.0.b21") < 0); - assertTrue(vc.compare("2.2.0.Final", "2.2.0.SP4") > 0); // Too difficult to implement correctly - the list of - // special - // qualifiers (like Final, GA, ...) would be needed - assertTrue(vc.compare("2.2.0.Final", "2.2.0.CR1") < 0); - assertTrue(vc.compare("2.2.0.GA", "2.2.0.SP4") > 0); // Too difficult to implement correctly - assertTrue(vc.compare("2.2.0.GA", "2.2.0.CR1") < 0); - assertTrue(vc.compare("2.2.0.MR1", "2.2.0.SP4") > 0); // Too difficult to implement correctly - assertTrue(vc.compare("2.2.0.MR1", "2.2.0.CR1") < 0); - } - - @Test - public void testBaseVersionWithClosestByPartsRule() { - VersionComparator vc = new VersionComparator("2.0.0", VersionDistanceRule.CLOSEST_BY_PARTS, VERSION_PARSER); - - assertTrue(vc.compare("2.0.1", "3.0.0") < 0); // Rule 1 - less different parts - assertTrue(vc.compare("3.0.0", "4.0.0") < 0); // Rule 2a - lesser difference in differing part - assertTrue(vc.compare("1.0.0", "0.0.0") < 0); - assertTrue(vc.compare("3.0.0", "1.0.0") < 0); // Rule 2b - same difference in differing part, but higher - assertTrue(vc.compare("3.0.0", "3.0.1") < 0); // Rule 3 - closer to base by order - assertTrue(vc.compare("1.0.1", "1.0.0") < 0); // Rule 3 - closer to base by order - - vc = new VersionComparator("3.4.2.Final", VersionDistanceRule.CLOSEST_BY_PARTS, VERSION_PARSER); - - assertTrue(vc.compare("3.4.3.Final", "3.4.4.Final") < 0); - assertTrue(vc.compare("3.4.3.Final", "3.4.1.Final") < 0); - assertTrue(vc.compare("3.4.4.Final", "3.4.1.Final") > 0); // 1 is close to 2 then 4 - assertTrue(vc.compare("3.4.99.Final", "3.5.0.Final") < 0); - assertTrue(vc.compare("3.4.3.Final", "3.4.3.Alpha") < 0); - assertTrue(vc.compare("3.4.3.Beta", "3.4.3.Alpha") < 0); - assertTrue(vc.compare("3.4.3.Final", "3.4.2.CR1") > 0); // Right one matches in micro - assertTrue(vc.compare("3.5.0.Final", "3.4.2.Beta") > 0); // Right one matches in minor - assertTrue(vc.compare("3.4.2.Alpha", "4.2.3.Final") < 0); - assertTrue(vc.compare("3.4.4.Final", "4.4.1.Final") < 0); - assertTrue(vc.compare("3.4.2.Alpha", "4.4.1.Final") < 0); - - vc = new VersionComparator("2.2.2.Beta2", VersionDistanceRule.CLOSEST_BY_PARTS, VERSION_PARSER); - - assertTrue(vc.compare("2.2.2.Beta4", "2.2.2.Beta3") < 0); - assertTrue(vc.compare("2.2.2.Beta3", "2.2.2.Beta1") < 0); - assertTrue(vc.compare("2.2.2.Final", "2.2.2.Alpha") < 0); - assertTrue(vc.compare("2.3.3.Final", "2.2.2.Alpha") > 0); // Right one matches in minor - assertTrue(vc.compare("2.2.3.Alpha", "2.2.2.Alpha") > 0); // Right one matches in micro - assertTrue(vc.compare("2.2.2.Beta3", "2.2.1.Final") < 0); - assertTrue(vc.compare("2.2.2.CR1", "2.2.1.Final") < 0); - assertTrue(vc.compare("2.2.2.Final", "2.2.1.Final") < 0); - assertTrue(vc.compare("2.2.2.Alpha", "2.2.1.Final") < 0); - - assertTrue(vc.compare("3.3.3.Final", "3.3.3.Final") == 0); - assertTrue(vc.compare("3.3.3.Final", "3.3.3.Alpha") < 0); - assertTrue(vc.compare("3.3.2.Final", "3.3.3.Final") < 0); - assertTrue(vc.compare("3.3.0.Final", "3.3.2.Final") < 0); - assertTrue(vc.compare("3.3.1.Final", "3.3.3.Final") < 0); - assertTrue(vc.compare("3.3.0.Final", "3.3.0.Final") == 0); - assertTrue(vc.compare("3.2.0.Final", "3.3.0.Final") < 0); - assertTrue(vc.compare("3.0.0.Final", "3.3.0.Final") < 0); - assertTrue(vc.compare("3.1.0.Final", "3.3.0.Final") < 0); - assertTrue(vc.compare("13.0.0.Final", "13.0.0.Final") == 0); - assertTrue(vc.compare("12.0.0.Final", "13.0.0.Final") < 0); - assertTrue(vc.compare("2.0.0.Final", "13.0.0.Final") < 0); - assertTrue(vc.compare("1.0.0.Final", "3.0.0.Final") > 0); - assertTrue(vc.compare("1.1.1.Final", "1.1.1.Final") == 0); - assertTrue(vc.compare("1.1.1.Final", "1.1.1.Alpha") < 0); - assertTrue(vc.compare("1.1.1.Final", "1.1.2.Final") > 0); - assertTrue(vc.compare("1.1.1.Final", "1.1.3.Final") > 0); - assertTrue(vc.compare("1.1.1.Final", "1.1.4.Final") > 0); - assertTrue(vc.compare("1.1.0.Final", "1.1.0.Final") == 0); - assertTrue(vc.compare("1.1.0.Final", "1.2.0.Final") > 0); - assertTrue(vc.compare("1.1.0.Final", "1.3.0.Final") > 0); - assertTrue(vc.compare("1.1.0.Final", "1.4.0.Final") > 0); - - vc = new VersionComparator("2.2", VersionDistanceRule.CLOSEST_BY_PARTS, VERSION_PARSER); - - assertTrue(vc.compare("2.2", "2.2.0") == 0); - - assertTrue(vc.compare("2.2", "2.2-beta-5") < 0); - assertTrue(vc.compare("2.2", "2.2.0-b21") < 0); - assertTrue(vc.compare("2.2", "2.2.0-b10") < 0); - assertTrue(vc.compare("2.2", "2.2.SP4") < 0); - assertTrue(vc.compare("2.2", "2.2.0.SP1") < 0); - assertTrue(vc.compare("2.2", "2.2.Final") < 0); - assertTrue(vc.compare("2.2", "2.2.0.Final") < 0); - assertTrue(vc.compare("2.2", "2.2.0.CR1") < 0); - - assertTrue(vc.compare("2.2.0", "2.2-beta-5") < 0); - assertTrue(vc.compare("2.2.0", "2.2.0-b21") < 0); - assertTrue(vc.compare("2.2.0", "2.2.0-b10") < 0); - assertTrue(vc.compare("2.2.0", "2.2.SP4") < 0); - assertTrue(vc.compare("2.2.0", "2.2.0.SP1") < 0); - assertTrue(vc.compare("2.2.0", "2.2.Final") < 0); - assertTrue(vc.compare("2.2.0", "2.2.0.Final") < 0); - assertTrue(vc.compare("2.2.0", "2.2.0.CR1") < 0); - - assertTrue(vc.compare("2.2.0.b21", "2.2.0.b10") < 0); - assertTrue(vc.compare("2.2.0.SP4", "2.2.0.b21") < 0); - assertTrue(vc.compare("2.2.0.Final", "2.2.0.SP4") > 0); // Too difficult to implement correctly - the list of - // special - // qualifiers (like Final, GA, ...) would be needed - assertTrue(vc.compare("2.2.0.Final", "2.2.0.CR1") < 0); - assertTrue(vc.compare("2.2.0.GA", "2.2.0.SP4") > 0); // Too difficult to implement correctly - assertTrue(vc.compare("2.2.0.GA", "2.2.0.CR1") < 0); - assertTrue(vc.compare("2.2.0.MR1", "2.2.0.SP4") > 0); // Too difficult to implement correctly - assertTrue(vc.compare("2.2.0.MR1", "2.2.0.CR1") < 0); - } - - @Test - public void testBaseVersionWithMultipleSuffixes() { - VersionComparator vc1 = new VersionComparator("3.4.2.Final", new VersionParser("temporary-redhat", "redhat")); - - assertTrue(vc1.compare("3.4.2.Final", "3.4.2.Final-redhat-1") < 0); - assertTrue(vc1.compare("3.4.2.Final-redhat-2", "3.4.2.Final-redhat-1") < 0); - assertTrue(vc1.compare("3.4.2.Final", "3.4.2.Final-temporary-redhat-1") < 0); - assertTrue(vc1.compare("3.4.2.Final-temporary-redhat-2", "3.4.2.Final-temporary-redhat-1") < 0); - assertTrue(vc1.compare("3.4.3.Final", "3.4.1.Final") < 0); - assertTrue(vc1.compare("3.4.99.Final", "3.5.0.Final") < 0); - assertTrue(vc1.compare("3.4.3.Final", "3.4.3.Alpha") < 0); - } - - @Test - public void testVersionDifference() { - VersionComparator vc = new VersionComparator(VERSION_PARSER); - assertEquals(MAJOR, vc.difference("3.4.2.Final", "2.4.2.Final")); - assertEquals(MINOR, vc.difference("3.4.2.Final", "3.3.2.Final")); - assertEquals(MICRO, vc.difference("3.4.2.Final", "3.4.1.Final")); - assertEquals(QUALIFIER, vc.difference("3.4.2.Final", "3.4.2.Beta")); - - assertEquals(EQUAL, vc.difference("3.0.0.Final", "3.Final")); - assertEquals(EQUAL, vc.difference("3.0.0.Final", "3.0.Final")); - assertEquals(EQUAL, vc.difference("3.0.0.Final", "3.0.0.Final")); - - assertEquals(EQUAL, vc.difference("3.0.0", "3")); - assertEquals(EQUAL, vc.difference("3.0.0", "3.0")); - assertEquals(EQUAL, vc.difference("3.0.0", "3.0.0")); - - assertEquals(MAJOR, vc.difference("3.4.2.Final", "4.4.2.Final")); - assertEquals(MINOR, vc.difference("3.4.2.Final", "3.5.2.Final")); - assertEquals(MICRO, vc.difference("3.4.2.Final", "3.4.3.Final")); - - assertEquals(QUALIFIER, vc.difference("3.4.2.Alpha", "3.4.2.Beta")); - - assertEquals(SUFFIX, vc.difference("3.4.2.Final", "3.4.2.Final-redhat-1")); - assertEquals(SUFFIX, vc.difference("3.4.2", "3.4.2.redhat-1")); - - assertEquals(RH_SUFFIX, vc.difference("3.4.2.Final-redhat-1", "3.4.2.Final-redhat-2")); - assertEquals(RH_SUFFIX, vc.difference("3.4.2.redhat-1", "3.4.2.redhat-2")); - - assertEquals(QUALIFIER, vc.difference("1.1.0.SP18-redhat-1", "1.1.0.SP17-redhat-1")); // NCL-3208 - } - - @Test - public void testBaseVersionWithClosestByPartsRuleReproduceNCLSUP898() { - VersionComparator vc = new VersionComparator( - "8.34.0.Final", - VersionDistanceRule.CLOSEST_BY_PARTS, - VERSION_PARSER); - - assertTrue(vc.compare("8.24.1.Beta-redhat-00006", "8.24.1.Beta-redhat-00005") < 0); - assertTrue(vc.compare("8.24.1.Beta-redhat-00006", "8.24.0.Beta-redhat-00004") < 0); - assertTrue(vc.compare("8.27.0.Beta-redhat-00005", "8.24.1.Beta-redhat-00006") < 0); - assertTrue(vc.compare("8.32.0.Final-redhat-00004", "8.24.1.Beta-redhat-00006") < 0); - assertTrue(vc.compare("8.33.0.Final-redhat-00003", "8.24.1.Beta-redhat-00006") < 0); - assertTrue(vc.compare("8.24.1.Beta-redhat-00006", "6.5.0.Final-redhat-27") < 0); - - } -} diff --git a/common/src/test/java/org/jboss/da/common/version/VersionParserTest.java b/common/src/test/java/org/jboss/da/common/version/VersionParserTest.java deleted file mode 100644 index f04f6788e..000000000 --- a/common/src/test/java/org/jboss/da/common/version/VersionParserTest.java +++ /dev/null @@ -1,172 +0,0 @@ -package org.jboss.da.common.version; - -import org.junit.Test; - -import java.util.Arrays; -import java.util.HashSet; -import java.util.List; -import java.util.Set; -import java.util.stream.Collectors; - -import static java.util.Collections.singleton; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -public class VersionParserTest { - - @Test - public void testOSGIParser() { - assertEquals("1.1.0.Final", VersionParser.getOSGiVersion("1.1.Final")); - assertEquals("1.1.0", VersionParser.getOSGiVersion("1.1")); - assertEquals("1.1.0.redhat-1", VersionParser.getOSGiVersion("1.1.redhat-1")); - assertEquals("1.1.0.redhat-1", VersionParser.getOSGiVersion("1.1-redhat-1")); - assertEquals("1.1.0.Final", VersionParser.getOSGiVersion("1.1Final")); - assertEquals("1.1.5.CR4", VersionParser.getOSGiVersion("1.1.5CR4")); - assertEquals("1.1.0", VersionParser.getOSGiVersion("1.1.")); - assertEquals("1.1.0.CR4", VersionParser.getOSGiVersion("1.1.CR4")); - assertEquals("1.1.0.final", VersionParser.getOSGiVersion("1.1-final")); - assertEquals("1.1.0.final-redhat-1", VersionParser.getOSGiVersion("1.1.0.final-redhat-1")); - assertEquals("1.1.2", VersionParser.getOSGiVersion("1.1-2")); - assertEquals("1.1.2.Final", VersionParser.getOSGiVersion("1.1-2.Final")); - assertEquals("1.1.2.Final", VersionParser.getOSGiVersion("1.1-2-Final")); - assertEquals("1.1.2.Final-redhat-2", VersionParser.getOSGiVersion("1.1-2.Final-redhat-2")); - assertEquals("1.1.2.Final-redhat-2", VersionParser.getOSGiVersion("1.1-2-Final-redhat-2")); - } - - @Test - public void testVersionParser() { - VersionParser versionParser = new VersionParser("redhat"); - assertEquals(new SuffixedVersion(1, 1, 0, "Final", "1.1.Final"), versionParser.parse("1.1.Final")); - assertEquals(new SuffixedVersion(1, 1, 0, "", "1.1"), versionParser.parse("1.1")); - assertEquals( - new SuffixedVersion(1, 1, 0, "", "redhat", 1, "1.1.redhat-1"), - versionParser.parse("1.1.redhat-1")); - assertEquals( - new SuffixedVersion(1, 1, 0, "", "redhat", 1, "1.1-redhat-1"), - versionParser.parse("1.1-redhat-1")); - assertEquals(new SuffixedVersion(1, 1, 0, "Final", "1.1Final"), versionParser.parse("1.1Final")); - assertEquals(new SuffixedVersion(1, 1, 5, "CR4", "1.1.5CR4"), versionParser.parse("1.1.5CR4")); - assertEquals(new SuffixedVersion(1, 1, 0, "", "1.1."), versionParser.parse("1.1.")); - assertEquals(new SuffixedVersion(1, 1, 0, "CR4", "1.1.CR4"), versionParser.parse("1.1.CR4")); - assertEquals(new SuffixedVersion(1, 1, 0, "final", "1.1-final"), versionParser.parse("1.1-final")); - assertEquals( - new SuffixedVersion(1, 1, 0, "final", "redhat", 1, "1.1.0.final-redhat-1"), - versionParser.parse("1.1.0.final-redhat-1")); - assertEquals(new SuffixedVersion(1, 1, 2, "", "1.1-2"), versionParser.parse("1.1-2")); - assertEquals(new SuffixedVersion(1, 1, 2, "Final", "1.1-2.Final"), versionParser.parse("1.1-2.Final")); - assertEquals(new SuffixedVersion(1, 1, 2, "Final", "1.1-2-Final"), versionParser.parse("1.1-2-Final")); - assertEquals( - new SuffixedVersion(1, 1, 2, "Final", "redhat", 2, "1.1-2.Final-redhat-2"), - versionParser.parse("1.1-2.Final-redhat-2")); - assertEquals( - new SuffixedVersion(1, 1, 2, "Final", "redhat", 2, "1.1-2-Final-redhat-2"), - versionParser.parse("1.1-2-Final-redhat-2")); - } - - @Test - public void testRedhatVersion() { - VersionParser versionParser = new VersionParser("redhat"); - assertFalse(versionParser.parse("1.1.Final").isSuffixed()); - assertFalse(versionParser.parse("1.1").isSuffixed()); - assertTrue(versionParser.parse("1.1.redhat-1").isSuffixed()); - assertTrue(versionParser.parse("1.1-redhat-1").isSuffixed()); - assertFalse(versionParser.parse("1.1").isSuffixed()); - assertFalse(versionParser.parse("1.1Final").isSuffixed()); - assertFalse(versionParser.parse("1.1.5CR4").isSuffixed()); - assertFalse(versionParser.parse("1.1.").isSuffixed()); - assertFalse(versionParser.parse("1.1.CR4").isSuffixed()); - assertFalse(versionParser.parse("1.1-final").isSuffixed()); - assertTrue(versionParser.parse("1.1.0.final-redhat-1").isSuffixed()); - assertTrue(versionParser.parse("1.1-redhat-001").isSuffixed()); - } - - @Test - public void testTemporarySuffix() { - List versions = Arrays - .asList("1.5.8", "1.5.8-patch-01", "1.6.1", "1.7.21.t20180522-115319-991-redhat-1"); - - VersionParser vp = new VersionParser("t20180522-115319-991-redhat"); - List filtered = versions.stream().filter(v -> vp.parse(v).isSuffixed()).collect(Collectors.toList()); - assertEquals(1, filtered.size()); - assertTrue(filtered.contains("1.7.21.t20180522-115319-991-redhat-1")); - } - - @Test - public void testTemporaryAndRedhatSuffix() { - List versions = Arrays.asList( - "1.5.8", - "1.5.8-patch-01", - "1.6.1", - "1.6.1-redhat-1", - "1.6.1-redhat-2", - "1.6.4.redhat-2", - "1.7.21.t20180417-125043-536-redhat-1", - "1.7.21.t20180425-112559-465-redhat-1", - "1.7.21.temporary-redhat-1"); - - VersionParser vp = new VersionParser("temporary-redhat", "redhat"); - List filtered = versions.stream().filter(v -> vp.parse(v).isSuffixed()).collect(Collectors.toList()); - assertEquals(6, filtered.size()); - assertTrue(filtered.contains("1.7.21.temporary-redhat-1")); - assertTrue(filtered.contains("1.6.4.redhat-2")); - assertTrue(filtered.contains("1.7.21.t20180425-112559-465-redhat-1")); - assertFalse(filtered.contains("1.5.8-patch-01")); - } - - @Test - public void shuldNormalizeVersionWhenParsing() { - VersionParser vp1 = new VersionParser("A", "B-A", "B-C-A"); - assertEquals(new SuffixedVersion(1, 5, 8, "", "1.5.8"), vp1.parse("1.5.8")); - assertEquals(new SuffixedVersion(1, 5, 8, "", "A", 2, "1.5.8.A-2"), vp1.parse("1.5.8.A-2")); - assertEquals(new SuffixedVersion(1, 5, 8, "B-2", "1.5.8.B-2"), vp1.parse("1.5.8.B-2")); - assertEquals(new SuffixedVersion(1, 5, 8, "", "B-A", 2, "1.5.8.B-A-2"), vp1.parse("1.5.8.B-A-2")); - assertEquals(new SuffixedVersion(1, 5, 8, "C", "A", 2, "1.5.8.B-A-2"), vp1.parse("1.5.8.C-A-2")); - assertEquals(new SuffixedVersion(1, 5, 8, "", "B-C-A", 2, "1.5.8.B-C-A-2"), vp1.parse("1.5.8.B-C-A-2")); - - VersionParser vp2 = new VersionParser("B-C-A", "B-A", "A"); - assertEquals(new SuffixedVersion(1, 5, 8, "", "1.5.8"), vp2.parse("1.5.8")); - assertEquals(new SuffixedVersion(1, 5, 8, "", "A", 2, "1.5.8.A-2"), vp2.parse("1.5.8.A-2")); - assertEquals(new SuffixedVersion(1, 5, 8, "B-2", "1.5.8.B-2"), vp2.parse("1.5.8.B-2")); - assertEquals(new SuffixedVersion(1, 5, 8, "", "B-A", 2, "1.5.8.B-A-2"), vp2.parse("1.5.8.B-A-2")); - assertEquals(new SuffixedVersion(1, 5, 8, "C", "A", 2, "1.5.8.B-A-2"), vp2.parse("1.5.8.C-A-2")); - assertEquals(new SuffixedVersion(1, 5, 8, "", "B-C-A", 2, "1.5.8.B-C-A-2"), vp2.parse("1.5.8.B-C-A-2")); - } - - @Test - public void shouldParseMultipleSuffixes() { - VersionParser vp1 = new VersionParser("A", "B-A", "B-C-A"); - - assertTrue(vp1.parseSuffixed("1.5.8").isEmpty()); - - String version1 = "1.5.8.A-2"; - Set set1 = vp1.parseSuffixed(version1); - assertEquals(1, set1.size()); - assertEquals(singleton(new SuffixedVersion(1, 5, 8, "", "A", 2, version1)), set1); - - assertTrue(vp1.parseSuffixed("1.5.8.B-2").isEmpty()); - - String version2 = "1.5.8.B-A-2"; - Set set2 = vp1.parseSuffixed(version2); - assertEquals(2, set2.size()); - Set expected2 = new HashSet<>( - Arrays.asList( - new SuffixedVersion(1, 5, 8, "B", "A", 2, version2), - new SuffixedVersion(1, 5, 8, "", "B-A", 2, version2))); - assertEquals(expected2, set2); - - String version3 = "1.5.8.C-A-2"; - Set set3 = vp1.parseSuffixed(version3); - assertEquals(1, set3.size()); - assertEquals(singleton(new SuffixedVersion(1, 5, 8, "C", "A", 2, version3)), set3); - - String version4 = "1.5.8.B-C-A-2"; - Set set4 = vp1.parseSuffixed(version4); - assertEquals(2, set4.size()); - Set expected4 = new HashSet<>( - Arrays.asList( - new SuffixedVersion(1, 5, 8, "B-C", "A", 2, version4), - new SuffixedVersion(1, 5, 8, "", "B-C-A", 2, version4))); - assertEquals(expected4, set4); - } -} diff --git a/pom.xml b/pom.xml index 96cda14ea..06185ed82 100644 --- a/pom.xml +++ b/pom.xml @@ -254,17 +254,6 @@ galley-cache-partyline ${version.galley} - - org.commonjava.maven.ext - pom-manipulation-core - 1.6 - - - * - * - - - diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ArtifactServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ArtifactServiceImpl.java index 14ef6b593..4e0a8f992 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ArtifactServiceImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ArtifactServiceImpl.java @@ -1,12 +1,12 @@ package org.jboss.da.listings.impl.service; -import org.jboss.da.common.version.VersionParser; import org.jboss.da.communication.auth.AuthenticatorService; import org.jboss.da.listings.api.dao.ArtifactDAO; import org.jboss.da.listings.api.dao.UserDAO; import org.jboss.da.listings.api.model.Artifact; import org.jboss.da.listings.api.model.User; import org.jboss.da.listings.api.service.ArtifactService; +import org.jboss.pnc.common.version.VersionParser; import javax.inject.Inject; diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java index 1fecd8c42..363867440 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java @@ -21,8 +21,8 @@ import java.util.SortedSet; import java.util.TreeSet; -import org.jboss.da.common.version.SuffixedVersion; -import org.jboss.da.common.version.VersionParser; +import org.jboss.pnc.common.version.SuffixedVersion; +import org.jboss.pnc.common.version.VersionParser; /** * @@ -82,7 +82,7 @@ public org.jboss.da.listings.api.service.ArtifactService.ArtifactStatus addArtif public Optional getArtifact(String groupId, String artifactId, String version) { SuffixedVersion parsedVersion = versionParser.parse(version); Optional artifact = blackArtifactDAO - .findArtifact(groupId, artifactId, parsedVersion.unsuffixedVesion()); + .findArtifact(groupId, artifactId, parsedVersion.unsuffixedVersion()); if (parsedVersion.isSuffixed() && !artifact.isPresent()) { artifact = blackArtifactDAO.findArtifact(groupId, artifactId, VersionParser.getOSGiVersion(version)); } diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactServiceImpl.java index a84e16e1a..7f77daada 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactServiceImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactServiceImpl.java @@ -7,8 +7,6 @@ import javax.enterprise.context.ApplicationScoped; import javax.inject.Inject; -import org.jboss.da.common.version.SuffixedVersion; -import org.jboss.da.common.version.VersionParser; import org.jboss.da.listings.api.dao.ArtifactDAO; import org.jboss.da.listings.api.dao.GADAO; @@ -20,6 +18,8 @@ import org.jboss.da.listings.api.service.BlackArtifactService; import org.jboss.da.listings.api.service.WhiteArtifactService; import org.jboss.da.model.rest.GAV; +import org.jboss.pnc.common.version.SuffixedVersion; +import org.jboss.pnc.common.version.VersionParser; /** * diff --git a/reports-backend/src/main/java/org/jboss/da/products/api/ArtifactDiff.java b/reports-backend/src/main/java/org/jboss/da/products/api/ArtifactDiff.java index c6503b19d..7f44f430c 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/api/ArtifactDiff.java +++ b/reports-backend/src/main/java/org/jboss/da/products/api/ArtifactDiff.java @@ -1,10 +1,10 @@ package org.jboss.da.products.api; -import org.jboss.da.common.version.VersionComparator.VersionDifference; import org.jboss.da.model.rest.GA; import lombok.Getter; import lombok.NonNull; +import org.jboss.pnc.common.version.VersionComparator.VersionDifference; /** * diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/AbstractProductProvider.java b/reports-backend/src/main/java/org/jboss/da/products/impl/AbstractProductProvider.java index cd67a1322..34d9097fc 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/impl/AbstractProductProvider.java +++ b/reports-backend/src/main/java/org/jboss/da/products/impl/AbstractProductProvider.java @@ -13,7 +13,6 @@ import org.jboss.da.common.json.LookupMode; import org.jboss.da.common.util.UserLog; -import org.jboss.da.common.version.VersionParser; import org.jboss.da.listings.model.ProductSupportStatus; import org.jboss.da.model.rest.GA; import org.jboss.da.model.rest.GAV; @@ -23,6 +22,7 @@ import org.jboss.da.products.api.Product; import org.jboss.da.products.api.ProductArtifacts; import org.jboss.da.products.api.ProductProvider; +import org.jboss.pnc.common.version.VersionParser; import org.jboss.pnc.enums.ArtifactQuality; import org.jboss.pnc.enums.BuildCategory; import org.slf4j.Logger; diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/ProductsServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/products/impl/ProductsServiceImpl.java index 975585a8a..de424b9ed 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/impl/ProductsServiceImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/products/impl/ProductsServiceImpl.java @@ -1,14 +1,14 @@ package org.jboss.da.products.impl; -import org.jboss.da.common.version.VersionComparator; -import org.jboss.da.common.version.VersionComparator.VersionDifference; -import org.jboss.da.common.version.VersionParser; import org.jboss.da.listings.api.dao.ProductVersionDAO; import org.jboss.da.listings.api.model.GA; import org.jboss.da.listings.api.model.ProductVersion; import org.jboss.da.listings.api.model.WhiteArtifact; import org.jboss.da.products.api.ArtifactDiff; import org.jboss.da.products.api.ProductsService; +import org.jboss.pnc.common.version.VersionComparator; +import org.jboss.pnc.common.version.VersionComparator.VersionDifference; +import org.jboss.pnc.common.version.VersionParser; import javax.inject.Inject; diff --git a/reports-backend/src/main/java/org/jboss/da/reports/api/LookupGenerator.java b/reports-backend/src/main/java/org/jboss/da/reports/api/LookupGenerator.java index 0479abe29..4dabb04a7 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/api/LookupGenerator.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/api/LookupGenerator.java @@ -8,8 +8,8 @@ import org.jboss.da.lookup.model.MavenVersionsResult; import org.jboss.da.lookup.model.NPMLookupResult; import org.jboss.da.lookup.model.NPMVersionsResult; -import org.jboss.da.lookup.model.VersionDistanceRule; -import org.jboss.da.lookup.model.VersionFilter; +import org.jboss.pnc.api.constants.versions.VersionDistanceRule; +import org.jboss.pnc.api.constants.versions.VersionFilter; import org.jboss.da.model.rest.GAV; import org.jboss.da.model.rest.NPMPackage; diff --git a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java index 51e58c8a2..09cc895af 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java @@ -4,15 +4,14 @@ import org.jboss.da.common.json.LookupMode; import org.jboss.da.common.util.Configuration; import org.jboss.da.common.util.ConfigurationParseException; -import org.jboss.da.common.version.VersionAnalyzer; import org.jboss.da.listings.api.service.BlackArtifactService; import org.jboss.da.lookup.model.MavenLatestResult; import org.jboss.da.lookup.model.MavenLookupResult; import org.jboss.da.lookup.model.MavenVersionsResult; import org.jboss.da.lookup.model.NPMLookupResult; import org.jboss.da.lookup.model.NPMVersionsResult; -import org.jboss.da.lookup.model.VersionDistanceRule; -import org.jboss.da.lookup.model.VersionFilter; +import org.jboss.pnc.api.constants.versions.VersionDistanceRule; +import org.jboss.pnc.api.constants.versions.VersionFilter; import org.jboss.da.model.rest.GA; import org.jboss.da.model.rest.GAV; import org.jboss.da.model.rest.NPMPackage; @@ -24,6 +23,7 @@ import org.jboss.da.products.impl.PncProductProvider; import org.jboss.da.products.impl.RepositoryProductProvider; import org.jboss.da.reports.api.LookupGenerator; +import org.jboss.pnc.common.version.VersionAnalyzer; import org.jboss.pnc.enums.ArtifactQuality; import javax.enterprise.context.ApplicationScoped; diff --git a/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java b/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java index 9680e30e2..682172d40 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java @@ -10,10 +10,6 @@ import org.jboss.da.common.util.Configuration; import org.jboss.da.common.util.ConfigurationParseException; import org.jboss.da.common.util.UserLog; -import org.jboss.da.common.version.SuffixedVersion; -import org.jboss.da.common.version.VersionAnalyzer; -import org.jboss.da.common.version.VersionComparator; -import org.jboss.da.common.version.VersionParser; import org.jboss.da.communication.indy.model.GAVDependencyTree; import org.jboss.da.communication.pom.PomAnalysisException; import org.jboss.da.communication.pom.api.PomAnalyzer; @@ -51,6 +47,10 @@ import org.jboss.da.reports.model.response.NPMVersionsReport; import org.jboss.da.scm.api.SCM; import org.jboss.da.scm.api.SCMType; +import org.jboss.pnc.common.version.SuffixedVersion; +import org.jboss.pnc.common.version.VersionAnalyzer; +import org.jboss.pnc.common.version.VersionComparator; +import org.jboss.pnc.common.version.VersionParser; import org.jboss.pnc.enums.ArtifactQuality; import org.jboss.pnc.enums.BuildCategory; import org.slf4j.Logger; diff --git a/reports-model/pom.xml b/reports-model/pom.xml index b31d6011a..947a16ba4 100644 --- a/reports-model/pom.xml +++ b/reports-model/pom.xml @@ -9,6 +9,10 @@ reports-model ejb + + org.jboss.pnc + pnc-api + com.fasterxml.jackson.core jackson-annotations diff --git a/reports-model/src/main/java/org/jboss/da/lookup/model/MavenVersionsRequest.java b/reports-model/src/main/java/org/jboss/da/lookup/model/MavenVersionsRequest.java index 0d973f33d..e71de03e4 100644 --- a/reports-model/src/main/java/org/jboss/da/lookup/model/MavenVersionsRequest.java +++ b/reports-model/src/main/java/org/jboss/da/lookup/model/MavenVersionsRequest.java @@ -21,6 +21,8 @@ import lombok.NonNull; import lombok.extern.jackson.Jacksonized; import org.jboss.da.model.rest.GAV; +import org.jboss.pnc.api.constants.versions.VersionDistanceRule; +import org.jboss.pnc.api.constants.versions.VersionFilter; import javax.validation.constraints.NotNull; import java.util.Set; diff --git a/reports-model/src/main/java/org/jboss/da/lookup/model/NPMVersionsRequest.java b/reports-model/src/main/java/org/jboss/da/lookup/model/NPMVersionsRequest.java index ff5032c59..baa583034 100644 --- a/reports-model/src/main/java/org/jboss/da/lookup/model/NPMVersionsRequest.java +++ b/reports-model/src/main/java/org/jboss/da/lookup/model/NPMVersionsRequest.java @@ -16,12 +16,13 @@ package org.jboss.da.lookup.model; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; import lombok.Builder; import lombok.Data; import lombok.NonNull; import lombok.extern.jackson.Jacksonized; import org.jboss.da.model.rest.NPMPackage; +import org.jboss.pnc.api.constants.versions.VersionDistanceRule; +import org.jboss.pnc.api.constants.versions.VersionFilter; import javax.validation.constraints.NotNull; import java.util.Set; diff --git a/reports-model/src/main/java/org/jboss/da/lookup/model/VersionDistanceRule.java b/reports-model/src/main/java/org/jboss/da/lookup/model/VersionDistanceRule.java deleted file mode 100644 index 9f224ee65..000000000 --- a/reports-model/src/main/java/org/jboss/da/lookup/model/VersionDistanceRule.java +++ /dev/null @@ -1,37 +0,0 @@ -package org.jboss.da.lookup.model; - -/** - * Rules for determining comparative distance of two versions toward a base version. - */ -public enum VersionDistanceRule { - /** - * This rule tries to suggest the best replacement version. - * - * Rule 1: Version with the same major part as base is closer than version with major part different to base. - *

- * Rule 2: Version higher than base is considered closer than version lower than base. - *

- * Rule 3: Version closer to base version by standard order is considered closer. - *

- * Note: Higher qualifier (e.g. Final) considered better and thus closer than otherwise the same version with lower - * qualifier (e.g. Alpha). This may not be correct for all qualifiers. - */ - RECOMMENDED_REPLACEMENT, - /** - * This rule orders the version by closeness of their parts. - * - * Rule 1: Version which differs in less significant part (major, minor, micro, qualifier, suffix) from the base - * version is considered closer than version with differs in more significant part. - *

- * Rule 2: If both version differs in the same most significant numerical part (major, minor, micro) to base - * version:
- * a) version which has the part numerically closer to base is considered closer.
- * b) if they are the same numerical distance to base, the higher number is considered closer. - *

- * Rule 3: Version closer to base version by standard order is considered closer. - *

- * Note: Higher qualifier (e.g. Final) considered better and thus closer than otherwise the same version with lower - * qualifier (e.g. Alpha). This may not be correct for all qualifiers. - */ - CLOSEST_BY_PARTS -} diff --git a/reports-model/src/main/java/org/jboss/da/lookup/model/VersionFilter.java b/reports-model/src/main/java/org/jboss/da/lookup/model/VersionFilter.java deleted file mode 100644 index d955c0ea9..000000000 --- a/reports-model/src/main/java/org/jboss/da/lookup/model/VersionFilter.java +++ /dev/null @@ -1,5 +0,0 @@ -package org.jboss.da.lookup.model; - -public enum VersionFilter { - ALL, MAJOR, MAJOR_MINOR, MAJOR_MINOR_MICRO, MAJOR_MINOR_MICRO_QUALIFIER -} diff --git a/reports-rest/pom.xml b/reports-rest/pom.xml index 495a8e23b..75a8963cf 100644 --- a/reports-rest/pom.xml +++ b/reports-rest/pom.xml @@ -21,10 +21,6 @@ pncmetrics provided - - org.jboss.pnc - pnc-common - org.slf4j slf4j-api @@ -88,10 +84,6 @@ provided - - io.opentelemetry.instrumentation - opentelemetry-instrumentation-annotations - From 5ed0959211f9cd9509004d604e3a692215dc3219 Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Tue, 17 Feb 2026 12:31:03 +0000 Subject: [PATCH 18/26] Update PNC components --- communication/pom.xml | 4 ++++ pom.xml | 6 +++--- reports-rest/pom.xml | 1 - 3 files changed, 7 insertions(+), 4 deletions(-) diff --git a/communication/pom.xml b/communication/pom.xml index 97452ca3d..9ab863d78 100644 --- a/communication/pom.xml +++ b/communication/pom.xml @@ -36,6 +36,10 @@ + + org.jboss.pnc + pnc-common + org.jboss.pnc rest-api diff --git a/pom.xml b/pom.xml index 06185ed82..28b11def4 100644 --- a/pom.xml +++ b/pom.xml @@ -81,9 +81,9 @@ UTF-8 1 1 - 2.5.0 - 2.2.1 - 2.4.5 + 3.4.2 + 3.4.1-SNAPSHOT + 3.5.0-SNAPSHOT 0.13.4 0.12.2 11 diff --git a/reports-rest/pom.xml b/reports-rest/pom.xml index 75a8963cf..75641d550 100644 --- a/reports-rest/pom.xml +++ b/reports-rest/pom.xml @@ -83,7 +83,6 @@ jackson-datatype-jsr310 provided - From ef8c41cf126aad29659c68707dd2b243664c9a17 Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Tue, 17 Feb 2026 15:14:08 +0000 Subject: [PATCH 19/26] Add explicit dependency on Atlas --- pom.xml | 7 ++++++- testsuite/pom.xml | 4 ++++ 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 28b11def4..bc1eb9705 100644 --- a/pom.xml +++ b/pom.xml @@ -84,6 +84,7 @@ 3.4.2 3.4.1-SNAPSHOT 3.5.0-SNAPSHOT + 0.16.2 0.13.4 0.12.2 11 @@ -254,7 +255,11 @@ galley-cache-partyline ${version.galley} - + + org.commonjava.maven.atlas + atlas-identities + ${atlasVersion} + org.projectlombok diff --git a/testsuite/pom.xml b/testsuite/pom.xml index b9cd504da..4048216bf 100644 --- a/testsuite/pom.xml +++ b/testsuite/pom.xml @@ -28,6 +28,10 @@ org.jboss.pnc.metrics pncmetrics + + org.commonjava.maven.atlas + atlas-identities + From 6d3aafd5ba70156bf943ef87f7d13fde5438f4d2 Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Wed, 18 Feb 2026 08:23:38 +0000 Subject: [PATCH 20/26] Exclude opentelemetry and httpcomponents --- pom.xml | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/pom.xml b/pom.xml index bc1eb9705..c5d310638 100644 --- a/pom.xml +++ b/pom.xml @@ -151,6 +151,16 @@ org.jboss.pnc pnc-common ${version.pnc-common} + + + io.opentelemetry + * + + + org.apache.httpcomponents + * + + org.jboss.pnc From 6e0f1d0eb2bbc75555694dbbc17b034fddab835a Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Wed, 18 Feb 2026 13:52:45 +0000 Subject: [PATCH 21/26] Reapply "Remove Whitelist" This reverts commit 20fa3341ab3bd9eb46c7e54e1b05c8af7afa537a. --- .../jboss/da/listings/api/dao/ProductDAO.java | 32 - .../listings/api/dao/ProductVersionDAO.java | 114 ---- .../da/listings/api/dao/WhiteArtifactDAO.java | 11 - .../jboss/da/listings/api/model/Product.java | 30 - .../da/listings/api/model/ProductVersion.java | 55 -- .../ProductVersionArtifactRelationship.java | 26 - .../da/listings/api/model/WhiteArtifact.java | 39 -- .../listings/api/service/ProductService.java | 42 -- .../api/service/ProductVersionService.java | 108 ---- .../da/listings/api/service/WLFiller.java | 19 - .../service/WhiteArtifactFilterService.java | 90 --- .../api/service/WhiteArtifactService.java | 65 --- .../da/listings/impl/dao/ProductDAOImpl.java | 55 -- .../impl/dao/ProductVersionDAOImpl.java | 205 ------- .../impl/dao/WhiteArtifactDAOImpl.java | 32 - .../service/BlackArtifactServiceImpl.java | 22 +- .../impl/service/ProductServiceImpl.java | 57 -- .../service/ProductVersionServiceImpl.java | 78 --- .../listings/impl/service/WLFillerImpl.java | 130 ----- .../WhiteArtifactFilterServiceImpl.java | 92 --- .../service/WhiteArtifactServiceImpl.java | 144 ----- .../da/products/api/ProductsService.java | 12 - .../impl/AggregatedProductProvider.java | 6 - .../impl/DatabaseProductProvider.java | 161 ----- .../da/products/impl/ProductsServiceImpl.java | 67 --- .../reports/backend/impl/ProductAdapter.java | 104 ---- .../da/reports/impl/ReportsGeneratorImpl.java | 50 +- .../impl/ReportsGeneratorImplTest.java | 13 - .../jboss/da/products/model/rest/GADiff.java | 82 --- .../da/products/model/rest/ProductDiff.java | 54 -- .../model/response/striped/WLStripper.java | 1 - .../model/rest/BackwardCompatibilityTest.java | 8 - .../jboss/da/rest/ReportsRestActivator.java | 4 - .../org/jboss/da/rest/listings/Artifacts.java | 416 ------------- .../jboss/da/rest/listings/RestConvert.java | 61 -- .../org/jboss/da/rest/products/Products.java | 111 ---- .../listings/AbstractRestApiListingTest.java | 61 +- .../rest/listings/RestApiListingsTestIT.java | 236 -------- .../rest/products/RestApiProductsTestIT.java | 83 --- ...tifactBlackWhitelistTransitionsTestIT.java | 237 -------- ...sWithWhitelistedArtifactsRemoteTestIT.java | 552 ------------------ .../listings/WhiteArtifactServiceTestIT.java | 47 -- 42 files changed, 17 insertions(+), 3795 deletions(-) delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/dao/ProductDAO.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/dao/ProductVersionDAO.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/dao/WhiteArtifactDAO.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/model/Product.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/model/ProductVersion.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/model/ProductVersionArtifactRelationship.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/model/WhiteArtifact.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/service/ProductService.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/service/ProductVersionService.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/service/WLFiller.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/service/WhiteArtifactFilterService.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/api/service/WhiteArtifactService.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ProductDAOImpl.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ProductVersionDAOImpl.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/impl/dao/WhiteArtifactDAOImpl.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/impl/service/ProductServiceImpl.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/impl/service/ProductVersionServiceImpl.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/impl/service/WLFillerImpl.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactFilterServiceImpl.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactServiceImpl.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/products/api/ProductsService.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/products/impl/DatabaseProductProvider.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/products/impl/ProductsServiceImpl.java delete mode 100644 reports-backend/src/main/java/org/jboss/da/reports/backend/impl/ProductAdapter.java delete mode 100644 reports-model/src/main/java/org/jboss/da/products/model/rest/GADiff.java delete mode 100644 reports-model/src/main/java/org/jboss/da/products/model/rest/ProductDiff.java delete mode 100644 reports-rest/src/main/java/org/jboss/da/rest/listings/Artifacts.java delete mode 100644 reports-rest/src/main/java/org/jboss/da/rest/products/Products.java delete mode 100644 testsuite/src/test/java/org/jboss/da/test/client/rest/products/RestApiProductsTestIT.java delete mode 100644 testsuite/src/test/java/org/jboss/da/test/server/ArtifactBlackWhitelistTransitionsTestIT.java delete mode 100644 testsuite/src/test/java/org/jboss/da/test/server/ReportsWithWhitelistedArtifactsRemoteTestIT.java delete mode 100644 testsuite/src/test/java/org/jboss/da/test/server/listings/WhiteArtifactServiceTestIT.java diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ProductDAO.java b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ProductDAO.java deleted file mode 100644 index a610086ef..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ProductDAO.java +++ /dev/null @@ -1,32 +0,0 @@ -package org.jboss.da.listings.api.dao; - -import org.jboss.da.listings.api.model.Product; - -import java.util.List; -import java.util.Optional; - -public interface ProductDAO extends GenericDAO { - - /** - * Finds all Products - * - * @return List of products - */ - List findAll(); - - /** - * Finds all products matching the supplied product names. - * - * @return List of products as if findProduct() was called once for each name in the list. - */ - List findAllWithNames(List productNames); - - /** - * Finds Product with specific name - * - * @param name - * @return Optional of product or empty - */ - Optional findProduct(String name); - -} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ProductVersionDAO.java b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ProductVersionDAO.java deleted file mode 100644 index 95e8aa1f3..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ProductVersionDAO.java +++ /dev/null @@ -1,114 +0,0 @@ -package org.jboss.da.listings.api.dao; - -import org.jboss.da.listings.api.model.ProductVersionArtifactRelationship; -import org.jboss.da.listings.api.model.ProductVersion; -import org.jboss.da.listings.model.ProductSupportStatus; - -import java.util.List; -import java.util.NoSuchElementException; -import java.util.Optional; - -public interface ProductVersionDAO extends GenericDAO { - - /** - * Change support status of ProductVersion with specific product name and version - * - * @param name - * @param version - * @param newStatus - * @return True if change was successful otherwise false - * @throws NoSuchElementException - */ - boolean changeProductVersionStatus(String name, String version, ProductSupportStatus newStatus); - - /** - * Finds ProductVersion with specific product name and version - * - * @param name - * @param version - * @return Optional of productVersion or empty - */ - Optional findProductVersion(String name, String version); - - /** - * Finds ProductVersions with specific product name - * - * @param name - * @return List of productVersions - */ - List findProductVersionsWithProduct(String name); - - /** - * Finds all ProductVersions - * - * @return List of productVersions - */ - List findAll(); - - /** - * Finds all ProductVersions with the specified IDs. - * - * @return List of productVersions - */ - List findAllWithIds(List productVersionIds); - - /** - * Find ProductsVersions that contains Artifact with specific groupId, artifactId and version - * - * @param groupId - * @param artifactId - * @param version - * @return List of productVersions - */ - List findProductVersionsWithArtifact( - String groupId, - String artifactId, - String version, - boolean preciseVersion); - - /** - * Finds ProductVersions with specific product id, product name, version or support status. All parameters are - * optional. - * - * @param id product id optional - * @param name product name optional - * @param version optional - * @param status optional - * @return List of productVersions with specified parameters - */ - List findProductVersions(Long id, String name, String version, ProductSupportStatus status); - - /** - * Finds Artifacts of ProductVersions with specific support status - * - * @param status - * @return List of products with their artifacts - */ - List findProductVersionsWithArtifactsByStatus(ProductSupportStatus status); - - /** - * Find ProductVersions that contains Artifact with specific groupId, artifactId and version - * - * @param groupId - * @param artifactId - * @param version - * @return List of products with artifacts - */ - List findProductVersionsWithArtifactByGAV( - String groupId, - String artifactId, - String version); - - /** - * Find ProductVersions with specific status that contains Artifact with specific groupId, artifactId - * - * @param groupId - * @param artifactId - * @param status - * @return - */ - List findProductVersionsWithArtifactsByGAStatus( - String groupId, - String artifactId, - Optional status); -} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/WhiteArtifactDAO.java b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/WhiteArtifactDAO.java deleted file mode 100644 index b67c197d0..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/WhiteArtifactDAO.java +++ /dev/null @@ -1,11 +0,0 @@ -package org.jboss.da.listings.api.dao; - -import org.jboss.da.listings.api.model.WhiteArtifact; - -/** - * - * @author Jozef Mrazek <jmrazek@redhat.com> - * - */ -public interface WhiteArtifactDAO extends ArtifactDAO { -} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/model/Product.java b/reports-backend/src/main/java/org/jboss/da/listings/api/model/Product.java deleted file mode 100644 index 619c1287d..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/model/Product.java +++ /dev/null @@ -1,30 +0,0 @@ -package org.jboss.da.listings.api.model; - -import javax.persistence.Entity; -import lombok.AccessLevel; -import lombok.Getter; -import lombok.NoArgsConstructor; -import lombok.NonNull; -import lombok.Setter; -import lombok.ToString; - -/** - * - * @author Jozef Mrazek <jmrazek@redhat.com> - * - */ -@NoArgsConstructor(access = AccessLevel.PROTECTED) -@ToString -@Entity -public class Product extends GenericEntity { - - @Setter - @Getter - @NonNull - private String name; - - public Product(String name) { - this.name = name; - } - -} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/model/ProductVersion.java b/reports-backend/src/main/java/org/jboss/da/listings/api/model/ProductVersion.java deleted file mode 100644 index 3f44249e7..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/model/ProductVersion.java +++ /dev/null @@ -1,55 +0,0 @@ -package org.jboss.da.listings.api.model; - -import org.jboss.da.listings.model.ProductSupportStatus; - -import javax.persistence.Entity; -import javax.persistence.FetchType; -import javax.persistence.ManyToMany; -import javax.persistence.ManyToOne; - -import java.util.HashSet; -import java.util.Set; - -import lombok.Getter; -import lombok.NoArgsConstructor; -import lombok.NonNull; -import lombok.Setter; - -@NoArgsConstructor -@Entity -public class ProductVersion extends GenericEntity { - - @Setter - @Getter - @ManyToOne - private Product product; - - @Setter - @Getter - @NonNull - private String productVersion; - - @Setter - @Getter - private ProductSupportStatus support; - - @Getter - @Setter - @ManyToMany(fetch = FetchType.EAGER) - private Set whiteArtifacts; - - public ProductVersion(Product p, String productVersion, ProductSupportStatus support) { - this.product = p; - this.productVersion = productVersion; - this.support = support; - whiteArtifacts = new HashSet<>(); - } - - public void addArtifact(WhiteArtifact artifact) { - whiteArtifacts.add(artifact); - } - - public void removeArtifact(WhiteArtifact artifact) { - whiteArtifacts.remove(artifact); - } -} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/model/ProductVersionArtifactRelationship.java b/reports-backend/src/main/java/org/jboss/da/listings/api/model/ProductVersionArtifactRelationship.java deleted file mode 100644 index 051996bce..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/model/ProductVersionArtifactRelationship.java +++ /dev/null @@ -1,26 +0,0 @@ -package org.jboss.da.listings.api.model; - -import lombok.AccessLevel; -import lombok.Getter; -import lombok.NoArgsConstructor; -import lombok.Setter; -import lombok.ToString; - -@NoArgsConstructor(access = AccessLevel.PUBLIC) -@ToString -public class ProductVersionArtifactRelationship { - - @Getter - @Setter - private WhiteArtifact artifact; - - @Getter - @Setter - private ProductVersion productVersion; - - public ProductVersionArtifactRelationship(ProductVersion productVersion, WhiteArtifact artifact) { - this.artifact = artifact; - this.productVersion = productVersion; - } - -} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/model/WhiteArtifact.java b/reports-backend/src/main/java/org/jboss/da/listings/api/model/WhiteArtifact.java deleted file mode 100644 index 790a4096d..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/model/WhiteArtifact.java +++ /dev/null @@ -1,39 +0,0 @@ -package org.jboss.da.listings.api.model; - -import javax.persistence.Entity; - -import lombok.AccessLevel; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.NoArgsConstructor; -import lombok.NonNull; -import lombok.Setter; -import lombok.ToString; - -/** - * - * @author Jozef Mrazek <jmrazek@redhat.com> - * - */ -@NoArgsConstructor(access = AccessLevel.PUBLIC) -@EqualsAndHashCode(callSuper = true) -@ToString(callSuper = true) -@Entity -public class WhiteArtifact extends Artifact { - - @Setter - @Getter - private boolean is3rdParty; - - @Setter - @Getter - @NonNull - private String osgiVersion; - - public WhiteArtifact(GA ga, String version, User insertedBy, String osgiVersion, boolean is3rdParty) { - super(ga, version, insertedBy); - this.is3rdParty = is3rdParty; - this.osgiVersion = osgiVersion; - } - -} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/service/ProductService.java b/reports-backend/src/main/java/org/jboss/da/listings/api/service/ProductService.java deleted file mode 100644 index 6553946cd..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/service/ProductService.java +++ /dev/null @@ -1,42 +0,0 @@ -package org.jboss.da.listings.api.service; - -import org.jboss.da.listings.model.ProductSupportStatus; - -import javax.persistence.EntityNotFoundException; - -import java.util.NoSuchElementException; - -public interface ProductService { - - /** - * Adds Product into whitelist products - * - * @param name - * @param version - * @param status - * @return true if operation was successful - */ - boolean addProduct(String name, String version, ProductSupportStatus status); - - /** - * Remove Product from whitelist products - * - * @param name - * @param version - * @return true if operation was successful - * @throws EntityNotFoundException - */ - boolean removeProduct(String name, String version) throws EntityNotFoundException; - - /** - * Change support status of Product with specific name and version - * - * @param name - * @param version - * @param newStatus - * @return True if change was successful otherwise false - * @throws NoSuchElementException - */ - boolean changeProductStatus(String name, String version, ProductSupportStatus newStatus); - -} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/service/ProductVersionService.java b/reports-backend/src/main/java/org/jboss/da/listings/api/service/ProductVersionService.java deleted file mode 100644 index 3dcb331fd..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/service/ProductVersionService.java +++ /dev/null @@ -1,108 +0,0 @@ -package org.jboss.da.listings.api.service; - -import org.jboss.da.listings.api.model.ProductVersion; -import org.jboss.da.listings.api.model.ProductVersionArtifactRelationship; -import org.jboss.da.listings.model.ProductSupportStatus; - -import java.util.List; -import java.util.Optional; - -public interface ProductVersionService { - - /** - * Get ProductVersion with specific product name and version - * - * @param name - * @param version - * @return Optional of productVersion or empty - */ - Optional getProductVersion(String name, String version); - - /** - * Get ProductVersion with specific id - * - * @param id - * @return Optional of productVersion or empty - */ - Optional getProductVersion(long id); - - /** - * Get all ProductVersions - * - * @return List of productVersions - */ - List getAll(); - - /** - * Get all ProductVersions for a product name - * - * @return List of productVersions - */ - List getAllForProduct(String productName); - - /** - * Get ProductVersions that contains Artifact with specific groupId, artifactId and version - * - * @param groupId - * @param artifactId - * @param version - * @return List of products - */ - List getProductVersionsOfArtifact(String groupId, String artifactId, String version); - - /** - * Finds ProductVersion with specific product id, product name, version or support status. All parameters are - * optional. - * - * @param id optional - * @param name optional - * @param version optional - * @param status optional - * @return List of productVersions with specified parameters - */ - List getProductVersions(Long id, String name, String version, ProductSupportStatus status); - - /** - * Finds Artifacts of ProductVersions with specific support status - * - * @param status - * @return List of productVersions with their artifacts - */ - List getProductVersionsWithArtifactsByStatus(ProductSupportStatus status); - - /** - * Find ProductVersions that contains Artifact with specific groupId, artifactId and version - * - * @param groupId - * @param artifactId - * @param version - * @return List of productVersions with artifacts - */ - List getProductVersionsWithArtifactByGAV( - String groupId, - String artifactId, - String version); - - /** - * Find ProductVersions with specific status that contains Artifact with specific groupId, artifactId - * - * @param groupId - * @param artifactId - * @param status - * @return - */ - List getProductVersionsWithArtifactsByGAStatus( - String groupId, - String artifactId, - ProductSupportStatus status); - - /** - * Find ProductVersions with any status that contains Artifact with specific groupId, artifactId - * - * @param groupId - * @param artifactId - * @return - */ - List getProductVersionsWithArtifactsByGA(String groupId, String artifactId); - -} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/service/WLFiller.java b/reports-backend/src/main/java/org/jboss/da/listings/api/service/WLFiller.java deleted file mode 100644 index 858aa927e..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/service/WLFiller.java +++ /dev/null @@ -1,19 +0,0 @@ -package org.jboss.da.listings.api.service; - -import java.util.List; - -public interface WLFiller { - - public enum WLStatus { - PRODUCT_NOT_FOUND, FILLED, ANALYSER_ERROR, POM_NOT_FOUND; - } - - WLStatus fillWhitelistFromPom( - String scmUrl, - String revision, - String pomPath, - List repositories, - long productId); - - WLStatus fillWhitelistFromGAV(String groupId, String artifactId, String version, long productId); -} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/service/WhiteArtifactFilterService.java b/reports-backend/src/main/java/org/jboss/da/listings/api/service/WhiteArtifactFilterService.java deleted file mode 100644 index 476dd4b80..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/service/WhiteArtifactFilterService.java +++ /dev/null @@ -1,90 +0,0 @@ -package org.jboss.da.listings.api.service; - -import java.util.List; -import java.util.Optional; - -import org.jboss.da.listings.api.model.ProductVersion; -import org.jboss.da.listings.api.model.ProductVersionArtifactRelationship; -import org.jboss.da.listings.model.ProductSupportStatus; - -/** - * - * Provides access to white artifacts by applying the required filtering - taking into consideration artifacts listed - * against ProductVersions, white list and black list. - * - * @author fkujikis - * - */ -public interface WhiteArtifactFilterService { - - /** - * Remove all blacklisted artifacts from the provided list of ProductVersion instances. - * - * @return List of ProductVersion instances such that for each instance, instance.getWhiteArtifacts() contains only - * whitelisted artifacts, with the blacklisted artifacts filtered out. - */ - public List toProductsContainingOnlyWhiteArtifacts(List products); - - /** - * Remove all blacklisted artifacts from the provided list of ProductVersionArtifactRelationship instances. - * - * @return List of ProductVersionArtifactRelationship instances such that for each instance, - * instance.getProductVersion().getWhiteArtifacts() contains only whitelisted artifacts, with the - * blacklisted artifacts filtered out. - */ - public List toProductRelsContainingOnlyWhiteArtifacts( - List products); - - /** - * Get ProductVersion with specific product name and version, such that it contains only white artifacts. - * - * @param name - * @param version - * @return Optional of productVersion or empty - */ - Optional getProductVersionWithWhiteArtifacts(String name, String version); - - /** - * Get all ProductVersions containing only White artifacts. - * - * @return List of productVersions with white artifacts - */ - List getAllWithWhiteArtifacts(); - - /** - * Finds Artifacts of ProductVersions with specific support status, only containing white artifacts - * - * @param status - * @return List of productVersions with their artifacts - */ - List getProductVersionsWithWhiteArtifactsByStatus(ProductSupportStatus status); - - /** - * Find ProductVersions that contains Artifact with specific groupId, artifactId and version such that it contains - * only white artifacts. - * - * @param groupId - * @param artifactId - * @param version - * @return List of productVersions with artifacts - */ - List getProductVersionsWithWhiteArtifactsByGAV( - String groupId, - String artifactId, - String version); - - /** - * Find ProductVersions with specific status that contains Artifact with specific groupId, artifactId such that it - * contains only white artifacts. - * - * @param groupId - * @param artifactId - * @param status - * @return - */ - List getProductVersionsWithWhiteArtifactsByGAStatus( - String groupId, - String artifactId, - ProductSupportStatus status); - -} \ No newline at end of file diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/service/WhiteArtifactService.java b/reports-backend/src/main/java/org/jboss/da/listings/api/service/WhiteArtifactService.java deleted file mode 100644 index 5f4ad6cfc..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/service/WhiteArtifactService.java +++ /dev/null @@ -1,65 +0,0 @@ -package org.jboss.da.listings.api.service; - -import java.util.List; - -import org.jboss.da.listings.api.model.WhiteArtifact; -import org.jboss.da.model.rest.GAV; - -/** - * - * @author Jozef Mrazek <jmrazek@redhat.com> - * - */ -public interface WhiteArtifactService extends ArtifactService { - - /** - * Add artifact to whitelist. The version must contain redhat suffix. - * - * @throws IllegalArgumentException when version doesn't have redhat suffix. - */ - public ArtifactStatus addArtifact(String groupId, String artifactId, String version, Long productVersionId) - throws IllegalArgumentException; - - /** - * - * @param groupId - * @param artifactId - * @param version - * @param productVersionId - * @return - */ - public boolean removeArtifractFromProductVersion( - String groupId, - String artifactId, - String version, - Long productVersionId); - - /** - * Checks if whitelist contains artifact with specific groupId, artifactId and version. If the version have redhat - * suffix, find exact match. If the version doesn't have redhat suffix, converts the version to OSGi version and - * finds any redhat suffixed versions in whitelist. - * - * @return List of found artifacts. - */ - public List getArtifacts(GAV gav); - - /** - * Checks if whitelist contains artifact with specific groupId, artifactId and version. If the version have redhat - * suffix, find exact match. If the version doesn't have redhat suffix, converts the version to OSGi version and - * finds any redhat suffixed versions in whitelist. - * - * @return List of found artifacts. - */ - public List getArtifacts(String groupId, String artifactId, String version); - - /** - * Remove artifact from list and from product versions. Removes only exact match of artifact. - * - * @param groupId - * @param artifactId - * @param version - * @return True if artifact was deleted. - */ - public boolean removeArtifact(String groupId, String artifactId, String version); - -} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ProductDAOImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ProductDAOImpl.java deleted file mode 100644 index 1f67663e9..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ProductDAOImpl.java +++ /dev/null @@ -1,55 +0,0 @@ -package org.jboss.da.listings.impl.dao; - -import org.jboss.da.listings.api.dao.ProductDAO; -import org.jboss.da.listings.api.model.Product; -import javax.ejb.Stateless; -import javax.persistence.NoResultException; -import javax.persistence.TypedQuery; -import javax.persistence.criteria.CriteriaBuilder; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Root; - -import java.util.List; -import java.util.Optional; - -@Stateless -public class ProductDAOImpl extends GenericDAOImpl implements ProductDAO { - - public ProductDAOImpl() { - super(Product.class); - } - - @Override - public List findAll() { - CriteriaBuilder cb = em.getCriteriaBuilder(); - CriteriaQuery cq = cb.createQuery(type); - Root product = cq.from(type); - cq.select(product); - TypedQuery q = em.createQuery(cq); - return q.getResultList(); - } - - @Override - public List findAllWithNames(List productNames) { - CriteriaBuilder cb = em.getCriteriaBuilder(); - CriteriaQuery cq = cb.createQuery(type); - Root product = cq.from(type); - cq.select(product).where(product.get("name").in(productNames)); - TypedQuery q = em.createQuery(cq); - return q.getResultList(); - } - - @Override - public Optional findProduct(String name) { - try { - CriteriaBuilder cb = em.getCriteriaBuilder(); - CriteriaQuery cq = cb.createQuery(type); - Root product = cq.from(type); - cq.select(product).where(cb.equal(product.get("name"), name)); - TypedQuery q = em.createQuery(cq); - return Optional.of(q.getSingleResult()); - } catch (NoResultException e) { - return Optional.empty(); - } - } -} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ProductVersionDAOImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ProductVersionDAOImpl.java deleted file mode 100644 index 774b0c5f9..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ProductVersionDAOImpl.java +++ /dev/null @@ -1,205 +0,0 @@ -package org.jboss.da.listings.impl.dao; - -import org.jboss.da.listings.api.dao.ProductVersionDAO; -import org.jboss.da.listings.api.model.Artifact; -import org.jboss.da.listings.api.model.GA; -import org.jboss.da.listings.api.model.Product; -import org.jboss.da.listings.api.model.ProductVersionArtifactRelationship; -import org.jboss.da.listings.api.model.ProductVersion; -import org.jboss.da.listings.api.model.WhiteArtifact; -import org.jboss.da.listings.model.ProductSupportStatus; - -import javax.ejb.Stateless; -import javax.persistence.NoResultException; -import javax.persistence.TypedQuery; -import javax.persistence.criteria.CriteriaBuilder; -import javax.persistence.criteria.CriteriaQuery; -import javax.persistence.criteria.Expression; -import javax.persistence.criteria.Join; -import javax.persistence.criteria.Predicate; -import javax.persistence.criteria.Root; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; -import java.util.Optional; - -@Stateless -public class ProductVersionDAOImpl extends GenericDAOImpl implements ProductVersionDAO { - - public ProductVersionDAOImpl() { - super(ProductVersion.class); - } - - @Override - public boolean changeProductVersionStatus(String name, String version, ProductSupportStatus newStatus) { - Optional pv = findProductVersion(name, version); - if (!pv.isPresent()) - return false; - pv.get().setSupport(newStatus); - update(pv.get()); - return true; - } - - @Override - public Optional findProductVersion(String name, String version) { - try { - CriteriaBuilder cb = em.getCriteriaBuilder(); - CriteriaQuery cq = cb.createQuery(type); - Root productVersion = cq.from(type); - Join product = productVersion.join("product"); - cq.select(productVersion) - .where( - cb.and( - cb.equal(product.get("name"), name), - cb.equal(productVersion.get("productVersion"), version))); - TypedQuery q = em.createQuery(cq); - return Optional.of(q.getSingleResult()); - } catch (NoResultException e) { - return Optional.empty(); - } - } - - @Override - public List findProductVersionsWithProduct(String name) { - CriteriaBuilder cb = em.getCriteriaBuilder(); - CriteriaQuery cq = cb.createQuery(type); - Root productVersion = cq.from(type); - Join product = productVersion.join("product"); - cq.select(productVersion).where(cb.equal(product.get("name"), name)); - TypedQuery q = em.createQuery(cq); - return q.getResultList(); - } - - @Override - public List findAll() { - CriteriaBuilder cb = em.getCriteriaBuilder(); - CriteriaQuery cq = cb.createQuery(type); - Root productVersion = cq.from(type); - cq.select(productVersion); - TypedQuery q = em.createQuery(cq); - return q.getResultList(); - } - - @Override - public List findAllWithIds(List productVersionIds) { - CriteriaBuilder cb = em.getCriteriaBuilder(); - CriteriaQuery cq = cb.createQuery(type); - Root product = cq.from(type); - cq.select(product).where(product.get("id").in(productVersionIds)); - TypedQuery q = em.createQuery(cq); - return q.getResultList(); - } - - @Override - public List findProductVersionsWithArtifact( - String groupId, - String artifactId, - String version, - boolean preciseVersion) { - CriteriaBuilder cb = em.getCriteriaBuilder(); - CriteriaQuery cq = cb.createQuery(type); - Root productVersion = cq.from(type); - Root artifact = cq.from(WhiteArtifact.class); - Join ga = artifact.join("ga"); - if (!preciseVersion) - version += '%'; - cq.select(productVersion) - .where( - cb.and( - cb.equal(ga.get("groupId"), groupId), - cb.equal(ga.get("artifactId"), artifactId), - cb.or( - cb.like(artifact.get("version"), version), - cb.like(artifact.get("osgiVersion"), version)))); - TypedQuery q = em.createQuery(cq); - List list = q.getResultList(); - return list; - } - - @Override - public List findProductVersions(Long id, String name, String version, ProductSupportStatus status) { - CriteriaBuilder cb = em.getCriteriaBuilder(); - CriteriaQuery cq = cb.createQuery(type); - Root productVersion = cq.from(type); - Join product = productVersion.join("product"); - List predicates = new ArrayList<>(); - if (id != null) { - predicates.add(cb.equal(productVersion.get("id"), id)); - } - if (name != null) { - predicates.add(cb.equal(product.get("name"), name)); - } - if (version != null) { - predicates.add(cb.equal(productVersion.get("productVersion"), version)); - } - if (status != null) { - predicates.add(cb.equal(productVersion.get("support"), status)); - } - cq.select(productVersion).where(cb.and(cb.and(predicates.toArray(new Predicate[predicates.size()])))); - TypedQuery q = em.createQuery(cq); - return q.getResultList(); - } - - @Override - public List findProductVersionsWithArtifactsByStatus(ProductSupportStatus status) { - CriteriaBuilder cb = em.getCriteriaBuilder(); - CriteriaQuery cq = cb.createQuery(type); - Root productVersion = cq.from(ProductVersion.class); - cq.select(productVersion).where(cb.and(cb.equal(productVersion.get("support"), status))); - TypedQuery q = em.createQuery(cq); - List pv = q.getResultList(); - return pv; - } - - @Override - public List findProductVersionsWithArtifactByGAV( - String groupId, - String artifactId, - String version) { - CriteriaBuilder cb = em.getCriteriaBuilder(); - CriteriaQuery cq = cb.createQuery(ProductVersionArtifactRelationship.class); - Root productVersion = cq.from(type); - Root artifact = cq.from(WhiteArtifact.class); - Join ga = artifact.join("ga"); - Expression> artifacts = productVersion.get("whiteArtifacts"); - cq.multiselect(productVersion, artifact); - cq.where( - cb.and( - cb.isMember(artifact, artifacts), - cb.equal(ga.get("artifactId"), artifactId), - cb.equal(ga.get("groupId"), groupId), - cb.or( - cb.equal(artifact.get("version"), version), - cb.equal(artifact.get("osgiVersion"), version)))); - TypedQuery q = em.createQuery(cq); - List l = q.getResultList(); - return l; - } - - @Override - public List findProductVersionsWithArtifactsByGAStatus( - String groupId, - String artifactId, - Optional status) { - CriteriaBuilder cb = em.getCriteriaBuilder(); - CriteriaQuery cq = cb.createQuery(ProductVersionArtifactRelationship.class); - Root productVersion = cq.from(type); - Root artifact = cq.from(WhiteArtifact.class); - Join ga = artifact.join("ga"); - Expression> artifacts = productVersion.get("whiteArtifacts"); - cq.multiselect(productVersion, artifact); - - final Predicate gaRestriction = cb.and( - cb.isMember(artifact, artifacts), - cb.equal(ga.get("artifactId"), artifactId), - cb.equal(ga.get("groupId"), groupId)); - Predicate restriction = status.map(x -> cb.and(gaRestriction, cb.equal(productVersion.get("support"), x))) - .orElse(gaRestriction); - - cq.where(restriction); - TypedQuery q = em.createQuery(cq); - List l = q.getResultList(); - return l; - } -} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/WhiteArtifactDAOImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/WhiteArtifactDAOImpl.java deleted file mode 100644 index 49874dac0..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/WhiteArtifactDAOImpl.java +++ /dev/null @@ -1,32 +0,0 @@ -package org.jboss.da.listings.impl.dao; - -import javax.ejb.Stateless; -import javax.inject.Inject; - -import org.jboss.da.common.logging.AuditLogger; -import org.jboss.da.listings.api.dao.WhiteArtifactDAO; -import org.jboss.da.listings.api.model.WhiteArtifact; - -/** - * - * @author Jozef Mrazek <jmrazek@redhat.com> - * - */ -@Stateless -public class WhiteArtifactDAOImpl extends ArtifactDAOImpl implements WhiteArtifactDAO { - - @Override - public void create(WhiteArtifact entity) { - try { - super.create(entity); - } catch (RuntimeException ex) { - AuditLogger.LOG.info("Adding allowlisted artifact " + entity.gav() + " failed."); - throw ex; - } - AuditLogger.LOG.info("Added allowlisted artifact " + entity.gav() + "."); - } - - public WhiteArtifactDAOImpl() { - super(WhiteArtifact.class); - } -} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java index 363867440..8c3075cdb 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java @@ -1,8 +1,6 @@ package org.jboss.da.listings.impl.service; -import java.util.HashSet; import java.util.Optional; -import java.util.Set; import javax.enterprise.context.ApplicationScoped; import javax.inject.Inject; @@ -10,10 +8,8 @@ import org.jboss.da.listings.api.dao.ArtifactDAO; import org.jboss.da.listings.api.dao.BlackArtifactDAO; import org.jboss.da.listings.api.dao.GADAO; -import org.jboss.da.listings.api.dao.WhiteArtifactDAO; import org.jboss.da.listings.api.model.BlackArtifact; import org.jboss.da.listings.api.model.GA; -import org.jboss.da.listings.api.model.WhiteArtifact; import org.jboss.da.listings.api.service.BlackArtifactService; import org.jboss.da.model.rest.GAV; @@ -35,9 +31,6 @@ public class BlackArtifactServiceImpl extends ArtifactServiceImpl @Inject private BlackArtifactDAO blackArtifactDAO; - @Inject - private WhiteArtifactDAO whiteArtifactDAO; - @Inject private GADAO gaDAO; @@ -61,21 +54,8 @@ public org.jboss.da.listings.api.service.ArtifactService.ArtifactStatus addArtif if (blackArtifactDAO.findArtifact(groupId, artifactId, osgiVersion).isPresent()) { return ArtifactStatus.NOT_MODIFIED; } - - Set whites = new HashSet<>(); - Optional rhA = whiteArtifactDAO.findArtifact(groupId, artifactId, osgiVersion); - rhA.ifPresent(x -> whites.add(rhA.get())); - Optional a = whiteArtifactDAO.findArtifact(groupId, artifactId, version); - a.ifPresent(x -> whites.add(a.get())); - - ArtifactStatus status = ArtifactStatus.ADDED; - - if (!whites.isEmpty()) { - status = ArtifactStatus.WAS_WHITELISTED; - } - blackArtifactDAO.create(artifact); - return status; + return ArtifactStatus.ADDED; } @Override diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ProductServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ProductServiceImpl.java deleted file mode 100644 index 10163d802..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ProductServiceImpl.java +++ /dev/null @@ -1,57 +0,0 @@ -package org.jboss.da.listings.impl.service; - -import org.jboss.da.listings.api.dao.ProductDAO; -import org.jboss.da.listings.api.dao.ProductVersionDAO; -import org.jboss.da.listings.api.model.Product; -import org.jboss.da.listings.api.model.ProductVersion; -import org.jboss.da.listings.api.service.ProductService; -import org.jboss.da.listings.model.ProductSupportStatus; - -import javax.enterprise.context.ApplicationScoped; -import javax.inject.Inject; -import javax.persistence.EntityNotFoundException; - -import java.util.Optional; - -@ApplicationScoped -public class ProductServiceImpl implements ProductService { - - @Inject - private ProductDAO productDAO; - - @Inject - private ProductVersionDAO productVersionDAO; - - @Override - public boolean addProduct(String name, String version, ProductSupportStatus status) { - if (productVersionDAO.findProductVersion(name, version).isPresent()) { - return false; - } - Optional p = productDAO.findProduct(name); - if (!p.isPresent()) { - Product pr = new Product(name); - productDAO.create(pr); - p = productDAO.findProduct(name); - } - productVersionDAO.create(new ProductVersion(p.get(), version, status)); - return true; - } - - @Override - public boolean removeProduct(String name, String version) throws EntityNotFoundException { - Optional pv = productVersionDAO.findProductVersion(name, version); - if (pv.isPresent()) { - productVersionDAO.delete(pv.get()); - if (productVersionDAO.findProductVersionsWithProduct(name).isEmpty()) { - productDAO.delete(productDAO.findProduct(name).get()); - } - return true; - } - throw new EntityNotFoundException("Product with this name and version is not in database"); - } - - @Override - public boolean changeProductStatus(String name, String version, ProductSupportStatus newStatus) { - return productVersionDAO.changeProductVersionStatus(name, version, newStatus); - } -} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ProductVersionServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ProductVersionServiceImpl.java deleted file mode 100644 index b48154dfa..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/ProductVersionServiceImpl.java +++ /dev/null @@ -1,78 +0,0 @@ -package org.jboss.da.listings.impl.service; - -import org.jboss.da.listings.api.dao.ProductVersionDAO; -import org.jboss.da.listings.api.model.ProductVersion; -import org.jboss.da.listings.api.model.ProductVersionArtifactRelationship; -import org.jboss.da.listings.api.service.ProductVersionService; -import org.jboss.da.listings.model.ProductSupportStatus; - -import javax.enterprise.context.ApplicationScoped; -import javax.inject.Inject; - -import java.util.List; -import java.util.Optional; - -@ApplicationScoped -public class ProductVersionServiceImpl implements ProductVersionService { - - @Inject - private ProductVersionDAO productVersionDAO; - - @Override - public List getAll() { - return productVersionDAO.findAll(); - } - - @Override - public Optional getProductVersion(String name, String version) { - return productVersionDAO.findProductVersion(name, version); - } - - @Override - public Optional getProductVersion(long id) { - return Optional.ofNullable(productVersionDAO.read(id)); - } - - @Override - public List getProductVersionsOfArtifact(String groupId, String artifactId, String version) { - return productVersionDAO.findProductVersionsWithArtifact(groupId, artifactId, version, false); - } - - @Override - public List getProductVersions(Long id, String name, String version, ProductSupportStatus status) { - return productVersionDAO.findProductVersions(id, name, version, status); - } - - @Override - public List getProductVersionsWithArtifactsByStatus(ProductSupportStatus status) { - return productVersionDAO.findProductVersionsWithArtifactsByStatus(status); - } - - @Override - public List getProductVersionsWithArtifactByGAV( - String groupId, - String artifactId, - String version) { - return productVersionDAO.findProductVersionsWithArtifactByGAV(groupId, artifactId, version); - } - - @Override - public List getProductVersionsWithArtifactsByGAStatus( - String groupId, - String artifactId, - ProductSupportStatus status) { - return productVersionDAO.findProductVersionsWithArtifactsByGAStatus(groupId, artifactId, Optional.of(status)); - } - - @Override - public List getProductVersionsWithArtifactsByGA( - String groupId, - String artifactId) { - return productVersionDAO.findProductVersionsWithArtifactsByGAStatus(groupId, artifactId, Optional.empty()); - } - - @Override - public List getAllForProduct(String productName) { - return productVersionDAO.findProductVersionsWithProduct(productName); - } -} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WLFillerImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WLFillerImpl.java deleted file mode 100644 index 713887bf8..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WLFillerImpl.java +++ /dev/null @@ -1,130 +0,0 @@ -package org.jboss.da.listings.impl.service; - -import org.apache.maven.scm.ScmException; -import org.commonjava.maven.galley.maven.GalleyMavenException; -import org.commonjava.maven.galley.maven.model.view.DependencyView; -import org.commonjava.maven.galley.maven.model.view.MavenPomView; -import org.jboss.da.common.CommunicationException; -import org.jboss.da.common.util.ConfigurationParseException; -import org.jboss.da.communication.indy.api.IndyConnector; -import org.jboss.da.communication.pom.PomAnalysisException; -import org.jboss.da.communication.pom.api.PomAnalyzer; -import org.jboss.da.listings.api.model.Artifact; -import org.jboss.da.listings.api.model.GA; -import org.jboss.da.listings.api.model.ProductVersion; -import org.jboss.da.listings.api.service.WLFiller; -import org.jboss.da.model.rest.GAV; -import org.jboss.da.scm.api.SCM; -import org.jboss.da.scm.api.SCMType; -import org.slf4j.Logger; - -import javax.enterprise.context.ApplicationScoped; -import javax.inject.Inject; - -import java.io.File; -import java.io.InputStream; -import java.util.ArrayList; -import java.util.List; -import java.util.Optional; - -import org.jboss.da.listings.api.service.ArtifactService.ArtifactStatus; - -@ApplicationScoped -public class WLFillerImpl implements WLFiller { - - @Inject - private Logger log; - - @Inject - private PomAnalyzer analyzer; - - @Inject - private WhiteArtifactServiceImpl whiteService; - - @Inject - private ProductVersionServiceImpl productVersionService; - - @Inject - private IndyConnector indyConnector; - - @Inject - private SCM scmManager; - - @Override - public WLStatus fillWhitelistFromPom( - String scmUrl, - String revision, - String pomPath, - List repositories, - long productId) { - if (!checkProduct(productId)) { - return WLStatus.PRODUCT_NOT_FOUND; - } - try { - fillWLFromPom(getPomListFromGit(scmUrl, revision, pomPath, repositories), productId); - } catch (ScmException | GalleyMavenException | PomAnalysisException e) { - log.error(e.getMessage()); - return WLStatus.ANALYSER_ERROR; - } - return WLStatus.FILLED; - } - - @Override - public WLStatus fillWhitelistFromGAV(String groupId, String artifactId, String version, long productId) { - if (!checkProduct(productId)) { - return WLStatus.PRODUCT_NOT_FOUND; - } - try { - final GAV gav = new GAV(groupId, artifactId, version); - Optional is = indyConnector.getPomStream(gav); - if (is.isPresent()) { - MavenPomView view = analyzer.getMavenPomView(is.get()); - fillWLFromPom(view, productId); - } else { - log.error("POM with given GAV not found in indy " + gav); - return WLStatus.POM_NOT_FOUND; - } - } catch (CommunicationException | ConfigurationParseException | GalleyMavenException e) { - log.error(e.getMessage()); - return WLStatus.ANALYSER_ERROR; - } - return WLStatus.FILLED; - } - - private MavenPomView getPomListFromGit(String scmUrl, String revision, String pomPath, List repositories) - throws GalleyMavenException, PomAnalysisException, ScmException { - - if (repositories == null) { - repositories = new ArrayList<>(); - } - - File clonedDir = scmManager.cloneRepository(SCMType.GIT, scmUrl, revision); - - MavenPomView pom = analyzer.getGitPomView(clonedDir, pomPath, repositories); - - return pom; - } - - private void fillWLFromPom(MavenPomView v, long productId) throws GalleyMavenException { - List dependencies = v.getAllManagedDependencies(); - for (DependencyView d : dependencies) { - GA ga = new GA(d.getGroupId(), d.getArtifactId()); - Artifact a = new Artifact(ga, d.getVersion(), whiteService.currentUser()); - ArtifactStatus status = whiteService - .addArtifact(a.getGa().getGroupId(), a.getGa().getArtifactId(), a.getVersion(), productId); - switch (status) { - case ADDED: - case NOT_MODIFIED: - break; // ok - default: - throw new IllegalStateException( - "Adition of artifact to product list failed. This shouldn't happen and is probably programming bug."); - } - } - } - - private boolean checkProduct(long productId) { - Optional pv = productVersionService.getProductVersion(productId); - return pv.isPresent(); - } -} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactFilterServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactFilterServiceImpl.java deleted file mode 100644 index 411e49cc7..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactFilterServiceImpl.java +++ /dev/null @@ -1,92 +0,0 @@ -package org.jboss.da.listings.impl.service; - -import java.util.Arrays; -import java.util.List; -import java.util.Optional; -import java.util.stream.Collectors; - -import javax.enterprise.context.ApplicationScoped; -import javax.inject.Inject; - -import org.jboss.da.listings.api.model.BlackArtifact; -import org.jboss.da.listings.api.model.ProductVersion; -import org.jboss.da.listings.api.model.ProductVersionArtifactRelationship; -import org.jboss.da.listings.api.service.BlackArtifactService; -import org.jboss.da.listings.api.service.ProductVersionService; -import org.jboss.da.listings.api.service.WhiteArtifactFilterService; -import org.jboss.da.listings.model.ProductSupportStatus; - -@ApplicationScoped -public class WhiteArtifactFilterServiceImpl implements WhiteArtifactFilterService { - - @Inject - private BlackArtifactService blackArtifactService; - - @Inject - private ProductVersionService productVersionService; - - @Override - public List toProductsContainingOnlyWhiteArtifacts(List products) { - // Get all black artifacts - List allBlackArtifacts = blackArtifactService.getAll(); - - // Remove every blacklisted artifact from a whitelist - for (BlackArtifact ba : allBlackArtifacts) { - for (ProductVersion pv : products) { - pv.getWhiteArtifacts() - .removeIf(x -> x.getGa().equals(ba.getGa()) && x.getVersion().equals(ba.getVersion())); - } - } - return products; - } - - @Override - public List toProductRelsContainingOnlyWhiteArtifacts( - List products) { - List productVersions = products.stream() - .map(ProductVersionArtifactRelationship::getProductVersion) - .collect(Collectors.toList()); - - toProductsContainingOnlyWhiteArtifacts(productVersions); - return products; - } - - @Override - public List getAllWithWhiteArtifacts() { - return toProductsContainingOnlyWhiteArtifacts(productVersionService.getAll()); - } - - @Override - public Optional getProductVersionWithWhiteArtifacts(String name, String version) { - Optional pv = productVersionService.getProductVersion(name, version); - if (pv.isPresent()) { - toProductsContainingOnlyWhiteArtifacts(Arrays.asList(pv.get())); - } - return pv; - } - - @Override - public List getProductVersionsWithWhiteArtifactsByStatus(ProductSupportStatus status) { - return toProductsContainingOnlyWhiteArtifacts( - productVersionService.getProductVersionsWithArtifactsByStatus(status)); - } - - @Override - public List getProductVersionsWithWhiteArtifactsByGAV( - String groupId, - String artifactId, - String version) { - return toProductRelsContainingOnlyWhiteArtifacts( - productVersionService.getProductVersionsWithArtifactByGAV(groupId, artifactId, version)); - } - - @Override - public List getProductVersionsWithWhiteArtifactsByGAStatus( - String groupId, - String artifactId, - ProductSupportStatus status) { - return toProductRelsContainingOnlyWhiteArtifacts( - productVersionService.getProductVersionsWithArtifactsByGAStatus(groupId, artifactId, status)); - } - -} diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactServiceImpl.java deleted file mode 100644 index 7f77daada..000000000 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/WhiteArtifactServiceImpl.java +++ /dev/null @@ -1,144 +0,0 @@ -package org.jboss.da.listings.impl.service; - -import java.util.ArrayList; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Optional; - -import javax.enterprise.context.ApplicationScoped; -import javax.inject.Inject; - -import org.jboss.da.listings.api.dao.ArtifactDAO; -import org.jboss.da.listings.api.dao.GADAO; -import org.jboss.da.listings.api.dao.ProductVersionDAO; -import org.jboss.da.listings.api.dao.WhiteArtifactDAO; -import org.jboss.da.listings.api.model.GA; -import org.jboss.da.listings.api.model.ProductVersion; -import org.jboss.da.listings.api.model.WhiteArtifact; -import org.jboss.da.listings.api.service.BlackArtifactService; -import org.jboss.da.listings.api.service.WhiteArtifactService; -import org.jboss.da.model.rest.GAV; -import org.jboss.pnc.common.version.SuffixedVersion; -import org.jboss.pnc.common.version.VersionParser; - -/** - * - * @author Jozef Mrazek <jmrazek@redhat.com> - * - */ -@ApplicationScoped -public class WhiteArtifactServiceImpl extends ArtifactServiceImpl implements WhiteArtifactService { - - @Inject - private BlackArtifactService blackArtifactService; - - @Inject - private WhiteArtifactDAO whiteArtifactDAO; - - @Inject - private GADAO gaDAO; - - @Inject - private ProductVersionDAO productVersionDAO; - - @Override - protected ArtifactDAO getDAO() { - return whiteArtifactDAO; - } - - @Override - public org.jboss.da.listings.api.service.ArtifactService.ArtifactStatus addArtifact( - String groupId, - String artifactId, - String version, - Long productVersionId) { - Optional dbArtifact = whiteArtifactDAO.findArtifact(groupId, artifactId, version); - WhiteArtifact artifact = dbArtifact.orElseGet(() -> createArtifact(groupId, artifactId, version)); - - ProductVersion p = productVersionDAO.read(productVersionId); - - if (p == null) { - throw new IllegalArgumentException("Wrong productId, product with this id not found"); - } - - if (p.getWhiteArtifacts().contains(artifact)) { - return ArtifactStatus.NOT_MODIFIED; - } - final GA ga = artifact.getGa(); - - p.addArtifact(artifact); - productVersionDAO.update(p); - return ArtifactStatus.ADDED; - } - - private WhiteArtifact createArtifact(String groupId, String artifactId, String version) { - SuffixedVersion parsedVersion = versionParser.parse(version); - final boolean is3rdParty = !parsedVersion.isSuffixed(); - final String osgiVersion = VersionParser.getOSGiVersion(version); - - GA ga = gaDAO.findOrCreate(groupId, artifactId); - WhiteArtifact a = new WhiteArtifact(ga, version, currentUser(), osgiVersion, is3rdParty); - whiteArtifactDAO.create(a); - return a; - } - - @Override - public boolean removeArtifractFromProductVersion( - String groupId, - String artifactId, - String version, - Long productVersionId) { - ProductVersion pv = productVersionDAO.read(productVersionId); - if (pv == null) { - return false; - } - Optional a = whiteArtifactDAO.findArtifact(groupId, artifactId, version); - if (a.isPresent()) { - pv.removeArtifact(a.get()); - productVersionDAO.update(pv); - return true; - } - return false; - } - - @Override - public List getArtifacts(String groupId, String artifactId, String version) { - - // Black listed artifacts can't be queried - if (blackArtifactService.isArtifactPresent(groupId, artifactId, version)) { - return new ArrayList<>(); - } - String osgi = VersionParser.getOSGiVersion(version); - - List whites = new ArrayList<>(); - Optional origArtifact = whiteArtifactDAO.findArtifact(groupId, artifactId, version); - Optional normArtifact = whiteArtifactDAO.findArtifact(groupId, artifactId, osgi); - origArtifact.ifPresent(x -> whites.add(x)); - if (!normArtifact.equals(origArtifact)) { - normArtifact.ifPresent(x -> whites.add(x)); - } - List nonDupWhites = new ArrayList<>(new LinkedHashSet<>(whites)); - return nonDupWhites; - } - - @Override - public List getArtifacts(GAV gav) { - return getArtifacts(gav.getGroupId(), gav.getArtifactId(), gav.getVersion()); - } - - @Override - public boolean removeArtifact(String groupId, String artifactId, String version) { - Optional artifact = whiteArtifactDAO.findArtifact(groupId, artifactId, version); - if (artifact.isPresent()) { - List productVersions = productVersionDAO - .findProductVersionsWithArtifact(groupId, artifactId, version, true); - for (ProductVersion pv : productVersions) { - pv.removeArtifact(artifact.get()); - productVersionDAO.update(pv); - } - whiteArtifactDAO.delete(artifact.get()); - return true; - } - return false; - } -} diff --git a/reports-backend/src/main/java/org/jboss/da/products/api/ProductsService.java b/reports-backend/src/main/java/org/jboss/da/products/api/ProductsService.java deleted file mode 100644 index 39bb059a6..000000000 --- a/reports-backend/src/main/java/org/jboss/da/products/api/ProductsService.java +++ /dev/null @@ -1,12 +0,0 @@ -package org.jboss.da.products.api; - -import java.util.Set; - -/** - * - * @author Honza Brázdil <jbrazdil@redhat.com> - */ -public interface ProductsService { - - Set difference(long leftProduct, long rightProduct); -} diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/AggregatedProductProvider.java b/reports-backend/src/main/java/org/jboss/da/products/impl/AggregatedProductProvider.java index e0aa8636a..daea78b93 100644 --- a/reports-backend/src/main/java/org/jboss/da/products/impl/AggregatedProductProvider.java +++ b/reports-backend/src/main/java/org/jboss/da/products/impl/AggregatedProductProvider.java @@ -6,7 +6,6 @@ import org.jboss.da.products.api.Product; import org.jboss.da.products.api.ProductArtifacts; import org.jboss.da.products.api.ProductProvider; -import org.jboss.da.products.impl.DatabaseProductProvider.Database; import org.jboss.da.products.impl.RepositoryProductProvider.Repository; import org.jboss.da.products.impl.PncProductProvider.Pnc; @@ -65,10 +64,6 @@ public static CompletableFuture> filterProducts( // TODO: filter unknown products, so that when there is artifact both in unknown product and in // known product, it's removed from the unknown - @Inject - @Database - ProductProvider databaseProductProvider; - @Inject @Repository RepositoryProductProvider repositoryProductProvider; @@ -125,7 +120,6 @@ private CompletableFuture aggregate( Collector collector) { final List> results = new ArrayList<>(); - results.add(getter.apply(databaseProductProvider)); results.add(getter.apply(repositoryProductProvider)); results.add(getter.apply(pncProductProvider)); diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/DatabaseProductProvider.java b/reports-backend/src/main/java/org/jboss/da/products/impl/DatabaseProductProvider.java deleted file mode 100644 index e60884d3c..000000000 --- a/reports-backend/src/main/java/org/jboss/da/products/impl/DatabaseProductProvider.java +++ /dev/null @@ -1,161 +0,0 @@ -package org.jboss.da.products.impl; - -import org.jboss.da.listings.api.dao.ProductVersionDAO; -import org.jboss.da.listings.api.model.ProductVersion; -import org.jboss.da.listings.api.model.ProductVersionArtifactRelationship; -import org.jboss.da.listings.api.model.WhiteArtifact; -import org.jboss.da.listings.model.ProductSupportStatus; -import org.jboss.da.model.rest.GA; -import org.jboss.da.model.rest.GAV; -import org.jboss.da.products.api.Artifact; -import org.jboss.da.products.api.ArtifactType; -import org.jboss.da.products.api.MavenArtifact; -import org.jboss.da.products.api.Product; -import org.jboss.da.products.api.ProductArtifacts; -import org.jboss.da.products.api.ProductProvider; -import org.jboss.da.products.impl.DatabaseProductProvider.Database; - -import javax.inject.Inject; -import javax.inject.Qualifier; - -import static java.lang.annotation.ElementType.FIELD; -import static java.lang.annotation.ElementType.METHOD; -import static java.lang.annotation.ElementType.PARAMETER; -import static java.lang.annotation.ElementType.TYPE; -import java.lang.annotation.Retention; -import static java.lang.annotation.RetentionPolicy.RUNTIME; -import java.lang.annotation.Target; -import java.util.Collection; -import java.util.Collections; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import java.util.concurrent.CompletableFuture; -import java.util.function.Supplier; -import java.util.stream.Collectors; - -/** - * - * @author Honza Brázdil <jbrazdil@redhat.com> - */ -@Database -public class DatabaseProductProvider implements ProductProvider { - - @Inject - private ProductVersionDAO productVersionDAO; - - @Override - public CompletableFuture> getAllProducts() { - return getProductsAsync(() -> productVersionDAO.findAll()); - } - - @Override - public CompletableFuture> getProductsByName(String name) { - return getProductsAsync(() -> productVersionDAO.findProductVersionsWithProduct(name)); - } - - @Override - public CompletableFuture> getProductsByStatus(ProductSupportStatus status) { - return getProductsAsync(() -> productVersionDAO.findProductVersionsWithArtifactsByStatus(status)); - } - - @Override - public CompletableFuture> getArtifacts(Product product) { - return CompletableFuture.supplyAsync(() -> _getArtifacts(product)); - } - - private Set _getArtifacts(Product product) { - return productVersionDAO.findProductVersion(product.getName(), product.getVersion()) - .map(ProductVersion::getWhiteArtifacts) - .orElseGet(Collections::emptySet) - .stream() - .map(DatabaseProductProvider::toArtifact) - .collect(Collectors.toSet()); - } - - @Override - public CompletableFuture> getArtifacts(Artifact artifact) { - if (artifact.getType() != ArtifactType.MAVEN) { - return CompletableFuture.completedFuture(Collections.emptySet()); - } - GA ga = ((MavenArtifact) artifact).getGav().getGA(); - return CompletableFuture.supplyAsync(() -> getArtifacts(ga.getGroupId(), ga.getArtifactId(), Optional.empty())); - } - - @Override - public CompletableFuture> getArtifacts(Artifact artifact, ProductSupportStatus status) { - if (artifact.getType() != ArtifactType.MAVEN) { - return CompletableFuture.completedFuture(Collections.emptySet()); - } - GA ga = ((MavenArtifact) artifact).getGav().getGA(); - return CompletableFuture - .supplyAsync(() -> getArtifacts(ga.getGroupId(), ga.getArtifactId(), Optional.of(status))); - } - - @Override - public CompletableFuture>> getVersions(Artifact artifact) { - if (artifact.getType() != ArtifactType.MAVEN) { - return CompletableFuture.completedFuture(Collections.emptyMap()); - } - GA ga = ((MavenArtifact) artifact).getGav().getGA(); - return CompletableFuture.supplyAsync( - () -> getArtifacts(ga.getGroupId(), ga.getArtifactId(), Optional.empty()).stream() - .collect( - Collectors.toMap( - ProductArtifacts::getProduct, - x -> x.getArtifacts() - .stream() - .map(Artifact::getVersion) - .collect(Collectors.toSet())))); - } - - @Override - public CompletableFuture> getAllVersions(Artifact artifact) { - if (artifact.getType() != ArtifactType.MAVEN) { - return CompletableFuture.completedFuture(Collections.emptySet()); - } - GA ga = ((MavenArtifact) artifact).getGav().getGA(); - return CompletableFuture.supplyAsync( - () -> getArtifacts(ga.getGroupId(), ga.getArtifactId(), Optional.empty()).stream() - .flatMap(a -> a.getArtifacts().stream()) - .map(Artifact::getVersion) - .collect(Collectors.toSet())); - } - - private Set getArtifacts( - final String groupId, - final String artifactId, - final Optional st) { - return productVersionDAO.findProductVersionsWithArtifactsByGAStatus(groupId, artifactId, st) - .stream() - .map(DatabaseProductProvider::toProductArtifacts) - .collect(Collectors.toSet()); - } - - private CompletableFuture> getProductsAsync( - final Supplier> productsSupplier) { - return CompletableFuture.supplyAsync(productsSupplier) - .thenApply(pvs -> pvs.stream().map(DatabaseProductProvider::toProduct).collect(Collectors.toSet())); - } - - private static Product toProduct(ProductVersion p) { - return new Product(p.getProduct().getName(), p.getProductVersion(), p.getSupport()); - } - - private static ProductArtifacts toProductArtifacts(ProductVersionArtifactRelationship pvar) { - return new ProductArtifacts( - toProduct(pvar.getProductVersion()), - Collections.singleton(toArtifact(pvar.getArtifact()))); - } - - private static Artifact toArtifact(WhiteArtifact a) { - final org.jboss.da.listings.api.model.GA ga = a.getGa(); - return new MavenArtifact(new GAV(a.getGa().getGroupId(), ga.getArtifactId(), a.getVersion())); - } - - @Qualifier - @Retention(RUNTIME) - @Target({ TYPE, METHOD, FIELD, PARAMETER }) - public static @interface Database { - } -} diff --git a/reports-backend/src/main/java/org/jboss/da/products/impl/ProductsServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/products/impl/ProductsServiceImpl.java deleted file mode 100644 index de424b9ed..000000000 --- a/reports-backend/src/main/java/org/jboss/da/products/impl/ProductsServiceImpl.java +++ /dev/null @@ -1,67 +0,0 @@ -package org.jboss.da.products.impl; - -import org.jboss.da.listings.api.dao.ProductVersionDAO; -import org.jboss.da.listings.api.model.GA; -import org.jboss.da.listings.api.model.ProductVersion; -import org.jboss.da.listings.api.model.WhiteArtifact; -import org.jboss.da.products.api.ArtifactDiff; -import org.jboss.da.products.api.ProductsService; -import org.jboss.pnc.common.version.VersionComparator; -import org.jboss.pnc.common.version.VersionComparator.VersionDifference; -import org.jboss.pnc.common.version.VersionParser; - -import javax.inject.Inject; - -import java.util.HashSet; -import java.util.Map; -import java.util.Set; -import java.util.stream.Collectors; - -import static org.jboss.da.reports.impl.ReportsGeneratorImpl.DEFAULT_SUFFIX; - -/** - * - * @author Honza Brázdil <jbrazdil@redhat.com> - */ -public class ProductsServiceImpl implements ProductsService { - - @Inject - private ProductVersionDAO productVersionDAO; - - @Override - public Set difference(long leftProduct, long rightProduct) { - ProductVersion left = productVersionDAO.read(leftProduct); - ProductVersion right = productVersionDAO.read(rightProduct); - if (left == null || right == null) { - throw new IllegalArgumentException( - "One or both of the products (" + leftProduct + ", " + rightProduct + ") doesn't exists."); - } - Set leftArtifacts = left.getWhiteArtifacts(); - Set rightArtifacts = right.getWhiteArtifacts(); - Set allGAs = new HashSet<>(); - Map leftGAs = leftArtifacts.stream() - .peek(o -> allGAs.add(o.getGa())) - .collect(Collectors.toMap(WhiteArtifact::getGa, WhiteArtifact::getOsgiVersion)); - Map rightGAs = rightArtifacts.stream() - .peek(o -> allGAs.add(o.getGa())) - .collect(Collectors.toMap(WhiteArtifact::getGa, WhiteArtifact::getOsgiVersion)); - Set ret = new HashSet<>(); - - VersionComparator comparator = new VersionComparator(new VersionParser(DEFAULT_SUFFIX)); - for (GA ga : allGAs) { - String leftVersion = leftGAs.get(ga); - String rightVersion = rightGAs.get(ga); - VersionDifference difference = null; - if (leftVersion != null && rightVersion != null) { - difference = comparator.difference(leftVersion, rightVersion); - } - ArtifactDiff ad = new ArtifactDiff( - leftVersion, - new org.jboss.da.model.rest.GA(ga.getGroupId(), ga.getArtifactId()), - rightVersion, - difference); - ret.add(ad); - } - return ret; - } -} diff --git a/reports-backend/src/main/java/org/jboss/da/reports/backend/impl/ProductAdapter.java b/reports-backend/src/main/java/org/jboss/da/reports/backend/impl/ProductAdapter.java deleted file mode 100644 index 57ce64c26..000000000 --- a/reports-backend/src/main/java/org/jboss/da/reports/backend/impl/ProductAdapter.java +++ /dev/null @@ -1,104 +0,0 @@ -/* - * Copyright 2018 Honza Brázdil <jbrazdil@redhat.com>. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.jboss.da.reports.backend.impl; - -import org.jboss.da.listings.api.dao.ProductDAO; -import org.jboss.da.listings.api.dao.ProductVersionDAO; -import org.jboss.da.listings.api.model.ProductVersion; -import org.jboss.da.listings.api.service.ProductVersionService; -import org.jboss.da.products.api.Product; -import org.jboss.da.products.api.ProductProvider; - -import javax.enterprise.context.ApplicationScoped; -import javax.inject.Inject; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.HashSet; -import java.util.List; -import java.util.Set; -import java.util.stream.Collectors; - -/** - * This bean is used to translate products identified by the DB identifiers to abstract product objects used by Product - * Providers. - * - * @see Product - * @see ProductProvider - * @author Honza Brázdil <jbrazdil@redhat.com> - */ -@ApplicationScoped -public class ProductAdapter { - - @Inject - private ProductDAO productDao; - - @Inject - private ProductVersionDAO productVersionDao; - - @Inject - private ProductVersionService productVersionService; - - public Set toProducts(Set productNames, Set productVersionIds) { - Set productVersions = new HashSet<>(); - StringBuilder errorMsg = new StringBuilder(); - - if (productNames != null && !productNames.isEmpty()) { - List productsByName = productDao - .findAllWithNames(new ArrayList<>(productNames)); - if (productNames.size() == productsByName.size()) { - for (String productName : productNames) { - List prodVers = productVersionService.getAllForProduct(productName); - productVersions.addAll(prodVers); - } - } else { - // Error - Set unexistingProductNames = new HashSet<>(productNames); - productsByName.stream().forEach(x -> unexistingProductNames.remove(x.getName())); - errorMsg.append("Product names do not exist: "); - errorMsg.append(joinMissing(unexistingProductNames)); - } - } - - if (productVersionIds != null && !productVersionIds.isEmpty()) { - List prodVersionsById = productVersionDao - .findAllWithIds(new ArrayList<>(productVersionIds)); - if (productVersionIds.size() == prodVersionsById.size()) { - productVersions.addAll(prodVersionsById); - } else { - // Error - Set unexistingProductVersionIds = new HashSet<>(productVersionIds); - prodVersionsById.stream().forEach(x -> unexistingProductVersionIds.remove(x.getId())); - errorMsg.append("Product Versions do not exist: "); - errorMsg.append(joinMissing(unexistingProductVersionIds)); - } - } - - if (errorMsg.length() > 0) { - throw new IllegalArgumentException(errorMsg.toString()); - } - - return productVersions.stream().map(ProductAdapter::toProduct).collect(Collectors.toSet()); - } - - private String joinMissing(Collection invalidItems) { - return invalidItems.stream().map(Object::toString).collect(Collectors.joining(",", "[", "];")); - } - - private static Product toProduct(ProductVersion pv) { - return new Product(pv.getProduct().getName(), pv.getProductVersion()); - } -} diff --git a/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java b/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java index 682172d40..5afe9050b 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/impl/ReportsGeneratorImpl.java @@ -36,7 +36,6 @@ import org.jboss.da.reports.api.ProductArtifact; import org.jboss.da.reports.api.ReportsGenerator; import org.jboss.da.reports.backend.api.DependencyTreeGenerator; -import org.jboss.da.reports.backend.impl.ProductAdapter; import org.jboss.da.reports.model.api.SCMLocator; import org.jboss.da.reports.model.request.LookupGAVsRequest; import org.jboss.da.reports.model.request.LookupNPMRequest; @@ -124,9 +123,6 @@ public class ReportsGeneratorImpl implements ReportsGenerator { @Repository private RepositoryProductProvider repositoryProductProvider; - @Inject - private ProductAdapter productAdapter; - private Map modes; @Inject @@ -144,14 +140,11 @@ public Optional getReportFromSCM(SCMReportRequest scml) throw new IllegalArgumentException("SCM information can't be null"); } - Set products = productAdapter.toProducts(scml.getProductNames(), scml.getProductVersionIds()); GAVDependencyTree dt = dependencyTreeGenerator.getDependencyTree(scml.getScml()); - - return createReport(dt, products); + return createReport(dt); } - private Optional createReport(GAVDependencyTree dt, Set products) - throws CommunicationException { + private Optional createReport(GAVDependencyTree dt) throws CommunicationException { ArtifactReport report = new ArtifactReport(dt.getGav()); Set nodesVisited = new HashSet<>(); @@ -159,7 +152,7 @@ private Optional createReport(GAVDependencyTree dt, Set addDependencyReports(report, dt.getDependencies(), nodesVisited); List> futures = new ArrayList<>(); - traverseAndFill(report, products, futures); + traverseAndFill(report, futures); FuturesUtil.joinFutures(futures); @@ -184,18 +177,18 @@ private void addDependencyReports( } } - private void traverseAndFill(ArtifactReport report, Set products, List> futures) { - futures.add(fillArtifactReport(report, products)); + private void traverseAndFill(ArtifactReport report, List> futures) { + futures.add(fillArtifactReport(report)); for (ArtifactReport dep : report.getDependencies()) { - traverseAndFill(dep, products, futures); + traverseAndFill(dep, futures); } } - private CompletableFuture fillArtifactReport(ArtifactReport report, Set products) { + private CompletableFuture fillArtifactReport(ArtifactReport report) { GAV gav = report.getGav(); CompletableFuture> artifacts = aggProductProvider.getArtifacts(new MavenArtifact(gav)); - artifacts = filterProductArtifacts(products, artifacts); + artifacts = filterProductArtifacts(artifacts); report.setBlacklisted(blackArtifactService.isArtifactPresent(gav)); List suffixes = Collections.singletonList(DEFAULT_SUFFIX); @@ -239,10 +232,9 @@ public Optional getAdvancedReportFromSCM(SCMReportReques throws ScmException, PomAnalysisException, CommunicationException { SCMLocator scml = request.getScml(); - Set products = productAdapter.toProducts(request.getProductNames(), request.getProductVersionIds()); GAVDependencyTree dt = dependencyTreeGenerator.getDependencyTree(scml); - Optional artifactReport = createReport(dt, products); + Optional artifactReport = createReport(dt); // TODO: hardcoded to git // hopefully we'll get the cached cloned folder for this repo File repoFolder = scmManager.cloneRepository(SCMType.GIT, scml.getScmUrl(), scml.getRevision()); @@ -319,7 +311,6 @@ public Set getAligmentReport( scml.getRevision(), scml.getPomPath(), scml.getRepositories()); - Set products = productAdapter.toProducts(Collections.emptySet(), productIds); List> futures = new ArrayList<>(); Set ret = new TreeSet<>(Comparator.comparing(x -> x.getModule())); @@ -346,7 +337,6 @@ public Set getAligmentReport( CompletableFuture> artifacts = filterProducts( useUnknownProduct, - products, aggProductProvider.getArtifacts(new MavenArtifact(gav))); CompletableFuture versions = analyzeVersions( Collections.singletonList(DEFAULT_SUFFIX), @@ -390,18 +380,14 @@ private static Set getBuilt(Set a, VersionAn private CompletableFuture> filterProducts( boolean useUnknownProduct, - Set products, CompletableFuture> artifacts) { - Predicate pred = (x) -> true; - if (products.isEmpty()) { - pred = pred.and(p -> p.getStatus() == SUPPORTED || p.getStatus() == SUPERSEDED); - if (useUnknownProduct) { - pred = pred.or(p -> UNKNOWN.equals(p)); - } + Predicate pred = p -> p.getStatus() == SUPPORTED || p.getStatus() == SUPERSEDED; + if (useUnknownProduct) { + pred = pred.or(p -> UNKNOWN.equals(p)); } - artifacts = filterProductArtifacts(products, artifacts, pred); + artifacts = filterProductArtifacts(artifacts, pred); return artifacts; } @@ -633,13 +619,12 @@ private Map>> getProductArtifactsPer ProductProvider productProvider, LookupGAVsRequest request, Set uniqueGAs) throws CommunicationException { - Set products = productAdapter.toProducts(request.getProductNames(), request.getProductVersionIds()); Map>> gaProductArtifactsMap = new HashMap<>(); for (GA ga : uniqueGAs) { CompletableFuture> artifacts = productProvider .getArtifacts(new MavenArtifact(new GAV(ga, "0.0.0"))); - artifacts = filterProductArtifacts(products, artifacts); + artifacts = filterProductArtifacts(artifacts); gaProductArtifactsMap.put(ga, artifacts); } @@ -701,18 +686,13 @@ private static ProductArtifact toProductArtifact( } private CompletableFuture> filterProductArtifacts( - Set products, CompletableFuture> artifacts) { - return filterProductArtifacts(products, artifacts, x -> true); + return filterProductArtifacts(artifacts, x -> true); } private CompletableFuture> filterProductArtifacts( - Set products, CompletableFuture> artifacts, Predicate pred) { - if (!products.isEmpty()) { - pred = pred.and(p -> products.contains(p)); - } artifacts = AggregatedProductProvider.filterProducts(artifacts, pred); artifacts = filterBuiltArtifacts(artifacts); return artifacts; diff --git a/reports-backend/src/test/java/org/jboss/da/reports/impl/ReportsGeneratorImplTest.java b/reports-backend/src/test/java/org/jboss/da/reports/impl/ReportsGeneratorImplTest.java index e6933d94d..31ea17275 100644 --- a/reports-backend/src/test/java/org/jboss/da/reports/impl/ReportsGeneratorImplTest.java +++ b/reports-backend/src/test/java/org/jboss/da/reports/impl/ReportsGeneratorImplTest.java @@ -21,8 +21,6 @@ import org.jboss.da.communication.indy.api.IndyConnector; import org.jboss.da.communication.indy.model.GAVDependencyTree; import org.jboss.da.listings.api.service.BlackArtifactService; -import org.jboss.da.listings.api.service.ProductVersionService; -import org.jboss.da.listings.api.service.WhiteArtifactService; import org.jboss.da.listings.model.ProductSupportStatus; import org.jboss.da.model.rest.GA; import org.jboss.da.model.rest.GAV; @@ -37,7 +35,6 @@ import org.jboss.da.reports.api.ArtifactReport; import org.jboss.da.reports.backend.api.DependencyTreeGenerator; import org.jboss.da.reports.backend.impl.DependencyTreeGeneratorImpl; -import org.jboss.da.reports.backend.impl.ProductAdapter; import org.jboss.da.reports.model.request.GAVRequest; import org.jboss.da.reports.model.request.LookupGAVsRequest; import org.jboss.da.reports.model.response.LookupReport; @@ -73,12 +70,6 @@ public class ReportsGeneratorImplTest { @Mock private BlackArtifactService blackArtifactService; - @Mock - private WhiteArtifactService whiteArtifactService; - - @Mock - private ProductVersionService productVersionService; - @Mock private AggregatedProductProvider productProvider; @@ -94,10 +85,6 @@ public class ReportsGeneratorImplTest { @UserLog private Logger userLog; - @InjectMocks - @Spy - private final ProductAdapter productAdapter = new ProductAdapter(); - @InjectMocks @Spy private final DependencyTreeGenerator dependencyTreeGenerator = new DependencyTreeGeneratorImpl(); diff --git a/reports-model/src/main/java/org/jboss/da/products/model/rest/GADiff.java b/reports-model/src/main/java/org/jboss/da/products/model/rest/GADiff.java deleted file mode 100644 index b825d5f9f..000000000 --- a/reports-model/src/main/java/org/jboss/da/products/model/rest/GADiff.java +++ /dev/null @@ -1,82 +0,0 @@ -package org.jboss.da.products.model.rest; - -import org.jboss.da.model.rest.GA; -import org.jboss.da.model.rest.DummyVersionComparator; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonIgnore; -import com.fasterxml.jackson.annotation.JsonProperty; - -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.NonNull; - -/** - * - * @author jbrazdil - */ -@EqualsAndHashCode -public class GADiff implements Comparable { - - @NonNull - private final GA ga; - - @Getter - @NonNull - private final String leftVersion; - - @Getter - @NonNull - private final String rightVersion; - - @Getter - @NonNull - private final String differenceType; - - @JsonCreator - public GADiff( - @JsonProperty("groupId") String groupId, - @JsonProperty("artifactId") String artifactId, - @JsonProperty("leftVersion") String leftVersion, - @JsonProperty("rightVersion") String rightVersion, - @JsonProperty("differenceType") String differenceType) { - this.ga = new GA(groupId, artifactId); - this.leftVersion = leftVersion; - this.rightVersion = rightVersion; - this.differenceType = differenceType; - } - - public GADiff(GA ga, String leftVersion, String rightVersion, String differenceType) { - this.ga = ga; - this.leftVersion = leftVersion; - this.rightVersion = rightVersion; - this.differenceType = differenceType; - } - - @JsonIgnore - public GA getGA() { - return ga; - } - - public String getGroupId() { - return ga.getGroupId(); - } - - public String getArtifactId() { - return ga.getArtifactId(); - } - - @Override - public int compareTo(GADiff o) { - int gaCmp = this.ga.compareTo(o.ga); - if (gaCmp != 0) { - return gaCmp; - } - gaCmp = DummyVersionComparator.compareVersions(this.leftVersion, o.leftVersion); - if (gaCmp != 0) { - return gaCmp; - } - return DummyVersionComparator.compareVersions(this.rightVersion, o.rightVersion); - } - -} diff --git a/reports-model/src/main/java/org/jboss/da/products/model/rest/ProductDiff.java b/reports-model/src/main/java/org/jboss/da/products/model/rest/ProductDiff.java deleted file mode 100644 index 985746c7e..000000000 --- a/reports-model/src/main/java/org/jboss/da/products/model/rest/ProductDiff.java +++ /dev/null @@ -1,54 +0,0 @@ -package org.jboss.da.products.model.rest; - -import org.jboss.da.listings.model.rest.RestProduct; -import org.jboss.da.model.rest.GAV; - -import java.util.Set; -import java.util.TreeSet; - -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.NoArgsConstructor; -import lombok.NonNull; -import lombok.Setter; -import lombok.ToString; - -/** - * - * @author Honza Brázdil <jbrazdil@redhat.com> - */ -@NoArgsConstructor -@EqualsAndHashCode -@ToString -public class ProductDiff { - - @Getter - @Setter - @NonNull - private RestProduct leftProduct; - - @Getter - @Setter - @NonNull - private RestProduct rightProduct; - - @Getter - @Setter - @NonNull - private Set added = new TreeSet<>(); - - @Getter - @Setter - @NonNull - private Set removed = new TreeSet<>(); - - @Getter - @Setter - @NonNull - private Set changed = new TreeSet<>(); - - @Getter - @Setter - @NonNull - private Set unchanged = new TreeSet<>(); -} diff --git a/reports-model/src/main/java/org/jboss/da/reports/model/response/striped/WLStripper.java b/reports-model/src/main/java/org/jboss/da/reports/model/response/striped/WLStripper.java index 0058a88a0..6a48a649c 100644 --- a/reports-model/src/main/java/org/jboss/da/reports/model/response/striped/WLStripper.java +++ b/reports-model/src/main/java/org/jboss/da/reports/model/response/striped/WLStripper.java @@ -1,6 +1,5 @@ package org.jboss.da.reports.model.response.striped; -import lombok.extern.slf4j.Slf4j; import org.jboss.da.reports.model.response.*; import org.jboss.da.reports.model.response.RestVersionProduct; diff --git a/reports-model/src/test/java/org/jboss/da/model/rest/BackwardCompatibilityTest.java b/reports-model/src/test/java/org/jboss/da/model/rest/BackwardCompatibilityTest.java index 7bcbef965..0929dadcb 100644 --- a/reports-model/src/test/java/org/jboss/da/model/rest/BackwardCompatibilityTest.java +++ b/reports-model/src/test/java/org/jboss/da/model/rest/BackwardCompatibilityTest.java @@ -11,7 +11,6 @@ import org.jboss.da.listings.model.rest.RestProductInput; import org.jboss.da.listings.model.rest.SuccessResponse; import org.jboss.da.listings.model.rest.WLFill; -import org.jboss.da.products.model.rest.GADiff; import org.jboss.da.reports.model.request.GAVRequest; import org.jboss.da.reports.model.response.LookupReport; import org.jboss.da.reports.model.response.Report; @@ -140,13 +139,6 @@ public void testGAV() throws IOException { compare(gav, "GAV"); } - @Test - public void testGADiff() throws IOException { - GADiff gadiff = new GADiff(new GA("g", "a"), "1.0.0", "1.0.1", "MICRO"); - - compare(gadiff, "GADiff"); - } - @Test public void testGAVRequest() throws IOException { GAVRequest gavRequest = new GAVRequest("g", "a", "v", new HashSet<>(), new HashSet<>()); diff --git a/reports-rest/src/main/java/org/jboss/da/rest/ReportsRestActivator.java b/reports-rest/src/main/java/org/jboss/da/rest/ReportsRestActivator.java index a991b5f72..d7bfcc74e 100644 --- a/reports-rest/src/main/java/org/jboss/da/rest/ReportsRestActivator.java +++ b/reports-rest/src/main/java/org/jboss/da/rest/ReportsRestActivator.java @@ -18,9 +18,7 @@ import org.jboss.da.rest.exceptions.AllExceptionsMapper; import org.jboss.da.rest.filter.MDCLoggingFilter; -import org.jboss.da.rest.listings.Artifacts; import org.jboss.da.rest.listings.BlackListImpl; -import org.jboss.da.rest.products.Products; import org.jboss.da.rest.reports.Reports; import org.jboss.pnc.pncmetrics.rest.GeneralRestMetricsFilter; import org.jboss.pnc.pncmetrics.rest.TimedMetric; @@ -80,10 +78,8 @@ public void addSwaggerResources(Set> resources) { */ public void addProjectResources(Set> resources) { resources.add(Root.class); - resources.add(Artifacts.class); resources.add(Reports.class); resources.add(LookupImpl.class); - resources.add(Products.class); resources.add(BlackListImpl.class); resources.add(VersionEndpointImpl.class); } diff --git a/reports-rest/src/main/java/org/jboss/da/rest/listings/Artifacts.java b/reports-rest/src/main/java/org/jboss/da/rest/listings/Artifacts.java deleted file mode 100644 index a60221c2f..000000000 --- a/reports-rest/src/main/java/org/jboss/da/rest/listings/Artifacts.java +++ /dev/null @@ -1,416 +0,0 @@ -package org.jboss.da.rest.listings; - -import io.opentelemetry.instrumentation.annotations.SpanAttribute; -import io.opentelemetry.instrumentation.annotations.WithSpan; -import io.swagger.v3.oas.annotations.Operation; -import io.swagger.v3.oas.annotations.tags.Tag; -import org.jboss.da.listings.api.model.ProductVersion; -import org.jboss.da.listings.api.service.ArtifactService.ArtifactStatus; -import org.jboss.da.listings.api.service.BlackArtifactService; -import org.jboss.da.listings.api.service.ProductService; -import org.jboss.da.listings.api.service.ProductVersionService; -import org.jboss.da.listings.api.service.WLFiller; -import org.jboss.da.listings.api.service.WhiteArtifactFilterService; -import org.jboss.da.listings.api.service.WhiteArtifactService; -import org.jboss.da.listings.model.ProductSupportStatus; -import org.jboss.da.listings.model.rest.RestArtifact; -import org.jboss.da.listings.model.rest.RestProduct; -import org.jboss.da.listings.model.rest.RestProductArtifact; -import org.jboss.da.listings.model.rest.RestProductGAV; -import org.jboss.da.listings.model.rest.RestProductInput; -import org.jboss.da.listings.model.rest.SuccessResponse; -import org.jboss.da.listings.model.rest.WLFill; -import org.jboss.da.model.rest.ErrorMessage; -import org.jboss.da.validation.Validation; -import org.jboss.da.validation.ValidationException; - -import javax.inject.Inject; -import javax.persistence.EntityNotFoundException; -import javax.ws.rs.Consumes; -import javax.ws.rs.DELETE; -import javax.ws.rs.GET; -import javax.ws.rs.POST; -import javax.ws.rs.PUT; -import javax.ws.rs.Path; -import javax.ws.rs.Produces; -import javax.ws.rs.QueryParam; -import javax.ws.rs.core.MediaType; -import javax.ws.rs.core.Response; -import javax.ws.rs.core.Response.Status; - -import java.util.Collection; -import java.util.Optional; - -/** - * - * @author Jozef Mrazek <jmrazek@redhat.com> - * @author Jakub Bartecek <jbartece@redhat.com> - * - */ -@Path("/listings") -@Tag(name = "deprecated") -public class Artifacts { - - @Inject - private RestConvert convert; - - @Inject - private WLFiller filler; - - @Inject - private WhiteArtifactService whiteService; - - @Inject - private BlackArtifactService blackService; - - @Inject - private ProductService productService; - - @Inject - private ProductVersionService productVersionService; - - @Inject - private WhiteArtifactFilterService whiteArtifactFilterService; - - @Inject - private Validation validation; - - // ////////////////////////////////// - // Whitelist endpoints - - @GET - @Path("/whitelist") - @Produces(MediaType.APPLICATION_JSON) - @Operation(deprecated = true) - @WithSpan() - public Collection getAllWhiteArtifacts() { - return convert.toRestProductGAVList(whiteArtifactFilterService.getAllWithWhiteArtifacts()); - } - - @POST - @Path("/whitelist/fill/scm") - @Consumes(MediaType.APPLICATION_JSON) - @Produces(MediaType.APPLICATION_JSON) - @Operation(deprecated = true) - @WithSpan() - public Response fillFromGitBom(@SpanAttribute(value = "wlFill") WLFill wlFill) { - - SuccessResponse response = new SuccessResponse(); - try { - validation.validation(wlFill, "Filling product from GIT POM failed"); - } catch (ValidationException e) { - return e.getResponse(); - } - WLFiller.WLStatus result = filler.fillWhitelistFromPom( - wlFill.getScmUrl(), - wlFill.getRevision(), - wlFill.getPomPath(), - wlFill.getRepositories(), - wlFill.getProductId()); - switch (result) { - case PRODUCT_NOT_FOUND: - response.setSuccess(false); - response.setMessage("Product with this id not found"); - return Response.status(Status.NOT_FOUND).entity(response).build(); - case FILLED: - response.setSuccess(true); - return Response.ok().entity(response).build(); - case ANALYSER_ERROR: - response.setSuccess(false); - response.setMessage("Error while analysing pom file"); - return Response.status(Status.BAD_REQUEST).entity(response).build(); - default: - return Response.status(Status.INTERNAL_SERVER_ERROR) - .entity( - new ErrorMessage( - ErrorMessage.ErrorType.UNEXPECTED_SERVER_ERR, - "Unexpected server error occurred", - "Result was " + result)) - .build(); - } - } - - @POST - @Path("/whitelist/fill/gav") - @Consumes(MediaType.APPLICATION_JSON) - @Produces(MediaType.APPLICATION_JSON) - @Operation(deprecated = true) - @WithSpan() - public Response fillFromGAVBom(@SpanAttribute(value = "a") RestProductArtifact a) { - SuccessResponse response = new SuccessResponse(); - WLFiller.WLStatus result = filler - .fillWhitelistFromGAV(a.getGroupId(), a.getArtifactId(), a.getVersion(), a.getProductId()); - switch (result) { - case PRODUCT_NOT_FOUND: - response.setSuccess(false); - response.setMessage("Product with this id not found"); - return Response.status(Status.NOT_FOUND).entity(response).build(); - case FILLED: - response.setSuccess(true); - return Response.ok().entity(response).build(); - case ANALYSER_ERROR: - response.setSuccess(false); - response.setMessage("Error while analysing pom file"); - return Response.status(Status.BAD_REQUEST).entity(response).build(); - case POM_NOT_FOUND: - response.setSuccess(false); - response.setMessage("Could not found pom file in repository"); - return Response.status(Status.NOT_FOUND).entity(response).build(); - default: - return Response.status(Status.INTERNAL_SERVER_ERROR) - .entity( - new ErrorMessage( - ErrorMessage.ErrorType.UNEXPECTED_SERVER_ERR, - "Unexpected server error occurred", - "Result was " + result)) - .build(); - } - } - - @POST - @Path("/whitelist/gav") - @Consumes(MediaType.APPLICATION_JSON) - @Produces(MediaType.APPLICATION_JSON) - @Operation(deprecated = true) - @WithSpan() - public Response addWhiteArtifact(@SpanAttribute(value = "artifact") RestProductArtifact artifact) { - SuccessResponse response = new SuccessResponse(); - try { - ArtifactStatus result = whiteService.addArtifact( - artifact.getGroupId(), - artifact.getArtifactId(), - artifact.getVersion(), - artifact.getProductId()); - switch (result) { - case ADDED: - response.setSuccess(true); - return Response.ok(response).build(); - case IS_BLACKLISTED: - return Response.status(Response.Status.CONFLICT) - .entity( - new ErrorMessage( - ErrorMessage.ErrorType.BLACKLIST, - "Can't add artifact to whitelist, artifact is blacklisted", - null)) - .build(); - case NOT_MODIFIED: - response.setSuccess(false); - return Response.ok(response).build(); - default: - return Response.status(Response.Status.INTERNAL_SERVER_ERROR) - .entity( - new ErrorMessage( - ErrorMessage.ErrorType.UNEXPECTED_SERVER_ERR, - "Unexpected server error occurred.", - "Result was " + result)) - .build(); - } - } catch (IllegalArgumentException ex) { - return Response.status(Response.Status.BAD_REQUEST).entity(ex.getMessage()).build(); - } - } - - @DELETE - @Path("/whitelist/gav") - @Consumes(MediaType.APPLICATION_JSON) - @Produces(MediaType.APPLICATION_JSON) - @Operation(deprecated = true) - @WithSpan() - public SuccessResponse removeWhiteArtifact(@SpanAttribute(value = "artifact") RestArtifact artifact) { - SuccessResponse response = new SuccessResponse(); - response.setSuccess( - whiteService.removeArtifact(artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion())); - return response; - } - - @DELETE - @Path("/whitelist/gavproduct") - @Consumes(MediaType.APPLICATION_JSON) - @Produces(MediaType.APPLICATION_JSON) - @Operation(deprecated = true) - @WithSpan() - public SuccessResponse removeWhiteArtifactFromProduct( - @SpanAttribute(value = "artifact") RestProductArtifact artifact) { - SuccessResponse response = new SuccessResponse(); - response.setSuccess( - whiteService.removeArtifractFromProductVersion( - artifact.getGroupId(), - artifact.getArtifactId(), - artifact.getVersion(), - artifact.getProductId())); - return response; - } - - // ////////////////////////////// - // whitelist products endpoints - - @POST - @Path("/whitelist/product") - @Consumes(MediaType.APPLICATION_JSON) - @Produces(MediaType.APPLICATION_JSON) - @Operation(deprecated = true) - @WithSpan() - public Response addProduct(@SpanAttribute(value = "product") RestProductInput product) { - SuccessResponse response = new SuccessResponse(); - if (product.getName().isEmpty() || product.getVersion().isEmpty()) { - return Response.status(Response.Status.BAD_REQUEST) - .entity( - new ErrorMessage( - ErrorMessage.ErrorType.PARAMS_REQUIRED, - "Name and version parameters are required", - null)) - .build(); - } - if (product.getSupportStatus() == null) { - product.setSupportStatus(ProductSupportStatus.SUPPORTED); - } - response.setSuccess( - productService.addProduct(product.getName(), product.getVersion(), product.getSupportStatus())); - Long id = productVersionService.getProductVersion(product.getName(), product.getVersion()).get().getId(); - response.setId(id); - return Response.ok(response).build(); - } - - @DELETE - @Path("/whitelist/product") - @Consumes(MediaType.APPLICATION_JSON) - @Produces(MediaType.APPLICATION_JSON) - @Operation(deprecated = true) - @WithSpan() - public Response removeProduct(@SpanAttribute(value = "product") RestProductInput product) { - SuccessResponse response = new SuccessResponse(); - try { - response.setSuccess(productService.removeProduct(product.getName(), product.getVersion())); - } catch (EntityNotFoundException e) { - return Response.status(Response.Status.NOT_FOUND) - .entity( - new ErrorMessage( - ErrorMessage.ErrorType.PRODUCT_NOT_FOUND, - "Product not found", - e.getMessage())) - .build(); - } - return Response.ok(response).build(); - } - - @PUT - @Path("/whitelist/product") - @Consumes(MediaType.APPLICATION_JSON) - @Produces(MediaType.APPLICATION_JSON) - @Operation(deprecated = true) - @WithSpan() - public Response changeProductStatus(@SpanAttribute(value = "product") RestProductInput product) { - SuccessResponse response = new SuccessResponse(); - if (product.getSupportStatus() == null) { - return Response.status(Response.Status.BAD_REQUEST) - .entity( - new ErrorMessage( - ErrorMessage.ErrorType.PARAMS_REQUIRED, - "All parameters are required", - "Parameter support status is required")) - .build(); - } - if (!productService.changeProductStatus(product.getName(), product.getVersion(), product.getSupportStatus())) { - return Response.status(Response.Status.NOT_FOUND) - .entity(new ErrorMessage(ErrorMessage.ErrorType.PRODUCT_NOT_FOUND, "Product not found", null)) - .build(); - } - response.setSuccess(true); - return Response.ok(response).build(); - } - - @GET - @Path("/whitelist/products") - @Produces(MediaType.APPLICATION_JSON) - @Operation(deprecated = true) - @WithSpan() - public Collection getProducts() { - return convert.toRestProductList(productVersionService.getAll()); - } - - @GET - @Path("/whitelist/product") - @Produces(MediaType.APPLICATION_JSON) - @Operation(deprecated = true) - @WithSpan() - public Collection getProduct( - @SpanAttribute(value = "id") @QueryParam("id") Long id, - @SpanAttribute(value = "name") @QueryParam("name") String name, - @SpanAttribute(value = "version") @QueryParam("version") String version, - @SpanAttribute(value = "supportStatus") @QueryParam("supportStatus") ProductSupportStatus supportStatus) { - return convert.toRestProductList(productVersionService.getProductVersions(id, name, version, supportStatus)); - } - - // ////////////////////////////// - // whitelist search endpoints - - @GET - @Path("/whitelist/artifacts/product") - @Produces(MediaType.APPLICATION_JSON) - @Operation(deprecated = true) - @WithSpan() - public Response artifactsOfProduct( - @SpanAttribute(value = "name") @QueryParam("name") String name, - @SpanAttribute(value = "version") @QueryParam("version") String version) { - Optional pv = whiteArtifactFilterService.getProductVersionWithWhiteArtifacts(name, version); - if (pv.isPresent()) { - return Response.ok(convert.toRestProductGAV(pv.get())).build(); - } - return Response.status(Response.Status.NOT_FOUND) - .entity(new ErrorMessage(ErrorMessage.ErrorType.PRODUCT_NOT_FOUND, "Product not found", null)) - .build(); - - } - - @GET - @Path("/whitelist/artifacts/gav") - @Produces(MediaType.APPLICATION_JSON) - @Operation(deprecated = true) - @WithSpan() - public Response productsWithArtifactGAV( - @SpanAttribute(value = "groupId") @QueryParam("groupid") String groupId, - @SpanAttribute(value = "artifactId") @QueryParam("artifactid") String artifactId, - @SpanAttribute(value = "version") @QueryParam("version") String version) { - - return Response - .ok( - convert.fromRelationshipToRestProductGAVList( - whiteArtifactFilterService - .getProductVersionsWithWhiteArtifactsByGAV(groupId, artifactId, version))) - .build(); - } - - @GET - @Path("/whitelist/artifacts/status") - @Produces(MediaType.APPLICATION_JSON) - @Operation(deprecated = true) - @WithSpan() - public Response productsWithArtifactStatus( - @SpanAttribute(value = "status") @QueryParam("status") ProductSupportStatus status) { - - return Response - .ok( - convert.toRestProductGAVList( - whiteArtifactFilterService.getProductVersionsWithWhiteArtifactsByStatus(status))) - .build(); - } - - @GET - @Path("/whitelist/artifacts/gastatus") - @Produces(MediaType.APPLICATION_JSON) - @Operation(deprecated = true) - @WithSpan() - public Response productsWithArtifactGAAndStatus( - @SpanAttribute(value = "groupId") @QueryParam("groupid") String groupId, - @SpanAttribute(value = "artifactId") @QueryParam("artifactid") String artifactId, - @SpanAttribute(value = "status") @QueryParam("status") ProductSupportStatus status) { - - return Response - .ok( - convert.fromRelationshipToRestProductGAVList( - whiteArtifactFilterService - .getProductVersionsWithWhiteArtifactsByGAStatus(groupId, artifactId, status))) - .build(); - } - -} diff --git a/reports-rest/src/main/java/org/jboss/da/rest/listings/RestConvert.java b/reports-rest/src/main/java/org/jboss/da/rest/listings/RestConvert.java index 12c8e0508..a0758aa94 100644 --- a/reports-rest/src/main/java/org/jboss/da/rest/listings/RestConvert.java +++ b/reports-rest/src/main/java/org/jboss/da/rest/listings/RestConvert.java @@ -1,8 +1,6 @@ package org.jboss.da.rest.listings; import org.jboss.da.listings.api.model.Artifact; -import org.jboss.da.listings.api.model.ProductVersion; -import org.jboss.da.listings.api.model.ProductVersionArtifactRelationship; import org.jboss.da.listings.model.rest.RestArtifact; import org.jboss.da.listings.model.rest.RestProduct; import org.jboss.da.listings.model.rest.RestProductGAV; @@ -26,65 +24,6 @@ public List toRestArtifacts(Collection art return artifacts.stream().map(RestConvert::toRestArtifact).collect(Collectors.toList()); } - public List toRestProductGAV(ProductVersion pv) { - List rpgList = new ArrayList<>(); - for (Artifact a : pv.getWhiteArtifacts()) { - RestProductGAV rpg = new RestProductGAV(); - rpg.setName(pv.getProduct().getName()); - rpg.setVersion(pv.getProductVersion()); - rpg.setSupportStatus(pv.getSupport()); - RestArtifact ra = new RestArtifact(); - ra.setArtifactId(a.getGa().getArtifactId()); - ra.setGroupId(a.getGa().getGroupId()); - ra.setVersion(a.getVersion()); - rpg.setGav(ra); - rpgList.add(rpg); - } - return rpgList; - } - - public List toRestProductGAVList(List productVersions) { - List rpgl = new ArrayList<>(); - for (ProductVersion p : productVersions) { - rpgl.addAll(toRestProductGAV(p)); - } - return rpgl; - } - - public List toRestProductList(List productVersions) { - List lrp = new ArrayList<>(); - for (ProductVersion p : productVersions) { - lrp.add(toRestProduct(p)); - } - return lrp; - } - - public RestProduct toRestProduct(ProductVersion productVersion) { - RestProduct rp = new RestProduct(); - rp.setId(productVersion.getId()); - rp.setName(productVersion.getProduct().getName()); - rp.setVersion(productVersion.getProductVersion()); - rp.setSupportStatus(productVersion.getSupport()); - return rp; - } - - public List fromRelationshipToRestProductGAVList(List rl) { - List rpgList = new ArrayList<>(); - for (ProductVersionArtifactRelationship r : rl) { - RestProductGAV rpg = new RestProductGAV(); - rpg.setName(r.getProductVersion().getProduct().getName()); - rpg.setVersion(r.getProductVersion().getProductVersion()); - rpg.setSupportStatus(r.getProductVersion().getSupport()); - RestArtifact ra = new RestArtifact(); - ra.setArtifactId(r.getArtifact().getGa().getArtifactId()); - ra.setGroupId(r.getArtifact().getGa().getGroupId()); - ra.setVersion(r.getArtifact().getVersion()); - rpg.setGav(ra); - rpgList.add(rpg); - } - return rpgList; - } - private static RestArtifact toRestArtifact(Artifact a) { RestArtifact ra = new RestArtifact(); ra.setArtifactId(a.getGa().getArtifactId()); diff --git a/reports-rest/src/main/java/org/jboss/da/rest/products/Products.java b/reports-rest/src/main/java/org/jboss/da/rest/products/Products.java deleted file mode 100644 index 3ef71c0ac..000000000 --- a/reports-rest/src/main/java/org/jboss/da/rest/products/Products.java +++ /dev/null @@ -1,111 +0,0 @@ -package org.jboss.da.rest.products; - -import io.opentelemetry.instrumentation.annotations.SpanAttribute; -import io.opentelemetry.instrumentation.annotations.WithSpan; -import io.swagger.v3.oas.annotations.Operation; -import io.swagger.v3.oas.annotations.tags.Tag; -import org.jboss.da.listings.api.model.ProductVersion; -import org.jboss.da.listings.api.service.ProductVersionService; -import org.jboss.da.model.rest.ErrorMessage; -import org.jboss.da.model.rest.GAV; -import org.jboss.da.products.api.ArtifactDiff; - -import javax.inject.Inject; -import javax.ws.rs.GET; -import javax.ws.rs.Path; -import javax.ws.rs.Produces; -import javax.ws.rs.QueryParam; -import javax.ws.rs.core.MediaType; - -import org.jboss.da.products.api.ProductsService; -import org.jboss.da.products.model.rest.GADiff; -import org.jboss.da.products.model.rest.ProductDiff; -import org.jboss.da.rest.listings.RestConvert; - -import javax.ws.rs.core.Response; -import static javax.ws.rs.core.Response.Status.NOT_FOUND; - -import java.util.Optional; -import java.util.Set; -import java.util.stream.Collectors; - -import java.util.TreeSet; - -/** - * - * @author Honza Brázdil <jbrazdil@redhat.com> - */ -@Path("/products") -@Tag(name = "deprecated") -public class Products { - - @Inject - private ProductsService products; - - @Inject - private ProductVersionService productService; - - @Inject - private RestConvert convert; - - @GET - @Path("/diff") - @Produces(MediaType.APPLICATION_JSON) - @Operation(deprecated = true) - @WithSpan() - public Response getProduct( - @SpanAttribute(value = "leftProduct") @QueryParam("leftProduct") Long leftProduct, - @SpanAttribute(value = "rightProduct") @QueryParam("rightProduct") Long rightProduct) { - Optional left = productService.getProductVersion(leftProduct); - if (!left.isPresent()) { - return Response.status(NOT_FOUND) - .entity( - new ErrorMessage( - ErrorMessage.ErrorType.PRODUCT_NOT_FOUND, - "Product " + leftProduct + " doesn't exist.", - null)) - .build(); - } - Optional right = productService.getProductVersion(rightProduct); - if (!right.isPresent()) { - return Response.status(NOT_FOUND) - .entity( - new ErrorMessage( - ErrorMessage.ErrorType.PRODUCT_NOT_FOUND, - "Product " + rightProduct + " doesn't exist.", - null)) - .build(); - } - Set diff = products.difference(leftProduct, rightProduct); - - ProductDiff ret = new ProductDiff(); - ret.setLeftProduct(convert.toRestProduct(left.get())); - ret.setRightProduct(convert.toRestProduct(right.get())); - ret.setAdded( - diff.stream() - .filter(ArtifactDiff::isAdded) - .map(d -> new GAV(d.getGa(), d.getRightVersion())) - .collect(Collectors.toCollection(TreeSet::new))); - ret.setRemoved( - diff.stream() - .filter(ArtifactDiff::isRemoved) - .map(d -> new GAV(d.getGa(), d.getLeftVersion())) - .collect(Collectors.toCollection(TreeSet::new))); - ret.setChanged( - diff.stream() - .filter(ArtifactDiff::isChanged) - .map( - d -> new GADiff( - d.getGa(), - d.getLeftVersion(), - d.getRightVersion(), - d.getDifference().toString())) - .collect(Collectors.toCollection(TreeSet::new))); - ret.setUnchanged( - diff.stream() - .filter(ArtifactDiff::isUnchanged) - .map(d -> new GAV(d.getGa(), d.getLeftVersion())) - .collect(Collectors.toCollection(TreeSet::new))); - return Response.ok().entity(ret).build(); - } -} diff --git a/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/AbstractRestApiListingTest.java b/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/AbstractRestApiListingTest.java index 90c90c437..979b95a64 100644 --- a/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/AbstractRestApiListingTest.java +++ b/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/AbstractRestApiListingTest.java @@ -6,7 +6,6 @@ import java.io.File; import java.io.IOException; -import java.util.ArrayList; import java.util.List; import static org.junit.Assert.assertEquals; @@ -24,7 +23,7 @@ public abstract class AbstractRestApiListingTest extends AbstractRestReportsTest { protected enum ListEntityType { - BLACK, WHITE, PRODUCT; + BLACK; } protected enum OperationType { @@ -33,33 +32,16 @@ protected enum OperationType { protected static final String PATH_FILES_LISTINGS_GAV = "/listings"; - protected static final String PATH_WHITE_LIST = "/listings/whitelist"; - protected static final String PATH_BLACK_LIST = "/listings/blacklist"; - protected static final String PATH_WHITE_LISTINGS_GAV = "/listings/whitelist/gav"; - - protected static final String PATH_WHITE_ARTIFACTS = "/listings/whitelist/artifacts/gav"; - protected static final String PATH_BLACK_LISTINGS_GAV = "/listings/blacklist/gav"; protected static final String PATH_BLACK_LISTINGS_GA = "/listings/blacklist/ga"; - protected static final String PATH_PRODUCT = "/listings/whitelist/product"; - - protected static final String PATH_PRODUCTS = "/listings/whitelist/products"; - @After public void dropTables() throws Exception { - List whitelistedArtifacts = getAllWhiteArtifactsFromList(PATH_WHITE_LIST); - List artifacts = whiteToRestArtifactList(whitelistedArtifacts); - artifacts.forEach(gav -> removeGavFromList(PATH_WHITE_LISTINGS_GAV, gav)); - List blacklistedArtifacts = getAllArtifactsFromList(PATH_BLACK_LIST); blacklistedArtifacts.forEach(gav -> removeGavFromList(PATH_BLACK_LISTINGS_GAV, gav)); - - List products = getAllProductsFromList(PATH_PRODUCTS); - products.forEach(product -> removeProductFromList(PATH_PRODUCT, product)); } private void removeGavFromList(String listUrl, RestArtifact gav) { @@ -70,15 +52,6 @@ private void removeGavFromList(String listUrl, RestArtifact gav) { } } - private void removeProductFromList(String url, RestProduct product) { - try { - createClientRequest(url).method("DELETE", Entity.json(toRestProductRequest(product)), String.class); - } catch (Exception e) { - fail("Failed to remove product from the list using URL " + url); - } - - } - private String toRestProductRequest(RestProduct p) { return "{" + "\"name\":" + "\"" + p.getName() + "\"," + "\"version\":" + "\"" + p.getVersion() + "\"" + "}"; } @@ -88,16 +61,6 @@ protected List getAllArtifactsFromList(String listUrl) throws Exce }, listUrl); } - private List getAllWhiteArtifactsFromList(String listUrl) throws Exception { - return processGetRequest(new GenericType>() { - }, listUrl); - } - - private List getAllProductsFromList(String listUrl) throws Exception { - return processGetRequest(new GenericType>() { - }, listUrl); - } - private T processGetRequest(GenericType type, String url) throws Exception { Response response = createClientRequest(url).get(); @@ -129,15 +92,9 @@ protected Response manipulateEntityString( Boolean checkSuccess) throws Exception { String path = null; switch (entity) { - case WHITE: - path = PATH_WHITE_LISTINGS_GAV; - break; case BLACK: path = PATH_BLACK_LISTINGS_GAV; break; - case PRODUCT: - path = PATH_PRODUCT; - break; } Invocation.Builder request = createClientRequest(path); @@ -161,20 +118,4 @@ protected Response manipulateEntityString( return response; } - private List whiteToRestArtifactList(List whites) { - List artifacts = new ArrayList<>(); - for (RestWhiteArtifact w : whites) { - RestArtifact a = new RestArtifact(); - a.setArtifactId(w.getGav().artifactId); - a.setGroupId(w.getGav().getGroupId()); - a.setVersion(w.getGav().getVersion()); - artifacts.add(a); - } - return artifacts; - } - - protected long getIdOfProduct(String name, String version) throws Exception { - return createClientRequest(PATH_PRODUCT + "?name=" + name + "&version=" + version).get(RestProduct[].class)[0] - .getId(); - } } diff --git a/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/RestApiListingsTestIT.java b/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/RestApiListingsTestIT.java index 9d419ada3..949e1c3c0 100644 --- a/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/RestApiListingsTestIT.java +++ b/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/RestApiListingsTestIT.java @@ -17,33 +17,6 @@ public class RestApiListingsTestIT extends AbstractRestApiListingTest { private final RequestGenerator generator = new RequestGenerator(); - @Test - public void testAddProduct() throws Exception { - Response response = manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); - - checkExpectedResponse(response, "success"); - } - - @Test - public void testChangeProduct() throws Exception { - Response response = manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); - - checkExpectedResponse(response, "success"); - - manipulateEntityFile(ListEntityType.PRODUCT, OperationType.PUT, "productChangeStatus", true); - } - - @Test - public void testDeleteProduct() throws Exception { - Response response = manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); - - checkExpectedResponse(response, "success"); - - response = manipulateEntityFile(ListEntityType.PRODUCT, OperationType.DELETE, "productAdd", true); - - checkExpectedResponse(response, "success"); - } - @Test public void testAddBlackArtifact() throws Exception { Response response = manipulateEntityFile(ListEntityType.BLACK, OperationType.POST, "gav", true); @@ -147,172 +120,6 @@ public void testAlreadyAddedBlackArtifact() throws Exception { checkExpectedResponse(response, "successFalse"); } - @Test - public void testAddWhiteArtifact() throws Exception { - Response response = manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); - - checkExpectedResponse(response, "success"); - - String artifact = generator.returnWhiteArtifactString( - "org.jboss.da", - "dependency-analyzer", - "0.3.0", - getIdOfProduct("test", "1.0.0")); - - response = manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); - - checkExpectedResponse(response, "success"); - } - - @Test - public void testDeleteWhiteArtifact() throws Exception { - Response response = manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); - - checkExpectedResponse(response, "success"); - - String artifact = generator.returnWhiteArtifactString( - "org.jboss.da", - "dependency-analyzer", - "0.3.0", - getIdOfProduct("test", "1.0.0")); - - response = manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); - - checkExpectedResponse(response, "success"); - - // delete artifact - response = manipulateEntityFile(ListEntityType.WHITE, OperationType.DELETE, "gav", true); - - checkExpectedResponse(response, "success"); - } - - @Test - public void testDeleteNonExistingWhiteArtifact() throws Exception { - Response response = manipulateEntityFile(ListEntityType.WHITE, OperationType.DELETE, "gav", true); - - checkExpectedResponse(response, "successFalse"); - } - - @Test - public void testAddBlacklistedArtifactToWhitelist() throws Exception { - // Add artifact to blacklist - Response response = manipulateEntityFile(ListEntityType.BLACK, OperationType.POST, "gav", true); - checkExpectedResponse(response, "success"); - - // Try to add artifact to whitelist - response = manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); - - checkExpectedResponse(response, "success"); - - String artifact = generator.returnWhiteArtifactString( - "org.jboss.da", - "dependency-analyzer", - "0.3.0", - getIdOfProduct("test", "1.0.0")); - - response = manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, false); - - assertEquals(200, response.getStatus()); - } - - @Test - public void testAddWhitelistedArtifactToBlacklist() throws Exception { - manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); - - // Add artifact to whitelist - String artifact = generator.returnWhiteArtifactString( - "org.jboss.da", - "dependency-analyzer", - "0.3.0", - getIdOfProduct("test", "1.0.0")); - - manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); - - // Add artifact to blacklist - Response response = manipulateEntityFile(ListEntityType.BLACK, OperationType.POST, "gav", true); - - checkExpectedResponse(response, "successMessage"); - - assertEquals(0, getAllArtifactsFromList(PATH_WHITE_LIST).size()); - } - - @Test - public void testAddMultipleTimeWhitelistedArtifactToBlacklist() throws Exception { - manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); - manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd2", true); - - // Add artifacts to whitelist - String artifact; - artifact = generator.returnWhiteArtifactString( - "org.jboss.da", - "dependency-analyzer", - "0.3.0", - getIdOfProduct("test", "1.0.0")); - - manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); - - artifact = generator.returnWhiteArtifactString( - "org.jboss.da", - "dependency-analyzer", - "0.3.0", - getIdOfProduct("test", "2.0.0")); - - manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); - // Add artifact to blacklist - Response response = manipulateEntityFile(ListEntityType.BLACK, OperationType.POST, "gav", true); - - checkExpectedResponse(response, "successMessage"); - } - - @Test - public void testAlreadyAddedWhiteArtifact() throws Exception { - manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); - - String artifact = generator.returnWhiteArtifactString( - "org.jboss.da", - "dependency-analyzer", - "0.3.0", - getIdOfProduct("test", "1.0.0")); - - manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); - - // add second white artifact - Response response = manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); - - checkExpectedResponse(response, "successFalse"); - } - - @Test - public void testGetAllWhiteArtifacts() throws Exception { - // Add artifacts to whitelist - manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); - manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd2", true); - - // Add artifacts to whitelist - String artifact; - artifact = generator.returnWhiteArtifactString( - "org.jboss.da", - "dependency-analyzer", - "0.3.0", - getIdOfProduct("test", "1.0.0")); - - manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); - - artifact = generator.returnWhiteArtifactString( - "org.jboss.da", - "dependency-analyzer", - "0.3.0", - getIdOfProduct("test", "2.0.0")); - - manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); - - // Get list - Response response = createClientRequest(PATH_WHITE_LIST).get(); - assertEquals(200, response.getStatus()); - - checkExpectedResponse(response, "gavWhiteList"); - } - @Test public void testGetAllBlackArtifacts() throws Exception { // Add artifacts to blacklist @@ -403,49 +210,6 @@ public void testCheckNonRHNonOSGiBlackArtifact() throws Exception { checkExpectedResponse(response, "gavResponse"); } - @Test - public void testCheckRHWhiteArtifact() throws Exception { - manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); - - String artifact = generator.returnWhiteArtifactString( - "org.jboss.da", - "dependency-analyzer", - "0.3.0.redhat-1", - getIdOfProduct("test", "1.0.0")); - - manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); - - Response response = createClientRequest( - PATH_WHITE_LIST + "?groupid=org.jboss.da&artifactid=dependency-analyzer&version=0.3.0.redhat-1").get(); - assertEquals(200, response.getStatus()); - - checkExpectedResponse(response, "gavRhResponse"); - } - - /** - * Non RedHat but OSGi compliant white artifact test - * - * @throws Exception - */ - @Test - public void testCheckNonRHWhiteArtifact() throws Exception { - manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); - - String artifact = generator.returnWhiteArtifactString( - "org.jboss.da", - "dependency-analyzer", - "0.3.0.redhat-1", - getIdOfProduct("test", "1.0.0")); - - manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); - - Response response = createClientRequest( - PATH_WHITE_LIST + "?groupid=org.jboss.da&artifactid=dependency-analyzer&version=0.3.0").get(); - assertEquals(200, response.getStatus()); - - checkExpectedResponse(response, "gavRhResponse"); - } - @Override protected void assertEqualsJson(String expected, String actual) { try { diff --git a/testsuite/src/test/java/org/jboss/da/test/client/rest/products/RestApiProductsTestIT.java b/testsuite/src/test/java/org/jboss/da/test/client/rest/products/RestApiProductsTestIT.java deleted file mode 100644 index cb7c51057..000000000 --- a/testsuite/src/test/java/org/jboss/da/test/client/rest/products/RestApiProductsTestIT.java +++ /dev/null @@ -1,83 +0,0 @@ -package org.jboss.da.test.client.rest.products; - -import org.jboss.da.test.client.rest.listings.AbstractRestApiListingTest; -import org.jboss.da.test.client.rest.listings.RequestGenerator; -import org.json.JSONException; -import org.junit.Test; -import org.skyscreamer.jsonassert.JSONAssert; -import org.skyscreamer.jsonassert.JSONCompareMode; - -import java.io.File; -import java.io.IOException; - -import static org.apache.commons.io.FileUtils.readFileToString; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.fail; - -import javax.ws.rs.core.Response; - -/** - * - * @author Honza Brázdil <jbrazdil@redhat.com> - */ -public class RestApiProductsTestIT extends AbstractRestApiListingTest { - - protected static final String PATH_FILES_PRODUCTS = "/products"; - - protected static final String PATH_PRODUCTS_DIFF = "/products/diff"; - - private final RequestGenerator generator = new RequestGenerator(); - - @Test - public void testProductsDiff() throws Exception { - String artifact; - - // Add whitelists - manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd", true); - long p1 = getIdOfProduct("test", "1.0.0"); - manipulateEntityFile(ListEntityType.PRODUCT, OperationType.POST, "productAdd2", true); - long p2 = getIdOfProduct("test", "2.0.0"); - - // Add artifacts to whitelist - artifact = generator.returnWhiteArtifactString("com.example", "added", "1.0.0", p2); - manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); - - artifact = generator.returnWhiteArtifactString("com.example", "removed", "1.0.0", p1); - manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); - - artifact = generator.returnWhiteArtifactString("com.example", "changed", "1.0.0", p1); - manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); - artifact = generator.returnWhiteArtifactString("com.example", "changed", "1.2.0", p2); - manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); - - artifact = generator.returnWhiteArtifactString("com.example", "unchanged", "1.0.0", p1); - manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); - artifact = generator.returnWhiteArtifactString("com.example", "unchanged", "1.0.0", p2); - manipulateEntityString(ListEntityType.WHITE, OperationType.POST, artifact, true); - - // Get diff - Response response = createClientRequest(PATH_PRODUCTS_DIFF + "?leftProduct=" + p1 + "&rightProduct=" + p2) - .get(); - assertEquals(200, response.getStatus()); - - checkExpectedResponse(response, "diff"); - } - - private void checkExpectedResponse(Response response, String expectedFile) throws IOException { - File expectedResponseFile = getJsonResponseFile(PATH_FILES_PRODUCTS, expectedFile); - final String expected = readFileToString(expectedResponseFile); - final String actual = response.readEntity(String.class); - System.out.println("Expected: " + expected); - System.out.println("Actual: " + actual); - assertEqualsJson(expected, actual); - } - - @Override - protected void assertEqualsJson(String expected, String actual) { - try { - JSONAssert.assertEquals(expected, actual, JSONCompareMode.LENIENT); - } catch (JSONException ex) { - fail("The test wasn't able to compare JSON strings" + ex); - } - } -} diff --git a/testsuite/src/test/java/org/jboss/da/test/server/ArtifactBlackWhitelistTransitionsTestIT.java b/testsuite/src/test/java/org/jboss/da/test/server/ArtifactBlackWhitelistTransitionsTestIT.java deleted file mode 100644 index 0f7b861d5..000000000 --- a/testsuite/src/test/java/org/jboss/da/test/server/ArtifactBlackWhitelistTransitionsTestIT.java +++ /dev/null @@ -1,237 +0,0 @@ -package org.jboss.da.test.server; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; - -import java.util.List; -import java.util.Optional; - -import javax.inject.Inject; - -import org.jboss.arquillian.junit.Arquillian; -import org.jboss.da.communication.auth.impl.JAASAuthenticatorService; -import org.jboss.da.listings.api.dao.ProductVersionDAO; -import org.jboss.da.listings.api.model.BlackArtifact; -import org.jboss.da.listings.api.model.ProductVersion; -import org.jboss.da.listings.api.model.WhiteArtifact; -import org.jboss.da.listings.api.service.ArtifactService.ArtifactStatus; -import org.jboss.da.listings.api.service.BlackArtifactService; -import org.jboss.da.listings.api.service.ProductService; -import org.jboss.da.listings.api.service.WhiteArtifactService; -import org.jboss.da.listings.model.ProductSupportStatus; -import org.jboss.da.listings.model.rest.RestProductArtifact; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; - -/** - * - * @author fkujikis - */ -@RunWith(Arquillian.class) -public class ArtifactBlackWhitelistTransitionsTestIT extends AbstractServerTest { - - @Inject - private BlackArtifactService blackService; - - @Inject - private WhiteArtifactService whiteService; - - @Inject - private ProductVersionDAO productVersionDao; - - @Inject - private ProductService productService; - - private RestProductArtifact whiteArtifact1; - - private RestProductArtifact whiteArtifact2; - - private RestProductArtifact blackArtifact1; - - private RestProductArtifact whiteToBlackArtifact; - - private ProductVersion product1; - - private ProductVersion product2; - - @Before - public void setUp() { - JAASAuthenticatorService.setUser(null); - - whiteArtifact1 = new RestProductArtifact(); - whiteArtifact1.setArtifactId("white1"); - whiteArtifact1.setGroupId("org.test"); - whiteArtifact1.setVersion("1.0.0"); - - whiteArtifact2 = new RestProductArtifact(); - whiteArtifact2.setArtifactId("white2"); - whiteArtifact2.setGroupId("org.test"); - whiteArtifact2.setVersion("1.0.0"); - - blackArtifact1 = new RestProductArtifact(); - blackArtifact1.setArtifactId("black1"); - blackArtifact1.setGroupId("org.test"); - blackArtifact1.setVersion("1.0.0"); - - whiteToBlackArtifact = new RestProductArtifact(); - whiteToBlackArtifact.setArtifactId("whiteToBlack"); - whiteToBlackArtifact.setGroupId("org.test"); - whiteToBlackArtifact.setVersion("1.0.0"); - - // Add product1 and product2 - productService.addProduct("Product1", "1.0.0", ProductSupportStatus.UNKNOWN); - product1 = productVersionDao.findProductVersion("Product1", "1.0.0").get(); - productService.addProduct("Product2", "1.0.0", ProductSupportStatus.UNKNOWN); - product2 = productVersionDao.findProductVersion("Product2", "1.0.0").get(); - - JAASAuthenticatorService.setUser("user"); - - // Add whiteArtifact1 and whiteToBlackArtifact to Product1 - whiteService.addArtifact( - whiteArtifact1.getGroupId(), - whiteArtifact1.getArtifactId(), - whiteArtifact1.getVersion(), - product1.getId()); - whiteService.addArtifact( - whiteToBlackArtifact.getGroupId(), - whiteToBlackArtifact.getArtifactId(), - whiteToBlackArtifact.getVersion(), - product1.getId()); - - // Add whiteArtifact2 and whiteToBlackArtifact to Product2 - whiteService.addArtifact( - whiteArtifact2.getGroupId(), - whiteArtifact2.getArtifactId(), - whiteArtifact2.getVersion(), - product2.getId()); - whiteService.addArtifact( - whiteToBlackArtifact.getGroupId(), - whiteToBlackArtifact.getArtifactId(), - whiteToBlackArtifact.getVersion(), - product2.getId()); - - blackService - .addArtifact(blackArtifact1.getGroupId(), blackArtifact1.getArtifactId(), blackArtifact1.getVersion()); - - } - - @After - public void tearDown() { - // Remove all artifacts - whiteService.removeArtifact( - whiteArtifact1.getGroupId(), - whiteArtifact1.getArtifactId(), - whiteArtifact1.getVersion()); - whiteService.removeArtifact( - whiteArtifact2.getGroupId(), - whiteArtifact2.getArtifactId(), - whiteArtifact2.getVersion()); - whiteService.removeArtifact( - whiteToBlackArtifact.getGroupId(), - whiteToBlackArtifact.getArtifactId(), - whiteToBlackArtifact.getVersion()); - blackService.removeArtifact( - whiteToBlackArtifact.getGroupId(), - whiteToBlackArtifact.getArtifactId(), - whiteToBlackArtifact.getVersion()); - blackService.removeArtifact( - blackArtifact1.getGroupId(), - blackArtifact1.getArtifactId(), - blackArtifact1.getVersion()); - - // Remove all products - productService.removeProduct("Product1", "1.0.0"); - productService.removeProduct("Product2", "1.0.0"); - - JAASAuthenticatorService.setUser(null); - } - - private void refreshProducts() { - product1 = productVersionDao.read(product1.getId()); - product2 = productVersionDao.read(product2.getId()); - } - - @Test - public void testBlacklistWhitelistedArtifact() { - - // Check original artifacts for product are set - refreshProducts(); - assertEquals(2, product1.getWhiteArtifacts().size()); - assertEquals(2, product2.getWhiteArtifacts().size()); - - // Check artifact was previously white listed - ArtifactStatus as = blackService.addArtifact( - whiteToBlackArtifact.getGroupId(), - whiteToBlackArtifact.getArtifactId(), - whiteToBlackArtifact.getVersion()); - assertEquals(ArtifactStatus.WAS_WHITELISTED, as); - - // Check the artifact was blacklisted - Optional artifact = blackService.getArtifact( - whiteToBlackArtifact.getGroupId(), - whiteToBlackArtifact.getArtifactId(), - whiteToBlackArtifact.getVersion()); - assertTrue(artifact.isPresent()); - - // Check artifact is no longer in whitelist DB - List whiteArtifactsMatchingGav = whiteService.getArtifacts( - whiteToBlackArtifact.getGroupId(), - whiteToBlackArtifact.getArtifactId(), - whiteToBlackArtifact.getVersion()); - assertTrue(whiteArtifactsMatchingGav.isEmpty()); - - // Check artifact is still on product white lists - // Demonstrates issue NCL-1883: - // - correct behaviour is as above asserts in test plus - // - blacklisted artifact shouldn't be removed from ProductVersion whiteArtifact lists - refreshProducts(); - assertEquals(2, product1.getWhiteArtifacts().size()); - assertEquals(2, product2.getWhiteArtifacts().size()); - } - - @Test - public void testAddBlacklistedArtifactToProductWhitelist() { - - // Check original artifacts for product are set - refreshProducts(); - assertEquals(2, product1.getWhiteArtifacts().size()); - - // Add the blacklisted artifact to a product - ArtifactStatus as = whiteService.addArtifact( - blackArtifact1.getGroupId(), - blackArtifact1.getArtifactId(), - blackArtifact1.getVersion(), - product1.getId()); - assertEquals(as, ArtifactStatus.ADDED); - - // Check blackArtifact1 artifact has been added to product 1 - refreshProducts(); - assertEquals(3, product1.getWhiteArtifacts().size()); - - // Confirm blackArtifact1 still on blacklist - boolean artifactOnBlacklist = blackService.isArtifactPresent( - blackArtifact1.getGroupId(), - blackArtifact1.getArtifactId(), - blackArtifact1.getVersion()); - assertTrue(artifactOnBlacklist); - - // Confirm artifact not on whitelist - List whiteArtifacts = whiteService - .getArtifacts(blackArtifact1.getGroupId(), blackArtifact1.getArtifactId(), blackArtifact1.getVersion()); - assertTrue(whiteArtifacts.isEmpty()); - - // Check artifact can be removed as before - boolean artifactRemovedFromProduct = whiteService.removeArtifractFromProductVersion( - blackArtifact1.getGroupId(), - blackArtifact1.getArtifactId(), - blackArtifact1.getVersion(), - product1.getId()); - assertTrue(artifactRemovedFromProduct); - - // Check blackArtifact1 artifact has been removed from product 1 - refreshProducts(); - assertEquals(2, product1.getWhiteArtifacts().size()); - } -} diff --git a/testsuite/src/test/java/org/jboss/da/test/server/ReportsWithWhitelistedArtifactsRemoteTestIT.java b/testsuite/src/test/java/org/jboss/da/test/server/ReportsWithWhitelistedArtifactsRemoteTestIT.java deleted file mode 100644 index 59acbae22..000000000 --- a/testsuite/src/test/java/org/jboss/da/test/server/ReportsWithWhitelistedArtifactsRemoteTestIT.java +++ /dev/null @@ -1,552 +0,0 @@ -package org.jboss.da.test.server; - -import static org.junit.Assert.*; - -import org.apache.maven.scm.ScmException; -import org.jboss.arquillian.junit.Arquillian; -import org.jboss.da.common.CommunicationException; -import org.jboss.da.communication.auth.impl.JAASAuthenticatorService; -import org.jboss.da.communication.indy.FindGAVDependencyException; -import org.jboss.da.communication.pom.PomAnalysisException; -import org.jboss.da.listings.api.dao.ProductVersionDAO; -import org.jboss.da.listings.api.model.ProductVersion; -import org.jboss.da.listings.api.service.ProductService; -import org.jboss.da.listings.api.service.WhiteArtifactService; -import org.jboss.da.listings.model.ProductSupportStatus; -import org.jboss.da.listings.model.rest.RestProductArtifact; -import org.jboss.da.model.rest.GAV; -import org.jboss.da.reports.api.ArtifactReport; -import org.jboss.da.reports.api.ReportsGenerator; -import org.jboss.da.reports.model.api.SCMLocator; -import org.jboss.da.reports.model.request.GAVRequest; -import org.jboss.da.reports.model.request.LookupGAVsRequest; -import org.jboss.da.reports.model.request.SCMReportRequest; -import org.jboss.da.reports.model.response.LookupReport; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; - -import javax.inject.Inject; - -import java.util.ArrayList; -import java.util.HashSet; -import java.util.List; -import java.util.Optional; -import java.util.Set; - -/** - * - * @author fkujikis - */ -@RunWith(Arquillian.class) -public class ReportsWithWhitelistedArtifactsRemoteTestIT extends AbstractServerTest { - - @Inject - private ReportsGenerator reportGenerator; - - @Inject - private WhiteArtifactService whiteService; - - @Inject - private ProductVersionDAO productVersionDao; - - @Inject - private ProductService productService; - - private ProductVersion prodVer1_1; - - private RestProductArtifact whiteArtifact1_1_1; - - private RestProductArtifact whiteArtifact1_1_2; - - private ProductVersion prodVer1_2; - - private RestProductArtifact whiteArtifact1_2_1; - - private RestProductArtifact whiteArtifact1_2_2; - - private ProductVersion prodVer2_1; - - private RestProductArtifact whiteArtifact2_1_a; - - private RestProductArtifact whiteArtifact2_1_b; - - private RestProductArtifact whiteArtifact2_1_c; - - private GAV hibernateGav; - - private GAV daGav; - - private GAV jacksonGav; - - @Before - public void workaroundNoHttpResponseException() throws InterruptedException { - Thread.sleep(2000); - } - - @Before - public void setUp() { - JAASAuthenticatorService.setUser("user"); - - whiteArtifact1_1_1 = new RestProductArtifact(); - whiteArtifact1_1_1.setGroupId("org.jboss.da"); - whiteArtifact1_1_1.setArtifactId("common"); - whiteArtifact1_1_1.setVersion("0.1.0-redhat-1"); - - whiteArtifact1_1_2 = new RestProductArtifact(); - whiteArtifact1_1_2.setGroupId("org.hibernate"); - whiteArtifact1_1_2.setArtifactId("hibernate-core"); - whiteArtifact1_1_2.setVersion("4.2.28.Final-redhat-1"); - - whiteArtifact1_2_1 = new RestProductArtifact(); - whiteArtifact1_2_1.setGroupId("org.jboss.da"); - whiteArtifact1_2_1.setArtifactId("common"); - whiteArtifact1_2_1.setVersion("0.1.1-redhat-1"); - - whiteArtifact1_2_2 = new RestProductArtifact(); - whiteArtifact1_2_2.setGroupId("org.hibernate"); - whiteArtifact1_2_2.setArtifactId("hibernate-core"); - whiteArtifact1_2_2.setVersion("4.2.29.Final-redhat-1"); - - productService.addProduct("Product1", "1.0.0", ProductSupportStatus.UNKNOWN); - prodVer1_1 = productVersionDao.findProductVersion("Product1", "1.0.0").get(); - productService.addProduct("Product1", "2.0.0", ProductSupportStatus.UNKNOWN); - prodVer1_2 = productVersionDao.findProductVersion("Product1", "2.0.0").get(); - - whiteService.addArtifact( - whiteArtifact1_1_1.getGroupId(), - whiteArtifact1_1_1.getArtifactId(), - whiteArtifact1_1_1.getVersion(), - prodVer1_1.getId()); - whiteService.addArtifact( - whiteArtifact1_1_2.getGroupId(), - whiteArtifact1_1_2.getArtifactId(), - whiteArtifact1_1_2.getVersion(), - prodVer1_1.getId()); - - whiteService.addArtifact( - whiteArtifact1_2_1.getGroupId(), - whiteArtifact1_2_1.getArtifactId(), - whiteArtifact1_2_1.getVersion(), - prodVer1_2.getId()); - whiteService.addArtifact( - whiteArtifact1_2_2.getGroupId(), - whiteArtifact1_2_2.getArtifactId(), - whiteArtifact1_2_2.getVersion(), - prodVer1_2.getId()); - - whiteArtifact2_1_a = new RestProductArtifact(); - whiteArtifact2_1_a.setGroupId("org.jboss.da"); - whiteArtifact2_1_a.setArtifactId("common"); - whiteArtifact2_1_a.setVersion("0.2.0-redhat-1"); - - whiteArtifact2_1_b = new RestProductArtifact(); - whiteArtifact2_1_b.setGroupId("com.fasterxml.jackson.core"); - whiteArtifact2_1_b.setArtifactId("jackson-databind"); - whiteArtifact2_1_b.setVersion("2.4.4-redhat-1"); - - whiteArtifact2_1_c = new RestProductArtifact(); - whiteArtifact2_1_c.setGroupId("org.hibernate"); - whiteArtifact2_1_c.setArtifactId("hibernate-core"); - whiteArtifact2_1_c.setVersion("4.2.30.Final-redhat-1"); - - productService.addProduct("Product2", "1.0.0", ProductSupportStatus.UNKNOWN); - prodVer2_1 = productVersionDao.findProductVersion("Product2", "1.0.0").get(); - - whiteService.addArtifact( - whiteArtifact2_1_a.getGroupId(), - whiteArtifact2_1_a.getArtifactId(), - whiteArtifact2_1_a.getVersion(), - prodVer2_1.getId()); - whiteService.addArtifact( - whiteArtifact2_1_b.getGroupId(), - whiteArtifact2_1_b.getArtifactId(), - whiteArtifact2_1_b.getVersion(), - prodVer2_1.getId()); - whiteService.addArtifact( - whiteArtifact2_1_c.getGroupId(), - whiteArtifact2_1_c.getArtifactId(), - whiteArtifact2_1_c.getVersion(), - prodVer2_1.getId()); - - hibernateGav = artifactToGAV(whiteArtifact1_1_2); - daGav = artifactToGAV(whiteArtifact1_1_1); - jacksonGav = artifactToGAV(whiteArtifact2_1_b); - } - - @After - public void tearDown() { - - // Remove artifacts - whiteService.removeArtifact( - whiteArtifact1_1_1.getGroupId(), - whiteArtifact1_1_1.getArtifactId(), - whiteArtifact1_1_1.getVersion()); - whiteService.removeArtifact( - whiteArtifact1_1_2.getGroupId(), - whiteArtifact1_1_2.getArtifactId(), - whiteArtifact1_1_2.getVersion()); - whiteService.removeArtifact( - whiteArtifact1_2_1.getGroupId(), - whiteArtifact1_2_1.getArtifactId(), - whiteArtifact1_2_1.getVersion()); - whiteService.removeArtifact( - whiteArtifact1_2_2.getGroupId(), - whiteArtifact1_2_2.getArtifactId(), - whiteArtifact1_2_2.getVersion()); - - whiteService.removeArtifact( - whiteArtifact2_1_a.getGroupId(), - whiteArtifact2_1_a.getArtifactId(), - whiteArtifact2_1_a.getVersion()); - whiteService.removeArtifact( - whiteArtifact2_1_b.getGroupId(), - whiteArtifact2_1_b.getArtifactId(), - whiteArtifact2_1_b.getVersion()); - whiteService.removeArtifact( - whiteArtifact2_1_c.getGroupId(), - whiteArtifact2_1_c.getArtifactId(), - whiteArtifact2_1_c.getVersion()); - - // Remove products - productService.removeProduct("Product1", "1.0.0"); - productService.removeProduct("Product1", "2.0.0"); - productService.removeProduct("Product2", "1.0.0"); - - JAASAuthenticatorService.setUser(null); - } - - // This allows to test: - // - whitelist lookup by product - // - whitelist lookup by product version - // - whitelist lookup without either (get all - 3 additions to top level) - // - whitelist addition to top level - // - whitelist addition to top-1 level - - private SCMReportRequest getDefaultSCMRequest() { - SCMLocator locator = SCMLocator - .generic("https://github.com/project-ncl/dependency-analysis.git", "05a878", "common"); - - SCMReportRequest request = new SCMReportRequest(); - request.setScml(locator); - - return request; - } - - @Test - public void testScmAllWhiteArtifactsPresent() throws ScmException, PomAnalysisException, CommunicationException { - - SCMReportRequest request = getDefaultSCMRequest(); - - Optional ar = reportGenerator.getReportFromSCM(request); - - // Ensure we got an artifact report back - assertTrue(ar.isPresent()); - ArtifactReport artifactReport = ar.get(); - - // Ensure all dependencies from whitelist are present - assertTrue(artifactReport.getAvailableVersions().contains(whiteArtifact1_1_1.getVersion())); - assertTrue(artifactReport.getAvailableVersions().contains(whiteArtifact1_2_1.getVersion())); - assertTrue(artifactReport.getAvailableVersions().contains(whiteArtifact2_1_a.getVersion())); - - // These have different GA so shouldn't be there - assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact1_1_2.getVersion())); - assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact1_2_2.getVersion())); - assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact2_1_b.getVersion())); - assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact2_1_c.getVersion())); - - // Find jackson artifactReport and check it contains the jackson version - Optional dependencyJacksonDatabind = artifactReport.getDependencies() - .stream() - .filter( - x -> x.getArtifactId().equals(whiteArtifact2_1_b.getArtifactId()) - && x.getGroupId().equals(whiteArtifact2_1_b.getGroupId())) - .findFirst(); - - assertTrue(dependencyJacksonDatabind.isPresent()); - assertTrue(dependencyJacksonDatabind.get().getAvailableVersions().contains(whiteArtifact2_1_b.getVersion())); - } - - @Test - public void testScmWhiteArtifactsPresentForDependenciesWithSingleProduct() - throws ScmException, PomAnalysisException, CommunicationException { - - SCMReportRequest request = getDefaultSCMRequest(); - - // Only use artifacts from the single product Product2 : version "1.0.0" - request.getProductNames().add(prodVer2_1.getProduct().getName()); - - Optional ar = reportGenerator.getReportFromSCM(request); - - assertTrue(ar.isPresent()); - ArtifactReport artifactReport = ar.get(); - - // Artifacts from Product2 version "1.0.0" expected - assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact1_1_1.getVersion())); - assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact1_2_1.getVersion())); - assertTrue(artifactReport.getAvailableVersions().contains(whiteArtifact2_1_a.getVersion())); - assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact2_1_b.getVersion())); - - // Find jackson artifactReport and check it contains the jackson version - Optional dependencyJacksonDatabind = artifactReport.getDependencies() - .stream() - .filter( - x -> x.getArtifactId().equals(whiteArtifact2_1_b.getArtifactId()) - && x.getGroupId().equals(whiteArtifact2_1_b.getGroupId())) - .findFirst(); - - assertTrue(dependencyJacksonDatabind.isPresent()); - assertTrue(dependencyJacksonDatabind.get().getAvailableVersions().contains(whiteArtifact2_1_b.getVersion())); - - } - - @Test - public void testScmWhiteArtifactsPresentForSingleProduct() - throws ScmException, PomAnalysisException, CommunicationException { - - SCMReportRequest request = getDefaultSCMRequest(); - // Only use artifacts from the single product Product1 : versions "1.0.0" and "2.0.0" should be included - request.getProductNames().add(prodVer1_1.getProduct().getName()); - - Optional ar = reportGenerator.getReportFromSCM(request); - - assertTrue(ar.isPresent()); - ArtifactReport artifactReport = ar.get(); - - // Artifacts from Product1 (product versions "1.0.0", "2.0.0" expected) - assertTrue(artifactReport.getAvailableVersions().contains(whiteArtifact1_1_1.getVersion())); - assertTrue(artifactReport.getAvailableVersions().contains(whiteArtifact1_2_1.getVersion())); - assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact2_1_a.getVersion())); - assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact2_1_b.getVersion())); - } - - @Test - public void testScmWhiteArtifactsPresentForSingleProductVersion() - throws ScmException, PomAnalysisException, CommunicationException { - - SCMReportRequest request = getDefaultSCMRequest(); - // Only use artifacts from the single product version : "Product1", "1.0.0" - request.getProductVersionIds().add(prodVer1_1.getId()); - - Optional ar = reportGenerator.getReportFromSCM(request); - - assertTrue(ar.isPresent()); - ArtifactReport artifactReport = ar.get(); - - // Artifacts from the single product version : "Product1", "1.0.0" : expect 1 only - assertTrue(artifactReport.getAvailableVersions().contains(whiteArtifact1_1_1.getVersion())); - assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact1_2_1.getVersion())); - assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact2_1_a.getVersion())); - assertFalse(artifactReport.getAvailableVersions().contains(whiteArtifact2_1_b.getVersion())); - } - - private GAVRequest getDefaultGAVRequest() { - Set productNames = new HashSet<>(); - Set productVersionIds = new HashSet<>(); - GAVRequest gavRequest = new GAVRequest( - "org.hibernate", - "hibernate-core", - "4.2.21.Final", - productNames, - productVersionIds); - return gavRequest; - } - - private GAV artifactToGAV(RestProductArtifact art) { - return new GAV(art.getGroupId(), art.getArtifactId(), art.getVersion()); - } - - private LookupGAVsRequest getDefaultLookupRequest() { - List gavs = new ArrayList<>(); - gavs.add(hibernateGav); - gavs.add(daGav); - gavs.add(jacksonGav); - - LookupGAVsRequest req = new LookupGAVsRequest(gavs); - - return req; - } - - @Test - public void testGavsLookupAllWhiteArtifactsPresent() throws CommunicationException, FindGAVDependencyException { - - LookupGAVsRequest req = getDefaultLookupRequest(); - - // Query all white artifacts from all products - - List lookupReports = reportGenerator.getLookupReportsForGavs(req); - - assertTrue(lookupReports != null); - assertEquals(3, lookupReports.size()); - - // Expecting to see all whitelist versions included - for (LookupReport lr : lookupReports) { - if (hibernateGav.equals(lr.getGav())) { - assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_1_2.getVersion())); - assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_2_2.getVersion())); - assertTrue(lr.getAvailableVersions().contains(whiteArtifact2_1_c.getVersion())); - assertTrue(lr.getBestMatchVersion().equals(hibernateGav.getVersion())); - } else if (daGav.equals(lr.getGav())) { - assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_1_1.getVersion())); - assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_2_1.getVersion())); - assertTrue(lr.getAvailableVersions().contains(whiteArtifact2_1_a.getVersion())); - assertTrue(lr.getBestMatchVersion().equals(daGav.getVersion())); - } else if (jacksonGav.equals(lr.getGav())) { - assertTrue(lr.getAvailableVersions().contains(whiteArtifact2_1_b.getVersion())); - assertTrue(lr.getBestMatchVersion().equals(jacksonGav.getVersion())); - } - } - } - - @Test - public void testGavsLookupAllWhiteArtifactsPresentForSingleProduct() - throws CommunicationException, FindGAVDependencyException { - - LookupGAVsRequest req = getDefaultLookupRequest(); - - // Query all white artifacts from Product 1 - req.getProductNames().add(prodVer1_1.getProduct().getName()); - - List lookupReports = reportGenerator.getLookupReportsForGavs(req); - - assertTrue(lookupReports != null); - assertEquals(3, lookupReports.size()); - - // Expecting to see whitelist versions included for Product 1 - for (LookupReport lr : lookupReports) { - if (hibernateGav.equals(lr.getGav())) { - assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_1_2.getVersion())); - assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_2_2.getVersion())); - assertFalse(lr.getAvailableVersions().contains(whiteArtifact2_1_c.getVersion())); - assertTrue(lr.getBestMatchVersion().equals(hibernateGav.getVersion())); - } else if (daGav.equals(lr.getGav())) { - assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_1_1.getVersion())); - assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_2_1.getVersion())); - assertFalse(lr.getAvailableVersions().contains(whiteArtifact2_1_a.getVersion())); - assertTrue(lr.getBestMatchVersion().equals(daGav.getVersion())); - } else if (jacksonGav.equals(lr.getGav())) { - assertFalse(lr.getAvailableVersions().contains(whiteArtifact2_1_b.getVersion())); - assertTrue(lr.getBestMatchVersion() == null); - } - } - } - - @Test - public void testGavsLookupAllWhiteArtifactsPresentForSingleProductVersion() - throws CommunicationException, FindGAVDependencyException { - - LookupGAVsRequest req = getDefaultLookupRequest(); - - // Query all white artifacts from Product 1 version 2 - req.getProductVersionIds().add(prodVer1_2.getId()); - - List lookupReports = reportGenerator.getLookupReportsForGavs(req); - - assertTrue(lookupReports != null); - assertEquals(3, lookupReports.size()); - - // Expecting to see whitelist versions included for Product 1 version 2 - for (LookupReport lr : lookupReports) { - if (hibernateGav.equals(lr.getGav())) { - assertFalse(lr.getAvailableVersions().contains(whiteArtifact1_1_2.getVersion())); - assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_2_2.getVersion())); - assertFalse(lr.getAvailableVersions().contains(whiteArtifact2_1_c.getVersion())); - } else if (daGav.equals(lr.getGav())) { - assertFalse(lr.getAvailableVersions().contains(whiteArtifact1_1_1.getVersion())); - assertTrue(lr.getAvailableVersions().contains(whiteArtifact1_2_1.getVersion())); - assertFalse(lr.getAvailableVersions().contains(whiteArtifact2_1_a.getVersion())); - } else if (jacksonGav.equals(lr.getGav())) { - assertFalse(lr.getAvailableVersions().contains(whiteArtifact2_1_b.getVersion())); - assertTrue(lr.getBestMatchVersion() == null); - } - } - } - - @Test - public void testGavsLookupAllWhiteArtifactsErroneousInput() - throws CommunicationException, FindGAVDependencyException { - - LookupGAVsRequest productsNamesReq = getDefaultLookupRequest(); - - // Test with product that doesn't exist - // Inputs : productNames [Product3] - productsNamesReq.getProductNames().add("Product3"); - try { - reportGenerator.getLookupReportsForGavs(productsNamesReq); - fail(); - } catch (IllegalArgumentException e) { - assertTrue(e.getMessage().contains("Product3")); - } - - // Test combination of existing / in-existing products - // Inputs : productNames [Product1, Product3] - productsNamesReq.getProductNames().add("Product1"); - try { - reportGenerator.getLookupReportsForGavs(productsNamesReq); - fail(); - } catch (IllegalArgumentException e) { - assertTrue(e.getMessage().contains("Product3")); - } - - LookupGAVsRequest productVersionsReq = getDefaultLookupRequest(); - - // Test with product version ID that doesn't exist - // Inputs : productVersionIds [5555] - productVersionsReq.getProductVersionIds().add(5555L); - try { - reportGenerator.getLookupReportsForGavs(productVersionsReq); - fail(); - } catch (IllegalArgumentException e) { - assertTrue(e.getMessage().contains("5555")); - } - - // Test combination of existing / in-existing product version IDs - // Inputs : productVersionIds [5555, prodVer1_2.getId()] - productVersionsReq.getProductVersionIds().add(prodVer1_2.getId()); - try { - reportGenerator.getLookupReportsForGavs(productVersionsReq); - fail(); - } catch (IllegalArgumentException e) { - assertTrue(e.getMessage().contains("5555")); - } - - // Test valid product name request with invalid product version id - LookupGAVsRequest validNameRequest = getDefaultLookupRequest(); - validNameRequest.getProductNames().add("Product1"); - validNameRequest.getProductVersionIds().add(5555L); - try { - reportGenerator.getLookupReportsForGavs(validNameRequest); - fail(); - } catch (IllegalArgumentException e) { - assertTrue(e.getMessage().contains("5555")); - } - - // Test valid product version id request with invalid product name - LookupGAVsRequest validProdVerRequest = getDefaultLookupRequest(); - validProdVerRequest.getProductNames().add("NoSuchProduct"); - validProdVerRequest.getProductVersionIds().add(prodVer1_2.getId()); - try { - reportGenerator.getLookupReportsForGavs(validProdVerRequest); - fail(); - } catch (IllegalArgumentException e) { - assertTrue(e.getMessage().contains("NoSuchProduct")); - } - - // Test combination of valid/invalid inputs for both name/ids - LookupGAVsRequest combinedValidAndInvalidRequest = getDefaultLookupRequest(); - combinedValidAndInvalidRequest.getProductNames().add("NoSuchProduct"); - combinedValidAndInvalidRequest.getProductNames().add("Product1"); - combinedValidAndInvalidRequest.getProductVersionIds().add(5555L); - combinedValidAndInvalidRequest.getProductVersionIds().add(prodVer1_2.getId()); - try { - reportGenerator.getLookupReportsForGavs(combinedValidAndInvalidRequest); - fail(); - } catch (IllegalArgumentException e) { - e.printStackTrace(); - assertTrue(e.getMessage().contains("NoSuchProduct")); - assertTrue(e.getMessage().contains("5555")); - } - } - -} diff --git a/testsuite/src/test/java/org/jboss/da/test/server/listings/WhiteArtifactServiceTestIT.java b/testsuite/src/test/java/org/jboss/da/test/server/listings/WhiteArtifactServiceTestIT.java deleted file mode 100644 index 56ab3b80d..000000000 --- a/testsuite/src/test/java/org/jboss/da/test/server/listings/WhiteArtifactServiceTestIT.java +++ /dev/null @@ -1,47 +0,0 @@ -package org.jboss.da.test.server.listings; - -import org.jboss.arquillian.junit.Arquillian; -import org.jboss.da.communication.auth.impl.JAASAuthenticatorService; -import org.jboss.da.listings.api.model.ProductVersion; -import org.jboss.da.listings.api.service.ArtifactService.ArtifactStatus; -import org.jboss.da.listings.api.service.ProductService; -import org.jboss.da.listings.api.service.ProductVersionService; -import org.jboss.da.listings.api.service.WhiteArtifactService; -import org.jboss.da.listings.model.ProductSupportStatus; -import org.jboss.da.test.server.AbstractServerTest; -import static org.junit.Assert.assertEquals; -import org.junit.Test; -import org.junit.runner.RunWith; - -import javax.inject.Inject; - -/** - * - * @author Honza Brázdil - */ -@RunWith(Arquillian.class) -public class WhiteArtifactServiceTestIT extends AbstractServerTest { - - @Inject - ProductVersionService pvs; - - @Inject - ProductService ps; - - @Inject - WhiteArtifactService was; - - @Test - public void testAddDuplicateGA() { - JAASAuthenticatorService.setUser("user"); - ps.addProduct("EAP", "9.4.6", ProductSupportStatus.UNKNOWN); - ProductVersion pv = pvs.getProductVersion("EAP", "9.4.6").get(); - ArtifactStatus ret1 = was.addArtifact("foo", "bar", "1.0.0", pv.getId()); - assertEquals(ArtifactStatus.ADDED, ret1); - ArtifactStatus ret2 = was.addArtifact("foo", "bar", "1.0.0", pv.getId()); - assertEquals(ArtifactStatus.NOT_MODIFIED, ret2); - ArtifactStatus ret3 = was.addArtifact("foo", "bar", "2.0.0", pv.getId()); - assertEquals(ArtifactStatus.ADDED, ret3); - } - -} From d2c7204510e2c81bb3464ab5a80ebd49ccc24ac6 Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Wed, 18 Feb 2026 14:02:25 +0000 Subject: [PATCH 22/26] Reapply "[NCLSUP-1016] Optimize blocklist querying" This reverts commit 6f2079370882f0882124a461726856579a782fc0. --- .../da/listings/api/dao/ArtifactDAO.java | 4 ++ .../org/jboss/da/listings/api/dao/GADAO.java | 10 +++++ .../jboss/da/listings/api/model/Artifact.java | 5 +++ .../api/service/BlackArtifactService.java | 13 +++++-- .../da/listings/impl/dao/ArtifactDAOImpl.java | 11 ++++++ .../jboss/da/listings/impl/dao/GADAOImpl.java | 39 +++++++++++++++++++ .../service/BlackArtifactServiceImpl.java | 27 ++++++++++++- .../da/reports/impl/LookupGeneratorImpl.java | 11 +++--- 8 files changed, 109 insertions(+), 11 deletions(-) diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ArtifactDAO.java b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ArtifactDAO.java index 8322ba09f..f5334d186 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ArtifactDAO.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ArtifactDAO.java @@ -2,8 +2,10 @@ import java.util.List; import java.util.Optional; +import java.util.Set; import org.jboss.da.listings.api.model.Artifact; +import org.jboss.da.listings.api.model.GA; /** * @@ -22,6 +24,8 @@ public interface ArtifactDAO extends GenericDAO { */ Optional findArtifact(String groupId, String artifactId, String version); + List findArtifact(Set gas); + /** * Finds and return all artifacts. * diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/GADAO.java b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/GADAO.java index 6574e9a39..06301530b 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/GADAO.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/GADAO.java @@ -4,6 +4,7 @@ import java.util.List; import java.util.Optional; +import java.util.Set; public interface GADAO extends GenericDAO { @@ -25,6 +26,15 @@ public interface GADAO extends GenericDAO { */ Optional findGA(String groupId, String artifactId); + /** + * Finds GA with specific groupId and artifactId + * + * @param groupId + * @param artifactId + * @return Optional of GA + */ + Set findGAs(Set gas); + /** * Finds all GA * diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/model/Artifact.java b/reports-backend/src/main/java/org/jboss/da/listings/api/model/Artifact.java index e2107307b..a4dd9730e 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/model/Artifact.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/model/Artifact.java @@ -11,6 +11,7 @@ import lombok.RequiredArgsConstructor; import lombok.Setter; import lombok.ToString; +import org.jboss.da.model.rest.GAV; /** * @author Jozef Mrazek <jmrazek@redhat.com> @@ -42,4 +43,8 @@ public class Artifact extends GenericEntity { public String gav() { return ga.getGroupId() + ":" + ga.getArtifactId() + ":" + version; } + + public GAV toGAV() { + return new GAV(ga.getGroupId(), ga.getArtifactId(), version); + } } diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/service/BlackArtifactService.java b/reports-backend/src/main/java/org/jboss/da/listings/api/service/BlackArtifactService.java index fce24b35a..d4c221eb7 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/service/BlackArtifactService.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/service/BlackArtifactService.java @@ -3,12 +3,13 @@ import java.util.Optional; import org.jboss.da.listings.api.model.BlackArtifact; +import org.jboss.da.model.rest.GA; import org.jboss.da.model.rest.GAV; import java.util.Set; /** - * + * * @author Jozef Mrazek <jmrazek@redhat.com> * */ @@ -28,7 +29,7 @@ public interface BlackArtifactService extends ArtifactService { /** * Checks if list contains artifact with specific GAV. All restrictions and conversions are applied like using * getArtifact method of specific list. - * + * * @param gav * @return True if list contains the artifact otherwise false. */ @@ -44,7 +45,7 @@ public interface BlackArtifactService extends ArtifactService { /** * Checks if blacklist contains artifact with specific groupId, artifactId and version. If the version have redhat * suffix it is removed. Then the version is converted to OSGi version and finds this version in blacklist; - * + * * @return found artifact */ public Optional getArtifact(String groupId, String artifactId, String version); @@ -59,7 +60,7 @@ public interface BlackArtifactService extends ArtifactService { /** * Remove artifact from list. Removes only exact match of artifact. - * + * * @param groupId * @param artifactId * @param version @@ -68,4 +69,8 @@ public interface BlackArtifactService extends ArtifactService { public boolean removeArtifact(String groupId, String artifactId, String version); public Set getArtifacts(String groupId, String artifactId); + + Set prefetchGAs(Set gas); + + boolean isBlocklisted(Set cache, GA ga, String version); } diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ArtifactDAOImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ArtifactDAOImpl.java index 170bcf5fc..8a8f25830 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ArtifactDAOImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ArtifactDAOImpl.java @@ -2,6 +2,7 @@ import java.util.List; import java.util.Optional; +import java.util.Set; import javax.persistence.NoResultException; import javax.persistence.TypedQuery; @@ -45,6 +46,16 @@ public Optional findArtifact(String groupId, String artifactId, String versio } } + @Override + public List findArtifact(Set gas) { + CriteriaBuilder cb = em.getCriteriaBuilder(); + CriteriaQuery cq = cb.createQuery(type); + Root artifact = cq.from(type); + cq.select(artifact).where(cb.in(artifact.get("ga").in(gas))); + TypedQuery q = em.createQuery(cq); + return q.getResultList(); + } + @Override public List findAll() { CriteriaBuilder cb = em.getCriteriaBuilder(); diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/GADAOImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/GADAOImpl.java index 127de1229..2cdf15c12 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/GADAOImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/GADAOImpl.java @@ -8,14 +8,20 @@ import javax.persistence.TypedQuery; import javax.persistence.criteria.CriteriaBuilder; import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Predicate; import javax.persistence.criteria.Root; +import java.util.ArrayList; +import java.util.HashSet; import java.util.List; import java.util.Optional; +import java.util.Set; @Stateless public class GADAOImpl extends GenericDAOImpl implements GADAO { + public static final int BATCH_SIZE = 100; + public GADAOImpl() { super(GA.class); } @@ -35,6 +41,39 @@ public Optional findGA(String groupId, String artifactId) { } } + @Override + public Set findGAs(Set gas) { + ArrayList listOfGAs = new ArrayList<>(gas); + Set ret = new HashSet<>(); + for (int i = 0; i <= gas.size(); i += BATCH_SIZE) { + int to = i + BATCH_SIZE; + if (to > gas.size()) { + to = gas.size(); + } + ret.addAll(findGAs(listOfGAs.subList(i, to))); + } + return ret; + } + + private List findGAs(List gas) { + CriteriaBuilder cb = em.getCriteriaBuilder(); + CriteriaQuery cq = cb.createQuery(type); + Root gaTable = cq.from(type); + + ArrayList ands = new ArrayList<>(); + for (org.jboss.da.model.rest.GA ga : gas) { + Predicate and = cb.and( + cb.equal(gaTable.get("groupId"), ga.getGroupId()), + cb.equal(gaTable.get("artifactId"), ga.getArtifactId())); + ands.add(and); + } + cq.select(gaTable).where(cb.or(ands.toArray(Predicate[]::new))); + + TypedQuery q = em.createQuery(cq); + + return q.getResultList(); + } + @Override public List findAll() { CriteriaBuilder cb = em.getCriteriaBuilder(); diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java index 8c3075cdb..5a04160e5 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/service/BlackArtifactServiceImpl.java @@ -8,20 +8,23 @@ import org.jboss.da.listings.api.dao.ArtifactDAO; import org.jboss.da.listings.api.dao.BlackArtifactDAO; import org.jboss.da.listings.api.dao.GADAO; +import org.jboss.da.listings.api.model.Artifact; import org.jboss.da.listings.api.model.BlackArtifact; import org.jboss.da.listings.api.model.GA; import org.jboss.da.listings.api.service.BlackArtifactService; import org.jboss.da.model.rest.GAV; import java.util.Comparator; +import java.util.Set; import java.util.SortedSet; import java.util.TreeSet; +import java.util.stream.Collectors; import org.jboss.pnc.common.version.SuffixedVersion; import org.jboss.pnc.common.version.VersionParser; /** - * + * * @author Jozef Mrazek <jmrazek@redhat.com> * */ @@ -39,6 +42,28 @@ protected ArtifactDAO getDAO() { return blackArtifactDAO; } + @Override + public Set prefetchGAs(Set gaToPrefetch) { + if (gaToPrefetch.isEmpty()) { + return Set.of(); + } + Set blocklistedGAs = gaDAO.findGAs(gaToPrefetch); + if (blocklistedGAs.isEmpty()) { + return Set.of(); + } + return blackArtifactDAO.findArtifact(blocklistedGAs).stream().map(Artifact::toGAV).collect(Collectors.toSet()); + } + + @Override + public boolean isBlocklisted(Set cache, org.jboss.da.model.rest.GA ga, String version) { + SuffixedVersion parsedVersion = versionParser.parse(version); + + GAV unsuffixedGAV = new GAV(ga, parsedVersion.unsuffixedVersion()); + GAV osgiGAV = new GAV(ga, VersionParser.getOSGiVersion(version)); + + return cache.contains(unsuffixedGAV) || cache.contains(osgiGAV); + } + @Override public org.jboss.da.listings.api.service.ArtifactService.ArtifactStatus addArtifact( String groupId, diff --git a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java index 09cc895af..02a828db5 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java @@ -142,11 +142,12 @@ private Map>> getArtifactVersions( boolean filterBlacklisted) { Map>> ret = new HashMap<>(); Set distinctGAs = gavs.stream().map(GAV::getGA).collect(Collectors.toSet()); + Set cache = blackArtifactService.prefetchGAs(distinctGAs); for (GA ga : distinctGAs) { MavenArtifact mavenArtifact = new MavenArtifact(new GAV(ga, "0.0.0")); CompletableFuture> versions = productProvider.getAllVersions(mavenArtifact); if (filterBlacklisted) { - versions = filterBlacklistedArtifacts(versions, ga); + versions = filterBlacklistedArtifacts(versions, cache, ga); } ret.put(ga, versions); } @@ -161,11 +162,9 @@ private Map>> getArtifactVersions(Set> filterBlacklistedArtifacts(CompletableFuture> versions, GA ga) { - Predicate isNotBlacklisted = version -> { - GAV gav = new GAV(ga, version); - return !blackArtifactService.isArtifactPresent(gav); - }; + private CompletableFuture> filterBlacklistedArtifacts(CompletableFuture> versions, Set cache, GA ga) { + Predicate isNotBlacklisted = version -> !blackArtifactService + .isBlocklisted(cache, ga, version); return versions.thenApply(v -> v.stream().filter(isNotBlacklisted).collect(Collectors.toSet())); } From e6c7bf2ba81456559ea8cd163d4f8ded6773ac03 Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Wed, 18 Feb 2026 14:29:42 +0000 Subject: [PATCH 23/26] Reapply "Update Javadoc" This reverts commit 7dc94134fb3a6eebeb1aeaf3bdbc7c579c331472. --- .../jboss/da/listings/api/dao/ArtifactDAO.java | 6 ++++++ .../org/jboss/da/listings/api/dao/GADAO.java | 7 +++---- .../api/service/BlackArtifactService.java | 16 ++++++++++++++++ 3 files changed, 25 insertions(+), 4 deletions(-) diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ArtifactDAO.java b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ArtifactDAO.java index f5334d186..27262f125 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ArtifactDAO.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/ArtifactDAO.java @@ -24,6 +24,12 @@ public interface ArtifactDAO extends GenericDAO { */ Optional findArtifact(String groupId, String artifactId, String version); + /** + * Find all artifacts that have group id and artifact id matching one from the provided set. + * + * @param gas Set of Group ids and artifact ids of desired artifacts. + * @return List of found artifacts. + */ List findArtifact(Set gas); /** diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/GADAO.java b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/GADAO.java index 06301530b..4184ef9d5 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/dao/GADAO.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/dao/GADAO.java @@ -27,11 +27,10 @@ public interface GADAO extends GenericDAO { Optional findGA(String groupId, String artifactId); /** - * Finds GA with specific groupId and artifactId + * Finds GA with specific groupId and artifactId from the provided set. * - * @param groupId - * @param artifactId - * @return Optional of GA + * @param gas Set of group ids and artifact ids to search. + * @return List of found GAss. */ Set findGAs(Set gas); diff --git a/reports-backend/src/main/java/org/jboss/da/listings/api/service/BlackArtifactService.java b/reports-backend/src/main/java/org/jboss/da/listings/api/service/BlackArtifactService.java index d4c221eb7..526397fbf 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/api/service/BlackArtifactService.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/api/service/BlackArtifactService.java @@ -70,7 +70,23 @@ public interface BlackArtifactService extends ArtifactService { public Set getArtifacts(String groupId, String artifactId); + /** + * Fetches all artifacts from blocklist, that have GA matching one of the provided GAs. + * + * @param gas Set of GAs to find in blocklist. + * @return Set of blocklisted artifacts. + */ Set prefetchGAs(Set gas); + /** + * Checks if given GA + version is blocklisted in the provided set of GAVs (obtained using + * {@link BlackArtifactService#prefetchGAs(Set)}). The same transformations as in + * {@link BlackArtifactService#getArtifact(GAV)} are performed with the version when looking for the artifact. + * + * @param cache Cache of blocklisted GAVs, obtained using {@link BlackArtifactService#prefetchGAs(Set)} + * @param ga Group Id + Artifact Id to check in the blocklist. + * @param version Version to check in the blocklist. + * @return True, if the GA + version is present in the blocklist. + */ boolean isBlocklisted(Set cache, GA ga, String version); } From a5841b1d7e8e4fa4d25222fb00fd66dd86ba155f Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Wed, 18 Feb 2026 14:29:59 +0000 Subject: [PATCH 24/26] Reapply "Fix double in" This reverts commit dd4ee72491895ea3eba9ef385025ba52cb5c9a81. --- .../da/listings/impl/dao/ArtifactDAOImpl.java | 2 +- .../listings/AbstractRestApiListingTest.java | 2 +- .../test/client/rest/lookup/LookupTestIT.java | 4 ++- .../rest/lookup/LookupTestITBlocklist.java | 34 +++++++++++++++++++ .../lookup/maven/guava13Blocklist.json | 8 +++++ .../lookup/maven/guava13Blocklist.json | 11 ++++++ 6 files changed, 58 insertions(+), 3 deletions(-) create mode 100644 testsuite/src/test/java/org/jboss/da/test/client/rest/lookup/LookupTestITBlocklist.java create mode 100644 testsuite/src/test/rest/v-1/expectedResponse/lookup/maven/guava13Blocklist.json create mode 100644 testsuite/src/test/rest/v-1/request/lookup/maven/guava13Blocklist.json diff --git a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ArtifactDAOImpl.java b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ArtifactDAOImpl.java index 8a8f25830..663d18f32 100644 --- a/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ArtifactDAOImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/listings/impl/dao/ArtifactDAOImpl.java @@ -51,7 +51,7 @@ public List findArtifact(Set gas) { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery cq = cb.createQuery(type); Root artifact = cq.from(type); - cq.select(artifact).where(cb.in(artifact.get("ga").in(gas))); + cq.select(artifact).where(artifact.get("ga").in(gas)); TypedQuery q = em.createQuery(cq); return q.getResultList(); } diff --git a/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/AbstractRestApiListingTest.java b/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/AbstractRestApiListingTest.java index 979b95a64..142d7f768 100644 --- a/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/AbstractRestApiListingTest.java +++ b/testsuite/src/test/java/org/jboss/da/test/client/rest/listings/AbstractRestApiListingTest.java @@ -34,7 +34,7 @@ protected enum OperationType { protected static final String PATH_BLACK_LIST = "/listings/blacklist"; - protected static final String PATH_BLACK_LISTINGS_GAV = "/listings/blacklist/gav"; + public static final String PATH_BLACK_LISTINGS_GAV = "/listings/blacklist/gav"; protected static final String PATH_BLACK_LISTINGS_GA = "/listings/blacklist/ga"; diff --git a/testsuite/src/test/java/org/jboss/da/test/client/rest/lookup/LookupTestIT.java b/testsuite/src/test/java/org/jboss/da/test/client/rest/lookup/LookupTestIT.java index ad371d202..3326655e6 100644 --- a/testsuite/src/test/java/org/jboss/da/test/client/rest/lookup/LookupTestIT.java +++ b/testsuite/src/test/java/org/jboss/da/test/client/rest/lookup/LookupTestIT.java @@ -1,15 +1,17 @@ package org.jboss.da.test.client.rest.lookup; +import javax.ws.rs.client.Entity; import javax.ws.rs.core.Response; import org.jboss.da.test.client.rest.AbstractRestReportsTest; import org.junit.Test; +import static org.jboss.da.test.client.rest.listings.AbstractRestApiListingTest.PATH_BLACK_LISTINGS_GAV; import static org.junit.Assert.assertEquals; public class LookupTestIT extends AbstractRestReportsTest { - private static final String PATH_LOOKUP_MAVEN = "/lookup/maven"; + static final String PATH_LOOKUP_MAVEN = "/lookup/maven"; private static final String PATH_LATEST_MAVEN = "/lookup/maven/latest"; private static final String PATH_MAVEN_VERSIONS = "/lookup/maven/versions"; diff --git a/testsuite/src/test/java/org/jboss/da/test/client/rest/lookup/LookupTestITBlocklist.java b/testsuite/src/test/java/org/jboss/da/test/client/rest/lookup/LookupTestITBlocklist.java new file mode 100644 index 000000000..c61efa0c2 --- /dev/null +++ b/testsuite/src/test/java/org/jboss/da/test/client/rest/lookup/LookupTestITBlocklist.java @@ -0,0 +1,34 @@ +package org.jboss.da.test.client.rest.lookup; + +import org.jboss.da.test.client.rest.AbstractRestReportsTest; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import javax.ws.rs.client.Entity; +import javax.ws.rs.core.Response; + +import static org.jboss.da.test.client.rest.listings.AbstractRestApiListingTest.PATH_BLACK_LISTINGS_GAV; +import static org.jboss.da.test.client.rest.lookup.LookupTestIT.PATH_LOOKUP_MAVEN; +import static org.junit.Assert.assertEquals; + +public class LookupTestITBlocklist extends AbstractRestReportsTest { + + @Before + public void prepareBlocklist() { + String blocklist = "{\"groupId\":\"com.google.guava\",\"artifactId\":\"guava\",\"version\":\"13.0.1-redhat-2\"}"; + createClientRequest(PATH_BLACK_LISTINGS_GAV).post(Entity.json(blocklist)).close(); + } + + @Test + public void testGavLookupSingleWithBlocklist() throws Exception { + Response response = assertResponseForRequest(PATH_LOOKUP_MAVEN, "guava13Blocklist"); + assertEquals(200, response.getStatus()); + } + + @After + public void cleanBlocklist() { + String blocklist = "{\"groupId\":\"com.google.guava\",\"artifactId\":\"guava\",\"version\":\"13.0.1-redhat-2\"}"; + createClientRequest(PATH_BLACK_LISTINGS_GAV).method("DELTE", Entity.json(blocklist)).close(); + } +} diff --git a/testsuite/src/test/rest/v-1/expectedResponse/lookup/maven/guava13Blocklist.json b/testsuite/src/test/rest/v-1/expectedResponse/lookup/maven/guava13Blocklist.json new file mode 100644 index 000000000..65771305a --- /dev/null +++ b/testsuite/src/test/rest/v-1/expectedResponse/lookup/maven/guava13Blocklist.json @@ -0,0 +1,8 @@ +[ + { + "bestMatchVersion": "13.0.1-redhat-1", + "groupId": "com.google.guava", + "artifactId": "guava", + "version": "13.0.1" + } +] diff --git a/testsuite/src/test/rest/v-1/request/lookup/maven/guava13Blocklist.json b/testsuite/src/test/rest/v-1/request/lookup/maven/guava13Blocklist.json new file mode 100644 index 000000000..2e1c5db7f --- /dev/null +++ b/testsuite/src/test/rest/v-1/request/lookup/maven/guava13Blocklist.json @@ -0,0 +1,11 @@ +{ + "artifacts": [ + { + "groupId": "com.google.guava", + "artifactId": "guava", + "version": "13.0.1" + } + ], + "mode": "PERSISTENT", + "brewPullActive": true +} \ No newline at end of file From 5ebaa8f5f70e848b8a852bc73abfeecd3e09c6a8 Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Mon, 23 Feb 2026 09:36:07 +0000 Subject: [PATCH 25/26] Add central snapshot repository --- pom.xml | 12 ++++++++++++ .../jboss/da/reports/impl/LookupGeneratorImpl.java | 8 +++++--- 2 files changed, 17 insertions(+), 3 deletions(-) diff --git a/pom.xml b/pom.xml index c5d310638..ebf41a4a2 100644 --- a/pom.xml +++ b/pom.xml @@ -375,6 +375,18 @@ + + Central Portal Snapshots + central-portal-snapshots + https://central.sonatype.com/repository/maven-snapshots/ + + false + + + true + + + MRRC GA https://maven.repository.redhat.com/ga diff --git a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java index 02a828db5..481fa1e6c 100644 --- a/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java +++ b/reports-backend/src/main/java/org/jboss/da/reports/impl/LookupGeneratorImpl.java @@ -162,9 +162,11 @@ private Map>> getArtifactVersions(Set> filterBlacklistedArtifacts(CompletableFuture> versions, Set cache, GA ga) { - Predicate isNotBlacklisted = version -> !blackArtifactService - .isBlocklisted(cache, ga, version); + private CompletableFuture> filterBlacklistedArtifacts( + CompletableFuture> versions, + Set cache, + GA ga) { + Predicate isNotBlacklisted = version -> !blackArtifactService.isBlocklisted(cache, ga, version); return versions.thenApply(v -> v.stream().filter(isNotBlacklisted).collect(Collectors.toSet())); } From bf36c80cb9a0267e9cf8f1faee504b160d681747 Mon Sep 17 00:00:00 2001 From: Nick Cross Date: Thu, 26 Feb 2026 12:23:26 +0000 Subject: [PATCH 26/26] Use fixed version for pnc-api. Use SLF4J format for logging --- .../org/jboss/da/communication/pnc/PncConnectorImpl.java | 8 +++----- pom.xml | 2 +- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/communication/src/main/java/org/jboss/da/communication/pnc/PncConnectorImpl.java b/communication/src/main/java/org/jboss/da/communication/pnc/PncConnectorImpl.java index 1c550b5e8..45fb5461a 100644 --- a/communication/src/main/java/org/jboss/da/communication/pnc/PncConnectorImpl.java +++ b/communication/src/main/java/org/jboss/da/communication/pnc/PncConnectorImpl.java @@ -20,7 +20,6 @@ import java.net.URI; import java.util.ArrayList; import java.util.Collection; -import java.util.Collections; import java.util.List; /** @@ -72,7 +71,7 @@ public List getMavenVersions(GA ga, LookupMode mode) throws RepositoryEx // TODO filtering by target repository if necessary versions.add(parts[3]); } else { - log.error("Cannot read version for artifact with identifier %s", art.getIdentifier()); + log.error("Cannot read version for artifact with identifier {}", art.getIdentifier()); } } return versions; @@ -90,7 +89,7 @@ public List getNpmVersions(String packageName, LookupMode mode) throws R // TODO filtering by target repository if necessary versions.add(parts[1]); } else { - log.error("Cannot read version for artifact with identifier %s", art.getIdentifier()); + log.error("Cannot read version for artifact with identifier {}", art.getIdentifier()); } } return versions; @@ -112,8 +111,7 @@ private Configuration getClientConfig(String protocol, String host, int port) { builder.mdcToHeadersMappings(MDCUtils.HEADER_KEY_MAPPING); - Configuration config = builder.build(); - return config; + return builder.build(); } } diff --git a/pom.xml b/pom.xml index ebf41a4a2..36299d081 100644 --- a/pom.xml +++ b/pom.xml @@ -83,7 +83,7 @@ 1 3.4.2 3.4.1-SNAPSHOT - 3.5.0-SNAPSHOT + 3.4.2 0.16.2 0.13.4 0.12.2