Bug 565684 API revision | diagnostic

fix all the compilation errors driven by refactoring `move access cycle services to crosscuting diagnostic` Signed-off-by: elena.parovyshnaya <elena.parovyshnaya@gmail.com>
eclipse-passage · Aug 3, 2020 · 2376d1a · 2376d1a
1 parent f7a6da9
commit 2376d1a
Show file tree

Hide file tree

Showing 12 changed files with 115 additions and 90 deletions.
diff --git a/...org.eclipse.passage.lic.base/src/org/eclipse/passage/lic/internal/base/FeatureFilter.java b/...org.eclipse.passage.lic.base/src/org/eclipse/passage/lic/internal/base/FeatureFilter.java
@@ -10,7 +10,7 @@
  * Contributors:
  *     ArSysOp - initial API and implementation
  *******************************************************************************/
-package org.eclipse.passage.lic.internal.base.access;
+package org.eclipse.passage.lic.internal.base;
 
 import java.util.Collection;
 import java.util.Collections;
@@ -20,15 +20,14 @@
 import java.util.stream.Collectors;
 
 import org.eclipse.passage.lic.internal.api.ServiceInvocationResult;
-import org.eclipse.passage.lic.internal.base.BaseServiceInvocationResult;
 
-final class FeatureFilter<T>
+public final class FeatureFilter<T>
 		implements Function<ServiceInvocationResult<Collection<T>>, ServiceInvocationResult<Collection<T>>> {
 
 	private final String feature;
 	private final BiFunction<T, String, Optional<T>> map;
 
-	FeatureFilter(String feature, BiFunction<T, String, Optional<T>> map) {
+	public FeatureFilter(String feature, BiFunction<T, String, Optional<T>> map) {
 		this.feature = feature;
 		this.map = map;
 	}

diff --git a/...eclipse.passage.lic.base/src/org/eclipse/passage/lic/internal/base/access/Conditions.java b/...eclipse.passage.lic.base/src/org/eclipse/passage/lic/internal/base/access/Conditions.java
@@ -24,6 +24,7 @@
 import org.eclipse.passage.lic.internal.api.registry.Registry;
 import org.eclipse.passage.lic.internal.api.registry.StringServiceId;
 import org.eclipse.passage.lic.internal.base.BaseServiceInvocationResult;
+import org.eclipse.passage.lic.internal.base.FeatureFilter;
 import org.eclipse.passage.lic.internal.base.SumOfCollections;
 import org.eclipse.passage.lic.internal.base.conditions.FeatureConditionPack;
 import org.eclipse.passage.lic.internal.base.diagnostic.code.NoServicesOfType;

diff --git a/...lipse.passage.lic.base/src/org/eclipse/passage/lic/internal/base/access/Requirements.java b/...lipse.passage.lic.base/src/org/eclipse/passage/lic/internal/base/access/Requirements.java
@@ -13,7 +13,6 @@
 package org.eclipse.passage.lic.internal.base.access;
 
 import java.util.Collection;
-import java.util.Optional;
 import java.util.function.Supplier;
 
 import org.eclipse.passage.lic.internal.api.ServiceInvocationResult;
@@ -26,6 +25,7 @@
 import org.eclipse.passage.lic.internal.base.SumOfCollections;
 import org.eclipse.passage.lic.internal.base.diagnostic.code.NoServicesOfType;
 import org.eclipse.passage.lic.internal.base.i18n.BaseMessages;
+import org.eclipse.passage.lic.internal.base.requirements.RequirementsFeatureFilter;
 
 /**
  * FIXME: Has public visibility only for testing.
@@ -52,12 +52,8 @@ public ServiceInvocationResult<Collection<Requirement>> get() {
 		return registry.services().stream() //
 				.map(ResolvedRequirements::all) //
 				.reduce(new BaseServiceInvocationResult.Sum<>(new SumOfCollections<Requirement>()))//
-				.map(new FeatureFilter<Requirement>(feature, this::filtered))//
+				.map(new RequirementsFeatureFilter(feature).get())//
 				.get(); // always exists
 	}
 
-	private Optional<Requirement> filtered(Requirement origin, String incoming) {
-		return incoming.equals(origin.feature().identifier()) ? Optional.of(origin) : Optional.empty();
-	}
-
 }
diff --git a/...ase/src/org/eclipse/passage/lic/internal/base/requirements/RequirementsFeatureFilter.java b/...ase/src/org/eclipse/passage/lic/internal/base/requirements/RequirementsFeatureFilter.java
@@ -0,0 +1,38 @@
+/*******************************************************************************
+ * Copyright (c) 2020 ArSysOp
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * https://www.eclipse.org/legal/epl-2.0/.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     ArSysOp - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.passage.lic.internal.base.requirements;
+
+import java.util.Optional;
+import java.util.function.Supplier;
+
+import org.eclipse.passage.lic.internal.api.requirements.Requirement;
+import org.eclipse.passage.lic.internal.base.FeatureFilter;
+
+public final class RequirementsFeatureFilter implements Supplier<FeatureFilter<Requirement>> {
+
+	private final String feature;
+
+	public RequirementsFeatureFilter(String feature) {
+		this.feature = feature;
+	}
+
+	@Override
+	public FeatureFilter<Requirement> get() {
+		return new FeatureFilter<Requirement>(feature, this::filtered);
+	}
+
+	private Optional<Requirement> filtered(Requirement origin, String incoming) {
+		return incoming.equals(origin.feature().identifier()) ? Optional.of(origin) : Optional.empty();
+	}
+
+}
diff --git a/...lic.api.tests/src/org/eclipse/passage/lic/api/tests/ResolvedRequirementsContractTest.java b/...lic.api.tests/src/org/eclipse/passage/lic/api/tests/ResolvedRequirementsContractTest.java
@@ -27,7 +27,7 @@ public abstract class ResolvedRequirementsContractTest extends ReadOnlyCollectio
 
 	@Override
 	protected final Supplier<Collection<Requirement>> collection() {
-		return service()::all;
+		return service().all().data()::get;
 	}
 
 	@Override

diff --git a/...ipse/passage/lic/api/tests/fakes/conditions/evaluation/FakePermissionEmittingService.java b/...ipse/passage/lic/api/tests/fakes/conditions/evaluation/FakePermissionEmittingService.java
@@ -15,6 +15,7 @@
 import java.util.Collection;
 
 import org.eclipse.passage.lic.internal.api.LicensedProduct;
+import org.eclipse.passage.lic.internal.api.ServiceInvocationResult;
 import org.eclipse.passage.lic.internal.api.conditions.ConditionPack;
 import org.eclipse.passage.lic.internal.api.conditions.evaluation.Emission;
 import org.eclipse.passage.lic.internal.api.conditions.evaluation.PermissionEmittingService;
@@ -29,7 +30,8 @@ public StringServiceId id() {
 	}
 
 	@Override
-	public Collection<Emission> emit(Collection<ConditionPack> conditions, LicensedProduct product) {
+	public ServiceInvocationResult<Collection<Emission>> emit(Collection<ConditionPack> conditions,
+			LicensedProduct product) {
 		throw new UnsupportedOperationException();
 	}
 

diff --git a/...i.tests/src/org/eclipse/passage/lic/api/tests/fakes/diagnostic/FakeFailureDiagnostic.java b/...i.tests/src/org/eclipse/passage/lic/api/tests/fakes/diagnostic/FakeFailureDiagnostic.java
@@ -25,4 +25,9 @@ public List<Trouble> bearable() {
 		throw new UnsupportedOperationException();
 	}
 
+	@Override
+	public List<Trouble> severe() {
+		throw new UnsupportedOperationException();
+	}
+
 }
diff --git a/...ts/src/org/eclipse/passage/lic/api/tests/fakes/requirements/FakeResolvedRequirements.java b/...ts/src/org/eclipse/passage/lic/api/tests/fakes/requirements/FakeResolvedRequirements.java
@@ -14,6 +14,7 @@
 
 import java.util.Collection;
 
+import org.eclipse.passage.lic.internal.api.ServiceInvocationResult;
 import org.eclipse.passage.lic.internal.api.registry.StringServiceId;
 import org.eclipse.passage.lic.internal.api.requirements.Requirement;
 import org.eclipse.passage.lic.internal.api.requirements.ResolvedRequirements;
@@ -27,7 +28,7 @@ public StringServiceId id() {
 	}
 
 	@Override
-	public Collection<Requirement> all() {
+	public ServiceInvocationResult<Collection<Requirement>> all() {
 		throw new UnsupportedOperationException();
 	}
 

diff --git a/...sage/lic/internal/base/tests/conditions/evaluation/BasePermissionEmittingServiceTest.java b/...sage/lic/internal/base/tests/conditions/evaluation/BasePermissionEmittingServiceTest.java
@@ -24,6 +24,7 @@
 import org.eclipse.passage.lic.api.tests.fakes.conditions.FakeCondition;
 import org.eclipse.passage.lic.api.tests.fakes.conditions.evaluation.FakeExpressionTokenAssessmentService;
 import org.eclipse.passage.lic.internal.api.LicensedProduct;
+import org.eclipse.passage.lic.internal.api.ServiceInvocationResult;
 import org.eclipse.passage.lic.internal.api.conditions.Condition;
 import org.eclipse.passage.lic.internal.api.conditions.ConditionPack;
 import org.eclipse.passage.lic.internal.api.conditions.EvaluationType;
@@ -33,6 +34,7 @@
 import org.eclipse.passage.lic.internal.api.conditions.evaluation.ExpressionPasringRegistry;
 import org.eclipse.passage.lic.internal.api.conditions.evaluation.ExpressionTokenAssessorsRegistry;
 import org.eclipse.passage.lic.internal.api.conditions.evaluation.PermissionEmittingService;
+import org.eclipse.passage.lic.internal.api.diagnostic.TroubleCode;
 import org.eclipse.passage.lic.internal.base.BaseLicensedProduct;
 import org.eclipse.passage.lic.internal.base.conditions.BaseConditionPack;
 import org.eclipse.passage.lic.internal.base.conditions.BaseEvaluationInstructions;
@@ -68,12 +70,14 @@ public void demandsEvluators() {
 	public void singleConditionFailureIsContagious() {
 		BiasedAssessor morphology = morphologyAssessor(2, 1);
 		BiasedAssessor dialog = dialogAssessor(4, 3);
-		Collection<Emission> emissions = service(morphology, dialog)//
+		ServiceInvocationResult<Collection<Emission>> result = service(morphology, dialog)//
 				.emit(packOf(humanoid(2, 1), teller(5, 3)), product());
+		assertTrue(result.diagnostic().severe().isEmpty());
+		assertTrue(result.data().isPresent());
+		Collection<Emission> emissions = result.data().get();
 		assertEquals(1, emissions.size());
-		Emission emission = emissions.iterator().next();
-		assertFalse(emission.successful());
-		assertTrue(emission.failureDiagnostic().bearable().size() == 1);
+		assertFalse(result.diagnostic().bearable().isEmpty());
+		assertEquals(1, result.diagnostic().bearable().size());
 		assertEquals(2, morphology.askedKeys().size());
 		assertTrue(dialog.askedKeys().contains("storytelling"));//$NON-NLS-1$
 	}
@@ -84,47 +88,55 @@ public void differentEvaluationTypes() {
 		BiasedAssessor morphology = morphologyAssessor(2, 1);
 		BiasedAssessor dialog = dialogAssessor(4, 3);
 		// when: emit on valid data
-		Collection<Emission> emissions = service(morphology, dialog)//
+		ServiceInvocationResult<Collection<Emission>> result = service(morphology, dialog)//
 				.emit(packOf(//
 						humanoid(2, 1), //
 						teller(4, 3)//
 				), product());
+		// then: there is no errors
+		assertTrue(result.diagnostic().severe().isEmpty());
+		assertTrue(result.diagnostic().bearable().isEmpty());
+		assertTrue(result.data().isPresent());
+		Collection<Emission> emissions = result.data().get();
 		// then: all conditions evaluated to permissions
 		assertEquals(1, emissions.size());
 		Emission emission = emissions.iterator().next();
-		assertTrue(emission.successful());
 		assertEquals(2, emission.permissions().size());
 		assertEquals(2, morphology.askedKeys().size());
 		assertEquals(2, dialog.askedKeys().size());
 	}
 
 	@Test
 	public void unsupportedEvaluationTypeFailsEmission() {
-		BiasedAssessor morphology = morphologyAssessor(4, 2);
-		Collection<Emission> emissions = service(morphology).emit(packOf(teller(4, 3)), product());
-		assertEquals(1, emissions.size());
-		Emission emission = emissions.iterator().next();
-		assertFalse(emission.successful());
-		assertEquals(1, emission.failureDiagnostic().bearable().size());
-		assertEquals(new LicenseCheckFailed(), emission.failureDiagnostic().bearable().get(0).code());
+		verifyMorelFailure(//
+				service(morphologyAssessor(4, 2)).emit(packOf(teller(4, 3)), product()), //
+				new LicenseCheckFailed());
 	}
 
 	@Test
 	public void corruptedExpressionFailsEmission() {
-		Collection<Emission> emissions = service(morphologyAssessor(1, 1)).emit(packOf(corrupted()), product());
-		assertEquals(1, emissions.size());
-		Emission emission = emissions.iterator().next();
-		assertFalse(emission.successful());
-		assertEquals(new LicenseInvalid(), emission.failureDiagnostic().bearable().get(0).code());
+		verifyMorelFailure(//
+				service(morphologyAssessor(1, 1)).emit(packOf(corrupted()), product()), //
+				new LicenseInvalid());
 	}
 
 	@Test
 	public void negativeAssessmentExpressionFailsEmission() {
-		Collection<Emission> emissions = service(morphologyAssessor(1, 1)).emit(packOf(humanoid(2, 1)), product());
-		assertEquals(1, emissions.size());
-		Emission emission = emissions.iterator().next();
-		assertFalse(emission.successful());
-		assertEquals(new LicenseDoesNotMatch(), emission.failureDiagnostic().bearable().get(0).code());
+		verifyMorelFailure(//
+				service(morphologyAssessor(1, 1)).emit(packOf(humanoid(2, 1)), product()), //
+				new LicenseDoesNotMatch());
+	}
+
+	private void verifyMorelFailure(ServiceInvocationResult<Collection<Emission>> result, TroubleCode expected) {
+		// there is no severe errors
+		assertTrue(result.diagnostic().severe().isEmpty());
+		// there is only one empty emission
+		assertTrue(result.data().isPresent());
+		assertEquals(1, result.data().get().size());
+		assertTrue(result.data().get().iterator().next().permissions().isEmpty());
+		// unsuccessful evolution is reported properly
+		assertEquals(1, result.diagnostic().bearable().size());
+		assertEquals(expected, result.diagnostic().bearable().get(0).code());
 	}
 
 	private PermissionEmittingService service(BiasedAssessor... assessors) {

diff --git a/...org/eclipse/passage/lic/internal/base/tests/conditions/evaluation/SumOfEmissionsTest.java b/...org/eclipse/passage/lic/internal/base/tests/conditions/evaluation/SumOfEmissionsTest.java
@@ -13,91 +13,55 @@
 package org.eclipse.passage.lic.internal.base.tests.conditions.evaluation;
 
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
 
 import java.util.Collections;
 
 import org.eclipse.passage.lic.api.tests.fakes.conditions.FakeConditionPack;
 import org.eclipse.passage.lic.api.tests.fakes.conditions.evaluation.FakePermission;
 import org.eclipse.passage.lic.internal.api.conditions.ConditionPack;
 import org.eclipse.passage.lic.internal.api.conditions.evaluation.Emission;
-import org.eclipse.passage.lic.internal.api.conditions.evaluation.Emission.Failed;
-import org.eclipse.passage.lic.internal.api.conditions.evaluation.Emission.Successful;
-import org.eclipse.passage.lic.internal.api.diagnostic.TroubleCode;
 import org.eclipse.passage.lic.internal.base.conditions.evaluation.SumOfEmissions;
-import org.eclipse.passage.lic.internal.base.diagnostic.BaseDiagnostic;
 import org.junit.Test;
 
 @SuppressWarnings("restriction")
 public final class SumOfEmissionsTest {
 
-	@Test
-	public void sumOfSuccessesIsSuccess() {
-		ConditionPack common = new FakeConditionPack();
-		assertTrue(new SumOfEmissions().apply(success(common), success(common)).successful());
-	}
-
-	@Test
-	public void sumOfSuccessesAndFailureIsFailure() {
-		ConditionPack common = new FakeConditionPack();
-		assertFalse(new SumOfEmissions().apply(success(common), failure(common)).successful());
-	}
-
-	@Test
-	public void sumOfFailureAndSuccessIsFailure() {
-		ConditionPack common = new FakeConditionPack();
-		assertFalse(new SumOfEmissions().apply(failure(common), success(common)).successful());
-	}
-
-	@Test
-	public void sumOfFailuresIsFailure() {
-		ConditionPack common = new FakeConditionPack();
-		assertFalse(new SumOfEmissions().apply(failure(common), failure(common)).successful());
-	}
-
 	@Test(expected = NullPointerException.class)
 	public void prohibitsNullFirstOperand() {
-		new SumOfEmissions().apply(null, success(new FakeConditionPack()));
+		new SumOfEmissions().apply(null, empty(new FakeConditionPack()));
 	}
 
 	@Test(expected = NullPointerException.class)
 	public void prohibitsNullSecondOperand() {
-		new SumOfEmissions().apply(success(new FakeConditionPack()), null);
+		new SumOfEmissions().apply(empty(new FakeConditionPack()), null);
 	}
 
 	@Test
 	public void sumsPermissions() {
 		ConditionPack common = new FakeConditionPack();
 		assertEquals(2, //
 				new SumOfEmissions().apply(//
-						new Emission.Successful(common, new FakePermission()), //
-						new Emission.Successful(common, new FakePermission()))//
+						new Emission(common, new FakePermission()), //
+						new Emission(common, new FakePermission()))//
 						.permissions().size());
 	}
 
 	@Test
-	public void sumsDiagnostics() {
+	public void sumSharesOriginalPack() {
 		ConditionPack common = new FakeConditionPack();
-		assertEquals(2, new SumOfEmissions()//
-				.apply(failure(common), failure(common))//
-				.failureDiagnostic()//
-				.bearable()//
-				.size());
+		assertEquals(common, //
+				new SumOfEmissions().apply(empty(common), empty(common)).conditionPack());
 	}
 
 	@Test(expected = Exception.class)
 	public void doesNotSumDifferentPacks() {
 		new SumOfEmissions().apply(//
-				new Emission.Successful(new FakeConditionPack(), new FakePermission()), //
-				new Emission.Successful(new FakeConditionPack(), new FakePermission()));
+				new Emission(new FakeConditionPack(), new FakePermission()), //
+				new Emission(new FakeConditionPack(), new FakePermission()));
 	}
 
-	private Successful success(ConditionPack pack) {
-		return new Emission.Successful(pack, Collections.emptyList());
+	private Emission empty(ConditionPack pack) {
+		return new Emission(pack, Collections.emptyList());
 	}
 
-	private Failed failure(ConditionPack pack) {
-		return new Emission.Failed(pack, new BaseDiagnostic(new TroubleCode.Of(0, "0"), "")); //$NON-NLS-1$ //$NON-NLS-2$
-	}
 }
diff --git a/....tests/src/org/eclipse/passage/lic/internal/base/tests/requirements/RequirementsTest.java b/....tests/src/org/eclipse/passage/lic/internal/base/tests/requirements/RequirementsTest.java
@@ -17,6 +17,7 @@
 
 import java.util.Collection;
 
+import org.eclipse.passage.lic.internal.api.ServiceInvocationResult;
 import org.eclipse.passage.lic.internal.api.requirements.Requirement;
 import org.eclipse.passage.lic.internal.base.access.Requirements;
 import org.junit.Test;
@@ -26,10 +27,13 @@ public final class RequirementsTest {
 
 	@Test
 	public void noResolversMeansNoAccess() {
-		Collection<Requirement> requirements = new Requirements(//
+		ServiceInvocationResult<Collection<Requirement>> result = new Requirements(//
 				new SabotagedFramework().accessCycleConfiguration().requirementResolvers().get(), //
 				"feature0" //$NON-NLS-1$
 		).get();
+		assertTrue(result.diagnostic().severe().isEmpty());
+		assertTrue(result.data().isPresent());
+		Collection<Requirement> requirements = result.data().get();
 		assertEquals(1, requirements.size());
 		assertTrue(new Unsatisfiable().test(requirements.iterator().next()));
 	}