method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
TableReference implements DeepCopyableWithTransformation<TableReference,
Builder<TableReference>> { public TableReference as(String aliasName) { if (AliasedField.immutableDslEnabled()) { return new TableReference(this, aliasName); } else { this.alias = aliasName; return this; } } private TableReference(TableReference sourceTable, String alias); TableReference(String name); TableReference(String schemaName, String tableName); TableReference(String tableName, boolean temporary); TableReference as(String aliasName); String getName(); String getAlias(); String getSchemaName(); boolean isTemporary(); @Deprecated void setName(String name); @Override Builder<TableReference> deepCopy(DeepCopyTransformation transformer); TableReference deepCopy(); @Override String toString(); FieldReference field(String fieldName); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testAliasImmutability() { AliasedField.withImmutableBuildersEnabled(() -> { assertEquals(isEqual.as("A"), onTest.as("A")); assertEquals(isEqual.as("B").as("A"), onTest.as("A")); assertNotEquals(isEqual.as("A"), onTest.as("B")); assertNotSame(onTest, onTest.as("A")); }); }
@Test public void testAliasMutablity() { AliasedField.withImmutableBuildersDisabled(() -> { assertSame(onTest, onTest.as("A")); }); } |
### Question:
TableReference implements DeepCopyableWithTransformation<TableReference,
Builder<TableReference>> { @Override public Builder<TableReference> deepCopy(DeepCopyTransformation transformer) { return TempTransitionalBuilderWrapper.wrapper(deepCopy()); } private TableReference(TableReference sourceTable, String alias); TableReference(String name); TableReference(String schemaName, String tableName); TableReference(String tableName, boolean temporary); TableReference as(String aliasName); String getName(); String getAlias(); String getSchemaName(); boolean isTemporary(); @Deprecated void setName(String name); @Override Builder<TableReference> deepCopy(DeepCopyTransformation transformer); TableReference deepCopy(); @Override String toString(); FieldReference field(String fieldName); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testDeepCopy() { TableReference deepCopy = onTest.deepCopy(); assertEquals(deepCopy, onTest); assertNotSame(deepCopy, onTest); }
@Test public void testDeepCopyAliased() { TableReference deepCopy = onTestAliased.deepCopy(); assertEquals(deepCopy, onTestAliased); assertNotSame(deepCopy, onTestAliased); } |
### Question:
DatabaseMetaDataProviderUtils { public static int getAutoIncrementStartValue(String columnComment) { if (StringUtils.isNotEmpty(columnComment)) { Matcher matcher = AUTONUM_START_REGEX.matcher(columnComment); if (matcher.find()) { return Integer.parseInt(matcher.group(1)); } } return -1; } static int getAutoIncrementStartValue(String columnComment); static Optional<String> getDataTypeFromColumnComment(String columnComment); static boolean shouldIgnoreIndex(String indexName); }### Answer:
@Test public void testGetAutoIncrementStartValue() { assertEquals("Failed to fetch correct value", 1234, DatabaseMetaDataProviderUtils.getAutoIncrementStartValue("AUTONUMSTART:[1234]")); assertEquals("Failed to fetch correct value from large string", 1234, DatabaseMetaDataProviderUtils.getAutoIncrementStartValue(" dfdfg AUTONUMSTART:[1234] dsfdfg")); assertEquals("Failed to fetch correct value when multiple values exist", 1234, DatabaseMetaDataProviderUtils.getAutoIncrementStartValue("AUTONUMSTART:[1234]/AUTONUMSTART:[2345]")); assertEquals("Failed to fetch unset value", -1, DatabaseMetaDataProviderUtils.getAutoIncrementStartValue("AUTONUMSTART:[1234")); assertEquals("Failed to fetch missing value", -1, DatabaseMetaDataProviderUtils.getAutoIncrementStartValue("AUTONUMSTART:[]")); assertEquals("Failed to fetch malformed value", -1, DatabaseMetaDataProviderUtils.getAutoIncrementStartValue("AUTONUMSTART:[ABC]")); } |
### Question:
DatabaseMetaDataProviderUtils { public static boolean shouldIgnoreIndex(String indexName) { return indexName.toUpperCase().matches(".*_PRF\\d+$"); } static int getAutoIncrementStartValue(String columnComment); static Optional<String> getDataTypeFromColumnComment(String columnComment); static boolean shouldIgnoreIndex(String indexName); }### Answer:
@Test public void shouldIgnoreIndex() { assertFalse(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Schedule_1")); assertFalse(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Fred")); assertFalse(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Schedule_PRF")); assertFalse(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Schedule_xPRF")); assertFalse(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Schedule_PRF1X")); assertTrue(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Schedule_PRF0")); assertTrue(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Schedule_PRF1")); assertTrue(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Schedule_PRF11")); assertTrue(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Fred_PRF2")); assertTrue(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Fred_prf2")); } |
### Question:
SqlQueryDataSetProducer implements DataSetProducer { @Override public void open() { try { this.connection = dataSource.getConnection(); this.wasAutoCommit = connection.getAutoCommit(); wasAutoCommit = connection.getAutoCommit(); connection.setAutoCommit(false); } catch (SQLException e) { throw new RuntimeSqlException("Error opening connection", e); } } SqlQueryDataSetProducer(Table table, String query, DataSource dataSource, SqlDialect sqlDialect); @Override void open(); @Override void close(); @Override Schema getSchema(); @Override Iterable<Record> records(String tableName); @Override boolean isTableEmpty(String tableName); }### Answer:
@Test public void testOpen() throws SQLException { Table table = buildTable(); String query = "select column from table"; given(dataSource.getConnection()) .willReturn(connection); SqlQueryDataSetProducer producer = new SqlQueryDataSetProducer(table, query, dataSource, sqlDialect); producer.open(); verify(connection).setAutoCommit(false); } |
### Question:
SqlQueryDataSetProducer implements DataSetProducer { @Override public void close() { if (connection == null) { return; } try { for (ResultSetIterator resultSetIterator : openResultSets) { resultSetIterator.close(); } openResultSets.clear(); connection.setAutoCommit(wasAutoCommit); connection.close(); connection = null; } catch (SQLException e) { throw new RuntimeException("Error closing result set", e); } } SqlQueryDataSetProducer(Table table, String query, DataSource dataSource, SqlDialect sqlDialect); @Override void open(); @Override void close(); @Override Schema getSchema(); @Override Iterable<Record> records(String tableName); @Override boolean isTableEmpty(String tableName); }### Answer:
@Test public void testClose() throws SQLException { Table table = buildTable(); String query = "select column from table"; given(dataSource.getConnection()) .willReturn(connection); given(connection.getAutoCommit()).willReturn(true); SqlQueryDataSetProducer producer = new SqlQueryDataSetProducer(table, query, dataSource, sqlDialect); producer.open(); producer.close(); verify(connection).setAutoCommit(false); verify(connection).setAutoCommit(true); verify(connection).close(); } |
### Question:
SqlQueryDataSetProducer implements DataSetProducer { @Override public Iterable<Record> records(String tableName) { Table table = getSchema().getTable(tableName); return new Iterable<Record>() { @Override public Iterator<Record> iterator() { ResultSetIterator resultSetIterator = new ResultSetIterator(table, query, connection, sqlDialect); openResultSets.add(resultSetIterator); return resultSetIterator; } }; } SqlQueryDataSetProducer(Table table, String query, DataSource dataSource, SqlDialect sqlDialect); @Override void open(); @Override void close(); @Override Schema getSchema(); @Override Iterable<Record> records(String tableName); @Override boolean isTableEmpty(String tableName); }### Answer:
@Test public void testRecords() throws SQLException { Table table = buildTable(); String query = "select column from table"; given(dataSource.getConnection()) .willReturn(connection); ResultSet resultSet = mock(ResultSet.class); given(statement.executeQuery(query)).willReturn(resultSet); given(resultSet.findColumn("Column")).willReturn(1); SqlQueryDataSetProducer producer = new SqlQueryDataSetProducer(table, query, dataSource, sqlDialect); producer.open(); Iterable<Record> records = producer.records("table"); records.iterator(); } |
### Question:
DatabaseExceptionHelper { public boolean isCausedByTimeoutException(Throwable throwable) { if (ExceptionUtils.indexOfType(throwable, SQLTimeoutException.class) != -1) { return true; } for (Throwable causeThrowable : ExceptionUtils.getThrowables(throwable)) { if (MYSQL_TIMEOUT_EXCEPTION_NAME.equals(causeThrowable.getClass().getSimpleName())) { return true; } } return false; } boolean isCausedByTimeoutException(Throwable throwable); }### Answer:
@Test public void testIsCausedByTimeoutForSQLTimeoutException() { assertEquals(true, databaseExceptionHelper.isCausedByTimeoutException(new ExtendsSQLTimeoutException())); }
@Test public void testIsCausedByTimeoutForMySQLTimeoutException() { assertEquals(true, databaseExceptionHelper.isCausedByTimeoutException(new MySQLTimeoutException())); } |
### Question:
NamedParameterPreparedStatement implements AutoCloseable { public static ParseResult parse(String sql) { return new ParseResult(sql); } NamedParameterPreparedStatement(Connection connection, String query, Map<String, List<Integer>> indexMap, boolean queryOnly, ParseResult sql); static ParseResult parse(String sql); boolean execute(); ResultSet executeQuery(); int executeUpdate(); @Override void close(); void addBatch(); int[] executeBatch(); void clearBatch(); void setFetchSize(int rows); NamedParameterPreparedStatement setBoolean(SqlParameter parameter, final boolean value); NamedParameterPreparedStatement setObject(SqlParameter parameter, final Object value); NamedParameterPreparedStatement setDate(SqlParameter parameter, final Date value); NamedParameterPreparedStatement setBigDecimal(SqlParameter parameter, final BigDecimal value); NamedParameterPreparedStatement setString(SqlParameter parameter, final String value); NamedParameterPreparedStatement setInt(SqlParameter parameter, final int value); NamedParameterPreparedStatement setLong(SqlParameter parameter, final long value); NamedParameterPreparedStatement setBinaryStream(SqlParameter parameter, final InputStream value); NamedParameterPreparedStatement setBlob(SqlParameter parameter, final byte[] value); void setMaxRows(Integer maxRows); void setQueryTimeout(Integer queryTimeout); @Override String toString(); }### Answer:
@Test public void testParse() { ParseResult parseResult = NamedParameterPreparedStatement.parse( "SELECT :fee,:fi, :fo(:fum), ':eek' FROM :fum WHERE :fum AND :fo" ); assertThat("Parsed SQL", parseResult.getParsedSql(), equalTo("SELECT ?,?, ?(?), ':eek' FROM ? WHERE ? AND ?")); assertThat("fee", parseResult.getIndexesForParameter("fee"), contains(1)); assertThat("fi", parseResult.getIndexesForParameter("fi"), contains(2)); assertThat("fo", parseResult.getIndexesForParameter("fo"), contains(3, 7)); assertThat("fum", parseResult.getIndexesForParameter("fum"), contains(4, 5, 6)); assertThat("eek", parseResult.getIndexesForParameter("eek"), hasSize(0)); } |
### Question:
SqlScriptExecutor { public int executeAndCommit(Iterable<String> sqlScript, Connection connection) { int result = 0; try { visitor.executionStart(); for (String sql : sqlScript) { result += executeInternal(sql, connection); connection.commit(); } visitor.executionEnd(); } catch (SQLException e) { throw reclassifiedRuntimeException(e, "Error with statement"); } return result; } SqlScriptExecutor(SqlScriptVisitor visitor, DataSource dataSource, SqlDialect sqlDialect); void doWork(Work work); int execute(final Iterable<String> sqlScript); int execute(Iterable<String> sqlScript, Connection connection); int executeAndCommit(Iterable<String> sqlScript, Connection connection); int execute(String sqlStatement, Connection connection); int execute(final String sqlStatement); int execute(String sqlStatement, Connection connection, Iterable<SqlParameter> parameterMetadata, DataValueLookup parameterData); int execute(final String sqlStatement, final Iterable<SqlParameter> parameterMetadata, final DataValueLookup parameterData); QueryBuilder executeQuery(SelectStatement query); QueryBuilder executeQuery(String query); T executeQuery(String sql, ResultSetProcessor<T> processor); T executeQuery(String sql, Connection connection, ResultSetProcessor<T> processor); T executeQuery(SelectStatement query, Iterable<SqlParameter> parameterMetadata,
DataValueLookup parameterData, Connection connection, ResultSetProcessor<T> resultSetProcessor); void executeStatementBatch(String sqlStatement, Iterable<SqlParameter> parameterMetadata, Iterable<? extends DataValueLookup> parameterData, Connection connection, boolean explicitCommit, int statementsPerFlush); }### Answer:
@Test public void testExecuteAndCommit() throws SQLException { when(statement.getUpdateCount()).thenReturn(5).thenReturn(2); int result = sqlScriptExecutor.executeAndCommit(sqlScripts, connection); assertEquals("Return value", 7, result); verify(connection, times(sqlScripts.size())).commit(); } |
### Question:
ResultSetMismatch { @Override public String toString(){ StringBuilder mismatchDetails = new StringBuilder(); if (key.length > 0) { mismatchDetails.append("Row key:").append(Arrays.toString(key)).append(" "); } mismatchDetails.append("Type:[").append(mismatchType) .append("] Column:[").append(mismatchColumnIndex); mismatchDetails.append("] Values:[").append(leftValue) .append(" <> ").append(rightValue).append("]"); return mismatchDetails.toString(); } ResultSetMismatch(MismatchType mismatchType, int mismatchColumnIndex, String leftValue, String rightValue, String... key); String[] getKey(); MismatchType getMismatchType(); int getMismatchColumnIndex(); String getLeftValue(); String getRightValue(); @Override String toString(); }### Answer:
@Test public void testToString(){ String[] keys = {"one", "two", "three"}; ResultSetMismatch unitUnderTest = new ResultSetMismatch(MismatchType.MISSING_LEFT, 3, "left", "rightValue", keys); String expectedString = "Row key:[one, two, three] Type:[MISSING_LEFT] Column:[3] Values:[left <> rightValue]"; assertEquals(expectedString, unitUnderTest.toString()); } |
### Question:
RemoveColumn implements SchemaChange { @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); boolean foundColumn = false; List<String> columns = new ArrayList<>(); for (Column column : original.columns()) { if (column.getName().equalsIgnoreCase(columnDefinition.getName())) { foundColumn = true; continue; } columns.add(column.getName()); } if (!foundColumn) { throw new IllegalArgumentException("Cannot remove column [" + columnDefinition.getName() + "] as it does not exist on table [" + tableName + "]"); } return new TableOverrideSchema(schema, new AlteredTable(original, columns)); } RemoveColumn(String tableName, Column column); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); Column getColumnDefinition(); String getTableName(); }### Answer:
@Test public void testRemovingColumn() { Schema testSchema = schema(appleTable); Schema updatedSchema = removeColumn.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade column count", 3, resultTable.columns().size()); assertEquals("Post upgrade existing column name", "pips", resultTable.columns().get(2).getName()); }
@Test public void testRemovePrimaryKey() { Schema testSchema = schema(appleTable); RemoveColumn removeIdColumn = new RemoveColumn("Apple", column("id", DataType.BIG_INTEGER).primaryKey()); Schema updatedSchema = removeIdColumn.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade column count", 3, resultTable.columns().size()); }
@Test public void testRemovingNonExistantColumn() { Schema testSchema = schema(appleTable); try { removeColumn = new RemoveColumn("Apple", column("foo", DataType.STRING).nullable()); removeColumn.apply(testSchema); fail("Should fail since column is not there"); } catch (Exception e) { } } |
### Question:
RemoveColumn implements SchemaChange { @Override public Schema reverse(Schema schema) { Table original = schema.getTable(tableName); List<String> columns = new ArrayList<>(); for (Column column : original.columns()) { columns.add(column.getName()); } columns.add(columnDefinition.getName()); return new TableOverrideSchema(schema, new AlteredTable(original, columns, Arrays.asList(new Column[] {columnDefinition}))); } RemoveColumn(String tableName, Column column); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); Column getColumnDefinition(); String getTableName(); }### Answer:
@Test public void testReverseAddingColumn() { appleTable.columns().remove(3); Schema testSchema = schema(appleTable); Schema downGradedSchema = removeColumn.reverse(testSchema); Table resultTable = downGradedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade column count", 4, resultTable.columns().size()); assertEquals("Post upgrade existing column name", "pips", resultTable.columns().get(2).getName()); assertEquals("Post upgrade existing column name", "colour", resultTable.columns().get(3).getName()); } |
### Question:
RemoveTable implements SchemaChange { @Override public Schema reverse(Schema schema) { if(schema.tableExists(tableToBeRemoved.getName().toUpperCase())){ throw new IllegalArgumentException("Cannot perform reversal for for [" + tableToBeRemoved.getName() + "] table removal as it already exist."); } return new AugmentedSchema(schema, tableToBeRemoved); } RemoveTable(Table tableToBeRemoved); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); Table getTable(); }### Answer:
@Test public void testReverseRemovingTable() { Schema testSchema = schema(appleTable, mangoTable); testSchema.tables().remove(appleTable); Schema updatedSchema = removeTable.reverse(testSchema); assertEquals("Post upgrade table count", 2, updatedSchema.tables().size()); assertTrue(updatedSchema.tableExists("Apple")); assertTrue(updatedSchema.tableExists("Mango")); } |
### Question:
RemoveTable implements SchemaChange { @Override public Schema apply(Schema schema) { if(!schema.tableExists(tableToBeRemoved.getName().toUpperCase())){ throw new IllegalArgumentException("Cannot remove table [" + tableToBeRemoved.getName() + "] as it does not exist."); } return new FilteredSchema(schema, tableToBeRemoved.getName()); } RemoveTable(Table tableToBeRemoved); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); Table getTable(); }### Answer:
@Test public void testRemovingNonExistantIndex() { Schema testSchema = schema(appleTable); try { Table table = table("Orange").columns( column("colour", DataType.STRING, 10).nullable(), column("totalValue", DataType.STRING, 10).nullable() ); removeTable = new RemoveTable(table); removeTable.apply(testSchema); fail("Should fail since column is not there"); } catch (Exception e) { } } |
### Question:
AnalyseTable implements SchemaChange { @Override public Schema apply(Schema schema) { if (!schema.tableExists(tableName.toUpperCase())) { throw new IllegalArgumentException("Cannot analyse table [" + tableName + "] as it does not exist."); } return schema; } AnalyseTable(String tableName); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override Schema reverse(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); String getTableName(); }### Answer:
@Test public void testApplyDoesNotChangeSchema() { Schema testSchema = schema(appleTable); AnalyseTable analyseTable = new AnalyseTable("Apple"); Schema updatedSchema = analyseTable.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade column count", 3, resultTable.columns().size()); assertEquals("Post upgrade column count", testSchema, updatedSchema); }
@Test(expected = IllegalArgumentException.class) public void testAnalyseNonExistentTable() { Schema testSchema = schema(appleTable); AnalyseTable analyseTable = new AnalyseTable("Pear"); analyseTable.apply(testSchema); } |
### Question:
UpgradePath implements SqlStatementWriter { public List<String> getSql() { List<String> results = Lists.newLinkedList(); if (!sql.isEmpty() || !upgradeScriptAdditions.isEmpty()) results.addAll(initialisationSql); results.addAll(sql); for (UpgradeScriptAddition addition : upgradeScriptAdditions) { Iterables.addAll(results, addition.sql()); } if (!results.isEmpty()) results.addAll(finalisationSql); return Collections.unmodifiableList(results); } UpgradePath(Set<UpgradeScriptAddition> upgradeScriptAdditions, SqlDialect sqlDialect, List<String> initialisationSql, List<String> finalisationSql); UpgradePath(Set<UpgradeScriptAddition> upgradeScriptAdditions, List<UpgradeStep> steps, SqlDialect sqlDialect, List<String> initialisationSql, List<String> finalisationSql); UpgradePath(UpgradeStatus upgradeStatus); List<UpgradeStep> getSteps(); @Override void writeSql(Collection<String> statements); List<String> getSql(); boolean hasStepsToApply(); boolean upgradeInProgress(); void logUpgradePathSQL(); void logUpgradePathSQL(Log logger); String getUpgradeSqlScript(); }### Answer:
@Test public void testSqlOrderingWhenEmpty() { Set<UpgradeScriptAddition> upgradeScriptAdditions = Collections.emptySet(); UpgradePath path = new UpgradePath(upgradeScriptAdditions, sqlDialect, ImmutableList.of("INIT1", "INIT2"), ImmutableList.of("FIN1", "FIN2")); List<String> sql = path.getSql(); assertEquals("Result", "[]", sql.toString()); } |
### Question:
AddColumn implements SchemaChange { @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); List<String> columns = new ArrayList<>(); for (Column column : original.columns()) { if (column.getName().equalsIgnoreCase(newColumnDefinition.getName())) { throw new IllegalStateException("Column [" + newColumnDefinition.getName() + "] is already present on table [" + tableName + "] so cannot be added."); } columns.add(column.getName()); } columns.add(newColumnDefinition.getName()); return new TableOverrideSchema(schema, new AlteredTable(original, columns, Arrays.asList(new Column[] {newColumnDefinition}))); } AddColumn(String tableName, Column column); @Override Schema reverse(Schema metadata); @Override Schema apply(Schema schema); String getTableName(); @Override boolean isApplied(Schema schema, ConnectionResources database); Column getNewColumnDefinition(); @Override void accept(SchemaChangeVisitor visitor); }### Answer:
@Test public void testAddingColumn() { Schema testSchema = schema(appleTable); Schema updatedSchema = addColumn.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade column count", 4, resultTable.columns().size()); assertEquals("Post upgrade existing column name", "pips", resultTable.columns().get(2).getName()); assertEquals("Post upgrade new column name", "colour", resultTable.columns().get(3).getName()); } |
### Question:
AddColumn implements SchemaChange { @Override public Schema reverse(Schema metadata) { Table original = metadata.getTable(tableName); List<String> columns = new ArrayList<>(); boolean found = false; for (Column column : original.columns()) { if (column.getName().equalsIgnoreCase(newColumnDefinition.getName())) { found = true; } else { columns.add(column.getName()); } } if (!found) { String columnsInTargetTable = original.columns().toString(); throw new IllegalStateException( "Column [" + newColumnDefinition + "] not found in table [" + tableName + "] so it could not be removed.\n" + "Columns in target table [" + tableName + "]:\n" + columnsInTargetTable.replace(",", ",\n") ); } return new TableOverrideSchema(metadata, new AlteredTable(original, columns)); } AddColumn(String tableName, Column column); @Override Schema reverse(Schema metadata); @Override Schema apply(Schema schema); String getTableName(); @Override boolean isApplied(Schema schema, ConnectionResources database); Column getNewColumnDefinition(); @Override void accept(SchemaChangeVisitor visitor); }### Answer:
@Test public void testReverseAddingColumn() { appleTable = table("Apple") .columns( idColumn(), versionColumn(), column("pips", DataType.STRING, 10).nullable(), column("colour", DataType.STRING, 10).nullable() ); Schema testSchema = schema(appleTable); Schema downGradedSchema = addColumn.reverse(testSchema); Table resultTable = downGradedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade column count", 3, resultTable.columns().size()); assertEquals("Post upgrade existing column name", "pips", resultTable.columns().get(2).getName()); }
@Test public void testRemovingNonExistantColumn() { Schema testSchema = schema(appleTable); try { addColumn.reverse(testSchema); fail("Should fail since column is not there"); } catch (Exception e) { } } |
### Question:
HumanReadableStatementHelper { public static String generateAddIndexString(final String tableName, final Index index) { return String.format("Add %s index called %s to %s", generateUniqueIndexString(index), index.getName(), tableName); } static String generateChangePrimaryKeyColumnsString(String tableName, List<String> oldPrimaryKeyColumns, List<String> newPrimaryKeyColumns); static String generateChangePrimaryKeyColumnsString(String tableName, List<String> newPrimaryKeyColumns); static String generateAddColumnString(final String tableName, final Column definition); static String generateAddColumnString(final String tableName, final Column definition, final FieldLiteral defaultValue); static String generateAddIndexString(final String tableName, final Index index); static String generateAddTableString(final Table definition); static String generateAddTableFromString(final Table definition, final SelectStatement selectStatement); static String generateAnalyseTableFromString(String tableName); static String generateRenameTableString(String from, String to); static String generateChangeColumnString(final String tableName, final Column fromDefinition, final Column toDefinition); static String generateChangeIndexString(final String tableName, final Index fromIndex, final Index toIndex); static String generateRenameIndexString(final String tableName, final String fromIndexName, final String toIndexName); static String generateRemoveColumnString(final String tableName, final Column definition); static String generateRemoveIndexString(final String tableName, final Index index); static String generateRemoveTableString(final Table table); static String generateDataUpgradeString(final Statement statement, final String preferredSQLDialect); }### Answer:
@Test public void testAddIndexGeneration() { assertEquals("Should have correct text - Unique", "Add unique index called my_table_1 to my_table", HumanReadableStatementHelper.generateAddIndexString("my_table", index("my_table_1").unique().columns("columnOne", "columnTwo"))); assertEquals("Should have correct text - Unique", "Add non-unique index called my_table_1 to my_table", HumanReadableStatementHelper.generateAddIndexString("my_table", index("my_table_1").columns("columnOne", "columnTwo"))); } |
### Question:
HumanReadableStatementHelper { public static String generateRemoveColumnString(final String tableName, final Column definition) { return String.format("Remove column %s from %s", definition.getName(), tableName); } static String generateChangePrimaryKeyColumnsString(String tableName, List<String> oldPrimaryKeyColumns, List<String> newPrimaryKeyColumns); static String generateChangePrimaryKeyColumnsString(String tableName, List<String> newPrimaryKeyColumns); static String generateAddColumnString(final String tableName, final Column definition); static String generateAddColumnString(final String tableName, final Column definition, final FieldLiteral defaultValue); static String generateAddIndexString(final String tableName, final Index index); static String generateAddTableString(final Table definition); static String generateAddTableFromString(final Table definition, final SelectStatement selectStatement); static String generateAnalyseTableFromString(String tableName); static String generateRenameTableString(String from, String to); static String generateChangeColumnString(final String tableName, final Column fromDefinition, final Column toDefinition); static String generateChangeIndexString(final String tableName, final Index fromIndex, final Index toIndex); static String generateRenameIndexString(final String tableName, final String fromIndexName, final String toIndexName); static String generateRemoveColumnString(final String tableName, final Column definition); static String generateRemoveIndexString(final String tableName, final Index index); static String generateRemoveTableString(final Table table); static String generateDataUpgradeString(final Statement statement, final String preferredSQLDialect); }### Answer:
@Test public void testRemoveColumnGeneration() { assertEquals("Should have the correct text - Simple", "Remove column columnOne from my_table", HumanReadableStatementHelper.generateRemoveColumnString("my_table", column("columnOne", DataType.STRING, 10))); } |
### Question:
HumanReadableStatementHelper { public static String generateRemoveIndexString(final String tableName, final Index index) { return String.format("Remove index %s from %s", index.getName(), tableName); } static String generateChangePrimaryKeyColumnsString(String tableName, List<String> oldPrimaryKeyColumns, List<String> newPrimaryKeyColumns); static String generateChangePrimaryKeyColumnsString(String tableName, List<String> newPrimaryKeyColumns); static String generateAddColumnString(final String tableName, final Column definition); static String generateAddColumnString(final String tableName, final Column definition, final FieldLiteral defaultValue); static String generateAddIndexString(final String tableName, final Index index); static String generateAddTableString(final Table definition); static String generateAddTableFromString(final Table definition, final SelectStatement selectStatement); static String generateAnalyseTableFromString(String tableName); static String generateRenameTableString(String from, String to); static String generateChangeColumnString(final String tableName, final Column fromDefinition, final Column toDefinition); static String generateChangeIndexString(final String tableName, final Index fromIndex, final Index toIndex); static String generateRenameIndexString(final String tableName, final String fromIndexName, final String toIndexName); static String generateRemoveColumnString(final String tableName, final Column definition); static String generateRemoveIndexString(final String tableName, final Index index); static String generateRemoveTableString(final Table table); static String generateDataUpgradeString(final Statement statement, final String preferredSQLDialect); }### Answer:
@Test public void testRemoveIndexGeneration() { assertEquals("Should have the correct text - Simple", "Remove index my_table_1 from my_table", HumanReadableStatementHelper.generateRemoveIndexString("my_table", index("my_table_1").unique().columns("columnOne", "columnTwo"))); } |
### Question:
HumanReadableStatementHelper { public static String generateRemoveTableString(final Table table) { return String.format("Remove table %s", table.getName()); } static String generateChangePrimaryKeyColumnsString(String tableName, List<String> oldPrimaryKeyColumns, List<String> newPrimaryKeyColumns); static String generateChangePrimaryKeyColumnsString(String tableName, List<String> newPrimaryKeyColumns); static String generateAddColumnString(final String tableName, final Column definition); static String generateAddColumnString(final String tableName, final Column definition, final FieldLiteral defaultValue); static String generateAddIndexString(final String tableName, final Index index); static String generateAddTableString(final Table definition); static String generateAddTableFromString(final Table definition, final SelectStatement selectStatement); static String generateAnalyseTableFromString(String tableName); static String generateRenameTableString(String from, String to); static String generateChangeColumnString(final String tableName, final Column fromDefinition, final Column toDefinition); static String generateChangeIndexString(final String tableName, final Index fromIndex, final Index toIndex); static String generateRenameIndexString(final String tableName, final String fromIndexName, final String toIndexName); static String generateRemoveColumnString(final String tableName, final Column definition); static String generateRemoveIndexString(final String tableName, final Index index); static String generateRemoveTableString(final Table table); static String generateDataUpgradeString(final Statement statement, final String preferredSQLDialect); }### Answer:
@Test public void testRemoveTableGeneration() { assertEquals("Should have the correct text - Simple", "Remove table my_table", HumanReadableStatementHelper.generateRemoveTableString(table("my_table"))); } |
### Question:
HumanReadableStatementHelper { public static String generateRenameTableString(String from, String to) { StringBuilder renameTableBuilder = new StringBuilder(); renameTableBuilder.append(String.format("Rename table %s to %s", from, to)); return renameTableBuilder.toString(); } static String generateChangePrimaryKeyColumnsString(String tableName, List<String> oldPrimaryKeyColumns, List<String> newPrimaryKeyColumns); static String generateChangePrimaryKeyColumnsString(String tableName, List<String> newPrimaryKeyColumns); static String generateAddColumnString(final String tableName, final Column definition); static String generateAddColumnString(final String tableName, final Column definition, final FieldLiteral defaultValue); static String generateAddIndexString(final String tableName, final Index index); static String generateAddTableString(final Table definition); static String generateAddTableFromString(final Table definition, final SelectStatement selectStatement); static String generateAnalyseTableFromString(String tableName); static String generateRenameTableString(String from, String to); static String generateChangeColumnString(final String tableName, final Column fromDefinition, final Column toDefinition); static String generateChangeIndexString(final String tableName, final Index fromIndex, final Index toIndex); static String generateRenameIndexString(final String tableName, final String fromIndexName, final String toIndexName); static String generateRemoveColumnString(final String tableName, final Column definition); static String generateRemoveIndexString(final String tableName, final Index index); static String generateRemoveTableString(final Table table); static String generateDataUpgradeString(final Statement statement, final String preferredSQLDialect); }### Answer:
@Test public void testRenameTableGeneration() { assertEquals("Should have the correct text - Simple", "Rename table my_table to your_table", HumanReadableStatementHelper.generateRenameTableString("my_table", "your_table")); } |
### Question:
HumanReadableStatementHelper { public static String generateRenameIndexString(final String tableName, final String fromIndexName, final String toIndexName) { return String.format("Rename index %s on %s to %s", fromIndexName, tableName, toIndexName); } static String generateChangePrimaryKeyColumnsString(String tableName, List<String> oldPrimaryKeyColumns, List<String> newPrimaryKeyColumns); static String generateChangePrimaryKeyColumnsString(String tableName, List<String> newPrimaryKeyColumns); static String generateAddColumnString(final String tableName, final Column definition); static String generateAddColumnString(final String tableName, final Column definition, final FieldLiteral defaultValue); static String generateAddIndexString(final String tableName, final Index index); static String generateAddTableString(final Table definition); static String generateAddTableFromString(final Table definition, final SelectStatement selectStatement); static String generateAnalyseTableFromString(String tableName); static String generateRenameTableString(String from, String to); static String generateChangeColumnString(final String tableName, final Column fromDefinition, final Column toDefinition); static String generateChangeIndexString(final String tableName, final Index fromIndex, final Index toIndex); static String generateRenameIndexString(final String tableName, final String fromIndexName, final String toIndexName); static String generateRemoveColumnString(final String tableName, final Column definition); static String generateRemoveIndexString(final String tableName, final Index index); static String generateRemoveTableString(final Table table); static String generateDataUpgradeString(final Statement statement, final String preferredSQLDialect); }### Answer:
@Test public void testRenameIndexGeneration() { assertEquals("Should have the correct text - Simple", "Rename index SomeBadlyNamedTable_1 on SomeBadlyNamedTable to ABetterNamedTable_1", HumanReadableStatementHelper.generateRenameIndexString("SomeBadlyNamedTable", "SomeBadlyNamedTable_1", "ABetterNamedTable_1")); } |
### Question:
OracleMetaDataProvider implements Schema { @Override public Collection<String> tableNames() { return tableMap().keySet(); } OracleMetaDataProvider(Connection connection, String schemaName); @Override boolean isEmptyDatabase(); @Override boolean tableExists(String name); @Override Table getTable(String name); @Override Collection<String> tableNames(); @Override Collection<Table> tables(); @Override boolean viewExists(String name); @Override View getView(String name); @Override Collection<String> viewNames(); @Override Collection<View> views(); }### Answer:
@Test public void testIgnoreSystemTables() throws SQLException { final PreparedStatement statement = mock(PreparedStatement.class, RETURNS_SMART_NULLS); when(connection.prepareStatement(anyString())).thenReturn(statement); when(statement.executeQuery()).thenAnswer(new ReturnTablesMockResultSet(1)).thenAnswer(new ReturnTablesMockResultSet(8)); final Schema oracleMetaDataProvider = oracle.openSchema(connection, "TESTDATABASE", "TESTSCHEMA"); assertEquals("Table names", "[AREALTABLE]", oracleMetaDataProvider.tableNames().toString()); assertFalse("Table names", oracleMetaDataProvider.tableNames().toString().contains("DBMS")); } |
### Question:
RemoveIndex implements SchemaChange { @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); boolean foundIndex = false; List<String> indexes = new ArrayList<>(); for (Index index : original.indexes()) { if (index.getName().equalsIgnoreCase(indexToBeRemoved.getName())) { foundIndex = true; continue; } indexes.add(index.getName()); } if (!foundIndex) { throw new IllegalArgumentException("Cannot remove index [" + indexToBeRemoved.getName() + "] as it does not exist on table [" + tableName + "]"); } return new TableOverrideSchema(schema, new AlteredTable(original, null, null, indexes, null)); } RemoveIndex(String tableName, Index index); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); String getTableName(); Index getIndexToBeRemoved(); }### Answer:
@Test public void testRemovingIndex() { Schema testSchema = schema(appleTable); assertEquals("Pre upgrade index count", 1, testSchema.getTable("Apple").indexes().size()); Schema updatedSchema = removeIndex.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade index count", 0, resultTable.indexes().size()); }
@Test public void testRemovingNonExistantIndex() { Schema testSchema = schema(appleTable); try { removeIndex = new RemoveIndex("Apple", index("foo").unique().columns("bar")); removeIndex.apply(testSchema); fail("Should fail since column is not there"); } catch (Exception e) { } } |
### Question:
RemoveIndex implements SchemaChange { @Override public Schema reverse(Schema schema) { Table original = schema.getTable(tableName); List<String> indexes = new ArrayList<>(); for (Index index : original.indexes()) { indexes.add(index.getName()); } indexes.add(indexToBeRemoved.getName()); return new TableOverrideSchema(schema, new AlteredTable(original, null, null, indexes, Arrays.asList(new Index[] {indexToBeRemoved}))); } RemoveIndex(String tableName, Index index); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); String getTableName(); Index getIndexToBeRemoved(); }### Answer:
@Test public void testReverseRemovingIndex() { appleTable.indexes().remove(0); Schema testSchema = schema(appleTable); Schema downGradedSchema = removeIndex.reverse(testSchema); Table resultTable = downGradedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade index count", 1, resultTable.indexes().size()); } |
### Question:
RenameTable implements SchemaChange { public RenameTable(String oldTableName, String newTableName) { this.oldTableName = oldTableName; this.newTableName = newTableName; } RenameTable(String oldTableName, String newTableName); String getOldTableName(); String getNewTableName(); @Override Schema apply(Schema schema); @Override Schema reverse(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override void accept(SchemaChangeVisitor visitor); }### Answer:
@Test public void testRenameTable() { Schema testSchema = schema(appleTable); RenameTable renameTable = new RenameTable("Apple", "Pear"); Schema updatedSchema = renameTable.apply(testSchema); assertTrue("Rename should be applied", renameTable.isApplied(updatedSchema, MockConnectionResources.build())); Table resultTable = updatedSchema.getTable("Pear"); assertNotNull(resultTable); } |
### Question:
ByteArraySchema implements DeserializationSchema<byte[]>, SerializationSchema<byte[]> { @Override public TypeInformation<byte[]> getProducedType() { return PrimitiveArrayTypeInfo.BYTE_PRIMITIVE_ARRAY_TYPE_INFO; } @Override byte[] deserialize(byte[] message); @Override boolean isEndOfStream(byte[] nextElement); @Override byte[] serialize(byte[] element); @Override TypeInformation<byte[]> getProducedType(); }### Answer:
@Test public void testSerializability() throws Exception { final ByteArraySchema schema = new ByteArraySchema(); final ByteArraySchema copy = CommonTestUtils.createCopySerializable(schema); assertEquals(schema.getProducedType(), copy.getProducedType()); } |
### Question:
GeneralUtils { public static Locale getDefaultLocale(User user) { if (user != null && user.getUserProperties() != null && user.getUserProperties().containsKey(OpenmrsConstants.USER_PROPERTY_DEFAULT_LOCALE)) { String localeString = user.getUserProperty(OpenmrsConstants.USER_PROPERTY_DEFAULT_LOCALE); Locale locale = normalizeLocale(localeString); return locale; } return null; } static Locale getDefaultLocale(User user); static Locale normalizeLocale(String localeString); static PatientIdentifierType getPatientIdentifierType(String id); static PatientIdentifierType getPatientIdentifierType(String id, PatientService patientService); static boolean isValidUuidFormat(String uuid); static String getPersonAddressProperty(PersonAddress address, String property); static PatientIdentifier getPatientIdentifier(Patient patient, PatientIdentifierType patientIdentifierType, Location location); static boolean setPropertyIfDifferent(Object bean, String propertyName, Object newValue); static List<Patient> getLastViewedPatients(User user); static Date getCurrentDateIfNull(Date date); }### Answer:
@Test public void shouldGetDefaultLocaleForUser() { User user = new User(); user.setUserProperty(OpenmrsConstants.USER_PROPERTY_DEFAULT_LOCALE, "ht"); Assert.assertEquals("ht", GeneralUtils.getDefaultLocale(user).toString()); } |
### Question:
GeneralUtils { public static boolean setPropertyIfDifferent(Object bean, String propertyName, Object newValue) { try { Object currentValue = PropertyUtils.getProperty(bean, propertyName); if (OpenmrsUtil.nullSafeEquals(currentValue, newValue)) { return false; } else { PropertyUtils.setProperty(bean, propertyName, newValue); return true; } } catch (Exception ex) { throw new RuntimeException(ex); } } static Locale getDefaultLocale(User user); static Locale normalizeLocale(String localeString); static PatientIdentifierType getPatientIdentifierType(String id); static PatientIdentifierType getPatientIdentifierType(String id, PatientService patientService); static boolean isValidUuidFormat(String uuid); static String getPersonAddressProperty(PersonAddress address, String property); static PatientIdentifier getPatientIdentifier(Patient patient, PatientIdentifierType patientIdentifierType, Location location); static boolean setPropertyIfDifferent(Object bean, String propertyName, Object newValue); static List<Patient> getLastViewedPatients(User user); static Date getCurrentDateIfNull(Date date); }### Answer:
@Test public void setPropertyIfDifferent_shouldChangePropertyWhenDifferent() throws Exception { Date date = new Date(); Patient p = new Patient(); boolean changed = GeneralUtils.setPropertyIfDifferent(p, "birthdate", date); assertThat(changed, is(true)); assertThat(p.getBirthdate(), is(date)); }
@Test public void setPropertyIfDifferent_shouldNotChangePropertyWhenAlreadySet() throws Exception { Date date = new Date(); Patient p = new Patient(); p.setBirthdate(date); boolean changed = GeneralUtils.setPropertyIfDifferent(p, "birthdate", date); assertThat(changed, is(false)); assertThat(p.getBirthdate(), is(date)); } |
### Question:
DateMapper { public Date convertUTCToDate(String date) { if (!StringUtils.isBlank(date)) { try { DateFormat utcFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"); utcFormat.setTimeZone(TimeZone.getTimeZone("UTC")); return utcFormat.parse(date); } catch (ParseException e) { throw new RuntimeException("Date format needs to be in UTC format. Incorrect Date:" + date + ".", e); } } return null; } Date convertUTCToDate(String date); }### Answer:
@Test public void shouldConvertUTCformatToDate() throws Exception { String utcDateString = "2015-07-30T18:30:00.000Z"; SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd"); simpleDateFormat.setTimeZone(TimeZone.getTimeZone("IST")); Date actualDate = new DateMapper().convertUTCToDate(utcDateString); assertNotNull(actualDate); assertEquals("2015-07-31", simpleDateFormat.format(actualDate)); }
@Test(expected = RuntimeException.class) public void shouldThrowExceptionForWrongUTCformat() throws Exception { String utcDateString = "2015-07-30T11:00:00.000"; Date actualDate = new DateMapper().convertUTCToDate(utcDateString); } |
### Question:
ObservationMapper1_12 extends ObservationMapper { @Override public EncounterTransaction.Observation map(Obs obs) { EncounterTransaction.Observation observation = super.map(obs); observation.setFormNamespace(obs.getFormFieldNamespace()); observation.setFormFieldPath(obs.getFormFieldPath()); setInterpretationAndStatus(observation, obs); return observation; } @Autowired ObservationMapper1_12(ConceptMapper conceptMapper, DrugMapper drugMapper, UserMapper userMapper); @Override EncounterTransaction.Observation map(Obs obs); }### Answer:
@Test public void shouldMapObservationWithNumericValue(){ when(conceptDatatype.isNumeric()).thenReturn(true); Obs obs = obsBuilder.setFormField("form uuid", "formFieldPath").get(); EncounterTransaction.Observation observation = observationMapper.map(obs); assertEquals(observation.getFormNamespace(), "form uuid"); assertEquals(observation.getFormFieldPath(), "formFieldPath"); } |
### Question:
ObsMapper { public Obs getMatchingObservation(Set<Obs> existingObservations, String observationUuid) { if (existingObservations == null) return null; for (Obs obs : existingObservations) { if (StringUtils.equals(obs.getUuid(), observationUuid)) return obs; } return null; } @Autowired ObsMapper(ConceptService conceptService,
EmrApiProperties emrApiProperties,
ObsService obsService, OrderService orderService); Obs transformEtObs(Encounter encounter,Obs observation, EncounterTransaction.Observation observationData); Obs getMatchingObservation(Set<Obs> existingObservations, String observationUuid); }### Answer:
@Test public void shouldReturnMatchingObs() { Obs obs1 = new Obs(); obs1.setUuid("o1_uuid"); obs1.setConcept(newConcept(new ConceptDataTypeBuilder().numeric(), "numeric-concept-uuid")); Obs obs2 = new Obs(); obs2.setUuid("o2_uuid"); obs2.setConcept(newConcept(new ConceptDataTypeBuilder().numeric(), "numeric-concept-uuid")); Set<Obs> obsSet = Sets.newSet(obs1, obs2); Obs obs = this.obsMapper.getMatchingObservation(obsSet, "o2_uuid"); assertEquals(obs2, obs); } |
### Question:
DiagnosisMapper { public List<EncounterTransaction.Diagnosis> convert(List<Diagnosis> pastDiagnoses) { List<EncounterTransaction.Diagnosis> pastEncounterDiagnoses = new ArrayList<EncounterTransaction.Diagnosis>(); for (Diagnosis diagnosis : pastDiagnoses) { pastEncounterDiagnoses.add(convert(diagnosis)); } return pastEncounterDiagnoses; } EncounterTransaction.Diagnosis map(Obs obs, DiagnosisMetadata diagnosisMetadata); List<EncounterTransaction.Diagnosis> convert(List<Diagnosis> pastDiagnoses); EncounterTransaction.Diagnosis convert(Diagnosis diagnosis); }### Answer:
@Test public void shouldMapEmrapiDiagnosisToEncounterTransactionDiagnosis() throws Exception { DiagnosisMapper diagnosisMapper = new DiagnosisMapper(); Diagnosis diagnosis = new Diagnosis(); diagnosis.setCertainty(Diagnosis.Certainty.CONFIRMED); diagnosis.setOrder(Diagnosis.Order.PRIMARY); CodedOrFreeTextAnswer freeTextAnswer = new CodedOrFreeTextAnswer(); freeTextAnswer.setNonCodedAnswer("cold"); diagnosis.setDiagnosis(freeTextAnswer); Obs existingObs = new Obs(); existingObs.setEncounter(new Encounter()); existingObs.setComment("comment"); diagnosis.setExistingObs(existingObs); EncounterTransaction.Diagnosis etDiagnosis = diagnosisMapper.convert(diagnosis); assertEquals(Diagnosis.Certainty.CONFIRMED.toString(), etDiagnosis.getCertainty()); assertEquals(Diagnosis.Order.PRIMARY.toString(), etDiagnosis.getOrder()); assertEquals("cold", etDiagnosis.getFreeTextAnswer()); assertNull(etDiagnosis.getCodedAnswer()); assertEquals("comment", etDiagnosis.getComments()); } |
### Question:
EncounterProviderMapper { public void update(EncounterTransaction encounterTransaction, Set<EncounterProvider> encounterProviders) { Set<EncounterTransaction.Provider> providers = convert(encounterProviders); encounterTransaction.setProviders(providers); } void update(EncounterTransaction encounterTransaction, Set<EncounterProvider> encounterProviders); Set<EncounterTransaction.Provider> convert(Set<EncounterProvider> encounterProviders); }### Answer:
@Test public void shouldMapProviders(){ EncounterTransaction encounterTransaction = new EncounterTransaction(); Set<EncounterProvider> encounterProviders = new HashSet<EncounterProvider>(); EncounterProvider encounterProvider = new EncounterProviderBuilder().build(); encounterProviders.add(encounterProvider); encounterProviderMapper.update(encounterTransaction,encounterProviders); Set<EncounterTransaction.Provider> mappedProviders = encounterTransaction.getProviders(); assertThat(mappedProviders.size(), is(1)); EncounterTransaction.Provider provider = mappedProviders.iterator().next(); assertThat(provider.getName(), is(equalTo(encounterProvider.getProvider().getName()))); assertThat(provider.getEncounterRoleUuid(), is(equalTo(encounterProvider.getEncounterRole().getUuid()))); }
@Test public void shouldMapProvidersWithoutEncounterRole(){ EncounterTransaction encounterTransaction = new EncounterTransaction(); Set<EncounterProvider> encounterProviders = new HashSet<EncounterProvider>(); EncounterProvider encounterProvider = new EncounterProviderBuilder().build(); encounterProvider.setEncounterRole(null); encounterProviders.add(encounterProvider); encounterProviderMapper.update(encounterTransaction,encounterProviders); Set<EncounterTransaction.Provider> mappedProviders = encounterTransaction.getProviders(); assertThat(mappedProviders.size(), is(1)); EncounterTransaction.Provider provider = mappedProviders.iterator().next(); assertThat(provider.getName(), is(equalTo(encounterProvider.getProvider().getName()))); assertThat(provider.getEncounterRoleUuid(), is(nullValue())); } |
### Question:
EncounterDomainWrapper implements DomainWrapper { public boolean participatedInEncounter(User currentUser) { if (verifyIfUserIsTheCreatorOfEncounter(currentUser)) { return true; } else if (verifyIfUserIsOneOfTheProviders(currentUser)) { return true; } return false; } EncounterDomainWrapper(); @Deprecated // use DomainWrapperFactory EncounterDomainWrapper(Encounter encounter); Encounter getEncounter(); void setEncounter(Encounter encounter); Visit getVisit(); Location getLocation(); Date getEncounterDatetime(); int getEncounterId(); Form getForm(); Boolean getVoided(); Set<EncounterProvider> getEncounterProviders(); Provider getPrimaryProvider(); boolean participatedInEncounter(User currentUser); void closeVisit(); Map<EncounterRole, Set<Provider>> getProviders(); @Transactional void attachToVisit(VisitDomainWrapper visit); @Transactional void attachToVisit(Visit visit); static final Predicate NON_VOIDED_PREDICATE; static final Comparator<Encounter> DATETIME_COMPARATOR; }### Answer:
@Test public void shouldReturnTrueWhenTheCurrentUserCreatedTheEncounter(){ User currentUser = createUserWithUuid("585812f0-a860-11e2-9e96-0800200c9a66"); User encounterCreator = createUserWithUuid("585812f0-a860-11e2-9e96-0800200c9a66"); when(encounter.getCreator()).thenReturn(encounterCreator); assertTrue(encounterDomainWrapper.participatedInEncounter(currentUser)); } |
### Question:
OrderMapper1_12 implements OrderMapper { @Override public List<EncounterTransaction.Order> mapOrders(Encounter encounter) { List<EncounterTransaction.Order> orders = new ArrayList<EncounterTransaction.Order>(); for (Order order : encounter.getOrders()) { order = HibernateUtil.getRealObjectFromProxy(order); if (Order.class.equals(order.getClass())) { orders.add(mapOrder(order)); } } return orders; } @Override List<EncounterTransaction.DrugOrder> mapDrugOrders(Encounter encounter); @Override List<EncounterTransaction.Order> mapOrders(Encounter encounter); @Override EncounterTransaction.DrugOrder mapDrugOrder(DrugOrder openMRSDrugOrder); @Override EncounterTransaction.Order mapOrder(Order order); }### Answer:
@Test public void shouldMapMultipleOrders() throws NoSuchFieldException, IllegalAccessException { Order order100 = order("before meals", "boil in water", null, "ORD-100", ORDER_TYPE, "ROUTINE"); Order order201 = order("before meals", "boil in water", null, "ORD-201", ORDER_TYPE, "ROUTINE"); Order order350 = order("before meals", "boil in water", null, "ORD-350", ORDER_TYPE, "ROUTINE"); Encounter encounter = new Encounter(); encounter.setOrders(new HashSet<Order>(Arrays.asList(order350, order100, order201))); List<EncounterTransaction.Order> ordersList = orderMapper1_12.mapOrders(encounter); assertEquals(3, ordersList.size()); } |
### Question:
EmrVisitServiceImpl extends BaseOpenmrsService implements EmrVisitService { @Override public VisitResponse find(VisitRequest visitRequest) { Visit visit = visitService.getVisitByUuid(visitRequest.getVisitUuid()); if(visit == null) throw new VisitNotFoundException("Visit by uuid "+ visitRequest.getVisitUuid() + " does not exist"); return visitResponseMapper.map(visit); } EmrVisitServiceImpl(VisitService visitService, VisitResponseMapper visitResponseMapper); EmrVisitDAO getDao(); void setDao(EmrVisitDAO dao); @Override VisitResponse find(VisitRequest visitRequest); @Override List<Obs> getDiagnoses(Visit visit, DiagnosisMetadata diagnosisMetadata, Boolean primaryOnly, Boolean confirmedOnly); @Override List<Integer> getAllPatientsWithDiagnosis(DiagnosisMetadata diagnosisMetadata); }### Answer:
@Test public void shouldFindVisitByUuid() throws Exception { VisitRequest visitRequest = new VisitRequest(UUID.randomUUID().toString()); Visit visit = new Visit(); when(visitService.getVisitByUuid(visitRequest.getVisitUuid())).thenReturn(visit); VisitResponse visitResponse = new VisitResponse(visit.getUuid()); when(visitResponseMapper.map(visit)).thenReturn(visitResponse); VisitResponse visitResponseFromService = emrVisitService.find(visitRequest); assertEquals(visitResponse, visitResponseFromService); verify(visitService).getVisitByUuid(visitRequest.getVisitUuid()); }
@Test(expected = VisitNotFoundException.class) public void shouldRaiseExceptionForNonExistingVisit() throws Exception { VisitRequest visitRequest = new VisitRequest(UUID.randomUUID().toString()); when(visitService.getVisitByUuid(visitRequest.getVisitUuid())).thenReturn(null); emrVisitService.find(visitRequest); } |
### Question:
VisitResponseMapper { public VisitResponse map(Visit visit) { if(visit == null) return null; VisitResponse visitResponse = new VisitResponse(visit.getUuid()); for (Encounter encounter : visit.getEncounters()) { visitResponse.addEncounter(encounterTransactionMapper.map(encounter, true)); } return visitResponse; } VisitResponseMapper(EncounterTransactionMapper encounterTransactionMapper); VisitResponse map(Visit visit); }### Answer:
@Test public void testMapsVisit() throws Exception { Visit visit = new Visit(); visit.addEncounter(new Encounter()); VisitResponse visitResponse = visitResponseMapper.map(visit); Assert.assertEquals(visit.getUuid(), visitResponse.getVisitUuid()); Assert.assertEquals(visit.getEncounters().size(), visitResponse.getEncounters().size()); }
@Test public void testMapsNullVisitToNull() throws Exception { Assert.assertNull(visitResponseMapper.map(null)); } |
### Question:
OrderMetadataService { public Concept getDurationUnitsConceptByName(String conceptName) { List<Concept> durationUnits = orderService.getDurationUnits(); for (Concept durationUnit : durationUnits) { if(durationUnit.getName().getName().equals(conceptName)){ return durationUnit; } } return null; } @Autowired OrderMetadataService(OrderService orderService); Concept getDurationUnitsConceptByName(String conceptName); OrderFrequency getOrderFrequencyByName(String conceptName, boolean includeRetired); }### Answer:
@Test public void shouldGetDurationConceptByName() throws Exception { Concept days = createConcept(DAYS_CONCEPT_NAME); Concept weeks = createConcept(WEEKS_CONCEPT_NAME); when(orderService.getDurationUnits()).thenReturn(Arrays.asList(days, weeks)); Concept durationUnitsConcept = orderMetadataService.getDurationUnitsConceptByName(DAYS_CONCEPT_NAME); assertThat(durationUnitsConcept, is(days)); }
@Test public void shouldReturnNullIfDurationConceptDoesNotExist() throws Exception { when(orderService.getDurationUnits()).thenReturn(new ArrayList<Concept>()); Concept durationUnitsConcept = orderMetadataService.getDurationUnitsConceptByName(DAYS_CONCEPT_NAME); assertNull(durationUnitsConcept); }
@Test public void shouldReturnNullDurationUnitsForNullInput() { assertNull(orderMetadataService.getDurationUnitsConceptByName(null)); } |
### Question:
EmrPatientProfileServiceImpl implements EmrPatientProfileService { @Override public PatientProfile save(PatientProfile patientProfile) { Patient patient = patientService.savePatient(patientProfile.getPatient()); saveRelationships(patientProfile.getRelationships()); patientProfile.setPatient(patient); PersonImage personImage = new PersonImage(); personImage.setPerson(patient); personImage.setBase64EncodedImage(patientProfile.getImage()); emrPersonImageService.savePersonImage(personImage); return patientProfile; } @Override PatientProfile save(PatientProfile patientProfile); @Override PatientProfile get(String patientUuid); void setPatientService(PatientService patientService); void setPersonService(PersonService personService); void setEmrPersonImageService(EmrPersonImageService emrPersonImageService); }### Answer:
@Test public void shouldSavePatientProfile() throws Exception { PatientProfile patientProfile = emrPatientProfileService.save(constructPatientProfile()); assertNotNull(patientProfile); assertEquals(patientProfile.getRelationships().size(), 1); } |
### Question:
EmrPatientProfileServiceImpl implements EmrPatientProfileService { @Override public PatientProfile get(String patientUuid) { PatientProfile delegate = new PatientProfile(); Patient patient = patientService.getPatientByUuid(patientUuid); delegate.setPatient(patient); Person person = personService.getPerson(patient.getPersonId()); List<Relationship> relationships = personService.getRelationshipsByPerson(person); delegate.setRelationships(relationships); return delegate; } @Override PatientProfile save(PatientProfile patientProfile); @Override PatientProfile get(String patientUuid); void setPatientService(PatientService patientService); void setPersonService(PersonService personService); void setEmrPersonImageService(EmrPersonImageService emrPersonImageService); }### Answer:
@Test public void shouldGetPatientProfile() throws Exception { PatientProfile patientProfile = emrPatientProfileService.get("patient_uuid"); assertNotNull(patientProfile.getPatient()); assertEquals(patientProfile.getPatient().getUuid(), "patient_uuid"); assertEquals(patientProfile.getRelationships().size(), 1); } |
### Question:
OrderMetadataService { public OrderFrequency getOrderFrequencyByName(String conceptName, boolean includeRetired) { List<OrderFrequency> orderFrequencies = orderService.getOrderFrequencies(includeRetired); for (OrderFrequency orderFrequency : orderFrequencies) { if(orderFrequency.getName().equals(conceptName)){ return orderFrequency; } } return null; } @Autowired OrderMetadataService(OrderService orderService); Concept getDurationUnitsConceptByName(String conceptName); OrderFrequency getOrderFrequencyByName(String conceptName, boolean includeRetired); }### Answer:
@Test public void shouldGetOrderFrequencyByName() throws Exception { OrderFrequency onceADayOrderFrequency = new OrderFrequency(); onceADayOrderFrequency.setConcept(createConcept(ONCE_A_DAY_CONCEPT_NAME)); OrderFrequency twiceADayOrderFrequency = new OrderFrequency(); twiceADayOrderFrequency.setConcept(createConcept(TWICE_A_DAY_CONCEPT_NAME)); when(orderService.getOrderFrequencies(false)).thenReturn(Arrays.asList(onceADayOrderFrequency, twiceADayOrderFrequency)); OrderFrequency orderFrequency = orderMetadataService.getOrderFrequencyByName(ONCE_A_DAY_CONCEPT_NAME, false); assertThat(orderFrequency, is(onceADayOrderFrequency)); }
@Test public void shouldReturnNullIfOrderFrequencyNotPresent() throws Exception { when(orderService.getOrderFrequencies(false)).thenReturn(new ArrayList<OrderFrequency>()); OrderFrequency orderFrequency = orderMetadataService.getOrderFrequencyByName(ONCE_A_DAY_CONCEPT_NAME, false); assertNull(orderFrequency); }
@Test public void shouldReturnNullOrderFrequencyForNullInput() { assertNull(orderMetadataService.getOrderFrequencyByName(null, false)); } |
### Question:
DispositionDescriptor extends ConceptSetDescriptor { public boolean isDisposition(Obs obs) { return obs.getConcept().equals(dispositionSetConcept); } DispositionDescriptor(ConceptService conceptService); DispositionDescriptor(); Concept getDispositionSetConcept(); void setDispositionSetConcept(Concept dispositionSetConcept); Concept getDispositionConcept(); void setDispositionConcept(Concept dispositionConcept); Concept getAdmissionLocationConcept(); void setAdmissionLocationConcept(Concept admissionLocationConcept); Concept getInternalTransferLocationConcept(); void setInternalTransferLocationConcept(Concept internalTransferLocationConcept); Concept getDateOfDeathConcept(); void setDateOfDeathConcept(Concept dateOfDeathConcept); Obs buildObsGroup(Disposition disposition, EmrConceptService emrConceptService); boolean isDisposition(Obs obs); Obs getDispositionObs(Obs obsGroup); Obs getAdmissionLocationObs(Obs obsGroup); Obs getInternalTransferLocationObs(Obs obsGroup); Obs getDateOfDeathObs(Obs obsGroup); Location getAdmissionLocation(Obs obsGroup, LocationService locationService); Location getInternalTransferLocation(Obs obsGroup, LocationService locationService); Date getDateOfDeath(Obs obsGroup); List<Obs> getAdditionalObs(Obs obsGroup); }### Answer:
@Test public void shouldReturnTrueWhenPassedInDispositionObsGroup() { Obs dispositionSet = createDispositionObsGroup(); assertTrue(dispositionDescriptor.isDisposition(dispositionSet)); }
@Test public void shouldReturnFalseWhenPassedInNonDispositionObsGroup() { Obs notDispositionSet = new Obs(); Concept notDispositionConcept = new Concept(); notDispositionSet.setConcept(notDispositionConcept); assertFalse(dispositionDescriptor.isDisposition(notDispositionSet)); } |
### Question:
DispositionDescriptor extends ConceptSetDescriptor { public Obs getAdmissionLocationObs(Obs obsGroup) { return findMember(obsGroup, admissionLocationConcept); } DispositionDescriptor(ConceptService conceptService); DispositionDescriptor(); Concept getDispositionSetConcept(); void setDispositionSetConcept(Concept dispositionSetConcept); Concept getDispositionConcept(); void setDispositionConcept(Concept dispositionConcept); Concept getAdmissionLocationConcept(); void setAdmissionLocationConcept(Concept admissionLocationConcept); Concept getInternalTransferLocationConcept(); void setInternalTransferLocationConcept(Concept internalTransferLocationConcept); Concept getDateOfDeathConcept(); void setDateOfDeathConcept(Concept dateOfDeathConcept); Obs buildObsGroup(Disposition disposition, EmrConceptService emrConceptService); boolean isDisposition(Obs obs); Obs getDispositionObs(Obs obsGroup); Obs getAdmissionLocationObs(Obs obsGroup); Obs getInternalTransferLocationObs(Obs obsGroup); Obs getDateOfDeathObs(Obs obsGroup); Location getAdmissionLocation(Obs obsGroup, LocationService locationService); Location getInternalTransferLocation(Obs obsGroup, LocationService locationService); Date getDateOfDeath(Obs obsGroup); List<Obs> getAdditionalObs(Obs obsGroup); }### Answer:
@Test public void shouldFetchAdmissionLocationObsOffObsGroup() { Obs dispositionObsGroup = createDispositionObsGroup(); Obs admissionLocation = new Obs(); admissionLocation.setConcept(admissionLocationConcept); dispositionObsGroup.addGroupMember(admissionLocation); assertThat(dispositionDescriptor.getAdmissionLocationObs(dispositionObsGroup), is(admissionLocation)); }
@Test public void shouldNotFailIfNoMatchingObsWhenFetchingAdmissionLocationObs() { Obs dispositionObsGroup = createDispositionObsGroup(); assertNull(dispositionDescriptor.getAdmissionLocationObs(dispositionObsGroup)); } |
### Question:
DispositionDescriptor extends ConceptSetDescriptor { public Obs getInternalTransferLocationObs(Obs obsGroup) { return findMember(obsGroup, internalTransferLocationConcept); } DispositionDescriptor(ConceptService conceptService); DispositionDescriptor(); Concept getDispositionSetConcept(); void setDispositionSetConcept(Concept dispositionSetConcept); Concept getDispositionConcept(); void setDispositionConcept(Concept dispositionConcept); Concept getAdmissionLocationConcept(); void setAdmissionLocationConcept(Concept admissionLocationConcept); Concept getInternalTransferLocationConcept(); void setInternalTransferLocationConcept(Concept internalTransferLocationConcept); Concept getDateOfDeathConcept(); void setDateOfDeathConcept(Concept dateOfDeathConcept); Obs buildObsGroup(Disposition disposition, EmrConceptService emrConceptService); boolean isDisposition(Obs obs); Obs getDispositionObs(Obs obsGroup); Obs getAdmissionLocationObs(Obs obsGroup); Obs getInternalTransferLocationObs(Obs obsGroup); Obs getDateOfDeathObs(Obs obsGroup); Location getAdmissionLocation(Obs obsGroup, LocationService locationService); Location getInternalTransferLocation(Obs obsGroup, LocationService locationService); Date getDateOfDeath(Obs obsGroup); List<Obs> getAdditionalObs(Obs obsGroup); }### Answer:
@Test public void shouldFetchTransferLocationObsOffObsGroup() { Obs dispositionObsGroup = createDispositionObsGroup(); Obs transferLocation = new Obs(); transferLocation.setConcept(transferLocationConcept); dispositionObsGroup.addGroupMember(transferLocation); assertThat(dispositionDescriptor.getInternalTransferLocationObs(dispositionObsGroup), is(transferLocation)); }
@Test public void shouldNotFailIfNoMatchingObsWhenFetchingTransferLocationOffObsGroup() { Obs dispositionObsGroup = createDispositionObsGroup(); assertNull(dispositionDescriptor.getInternalTransferLocationObs(dispositionObsGroup)); } |
### Question:
DispositionDescriptor extends ConceptSetDescriptor { public Obs getDateOfDeathObs(Obs obsGroup) { return findMember(obsGroup, dateOfDeathConcept); } DispositionDescriptor(ConceptService conceptService); DispositionDescriptor(); Concept getDispositionSetConcept(); void setDispositionSetConcept(Concept dispositionSetConcept); Concept getDispositionConcept(); void setDispositionConcept(Concept dispositionConcept); Concept getAdmissionLocationConcept(); void setAdmissionLocationConcept(Concept admissionLocationConcept); Concept getInternalTransferLocationConcept(); void setInternalTransferLocationConcept(Concept internalTransferLocationConcept); Concept getDateOfDeathConcept(); void setDateOfDeathConcept(Concept dateOfDeathConcept); Obs buildObsGroup(Disposition disposition, EmrConceptService emrConceptService); boolean isDisposition(Obs obs); Obs getDispositionObs(Obs obsGroup); Obs getAdmissionLocationObs(Obs obsGroup); Obs getInternalTransferLocationObs(Obs obsGroup); Obs getDateOfDeathObs(Obs obsGroup); Location getAdmissionLocation(Obs obsGroup, LocationService locationService); Location getInternalTransferLocation(Obs obsGroup, LocationService locationService); Date getDateOfDeath(Obs obsGroup); List<Obs> getAdditionalObs(Obs obsGroup); }### Answer:
@Test public void shouldFetchDateOfDeathObsOffObsGroup() { Obs dispositionObsGroup = createDispositionObsGroup(); Obs dateOfDeath = new Obs(); dateOfDeath.setConcept(dateOfDeathConcept); dispositionObsGroup.addGroupMember(dateOfDeath); assertThat(dispositionDescriptor.getDateOfDeathObs(dispositionObsGroup), is(dateOfDeath)); }
@Test public void shouldNotFailIfNoMatchingObsWhenDateOfDeath() { Obs dispositionObsGroup = createDispositionObsGroup(); assertNull(dispositionDescriptor.getDateOfDeathObs(dispositionObsGroup)); } |
### Question:
NoteFrequencyCalculator { public double getFrequency(Note note) { int semitonesPerOctave = 12; int referenceOctave = 4; double distance = semitonesPerOctave * (note.getOctave() - referenceOctave); distance += notes.indexOf(note.getName() + note.getSign()) - notes.indexOf("A"); return referenceFrequency * Math.pow(2, distance / 12); } NoteFrequencyCalculator(float referenceFrequency); double getFrequency(Note note); }### Answer:
@Test public void TestCalc() { InputStream resourceAsStream = getClass().getResourceAsStream("note_frequencies.csv"); try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceAsStream))) { while (reader.ready()) { String line = reader.readLine(); String[] components = line.split(","); String noteWithOctave = components[0].split("/")[0]; String frequency = components[1]; String noteName = noteWithOctave.substring(0, 1); String octave = noteWithOctave.substring(1); String sign = ""; if (noteWithOctave.contains("#")) { noteName = noteWithOctave.substring(0, 1); octave = noteWithOctave.substring(2); sign = "#"; } String finalNoteName = noteName; String finalOctave = octave; String finalSign = sign; Note note = new Note() { @Override public NoteName getName() { return NoteName.fromScientificName(finalNoteName); } @Override public int getOctave() { return Integer.parseInt(finalOctave); } @Override public String getSign() { return finalSign; } }; NoteFrequencyCalculator noteFrequencyCalculator = new NoteFrequencyCalculator(440); double expectedFrequency = Double.parseDouble(frequency); double actualFrequency = noteFrequencyCalculator.getFrequency(note); Assert.assertEquals(expectedFrequency, actualFrequency, 0.01); } } catch (IOException e) { Assert.fail(e.getMessage()); } } |
### Question:
Sampler { static PitchDifference calculateAverageDifference(List<PitchDifference> samples) { Note mostFrequentNote = extractMostFrequentNote(samples); List<PitchDifference> filteredSamples = filterByNote(samples, mostFrequentNote); double deviationSum = 0; int sameNoteCount = 0; for (PitchDifference pitchDifference : filteredSamples) { deviationSum += pitchDifference.deviation; sameNoteCount++; } if (sameNoteCount > 0) { double averageDeviation = deviationSum / sameNoteCount; return new PitchDifference(mostFrequentNote, averageDeviation); } return null; } }### Answer:
@Test public void the_average_difference_is_calculated_correctly() { List<PitchDifference> samples = new ArrayList<>(); samples.add(new PitchDifference(E2, 2.46D)); samples.add(new PitchDifference(E2, -10.3D)); samples.add(new PitchDifference(E2, 5.71D)); samples.add(new PitchDifference(E2, 12.532D)); samples.add(new PitchDifference(E2, -0.414D)); PitchDifference pitchDifference = calculateAverageDifference(samples); double average = (2.46D - 10.3D + 5.71D + 12.532D - 0.414D) / 5D; assertNotNull(pitchDifference); assertThat(pitchDifference.closest.getName(), is(E2.getName())); assertThat(pitchDifference.deviation, closeTo(average, 0.001)); } |
### Question:
Sampler { static List<PitchDifference> filterByNote(List<PitchDifference> samples, Note note) { List<PitchDifference> filteredSamples = new ArrayList<>(); for (PitchDifference sample : samples) { if (sample.closest == note) { filteredSamples.add(sample); } } return filteredSamples; } }### Answer:
@Test public void samples_are_filtered_correctly() { List<PitchDifference> samples = new ArrayList<>(); samples.add(new PitchDifference(E2, 2D)); samples.add(new PitchDifference(E2, 2D)); samples.add(new PitchDifference(B3, 3D)); samples.add(new PitchDifference(E2, 2D)); samples.add(new PitchDifference(G3, 4D)); samples.add(new PitchDifference(B3, 3D)); List<PitchDifference> filteredSamples = filterByNote(samples, B3); for (PitchDifference sample : filteredSamples) { assertThat(sample.closest.getName(), is(B3.getName())); } } |
### Question:
FormatService { public static SerializationFormat getInputFormat(String name) { for (SerializationFormat ft : Instance.serializationFormats) { if (ft.isAcceptedAsInput(name)) { return ft; } } return null; } private FormatService(); static SerializationFormat getInputFormat(String name); static SerializationFormat getOutputFormat(String name); static String getFormatFromExtension(String filename); }### Answer:
@Test public void testGetInputFormat() { assertEquals(FormatService.getInputFormat("turtle"), SerializationFormatFactory.createTurtle()); assertEquals(FormatService.getInputFormat("ttl"), SerializationFormatFactory.createTurtle()); assertEquals(FormatService.getInputFormat("ntriples"), SerializationFormatFactory.createNTriples()); assertEquals(FormatService.getInputFormat("N-Triple"), SerializationFormatFactory.createNTriples()); assertEquals(FormatService.getInputFormat("n3"), SerializationFormatFactory.createN3()); assertEquals(FormatService.getInputFormat("RDF/XML"), SerializationFormatFactory.createRDFXMLIn()); assertEquals(FormatService.getInputFormat("rdfxml"), SerializationFormatFactory.createRDFXMLIn()); assertEquals(FormatService.getInputFormat("RDF/XML-ABBREV"), SerializationFormatFactory.createRDFXMLIn()); assertEquals(FormatService.getInputFormat("RDFA"), SerializationFormatFactory.createRDFa()); } |
### Question:
RDFUnitUtils { public static void fillSchemaServiceFromLOV() throws IOException { log.info("Loading cached schema entries from LOV!"); RDFUnitUtils.fillSchemaServiceFromResource("org/aksw/rdfunit/configuration/schemaLOV.csv"); } private RDFUnitUtils(); static void fillSchemaServiceFromFile(String additionalCSV); static void fillSchemaServiceWithStandardVocabularies(); static void fillSchemaServiceFromSchemaDecl(); static void fillSchemaServiceFromLOV(); static Optional<T> getFirstItemInCollection(Collection<T> collection); static List<SchemaSource> augmentWithOwlImports(Set<SchemaSource> originalSources); }### Answer:
@Test public void fillSchemaServiceFromLOVTest() throws IOException { int currentSize = SchemaService.getSize(); RDFUnitUtils.fillSchemaServiceFromLOV(); assertThat(SchemaService.getSize()) .isGreaterThan(currentSize); } |
### Question:
RDFUnitUtils { public static void fillSchemaServiceFromSchemaDecl() throws IOException { log.info("Adding manual schema entries (or overriding LOV)!"); RDFUnitUtils.fillSchemaServiceFromResource("org/aksw/rdfunit/configuration/schemaDecl.csv"); } private RDFUnitUtils(); static void fillSchemaServiceFromFile(String additionalCSV); static void fillSchemaServiceWithStandardVocabularies(); static void fillSchemaServiceFromSchemaDecl(); static void fillSchemaServiceFromLOV(); static Optional<T> getFirstItemInCollection(Collection<T> collection); static List<SchemaSource> augmentWithOwlImports(Set<SchemaSource> originalSources); }### Answer:
@Test public void fillSchemaServiceFromDeclTest() throws IOException { int currentSize = SchemaService.getSize(); RDFUnitUtils.fillSchemaServiceFromSchemaDecl(); assertThat(SchemaService.getSize()) .isGreaterThan(currentSize); } |
### Question:
RDFUnitStaticValidator { public static TestExecution validate(final Model inputModel) throws Exception { return validate(inputModel, TestCaseExecutionType.shaclTestCaseResult); } private RDFUnitStaticValidator(); static void initWrapper(@NonNull RDFUnitTestSuiteGenerator testSuiteGenerator); static TestSuite getTestSuite(); static TestExecution validate(final Model inputModel); static TestExecution validate(final Model inputModel, final TestCaseExecutionType executionType); static TestExecution validate(final Model inputModel, final String inputURI); static TestExecution validate(final Model inputModel, final TestCaseExecutionType executionType, final String inputURI); static TestExecution validate(final Model inputModel, final TestCaseExecutionType executionType, final String inputURI, DatasetOverviewResults overviewResults); static TestExecution validate(final TestCaseExecutionType testCaseExecutionType, final Model model, final TestSuite testSuite); static TestExecution validate(final TestCaseExecutionType testCaseExecutionType, final TestSource testSource, final TestSuite testSuite); static TestExecution validate(final TestCaseExecutionType testCaseExecutionType, final TestSource testSource, final TestSuite testSuite, DatasetOverviewResults overviewResults); static TestExecution validate(final TestCaseExecutionType testCaseExecutionType, final TestSource testSource, final TestSuite testSuite, final String agentID, DatasetOverviewResults overviewResults); }### Answer:
@Test public void testValidateModel() throws Exception { RDFUnitStaticValidator.validate(ModelFactory.createDefaultModel(), testCaseExecutionType); } |
### Question:
PrefixNSService { public static String getNSFromPrefix(final String prefix) { return MapInstance.prefixNsBidiMap.get(prefix); } private PrefixNSService(); static String getNSFromPrefix(final String prefix); static String getPrefixFromNS(final String namespace); static void setNSPrefixesInModel(Model model); static String getSparqlPrefixDecl(); static String getURIFromAbbrev(final String abbreviation); static String getLocalName(final String uri, final String prefix); }### Answer:
@Test public void testGetPrefix() throws IOException { Model prefixModel = ModelFactory.createDefaultModel(); try (InputStream is = org.aksw.rdfunit.services.PrefixNSService.class.getResourceAsStream(Resources.PREFIXES)) { prefixModel.read(is, null, "TURTLE"); } Map<String, String> prefixes = prefixModel.getNsPrefixMap(); for (Map.Entry<String, String> entry : prefixes.entrySet()) { String uri = org.aksw.rdfunit.services.PrefixNSService.getNSFromPrefix(entry.getKey()); Assert.assertEquals("All prefixed should be initialized", uri, entry.getValue()); } } |
### Question:
PatternWriter implements ElementWriter { @Override public Resource write(Model model) { Resource resource = ElementWriter.copyElementResourceInModel(pattern, model); resource .addProperty(RDF.type, RDFUNITv.Pattern) .addProperty(DCTerms.identifier, pattern.getId()) .addProperty(DCTerms.description, pattern.getDescription()) .addProperty(RDFUNITv.sparqlWherePattern, pattern.getSparqlWherePattern()); if (pattern.getSparqlPatternPrevalence().isPresent()) { resource.addProperty(RDFUNITv.sparqlPrevalencePattern, pattern.getSparqlPatternPrevalence().get()); } for (PatternParameter patternParameter: pattern.getParameters()) { Resource parameter = PatternParameterWriter.create(patternParameter).write(model); resource.addProperty(RDFUNITv.parameter, parameter); } for (ResultAnnotation resultAnnotation: pattern.getResultAnnotations()) { Resource annotationResource = ResultAnnotationWriter.create(resultAnnotation).write(model); resource.addProperty(RDFUNITv.resultAnnotation, annotationResource); } return resource; } private PatternWriter(Pattern pattern); static PatternWriter create(Pattern pattern); @Override Resource write(Model model); }### Answer:
@Test public void testWrite() throws RdfReaderException, RdfWriterException { Model inputModel = RdfReaderFactory.createResourceReader(Resources.PATTERNS).read(); Collection<Pattern> patterns = BatchPatternReader.create().getPatternsFromModel(inputModel); Model outputModel = ModelFactory.createDefaultModel(); for (Pattern pattern: patterns) { PatternWriter.create(pattern).write(outputModel); } assertThat(inputModel.isIsomorphicWith(outputModel)).isTrue(); } |
### Question:
ShaclModel { public Set<GenericTestCase> generateTestCases() { return allShapeGroup.stream().flatMap(groupShape -> getGenericTestCase(groupShape).values().stream().flatMap(Collection::stream)).collect(Collectors.toSet()); } ShaclModel(Model inputShaclGraph); Set<GenericTestCase> generateTestCases(); }### Answer:
@Test public void testRead() throws RdfReaderException { ShaclModel shaclModel = new ShaclModel(RdfReaderFactory.createResourceReader(shapeResource).read()); Set<GenericTestCase> tests = shaclModel.generateTestCases(); assertThat(tests) .isNotEmpty(); } |
### Question:
ShapeReader implements ElementReader<Shape> { @Override public Shape read(Resource resource) { checkNotNull(resource); ShapeImpl.ShapeImplBuilder shapeBuilder = ShapeImpl.builder(); shapeBuilder .element(resource) .propertyValuePairSets(PropertyValuePairSet.createFromResource(resource)); Resource path = resource.getPropertyResourceValue(SHACL.path); if (path != null) { shapeBuilder.shaclPath( ShapePathReader.create().read(path) ); } return shapeBuilder.build(); } private ShapeReader(); static ShapeReader create(); @Override Shape read(Resource resource); }### Answer:
@Test public void testRead() throws RdfReaderException { Model shapesModel = RdfReaderFactory.createResourceReader(shapeResource).read(); List<Shape> shapes = shapesModel.listResourcesWithProperty(RDF.type, SHACL.Shape).toList() .stream() .map( r -> ShapeReader.create().read(r)) .collect(Collectors.toList()); assertThat(shapes) .hasSize(1); Shape sh = shapes.get(0); checkTarget(sh); } |
### Question:
ComponentReader implements ElementReader<Component> { @Override public Component read(Resource resource) { checkNotNull(resource); ComponentImpl.ComponentImplBuilder componentBuilder = ComponentImpl.builder(); componentBuilder.element(resource); for (Statement smt : resource.listProperties(SHACL.parameter).toList()) { Resource obj = smt.getObject().asResource(); ComponentParameter cp = ComponentParameterReader.create().read(obj); componentBuilder.parameter(cp); } for (Statement smt : resource.listProperties(SHACL.validator).toList()) { Resource obj = smt.getObject().asResource(); ComponentValidator cv = ComponentValidatorReader.create(ComponentValidatorType.ASK_VALIDATOR).read(obj); componentBuilder.validator(cv); } for (Statement smt : resource.listProperties(SHACL.nodeValidator).toList()) { Resource obj = smt.getObject().asResource(); ComponentValidator cv = ComponentValidatorReader.create(ComponentValidatorType.NODE_VALIDATOR).read(obj); componentBuilder.validator(cv); } for (Statement smt : resource.listProperties(SHACL.propertyValidator).toList()) { Resource obj = smt.getObject().asResource(); ComponentValidator cv = ComponentValidatorReader.create(ComponentValidatorType.PROPERTY_VALIDATOR).read(obj); componentBuilder.validator(cv); } return componentBuilder.build(); } private ComponentReader(); static ComponentReader create(); @Override Component read(Resource resource); }### Answer:
@Test public void testRead() { Component c = ComponentReader.create().read(resource); int i = 0; } |
### Question:
SparqlValidatorReader implements ElementReader<Validator> { @Override public Validator read(Resource resource) { checkNotNull(resource); SparqlValidatorImpl.SparqlValidatorImplBuilder validatorBuilder = SparqlValidatorImpl.builder(); validatorBuilder.element(resource); for (Statement smt : resource.listProperties(SHACL.message).toList()) { validatorBuilder.message(smt.getObject().asLiteral()); } for (Statement smt : resource.listProperties(SHACL.prefixes).toList()) { RDFNode obj = smt.getObject(); if (obj.isResource()) { validatorBuilder.prefixDeclarations(BatchPrefixDeclarationReader.create().getPrefixDeclarations(obj.asResource())); } } for (Statement smt : resource.listProperties(SHACL.select).toList()) { validatorBuilder.sparqlQuery(smt.getObject().asLiteral().getLexicalForm()); } return validatorBuilder.build(); } private SparqlValidatorReader(); static SparqlValidatorReader create(); @Override Validator read(Resource resource); }### Answer:
@Test public void testRead() { SparqlValidatorReader.create().read(resource); } |
### Question:
FormatService { public static SerializationFormat getOutputFormat(String name) { for (SerializationFormat ft : Instance.serializationFormats) { if (ft.isAcceptedAsOutput(name)) { return ft; } } return null; } private FormatService(); static SerializationFormat getInputFormat(String name); static SerializationFormat getOutputFormat(String name); static String getFormatFromExtension(String filename); }### Answer:
@Test public void testGetOutputFormat() { assertEquals(FormatService.getOutputFormat("turtle"), SerializationFormatFactory.createTurtle()); assertEquals(FormatService.getOutputFormat("ttl"), SerializationFormatFactory.createTurtle()); assertEquals(FormatService.getOutputFormat("ntriples"), SerializationFormatFactory.createNTriples()); assertEquals(FormatService.getOutputFormat("N-Triple"), SerializationFormatFactory.createNTriples()); assertEquals(FormatService.getOutputFormat("n3"), SerializationFormatFactory.createN3()); assertEquals(FormatService.getOutputFormat("RDF/XML"), SerializationFormatFactory.createRDFXMLOut()); assertEquals(FormatService.getOutputFormat("rdfxml"), SerializationFormatFactory.createRDFXMLOut()); assertEquals(FormatService.getOutputFormat("RDF/XML-ABBREV"), SerializationFormatFactory.createRDFXMLAbbrevOut()); } |
### Question:
ShapePathReader implements ElementReader<ShapePath> { @Override public ShapePath read(Resource resource) { checkNotNull(resource); ShapePathImpl.ShapePathImplBuilder shapePathBuilder = ShapePathImpl.builder(); shapePathBuilder.element(resource); shapePathBuilder.jenaPath(readPath(resource)); return shapePathBuilder.build(); } private ShapePathReader(); static ShapePathReader create(); @Override ShapePath read(Resource resource); }### Answer:
@Test public void testRead() { assertThat(ShapePathReader.create().read(shaclPath).asSparqlPropertyPath()) .isEqualTo(propertyPathString); } |
### Question:
ComponentValidatorReader implements ElementReader<ComponentValidator> { @Override public ComponentValidator read(Resource resource) { checkNotNull(resource); ComponentValidatorImpl.ComponentValidatorImplBuilder validatorBuilder = ComponentValidatorImpl.builder(); validatorBuilder.element(resource); validatorBuilder.type(type); for (Statement smt : resource.listProperties(SHACL.message).toList()) { validatorBuilder.message(smt.getObject().asLiteral()); } for (Statement smt : resource.listProperties(SHACL.prefixes).toList()) { RDFNode obj = smt.getObject(); if (obj.isResource()) { validatorBuilder.prefixDeclarations(BatchPrefixDeclarationReader.create().getPrefixDeclarations(obj.asResource())); } } for (Statement smt : resource.listProperties(SHACL.ask).toList()) { checkArgument(type.equals(ComponentValidatorType.ASK_VALIDATOR), "SPARQL SELECT-Based Validator contains ASK query: %s", smt.getObject().asLiteral().getLexicalForm()); validatorBuilder.sparqlQuery(smt.getObject().asLiteral().getLexicalForm()); } for (Statement smt : resource.listProperties(SHACL.select).toList()) { checkArgument(!type.equals(ComponentValidatorType.ASK_VALIDATOR), "SPARQL ASK-Based Validator contains SELECT query %s", smt.getObject().asLiteral().getLexicalForm()); validatorBuilder.sparqlQuery(smt.getObject().asLiteral().getLexicalForm()); } for (Statement smt : resource.listProperties(RDFUNIT_SHACL_EXT.filter).toList()) { validatorBuilder.filter(smt.getObject().asLiteral().getLexicalForm()); } return validatorBuilder.build(); } private ComponentValidatorReader(ComponentValidatorType type); static ComponentValidatorReader create(ComponentValidatorType type); @Override ComponentValidator read(Resource resource); }### Answer:
@Test public void testRead() { ComponentValidatorReader.create(ComponentValidatorType.ASK_VALIDATOR).read(resource); } |
### Question:
ComponentParameterReader implements ElementReader<ComponentParameter> { @Override public ComponentParameter read(Resource resource) { checkNotNull(resource); ComponentParameterImpl.ComponentParameterImplBuilder argumentBuilder = ComponentParameterImpl.builder(); argumentBuilder.element(resource); for (Statement smt : resource.listProperties(SHACL.path).toList()) { argumentBuilder = argumentBuilder.predicate(ResourceFactory.createProperty(smt.getObject().asResource().getURI())); } checkNotNull(argumentBuilder); for (Statement smt : resource.listProperties(SHACL.defaultValue).toList()) { argumentBuilder.defaultValue(smt.getObject()); } for (Statement smt : resource.listProperties(SHACL.optional).toList()) { argumentBuilder.isOptional(smt.getObject().asLiteral().getBoolean()); } return argumentBuilder.build(); } private ComponentParameterReader(); static ComponentParameterReader create(); @Override ComponentParameter read(Resource resource); }### Answer:
@Test public void testRead() { ComponentParameterReader.create().read(resource); } |
### Question:
BatchShapeTargetReader { public Set<ShapeTarget> read(Resource resource) { checkNotNull(resource); ImmutableSet.Builder<ShapeTarget> targetBuilder = ImmutableSet.builder(); targetBuilder.addAll(collectExplicitTargets(resource)); return targetBuilder.build(); } private BatchShapeTargetReader(); static BatchShapeTargetReader create(); Set<ShapeTarget> read(Resource resource); }### Answer:
@Test public void testRead() throws RdfReaderException { Model shapesModel = RdfReaderFactory.createResourceReader(shapeResource).read(); Resource r1 = shapesModel.getResource("http: Set<ShapeTarget> targets1 = BatchShapeTargetReader.create().read(r1); assertThat(targets1) .hasSize(2); } |
### Question:
PatternParameterReader implements ElementReader<PatternParameter> { @Override public PatternParameter read(Resource resource) { checkNotNull(resource); PatternParameterImpl.Builder parameterBuilder = new PatternParameterImpl.Builder(); parameterBuilder.setElement(resource); for (Statement smt : resource.listProperties(DCTerms.identifier).toList()) { parameterBuilder.setID(smt.getObject().asLiteral().getLexicalForm()); } for (Statement smt : resource.listProperties(RDFUNITv.parameterConstraint).toList()) { parameterBuilder.setPatternParameterConstraints(smt.getObject().asResource().getURI()); } for (Statement smt : resource.listProperties(RDFUNITv.constraintPattern).toList()) { parameterBuilder.setConstraintPattern(smt.getObject().asLiteral().getLexicalForm()); } return parameterBuilder.build(); } private PatternParameterReader(); static PatternParameterReader create(); @Override PatternParameter read(Resource resource); }### Answer:
@Test public void testRead() { PatternParameterReader.create().read(resource); } |
### Question:
SelectVar { public static SelectVar create(String name) { return new SelectVar(name, name); } static SelectVar create(String name); static SelectVar create(String name, String label); String asString(); }### Answer:
@Test public void testCreate() { String varName = "test"; SelectVar selectVar = SelectVar.create(varName); assertThat(selectVar.getName()) .isEqualTo(varName); assertThat(selectVar.getLabel()) .isEqualTo(varName); assertThat(selectVar.asString()) .isEqualTo(" ?" + varName + " "); }
@Test(expected=NullPointerException.class) public void testNull() { SelectVar.create(null); } |
### Question:
AnnotationTemplate { public void addTemplateMin(Property property, int minOccurs) { template.put(property, Range.atLeast(minOccurs)); } private AnnotationTemplate(); static AnnotationTemplate create(); void addTemplateMin(Property property, int minOccurs); void addTemplateMax(Property property, int maxOccurs); void addTemplateMinMax(Property property, int minOccurs, int maxOccurs); Set<Property> getPropertiesAsSet(); boolean existsInTemplate(PropertyValuePair propertyValuePair); boolean isValidAccordingToTemplate(PropertyValuePair propertyValuePair); }### Answer:
@Test public void testAddTemplateMin() { AnnotationTemplate at = AnnotationTemplate.create(); assertThat(at.existsInTemplate(sa1)).isFalse(); at.addTemplateMin(RDF.type, 2); assertThat(at.existsInTemplate(sa1)).isTrue(); assertThat(at.isValidAccordingToTemplate(sa1)).isFalse(); assertThat(at.existsInTemplate(sa2)).isFalse(); at.addTemplateMin(RDF.predicate, 2); assertThat(at.existsInTemplate(sa2)).isTrue(); assertThat(at.isValidAccordingToTemplate(sa2)).isTrue(); } |
### Question:
AnnotationTemplate { public void addTemplateMax(Property property, int maxOccurs) { template.put(property, Range.atMost(maxOccurs)); } private AnnotationTemplate(); static AnnotationTemplate create(); void addTemplateMin(Property property, int minOccurs); void addTemplateMax(Property property, int maxOccurs); void addTemplateMinMax(Property property, int minOccurs, int maxOccurs); Set<Property> getPropertiesAsSet(); boolean existsInTemplate(PropertyValuePair propertyValuePair); boolean isValidAccordingToTemplate(PropertyValuePair propertyValuePair); }### Answer:
@Test public void testAddTemplateMax() { AnnotationTemplate at = AnnotationTemplate.create(); assertThat(at.existsInTemplate(sa1)).isFalse(); at.addTemplateMax(RDF.type, 1); assertThat(at.existsInTemplate(sa1)).isTrue(); assertThat(at.isValidAccordingToTemplate(sa1)).isTrue(); assertThat(at.existsInTemplate(sa2)).isFalse(); assertThat(at.isValidAccordingToTemplate(sa2)).isFalse(); at.addTemplateMax(RDF.predicate, 1); assertThat(at.existsInTemplate(sa2)).isTrue(); assertThat(at.isValidAccordingToTemplate(sa2)).isFalse(); } |
### Question:
FormatService { public static String getFormatFromExtension(String filename) { String format = "TURTLE"; try { String extension; Lang jenaLang = RDFLanguages.filenameToLang(filename); if (jenaLang != null) { extension = jenaLang.getFileExtensions().get(0); } else { int index = filename.lastIndexOf('.'); extension = filename.substring(index + 1, filename.length()); } SerializationFormat f = FormatService.getInputFormat(extension); if (f != null) { format = f.getName(); } } catch (Exception e) { log.debug("No format found, using the default one", e); return "TURTLE"; } return format; } private FormatService(); static SerializationFormat getInputFormat(String name); static SerializationFormat getOutputFormat(String name); static String getFormatFromExtension(String filename); }### Answer:
@Test public void testGetFormatFromExtension() { Map<String, String> testVals = new HashMap<>(); testVals.put("asdf.ttl", "TURTLE"); testVals.put("asdf.nt", "N-TRIPLE"); testVals.put("asdf.n3", "N3"); testVals.put("asdf.jsonld", "JSON-LD"); testVals.put("asdf.rj", "RDF/JSON"); testVals.put("asdf.rdf", "RDF/XML"); testVals.put("asdf.nq", "NQuads"); testVals.put("asdf.trix", "TriX"); testVals.put("asdf.trig", "TriG"); testVals.put("asdf.html", "RDFA"); for (Map.Entry<String, String> entry: testVals.entrySet()) { assertEquals("Should be equal", entry.getValue(), FormatService.getFormatFromExtension(entry.getKey())); } } |
### Question:
AnnotationTemplate { public void addTemplateMinMax(Property property, int minOccurs, int maxOccurs) { template.put(property, Range.closed(minOccurs, maxOccurs)); } private AnnotationTemplate(); static AnnotationTemplate create(); void addTemplateMin(Property property, int minOccurs); void addTemplateMax(Property property, int maxOccurs); void addTemplateMinMax(Property property, int minOccurs, int maxOccurs); Set<Property> getPropertiesAsSet(); boolean existsInTemplate(PropertyValuePair propertyValuePair); boolean isValidAccordingToTemplate(PropertyValuePair propertyValuePair); }### Answer:
@Test public void testAddTemplateMinMax() { AnnotationTemplate at = AnnotationTemplate.create(); assertThat(at.existsInTemplate(sa1)).isFalse(); at.addTemplateMinMax(RDF.type, 1, 2); assertThat(at.existsInTemplate(sa1)).isTrue(); assertThat(at.isValidAccordingToTemplate(sa1)).isTrue(); assertThat(at.existsInTemplate(sa2)).isFalse(); at.addTemplateMinMax(RDF.predicate, 3, 5); assertThat(at.existsInTemplate(sa2)).isTrue(); assertThat(at.isValidAccordingToTemplate(sa2)).isFalse(); } |
### Question:
AnnotationTemplate { public Set<Property> getPropertiesAsSet() { return template.keySet(); } private AnnotationTemplate(); static AnnotationTemplate create(); void addTemplateMin(Property property, int minOccurs); void addTemplateMax(Property property, int maxOccurs); void addTemplateMinMax(Property property, int minOccurs, int maxOccurs); Set<Property> getPropertiesAsSet(); boolean existsInTemplate(PropertyValuePair propertyValuePair); boolean isValidAccordingToTemplate(PropertyValuePair propertyValuePair); }### Answer:
@Test public void testGetPropertiesAsSet() { AnnotationTemplate at = AnnotationTemplate.create(); at.addTemplateMinMax(RDF.type, 1,2); at.addTemplateMinMax(RDF.predicate, 3,5); assertThat(at.getPropertiesAsSet()).isNotEmpty(); assertThat(at.getPropertiesAsSet().size()).isEqualTo(2); } |
### Question:
ShapeTargetCore implements ShapeTarget { public static ShapeTarget create(@NonNull ShapeTargetType targetType, @NonNull RDFNode node) { switch (targetType) { case ClassTarget: return new ShapeTargetCore(targetType, node, ShapeTargetCore::classTargetPattern); case NodeTarget: return new ShapeTargetCore(targetType, node, ShapeTargetCore::nodeTargetPattern); case ObjectsOfTarget: return new ShapeTargetCore(targetType, node, ShapeTargetCore::objectsOfTargetPattern); case SubjectsOfTarget: return new ShapeTargetCore(targetType, node, ShapeTargetCore::subjectsOfTargetPattern); default: throw new IllegalArgumentException("Something wrong with the input"); } } private ShapeTargetCore(ShapeTargetType targetType, RDFNode node, Function<RDFNode, String> generatePattern); @Override String getPattern(); @Override Set<Resource> getRelatedOntologyResources(); static ShapeTarget create(@NonNull ShapeTargetType targetType, @NonNull RDFNode node); }### Answer:
@Test(expected=NullPointerException.class) public void testCreateNullType() { ShapeTargetCore.create(null, null); }
@Test public void testPatternUnique() { List<String> targetPatterns = Arrays.stream(ShapeTargetType.values() ) .filter( sct -> !sct.equals(ShapeTargetType.ValueShapeTarget)) .map( s -> ShapeTargetCore.create(s, ResourceFactory.createResource("http: .map(ShapeTarget::getPattern) .collect(Collectors.toList()); assertThat(targetPatterns.size()) .isEqualTo(new HashSet<>(targetPatterns).size()); } |
### Question:
ComponentParameterImpl implements ComponentParameter { @Override public Optional<RDFNode> getDefaultValue() { return Optional.ofNullable(defaultValue); } @Override Optional<RDFNode> getDefaultValue(); }### Answer:
@Test public void testGetDefaultValue() { assertThat(argDef.getDefaultValue().isPresent()) .isFalse(); RDFNode node = ResourceFactory.createResource("http: ComponentParameterImpl arg2 = ComponentParameterImpl.builder().element(element).predicate(predicate).defaultValue(node).build(); assertThat(arg2.getDefaultValue().get()) .isEqualTo(node); } |
### Question:
RdfUnitJunitRunner extends ParentRunner<RdfUnitJunitTestCase> { protected RdfReader getAdditionalDataModel() { return additionalData; } RdfUnitJunitRunner(Class<?> testClass); static final Class<?> INPUT_DATA_RETURN_TYPE; }### Answer:
@Test public void returnsVocabulary() throws InitializationError { final RdfUnitJunitRunner rdfUnitJunitRunner = new RdfUnitJunitRunner(ControlledVocabularyTest.class); assertThat(rdfUnitJunitRunner.getAdditionalDataModel()).isSameAs(CONTROLLED_VOCABULARY); } |
### Question:
MetricMapper { public static MetricMapper createDefault() { Model model; try { model = RdfReaderFactory.createResourceReader("/org/aksw/rdfunit/dqv/metricMappings.ttl").read(); } catch (RdfReaderException e) { throw new IllegalArgumentException("Cannot read default metric mappings", e); } ImmutableMap.Builder<String, String> builder = new ImmutableMap.Builder<>(); model.listStatements().toList().stream() .filter(smt -> smt.getPredicate().equals(RDFUNITv.metric)) .filter(smt -> smt.getObject().isResource()) .forEach(smt -> builder.put(smt.getSubject().getURI(), smt.getObject().asResource().getURI())); return new MetricMapper(builder.build()); } private MetricMapper(ImmutableMap<String, String> metricMap); Map<String, String> getMetricMap(); static MetricMapper createDefault(); }### Answer:
@Test public void testCreateDefault() { MetricMapper metricMapper = MetricMapper.createDefault(); int DEFAULT_MAP_SIZE = 16; assertThat(metricMapper.getMetricMap().size()) .isEqualTo(DEFAULT_MAP_SIZE); } |
### Question:
RdfFirstSuccessReader implements RdfReader { @Override public void read(Model model) throws RdfReaderException { StringBuilder message = new StringBuilder(); for (RdfReader r : readers) { try { r.read(model); return; } catch (RdfReaderException e) { message.append('\n'); if (e.getMessage() != null) { message.append(e.getMessage()); } else { message.append(e); } } } throw new RdfReaderException("Cannot read from any reader: " + message.toString()); } RdfFirstSuccessReader(Collection<RdfReader> readers); @Override void read(Model model); @Override void readDataset(Dataset dataset); @Override String toString(); }### Answer:
@Test public void testNotExceptionRead() { ArrayList<RdfReader> rdfReaders = new ArrayList<>(); rdfReaders.add(new RdfStreamReader("")); rdfReaders.add(RdfReaderFactory.createResourceReader("/org/aksw/rdfunit/io/empty.ttl")); RdfFirstSuccessReader reader = new RdfFirstSuccessReader(rdfReaders); try { reader.read(); } catch (RdfReaderException e) { fail("Should have NOT raised a TripleReaderException"); } } |
### Question:
RdfFirstSuccessReader implements RdfReader { @Override public void readDataset(Dataset dataset) throws RdfReaderException { StringBuilder message = new StringBuilder(); for (RdfReader r : readers) { try { r.readDataset(dataset); return; } catch (RdfReaderException e) { message.append("\n"); if (e.getMessage() != null) { message.append(e.getMessage()); } else { message.append(e); } } } throw new RdfReaderException("Cannot read from any reader: " + message.toString()); } RdfFirstSuccessReader(Collection<RdfReader> readers); @Override void read(Model model); @Override void readDataset(Dataset dataset); @Override String toString(); }### Answer:
@Test public void testNotExceptionReadDataset() { ArrayList<RdfReader> rdfReaders = new ArrayList<>(); rdfReaders.add(new RdfStreamReader("")); rdfReaders.add(RdfReaderFactory.createResourceReader("/org/aksw/rdfunit/io/empty.ttl")); RdfFirstSuccessReader reader = new RdfFirstSuccessReader(rdfReaders); try { reader.readDataset(); } catch (RdfReaderException e) { Assert.fail("Should have NOT raised a TripleReaderException"); } } |
### Question:
RdfStreamReader implements RdfReader { @Override public void read(Model model) throws RdfReaderException { try { RDFDataMgr.read(model, inputStream, null, RDFLanguages.nameToLang(format)); } catch (Exception e) { throw new RdfReaderException(e.getMessage(), e); } } RdfStreamReader(String filename); RdfStreamReader(String filename, String format); RdfStreamReader(InputStream inputStream, String format); @Override void read(Model model); @Override void readDataset(Dataset dataset); @Override String toString(); }### Answer:
@Test public void testReader() throws Exception{ Model readModel = RdfReaderFactory.createResourceReader(resourceName).read(); assertTrue("Models not the same", model.isIsomorphicWith(readModel)); } |
### Question:
RdfReaderFactory { public static RdfReader createReaderFromText(String text, String format) { InputStream is; is = new ByteArrayInputStream(text.getBytes(StandardCharsets.UTF_8)); return new RdfStreamReader(is, format); } private RdfReaderFactory(); static RdfReader createFileOrDereferenceReader(String filename, String uri); static RdfReader createResourceReader(String resource); static RdfReader createFileOrResourceReader(String filename, String resource); static RdfReader createResourceOrFileOrDereferenceReader(String uri); static RdfReader createDereferenceReader(String uri); static RdfReader createReaderFromText(String text, String format); static RdfReader createEmptyReader(); }### Answer:
@Test public void testCreateReaderFromText() throws IOException, RdfReaderException { URL url = Resources.getResource(this.getClass(),"/org/aksw/rdfunit/io/onetriple.ttl"); String content = Resources.toString(url, Charsets.UTF_8); RdfReader reader = RdfReaderFactory.createReaderFromText(content, "TTL"); Model model = reader.read(); assertThat(model.isIsomorphicWith(ReaderTestUtils.createOneTripleModel())).isTrue(); } |
### Question:
NamespaceStatistics { public Collection<SchemaSource> getNamespaces(QueryExecutionFactory qef) { Set<String> namespaces = new HashSet<>(); for (DatasetStatistics dt : datasetStatistics) { namespaces.addAll(dt.getStatisticsMap(qef).keySet().stream() .map(this::getNamespaceFromURI) .collect(Collectors.toList())); } return getIdentifiedSchemata(namespaces); } private NamespaceStatistics(Collection<DatasetStatistics> datasetStatisticses, boolean skipUnknownNamespaces, RDFUnitConfiguration conf); static NamespaceStatistics createOntologyNSStatisticsKnown(RDFUnitConfiguration conf); static NamespaceStatistics createOntologyNSStatisticsAll(RDFUnitConfiguration conf); static NamespaceStatistics createCompleteNSStatisticsKnown(RDFUnitConfiguration conf); static NamespaceStatistics createCompleteNSStatisticsAll(RDFUnitConfiguration conf); Collection<SchemaSource> getNamespaces(QueryExecutionFactory qef); String getNamespaceFromURI(String uri); }### Answer:
@Test public void testGetNamespaces() { assertEquals(13, NamespaceStatistics.createCompleteNSStatisticsAll(null).getNamespaces(qef).size()); assertEquals(0, NamespaceStatistics.createCompleteNSStatisticsKnown(null).getNamespaces(qef).size()); assertEquals(8, NamespaceStatistics.createOntologyNSStatisticsAll(null).getNamespaces(qef).size()); assertEquals(0, NamespaceStatistics.createOntologyNSStatisticsKnown(null).getNamespaces(qef).size()); } |
### Question:
NamespaceStatistics { public String getNamespaceFromURI(String uri) { String breakChar = "/"; if (uri.contains("#")) { breakChar = "#"; } else { if (uri.substring(6).contains(":")) { breakChar = ":"; } } int pos = Math.min(uri.lastIndexOf(breakChar), uri.length()); return uri.substring(0, pos + 1); } private NamespaceStatistics(Collection<DatasetStatistics> datasetStatisticses, boolean skipUnknownNamespaces, RDFUnitConfiguration conf); static NamespaceStatistics createOntologyNSStatisticsKnown(RDFUnitConfiguration conf); static NamespaceStatistics createOntologyNSStatisticsAll(RDFUnitConfiguration conf); static NamespaceStatistics createCompleteNSStatisticsKnown(RDFUnitConfiguration conf); static NamespaceStatistics createCompleteNSStatisticsAll(RDFUnitConfiguration conf); Collection<SchemaSource> getNamespaces(QueryExecutionFactory qef); String getNamespaceFromURI(String uri); }### Answer:
@Test public void testGetNamespaceFromURI() { Map<String, String> examples = new HashMap<>(); examples.put("http: examples.put("http: examples.put("http: NamespaceStatistics namespaceStatistics = NamespaceStatistics.createCompleteNSStatisticsAll(null); for (Map.Entry<String, String> entry : examples.entrySet()) { String namespace = entry.getValue(); assertEquals("All prefixed should be initialized", namespace, namespaceStatistics.getNamespaceFromURI(entry.getKey())); } } |
### Question:
LoginPresenter extends BaseRxJavaPresenter<LoginContract.View> implements LoginContract.Presenter { @Override public void onStart() { mLoginRepository.getUser() .subscribeOn(mSchedulerProvider.io()) .observeOn(mSchedulerProvider.ui()) .subscribe(new OnceObserver<User>() { @Override protected void onResponse(User value) { mView.setUserName(value.getName()); } }); } @Inject LoginPresenter(@NonNull LoginRepository loginRepository,
@NonNull ISchedulerProvider schedulerProvider); @Override void onStart(); @Override void onEdtUserNameChanged(String userName); @Override void onBtnClearUserNameClick(); @Override void onBtnShowOrHidePasswordClick(boolean needShow); @Override void login(User user); }### Answer:
@Test public void onStartFirst() { when(mLoginRepository.getUser()).thenReturn(Observable.<User>empty()); mLoginPresenter.onStart(); verify(mLoginRepository).getUser(); verify(mLoginView, never()).setUserName(anyString()); verify(mLoginView, never()).setPassword(anyString()); }
@Test public void onStartNotFirst() { when(mLoginRepository.getUser()).thenReturn(Observable.just(mUser)); when(mLoginRepository.loginRemote(mUser)).thenReturn(Observable.just(mUser)); mLoginPresenter.onStart(); verify(mLoginRepository).getUser(); verify(mLoginView).setUserName(mUser.getName()); } |
### Question:
LoginPresenter extends BaseRxJavaPresenter<LoginContract.View> implements LoginContract.Presenter { @Override public void onEdtUserNameChanged(String userName) { if (!TextUtil.isEmpty(userName)) { mView.showClearUserNameButton(); } else { mView.hideClearUserNameButton(); } } @Inject LoginPresenter(@NonNull LoginRepository loginRepository,
@NonNull ISchedulerProvider schedulerProvider); @Override void onStart(); @Override void onEdtUserNameChanged(String userName); @Override void onBtnClearUserNameClick(); @Override void onBtnShowOrHidePasswordClick(boolean needShow); @Override void login(User user); }### Answer:
@Test public void onUserNameAfterTextChangedEmpty() { mLoginPresenter.onEdtUserNameChanged(""); verify(mLoginView).hideClearUserNameButton(); }
@Test public void onUserNameAfterTextChangedNotEmpty() { mLoginPresenter.onEdtUserNameChanged("a"); verify(mLoginView).showClearUserNameButton(); } |
### Question:
LoginPresenter extends BaseRxJavaPresenter<LoginContract.View> implements LoginContract.Presenter { @Override public void onBtnClearUserNameClick() { mView.setUserNameEmpty(); } @Inject LoginPresenter(@NonNull LoginRepository loginRepository,
@NonNull ISchedulerProvider schedulerProvider); @Override void onStart(); @Override void onEdtUserNameChanged(String userName); @Override void onBtnClearUserNameClick(); @Override void onBtnShowOrHidePasswordClick(boolean needShow); @Override void login(User user); }### Answer:
@Test public void onClearUserNameBtnClick() { mLoginPresenter.onBtnClearUserNameClick(); verify(mLoginView).setUserNameEmpty(); } |
### Question:
LoginPresenter extends BaseRxJavaPresenter<LoginContract.View> implements LoginContract.Presenter { @Override public void onBtnShowOrHidePasswordClick(boolean needShow) { if (needShow) { mView.showPassword(); } else { mView.hidePassword(); } } @Inject LoginPresenter(@NonNull LoginRepository loginRepository,
@NonNull ISchedulerProvider schedulerProvider); @Override void onStart(); @Override void onEdtUserNameChanged(String userName); @Override void onBtnClearUserNameClick(); @Override void onBtnShowOrHidePasswordClick(boolean needShow); @Override void login(User user); }### Answer:
@Test public void onShowPasswordButtonClickTrue() { mLoginPresenter.onBtnShowOrHidePasswordClick(true); verify(mLoginView).showPassword(); }
@Test public void onShowPasswordButtonClickFalse() { mLoginPresenter.onBtnShowOrHidePasswordClick(false); verify(mLoginView).hidePassword(); } |
### Question:
PrometheusPublisher extends Collector implements Collector.Describable, MetricsInitializer { @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { this.globalRegistry = globalRegistry; String address = DynamicPropertyFactory.getInstance().getStringProperty(METRICS_PROMETHEUS_ADDRESS, "0.0.0.0:9696").get(); try { InetSocketAddress socketAddress = getSocketAddress(address); register(); this.httpServer = new HTTPServer(socketAddress, CollectorRegistry.defaultRegistry, true); LOGGER.info("Prometheus httpServer listened : {}.", address); } catch (Exception e) { throw new ServiceCombException("create http publish server failed,may bad address : " + address, e); } } @Override void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config); @Override List<MetricFamilySamples> describe(); @Override List<MetricFamilySamples> collect(); @Override void destroy(); }### Answer:
@Test public void testBadPublishAddress() { thrown.expect(ServiceCombException.class); ArchaiusUtils.setProperty(PrometheusPublisher.METRICS_PROMETHEUS_ADDRESS, "a:b:c"); publisher.init(globalRegistry, null, null); }
@Test public void testBadPublishAddress_BadPort() { thrown.expect(ServiceCombException.class); ArchaiusUtils.setProperty(PrometheusPublisher.METRICS_PROMETHEUS_ADDRESS, "localhost:xxxx"); publisher.init(globalRegistry, null, null); }
@Test public void testBadPublishAddress_TooLargePort() { thrown.expect(ServiceCombException.class); ArchaiusUtils.setProperty(PrometheusPublisher.METRICS_PROMETHEUS_ADDRESS, "localhost:9999999"); publisher.init(globalRegistry, null, null); } |
### Question:
AbstractRestInvocation { protected void runOnExecutor() { invocation.onExecuteStart(); invoke(); } AbstractRestInvocation(); void setHttpServerFilters(List<HttpServerFilter> httpServerFilters); String getContext(String key); void invoke(); void sendFailResponse(Throwable throwable); static final String UNKNOWN_OPERATION_ID; }### Answer:
@Test public void runOnExecutor() { long time = 123; new MockUp<System>() { @Mock long nanoTime() { return time; } }; Holder<Boolean> result = new Holder<>(); restInvocation = new AbstractRestInvocationForTest() { @Override public void invoke() { result.value = true; } }; restInvocation.createInvocation(); restInvocation.requestEx = requestEx; restInvocation.restOperationMeta = restOperation; restInvocation.runOnExecutor(); Assert.assertTrue(result.value); Assert.assertSame(invocation, restInvocation.invocation); assertEquals(time, invocation.getInvocationStageTrace().getStartExecution()); } |
### Question:
EnvAdapterManager extends RegisterManager<String, EnvAdapter> { public void processMicroserviceWithAdapters(Microservice microservice) { getObjMap().forEach((name, adapter) -> { LOGGER.info("Start process microservice with adapter {}", name); adapter.beforeRegisterService(microservice); }); } EnvAdapterManager(); void processMicroserviceWithAdapters(Microservice microservice); void processSchemaWithAdapters(String schemaId, String content); void processInstanceWithAdapters(MicroserviceInstance instance); static final EnvAdapterManager INSTANCE; }### Answer:
@Test public void testProcessMicroservice() { Microservice microservice = new Microservice(); manager.processMicroserviceWithAdapters(microservice); assertEquals("order=0", microservice.getProperties().get("cas_env_one")); assertEquals("order=0", microservice.getProperties().get("cas_env_two")); assertNull(microservice.getProperties().get("default-env-adapter")); } |
### Question:
AbstractRestInvocation { protected void doInvoke() throws Throwable { invocation.getInvocationStageTrace().startHandlersRequest(); invocation.next(resp -> sendResponseQuietly(resp)); } AbstractRestInvocation(); void setHttpServerFilters(List<HttpServerFilter> httpServerFilters); String getContext(String key); void invoke(); void sendFailResponse(Throwable throwable); static final String UNKNOWN_OPERATION_ID; }### Answer:
@Test public void doInvoke(@Mocked Endpoint endpoint, @Mocked OperationMeta operationMeta, @Mocked Object[] swaggerArguments, @Mocked SchemaMeta schemaMeta) throws Throwable { Response response = Response.ok("ok"); Handler handler = (invocation, asyncResp) -> asyncResp.complete(response); List<Handler> handlerChain = Arrays.asList(handler); Deencapsulation.setField(invocation, "handlerList", handlerChain); Holder<Response> result = new Holder<>(); restInvocation = new AbstractRestInvocationForTest() { @Override protected void sendResponse(Response response) { result.value = response; } }; restInvocation.invocation = invocation; restInvocation.doInvoke(); Assert.assertSame(response, result.value); assertEquals(nanoTime, invocation.getInvocationStageTrace().getStartHandlersRequest()); assertEquals(nanoTime, invocation.getInvocationStageTrace().getFinishHandlersResponse()); } |
### Question:
ClassPathStaticResourceHandler extends StaticResourceHandler { protected Part findResource(String path) throws IOException { URL url = this.getClass().getClassLoader().getResource(path); if (url == null) { return null; } return new InputStreamPart(null, url.openStream()).setSubmittedFileName(path); } }### Answer:
@Test public void readContentFailed() throws IOException { new Expectations(handler) { { handler.findResource(anyString); result = new RuntimeExceptionWithoutStackTrace("read content failed."); } }; try (LogCollector logCollector = new LogCollector()) { Response response = handler.handle("index.html"); Assert.assertEquals("failed to process static resource, path=web-root/index.html", logCollector.getLastEvents().getMessage()); InvocationException invocationException = response.getResult(); Assert.assertEquals(Status.INTERNAL_SERVER_ERROR, invocationException.getStatus()); Assert.assertEquals("failed to process static resource.", ((CommonExceptionData) invocationException.getErrorData()).getMessage()); Assert.assertEquals(Status.INTERNAL_SERVER_ERROR.getStatusCode(), response.getStatusCode()); Assert.assertEquals(Status.INTERNAL_SERVER_ERROR.getReasonPhrase(), response.getReasonPhrase()); } } |
### Question:
ServicePathManager { public static ServicePathManager getServicePathManager(MicroserviceMeta microserviceMeta) { return microserviceMeta.getExtData(REST_PATH_MANAGER); } ServicePathManager(MicroserviceMeta microserviceMeta); static ServicePathManager getServicePathManager(MicroserviceMeta microserviceMeta); OperationLocator consumerLocateOperation(String path, String httpMethod); OperationLocator producerLocateOperation(String path, String httpMethod); void addResource(RestOperationMeta swaggerRestOperation); void sortPath(); void buildProducerPaths(); }### Answer:
@Test public void testBuildProducerPathsNoPrefix() { SCBEngine scbEngine = SCBBootstrap.createSCBEngineForTest() .addProducerMeta("sid1", new TestPathSchema()) .run(); ServicePathManager spm = ServicePathManager.getServicePathManager(scbEngine.getProducerMicroserviceMeta()); Assert.assertSame(spm.producerPaths, spm.swaggerPaths); scbEngine.destroy(); } |
### Question:
MicroservicePaths { public Map<String, OperationGroup> getStaticPathOperationMap() { return staticPathOperations; } void sortPath(); void addResource(RestOperationMeta swaggerRestOperation); Map<String, OperationGroup> getStaticPathOperationMap(); List<RestOperationMeta> getDynamicPathOperationList(); void printPaths(); }### Answer:
@Test public void staticGroup() { RestOperationMeta meta = paths.getStaticPathOperationMap().get("/static/").findValue("POST"); Assert.assertSame("postStatic", meta.getOperationMeta().getOperationId()); meta = paths.getStaticPathOperationMap().get("/static/").findValue("GET"); Assert.assertSame("getStatic", meta.getOperationMeta().getOperationId()); } |
### Question:
MicroservicePaths { public void addResource(RestOperationMeta swaggerRestOperation) { if (swaggerRestOperation.isAbsoluteStaticPath()) { addStaticPathResource(swaggerRestOperation); return; } dynamicPathOperationsList.add(swaggerRestOperation); } void sortPath(); void addResource(RestOperationMeta swaggerRestOperation); Map<String, OperationGroup> getStaticPathOperationMap(); List<RestOperationMeta> getDynamicPathOperationList(); void printPaths(); }### Answer:
@Test public void testAddResourceStaticDuplicatedHttpMethod(@Mocked RestOperationMeta staticResPost) { new Expectations() { { staticResPost.getHttpMethod(); result = "POST"; staticResPost.getAbsolutePath(); result = "/static/"; staticResPost.isAbsoluteStaticPath(); result = true; } }; expectedException.expect(ServiceCombException.class); expectedException.expectMessage("operation with url /static/, method POST is duplicated."); paths.addResource(staticResPost); } |
### Question:
MicroservicePaths { public List<RestOperationMeta> getDynamicPathOperationList() { return dynamicPathOperationsList; } void sortPath(); void addResource(RestOperationMeta swaggerRestOperation); Map<String, OperationGroup> getStaticPathOperationMap(); List<RestOperationMeta> getDynamicPathOperationList(); void printPaths(); }### Answer:
@Test public void dynamicPath() { Assert.assertEquals("dynamicExId", paths.getDynamicPathOperationList().get(0).getOperationMeta().getOperationId()); Assert.assertEquals("dynamicId", paths.getDynamicPathOperationList().get(1).getOperationMeta().getOperationId()); } |
### Question:
MicroservicePaths { public void printPaths() { for (Entry<String, OperationGroup> entry : staticPathOperations.entrySet()) { OperationGroup operationGroup = entry.getValue(); printPath(operationGroup.values()); } printPath(getDynamicPathOperationList()); } void sortPath(); void addResource(RestOperationMeta swaggerRestOperation); Map<String, OperationGroup> getStaticPathOperationMap(); List<RestOperationMeta> getDynamicPathOperationList(); void printPaths(); }### Answer:
@Test public void testPrintPaths() { try (LogCollector collector = new LogCollector()) { paths.printPaths(); StringBuilder sb = new StringBuilder(); collector.getEvents().stream() .forEach(e -> sb.append(e.getMessage()).append("\n")); Assert.assertEquals( "Swagger mapped \"{[/static/], method=[POST], produces=[application/json]}\" onto public void org.apache.servicecomb.common.rest.locator.TestPathSchema.postStatic()\n" + "Swagger mapped \"{[/static/], method=[GET], produces=[application/json]}\" onto public void org.apache.servicecomb.common.rest.locator.TestPathSchema.getStatic()\n" + "Swagger mapped \"{[/staticEx/], method=[GET], produces=[application/json]}\" onto public void org.apache.servicecomb.common.rest.locator.TestPathSchema.getStaticEx()\n" + "Swagger mapped \"{[/dynamicEx/{id}/], method=[GET], produces=[application/json]}\" onto public void org.apache.servicecomb.common.rest.locator.TestPathSchema.dynamicExId(java.lang.String)\n" + "Swagger mapped \"{[/dynamic/{id}/], method=[GET], produces=[application/json]}\" onto public void org.apache.servicecomb.common.rest.locator.TestPathSchema.dynamicId(java.lang.String)\n", sb.toString()); } } |
### Question:
EnvAdapterManager extends RegisterManager<String, EnvAdapter> { public void processInstanceWithAdapters(MicroserviceInstance instance) { getObjMap().forEach((name, adapter) -> { LOGGER.info("Start process instance with adapter {}", name); adapter.beforeRegisterInstance(instance); }); } EnvAdapterManager(); void processMicroserviceWithAdapters(Microservice microservice); void processSchemaWithAdapters(String schemaId, String content); void processInstanceWithAdapters(MicroserviceInstance instance); static final EnvAdapterManager INSTANCE; }### Answer:
@Test public void testProcessInstance() { MicroserviceInstance instance = new MicroserviceInstance(); manager.processInstanceWithAdapters(instance); assertEquals("order=0", instance.getProperties().get("cas_env_one")); assertEquals("order=0", instance.getProperties().get("cas_env_two")); assertNull(instance.getProperties().get("default-env-adapter")); } |
### Question:
RestOperationMeta { public String getAbsolutePath() { return this.absolutePath; } void init(OperationMeta operationMeta); boolean isDownloadFile(); boolean isFormData(); void setOperationMeta(OperationMeta operationMeta); String getAbsolutePath(); void setAbsolutePath(String absolutePath); PathRegExp getAbsolutePathRegExp(); boolean isAbsoluteStaticPath(); RestParam getParamByName(String name); RestParam getParamByIndex(int index); OperationMeta getOperationMeta(); URLPathBuilder getPathBuilder(); List<RestParam> getParamList(); ProduceProcessor findProduceProcessor(String type); ProduceProcessor ensureFindProduceProcessor(HttpServletRequestEx requestEx); ProduceProcessor ensureFindProduceProcessor(String acceptType); String getHttpMethod(); List<String> getFileKeys(); List<String> getProduces(); }### Answer:
@Test public void generatesAbsolutePathWithRootBasePath() { findOperation("textCharJsonChar"); assertThat(operationMeta.getAbsolutePath(), is("/textCharJsonChar/")); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.