src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
ChangeSet { public boolean addChange(final Change change) { EhSupport.ensureArg(change != null, "Cannot add a null change"); return this.changes.add(change); } ChangeSet(final UUID id, final String name, final Set<Change> changes); UUID getId(); String getName(); Set<Change> getChanges(); boolean addChange(final Change change); boolean removeChange(final Change change); } | @Test public void addChange() { testConstruction(); final Set<RuleChange> ruleChanges = new HashSet<>(1); final Instant start = NOW.minus(Period.ofWeeks(-1)); final Instant end = start.plus(Period.ofWeeks(5)); final DateRange range = new DateRange(start, end); final InputDriver[] drivers = getInputDriverArray("Test1", "Test2", "Test3"); final Map<String, String> outputs = Collections.singletonMap("outputDriver", "result"); final DecisionTreeRule rule = new DecisionTreeRule(new UUID(0, 7), new UUID(0, 7), drivers, outputs, start, end); final RuleChange ruleChange = new RuleChange(Type.ORIGINAL, rule); ruleChanges.add(ruleChange); final Set<ValueGroupChange> valueGroupChanges = new HashSet<>(); final List<String> valueGroupDrivers = getValueGroupsDrivers("Test1", "Test2", "Test3"); final ValueGroup valueGroup = new ValueGroup(new UUID(0, 8), "TestValueGroup", valueGroupDrivers, range); final ValueGroupChange valueGroupChange = new ValueGroupChange(Type.NEW, valueGroup); valueGroupChanges.add(valueGroupChange); final Instant initiatorTime = NOW; final Instant authoriserTime = initiatorTime.plus(Period.ofWeeks(1)); final Audit audit = new Audit("User1", initiatorTime, "User2", authoriserTime); final Change change = new Change(ADDED_CHANGE_ID, "TEST-RULESET", NOW, CHANGE_RANGE, audit, ruleChanges, valueGroupChanges); getBean().addChange(change); assertThat(getBean().getChanges(), hasSize(2)); assertThat(getBean().getChanges(), hasItem(change)); }
@Test(expected = IllegalArgumentException.class) public void cannotAddNullChange() { testConstruction(); getBean().addChange(null); } |
OutputResults { public Map<String, String> results() { return this.rule.getOutputs(); } OutputResults(final DecisionTreeRule rule); Map<String, String> results(); } | @Test public void testConstruction() { final Map<String, String> outputDriver = Collections.singletonMap("outputDriver", "result"); final DecisionTreeRule decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), null, outputDriver, Instant.now(), Instant.now()); final OutputResults results = new OutputResults(decisionTreeRule); Assert.assertEquals(outputDriver, results.results()); } |
GroupEvaluation implements Predicate<String> { @Override public boolean test(final String input) { if (this.group.contains(input)) { return true; } for (final InputDriver driver : this.drivers) { if (driver.evaluate(input)) { return true; } } return false; } GroupEvaluation(final String value, final List<InputDriver> inputDrivers); void setSubValues(final List<InputDriver> inputDrivers); @Override boolean test(final String input); @Override boolean equals(final Object other); @Override int hashCode(); } | @Test public void testEvaluation() { final GroupEvaluation groupEvaluation = new GroupEvaluation("TestGroup", GroupDriverTest.createSubInputDrivers("test")); assertTrue(groupEvaluation.test("test1")); assertTrue(groupEvaluation.test("test2")); assertTrue(groupEvaluation.test("test3")); assertTrue(groupEvaluation.test("test4")); assertFalse(groupEvaluation.test("test5")); assertFalse(groupEvaluation.test("TestGroup")); } |
GroupEvaluation implements Predicate<String> { @Override public int hashCode() { return this.value.hashCode(); } GroupEvaluation(final String value, final List<InputDriver> inputDrivers); void setSubValues(final List<InputDriver> inputDrivers); @Override boolean test(final String input); @Override boolean equals(final Object other); @Override int hashCode(); } | @Test public void hashCodeValue() { final GroupEvaluation driver = new GroupEvaluation("Test1", Arrays.asList(new StringDriver("test"))); final GroupEvaluation other = new GroupEvaluation("Test1", Arrays.asList(new StringDriver("test"))); assertTrue(driver.hashCode() == other.hashCode()); } |
GroupEvaluation implements Predicate<String> { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null || getClass() != other.getClass()) { return false; } return this.value.equals(((GroupEvaluation) other).value); } GroupEvaluation(final String value, final List<InputDriver> inputDrivers); void setSubValues(final List<InputDriver> inputDrivers); @Override boolean test(final String input); @Override boolean equals(final Object other); @Override int hashCode(); } | @Test public void equalsCorrect() { final GroupEvaluation driver = new GroupEvaluation("Test1", Arrays.asList(new StringDriver("test"))); assertTrue(driver.equals(driver)); assertFalse(driver.equals(null)); assertFalse(driver.equals(Boolean.TRUE)); GroupEvaluation other = new GroupEvaluation("Test1", Arrays.asList(new StringDriver("test"))); assertTrue(driver.equals(other)); other = new GroupEvaluation("Test10", Arrays.asList(new StringDriver("test"))); assertFalse(driver.equals(other)); } |
TimeSlicedRootNode implements TreeNode { Optional<DecisionTreeRuleSet> getSlicedRuleSet(final Instant time) { final Map<UUID, DecisionTreeRule> ruleMap = new HashMap<>(); final Optional<Range<Instant>> activeRange = getActiveRange(time); if (activeRange.isPresent()) { ruleSet.getRules().forEach((ruleId, rule) -> { if (PREDICATE_RULE_START_CHECK.test(activeRange.get().getStart(), rule.getStart()) && PREDICATE_RULE_END_CHECK.test(activeRange.get().getFinish(), rule.getEnd())) { ruleMap.put(ruleId, rule); } }); return Optional.of(new DecisionTreeRuleSet(ruleSet.getName(), ruleMap, ruleSet.getDriverNames(), Collections.emptyList(), ruleSet.getDriverCache(), ruleSet.getValueGroups())); } return Optional.empty(); } TimeSlicedRootNode(final DecisionTreeRuleSet ruleSet); @Override Stream<TreeNode> stream(); @Override boolean evaluate(final String input); @Override List<TreeNode> getEvaluatedNodes(final List<String> inputs, final Instant time); @Override List<TreeNode> getEvaluatedNodesWithWildcards(final List<String> inputs, final Instant time); @Override Optional<TreeNode> getExactNode(final TreeNode inputValue); @Override TreeNode addNode(final TreeNode newNode); @Override InputValueType getDriverType(); @Override String getValue(); @Override InputDriver getDriver(); @Override Range<Instant> getDateRange(); } | @Test public void testGeneratingSlicedRuleSets() { final DecisionTreeRuleSet ruleSet = CommisionRuleSetSupplier.getSlicedRuleSet().build(); final TimeSlicedRootNode timeSlicedRootNode = (TimeSlicedRootNode) NodeSupplier.createTimeSlicedRootNode(ruleSet).get(); assertNotNull(timeSlicedRootNode); final Optional<DecisionTreeRuleSet> slicedRuleSet = timeSlicedRootNode.getSlicedRuleSet( Instant.parse("2013-03-28T01:00:00Z")); assertTrue(slicedRuleSet.isPresent()); assertNotNull(slicedRuleSet.get().getRules()); assertEquals(Integer.valueOf(2), Integer.valueOf(slicedRuleSet.get().getRules().size())); } |
TimeSlicedRootNode implements TreeNode { @Override public List<TreeNode> getEvaluatedNodes(final List<String> inputs, final Instant time) { EhSupport.ensureArg(time != null, "Time sliced decision tree has %s time", time); final Optional<TreeNode> rootSlicedNode = getTreeNodeForTime(time); EhSupport.ensure(rootSlicedNode.isPresent(), "No slice node found"); return rootSlicedNode.get().getEvaluatedNodes(inputs, time); } TimeSlicedRootNode(final DecisionTreeRuleSet ruleSet); @Override Stream<TreeNode> stream(); @Override boolean evaluate(final String input); @Override List<TreeNode> getEvaluatedNodes(final List<String> inputs, final Instant time); @Override List<TreeNode> getEvaluatedNodesWithWildcards(final List<String> inputs, final Instant time); @Override Optional<TreeNode> getExactNode(final TreeNode inputValue); @Override TreeNode addNode(final TreeNode newNode); @Override InputValueType getDriverType(); @Override String getValue(); @Override InputDriver getDriver(); @Override Range<Instant> getDateRange(); } | @Test(expected = IllegalArgumentException.class) public void throwsIllegalArgumentException() { final TreeNode node = NodeSupplier.createTimeSlicedRootNode(null).get(); node.getEvaluatedNodes(null, null); } |
TimeSlicedRootNode implements TreeNode { Optional<TreeNode> getTreeNodeForTime(final Instant time) { Optional<Range<Instant>> activeRange = Optional.empty(); for (final Range<Instant> range : cache.keys()) { if (Range.RANGE_CHECK.test(range, time)) { activeRange = Optional.of(range); break; } } if (activeRange.isPresent()) { return cache.get(activeRange); } Optional<TreeNode> rootSlicedNode = Optional.empty(); activeRange = getActiveRange(time); final Optional<DecisionTreeRuleSet> decisionTreeRuleSet = getSlicedRuleSet(time); if (decisionTreeRuleSet.isPresent()) { final TreeNode newNode = DecisionTreeFactory.constructDecisionTree(decisionTreeRuleSet.get(), DecisionTreeType.SINGLE); rootSlicedNode = Optional.of(newNode); cache.put(activeRange.get(), rootSlicedNode); } return rootSlicedNode; } TimeSlicedRootNode(final DecisionTreeRuleSet ruleSet); @Override Stream<TreeNode> stream(); @Override boolean evaluate(final String input); @Override List<TreeNode> getEvaluatedNodes(final List<String> inputs, final Instant time); @Override List<TreeNode> getEvaluatedNodesWithWildcards(final List<String> inputs, final Instant time); @Override Optional<TreeNode> getExactNode(final TreeNode inputValue); @Override TreeNode addNode(final TreeNode newNode); @Override InputValueType getDriverType(); @Override String getValue(); @Override InputDriver getDriver(); @Override Range<Instant> getDateRange(); } | @Test public void constructsTreeFromRule() { final Builder<RuleSetBuilder, DecisionTreeRuleSet> ruleSetBuilder = RuleSetBuilder.creator(Arrays.asList("EXMETHOD", "EXCHANGE", "PRODUCT", "REGION", "ASSET")); CommisionRuleSetSupplier.addRule(ruleSetBuilder, "VOICE", "CME", "ED", "APAC", "INDEX", NOW, NOW.plus(Period.ofWeeks(2)), 1L, "1.9"); CommisionRuleSetSupplier.addRule(ruleSetBuilder, "EMAIL", "S&P", "ED", "US", "INDEX", NOW.plus(Period.ofWeeks(4)), NOW.plus(Period.ofWeeks(6)), 2L, "2.1"); CommisionRuleSetSupplier.addRule(ruleSetBuilder, "ELECTRONIC", "CBOT", "EB", "UK", "INDEX", NOW.plus(Period.ofWeeks(2)), NOW.plus(Period.ofWeeks(4)), 3L, "1.1"); final DecisionTreeRuleSet ruleSet = ruleSetBuilder.build(); final TimeSlicedRootNode slicedRoodNode = (TimeSlicedRootNode) DecisionTreeFactory.constructDecisionTree( ruleSet, DecisionTreeType.SLICED); assertNotNull(slicedRoodNode); final TreeNode root = slicedRoodNode.getTreeNodeForTime(NOW.plus(Period.ofWeeks(2))).get(); assertNotNull(root); List<TreeNode> treeNodes = assertAndGetChildNodes(root, 1); BaseTreeNode treeNode = (BaseTreeNode) treeNodes.get(0); checkNodeValue(treeNode, "ELECTRONIC", 1); treeNodes = assertAndGetChildNodes(treeNode, 1); treeNode = (BaseTreeNode) treeNodes.get(0); checkNodeValue(treeNode, "CBOT", 2); treeNodes = assertAndGetChildNodes(treeNode, 1); treeNode = (BaseTreeNode) treeNodes.get(0); checkNodeValue(treeNode, "EB", 3); treeNodes = assertAndGetChildNodes(treeNode, 1); treeNode = (BaseTreeNode) treeNodes.get(0); checkNodeValue(treeNode, "UK", 4); treeNodes = assertAndGetChildNodes(treeNode, 1); treeNode = (BaseTreeNode) treeNodes.get(0); checkNodeValue(treeNode, "INDEX", 5); final ResultNode resultNode = (ResultNode) treeNodes.get(0); assertEquals(new UUID(0, 3L), resultNode.getRuleIdentifier()); assertEquals(31L, resultNode.getWeight()); }
@Test public void testTreeWithSameRuleDates() { final Builder<RuleSetBuilder, DecisionTreeRuleSet> ruleSetBuilder = RuleSetBuilder.creator(Arrays.asList("EXMETHOD", "EXCHANGE", "PRODUCT", "REGION", "ASSET")); CommisionRuleSetSupplier.addRule(ruleSetBuilder, "VOICE", "CME", "ED", "APAC", "INDEX", NOW, NOW.plus(Period.ofWeeks(5)), 1L, "2.1"); CommisionRuleSetSupplier.addRule(ruleSetBuilder, "EMAIL", "S&P", "ED", "US", "INDEX", NOW, NOW.plus(Period.ofWeeks(5)), 2L, "2.1"); CommisionRuleSetSupplier.addRule(ruleSetBuilder, "ELECTRONIC", "CBOT", "EB", "UK", "INDEX", NOW, NOW.plus(Period.ofWeeks(5)), 3L, "1.1"); final DecisionTreeRuleSet ruleSet = ruleSetBuilder.build(); final TimeSlicedRootNode slicedRoodNode = (TimeSlicedRootNode) DecisionTreeFactory.constructDecisionTree( ruleSet, DecisionTreeType.SLICED); assertNotNull(slicedRoodNode); final Optional<TreeNode> root = slicedRoodNode.getTreeNodeForTime(NOW.minus(Period.ofWeeks(1))); assertFalse(root.isPresent()); } |
ResultNode extends BaseTreeNode implements EvaluationResult, TreeNode { @Override public boolean equals(final Object other) { return false; } ResultNode(final InputDriver driver,
final int driverLevel,
final DecisionTreeRule rule,
final TreeNode delegate); @Override boolean equals(final Object other); @Override int hashCode(); @Override Range<Instant> getDateRange(); @Override UUID getRuleIdentifier(); @Override long getWeight(); @Override Optional<InputDriver[]> getEvaluations(); } | @Test public void equalsCorrect() { final TreeNode treeNode = NodeSupplier.createResultTreeNode( createGroupDriver("CMEGroup"), NodeSupplier.ROOT_NODE_LEVEL, getRule()).get(); assertFalse(treeNode.equals(treeNode)); } |
ResultNode extends BaseTreeNode implements EvaluationResult, TreeNode { @Override public int hashCode() { return super.hashCode() + Objects.hashCode(this.range); } ResultNode(final InputDriver driver,
final int driverLevel,
final DecisionTreeRule rule,
final TreeNode delegate); @Override boolean equals(final Object other); @Override int hashCode(); @Override Range<Instant> getDateRange(); @Override UUID getRuleIdentifier(); @Override long getWeight(); @Override Optional<InputDriver[]> getEvaluations(); } | @Test public void hashCodeCorrect() { final TreeNode treeNode = NodeSupplier.createDatedResultTreeNode( createGroupDriver("CMEGroup"), NodeSupplier.ROOT_NODE_LEVEL, getRule()).get(); final TreeNode otherNode = NodeSupplier.createDatedResultTreeNode( createGroupDriver("CMEGroup"), NodeSupplier.ROOT_NODE_LEVEL, getRule()).get(); assertEquals(treeNode.hashCode(), otherNode.hashCode()); }
@Test public void hashCodeDatedTreeNodeCorrect() { final TreeNode treeNode = NodeSupplier.createResultTreeNode( createGroupDriver("CMEGroup"), NodeSupplier.ROOT_NODE_LEVEL, getRule()).get(); final TreeNode otherNode = NodeSupplier.createResultTreeNode( createGroupDriver("CMEGroup"), NodeSupplier.ROOT_NODE_LEVEL, getRule()).get(); assertEquals(treeNode.hashCode(), otherNode.hashCode()); } |
DatedTreeNode extends BaseTreeNode { @Override public boolean equals(final Object obj) { if (!(super.equals(obj))) { return false; } final Range<Instant> other = ((BaseTreeNode) obj).getDateRange(); return Objects.equals(this.range, other) || inRange(other.getStart(), this.range) || inRange(other.getFinish(), this.range); } DatedTreeNode(final InputDriver driver, final int level, final Range<Instant> dateRange); @Override boolean equals(final Object obj); @Override int hashCode(); @Override Range<Instant> getDateRange(); @Override void setDateRange(final Range<Instant> range); @Override Optional<TreeNode> getExactNode(final TreeNode inputValue); @Override TreeNode addNode(final TreeNode newNode); @Override List<TreeNode> getEvaluatedNodes(final List<String> inputs, final Instant time); } | @Test public void equalsCorrect() { final Instant start = NOW.minus(Period.ofWeeks(5)); final Instant end = NOW.plus(Period.ofWeeks(5)); final TreeNode node = createDatedTreeNode("Test1", start, end); TreeNode other = createDatedTreeNode("Test1", start, end); assertTrue(node.equals(other)); other = createDatedTreeNode("Test1", start, Instant.MAX); assertTrue(node.equals(other)); other = createDatedTreeNode("Test1", NOW, Instant.MAX); assertTrue(node.equals(other)); other = createDatedTreeNode("Test1", end, Instant.MAX); assertTrue(node.equals(other)); other = createDatedTreeNode("Test1", Instant.MIN, start); assertTrue(node.equals(other)); other = createDatedTreeNode("Test1", Instant.MIN, NOW); assertTrue(node.equals(other)); other = createDatedTreeNode("Test1", Instant.MIN, end); assertTrue(node.equals(other)); other = createDatedTreeNode("Test1", Instant.MIN, Instant.MAX); assertFalse(node.equals(other)); } |
DatedTreeNode extends BaseTreeNode { @Override public int hashCode() { return super.hashCode() + this.range.hashCode(); } DatedTreeNode(final InputDriver driver, final int level, final Range<Instant> dateRange); @Override boolean equals(final Object obj); @Override int hashCode(); @Override Range<Instant> getDateRange(); @Override void setDateRange(final Range<Instant> range); @Override Optional<TreeNode> getExactNode(final TreeNode inputValue); @Override TreeNode addNode(final TreeNode newNode); @Override List<TreeNode> getEvaluatedNodes(final List<String> inputs, final Instant time); } | @Test public void hashCodeCorrect() { TreeNode node = createDatedTreeNode("Test1", Instant.MIN, Instant.MAX); assertEquals(node.hashCode(), createDatedTreeNode("Test1", Instant.MIN, Instant.MAX).hashCode()); node = createDatedTreeNode("Test1", null, Instant.MAX); assertEquals(node.hashCode(), createDatedTreeNode("Test1", null, Instant.MAX).hashCode()); node = createDatedTreeNode("Test1", Instant.MIN, null); assertEquals(node.hashCode(), createDatedTreeNode("Test1", Instant.MIN, null).hashCode()); } |
StringEvaluation implements Predicate<String> { @Override public int hashCode() { return this.value.hashCode(); } StringEvaluation(final String value); @Override boolean test(final String input); @Override boolean equals(final Object other); @Override int hashCode(); } | @Test public void hashCodeValue() { final StringEvaluation driver = new StringEvaluation("Test1"); assertEquals(new StringEvaluation("Test1").hashCode(), driver.hashCode()); } |
StringEvaluation implements Predicate<String> { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null || getClass() != other.getClass()) { return false; } return this.value.equals(((StringEvaluation) other).value); } StringEvaluation(final String value); @Override boolean test(final String input); @Override boolean equals(final Object other); @Override int hashCode(); } | @Test public void equalsCorrect() { final StringEvaluation driver = new StringEvaluation("Test1"); assertTrue(driver.equals(driver)); assertFalse(driver.equals(null)); assertFalse(driver.equals(new Integer(1))); StringEvaluation other = new StringEvaluation("Test1"); assertTrue(driver.equals(other)); other = new StringEvaluation("Test3"); assertFalse(driver.equals(other)); final RegExEvaluation regExEvaluation = new RegExEvaluation("Test1"); assertFalse(driver.equals(regExEvaluation)); } |
DatedNodeKey { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } final DatedNodeKey otherKey = (DatedNodeKey) other; return Objects.equals(getValue(), otherKey.getValue()) && Objects.equals(getRange(), otherKey.getRange()); } DatedNodeKey(final String value, final Range<Instant> range); Range<Instant> getRange(); String getValue(); @Override boolean equals(final Object other); @Override int hashCode(); } | @Test public void equalsCorrect() { DatedNodeKey key = new DatedNodeKey("test1", new Range<>(DecisionTreeRule.EPOCH, DecisionTreeRule.MAX)); final DatedNodeKey sameKey = new DatedNodeKey("test1", new Range<>(DecisionTreeRule.EPOCH, DecisionTreeRule.MAX)); assertTrue(key.equals(key)); assertTrue(key.equals(sameKey)); assertFalse(key.equals(null)); assertFalse(key.equals(new Integer(1))); DatedNodeKey otherKeyValue = new DatedNodeKey("test2", new Range<>(DecisionTreeRule.EPOCH, DecisionTreeRule.MAX)); assertFalse(key.equals(otherKeyValue)); otherKeyValue = new DatedNodeKey("test1", new Range<>(Instant.now(), DecisionTreeRule.MAX)); assertFalse(key.equals(otherKeyValue)); otherKeyValue = new DatedNodeKey("test1", new Range<>(DecisionTreeRule.EPOCH, Instant.now())); assertFalse(key.equals(otherKeyValue)); otherKeyValue = new DatedNodeKey("test1", new Range<>(DecisionTreeRule.EPOCH, null)); assertFalse(key.equals(otherKeyValue)); otherKeyValue = new DatedNodeKey("test1", new Range<>(null, DecisionTreeRule.MAX)); assertFalse(key.equals(otherKeyValue)); otherKeyValue = new DatedNodeKey("test1", null); assertFalse(key.equals(otherKeyValue)); key = new DatedNodeKey("test1", null); assertTrue(key.equals(otherKeyValue)); otherKeyValue = new DatedNodeKey("test2", new Range<>(DecisionTreeRule.EPOCH, DecisionTreeRule.MAX)); assertFalse(key.equals(otherKeyValue)); } |
DatedNodeKey { @Override public int hashCode() { return getValue().hashCode() + getRange().hashCode(); } DatedNodeKey(final String value, final Range<Instant> range); Range<Instant> getRange(); String getValue(); @Override boolean equals(final Object other); @Override int hashCode(); } | @Test public void hashCodeCorrect() { final DatedNodeKey key = new DatedNodeKey("test1", new Range<>(DecisionTreeRule.EPOCH, DecisionTreeRule.MAX)); final DatedNodeKey other = new DatedNodeKey("test1", new Range<>(DecisionTreeRule.EPOCH, DecisionTreeRule.MAX)); assertEquals(key.hashCode(), other.hashCode()); } |
GroupDriver extends InputDriver { @Override public int hashCode() { return super.hashCode(); } GroupDriver(final String value, final List<InputDriver> inputDrivers); static void convertDriversIntoDriversAndGroups(final List<InputDriver> originalDrivers,
final List<String> drivers,
final List<String> groups); InputDriver[] getSubDrivers(final boolean recurse); List<String> convertDrivers(); void setSubValues(final List<InputDriver> subValues); @Override String toString(); @Override boolean equals(final Object other); @Override int hashCode(); static final String VG_PREFIX; } | @Test public void hashCodeValue() { final InputDriver driver = createInputDriver("Test1", "test"); assertEquals(80698815, driver.hashCode()); } |
GroupDriver extends InputDriver { static List<InputDriver> getSubInputDrivers(final List<InputDriver> originalDrivers, final boolean recurse) { final Set<InputDriver> allDrivers = new HashSet<>(originalDrivers); for (final InputDriver driver : originalDrivers) { if (recurse && InputValueType.VALUE_GROUP.equals(driver.getType())) { getSubInputDrivers(((GroupDriver) driver).originalDrivers, allDrivers); } } return new ArrayList<>(allDrivers); } GroupDriver(final String value, final List<InputDriver> inputDrivers); static void convertDriversIntoDriversAndGroups(final List<InputDriver> originalDrivers,
final List<String> drivers,
final List<String> groups); InputDriver[] getSubDrivers(final boolean recurse); List<String> convertDrivers(); void setSubValues(final List<InputDriver> subValues); @Override String toString(); @Override boolean equals(final Object other); @Override int hashCode(); static final String VG_PREFIX; } | @Test public void testOnlyStoreUniqueDrivers() { final List<InputDriver> subDriverList = createSubInputDrivers("test"); final List<InputDriver> duplicateSubDriverList = createSubInputDrivers("test"); final InputDriver dupDriver = new GroupDriver("dup1", duplicateSubDriverList); subDriverList.add(dupDriver); final InputDriver subDriver = new GroupDriver("sub1", subDriverList); final List<InputDriver> drivers = Collections.singletonList(subDriver); final List<InputDriver> inputs = GroupDriver.getSubInputDrivers(drivers, true); assertNotNull(inputs); assertEquals(6, inputs.size()); inputs.forEach(input -> assertThat(1, Matchers.equalTo(Collections.frequency(inputs, input)))); }
@Test public void testSameNameOfValueGroupAsStringInGroup() { final List<InputDriver> subDriverList = createSubInputDrivers("test"); subDriverList.add(new StringDriver("test")); final GroupDriver group = new GroupDriver("test", subDriverList); assertNotNull(group); assertTrue(group.evaluate("test")); final List<InputDriver> inputs = GroupDriver.getSubInputDrivers(subDriverList, true); assertNotNull(inputs); } |
GroupDriver extends InputDriver { public InputDriver[] getSubDrivers(final boolean recurse) { final List<InputDriver> allDrivers = getSubInputDrivers(this.originalDrivers, recurse); return allDrivers.toArray(new InputDriver[allDrivers.size()]); } GroupDriver(final String value, final List<InputDriver> inputDrivers); static void convertDriversIntoDriversAndGroups(final List<InputDriver> originalDrivers,
final List<String> drivers,
final List<String> groups); InputDriver[] getSubDrivers(final boolean recurse); List<String> convertDrivers(); void setSubValues(final List<InputDriver> subValues); @Override String toString(); @Override boolean equals(final Object other); @Override int hashCode(); static final String VG_PREFIX; } | @Test public void testGetSubDrivers() { final List<InputDriver> subDriverList = createSubInputDrivers("test"); final List<InputDriver> sub2DriverList = createSubInputDrivers("subtest"); final InputDriver sub2Driver = new GroupDriver("sub2", sub2DriverList); subDriverList.add(sub2Driver); final InputDriver subDriver = new GroupDriver("sub1", subDriverList); final List<InputDriver> drivers = Collections.singletonList(subDriver); final GroupDriver group = new GroupDriver("group", drivers); assertNotNull(group); InputDriver[] inputs = group.getSubDrivers(false); assertNotNull(inputs); assertArrayEquals(new InputDriver[]{subDriver}, inputs); inputs = ((GroupDriver) subDriver).getSubDrivers(false); assertNotNull(inputs); assertThat(subDriverList, IsCollectionContaining.hasItems(inputs)); final List<InputDriver> everyDriver = new ArrayList<>(drivers); everyDriver.addAll(sub2DriverList); everyDriver.addAll(subDriverList); inputs = group.getSubDrivers(true); assertNotNull(inputs); assertThat(everyDriver, IsCollectionContaining.hasItems(inputs)); } |
ChangeSet { public boolean removeChange(final Change change) { return this.changes.remove(change); } ChangeSet(final UUID id, final String name, final Set<Change> changes); UUID getId(); String getName(); Set<Change> getChanges(); boolean addChange(final Change change); boolean removeChange(final Change change); } | @Test public void removeChange() { addChange(); final Audit audit = new Audit("User1", null, "User2", null); Change change = new Change(new UUID(0, 6), "TEST-RULESET", NOW, CHANGE_RANGE, audit, Collections.emptySet(), Collections.emptySet()); getBean().removeChange(change); assertThat(getBean().getChanges(), hasSize(2)); change = new Change(ADDED_CHANGE_ID, "TEST-RULESET", NOW, CHANGE_RANGE, audit, Collections.emptySet(), Collections.emptySet()); getBean().removeChange(change); assertThat(getBean().getChanges(), hasSize(1)); } |
GroupDriver extends InputDriver { @Override public boolean equals(final Object other) { return super.equals(other); } GroupDriver(final String value, final List<InputDriver> inputDrivers); static void convertDriversIntoDriversAndGroups(final List<InputDriver> originalDrivers,
final List<String> drivers,
final List<String> groups); InputDriver[] getSubDrivers(final boolean recurse); List<String> convertDrivers(); void setSubValues(final List<InputDriver> subValues); @Override String toString(); @Override boolean equals(final Object other); @Override int hashCode(); static final String VG_PREFIX; } | @Test public void driverEquals() { final InputDriver driver = createInputDriver("Test1", "test"); assertTrue(driver.equals(driver)); assertFalse(driver.equals(null)); assertFalse(driver.equals(new Integer(1))); InputDriver other = createInputDriver("Test1", "test"); assertTrue(driver.equals(other)); other = createInputDriver("Feast", "test"); assertFalse(driver.equals(other)); other = new RegexDriver("Test1"); assertFalse(driver.equals(other)); } |
RegExEvaluation implements Predicate<String> { @Override public boolean test(final String input) { return this.pattern.matcher(input).matches(); } RegExEvaluation(final String value); @Override boolean test(final String input); @Override boolean equals(final Object other); @Override int hashCode(); } | @Test public void evaluation() { final RegExEvaluation driver = new RegExEvaluation("Te.?t1"); assertTrue(driver.test("Test1")); assertFalse(driver.test("Fest1")); } |
RegExEvaluation implements Predicate<String> { @Override public int hashCode() { return this.pattern.toString().hashCode(); } RegExEvaluation(final String value); @Override boolean test(final String input); @Override boolean equals(final Object other); @Override int hashCode(); } | @Test public void hashCodeValue() { final RegExEvaluation driver = new RegExEvaluation("Te.?t1"); assertEquals(new RegExEvaluation("Te.?t1").hashCode(), driver.hashCode()); } |
RegExEvaluation implements Predicate<String> { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null || getClass() != other.getClass()) { return false; } return this.pattern.toString().equals(((RegExEvaluation) other).pattern.toString()); } RegExEvaluation(final String value); @Override boolean test(final String input); @Override boolean equals(final Object other); @Override int hashCode(); } | @Test public void driverEquals() { final RegExEvaluation driver = new RegExEvaluation("Te.?t1"); assertEquals(new RegExEvaluation("Te.?t1"), driver); assertTrue(driver.equals(driver)); assertFalse(driver.equals(null)); assertFalse(driver.equals("Te.?t1")); } |
WeightedDriver implements Comparable<WeightedDriver> { public String getName() { return this.name; } WeightedDriver(final String name, final int weight); String getName(); int getWeight(); @Override int compareTo(final WeightedDriver other); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); } | @Test public void testOrdering() { final WeightedDriver test1 = new WeightedDriver("TestName1", 1); final WeightedDriver test2 = new WeightedDriver("TestName2", 2); final WeightedDriver test3 = new WeightedDriver("TestName3", 3); final SortedSet<WeightedDriver> weights = new TreeSet<>(); weights.add(test2); weights.add(test1); weights.add(test3); final Iterator<WeightedDriver> iterator = weights.iterator(); assertEquals("TestName3", iterator.next().getName()); assertEquals("TestName2", iterator.next().getName()); assertEquals("TestName1", iterator.next().getName()); } |
DecisionTreeRule implements TreeRule { public boolean isActiveAt(final Instant time) { return time.isAfter(this.start) && time.isBefore(this.end); } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers,
final InputDriver[] evaluations, final Map<String, String> outputs,
final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers,
final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final int INITIAL_WEIGHTED_VALUE; static final Instant EPOCH; static final Instant MAX; } | @Test public void testIsActiveWithinDateRange() { final Instant startInstance = Instant.now().minus(1, ChronoUnit.DAYS); final Instant endInstance = startInstance.plus(2, ChronoUnit.DAYS); final DecisionTreeRule decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, startInstance, endInstance); assertTrue(decisionTreeRule.isActiveAt(Instant.now())); Assert.assertFalse(decisionTreeRule.isActiveAt(Instant.now().minus(2, ChronoUnit.DAYS))); Assert.assertFalse(decisionTreeRule.isActiveAt(Instant.now().plus(2, ChronoUnit.DAYS))); } |
DecisionTreeRule implements TreeRule { public long getRuleWeight() { long weight = 0; long weightedLevel = INITIAL_WEIGHTED_VALUE; for (int i = drivers.length - 1; i >= 0; i--) { if (!InputValueType.WILDCARD.equals(drivers[i].getValue())) { weight += weightedLevel; } weightedLevel = weightedLevel * 2; } return weight; } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers,
final InputDriver[] evaluations, final Map<String, String> outputs,
final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers,
final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final int INITIAL_WEIGHTED_VALUE; static final Instant EPOCH; static final Instant MAX; } | @Test public void testWeightedCalculations() { DecisionTreeRule decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1"), this.outputDriver, null, null); assertEquals(1, decisionTreeRule.getRuleWeight()); decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, null, null); assertEquals(3, decisionTreeRule.getRuleWeight()); decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "*"), this.outputDriver, null, null); assertEquals(2, decisionTreeRule.getRuleWeight()); decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2", "input3"), this.outputDriver, null, null); assertEquals(7, decisionTreeRule.getRuleWeight()); decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "*", "input3"), this.outputDriver, null, null); assertEquals(5, decisionTreeRule.getRuleWeight()); decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("*", "*", "*"), this.outputDriver, null, null); assertEquals(0, decisionTreeRule.getRuleWeight()); decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "*", "*", "*"), this.outputDriver, null, null); assertEquals(8, decisionTreeRule.getRuleWeight()); } |
DecisionTreeRule implements TreeRule { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null || getClass() != other.getClass()) { return false; } final DecisionTreeRule otherRule = (DecisionTreeRule) other; return ruleIdentifier.equals(otherRule.ruleIdentifier); } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers,
final InputDriver[] evaluations, final Map<String, String> outputs,
final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers,
final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final int INITIAL_WEIGHTED_VALUE; static final Instant EPOCH; static final Instant MAX; } | @Test public void testEquals() { final DecisionTreeRule decisionTreeRule1 = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, null, null); assertFalse(decisionTreeRule1.equals(null)); assertFalse(decisionTreeRule1.equals(new Integer(1))); assertTrue(decisionTreeRule1.equals(decisionTreeRule1)); assertTrue(decisionTreeRule1.equals(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, null, null))); assertTrue(decisionTreeRule1.equals(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input2", "input3"), this.outputDriver, null, null))); assertFalse(decisionTreeRule1.equals(new DecisionTreeRule(new UUID(0, 2), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, null, null))); } |
DecisionTreeRule implements TreeRule { @Override public int hashCode() { return ruleIdentifier.hashCode(); } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers,
final InputDriver[] evaluations, final Map<String, String> outputs,
final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers,
final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final int INITIAL_WEIGHTED_VALUE; static final Instant EPOCH; static final Instant MAX; } | @Test public void hashCodeCorrect() { final DecisionTreeRule rule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, null, null); final DecisionTreeRule other = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, null, null); assertTrue(rule.hashCode() == other.hashCode()); } |
UserLookUp { public boolean checkUsernameUniqueness( String username, boolean isEncrypted, RequestContext context) { List<Map<String, Object>> userMapList = getRecordByType(JsonKey.USER_LOOKUP_FILED_USER_NAME, username, !isEncrypted, context); if (CollectionUtils.isNotEmpty(userMapList)) { return false; } return true; } Response insertRecords(List<Map<String, Object>> reqMap, RequestContext context); void deleteRecords(List<Map<String, String>> reqMap, RequestContext context); Response insertExternalIdIntoUserLookup(
List<Map<String, Object>> reqMap, String userId, RequestContext context); List<Map<String, Object>> getRecordByType(
String type, String value, boolean encrypt, RequestContext context); List<Map<String, Object>> getEmailByType(String email, RequestContext context); void checkEmailUniqueness(String email, RequestContext context); void checkEmailUniqueness(User user, String opType, RequestContext context); List<Map<String, Object>> getPhoneByType(String phone, RequestContext context); void checkPhoneUniqueness(String phone, RequestContext context); void checkPhoneUniqueness(User user, String opType, RequestContext context); boolean checkUsernameUniqueness(
String username, boolean isEncrypted, RequestContext context); void checkExternalIdUniqueness(User user, String operation, RequestContext context); } | @Test public void checkUsernameUniqueness() throws Exception { boolean response = new UserLookUp().checkUsernameUniqueness("userName", true, null); assertFalse(response); } |
ElasticSearchRestHighImpl implements ElasticSearchService { @Override public Future<Boolean> delete(String index, String identifier, RequestContext context) { long startTime = System.currentTimeMillis(); logger.info(context, "ElasticSearchRestHighImpl:delete: method started at ==" + startTime); Promise<Boolean> promise = Futures.promise(); if (StringUtils.isNotEmpty(identifier) && StringUtils.isNotEmpty(index)) { DeleteRequest delRequest = new DeleteRequest(index, _DOC, identifier); ActionListener<DeleteResponse> listener = new ActionListener<DeleteResponse>() { @Override public void onResponse(DeleteResponse deleteResponse) { if (deleteResponse.getResult() == DocWriteResponse.Result.NOT_FOUND) { logger.info( context, "ElasticSearchRestHighImpl:delete:OnResponse: Document not found for index : " + index + " , identifier : " + identifier); promise.success(false); } else { promise.success(true); } } @Override public void onFailure(Exception e) { logger.error( context, "ElasticSearchRestHighImpl:delete: Async Failed due to error :", e); promise.failure(e); } }; ConnectionManager.getRestClient().deleteAsync(delRequest, listener); } else { logger.info( context, "ElasticSearchRestHighImpl:delete: " + "provided index or identifier is null, index = " + index + "," + " identifier = " + identifier); promise.failure(ProjectUtil.createClientException(ResponseCode.invalidData)); } logger.info( context, "ElasticSearchRestHighImpl:delete: method end ==" + " ,Total time elapsed = " + calculateEndTime(startTime)); return promise.future(); } @Override Future<String> save(
String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Boolean> update(
String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Map<String, Object>> getDataByIdentifier(
String index, String identifier, RequestContext context); @Override Future<Boolean> delete(String index, String identifier, RequestContext context); @Override @SuppressWarnings({"unchecked", "rawtypes"}) Future<Map<String, Object>> search(
SearchDTO searchDTO, String index, RequestContext context); @Override Future<Boolean> healthCheck(); @Override Future<Boolean> bulkInsert(
String index, List<Map<String, Object>> dataList, RequestContext context); @Override Future<Boolean> upsert(
String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Map<String, Map<String, Object>>> getEsResultByListOfIds(
List<String> ids, List<String> fields, String index, RequestContext context); } | @Test public void testDeleteSuccess() { mockRulesForDelete(false, false); Future<Boolean> result = esService.delete("test", "001", null); boolean res = (boolean) ElasticSearchHelper.getResponseFromFuture(result); assertEquals(true, res); }
@Test public void testDeleteSuccessWithoutDelete() { mockRulesForDelete(false, true); Future<Boolean> result = esService.delete("test", "001", null); boolean res = (boolean) ElasticSearchHelper.getResponseFromFuture(result); assertEquals(false, res); }
@Test public void testDeleteFailure() { mockRulesForDelete(true, false); Future<Boolean> result = esService.delete("test", "001", null); Object res = ElasticSearchHelper.getResponseFromFuture(result); assertEquals(null, res); }
@Test public void testDeleteFailureWithEmptyIdentifier() { try { esService.delete("test", "", null); } catch (ProjectCommonException e) { assertEquals(e.getResponseCode(), ResponseCode.invalidData.getResponseCode()); } }
@Test public void testDeleteFailureWithEmptyIndex() { try { esService.delete("", "001", null); } catch (ProjectCommonException e) { assertEquals(e.getResponseCode(), ResponseCode.invalidData.getResponseCode()); } } |
ElasticSearchRestHighImpl implements ElasticSearchService { @Override public Future<Boolean> update( String index, String identifier, Map<String, Object> data, RequestContext context) { long startTime = System.currentTimeMillis(); logger.info( context, "ElasticSearchRestHighImpl:update: method started at ==" + startTime + " for Index " + index); Promise<Boolean> promise = Futures.promise(); data.put("identifier", identifier); if (!StringUtils.isBlank(index) && !StringUtils.isBlank(identifier) && data != null) { UpdateRequest updateRequest = new UpdateRequest(index, _DOC, identifier).doc(data); ActionListener<UpdateResponse> listener = new ActionListener<UpdateResponse>() { @Override public void onResponse(UpdateResponse updateResponse) { promise.success(true); logger.info( context, "ElasticSearchRestHighImpl:update: Success with " + updateResponse.getResult() + " response from elastic search for index" + index + ",identifier : " + identifier); logger.info( context, "ElasticSearchRestHighImpl:update: method end ==" + " for INdex " + index + " ,Total time elapsed = " + calculateEndTime(startTime)); } @Override public void onFailure(Exception e) { logger.error( context, "ElasticSearchRestHighImpl:update: exception occured:" + e.getMessage(), e); promise.failure(e); } }; ConnectionManager.getRestClient().updateAsync(updateRequest, listener); } else { logger.info(context, "ElasticSearchRestHighImpl:update: Requested data is invalid."); promise.failure(ProjectUtil.createClientException(ResponseCode.invalidData)); } return promise.future(); } @Override Future<String> save(
String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Boolean> update(
String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Map<String, Object>> getDataByIdentifier(
String index, String identifier, RequestContext context); @Override Future<Boolean> delete(String index, String identifier, RequestContext context); @Override @SuppressWarnings({"unchecked", "rawtypes"}) Future<Map<String, Object>> search(
SearchDTO searchDTO, String index, RequestContext context); @Override Future<Boolean> healthCheck(); @Override Future<Boolean> bulkInsert(
String index, List<Map<String, Object>> dataList, RequestContext context); @Override Future<Boolean> upsert(
String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Map<String, Map<String, Object>>> getEsResultByListOfIds(
List<String> ids, List<String> fields, String index, RequestContext context); } | @Test public void testUpsertSuccess() { mockRulesForUpdate(false); Future<Boolean> result = esService.update("test", "001", new HashMap<>(), null); boolean res = (boolean) ElasticSearchHelper.getResponseFromFuture(result); assertEquals(true, res); }
@Test public void testUpsertFailure() { mockRulesForUpdate(true); Future<Boolean> result = esService.update("test", "001", new HashMap<>(), null); Object res = ElasticSearchHelper.getResponseFromFuture(result); assertEquals(null, res); }
@Test public void testUpsertFailureWithEmptyIndex() { try { esService.update("", "001", new HashMap<>(), null); } catch (ProjectCommonException e) { assertEquals(e.getResponseCode(), ResponseCode.invalidData.getResponseCode()); } }
@Test public void testUpsertFailureWithEmptyIdentifier() { try { esService.update("test", "", new HashMap<>(), null); } catch (ProjectCommonException e) { assertEquals(e.getResponseCode(), ResponseCode.invalidData.getResponseCode()); } }
@Test public void testUpdateSuccess() { mockRulesForUpdate(false); Future<Boolean> result = esService.update("test", "001", new HashMap<>(), null); boolean res = (boolean) ElasticSearchHelper.getResponseFromFuture(result); assertEquals(true, res); }
@Test public void testUpdateFailure() { mockRulesForUpdate(true); Future<Boolean> result = esService.update("test", "001", new HashMap<>(), null); Object res = ElasticSearchHelper.getResponseFromFuture(result); assertEquals(null, res); }
@Test public void testUpdateFailureWithEmptyIndex() { try { esService.update("", "001", new HashMap<>(), null); } catch (ProjectCommonException e) { assertEquals(e.getResponseCode(), ResponseCode.invalidData.getResponseCode()); } }
@Test public void testUpdateFailureWithEmptyIdentifier() { try { esService.update("test", "", new HashMap<>(), null); } catch (ProjectCommonException e) { assertEquals(e.getResponseCode(), ResponseCode.invalidData.getResponseCode()); } } |
ElasticSearchRestHighImpl implements ElasticSearchService { @Override public Future<Boolean> bulkInsert( String index, List<Map<String, Object>> dataList, RequestContext context) { long startTime = System.currentTimeMillis(); logger.info( context, "ElasticSearchRestHighImpl:bulkInsert: method started at ==" + startTime + " for Index " + index); BulkRequest request = new BulkRequest(); Promise<Boolean> promise = Futures.promise(); for (Map<String, Object> data : dataList) { data.put("identifier", data.get(JsonKey.ID)); request.add(new IndexRequest(index, _DOC, (String) data.get(JsonKey.ID)).source(data)); } ActionListener<BulkResponse> listener = new ActionListener<BulkResponse>() { @Override public void onResponse(BulkResponse bulkResponse) { Iterator<BulkItemResponse> responseItr = bulkResponse.iterator(); if (responseItr != null) { promise.success(true); while (responseItr.hasNext()) { BulkItemResponse bResponse = responseItr.next(); if (bResponse.isFailed()) { logger.info( context, "ElasticSearchRestHighImpl:bulkinsert: api response===" + bResponse.getId() + " " + bResponse.getFailureMessage()); } } } } @Override public void onFailure(Exception e) { logger.error( context, "ElasticSearchRestHighImpl:bulkinsert: Bulk upload error block", e); promise.success(false); } }; ConnectionManager.getRestClient().bulkAsync(request, listener); logger.info( context, "ElasticSearchRestHighImpl:bulkInsert: method end ==" + " for Index " + index + " ,Total time elapsed = " + calculateEndTime(startTime)); return promise.future(); } @Override Future<String> save(
String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Boolean> update(
String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Map<String, Object>> getDataByIdentifier(
String index, String identifier, RequestContext context); @Override Future<Boolean> delete(String index, String identifier, RequestContext context); @Override @SuppressWarnings({"unchecked", "rawtypes"}) Future<Map<String, Object>> search(
SearchDTO searchDTO, String index, RequestContext context); @Override Future<Boolean> healthCheck(); @Override Future<Boolean> bulkInsert(
String index, List<Map<String, Object>> dataList, RequestContext context); @Override Future<Boolean> upsert(
String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Map<String, Map<String, Object>>> getEsResultByListOfIds(
List<String> ids, List<String> fields, String index, RequestContext context); } | @Test public void testBuilInsertSuccess() { mockRulesForBulk(false); List<Map<String, Object>> list = new ArrayList<>(); Map<String, Object> map = new HashMap<>(); map.put(JsonKey.IDENTIFIER, "0001"); list.add(map); Future<Boolean> result = esService.bulkInsert("test", list, null); boolean res = (boolean) ElasticSearchHelper.getResponseFromFuture(result); assertEquals(true, res); }
@Test public void testBuilInsertFailure() { mockRulesForBulk(true); List<Map<String, Object>> list = new ArrayList<>(); Map<String, Object> map = new HashMap<>(); map.put(JsonKey.IDENTIFIER, "0001"); list.add(map); Future<Boolean> result = esService.bulkInsert("test", list, null); boolean res = (boolean) ElasticSearchHelper.getResponseFromFuture(result); assertEquals(false, res); } |
MigrationUtils { public static ShadowUser getRecordByUserId(String userId, RequestContext context) { ShadowUser shadowUser = null; Response response = cassandraOperation.searchValueInList( JsonKey.SUNBIRD, JsonKey.SHADOW_USER, JsonKey.USERIDS, userId, context); if (!((List) response.getResult().get(JsonKey.RESPONSE)).isEmpty()) { shadowUser = mapper.convertValue( ((List) response.getResult().get(JsonKey.RESPONSE)).get(0), ShadowUser.class); } return shadowUser; } static ShadowUser getRecordByUserId(String userId, RequestContext context); static boolean updateRecord(
Map<String, Object> propertiesMap, String channel, String userExtId, RequestContext context); static boolean markUserAsRejected(ShadowUser shadowUser, RequestContext context); static boolean updateClaimStatus(
ShadowUser shadowUser, int claimStatus, RequestContext context); static List<ShadowUser> getEligibleUsersById(
String userId, Map<String, Object> propsMap, RequestContext context); static List<ShadowUser> getEligibleUsersById(String userId, RequestContext context); } | @Test public void testGetRecordByUserIdSuccess() { ShadowUser shadowUser = MigrationUtils.getRecordByUserId("EFG", null); Assert.assertEquals("TN", shadowUser.getChannel()); }
@Test public void testGetRecordByUserIdFailure() { ShadowUser shadowUser = MigrationUtils.getRecordByUserId("DEF", null); Assert.assertEquals(null, shadowUser); } |
ElasticSearchMapping { public static String createMapping() { String mapping = " { \"dynamic_templates\": [ {\"longs\": {\"match_mapping_type\": \"long\", \"mapping\": {\"type\": \"long\", \"fields\": { \"raw\": {\"type\": \"long\" } }}}},{\"booleans\": {\"match_mapping_type\": \"boolean\", \"mapping\": {\"type\": \"boolean\", \"fields\": { \"raw\": { \"type\": \"boolean\" }} }}},{\"doubles\": {\"match_mapping_type\": \"double\",\"mapping\": {\"type\": \"double\",\"fields\":{\"raw\": { \"type\": \"double\" } }}}},{ \"dates\": {\"match_mapping_type\": \"date\", \"mapping\": { \"type\": \"date\",\"fields\": {\"raw\": { \"type\": \"date\" } } }}},{\"strings\": {\"match_mapping_type\": \"string\",\"mapping\": {\"type\": \"text\",\"fielddata\": true,\"copy_to\": \"all_fields\",\"analyzer\": \"cs_index_analyzer\",\"search_analyzer\": \"cs_search_analyzer\",\"fields\": {\"raw\": {\"type\": \"text\",\"fielddata\": true,\"analyzer\": \"keylower\"}}}}}],\"properties\": {\"all_fields\": {\"type\": \"text\",\"analyzer\": \"cs_index_analyzer\",\"search_analyzer\": \"cs_search_analyzer\",\"fields\": { \"raw\": { \"type\": \"text\",\"analyzer\": \"keylower\" } }} }}"; return mapping; } static String createMapping(); } | @Test public void testcreateMapping() { String mapping = ElasticSearchMapping.createMapping(); Assert.assertNotNull(mapping); } |
ElasticSearchSettings { public static String createSettingsForIndex() { String settings = "{\"analysis\": {\"analyzer\": {\"cs_index_analyzer\": {\"type\": \"custom\",\"tokenizer\": \"standard\",\"filter\": [\"lowercase\",\"mynGram\"]},\"cs_search_analyzer\": {\"type\": \"custom\",\"tokenizer\": \"standard\",\"filter\": [\"lowercase\",\"standard\"]},\"keylower\": {\"type\": \"custom\",\"tokenizer\": \"keyword\",\"filter\": \"lowercase\"}},\"filter\": {\"mynGram\": {\"type\": \"ngram\",\"min_gram\": 1,\"max_gram\": 20,\"token_chars\": [\"letter\", \"digit\",\"whitespace\",\"punctuation\",\"symbol\"]} }}}"; return settings; } static String createSettingsForIndex(); } | @Test public void testcreateSettingsForIndex() { String settings = ElasticSearchSettings.createSettingsForIndex(); Assert.assertNotNull(settings); } |
TelemetryGenerator { public static String audit(Map<String, Object> context, Map<String, Object> params) { if (!validateRequest(context, params)) { return ""; } String actorId = (String) context.get(JsonKey.ACTOR_ID); String actorType = (String) context.get(JsonKey.ACTOR_TYPE); Actor actor = new Actor(actorId, StringUtils.capitalize(actorType)); Target targetObject = generateTargetObject((Map<String, Object>) params.get(JsonKey.TARGET_OBJECT)); Context eventContext = getContext(context); if (params.containsKey(JsonKey.CORRELATED_OBJECTS)) { setCorrelatedDataToContext(params.get(JsonKey.CORRELATED_OBJECTS), eventContext); } String reqId = (String) context.get(JsonKey.X_REQUEST_ID); if (!StringUtils.isBlank(reqId)) { Map<String, Object> map = new HashMap<>(); map.put(JsonKey.ID, reqId); map.put(JsonKey.TYPE, TelemetryEnvKey.REQUEST_UPPER_CAMEL); eventContext.getCdata().add(map); } Map<String, Object> edata = generateAuditEdata(params); Telemetry telemetry = new Telemetry(TelemetryEvents.AUDIT.getName(), actor, eventContext, edata, targetObject); telemetry.setMid(reqId); return getTelemetry(telemetry); } private TelemetryGenerator(); static String audit(Map<String, Object> context, Map<String, Object> params); static String search(Map<String, Object> context, Map<String, Object> params); static String log(Map<String, Object> context, Map<String, Object> params); static String error(Map<String, Object> context, Map<String, Object> params); } | @Test public void testAudit() { String audit = TelemetryGenerator.audit(context, params); assertNotNull(audit); } |
TelemetryGenerator { public static String search(Map<String, Object> context, Map<String, Object> params) { if (!validateRequest(context, params)) { return ""; } String actorId = (String) context.get(JsonKey.ACTOR_ID); String actorType = (String) context.get(JsonKey.ACTOR_TYPE); Actor actor = new Actor(actorId, StringUtils.capitalize(actorType)); Context eventContext = getContext(context); String reqId = (String) context.get(JsonKey.X_REQUEST_ID); if (!StringUtils.isBlank(reqId)) { Map<String, Object> map = new HashMap<>(); map.put(JsonKey.ID, reqId); map.put(JsonKey.TYPE, TelemetryEnvKey.REQUEST_UPPER_CAMEL); eventContext.getCdata().add(map); } Map<String, Object> edata = generateSearchEdata(params); Telemetry telemetry = new Telemetry(TelemetryEvents.SEARCH.getName(), actor, eventContext, edata); telemetry.setMid(reqId); return getTelemetry(telemetry); } private TelemetryGenerator(); static String audit(Map<String, Object> context, Map<String, Object> params); static String search(Map<String, Object> context, Map<String, Object> params); static String log(Map<String, Object> context, Map<String, Object> params); static String error(Map<String, Object> context, Map<String, Object> params); } | @Test public void testSearch() { String audit = TelemetryGenerator.search(context, params); assertNotNull(audit); } |
TelemetryGenerator { public static String log(Map<String, Object> context, Map<String, Object> params) { if (!validateRequest(context, params)) { return ""; } String actorId = (String) context.get(JsonKey.ACTOR_ID); String actorType = (String) context.get(JsonKey.ACTOR_TYPE); Actor actor = new Actor(actorId, StringUtils.capitalize(actorType)); Context eventContext = getContext(context); String reqId = (String) context.get(JsonKey.X_REQUEST_ID); if (!StringUtils.isBlank(reqId)) { Map<String, Object> map = new HashMap<>(); map.put(JsonKey.ID, reqId); map.put(JsonKey.TYPE, TelemetryEnvKey.REQUEST_UPPER_CAMEL); eventContext.getCdata().add(map); } Map<String, Object> edata = generateLogEdata(params); Telemetry telemetry = new Telemetry(TelemetryEvents.LOG.getName(), actor, eventContext, edata); telemetry.setMid(reqId); return getTelemetry(telemetry); } private TelemetryGenerator(); static String audit(Map<String, Object> context, Map<String, Object> params); static String search(Map<String, Object> context, Map<String, Object> params); static String log(Map<String, Object> context, Map<String, Object> params); static String error(Map<String, Object> context, Map<String, Object> params); } | @Test public void testLog() { String audit = TelemetryGenerator.log(context, params); assertNotNull(audit); } |
TelemetryGenerator { public static String error(Map<String, Object> context, Map<String, Object> params) { if (!validateRequest(context, params)) { return ""; } String actorId = (String) context.get(JsonKey.ACTOR_ID); String actorType = (String) context.get(JsonKey.ACTOR_TYPE); Actor actor = new Actor(actorId, StringUtils.capitalize(actorType)); Context eventContext = getContext(context); String reqId = (String) context.get(JsonKey.X_REQUEST_ID); if (!StringUtils.isBlank(reqId)) { Map<String, Object> map = new HashMap<>(); map.put(JsonKey.ID, reqId); map.put(JsonKey.TYPE, TelemetryEnvKey.REQUEST_UPPER_CAMEL); eventContext.getCdata().add(map); } Map<String, Object> edata = generateErrorEdata(params); Telemetry telemetry = new Telemetry(TelemetryEvents.ERROR.getName(), actor, eventContext, edata); telemetry.setMid(reqId); return getTelemetry(telemetry); } private TelemetryGenerator(); static String audit(Map<String, Object> context, Map<String, Object> params); static String search(Map<String, Object> context, Map<String, Object> params); static String log(Map<String, Object> context, Map<String, Object> params); static String error(Map<String, Object> context, Map<String, Object> params); } | @Test public void testError() { String audit = TelemetryGenerator.error(context, params); assertNotNull(audit); } |
KeyCloakServiceImpl implements SSOManager { @Override public String getUsernameById(String userId) { String fedUserId = getFederatedUserId(userId); try { UserResource resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); UserRepresentation ur = resource.toRepresentation(); return ur.getUsername(); } catch (Exception e) { logger.error("KeyCloakServiceImpl:getUsernameById: User not found for userId = " + userId, e); } logger.info("getUsernameById: User not found for userId = " + userId); return ""; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); } | @Test public void testGetUsernameById() { String result = keyCloakService.getUsernameById("1234-567-890"); Assert.assertNotNull(result); } |
KeyCloakServiceImpl implements SSOManager { @Override public String updateUser(Map<String, Object> request, RequestContext context) { String userId = (String) request.get(JsonKey.USER_ID); String fedUserId = getFederatedUserId(userId); UserRepresentation ur = null; UserResource resource = null; boolean needTobeUpdate = false; try { resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); ur = resource.toRepresentation(); } catch (Exception e) { ProjectUtil.createAndThrowInvalidUserDataException(); } if (isNotNull(request.get(JsonKey.FIRST_NAME))) { needTobeUpdate = true; ur.setFirstName((String) request.get(JsonKey.FIRST_NAME)); } if (isNotNull(request.get(JsonKey.LAST_NAME))) { needTobeUpdate = true; ur.setLastName((String) request.get(JsonKey.LAST_NAME)); } if (isNotNull(request.get(JsonKey.EMAIL))) { needTobeUpdate = true; ur.setEmail((String) request.get(JsonKey.EMAIL)); ur.setEmailVerified(false); Map<String, List<String>> map = ur.getAttributes(); List<String> list = new ArrayList<>(); list.add("false"); if (map == null) { map = new HashMap<>(); } map.put(JsonKey.EMAIL_VERIFIED_UPDATED, list); ur.setAttributes(map); } if (!StringUtils.isBlank((String) request.get(JsonKey.PHONE))) { needTobeUpdate = true; Map<String, List<String>> map = ur.getAttributes(); List<String> list = new ArrayList<>(); list.add((String) request.get(JsonKey.PHONE)); if (map == null) { map = new HashMap<>(); } map.put(JsonKey.PHONE, list); ur.setAttributes(map); } if (!StringUtils.isBlank((String) request.get(JsonKey.COUNTRY_CODE))) { needTobeUpdate = true; Map<String, List<String>> map = ur.getAttributes(); if (map == null) { map = new HashMap<>(); } List<String> list = new ArrayList<>(); list.add(PropertiesCache.getInstance().getProperty("sunbird_default_country_code")); if (!StringUtils.isBlank((String) request.get(JsonKey.COUNTRY_CODE))) { list.add(0, (String) request.get(JsonKey.COUNTRY_CODE)); } map.put(JsonKey.COUNTRY_CODE, list); ur.setAttributes(map); } try { if (needTobeUpdate) { resource.update(ur); } } catch (Exception ex) { ProjectUtil.createAndThrowInvalidUserDataException(); } return JsonKey.SUCCESS; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); } | @Test public void testUserUpdateTestSuccessWithAllData() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USER_ID, userId.get(JsonKey.USER_ID)); request.put(JsonKey.FIRST_NAME, userName); request.put(JsonKey.PHONE, "9870060000"); request.put(JsonKey.EMAIL, userName.substring(0, 10)); request.put(JsonKey.USERNAME, userName); request.put(JsonKey.PROVIDER, "ntp"); String result = keyCloakService.updateUser(request, null); Assert.assertNotNull(result); }
@Test public void testUpdateUserSuccessWithoutProvider() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USER_ID, userId.get(JsonKey.USER_ID)); request.put(JsonKey.FIRST_NAME, userName); request.put(JsonKey.PHONE, "9870060000"); request.put(JsonKey.COUNTRY_CODE, "+91"); request.put(JsonKey.EMAIL, userName.substring(0, 10)); request.put(JsonKey.USERNAME, userName); String result = keyCloakService.updateUser(request, null); Assert.assertNotNull(result); }
@Test public void testUpdateUserSuccessWithoutProviderAndCountryCode() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USER_ID, userId.get(JsonKey.USER_ID)); request.put(JsonKey.FIRST_NAME, userName); request.put(JsonKey.PHONE, "9870060000"); request.put(JsonKey.EMAIL, userName.substring(0, 10)); request.put(JsonKey.USERNAME, userName); String result = keyCloakService.updateUser(request, null); Assert.assertNotNull(result); }
@Test public void testUpdateUserSuccessWithoutAnyField() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USER_ID, userId.get(JsonKey.USER_ID)); String result = keyCloakService.updateUser(request, null); Assert.assertNotNull(result); } |
KeyCloakServiceImpl implements SSOManager { @Override public String deactivateUser(Map<String, Object> request, RequestContext context) { String userId = (String) request.get(JsonKey.USER_ID); makeUserActiveOrInactive(userId, false, context); return JsonKey.SUCCESS; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); } | @Test(expected = ProjectCommonException.class) public void testDeactivateUserSuccess() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USER_ID, "123"); request.put(JsonKey.FIRST_NAME, userName); keyCloakService.deactivateUser(request, null); } |
KeyCloakServiceImpl implements SSOManager { @Override public String removeUser(Map<String, Object> request, RequestContext context) { Keycloak keycloak = KeyCloakConnectionProvider.getConnection(); String userId = (String) request.get(JsonKey.USER_ID); try { String fedUserId = getFederatedUserId(userId); UserResource resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); if (isNotNull(resource)) { resource.remove(); } } catch (Exception ex) { logger.error(context, "Error occurred : ", ex); ProjectUtil.createAndThrowInvalidUserDataException(); } return JsonKey.SUCCESS; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); } | @Test(expected = ProjectCommonException.class) public void testRemoveUserSuccess() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USER_ID, "123"); keyCloakService.removeUser(request, null); } |
KeyCloakServiceImpl implements SSOManager { @Override public String verifyToken(String accessToken, RequestContext context) { return verifyToken(accessToken, null, context); } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); } | @Test(expected = ProjectCommonException.class) public void testVerifyTokenSuccess() { keyCloakService.verifyToken( "eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICI5emhhVnZDbl81OEtheHpldHBzYXNZQ2lEallkemJIX3U2LV93SDk4SEc0In0.eyJqdGkiOiI5ZmQzNzgzYy01YjZmLTQ3OWQtYmMzYy0yZWEzOGUzZmRmYzgiLCJleHAiOjE1MDUxMTQyNDYsIm5iZiI6MCwiaWF0IjoxNTA1MTEzNjQ2LCJpc3MiOiJodHRwOi8vbG9jYWxob3N0OjgwODAvYXV0aC9yZWFsbXMvbWFzdGVyIiwiYXVkIjoic2VjdXJpdHktYWRtaW4tY29uc29sZSIsInN1YiI6ImIzYTZkMTY4LWJjZmQtNDE2MS1hYzVmLTljZjYyODIyNzlmMyIsInR5cCI6IkJlYXJlciIsImF6cCI6InNlY3VyaXR5LWFkbWluLWNvbnNvbGUiLCJub25jZSI6ImMxOGVlMDM2LTAyMWItNGVlZC04NWVhLTc0MjMyYzg2ZmI4ZSIsImF1dGhfdGltZSI6MTUwNTExMzY0Niwic2Vzc2lvbl9zdGF0ZSI6ImRiZTU2NDlmLTY4MDktNDA3NS05Njk5LTVhYjIyNWMwZTkyMiIsImFjciI6IjEiLCJhbGxvd2VkLW9yaWdpbnMiOltdLCJyZXNvdXJjZV9hY2Nlc3MiOnt9LCJuYW1lIjoiTWFuemFydWwgaGFxdWUiLCJwcmVmZXJyZWRfdXNlcm5hbWUiOiJ0ZXN0MTIzNDU2NyIsImdpdmVuX25hbWUiOiJNYW56YXJ1bCBoYXF1ZSIsImVtYWlsIjoidGVzdDEyM0B0LmNvbSJ9.Xdjqe16MSkiR94g-Uj_pVZ2L3gnIdKpkJ6aB82W_w_c3yEmx1mXYBdkxe4zMz3ks4OX_PWwSFEbJECHcnujUwF6Ula0xtXTfuESB9hFyiWHtVAhuh5UlCCwPnsihv5EqK6u-Qzo0aa6qZOiQK3Zo7FLpnPUDxn4yHyo3mRZUiWf76KTl8PhSMoXoWxcR2vGW0b-cPixILTZPV0xXUZoozCui70QnvTgOJDWqr7y80EWDkS4Ptn-QM3q2nJlw63mZreOG3XTdraOlcKIP5vFK992dyyHlYGqWVzigortS9Ah4cprFVuLlX8mu1cQvqHBtW-0Dq_JlcTMaztEnqvJ6XA", null); } |
KeyCloakServiceImpl implements SSOManager { @Override public boolean addUserLoginTime(String userId) { boolean response = true; try { String fedUserId = getFederatedUserId(userId); UserResource resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); UserRepresentation ur = resource.toRepresentation(); Map<String, List<String>> map = ur.getAttributes(); List<String> list = new ArrayList<>(); if (map == null) { map = new HashMap<>(); } List<String> currentLogTime = map.get(JsonKey.CURRENT_LOGIN_TIME); if (currentLogTime == null || currentLogTime.isEmpty()) { currentLogTime = new ArrayList<>(); currentLogTime.add(Long.toString(System.currentTimeMillis())); } else { list.add(currentLogTime.get(0)); currentLogTime.clear(); currentLogTime.add(0, Long.toString(System.currentTimeMillis())); } map.put(JsonKey.CURRENT_LOGIN_TIME, currentLogTime); map.put(JsonKey.LAST_LOGIN_TIME, list); ur.setAttributes(map); resource.update(ur); } catch (Exception e) { logger.error(e.getMessage(), e); response = false; } return response; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); } | @Test public void testAddUserLoginTimeSuccess() { boolean response = keyCloakService.addUserLoginTime(userId.get(JsonKey.USER_ID)); Assert.assertEquals(true, response); } |
KeyCloakServiceImpl implements SSOManager { @Override public String getLastLoginTime(String userId) { String lastLoginTime = null; try { String fedUserId = getFederatedUserId(userId); UserResource resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); UserRepresentation ur = resource.toRepresentation(); Map<String, List<String>> map = ur.getAttributes(); if (map == null) { map = new HashMap<>(); } List<String> list = map.get(JsonKey.LAST_LOGIN_TIME); if (list != null && !list.isEmpty()) { lastLoginTime = list.get(0); } } catch (Exception e) { logger.error(e.getMessage(), e); } return lastLoginTime; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); } | @Test public void testGetLastLoginTimeSuccess() { String lastLoginTime = keyCloakService.getLastLoginTime(userId.get(JsonKey.USER_ID)); Assert.assertNull(lastLoginTime); } |
KeyCloakServiceImpl implements SSOManager { @Override public String activateUser(Map<String, Object> request, RequestContext context) { String userId = (String) request.get(JsonKey.USER_ID); makeUserActiveOrInactive(userId, true, context); return JsonKey.SUCCESS; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); } | @Test public void testActivateUserFailureWithEmptyUserId() { Map<String, Object> reqMap = new HashMap<>(); reqMap.put(JsonKey.USER_ID, ""); try { keyCloakService.activateUser(reqMap, null); } catch (ProjectCommonException e) { Assert.assertEquals(ResponseCode.invalidUsrData.getErrorCode(), e.getCode()); Assert.assertEquals(ResponseCode.invalidUsrData.getErrorMessage(), e.getMessage()); Assert.assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); } } |
KeyCloakServiceImpl implements SSOManager { @Override public boolean isEmailVerified(String userId) { String fedUserId = getFederatedUserId(userId); UserResource resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); if (isNull(resource)) { return false; } return resource.toRepresentation().isEmailVerified(); } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); } | @Test public void testIsEmailVerifiedSuccess() { boolean response = keyCloakService.isEmailVerified(userId.get(JsonKey.USER_ID)); Assert.assertEquals(false, response); } |
KeyCloakServiceImpl implements SSOManager { @Override public String setEmailVerifiedTrue(String userId) { updateEmailVerifyStatus(userId, true); return JsonKey.SUCCESS; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); } | @Test public void testSetEmailVerifiedSuccessWithVerifiedTrue() { String response = keyCloakService.setEmailVerifiedTrue(userId.get(JsonKey.USER_ID)); Assert.assertEquals(JsonKey.SUCCESS, response); } |
MigrationUtils { public static boolean updateRecord( Map<String, Object> propertiesMap, String channel, String userExtId, RequestContext context) { Map<String, Object> compositeKeysMap = new HashMap<>(); compositeKeysMap.put(JsonKey.USER_EXT_ID, userExtId); compositeKeysMap.put(JsonKey.CHANNEL, channel); Response response = cassandraOperation.updateRecord( JsonKey.SUNBIRD, JsonKey.SHADOW_USER, propertiesMap, compositeKeysMap, context); logger.info( context, "MigrationUtils:updateRecord:update in cassandra with userExtId" + userExtId + ":and response is:" + response); return true; } static ShadowUser getRecordByUserId(String userId, RequestContext context); static boolean updateRecord(
Map<String, Object> propertiesMap, String channel, String userExtId, RequestContext context); static boolean markUserAsRejected(ShadowUser shadowUser, RequestContext context); static boolean updateClaimStatus(
ShadowUser shadowUser, int claimStatus, RequestContext context); static List<ShadowUser> getEligibleUsersById(
String userId, Map<String, Object> propsMap, RequestContext context); static List<ShadowUser> getEligibleUsersById(String userId, RequestContext context); } | @Test public void testUpdateRecord() { Map<String, Object> compositeKeysMap = new HashMap<>(); compositeKeysMap.put(JsonKey.USER_EXT_ID, "anyUserExtId"); compositeKeysMap.put(JsonKey.CHANNEL, "anyChannel"); when(cassandraOperationImpl.updateRecord( JsonKey.SUNBIRD, JsonKey.SHADOW_USER, new HashMap<>(), compositeKeysMap, null)) .thenReturn(response); boolean isRecordUpdated = MigrationUtils.updateRecord(new HashMap<>(), "anyChannel", "anyUserExtId", null); Assert.assertEquals(true, isRecordUpdated); } |
KeyCloakServiceImpl implements SSOManager { @Override public String syncUserData(Map<String, Object> request) { String userId = (String) request.get(JsonKey.USER_ID); String fedUserId = getFederatedUserId(userId); UserRepresentation ur = null; UserResource resource = null; boolean needTobeUpdate = false; try { resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); ur = resource.toRepresentation(); } catch (Exception e) { ProjectUtil.createAndThrowInvalidUserDataException(); } if (isNotNull(request.get(JsonKey.FIRST_NAME))) { needTobeUpdate = true; ur.setFirstName((String) request.get(JsonKey.FIRST_NAME)); } if (isNotNull(request.get(JsonKey.LAST_NAME))) { needTobeUpdate = true; ur.setLastName((String) request.get(JsonKey.LAST_NAME)); } if (isNotNull(request.get(JsonKey.EMAIL))) { needTobeUpdate = true; ur.setEmail((String) request.get(JsonKey.EMAIL)); } logger.info( "check user email is verified or not ,resource.toRepresentation().isEmailVerified() :" + resource.toRepresentation().isEmailVerified() + " for userId :" + userId); if (!resource.toRepresentation().isEmailVerified()) { needTobeUpdate = true; Map<String, List<String>> map = ur.getAttributes(); List<String> list = new ArrayList<>(); list.add("false"); if (map == null) { map = new HashMap<>(); } map.put(JsonKey.EMAIL_VERIFIED_UPDATED, list); ur.setAttributes(map); } else { needTobeUpdate = true; Map<String, List<String>> map = ur.getAttributes(); List<String> list = new ArrayList<>(); list.add("true"); if (map == null) { map = new HashMap<>(); } map.put(JsonKey.EMAIL_VERIFIED_UPDATED, list); ur.setAttributes(map); } if (isNotNull(request.get(JsonKey.LOGIN_ID))) { needTobeUpdate = true; ur.setUsername((String) request.get(JsonKey.LOGIN_ID)); } if (!StringUtils.isBlank((String) request.get(JsonKey.PHONE))) { needTobeUpdate = true; Map<String, List<String>> map = ur.getAttributes(); List<String> list = new ArrayList<>(); list.add((String) request.get(JsonKey.PHONE)); if (map == null) { map = new HashMap<>(); } map.put(JsonKey.PHONE, list); ur.setAttributes(map); } Map<String, List<String>> map = ur.getAttributes(); if (map == null) { map = new HashMap<>(); } List<String> list = new ArrayList<>(); list.add(PropertiesCache.getInstance().getProperty("sunbird_default_country_code")); map.put(JsonKey.COUNTRY_CODE, list); if (!StringUtils.isBlank((String) request.get(JsonKey.COUNTRY_CODE))) { needTobeUpdate = true; list.add(0, (String) request.get(JsonKey.COUNTRY_CODE)); map.put(JsonKey.COUNTRY_CODE, list); } ur.setAttributes(map); try { if (needTobeUpdate) { resource.update(ur); } } catch (Exception ex) { ProjectUtil.createAndThrowInvalidUserDataException(); } return JsonKey.SUCCESS; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); } | @Test public void testSyncUserDataSuccess() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USERNAME, userName); request.put(JsonKey.PROVIDER, "ntp"); request.put(JsonKey.PASSWORD, "password"); request.put(JsonKey.FIRST_NAME, "A"); request.put(JsonKey.LAST_NAME, "B"); request.put(JsonKey.PHONE, "9870060000"); request.put(JsonKey.COUNTRY_CODE, "+91"); request.put(JsonKey.EMAIL, userName.substring(0, 10)); request.put(JsonKey.USER_ID, userId.get(JsonKey.USER_ID)); String response = keyCloakService.syncUserData(request); Assert.assertEquals(JsonKey.SUCCESS, response); }
@Test public void testSyncUserDataSuccessWithoutCountryCode() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USERNAME, userName); request.put(JsonKey.PROVIDER, "ntp"); request.put(JsonKey.PASSWORD, "password"); request.put(JsonKey.FIRST_NAME, "A"); request.put(JsonKey.LAST_NAME, "B"); request.put(JsonKey.PHONE, "9870060000"); request.put(JsonKey.EMAIL, userName.substring(0, 10)); request.put(JsonKey.USER_ID, userId.get(JsonKey.USER_ID)); String response = keyCloakService.syncUserData(request); Assert.assertEquals(JsonKey.SUCCESS, response); }
@Test public void testSyncUserDataSuccessWithoutProvider() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USERNAME, userName); request.put(JsonKey.PASSWORD, "password"); request.put(JsonKey.FIRST_NAME, "A"); request.put(JsonKey.LAST_NAME, "B"); request.put(JsonKey.PHONE, "9870060000"); request.put(JsonKey.EMAIL, userName.substring(0, 10)); request.put(JsonKey.USER_ID, userId.get(JsonKey.USER_ID)); String response = keyCloakService.syncUserData(request); Assert.assertEquals(JsonKey.SUCCESS, response); }
@Test public void testSyncUserDataSuccessWithInvalidUser() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USERNAME, userName); request.put(JsonKey.PASSWORD, "password"); request.put(JsonKey.FIRST_NAME, "A"); request.put(JsonKey.LAST_NAME, "B"); request.put(JsonKey.PHONE, "9870060000"); request.put(JsonKey.EMAIL, userName.substring(0, 10)); request.put(JsonKey.USER_ID, "xey123-23sss-cbdsgdgdg"); try { keyCloakService.syncUserData(request); } catch (ProjectCommonException e) { Assert.assertEquals(ResponseCode.invalidUsrData.getErrorCode(), e.getCode()); Assert.assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); } } |
KeyCloakServiceImpl implements SSOManager { @Override public boolean doPasswordUpdate(String userId, String password) { boolean response = false; try { String fedUserId = getFederatedUserId(userId); UserResource resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); CredentialRepresentation newCredential = new CredentialRepresentation(); newCredential.setValue(password); newCredential.setType(CredentialRepresentation.PASSWORD); newCredential.setTemporary(true); resource.resetPassword(newCredential); response = true; } catch (Exception ex) { logger.error(ex.getMessage(), ex); } return response; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); } | @Test public void testDoPasswordUpdateSuccess() { boolean response = keyCloakService.doPasswordUpdate(userId.get(JsonKey.USER_ID), "password"); Assert.assertEquals(true, response); } |
KeyCloakServiceImpl implements SSOManager { private String getFederatedUserId(String userId) { return String.join( ":", "f", ProjectUtil.getConfigValue(JsonKey.SUNBIRD_KEYCLOAK_USER_FEDERATION_PROVIDER_ID), userId); } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); } | @Test public void testGetFederatedUserId() throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException { KeyCloakServiceImpl.class.getDeclaredMethods(); Method m = KeyCloakServiceImpl.class.getDeclaredMethod("getFederatedUserId", String.class); m.setAccessible(true); SSOManager keyCloakService = SSOServiceFactory.getInstance(); String fedUserId = (String) m.invoke(keyCloakService, "userId"); Assert.assertEquals( "f:" + ProjectUtil.getConfigValue(JsonKey.SUNBIRD_KEYCLOAK_USER_FEDERATION_PROVIDER_ID) + ":userId", fedUserId); } |
KeyCloakServiceImpl implements SSOManager { @Override public boolean updatePassword(String userId, String password, RequestContext context) { try { String fedUserId = getFederatedUserId(userId); UserResource ur = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); CredentialRepresentation cr = new CredentialRepresentation(); cr.setType(CredentialRepresentation.PASSWORD); cr.setValue(password); ur.resetPassword(cr); return true; } catch (Exception e) { logger.error(context, "updatePassword: Exception occurred: ", e); } return false; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); } | @Test public void testUpdatePassword() throws Exception { boolean updated = keyCloakService.updatePassword(userId.get(JsonKey.USER_ID), "password", null); Assert.assertTrue(updated); } |
KeyCloakRsaKeyFetcher { public PublicKey getPublicKeyFromKeyCloak(String url, String realm) { try { Map<String, String> valueMap = null; Decoder urlDecoder = Base64.getUrlDecoder(); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); String publicKeyString = requestKeyFromKeycloak(url, realm); if (publicKeyString != null) { valueMap = getValuesFromJson(publicKeyString); if (valueMap != null) { BigInteger modulus = new BigInteger(1, urlDecoder.decode(valueMap.get(MODULUS))); BigInteger publicExponent = new BigInteger(1, urlDecoder.decode(valueMap.get(EXPONENT))); PublicKey key = keyFactory.generatePublic(new RSAPublicKeySpec(modulus, publicExponent)); saveToCache(key); return key; } } } catch (Exception e) { ProjectLogger.log( "KeyCloakRsaKeyFetcher:getPublicKeyFromKeyCloak: Exception occurred with message = " + e.getMessage(), LoggerEnum.ERROR); } return null; } PublicKey getPublicKeyFromKeyCloak(String url, String realm); } | @Test public void testGetPublicKeyFromKeyCloakSuccess() throws Exception { response = PowerMockito.mock(CloseableHttpResponse.class); when(client.execute(Mockito.any())).thenReturn(response); when(response.getEntity()).thenReturn(httpEntity); String jsonString = "{\"keys\":[{\"kid\":\"YOw4KbDjM0_HIdGkf_QhRfKc9qHc4W_8Bni91nKFyck\",\"kty\":\"RSA\",\"alg\":\"RS256\",\"use\":\"sig\",\"n\":\"" + "5OwCfx4UZTUfUDSBjOg65HuE4ReOg9GhZyoDJNqbWFrsY3dz7C12lmM3rewBHoY0F5_KW0A7rniS9LcqDg2RODvV8pRtJZ_Ge-jsnPMBY5nDJeEW35PH9ewaBhbY3Dj0bZQda2KdHGwiQ" + "zItMT4vw0uITKsFq9o1bcYj0QvPq10AE_wOx3T5xsysuTTkcvQ6evbbs6P5yz_SHhQFRTk7_ZhMwhBeTolvg9wF4yl4qwr220A1ORsLAwwydpmfMHU9RD97nzHDlhXTBAOhDoA3Z3wA8KG6V" + "i3LxqTLNRVS4hgq310fHzWfCX7shFQxygijW9zit-X1WVXaS1NxazuLJw\",\"e\":\"AQAB\"}]}"; when(EntityUtils.toString(httpEntity)).thenReturn(jsonString); PublicKey key = new KeyCloakRsaKeyFetcher() .getPublicKeyFromKeyCloak( KeyCloakConnectionProvider.SSO_URL, KeyCloakConnectionProvider.SSO_REALM); Assert.assertNotNull(key); }
@Test public void testGetPublicKeyFromKeyCloakFailure() throws Exception { PublicKey key = new KeyCloakRsaKeyFetcher() .getPublicKeyFromKeyCloak(KeyCloakConnectionProvider.SSO_URL, FALSE_REALM); Assert.assertEquals(key, null); } |
CloudStorageUtil { public static String upload( CloudStorageType storageType, String container, String objectKey, String filePath) { IStorageService storageService = getStorageService(storageType); return storageService.upload( container, filePath, objectKey, Option.apply(false), Option.apply(1), Option.apply(STORAGE_SERVICE_API_RETRY_COUNT), Option.empty()); } static String upload(
CloudStorageType storageType, String container, String objectKey, String filePath); static String getSignedUrl(
CloudStorageType storageType, String container, String objectKey); static String getAnalyticsSignedUrl(
CloudStorageType storageType, String container, String objectKey); static String getSignedUrl(
IStorageService storageService,
CloudStorageType storageType,
String container,
String objectKey); static String getUri(
CloudStorageType storageType, String container, String prefix, boolean isDirectory); } | @Test @Ignore public void testUploadSuccess() { String result = CloudStorageUtil.upload(CloudStorageType.AZURE, "container", "key", "/file/path"); assertTrue(UPLOAD_URL.equals(result)); } |
MigrationUtils { public static boolean markUserAsRejected(ShadowUser shadowUser, RequestContext context) { Map<String, Object> propertiesMap = new HashMap<>(); propertiesMap.put(JsonKey.CLAIM_STATUS, ClaimStatus.REJECTED.getValue()); propertiesMap.put(JsonKey.UPDATED_ON, new Timestamp(System.currentTimeMillis())); boolean isRecordUpdated = updateRecord(propertiesMap, shadowUser.getChannel(), shadowUser.getUserExtId(), context); logger.info( context, "MigrationUtils:markUserAsRejected:update in cassandra with userExtId" + shadowUser.getUserExtId()); return isRecordUpdated; } static ShadowUser getRecordByUserId(String userId, RequestContext context); static boolean updateRecord(
Map<String, Object> propertiesMap, String channel, String userExtId, RequestContext context); static boolean markUserAsRejected(ShadowUser shadowUser, RequestContext context); static boolean updateClaimStatus(
ShadowUser shadowUser, int claimStatus, RequestContext context); static List<ShadowUser> getEligibleUsersById(
String userId, Map<String, Object> propsMap, RequestContext context); static List<ShadowUser> getEligibleUsersById(String userId, RequestContext context); } | @Test public void testmarkUserAsRejected() { ShadowUser shadowUser = new ShadowUser.ShadowUserBuilder() .setChannel("anyChannel") .setUserExtId("anyUserExtId") .build(); Map<String, Object> compositeKeysMap = new HashMap<>(); compositeKeysMap.put(JsonKey.USER_EXT_ID, "anyUserExtId"); compositeKeysMap.put(JsonKey.CHANNEL, "anyChannel"); when(cassandraOperationImpl.updateRecord( JsonKey.SUNBIRD, JsonKey.SHADOW_USER, new HashMap<>(), compositeKeysMap, null)) .thenReturn(response); boolean isRecordUpdated = MigrationUtils.markUserAsRejected(shadowUser, null); Assert.assertEquals(true, isRecordUpdated); } |
CloudStorageUtil { public static String getSignedUrl( CloudStorageType storageType, String container, String objectKey) { IStorageService storageService = getStorageService(storageType); return getSignedUrl(storageService, storageType, container, objectKey); } static String upload(
CloudStorageType storageType, String container, String objectKey, String filePath); static String getSignedUrl(
CloudStorageType storageType, String container, String objectKey); static String getAnalyticsSignedUrl(
CloudStorageType storageType, String container, String objectKey); static String getSignedUrl(
IStorageService storageService,
CloudStorageType storageType,
String container,
String objectKey); static String getUri(
CloudStorageType storageType, String container, String prefix, boolean isDirectory); } | @Test @Ignore public void testGetSignedUrlSuccess() { String signedUrl = CloudStorageUtil.getSignedUrl(CloudStorageType.AZURE, "container", "key"); assertTrue(SIGNED_URL.equals(signedUrl)); } |
ConfigUtil { public static Config getConfigFromJsonString(String jsonString, String configType) { ProjectLogger.log("ConfigUtil: getConfigFromJsonString called", LoggerEnum.DEBUG.name()); if (null == jsonString || StringUtils.isBlank(jsonString)) { ProjectLogger.log( "ConfigUtil:getConfigFromJsonString: Empty string", LoggerEnum.ERROR.name()); ProjectCommonException.throwServerErrorException( ResponseCode.errorConfigLoadEmptyString, ProjectUtil.formatMessage( ResponseCode.errorConfigLoadEmptyString.getErrorMessage(), configType)); } Config jsonConfig = null; try { jsonConfig = ConfigFactory.parseString(jsonString); } catch (Exception e) { ProjectLogger.log( "ConfigUtil:getConfigFromJsonString: Exception occurred during parse with error message = " + e.getMessage(), LoggerEnum.ERROR.name()); ProjectCommonException.throwServerErrorException( ResponseCode.errorConfigLoadParseString, ProjectUtil.formatMessage( ResponseCode.errorConfigLoadParseString.getErrorMessage(), configType)); } if (null == jsonConfig || jsonConfig.isEmpty()) { ProjectLogger.log( "ConfigUtil:getConfigFromJsonString: Empty configuration", LoggerEnum.ERROR.name()); ProjectCommonException.throwServerErrorException( ResponseCode.errorConfigLoadEmptyConfig, ProjectUtil.formatMessage( ResponseCode.errorConfigLoadEmptyConfig.getErrorMessage(), configType)); } ProjectLogger.log( "ConfigUtil:getConfigFromJsonString: Successfully constructed type safe configuration", LoggerEnum.DEBUG.name()); return jsonConfig; } private ConfigUtil(); static Config getConfig(); static Config getConfig(String fileName); static void validateMandatoryConfigValue(String configParameter); static Config getConfigFromJsonString(String jsonString, String configType); } | @Test(expected = ProjectCommonException.class) public void testGetConfigFromJsonStringFailureWithNullString() { try { ConfigUtil.getConfigFromJsonString(null, configType); } catch (ProjectCommonException e) { assertTrue(e.getCode().equals(ResponseCode.errorConfigLoadEmptyString.getErrorCode())); throw e; } }
@Test(expected = ProjectCommonException.class) public void testGetConfigFromJsonStringFailureWithEmptyString() { try { ConfigUtil.getConfigFromJsonString("", configType); } catch (ProjectCommonException e) { assertTrue(e.getCode().equals(ResponseCode.errorConfigLoadEmptyString.getErrorCode())); throw e; } }
@Test(expected = ProjectCommonException.class) public void testGetConfigFromJsonStringFailureWithInvalidJsonString() { try { ConfigUtil.getConfigFromJsonString("{dummy}", configType); } catch (ProjectCommonException e) { assertTrue(e.getCode().equals(ResponseCode.errorConfigLoadParseString.getErrorCode())); throw e; } }
@Test public void testGetConfigFromJsonStringSuccess() { Config config = ConfigUtil.getConfigFromJsonString(validJson, configType); assertTrue("value".equals(config.getString("key"))); } |
UserProfileRequestValidator extends BaseRequestValidator { @SuppressWarnings("unchecked") public void validateProfileVisibility(Request request) { validateParam( (String) request.getRequest().get(JsonKey.USER_ID), ResponseCode.mandatoryParamsMissing, JsonKey.USER_ID); validateUserId(request, JsonKey.USER_ID); validatePublicAndPrivateFields(request); } @SuppressWarnings("unchecked") void validateProfileVisibility(Request request); } | @Test public void testValidateProfileVisibilityFailureWithFieldInPrivateAndPublic() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.USER_ID, "9878888888"); List<String> publicList = new ArrayList<>(); publicList.add("Education"); requestObj.put(JsonKey.PUBLIC, publicList); List<String> privateList = new ArrayList<>(); privateList.add("Education"); requestObj.put(JsonKey.PRIVATE, privateList); request.setRequest(requestObj); try { userProfileRequestValidator.validateProfileVisibility(request); } catch (ProjectCommonException e) { Assert.assertNotNull(e); } }
@Test public void testValidateProfileVisibilityFailureWithEmptyUserId() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.USER_ID, ""); request.setRequest(requestObj); try { userProfileRequestValidator.validateProfileVisibility(request); } catch (ProjectCommonException e) { Assert.assertNotNull(e); } }
@Test public void testValidateProfileVisibilityFailureWithInvalidPrivateType() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.USER_ID, "123"); requestObj.put(JsonKey.PRIVATE, ""); request.setRequest(requestObj); try { userProfileRequestValidator.validateProfileVisibility(request); } catch (ProjectCommonException e) { Assert.assertNotNull(e); } }
@Test public void testValidateProfileVisibilityFailureWithInvalidPublicType() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.USER_ID, "123"); requestObj.put(JsonKey.PUBLIC, ""); request.setRequest(requestObj); try { userProfileRequestValidator.validateProfileVisibility(request); } catch (ProjectCommonException e) { Assert.assertNotNull(e); } } |
RequestValidator { public static void validateRegisterClient(Request request) { if (StringUtils.isBlank((String) request.getRequest().get(JsonKey.CLIENT_NAME))) { throw createExceptionInstance(ResponseCode.invalidClientName.getErrorCode()); } } private RequestValidator(); static void validateUploadUser(Map<String, Object> reqObj); static void validateSyncRequest(Request request); static void validateSendMail(Request request); static void validateFileUpload(Request reqObj); static void validateCreateOrgType(Request reqObj); static void validateUpdateOrgType(Request reqObj); @SuppressWarnings("rawtypes") static void validateNote(Request request); static void validateNoteId(String noteId); static void validateRegisterClient(Request request); static void validateUpdateClientKey(String clientId, String masterAccessToken); static void validateGetClientKey(String id, String type); static void validateClientId(String clientId); @SuppressWarnings("unchecked") static void validateSendNotification(Request request); @SuppressWarnings("rawtypes") static void validateGetUserCount(Request request); } | @Test public void testValidateRegisterClientFailureWithEmptyClientName() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.CLIENT_NAME, ""); request.setRequest(requestObj); try { RequestValidator.validateRegisterClient(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.invalidClientName.getErrorCode(), e.getCode()); } }
@Test public void testValidateRegisterClientSuccess() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.CLIENT_NAME, "1234"); request.setRequest(requestObj); try { RequestValidator.validateRegisterClient(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.invalidClientName.getErrorCode(), e.getCode()); } } |
MigrationUtils { public static boolean updateClaimStatus( ShadowUser shadowUser, int claimStatus, RequestContext context) { Map<String, Object> propertiesMap = new WeakHashMap<>(); propertiesMap.put(JsonKey.CLAIM_STATUS, claimStatus); propertiesMap.put(JsonKey.UPDATED_ON, new Timestamp(System.currentTimeMillis())); updateRecord(propertiesMap, shadowUser.getChannel(), shadowUser.getUserExtId(), context); logger.info( context, "MigrationUtils:markUserAsRejected:update in cassandra with userExtId" + shadowUser.getUserExtId()); return true; } static ShadowUser getRecordByUserId(String userId, RequestContext context); static boolean updateRecord(
Map<String, Object> propertiesMap, String channel, String userExtId, RequestContext context); static boolean markUserAsRejected(ShadowUser shadowUser, RequestContext context); static boolean updateClaimStatus(
ShadowUser shadowUser, int claimStatus, RequestContext context); static List<ShadowUser> getEligibleUsersById(
String userId, Map<String, Object> propsMap, RequestContext context); static List<ShadowUser> getEligibleUsersById(String userId, RequestContext context); } | @Test public void testUpdateClaimStatus() { ShadowUser shadowUser = new ShadowUser.ShadowUserBuilder() .setChannel("anyChannel") .setUserExtId("anyUserExtId") .build(); Map<String, Object> compositeKeysMap = new HashMap<>(); compositeKeysMap.put(JsonKey.USER_EXT_ID, "anyUserExtId"); compositeKeysMap.put(JsonKey.CHANNEL, "anyChannel"); when(cassandraOperationImpl.updateRecord( JsonKey.SUNBIRD, JsonKey.SHADOW_USER, new HashMap<>(), compositeKeysMap, null)) .thenReturn(response); boolean isRecordUpdated = MigrationUtils.updateClaimStatus(shadowUser, ClaimStatus.ELIGIBLE.getValue(), null); Assert.assertEquals(true, isRecordUpdated); } |
RequestValidator { public static void validateUpdateClientKey(String clientId, String masterAccessToken) { validateClientId(clientId); if (StringUtils.isBlank(masterAccessToken)) { throw createExceptionInstance(ResponseCode.invalidRequestData.getErrorCode()); } } private RequestValidator(); static void validateUploadUser(Map<String, Object> reqObj); static void validateSyncRequest(Request request); static void validateSendMail(Request request); static void validateFileUpload(Request reqObj); static void validateCreateOrgType(Request reqObj); static void validateUpdateOrgType(Request reqObj); @SuppressWarnings("rawtypes") static void validateNote(Request request); static void validateNoteId(String noteId); static void validateRegisterClient(Request request); static void validateUpdateClientKey(String clientId, String masterAccessToken); static void validateGetClientKey(String id, String type); static void validateClientId(String clientId); @SuppressWarnings("unchecked") static void validateSendNotification(Request request); @SuppressWarnings("rawtypes") static void validateGetUserCount(Request request); } | @Test public void testValidateUpdateClientKeyFailureWithEmptyToken() { try { RequestValidator.validateUpdateClientKey("1234", ""); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.invalidRequestData.getErrorCode(), e.getCode()); } }
@Test public void testValidateUpdateClientKeySuccess() { try { RequestValidator.validateUpdateClientKey("1234", "test123"); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.invalidRequestData.getErrorCode(), e.getCode()); } } |
RequestValidator { public static void validateClientId(String clientId) { if (StringUtils.isBlank(clientId)) { throw createExceptionInstance(ResponseCode.invalidClientId.getErrorCode()); } } private RequestValidator(); static void validateUploadUser(Map<String, Object> reqObj); static void validateSyncRequest(Request request); static void validateSendMail(Request request); static void validateFileUpload(Request reqObj); static void validateCreateOrgType(Request reqObj); static void validateUpdateOrgType(Request reqObj); @SuppressWarnings("rawtypes") static void validateNote(Request request); static void validateNoteId(String noteId); static void validateRegisterClient(Request request); static void validateUpdateClientKey(String clientId, String masterAccessToken); static void validateGetClientKey(String id, String type); static void validateClientId(String clientId); @SuppressWarnings("unchecked") static void validateSendNotification(Request request); @SuppressWarnings("rawtypes") static void validateGetUserCount(Request request); } | @Test public void testValidateClientIdFailureWithEmptyId() { try { RequestValidator.validateClientId(""); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.invalidClientId.getErrorCode(), e.getCode()); } } |
RequestValidator { public static void validateFileUpload(Request reqObj) { if (StringUtils.isBlank((String) reqObj.get(JsonKey.CONTAINER))) { throw new ProjectCommonException( ResponseCode.storageContainerNameMandatory.getErrorCode(), ResponseCode.storageContainerNameMandatory.getErrorMessage(), ERROR_CODE); } } private RequestValidator(); static void validateUploadUser(Map<String, Object> reqObj); static void validateSyncRequest(Request request); static void validateSendMail(Request request); static void validateFileUpload(Request reqObj); static void validateCreateOrgType(Request reqObj); static void validateUpdateOrgType(Request reqObj); @SuppressWarnings("rawtypes") static void validateNote(Request request); static void validateNoteId(String noteId); static void validateRegisterClient(Request request); static void validateUpdateClientKey(String clientId, String masterAccessToken); static void validateGetClientKey(String id, String type); static void validateClientId(String clientId); @SuppressWarnings("unchecked") static void validateSendNotification(Request request); @SuppressWarnings("rawtypes") static void validateGetUserCount(Request request); } | @Test public void testValidateFileUploadFailureWithoutContainerName() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.CONTAINER, ""); request.setRequest(requestObj); try { RequestValidator.validateFileUpload(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.storageContainerNameMandatory.getErrorCode(), e.getCode()); } } |
RequestValidator { public static void validateSendMail(Request request) { if (StringUtils.isBlank((String) request.getRequest().get(JsonKey.SUBJECT))) { throw new ProjectCommonException( ResponseCode.emailSubjectError.getErrorCode(), ResponseCode.emailSubjectError.getErrorMessage(), ERROR_CODE); } if (StringUtils.isBlank((String) request.getRequest().get(JsonKey.BODY))) { throw new ProjectCommonException( ResponseCode.emailBodyError.getErrorCode(), ResponseCode.emailBodyError.getErrorMessage(), ERROR_CODE); } if (CollectionUtils.isEmpty((List<String>) (request.getRequest().get(JsonKey.RECIPIENT_EMAILS))) && CollectionUtils.isEmpty( (List<String>) (request.getRequest().get(JsonKey.RECIPIENT_USERIDS))) && MapUtils.isEmpty( (Map<String, Object>) (request.getRequest().get(JsonKey.RECIPIENT_SEARCH_QUERY))) && CollectionUtils.isEmpty( (List<String>) (request.getRequest().get(JsonKey.RECIPIENT_PHONES)))) { throw new ProjectCommonException( ResponseCode.mandatoryParamsMissing.getErrorCode(), MessageFormat.format( ResponseCode.mandatoryParamsMissing.getErrorMessage(), StringFormatter.joinByOr( StringFormatter.joinByComma( JsonKey.RECIPIENT_EMAILS, JsonKey.RECIPIENT_USERIDS, JsonKey.RECIPIENT_PHONES), JsonKey.RECIPIENT_SEARCH_QUERY)), ERROR_CODE); } } private RequestValidator(); static void validateUploadUser(Map<String, Object> reqObj); static void validateSyncRequest(Request request); static void validateSendMail(Request request); static void validateFileUpload(Request reqObj); static void validateCreateOrgType(Request reqObj); static void validateUpdateOrgType(Request reqObj); @SuppressWarnings("rawtypes") static void validateNote(Request request); static void validateNoteId(String noteId); static void validateRegisterClient(Request request); static void validateUpdateClientKey(String clientId, String masterAccessToken); static void validateGetClientKey(String id, String type); static void validateClientId(String clientId); @SuppressWarnings("unchecked") static void validateSendNotification(Request request); @SuppressWarnings("rawtypes") static void validateGetUserCount(Request request); } | @Test public void testValidateSendEmailSuccess() { boolean response = false; Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.SUBJECT, "test123"); requestObj.put(JsonKey.BODY, "test"); List<String> data = new ArrayList<>(); data.add("[email protected]"); requestObj.put(JsonKey.RECIPIENT_EMAILS, data); requestObj.put(JsonKey.RECIPIENT_USERIDS, new ArrayList<>()); request.setRequest(requestObj); try { RequestValidator.validateSendMail(request); response = true; } catch (ProjectCommonException e) { } assertTrue(response); }
@Test public void testValidateSendMailFailureWithNullRecipients() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.SUBJECT, "test123"); requestObj.put(JsonKey.BODY, "test"); requestObj.put(JsonKey.RECIPIENT_EMAILS, null); request.setRequest(requestObj); try { RequestValidator.validateSendMail(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.mandatoryParamsMissing.getErrorCode(), e.getCode()); } }
@Test public void testValidateSendMailFailureWithEmptyBody() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.SUBJECT, "test123"); requestObj.put(JsonKey.BODY, ""); request.setRequest(requestObj); try { RequestValidator.validateSendMail(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.emailBodyError.getErrorCode(), e.getCode()); } }
@Test public void testValidateSendMailFailureWithEmptySubject() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.SUBJECT, ""); request.setRequest(requestObj); try { RequestValidator.validateSendMail(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.emailSubjectError.getErrorCode(), e.getCode()); } } |
RequestValidator { public static void validateSyncRequest(Request request) { String operation = (String) request.getRequest().get(JsonKey.OPERATION_FOR); if ((null != operation) && (!operation.equalsIgnoreCase("keycloak"))) { if (request.getRequest().get(JsonKey.OBJECT_TYPE) == null) { throw new ProjectCommonException( ResponseCode.dataTypeError.getErrorCode(), ResponseCode.dataTypeError.getErrorMessage(), ERROR_CODE); } List<String> list = new ArrayList<>(Arrays.asList(new String[] {JsonKey.USER, JsonKey.ORGANISATION})); if (!list.contains(request.getRequest().get(JsonKey.OBJECT_TYPE))) { throw new ProjectCommonException( ResponseCode.invalidObjectType.getErrorCode(), ResponseCode.invalidObjectType.getErrorMessage(), ERROR_CODE); } } } private RequestValidator(); static void validateUploadUser(Map<String, Object> reqObj); static void validateSyncRequest(Request request); static void validateSendMail(Request request); static void validateFileUpload(Request reqObj); static void validateCreateOrgType(Request reqObj); static void validateUpdateOrgType(Request reqObj); @SuppressWarnings("rawtypes") static void validateNote(Request request); static void validateNoteId(String noteId); static void validateRegisterClient(Request request); static void validateUpdateClientKey(String clientId, String masterAccessToken); static void validateGetClientKey(String id, String type); static void validateClientId(String clientId); @SuppressWarnings("unchecked") static void validateSendNotification(Request request); @SuppressWarnings("rawtypes") static void validateGetUserCount(Request request); } | @Test public void testValidateSyncRequestSuccess() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.OPERATION_FOR, "keycloak"); requestObj.put(JsonKey.OBJECT_TYPE, JsonKey.USER); request.setRequest(requestObj); boolean response = false; try { RequestValidator.validateSyncRequest(request); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); } Assert.assertTrue(response); }
@Test public void testValidateSyncRequestFailureWithNullObjectType() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.OPERATION_FOR, "not keycloack"); requestObj.put(JsonKey.OBJECT_TYPE, null); request.setRequest(requestObj); boolean response = false; try { RequestValidator.validateSyncRequest(request); response = true; } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.dataTypeError.getErrorCode(), e.getCode()); } Assert.assertFalse(response); }
@Test public void testValidateSyncRequestFailureWithInvalidObjectType() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.OPERATION_FOR, "not keycloack"); List<String> objectLsit = new ArrayList<>(); objectLsit.add("testval"); requestObj.put(JsonKey.OBJECT_TYPE, objectLsit); request.setRequest(requestObj); boolean response = false; try { RequestValidator.validateSyncRequest(request); response = true; } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.invalidObjectType.getErrorCode(), e.getCode()); } Assert.assertFalse(response); } |
MigrationUtils { public static List<ShadowUser> getEligibleUsersById( String userId, Map<String, Object> propsMap, RequestContext context) { List<ShadowUser> shadowUsersList = new ArrayList<>(); Response response = cassandraOperation.searchValueInList( JsonKey.SUNBIRD, JsonKey.SHADOW_USER, JsonKey.USERIDS, userId, propsMap, context); if (!((List) response.getResult().get(JsonKey.RESPONSE)).isEmpty()) { ((List) response.getResult().get(JsonKey.RESPONSE)) .stream() .forEach( shadowMap -> { ShadowUser shadowUser = mapper.convertValue(shadowMap, ShadowUser.class); if (shadowUser.getClaimStatus() == ClaimStatus.ELIGIBLE.getValue()) { shadowUsersList.add(shadowUser); } }); } return shadowUsersList; } static ShadowUser getRecordByUserId(String userId, RequestContext context); static boolean updateRecord(
Map<String, Object> propertiesMap, String channel, String userExtId, RequestContext context); static boolean markUserAsRejected(ShadowUser shadowUser, RequestContext context); static boolean updateClaimStatus(
ShadowUser shadowUser, int claimStatus, RequestContext context); static List<ShadowUser> getEligibleUsersById(
String userId, Map<String, Object> propsMap, RequestContext context); static List<ShadowUser> getEligibleUsersById(String userId, RequestContext context); } | @Test public void testGetEligibleUserByIdsSuccess() { List<ShadowUser> shadowUserList = MigrationUtils.getEligibleUsersById("ABC", new HashMap<>(), null); Assert.assertEquals(1, shadowUserList.size()); }
@Test public void testGetEligibleUserByIdsFailure() { List<ShadowUser> shadowUserList = MigrationUtils.getEligibleUsersById("XYZ", new HashMap<>(), null); Assert.assertEquals(0, shadowUserList.size()); }
@Test public void testGetEligibleUserByIdsWithoutProps() { List<ShadowUser> shadowUserList = MigrationUtils.getEligibleUsersById("EFG", null); Assert.assertEquals(1, shadowUserList.size()); } |
RequestValidator { public static void validateUpdateOrgType(Request reqObj) { if (StringUtils.isBlank((String) reqObj.getRequest().get(JsonKey.NAME))) { throw createExceptionInstance(ResponseCode.orgTypeMandatory.getErrorCode()); } if (StringUtils.isBlank((String) reqObj.getRequest().get(JsonKey.ID))) { throw createExceptionInstance(ResponseCode.orgTypeIdRequired.getErrorCode()); } } private RequestValidator(); static void validateUploadUser(Map<String, Object> reqObj); static void validateSyncRequest(Request request); static void validateSendMail(Request request); static void validateFileUpload(Request reqObj); static void validateCreateOrgType(Request reqObj); static void validateUpdateOrgType(Request reqObj); @SuppressWarnings("rawtypes") static void validateNote(Request request); static void validateNoteId(String noteId); static void validateRegisterClient(Request request); static void validateUpdateClientKey(String clientId, String masterAccessToken); static void validateGetClientKey(String id, String type); static void validateClientId(String clientId); @SuppressWarnings("unchecked") static void validateSendNotification(Request request); @SuppressWarnings("rawtypes") static void validateGetUserCount(Request request); } | @Test public void testValidateUserOrgTypeSuccess() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.NAME, "orgtypeName"); requestObj.put(JsonKey.ID, "orgtypeId"); request.setRequest(requestObj); boolean response = false; try { RequestValidator.validateUpdateOrgType(request); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); } Assert.assertTrue(response); }
@Test public void testValidateUserOrgTypeFailureWithEmptyName() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.NAME, ""); requestObj.put(JsonKey.ID, "orgtypeId"); request.setRequest(requestObj); boolean response = false; try { RequestValidator.validateUpdateOrgType(request); response = true; } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.orgTypeMandatory.getErrorCode(), e.getCode()); } Assert.assertFalse(response); }
@Test public void testValidateUserOrgTypeFailureWithEmptyId() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.NAME, "orgTypeName"); requestObj.put(JsonKey.ID, ""); request.setRequest(requestObj); boolean response = false; try { RequestValidator.validateUpdateOrgType(request); response = true; } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.orgTypeIdRequired.getErrorCode(), e.getCode()); } Assert.assertFalse(response); } |
RequestValidator { public static void validateCreateOrgType(Request reqObj) { if (StringUtils.isBlank((String) reqObj.getRequest().get(JsonKey.NAME))) { throw createExceptionInstance(ResponseCode.orgTypeMandatory.getErrorCode()); } } private RequestValidator(); static void validateUploadUser(Map<String, Object> reqObj); static void validateSyncRequest(Request request); static void validateSendMail(Request request); static void validateFileUpload(Request reqObj); static void validateCreateOrgType(Request reqObj); static void validateUpdateOrgType(Request reqObj); @SuppressWarnings("rawtypes") static void validateNote(Request request); static void validateNoteId(String noteId); static void validateRegisterClient(Request request); static void validateUpdateClientKey(String clientId, String masterAccessToken); static void validateGetClientKey(String id, String type); static void validateClientId(String clientId); @SuppressWarnings("unchecked") static void validateSendNotification(Request request); @SuppressWarnings("rawtypes") static void validateGetUserCount(Request request); } | @Test public void testValidateCreateOrgTypeSuccess() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.NAME, "OrgTypeName"); request.setRequest(requestObj); boolean response = false; try { RequestValidator.validateCreateOrgType(request); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); } Assert.assertTrue(response); }
@Test public void testValidateCreateOrgTypeFailureWithNullName() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.NAME, null); request.setRequest(requestObj); boolean response = false; try { RequestValidator.validateCreateOrgType(request); response = true; } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.orgTypeMandatory.getErrorCode(), e.getCode()); } Assert.assertFalse(response); } |
RequestValidator { public static void validateGetClientKey(String id, String type) { validateClientId(id); if (StringUtils.isBlank(type)) { throw createExceptionInstance(ResponseCode.invalidRequestData.getErrorCode()); } } private RequestValidator(); static void validateUploadUser(Map<String, Object> reqObj); static void validateSyncRequest(Request request); static void validateSendMail(Request request); static void validateFileUpload(Request reqObj); static void validateCreateOrgType(Request reqObj); static void validateUpdateOrgType(Request reqObj); @SuppressWarnings("rawtypes") static void validateNote(Request request); static void validateNoteId(String noteId); static void validateRegisterClient(Request request); static void validateUpdateClientKey(String clientId, String masterAccessToken); static void validateGetClientKey(String id, String type); static void validateClientId(String clientId); @SuppressWarnings("unchecked") static void validateSendNotification(Request request); @SuppressWarnings("rawtypes") static void validateGetUserCount(Request request); } | @Test public void testValidateGetClientKeySuccess() { boolean response = false; try { RequestValidator.validateGetClientKey("clientId", "clientType"); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); } Assert.assertTrue(response); }
@Test public void testValidateGetClientKeyFailureWithEmptyClientId() { boolean response = false; try { RequestValidator.validateGetClientKey("", "clientType"); response = true; } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.invalidClientId.getErrorCode(), e.getCode()); } Assert.assertFalse(response); }
@Test public void testValidateGetClientKeyFailureWithEmptyClientType() { boolean response = false; try { RequestValidator.validateGetClientKey("clientId", ""); response = true; } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.invalidRequestData.getErrorCode(), e.getCode()); } Assert.assertFalse(response); } |
BaseRequestValidator { public void validateSearchRequest(Request request) { if (null == request.getRequest().get(JsonKey.FILTERS)) { throw new ProjectCommonException( ResponseCode.mandatoryParamsMissing.getErrorCode(), MessageFormat.format( ResponseCode.mandatoryParamsMissing.getErrorMessage(), JsonKey.FILTERS), ResponseCode.CLIENT_ERROR.getResponseCode()); } if (request.getRequest().containsKey(JsonKey.FILTERS) && (!(request.getRequest().get(JsonKey.FILTERS) instanceof Map))) { throw new ProjectCommonException( ResponseCode.dataTypeError.getErrorCode(), MessageFormat.format( ResponseCode.dataTypeError.getErrorMessage(), JsonKey.FILTERS, "Map"), ResponseCode.CLIENT_ERROR.getResponseCode()); } validateSearchRequestFiltersValues(request); validateSearchRequestFieldsValues(request); } void validateParam(String value, ResponseCode error); void validateParam(String value, ResponseCode error, String errorMsgArgument); void validateListParamSize(String paramName, String key, List<Object> listValue); ProjectCommonException createExceptionByResponseCode(ResponseCode code, int errorCode); ProjectCommonException createExceptionByResponseCode(
ResponseCode code, int errorCode, String errorMsgArgument); void checkMandatoryFieldsPresent(Map<String, Object> data, String... keys); void checkMandatoryFieldsPresent(
Map<String, Object> data, List<String> mandatoryParamsList); void checkMandatoryParamsPresent(
Map<String, Object> data, String exceptionMsg, String... keys); void checkReadOnlyAttributesAbsent(Map<String, Object> data, String... keys); void checkMandatoryHeadersPresent(Map<String, String[]> data, String... keys); void checkForFieldsNotAllowed(Map<String, Object> requestMap, List<String> fields); void validateListParamWithPrefix(
Map<String, Object> requestMap, String fieldPrefix, String... fields); void validateListParam(Map<String, Object> requestMap, String... fields); void validateDateParam(String dob); void validateParamValue(String value, ResponseCode error, String errorMsg); static void validateUserId(Request request, String userIdKey); void validateSearchRequest(Request request); void validateEmail(String email); void validatePhone(String phone); } | @Test public void testValidateSearchRequestFailureWithInvalidFieldType() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.FILTERS, new HashMap<>()); requestObj.put(JsonKey.FIELDS, "invalid"); request.setRequest(requestObj); try { baseRequestValidator.validateSearchRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.dataTypeError.getErrorCode(), e.getCode()); assertEquals( MessageFormat.format( ResponseCode.dataTypeError.getErrorMessage(), JsonKey.FIELDS, "List"), e.getMessage()); } }
@Test public void testValidateSearchRequestFailureWithInvalidFieldsValueInList() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.FILTERS, new HashMap<>()); requestObj.put(JsonKey.FIELDS, Arrays.asList(1)); request.setRequest(requestObj); try { baseRequestValidator.validateSearchRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.dataTypeError.getErrorCode(), e.getCode()); assertEquals( MessageFormat.format( ResponseCode.dataTypeError.getErrorMessage(), JsonKey.FIELDS, "List of String"), e.getMessage()); } }
@Test public void testValidateSearchRequestFailureWithInvalidFiltersKeyAsNull() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); Map<String, Object> filterMap = new HashMap<>(); filterMap.put(null, "data"); requestObj.put(JsonKey.FILTERS, filterMap); request.setRequest(requestObj); try { baseRequestValidator.validateSearchRequest(request); } catch (ProjectCommonException e) { assertEquals( MessageFormat.format( ResponseCode.invalidParameterValue.getErrorMessage(), null, JsonKey.FILTERS), e.getMessage()); } }
@Test public void testValidateSearchRequestFailureWithInvalidFiltersNullValueInList() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); Map<String, Object> filterMap = new HashMap<>(); List<String> data = new ArrayList<>(); data.add(null); filterMap.put(JsonKey.FIRST_NAME, data); requestObj.put(JsonKey.FILTERS, filterMap); request.setRequest(requestObj); try { baseRequestValidator.validateSearchRequest(request); } catch (ProjectCommonException e) { assertEquals( MessageFormat.format( ResponseCode.invalidParameterValue.getErrorMessage(), null, JsonKey.FIRST_NAME), e.getMessage()); } }
@Test public void testValidateSearchRequestFailureWithInvalidFiltersNullValueInMap() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); Map<String, Object> filterMap = new HashMap<>(); Map<String, Object> data = new HashMap<>(); data.put(JsonKey.FIRST_NAME, null); filterMap.put(JsonKey.FIELD, data); requestObj.put(JsonKey.FILTERS, filterMap); request.setRequest(requestObj); try { baseRequestValidator.validateSearchRequest(request); } catch (ProjectCommonException e) { assertEquals( MessageFormat.format( ResponseCode.invalidParameterValue.getErrorMessage(), null, JsonKey.FIRST_NAME), e.getMessage()); } }
@Test public void testValidateSearchRequestFailureWithInvalidFiltersNullValueInString() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); Map<String, Object> data = new HashMap<>(); data.put(JsonKey.FIRST_NAME, null); requestObj.put(JsonKey.FILTERS, data); request.setRequest(requestObj); try { baseRequestValidator.validateSearchRequest(request); } catch (ProjectCommonException e) { assertEquals( MessageFormat.format( ResponseCode.invalidParameterValue.getErrorMessage(), null, JsonKey.FIRST_NAME), e.getMessage()); } } |
UserRequestValidator extends BaseRequestValidator { public void validateCreateUserRequest(Request userRequest) { externalIdsValidation(userRequest, JsonKey.CREATE); fieldsNotAllowed( Arrays.asList( JsonKey.REGISTERED_ORG_ID, JsonKey.ROOT_ORG_ID, JsonKey.PROVIDER, JsonKey.EXTERNAL_ID, JsonKey.EXTERNAL_ID_PROVIDER, JsonKey.EXTERNAL_ID_TYPE, JsonKey.ID_TYPE), userRequest); createUserBasicValidation(userRequest); validateUserType(userRequest); phoneValidation(userRequest); validateLocationCodes(userRequest); validatePassword((String) userRequest.getRequest().get(JsonKey.PASSWORD)); } void validateCreateUserRequest(Request userRequest); static boolean isGoodPassword(String password); void validateUserCreateV3(Request userRequest); void validateCreateUserV3Request(Request userRequest); void validateUserCreateV4(Request userRequest); void validateCreateUserV1Request(Request userRequest); void validateCreateUserV2Request(Request userRequest); void fieldsNotAllowed(List<String> fields, Request userRequest); void phoneValidation(Request userRequest); void createUserBasicValidation(Request userRequest); void validateUpdateUserRequest(Request userRequest); void externalIdsValidation(Request userRequest, String operation); void validateChangePassword(Request userRequest); void validateVerifyUser(Request userRequest); void validateAssignRole(Request request); void validateForgotPassword(Request request); @SuppressWarnings("unchecked") void validateMandatoryFrameworkFields(
Map<String, Object> userMap,
List<String> frameworkFields,
List<String> frameworkMandatoryFields); @SuppressWarnings("unchecked") void validateFrameworkCategoryValues(
Map<String, Object> userMap, Map<String, List<Map<String, String>>> frameworkMap); void validateUserMergeRequest(
Request request, String authUserToken, String sourceUserToken); void validateCertValidationRequest(Request request); void validateUserId(String uuid); void validateUserDeclarationRequest(Request userDeclareRequest); } | @Test public void testValidatePasswordFailure() { Request request = initailizeRequest(); Map<String, Object> requestObj = request.getRequest(); requestObj.put(JsonKey.PASSWORD, "password"); request.setRequest(requestObj); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.passwordValidation.getErrorCode(), e.getCode()); } }
@Test public void testValidatePasswordSuccess() { boolean response = false; Request request = initailizeRequest(); Map<String, Object> requestObj = request.getRequest(); requestObj.put(JsonKey.PASSWORD, "Password@1"); request.setRequest(requestObj); try { userRequestValidator.validateCreateUserRequest(request); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); } assertEquals(true, response); }
@Test public void testValidateLocationCodesSuccess() { boolean response = false; Request request = initailizeRequest(); Map<String, Object> requestObj = request.getRequest(); List<String> location = new ArrayList<>(); location.add("KA"); location.add("AP"); requestObj.put(JsonKey.LOCATION_CODES, location); request.setRequest(requestObj); try { userRequestValidator.validateCreateUserRequest(request); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.dataTypeError.getErrorCode(), e.getCode()); } assertEquals(true, response); }
@Test public void testValidateLocationCodesFailure() { Request request = initailizeRequest(); Map<String, Object> requestObj = request.getRequest(); requestObj.put(JsonKey.LOCATION_CODES, "AP"); request.setRequest(requestObj); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.dataTypeError.getErrorCode(), e.getCode()); } }
@Test public void testCreateUserSuccess() { boolean response = false; Request request = initailizeRequest(); Map<String, Object> requestObj = request.getRequest(); List<String> roles = new ArrayList<String>(); roles.add("PUBLIC"); roles.add("CONTENT-CREATOR"); requestObj.put(JsonKey.ROLE, roles); List<String> language = new ArrayList<>(); language.add("English"); requestObj.put(JsonKey.LANGUAGE, language); List<Map<String, Object>> addressList = new ArrayList<>(); Map<String, Object> map = new HashMap<>(); map.put(JsonKey.ADDRESS_LINE1, "test"); map.put(JsonKey.CITY, "Bangalore"); map.put(JsonKey.COUNTRY, "India"); map.put(JsonKey.ADD_TYPE, "current"); addressList.add(map); requestObj.put(JsonKey.ADDRESS, addressList); List<Map<String, Object>> educationList = new ArrayList<>(); Map<String, Object> map1 = new HashMap<>(); map1.put(JsonKey.COURSE_NAME, "M.C.A"); map1.put(JsonKey.DEGREE, "Master"); map1.put(JsonKey.NAME, "CUSAT"); educationList.add(map1); requestObj.put(JsonKey.EDUCATION, educationList); List<Map<String, Object>> jobProfileList = new ArrayList<>(); map1 = new HashMap<>(); map1.put(JsonKey.JOB_NAME, "SE"); map1.put(JsonKey.ORGANISATION_NAME, "Tarento"); jobProfileList.add(map1); requestObj.put(JsonKey.JOB_PROFILE, jobProfileList); request.setRequest(requestObj); try { userRequestValidator.validateCreateUserRequest(request); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); } assertEquals(true, response); }
@Test public void testValidateCreateUserFailureWithWrongAddType() { Request request = initailizeRequest(); Map<String, Object> requestObj = request.getRequest(); List<String> roles = new ArrayList<String>(); roles.add("PUBLIC"); roles.add("CONTENT-CREATOR"); requestObj.put(JsonKey.ROLE, roles); List<String> language = new ArrayList<>(); language.add("English"); requestObj.put(JsonKey.LANGUAGE, language); List<Map<String, Object>> addressList = new ArrayList<>(); Map<String, Object> map = new HashMap<>(); map.put(JsonKey.ADDRESS_LINE1, "test"); map.put(JsonKey.CITY, "Bangalore"); map.put(JsonKey.COUNTRY, "India"); map.put(JsonKey.ADD_TYPE, "lmlkmkl"); addressList.add(map); requestObj.put(JsonKey.ADDRESS, addressList); List<Map<String, Object>> educationList = new ArrayList<>(); Map<String, Object> map1 = new HashMap<>(); map1.put(JsonKey.COURSE_NAME, "M.C.A"); map1.put(JsonKey.DEGREE, "Master"); map1.put(JsonKey.NAME, "CUSAT"); educationList.add(map1); requestObj.put(JsonKey.EDUCATION, educationList); List<Map<String, Object>> jobProfileList = new ArrayList<>(); map1 = new HashMap<>(); map1.put(JsonKey.JOB_NAME, "SE"); map1.put(JsonKey.ORGANISATION_NAME, "Tarento"); jobProfileList.add(map1); requestObj.put(JsonKey.JOB_PROFILE, jobProfileList); request.setRequest(requestObj); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.addressTypeError.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserFailureWithEmptyAddType() { Request request = initailizeRequest(); Map<String, Object> requestObj = request.getRequest(); List<String> roles = new ArrayList<String>(); roles.add("PUBLIC"); roles.add("CONTENT-CREATOR"); requestObj.put(JsonKey.ROLE, roles); List<String> language = new ArrayList<>(); language.add("English"); requestObj.put(JsonKey.LANGUAGE, language); List<Map<String, Object>> addressList = new ArrayList<>(); Map<String, Object> map = new HashMap<>(); map.put(JsonKey.ADDRESS_LINE1, "test"); map.put(JsonKey.CITY, "Bangalore"); map.put(JsonKey.COUNTRY, "India"); map.put(JsonKey.ADD_TYPE, ""); addressList.add(map); requestObj.put(JsonKey.ADDRESS, addressList); List<Map<String, Object>> educationList = new ArrayList<>(); Map<String, Object> map1 = new HashMap<>(); map1.put(JsonKey.COURSE_NAME, "M.C.A"); map1.put(JsonKey.DEGREE, "Master"); map1.put(JsonKey.NAME, "CUSAT"); educationList.add(map1); requestObj.put(JsonKey.EDUCATION, educationList); List<Map<String, Object>> jobProfileList = new ArrayList<>(); map1 = new HashMap<>(); map1.put(JsonKey.JOB_NAME, "SE"); map1.put(JsonKey.ORGANISATION_NAME, "Tarento"); jobProfileList.add(map1); requestObj.put(JsonKey.JOB_PROFILE, jobProfileList); request.setRequest(requestObj); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.addressError.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserRequestFailureWithInvalidLanguage() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.PHONE, "9321234123"); requestObj.put(JsonKey.EMAIL, "[email protected]"); requestObj.put(JsonKey.EMAIL_VERIFIED, true); requestObj.put(JsonKey.USERNAME, "test123"); requestObj.put(JsonKey.FIRST_NAME, "test123"); requestObj.put(JsonKey.LANGUAGE, ""); request.setRequest(requestObj); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.dataTypeError.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserRequestFailureWithInvalidAddress() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.PHONE, "9321234123"); requestObj.put(JsonKey.PHONE_VERIFIED, true); requestObj.put(JsonKey.EMAIL, "[email protected]"); requestObj.put(JsonKey.EMAIL_VERIFIED, true); requestObj.put(JsonKey.USERNAME, "test123"); requestObj.put(JsonKey.FIRST_NAME, "test123"); requestObj.put(JsonKey.ADDRESS, ""); request.setRequest(requestObj); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.dataTypeError.getErrorCode(), e.getCode()); } }
@Test public void testValidaeCreateUserRequestFailureWithInvalidEducation() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.PHONE, "9321234123"); requestObj.put(JsonKey.PHONE_VERIFIED, true); requestObj.put(JsonKey.EMAIL, "[email protected]"); requestObj.put(JsonKey.EMAIL_VERIFIED, true); requestObj.put(JsonKey.USERNAME, "test123"); requestObj.put(JsonKey.FIRST_NAME, "test123"); requestObj.put(JsonKey.EDUCATION, ""); request.setRequest(requestObj); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.dataTypeError.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserRequestFailureWithInvalidAddressType() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.PHONE, "9321234123"); requestObj.put(JsonKey.PHONE_VERIFIED, true); requestObj.put(JsonKey.EMAIL, "[email protected]"); requestObj.put(JsonKey.EMAIL_VERIFIED, true); requestObj.put(JsonKey.USERNAME, "test123"); requestObj.put(JsonKey.FIRST_NAME, "test123"); List<Map<String, Object>> addressList = new ArrayList<>(); Map<String, Object> map = new HashMap<>(); map.put(JsonKey.ADDRESS_LINE1, "test"); map.put(JsonKey.CITY, "Bangalore"); map.put(JsonKey.COUNTRY, "India"); map.put(JsonKey.ADD_TYPE, "localr"); addressList.add(map); requestObj.put(JsonKey.ADDRESS, addressList); request.setRequest(requestObj); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.addressTypeError.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserRequestFailureWithInvalidCountryCode() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.PHONE, "9321234123"); requestObj.put(JsonKey.PHONE_VERIFIED, true); requestObj.put(JsonKey.EMAIL, "[email protected]"); requestObj.put(JsonKey.EMAIL_VERIFIED, true); requestObj.put(JsonKey.USERNAME, "test123"); requestObj.put(JsonKey.FIRST_NAME, "test123"); request.setRequest(requestObj); request.getRequest().put(JsonKey.COUNTRY_CODE, "+as"); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.invalidCountryCode.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserRequestFailureWithEmptyEmailAndPhone() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.USERNAME, "test123"); requestObj.put(JsonKey.PHONE, "9321234123"); requestObj.put(JsonKey.PHONE_VERIFIED, true); requestObj.put(JsonKey.FIRST_NAME, "test123"); requestObj.put(JsonKey.EMAIL, ""); requestObj.put(JsonKey.PHONE, ""); request.setRequest(requestObj); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.emailorPhoneorManagedByRequired.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserFailureWithInvalidEmail() { Request request = initailizeRequest(); request.getRequest().put(JsonKey.EMAIL, "am@ds@cmo"); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.emailFormatError.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserFailureWithoutPhoneVerified() { Request request = initailizeRequest(); request.getRequest().put(JsonKey.PHONE, "7894561230"); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.phoneVerifiedError.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserSuccess() { Request request = initailizeRequest(); request.getRequest().put(JsonKey.PHONE, "7894561230"); request.getRequest().put(JsonKey.PHONE_VERIFIED, ""); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.phoneVerifiedError.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserFailureWithPhoneVerifiedFalse() { Request request = initailizeRequest(); request.getRequest().put(JsonKey.PHONE, "7894561230"); request.getRequest().put(JsonKey.PHONE_VERIFIED, false); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.phoneVerifiedError.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserFailureWithEmptyEducationName() { Request request = initailizeRequest(); request.getRequest().put(JsonKey.PHONE_VERIFIED, true); Map<String, Object> map = new HashMap<>(); map.put(JsonKey.NAME, ""); List<Map<String, Object>> list = new ArrayList<>(); list.add(map); request.getRequest().put(JsonKey.EDUCATION, list); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.educationNameError.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserFailureWithEmptyEducationDegree() { Request request = initailizeRequest(); request.getRequest().put(JsonKey.PHONE_VERIFIED, true); Map<String, Object> map = new HashMap<>(); map.put(JsonKey.NAME, "name"); map.put(JsonKey.DEGREE, ""); List<Map<String, Object>> list = new ArrayList<>(); list.add(map); request.getRequest().put(JsonKey.EDUCATION, list); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.educationDegreeError.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserFailureWithEmptyEducationAddress() { Request request = initailizeRequest(); request.getRequest().put(JsonKey.PHONE_VERIFIED, true); Map<String, Object> map = new HashMap<>(); map.put(JsonKey.NAME, "name"); map.put(JsonKey.DEGREE, "degree"); Map<String, Object> address = new HashMap<>(); address.put(JsonKey.ADDRESS_LINE1, ""); map.put(JsonKey.ADDRESS, address); List<Map<String, Object>> list = new ArrayList<>(); list.add(map); request.getRequest().put(JsonKey.EDUCATION, list); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.addressError.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserFailureWithEmptyEducationCity() { Request request = initailizeRequest(); request.getRequest().put(JsonKey.PHONE_VERIFIED, true); Map<String, Object> map = new HashMap<>(); map.put(JsonKey.NAME, "name"); map.put(JsonKey.DEGREE, "degree"); Map<String, Object> address = new HashMap<>(); address.put(JsonKey.ADDRESS_LINE1, "line1"); address.put(JsonKey.CITY, ""); map.put(JsonKey.ADDRESS, address); List<Map<String, Object>> list = new ArrayList<>(); list.add(map); request.getRequest().put(JsonKey.EDUCATION, list); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.addressError.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserFailureWithEmptyJobProfile() { Request request = initailizeRequest(); request.getRequest().put(JsonKey.PHONE_VERIFIED, true); request.getRequest().put(JsonKey.JOB_PROFILE, ""); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.dataTypeError.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserFailureWithEmptyJobName() { Request request = initailizeRequest(); Map<String, Object> map = new HashMap<>(); map.put(JsonKey.JOB_NAME, ""); map.put(JsonKey.ORG_NAME, "degree"); List<Map<String, Object>> list = new ArrayList<>(); list.add(map); request.getRequest().put(JsonKey.JOB_PROFILE, list); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.jobNameError.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserFailureWithInvalidJobProfileJoiningDate() { Request request = initailizeRequest(); Map<String, Object> map = new HashMap<>(); map.put(JsonKey.JOB_NAME, "kijklo"); map.put(JsonKey.ORG_NAME, "degree"); map.put(JsonKey.JOINING_DATE, "20-15-18"); List<Map<String, Object>> list = new ArrayList<>(); list.add(map); request.getRequest().put(JsonKey.JOB_PROFILE, list); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.dateFormatError.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserFailureWithInvalidJobProfileEndDate() { Request request = initailizeRequest(); Map<String, Object> map = new HashMap<>(); map.put(JsonKey.JOB_NAME, "kijklo"); map.put(JsonKey.ORG_NAME, "degree"); map.put(JsonKey.END_DATE, "20-15-18"); List<Map<String, Object>> list = new ArrayList<>(); list.add(map); request.getRequest().put(JsonKey.JOB_PROFILE, list); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.dateFormatError.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserFailureWithEmptyJobProfileOrgName() { Request request = initailizeRequest(); Map<String, Object> map = new HashMap<>(); map.put(JsonKey.JOB_NAME, "kijklo"); map.put(JsonKey.ORG_NAME, ""); List<Map<String, Object>> list = new ArrayList<>(); list.add(map); request.getRequest().put(JsonKey.JOB_PROFILE, list); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.organisationNameError.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserFailureWithEmptyJobProfileCity() { Request request = initailizeRequest(); Map<String, Object> map = new HashMap<>(); map.put(JsonKey.JOB_NAME, "jabName"); map.put(JsonKey.ORG_NAME, "orgName"); Map<String, Object> address = new HashMap<>(); address.put(JsonKey.ADDRESS_LINE1, "line1"); address.put(JsonKey.CITY, ""); map.put(JsonKey.ADDRESS, address); List<Map<String, Object>> list = new ArrayList<>(); list.add(map); request.getRequest().put(JsonKey.JOB_PROFILE, list); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.addressError.getErrorCode(), e.getCode()); } }
@Test public void testValidateCreateUserFailureWithInvalidPhoneFormat() { Request request = new Request(); request.getRequest().put(JsonKey.EMAIL, "[email protected]"); request.getRequest().put(JsonKey.EMAIL_VERIFIED, true); request.getRequest().put(JsonKey.PHONE, "9874561230"); request.getRequest().put(JsonKey.COUNTRY_CODE, "+001"); request.getRequest().put(JsonKey.USERNAME, "98745"); request.getRequest().put(JsonKey.FIRST_NAME, "98745"); try { userRequestValidator.validateCreateUserRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.phoneNoFormatError.getErrorCode(), e.getCode()); } } |
UserRequestValidator extends BaseRequestValidator { public static boolean isGoodPassword(String password) { return password.matches(ProjectUtil.getConfigValue(JsonKey.SUNBIRD_PASS_REGEX)); } void validateCreateUserRequest(Request userRequest); static boolean isGoodPassword(String password); void validateUserCreateV3(Request userRequest); void validateCreateUserV3Request(Request userRequest); void validateUserCreateV4(Request userRequest); void validateCreateUserV1Request(Request userRequest); void validateCreateUserV2Request(Request userRequest); void fieldsNotAllowed(List<String> fields, Request userRequest); void phoneValidation(Request userRequest); void createUserBasicValidation(Request userRequest); void validateUpdateUserRequest(Request userRequest); void externalIdsValidation(Request userRequest, String operation); void validateChangePassword(Request userRequest); void validateVerifyUser(Request userRequest); void validateAssignRole(Request request); void validateForgotPassword(Request request); @SuppressWarnings("unchecked") void validateMandatoryFrameworkFields(
Map<String, Object> userMap,
List<String> frameworkFields,
List<String> frameworkMandatoryFields); @SuppressWarnings("unchecked") void validateFrameworkCategoryValues(
Map<String, Object> userMap, Map<String, List<Map<String, String>>> frameworkMap); void validateUserMergeRequest(
Request request, String authUserToken, String sourceUserToken); void validateCertValidationRequest(Request request); void validateUserId(String uuid); void validateUserDeclarationRequest(Request userDeclareRequest); } | @Test public void testIsGoodPassword() { HashMap<String, Boolean> passwordExpectations = new HashMap<String, Boolean>() { { put("Test 1234", false); put("hello1234", false); put("helloABCD", false); put("hello#$%&'", false); put("sho!1", false); put("B1!\"#$%&'()*+,-./:;<=>?@[]^_`{|}~", false); put("Test @1234", false); put("Test123!", true); put("ALongPassword@123", true); put("Abc1!\"#$%&'()*+,-./:;<=>?@[]^_`{|}~", true); } }; passwordExpectations.forEach( (pwd, expectedResult) -> { assertEquals(expectedResult, UserRequestValidator.isGoodPassword(pwd)); }); } |
UserRequestValidator extends BaseRequestValidator { public void createUserBasicValidation(Request userRequest) { createUserBasicProfileFieldsValidation(userRequest); if (userRequest.getRequest().containsKey(JsonKey.ROLES) && null != userRequest.getRequest().get(JsonKey.ROLES) && !(userRequest.getRequest().get(JsonKey.ROLES) instanceof List)) { throw new ProjectCommonException( ResponseCode.dataTypeError.getErrorCode(), ProjectUtil.formatMessage( ResponseCode.dataTypeError.getErrorMessage(), JsonKey.ROLES, JsonKey.LIST), ERROR_CODE); } if (userRequest.getRequest().containsKey(JsonKey.LANGUAGE) && null != userRequest.getRequest().get(JsonKey.LANGUAGE) && !(userRequest.getRequest().get(JsonKey.LANGUAGE) instanceof List)) { throw new ProjectCommonException( ResponseCode.dataTypeError.getErrorCode(), ProjectUtil.formatMessage( ResponseCode.dataTypeError.getErrorMessage(), JsonKey.LANGUAGE, JsonKey.LIST), ERROR_CODE); } } void validateCreateUserRequest(Request userRequest); static boolean isGoodPassword(String password); void validateUserCreateV3(Request userRequest); void validateCreateUserV3Request(Request userRequest); void validateUserCreateV4(Request userRequest); void validateCreateUserV1Request(Request userRequest); void validateCreateUserV2Request(Request userRequest); void fieldsNotAllowed(List<String> fields, Request userRequest); void phoneValidation(Request userRequest); void createUserBasicValidation(Request userRequest); void validateUpdateUserRequest(Request userRequest); void externalIdsValidation(Request userRequest, String operation); void validateChangePassword(Request userRequest); void validateVerifyUser(Request userRequest); void validateAssignRole(Request request); void validateForgotPassword(Request request); @SuppressWarnings("unchecked") void validateMandatoryFrameworkFields(
Map<String, Object> userMap,
List<String> frameworkFields,
List<String> frameworkMandatoryFields); @SuppressWarnings("unchecked") void validateFrameworkCategoryValues(
Map<String, Object> userMap, Map<String, List<Map<String, String>>> frameworkMap); void validateUserMergeRequest(
Request request, String authUserToken, String sourceUserToken); void validateCertValidationRequest(Request request); void validateUserId(String uuid); void validateUserDeclarationRequest(Request userDeclareRequest); } | @Test public void testValidateCreateUserBasicValidationFailure() { Request request = initailizeRequest(); Map<String, Object> requestObj = request.getRequest(); requestObj.put(JsonKey.ROLES, "admin"); request.setRequest(requestObj); try { userRequestValidator.createUserBasicValidation(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.dataTypeError.getErrorCode(), e.getCode()); } }
@Test public void testCreateUserBasicValidationFailureWithoutEmailAndPhone() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.USERNAME, "test123"); requestObj.put(JsonKey.FIRST_NAME, "test123"); requestObj.put(JsonKey.DOB, "2018-10-15"); request.setRequest(requestObj); try { userRequestValidator.createUserBasicValidation(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.emailorPhoneorManagedByRequired.getErrorCode(), e.getCode()); } }
@Test public void testCreateUserBasicValidationFailureWithInvalidEmail() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.USERNAME, "test123"); requestObj.put(JsonKey.FIRST_NAME, "test123"); requestObj.put(JsonKey.DOB, "2018-10-15"); requestObj.put(JsonKey.EMAIL, "asd@as"); request.setRequest(requestObj); try { userRequestValidator.createUserBasicValidation(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.emailFormatError.getErrorCode(), e.getCode()); } } |
UserRequestValidator extends BaseRequestValidator { public void fieldsNotAllowed(List<String> fields, Request userRequest) { for (String field : fields) { if (((userRequest.getRequest().get(field) instanceof String) && StringUtils.isNotBlank((String) userRequest.getRequest().get(field))) || (null != userRequest.getRequest().get(field))) { throw new ProjectCommonException( ResponseCode.invalidRequestParameter.getErrorCode(), ProjectUtil.formatMessage( ResponseCode.invalidRequestParameter.getErrorMessage(), field), ERROR_CODE); } } } void validateCreateUserRequest(Request userRequest); static boolean isGoodPassword(String password); void validateUserCreateV3(Request userRequest); void validateCreateUserV3Request(Request userRequest); void validateUserCreateV4(Request userRequest); void validateCreateUserV1Request(Request userRequest); void validateCreateUserV2Request(Request userRequest); void fieldsNotAllowed(List<String> fields, Request userRequest); void phoneValidation(Request userRequest); void createUserBasicValidation(Request userRequest); void validateUpdateUserRequest(Request userRequest); void externalIdsValidation(Request userRequest, String operation); void validateChangePassword(Request userRequest); void validateVerifyUser(Request userRequest); void validateAssignRole(Request request); void validateForgotPassword(Request request); @SuppressWarnings("unchecked") void validateMandatoryFrameworkFields(
Map<String, Object> userMap,
List<String> frameworkFields,
List<String> frameworkMandatoryFields); @SuppressWarnings("unchecked") void validateFrameworkCategoryValues(
Map<String, Object> userMap, Map<String, List<Map<String, String>>> frameworkMap); void validateUserMergeRequest(
Request request, String authUserToken, String sourceUserToken); void validateCertValidationRequest(Request request); void validateUserId(String uuid); void validateUserDeclarationRequest(Request userDeclareRequest); } | @Test public void testValidateFieldsNotAllowedFailure() { Request request = initailizeRequest(); Map<String, Object> requestObj = request.getRequest(); requestObj.put(JsonKey.PROVIDER, "AP"); request.setRequest(requestObj); try { userRequestValidator.fieldsNotAllowed( Arrays.asList( JsonKey.REGISTERED_ORG_ID, JsonKey.ROOT_ORG_ID, JsonKey.PROVIDER, JsonKey.EXTERNAL_ID, JsonKey.EXTERNAL_ID_PROVIDER, JsonKey.EXTERNAL_ID_TYPE, JsonKey.ID_TYPE), request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.invalidRequestParameter.getErrorCode(), e.getCode()); } } |
UserRequestValidator extends BaseRequestValidator { public void validateCreateUserV3Request(Request userRequest) { validateCreateUserRequest(userRequest); } void validateCreateUserRequest(Request userRequest); static boolean isGoodPassword(String password); void validateUserCreateV3(Request userRequest); void validateCreateUserV3Request(Request userRequest); void validateUserCreateV4(Request userRequest); void validateCreateUserV1Request(Request userRequest); void validateCreateUserV2Request(Request userRequest); void fieldsNotAllowed(List<String> fields, Request userRequest); void phoneValidation(Request userRequest); void createUserBasicValidation(Request userRequest); void validateUpdateUserRequest(Request userRequest); void externalIdsValidation(Request userRequest, String operation); void validateChangePassword(Request userRequest); void validateVerifyUser(Request userRequest); void validateAssignRole(Request request); void validateForgotPassword(Request request); @SuppressWarnings("unchecked") void validateMandatoryFrameworkFields(
Map<String, Object> userMap,
List<String> frameworkFields,
List<String> frameworkMandatoryFields); @SuppressWarnings("unchecked") void validateFrameworkCategoryValues(
Map<String, Object> userMap, Map<String, List<Map<String, String>>> frameworkMap); void validateUserMergeRequest(
Request request, String authUserToken, String sourceUserToken); void validateCertValidationRequest(Request request); void validateUserId(String uuid); void validateUserDeclarationRequest(Request userDeclareRequest); } | @Test public void testValidateValidateCreateUserV3RequestSuccess() { boolean response = false; Request request = initailizeRequest(); Map<String, Object> requestObj = request.getRequest(); requestObj.put(JsonKey.PASSWORD, "Password@1"); request.setRequest(requestObj); try { userRequestValidator.validateCreateUserV3Request(request); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); } assertEquals(true, response); } |
UserRequestValidator extends BaseRequestValidator { public void validateUserCreateV3(Request userRequest) { validateParam( (String) userRequest.getRequest().get(JsonKey.FIRST_NAME), ResponseCode.mandatoryParamsMissing, JsonKey.FIRST_NAME); if (StringUtils.isBlank((String) userRequest.getRequest().get(JsonKey.EMAIL)) && StringUtils.isBlank((String) userRequest.getRequest().get(JsonKey.PHONE)) && StringUtils.isBlank((String) userRequest.getRequest().get(JsonKey.MANAGED_BY))) { ProjectCommonException.throwClientErrorException( ResponseCode.emailorPhoneorManagedByRequired); } if ((StringUtils.isNotBlank((String) userRequest.getRequest().get(JsonKey.EMAIL)) || StringUtils.isNotBlank((String) userRequest.getRequest().get(JsonKey.PHONE))) && StringUtils.isNotBlank((String) userRequest.getRequest().get(JsonKey.MANAGED_BY))) { ProjectCommonException.throwClientErrorException( ResponseCode.OnlyEmailorPhoneorManagedByRequired); } if (StringUtils.isNotBlank((String) userRequest.getRequest().get(JsonKey.MANAGED_BY))) { userRequest.getRequest().put(JsonKey.EMAIL_VERIFIED, null); userRequest.getRequest().put(JsonKey.PHONE_VERIFIED, null); } phoneVerifiedValidation(userRequest); emailVerifiedValidation(userRequest); validatePassword((String) userRequest.getRequest().get(JsonKey.PASSWORD)); if (StringUtils.isNotBlank((String) userRequest.getRequest().get(JsonKey.EMAIL))) { validateEmail((String) userRequest.getRequest().get(JsonKey.EMAIL)); } if (StringUtils.isNotBlank((String) userRequest.getRequest().get(JsonKey.PHONE))) { validatePhone((String) userRequest.getRequest().get(JsonKey.PHONE)); } } void validateCreateUserRequest(Request userRequest); static boolean isGoodPassword(String password); void validateUserCreateV3(Request userRequest); void validateCreateUserV3Request(Request userRequest); void validateUserCreateV4(Request userRequest); void validateCreateUserV1Request(Request userRequest); void validateCreateUserV2Request(Request userRequest); void fieldsNotAllowed(List<String> fields, Request userRequest); void phoneValidation(Request userRequest); void createUserBasicValidation(Request userRequest); void validateUpdateUserRequest(Request userRequest); void externalIdsValidation(Request userRequest, String operation); void validateChangePassword(Request userRequest); void validateVerifyUser(Request userRequest); void validateAssignRole(Request request); void validateForgotPassword(Request request); @SuppressWarnings("unchecked") void validateMandatoryFrameworkFields(
Map<String, Object> userMap,
List<String> frameworkFields,
List<String> frameworkMandatoryFields); @SuppressWarnings("unchecked") void validateFrameworkCategoryValues(
Map<String, Object> userMap, Map<String, List<Map<String, String>>> frameworkMap); void validateUserMergeRequest(
Request request, String authUserToken, String sourceUserToken); void validateCertValidationRequest(Request request); void validateUserId(String uuid); void validateUserDeclarationRequest(Request userDeclareRequest); } | @Test public void testValidateUserCreateV3Success() { boolean response = false; Request request = initailizeRequest(); Map<String, Object> requestObj = request.getRequest(); requestObj.put(JsonKey.PASSWORD, "Password@1"); request.setRequest(requestObj); try { userRequestValidator.validateUserCreateV3(request); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); } assertEquals(true, response); }
@Test public void testValidateUserCreateV3Failure() { Request request = initailizeRequest(); Map<String, Object> requestObj = request.getRequest(); requestObj.put(JsonKey.FIRST_NAME, ""); request.setRequest(requestObj); try { userRequestValidator.validateUserCreateV3(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.mandatoryParamsMissing.getErrorCode(), e.getCode()); } }
@Test public void validateUserCreateV3Sussess() { boolean response = true; try { Request request = new Request(); request.getRequest().put(JsonKey.FIRST_NAME, "test name"); request.getRequest().put(JsonKey.EMAIL, "[email protected]"); request.getRequest().put(JsonKey.EMAIL_VERIFIED, true); request.getRequest().put(JsonKey.PHONE, "9663890445"); request.getRequest().put(JsonKey.PHONE_VERIFIED, true); new UserRequestValidator().validateUserCreateV3(request); } catch (Exception e) { response = false; } Assert.assertTrue(response); } |
UserRequestValidator extends BaseRequestValidator { public void validateCreateUserV1Request(Request userRequest) { validateUserName(userRequest); validateCreateUserV3Request(userRequest); } void validateCreateUserRequest(Request userRequest); static boolean isGoodPassword(String password); void validateUserCreateV3(Request userRequest); void validateCreateUserV3Request(Request userRequest); void validateUserCreateV4(Request userRequest); void validateCreateUserV1Request(Request userRequest); void validateCreateUserV2Request(Request userRequest); void fieldsNotAllowed(List<String> fields, Request userRequest); void phoneValidation(Request userRequest); void createUserBasicValidation(Request userRequest); void validateUpdateUserRequest(Request userRequest); void externalIdsValidation(Request userRequest, String operation); void validateChangePassword(Request userRequest); void validateVerifyUser(Request userRequest); void validateAssignRole(Request request); void validateForgotPassword(Request request); @SuppressWarnings("unchecked") void validateMandatoryFrameworkFields(
Map<String, Object> userMap,
List<String> frameworkFields,
List<String> frameworkMandatoryFields); @SuppressWarnings("unchecked") void validateFrameworkCategoryValues(
Map<String, Object> userMap, Map<String, List<Map<String, String>>> frameworkMap); void validateUserMergeRequest(
Request request, String authUserToken, String sourceUserToken); void validateCertValidationRequest(Request request); void validateUserId(String uuid); void validateUserDeclarationRequest(Request userDeclareRequest); } | @Test public void testValidateUserNameFailure() { Request request = initailizeRequest(); Map<String, Object> requestObj = request.getRequest(); requestObj.put(JsonKey.USERNAME, ""); request.setRequest(requestObj); try { userRequestValidator.validateCreateUserV1Request(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.mandatoryParamsMissing.getErrorCode(), e.getCode()); } } |
UserRequestValidator extends BaseRequestValidator { public void validateForgotPassword(Request request) { if (request.getRequest().get(JsonKey.USERNAME) == null || StringUtils.isBlank((String) request.getRequest().get(JsonKey.USERNAME))) { throw new ProjectCommonException( ResponseCode.userNameRequired.getErrorCode(), ResponseCode.userNameRequired.getErrorMessage(), ERROR_CODE); } } void validateCreateUserRequest(Request userRequest); static boolean isGoodPassword(String password); void validateUserCreateV3(Request userRequest); void validateCreateUserV3Request(Request userRequest); void validateUserCreateV4(Request userRequest); void validateCreateUserV1Request(Request userRequest); void validateCreateUserV2Request(Request userRequest); void fieldsNotAllowed(List<String> fields, Request userRequest); void phoneValidation(Request userRequest); void createUserBasicValidation(Request userRequest); void validateUpdateUserRequest(Request userRequest); void externalIdsValidation(Request userRequest, String operation); void validateChangePassword(Request userRequest); void validateVerifyUser(Request userRequest); void validateAssignRole(Request request); void validateForgotPassword(Request request); @SuppressWarnings("unchecked") void validateMandatoryFrameworkFields(
Map<String, Object> userMap,
List<String> frameworkFields,
List<String> frameworkMandatoryFields); @SuppressWarnings("unchecked") void validateFrameworkCategoryValues(
Map<String, Object> userMap, Map<String, List<Map<String, String>>> frameworkMap); void validateUserMergeRequest(
Request request, String authUserToken, String sourceUserToken); void validateCertValidationRequest(Request request); void validateUserId(String uuid); void validateUserDeclarationRequest(Request userDeclareRequest); } | @Test public void testValidateForgotPasswordSuccess() { Request request = new Request(); boolean response = false; Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.USERNAME, "manzarul07"); request.setRequest(requestObj); try { userRequestValidator.validateForgotPassword(request); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); } assertEquals(true, response); }
@Test public void testValidateForgotPasswordFailureWithEmptyName() { try { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.USERNAME, ""); request.setRequest(requestObj); userRequestValidator.validateForgotPassword(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.userNameRequired.getErrorCode(), e.getCode()); } }
@Test public void testValidateForgotPasswordFailureWithoutName() { try { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); request.setRequest(requestObj); userRequestValidator.validateForgotPassword(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.userNameRequired.getErrorCode(), e.getCode()); } } |
UserExternalIdentityAdapter { public static List<Map<String, String>> convertSelfDeclareFieldsToExternalIds( Map<String, Object> selfDeclaredFields) { List<Map<String, String>> externalIds = new ArrayList<>(); if (MapUtils.isNotEmpty(selfDeclaredFields)) { Map<String, String> userInfo = (Map<String, String>) selfDeclaredFields.get(JsonKey.USER_INFO); if (MapUtils.isNotEmpty(userInfo)) { for (Map.Entry<String, String> itr : userInfo.entrySet()) { Map<String, String> externalIdMap = new HashMap<>(); externalIdMap.put(JsonKey.USER_ID, (String) selfDeclaredFields.get(JsonKey.USER_ID)); externalIdMap.put(JsonKey.ID_TYPE, itr.getKey()); externalIdMap.put(JsonKey.ORIGINAL_ID_TYPE, itr.getKey()); externalIdMap.put(JsonKey.PROVIDER, (String) selfDeclaredFields.get(JsonKey.ORG_ID)); externalIdMap.put( JsonKey.ORIGINAL_PROVIDER, (String) selfDeclaredFields.get(JsonKey.ORG_ID)); externalIdMap.put(JsonKey.EXTERNAL_ID, itr.getValue()); externalIdMap.put(JsonKey.ORIGINAL_EXTERNAL_ID, itr.getValue()); externalIds.add(externalIdMap); } } } return externalIds; } static List<Map<String, String>> convertSelfDeclareFieldsToExternalIds(
Map<String, Object> selfDeclaredFields); static Map<String, Object> convertExternalFieldsToSelfDeclareFields(
List<Map<String, String>> externalIds); } | @Test public void testConvertSelfDeclareFieldsToExternalIds() { Map<String, Object> selfDeclaredFields = getSelfDeclareFields(); List<Map<String, String>> externalIds = UserExternalIdentityAdapter.convertSelfDeclareFieldsToExternalIds(selfDeclaredFields); String declaredEmail = ""; String declaredPhone = ""; for (Map<String, String> extIdMap : externalIds) { if (JsonKey.DECLARED_EMAIL.equals((String) extIdMap.get(JsonKey.ORIGINAL_ID_TYPE))) { declaredEmail = (String) extIdMap.get(JsonKey.ORIGINAL_EXTERNAL_ID); } if (JsonKey.DECLARED_PHONE.equals((String) extIdMap.get(JsonKey.ORIGINAL_ID_TYPE))) { declaredPhone = (String) extIdMap.get(JsonKey.ORIGINAL_EXTERNAL_ID); } } Assert.assertEquals("[email protected]", declaredEmail); Assert.assertEquals("999999999", declaredPhone); } |
UserRequestValidator extends BaseRequestValidator { public void validateChangePassword(Request userRequest) { if (userRequest.getRequest().get(JsonKey.PASSWORD) == null || (StringUtils.isBlank((String) userRequest.getRequest().get(JsonKey.PASSWORD)))) { ProjectCommonException.throwClientErrorException(ResponseCode.passwordRequired); } if (userRequest.getRequest().get(JsonKey.NEW_PASSWORD) == null) { ProjectCommonException.throwClientErrorException(ResponseCode.newPasswordRequired); } if (StringUtils.isBlank((String) userRequest.getRequest().get(JsonKey.NEW_PASSWORD))) { ProjectCommonException.throwClientErrorException(ResponseCode.newPasswordEmpty); } } void validateCreateUserRequest(Request userRequest); static boolean isGoodPassword(String password); void validateUserCreateV3(Request userRequest); void validateCreateUserV3Request(Request userRequest); void validateUserCreateV4(Request userRequest); void validateCreateUserV1Request(Request userRequest); void validateCreateUserV2Request(Request userRequest); void fieldsNotAllowed(List<String> fields, Request userRequest); void phoneValidation(Request userRequest); void createUserBasicValidation(Request userRequest); void validateUpdateUserRequest(Request userRequest); void externalIdsValidation(Request userRequest, String operation); void validateChangePassword(Request userRequest); void validateVerifyUser(Request userRequest); void validateAssignRole(Request request); void validateForgotPassword(Request request); @SuppressWarnings("unchecked") void validateMandatoryFrameworkFields(
Map<String, Object> userMap,
List<String> frameworkFields,
List<String> frameworkMandatoryFields); @SuppressWarnings("unchecked") void validateFrameworkCategoryValues(
Map<String, Object> userMap, Map<String, List<Map<String, String>>> frameworkMap); void validateUserMergeRequest(
Request request, String authUserToken, String sourceUserToken); void validateCertValidationRequest(Request request); void validateUserId(String uuid); void validateUserDeclarationRequest(Request userDeclareRequest); } | @Test public void testValidateChangePasswordSuccess() { Request request = new Request(); boolean response = false; Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.NEW_PASSWORD, "password1"); requestObj.put(JsonKey.PASSWORD, "password"); request.setRequest(requestObj); try { userRequestValidator.validateChangePassword(request); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); } assertEquals(true, response); }
@Test public void testValidateChangePasswordFailureWithEmptyNewPassword() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.NEW_PASSWORD, ""); requestObj.put(JsonKey.PASSWORD, "password"); request.setRequest(requestObj); try { userRequestValidator.validateChangePassword(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.newPasswordEmpty.getErrorCode(), e.getCode()); } }
@Test public void testValidateChangePasswordFailureWithoutNewPassword() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.PASSWORD, "password"); request.setRequest(requestObj); try { userRequestValidator.validateChangePassword(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.newPasswordRequired.getErrorCode(), e.getCode()); } }
@Test public void testValidateChangePasswordFailureWithSameOldPassword() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.NEW_PASSWORD, "password"); requestObj.put(JsonKey.PASSWORD, "password"); request.setRequest(requestObj); try { userRequestValidator.validateChangePassword(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.samePasswordError.getErrorCode(), e.getCode()); } }
@Test public void testValidateChangePasswordFailureWithPasswordMissing() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.NEW_PASSWORD, "password"); request.setRequest(requestObj); try { userRequestValidator.validateChangePassword(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.passwordRequired.getErrorCode(), e.getCode()); } } |
UserRequestValidator extends BaseRequestValidator { public void phoneValidation(Request userRequest) { if (!StringUtils.isBlank((String) userRequest.getRequest().get(JsonKey.COUNTRY_CODE))) { boolean bool = ProjectUtil.validateCountryCode( (String) userRequest.getRequest().get(JsonKey.COUNTRY_CODE)); if (!bool) { ProjectCommonException.throwClientErrorException(ResponseCode.invalidCountryCode); } } if (StringUtils.isNotBlank((String) userRequest.getRequest().get(JsonKey.PHONE))) { validatePhoneNo( (String) userRequest.getRequest().get(JsonKey.PHONE), (String) userRequest.getRequest().get(JsonKey.COUNTRY_CODE)); } phoneVerifiedValidation(userRequest); } void validateCreateUserRequest(Request userRequest); static boolean isGoodPassword(String password); void validateUserCreateV3(Request userRequest); void validateCreateUserV3Request(Request userRequest); void validateUserCreateV4(Request userRequest); void validateCreateUserV1Request(Request userRequest); void validateCreateUserV2Request(Request userRequest); void fieldsNotAllowed(List<String> fields, Request userRequest); void phoneValidation(Request userRequest); void createUserBasicValidation(Request userRequest); void validateUpdateUserRequest(Request userRequest); void externalIdsValidation(Request userRequest, String operation); void validateChangePassword(Request userRequest); void validateVerifyUser(Request userRequest); void validateAssignRole(Request request); void validateForgotPassword(Request request); @SuppressWarnings("unchecked") void validateMandatoryFrameworkFields(
Map<String, Object> userMap,
List<String> frameworkFields,
List<String> frameworkMandatoryFields); @SuppressWarnings("unchecked") void validateFrameworkCategoryValues(
Map<String, Object> userMap, Map<String, List<Map<String, String>>> frameworkMap); void validateUserMergeRequest(
Request request, String authUserToken, String sourceUserToken); void validateCertValidationRequest(Request request); void validateUserId(String uuid); void validateUserDeclarationRequest(Request userDeclareRequest); } | @Test public void testPhoneValidationSuccess() { Request request = new Request(); boolean response = false; Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.PHONE, "9321234123"); requestObj.put(JsonKey.COUNTRY_CODE, "+91"); requestObj.put(JsonKey.PROVIDER, "sunbird"); requestObj.put(JsonKey.PHONE_VERIFIED, true); requestObj.put(JsonKey.EMAIL_VERIFIED, true); request.setRequest(requestObj); try { userRequestValidator.phoneValidation(request); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); } assertEquals(true, response); }
@Test public void testPhoneValidationFailureWithInvalidPhone() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.PHONE, "+9321234123"); requestObj.put(JsonKey.COUNTRY_CODE, "+91"); requestObj.put(JsonKey.PROVIDER, "sunbird"); requestObj.put(JsonKey.PHONE_VERIFIED, true); requestObj.put(JsonKey.EMAIL_VERIFIED, true); request.setRequest(requestObj); try { userRequestValidator.phoneValidation(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.invalidPhoneNumber.getErrorCode(), e.getCode()); } }
@Test public void testPhoneValidationFailureWithInvalidCountryCode() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.PHONE, "+9321234123"); requestObj.put(JsonKey.COUNTRY_CODE, "+91968"); requestObj.put(JsonKey.PROVIDER, "sunbird"); requestObj.put(JsonKey.PHONE_VERIFIED, true); requestObj.put(JsonKey.EMAIL_VERIFIED, true); request.setRequest(requestObj); try { userRequestValidator.phoneValidation(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.invalidCountryCode.getErrorCode(), e.getCode()); } }
@Test public void testPhoneValidationFailureWithEmptyPhoneVerified() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.PHONE, "9321234123"); requestObj.put(JsonKey.COUNTRY_CODE, "+91"); requestObj.put(JsonKey.PROVIDER, "sunbird"); requestObj.put(JsonKey.PHONE_VERIFIED, ""); request.setRequest(requestObj); try { userRequestValidator.phoneValidation(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.phoneVerifiedError.getErrorCode(), e.getCode()); } }
@Test public void testPhoneValidationFailureWithPhoneVerifiedFalse() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.PHONE, "9321234123"); requestObj.put(JsonKey.COUNTRY_CODE, "+91"); requestObj.put(JsonKey.PROVIDER, "sunbird"); requestObj.put(JsonKey.PHONE_VERIFIED, false); request.setRequest(requestObj); try { userRequestValidator.phoneValidation(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.phoneVerifiedError.getErrorCode(), e.getCode()); } }
@Test public void testPhoneValidationFailureWithPhoneVerifiedNull() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.PHONE, "9321234123"); requestObj.put(JsonKey.COUNTRY_CODE, "+91"); requestObj.put(JsonKey.PROVIDER, "sunbird"); requestObj.put(JsonKey.PHONE_VERIFIED, null); request.setRequest(requestObj); try { userRequestValidator.phoneValidation(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.phoneVerifiedError.getErrorCode(), e.getCode()); } } |
UserExternalIdentityAdapter { public static Map<String, Object> convertExternalFieldsToSelfDeclareFields( List<Map<String, String>> externalIds) { Map<String, Object> selfDeclaredField = new HashMap<>(); if (CollectionUtils.isNotEmpty(externalIds)) { Map<String, String> userInfo = new HashMap<>(); for (Map<String, String> extIdMap : externalIds) { userInfo.put( extIdMap.get(JsonKey.ORIGINAL_ID_TYPE), extIdMap.get(JsonKey.ORIGINAL_EXTERNAL_ID)); } selfDeclaredField.put(JsonKey.USER_ID, externalIds.get(0).get(JsonKey.USER_ID)); selfDeclaredField.put(JsonKey.ORG_ID, externalIds.get(0).get(JsonKey.ORIGINAL_PROVIDER)); selfDeclaredField.put(JsonKey.PERSONA, JsonKey.TEACHER_PERSONA); selfDeclaredField.put(JsonKey.USER_INFO, userInfo); } return selfDeclaredField; } static List<Map<String, String>> convertSelfDeclareFieldsToExternalIds(
Map<String, Object> selfDeclaredFields); static Map<String, Object> convertExternalFieldsToSelfDeclareFields(
List<Map<String, String>> externalIds); } | @Test public void testConvertExternalFieldsToSelfDeclareFields() { Map<String, Object> declaredFeilds = getSelfDeclareFields(); List<Map<String, String>> externalIds = UserExternalIdentityAdapter.convertSelfDeclareFieldsToExternalIds(declaredFeilds); Map<String, Object> resultDeclaredFields = UserExternalIdentityAdapter.convertExternalFieldsToSelfDeclareFields(externalIds); Assert.assertEquals( declaredFeilds.get(JsonKey.USER_ID), resultDeclaredFields.get(JsonKey.USER_ID)); Assert.assertEquals( ((Map<String, Object>) declaredFeilds.get(JsonKey.USER_INFO)).get(JsonKey.DECLARED_EMAIL), ((Map<String, Object>) resultDeclaredFields.get(JsonKey.USER_INFO)) .get(JsonKey.DECLARED_EMAIL)); } |
UserLookUp { public void checkPhoneUniqueness(String phone, RequestContext context) { if (StringUtils.isNotBlank(phone)) { List<Map<String, Object>> userMapList = getPhoneByType(phone, context); if (CollectionUtils.isNotEmpty(userMapList)) { ProjectCommonException.throwClientErrorException(ResponseCode.PhoneNumberInUse, null); } } } Response insertRecords(List<Map<String, Object>> reqMap, RequestContext context); void deleteRecords(List<Map<String, String>> reqMap, RequestContext context); Response insertExternalIdIntoUserLookup(
List<Map<String, Object>> reqMap, String userId, RequestContext context); List<Map<String, Object>> getRecordByType(
String type, String value, boolean encrypt, RequestContext context); List<Map<String, Object>> getEmailByType(String email, RequestContext context); void checkEmailUniqueness(String email, RequestContext context); void checkEmailUniqueness(User user, String opType, RequestContext context); List<Map<String, Object>> getPhoneByType(String phone, RequestContext context); void checkPhoneUniqueness(String phone, RequestContext context); void checkPhoneUniqueness(User user, String opType, RequestContext context); boolean checkUsernameUniqueness(
String username, boolean isEncrypted, RequestContext context); void checkExternalIdUniqueness(User user, String operation, RequestContext context); } | @Test public void checkPhoneUniquenessExist() throws Exception { User user = new User(); user.setPhone("9663890400"); boolean response = false; try { new UserLookUp().checkPhoneUniqueness(user, "create", null); response = true; } catch (ProjectCommonException e) { assertEquals(e.getResponseCode(), 400); } assertFalse(response); }
@Test public void checkPhoneUniqueness() throws Exception { User user = new User(); user.setPhone("9663890400"); boolean response = false; try { new UserLookUp().checkPhoneUniqueness(user, "update", null); response = true; } catch (ProjectCommonException e) { assertEquals(e.getResponseCode(), 400); } assertFalse(response); }
@Test public void checkPhoneExist() { boolean response = false; try { new UserLookUp().checkPhoneUniqueness("9663890400", null); response = true; } catch (ProjectCommonException e) { assertEquals(e.getResponseCode(), 400); } assertFalse(response); } |
UserRequestValidator extends BaseRequestValidator { public void validateUpdateUserRequest(Request userRequest) { if (userRequest.getRequest().containsKey(JsonKey.MANAGED_BY)) { ProjectCommonException.throwClientErrorException(ResponseCode.managedByNotAllowed); } externalIdsValidation(userRequest, JsonKey.UPDATE); phoneValidation(userRequest); updateUserBasicValidation(userRequest); validateUserType(userRequest); validateUserOrgField(userRequest); if (userRequest.getRequest().containsKey(JsonKey.ROOT_ORG_ID) && StringUtils.isBlank((String) userRequest.getRequest().get(JsonKey.ROOT_ORG_ID))) { ProjectCommonException.throwClientErrorException(ResponseCode.invalidRootOrganisationId); } validateLocationCodes(userRequest); validateExtIdTypeAndProvider(userRequest); validateFrameworkDetails(userRequest); validateRecoveryEmailOrPhone(userRequest); } void validateCreateUserRequest(Request userRequest); static boolean isGoodPassword(String password); void validateUserCreateV3(Request userRequest); void validateCreateUserV3Request(Request userRequest); void validateUserCreateV4(Request userRequest); void validateCreateUserV1Request(Request userRequest); void validateCreateUserV2Request(Request userRequest); void fieldsNotAllowed(List<String> fields, Request userRequest); void phoneValidation(Request userRequest); void createUserBasicValidation(Request userRequest); void validateUpdateUserRequest(Request userRequest); void externalIdsValidation(Request userRequest, String operation); void validateChangePassword(Request userRequest); void validateVerifyUser(Request userRequest); void validateAssignRole(Request request); void validateForgotPassword(Request request); @SuppressWarnings("unchecked") void validateMandatoryFrameworkFields(
Map<String, Object> userMap,
List<String> frameworkFields,
List<String> frameworkMandatoryFields); @SuppressWarnings("unchecked") void validateFrameworkCategoryValues(
Map<String, Object> userMap, Map<String, List<Map<String, String>>> frameworkMap); void validateUserMergeRequest(
Request request, String authUserToken, String sourceUserToken); void validateCertValidationRequest(Request request); void validateUserId(String uuid); void validateUserDeclarationRequest(Request userDeclareRequest); } | @Test public void testUpdateUserSuccess() { Request request = initailizeRequest(); Map<String, Object> requestObj = request.getRequest(); requestObj.remove(JsonKey.USERNAME); requestObj.put(JsonKey.USER_ID, "userId"); List<String> roles = new ArrayList<String>(); roles.add("PUBLIC"); roles.add("CONTENT-CREATOR"); requestObj.put(JsonKey.ROLE, roles); List<String> language = new ArrayList<>(); language.add("English"); requestObj.put(JsonKey.LANGUAGE, language); List<Map<String, Object>> addressList = new ArrayList<>(); Map<String, Object> map = new HashMap<>(); map.put(JsonKey.ADDRESS_LINE1, "test"); map.put(JsonKey.CITY, "Bangalore"); map.put(JsonKey.COUNTRY, "India"); map.put(JsonKey.ADD_TYPE, "current"); addressList.add(map); requestObj.put(JsonKey.ADDRESS, addressList); List<Map<String, Object>> educationList = new ArrayList<>(); Map<String, Object> map1 = new HashMap<>(); map1.put(JsonKey.COURSE_NAME, "M.C.A"); map1.put(JsonKey.DEGREE, "Master"); map1.put(JsonKey.NAME, "CUSAT"); educationList.add(map1); requestObj.put(JsonKey.EDUCATION, educationList); List<Map<String, Object>> jobProfileList = new ArrayList<>(); map1 = new HashMap<>(); map1.put(JsonKey.JOB_NAME, "SE"); map1.put(JsonKey.ORGANISATION_NAME, "Tarento"); jobProfileList.add(map1); requestObj.put(JsonKey.JOB_PROFILE, jobProfileList); boolean response = false; request.setRequest(requestObj); try { userRequestValidator.validateUpdateUserRequest(request); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); } assertEquals(true, response); } |
UserRequestValidator extends BaseRequestValidator { public void validateAssignRole(Request request) { if (StringUtils.isBlank((String) request.getRequest().get(JsonKey.USER_ID))) { ProjectCommonException.throwClientErrorException(ResponseCode.userIdRequired); } if (request.getRequest().get(JsonKey.ROLES) == null || !(request.getRequest().get(JsonKey.ROLES) instanceof List)) { throw new ProjectCommonException( ResponseCode.dataTypeError.getErrorCode(), ProjectUtil.formatMessage( ResponseCode.dataTypeError.getErrorMessage(), JsonKey.ROLES, JsonKey.LIST), ERROR_CODE); } String organisationId = (String) request.getRequest().get(JsonKey.ORGANISATION_ID); String externalId = (String) request.getRequest().get(JsonKey.EXTERNAL_ID); String provider = (String) request.getRequest().get(JsonKey.PROVIDER); if (StringUtils.isBlank(organisationId) && (StringUtils.isBlank(externalId) || StringUtils.isBlank(provider))) { throw new ProjectCommonException( ResponseCode.mandatoryParamsMissing.getErrorCode(), ProjectUtil.formatMessage( ResponseCode.mandatoryParamsMissing.getErrorMessage(), (StringFormatter.joinByOr( JsonKey.ORGANISATION_ID, StringFormatter.joinByAnd(JsonKey.EXTERNAL_ID, JsonKey.PROVIDER)))), ERROR_CODE); } } void validateCreateUserRequest(Request userRequest); static boolean isGoodPassword(String password); void validateUserCreateV3(Request userRequest); void validateCreateUserV3Request(Request userRequest); void validateUserCreateV4(Request userRequest); void validateCreateUserV1Request(Request userRequest); void validateCreateUserV2Request(Request userRequest); void fieldsNotAllowed(List<String> fields, Request userRequest); void phoneValidation(Request userRequest); void createUserBasicValidation(Request userRequest); void validateUpdateUserRequest(Request userRequest); void externalIdsValidation(Request userRequest, String operation); void validateChangePassword(Request userRequest); void validateVerifyUser(Request userRequest); void validateAssignRole(Request request); void validateForgotPassword(Request request); @SuppressWarnings("unchecked") void validateMandatoryFrameworkFields(
Map<String, Object> userMap,
List<String> frameworkFields,
List<String> frameworkMandatoryFields); @SuppressWarnings("unchecked") void validateFrameworkCategoryValues(
Map<String, Object> userMap, Map<String, List<Map<String, String>>> frameworkMap); void validateUserMergeRequest(
Request request, String authUserToken, String sourceUserToken); void validateCertValidationRequest(Request request); void validateUserId(String uuid); void validateUserDeclarationRequest(Request userDeclareRequest); } | @Test public void testValidateAssignRoleSuccess() { Request request = new Request(); boolean response = false; Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.USER_ID, "ORG-provider"); requestObj.put(JsonKey.EXTERNAL_ID, "EXT_ID"); requestObj.put(JsonKey.ORGANISATION_ID, "ORG_ID"); requestObj.put(JsonKey.ORG_PROVIDER, "ORG_PROVIDER"); List<String> roles = new ArrayList<>(); roles.add("PUBLIC"); requestObj.put(JsonKey.ROLES, roles); request.setRequest(requestObj); try { userRequestValidator.validateAssignRole(request); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); } assertEquals(true, response); }
@Test public void testValidateAssignRoleSuccessWithProviderAndExternalId() { Request request = new Request(); boolean response = false; Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.PROVIDER, "ORG-provider"); requestObj.put(JsonKey.EXTERNAL_ID, "ORG-1233"); requestObj.put(JsonKey.USER_ID, "User1"); List<String> roles = new ArrayList<>(); roles.add("PUBLIC"); requestObj.put(JsonKey.ROLES, roles); request.setRequest(requestObj); try { userRequestValidator.validateAssignRole(request); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); } assertEquals(true, response); } |
UserUtil { public static String generateUniqueString(int length) { int totalChars = alphabet.length; BigDecimal exponent = BigDecimal.valueOf(totalChars); exponent = exponent.pow(length); String code = ""; BigDecimal number = new BigDecimal(rand.nextInt(1000000)); BigDecimal num = number.multiply(largePrimeNumber).remainder(exponent); code = baseN(num, totalChars); int codeLenght = code.length(); if (codeLenght < length) { for (int i = codeLenght; i < length; i++) { code = code + alphabet[rand.nextInt(totalChars - 1)]; } } if (NumberUtils.isNumber(code.substring(1, 2)) || NumberUtils.isNumber(code.substring(2, 3))) { return code; } else { code = code.substring(0, 1) + alphabet[rand.nextInt(9)] + code.substring(2); return code; } } private UserUtil(); static void updateExternalIdsProviderWithOrgId(
Map<String, Object> userMap, RequestContext context); static String getCaseInsensitiveOrgFromProvider(
String provider, Map<String, String> providerOrgMap); static Map<String, Object> validateExternalIdsAndReturnActiveUser(
Map<String, Object> userMap, RequestContext context); @SuppressWarnings("unchecked") static Map<String, Object> getUserFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserIdFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserId(Map<String, Object> userMap, RequestContext context); static void validateUserPhoneEmailAndWebPages(
User user, String operationType, RequestContext context); static String getDecryptedData(String value, RequestContext context); static List<Map<String, String>> copyAndConvertExternalIdsToLower(
List<Map<String, String>> externalIds); static void storeOriginalExternalIdsValue(List<Map<String, String>> externalIds); static void updateExternalIdsWithProvider(
List<Map<String, String>> dbResExternalIds, RequestContext context); static List<Map<String, String>> convertExternalIdsValueToLowerCase(
List<Map<String, String>> externalIds); static boolean updatePassword(Map<String, Object> userMap, RequestContext context); static void addMaskEmailAndMaskPhone(Map<String, Object> userMap); @SuppressWarnings("unchecked") static Map<String, Object> encryptUserData(Map<String, Object> userMap); static void setUserDefaultValueForV3(Map<String, Object> userMap, RequestContext context); static String transliterateUserName(String userName); static String generateUniqueString(int length); static void setUserDefaultValue(
Map<String, Object> userMap, String callerId, RequestContext context); static void validateExternalIds(User user, String operationType, RequestContext context); static void validateExternalIdsForUpdateUser(
User user, boolean isCustodianOrg, RequestContext context); static void checkEmailSameOrDiff(
Map<String, Object> userRequestMap, Map<String, Object> userDbRecord); static void validateUserExternalIds(User user, RequestContext context); static List<Map<String, String>> getExternalIds(String userId, RequestContext context); static List<Map<String, Object>> getActiveUserOrgDetails(
String userId, RequestContext context); static List<Map<String, Object>> getAllUserOrgDetails(
String userId, RequestContext context); static void toLower(Map<String, Object> userMap); static Map<String, Object> validateManagedByUser(
String managedBy, RequestContext context); static void validateManagedUserLimit(String managedBy, RequestContext context); static List<UserDeclareEntity> transformExternalIdsToSelfDeclaredRequest(
List<Map<String, String>> externalIds, Map<String, Object> requestMap); static String fetchProviderByOrgId(String orgId, RequestContext context); static Map<String, String> fetchOrgIdByProvider(
List<String> providers, RequestContext context); static void encryptDeclarationFields(
List<Map<String, Object>> declarations,
Map<String, Object> userDbRecords,
RequestContext context); static UserDeclareEntity createUserDeclaredObject(
Map<String, Object> declareFieldMap, String callerId); static void removeEntryFromUserLookUp(
Map<String, Object> userDbMap, List<String> identifiers, RequestContext context); } | @Test public void generateUniqueStringSuccess() { beforeEachTest(); String val = UserUtil.generateUniqueString(4); assertTrue(val.length() == 4); }
@Test public void generateUniqueStringSecondCharCheck() { beforeEachTest(); String val = UserUtil.generateUniqueString(5); assertTrue(val.length() == 5); assertTrue( NumberUtils.isNumber(val.substring(1, 2)) || NumberUtils.isNumber(val.substring(2, 3))); } |
UserUtil { public static List<Map<String, String>> copyAndConvertExternalIdsToLower( List<Map<String, String>> externalIds) { List<Map<String, String>> list = new ArrayList<>(); if (CollectionUtils.isNotEmpty(externalIds)) { storeOriginalExternalIdsValue(externalIds); list = convertExternalIdsValueToLowerCase(externalIds); } return list; } private UserUtil(); static void updateExternalIdsProviderWithOrgId(
Map<String, Object> userMap, RequestContext context); static String getCaseInsensitiveOrgFromProvider(
String provider, Map<String, String> providerOrgMap); static Map<String, Object> validateExternalIdsAndReturnActiveUser(
Map<String, Object> userMap, RequestContext context); @SuppressWarnings("unchecked") static Map<String, Object> getUserFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserIdFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserId(Map<String, Object> userMap, RequestContext context); static void validateUserPhoneEmailAndWebPages(
User user, String operationType, RequestContext context); static String getDecryptedData(String value, RequestContext context); static List<Map<String, String>> copyAndConvertExternalIdsToLower(
List<Map<String, String>> externalIds); static void storeOriginalExternalIdsValue(List<Map<String, String>> externalIds); static void updateExternalIdsWithProvider(
List<Map<String, String>> dbResExternalIds, RequestContext context); static List<Map<String, String>> convertExternalIdsValueToLowerCase(
List<Map<String, String>> externalIds); static boolean updatePassword(Map<String, Object> userMap, RequestContext context); static void addMaskEmailAndMaskPhone(Map<String, Object> userMap); @SuppressWarnings("unchecked") static Map<String, Object> encryptUserData(Map<String, Object> userMap); static void setUserDefaultValueForV3(Map<String, Object> userMap, RequestContext context); static String transliterateUserName(String userName); static String generateUniqueString(int length); static void setUserDefaultValue(
Map<String, Object> userMap, String callerId, RequestContext context); static void validateExternalIds(User user, String operationType, RequestContext context); static void validateExternalIdsForUpdateUser(
User user, boolean isCustodianOrg, RequestContext context); static void checkEmailSameOrDiff(
Map<String, Object> userRequestMap, Map<String, Object> userDbRecord); static void validateUserExternalIds(User user, RequestContext context); static List<Map<String, String>> getExternalIds(String userId, RequestContext context); static List<Map<String, Object>> getActiveUserOrgDetails(
String userId, RequestContext context); static List<Map<String, Object>> getAllUserOrgDetails(
String userId, RequestContext context); static void toLower(Map<String, Object> userMap); static Map<String, Object> validateManagedByUser(
String managedBy, RequestContext context); static void validateManagedUserLimit(String managedBy, RequestContext context); static List<UserDeclareEntity> transformExternalIdsToSelfDeclaredRequest(
List<Map<String, String>> externalIds, Map<String, Object> requestMap); static String fetchProviderByOrgId(String orgId, RequestContext context); static Map<String, String> fetchOrgIdByProvider(
List<String> providers, RequestContext context); static void encryptDeclarationFields(
List<Map<String, Object>> declarations,
Map<String, Object> userDbRecords,
RequestContext context); static UserDeclareEntity createUserDeclaredObject(
Map<String, Object> declareFieldMap, String callerId); static void removeEntryFromUserLookUp(
Map<String, Object> userDbMap, List<String> identifiers, RequestContext context); } | @Test public void copyAndConvertExternalIdsToLower() { beforeEachTest(); List<Map<String, String>> externalIds = new ArrayList<Map<String, String>>(); Map<String, String> userExternalIdMap = new HashMap<String, String>(); userExternalIdMap.put(JsonKey.ID, "test123"); userExternalIdMap.put(JsonKey.PROVIDER, "State"); userExternalIdMap.put(JsonKey.ID_TYPE, "UserExtId"); externalIds.add(userExternalIdMap); externalIds = UserUtil.copyAndConvertExternalIdsToLower(externalIds); userExternalIdMap = externalIds.get(0); assertNotNull(userExternalIdMap.get(JsonKey.ORIGINAL_EXTERNAL_ID)); assertEquals(userExternalIdMap.get(JsonKey.PROVIDER), "state"); } |
UserRequestValidator extends BaseRequestValidator { public void validateVerifyUser(Request userRequest) { if (StringUtils.isBlank((String) userRequest.getRequest().get(JsonKey.LOGIN_ID))) { ProjectCommonException.throwClientErrorException(ResponseCode.loginIdRequired); } } void validateCreateUserRequest(Request userRequest); static boolean isGoodPassword(String password); void validateUserCreateV3(Request userRequest); void validateCreateUserV3Request(Request userRequest); void validateUserCreateV4(Request userRequest); void validateCreateUserV1Request(Request userRequest); void validateCreateUserV2Request(Request userRequest); void fieldsNotAllowed(List<String> fields, Request userRequest); void phoneValidation(Request userRequest); void createUserBasicValidation(Request userRequest); void validateUpdateUserRequest(Request userRequest); void externalIdsValidation(Request userRequest, String operation); void validateChangePassword(Request userRequest); void validateVerifyUser(Request userRequest); void validateAssignRole(Request request); void validateForgotPassword(Request request); @SuppressWarnings("unchecked") void validateMandatoryFrameworkFields(
Map<String, Object> userMap,
List<String> frameworkFields,
List<String> frameworkMandatoryFields); @SuppressWarnings("unchecked") void validateFrameworkCategoryValues(
Map<String, Object> userMap, Map<String, List<Map<String, String>>> frameworkMap); void validateUserMergeRequest(
Request request, String authUserToken, String sourceUserToken); void validateCertValidationRequest(Request request); void validateUserId(String uuid); void validateUserDeclarationRequest(Request userDeclareRequest); } | @Test public void testValidateVerifyUserSuccess() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.LOGIN_ID, "username@provider"); request.setRequest(requestObj); boolean response = false; try { new UserRequestValidator().validateVerifyUser(request); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); } Assert.assertTrue(response); }
@Test public void testValidateGerUserCountFailureWithEstCntReqTrue() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.LOGIN_ID, ""); request.setRequest(requestObj); boolean response = false; try { new UserRequestValidator().validateVerifyUser(request); response = true; } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.loginIdRequired.getErrorCode(), e.getCode()); } Assert.assertFalse(response); }
@Test public void testValidateVerifyUserFailureWithEmptyId() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.LOGIN_ID, ""); request.setRequest(requestObj); boolean response = false; try { userRequestValidator.validateVerifyUser(request); response = true; } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.loginIdRequired.getErrorCode(), e.getCode()); } Assert.assertFalse(response); } |
UserRequestValidator extends BaseRequestValidator { @SuppressWarnings("unchecked") public void validateMandatoryFrameworkFields( Map<String, Object> userMap, List<String> frameworkFields, List<String> frameworkMandatoryFields) { if (userMap.containsKey(JsonKey.FRAMEWORK)) { Map<String, Object> frameworkRequest = (Map<String, Object>) userMap.get(JsonKey.FRAMEWORK); for (String field : frameworkFields) { if (CollectionUtils.isNotEmpty(frameworkMandatoryFields) && frameworkMandatoryFields.contains(field)) { if (!frameworkRequest.containsKey(field)) { validateParam(null, ResponseCode.mandatoryParamsMissing, field); } validateListParamWithPrefix(frameworkRequest, JsonKey.FRAMEWORK, field); List<String> fieldValue = (List) frameworkRequest.get(field); if (fieldValue.isEmpty()) { throw new ProjectCommonException( ResponseCode.errorMandatoryParamsEmpty.getErrorCode(), ResponseCode.errorMandatoryParamsEmpty.getErrorMessage(), ERROR_CODE, StringFormatter.joinByDot(JsonKey.FRAMEWORK, field)); } } else { if (frameworkRequest.containsKey(field) && frameworkRequest.get(field) != null && !(frameworkRequest.get(field) instanceof List)) { throw new ProjectCommonException( ResponseCode.dataTypeError.getErrorCode(), ResponseCode.dataTypeError.getErrorMessage(), ERROR_CODE, field, JsonKey.LIST); } } } List<String> frameworkRequestFieldList = frameworkRequest.keySet().stream().collect(Collectors.toList()); for (String frameworkRequestField : frameworkRequestFieldList) { if (!frameworkFields.contains(frameworkRequestField)) { throw new ProjectCommonException( ResponseCode.errorUnsupportedField.getErrorCode(), ResponseCode.errorUnsupportedField.getErrorMessage(), ERROR_CODE, StringFormatter.joinByDot(JsonKey.FRAMEWORK, frameworkRequestField)); } } } } void validateCreateUserRequest(Request userRequest); static boolean isGoodPassword(String password); void validateUserCreateV3(Request userRequest); void validateCreateUserV3Request(Request userRequest); void validateUserCreateV4(Request userRequest); void validateCreateUserV1Request(Request userRequest); void validateCreateUserV2Request(Request userRequest); void fieldsNotAllowed(List<String> fields, Request userRequest); void phoneValidation(Request userRequest); void createUserBasicValidation(Request userRequest); void validateUpdateUserRequest(Request userRequest); void externalIdsValidation(Request userRequest, String operation); void validateChangePassword(Request userRequest); void validateVerifyUser(Request userRequest); void validateAssignRole(Request request); void validateForgotPassword(Request request); @SuppressWarnings("unchecked") void validateMandatoryFrameworkFields(
Map<String, Object> userMap,
List<String> frameworkFields,
List<String> frameworkMandatoryFields); @SuppressWarnings("unchecked") void validateFrameworkCategoryValues(
Map<String, Object> userMap, Map<String, List<Map<String, String>>> frameworkMap); void validateUserMergeRequest(
Request request, String authUserToken, String sourceUserToken); void validateCertValidationRequest(Request request); void validateUserId(String uuid); void validateUserDeclarationRequest(Request userDeclareRequest); } | @Test public void testValidateMandatoryFrameworkFieldsSuccess() { Request request = initailizeRequest(); request.getRequest().put(JsonKey.FRAMEWORK, createFrameWork()); boolean response = false; try { new UserRequestValidator() .validateMandatoryFrameworkFields( request.getRequest(), getSupportedFileds(), getMandatoryFields()); response = true; } catch (Exception e) { Assert.assertTrue(response); } Assert.assertTrue(response); }
@Test public void testValidateMandatoryFrameworkFieldValueAsString() { Request request = initailizeRequest(); Map<String, Object> frameworkMap = createFrameWork(); frameworkMap.put("medium", "hindi"); request.getRequest().put(JsonKey.FRAMEWORK, frameworkMap); boolean response = false; try { new UserRequestValidator() .validateMandatoryFrameworkFields( request.getRequest(), getSupportedFileds(), getMandatoryFields()); response = true; } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.dataTypeError.getErrorCode(), e.getCode()); } Assert.assertFalse(response); }
@Test public void testValidateFrameworkUnknownField() { Request request = initailizeRequest(); Map<String, Object> frameworkMap = createFrameWork(); frameworkMap.put("school", Arrays.asList("school1")); request.getRequest().put(JsonKey.FRAMEWORK, frameworkMap); boolean response = false; try { new UserRequestValidator() .validateMandatoryFrameworkFields( request.getRequest(), getSupportedFileds(), getMandatoryFields()); response = true; } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.errorUnsupportedField.getErrorCode(), e.getCode()); } Assert.assertFalse(response); }
@Test public void testValidateFrameworkWithEmptyValue() { Request request = initailizeRequest(); Map<String, Object> frameworkMap = createFrameWork(); frameworkMap.put("medium", Arrays.asList()); request.getRequest().put(JsonKey.FRAMEWORK, frameworkMap); boolean response = false; try { new UserRequestValidator() .validateMandatoryFrameworkFields( request.getRequest(), getSupportedFileds(), getMandatoryFields()); response = true; } catch (Exception e) { Assert.assertTrue(response); } Assert.assertTrue(response); }
@Test public void testValidateFrameworkWithNullValue() { Request request = initailizeRequest(); Map<String, Object> frameworkMap = createFrameWork(); frameworkMap.put("medium", null); request.getRequest().put(JsonKey.FRAMEWORK, frameworkMap); boolean response = false; try { new UserRequestValidator() .validateMandatoryFrameworkFields( request.getRequest(), getSupportedFileds(), getMandatoryFields()); response = true; } catch (Exception e) { Assert.assertTrue(response); } Assert.assertTrue(response); } |
UserRequestValidator extends BaseRequestValidator { public void validateUserDeclarationRequest(Request userDeclareRequest) { try { List<Map<String, Object>> declarations = (List<Map<String, Object>>) userDeclareRequest.getRequest().get(JsonKey.DECLARATIONS); if (CollectionUtils.isEmpty(declarations)) { throw new ProjectCommonException( ResponseCode.mandatoryParamsMissing.getErrorCode(), MessageFormat.format( ResponseCode.mandatoryParamsMissing.getErrorMessage(), JsonKey.DECLARATIONS), ResponseCode.CLIENT_ERROR.getResponseCode()); } else { for (Map<String, Object> declareFields : declarations) { String userId = (String) declareFields.get(JsonKey.USER_ID); String orgId = (String) declareFields.get(JsonKey.ORG_ID); String persona = (String) declareFields.get(JsonKey.PERSONA); Map<String, Object> info = (Map<String, Object>) declareFields.get(JsonKey.INFO); if (StringUtils.isBlank(userId) || StringUtils.isBlank(orgId) || StringUtils.isBlank(persona)) { throw new ProjectCommonException( ResponseCode.mandatoryParamsMissing.getErrorCode(), MessageFormat.format( ResponseMessage.Message.MISSING_SELF_DECLARED_MANDATORY_PARAMETERS, new String[] {JsonKey.USER_ID, JsonKey.ORG_ID, JsonKey.PERSONA}), ResponseCode.CLIENT_ERROR.getResponseCode()); } if (MapUtils.isNotEmpty(info) && info.containsValue(null)) { ProjectCommonException.throwClientErrorException(ResponseCode.InvalidUserInfoValue); } } } } catch (Exception ex) { throw new ProjectCommonException( ResponseCode.invalidParameterValue.getErrorCode(), ex.getMessage(), ResponseCode.CLIENT_ERROR.getResponseCode()); } } void validateCreateUserRequest(Request userRequest); static boolean isGoodPassword(String password); void validateUserCreateV3(Request userRequest); void validateCreateUserV3Request(Request userRequest); void validateUserCreateV4(Request userRequest); void validateCreateUserV1Request(Request userRequest); void validateCreateUserV2Request(Request userRequest); void fieldsNotAllowed(List<String> fields, Request userRequest); void phoneValidation(Request userRequest); void createUserBasicValidation(Request userRequest); void validateUpdateUserRequest(Request userRequest); void externalIdsValidation(Request userRequest, String operation); void validateChangePassword(Request userRequest); void validateVerifyUser(Request userRequest); void validateAssignRole(Request request); void validateForgotPassword(Request request); @SuppressWarnings("unchecked") void validateMandatoryFrameworkFields(
Map<String, Object> userMap,
List<String> frameworkFields,
List<String> frameworkMandatoryFields); @SuppressWarnings("unchecked") void validateFrameworkCategoryValues(
Map<String, Object> userMap, Map<String, List<Map<String, String>>> frameworkMap); void validateUserMergeRequest(
Request request, String authUserToken, String sourceUserToken); void validateCertValidationRequest(Request request); void validateUserId(String uuid); void validateUserDeclarationRequest(Request userDeclareRequest); } | @Test public void testValidateUserDeclarationRequest() { Request request = initailizeRequest(); List<Map<String, Object>> declarations = createUpdateUserDeclarationRequests(); request.getRequest().put(JsonKey.DECLARATIONS, declarations); boolean response = false; try { new UserRequestValidator().validateUserDeclarationRequest(request); response = true; } catch (Exception e) { Assert.assertTrue(response); } Assert.assertTrue(response); }
@Test public void testValidateUserMissingDeclarationsFieldRequest() { Request request = initailizeRequest(); List<Map<String, Object>> declarations = createUpdateUserDeclarationMissingUserIdRequests(); request.getRequest().put(JsonKey.DECLARATIONS, declarations); boolean response = false; try { new UserRequestValidator().validateUserDeclarationRequest(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals( MessageFormat.format( ResponseMessage.Message.MISSING_SELF_DECLARED_MANDATORY_PARAMETERS, new String[] {JsonKey.USER_ID, JsonKey.ORG_ID, JsonKey.PERSONA}), e.getMessage()); response = true; } Assert.assertTrue(response); }
@Test public void testValidateUserMissingInfoDeclarationsFieldRequest() { Request request = initailizeRequest(); List<Map<String, Object>> declarations = createUpdateUserDeclarationMissingUserInfoIdRequests(); request.getRequest().put(JsonKey.DECLARATIONS, declarations); boolean response = false; try { new UserRequestValidator().validateUserDeclarationRequest(request); } catch (ProjectCommonException e) { response = true; } Assert.assertTrue(response); } |
UserUtil { public static void setUserDefaultValueForV3(Map<String, Object> userMap, RequestContext context) { List<String> roles = new ArrayList<>(); roles.add(ProjectUtil.UserRole.PUBLIC.getValue()); userMap.put(JsonKey.ROLES, roles); userMap.put( JsonKey.COUNTRY_CODE, propertiesCache.getProperty(JsonKey.SUNBIRD_DEFAULT_COUNTRY_CODE)); userMap.put(JsonKey.PROFILE_VISIBILITY, new HashMap<String, String>()); userMap.put(JsonKey.IS_DELETED, false); userMap.put(JsonKey.CREATED_DATE, ProjectUtil.getFormattedDate()); userMap.put(JsonKey.STATUS, ProjectUtil.Status.ACTIVE.getValue()); if (StringUtils.isBlank((String) userMap.get(JsonKey.USERNAME))) { String firstName = (String) userMap.get(JsonKey.FIRST_NAME); firstName = firstName.split(" ")[0]; String translatedFirstName = transliterateUserName(firstName); userMap.put(JsonKey.USERNAME, translatedFirstName + "_" + generateUniqueString(4)); } else { String userName = transliterateUserName((String) userMap.get(JsonKey.USERNAME)); userMap.put(JsonKey.USERNAME, userName); UserLookUp userLookUp = new UserLookUp(); if (!userLookUp.checkUsernameUniqueness(userName, false, context)) { ProjectCommonException.throwClientErrorException(ResponseCode.userNameAlreadyExistError); } } } private UserUtil(); static void updateExternalIdsProviderWithOrgId(
Map<String, Object> userMap, RequestContext context); static String getCaseInsensitiveOrgFromProvider(
String provider, Map<String, String> providerOrgMap); static Map<String, Object> validateExternalIdsAndReturnActiveUser(
Map<String, Object> userMap, RequestContext context); @SuppressWarnings("unchecked") static Map<String, Object> getUserFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserIdFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserId(Map<String, Object> userMap, RequestContext context); static void validateUserPhoneEmailAndWebPages(
User user, String operationType, RequestContext context); static String getDecryptedData(String value, RequestContext context); static List<Map<String, String>> copyAndConvertExternalIdsToLower(
List<Map<String, String>> externalIds); static void storeOriginalExternalIdsValue(List<Map<String, String>> externalIds); static void updateExternalIdsWithProvider(
List<Map<String, String>> dbResExternalIds, RequestContext context); static List<Map<String, String>> convertExternalIdsValueToLowerCase(
List<Map<String, String>> externalIds); static boolean updatePassword(Map<String, Object> userMap, RequestContext context); static void addMaskEmailAndMaskPhone(Map<String, Object> userMap); @SuppressWarnings("unchecked") static Map<String, Object> encryptUserData(Map<String, Object> userMap); static void setUserDefaultValueForV3(Map<String, Object> userMap, RequestContext context); static String transliterateUserName(String userName); static String generateUniqueString(int length); static void setUserDefaultValue(
Map<String, Object> userMap, String callerId, RequestContext context); static void validateExternalIds(User user, String operationType, RequestContext context); static void validateExternalIdsForUpdateUser(
User user, boolean isCustodianOrg, RequestContext context); static void checkEmailSameOrDiff(
Map<String, Object> userRequestMap, Map<String, Object> userDbRecord); static void validateUserExternalIds(User user, RequestContext context); static List<Map<String, String>> getExternalIds(String userId, RequestContext context); static List<Map<String, Object>> getActiveUserOrgDetails(
String userId, RequestContext context); static List<Map<String, Object>> getAllUserOrgDetails(
String userId, RequestContext context); static void toLower(Map<String, Object> userMap); static Map<String, Object> validateManagedByUser(
String managedBy, RequestContext context); static void validateManagedUserLimit(String managedBy, RequestContext context); static List<UserDeclareEntity> transformExternalIdsToSelfDeclaredRequest(
List<Map<String, String>> externalIds, Map<String, Object> requestMap); static String fetchProviderByOrgId(String orgId, RequestContext context); static Map<String, String> fetchOrgIdByProvider(
List<String> providers, RequestContext context); static void encryptDeclarationFields(
List<Map<String, Object>> declarations,
Map<String, Object> userDbRecords,
RequestContext context); static UserDeclareEntity createUserDeclaredObject(
Map<String, Object> declareFieldMap, String callerId); static void removeEntryFromUserLookUp(
Map<String, Object> userDbMap, List<String> identifiers, RequestContext context); } | @Test public void setUserDefaultValueForV3() { beforeEachTest(); Map<String, Object> userMap = new HashMap<String, Object>(); userMap.put(JsonKey.FIRST_NAME, "Test User"); UserUtil.setUserDefaultValueForV3(userMap, null); assertNotNull(userMap.get(JsonKey.USERNAME)); assertNotNull(userMap.get(JsonKey.STATUS)); assertNotNull(userMap.get(JsonKey.ROLES)); } |
ProjectUtil { public static VelocityContext getContext(Map<String, Object> map) { propertiesCache = PropertiesCache.getInstance(); VelocityContext context = new VelocityContext(); if (StringUtils.isNotBlank((String) map.get(JsonKey.ACTION_URL))) { context.put(JsonKey.ACTION_URL, getValue(map, JsonKey.ACTION_URL)); } if (StringUtils.isNotBlank((String) map.get(JsonKey.NAME))) { context.put(JsonKey.NAME, getValue(map, JsonKey.NAME)); } context.put(JsonKey.BODY, getValue(map, JsonKey.BODY)); String fromEmail = getFromEmail(map); if (StringUtils.isNotBlank(fromEmail)) { context.put(JsonKey.FROM_EMAIL, fromEmail); } if (StringUtils.isNotBlank((String) map.get(JsonKey.ORG_NAME))) { context.put(JsonKey.ORG_NAME, getValue(map, JsonKey.ORG_NAME)); } String logoUrl = getSunbirdLogoUrl(map); if (StringUtils.isNotBlank(logoUrl)) { context.put(JsonKey.ORG_IMAGE_URL, logoUrl); } context.put(JsonKey.ACTION_NAME, getValue(map, JsonKey.ACTION_NAME)); context.put(JsonKey.USERNAME, getValue(map, JsonKey.USERNAME)); context.put(JsonKey.TEMPORARY_PASSWORD, getValue(map, JsonKey.TEMPORARY_PASSWORD)); if (StringUtils.isNotBlank((String) map.get(JsonKey.COURSE_NAME))) { context.put(JsonKey.COURSE_NAME, map.remove(JsonKey.COURSE_NAME)); } if (StringUtils.isNotBlank((String) map.get(JsonKey.START_DATE))) { context.put(JsonKey.BATCH_START_DATE, map.remove(JsonKey.START_DATE)); } if (StringUtils.isNotBlank((String) map.get(JsonKey.END_DATE))) { context.put(JsonKey.BATCH_END_DATE, map.remove(JsonKey.END_DATE)); } if (StringUtils.isNotBlank((String) map.get(JsonKey.BATCH_NAME))) { context.put(JsonKey.BATCH_NAME, map.remove(JsonKey.BATCH_NAME)); } if (StringUtils.isNotBlank((String) map.get(JsonKey.FIRST_NAME))) { context.put(JsonKey.NAME, map.remove(JsonKey.FIRST_NAME)); } else { context.put(JsonKey.NAME, ""); } if (StringUtils.isNotBlank((String) map.get(JsonKey.SIGNATURE))) { context.put(JsonKey.SIGNATURE, map.remove(JsonKey.SIGNATURE)); } if (StringUtils.isNotBlank((String) map.get(JsonKey.COURSE_BATCH_URL))) { context.put(JsonKey.COURSE_BATCH_URL, map.remove(JsonKey.COURSE_BATCH_URL)); } context.put(JsonKey.ALLOWED_LOGIN, propertiesCache.getProperty(JsonKey.SUNBIRD_ALLOWED_LOGIN)); map = addCertStaticResource(map); for (Map.Entry<String, Object> entry : map.entrySet()) { context.put(entry.getKey(), entry.getValue()); } return context; } static String getFormattedDate(); static boolean isEmailvalid(final String email); static String createAuthToken(String name, String source); static String getUniqueIdFromTimestamp(int environmentId); static synchronized String generateUniqueId(); static boolean isNull(Object obj); static boolean isNotNull(Object obj); static String formatMessage(String exceptionMsg, Object... fieldValue); static SimpleDateFormat getDateFormatter(); static VelocityContext getContext(Map<String, Object> map); static Map<String, Object> createCheckResponse(
String serviceName, boolean isError, Exception e); static String registertag(
String tagId, String body, Map<String, String> header, RequestContext context); static String generateRandomPassword(); static boolean validatePhoneNumber(String phone); static Map<String, String> getEkstepHeader(); static boolean validatePhone(String phNumber, String countryCode); static boolean validateCountryCode(String countryCode); static boolean validateUUID(String uuidStr); static String getSMSBody(Map<String, String> smsTemplate); static boolean isDateValidFormat(String format, String value); static void createAndThrowServerError(); static ProjectCommonException createServerError(ResponseCode responseCode); static void createAndThrowInvalidUserDataException(); static boolean isUrlvalid(String url); static String getConfigValue(String key); static boolean isNotEmptyStringArray(String[] strArray); static String convertMapToJsonString(List<Map<String, Object>> mapList); static void removeUnwantedFields(Map<String, Object> map, String... keys); static T convertToRequestPojo(Request request, Class<T> clazz); static Map<String, String> getDateRange(int numDays); static ProjectCommonException createClientException(ResponseCode responseCode); static String getLmsUserId(String fedUserId); static String getFirstNCharacterString(String originalText, int noOfChar); static final String YEAR_MONTH_DATE_FORMAT; static PropertiesCache propertiesCache; static final String[] excludes; } | @Test public void testGetContextFailureWithoutActionUrl() { Map<String, Object> templateMap = new HashMap<>(); templateMap.put(JsonKey.NAME, "userName"); VelocityContext context = ProjectUtil.getContext(templateMap); assertEquals(false, context.internalContainsKey(JsonKey.ACTION_URL)); }
@Test public void testGetContextSuccessWithFromMail() { Map<String, Object> templateMap = new HashMap<>(); templateMap.put(JsonKey.ACTION_URL, "googli.com"); templateMap.put(JsonKey.NAME, "userName"); boolean envVal = !StringUtils.isBlank(System.getenv(JsonKey.EMAIL_SERVER_FROM)); boolean cacheVal = propertiesCache.getProperty(JsonKey.EMAIL_SERVER_FROM) != null; VelocityContext context = ProjectUtil.getContext(templateMap); if (envVal) { assertEquals( System.getenv(JsonKey.EMAIL_SERVER_FROM), context.internalGet(JsonKey.FROM_EMAIL)); } else if (cacheVal) { assertEquals( propertiesCache.getProperty(JsonKey.EMAIL_SERVER_FROM), context.internalGet(JsonKey.FROM_EMAIL)); } }
@Test public void testGetContextSuccessWithOrgImageUrl() { Map<String, Object> templateMap = new HashMap<>(); templateMap.put(JsonKey.ACTION_URL, "googli.com"); templateMap.put(JsonKey.NAME, "userName"); boolean envVal = !StringUtils.isBlank(System.getenv(JsonKey.SUNBIRD_ENV_LOGO_URL)); boolean cacheVal = propertiesCache.getProperty(JsonKey.SUNBIRD_ENV_LOGO_URL) != null; VelocityContext context = ProjectUtil.getContext(templateMap); if (envVal) { assertEquals( System.getenv(JsonKey.SUNBIRD_ENV_LOGO_URL), context.internalGet(JsonKey.ORG_IMAGE_URL)); } else if (cacheVal) { assertEquals( propertiesCache.getProperty(JsonKey.SUNBIRD_ENV_LOGO_URL), context.internalGet(JsonKey.ORG_IMAGE_URL)); } } |
ProjectUtil { public static String createAuthToken(String name, String source) { String data = name + source + System.currentTimeMillis(); UUID authId = UUID.nameUUIDFromBytes(data.getBytes(StandardCharsets.UTF_8)); return authId.toString(); } static String getFormattedDate(); static boolean isEmailvalid(final String email); static String createAuthToken(String name, String source); static String getUniqueIdFromTimestamp(int environmentId); static synchronized String generateUniqueId(); static boolean isNull(Object obj); static boolean isNotNull(Object obj); static String formatMessage(String exceptionMsg, Object... fieldValue); static SimpleDateFormat getDateFormatter(); static VelocityContext getContext(Map<String, Object> map); static Map<String, Object> createCheckResponse(
String serviceName, boolean isError, Exception e); static String registertag(
String tagId, String body, Map<String, String> header, RequestContext context); static String generateRandomPassword(); static boolean validatePhoneNumber(String phone); static Map<String, String> getEkstepHeader(); static boolean validatePhone(String phNumber, String countryCode); static boolean validateCountryCode(String countryCode); static boolean validateUUID(String uuidStr); static String getSMSBody(Map<String, String> smsTemplate); static boolean isDateValidFormat(String format, String value); static void createAndThrowServerError(); static ProjectCommonException createServerError(ResponseCode responseCode); static void createAndThrowInvalidUserDataException(); static boolean isUrlvalid(String url); static String getConfigValue(String key); static boolean isNotEmptyStringArray(String[] strArray); static String convertMapToJsonString(List<Map<String, Object>> mapList); static void removeUnwantedFields(Map<String, Object> map, String... keys); static T convertToRequestPojo(Request request, Class<T> clazz); static Map<String, String> getDateRange(int numDays); static ProjectCommonException createClientException(ResponseCode responseCode); static String getLmsUserId(String fedUserId); static String getFirstNCharacterString(String originalText, int noOfChar); static final String YEAR_MONTH_DATE_FORMAT; static PropertiesCache propertiesCache; static final String[] excludes; } | @Test public void testCreateAuthTokenSuccess() { String authToken = ProjectUtil.createAuthToken("test", "tset1234"); assertNotNull(authToken); } |
ProjectUtil { public static boolean validatePhoneNumber(String phone) { String phoneNo = ""; phoneNo = phone.replace("+", ""); if (phoneNo.matches("\\d{10}")) return true; else if (phoneNo.matches("\\d{3}[-\\.\\s]\\d{3}[-\\.\\s]\\d{4}")) return true; else if (phoneNo.matches("\\d{3}-\\d{3}-\\d{4}\\s(x|(ext))\\d{3,5}")) return true; else return (phoneNo.matches("\\(\\d{3}\\)-\\d{3}-\\d{4}")); } static String getFormattedDate(); static boolean isEmailvalid(final String email); static String createAuthToken(String name, String source); static String getUniqueIdFromTimestamp(int environmentId); static synchronized String generateUniqueId(); static boolean isNull(Object obj); static boolean isNotNull(Object obj); static String formatMessage(String exceptionMsg, Object... fieldValue); static SimpleDateFormat getDateFormatter(); static VelocityContext getContext(Map<String, Object> map); static Map<String, Object> createCheckResponse(
String serviceName, boolean isError, Exception e); static String registertag(
String tagId, String body, Map<String, String> header, RequestContext context); static String generateRandomPassword(); static boolean validatePhoneNumber(String phone); static Map<String, String> getEkstepHeader(); static boolean validatePhone(String phNumber, String countryCode); static boolean validateCountryCode(String countryCode); static boolean validateUUID(String uuidStr); static String getSMSBody(Map<String, String> smsTemplate); static boolean isDateValidFormat(String format, String value); static void createAndThrowServerError(); static ProjectCommonException createServerError(ResponseCode responseCode); static void createAndThrowInvalidUserDataException(); static boolean isUrlvalid(String url); static String getConfigValue(String key); static boolean isNotEmptyStringArray(String[] strArray); static String convertMapToJsonString(List<Map<String, Object>> mapList); static void removeUnwantedFields(Map<String, Object> map, String... keys); static T convertToRequestPojo(Request request, Class<T> clazz); static Map<String, String> getDateRange(int numDays); static ProjectCommonException createClientException(ResponseCode responseCode); static String getLmsUserId(String fedUserId); static String getFirstNCharacterString(String originalText, int noOfChar); static final String YEAR_MONTH_DATE_FORMAT; static PropertiesCache propertiesCache; static final String[] excludes; } | @Test public void testValidatePhoneNumberFailureWithInvalidPhoneNumber() { assertFalse(ProjectUtil.validatePhoneNumber("312")); }
@Test public void testValidatePhoneNumberSuccess() { assertTrue(ProjectUtil.validatePhoneNumber("9844016699")); } |
ProjectUtil { public static String generateRandomPassword() { String SALTCHARS = "abcdef12345ghijklACDEFGHmnopqrs67IJKLMNOP890tuvQRSTUwxyzVWXYZ"; StringBuilder salt = new StringBuilder(); Random rnd = new Random(); while (salt.length() < randomPasswordLength) { int index = (int) (rnd.nextFloat() * SALTCHARS.length()); salt.append(SALTCHARS.charAt(index)); } String saltStr = salt.toString(); return saltStr; } static String getFormattedDate(); static boolean isEmailvalid(final String email); static String createAuthToken(String name, String source); static String getUniqueIdFromTimestamp(int environmentId); static synchronized String generateUniqueId(); static boolean isNull(Object obj); static boolean isNotNull(Object obj); static String formatMessage(String exceptionMsg, Object... fieldValue); static SimpleDateFormat getDateFormatter(); static VelocityContext getContext(Map<String, Object> map); static Map<String, Object> createCheckResponse(
String serviceName, boolean isError, Exception e); static String registertag(
String tagId, String body, Map<String, String> header, RequestContext context); static String generateRandomPassword(); static boolean validatePhoneNumber(String phone); static Map<String, String> getEkstepHeader(); static boolean validatePhone(String phNumber, String countryCode); static boolean validateCountryCode(String countryCode); static boolean validateUUID(String uuidStr); static String getSMSBody(Map<String, String> smsTemplate); static boolean isDateValidFormat(String format, String value); static void createAndThrowServerError(); static ProjectCommonException createServerError(ResponseCode responseCode); static void createAndThrowInvalidUserDataException(); static boolean isUrlvalid(String url); static String getConfigValue(String key); static boolean isNotEmptyStringArray(String[] strArray); static String convertMapToJsonString(List<Map<String, Object>> mapList); static void removeUnwantedFields(Map<String, Object> map, String... keys); static T convertToRequestPojo(Request request, Class<T> clazz); static Map<String, String> getDateRange(int numDays); static ProjectCommonException createClientException(ResponseCode responseCode); static String getLmsUserId(String fedUserId); static String getFirstNCharacterString(String originalText, int noOfChar); static final String YEAR_MONTH_DATE_FORMAT; static PropertiesCache propertiesCache; static final String[] excludes; } | @Test public void testGenerateRandomPasswordSuccess() { assertNotNull(ProjectUtil.generateRandomPassword()); } |
ProjectUtil { public static Map<String, Object> createCheckResponse( String serviceName, boolean isError, Exception e) { Map<String, Object> responseMap = new HashMap<>(); responseMap.put(JsonKey.NAME, serviceName); if (!isError) { responseMap.put(JsonKey.Healthy, true); responseMap.put(JsonKey.ERROR, ""); responseMap.put(JsonKey.ERRORMSG, ""); } else { responseMap.put(JsonKey.Healthy, false); if (e != null && e instanceof ProjectCommonException) { ProjectCommonException commonException = (ProjectCommonException) e; responseMap.put(JsonKey.ERROR, commonException.getResponseCode()); responseMap.put(JsonKey.ERRORMSG, commonException.getMessage()); } else { responseMap.put(JsonKey.ERROR, e != null ? e.getMessage() : "CONNECTION_ERROR"); responseMap.put(JsonKey.ERRORMSG, e != null ? e.getMessage() : "Connection error"); } } return responseMap; } static String getFormattedDate(); static boolean isEmailvalid(final String email); static String createAuthToken(String name, String source); static String getUniqueIdFromTimestamp(int environmentId); static synchronized String generateUniqueId(); static boolean isNull(Object obj); static boolean isNotNull(Object obj); static String formatMessage(String exceptionMsg, Object... fieldValue); static SimpleDateFormat getDateFormatter(); static VelocityContext getContext(Map<String, Object> map); static Map<String, Object> createCheckResponse(
String serviceName, boolean isError, Exception e); static String registertag(
String tagId, String body, Map<String, String> header, RequestContext context); static String generateRandomPassword(); static boolean validatePhoneNumber(String phone); static Map<String, String> getEkstepHeader(); static boolean validatePhone(String phNumber, String countryCode); static boolean validateCountryCode(String countryCode); static boolean validateUUID(String uuidStr); static String getSMSBody(Map<String, String> smsTemplate); static boolean isDateValidFormat(String format, String value); static void createAndThrowServerError(); static ProjectCommonException createServerError(ResponseCode responseCode); static void createAndThrowInvalidUserDataException(); static boolean isUrlvalid(String url); static String getConfigValue(String key); static boolean isNotEmptyStringArray(String[] strArray); static String convertMapToJsonString(List<Map<String, Object>> mapList); static void removeUnwantedFields(Map<String, Object> map, String... keys); static T convertToRequestPojo(Request request, Class<T> clazz); static Map<String, String> getDateRange(int numDays); static ProjectCommonException createClientException(ResponseCode responseCode); static String getLmsUserId(String fedUserId); static String getFirstNCharacterString(String originalText, int noOfChar); static final String YEAR_MONTH_DATE_FORMAT; static PropertiesCache propertiesCache; static final String[] excludes; } | @Test public void testCreateCheckResponseSuccess() { Map<String, Object> responseMap = ProjectUtil.createCheckResponse("LearnerService", false, null); assertEquals(true, responseMap.get(JsonKey.Healthy)); }
@Test public void testCreateCheckResponseFailureWithException() { Map<String, Object> responseMap = ProjectUtil.createCheckResponse( "LearnerService", true, new ProjectCommonException( ResponseCode.invalidObjectType.getErrorCode(), ResponseCode.invalidObjectType.getErrorMessage(), ResponseCode.CLIENT_ERROR.getResponseCode())); assertEquals(false, responseMap.get(JsonKey.Healthy)); assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), responseMap.get(JsonKey.ERROR)); assertEquals( ResponseCode.invalidObjectType.getErrorMessage(), responseMap.get(JsonKey.ERRORMSG)); } |
UserUtil { public static void validateManagedUserLimit(String managedBy, RequestContext context) { if (Boolean.valueOf(ProjectUtil.getConfigValue(JsonKey.LIMIT_MANAGED_USER_CREATION))) { Map<String, Object> searchQueryMap = new HashMap<>(); searchQueryMap.put(JsonKey.MANAGED_BY, managedBy); List<User> managedUserList = Util.searchUser(searchQueryMap, context); if (CollectionUtils.isNotEmpty(managedUserList) && managedUserList.size() >= Integer.valueOf(ProjectUtil.getConfigValue(JsonKey.MANAGED_USER_LIMIT))) { throw new ProjectCommonException( ResponseCode.managedUserLimitExceeded.getErrorCode(), ResponseCode.managedUserLimitExceeded.getErrorMessage(), ResponseCode.CLIENT_ERROR.getResponseCode()); } } } private UserUtil(); static void updateExternalIdsProviderWithOrgId(
Map<String, Object> userMap, RequestContext context); static String getCaseInsensitiveOrgFromProvider(
String provider, Map<String, String> providerOrgMap); static Map<String, Object> validateExternalIdsAndReturnActiveUser(
Map<String, Object> userMap, RequestContext context); @SuppressWarnings("unchecked") static Map<String, Object> getUserFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserIdFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserId(Map<String, Object> userMap, RequestContext context); static void validateUserPhoneEmailAndWebPages(
User user, String operationType, RequestContext context); static String getDecryptedData(String value, RequestContext context); static List<Map<String, String>> copyAndConvertExternalIdsToLower(
List<Map<String, String>> externalIds); static void storeOriginalExternalIdsValue(List<Map<String, String>> externalIds); static void updateExternalIdsWithProvider(
List<Map<String, String>> dbResExternalIds, RequestContext context); static List<Map<String, String>> convertExternalIdsValueToLowerCase(
List<Map<String, String>> externalIds); static boolean updatePassword(Map<String, Object> userMap, RequestContext context); static void addMaskEmailAndMaskPhone(Map<String, Object> userMap); @SuppressWarnings("unchecked") static Map<String, Object> encryptUserData(Map<String, Object> userMap); static void setUserDefaultValueForV3(Map<String, Object> userMap, RequestContext context); static String transliterateUserName(String userName); static String generateUniqueString(int length); static void setUserDefaultValue(
Map<String, Object> userMap, String callerId, RequestContext context); static void validateExternalIds(User user, String operationType, RequestContext context); static void validateExternalIdsForUpdateUser(
User user, boolean isCustodianOrg, RequestContext context); static void checkEmailSameOrDiff(
Map<String, Object> userRequestMap, Map<String, Object> userDbRecord); static void validateUserExternalIds(User user, RequestContext context); static List<Map<String, String>> getExternalIds(String userId, RequestContext context); static List<Map<String, Object>> getActiveUserOrgDetails(
String userId, RequestContext context); static List<Map<String, Object>> getAllUserOrgDetails(
String userId, RequestContext context); static void toLower(Map<String, Object> userMap); static Map<String, Object> validateManagedByUser(
String managedBy, RequestContext context); static void validateManagedUserLimit(String managedBy, RequestContext context); static List<UserDeclareEntity> transformExternalIdsToSelfDeclaredRequest(
List<Map<String, String>> externalIds, Map<String, Object> requestMap); static String fetchProviderByOrgId(String orgId, RequestContext context); static Map<String, String> fetchOrgIdByProvider(
List<String> providers, RequestContext context); static void encryptDeclarationFields(
List<Map<String, Object>> declarations,
Map<String, Object> userDbRecords,
RequestContext context); static UserDeclareEntity createUserDeclaredObject(
Map<String, Object> declareFieldMap, String callerId); static void removeEntryFromUserLookUp(
Map<String, Object> userDbMap, List<String> identifiers, RequestContext context); } | @Test public void testValidateManagedUserLimit() { beforeEachTest(); Map<String, Object> req = new HashMap<>(); req.put(JsonKey.MANAGED_BY, "ManagedBy"); List managedUserList = new ArrayList<User>(); while (managedUserList.size() <= 31) { managedUserList.add(new User()); } when(Util.searchUser(req, null)).thenReturn(managedUserList); try { UserUtil.validateManagedUserLimit("ManagedBy", null); } catch (ProjectCommonException e) { assertEquals(e.getResponseCode(), 400); assertEquals(e.getMessage(), ResponseCode.managedUserLimitExceeded.getErrorMessage()); } } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.