@Inject public CommonDomainLookups(final DefinitionUtils definitionUtils, final DefinitionsCacheRegistry definitionsRegistry, final RuleManager ruleManager) { this(definitionUtils, definitionsRegistry, ruleManager, defSetId -> new DomainLookupsCache(definitionUtils.getDefinitionManager(), definitionsRegistry, defSetId)); }
@PreDestroy public void destroy() { if (null != cache) { cache.clear(); cache = null; } }
@Override public Set<String> execute(final DomainLookupContext context) { final Set<String> labels = context.getDefinitionsRegistry().getLabels(sourceNodeDefId); return context.getCache() .getConnectionRules() .stream() .filter(rule -> rule.getRole().equals(edgeDefId)) .flatMap(rule -> rule.getPermittedConnections().stream()) .filter(pc -> labels.contains(pc.getStartRole())) .map(CanConnect.PermittedConnection::getEndRole) .collect(Collectors.toSet()); } }
@Test public void testCleanUp() { DefinitionsCacheRegistry definitionsRegistry = mock(DefinitionsCacheRegistry.class); when(definitionsRegistry.getLabels(eq(DEF_ID1))).thenReturn(Collections.singleton(ROLE1)); when(definitionsRegistry.getLabels(eq(DEF_ID2))).thenReturn(Collections.singleton(ROLE2)); DomainLookupsCache tested = new DomainLookupsCache(definitionManager, definitionsRegistry, DEF_SET_ID); assertEquals(1, tested.getDefinitions(ROLE1).size()); assertEquals(1, tested.getDefinitions(ROLE2).size()); tested.clear(); assertEquals(Collections.emptySet(), tested.getDefinitions(ROLE1)); assertEquals(Collections.emptySet(), tested.getDefinitions(ROLE2)); assertEquals(0, tested.getConnectionRules().size()); } }
@Before public void setup() throws Exception { final TestingGraphMockHandler graphTestHandler = new TestingGraphMockHandler(); graph = TestingGraphInstanceBuilder.newGraph1(graphTestHandler); TestingGraphInstanceBuilder.createDefaultRulesForGraph1(graphTestHandler.ruleSet); when(cacheBuilder.apply(anyString())).thenReturn(cache); when(cache.getRuleSet()).thenReturn(graphTestHandler.ruleSet); CanConnect connectionRule = (CanConnect) ((List<Rule>) graphTestHandler.ruleSet.getRules()).get(0); when(cache.getConnectionRules()).thenReturn(Collections.singletonList(connectionRule)); when(cache.getDefinitions(contains("label1"))).thenReturn(Stream.of(TestingGraphInstanceBuilder.DEF1_ID).collect(Collectors.toSet())); when(cache.getDefinitions(contains("label2"))).thenReturn(Stream.of(TestingGraphInstanceBuilder.DEF2_ID).collect(Collectors.toSet())); when(definitionsRegistry.getLabels(eq(TestingGraphInstanceBuilder.DEF1_ID))).thenReturn(TestingGraphInstanceBuilder.DEF1_LABELS); when(definitionsRegistry.getLabels(eq(TestingGraphInstanceBuilder.DEF2_ID))).thenReturn(TestingGraphInstanceBuilder.DEF2_LABELS); tested = new CommonDomainLookups(graphTestHandler.definitionUtils, definitionsRegistry, graphTestHandler.ruleManager, cacheBuilder) .setDomain("ds1"); }
@Override public Set<String> execute(final DomainLookupContext context) { final DomainLookupsCache cache = context.getCache(); final Set<String> labels = sourceNode.getLabels(); final Set<String> allowedTargetConnectors = context.getCache() .getConnectionRules() .stream() .filter(rule -> isSourceConnectionAllowed(rule, labels)) .map(CanConnect::getRole) .collect(Collectors.toSet()); final Set<String> result = new LinkedHashSet<>(); for (final String allowedConnector : allowedTargetConnectors) { final int outEdgeCount = countOutgoingEdges(context, sourceNode, allowedConnector); final RuleViolations outEdgeCardinalityResult = context.getRuleManager() .evaluate(cache.getRuleSet(), edgeCardinality(sourceNode.getLabels(), allowedConnector, outEdgeCount, EdgeCardinalityContext.Direction.OUTGOING, Optional.of(CardinalityContext.Operation.ADD))); if (isValid(outEdgeCardinalityResult)) { result.add(allowedConnector); } } return result; } }
@Override public Set<String> execute(final DomainLookupContext context) { final DomainLookupsCache cache = context.getCache(); return labels.stream() .flatMap(label -> cache.getDefinitions(label).stream()) .filter(definitionIdsAllowedFilter::test) .collect(Collectors.toSet()); } }
@Override public Set<String> execute(final DomainLookupContext context) { final DomainLookupsCache cache = context.getCache(); final Set<String> result = new LinkedHashSet<>(); for (final String definitionId : definitionIds) { final Set<String> labels = context.getDefinitionsRegistry().getLabels(definitionId); final RuleViolations violations = context.getRuleManager() .evaluate(cache.getRuleSet(), RuleContextBuilder.DomainContexts.edgeCardinality(labels, edgeId, 0, EdgeCardinalityContext.Direction.INCOMING, Optional.of(CardinalityContext.Operation.ADD))); if (isValid(violations)) { result.add(definitionId); } } return result; } }
private void registerDefinition(final DefinitionsCacheRegistry definitionsRegistry, final String id) { definitionsRegistry.getLabels(id).forEach(label -> registerDefinition(label, id)); }
DomainLookupsCache(final DefinitionManager definitionManager, final DefinitionsCacheRegistry definitionsRegistry, final String defSetId) { this.defSetId = defSetId; this.definitionsByLabel = new HashMap<>(200); final Object definitionSet = definitionManager.definitionSets().getDefinitionSetById(defSetId); this.ruleSet = definitionManager.adapters().forRules().getRuleSet(definitionSet); this.connectionRules = ruleSet.getRules() .stream() .map(DomainLookupsCache::isConnectionRule) .filter(Optional::isPresent) .map(Optional::get) .collect(Collectors.toList()); registerDefinitions(definitionManager, definitionsRegistry, definitionSet); }
@Test public void testGetDefinitionSetId() { assertEquals(DEF_SET_ID, tested.getDefinitionSetId()); }
@Before @SuppressWarnings("unchecked") public void setup() throws Exception { when(context.getRuleManager()).thenReturn(ruleManager); when(context.getCache()).thenReturn(cache); when(cache.getRuleSet()).thenReturn(RULE_SET); when(cache.getConnectionRules()).thenReturn(Collections.singletonList(permittedConnections)); when(context.getDefinitionsRegistry()).thenReturn(definitionsCache); TestingGraphMockHandler graphTestHandler = new TestingGraphMockHandler(); when(context.getDefinitionManager()).thenReturn(graphTestHandler.definitionManager); graph1Instance = TestingGraphInstanceBuilder.newGraph1(graphTestHandler); when(definitionsCache.getLabels(eq(DEF_ID1))).thenReturn(Collections.singleton(ROLE1)); when(definitionsCache.getLabels(eq(DEF_ID2))).thenReturn(Collections.singleton(ROLE2)); when(definitionsCache.getLabels(eq(DEF_ID3))).thenReturn(Collections.singleton(ROLE3)); }
@Test public void testGetDefinitionsByLabel() { assertEquals(Collections.emptySet(), tested.getDefinitions("SOMETHING_NOT_EXISTING")); Set<String> defs1 = tested.getDefinitions(ROLE1); assertEquals(1, defs1.size()); assertEquals(DEF_ID1, defs1.iterator().next()); Set<String> defs2 = tested.getDefinitions(ROLE2); assertEquals(1, defs2.size()); assertEquals(DEF_ID2, defs2.iterator().next()); }
@Override public Set<String> execute(final DomainLookupContext context) { final Set<String> ids = new LookupDefinitionsByLabels(labels, definitionIdsAllowedFilter).execute(context); final Map<String, Integer> graphLabelCount = GraphUtils.getLabelsCount(graph, labels); final Set<String> result = new LinkedHashSet<>(); for (final String defId : ids) { final Set<String> defLabels = context.getDefinitionsRegistry().getLabels(defId); for (final String label : defLabels) { final Integer roleCount = Optional.ofNullable(graphLabelCount.get(label)).orElse(0); final RuleViolations violations = context.getRuleManager() .evaluate(context.getCache().getRuleSet(), cardinality(Collections.singleton(label), roleCount, Optional.of(CardinalityContext.Operation.ADD))); if (isValid(violations)) { result.add(defId); } } } return result; } }
private void registerDefinitions(final DefinitionManager definitionManager, final DefinitionsCacheRegistry definitionsRegistry, final Object definitionSet) { definitionManager .adapters() .forDefinitionSet() .getDefinitions(definitionSet) .forEach(id -> registerDefinition(definitionsRegistry, id)); }
@Test @SuppressWarnings("unchecked") public void testLookupAllowedDefinitionsByLabelsWithFiltering() { when(cache.getDefinitions(eq("label1"))).thenReturn(Collections.singleton(TestingGraphInstanceBuilder.DEF1_ID)); when(definitionsCache.getLabels(eq(TestingGraphInstanceBuilder.DEF1_ID))) .thenReturn(TestingGraphInstanceBuilder.DEF1_LABELS); LookupAllowedDefinitionsByLabels function = new LookupAllowedDefinitionsByLabels(graph1Instance.graph, new HashSet<String>(1) {{ add("label1"); }}, DEF_ID2::equals); Set<String> result = function.execute(context); assertTrue(result.isEmpty()); }
@Test public void testCacheTheConnectionRules() { List<CanConnect> rules = tested.getConnectionRules(); assertEquals(1, rules.size()); assertEquals(canConnect1To2, rules.get(0)); }
@Override public Set<String> execute(final DomainLookupContext context) { final DomainLookupsCache cache = context.getCache(); final int outEdgeCount = countOutgoingEdges(context, sourceNode, edgeId); final RuleViolations outEdgeCardinalityResult = context.getRuleManager() .evaluate(cache.getRuleSet(), edgeCardinality(sourceNode.getLabels(), edgeId, outEdgeCount, EdgeCardinalityContext.Direction.OUTGOING, Optional.of(CardinalityContext.Operation.ADD))); if (isValid(outEdgeCardinalityResult)) { final String defId = context.getDefinitionManager() .adapters() .forDefinition() .getId(sourceNode.getContent().getDefinition()) .value(); return new LookupConnectionTargetRoles(edgeId, defId) .execute(context); } return Collections.emptySet(); } }
@Test public void testDestroy() { tested.setDomain("someDomain"); tested.destroy(); verify(cache, times(1)).clear(); assertNull(tested.getCache()); } }
@Before @SuppressWarnings("unchecked") public void setup() throws Exception { when(definitionManager.adapters()).thenReturn(adapterManager); when(adapterManager.forDefinitionSet()).thenReturn(definitionSetAdapter); when(adapterManager.forRules()).thenReturn(ruleAdapter); when(definitionManager.definitionSets()).thenReturn(definitionSetRegistry); when(definitionSetRegistry.getDefinitionSetById(eq(DEF_SET_ID))).thenReturn(definitionSet); when(ruleAdapter.getRuleSet(eq(definitionSet))).thenReturn(RULE_SET); when(definitionSetAdapter.getDefinitions(eq(definitionSet))).thenReturn(new HashSet<String>(2) {{ add(DEF_ID1); add(DEF_ID2); }}); when(definitionsRegistry.getLabels(eq(DEF_ID1))).thenReturn(Collections.singleton(ROLE1)); when(definitionsRegistry.getLabels(eq(DEF_ID2))).thenReturn(Collections.singleton(ROLE2)); tested = new DomainLookupsCache(definitionManager, definitionsRegistry, DEF_SET_ID); }