Let a rule read a named set from the test resources

semantic-tag-hierarchies.txt is loaded as a generic key=value,value,value store,
but isSemanticTagCompatibleWithinHierarchy is the only way a rule can read it -
and that method extracts a semantic tag from a term before looking it up, so the
store is only reachable for values that are semantic tags.

This exposes the same store for values that are not, so a rule can be driven by
per-edition configuration. The case that prompted it is a set of module ids: an
editorial policy that some editions have adopted and others have not cannot be
expressed as a semantic tag, and hardcoding either the policy or its exceptions
into a rule in common-authoring makes that rule wrong for somebody.

Defaulted rather than abstract, so implementations outside this project - the
authoring platform's, in particular - keep compiling untouched. The default
answers false for every key, meaning "no configuration present", which obliges a
rule using it to behave on false exactly as it did before the method existed.
NamedSetLookupTest asserts that against an implementation declaring only the
methods the interface required before this change.

TestDescriptionService implements it too. Without that the rules test rig would
always see the default, so a rule driven by a named set could only ever be
tested unconfigured - the set would look empty however test-cases.json and the
dummy test resources were written.

No behaviour change on its own: no rule calls it yet.

Author: dionmcm

snomed-drools-engine/src/main/java/org/ihtsdo/drools/service/DescriptionService.java

@@ -25,4 +25,29 @@ public interface DescriptionService {
 
 	boolean isSemanticTagCompatibleWithinHierarchy(String term, Set<String> topLevelSemanticTags);
 
+	/**
+	 * Is {@code value} a member of the named set {@code setKey} in the test
+	 * resources?
+	 *
+	 * <p>semantic-tag-hierarchies.txt is loaded as a generic
+	 * {@code key=value,value,value} store, and
+	 * {@link #isSemanticTagCompatibleWithinHierarchy} is currently the only way a
+	 * rule can read it - which restricts it to values that are semantic tags
+	 * extracted from a term. This exposes the same store for values that are not,
+	 * so that a rule can be driven by per-edition configuration such as a set of
+	 * module ids.
+	 *
+	 * <p>Defaulted rather than abstract so that existing implementations outside
+	 * this project keep compiling. The default answers {@code false} for every
+	 * key, which means "no configuration present" - a rule written against this
+	 * must therefore behave, when it gets {@code false}, exactly as it did before
+	 * the configuration existed.
+	 *
+	 * @param setKey the key on the left of the {@code =} in the resource file
+	 * @param value  the value to look for among that key's members
+	 */
+	default boolean isInNamedSet(String setKey, String value) {
+		return false;
+	}
+
 }

snomed-drools-engine/src/test/java/org/ihtsdo/drools/rulestestrig/service/TestDescriptionService.java

@@ -162,4 +162,19 @@ public boolean isSemanticTagCompatibleWithinHierarchy(String testTerm, Set<Strin
 
 		return false;
 	}
+
+	/**
+	 * Without this the rules test rig always sees the interface default,
+	 * {@code false}, so a rule driven by a named set could only ever be tested in
+	 * its unconfigured state - the set would appear empty however the test
+	 * resources were written.
+	 */
+	@Override
+	public boolean isInNamedSet(String setKey, String value) {
+		if (setKey == null || value == null) {
+			return false;
+		}
+		Set<String> members = testResourceProvider.getSemanticHierarchyMap().get(setKey);
+		return !CollectionUtils.isEmpty(members) && members.contains(value);
+	}
 }

snomed-drools-engine/src/test/java/org/ihtsdo/drools/unittest/NamedSetLookupTest.java

@@ -0,0 +1,99 @@
+package org.ihtsdo.drools.unittest;
+
+import org.ihtsdo.drools.domain.Concept;
+import org.ihtsdo.drools.domain.Description;
+import org.ihtsdo.drools.service.DescriptionService;
+import org.junit.Test;
+
+import java.util.Set;
+
+import static org.junit.Assert.assertFalse;
+
+/**
+ * The guarantee that makes {@link DescriptionService#isInNamedSet} safe to add:
+ * an implementation written before it existed keeps compiling, and answers in a
+ * way that leaves a rule using it behaving exactly as it did before.
+ *
+ * <p>{@link LegacyDescriptionService} below is such an implementation - it
+ * implements every method the interface had previously and does not mention the
+ * new one. That this file compiles is half the test; the assertions are the
+ * other half.
+ */
+public class NamedSetLookupTest {
+
+	private final DescriptionService legacy = new LegacyDescriptionService();
+
+	@Test
+	public void anImplementationThatDoesNotOverrideItAnswersFalse() {
+		assertFalse(legacy.isInNamedSet("redundant-isa-exempt-modules", "32506021000036107"));
+	}
+
+	@Test
+	public void theDefaultDoesNotDistinguishBetweenKeys() {
+		// "No configuration present" has to be the answer for every key, not only
+		// for keys nobody has defined, or a rule would behave differently
+		// depending on which implementation it ran against.
+		assertFalse(legacy.isInNamedSet("anything-at-all", "any-value"));
+		assertFalse(legacy.isInNamedSet("", ""));
+	}
+
+	@Test
+	public void theDefaultToleratesNulls() {
+		assertFalse(legacy.isInNamedSet(null, "32506021000036107"));
+		assertFalse(legacy.isInNamedSet("redundant-isa-exempt-modules", null));
+		assertFalse(legacy.isInNamedSet(null, null));
+	}
+
+	/**
+	 * Stands in for an implementation outside this project - the authoring
+	 * platform's, in particular. Only the methods the interface required before
+	 * this change are declared.
+	 */
+	private static final class LegacyDescriptionService implements DescriptionService {
+
+		@Override
+		public Set<String> getFSNs(Set<String> conceptIds, String... languageRefsetIds) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public Set<Description> findActiveDescriptionByExactTerm(String exactTerm) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public Set<Description> findInactiveDescriptionByExactTerm(String exactTerm) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public Set<Description> findMatchingDescriptionInHierarchy(Concept concept, Description description) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public String getLanguageSpecificErrorMessage(Description description) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public String getCaseSensitiveWordsErrorMessage(Description description) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public Set<String> findParentsNotContainingSemanticTag(Concept concept, String termSematicTag, String... languageRefsetIds) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public boolean isRecognisedSemanticTag(String termSemanticTag, String language) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public boolean isSemanticTagCompatibleWithinHierarchy(String term, Set<String> topLevelSemanticTags) {
+			throw new UnsupportedOperationException();
+		}
+	}
+}

