method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
JdbcSqlExecutor implements SqlExecutor { @Override public int update(String sql, Object[] args) { try (CompositeAutoCloseable autoCloseable = new CompositeAutoCloseable()) { Connection connection = autoCloseable.add(connect()); return update(connection, sql, args); } } private JdbcSqlExecutor(DataSource dataSource, int fetchSize, Executor executor); @Override Dialect dialect(); @Override JdbcTransaction beginTransaction(); @Override DatabaseMetaData metadata(CompositeAutoCloseable autoCloseable); @Override List<T> query(String sql, Object[] args, RowMapper<T> rowMapper); @Override Stream<T> stream(String sql, Object[] args, RowMapper<T> rowMapper); @Override int update(String sql, Object[] args); CompletableFuture<Integer> updateAsync(Connection connection, String sql, Object[] args); static JdbcSqlExecutor of(DataSource dataSource); static JdbcSqlExecutor of(DataSource dataSource, int fetchSize); static JdbcSqlExecutor of(DataSource dataSource, Executor executor); static JdbcSqlExecutor of(DataSource dataSource, int fetchSize, Executor executor); }### Answer:
@Test void update() throws SQLException { when(preparedStatement.executeUpdate()).thenReturn(5); JdbcSqlExecutor sut = JdbcSqlExecutor.of(dataSource); String sql = "update foo set num = ?"; int result = sut.update(connection, sql, toArray(3)); verify(connection).prepareStatement(sql); verify(preparedStatement).executeUpdate(); verify(preparedStatement).setObject(1, 3); verify(preparedStatement).close(); verifyNoMoreInteractions(connection, preparedStatement, resultSet, rowMapper); assertThat(result, is(5)); }
|
### Question:
JdbcSqlExecutor implements SqlExecutor { @Override public DatabaseMetaData metadata(CompositeAutoCloseable autoCloseable) { Connection connection = autoCloseable.add(connect()); return ConnectionUtil.getMetaData(connection); } private JdbcSqlExecutor(DataSource dataSource, int fetchSize, Executor executor); @Override Dialect dialect(); @Override JdbcTransaction beginTransaction(); @Override DatabaseMetaData metadata(CompositeAutoCloseable autoCloseable); @Override List<T> query(String sql, Object[] args, RowMapper<T> rowMapper); @Override Stream<T> stream(String sql, Object[] args, RowMapper<T> rowMapper); @Override int update(String sql, Object[] args); CompletableFuture<Integer> updateAsync(Connection connection, String sql, Object[] args); static JdbcSqlExecutor of(DataSource dataSource); static JdbcSqlExecutor of(DataSource dataSource, int fetchSize); static JdbcSqlExecutor of(DataSource dataSource, Executor executor); static JdbcSqlExecutor of(DataSource dataSource, int fetchSize, Executor executor); }### Answer:
@Test void metadata() throws SQLException { Mockito.reset(connection); when(dataSource.getConnection()).thenReturn(connection); when(closer.add(connection)).thenReturn(connection); when(connection.getMetaData()).thenReturn(metadata); JdbcSqlExecutor sut = JdbcSqlExecutor.of(dataSource); DatabaseMetaData result = sut.metadata(closer); assertThat(result, sameInstance(metadata)); verify(dataSource, times(1)).getConnection(); verify(closer, times(1)).add(connection); verify(connection, times(1)).getMetaData(); verifyNoMoreInteractions(dataSource, connection, metadata); }
|
### Question:
SchemaGenerator { public void generate(Database database, SchemaDefinition schemaDefinition) { if (dropFirst) { long dropped = dropAll(database); LOG.debug("Dropped {} objects", dropped); } Stream<Action> actions = Stream.concat( Stream.of(new CreateActionLogTable(database.defaultCatalog(), database.defaultSchema())), schemaDefinition.actions()); long count = pipeline .process(database, actions) .count(); LOG.debug("Processed {} actions", count); } SchemaGenerator(boolean dropFirst); void generate(Database database, SchemaDefinition schemaDefinition); void generate(Database database, Function1<T,SchemaDefinition> schemaDefinition); }### Answer:
@Test void generate() { Database database = TestDatabase.testDatabaseBuilder() .defaultSqlExecutor(JdbcSqlExecutor.of(dataSource())) .dialect(new H2Dialect()) .build(); SchemaGenerator schemaGenerator = new SchemaGenerator(true); schemaGenerator.generate(database, TestSchema::schemaDefinition); schemaGenerator.generate(database, TestSchema::schemaDefinition); SalespersonRow salespersonRow = aRandomSalesperson(); database.insert(salespersonRow); }
|
### Question:
SelectStatement { void fetchFirst(long i) { fetchFirst = Optional.of(i); } SelectStatement(Scope scope, TypeToken<RT> rowType, From from, RowMapper<RT> rowMapper, Projection projection); TypeToken<RT> rowType(); Stream<CommonTableExpression<?>> commonTableExpressions(); }### Answer:
@Test void fetchFirst() { SelectStatement<Integer> sut = new SelectStatement<>(createScope(), TypeToken.of(Integer.class), from, rowMapper, projection); when(projection.sql(any())).thenReturn("*"); when(from.sql(any())).thenReturn(" from bob"); sut.fetchFirst(4L); assertThat(sut.sql(), is("select * from bob fetch first 4 rows only")); }
|
### Question:
ArrayUtil extends UtilityClass { @SuppressWarnings("unchecked") public static <T> T[] newArray(Class<T> elementType, int size) { return (T[]) Array.newInstance(elementType, size); } @SuppressWarnings("unchecked") static T[] newArray(Class<T> elementType, int size); @SuppressWarnings("unchecked") static T[] newArray(TypeToken<T> elementType, int size); @SuppressWarnings("unchecked") static IntFunction<T[]> generator(Class<? super T> elementClass); @SuppressWarnings("unchecked") static IntFunction<T[]> generator(T prototype); @SuppressWarnings("unchecked") static T[] arrayOf(int size, T value); static char[] arrayOf(int size, char value); static boolean[] arrayOf(int size, boolean value); static byte[] arrayOf(int size, byte value); static short[] arrayOf(int size, short value); static int[] arrayOf(int size, int value); static long[] arrayOf(int size, long value); static float[] arrayOf(int size, float value); static double[] arrayOf(int size, double value); static Stream<Boolean> stream(boolean[] booleans); static Stream<Byte> stream(byte[] bytes); static Stream<Character> stream(char[] chars); static Stream<Short> stream(short[] shorts); static Stream<Float> stream(float[] floats); }### Answer:
@Test void newArrayClass() { int size = RandomUtils.nextInt(5, 20); ZonedDateTime[] result = ArrayUtil.newArray(ZonedDateTime.class, size); assertThat(result, arrayWithSize(size)); }
@Test void newArrayTypeToken() { int size = RandomUtils.nextInt(5, 20); List<Integer>[] result = ArrayUtil.newArray(new TypeToken<List<Integer>>() {}, size); assertThat(result, arrayWithSize(size)); }
|
### Question:
ArrayUtil extends UtilityClass { @SuppressWarnings("unchecked") public static <T> IntFunction<T[]> generator(Class<? super T> elementClass) { return size -> (T[])ArrayUtil.newArray(elementClass, size); } @SuppressWarnings("unchecked") static T[] newArray(Class<T> elementType, int size); @SuppressWarnings("unchecked") static T[] newArray(TypeToken<T> elementType, int size); @SuppressWarnings("unchecked") static IntFunction<T[]> generator(Class<? super T> elementClass); @SuppressWarnings("unchecked") static IntFunction<T[]> generator(T prototype); @SuppressWarnings("unchecked") static T[] arrayOf(int size, T value); static char[] arrayOf(int size, char value); static boolean[] arrayOf(int size, boolean value); static byte[] arrayOf(int size, byte value); static short[] arrayOf(int size, short value); static int[] arrayOf(int size, int value); static long[] arrayOf(int size, long value); static float[] arrayOf(int size, float value); static double[] arrayOf(int size, double value); static Stream<Boolean> stream(boolean[] booleans); static Stream<Byte> stream(byte[] bytes); static Stream<Character> stream(char[] chars); static Stream<Short> stream(short[] shorts); static Stream<Float> stream(float[] floats); }### Answer:
@Test void generator() { int size = RandomUtils.nextInt(5, 20); IntFunction<List<String>[]> result = ArrayUtil.generator(List.class); assertThat(result.apply(size), arrayWithSize(size)); }
|
### Question:
Try { public static <T, E extends Throwable> Try<T> trySupply(ThrowingSupplier<? extends T,E> supplier) { requireNonNull(supplier); try { return success(supplier.get()); } catch (Throwable e) { return failure(e); } } abstract boolean isSuccess(); abstract boolean isFailure(); abstract T orElseThrow(); abstract Throwable throwable(); abstract Try<U> map(ThrowingFunction<? super T,? extends U,? extends E> function); abstract Try<U> flatMap(ThrowingFunction<? super T,Try<U>,? extends E> function); abstract Try<R> combine(Try<U> other, ThrowingFunction2<? super T,? super U,? extends R,? extends E> function); abstract T orElse(T alternativeValue); abstract T orElseGet(Supplier<T> supplier); abstract Try<T> orElseTry(ThrowingSupplier<T,? extends E> supplier); abstract T orElseThrow(Supplier<? extends X> exceptionSupplier); abstract Try<T> throwIfError(); abstract Try<T> ifSuccess(Consumer<? super T> consumer); abstract Try<T> ifFailure(Consumer<? super Throwable> consumer); abstract Optional<T> toOptional(); abstract Stream<T> stream(); static Try<T> trySupply(ThrowingSupplier<? extends T,E> supplier); static Try<T> success(T value); static Try<T> failure(Throwable e); }### Answer:
@Test void trySupplyWithNullSupplier() { calling(() -> Try.trySupply(null)) .shouldThrow(NullPointerException.class); }
|
### Question:
OptionalUtil extends UtilityClass { public static <T extends CharSequence> Optional<T> ofBlankable(T s) { return StringUtils.isBlank(s) ? Optional.empty() : Optional.of(s); } static Optional<T> ofBlankable(T s); static Optional<T> ofOnly(Iterable<T> iterable); static OptionalWrapper<T> with(Optional<T> optional); static Optional<T> or(Optional<T> optional, Optional<T> other); static Optional<T> orGet(Optional<T> optional, Supplier<? extends Optional<? extends T>> supplier); static Optional<U> as(Class<U> targetClass, Optional<T> source); @SuppressWarnings("unchecked") static Optional<U> as(TypeToken<U> targetType, Optional<T> source); static Optional<U> as(Class<U> targetClass, T source); @SuppressWarnings("unchecked") static Optional<U> as(TypeToken<U> targetType, T source); }### Answer:
@ParameterizedTest @ArgumentsSource(TestCaseArgumentsProvider.class) @TestCase({"null", "empty"}) @TestCase({"", "empty"}) @TestCase({"\n", "empty"}) @TestCase({" ", "empty"}) @TestCase({"\f\r\n ", "empty"}) @TestCase({"x", "x"}) void ofBlankable(String input, Optional<String> expected) { Optional<String> result = OptionalUtil.ofBlankable(input); assertThat(result, is(expected)); }
|
### Question:
SelectStatement { void withIsolation(IsolationLevel level) { isolationLevel = level; } SelectStatement(Scope scope, TypeToken<RT> rowType, From from, RowMapper<RT> rowMapper, Projection projection); TypeToken<RT> rowType(); Stream<CommonTableExpression<?>> commonTableExpressions(); }### Answer:
@ParameterizedTest @ArgumentsSource(TestCaseArgumentsProvider.class) @TestCase({"UNSPECIFIED", ""}) @TestCase({"UNCOMMITTED_READ", " with ur"}) @TestCase({"READ_COMMITTED", " with cs"}) @TestCase({"REPEATABLE_READ", " with rs"}) @TestCase({"SERIALIZABLE", " with rr"}) void withIsolation(IsolationLevel isolation, String isolationSql) { SelectStatement<Integer> sut = new SelectStatement<>(createScope(), TypeToken.of(Integer.class), from, rowMapper, projection); sut.withIsolation(isolation); when(projection.sql(any())).thenReturn("col1"); when(from.sql(any())).thenReturn(" from tab1"); assertThat(sut.sql(), is("select col1 from tab1" + isolationSql)); }
|
### Question:
Evaluator { public static String calculate(String calculation) throws Exception{ ScriptEngineManager mgr = new ScriptEngineManager(); ScriptEngine engine = mgr.getEngineByName("JavaScript"); return engine.eval(calculation).toString(); } static String calculate(String calculation); }### Answer:
@Test public void testSomeCalculations() throws Exception{ Assert.assertEquals(mEvalutor.calculate("5+5"), "10", "5+5 should equal 10"); }
@Test public void testBooleanExpression() throws Exception{ Assert.assertEquals(mEvalutor.calculate("true == false"), "false", "true is never false"); Assert.assertEquals( mEvalutor.calculate("5 > 0"), "true", "this always holds"); }
|
### Question:
QuickCount extends Count { public void increment(Integer amount) { super.increment(2 * amount.intValue()); } void increment(Integer amount); }### Answer:
@Test public void testInheritance() throws Exception { Count c = new QuickCount(); c.increment(); Assert.assertEquals(c.getCount(), 2, "Java always calls the overriden method, despite not marking it as abstract"); }
@Test public void testDerivedCall() throws Exception { Count a = new QuickCount(); Number b = new Integer(5); a.increment(b); Assert.assertEquals(a.getCount(), 5, "Overriding only works for equal signatures"); }
|
### Question:
SampleOperation { public void add(Int a){ a.setValue(10); System.out.println("Called Int"); } void add(Int a); void add(Real a); void add(); }### Answer:
@Test public void testSomeAddition() throws Exception { Num b = new Int(5); SampleOperation s = new SampleOperation(); s.add((Int) b); Assert.assertEquals(((Int) b).getValue(), 10, "Java should automatically grab the proper overload"); }
|
### Question:
Addition extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " + " + getRight() + ")"; } Addition(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }### Answer:
@Test public void checkAdditionParse() { final String EXPECTED_RESULT = "(1 + 2)"; QLParser parser = ASTBuilder.getQlParser("1+2"); Addition expression = (Addition) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkAdditionNestedParse() { final String EXPECTED_RESULT = "((1 + 2) + 3)"; QLParser parser = ASTBuilder.getQlParser("1+2+3"); Addition expression = (Addition) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
### Question:
LogicalOr extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " || " + getRight() + ")"; } LogicalOr(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }### Answer:
@Test public void checkLogicalOrParse() { final String EXPECTED_RESULT = "(1 || 2)"; QLParser parser = ASTBuilder.getQlParser("1||2"); LogicalOr expression = (LogicalOr) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkLogicalOrNestedParse() { final String EXPECTED_RESULT = "((1 || 2) || 3)"; QLParser parser = ASTBuilder.getQlParser("1||2||3"); LogicalOr expression = (LogicalOr) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
### Question:
LessThanEqualTo extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " <= " + getRight() + ")"; } LessThanEqualTo(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }### Answer:
@Test public void checkLessThanEqualToParse() { final String EXPECTED_RESULT = "(1 <= 2)"; QLParser parser = ASTBuilder.getQlParser("1<=2"); LessThanEqualTo expression = (LessThanEqualTo) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkLessThanEqualToNestedParse() { final String EXPECTED_RESULT = "((1 <= 2) <= 3)"; QLParser parser = ASTBuilder.getQlParser("1<=2<=3"); LessThanEqualTo expression = (LessThanEqualTo) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
### Question:
LessThan extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " < " + getRight() + ")"; } LessThan(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }### Answer:
@Test public void checkLessThanParse() { final String EXPECTED_RESULT = "(1 < 2)"; QLParser parser = ASTBuilder.getQlParser("1<2"); LessThan expression = (LessThan) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkLessThanNestedParse() { final String EXPECTED_RESULT = "((1 < 2) < 3)"; QLParser parser = ASTBuilder.getQlParser("1<2<3"); LessThan expression = (LessThan) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
### Question:
Subtraction extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " - " + getRight() + ")"; } Subtraction(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }### Answer:
@Test public void checkSubtractionParse() { final String EXPECTED_RESULT = "(1 - 2)"; QLParser parser = ASTBuilder.getQlParser("1-2"); Subtraction expression = (Subtraction) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkSubtractionNestedParse() { final String EXPECTED_RESULT = "((1 - 2) - 3)"; QLParser parser = ASTBuilder.getQlParser("1-2-3"); Subtraction expression = (Subtraction) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
### Question:
DependencyChecker { public DependencyChecker() { this.dependencies = new HashSet<>(); } DependencyChecker(); ErrorLogger checkForCircularDependencies(Map<String, List<Parameter>> expressionMap); }### Answer:
@Test public void testDependencyChecker() { DependencyChecker checker = new DependencyChecker(); int EXPECTED_PAIRS = 6; int EXPECTED_REFLEXIVE_PAIRS = 3; DependencyPair pair1 = new DependencyPair("test1", "test2"); DependencyPair pair2 = new DependencyPair("test2", "test3"); DependencyPair pair3 = new DependencyPair("test3", "test1"); Set<DependencyPair> dependencySet = new HashSet<DependencyPair>() {{ add(pair1); add(pair2); add(pair3); }}; Set<DependencyPair> closure = checker.makeClosure(dependencySet); int reflexiveCount = 0; for (DependencyPair pair : closure) { if (pair.isReflexive()) { reflexiveCount++; } } assertEquals(EXPECTED_PAIRS, closure.size()); assertEquals(EXPECTED_REFLEXIVE_PAIRS, reflexiveCount); }
|
### Question:
Division extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " / " + getRight() + ")"; } Division(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }### Answer:
@Test public void checkDivisionParse() { final String EXPECTED_RESULT = "(1 / 2)"; QLParser parser = ASTBuilder.getQlParser("1/2"); Division expression = (Division) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkDivisionNestedParse() { final String EXPECTED_RESULT = "((1 / 2) / 3)"; QLParser parser = ASTBuilder.getQlParser("1/2/3"); Division expression = (Division) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
### Question:
LogicalAnd extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " && " + getRight() + ")"; } LogicalAnd(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }### Answer:
@Test public void checkLogicalAndParse() { final String EXPECTED_RESULT = "(1 && 2)"; QLParser parser = ASTBuilder.getQlParser("1&&2"); LogicalAnd expression = (LogicalAnd) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkLogicalAndNestedParse() { final String EXPECTED_RESULT = "((1 && 2) && 3)"; QLParser parser = ASTBuilder.getQlParser("1&&2&&3"); LogicalAnd expression = (LogicalAnd) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
### Question:
GreaterThan extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " > " + getRight() + ")"; } GreaterThan(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }### Answer:
@Test public void checkGreaterThanParse() { final String EXPECTED_RESULT = "(1 > 2)"; QLParser parser = ASTBuilder.getQlParser("1>2"); GreaterThan expression = (GreaterThan) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkGreaterThanNestedParse() { final String EXPECTED_RESULT = "((1 > 2) > 3)"; QLParser parser = ASTBuilder.getQlParser("1>2>3"); GreaterThan expression = (GreaterThan) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
### Question:
NotEqual extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " != " + getRight() + ")"; } NotEqual(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }### Answer:
@Test public void checkNotEqualParse() { final String EXPECTED_RESULT = "(1 != 2)"; QLParser parser = ASTBuilder.getQlParser("1!=2"); NotEqual expression = (NotEqual) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkNotEqualNestedParse() { final String EXPECTED_RESULT = "((1 != 2) != 3)"; QLParser parser = ASTBuilder.getQlParser("1!=2!=3"); NotEqual expression = (NotEqual) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
### Question:
Equal extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " == " + getRight() + ")"; } Equal(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }### Answer:
@Test public void checkEqualParse() { final String EXPECTED_RESULT = "(1 == 2)"; QLParser parser = ASTBuilder.getQlParser("1==2"); Equal expression = (Equal) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkEqualNestedParse() { final String EXPECTED_RESULT = "((1 == 2) == 3)"; QLParser parser = ASTBuilder.getQlParser("1==2==3"); Equal expression = (Equal) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
### Question:
Question extends Item { public ValueType getType() { return type; } Question(int lineNumber, String label, String identifier, ValueType type); String getLabel(); String getIdentifier(); ValueType getType(); @Override String toString(); @Override T accept(ItemVisitor<T> visitor); }### Answer:
@Test public void testIntegerValueType() throws IOException { String qlForm = "form taxOfficeExample { \"q1?\" value: integer }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); Question question = (Question) questions.get(0); assertThat(question.getType(), instanceOf(Integer.class)); }
@Test public void testMoneyValueType() throws IOException { String qlForm = "form taxOfficeExample { \"q1?\" value: money }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); Question question = (Question) questions.get(0); assertThat(question.getType(), instanceOf(Money.class)); }
|
### Question:
IfThenElse extends IfThen { public List<Item> getElseStatements() { return elseStatements; } IfThenElse(int lineNumber, Expression condition, List<Item> thenStatements, List<Item> elseStatements); List<Item> getElseStatements(); @Override T accept(ItemVisitor<T> visitor); }### Answer:
@Test public void testIfElseBlock() throws IOException { String qlForm = "form taxOfficeExample { if (hasSoldHouse) { \"q1?\" val1: boolean } else { \"q2?\" val2: boolean } }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); IfThenElse ifThenElse = (IfThenElse) questions.get(0); assertEquals(1, ifThenElse.getThenStatements().size()); assertEquals(1, ifThenElse.getElseStatements().size()); }
@Test public void testEmptyElseStatements() throws IOException { String qlForm = "form taxOfficeExample { if (hasSoldHouse) { \"q1?\" val1: boolean } else { } }"; Form form = ASTGenerator.getForm(qlForm); List<Item> questions = form.getQuestions(); IfThenElse ifThenElse = (IfThenElse) questions.get(0); assertEquals(1, ifThenElse.getThenStatements().size()); assertEquals(0, ifThenElse.getElseStatements().size()); }
|
### Question:
FileReader { public String readFile(File selectedFile) { String fileContents = ""; try (BufferedReader br = new BufferedReader(new java.io.FileReader(selectedFile))) { String line; while ((line = br.readLine()) != null) { fileContents = fileContents.concat(line + '\n'); } } catch (IOException e) { Logger.getAnonymousLogger().log(Level.SEVERE, "Exception", e); ErrorDialogGenerator.generateErrorListBox(e.getMessage(), "File Read Error", "There was an error reading the input file"); Platform.exit(); } return fileContents; } String readFile(File selectedFile); }### Answer:
@Test public void readFile() { String output = fileReader.readFile(file); int expectedLines = 47; String[] lines = output.split(System.getProperty("line.separator")); assertEquals(expectedLines, lines.length); }
|
### Question:
Parameter extends Expression { public String getID() { return this.id; } Parameter(String s, int line, int column); String getID(); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }### Answer:
@Test public void checkParameterParse() { final String EXPECTED_RESULT = "testParameter"; QLParser parser = ASTBuilder.getQlParser("testParameter"); Parameter parameter = (Parameter) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, parameter.getID()); }
|
### Question:
Multiplication extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " * " + getRight() + ")"; } Multiplication(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }### Answer:
@Test public void checkMultiplicationParse() { final String EXPECTED_RESULT = "(1 * 2)"; QLParser parser = ASTBuilder.getQlParser("1*2"); Multiplication expression = (Multiplication) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkMultiplicationNestedParse() { final String EXPECTED_RESULT = "((1 * 2) * 3)"; QLParser parser = ASTBuilder.getQlParser("1*2*3"); Multiplication expression = (Multiplication) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
### Question:
GreaterThanEqualTo extends BinaryOperation { @Override public String toString() { return "(" + getLeft() + " >= " + getRight() + ")"; } GreaterThanEqualTo(Expression left, Expression right, int line, int charPositionInLine); @Override String toString(); @Override T accept(ExpressionVisitor<T, C> visitor, C context); }### Answer:
@Test public void checkGreaterThenEqualToParse() { final String EXPECTED_RESULT = "(1 >= 2)"; QLParser parser = ASTBuilder.getQlParser("1>=2"); GreaterThanEqualTo expression = (GreaterThanEqualTo) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
@Test public void checkGreaterThenEqualToNestedParse() { final String EXPECTED_RESULT = "((1 >= 2) >= 3)"; QLParser parser = ASTBuilder.getQlParser("1>=2>=3"); GreaterThanEqualTo expression = (GreaterThanEqualTo) ASTBuilder.getExpression(parser); assertEquals(EXPECTED_RESULT, expression.toString()); }
|
### Question:
FactMap implements NameValueReferableMap<T> { @Override public boolean isEmpty() { return _facts.isEmpty(); } FactMap(Map<String, NameValueReferable<T>> facts); @SafeVarargs FactMap(NameValueReferable<T>... facts); FactMap(); @Override T getOne(); @Override T getValue(String name); @Deprecated String getStrVal(String name); @Deprecated Integer getIntVal(String name); @Deprecated Double getDblVal(String name); void setValue(String name, T value); @Override Fact<T> put(NameValueReferable<T> fact); @Override Fact<T> put(String key, NameValueReferable<T> fact); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override Fact<T> get(Object key); @Override Fact<T> remove(Object key); @Override void putAll(Map<? extends String, ? extends NameValueReferable<T>> map); @Override void clear(); @Override Set<String> keySet(); @Override Collection<NameValueReferable<T>> values(); @Override Set<Entry<String, NameValueReferable<T>>> entrySet(); @Override String toString(); }### Answer:
@Test public void isEmptyShouldDelegateToMap() { Map<String, Object> map = Mockito.mock(Map.class); FactMap factMap = new FactMap(map); Mockito.when(map.isEmpty()).thenReturn(true); Assert.assertTrue(factMap.isEmpty()); Mockito.verify(map, Mockito.times(1)).isEmpty(); }
|
### Question:
AnnotationUtils { public static Optional<Field> getAnnotatedField(Class annotation, Class clazz) { List<Field> fields = getAnnotatedFields(annotation, clazz); return Optional.ofNullable(fields.size() > 0 ? fields.get(0) : null); } private AnnotationUtils(); @SuppressWarnings("unchecked") static List<Field> getAnnotatedFields(Class annotation, Class clazz); static Optional<Field> getAnnotatedField(Class annotation, Class clazz); @SuppressWarnings("unchecked") static List<Method> getAnnotatedMethods(Class annotation, Class clazz); static Optional<Method> getAnnotatedMethod(Class annotation, Class clazz); @SuppressWarnings("unchecked") static A getAnnotation(Class<A> annotation, Class<?> clazz); }### Answer:
@Test public void getAnnotatedFieldShouldFindFirstAnnotatedField() { Optional<Field> givenField = getAnnotatedField(Given.class, SampleRuleWithResult.class); Assert.assertEquals(givenField.get().getType(), Fact.class); Assert.assertEquals(givenField.get().getName(), "_fact1"); }
@Test public void getAnnotatedFieldShouldFindFirsAnnotatedFieldInCurrentClassBeforeParent() { Optional<Field> givenField = getAnnotatedField(Given.class, SubRuleWithResult.class); Assert.assertEquals(givenField.get().getType(), String.class); Assert.assertEquals(givenField.get().getName(), "_subFact"); }
|
### Question:
AnnotationUtils { @SuppressWarnings("unchecked") public static List<Method> getAnnotatedMethods(Class annotation, Class clazz) { List<Method> methods = new ArrayList<>(); if (clazz == Object.class) { return methods; } methods.addAll((List<Method>) Arrays.stream(clazz.getDeclaredMethods()) .filter(field -> field.getAnnotation(annotation) != null) .collect(Collectors.toList())); methods.addAll(getAnnotatedMethods(annotation, clazz.getSuperclass())); return methods; } private AnnotationUtils(); @SuppressWarnings("unchecked") static List<Field> getAnnotatedFields(Class annotation, Class clazz); static Optional<Field> getAnnotatedField(Class annotation, Class clazz); @SuppressWarnings("unchecked") static List<Method> getAnnotatedMethods(Class annotation, Class clazz); static Optional<Method> getAnnotatedMethod(Class annotation, Class clazz); @SuppressWarnings("unchecked") static A getAnnotation(Class<A> annotation, Class<?> clazz); }### Answer:
@Test public void getAnnotatedMethodsShouldFindAnnotatedMethods() { List<Method> thenMethods = getAnnotatedMethods(Then.class, SampleRuleWithResult.class); List<Method> whenMethods = getAnnotatedMethods(When.class, SampleRuleWithResult.class); Assert.assertEquals(1, thenMethods.size()); Assert.assertEquals(1, whenMethods.size()); }
@Test public void getAnnotatedMethodsShouldFindAnnotatedMethodsInParent() { List<Method> thenMethods = getAnnotatedMethods(Then.class, SubRuleWithResult.class); List<Method> whenMethods = getAnnotatedMethods(When.class, SubRuleWithResult.class); Assert.assertEquals(1, thenMethods.size()); Assert.assertEquals(2, whenMethods.size()); }
|
### Question:
AnnotationUtils { public static Optional<Method> getAnnotatedMethod(Class annotation, Class clazz) { List<Method> methods = getAnnotatedMethods(annotation, clazz); return Optional.ofNullable(methods.size() > 0 ? methods.get(0) : null); } private AnnotationUtils(); @SuppressWarnings("unchecked") static List<Field> getAnnotatedFields(Class annotation, Class clazz); static Optional<Field> getAnnotatedField(Class annotation, Class clazz); @SuppressWarnings("unchecked") static List<Method> getAnnotatedMethods(Class annotation, Class clazz); static Optional<Method> getAnnotatedMethod(Class annotation, Class clazz); @SuppressWarnings("unchecked") static A getAnnotation(Class<A> annotation, Class<?> clazz); }### Answer:
@Test public void getAnnotatedMethodShouldFindFirstMethod() { Optional<Method> whenMethod = getAnnotatedMethod(When.class, SubRuleWithResult.class); Assert.assertEquals(whenMethod.get().getName(), "condition"); }
@Test public void getAnnotatedMethodShouldReturnEmptyOptionalWhenAnnotationNotFound() { Optional<Method> whenMethod = getAnnotatedMethod(When.class, SampleRuleWithoutRuleAnnotation.class); Assert.assertFalse(whenMethod.isPresent()); }
|
### Question:
AnnotationUtils { @SuppressWarnings("unchecked") public static <A extends Annotation> A getAnnotation(Class<A> annotation, Class<?> clazz) { return Optional.ofNullable(clazz.getAnnotation(annotation)).orElse((A) Arrays.stream(clazz.getDeclaredAnnotations()) .flatMap(anno -> Arrays.stream(anno.getClass().getInterfaces()) .flatMap(iface -> Arrays.stream(iface.getDeclaredAnnotations()))) .filter(annotation::isInstance) .findFirst().orElse(null) ); } private AnnotationUtils(); @SuppressWarnings("unchecked") static List<Field> getAnnotatedFields(Class annotation, Class clazz); static Optional<Field> getAnnotatedField(Class annotation, Class clazz); @SuppressWarnings("unchecked") static List<Method> getAnnotatedMethods(Class annotation, Class clazz); static Optional<Method> getAnnotatedMethod(Class annotation, Class clazz); @SuppressWarnings("unchecked") static A getAnnotation(Class<A> annotation, Class<?> clazz); }### Answer:
@Test public void getAnnotationShouldFindTheAnnotationOfAnAnnotation() { Rule ruleAnnotation = getAnnotation(Rule.class, SubRuleWithResult.class); SubRuleAnnotation subRuleAnnotation = getAnnotation(SubRuleAnnotation.class, SubRuleWithResult.class); Assert.assertNotNull(ruleAnnotation); Assert.assertNotNull(subRuleAnnotation); }
|
### Question:
FactMap implements NameValueReferableMap<T> { @Override public boolean containsValue(Object value) { return _facts.containsValue(value); } FactMap(Map<String, NameValueReferable<T>> facts); @SafeVarargs FactMap(NameValueReferable<T>... facts); FactMap(); @Override T getOne(); @Override T getValue(String name); @Deprecated String getStrVal(String name); @Deprecated Integer getIntVal(String name); @Deprecated Double getDblVal(String name); void setValue(String name, T value); @Override Fact<T> put(NameValueReferable<T> fact); @Override Fact<T> put(String key, NameValueReferable<T> fact); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override Fact<T> get(Object key); @Override Fact<T> remove(Object key); @Override void putAll(Map<? extends String, ? extends NameValueReferable<T>> map); @Override void clear(); @Override Set<String> keySet(); @Override Collection<NameValueReferable<T>> values(); @Override Set<Entry<String, NameValueReferable<T>>> entrySet(); @Override String toString(); }### Answer:
@Test public void containsValueShouldDelegateToMap() { Map<String, Object> map = Mockito.mock(Map.class); FactMap factMap = new FactMap(map); Mockito.when(map.containsValue("value1")).thenReturn(true); Mockito.when(map.containsValue("value2")).thenReturn(false); Assert.assertTrue(factMap.containsValue("value1")); Assert.assertFalse(factMap.containsValue("value2")); Mockito.verify(map, Mockito.times(1)).containsValue("value1"); Mockito.verify(map, Mockito.times(1)).containsValue("value2"); }
|
### Question:
RuleAdapter implements Rule { @Override @SuppressWarnings("unchecked") public List<Object> getActions() { if (_rule.getActions().size() < 1) { List<Object> actionList = new ArrayList<>(); for (Method actionMethod : getAnnotatedMethods(Then.class, _pojoRule.getClass())) { actionMethod.setAccessible(true); Object then = getThenMethodAsBiConsumer(actionMethod).map(Object.class::cast) .orElse(getThenMethodAsConsumer(actionMethod).orElse(factMap -> { })); actionList.add(then); } _rule.getActions().addAll(actionList); } return _rule.getActions(); } RuleAdapter(Object pojoRule, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object pojoRule); @Override void addFacts(NameValueReferable... facts); @Override void addFacts(NameValueReferableMap facts); @Override void setFacts(NameValueReferableMap facts); @Override @SuppressWarnings("unchecked") void setCondition(Predicate condition); @Override void setRuleState(RuleState ruleState); @Override @SuppressWarnings("unchecked") void addAction(Consumer action); @Override @SuppressWarnings("unchecked") void addAction(BiConsumer action); @Override void addFactNameFilter(String... factNames); @Override NameValueReferableMap getFacts(); @Override @SuppressWarnings("unchecked") Predicate<NameValueReferableMap> getCondition(); @Override RuleState getRuleState(); @Override @SuppressWarnings("unchecked") List<Object> getActions(); @Override @SuppressWarnings("unchecked") boolean invoke(NameValueReferableMap facts); @Override @SuppressWarnings("unchecked") void setResult(Result result); @Override Optional<Result> getResult(); }### Answer:
@Test public void pojoWithNoThenAnnotationDefaultsToNext() throws InvalidClassException { SampleRuleWithoutAnnotations sampleRule = new SampleRuleWithoutAnnotations(); RuleAdapter ruleAdapter = new RuleAdapter(sampleRule); Assert.assertEquals(0, ((List<Object>)ruleAdapter.getActions()).size()); }
|
### Question:
RuleAdapter implements Rule { @Override public void addFactNameFilter(String... factNames) { throw new UnsupportedOperationException(); } RuleAdapter(Object pojoRule, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object pojoRule); @Override void addFacts(NameValueReferable... facts); @Override void addFacts(NameValueReferableMap facts); @Override void setFacts(NameValueReferableMap facts); @Override @SuppressWarnings("unchecked") void setCondition(Predicate condition); @Override void setRuleState(RuleState ruleState); @Override @SuppressWarnings("unchecked") void addAction(Consumer action); @Override @SuppressWarnings("unchecked") void addAction(BiConsumer action); @Override void addFactNameFilter(String... factNames); @Override NameValueReferableMap getFacts(); @Override @SuppressWarnings("unchecked") Predicate<NameValueReferableMap> getCondition(); @Override RuleState getRuleState(); @Override @SuppressWarnings("unchecked") List<Object> getActions(); @Override @SuppressWarnings("unchecked") boolean invoke(NameValueReferableMap facts); @Override @SuppressWarnings("unchecked") void setResult(Result result); @Override Optional<Result> getResult(); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void usingMethodShouldThrowNotImplemented() throws InvalidClassException { RuleAdapter ruleAdapter = new RuleAdapter(new SampleRuleWithResult()); ruleAdapter.addFactNameFilter(); }
|
### Question:
RuleAdapter implements Rule { @Override @SuppressWarnings("unchecked") public void addAction(Consumer action) { _rule.addAction(action); } RuleAdapter(Object pojoRule, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object pojoRule); @Override void addFacts(NameValueReferable... facts); @Override void addFacts(NameValueReferableMap facts); @Override void setFacts(NameValueReferableMap facts); @Override @SuppressWarnings("unchecked") void setCondition(Predicate condition); @Override void setRuleState(RuleState ruleState); @Override @SuppressWarnings("unchecked") void addAction(Consumer action); @Override @SuppressWarnings("unchecked") void addAction(BiConsumer action); @Override void addFactNameFilter(String... factNames); @Override NameValueReferableMap getFacts(); @Override @SuppressWarnings("unchecked") Predicate<NameValueReferableMap> getCondition(); @Override RuleState getRuleState(); @Override @SuppressWarnings("unchecked") List<Object> getActions(); @Override @SuppressWarnings("unchecked") boolean invoke(NameValueReferableMap facts); @Override @SuppressWarnings("unchecked") void setResult(Result result); @Override Optional<Result> getResult(); }### Answer:
@Test public void thenMethodShouldDelegateToRuleThenMethod() throws InvalidClassException { Rule rule = mock(Rule.class); BiConsumer<NameValueReferable, Result> biConsumer = (result, facts) -> { }; RuleAdapter ruleAdapter = new RuleAdapter(new SampleRuleWithResult(), rule); ruleAdapter.addAction(biConsumer); verify(rule, times(1)).addAction(biConsumer); }
|
### Question:
AuditableRule implements Rule<T, U>, Auditable { @Override public String getName() { return _name; } AuditableRule(Rule<T, U> rule); AuditableRule(Rule<T, U> rule, String name); @Override void addFacts(NameValueReferable... facts); @Override void addFacts(NameValueReferableMap facts); @Override void setFacts(NameValueReferableMap facts); @Override void setCondition(Predicate<NameValueReferableTypeConvertibleMap<T>> condition); @Override void setRuleState(RuleState ruleState); @Override void addAction(Consumer<NameValueReferableTypeConvertibleMap<T>> action); @Override void addAction(BiConsumer<NameValueReferableTypeConvertibleMap<T>, Result<U>> action); @Override void addFactNameFilter(String... factNames); @Override NameValueReferableMap getFacts(); @Override Predicate<NameValueReferableTypeConvertibleMap<T>> getCondition(); @Override RuleState getRuleState(); @Override List<Object> getActions(); @Override boolean invoke(NameValueReferableMap facts); @Override void setResult(Result<U> result); @Override Optional<Result<U>> getResult(); @Override void setAuditor(Auditor auditor); @Override String getName(); }### Answer:
@Test @SuppressWarnings("unchecked") public void auditableRulesSetRuleNames() { Rule<String, String> rule = Mockito.mock(Rule.class); Auditable auditable = new AuditableRule<String, String>(rule, "My Special Rule"); Assert.assertEquals("My Special Rule", auditable.getName()); }
@Test @SuppressWarnings("unchecked") public void auditableRulesGetClassNameAsDefaultName() { Rule<String, String> rule = Mockito.mock(Rule.class); Auditable auditable = new AuditableRule<String, String>(rule); Assert.assertEquals("AuditableRule", auditable.getName()); }
|
### Question:
AuditableRule implements Rule<T, U>, Auditable { @Override public void setAuditor(Auditor auditor) { _auditor = auditor; _auditor.registerRule(this); } AuditableRule(Rule<T, U> rule); AuditableRule(Rule<T, U> rule, String name); @Override void addFacts(NameValueReferable... facts); @Override void addFacts(NameValueReferableMap facts); @Override void setFacts(NameValueReferableMap facts); @Override void setCondition(Predicate<NameValueReferableTypeConvertibleMap<T>> condition); @Override void setRuleState(RuleState ruleState); @Override void addAction(Consumer<NameValueReferableTypeConvertibleMap<T>> action); @Override void addAction(BiConsumer<NameValueReferableTypeConvertibleMap<T>, Result<U>> action); @Override void addFactNameFilter(String... factNames); @Override NameValueReferableMap getFacts(); @Override Predicate<NameValueReferableTypeConvertibleMap<T>> getCondition(); @Override RuleState getRuleState(); @Override List<Object> getActions(); @Override boolean invoke(NameValueReferableMap facts); @Override void setResult(Result<U> result); @Override Optional<Result<U>> getResult(); @Override void setAuditor(Auditor auditor); @Override String getName(); }### Answer:
@Test @SuppressWarnings("unchecked") public void auditableRulesRegisterThemselvesWithAuditors() { Rule<String, String> rule = Mockito.mock(Rule.class); Auditable auditable = new AuditableRule<String, String>(rule); Auditor auditor = Mockito.mock(Auditor.class); auditable.setAuditor(auditor); Mockito.verify(auditor, Mockito.times(1)).registerRule(auditable); }
|
### Question:
AuditableRule implements Rule<T, U>, Auditable { @Override public void addFactNameFilter(String... factNames) { _rule.addFactNameFilter(factNames); } AuditableRule(Rule<T, U> rule); AuditableRule(Rule<T, U> rule, String name); @Override void addFacts(NameValueReferable... facts); @Override void addFacts(NameValueReferableMap facts); @Override void setFacts(NameValueReferableMap facts); @Override void setCondition(Predicate<NameValueReferableTypeConvertibleMap<T>> condition); @Override void setRuleState(RuleState ruleState); @Override void addAction(Consumer<NameValueReferableTypeConvertibleMap<T>> action); @Override void addAction(BiConsumer<NameValueReferableTypeConvertibleMap<T>, Result<U>> action); @Override void addFactNameFilter(String... factNames); @Override NameValueReferableMap getFacts(); @Override Predicate<NameValueReferableTypeConvertibleMap<T>> getCondition(); @Override RuleState getRuleState(); @Override List<Object> getActions(); @Override boolean invoke(NameValueReferableMap facts); @Override void setResult(Result<U> result); @Override Optional<Result<U>> getResult(); @Override void setAuditor(Auditor auditor); @Override String getName(); }### Answer:
@Test @SuppressWarnings("unchecked") public void auditableRulesDelegateFactNameFiltersTheirRule() { Rule<String, String> rule = Mockito.mock(Rule.class); AuditableRule auditableRule = new AuditableRule<String, String>(rule); String[] filters = {"filter"}; auditableRule.addFactNameFilter(filters); Mockito.verify(rule, Mockito.times(1)).addFactNameFilter(filters); }
|
### Question:
TypeConvertibleFactMap implements NameValueReferableTypeConvertibleMap<T> { @Override public String toString() { return _map.toString(); } TypeConvertibleFactMap(NameValueReferableMap<T> map); @Override String getStrVal(String name); @Override T getOne(); @Override T getValue(String name); @Override Integer getIntVal(String name); @Override Double getDblVal(String name); @Override Boolean getBoolVal(String name); @Override BigDecimal getBigDeciVal(String name); @Override void setValue(String name, T obj); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override NameValueReferable<T> get(Object key); @Override NameValueReferable<T> put(NameValueReferable<T> ref); @Override NameValueReferable<T> put(String key, NameValueReferable<T> value); @Override NameValueReferable<T> remove(Object key); @Override void putAll(Map<? extends String, ? extends NameValueReferable<T>> map); @Override void clear(); @Override Set<String> keySet(); @Override Collection<NameValueReferable<T>> values(); @Override Set<Entry<String, NameValueReferable<T>>> entrySet(); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void toStringDelegatesToDecoratedMap() { NameValueReferableMap factMap = mock(NameValueReferableMap.class); when(factMap.toString()).thenReturn("delegated!"); NameValueReferableMap facts = new TypeConvertibleFactMap(factMap); Assert.assertEquals("delegated!", facts.toString()); }
|
### Question:
TypeConvertibleFactMap implements NameValueReferableTypeConvertibleMap<T> { @Override public void putAll(Map<? extends String, ? extends NameValueReferable<T>> map) { _map.putAll(map); } TypeConvertibleFactMap(NameValueReferableMap<T> map); @Override String getStrVal(String name); @Override T getOne(); @Override T getValue(String name); @Override Integer getIntVal(String name); @Override Double getDblVal(String name); @Override Boolean getBoolVal(String name); @Override BigDecimal getBigDeciVal(String name); @Override void setValue(String name, T obj); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override NameValueReferable<T> get(Object key); @Override NameValueReferable<T> put(NameValueReferable<T> ref); @Override NameValueReferable<T> put(String key, NameValueReferable<T> value); @Override NameValueReferable<T> remove(Object key); @Override void putAll(Map<? extends String, ? extends NameValueReferable<T>> map); @Override void clear(); @Override Set<String> keySet(); @Override Collection<NameValueReferable<T>> values(); @Override Set<Entry<String, NameValueReferable<T>>> entrySet(); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void putAllDelegatesToDecoratedMap() { NameValueReferableMap factMap = mock(NameValueReferableMap.class); FactMap map = new FactMap(); NameValueReferableMap facts = new TypeConvertibleFactMap(factMap); facts.putAll(map); verify(factMap, times(1)).putAll(map); }
|
### Question:
StandardDecision implements Decision<T, U> { public static <T, U> StandardDecision<T, U> create(Class<T> factType, Class<U> resultType) { return new StandardDecision<T, U>(factType, resultType); } StandardDecision(Class<T> factClazz, Class<U> resultClazz); static StandardDecision<T, U> create(Class<T> factType, Class<U> resultType); static StandardDecision<Object, Object> create(); @Override @SuppressWarnings("unchecked") void run(Object... args); @Override Decision<T, U> given(String name, T value); @Override Decision<T, U> given(Fact<T>... facts); @Override Decision<T, U> given(List<Fact<T>> facts); @Override Decision<T, U> given(FactMap<T> facts); @Override Decision<T, U> givenUnTyped(FactMap facts); @Override FactMap getFactMap(); @Override Decision<T, U> when(Predicate<FactMap<T>> test); @Override Decision<T, U> then(BiConsumer<FactMap<T>, Result<U>> action); @Override Decision<T, U> then(Consumer<FactMap<T>> action); @Override Decision<T, U> stop(); @Override @SuppressWarnings("unchecked") Decision<T, U> using(String... factNames); @Override void setNextRule(Rule<T> rule); @Override U getResult(); @Override void setResult(Result<U> result); @Override Predicate<FactMap<T>> getWhen(); @Override List<Object> getThen(); }### Answer:
@Test @SuppressWarnings("checked") public void standardDecisionIsCreated() { Decision<String, Boolean> decision2 = StandardDecision.create(String.class, Boolean.class); Decision decision3 = StandardDecision.create(); Assert.assertNotNull(decision2); Assert.assertNotNull(decision3); }
|
### Question:
RuleAdapter implements Decision { @Override @SuppressWarnings("unchecked") public Decision given(Fact... facts) { _rule.given(facts); mapGivenFactsToProperties(); return this; } @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo); @Override @SuppressWarnings("unchecked") Decision given(Fact... facts); @Override @SuppressWarnings("unchecked") Decision given(List list); @Override @SuppressWarnings("unchecked") Decision given(FactMap facts); @Override @SuppressWarnings("unchecked") Decision given(String name, Object value); @Override Decision givenUnTyped(FactMap facts); @Override Predicate getWhen(); @Override List<Object> getThen(); @Override void run(Object... otherArgs); @Override Decision when(Predicate test); @Override Decision then(Consumer action); @Override Decision then(BiConsumer action); @Override Decision using(String... factName); @Override Decision stop(); @Override Object getResult(); @Override void setResult(Result result); @Override FactMap getFactMap(); @Override void setNextRule(Rule rule); }### Answer:
@Test public void givenAttributesShouldMapToFacts() throws InvalidClassException { SampleRuleWithResult sampleRuleWithResult = new SampleRuleWithResult(); RuleAdapter ruleAdapter = new RuleAdapter(sampleRuleWithResult); ruleAdapter.given(_factMap); Assert.assertEquals("FirstFact", sampleRuleWithResult.getFact1()); Assert.assertEquals("SecondFact", sampleRuleWithResult.getFact2()); Assert.assertEquals(1, sampleRuleWithResult.getValue1()); }
|
### Question:
RuleAdapter implements Decision { @Override public Predicate getWhen() { if (_rule.getWhen() != null) { return _rule.getWhen(); } return Arrays.stream(_rulePojo.getClass().getMethods()) .filter(method -> method.getReturnType() == boolean.class || method.getReturnType() == Boolean.class) .filter(method -> Arrays.stream(method.getDeclaredAnnotations()).anyMatch(When.class::isInstance)) .findFirst() .<Predicate>map(method -> object -> { try { return (Boolean) method.invoke(_rulePojo); } catch (InvocationTargetException | IllegalAccessException ex) { LOGGER.error( "Unable to validate condition due to an exception. Condition will be interpreted as false", ex); return false; } }) .orElse(o -> false); } @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo); @Override @SuppressWarnings("unchecked") Decision given(Fact... facts); @Override @SuppressWarnings("unchecked") Decision given(List list); @Override @SuppressWarnings("unchecked") Decision given(FactMap facts); @Override @SuppressWarnings("unchecked") Decision given(String name, Object value); @Override Decision givenUnTyped(FactMap facts); @Override Predicate getWhen(); @Override List<Object> getThen(); @Override void run(Object... otherArgs); @Override Decision when(Predicate test); @Override Decision then(Consumer action); @Override Decision then(BiConsumer action); @Override Decision using(String... factName); @Override Decision stop(); @Override Object getResult(); @Override void setResult(Result result); @Override FactMap getFactMap(); @Override void setNextRule(Rule rule); }### Answer:
@Test public void pojoWithNoWhenAnnotationDefaultsToFalse() throws InvalidClassException { SampleRuleWithoutAnnotations sampleRule = new SampleRuleWithoutAnnotations(); RuleAdapter ruleAdapter = new RuleAdapter(sampleRule); Predicate predicate = ruleAdapter.getWhen(); Assert.assertFalse(predicate.test(null)); }
|
### Question:
RuleAdapter implements Decision { @Override public List<Object> getThen() { if ((_rule.getThen()).size() < 1) { List<Object> thenList = new ArrayList<>(); for (Method thenMethod : getAnnotatedMethods(Then.class, _rulePojo.getClass())) { thenMethod.setAccessible(true); Object then = getThenMethodAsBiConsumer(thenMethod).map(Object.class::cast) .orElse(getThenMethodAsConsumer(thenMethod).orElse(factMap -> { })); thenList.add(then); } (_rule.getThen()).addAll(thenList); } return _rule.getThen(); } @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo); @Override @SuppressWarnings("unchecked") Decision given(Fact... facts); @Override @SuppressWarnings("unchecked") Decision given(List list); @Override @SuppressWarnings("unchecked") Decision given(FactMap facts); @Override @SuppressWarnings("unchecked") Decision given(String name, Object value); @Override Decision givenUnTyped(FactMap facts); @Override Predicate getWhen(); @Override List<Object> getThen(); @Override void run(Object... otherArgs); @Override Decision when(Predicate test); @Override Decision then(Consumer action); @Override Decision then(BiConsumer action); @Override Decision using(String... factName); @Override Decision stop(); @Override Object getResult(); @Override void setResult(Result result); @Override FactMap getFactMap(); @Override void setNextRule(Rule rule); }### Answer:
@Test public void pojoWithNoThenAnnotationDefaultsToNext() throws InvalidClassException { SampleRuleWithoutAnnotations sampleRule = new SampleRuleWithoutAnnotations(); RuleAdapter ruleAdapter = new RuleAdapter(sampleRule); Assert.assertEquals(0, ((List<Object>)ruleAdapter.getThen()).size()); }
|
### Question:
RuleAdapter implements Decision { @Override public Decision stop() { _rule.stop(); return this; } @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo); @Override @SuppressWarnings("unchecked") Decision given(Fact... facts); @Override @SuppressWarnings("unchecked") Decision given(List list); @Override @SuppressWarnings("unchecked") Decision given(FactMap facts); @Override @SuppressWarnings("unchecked") Decision given(String name, Object value); @Override Decision givenUnTyped(FactMap facts); @Override Predicate getWhen(); @Override List<Object> getThen(); @Override void run(Object... otherArgs); @Override Decision when(Predicate test); @Override Decision then(Consumer action); @Override Decision then(BiConsumer action); @Override Decision using(String... factName); @Override Decision stop(); @Override Object getResult(); @Override void setResult(Result result); @Override FactMap getFactMap(); @Override void setNextRule(Rule rule); }### Answer:
@Test public void stopMethodShouldDelegateToRuleStopMethod() throws InvalidClassException { Rule rule = mock(Rule.class); RuleAdapter ruleAdapter = new RuleAdapter(new SampleRuleWithResult(), rule); Decision retVal = ruleAdapter.stop(); Assert.assertEquals(retVal, ruleAdapter); verify(rule, times(1)).stop(); }
|
### Question:
RuleAdapter implements Decision { @Override public Decision using(String... factName) { throw new UnsupportedOperationException(); } @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo); @Override @SuppressWarnings("unchecked") Decision given(Fact... facts); @Override @SuppressWarnings("unchecked") Decision given(List list); @Override @SuppressWarnings("unchecked") Decision given(FactMap facts); @Override @SuppressWarnings("unchecked") Decision given(String name, Object value); @Override Decision givenUnTyped(FactMap facts); @Override Predicate getWhen(); @Override List<Object> getThen(); @Override void run(Object... otherArgs); @Override Decision when(Predicate test); @Override Decision then(Consumer action); @Override Decision then(BiConsumer action); @Override Decision using(String... factName); @Override Decision stop(); @Override Object getResult(); @Override void setResult(Result result); @Override FactMap getFactMap(); @Override void setNextRule(Rule rule); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void usingMethodShouldThrowNotImplemented() throws InvalidClassException { RuleAdapter ruleAdapter = new RuleAdapter(new SampleRuleWithResult()); ruleAdapter.using(); }
|
### Question:
RuleAdapter implements Decision { @Override public Decision givenUnTyped(FactMap facts) { _rule.givenUnTyped(facts); mapGivenFactsToProperties(); return this; } @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo, Rule rule); @SuppressWarnings("unchecked") RuleAdapter(Object rulePojo); @Override @SuppressWarnings("unchecked") Decision given(Fact... facts); @Override @SuppressWarnings("unchecked") Decision given(List list); @Override @SuppressWarnings("unchecked") Decision given(FactMap facts); @Override @SuppressWarnings("unchecked") Decision given(String name, Object value); @Override Decision givenUnTyped(FactMap facts); @Override Predicate getWhen(); @Override List<Object> getThen(); @Override void run(Object... otherArgs); @Override Decision when(Predicate test); @Override Decision then(Consumer action); @Override Decision then(BiConsumer action); @Override Decision using(String... factName); @Override Decision stop(); @Override Object getResult(); @Override void setResult(Result result); @Override FactMap getFactMap(); @Override void setNextRule(Rule rule); }### Answer:
@Test public void givenUnTypedMethodShouldDelegateToRuleGivenUnTypedMethod() throws InvalidClassException { Rule rule = mock(Rule.class); RuleAdapter ruleAdapter = new RuleAdapter(new SampleRuleWithResult(), rule); Decision retVal = ruleAdapter.givenUnTyped(new FactMap()); Assert.assertEquals(retVal, ruleAdapter); verify(rule, times(1)).givenUnTyped(any(FactMap.class)); }
|
### Question:
Fact implements NameValueReferable<T> { @Override public int hashCode() { return (_name.hashCode() + _value.hashCode()) % Integer.MAX_VALUE; } Fact(String name, T value); Fact(T obj); Fact(NameValueReferable<T> fact); @Override String getName(); @Override void setName(String name); @Override T getValue(); @Override void setValue(T value); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void equivalentFactsShouldHaveTheSametHashCode() { Fact<String> fact1 = new Fact<String>("fact1", "Fact One"); Fact<String> fact2 = new Fact<String>("fact1", "Fact One"); Fact<Double> fact3 = new Fact<Double>("fact2", 1.25); Fact<Double> fact4 = new Fact<Double>("fact2", 1.25); Assert.assertEquals(fact3, fact4); Assert.assertEquals(fact1, fact2); Assert.assertEquals(fact1.hashCode(), fact2.hashCode()); Assert.assertEquals(fact3.hashCode(), fact4.hashCode()); Assert.assertNotEquals(fact1, fact3); }
|
### Question:
StandardRule implements Rule<T> { public static <T> StandardRule<T> create(Class<T> factType) { return new StandardRule<>(factType); } protected StandardRule(); StandardRule(Class<T> clazz); static StandardRule<T> create(Class<T> factType); static StandardRule<Object> create(); @Override @SuppressWarnings("unchecked") void run(Object... otherArgs); @Override @SuppressWarnings("unchecked") Rule<T> given(String name, T value); @Override @SuppressWarnings("unchecked") Rule<T> given(Fact<T>... facts); @SuppressWarnings("unchecked") @Override Rule<T> given(List<Fact<T>> facts); @Override Rule<T> given(FactMap<T> facts); @Override Rule<T> givenUnTyped(FactMap facts); @Override FactMap getFactMap(); @Override Rule<T> when(Predicate<FactMap<T>> test); @Override @SuppressWarnings("unchecked") Rule<T> then(Consumer<FactMap<T>> action); @Override Rule<T> stop(); @Override @SuppressWarnings("unchecked") StandardRule<T> using(String... factNames); @Override void setNextRule(Rule<T> rule); @Override Predicate<FactMap<T>> getWhen(); @Override List<Object> getThen(); }### Answer:
@Test public void standardRuleIsCreated() { Rule<String> rule1 = new StandardRule<>(String.class); Rule<String> rule2 = StandardRule.create(String.class); Rule rule3 = StandardRule.create(); Assert.assertNotNull(rule1); Assert.assertNotNull(rule2); Assert.assertNotNull(rule3); }
|
### Question:
SpringRuleBook implements RuleBook<T> { @Override public void addRule(Rule rule) { _ruleBook.addRule(rule); } SpringRuleBook(RuleBook<T> ruleBook); @Override void addRule(Rule rule); void addRule(Object rule); @Override void run(NameValueReferableMap facts); @Override void setDefaultResult(T result); @Override Optional<Result<T>> getResult(); @Override boolean hasRules(); }### Answer:
@Test public void addingRulesToSpringRuleBookShouldAddTheRuleToTheDelegate() throws InvalidClassException { RuleBook<String> mockRuleBook = (RuleBook<String>)mock(CoRRuleBook.class); SpringRuleBook<String> ruleBook = new SpringRuleBook<>(mockRuleBook); Rule rule = RuleBuilder.create().build(); ruleBook.addRule(rule); Mockito.verify(mockRuleBook, times(1)).addRule(rule); }
|
### Question:
SpringRuleBook implements RuleBook<T> { @Override public boolean hasRules() { return _ruleBook.hasRules(); } SpringRuleBook(RuleBook<T> ruleBook); @Override void addRule(Rule rule); void addRule(Object rule); @Override void run(NameValueReferableMap facts); @Override void setDefaultResult(T result); @Override Optional<Result<T>> getResult(); @Override boolean hasRules(); }### Answer:
@Test public void springRuleBooksWithNoRulesShouldReturnFalseForHasRules() { SpringRuleBook<String> ruleBook = new SpringRuleBook<>(_ruleBook); Assert.assertFalse(ruleBook.hasRules()); }
|
### Question:
RuleBookBean extends DecisionBook { @SuppressWarnings("unchecked") public void addRule(Object rule) throws InvalidClassException { super.addRule(new RuleAdapter(rule)); } @SuppressWarnings("unchecked") void addRule(Object rule); }### Answer:
@Test(expected = InvalidClassException.class) public void ruleBookBeanShouldHandlePojosInRuleAdapterWithNoAnnotation() throws InvalidClassException { RuleBookBean ruleBookBean = new RuleBookBean(); ruleBookBean.addRule(new Object()); }
|
### Question:
SpringAwareRuleBookRunner extends RuleBookRunner implements ApplicationContextAware { @Override protected Object getRuleInstance(Class<?> rule) { if (_applicationContext == null) { throw new IllegalStateException("Cannot instantiate RuleBookRunner because " + "Spring application context is not available."); } try { return _applicationContext.getBean(rule); } catch (BeansException e) { return super.getRuleInstance(rule); } } SpringAwareRuleBookRunner(String rulePackage); SpringAwareRuleBookRunner(Class<? extends RuleBook> ruleBookClass, String rulePackage); SpringAwareRuleBookRunner(String rulePackage, Predicate<String> subPkgMatch); SpringAwareRuleBookRunner(
Class<? extends RuleBook> ruleBookClass, String rulePackage, Predicate<String> subPkgMatch); @Override void setApplicationContext(ApplicationContext applicationContext); }### Answer:
@Test public void ruleRunnerShouldReturnNullRuleClassIsInvalid() { Class clazz = Class.class; Assert.assertNull(_ruleBook.getRuleInstance(clazz)); }
|
### Question:
FactMap implements NameValueReferableMap<T> { @Override public void clear() { _facts.clear(); } FactMap(Map<String, NameValueReferable<T>> facts); @SafeVarargs FactMap(NameValueReferable<T>... facts); FactMap(); @Override T getOne(); @Override T getValue(String name); @Deprecated String getStrVal(String name); @Deprecated Integer getIntVal(String name); @Deprecated Double getDblVal(String name); void setValue(String name, T value); @Override Fact<T> put(NameValueReferable<T> fact); @Override Fact<T> put(String key, NameValueReferable<T> fact); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override Fact<T> get(Object key); @Override Fact<T> remove(Object key); @Override void putAll(Map<? extends String, ? extends NameValueReferable<T>> map); @Override void clear(); @Override Set<String> keySet(); @Override Collection<NameValueReferable<T>> values(); @Override Set<Entry<String, NameValueReferable<T>>> entrySet(); @Override String toString(); }### Answer:
@Test public void clearShouldDelegateToMap() { Map<String, Object> map = Mockito.mock(Map.class); FactMap factMap = new FactMap(map); factMap.clear(); Mockito.verify(map, Mockito.times(1)).clear(); }
|
### Question:
Result implements Referable<T> { public void reset() { _lock.readLock().lock(); try { if (_defaultValue == null) { return; } } finally { _lock.readLock().unlock(); } setValue(_defaultValue); } Result(); Result(T value); void reset(); @Override T getValue(); @Override void setValue(T value); @Override String toString(); }### Answer:
@Test public void resetWithNoDefaultValueSetDoesNotError() { Result<String> result = new Result<>(); result.reset(); }
|
### Question:
Result implements Referable<T> { @Override public String toString() { _lock.readLock().lock(); try { long key = Thread.currentThread().getId(); if (_valueMap.containsKey(key)) { return _valueMap.get(key).toString(); } if (_defaultValue != null) { return _defaultValue.toString(); } return ""; } finally { _lock.readLock().unlock(); } } Result(); Result(T value); void reset(); @Override T getValue(); @Override void setValue(T value); @Override String toString(); }### Answer:
@Test public void toStringWithNoValueReturnsToStringOnDefaultValue() { Result<String> result = new Result<>("Default"); Assert.assertEquals("Default", result.toString()); }
@Test public void toStringWithNoValueOrDefaultReturnsBlankString() { Result<String> result = new Result<>(); Assert.assertEquals("", result.toString()); }
|
### Question:
AnnotationUtils { @SuppressWarnings("unchecked") public static List<Field> getAnnotatedFields(Class annotation, Class clazz) { if (clazz == Object.class) { return new ArrayList<>(); } List<Field> fields = (List<Field>)Arrays.stream(clazz.getDeclaredFields()) .filter(field -> field.getAnnotation(annotation) != null) .collect(Collectors.toList()); if (clazz.getSuperclass() != null) { fields.addAll(getAnnotatedFields(annotation, clazz.getSuperclass())); } return fields; } private AnnotationUtils(); @SuppressWarnings("unchecked") static List<Field> getAnnotatedFields(Class annotation, Class clazz); static Optional<Field> getAnnotatedField(Class annotation, Class clazz); @SuppressWarnings("unchecked") static List<Method> getAnnotatedMethods(Class annotation, Class clazz); static Optional<Method> getAnnotatedMethod(Class annotation, Class clazz); @SuppressWarnings("unchecked") static A getAnnotation(Class<A> annotation, Class<?> clazz); }### Answer:
@Test public void getAnnotatedFieldsShouldFindAnnotatedFields() { List<Field> givenFields = getAnnotatedFields(Given.class, SampleRuleWithResult.class); List<Field> resultFields = getAnnotatedFields(Result.class, SampleRuleWithResult.class); Assert.assertEquals(11, givenFields.size()); Assert.assertEquals(1, resultFields.size()); }
@Test public void getAnnotatedFieldsShouldFindAnnotatedFieldsInParentClasses() { List<Field> givenFields = getAnnotatedFields(Given.class, SubRuleWithResult.class); List<Field> resultFields = getAnnotatedFields(Result.class, SubRuleWithResult.class); Assert.assertEquals(12, givenFields.size()); Assert.assertEquals(1, resultFields.size()); }
|
### Question:
SessionAdapter implements TokenAdapter<InternalSession> { public int findIndexOfValidField(String blob) { for (Field field : AttributeCompressionStrategy.getAllValidFields(InternalSession.class)) { String search = JSONSerialisation.jsonAttributeName(field.getName()); int index = blob.indexOf(search); if (index != -1) { return index; } } return -1; } @Inject SessionAdapter(TokenIdFactory tokenIdFactory, CoreTokenConfig config,
JSONSerialisation serialisation, LDAPDataConversion dataConversion,
TokenBlobUtils blobUtils); Token toToken(InternalSession session); InternalSession fromToken(Token token); int findIndexOfValidField(String blob); String filterLatestAccessTime(Token token); }### Answer:
@Test public void shouldLocateValidFieldInJSON() { String json = "{\"clientDomain\":null,\"creationTime\":1376307674,\"isISStored\":true,\"latestAccessTime\":1376308558,\"maxCachingTime\":3}"; assertEquals(1, adapter.findIndexOfValidField(json)); }
@Test public void shouldIndicateNoValidFieldsInJSON() { assertEquals(-1, adapter.findIndexOfValidField("")); }
|
### Question:
SAMLAdapter implements TokenAdapter<SAMLToken> { public Token toToken(SAMLToken samlToken) { String tokenId = tokenIdFactory.toSAMLPrimaryTokenId(samlToken.getPrimaryKey()); Token token = new Token(tokenId, TokenType.SAML2); Calendar timestamp = dataConversion.fromEpochedSeconds(samlToken.getExpiryTime()); token.setExpiryTimestamp(timestamp); String className = samlToken.getToken().getClass().getName(); token.setAttribute(SAMLTokenField.OBJECT_CLASS.getField(), className); String secondaryKey = samlToken.getSecondaryKey(); if (secondaryKey != null) { secondaryKey = tokenIdFactory.toSAMLSecondaryTokenId(secondaryKey); token.setAttribute(SAMLTokenField.SECONDARY_KEY.getField(), secondaryKey); } String jsonBlob = serialisation.serialise(samlToken.getToken()); blobUtils.setBlobFromString(token, jsonBlob); return token; } @Inject SAMLAdapter(TokenIdFactory tokenIdFactory, JSONSerialisation serialisation,
LDAPDataConversion dataConversion, TokenBlobUtils blobUtils); Token toToken(SAMLToken samlToken); SAMLToken fromToken(Token token); }### Answer:
@Test public void shouldNotStoreSecondaryKeyIfNull() { SAMLToken samlToken = new SAMLToken("primary", null, 12345, ""); given(tokenIdFactory.toSAMLPrimaryTokenId(anyString())).willReturn("id"); given(serialisation.serialise(anyObject())).willReturn(""); Token token = adapter.toToken(samlToken); assertThat(token.getValue(SAMLTokenField.SECONDARY_KEY.getField())).isNull(); }
|
### Question:
TokenIdFactory { public String toSessionTokenId(InternalSession session) { return toSessionTokenId(session.getID()); } @Inject TokenIdFactory(KeyConversion encoding); String toSAMLPrimaryTokenId(String requestId); String fromSAMLPrimaryTokenId(String primaryId); String toSAMLSecondaryTokenId(String secondaryKey); String fromSAMLSecondaryTokenId(String secondaryId); String toSessionTokenId(InternalSession session); String toSessionTokenId(SessionID sessionID); String getOAuthTokenId(String id); static final String ID; }### Answer:
@Test public void shouldUseKeyConversionForSessionTokens() { SessionID session = new SessionID("badger"); factory.toSessionTokenId(session); verify(conversion).encryptKey(session); }
|
### Question:
TokenIdFactory { public String getOAuthTokenId(String id) { if (id == null){ id = UUID.randomUUID().toString(); } return id; } @Inject TokenIdFactory(KeyConversion encoding); String toSAMLPrimaryTokenId(String requestId); String fromSAMLPrimaryTokenId(String primaryId); String toSAMLSecondaryTokenId(String secondaryKey); String fromSAMLSecondaryTokenId(String secondaryId); String toSessionTokenId(InternalSession session); String toSessionTokenId(SessionID sessionID); String getOAuthTokenId(String id); static final String ID; }### Answer:
@Test public void shouldGetOAuthTokenIdWhenSet() { String key = "badger"; String result = factory.getOAuthTokenId(key); assertEquals(result, key); }
@Test public void shouldGenerateRandomIdWhenOAuthTokenIdNotSet() { String result = factory.getOAuthTokenId(null); assertNotNull(result); }
|
### Question:
JSONSerialisation { public <T> String serialise(T object) { try { String value = mapper.writeValueAsString(object); return value; } catch (IOException e) { throw new IllegalStateException( MessageFormat.format( "Failed to serialise {0}:{1}", object.getClass().getSimpleName(), object), e); } } JSONSerialisation(); String serialise(T object); T deserialise(String text, Class<T> clazz); static String jsonAttributeName(String name); }### Answer:
@Test public void basicSessionSerializationWorks() throws Exception { InternalSession is = new InternalSession(); String serialised = SERIALISATION.serialise(is); assertThat(serialised).isNotNull().isEqualTo(getJSON("/json/basic-session.json")); assertThat(is).isNotNull(); }
|
### Question:
JSONSerialisation { public static String jsonAttributeName(String name) { return "\"" + name + "\":"; } JSONSerialisation(); String serialise(T object); T deserialise(String text, Class<T> clazz); static String jsonAttributeName(String name); }### Answer:
@Test public void shouldChangeAttributeName() { String name = "badger"; assertNotEquals(name, JSONSerialisation.jsonAttributeName(name)); }
|
### Question:
TokenAttributeConversion { public DN generateTokenDN(Token token) { return generateTokenDN(token.getTokenId()); } @Inject TokenAttributeConversion(LDAPConfig constants, LDAPDataConversion conversion); Entry getEntry(Token token); Map<CoreTokenField, Object> mapFromEntry(Entry entry); Token tokenFromEntry(Entry entry); static Entry addObjectClass(Entry entry); static Entry stripObjectClass(Entry entry); DN generateTokenDN(Token token); DN generateTokenDN(String tokenId); }### Answer:
@Test public void shouldProduceDNWithTokenId() { String tokenId = "badger"; LDAPConfig constants = mock(LDAPConfig.class); given(constants.getTokenStoreRootSuffix()).willReturn(DN.rootDN()); LDAPDataConversion dataConversion = new LDAPDataConversion(); TokenAttributeConversion conversion = new TokenAttributeConversion(constants, dataConversion); DN dn = conversion.generateTokenDN(tokenId); verify(constants).getTokenStoreRootSuffix(); assertTrue(dn.toString().contains(tokenId)); }
@Test public void shouldAllowPlusSignInDN() { TokenAttributeConversion conversion = generateTokenAttributeConversion(); conversion.generateTokenDN("Badger+"); }
|
### Question:
TokenAttributeConversion { public static Entry stripObjectClass(Entry entry) { Attribute attribute = entry.getAttribute(CoreTokenConstants.OBJECT_CLASS); if (attribute != null) { AttributeDescription description = attribute.getAttributeDescription(); entry.removeAttribute(description); } return entry; } @Inject TokenAttributeConversion(LDAPConfig constants, LDAPDataConversion conversion); Entry getEntry(Token token); Map<CoreTokenField, Object> mapFromEntry(Entry entry); Token tokenFromEntry(Entry entry); static Entry addObjectClass(Entry entry); static Entry stripObjectClass(Entry entry); DN generateTokenDN(Token token); DN generateTokenDN(String tokenId); }### Answer:
@Test public void shouldNotStripObjectClassIfNotPresent() { Entry entry = mock(Entry.class); given(entry.getAttribute(anyString())).willReturn(null); TokenAttributeConversion.stripObjectClass(entry); verify(entry, times(0)).removeAttribute(anyString(), any()); }
@Test public void shouldStripObjectClass() { Entry entry = mock(Entry.class); Attribute attribute = mock(Attribute.class); given(entry.getAttribute(anyString())).willReturn(attribute); AttributeDescription description = AttributeDescription.valueOf("badger"); given(attribute.getAttributeDescription()).willReturn(description); TokenAttributeConversion.stripObjectClass(entry); verify(entry).removeAttribute(description); }
|
### Question:
TokenAttributeConversion { public static Entry addObjectClass(Entry entry) { Attribute attribute = entry.getAttribute(CoreTokenConstants.OBJECT_CLASS); if (attribute == null) { entry.addAttribute(CoreTokenConstants.OBJECT_CLASS, CoreTokenConstants.FR_CORE_TOKEN); } return entry; } @Inject TokenAttributeConversion(LDAPConfig constants, LDAPDataConversion conversion); Entry getEntry(Token token); Map<CoreTokenField, Object> mapFromEntry(Entry entry); Token tokenFromEntry(Entry entry); static Entry addObjectClass(Entry entry); static Entry stripObjectClass(Entry entry); DN generateTokenDN(Token token); DN generateTokenDN(String tokenId); }### Answer:
@Test public void shouldNotAddObjectClassIfPresent() { Entry entry = mock(Entry.class); Attribute attribute = mock(Attribute.class); given(entry.getAttribute(anyString())).willReturn(attribute); TokenAttributeConversion.addObjectClass(entry); verify(entry, times(0)).addAttribute(anyString(), any()); }
@Test public void shouldAddObjectClass() { Entry entry = mock(Entry.class); given(entry.getAttribute(anyString())).willReturn(null); TokenAttributeConversion.addObjectClass(entry); verify(entry).addAttribute(anyString(), any()); }
|
### Question:
TokenAttributeConversion { public Entry getEntry(Token token) { Entry entry = new LinkedHashMapEntry(generateTokenDN(token)); addObjectClass(entry); for (CoreTokenField field : token.getAttributeNames()) { String key = field.toString(); if (CoreTokenField.TOKEN_TYPE.equals(field)) { TokenType type = token.getValue(field); entry.addAttribute(key, type.name()); continue; } if (CoreTokenFieldTypes.isCalendar(field)) { Calendar calendar = token.getValue(field); String dateString = conversion.toLDAPDate(calendar); entry.addAttribute(key, dateString); } else if (CoreTokenFieldTypes.isByteArray(field)) { byte[] array = token.getValue(field); entry.addAttribute(key, ByteString.valueOf(array)); } else if (CoreTokenFieldTypes.isInteger(field)) { Integer value = token.getValue(field); entry.addAttribute(key, ByteString.valueOf(value)); } else if (CoreTokenFieldTypes.isString(field)) { String value = token.getValue(field); if (value.isEmpty()) { value = EMPTY; } entry.addAttribute(key, ByteString.valueOf(value)); } else { throw new IllegalStateException(); } } return entry; } @Inject TokenAttributeConversion(LDAPConfig constants, LDAPDataConversion conversion); Entry getEntry(Token token); Map<CoreTokenField, Object> mapFromEntry(Entry entry); Token tokenFromEntry(Entry entry); static Entry addObjectClass(Entry entry); static Entry stripObjectClass(Entry entry); DN generateTokenDN(Token token); DN generateTokenDN(String tokenId); }### Answer:
@Test public void shouldHandleEmptyStrings() { Token token = new Token("id", TokenType.OAUTH); token.setAttribute(CoreTokenField.STRING_ONE, ""); TokenAttributeConversion conversion = generateTokenAttributeConversion(); Entry result = conversion.getEntry(token); Attribute attribute = result.getAttribute(CoreTokenField.STRING_ONE.toString()); String string = attribute.firstValue().toString(); assertFalse(string.isEmpty()); }
|
### Question:
TokenAttributeConversion { public Token tokenFromEntry(Entry entry) { Map<CoreTokenField, Object> map = mapFromEntry(entry); String tokenId = (String) map.get(CoreTokenField.TOKEN_ID); TokenType type = (TokenType) map.get(CoreTokenField.TOKEN_TYPE); Token token = new Token(tokenId, type); for (Map.Entry<CoreTokenField, Object> e : map.entrySet()) { CoreTokenField key = e.getKey(); Object value = e.getValue(); if (Token.isFieldReadOnly(key)) { continue; } token.setAttribute(key, value); } return token; } @Inject TokenAttributeConversion(LDAPConfig constants, LDAPDataConversion conversion); Entry getEntry(Token token); Map<CoreTokenField, Object> mapFromEntry(Entry entry); Token tokenFromEntry(Entry entry); static Entry addObjectClass(Entry entry); static Entry stripObjectClass(Entry entry); DN generateTokenDN(Token token); DN generateTokenDN(String tokenId); }### Answer:
@Test public void shouldUnderstandEmptyStrings() { Entry entry = new LinkedHashMapEntry(); entry.addAttribute(CoreTokenField.TOKEN_ID.toString(), "id"); entry.addAttribute(CoreTokenField.TOKEN_TYPE.toString(), TokenType.OAUTH.toString()); entry.addAttribute(CoreTokenField.STRING_ONE.toString(), TokenAttributeConversion.EMPTY); TokenAttributeConversion conversion = generateTokenAttributeConversion(); Token result = conversion.tokenFromEntry(entry); String string = result.getValue(CoreTokenField.STRING_ONE); assertTrue(string.isEmpty()); }
|
### Question:
TokenBlobUtils { public void setBlobFromString(Token token, String blob) { try { token.setBlob(blob.getBytes(ENCODING)); } catch (UnsupportedEncodingException e) { throw new IllegalStateException("Failed to encode blob to " + ENCODING, e); } } String getBlobAsString(Token token); void setBlobFromString(Token token, String blob); static final String ENCODING; }### Answer:
@Test public void shouldUseTokenWhenStoringStringAsBlob() throws CoreTokenException { TokenBlobUtils utils = new TokenBlobUtils(); Token mockToken = mock(Token.class); utils.setBlobFromString(mockToken, "badger"); verify(mockToken).setBlob(any(byte[].class)); }
|
### Question:
TokenBlobUtils { public String getBlobAsString(Token token) { try { return new String(token.getBlob(), ENCODING); } catch (UnsupportedEncodingException e) { throw new IllegalStateException("Failed to decode blob to " + ENCODING, e); } } String getBlobAsString(Token token); void setBlobFromString(Token token, String blob); static final String ENCODING; }### Answer:
@Test public void shouldUseTokenForBlobAsString() throws CoreTokenException, UnsupportedEncodingException { TokenBlobUtils utils = new TokenBlobUtils(); Token mockToken = mock(Token.class); given(mockToken.getBlob()).willReturn("badger".getBytes(TokenBlobUtils.ENCODING)); utils.getBlobAsString(mockToken); verify(mockToken).getBlob(); }
|
### Question:
TokenBlobStrategy { public void perfom(Token token) throws TokenStrategyFailedException { for (BlobStrategy strategy : strategies) { strategy.perform(token); } } @Inject TokenBlobStrategy(TokenStrategyFactory factory, CoreTokenConfig config); void perfom(Token token); void reverse(Token token); }### Answer:
@Test public void shouldPerformAllStrategy() throws TokenStrategyFailedException { BlobStrategy first = mock(BlobStrategy.class); BlobStrategy second = mock(BlobStrategy.class); BlobStrategy third = mock(BlobStrategy.class); given(factory.getStrategies(any(CoreTokenConfig.class))) .willReturn(Arrays.asList(first, second, third)); Token mockToken = mock(Token.class); TokenBlobStrategy strategy = new TokenBlobStrategy(factory, config); strategy.perfom(mockToken); verify(first).perform(mockToken); verify(second).perform(mockToken); verify(third).perform(mockToken); }
@Test public void shouldDoNothingWithNoStrategy() throws TokenStrategyFailedException { Token mockToken = mock(Token.class); TokenBlobStrategy strategy = new TokenBlobStrategy(factory, config); strategy.perfom(mockToken); verify(mockToken, times(0)).getBlob(); }
|
### Question:
TokenBlobStrategy { public void reverse(Token token) throws TokenStrategyFailedException { for (BlobStrategy strategy : reverseStrategies) { strategy.reverse(token); } } @Inject TokenBlobStrategy(TokenStrategyFactory factory, CoreTokenConfig config); void perfom(Token token); void reverse(Token token); }### Answer:
@Test public void shouldReverseAllStrategy() throws TokenStrategyFailedException { BlobStrategy first = mock(BlobStrategy.class); BlobStrategy second = mock(BlobStrategy.class); BlobStrategy third = mock(BlobStrategy.class); given(factory.getStrategies(any(CoreTokenConfig.class))) .willReturn(Arrays.asList(first, second, third)); Token mockToken = mock(Token.class); TokenBlobStrategy strategy = new TokenBlobStrategy(factory, config); strategy.reverse(mockToken); verify(first).reverse(mockToken); verify(second).reverse(mockToken); verify(third).reverse(mockToken); }
|
### Question:
CompressionStrategy implements BlobStrategy { @Override public void perform(Token token) throws TokenStrategyFailedException { bout.reset(); try { GZIPOutputStream out = new GZIPOutputStream(bout); out.write(token.getBlob(), 0, token.getBlob().length); out.flush(); out.close(); } catch (IOException e) { throw new TokenStrategyFailedException(e); } token.setBlob(bout.toByteArray()); } @Override void perform(Token token); @Override void reverse(Token token); }### Answer:
@Test public void shouldUpdateToken() throws TokenStrategyFailedException { Token token = mock(Token.class); byte[] testData = JSON_SAMPLE.getBytes(); given(token.getBlob()).willReturn(testData); compression.perform(token); verify(token).setBlob(any(byte[].class)); }
@Test public void shouldCompressContents() throws TokenStrategyFailedException { Token token = mock(Token.class); byte[] testData = JSON_SAMPLE.getBytes(); given(token.getBlob()).willReturn(testData); compression.perform(token); ArgumentCaptor<byte[]> captor = ArgumentCaptor.forClass(byte[].class); verify(token).setBlob(captor.capture()); byte[] result = captor.getValue(); assertTrue(result.length < testData.length); }
|
### Question:
EncryptionStrategy implements BlobStrategy { public void perform(Token token) throws TokenStrategyFailedException { try { encyptionAction.setBlob(token.getBlob()); byte[] encryptedBlob = AccessController.doPrivileged(encyptionAction); token.setBlob(encryptedBlob); if (debug.messageEnabled()) { debug.message(CoreTokenConstants.DEBUG_HEADER + "Encrypted Token"); } } catch (PrivilegedActionException e) { throw new TokenStrategyFailedException("Failed to encrypt JSON Blob", e); } } @Inject EncryptionStrategy(EncryptAction encyptionAction, DecryptAction decyptAction,
@Named(CoreTokenConstants.CTS_DEBUG) Debug debug); void perform(Token token); void reverse(Token token); }### Answer:
@Test public void shouldCallEncryptOnPerform() throws Exception { byte[] bytes = {}; EncryptAction mockEncryptAction = mock(EncryptAction.class); EncryptionStrategy strategy = new EncryptionStrategy( mockEncryptAction, mock(DecryptAction.class), mock(Debug.class)); Token mockToken = mock(Token.class); given(mockToken.getBlob()).willReturn(bytes); strategy.perform(mockToken); verify(mockEncryptAction).setBlob(eq(bytes)); verify(mockEncryptAction).run(); }
@Test (expectedExceptions = TokenStrategyFailedException.class) public void shouldThrowExceptionIfEncryptionFails() throws Exception { EncryptAction mockEncryptAction = mock(EncryptAction.class); EncryptionStrategy strategy = new EncryptionStrategy( mockEncryptAction, mock(DecryptAction.class), mock(Debug.class)); given(mockEncryptAction.run()).willThrow(new Exception()); strategy.perform(mock(Token.class)); }
|
### Question:
EncryptionStrategy implements BlobStrategy { public void reverse(Token token) throws TokenStrategyFailedException { try { decyptAction.setBlob(token.getBlob()); byte[] decryptedBlob = AccessController.doPrivileged(decyptAction); token.setBlob(decryptedBlob); if (debug.messageEnabled()) { debug.message(CoreTokenConstants.DEBUG_HEADER + "Decrypted Token"); } } catch (PrivilegedActionException e) { throw new TokenStrategyFailedException("Failed to decrypt JSON Blob", e); } } @Inject EncryptionStrategy(EncryptAction encyptionAction, DecryptAction decyptAction,
@Named(CoreTokenConstants.CTS_DEBUG) Debug debug); void perform(Token token); void reverse(Token token); }### Answer:
@Test public void shouldCallDecryptOnReverse() throws Exception { byte[] bytes = {}; DecryptAction mockDecryptAction = mock(DecryptAction.class); EncryptionStrategy strategy = new EncryptionStrategy( mock(EncryptAction.class), mockDecryptAction, mock(Debug.class)); Token mockToken = mock(Token.class); given(mockToken.getBlob()).willReturn(bytes); strategy.reverse(mockToken); verify(mockDecryptAction).setBlob(eq(bytes)); verify(mockDecryptAction).run(); }
@Test (expectedExceptions = TokenStrategyFailedException.class) public void shouldThrowExceptionIfDecryptionFails() throws Exception { DecryptAction mockDecryptAction = mock(DecryptAction.class); EncryptionStrategy strategy = new EncryptionStrategy( mock(EncryptAction.class), mockDecryptAction, mock(Debug.class)); given(mockDecryptAction.run()).willThrow(new Exception()); strategy.reverse(mock(Token.class)); }
|
### Question:
AttributeCompressionStrategy implements BlobStrategy { public static Collection<Field> getAllValidFields(Class c) { List<Field> r = new ArrayList<Field>(); for (Field f : c.getDeclaredFields()) { int modifiers = f.getModifiers(); if (Modifier.isStatic(modifiers)) continue; if (Modifier.isVolatile(modifiers)) continue; if (Modifier.isTransient(modifiers)) continue; r.add(f); } return r; } @Inject AttributeCompressionStrategy(TokenBlobUtils blobUtils); void perform(Token token); void reverse(Token token); static String getInitials(String name); static Collection<Field> getAllValidFields(Class c); }### Answer:
@Test public void shouldNotSelectAStaticFieldFromClass() { assertEquals(0, AttributeCompressionStrategy.getAllValidFields(StaticFieldTest.class).size()); }
@Test public void shouldSelectPrivateFields() { assertEquals(1, AttributeCompressionStrategy.getAllValidFields(PrivateFieldTest.class).size()); }
|
### Question:
AttributeCompressionStrategy implements BlobStrategy { public static String getInitials(String name) { if (name == null) { throw new IllegalArgumentException("Name was null"); } StringBuilder r = new StringBuilder(); boolean start = true; for (int ii = 0; ii < name.length(); ii++) { char c = name.charAt(ii); if (start) { r.append(c); start = false; continue; } if (Character.isUpperCase(c)) { r.append(c); } } return r.toString(); } @Inject AttributeCompressionStrategy(TokenBlobUtils blobUtils); void perform(Token token); void reverse(Token token); static String getInitials(String name); static Collection<Field> getAllValidFields(Class c); }### Answer:
@Test public void shouldConvertFieldNameToInitials() { assertEquals("bW", AttributeCompressionStrategy.getInitials("badgerWoodland")); assertEquals("bWO", AttributeCompressionStrategy.getInitials("badgerWOodland")); assertEquals("bWOL", AttributeCompressionStrategy.getInitials("badgerWOodLand")); }
|
### Question:
ExternalTokenConfig { public void update() { hostname.set(SystemProperties.get(Constants.CTS_STORE_HOSTNAME)); port.set(SystemProperties.get(Constants.CTS_STORE_PORT)); username.set(SystemProperties.get(Constants.CTS_STORE_USERNAME)); password.set(AMPasswordUtil.decrypt(SystemProperties.get(Constants.CTS_STORE_PASSWORD))); maxConnections.set(SystemProperties.get(Constants.CTS_MAX_CONNECTIONS)); sslMode.set(SystemProperties.getAsBoolean(Constants.CTS_SSL_ENABLED, false)); String heartbeatStr = SystemProperties.get(Constants.LDAP_HEARTBEAT); if (StringUtils.isNotEmpty(heartbeatStr)) { try { heartbeat.set(Integer.parseInt(heartbeatStr)); } catch (NumberFormatException e) { heartbeat.set(new Integer(-1)); } } else { heartbeat.set(new Integer(-1)); } String mode = SystemProperties.get(Constants.CTS_STORE_LOCATION); if (StringUtils.isNotEmpty(mode)) { storeMode.set(StoreMode.valueOf(mode.toUpperCase())); } else { storeMode.set(StoreMode.DEFAULT); } } @Inject ExternalTokenConfig(); StoreMode getStoreMode(); String getHostname(); String getPort(); String getUsername(); String getPassword(); String getMaxConnections(); int getHeartbeat(); boolean isSslMode(); boolean hasChanged(); void update(); }### Answer:
@Test public void shouldUseSystemPropertiesWrapperForNotifyChanges() { PowerMockito.mockStatic(SystemProperties.class); ExternalTokenConfig config = new ExternalTokenConfig(); config.update(); PowerMockito.verifyStatic(times(7)); SystemProperties.get(anyString()); PowerMockito.verifyStatic(); SystemProperties.getAsBoolean(anyString(), anyBoolean()); }
|
### Question:
CoreTokenAdapter { public void create(Token token) throws CoreTokenException { Connection connection = null; try { connection = connectionFactory.getConnection(); ldapAdapter.create(connection, token); if (debug.messageEnabled()) { debug.message(MessageFormat.format( CoreTokenConstants.DEBUG_HEADER + "Create: Created {0} Token {1}\n" + "{2}", token.getType(), token.getTokenId(), token)); } } catch (ErrorResultException e) { throw new CreateFailedException(token, e); } finally { IOUtils.closeIfNotNull(connection); } } @Inject CoreTokenAdapter(ConnectionFactory connectionFactory, QueryFactory queryFactory,
LDAPAdapter ldapAdapter, ConfigurationObserver observer,
CoreTokenConfigListener listener, @Named(CoreTokenConstants.CTS_DEBUG) Debug debug); void create(Token token); Token read(String tokenId); QueryBuilder query(); QueryFilter buildFilter(); void updateOrCreate(Token token); void delete(String tokenId); }### Answer:
@Test public void shouldCreateToken() throws CoreTokenException, ErrorResultException { Token token = new Token("badger", TokenType.SESSION); adapter.create(token); verify(mockLDAPAdapter).create(any(Connection.class), eq(token)); }
|
### Question:
CoreTokenAdapter { public Token read(String tokenId) throws CoreTokenException { Connection connection = null; try { connection = connectionFactory.getConnection(); Token token = ldapAdapter.read(connection, tokenId); if (token == null) { if (debug.messageEnabled()) { debug.message(MessageFormat.format( CoreTokenConstants.DEBUG_HEADER + "Read: {0} not found.", tokenId)); } return null; } if (debug.messageEnabled()) { debug.message(MessageFormat.format( CoreTokenConstants.DEBUG_HEADER + "Read: {0} successfully.", tokenId)); } return token; } catch (ErrorResultException e) { Result result = e.getResult(); throw new LDAPOperationFailedException(result); } finally { IOUtils.closeIfNotNull(connection); } } @Inject CoreTokenAdapter(ConnectionFactory connectionFactory, QueryFactory queryFactory,
LDAPAdapter ldapAdapter, ConfigurationObserver observer,
CoreTokenConfigListener listener, @Named(CoreTokenConstants.CTS_DEBUG) Debug debug); void create(Token token); Token read(String tokenId); QueryBuilder query(); QueryFilter buildFilter(); void updateOrCreate(Token token); void delete(String tokenId); }### Answer:
@Test public void shouldReadToken() throws CoreTokenException, ErrorResultException { String tokenId = "badger"; Token token = new Token(tokenId, TokenType.SESSION); given(mockLDAPAdapter.read(any(Connection.class), eq(tokenId))).willReturn(token); Token result = adapter.read(tokenId); assertThat(result.getTokenId()).isEqualTo(tokenId); }
|
### Question:
CoreTokenAdapter { public QueryBuilder query() { return queryFactory.createInstance(); } @Inject CoreTokenAdapter(ConnectionFactory connectionFactory, QueryFactory queryFactory,
LDAPAdapter ldapAdapter, ConfigurationObserver observer,
CoreTokenConfigListener listener, @Named(CoreTokenConstants.CTS_DEBUG) Debug debug); void create(Token token); Token read(String tokenId); QueryBuilder query(); QueryFilter buildFilter(); void updateOrCreate(Token token); void delete(String tokenId); }### Answer:
@Test public void shouldGenerateAnInstanceOfQueryBuilder() throws ErrorResultException { adapter.query(); verify(mockQueryFactory).createInstance(); }
|
### Question:
CoreTokenAdapter { public void delete(String tokenId) throws DeleteFailedException { Connection connection = null; try { connection = connectionFactory.getConnection(); ldapAdapter.delete(connection, tokenId); if (debug.messageEnabled()) { debug.message(MessageFormat.format( CoreTokenConstants.DEBUG_HEADER + "Delete: Deleted DN {0}", tokenId)); } } catch (ErrorResultException e) { throw new DeleteFailedException(tokenId, e); } catch (LDAPOperationFailedException e) { throw new DeleteFailedException(tokenId, e); } finally { IOUtils.closeIfNotNull(connection); } } @Inject CoreTokenAdapter(ConnectionFactory connectionFactory, QueryFactory queryFactory,
LDAPAdapter ldapAdapter, ConfigurationObserver observer,
CoreTokenConfigListener listener, @Named(CoreTokenConstants.CTS_DEBUG) Debug debug); void create(Token token); Token read(String tokenId); QueryBuilder query(); QueryFilter buildFilter(); void updateOrCreate(Token token); void delete(String tokenId); }### Answer:
@Test public void shouldPerformDelete() throws LDAPOperationFailedException, ErrorResultException, DeleteFailedException { String tokenId = "badger"; adapter.delete(tokenId); verify(mockLDAPAdapter).delete(any(Connection.class), eq(tokenId)); }
|
### Question:
LDAPSearchHandler { public Result performSearch(SearchRequest request, Collection<Entry> entries) throws QueryFailedException { Filter filter = request.getFilter(); Connection connection = null; try { connection = connectionFactory.getConnection(); result = connection.search(request, entries); return result; } catch (ErrorResultException e) { if (!entries.isEmpty()) { if (debug.warningEnabled()) { debug.warning("Partial search result has been received due to the following error:", e); } return e.getResult(); } throw new QueryFailedException(connection, constants.getTokenStoreRootSuffix(), filter, e); } finally { IOUtils.closeIfNotNull(connection); } } @Inject LDAPSearchHandler(ConnectionFactory connectionFactory, LDAPConfig constants,
@Named(CoreTokenConstants.CTS_DEBUG) Debug debug); Result performSearch(SearchRequest request, Collection<Entry> entries); }### Answer:
@Test public void shouldGetConnectionFromFactory() throws QueryFailedException, ErrorResultException, ErrorResultIOException { given(mockFactory.getConnection()).willReturn(mockConnection); handler.performSearch(mockRequest, mock(Collection.class)); verify(mockFactory).getConnection(); }
@Test(expectedExceptions = QueryFailedException.class) public void shouldHandleException() throws Exception { given(mockFactory.getConnection()).willThrow(ErrorResultException.class); handler.performSearch(mockRequest, new ArrayList<Entry>(0)); }
@Test public void shouldNotFailWithExceptionIfEntriesWerePresent() throws Exception { given(mockFactory.getConnection()).willReturn(mockConnection); List<Entry> entries = new ArrayList<Entry>(); entries.add(null); given(mockConnection.search(mockRequest, entries)).willThrow(ErrorResultException.class); handler.performSearch(mockRequest, new ArrayList<Entry>(0)); }
@Test public void shouldReturnResult() throws ErrorResultException, QueryFailedException { Result mockResult = mock(Result.class); given(mockConnection.search(eq(mockRequest), any(Collection.class))).willReturn(mockResult); Result result = handler.performSearch(mockRequest, mock(Collection.class)); assertThat(result).isEqualTo(mockResult); }
|
### Question:
QueryPageIterator implements Iterator<Collection<Entry>> { public boolean hasNext() { if (firstCall) { return true; } return cookie.length() != QueryBuilder.getEmptyPagingCookie().length(); } QueryPageIterator(QueryBuilder builder, int pageSize); boolean hasNext(); Collection<Entry> next(); void remove(); }### Answer:
@Test public void shouldHaveNextOnFirstCall() { assertThat(iterator.hasNext()).isTrue(); }
|
### Question:
QueryPageIterator implements Iterator<Collection<Entry>> { public Collection<Entry> next() { if (firstCall) { firstCall = false; } try { return queryPage(); } catch (CoreTokenException e) { throw new IllegalStateException(e); } } QueryPageIterator(QueryBuilder builder, int pageSize); boolean hasNext(); Collection<Entry> next(); void remove(); }### Answer:
@Test public void shouldPerfomQueryWithNextCall() throws CoreTokenException { iterator.next(); verify(mockBuilder, atLeastOnce()).executeRawResults(); }
|
### Question:
LDAPAdapter { public void create(Connection connection, Token token) throws ErrorResultException, LDAPOperationFailedException { Entry entry = conversion.getEntry(token); processResult(connection.add(entry)); } @Inject LDAPAdapter(TokenAttributeConversion conversion); void create(Connection connection, Token token); Token read(Connection connection, String tokenId); boolean update(Connection connection, Token previous, Token updated); void delete(Connection connection, String tokenId); void deleteAsync(Connection connection, String tokenId, ResultHandler<Result> handler); }### Answer:
@Test public void shouldUseConnectionForCreate() throws LDAPOperationFailedException, ErrorResultException { Token token = new Token("badger", TokenType.SESSION); Connection mockConnection = mock(Connection.class); Result successResult = mockSuccessfulResult(); given(mockConnection.add(any(Entry.class))).willReturn(successResult); TokenAttributeConversion mockConversion = mock(TokenAttributeConversion.class); given(mockConversion.getEntry(any(Token.class))).willReturn(mock(Entry.class)); LDAPAdapter adapter = new LDAPAdapter(mockConversion); adapter.create(mockConnection, token); verify(mockConnection).add(any(Entry.class)); }
|
### Question:
LDAPAdapter { public Token read(Connection connection, String tokenId) throws ErrorResultException { DN dn = conversion.generateTokenDN(tokenId); try { SearchResultEntry resultEntry = connection.readEntry(dn); return conversion.tokenFromEntry(resultEntry); } catch (ErrorResultException e) { Result result = e.getResult(); if (result != null && ResultCode.NO_SUCH_OBJECT.equals(result.getResultCode())) { return null; } throw e; } } @Inject LDAPAdapter(TokenAttributeConversion conversion); void create(Connection connection, Token token); Token read(Connection connection, String tokenId); boolean update(Connection connection, Token previous, Token updated); void delete(Connection connection, String tokenId); void deleteAsync(Connection connection, String tokenId, ResultHandler<Result> handler); }### Answer:
@Test public void shouldUseConnectionForRead() throws ErrorResultException { String tokenId = "badger"; DN testDN = DN.rootDN(); Connection mockConnection = mock(Connection.class); TokenAttributeConversion mockConversion = mock(TokenAttributeConversion.class); given(mockConversion.generateTokenDN(anyString())).willReturn(testDN); LDAPAdapter adapter = new LDAPAdapter(mockConversion); adapter.read(mockConnection, tokenId); ArgumentCaptor<DN> captor = ArgumentCaptor.forClass(DN.class); verify(mockConnection).readEntry(captor.capture()); assertEquals(testDN, captor.getValue()); }
@Test public void shouldReturnNullWhenObjectNotFound() throws ErrorResultException { String tokenId = "badger"; DN testDN = DN.rootDN(); Connection mockConnection = mock(Connection.class); ErrorResultException exception = ErrorResultException.newErrorResult(ResultCode.NO_SUCH_OBJECT); given(mockConnection.readEntry(eq(testDN))).willThrow(exception); TokenAttributeConversion mockConversion = mock(TokenAttributeConversion.class); given(mockConversion.generateTokenDN(anyString())).willReturn(testDN); LDAPAdapter adapter = new LDAPAdapter(mockConversion); Token result = adapter.read(mockConnection, tokenId); assertThat(result).isNull(); }
|
### Question:
LDAPConfig { public void update() { tokenStoreRootSuffix.set(SystemProperties.get(Constants.CTS_ROOT_SUFFIX)); } @Inject LDAPConfig(String rootSuffix); DN getTokenStoreRootSuffix(); boolean hasChanged(); void update(); }### Answer:
@Test public void shouldUseSystemPropertiesForNotifyChanges() { PowerMockito.mockStatic(SystemProperties.class); LDAPConfig config = new LDAPConfig(""); config.update(); PowerMockito.verifyStatic(); SystemProperties.get(anyString()); }
|
### Question:
CTSConnectionFactory implements ConnectionFactory, ShutdownListener { public void close() { IOUtils.closeIfNotNull(factory); } @Inject CTSConnectionFactory(DataLayerConnectionFactory dlcf, LDAPConfig ldapConfig,
ExternalTokenConfig external, @Named(CoreTokenConstants.CTS_DEBUG) Debug debug); void updateConnection(); Connection getConnection(); FutureResult<Connection> getConnectionAsync(ResultHandler<? super Connection> resultHandler); void close(); void shutdown(); }### Answer:
@Test public void shouldCloseFactoryOnClose() { factory.close(); verify(mockDLCF).close(); }
|
### Question:
CTSConnectionFactory implements ConnectionFactory, ShutdownListener { public Connection getConnection() throws ErrorResultException { try { readLock.lock(); return factory.getConnection(); } finally { readLock.unlock(); } } @Inject CTSConnectionFactory(DataLayerConnectionFactory dlcf, LDAPConfig ldapConfig,
ExternalTokenConfig external, @Named(CoreTokenConstants.CTS_DEBUG) Debug debug); void updateConnection(); Connection getConnection(); FutureResult<Connection> getConnectionAsync(ResultHandler<? super Connection> resultHandler); void close(); void shutdown(); }### Answer:
@Test public void shouldUseDLCFByDefault() throws ErrorResultException { factory.getConnection(); verify(mockDLCF).getConnection(); }
|
### Question:
CTSConnectionFactory implements ConnectionFactory, ShutdownListener { public FutureResult<Connection> getConnectionAsync(ResultHandler<? super Connection> resultHandler) { try { readLock.lock(); return factory.getConnectionAsync(resultHandler); } finally { readLock.unlock(); } } @Inject CTSConnectionFactory(DataLayerConnectionFactory dlcf, LDAPConfig ldapConfig,
ExternalTokenConfig external, @Named(CoreTokenConstants.CTS_DEBUG) Debug debug); void updateConnection(); Connection getConnection(); FutureResult<Connection> getConnectionAsync(ResultHandler<? super Connection> resultHandler); void close(); void shutdown(); }### Answer:
@Test public void shouldUseFactoryForAsynConnection() { factory.getConnectionAsync(mock(ResultHandler.class)); verify(mockDLCF).getConnectionAsync(any(ResultHandler.class)); }
|
### Question:
CTSConnectionFactory implements ConnectionFactory, ShutdownListener { public void updateConnection() { try { writeLock.lock(); if (ldapConfig.hasChanged() || external.hasChanged()) { reconfigureConnection(); } } finally { writeLock.unlock(); } } @Inject CTSConnectionFactory(DataLayerConnectionFactory dlcf, LDAPConfig ldapConfig,
ExternalTokenConfig external, @Named(CoreTokenConstants.CTS_DEBUG) Debug debug); void updateConnection(); Connection getConnection(); FutureResult<Connection> getConnectionAsync(ResultHandler<? super Connection> resultHandler); void close(); void shutdown(); }### Answer:
@Test public void shouldUseLDAPUtilsForExternalConfiguration() { PowerMockito.mockStatic(LDAPUtils.class); ConnectionFactory mockConnectionFactory = mock(ConnectionFactory.class); given(LDAPUtils.newFailoverConnectionPool( any(Set.class), anyString(), any(char[].class), anyInt(), anyInt(), anyString(), any(LDAPOptions.class))).willReturn(mockConnectionFactory); given(mockExternal.getStoreMode()).willReturn(ExternalTokenConfig.StoreMode.EXTERNAL); given(mockExternal.getHostname()).willReturn("badger"); given(mockExternal.getMaxConnections()).willReturn("50"); given(mockExternal.getPassword()).willReturn("weasel"); given(mockExternal.getPort()).willReturn("1234"); given(mockExternal.getUsername()).willReturn("ferret"); given(mockExternal.hasChanged()).willReturn(true); factory.updateConnection(); PowerMockito.verifyStatic(); LDAPUtils.newFailoverConnectionPool( any(Set.class), anyString(), any(char[].class), anyInt(), anyInt(), anyString(), any(LDAPOptions.class)); }
|
### Question:
ServerGroupConfiguration { public String getBindDN() { return instance.getAuthID(); } ServerGroupConfiguration(ServerGroup group, ServerInstance instance); String getBindDN(); char[] getBindPassword(); int getMaxConnections(); int getLdapHeartbeat(); Set<LDAPURL> getLDAPURLs(); }### Answer:
@Test public void shouldReturnBindDNFromInstance() { ServerInstance mockInstance = mock(ServerInstance.class); ServerGroup mockGroup = mock(ServerGroup.class); ServerGroupConfiguration config = new ServerGroupConfiguration(mockGroup, mockInstance); config.getBindDN(); verify(mockInstance).getAuthID(); }
|
### Question:
ServerGroupConfiguration { public char[] getBindPassword() { return instance.getPasswd().toCharArray(); } ServerGroupConfiguration(ServerGroup group, ServerInstance instance); String getBindDN(); char[] getBindPassword(); int getMaxConnections(); int getLdapHeartbeat(); Set<LDAPURL> getLDAPURLs(); }### Answer:
@Test public void shouldReturnPasswordFromInstance() { ServerInstance mockInstance = mock(ServerInstance.class); ServerGroup mockGroup = mock(ServerGroup.class); ServerGroupConfiguration config = new ServerGroupConfiguration(mockGroup, mockInstance); given(mockInstance.getPasswd()).willReturn(""); config.getBindPassword(); verify(mockInstance).getPasswd(); }
|
### Question:
ServerGroupConfiguration { public int getMaxConnections() { return instance.getMaxConnections(); } ServerGroupConfiguration(ServerGroup group, ServerInstance instance); String getBindDN(); char[] getBindPassword(); int getMaxConnections(); int getLdapHeartbeat(); Set<LDAPURL> getLDAPURLs(); }### Answer:
@Test public void shouldReturnMaxConnectionsFromInstance() { ServerInstance mockInstance = mock(ServerInstance.class); ServerGroup mockGroup = mock(ServerGroup.class); ServerGroupConfiguration config = new ServerGroupConfiguration(mockGroup, mockInstance); config.getMaxConnections(); verify(mockInstance).getMaxConnections(); }
|
### Question:
ClusterStateService extends GeneralTaskRunnable { private int getNextSelected() { return lastSelected = (lastSelected + 1) % serverSelectionList.length; } protected ClusterStateService(SessionService sessionService, String localServerId,
int timeout, long period, Map<String, String> members); long getRunPeriod(); boolean addElement(Object obj); boolean removeElement(Object obj); boolean isEmpty(); void run(); @Override String toString(); static Debug sessionDebug; static final int DEFAULT_TIMEOUT; static final long DEFAULT_PERIOD; }### Answer:
@Test(expectedExceptions={java.lang.ArithmeticException.class}) public void testGetNextSelected() throws Exception { int lastSelected = -1; lastSelected = (lastSelected + 1) % 0; assertTrue(false); }
|
### Question:
QueryParameterMatcher { public boolean match(String queryString) { if (StringUtils.isEmpty(queryString)) { return false; } String[] queryParams = queryString.split("&"); for (String param : queryParams) { String[] params = param.split("="); if (params.length != 2) { throw new IllegalArgumentException("Query Param string does not contain valid query parameters"); } String key = params[0]; String val = params[1]; if (queryParam.equalsIgnoreCase(key) && value.equalsIgnoreCase(val)) { return true; } } return false; } QueryParameterMatcher(String queryParam, String value); boolean match(String queryString); }### Answer:
@Test public void shouldMatch() { QueryParameterMatcher queryParameterMatcher = new QueryParameterMatcher("KEY", "VALUE"); boolean matches = queryParameterMatcher.match("A=1&KeY=VALuE&-fdw=23nd"); assertTrue(matches); }
@Test public void shouldNotMatchOnKey() { QueryParameterMatcher queryParameterMatcher = new QueryParameterMatcher("KEY", "VALUE"); boolean matches = queryParameterMatcher.match("A=1&KEY1=VALUE&-fdw=23nd"); assertFalse(matches); }
@Test public void shouldNotMatchOnValue() { QueryParameterMatcher queryParameterMatcher = new QueryParameterMatcher("KEY", "VALUE"); boolean matches = queryParameterMatcher.match("A=1&KEY=VALUE1&-fdw=23nd"); assertFalse(matches); }
@Test public void shouldNotMatchWhenQueryStringIsNull() { QueryParameterMatcher queryParameterMatcher = new QueryParameterMatcher("KEY", "VALUE"); boolean matches = queryParameterMatcher.match(null); assertFalse(matches); }
@Test public void shouldNotMatchWhenQueryStringIsEmpty() { QueryParameterMatcher queryParameterMatcher = new QueryParameterMatcher("KEY", "VALUE"); boolean matches = queryParameterMatcher.match(""); assertFalse(matches); }
@Test (expectedExceptions = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionWhenMissingEqualsInQueryParamKeyValue() { QueryParameterMatcher queryParameterMatcher = new QueryParameterMatcher("KEY", "VALUE"); queryParameterMatcher.match("KEYVALUE"); fail(); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.