snomed-drools-rf2-validator/src/main/java/org/ihtsdo/drools/validator/rf2/service/DroolsDescriptionService.java

@@ -191,6 +191,15 @@ public boolean isSemanticTagCompatibleWithinHierarchy(String testTerm, Set<Strin
 		return false;
 	}
 
+	@Override
+	public boolean isInNamedSet(String setKey, String value) {
+		if (setKey == null || value == null) {
+			return false;
+		}
+		Set<String> members = testResourceProvider.getSemanticHierarchyMap().get(setKey);
+		return !CollectionUtils.isEmpty(members) && members.contains(value);
+	}
+
 	private static String getTag(String term) {
 		final Matcher matcher = DescriptionHelper.TAG_PATTERN.matcher(term);
 		if (matcher.matches()) {

snomed-drools-rf2-validator/src/test/java/org/ihtsdo/drools/validator/rf2/service/DroolsNamedSetLookupTest.java

@@ -0,0 +1,97 @@
+package org.ihtsdo.drools.validator.rf2.service;
+
+import org.ihtsdo.drools.service.TestResourceProvider;
+import org.ihtsdo.drools.validator.rf2.DroolsRF2Validator;
+import org.ihtsdo.otf.resourcemanager.ResourceManager;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * {@code isInNamedSet} against the real reference-data store.
+ *
+ * <p>The absent-key case is the one that matters, because it is the state every
+ * edition is in until it adds a key: a rule that negates this method must go on
+ * behaving as it did before the key existed.
+ */
+public class DroolsNamedSetLookupTest extends BaseServiceTest {
+
+	private static final String KEY = "redundant-isa-exempt-modules";
+	private static final String AU_MODULE = "32506021000036107";
+	private static final String CORE_MODULE = "900000000000207008";
+
+	private DroolsDescriptionService serviceWithNoResources;
+
+	@Before
+	public void setup() throws IOException {
+		loadConceptsIntoRepository();
+		loadDescriptionsIntoRepository();
+		ResourceManager blank = new ResourceManager(DroolsRF2Validator.BLANK_RESOURCES_CONFIGURATION, null);
+		serviceWithNoResources = service(new TestResourceProvider(blank));
+	}
+
+	private DroolsDescriptionService service(TestResourceProvider provider) {
+		return new DroolsDescriptionService(repository, new DroolsConceptService(repository, null), provider);
+	}
+
+	/** No reference data at all - every lookup must answer false. */
+	@Test
+	public void absentFileMeansNotAMember() {
+		assertFalse(serviceWithNoResources.isInNamedSet(KEY, AU_MODULE));
+		assertFalse(serviceWithNoResources.isInNamedSet(KEY, CORE_MODULE));
+	}
+
+	@Test
+	public void aKeyThatIsNotInTheFileMeansNotAMember() throws IOException {
+		assertFalse(withSet("some-other-key", AU_MODULE).isInNamedSet(KEY, AU_MODULE));
+	}
+
+	@Test
+	public void aListedValueIsAMemberAndAnUnlistedOneIsNot() throws IOException {
+		DroolsDescriptionService s = withSet(KEY, AU_MODULE);
+		assertTrue(s.isInNamedSet(KEY, AU_MODULE));
+		assertFalse(s.isInNamedSet(KEY, CORE_MODULE));
+	}
+
+	@Test
+	public void matchingIsExactRatherThanBySubstring() throws IOException {
+		// Module ids are long and share prefixes; a substring match would exempt
+		// modules nobody listed.
+		DroolsDescriptionService s = withSet(KEY, AU_MODULE);
+		assertFalse(s.isInNamedSet(KEY, AU_MODULE.substring(0, 8)));
+		assertFalse(s.isInNamedSet(KEY, AU_MODULE + "9"));
+	}
+
+	@Test
+	public void nullsAreNotMembers() throws IOException {
+		DroolsDescriptionService s = withSet(KEY, AU_MODULE);
+		assertFalse(s.isInNamedSet(null, AU_MODULE));
+		assertFalse(s.isInNamedSet(KEY, null));
+	}
+
+	/**
+	 * The loader that reads {@code key=value,value} from
+	 * semantic-tag-hierarchies.txt is already exercised by the semantic-tag
+	 * tests, so the map is supplied directly here to keep this about the lookup.
+	 */
+	private DroolsDescriptionService withSet(String key, String... values) throws IOException {
+		ResourceManager blank = new ResourceManager(DroolsRF2Validator.BLANK_RESOURCES_CONFIGURATION, null);
+		Map<String, Set<String>> named = new HashMap<>();
+		named.put(key, new HashSet<>(java.util.Arrays.asList(values)));
+		return service(new TestResourceProvider(blank) {
+			@Override
+			public Map<String, Set<String>> getSemanticHierarchyMap() {
+				return Collections.unmodifiableMap(named);
+			}
+		});
+	}
+}