src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
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); } | @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) { } } |
HumanReadableStatementHelper { public static String generateChangePrimaryKeyColumnsString(String tableName, List<String> oldPrimaryKeyColumns, List<String> newPrimaryKeyColumns) { StringBuilder changePrimaryKeyColumnsBuilder = new StringBuilder(); changePrimaryKeyColumnsBuilder.append(String.format("Change primary key columns on %s from %s to %s", tableName, "(" + Joiner.on(", ").join(oldPrimaryKeyColumns) + ")", "(" + Joiner.on(", ").join(newPrimaryKeyColumns) + ")")); return changePrimaryKeyColumnsBuilder.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); } | @Test public void testChangePrimaryKeyColumnsGeneration() { List<String> fromList = ImmutableList.of("column1", "column2", "column3"); List<String> newList = ImmutableList.of("column4", "column5"); assertEquals("Should have the correct text - Simple", "Change primary key columns on my_table from (column1, column2, column3) to (column4, column5)", HumanReadableStatementHelper.generateChangePrimaryKeyColumnsString("my_table", fromList, newList)); } |
HumanReadableStatementHelper { public static String generateAddColumnString(final String tableName, final Column definition) { return String.format("Add a %s column to %s called %s [%s]%s", generateNullableString(definition), tableName, definition.getName(), generateColumnDefinitionString(definition), generateColumnDefaultValueClause(definition)); } 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); } | @Test public void testAddColumnGeneration() { assertEquals("Should have correct text - NON NULL STRING", "Add a non-null column to my_table called newColumn [STRING(10)]", HumanReadableStatementHelper.generateAddColumnString("my_table", column("newColumn", DataType.STRING, 10))); assertEquals("Should have correct text - NULLABLE STRING", "Add a nullable column to my_table called newColumn [STRING(10)]", HumanReadableStatementHelper.generateAddColumnString("my_table", column("newColumn", DataType.STRING, 10).nullable())); assertEquals("Should have correct text - NON NULL DECIMAL", "Add a non-null column to my_table called newColumn [DECIMAL(9,5)]", HumanReadableStatementHelper.generateAddColumnString("my_table", column("newColumn", DataType.DECIMAL, 9, 5))); assertEquals("Should have correct text - NULLABLE DECIMAL", "Add a nullable column to my_table called newColumn [DECIMAL(9,5)]", HumanReadableStatementHelper.generateAddColumnString("my_table", column("newColumn", DataType.DECIMAL, 9, 5).nullable())); assertEquals("Should have correct text - NON NULL DECIMAL 2", "Add a non-null column to my_table called newColumn [DECIMAL(9,0)]", HumanReadableStatementHelper.generateAddColumnString("my_table", column("newColumn", DataType.DECIMAL, 9, 0))); assertEquals("Should have correct text - NULLABLE DECIMAL 2", "Add a nullable column to my_table called newColumn [DECIMAL(9,0)]", HumanReadableStatementHelper.generateAddColumnString("my_table", column("newColumn", DataType.DECIMAL, 9, 0).nullable())); assertEquals("Should have correct text - NON NULL WITH DEFAULT", "Add a non-null column to my_table called newColumn [STRING(1)], set to 'N'", HumanReadableStatementHelper.generateAddColumnString("my_table", column("newColumn", DataType.STRING, 1).defaultValue("N"))); assertEquals("Should have correct text - NON NULL POPULATED ", "Add a non-null column to my_table called newColumn [STRING(1)], set to 'N'", HumanReadableStatementHelper.generateAddColumnString("my_table", column("newColumn", DataType.STRING, 1), new FieldLiteral("N"))); } |
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); } | @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"))); } |
HumanReadableStatementHelper { public static String generateAddTableString(final Table definition) { StringBuilder addTableBuilder = new StringBuilder(); addTableBuilder.append(String.format("Create table %s with %s and %s", definition.getName(), generateColumnCountString(definition.columns().size()), generateIndexCountString(definition.indexes().size())) ); for (Column column : definition.columns()) { addTableBuilder.append(generateNewTableColumnString(column)); } return addTableBuilder.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); } | @Test public void testAddTableOneColumnNoIndex() { Table newTable = table("new_table").columns( column("column_one", DataType.STRING, 10) ); assertEquals( String.format("Create table new_table with 1 column and no indexes" + "%n - A non-null column called column_one [STRING(10)]"), HumanReadableStatementHelper.generateAddTableString(newTable) ); }
@Test public void testAddTableOneColumnOneIndex() { Table newTable = table("new_table").columns( column("column_one", DataType.STRING, 10) ).indexes( index("new_table_1").unique().columns("column_one") ); assertEquals( String.format("Create table new_table with 1 column and 1 index" + "%n - A non-null column called column_one [STRING(10)]"), HumanReadableStatementHelper.generateAddTableString(newTable) ); }
@Test public void testAddTableTwoColumnsNoIndex() { Table newTable = table("new_table").columns( column("column_one", DataType.STRING, 10), column("column_two", DataType.DECIMAL, 9, 5).nullable() ); assertEquals( String.format("Create table new_table with 2 columns and no indexes" + "%n - A non-null column called column_one [STRING(10)]" + "%n - A nullable column called column_two [DECIMAL(9,5)]"), HumanReadableStatementHelper.generateAddTableString(newTable) ); }
@Test public void testAddTableTwoColumnsOneIndex() { Table newTable = table("new_table").columns( column("column_one", DataType.STRING, 10), column("column_two", DataType.DECIMAL, 9, 5).nullable() ).indexes( index("new_table_1").unique().columns("column_one") ); assertEquals( String.format("Create table new_table with 2 columns and 1 index" + "%n - A non-null column called column_one [STRING(10)]" + "%n - A nullable column called column_two [DECIMAL(9,5)]"), HumanReadableStatementHelper.generateAddTableString(newTable) ); }
@Test public void testAddTableTwoColumnsTwoIndexes() { Table newTable = table("new_table").columns( column("column_one", DataType.STRING, 10), column("column_two", DataType.DECIMAL, 9, 5).nullable() ).indexes( index("new_table_1").unique().columns("column_one"), index("new_table_2").columns("column_two") ); assertEquals( String.format("Create table new_table with 2 columns and 2 indexes" + "%n - A non-null column called column_one [STRING(10)]" + "%n - A nullable column called column_two [DECIMAL(9,5)]"), HumanReadableStatementHelper.generateAddTableString(newTable) ); }
@Test public void testAddTableTenColumns() { Table newTable = table("new_table").columns( column("column_one", DataType.STRING, 10).defaultValue("Foo"), column("column_two", DataType.STRING, 1).nullable(), column("column_three", DataType.DECIMAL, 9, 5), column("column_four", DataType.DECIMAL, 15, 0).nullable(), column("column_five", DataType.INTEGER).defaultValue("42"), column("column_six", DataType.INTEGER).nullable(), column("column_seven", DataType.BIG_INTEGER), column("column_eight", DataType.BIG_INTEGER).nullable(), column("column_bool", DataType.BOOLEAN), column("column_nullbool", DataType.BOOLEAN).nullable(), column("column_date", DataType.DATE), column("column_nulldate", DataType.DATE).nullable(), column("column_clob", DataType.CLOB), column("column_nullclob", DataType.CLOB).nullable(), column("column_nine", DataType.BLOB), column("column_ten", DataType.BLOB).nullable() ); assertEquals( String.format("Create table new_table with 16 columns and no indexes" + "%n - A non-null column called column_one [STRING(10)], set to 'Foo'" + "%n - A nullable column called column_two [STRING(1)]" + "%n - A non-null column called column_three [DECIMAL(9,5)]" + "%n - A nullable column called column_four [DECIMAL(15,0)]" + "%n - A non-null column called column_five [INTEGER], set to 42" + "%n - A nullable column called column_six [INTEGER]" + "%n - A non-null column called column_seven [BIG_INTEGER]" + "%n - A nullable column called column_eight [BIG_INTEGER]" + "%n - A non-null column called column_bool [BOOLEAN]" + "%n - A nullable column called column_nullbool [BOOLEAN]" + "%n - A non-null column called column_date [DATE]" + "%n - A nullable column called column_nulldate [DATE]" + "%n - A non-null column called column_clob [CLOB]" + "%n - A nullable column called column_nullclob [CLOB]" + "%n - A non-null column called column_nine [BLOB]" + "%n - A nullable column called column_ten [BLOB]"), HumanReadableStatementHelper.generateAddTableString(newTable) ); } |
HumanReadableStatementHelper { public static String generateAddTableFromString(final Table definition, final SelectStatement selectStatement) { StringBuilder addTableBuilder = new StringBuilder() .append(generateAddTableString(definition)); addTableBuilder .append(" from ") .append(generateSelectStatementString(selectStatement, false)); return addTableBuilder .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); } | @Test public void testAddTableFromSelectSingleColumn() { Table newTable = table("new_table").columns( column("column_one", DataType.STRING, 10) ); assertEquals( String.format("Create table new_table with 1 column and no indexes" + "%n - A non-null column called column_one [STRING(10)] from foo from Wherever where bar is 1"), HumanReadableStatementHelper.generateAddTableFromString(newTable, select(field("foo")).from("Wherever").where(field("bar").eq(1))) ); }
@Test public void testAddTableFromSelectMultiColumn() { Table newTable = table("new_table").columns( column("column_one", DataType.STRING, 10), column("column_two", DataType.STRING, 10) ); assertEquals( String.format("Create table new_table with 2 columns and no indexes" + "%n - A non-null column called column_one [STRING(10)]" + "%n - A non-null column called column_two [STRING(10)] from foo, bar from Wherever where bar is 1"), HumanReadableStatementHelper.generateAddTableFromString(newTable, select(field("foo"), field("bar")).from("Wherever").where(field("bar").eq(1))) ); } |
HumanReadableStatementHelper { public static String generateChangeColumnString(final String tableName, final Column fromDefinition, final Column toDefinition) { if (fromDefinition.getName().equals(toDefinition.getName())) { return String.format("Change column %s on %s from %s %s to %s %s", fromDefinition.getName(), tableName, generateNullableString(fromDefinition), generateColumnDefinitionString(fromDefinition), generateNullableString(toDefinition), generateColumnDefinitionString(toDefinition)); } return String.format("Rename %s column %s [%s] on %s to %s %s [%s]", generateNullableString(fromDefinition), fromDefinition.getName(), generateColumnDefinitionString(fromDefinition), tableName, generateNullableString(toDefinition), toDefinition.getName(), generateColumnDefinitionString(toDefinition)); } 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); } | @Test public void testChangeColumnGeneration() { assertEquals("Should have the correct text - Lengthen String", "Change column columnOne on my_table from non-null STRING(10) to non-null STRING(20)", HumanReadableStatementHelper.generateChangeColumnString("my_table", column("columnOne", DataType.STRING, 10), column("columnOne", DataType.STRING, 20))); assertEquals("Should have the correct text - Change nullability String", "Change column columnOne on my_table from non-null STRING(10) to nullable STRING(10)", HumanReadableStatementHelper.generateChangeColumnString("my_table", column("columnOne", DataType.STRING, 10), column("columnOne", DataType.STRING, 10).nullable())); assertEquals("Should have the correct text - Change column type", "Change column columnOne on my_table from non-null STRING(10) to non-null DECIMAL(9,5)", HumanReadableStatementHelper.generateChangeColumnString("my_table", column("columnOne", DataType.STRING, 10), column("columnOne", DataType.DECIMAL, 9, 5))); }
@Test public void testRenameColumnGeneration() { assertEquals("Should have the correct text - Rename no length change", "Rename non-null column columnOne [STRING(10)] on my_table to non-null columnTwo [STRING(10)]", HumanReadableStatementHelper.generateChangeColumnString("my_table", column("columnOne", DataType.STRING, 10), column("columnTwo", DataType.STRING, 10))); assertEquals("Should have the correct text - Rename with length change", "Rename non-null column columnOne [STRING(10)] on my_table to non-null columnTwo [STRING(20)]", HumanReadableStatementHelper.generateChangeColumnString("my_table", column("columnOne", DataType.STRING, 10), column("columnTwo", DataType.STRING, 20))); assertEquals("Should have the correct text - Rename with null change", "Rename non-null column columnOne [STRING(10)] on my_table to nullable columnTwo [STRING(10)]", HumanReadableStatementHelper.generateChangeColumnString("my_table", column("columnOne", DataType.STRING, 10), column("columnTwo", DataType.STRING, 10).nullable())); } |
HumanReadableStatementHelper { public static String generateChangeIndexString(final String tableName, final Index fromIndex, final Index toIndex) { if (fromIndex.isUnique() == toIndex.isUnique()) { return String.format("Change %s index %s on %s", generateUniqueIndexString(fromIndex), fromIndex.getName(), tableName); } return String.format("Change %s index %s on %s to be %s", generateUniqueIndexString(fromIndex), fromIndex.getName(), tableName, generateUniqueIndexString(toIndex)); } 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); } | @Test public void testChangeIndexGeneration() { assertEquals("Should have the correct text - Change to non-unique", "Change unique index my_table_1 on my_table to be non-unique", HumanReadableStatementHelper.generateChangeIndexString("my_table", index("my_table_1").unique().columns("columnOne", "columnTwo"), index("my_table_1").columns("columnOne", "columnTwo"))); assertEquals("Should have the correct text - Change to unique", "Change non-unique index my_table_1 on my_table to be unique", HumanReadableStatementHelper.generateChangeIndexString("my_table", index("my_table_1").columns("columnOne", "columnTwo"), index("my_table_1").unique().columns("columnOne", "columnTwo"))); assertEquals("Should have the correct text - No change", "Change unique index my_table_1 on my_table", HumanReadableStatementHelper.generateChangeIndexString("my_table", index("my_table_1").unique().columns("columnOne", "columnTwo"), index("my_table_1").unique().columns("columnOne", "columnTwo"))); } |
OracleMetaDataProvider implements Schema { @Override public boolean isEmptyDatabase() { if (tableMap != null && !tableMap.isEmpty()) return false; return readTableKeys().isEmpty(); } 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(); } | @Test public void testIsEmptyDatabase() throws SQLException { String query1 = "SELECT A.TABLE_NAME, A.COLUMN_NAME FROM ALL_CONS_COLUMNS A JOIN ALL_CONSTRAINTS C ON A.CONSTRAINT_NAME = C.CONSTRAINT_NAME AND A.OWNER = C.OWNER and A.TABLE_NAME = C.TABLE_NAME WHERE C.TABLE_NAME not like 'BIN$%' AND " + "C.OWNER=? AND C.CONSTRAINT_TYPE = 'P' ORDER BY A.TABLE_NAME, A.POSITION"; final PreparedStatement statement1 = mock(PreparedStatement.class, RETURNS_SMART_NULLS); String query2 = "SELECT A.TABLE_NAME, A.COLUMN_NAME FROM ALL_CONS_COLUMNS A JOIN ALL_CONSTRAINTS C ON A.CONSTRAINT_NAME = C.CONSTRAINT_NAME AND A.OWNER = C.OWNER and A.TABLE_NAME = C.TABLE_NAME WHERE C.TABLE_NAME not like 'BIN$%' AND " + "C.OWNER=? AND C.CONSTRAINT_TYPE = 'P' ORDER BY A.TABLE_NAME, A.POSITION"; final PreparedStatement statement2 = mock(PreparedStatement.class, RETURNS_SMART_NULLS); final Schema oracleMetaDataProvider = oracle.openSchema(connection, "TESTDATABASE", "TESTSCHEMA"); when(connection.prepareStatement(query1)).thenReturn(statement1); when(statement1.executeQuery()).thenAnswer(new ReturnMockResultSet(0)); assertTrue("Database should be reported empty", oracleMetaDataProvider.isEmptyDatabase()); when(connection.prepareStatement(query2)).thenReturn(statement2); when(statement2.executeQuery()).thenAnswer(new ReturnMockResultSet(1)); assertFalse("Database should not be reported empty", oracleMetaDataProvider.isEmptyDatabase()); verify(statement1).setString(1, "TESTSCHEMA"); verify(statement2).setString(1, "TESTSCHEMA"); }
@Test public void testCloseStatementOnException() throws SQLException { final PreparedStatement statement = mock(PreparedStatement.class, RETURNS_SMART_NULLS); doThrow(new SQLException("Test")).when(statement).setFetchSize(anyInt()); when(connection.prepareStatement(anyString())).thenReturn(statement); when(statement.executeQuery()).thenAnswer(new ReturnMockResultSet(1)); final Schema oracleMetaDataProvider = oracle.openSchema(connection, "TESTDATABASE", "TESTSCHEMA"); try { oracleMetaDataProvider.isEmptyDatabase(); fail("Exception expected"); } catch (RuntimeSqlException e) { verify(statement).close(); } } |
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); } | @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))); } |
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); } | @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"))); } |
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); } | @Test public void testRemoveTableGeneration() { assertEquals("Should have the correct text - Simple", "Remove table my_table", HumanReadableStatementHelper.generateRemoveTableString(table("my_table"))); } |
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); } | @Test public void testRenameTableGeneration() { assertEquals("Should have the correct text - Simple", "Rename table my_table to your_table", HumanReadableStatementHelper.generateRenameTableString("my_table", "your_table")); } |
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); } | @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")); } |
HumanReadableStatementHelper { public static String generateDataUpgradeString(final Statement statement, final String preferredSQLDialect) { if (statement instanceof DeleteStatement) { return generateDeleteStatementString((DeleteStatement)statement); } else if (statement instanceof InsertStatement) { return generateInsertStatementString((InsertStatement)statement); } else if (statement instanceof MergeStatement) { return generateMergeStatementString((MergeStatement)statement); } else if (statement instanceof PortableSqlStatement) { return generatePortableSqlStatementString((PortableSqlStatement)statement, preferredSQLDialect); } else if (statement instanceof TruncateStatement) { return generateTruncateStatementString((TruncateStatement)statement); } else if (statement instanceof UpdateStatement) { return generateUpdateStatementString((UpdateStatement)statement); } else { throw new UnsupportedOperationException("Unable to generate data upgrade string for: [" + statement.getClass().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); } | @Test public void testSingleRecordInsertStatementGeneration() { final InsertStatement statement = new InsertStatement() .into(new TableReference("TransactionCode")) .values(new FieldLiteral("Z02").as("transactionCode"), new FieldLiteral("Example Description").as("transactionDescription")); assertEquals("Data upgrade description incorrect", String.format("Add record into TransactionCode:" + "%n - Set transactionCode to 'Z02'" + "%n - Set transactionDescription to 'Example Description'"), HumanReadableStatementHelper.generateDataUpgradeString(statement, null)); }
@Test public void testMultipleRecordInsertStatementGeneration() { final InsertStatement statement = new InsertStatement() .into(new TableReference("AgrmmentBllngAddrssFrmTmp")) .from( new SelectStatement(new FieldReference("agreementNumber"), new FieldReference("billingAddressFrameAgreement")) .from("AgreementbillingAddressFrame") .where(Criterion.eq(new FieldReference("extracted"), "N"))); assertEquals("Data upgrade description incorrect", String.format("Add records into AgrmmentBllngAddrssFrmTmp: agreementNumber and billingAddressFrameAgreement from AgreementbillingAddressFrame where extracted is 'N'"), HumanReadableStatementHelper.generateDataUpgradeString(statement, null)); }
@Test public void testUpdateWithoutCriterionStatementGeneration() { final UpdateStatement statement = new UpdateStatement(new TableReference("GenericGlPosting")) .set(new FieldReference("currencyConversionDate").as("valueDate")); assertEquals("Data upgrade description incorrect", String.format("Update records in GenericGlPosting" + "%n - Set valueDate to currencyConversionDate's value"), HumanReadableStatementHelper.generateDataUpgradeString(statement, null)); }
@Test public void testUpdateWithCriterionStatementGeneration() { final UpdateStatement statement = new UpdateStatement(new TableReference("Agreement")) .set(new NullFieldLiteral().as("frequency"), new NullFieldLiteral().as("unit")) .where(Criterion.and( Criterion.isNotNull(new FieldReference("documentCode")), Criterion.or( Criterion.isNull(new FieldReference("productCode")), Criterion.not(Criterion.in(new FieldReference("documentCode"), new SelectStatement(new FieldReference("documentCode")).from("Document")))))); assertEquals("Data upgrade description incorrect", String.format("Update Agreement where documentCode is not null and (productCode is null or documentCode is not in Document)" + "%n - Set frequency to null" + "%n - Set unit to null"), HumanReadableStatementHelper.generateDataUpgradeString(statement, null)); }
@Test public void testDeleteWithoutCriterionStatementGeneration() { final DeleteStatement statement = new DeleteStatement(new TableReference("TransactionCode")); assertEquals("Data upgrade description incorrect", String.format("Delete all records in TransactionCode"), HumanReadableStatementHelper.generateDataUpgradeString(statement, null)); }
@Test public void testDeleteWithCriterionStatementGeneration() { final DeleteStatement statement = new DeleteStatement(new TableReference("TransactionCode")) .where(Criterion.in(new FieldReference("transactionCode"), "Z02", "Z03")); assertEquals("Data upgrade description incorrect", String.format("Delete records in TransactionCode where transactionCode is in ('Z02', 'Z03')"), HumanReadableStatementHelper.generateDataUpgradeString(statement, null)); }
@Test public void testTruncateStatementGeneration() { final TruncateStatement statement = new TruncateStatement(new TableReference("TransactionCode")); assertEquals("Data upgrade description incorrect", String.format("Delete all records in TransactionCode"), HumanReadableStatementHelper.generateDataUpgradeString(statement, null)); }
@Test public void testMergeWithoutCriterionStatementGeneration() { final MergeStatement statement = new MergeStatement() .from(new SelectStatement().from("AgreementbillingAddressFrame")) .into(new TableReference("AgrmmentBllngAddrssFrmTmp")); assertEquals("Data upgrade description incorrect", String.format("Merge records into AgrmmentBllngAddrssFrmTmp from AgreementbillingAddressFrame"), HumanReadableStatementHelper.generateDataUpgradeString(statement, null)); }
@Test public void testMergeWithCriterionStatementGeneration() { final MergeStatement statement = new MergeStatement() .from(new SelectStatement().from("AgreementbillingAddressFrame").where(Criterion.eq(new FieldReference("extracted"), "N"))) .into(new TableReference("AgrmmentBllngAddrssFrmTmp")); assertEquals("Data upgrade description incorrect", String.format("Merge records into AgrmmentBllngAddrssFrmTmp from AgreementbillingAddressFrame where extracted is 'N'"), HumanReadableStatementHelper.generateDataUpgradeString(statement, null)); }
@Test public void testMergeWithNoSourceTable() { final MergeStatement statement = new MergeStatement() .from(new SelectStatement(new FieldLiteral("Z02").as("transactionCode"), new FieldLiteral("Modified example description").as("transactionDescription"))) .into(new TableReference("TransactionCode")); assertEquals("Data upgrade description incorrect", String.format("Merge record into TransactionCode:" + "%n - Set transactionCode to 'Z02'" + "%n - Set transactionDescription to 'Modified example description'"), HumanReadableStatementHelper.generateDataUpgradeString(statement, null)); }
@Test public void testRawSQLStatementGeneration() { final PortableSqlStatement statement = new PortableSqlStatement() .add("FOO", String.format("mysql statements%non multiple lines%nend")) .add("BAR", "oracle statements"); final String oracleResult = HumanReadableStatementHelper.generateDataUpgradeString(statement, "BAR"); final String expectedOracleResult = String.format("Run the following raw SQL statement" + "%n - oracle statements"); assertEquals("Data upgrade description incorrect", expectedOracleResult, oracleResult); final String mySqlResult = HumanReadableStatementHelper.generateDataUpgradeString(statement, "FOO"); final String expectedMySqlResult = String.format("Run the following raw SQL statement" + "%n - mysql statements" + "%n on multiple lines" + "%n end"); assertEquals("Data upgrade description incorrect", expectedMySqlResult, mySqlResult); final String arbitraryResult = HumanReadableStatementHelper.generateDataUpgradeString(statement, null); assertTrue("Data upgrade description incorrect", expectedOracleResult.equals(arbitraryResult) || expectedMySqlResult.equals(arbitraryResult)); } |
HumanReadableStatementHelper { static String generateCriterionString(final Criterion criterion) { return generateCriterionString(criterion, false); } 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); } | @Test public void testCriteriaStrings() { final Criterion eq = Criterion.eq(new FieldReference("a"), 42); final Criterion exists = Criterion.exists(new SelectStatement().from("Bar").where(eq)); final Criterion gt = Criterion.greaterThan(new FieldReference("b"), 42); final Criterion gte = Criterion.greaterThanOrEqualTo(new FieldReference("c"), 42); final Criterion inValues = Criterion.in(new FieldReference("d"), 1, 2, 3); final Criterion inSelect = Criterion.in(new FieldReference("e"), new SelectStatement(new FieldReference("foo")).from("Bar")); final Criterion inList = Criterion.in(new FieldReference("f"), Lists.newArrayList(1, 2, 3)); final Criterion isNotNull = Criterion.isNotNull(new FieldReference("g")); final Criterion isNull = Criterion.isNull(new FieldReference("h")); final Criterion like = Criterion.like(new FieldReference("i"), "%x%"); final Criterion lt = Criterion.lessThan(new FieldReference("j"), 42); final Criterion lte = Criterion.lessThanOrEqualTo(new FieldReference("k"), 42); final Criterion neq = Criterion.neq(new FieldReference("l"), 42); final Criterion and = Criterion.and(eq, inSelect, inValues, isNull); final Criterion or = Criterion.or(eq, and, gt, inSelect); assertEquals("EQ", "a is 42", HumanReadableStatementHelper.generateCriterionString(eq)); assertEquals("EXISTS", "exists Bar where a is 42", HumanReadableStatementHelper.generateCriterionString(exists)); assertEquals("GT", "b is greater than 42", HumanReadableStatementHelper.generateCriterionString(gt)); assertEquals("GTE", "c is greater than or equal to 42", HumanReadableStatementHelper.generateCriterionString(gte)); assertEquals("IN", "d is in (1, 2, 3)", HumanReadableStatementHelper.generateCriterionString(inValues)); assertEquals("IN", "e is in Bar", HumanReadableStatementHelper.generateCriterionString(inSelect)); assertEquals("IN", "f is in (1, 2, 3)", HumanReadableStatementHelper.generateCriterionString(inList)); assertEquals("ISNOTNULL", "g is not null", HumanReadableStatementHelper.generateCriterionString(isNotNull)); assertEquals("ISNULL", "h is null", HumanReadableStatementHelper.generateCriterionString(isNull)); assertEquals("LIKE", "i is like '%x%'", HumanReadableStatementHelper.generateCriterionString(like)); assertEquals("LT", "j is less than 42", HumanReadableStatementHelper.generateCriterionString(lt)); assertEquals("LTE", "k is less than or equal to 42", HumanReadableStatementHelper.generateCriterionString(lte)); assertEquals("NEQ", "l is not 42", HumanReadableStatementHelper.generateCriterionString(neq)); assertEquals("AND", "a is 42 and e is in Bar and d is in (1, 2, 3) and h is null", HumanReadableStatementHelper.generateCriterionString(and)); assertEquals("OR", "a is 42 or (a is 42 and e is in Bar and d is in (1, 2, 3) and h is null) or b is greater than 42 or e is in Bar", HumanReadableStatementHelper.generateCriterionString(or)); assertEquals("!EQ", "a is not 42", HumanReadableStatementHelper.generateCriterionString(Criterion.not(eq))); assertEquals("!EXISTS", "not exists Bar where a is 42", HumanReadableStatementHelper.generateCriterionString(Criterion.not(exists))); assertEquals("!GT", "b is less than or equal to 42", HumanReadableStatementHelper.generateCriterionString(Criterion.not(gt))); assertEquals("!GTE", "c is less than 42", HumanReadableStatementHelper.generateCriterionString(Criterion.not(gte))); assertEquals("!IN", "d is not in (1, 2, 3)", HumanReadableStatementHelper.generateCriterionString(Criterion.not(inValues))); assertEquals("!IN", "e is not in Bar", HumanReadableStatementHelper.generateCriterionString(Criterion.not(inSelect))); assertEquals("!IN", "f is not in (1, 2, 3)", HumanReadableStatementHelper.generateCriterionString(Criterion.not(inList))); assertEquals("!ISNOTNULL", "g is null", HumanReadableStatementHelper.generateCriterionString(Criterion.not(isNotNull))); assertEquals("!ISNULL", "h is not null", HumanReadableStatementHelper.generateCriterionString(Criterion.not(isNull))); assertEquals("!LIKE", "i is not like '%x%'", HumanReadableStatementHelper.generateCriterionString(Criterion.not(like))); assertEquals("!LT", "j is greater than or equal to 42", HumanReadableStatementHelper.generateCriterionString(Criterion.not(lt))); assertEquals("!LTE", "k is greater than 42", HumanReadableStatementHelper.generateCriterionString(Criterion.not(lte))); assertEquals("!NEQ", "l is 42", HumanReadableStatementHelper.generateCriterionString(Criterion.not(neq))); assertEquals("!AND", "a is not 42 or e is not in Bar or d is not in (1, 2, 3) or h is not null", HumanReadableStatementHelper.generateCriterionString(Criterion.not(and))); assertEquals("!OR", "a is not 42 and (a is not 42 or e is not in Bar or d is not in (1, 2, 3) or h is not null) and b is less than or equal to 42 and e is not in Bar", HumanReadableStatementHelper.generateCriterionString(Criterion.not(or))); } |
HumanReadableStatementHelper { static String generateAliasedFieldAssignmentString(final AliasedField field) { if (field instanceof CaseStatement) { final StringBuilder sb = new StringBuilder(); for (WhenCondition when : ((CaseStatement)field).getWhenConditions()) { sb.append(String.format("%n - If %s then set %s to %s", generateCriterionString(when.getCriterion(), false), generateFieldSymbolString(field), generateFieldValueString(when.getValue()))); } sb.append(String.format("%n - Otherwise set %s to %s", generateFieldSymbolString(field), generateFieldValueString(((CaseStatement)field).getDefaultValue()))); return sb.toString(); } else if (field instanceof Cast) { if (((Cast)field).getExpression() instanceof FieldReference) { return String.format("%n - Set %s to %s's value", generateFieldSymbolString(field), ((FieldReference)((Cast)field).getExpression()).getName()); } else { return String.format("%n - Set %s to %s", generateFieldSymbolString(field), generateFieldValueString(field)); } } else if (field instanceof FieldReference) { return String.format("%n - Set %s to %s's value", generateFieldSymbolString(field), ((FieldReference)field).getName()); } else { return String.format("%n - Set %s to %s", generateFieldSymbolString(field), generateFieldValueString(field)); } } 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); } | @Test public void testCaseStatementField() { final NullFieldLiteral defaultValue = new NullFieldLiteral(); final WhenCondition when1 = new WhenCondition(Criterion.eq(new FieldReference("foo"), "Y"), new FieldLiteral(1234)); final WhenCondition when2 = new WhenCondition(Criterion.eq(new FieldReference("foo"), "N"), new FieldLiteral(5678)); CaseStatement field = new CaseStatement(defaultValue, when1, when2); field = (CaseStatement)field.as("bar"); assertEquals("Incorrect strings generated", String.format("%n - If foo is 'Y' then set bar to 1234" + "%n - If foo is 'N' then set bar to 5678" + "%n - Otherwise set bar to null"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(field)); }
@Test public void testCastField() { Cast field1 = new Cast(new FieldReference("foo"), DataType.DECIMAL, 10); field1 = field1.as("bar"); Cast field2 = new Cast(new FieldLiteral("1234"), DataType.DECIMAL, 10); field2 = field2.as("bar"); assertEquals("Incorrect string generated", String.format("%n - Set bar to foo's value"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(field1)); assertEquals("Incorrect string generated", String.format("%n - Set bar to 1234"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(field2)); }
@Test public void testConcatenatedField() { ConcatenatedField field = new ConcatenatedField(new FieldReference("foo"), new FieldLiteral(1234), new FieldLiteral("bar")); field = (ConcatenatedField)field.as("bar"); assertEquals("Incorrect string generated", String.format("%n - Set bar to the concatenation of foo, 1234 and 'bar'"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(field)); }
@Test public void testFieldFromSelect() { final SelectStatement select = new SelectStatement(new FieldReference("foo")).from("ExampleData"); FieldFromSelect field = new FieldFromSelect(select); field = (FieldFromSelect)field.as("bar"); assertEquals("Incorrect string generated", String.format("%n - Set bar to foo from ExampleData"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(field)); }
@Test public void testFieldFromSelectWithJoin() { final SelectStatement select = new SelectStatement(new FieldReference("foo")).from("ExampleData").innerJoin(new TableReference("OtherTable"), Criterion.eq(new FieldReference("x"), new FieldReference("y"))); FieldFromSelect field = new FieldFromSelect(select); field = (FieldFromSelect)field.as("bar"); assertEquals("Incorrect string generated", String.format("%n - Set bar to foo from ExampleData and OtherTable, joined on x is y"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(field)); }
@Test public void testFieldFromSelectWithJoinAndWhere() { final SelectStatement select = new SelectStatement(new FieldReference("foo")).from("ExampleData") .innerJoin(new TableReference("OtherTable"), Criterion.eq(new FieldReference("x"), new FieldReference("y"))) .where(Criterion.eq(new FieldReference("z"), 1)); FieldFromSelect field = new FieldFromSelect(select); field = (FieldFromSelect)field.as("bar"); assertEquals("Incorrect string generated", String.format("%n - Set bar to foo from ExampleData and OtherTable, joined on x is y, where z is 1"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(field)); }
@Test public void testFieldFromSelectFirst() { final SelectFirstStatement select = new SelectFirstStatement(new FieldReference("foo")).from("ExampleData").orderBy(new FieldReference("foo")); FieldFromSelectFirst field = new FieldFromSelectFirst(select); field = (FieldFromSelectFirst)field.as("bar"); assertEquals("Incorrect string generated", String.format("%n - Set bar to first foo from ExampleData ordered by foo"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(field)); }
@Test public void testFunctionField() { final Function count1 = Function.count(); final Function count2 = Function.count(new FieldReference("foo")); final Function max = Function.max(new FieldReference("foo")); final Function min = Function.min(new FieldReference("foo")); final Function sum = Function.sum(new FieldReference("foo")); final Function length = Function.length(new FieldReference("foo")); final Function yyyymmddToDate = Function.yyyymmddToDate(new FieldReference("foo")); final Function dateToYyyymmdd = Function.dateToYyyymmdd(new FieldReference("foo")); final Function substring = Function.substring(new FieldReference("foo"), new FieldLiteral(3), Function.length(new FieldReference("foo")).minus(new FieldLiteral(1))); final Function addDays = Function.addDays(new FieldReference("foo"), new FieldLiteral(42)); final Function round = Function.round(new FieldReference("foo"), new FieldLiteral(2)); final Function floor = Function.floor(new FieldReference("foo")); final Function isnull = Function.isnull(new FieldReference("foo"), new FieldLiteral("N")); final Function mod = Function.mod(new FieldReference("foo"), new FieldLiteral(100)); final Function coalesce = Function.coalesce(new FieldReference("foo"), new FieldReference("foo2"), new FieldLiteral(42)); final AliasedField daysBetween = Function.daysBetween(new FieldReference("foo"), new FieldReference("foo2")); final Function monthsBetween = Function.monthsBetween(new FieldReference("foo"), new FieldReference("foo2")); final Function leftTrim = Function.leftTrim(new FieldReference("foo")); final Function rightTrim = Function.rightTrim(new FieldReference("foo")); final Function random = Function.random(); final Function randomString = Function.randomString(new FieldLiteral(16)); final Function power = Function.power(new FieldReference("foo"), new FieldLiteral(2)); final Function lowerCase = Function.lowerCase(new FieldReference("foo")); final Function upperCase = Function.upperCase(new FieldReference("foo")); final Function leftPad = Function.leftPad(new FieldReference("foo"), new FieldLiteral(32), new FieldLiteral(' ')); final Function now = Function.now(); final Function lastDayOfMonth = Function.lastDayOfMonth(new FieldReference("foo")); assertEquals("COUNT", String.format("%n - Set bar to record count"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(count1.as("bar"))); assertEquals("COUNT", String.format("%n - Set bar to count of foo"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(count2.as("bar"))); assertEquals("MAX", String.format("%n - Set bar to highest foo"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(max.as("bar"))); assertEquals("MIN", String.format("%n - Set bar to lowest foo"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(min.as("bar"))); assertEquals("SUM", String.format("%n - Set bar to sum of foo"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(sum.as("bar"))); assertEquals("LENGTH", String.format("%n - Set bar to length of foo"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(length.as("bar"))); assertEquals("YYYYMMDD_TO_DATE", String.format("%n - Set bar to foo"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(yyyymmddToDate.as("bar"))); assertEquals("DATE_TO_YYYYMMDD", String.format("%n - Set bar to foo"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(dateToYyyymmdd.as("bar"))); assertEquals("SUBSTRING", String.format("%n - Set bar to substring(foo, 3, length of foo - 1)"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(substring.as("bar"))); assertEquals("ADD_DAYS", String.format("%n - Set bar to foo plus 42 days"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(addDays.as("bar"))); assertEquals("ROUND", String.format("%n - Set bar to foo rounded to 2 decimal places"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(round.as("bar"))); assertEquals("FLOOR", String.format("%n - Set bar to floor(foo)"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(floor.as("bar"))); assertEquals("IS_NULL", String.format("%n - Set bar to foo or 'N' if null"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(isnull.as("bar"))); assertEquals("MOD", String.format("%n - Set bar to foo mod 100"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(mod.as("bar"))); assertEquals("COALESCE", String.format("%n - Set bar to first non-null of (foo, foo2, 42)"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(coalesce.as("bar"))); assertEquals("DAYS_BETWEEN", String.format("%n - Set bar to days between foo and foo2"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(daysBetween.as("bar"))); assertEquals("MONTHS_BETWEEN", String.format("%n - Set bar to months between foo and foo2"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(monthsBetween.as("bar"))); assertEquals("LEFT_TRIM", String.format("%n - Set bar to left trimmed foo"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(leftTrim.as("bar"))); assertEquals("RIGHT_TRIM", String.format("%n - Set bar to right trimmed foo"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(rightTrim.as("bar"))); assertEquals("RANDOM", String.format("%n - Set bar to random"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(random.as("bar"))); assertEquals("RANDOM_STRING", String.format("%n - Set bar to random 16 character string"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(randomString.as("bar"))); assertEquals("POWER", String.format("%n - Set bar to foo to the power 2"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(power.as("bar"))); assertEquals("LOWER_CASE", String.format("%n - Set bar to lower case foo"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(lowerCase.as("bar"))); assertEquals("UPPER_CASE", String.format("%n - Set bar to upper case foo"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(upperCase.as("bar"))); assertEquals("LEFT_PAD", String.format("%n - Set bar to leftPad(foo, 32, ' ')"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(leftPad.as("bar"))); assertEquals("NOW", String.format("%n - Set bar to now"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(now.as("bar"))); assertEquals("LAST_DAY_OF_MONTH", String.format("%n - Set bar to last day of month foo"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(lastDayOfMonth.as("bar"))); }
@Test public void testMathsField() { final AliasedField field = new MathsField(new FieldReference("foo"), MathsOperator.PLUS, new FieldLiteral(42)).as("bar"); assertEquals("Incorrect string generated", String.format("%n - Set bar to foo + 42"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(field)); }
@Test public void testBracketExpression() { final MathsField field = new MathsField(new FieldReference("foo"), MathsOperator.PLUS, new FieldLiteral(42)); final AliasedField bracketExpression = new BracketedExpression(field).as("bar"); assertEquals("Incorrect string generated", String.format("%n - Set bar to (foo + 42)"), HumanReadableStatementHelper.generateAliasedFieldAssignmentString(bracketExpression)); } |
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(); } | @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")); } |
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(); } | @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) { } } |
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(); } | @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()); } |
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); } | @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); } |
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(); } | @Test public void testSerializability() throws Exception { final ByteArraySchema schema = new ByteArraySchema(); final ByteArraySchema copy = CommonTestUtils.createCopySerializable(schema); assertEquals(schema.getProducedType(), copy.getProducedType()); } |
AwaitingAdmissionVisitQueryEvaluator implements VisitQueryEvaluator { @Override public VisitQueryResult evaluate(VisitQuery visitQuery, EvaluationContext evaluationContext) throws EvaluationException { AwaitingAdmissionVisitQuery eq = (AwaitingAdmissionVisitQuery) visitQuery; Location location = eq.getLocation(); Location visitLocation = null ; if (location != null ) { visitLocation = adtService.getLocationThatSupportsVisits(location); } HqlQueryBuilder query = new HqlQueryBuilder(); query.select("distinct visit.visitId").from(Visit.class, "visit") .innerJoin("visit.encounters", "dispoEncounter") .innerJoin("dispoEncounter.obs", "dispo") .whereEqual("dispo.concept", dispositionService.getDispositionDescriptor().getDispositionConcept()) .whereIn("dispo.valueCoded", AdtUtil.getAdmissionDispositionsConcepts(emrConceptService, dispositionService)) .whereEqual("dispo.voided", false) .whereEqual("dispoEncounter.voided", false) .whereEqual("visit.voided", false) .whereEqual("visit.location", visitLocation) .whereEqual("visit.patient.dead", false) .whereNull("visit.stopDatetime") .where("(select count(*) from Encounter as admission " + "where admission.visit = visit " + "and admission.voided = false " + "and admission.encounterType = :admissionEncounterType" + ") = 0") .where("(select count(*) from Obs as admitDecision inner join admitDecision.encounter as encounterInVisit " + "where encounterInVisit.visit = visit " + "and encounterInVisit.voided = false " + "and admitDecision.voided = false " + "and admitDecision.concept = :admissionDecisionConcept " + "and admitDecision.valueCoded = :denyAdmissionConcept " + "and encounterInVisit.encounterDatetime > dispoEncounter.encounterDatetime " + ") = 0") .whereVisitIn("visit", evaluationContext) .withValue("admissionEncounterType", emrApiProperties.getAdmissionEncounterType()) .withValue("admissionDecisionConcept", emrApiProperties.getAdmissionDecisionConcept()) .withValue("denyAdmissionConcept", emrApiProperties.getDenyAdmissionConcept()); VisitQueryResult result = new VisitQueryResult(visitQuery, evaluationContext); List<Integer> results= evaluationService.evaluateToList(query, Integer.class, evaluationContext); result.add(results.toArray(new Integer[results.size()])); return result; } @Override VisitQueryResult evaluate(VisitQuery visitQuery, EvaluationContext evaluationContext); } | @Test public void shouldFindVisitAwaitingAdmission() throws Exception { Patient patient = testDataManager.randomPatient().save(); Visit visit = testDataManager.visit() .patient(patient) .visitType(emrApiProperties.getAtFacilityVisitType()) .started(new Date()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new Date()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .save(); VisitQueryResult result = visitQueryService.evaluate(query, null); assertThat(result.getMemberIds().size(), is(1)); assertThat(result.getMemberIds().iterator().next(), is(visit.getId())); }
@Test public void shouldNotCountDispositionOnVoidedEncounter() throws Exception { Patient patient = testDataManager.randomPatient().save(); Visit visit = testDataManager.visit() .patient(patient) .visitType(emrApiProperties.getAtFacilityVisitType()) .started(new Date()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new Date()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .voided(true) .dateVoided(new Date()) .voidReason("test") .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .save(); VisitQueryResult result = visitQueryService.evaluate(query, null); assertThat(result.getMemberIds().size(), is(0)); }
@Test public void shouldNotFindVisitIfPatientAdmitted() throws Exception { Patient patient = testDataManager.randomPatient().save(); Date visitDatetime = new DateTime(2014,2,2,9,0,0).toDate(); Date visitNoteDatetime = new DateTime(2014,2,2,10,0,0).toDate(); Date admitDatetime = new DateTime(2014,2,2,11,0,0).toDate(); Visit visit = testDataManager.visit() .patient(patient) .visitType(emrApiProperties.getAtFacilityVisitType()) .started(visitDatetime) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(visitNoteDatetime) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(admitDatetime) .encounterType(emrApiProperties.getAdmissionEncounterType()) .get()) .save(); VisitQueryResult result = visitQueryService.evaluate(query, null); assertThat(result.getMemberIds().size(), is(0)); }
@Test public void shouldNotConsiderVoidedAdmissionEncounter() throws Exception { Patient patient = testDataManager.randomPatient().save(); Date visitDatetime = new DateTime(2014,2,2,9,0,0).toDate(); Date visitNoteDatetime = new DateTime(2014,2,2,10,0,0).toDate(); Date admitDatetime = new DateTime(2014,2,2,11,0,0).toDate(); Visit visit = testDataManager.visit() .patient(patient) .visitType(emrApiProperties.getAtFacilityVisitType()) .started(visitDatetime) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(visitNoteDatetime) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(admitDatetime) .encounterType(emrApiProperties.getAdmissionEncounterType()) .voided(true) .dateVoided(new Date()) .voidReason("test") .get()) .save(); VisitQueryResult result = visitQueryService.evaluate(query, null); assertThat(result.getMemberIds().size(), is(1)); assertThat(result.getMemberIds().iterator().next(), is(visit.getId())); }
@Test public void shouldFindVisitEvenIfPatientHasMoreRecentVisitNoteWithoutAdmissionDisposition() throws Exception { Patient patient = testDataManager.randomPatient().save(); Date visitDatetime = new DateTime(2014,2,2,9,0,0).toDate(); Date firstVisitNoteDatetime = new DateTime(2014,2,2,10,0,0).toDate(); Date secondVisitNoteDatetime = new DateTime(2014,2,2,11,0,0).toDate(); Visit visit = testDataManager.visit() .patient(patient) .visitType(emrApiProperties.getAtFacilityVisitType()) .started(visitDatetime) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(firstVisitNoteDatetime) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(secondVisitNoteDatetime) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Death")) .get()) .get()) .save(); VisitQueryResult result = visitQueryService.evaluate(query, null); assertThat(result.getMemberIds().size(), is(1)); assertThat(result.getMemberIds().iterator().next(), is(visit.getId())); }
@Test public void shouldNotFindVisitIfNoAdmitDisposition() throws Exception { Patient patient = testDataManager.randomPatient().save(); Date visitDatetime = new DateTime(2014,2,2,9,0,0).toDate(); Date visitNoteDatetime = new DateTime(2014,2,2,10,0,0).toDate(); Visit visit = testDataManager.visit() .patient(patient) .visitType(emrApiProperties.getAtFacilityVisitType()) .started(visitDatetime) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(visitNoteDatetime) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Death")) .get()) .get()) .save(); VisitQueryResult result = visitQueryService.evaluate(query, null); assertThat(result.getMemberIds().size(), is(0)); }
@Test public void shouldNotFindVisitIfAtAnotherLocation() throws Exception { Patient patient = testDataManager.randomPatient().save(); Location visitLocation = testDataManager.location().name("Visit Location") .tag(EmrApiConstants.LOCATION_TAG_SUPPORTS_VISITS).save(); Location queryLocation = testDataManager.location().name("Query Location") .tag(EmrApiConstants.LOCATION_TAG_SUPPORTS_VISITS).save(); Visit visit = testDataManager.visit() .patient(patient) .visitType(emrApiProperties.getAtFacilityVisitType()) .location(visitLocation) .started(new Date()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new Date()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .save(); query.setLocation(queryLocation); VisitQueryResult result = visitQueryService.evaluate(query, null); assertThat(result.getMemberIds().size(), is(0)); }
@Test public void shouldFindVisitIfAtSameLocation() throws Exception { Patient patient = testDataManager.randomPatient().save(); Location visitLocation = testDataManager.location().name("Visit Location") .tag(EmrApiConstants.LOCATION_TAG_SUPPORTS_VISITS).save(); Location queryLocation = visitLocation; Visit visit = testDataManager.visit() .patient(patient) .visitType(emrApiProperties.getAtFacilityVisitType()) .location(visitLocation) .started(new Date()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new Date()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .save(); query.setLocation(queryLocation); VisitQueryResult result = visitQueryService.evaluate(query, null); assertThat(result.getMemberIds().size(), is(1)); assertThat(result.getMemberIds().iterator().next(), is(visit.getId())); }
@Test public void shouldNotReturnSameVisitTwice() throws Exception { Patient patient = testDataManager.randomPatient().save(); Visit visit = testDataManager.visit() .patient(patient) .visitType(emrApiProperties.getAtFacilityVisitType()) .started(new Date()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new Date()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new Date()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .save(); VisitQueryResult result = visitQueryService.evaluate(query, null); assertThat(result.getMemberIds().size(), is(1)); assertThat(result.getMemberIds().iterator().next(), is(visit.getId())); }
@Test public void shouldNotFindVisitAwaitingAdmissionIfPatientNotInContext() throws Exception { Patient patient = testDataManager.randomPatient().save(); Visit visit = testDataManager.visit() .patient(patient) .visitType(emrApiProperties.getAtFacilityVisitType()) .started(new Date()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new Date()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .save(); EvaluationContext context = new EvaluationContext(); context.setBaseCohort(new Cohort(Collections.singleton(2))); VisitQueryResult result = visitQueryService.evaluate(query, context); assertThat(result.getMemberIds().size(), is(0)); }
@Test public void shouldNotFindVisitAwaitingAdmissionIfVisitNotInContext() throws Exception { Patient patient = testDataManager.randomPatient().save(); Visit visit = testDataManager.visit() .patient(patient) .visitType(emrApiProperties.getAtFacilityVisitType()) .started(new Date()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new Date()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .save(); VisitEvaluationContext context = new VisitEvaluationContext(); context.setBaseVisits(new VisitIdSet(10101)); VisitQueryResult result = visitQueryService.evaluate(query, context); assertThat(result.getMemberIds().size(), is(0)); }
@Test public void shouldNotFindVisitWithDispositionOfAdmitIfFollowedByAdmissionDenialObs() throws Exception { Patient patient = testDataManager.randomPatient().save(); Visit visit = testDataManager.visit() .patient(patient) .visitType(emrApiProperties.getAtFacilityVisitType()) .started(new Date()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new DateTime(2014,10,10,10,0,0).toDate()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new DateTime(2014,10,11,10,0,0).toDate()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(emrApiProperties.getAdmissionDecisionConcept()) .value(emrApiProperties.getDenyAdmissionConcept()) .get()) .get()) .save(); VisitQueryResult result = visitQueryService.evaluate(query, null); assertThat(result.getMemberIds().size(), is(0)); }
@Test public void shouldFindVisitWithDispositionOfAdmitIfFollowedByAdmissionDenialObsFollowedByAnotherAdmissionDisposition() throws Exception { Patient patient = testDataManager.randomPatient().save(); Visit visit = testDataManager.visit() .patient(patient) .visitType(emrApiProperties.getAtFacilityVisitType()) .started(new Date()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new DateTime(2014,10,10,10,0,0).toDate()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new DateTime(2014,10,11,10,0,0).toDate()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(emrApiProperties.getAdmissionDecisionConcept()) .value(emrApiProperties.getDenyAdmissionConcept()) .get()) .get()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new DateTime(2014,10,12,10,0,0).toDate()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .save(); VisitQueryResult result = visitQueryService.evaluate(query, null); assertThat(result.getMemberIds().size(), is(1)); assertThat(result.getMemberIds().iterator().next(), is(visit.getId())); }
@Test public void shouldNotFindVisitWithDispositionOfAdmitIfFollowedByAdmissionDenialObsFollowedByAnotherAdmissionDispositionFollowedByAnotherAdmissionDenial() throws Exception { Patient patient = testDataManager.randomPatient().save(); Visit visit = testDataManager.visit() .patient(patient) .visitType(emrApiProperties.getAtFacilityVisitType()) .started(new Date()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new DateTime(2014,10,10,10,0,0).toDate()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new DateTime(2014,10,11,10,0,0).toDate()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(emrApiProperties.getAdmissionDecisionConcept()) .value(emrApiProperties.getDenyAdmissionConcept()) .get()) .get()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new DateTime(2014,10,12,10,0,0).toDate()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new DateTime(2014,10,13,10,0,0).toDate()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(emrApiProperties.getAdmissionDecisionConcept()) .value(emrApiProperties.getDenyAdmissionConcept()) .get()) .get()) .save(); VisitQueryResult result = visitQueryService.evaluate(query, null); assertThat(result.getMemberIds().size(), is(0)); }
@Test public void shouldFindVisitWithDispositionOfAdmitIfFollowedByAdmissionDecisionThatIsNotDeny() throws Exception { Patient patient = testDataManager.randomPatient().save(); Visit visit = testDataManager.visit() .patient(patient) .visitType(emrApiProperties.getAtFacilityVisitType()) .started(new Date()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new DateTime(2014,10,10,10,0,0).toDate()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new DateTime(2014,10,11,10,0,0).toDate()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(emrApiProperties.getAdmissionDecisionConcept()) .get()) .get()) .save(); VisitQueryResult result = visitQueryService.evaluate(query, null); assertThat(result.getMemberIds().size(), is(1)); assertThat(result.getMemberIds().iterator().next(), is(visit.getId())); }
@Test public void shouldFindVisitWithDispositionOfAdmitIfPrecededByAdmissionDenialObs() throws Exception { Patient patient = testDataManager.randomPatient().save(); Visit visit = testDataManager.visit() .patient(patient) .visitType(emrApiProperties.getAtFacilityVisitType()) .started(new Date()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new DateTime(2014,10,10,10,0,0).toDate()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new DateTime(2014,10,9,10,0,0).toDate()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(emrApiProperties.getAdmissionDecisionConcept()) .value(emrApiProperties.getDenyAdmissionConcept()) .get()) .get()) .save(); VisitQueryResult result = visitQueryService.evaluate(query, null); assertThat(result.getMemberIds().size(), is(1)); assertThat(result.getMemberIds().iterator().next(), is(visit.getId())); }
@Test public void shouldFindVisitWithDispositionOfAdmitIfFollowedByAdmissionDenialObsThatIsVoided() throws Exception { Patient patient = testDataManager.randomPatient().save(); Visit visit = testDataManager.visit() .patient(patient) .visitType(emrApiProperties.getAtFacilityVisitType()) .started(new Date()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new DateTime(2014,10,10,10,0,0).toDate()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new DateTime(2014,10,11,10,0,0).toDate()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(emrApiProperties.getAdmissionDecisionConcept()) .value(emrApiProperties.getDenyAdmissionConcept()) .voided(true) .get()) .get()) .save(); VisitQueryResult result = visitQueryService.evaluate(query, null); assertThat(result.getMemberIds().size(), is(1)); assertThat(result.getMemberIds().iterator().next(), is(visit.getId())); }
@Test public void shouldNotFindVisitAwaitingAdmissionIfPatientIsDead() throws Exception { Patient patient = testDataManager.randomPatient() .dead(true) .deathDate(new Date()) .causeOfDeath(conceptService.getConcept(3)) .save(); Visit visit = testDataManager.visit() .patient(patient) .visitType(emrApiProperties.getAtFacilityVisitType()) .started(new Date()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(new Date()) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value(emrConceptService.getConcept("org.openmrs.module.emrapi:Admit to hospital")) .get()) .get()) .save(); VisitQueryResult result = visitQueryService.evaluate(query, null); assertThat(result.getMemberIds().size(), is(0)); } |
EmrOrderServiceImpl_1_12 implements EmrOrderService { @Override public void saveOrders(List<EncounterTransaction.Order> orders, Encounter encounter) { Set<OrderGroup> orderGroups = new LinkedHashSet<OrderGroup>(); for (EncounterTransaction.Order order : orders) { OrderGroup orderGroup = mapToOpenMRSOrderGroup(orderGroups, order.getOrderGroup(), encounter); Order omrsOrder = openMRSOrderMapper.map(order, encounter); omrsOrder.setOrderGroup(orderGroup); encounter.addOrder(omrsOrder); } encounterService.saveEncounter(encounter); } @Autowired EmrOrderServiceImpl_1_12(OpenMRSDrugOrderMapper openMRSDrugOrderMapper, EncounterService encounterService,
OpenMRSOrderMapper openMRSOrderMapper, OrderSetService orderSetService,
OpenMRSOrderGroupMapper openMRSOrderGroupMapper); @Override void save(List<EncounterTransaction.DrugOrder> drugOrders, Encounter encounter); @Override void saveOrders(List<EncounterTransaction.Order> orders, Encounter encounter); } | @Test public void shouldSaveOrdersToEncounterWithExistingOrders() throws ParseException { EmrOrderServiceImpl_1_12 emrOrderService = new EmrOrderServiceImpl_1_12(openMRSDrugOrderMapper, encounterService, openMRSOrderMapper, orderSetService, openMRSOrderGroupMapper); EncounterTransaction.Order order1 = new OrderBuilder().withConceptUuid("concept-uuid1").withComment("Comment").build(); EncounterTransaction.Order order2 = new OrderBuilder().withConceptUuid("concept-uuid2").withComment("Comment").build(); Order mappedOrder1 = new Order(); Concept concept = new Concept(); concept.setUuid("concept-uuid1"); mappedOrder1.setConcept(concept); mappedOrder1.setCommentToFulfiller("Comment"); Order mappedOrder2 = new Order(); concept = new Concept(); concept.setUuid("concept-uuid2"); mappedOrder2.setConcept(concept); mappedOrder2.setCommentToFulfiller("Comment"); Order existingOrder1 = new Order(); Order existingOrder2 = new Order(); Encounter encounter = new Encounter(); encounter.addOrder(existingOrder1); encounter.addOrder(existingOrder2); when(openMRSOrderMapper.map(order1,encounter)).thenReturn(mappedOrder1); when(openMRSOrderMapper.map(order2,encounter)).thenReturn(mappedOrder2); emrOrderService.saveOrders(Arrays.asList(order1, order2), encounter); ArgumentCaptor<Encounter> encounterArgumentCaptor = ArgumentCaptor.forClass(Encounter.class); verify(encounterService).saveEncounter(encounterArgumentCaptor.capture()); Encounter savedEncounter = encounterArgumentCaptor.getValue(); ArrayList<Order> savedOrders = new ArrayList<Order>(savedEncounter.getOrders()); assertThat(savedOrders.size(), is(4)); assertTrue(existsInOrdersList(mappedOrder1, savedOrders)); assertTrue(existsInOrdersList(mappedOrder2, savedOrders)); }
@Test public void shouldSaveOrders() throws ParseException { EmrOrderServiceImpl_1_12 emrOrderService = new EmrOrderServiceImpl_1_12(openMRSDrugOrderMapper, encounterService, openMRSOrderMapper, orderSetService, openMRSOrderGroupMapper); EncounterTransaction.Order order1 = new OrderBuilder().withConceptUuid("concept-uuid1").withComment("Comment").build(); EncounterTransaction.Order order2 = new OrderBuilder().withConceptUuid("concept-uuid2").withComment("Comment").build(); Order mappedOrder1 = new Order(); Concept concept = new Concept(); concept.setUuid("concept-uuid1"); mappedOrder1.setConcept(concept); mappedOrder1.setCommentToFulfiller("Comment"); Order mappedOrder2 = new Order(); concept = new Concept(); concept.setUuid("concept-uuid2"); mappedOrder2.setConcept(concept); mappedOrder2.setCommentToFulfiller("Comment"); Encounter encounter = new Encounter(); when(openMRSOrderMapper.map(order1,encounter)).thenReturn(mappedOrder1); when(openMRSOrderMapper.map(order2,encounter)).thenReturn(mappedOrder2); emrOrderService.saveOrders(Arrays.asList(order1, order2), encounter); ArgumentCaptor<Encounter> encounterArgumentCaptor = ArgumentCaptor.forClass(Encounter.class); verify(encounterService).saveEncounter(encounterArgumentCaptor.capture()); Encounter savedEncounter = encounterArgumentCaptor.getValue(); ArrayList<Order> savedOrders = new ArrayList<Order>(savedEncounter.getOrders()); assertThat(savedOrders.size(), is(2)); assertTrue(existsInOrdersList(mappedOrder1, savedOrders)); assertTrue(existsInOrdersList(mappedOrder2, savedOrders)); }
@Test public void shouldSaveOrdersWithOrderGroups() throws ParseException { EmrOrderServiceImpl_1_12 emrOrderService = new EmrOrderServiceImpl_1_12(openMRSDrugOrderMapper, encounterService, openMRSOrderMapper, orderSetService, openMRSOrderGroupMapper); EncounterTransaction.Order order1 = new OrderBuilder().withConceptUuid("concept-uuid1").withComment("Comment").withOrderGroup("orderSet-uuid1").build(); EncounterTransaction.Order order2 = new OrderBuilder().withConceptUuid("concept-uuid2").withComment("Comment").withOrderGroup("orderSet-uuid1").build(); EncounterTransaction.Order order3 = new OrderBuilder().withConceptUuid("concept-uuid3").withComment("Comment").withOrderGroup("orderSet-uuid2").build(); Encounter encounter = new Encounter(); Patient patient = new Patient(); OrderGroup mappedOrderGroup1 = new OrderGroup(); mappedOrderGroup1.setEncounter(encounter); mappedOrderGroup1.setPatient(patient); OrderSet orderSet1 = new OrderSet(); mappedOrderGroup1.setOrderSet(orderSet1); OrderGroup mappedOrderGroup2 = new OrderGroup(); mappedOrderGroup2.setEncounter(encounter); mappedOrderGroup2.setPatient(patient); OrderSet orderSet2 = new OrderSet(); mappedOrderGroup2.setOrderSet(orderSet2); Order mappedOrder1 = new Order(); Concept concept = new Concept(); concept.setUuid("concept-uuid1"); mappedOrder1.setConcept(concept); mappedOrder1.setOrderGroup(mappedOrderGroup1); mappedOrder1.setCommentToFulfiller("Comment"); Order mappedOrder2 = new Order(); concept = new Concept(); concept.setUuid("concept-uuid2"); mappedOrder2.setConcept(concept); mappedOrder2.setOrderGroup(mappedOrderGroup1); mappedOrder2.setCommentToFulfiller("Comment"); Order mappedOrder3 = new Order(); concept = new Concept(); concept.setUuid("concept-uuid3"); mappedOrder2.setConcept(concept); mappedOrder3.setOrderGroup(mappedOrderGroup2); mappedOrder2.setCommentToFulfiller("Comment"); when(openMRSOrderMapper.map(order1,encounter)).thenReturn(mappedOrder1); when(openMRSOrderMapper.map(order2,encounter)).thenReturn(mappedOrder2); when(openMRSOrderMapper.map(order3,encounter)).thenReturn(mappedOrder3); when(openMRSOrderGroupMapper.map(order1.getOrderGroup(), encounter)).thenReturn(mappedOrderGroup1); when(openMRSOrderGroupMapper.map(order2.getOrderGroup(), encounter)).thenReturn(mappedOrderGroup1); when(openMRSOrderGroupMapper.map(order3.getOrderGroup(), encounter)).thenReturn(mappedOrderGroup2); when(orderSetService.getOrderSetByUuid(order1.getOrderGroup().getOrderSet().getUuid())).thenReturn(mappedOrder1.getOrderGroup().getOrderSet()); when(orderSetService.getOrderSetByUuid(order2.getOrderGroup().getOrderSet().getUuid())).thenReturn(mappedOrder2.getOrderGroup().getOrderSet()); when(orderSetService.getOrderSetByUuid(order3.getOrderGroup().getOrderSet().getUuid())).thenReturn(mappedOrder3.getOrderGroup().getOrderSet()); emrOrderService.saveOrders(Arrays.asList(order1, order2, order3), encounter); ArgumentCaptor<Encounter> encounterArgumentCaptor = ArgumentCaptor.forClass(Encounter.class); verify(encounterService).saveEncounter(encounterArgumentCaptor.capture()); Encounter savedEncounter = encounterArgumentCaptor.getValue(); ArrayList<Order> savedOrders = new ArrayList<Order>(savedEncounter.getOrders()); assertThat(savedOrders.size(), is(3)); HashMap<String, OrderGroup> orderGroups = new HashMap<String, OrderGroup>(); for (Order savedOrder : savedOrders) { if (savedOrder.getOrderGroup() != null) { orderGroups.put(savedOrder.getOrderGroup().getOrderSet().getUuid(), savedOrder.getOrderGroup()); } } assertEquals(2, orderGroups.size()); } |
MostRecentAdmissionRequestVisitDataEvaluator implements VisitDataEvaluator { @Override public EvaluatedVisitData evaluate(VisitDataDefinition visitDataDefinition, EvaluationContext evaluationContext) throws EvaluationException { EvaluatedVisitData data = new EvaluatedVisitData(visitDataDefinition, evaluationContext); HqlQueryBuilder query = new HqlQueryBuilder(); query.select("encounter.visit.id, encounter").from(Encounter.class, "encounter") .innerJoin("encounter.obs", "dispo") .whereEqual("dispo.concept", dispositionService.getDispositionDescriptor().getDispositionConcept()) .whereIn("dispo.valueCoded", AdtUtil.getAdmissionDispositionsConcepts(emrConceptService, dispositionService)) .whereEqual("dispo.voided", false) .whereEqual("encounter.voided", false) .whereVisitIn("encounter.visit.id", evaluationContext); List<Object[]> result = evaluationService.evaluateToList(query, evaluationContext); for (Object[] row : result) { Integer visitId = (Integer) row[0]; Encounter encounter = (Encounter) row[1]; if (data.getData().containsKey(visitId)) { Map<String,Object> resultRow = (Map<String,Object>) data.getData().get(visitId); if (encounter.getEncounterDatetime().before((Date) resultRow.get("datetime"))) { continue; } } Map<String,Object> resultRow = new HashMap<String, Object>(); resultRow.put("fromLocation", encounter.getLocation()); resultRow.put("toLocation", getToLocation(encounter, dispositionService, locationService)); resultRow.put("datetime", encounter.getEncounterDatetime()); resultRow.put("provider", getProvider(encounter)); resultRow.put("diagnoses", diagnosisService.getPrimaryDiagnoses(encounter)); data.getData().put(visitId, resultRow); } return data; } @Override EvaluatedVisitData evaluate(VisitDataDefinition visitDataDefinition, EvaluationContext evaluationContext); } | @Test public void shouldReturnMostRecentAdmissionRequestForVisit() throws Exception { EncounterRole encounterRole = testDataManager.getEncounterService().getEncounterRole(1); Patient patient = testDataManager.randomPatient().save(); Concept firstCodedDiagnosisConcept = conceptService.getConcept(3); Concept secondCodedDiagnosisConcept = conceptService.getConcept(4); Provider mostRecentProvider = testDataManager.randomProvider().save(); Location mostRecentLocation = testDataManager.getLocationService().getLocation(1); Date mostRecentDate = new DateTime(2014,1,1,12,0,0).toDate(); Provider otherProvider = testDataManager.randomProvider().save(); Location otherLocation = testDataManager.getLocationService().getLocation(2); Date otherDate = new DateTime(2014,1,1,11,0,0).toDate(); Location mostRecentAdmissionLocation = testDataManager.getLocationService().getLocation(3); Location otherAdmissionLocation = testDataManager.getLocationService().getLocation(1); Visit visit = testDataManager.visit() .patient(patient) .visitType(emrApiProperties.getAtFacilityVisitType()) .started(new Date()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(mostRecentDate) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .provider(encounterRole, mostRecentProvider) .location(mostRecentLocation) .obs(testDataManager.obs() .concept(diagnosisMetadata.getDiagnosisSetConcept()) .obs(testDataManager.obs() .concept(diagnosisMetadata.getCodedDiagnosisConcept()) .value(firstCodedDiagnosisConcept) .get()) .obs(testDataManager.obs() .concept(diagnosisMetadata.getDiagnosisOrderConcept()) .value("Primary", "org.openmrs.module.emrapi") .get()) .get()) .obs(testDataManager.obs() .concept(diagnosisMetadata.getDiagnosisSetConcept()) .obs(testDataManager.obs() .concept(diagnosisMetadata.getCodedDiagnosisConcept()) .value(secondCodedDiagnosisConcept) .get()) .obs(testDataManager.obs() .concept(diagnosisMetadata.getDiagnosisOrderConcept()) .value("Secondary", "org.openmrs.module.emrapi") .get()) .get()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionSetConcept()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .value("Admit to hospital", "org.openmrs.module.emrapi") .get()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getAdmissionLocationConcept()) .value("3") .get()) .get()) .obs(testDataManager.obs() .concept(diagnosisMetadata.getDiagnosisSetConcept()) .obs(testDataManager.obs() .concept(diagnosisMetadata.getNonCodedDiagnosisConcept()) .value("some diagnosis") .get()) .obs(testDataManager.obs() .concept(diagnosisMetadata.getDiagnosisOrderConcept()) .value("Primary", "org.openmrs.module.emrapi") .get()) .get()) .get()) .encounter(testDataManager.encounter() .patient(patient) .encounterDatetime(otherDate) .encounterType(emrApiProperties.getVisitNoteEncounterType()) .provider(encounterRole, otherProvider) .location(otherLocation) .obs(testDataManager.obs() .concept(diagnosisMetadata.getDiagnosisSetConcept()) .obs(testDataManager.obs() .concept(diagnosisMetadata.getCodedDiagnosisConcept()) .value(secondCodedDiagnosisConcept) .get()) .obs(testDataManager.obs() .concept(diagnosisMetadata.getDiagnosisOrderConcept()) .value("Primary", "org.openmrs.module.emrapi") .get()) .get()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionSetConcept()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getDispositionConcept()) .get()) .obs(testDataManager.obs() .concept(dispositionDescriptor.getAdmissionLocationConcept()) .value("1") .get()) .get()) .get()) .save(); new VisitIdSet(visit.getId()); EvaluatedVisitData data = visitDataService.evaluate(def, context); assertThat(data.getData().size(), is(1)); assertThat( (Date) ((Map<String,Object>) data.getData().get(visit.getId())).get("datetime"), is(mostRecentDate)); assertThat( (Provider) ((Map<String,Object>) data.getData().get(visit.getId())).get("provider"), is(mostRecentProvider)); assertThat( (Location) ((Map<String,Object>) data.getData().get(visit.getId())).get("fromLocation"), is(mostRecentLocation)); assertThat( (Location) ((Map<String,Object>) data.getData().get(visit.getId())).get("toLocation"), is(mostRecentAdmissionLocation)); List<Diagnosis> diagnoses = (List<Diagnosis>) ((Map<String,Object>) data.getData().get(visit.getId())).get("diagnoses"); assertThat(diagnoses.size(), is(2)); if (diagnoses.get(0).getDiagnosis().getCodedAnswer() != null) { assertThat(diagnoses.get(0).getDiagnosis().getCodedAnswer(), is(firstCodedDiagnosisConcept)); assertThat(diagnoses.get(1).getDiagnosis().getNonCodedAnswer(), is("some diagnosis")); } else { assertThat(diagnoses.get(1).getDiagnosis().getCodedAnswer(), is(firstCodedDiagnosisConcept)); assertThat(diagnoses.get(0).getDiagnosis().getNonCodedAnswer(), is("some diagnosis")); } } |
EmrApiProperties extends ModuleProperties { public int getVisitExpireHours() { return NumberUtils.toInt(getGlobalProperty(EmrApiConstants.GP_VISIT_EXPIRE_HOURS, false), EmrApiConstants.DEFAULT_VISIT_EXPIRE_HOURS); } @Override String getMetadataSourceName(); Location getUnknownLocation(); Provider getUnknownProvider(); EncounterRole getOrderingProviderEncounterRole(); Role getFullPrivilegeLevel(); Role getHighPrivilegeLevel(); EncounterType getCheckInEncounterType(); EncounterRole getCheckInClerkEncounterRole(); EncounterType getVisitNoteEncounterType(); @Deprecated // use visit note encounter type, as "Visit Note" is the proper naming convention EncounterType getConsultEncounterType(); EncounterRole getClinicianEncounterRole(); EncounterType getAdmissionEncounterType(); EncounterType getExitFromInpatientEncounterType(); EncounterType getTransferWithinHospitalEncounterType(); Form getAdmissionForm(); Form getDischargeForm(); Form getTransferForm(); int getVisitExpireHours(); VisitType getAtFacilityVisitType(); LocationTag getSupportsVisitsLocationTag(); LocationTag getSupportsLoginLocationTag(); LocationTag getSupportsAdmissionLocationTag(); LocationTag getSupportsTransferLocationTag(); PersonAttributeType getTestPatientPersonAttributeType(); PersonAttributeType getTelephoneAttributeType(); PersonAttributeType getUnknownPatientPersonAttributeType(); PatientIdentifierType getPrimaryIdentifierType(); List<PatientIdentifierType> getExtraPatientIdentifierTypes(); DiagnosisMetadata getDiagnosisMetadata(); List<ConceptSource> getConceptSourcesForDiagnosisSearch(); ConceptSource getEmrApiConceptSource(); Concept getUnknownCauseOfDeathConcept(); Concept getAdmissionDecisionConcept(); Concept getDenyAdmissionConcept(); List<PatientIdentifierType> getIdentifierTypesToSearch(); Collection<Concept> getDiagnosisSets(); Collection<Concept> getNonDiagnosisConceptSets(); Collection<Concept> getSuppressedDiagnosisConcepts(); ConceptMapType getSameAsConceptMapType(); ConceptMapType getNarrowerThanConceptMapType(); Integer getLastViewedPatientSizeLimit(); File getPersonImageDirectory(); Boolean getVisitAssignmentHandlerAdjustEncounterTimeOfDayIfNecessary(); } | @Test public void visitExpireHours_shouldBeConfiguredValueFromGlobalProperty(){ when(administrationService.getGlobalProperty(EmrApiConstants.GP_VISIT_EXPIRE_HOURS)).thenReturn("10"); assertEquals(10, emrApiProperties.getVisitExpireHours()); }
@Test public void visitExpireHours_shouldBeDefaultValueWhenNotConfigured(){ when(administrationService.getGlobalProperty(EmrApiConstants.GP_VISIT_EXPIRE_HOURS)).thenReturn(null); assertEquals(EmrApiConstants.DEFAULT_VISIT_EXPIRE_HOURS, emrApiProperties.getVisitExpireHours()); }
@Test public void visitExpireHours_shouldBeDefaultValueWhenNotConfiguredAsNonInteger(){ when(administrationService.getGlobalProperty(EmrApiConstants.GP_VISIT_EXPIRE_HOURS)).thenReturn("foo"); assertEquals(EmrApiConstants.DEFAULT_VISIT_EXPIRE_HOURS, emrApiProperties.getVisitExpireHours()); } |
DosingInstructionsMapper { public DrugOrder map(EncounterTransaction.DosingInstructions dosingInstructions, DrugOrder drugOrder) { drugOrder.setDose(dosingInstructions.getDose()); drugOrder.setDoseUnits(conceptByName(dosingInstructions.getDoseUnits())); drugOrder.setDosingInstructions(dosingInstructions.getAdministrationInstructions()); drugOrder.setRoute(conceptByName(dosingInstructions.getRoute())); drugOrder.setAsNeeded(dosingInstructions.getAsNeeded()); drugOrder.setFrequency(orderMetadataService.getOrderFrequencyByName(dosingInstructions.getFrequency(), false)); drugOrder.setQuantity(Double.valueOf(dosingInstructions.getQuantity())); drugOrder.setQuantityUnits(conceptByName(dosingInstructions.getQuantityUnits())); Integer numberOfRefills = dosingInstructions.getNumberOfRefills(); drugOrder.setNumRefills(numberOfRefills == null? 0: numberOfRefills); return drugOrder; } DosingInstructionsMapper(ConceptService conceptService, OrderMetadataService orderMetadataService); DrugOrder map(EncounterTransaction.DosingInstructions dosingInstructions, DrugOrder drugOrder); } | @Test public void shouldMapDosingInstructionsToDrugOrder() { DosingInstructions dosingInstructions = DosingInstructionsBuilder.sample(); Concept capsuleConcept = new Concept(); when(conceptService.getConceptByName(dosingInstructions.getDoseUnits())).thenReturn(capsuleConcept); Concept routeConcept = new Concept(); when(conceptService.getConceptByName(dosingInstructions.getRoute())).thenReturn(routeConcept); Concept frequencyConcept = new Concept(); when(conceptService.getConceptByName(dosingInstructions.getFrequency())).thenReturn(frequencyConcept); OrderFrequency orderFrequency = new OrderFrequency(); when(orderMetadataService.getOrderFrequencyByName("QDS", false)).thenReturn(orderFrequency); Concept quantityUnits = new Concept(); when(conceptService.getConceptByName(dosingInstructions.getQuantityUnits())).thenReturn(quantityUnits); DrugOrder drugOrder = new DrugOrder(); DosingInstructionsMapper dosingInstructionsMapper = new DosingInstructionsMapper(conceptService, orderMetadataService); dosingInstructionsMapper.map(dosingInstructions, drugOrder); assertThat(drugOrder.getDosingInstructions(), is(equalTo("AC"))); assertThat(drugOrder.getDose(), is(equalTo(2.0))); assertThat(drugOrder.getDoseUnits(), is(capsuleConcept)); assertThat(drugOrder.getRoute(), is(equalTo(routeConcept))); assertThat(drugOrder.getFrequency(), is(equalTo(orderFrequency))); assertThat(drugOrder.getAsNeeded(), is(equalTo(false))); assertThat(drugOrder.getQuantity(), is(equalTo(Double.valueOf(dosingInstructions.getQuantity())))); assertThat(drugOrder.getQuantityUnits(), is(equalTo(quantityUnits))); assertThat(drugOrder.getNumRefills(), is(equalTo(dosingInstructions.getNumberOfRefills()))); }
@Test public void shouldDefaultNumRefillsToZeroIfNotAvailable() { DosingInstructions dosingInstructions = DosingInstructionsBuilder.sample(); dosingInstructions.setNumberOfRefills(null); DrugOrder drugOrder = new DrugOrder(); DosingInstructionsMapper dosingInstructionsMapper = new DosingInstructionsMapper(conceptService, orderMetadataService); dosingInstructionsMapper.map(dosingInstructions, drugOrder); assertThat(drugOrder.getNumRefills(), is(equalTo(0))); } |
EmrApiProperties extends ModuleProperties { public List<ConceptSource> getConceptSourcesForDiagnosisSearch() { String conceptSourcesForDiagnosisSearch = administrationService.getGlobalProperty(EmrApiConstants.EMR_CONCEPT_SOURCES_FOR_DIAGNOSIS_SEARCH); List<ConceptSource> conceptSourceList = new ArrayList<ConceptSource>(); if (StringUtils.hasText(conceptSourcesForDiagnosisSearch)) { String[] specifiedSourceNames = conceptSourcesForDiagnosisSearch.split(","); for (String specifiedSourceName : specifiedSourceNames) { ConceptSource aSource = conceptService.getConceptSourceByName(specifiedSourceName); if (aSource != null) { conceptSourceList.add(aSource); } } } return conceptSourceList; } @Override String getMetadataSourceName(); Location getUnknownLocation(); Provider getUnknownProvider(); EncounterRole getOrderingProviderEncounterRole(); Role getFullPrivilegeLevel(); Role getHighPrivilegeLevel(); EncounterType getCheckInEncounterType(); EncounterRole getCheckInClerkEncounterRole(); EncounterType getVisitNoteEncounterType(); @Deprecated // use visit note encounter type, as "Visit Note" is the proper naming convention EncounterType getConsultEncounterType(); EncounterRole getClinicianEncounterRole(); EncounterType getAdmissionEncounterType(); EncounterType getExitFromInpatientEncounterType(); EncounterType getTransferWithinHospitalEncounterType(); Form getAdmissionForm(); Form getDischargeForm(); Form getTransferForm(); int getVisitExpireHours(); VisitType getAtFacilityVisitType(); LocationTag getSupportsVisitsLocationTag(); LocationTag getSupportsLoginLocationTag(); LocationTag getSupportsAdmissionLocationTag(); LocationTag getSupportsTransferLocationTag(); PersonAttributeType getTestPatientPersonAttributeType(); PersonAttributeType getTelephoneAttributeType(); PersonAttributeType getUnknownPatientPersonAttributeType(); PatientIdentifierType getPrimaryIdentifierType(); List<PatientIdentifierType> getExtraPatientIdentifierTypes(); DiagnosisMetadata getDiagnosisMetadata(); List<ConceptSource> getConceptSourcesForDiagnosisSearch(); ConceptSource getEmrApiConceptSource(); Concept getUnknownCauseOfDeathConcept(); Concept getAdmissionDecisionConcept(); Concept getDenyAdmissionConcept(); List<PatientIdentifierType> getIdentifierTypesToSearch(); Collection<Concept> getDiagnosisSets(); Collection<Concept> getNonDiagnosisConceptSets(); Collection<Concept> getSuppressedDiagnosisConcepts(); ConceptMapType getSameAsConceptMapType(); ConceptMapType getNarrowerThanConceptMapType(); Integer getLastViewedPatientSizeLimit(); File getPersonImageDirectory(); Boolean getVisitAssignmentHandlerAdjustEncounterTimeOfDayIfNecessary(); } | @Test public void getConceptSourcesForDiagnosisSearch_shouldNotReturnNull(){ when(administrationService.getGlobalProperty(EmrApiConstants.EMR_CONCEPT_SOURCES_FOR_DIAGNOSIS_SEARCH)).thenReturn("ICD-10-WHO"); when(conceptService.getConceptSourceByName(anyString())).thenReturn(null); Assert.assertNotNull(emrApiProperties.getConceptSourcesForDiagnosisSearch()); Assert.assertTrue(emrApiProperties.getConceptSourcesForDiagnosisSearch().isEmpty()); ConceptSource icd10Source = new ConceptSource(); icd10Source.setName("ICD-10-WHO"); when(conceptService.getConceptSourceByName(anyString())).thenReturn(icd10Source); Assert.assertNotNull(emrApiProperties.getConceptSourcesForDiagnosisSearch()); Assert.assertTrue(emrApiProperties.getConceptSourcesForDiagnosisSearch().size() > 0); } |
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); } | @Test public void shouldGetDefaultLocaleForUser() { User user = new User(); user.setUserProperty(OpenmrsConstants.USER_PROPERTY_DEFAULT_LOCALE, "ht"); Assert.assertEquals("ht", GeneralUtils.getDefaultLocale(user).toString()); } |
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); } | @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)); } |
GeneralUtils { public static List<Patient> getLastViewedPatients(User user) { List<Patient> lastViewed = new ArrayList<Patient>(); if (user != null) { user = Context.getUserService().getUser(user.getId()); String lastViewedPatientIdsString = user .getUserProperty(EmrApiConstants.USER_PROPERTY_NAME_LAST_VIEWED_PATIENT_IDS); if (StringUtils.isNotBlank(lastViewedPatientIdsString)) { PatientService ps = Context.getPatientService(); lastViewedPatientIdsString = lastViewedPatientIdsString.replaceAll("\\s", ""); String[] patientIds = lastViewedPatientIdsString.split(","); for (String pId : patientIds) { try { Patient p = ps.getPatient(Integer.valueOf(pId)); if (p != null && !p.isVoided() && !p.isPersonVoided()) { lastViewed.add(p); } } catch (NumberFormatException e) {} } } } Collections.reverse(lastViewed); return lastViewed; } 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); } | @Test public void getLastViewedPatients_shouldReturnAListOfThePatientsLastViewedByTheSpecifiedUser() throws Exception { User user = new User(1); user.setUserProperty(EmrApiConstants.USER_PROPERTY_NAME_LAST_VIEWED_PATIENT_IDS, "2,6,7"); PowerMockito.mockStatic(Context.class); AdministrationService as = mock(AdministrationService.class); PatientService ps = mock(PatientService.class); UserService us = mock(UserService.class); when(Context.getAdministrationService()).thenReturn(as); when(Context.getPatientService()).thenReturn(ps); when(Context.getUserService()).thenReturn(us); when(as.getGlobalProperty(Mockito.eq(EmrApiConstants.UNKNOWN_PATIENT_PERSON_ATTRIBUTE_TYPE_NAME))).thenReturn(""); when(ps.getPatient(eq(2))).thenReturn(new Patient(2)); when(ps.getPatient(eq(6))).thenReturn(new Patient(6)); when(ps.getPatient(eq(7))).thenReturn(new Patient(7)); when(us.getUser(eq(user.getId()))).thenReturn(user); List<Patient> lastViewed = GeneralUtils.getLastViewedPatients(user); Assert.assertEquals(7, lastViewed.get(0).getId().intValue()); Assert.assertEquals(6, lastViewed.get(1).getId().intValue()); Assert.assertEquals(2, lastViewed.get(2).getId().intValue()); }
@Test public void getLastViewedPatients_shouldNotReturnVoidedPatients() throws Exception { Patient voided = new Patient(999); voided.setVoided(true); User user = new User(1); user.setUserProperty(EmrApiConstants.USER_PROPERTY_NAME_LAST_VIEWED_PATIENT_IDS, "2,999,3"); PowerMockito.mockStatic(Context.class); AdministrationService as = mock(AdministrationService.class); PatientService ps = mock(PatientService.class); UserService us = mock(UserService.class); when(Context.getAdministrationService()).thenReturn(as); when(Context.getPatientService()).thenReturn(ps); when(Context.getUserService()).thenReturn(us); when(as.getGlobalProperty(Mockito.eq(EmrApiConstants.UNKNOWN_PATIENT_PERSON_ATTRIBUTE_TYPE_NAME))).thenReturn(""); when(ps.getPatient(eq(2))).thenReturn(new Patient(2)); when(ps.getPatient(eq(3))).thenReturn(new Patient(3)); when(ps.getPatient(eq(999))).thenReturn(voided); when(us.getUser(eq(user.getId()))).thenReturn(user); List<Patient> lastViewed = GeneralUtils.getLastViewedPatients(user); Assert.assertEquals(2, lastViewed.size()); Assert.assertEquals(3, lastViewed.get(0).getId().intValue()); Assert.assertEquals(2, lastViewed.get(1).getId().intValue()); } |
ConceptMapper { public EncounterTransaction.Concept map(Concept concept) { if (concept == null) { return null; } concept = new HibernateLazyLoader().load(concept); ConceptClass conceptClass = concept.getConceptClass(); String conceptClassName = (conceptClass != null) ? conceptClass.getName() : null; EncounterTransaction.Concept encounterTransactionConcept = new EncounterTransaction.Concept( concept.getUuid(), concept.getName().getName(), concept.isSet(), concept.getDatatype().getName(), null, conceptClassName, getShortName(concept), concept.getConceptMappings()); if (concept.isNumeric()) { encounterTransactionConcept.setUnits(((ConceptNumeric) concept).getUnits()); encounterTransactionConcept.setHiNormal(((ConceptNumeric) concept).getHiNormal()); encounterTransactionConcept.setLowNormal(((ConceptNumeric) concept).getLowNormal()); } return encounterTransactionConcept; } EncounterTransaction.Concept map(Concept concept); } | @Test public void should_convert_concept_to_encounter_concept() { ConceptMapper conceptMapper = new ConceptMapper(); ConceptBuilder conceptBuilder = new ConceptBuilder(null, new ConceptDatatype(), new ConceptClass()); ConceptSource source = new ConceptSource(); source.setName("PACS Procedure Code"); conceptBuilder.addName("Test concept"); conceptBuilder.addMapping(new ConceptMapType(), source, "122"); EncounterTransaction.Concept encounterTransactionConcept = conceptMapper.map(conceptBuilder.get()); Map<String, Object> mappings = encounterTransactionConcept.getMappings().get(0); assertThat(mappings.size(), is(3)); assertThat((String) mappings.get("code"), is("122")); assertThat(mappings.get("name"), is(nullValue())); assertThat((String) mappings.get("source"), is("PACS Procedure Code")); }
@Test public void should_set_hiNormal_and_lowNormal_properties_for_numeric_concept() throws Exception { when(authenticatedUser.getUserProperty(OpenmrsConstants.USER_PROPERTY_DEFAULT_LOCALE)).thenReturn("fr"); ConceptNumeric concept = new ConceptNumeric(); ConceptName conceptName = new ConceptName(); conceptName.setName("Temperature Data"); concept.addName(conceptName); ConceptDatatype conceptDatatype = new ConceptDatatype(); conceptDatatype.setName("Numeric"); concept.setDatatype(conceptDatatype); ConceptClass conceptClass = new ConceptClass(); conceptClass.setName("Concept Details"); concept.setConceptClass(conceptClass); concept.setHiNormal((double) 20); concept.setLowNormal((double) 15); ConceptMapper conceptMapper = new ConceptMapper(); EncounterTransaction.Concept encounterTransactionConcept = conceptMapper.map(concept); Assert.assertEquals((double) 20, encounterTransactionConcept.getHiNormal(), 0.0); Assert.assertEquals((double) 15, encounterTransactionConcept.getLowNormal(), 0.0); } |
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); } | @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); } |
EncounterDispositionServiceHelper { public void update(Encounter encounter, EncounterTransaction.Disposition disposition) { try { if (isValid(disposition)) { dispositionGroupConcept = getDispositionGroupConcept(); dispositionConcept = getDispositionConcept(); Obs dispositionObsGroup = getExistingDisposition(encounter); if (dispositionObsGroup == null) { dispositionObsGroup = createObsGroupForDisposition(disposition); } else if (disposition.isVoided()) { dispositionObsGroup = voidDisposition(dispositionObsGroup, disposition); } else { dispositionObsGroup = editExistingDisposition(dispositionObsGroup, disposition); } encounter.addObs(dispositionObsGroup); } } catch (ParseException e) { throw new IllegalArgumentException(e); } } EncounterDispositionServiceHelper(ConceptService conceptService); EncounterDispositionServiceHelper(); void update(Encounter encounter, EncounterTransaction.Disposition disposition); } | @Test public void shouldSaveDispositionAsObsGroup() { String noteConceptUuid = "disposition-note"+UUID_SUFFIX; String dispositionNoteValue = "disposition note text"; String code = "ADMIT"; newConcept(ConceptDatatype.TEXT, noteConceptUuid); Encounter encounter = createEncounter("e-uuid"); EncounterTransaction.Disposition disposition = new EncounterTransaction.Disposition(); EncounterTransaction.Observation additionalObs = new EncounterTransaction.Observation() .setConcept(getConcept(noteConceptUuid)).setValue(dispositionNoteValue); disposition.setCode(code).setAdditionalObs(Arrays.asList(additionalObs)); encounterDispositionServiceHelper.update(encounter, disposition); assertDispositionValues(noteConceptUuid, dispositionNoteValue, code, encounter); }
@Test public void shouldVoidObsWhenDispositionIsVoided() { Encounter encounter = new Encounter(); Obs dispositionGroupObservation = buildDispositionGroupObservation(); Set<Obs> groupMembersObservation = dispositionGroupObservation.getGroupMembers(); encounter.addObs(dispositionGroupObservation); EncounterTransaction.Disposition disposition = new EncounterTransaction.Disposition(); disposition.setCode("ADMIT"); disposition.setVoided(true); disposition.setVoidReason("Entry by mistake"); encounterDispositionServiceHelper.update(encounter, disposition); Obs updatedDispositionGroupObservation = getObsByUuid(dispositionGroupObservation.getUuid(), encounter.getAllObs(true)); assertEquals(true, updatedDispositionGroupObservation.getVoided()); assertEquals(disposition.getVoidReason(), updatedDispositionGroupObservation.getVoidReason()); for (Obs obs : groupMembersObservation) { assertEquals(true, obs.getVoided()); assertEquals(disposition.getVoidReason(), obs.getVoidReason()); } }
@Test public void shouldUpdateDispositionAsObsGroup() { String noteConceptUuid = "disposition-note"+UUID_SUFFIX; String dispositionNoteValue = "disposition note text"; String code = "ADMIT"; newConcept(ConceptDatatype.TEXT, noteConceptUuid); Encounter encounter = createEncounter("e-uuid"); EncounterTransaction.Disposition disposition = new EncounterTransaction.Disposition(); disposition.setCode(code).setAdditionalObs(Arrays.asList(new EncounterTransaction.Observation().setConcept(getConcept(noteConceptUuid)).setValue(dispositionNoteValue))); encounterDispositionServiceHelper.update(encounter, disposition); code = "DISCHARGE"; dispositionNoteValue = dispositionNoteValue+" addendum"; disposition = new EncounterTransaction.Disposition(); disposition.setCode(code).setAdditionalObs(Arrays.asList(new EncounterTransaction.Observation().setConcept(getConcept(noteConceptUuid)).setValue(dispositionNoteValue))); setUpConceptByMapping(code, null); encounterDispositionServiceHelper.update(encounter, disposition); assertDispositionValues(noteConceptUuid, dispositionNoteValue, code, encounter); } |
EncounterTransactionMapper { public EncounterTransaction map(Encounter encounter, Boolean includeAll) { Visit visit = encounter.getVisit(); EncounterTransaction encounterTransaction = new EncounterTransaction(visit.getUuid(), encounter.getUuid()); encounterTransaction.setPatientUuid(encounter.getPatient().getUuid()); encounterTransaction.setEncounterTypeUuid(encounter.getEncounterType() != null ? encounter.getEncounterType().getUuid() : null); encounterTransaction.setLocationUuid(encounter.getLocation() != null ? encounter.getLocation().getUuid() : null); encounterTransaction.setLocationName(encounter.getLocation() != null ? encounter.getLocation().getName() : null); encounterTransaction.setVisitTypeUuid(visit.getVisitType().getUuid()); encounterTransaction.setVisitLocationUuid(visit.getLocation() != null ? visit.getLocation().getUuid() : null); encounterTransaction.setEncounterDateTime(encounter.getEncounterDatetime()); encounterProviderMapper.update(encounterTransaction, encounter.getEncounterProviders()); encounterObservationsMapper.update(encounterTransaction, getSortedTopLevelObservations(encounter, includeAll)); if (orderMapper != null) { encounterTransaction.setDrugOrders(orderMapper.mapDrugOrders(encounter)); encounterTransaction.setOrders(orderMapper.mapOrders(encounter)); } postProcessEncounter(encounter,encounterTransaction); return encounterTransaction; } @Autowired(required = false) EncounterTransactionMapper(EncounterObservationsMapper encounterObservationsMapper, EncounterProviderMapper encounterProviderMapper); @Autowired(required = false) EncounterTransactionMapper(EncounterObservationsMapper encounterObservationsMapper, EncounterProviderMapper encounterProviderMapper, OrderMapper orderMapper); EncounterTransaction map(Encounter encounter, Boolean includeAll); } | @Test public void shouldMap() throws Exception { Encounter encounter = new EncounterBuilder().build(); boolean includeAll = false; when(Context.getRegisteredComponents(EncounterTransactionHandler.class)).thenReturn(null); EncounterTransaction encounterTransaction = encounterTransactionMapper.map(encounter, includeAll); Assert.assertEquals(encounter.getUuid(), encounterTransaction.getEncounterUuid()); Assert.assertEquals(encounter.getVisit().getUuid(), encounterTransaction.getVisitUuid()); Assert.assertEquals(encounter.getPatient().getUuid(), encounterTransaction.getPatientUuid()); Assert.assertEquals(encounter.getEncounterType().getUuid(), encounterTransaction.getEncounterTypeUuid()); Assert.assertEquals(encounter.getLocation().getUuid(), encounterTransaction.getLocationUuid()); Assert.assertEquals(encounter.getLocation().getName(), encounterTransaction.getLocationName()); Assert.assertEquals(encounter.getVisit().getLocation().getUuid(), encounterTransaction.getVisitLocationUuid()); Assert.assertEquals(encounter.getVisit().getVisitType().getUuid(), encounterTransaction.getVisitTypeUuid()); }
@Test public void shouldMapEncounterWithoutEncounterType() throws Exception { Encounter encounter = new EncounterBuilder().withEncounterType(null).build(); when(Context.getRegisteredComponents(EncounterTransactionHandler.class)).thenReturn(null); EncounterTransaction encounterTransaction = encounterTransactionMapper.map(encounter, false); Assert.assertEquals(null, encounterTransaction.getEncounterTypeUuid()); }
@Test public void shouldMapEncounterTransactionsWithExtensions(){ Encounter encounter = new EncounterBuilder().build(); boolean includeAll = false; EncounterTransactionHandler encounterTransactionHandler = mock(EncounterTransactionHandler.class); when(Context.getRegisteredComponents(EncounterTransactionHandler.class)).thenReturn( Arrays.asList(encounterTransactionHandler)); encounterTransactionMapper = new EncounterTransactionMapper(encounterObservationsMapper, encounterProviderMapper, orderMapper); EncounterTransaction encounterTransaction = encounterTransactionMapper.map(encounter, includeAll); verify(encounterTransactionHandler).forRead(eq(encounter), any(EncounterTransaction.class)); } |
ObsMapper { public Obs transformEtObs(Encounter encounter,Obs observation, EncounterTransaction.Observation observationData) { if (observation == null) { observation = newObservation(encounter,observationData); } mapObservationProperties(observationData, observation); for (EncounterTransaction.Observation member : observationData.getGroupMembers()) { Obs nextLevelObs = getMatchingObservation(observation.getGroupMembers(), member.getUuid()); observation.addGroupMember(transformEtObs(encounter,nextLevelObs, member)); } return observation; } @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); } | @Test public void shouldTransformGivenETObsToObs() throws ParseException { Concept numericConcept = newConcept(new ConceptDataTypeBuilder().numeric(), "numeric-concept-uuid"); Date observationDateTime = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ").parse("2005-01-01T00:00:00.000+0000"); EncounterTransaction.Observation etObs = new EncounterTransaction.Observation().setUuid("o-uuid").setValue(35.0).setComment("overweight").setObservationDateTime(observationDateTime).setConcept(newEtConcept("ET_CONCEPT")); when(conceptService.getConceptByUuid(etObs.getConceptUuid())).thenReturn(numericConcept); Obs obs = this.obsMapper.transformEtObs(encounter,null, etObs); assertEquals(new Double(35.0), obs.getValueNumeric()); assertEquals("overweight", obs.getComment()); assertEquals(observationDateTime, obs.getObsDatetime()); assertEquals(patient, obs.getPerson()); }
@Test public void shouldVoidObs() throws ParseException { Concept numericConcept = newConcept(new ConceptDataTypeBuilder().numeric(), "numeric-concept-uuid"); Date observationDateTime = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ").parse("2005-01-01T00:00:00.000+0000"); EncounterTransaction.Observation etObs = new EncounterTransaction.Observation().setUuid("o-uuid").setVoided(true).setValue("").setComment("overweight").setObservationDateTime(observationDateTime).setConcept(newEtConcept("ET_CONCEPT")); when(conceptService.getConceptByUuid(etObs.getConceptUuid())).thenReturn(numericConcept); Obs obs = this.obsMapper.transformEtObs(encounter,null, etObs); assertEquals(true, obs.getVoided()); assertEquals(patient, obs.getPerson()); } |
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); } | @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"); } |
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); } | @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); } |
EncounterProviderServiceHelper { public void update(Encounter encounter, Set<EncounterTransaction.Provider> providers) { for (EncounterTransaction.Provider provider : providers) { EncounterProvider encounterProvider = findProvider(encounter, provider.getUuid(), provider.getEncounterRoleUuid()); if(encounterProvider == null) { EncounterRole encounterRole = null; if (StringUtils.isNotEmpty(provider.getEncounterRoleUuid())) { encounterRole = encounterService.getEncounterRoleByUuid(provider.getEncounterRoleUuid()); } if (encounterRole == null) { encounterRole = encounterService.getEncounterRoleByUuid(EncounterRole.UNKNOWN_ENCOUNTER_ROLE_UUID); } encounter.addProvider(encounterRole, providerService.getProviderByUuid(provider.getUuid())); } } } EncounterProviderServiceHelper(ProviderService providerService, EncounterService encounterService); void update(Encounter encounter, Set<EncounterTransaction.Provider> providers); } | @Test public void shouldAddProvider() { Encounter encounter = new Encounter(); EncounterTransaction.Provider provider = new EncounterTransaction.Provider(); provider.setUuid("provider-uuid"); provider.setName("provider-name"); provider.setEncounterRoleUuid("role-uuid"); encounterProviderServiceHelper.update(encounter, Collections.singleton(provider)); assertThat(encounter.getEncounterProviders().size(), is(equalTo(1))); EncounterProvider encounterProvider = encounter.getEncounterProviders().iterator().next(); assertThat(encounterProvider.getProvider().getUuid(), is(equalTo("provider-uuid"))); assertThat(encounterProvider.getProvider().getName(), is(equalTo("provider-name"))); assertThat(encounterProvider.getEncounterRole().getUuid(), is(equalTo("role-uuid"))); }
@Test public void shouldSetEncounterRoleToUknownIfNotSpecified() { Encounter encounter = new Encounter(); EncounterTransaction.Provider provider = new EncounterTransaction.Provider(); provider.setUuid("provider-uuid"); provider.setName("provider-name"); encounterProviderServiceHelper.update(encounter, Collections.singleton(provider)); assertThat(encounter.getEncounterProviders().size(), is(equalTo(1))); EncounterProvider encounterProvider = encounter.getEncounterProviders().iterator().next(); assertThat(encounterProvider.getProvider().getUuid(), is(equalTo("provider-uuid"))); assertThat(encounterProvider.getProvider().getName(), is(equalTo("provider-name"))); assertThat(encounterProvider.getEncounterRole().getUuid(), is(equalTo(EncounterRole.UNKNOWN_ENCOUNTER_ROLE_UUID))); }
@Test public void shoulAddSecondProvider() { Encounter encounter = new Encounter(); Provider provider = new Provider(); provider.setUuid("provider-uuid"); EncounterRole role = new EncounterRole(); role.setUuid("role-uuid"); encounter.addProvider(role, provider); EncounterTransaction.Provider encounterTransactionProvider = new EncounterTransaction.Provider(); encounterTransactionProvider.setUuid("another-provider-uuid"); encounterTransactionProvider.setEncounterRoleUuid("role-uuid"); assertThat(encounter.getEncounterProviders().size(), is(equalTo(1))); encounterProviderServiceHelper.update(encounter, Collections.singleton(encounterTransactionProvider)); assertThat(encounter.getEncounterProviders().size(), is(equalTo(2))); Iterator<EncounterProvider> i = encounter.getEncounterProviders().iterator(); EncounterProvider encounterProvider1 = i.next(); EncounterProvider encounterProvider2 = i.next(); assertTrue(encounterProvider1.getProvider().getUuid().equals("provider-uuid") && encounterProvider2.getProvider().getUuid().equals("another-provider-uuid") || encounterProvider1.getProvider().getUuid().equals("another-provider-uuid") && encounterProvider2.getProvider().getUuid().equals("provider-uuid")); assertThat(encounterProvider1.getEncounterRole().getUuid(), is(equalTo("role-uuid"))); assertThat(encounterProvider2.getEncounterRole().getUuid(), is(equalTo("role-uuid"))); }
@Test public void shouldNotAddProviderIfAlreadyAssociatedWithEncounterWithSpecifiedEncounterRole() { Encounter encounter = new Encounter(); Provider provider = new Provider(); provider.setUuid("provider-uuid"); EncounterRole role = new EncounterRole(); role.setUuid("role-uuid"); encounter.addProvider(role, provider); EncounterTransaction.Provider encounterTransactionProvider = new EncounterTransaction.Provider(); encounterTransactionProvider.setUuid("provider-uuid"); encounterTransactionProvider.setEncounterRoleUuid("role-uuid"); assertThat(encounter.getEncounterProviders().size(), is(equalTo(1))); encounterProviderServiceHelper.update(encounter, Collections.singleton(encounterTransactionProvider)); assertThat(encounter.getEncounterProviders().size(), is(equalTo(1))); EncounterProvider encounterProvider = encounter.getEncounterProviders().iterator().next(); assertThat(encounterProvider.getProvider().getUuid(), is(equalTo("provider-uuid"))); assertThat(encounterProvider.getEncounterRole().getUuid(), is(equalTo("role-uuid"))); }
@Test public void shouldAddProviderIfAlreadyAssociatedWithEncounterButWithDifferentEncounterRole() { Encounter encounter = new Encounter(); Provider provider = new Provider(); provider.setUuid("provider-uuid"); EncounterRole role = new EncounterRole(); role.setUuid("role-uuid"); encounter.addProvider(role, provider); EncounterTransaction.Provider encounterTransactionProvider = new EncounterTransaction.Provider(); encounterTransactionProvider.setUuid(provider.getUuid()); encounterTransactionProvider.setEncounterRoleUuid("another-role-uuid"); assertThat(encounter.getEncounterProviders().size(), is(equalTo(1))); encounterProviderServiceHelper.update(encounter, Collections.singleton(encounterTransactionProvider)); assertThat(encounter.getEncounterProviders().size(), is(equalTo(2))); Iterator<EncounterProvider> i = encounter.getEncounterProviders().iterator(); EncounterProvider encounterProvider1 = i.next(); EncounterProvider encounterProvider2 = i.next(); assertThat(encounterProvider1.getProvider().getUuid(), is(equalTo("provider-uuid"))); assertThat(encounterProvider2.getProvider().getUuid(), is(equalTo("provider-uuid"))); EncounterRole role1 = encounterProvider1.getEncounterRole(); EncounterRole role2 = encounterProvider2.getEncounterRole(); assertTrue(role1.getUuid().equals("role-uuid") && role2.getUuid().equals("another-role-uuid") || role1.getUuid().equals("another-role-uuid") && role2.getUuid().equals("role-uuid")); } |
ObservationMapper { public EncounterTransaction.Observation map(Obs obs) { Concept concept = obs.getConcept(); Object value = getValue(obs, concept); EncounterTransaction.Observation observation = new EncounterTransaction.Observation(); observation.setUuid(obs.getUuid()); observation.setConcept(conceptMapper.map(concept)); observation.setValue(value); observation.setVoided(obs.getVoided()); observation.setVoidReason(obs.getVoidReason()); observation.setObservationDateTime(obs.getObsDatetime()); observation.setComment(obs.getComment()); observation.setCreator(userMapper.map(obs.getCreator())); if (obs.getOrder() != null) { observation.setOrderUuid(obs.getOrder().getUuid()); } if (obs.getGroupMembers() != null) { for (Obs obsGroupMember : obs.getGroupMembers()) { observation.addGroupMember(map(obsGroupMember)); } } return observation; } @Autowired(required = false) ObservationMapper(ConceptMapper conceptMapper, DrugMapper drugMapper, UserMapper userMapper); EncounterTransaction.Observation map(Obs obs); } | @Test public void shouldMapVoidedObservation(){ when(conceptDatatype.isNumeric()).thenReturn(true); Obs obs = obsBuilder.setVoided(true).setVoidedReason("reason").get(); EncounterTransaction.Observation observation = observationMapper.map(obs); assertEquals(obs.getUuid(), observation.getUuid()); assertEquals(obs.getVoided(), observation.getVoided()); assertEquals(obs.getVoidReason(), observation.getVoidReason()); }
@Test public void shouldMapConceptClassAndComment(){ when(conceptDatatype.isNumeric()).thenReturn(true); Obs obs = obsBuilder.setComment("Intermittent Pain").get(); EncounterTransaction.Observation observation = observationMapper.map(obs); assertEquals(obs.getComment(), observation.getComment()); assertEquals(obs.getConcept().getConceptClass().getName(), observation.getConcept().getConceptClass()); }
@Test public void shouldMapCreator() { when(conceptDatatype.isDate()).thenReturn(true); Obs obs = obsBuilder.setValue("2015-02-01").get(); EncounterTransaction.Observation observation = observationMapper.map(obs); assertEquals("uuid", observation.getCreator().getUuid()); assertEquals("superman", observation.getCreator().getPersonName()); } |
EncounterObservationsMapper { public void update(EncounterTransaction encounterTransaction, Set<Obs> allObs) { for (Obs obs : allObs) { ObservationTypeMatcher.ObservationType observationType = observationTypeMatcher.getObservationType(obs); switch (observationType) { case DIAGNOSIS: if (!obs.isVoided()) { encounterTransaction.addDiagnosis(diagnosisMapper.map(obs, getDiagnosisMetadata())); } break; case DISPOSITION: encounterTransaction.setDisposition(dispositionMapper.getDisposition(obs)); break; default: encounterTransaction.addObservation(observationMapper.map(obs)); break; } } } EncounterObservationsMapper(ObservationMapper observationMapper, DiagnosisMapper diagnosisMapper, DispositionMapper dispositionMapper, EmrApiProperties emrApiProperties, ObservationTypeMatcher observationTypeMatcher); void update(EncounterTransaction encounterTransaction, Set<Obs> allObs); } | @Test public void testUpdateMapsDiagnosis() throws Exception { EncounterTransaction encounterTransaction = new EncounterTransaction(); Obs obs1 = new Obs(); Obs obs2 = new Obs(); Obs obs3 = new Obs(); Obs obs4 = new Obs(); HashSet<Obs> allObs = new HashSet<Obs>(Arrays.asList(obs1, obs2, obs3, obs4)); when(observationTypeMatcher.getObservationType(obs1)).thenReturn(ObservationTypeMatcher.ObservationType.DIAGNOSIS); when(observationTypeMatcher.getObservationType(obs2)).thenReturn(ObservationTypeMatcher.ObservationType.OBSERVATION); when(observationTypeMatcher.getObservationType(obs3)).thenReturn(ObservationTypeMatcher.ObservationType.DIAGNOSIS); EncounterTransaction.Disposition disposition = new EncounterTransaction.Disposition(); when(observationTypeMatcher.getObservationType(obs4)).thenReturn(ObservationTypeMatcher.ObservationType.DISPOSITION); when(dispositionMapper.getDisposition(obs4)).thenReturn(disposition); encounterObservationsMapper.update(encounterTransaction, allObs); assertEquals(2, encounterTransaction.getDiagnoses().size()); assertEquals(disposition, encounterTransaction.getDisposition()); assertEquals(1, encounterTransaction.getObservations().size()); }
@Test public void updateShouldNotMapVoidedDiagnosis() throws Exception { EncounterTransaction encounterTransaction = new EncounterTransaction(); Obs obs1 = new Obs(); Obs obs2 = new Obs(); obs2.setVoided(Boolean.TRUE); HashSet<Obs> allObs = new HashSet<Obs>(Arrays.asList(obs1, obs2)); when(observationTypeMatcher.getObservationType(obs1)).thenReturn(ObservationTypeMatcher.ObservationType.DIAGNOSIS); when(observationTypeMatcher.getObservationType(obs2)).thenReturn(ObservationTypeMatcher.ObservationType.DIAGNOSIS); encounterObservationsMapper.update(encounterTransaction, allObs); assertEquals(1, encounterTransaction.getDiagnoses().size()); } |
OrderMapper1_12 implements OrderMapper { @Override public EncounterTransaction.Order mapOrder(Order order) { EncounterTransaction.Order emrOrder = new EncounterTransaction.Order(); emrOrder.setUuid(order.getUuid()); emrOrder.setConcept(conceptMapper.map(order.getConcept())); emrOrder.setOrderType(order.getOrderType().getName()); emrOrder.setInstructions(order.getInstructions()); emrOrder.setDateCreated(order.getDateCreated()); emrOrder.setDateChanged(order.getDateChanged()); emrOrder.setDateStopped(order.getDateStopped()); emrOrder.setOrderNumber(order.getOrderNumber()); emrOrder.setCommentToFulfiller(order.getCommentToFulfiller()); emrOrder.setAction(order.getAction().name()); emrOrder.setUrgency(String.valueOf(order.getUrgency())); Order previousOrder = order.getPreviousOrder(); if (previousOrder != null && StringUtils.isNotBlank(previousOrder.getUuid())) { emrOrder.setPreviousOrderUuid(previousOrder.getUuid()); } return emrOrder; } @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); } | @Test public void shouldMapNewOrder() throws ParseException, NoSuchFieldException, IllegalAccessException { Order openMrsOrder = order("boil in water", "comments", "ORD-99", "ORD-100", ORDER_TYPE,"STAT"); openMrsOrder.setUuid(ORDER_UUID); EncounterTransaction.Order order = orderMapper1_12.mapOrder(openMrsOrder); assertThat(order.getAction(), is(equalTo(Order.Action.NEW.name()))); assertThat(order.getUuid(), is(equalTo(ORDER_UUID))); assertThat(order.getOrderType(), is(equalTo(ORDER_TYPE))); assertThat(order.getInstructions(), is(equalTo("boil in water"))); assertThat(order.getCommentToFulfiller(), is(equalTo("comments"))); assertThat(order.getUrgency(),is(equalTo("STAT"))); assertThat(order.getOrderNumber(), is(equalTo("ORD-100"))); assertThat(order.getDateCreated(), is(equalTo(new LocalDate().toDate()))); assertThat(order.getDateChanged(), is(equalTo(new LocalDate().toDate()))); assertThat(order.getOrderNumber(), is(equalTo("ORD-100"))); }
@Test public void shouldSetPreviousOrder() throws NoSuchFieldException, IllegalAccessException { Order openMrsOrder = order("boil in water", "comments", "Previous Order Uuid", "ORD-100", ORDER_TYPE,"ROUTINE"); EncounterTransaction.Order order = orderMapper1_12.mapOrder(openMrsOrder); assertThat(order.getPreviousOrderUuid(), is(equalTo("Previous Order Uuid"))); } |
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); } | @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()); } |
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); } | @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())); } |
EncounterObservationServiceHelper { public void update(Encounter encounter, List<EncounterTransaction.Observation> observations) { Set<Obs> existingObservations = encounter.getObsAtTopLevel(false); for (EncounterTransaction.Observation observationData : observations) { Obs obsFound = this.obsMapper.getMatchingObservation(existingObservations,observationData.getUuid()); encounter.addObs(this.obsMapper.transformEtObs(encounter,obsFound, observationData)); } } @Autowired EncounterObservationServiceHelper(ConceptService conceptService,
EmrApiProperties emrApiProperties,
ObsService obsService, OrderService orderService,
ObsMapper obsMapper ); void update(Encounter encounter, List<EncounterTransaction.Observation> observations); void updateDiagnoses(Encounter encounter, List<EncounterTransaction.Diagnosis> diagnoses); } | @Test public void shouldAddNewObservation() throws ParseException { newConcept(new ConceptDataTypeBuilder().text(), TEXT_CONCEPT_UUID); List<EncounterTransaction.Observation> observations = asList( new EncounterTransaction.Observation().setConcept(getConcept(TEXT_CONCEPT_UUID)).setValue("text value").setComment("overweight") ); Date encounterDateTime = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ").parse("2005-01-01T00:00:00.000+0000"); Patient patient = new Patient(); Encounter encounter = new Encounter(); encounter.setUuid("e-uuid"); encounter.setPatient(patient); encounter.setEncounterDatetime(encounterDateTime); encounterObservationServiceHelper.update(encounter, observations); assertEquals(1, encounter.getObs().size()); Obs textObservation = encounter.getObs().iterator().next(); assertEquals(patient, textObservation.getPerson()); assertEquals("text value", textObservation.getValueText()); assertEquals(TEXT_CONCEPT_UUID, textObservation.getConcept().getUuid()); assertEquals("e-uuid", textObservation.getEncounter().getUuid()); assertEquals("overweight", textObservation.getComment()); }
@Test public void shouldAddCodedObservation() throws ParseException { newConcept(new ConceptDataTypeBuilder().coded(), CODED_CONCEPT_UUID); Concept answerConcept = newConcept(new ConceptDataTypeBuilder().text(), "answer-uuid"); List<EncounterTransaction.Observation> observations = asList( new EncounterTransaction.Observation().setConcept(getConcept(CODED_CONCEPT_UUID)).setValue("answer-uuid") ); Patient patient = new Patient(); Encounter encounter = new Encounter(); encounter.setUuid("e-uuid"); encounter.setPatient(patient); encounterObservationServiceHelper.update(encounter, observations); assertEquals(1, encounter.getObs().size()); Obs codedObservation = encounter.getObs().iterator().next(); assertEquals(answerConcept, codedObservation.getValueCoded()); assertEquals("e-uuid", codedObservation.getEncounter().getUuid()); }
@Test public void shouldAddDrugObservation() throws ParseException { newConcept(new ConceptDataTypeBuilder().coded(), CODED_CONCEPT_UUID); Concept drugConcept = newConcept(new ConceptDataTypeBuilder().text(), "drug-concept-uuid"); Drug drug = new Drug(); drug.setUuid("drug-uuid"); drug.setConcept(drugConcept); when(conceptService.getDrugByUuid("drug-uuid")).thenReturn(drug); List<EncounterTransaction.Observation> observations = asList( new EncounterTransaction.Observation().setConcept(getConcept(CODED_CONCEPT_UUID)).setValue("drug-uuid") ); Patient patient = new Patient(); Encounter encounter = new Encounter(); encounter.setUuid("e-uuid"); encounter.setPatient(patient); encounterObservationServiceHelper.update(encounter, observations); assertEquals(1, encounter.getObs().size()); Obs codedObservation = encounter.getObs().iterator().next(); assertEquals(drugConcept, codedObservation.getValueCoded()); assertEquals(drug, codedObservation.getValueDrug()); assertEquals("e-uuid", codedObservation.getEncounter().getUuid()); }
@Test public void shouldUpdateExistingObservation() throws ParseException { Concept numericConcept = newConcept(new ConceptDataTypeBuilder().numeric(), NUMERIC_CONCEPT_UUID); Date observationDateTime = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ").parse("2005-01-01T00:00:00.000+0000"); List<EncounterTransaction.Observation> observations = asList( new EncounterTransaction.Observation().setUuid("o-uuid").setValue(35.0).setComment("overweight").setObservationDateTime(observationDateTime) ); Encounter encounter = new Encounter(); encounter.setUuid("e-uuid"); Obs obs = new Obs(); obs.setUuid("o-uuid"); obs.setConcept(numericConcept); encounter.addObs(obs); encounterObservationServiceHelper.update(encounter, observations); assertEquals(1, encounter.getObs().size()); Obs textObservation = encounter.getObs().iterator().next(); assertEquals(new Double(35.0), textObservation.getValueNumeric()); assertEquals("overweight", textObservation.getComment()); assertEquals(observationDateTime, textObservation.getObsDatetime()); }
@Test public void shouldHandleNullValueObservationWhileSaving() throws Exception { Concept concept = newConcept(new ConceptDataTypeBuilder().text(), TEXT_CONCEPT_UUID); List<EncounterTransaction.Observation> observations = asList( new EncounterTransaction.Observation().setConcept(getConcept(TEXT_CONCEPT_UUID)).setValue(null).setComment("overweight") ); Patient patient = new Patient(); Encounter encounter = new Encounter(); encounter.setUuid("e-uuid"); encounter.setPatient(patient); Date observationDateTime = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ").parse("2005-01-01T00:00:00.000+0000"); encounterObservationServiceHelper.update(encounter, observations); assertEquals(1, encounter.getObs().size()); Obs textObservation = encounter.getObs().iterator().next(); assertEquals(null, textObservation.getValueText()); }
@Test public void shouldVoidExistingObservation() throws ParseException { Concept numericConcept = newConcept(new ConceptDataTypeBuilder().numeric(), NUMERIC_CONCEPT_UUID); List<EncounterTransaction.Observation> observations = asList( new EncounterTransaction.Observation().setUuid("o-uuid").setConcept(getConcept(NUMERIC_CONCEPT_UUID)).setVoided(true).setVoidReason("closed") ); Encounter encounter = new Encounter(); encounter.setUuid("e-uuid"); Obs obs = new Obs(); obs.setUuid("o-uuid"); obs.setConcept(numericConcept); encounter.addObs(obs); Date observationDateTime = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ").parse("2005-01-01T00:00:00.000+0000"); encounterObservationServiceHelper.update(encounter, observations); assertEquals(0, encounter.getObs().size()); assertEquals(1, encounter.getAllObs(true).size()); Obs voidedObs = encounter.getAllObs(true).iterator().next(); assertTrue(voidedObs.isVoided()); assertEquals("closed", voidedObs.getVoidReason()); }
@Test(expected = ConceptNotFoundException.class) public void shouldReturnErrorWhenObservationConceptIsNotFound() throws Exception { List<EncounterTransaction.Observation> observations = asList( new EncounterTransaction.Observation().setConcept(getConcept("non-existent")) ); Encounter encounter = new Encounter(); encounterObservationServiceHelper.update(encounter, observations); }
@Test public void shouldLinkOrderWithObservation() throws ParseException { Concept numericConcept = newConcept(new ConceptDataTypeBuilder().numeric(), NUMERIC_CONCEPT_UUID); Order obsOrder = fetchOrder("order-uuid"); EncounterTransaction.Concept encConcept = new EncounterTransaction.Concept(numericConcept.getUuid()); List<EncounterTransaction.Observation> observations = asList( new EncounterTransaction.Observation().setUuid("o-uuid").setValue(35.0).setComment("overweight").setOrderUuid("order-uuid").setConcept(encConcept) ); Encounter encounter = new Encounter(); encounter.setUuid("e-uuid"); encounterObservationServiceHelper.update(encounter, observations); assertEquals(1, encounter.getObs().size()); Obs textObservation = encounter.getObs().iterator().next(); assertEquals(new Double(35.0), textObservation.getValueNumeric()); assertEquals("overweight", textObservation.getComment()); assertEquals("order-uuid",textObservation.getOrder().getUuid()); }
@Test public void shouldIgnoreNullOrdersInObservation() throws ParseException { Concept numericConcept = newConcept(new ConceptDataTypeBuilder().numeric(), NUMERIC_CONCEPT_UUID); EncounterTransaction.Concept encConcept = new EncounterTransaction.Concept(numericConcept.getUuid()); List<EncounterTransaction.Observation> observations = asList( new EncounterTransaction.Observation().setUuid("o-uuid").setValue(35.0).setComment("overweight").setOrderUuid(null).setConcept(encConcept) ); Encounter encounter = new Encounter(); encounter.setUuid("e-uuid"); encounterObservationServiceHelper.update(encounter, observations); assertEquals(1, encounter.getObs().size()); Obs textObservation = encounter.getObs().iterator().next(); assertEquals(new Double(35.0), textObservation.getValueNumeric()); assertEquals("overweight", textObservation.getComment()); assertNull(textObservation.getOrder()); }
@Test public void shouldHandleVoidedObservations() throws ParseException { Concept numericConcept = newConcept(new ConceptDataTypeBuilder().numeric(), NUMERIC_CONCEPT_UUID); EncounterTransaction.Concept obsConcept = new EncounterTransaction.Concept(numericConcept.getUuid()); double value = 35.0; String obsUuid = "o-uuid"; List<EncounterTransaction.Observation> observations = asList( new EncounterTransaction.Observation().setUuid(obsUuid).setValue(value).setVoided(true).setConcept(obsConcept) ); Encounter encounter = new Encounter(); Obs existingObs = new Obs(); existingObs.setUuid(obsUuid); existingObs.setConcept(numericConcept); existingObs.setValueNumeric(value); encounter.addObs(existingObs); encounter.setUuid("e-uuid"); encounterObservationServiceHelper.update(encounter, observations); Set<Obs> obsSet = encounter.getObsAtTopLevel(true); assertEquals(1, obsSet.size()); Obs textObservation = obsSet.iterator().next(); assertEquals(new Double(value), textObservation.getValueNumeric()); assertTrue(textObservation.getVoided()); } |
EncounterObservationServiceHelper { public void updateDiagnoses(Encounter encounter, List<EncounterTransaction.Diagnosis> diagnoses) { for (EncounterTransaction.Diagnosis diagnosisRequest : diagnoses) { org.openmrs.module.emrapi.diagnosis.Diagnosis diagnosis = createDiagnosis(diagnosisRequest); Obs obs = emrApiProperties.getDiagnosisMetadata().buildDiagnosisObsGroup(diagnosis); if (diagnosisRequest.getDiagnosisDateTime() != null) { obs.setObsDatetime(diagnosisRequest.getDiagnosisDateTime()); } if (obs.getObsDatetime() == null) { obs.setObsDatetime(new Date()); } obs.setComment(diagnosisRequest.getComments()); if (diagnosisRequest.isVoided()) { voidDiagnosisObservation(diagnosisRequest, obs); } encounter.addObs(obs); } } @Autowired EncounterObservationServiceHelper(ConceptService conceptService,
EmrApiProperties emrApiProperties,
ObsService obsService, OrderService orderService,
ObsMapper obsMapper ); void update(Encounter encounter, List<EncounterTransaction.Observation> observations); void updateDiagnoses(Encounter encounter, List<EncounterTransaction.Diagnosis> diagnoses); } | @Test public void shouldSaveDiagnosisAsAnObservationWhenPassedTheUuidOfDiagnosisConcept() { Date encounterDatetime = new Date(1000); String diagnosisConceptUuid = "f100e906-2c1c-11e3-bd6a-d72943d76e9f"; List<EncounterTransaction.Diagnosis> diagnosises = asList( new EncounterTransaction.Diagnosis().setCertainty("CONFIRMED").setOrder("PRIMARY") .setComments("comments") .setCodedAnswer(new EncounterTransaction.Concept(diagnosisConceptUuid, "conceptName")) ); Encounter encounter = new Encounter(); encounter.setUuid("e-uuid"); encounter.setEncounterDatetime(encounterDatetime); Obs savedObservations = new Obs(); savedObservations.addGroupMember(new Obs()); savedObservations.addGroupMember(new Obs()); savedObservations.addGroupMember(new Obs()); Concept conceptForDiagnosis = new Concept(); when(diagnosisMetadata.buildDiagnosisObsGroup(any(org.openmrs.module.emrapi.diagnosis.Diagnosis.class))).thenReturn(savedObservations); when(conceptService.getConceptByUuid(diagnosisConceptUuid)).thenReturn(conceptForDiagnosis); encounterObservationServiceHelper.updateDiagnoses(encounter, diagnosises); Set<Obs> parentObservations = encounter.getObsAtTopLevel(false); assertEquals(1, parentObservations.size()); Obs parent = parentObservations.iterator().next(); assertTrue(parent.isObsGrouping()); assertNotNull(parent.getObsDatetime()); assertNotEquals(encounterDatetime, parent.getObsDatetime()); assertEquals("comments", parent.getComment()); int children = parent.getGroupMembers().size(); assertEquals(3, children); ArgumentCaptor<org.openmrs.module.emrapi.diagnosis.Diagnosis> diagnosisCaptor = ArgumentCaptor.forClass(org.openmrs.module.emrapi.diagnosis.Diagnosis.class); verify(diagnosisMetadata, times(1)).buildDiagnosisObsGroup(diagnosisCaptor.capture()); org.openmrs.module.emrapi.diagnosis.Diagnosis diagnosis = diagnosisCaptor.getValue(); assertEquals(conceptForDiagnosis, diagnosis.getDiagnosis().getCodedAnswer()); assertEquals(org.openmrs.module.emrapi.diagnosis.Diagnosis.Certainty.CONFIRMED, diagnosis.getCertainty()); assertEquals(org.openmrs.module.emrapi.diagnosis.Diagnosis.Order.PRIMARY, diagnosis.getOrder()); verify(conceptService).getConceptByUuid(diagnosisConceptUuid); verify(conceptService, never()).getConcept(anyInt()); }
@Test public void shouldSetObsdatetimeWithDiagnosisDateTimeIfProvided() { String diagnosisConceptUuid = "f100e906-2c1c-11e3-bd6a-d72943d76e9f"; Date diagnosisDateTime = new Date(); EncounterTransaction.Diagnosis diagnosis = new EncounterTransaction.Diagnosis().setCertainty("CONFIRMED").setOrder("PRIMARY") .setComments("comments") .setCodedAnswer(new EncounterTransaction.Concept(diagnosisConceptUuid, "conceptName")); diagnosis.setDiagnosisDateTime(diagnosisDateTime); Encounter encounter = new Encounter(); encounter.setUuid("e-uuid"); encounter.setEncounterDatetime(new Date()); Obs savedObservations = new Obs(); savedObservations.addGroupMember(new Obs()); savedObservations.addGroupMember(new Obs()); savedObservations.addGroupMember(new Obs()); Concept conceptForDiagnosis = new Concept(); when(diagnosisMetadata.buildDiagnosisObsGroup(any(org.openmrs.module.emrapi.diagnosis.Diagnosis.class))) .thenReturn(savedObservations); when(conceptService.getConceptByUuid(diagnosisConceptUuid)).thenReturn(conceptForDiagnosis); encounterObservationServiceHelper.updateDiagnoses(encounter, Arrays.asList(diagnosis)); Set<Obs> parentObservations = encounter.getObsAtTopLevel(false); assertEquals(1, parentObservations.size()); Obs parent = parentObservations.iterator().next(); assertEquals(diagnosisDateTime, parent.getObsDatetime()); assertTrue(parent.isObsGrouping()); assertEquals("comments", parent.getComment()); int children = parent.getGroupMembers().size(); assertEquals(3, children); ArgumentCaptor<org.openmrs.module.emrapi.diagnosis.Diagnosis> diagnosisCaptor = ArgumentCaptor.forClass(org.openmrs.module.emrapi.diagnosis.Diagnosis.class); verify(diagnosisMetadata, times(1)).buildDiagnosisObsGroup(diagnosisCaptor.capture()); org.openmrs.module.emrapi.diagnosis.Diagnosis actualDiagnosis = diagnosisCaptor.getValue(); assertEquals(conceptForDiagnosis, actualDiagnosis.getDiagnosis().getCodedAnswer()); assertEquals(org.openmrs.module.emrapi.diagnosis.Diagnosis.Certainty.CONFIRMED, actualDiagnosis.getCertainty()); assertEquals(org.openmrs.module.emrapi.diagnosis.Diagnosis.Order.PRIMARY, actualDiagnosis.getOrder()); verify(conceptService).getConceptByUuid(diagnosisConceptUuid); verify(conceptService, never()).getConcept(anyInt()); }
@Test public void shouldVoidDiagnosisObservation() { String diagnosisConceptUuid = "f100e906-2c1c-11e3-bd6a-d72943d76e9f"; String existingObsUuid = "obs-uuid"; List<EncounterTransaction.Diagnosis> diagnoses = asList( new EncounterTransaction.Diagnosis().setCertainty("CONFIRMED").setOrder("PRIMARY") .setCodedAnswer(new EncounterTransaction.Concept(diagnosisConceptUuid, "conceptName")) .setVoided(true).setExistingObs(existingObsUuid) ); Encounter encounter = new Encounter(); encounter.setUuid("e-uuid"); encounter.setEncounterDatetime(new Date()); Obs savedObservations = new Obs(); savedObservations.setUuid(existingObsUuid); savedObservations.addGroupMember(new Obs()); savedObservations.addGroupMember(new Obs()); savedObservations.addGroupMember(new Obs()); Concept conceptForDiagnosis = new Concept(); encounter.addObs(savedObservations); when(diagnosisMetadata.buildDiagnosisObsGroup(any(org.openmrs.module.emrapi.diagnosis.Diagnosis.class))).thenReturn(savedObservations); when(conceptService.getConceptByUuid(diagnosisConceptUuid)).thenReturn(conceptForDiagnosis); when(obsService.getObsByUuid(existingObsUuid)).thenReturn(savedObservations); encounterObservationServiceHelper.updateDiagnoses(encounter, diagnoses); Set<Obs> parentObservations = encounter.getObsAtTopLevel(true); assertEquals(1, parentObservations.size()); Obs parent = parentObservations.iterator().next(); assertTrue(parent.isObsGrouping()); assertTrue(parent.isVoided()); Set<Obs> children = parent.getGroupMembers(true); assertEquals(3, children.size()); for(Obs childObs : children){ assertTrue(childObs.isVoided()); } } |
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; } | @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)); } |
EncounterDomainWrapper implements DomainWrapper { @Transactional public void attachToVisit(VisitDomainWrapper visit) throws EncounterDateBeforeVisitStartDateException, EncounterDateAfterVisitStopDateException { if (dateHasTimeComponent(encounter.getEncounterDatetime())) { if (encounter.getEncounterDatetime().before(visit.getStartDatetime())) { throw new EncounterDateBeforeVisitStartDateException(); } if (visit.getStopDatetime() != null && encounter.getEncounterDatetime().after(visit.getStopDatetime())) { throw new EncounterDateAfterVisitStopDateException(); } } else { DateMidnight encounterDate = new DateMidnight(encounter.getEncounterDatetime()); DateMidnight currentDate = new DateMidnight(); DateMidnight visitStartDate = new DateMidnight(visit.getStartDatetime()); DateMidnight visitStopDate = visit.getStopDatetime() != null ? new DateMidnight(visit.getStopDatetime()) : null; if (encounterDate.isBefore(visitStartDate)) { throw new EncounterDateBeforeVisitStartDateException(); } if (visitStopDate != null && encounterDate.isAfter(visitStopDate)) { throw new EncounterDateAfterVisitStopDateException(); } if (encounterDate.equals(currentDate) && visit.isOpen()) { setEncounterDatetimeAndPropagateToObs(encounter, new Date()); } else if (encounterDate.isBefore(new DateTime(visit.getStartDatetime()))) { setEncounterDatetimeAndPropagateToObs(encounter, visit.getStartDatetime()); } } encounter.setVisit(visit.getVisit()); } 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; } | @Test(expected = EncounterDateBeforeVisitStartDateException.class) public void test_attachToVisit_shouldFailIfEncounterDateBeforeVisitStartDate() throws Exception { Encounter encounter = new Encounter(); encounter.setEncounterDatetime(new DateMidnight(2012,12,12).toDate()); EncounterDomainWrapper encounterWrapper = new EncounterDomainWrapper(encounter); Visit visit = new Visit(); visit.setStartDatetime(new DateTime(2012, 12, 13, 10, 10, 10).toDate()); visit.setStopDatetime(new DateTime(2012, 12, 15, 10, 10, 10).toDate()); encounterWrapper.attachToVisit(visit); }
@Test(expected = EncounterDateAfterVisitStopDateException.class) public void test_attachToVisit_shouldFailIfEncounterDateAfterVisitStopDate() throws Exception { Encounter encounter = new Encounter(); encounter.setEncounterDatetime(new DateMidnight(2012,12,16).toDate()); EncounterDomainWrapper encounterWrapper = new EncounterDomainWrapper(encounter); Visit visit = new Visit(); visit.setStartDatetime(new DateTime(2012, 12, 13, 10, 10, 10).toDate()); visit.setStopDatetime(new DateTime(2012, 12, 15, 10, 10, 10).toDate()); encounterWrapper.attachToVisit(visit); } |
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); } | @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()); } |
EncounterDomainWrapper implements DomainWrapper { public Provider getPrimaryProvider() { for (EncounterProvider provider : encounter.getEncounterProviders()) { if (!provider.isVoided()) { return provider.getProvider(); } } return null; } 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; } | @Test public void test_getPrimaryProvider_shouldReturnFirstNonVoidedEncounterProvider() { Encounter encounter = new Encounter(); Provider provider1 = new Provider(); Provider provider2 = new Provider(); EncounterRole role = new EncounterRole(); EncounterProvider encounterProvider1 = new EncounterProvider(); encounterProvider1.setVoided(true); encounterProvider1.setProvider(provider1); encounterProvider1.setEncounterRole(role); EncounterProvider encounterProvider2 = new EncounterProvider(); encounterProvider2.setVoided(false); encounterProvider2.setProvider(provider2); encounterProvider2.setEncounterRole(role); Set<EncounterProvider> encounterProviders = new HashSet<EncounterProvider>(); encounterProviders.add(encounterProvider1); encounterProviders.add(encounterProvider2); encounter.setEncounterProviders(encounterProviders); assertThat(new EncounterDomainWrapper(encounter).getPrimaryProvider(), is(provider2)); }
@Test public void test_getPrimaryProvider_shouldReturnNullIfNoNonVoidedEncounterProviders() { Encounter encounter = new Encounter(); Provider provider1 = new Provider(); Provider provider2 = new Provider(); EncounterRole role = new EncounterRole(); EncounterProvider encounterProvider1 = new EncounterProvider(); encounterProvider1.setVoided(true); encounterProvider1.setProvider(provider1); encounterProvider1.setEncounterRole(role); EncounterProvider encounterProvider2 = new EncounterProvider(); encounterProvider2.setVoided(true); encounterProvider2.setProvider(provider2); encounterProvider2.setEncounterRole(role); Set<EncounterProvider> encounterProviders = new HashSet<EncounterProvider>(); encounterProviders.add(encounterProvider1); encounterProviders.add(encounterProvider2); encounter.setEncounterProviders(encounterProviders); assertNull(new EncounterDomainWrapper(encounter).getPrimaryProvider()); } |
EncounterTransaction { public Map<String, Object> getContext() { return context; } EncounterTransaction(); EncounterTransaction(String visitUuid, String encounterUuid); String getVisitLocationUuid(); void setVisitLocationUuid(String visitLocationUuid); Map<String, Object> getExtensions(); void setExtensions(Map<String, Object> extensions); Disposition getDisposition(); void setDisposition(Disposition disposition); String getPatientUuid(); String getEncounterTypeUuid(); String getVisitTypeUuid(); EncounterTransaction setPatientUuid(String patientUuid); EncounterTransaction setVisitTypeUuid(String visitTypeUuid); EncounterTransaction setEncounterTypeUuid(String encounterTypeUuid); EncounterTransaction setObservations(List<Observation> observations); String getLocationName(); EncounterTransaction setLocationName(String locationName); List<Observation> getObservations(); List<Order> getOrders(); void setOrders(List<Order> orders); List<DrugOrder> getDrugOrders(); void setDrugOrders(List<DrugOrder> drugOrders); @JsonSerialize(using = CustomJsonDateSerializer.class) Date getEncounterDateTime(); EncounterTransaction setEncounterDateTime(Date encounterDateTime); String getLocationUuid(); EncounterTransaction setLocationUuid(String locationUuid); List<Diagnosis> getDiagnoses(); void setDiagnoses(List<Diagnosis> diagnoses); String getVisitUuid(); void setVisitUuid(String visitUuid); String getEncounterUuid(); void setEncounterUuid(String encounterUuid); Map<String, Object> getContext(); void setContext(Map<String, Object> context); void addObservation(Observation observation); void addOrder(Order order); void addDrugOrder(DrugOrder drugOrder); void addDiagnosis(Diagnosis diagnosis); Set<Provider> getProviders(); void setProviders(Set<Provider> providers); } | @Test public void shouldDeserializeContext() throws IOException { String patientProgramUuidKey = "patientProgramUuid"; String patientProgramUuidValue = "c4f735a8-dbac-11e5-b5d2-0a1d41d68578"; EncounterTransaction encounterTransaction = new ObjectMapper().readValue("{" + " \"context\": {" + " \"" + patientProgramUuidKey + "\": \"" + patientProgramUuidValue + "\"," + " \"anotherKey\": \"anotherValue\"," + " \"contextObject\": {" + " \"key\": \"value\"" + " }" + " }" + "}", EncounterTransaction.class); Map<String, Object> context = encounterTransaction.getContext(); assertThat(context.get(patientProgramUuidKey), is(equalTo((Object) patientProgramUuidValue))); } |
VisitDomainWrapper implements DomainWrapper { public boolean hasEncounterWithoutSubsequentEncounter(EncounterType lookForEncounterType, EncounterType withoutSubsequentEncounterType) { return hasEncounterWithoutSubsequentEncounter(lookForEncounterType, withoutSubsequentEncounterType, null); } VisitDomainWrapper(); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties, DispositionService dispositionService); Visit getVisit(); void setVisit(Visit visit); int getVisitId(); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setDispositionService(DispositionService dispositionService); void setVisitQueryService(VisitQueryService visitQueryService); Encounter getAdmissionEncounter(); Encounter getLatestAdtEncounter(); boolean isActive(); @Deprecated // renamed to is Active boolean isOpen(); Encounter getMostRecentCheckInEncounter(); Encounter getEarliestCheckInEncounter(); @Deprecated // use getMostRecentCheckInEncounter, as this is a more accurate method name Encounter getCheckInEncounter(); Encounter getMostRecentEncounter(); @Deprecated //use getMostRecentEncounter because this method name doesn't make sense Encounter getLastEncounter(); Encounter getEarliestEncounter(); @Deprecated // we are standardizing on "Earliest" and "Most Recent" to the Encounter getOldestEncounter(); Encounter getMostRecentVisitNote(); Encounter getMostRecentVisitNoteAtLocation(Location location); boolean hasVisitNote(); boolean hasVisitNoteAtLocation(Location location); List<Encounter> getSortedEncounters(); List<Encounter> getSortedEncounters(SortOrder order); int getDifferenceInDaysBetweenCurrentDateAndStartDate(); Disposition getMostRecentDisposition(); List<Diagnosis> getDiagnosesFromMostRecentDispositionByType(DispositionType type); List<Diagnosis> getPrimaryDiagnoses(); List<Diagnosis> getUniqueDiagnoses(Boolean primaryOnly, Boolean confirmedOnly); @Deprecated List<Diagnosis> getUniqueDiagnosesLegacy(Boolean primaryOnly, Boolean confirmedOnly); boolean hasEncounters(); boolean hasEncounterWithoutSubsequentEncounter(EncounterType lookForEncounterType, EncounterType withoutSubsequentEncounterType); boolean isAdmitted(); boolean isAdmitted(Date onDate); boolean isAwaitingAdmission(); Location getInpatientLocation(Date onDate); Date getStartDatetime(); Date getStopDatetime(); Date getStartDate(); Date getStopDate(); VisitDomainWrapper addEncounter(Encounter encounter); void closeOnLastEncounterDatetime(); void errorIfOutsideVisit(Date checkDatetime, String errorMessage); Date getEncounterStopDateRange(); boolean verifyIfUserIsTheCreatorOfVisit(User currentUser); Object getVisitAttribute(String uuidOrName); } | @Test public void shouldNotHaveEncounterWithoutSubsequentEncounterIfNoRelevantEncounters() throws Exception { when(visit.getEncounters()).thenReturn(new LinkedHashSet<Encounter>()); assertFalse(visitDomainWrapper.hasEncounterWithoutSubsequentEncounter(new EncounterType(), new EncounterType())); }
@Test public void shouldHaveEncounterWithoutSubsequentEncounterIfOneEncounterOfCorrectType() throws Exception { EncounterType targetType = new EncounterType(); Encounter encounter = new Encounter(); encounter.setEncounterType(targetType); encounter.setEncounterDatetime(new Date()); LinkedHashSet<Encounter> encounters = new LinkedHashSet<Encounter>(); encounters.add(encounter); when(visit.getEncounters()).thenReturn(encounters); assertTrue(visitDomainWrapper.hasEncounterWithoutSubsequentEncounter(targetType, null)); }
@Test public void shouldNotHaveEncounterWithoutSubsequentEncounterIfOneEncounterOfWrongType() throws Exception { Encounter encounter = new Encounter(); encounter.setEncounterType(new EncounterType()); encounter.setEncounterDatetime(new Date()); LinkedHashSet<Encounter> encounters = new LinkedHashSet<Encounter>(); encounters.add(encounter); when(visit.getEncounters()).thenReturn(encounters); assertFalse(visitDomainWrapper.hasEncounterWithoutSubsequentEncounter(new EncounterType(), null)); }
@Test public void shouldHaveEncounterWithoutSubsequentEncounterIfMostRecentRelevantEncounterIsOfCorrectType() throws Exception { EncounterType lookForType = new EncounterType(); EncounterType cancelType = new EncounterType(); Encounter admit = new Encounter(); admit.setEncounterType(lookForType); admit.setEncounterDatetime(DateUtils.addHours(new Date(), -3)); Encounter discharge = new Encounter(); discharge.setEncounterType(cancelType); discharge.setEncounterDatetime(DateUtils.addHours(new Date(), -2)); Encounter admitAgain = new Encounter(); admitAgain.setEncounterType(lookForType); admitAgain.setEncounterDatetime(DateUtils.addHours(new Date(), -1)); Encounter anotherEncounter = new Encounter(); anotherEncounter.setEncounterType(new EncounterType()); anotherEncounter.setEncounterDatetime(new Date()); Set<Encounter> encounters = new HashSet<Encounter>(); encounters.add(admit); encounters.add(discharge); encounters.add(admitAgain); encounters.add(anotherEncounter); when(visit.getEncounters()).thenReturn(encounters); assertTrue(visitDomainWrapper.hasEncounterWithoutSubsequentEncounter(lookForType, cancelType)); } |
VisitDomainWrapper implements DomainWrapper { public Date getEncounterStopDateRange() { return getStopDatetime() == null ? new Date() : getStopDatetime(); } VisitDomainWrapper(); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties, DispositionService dispositionService); Visit getVisit(); void setVisit(Visit visit); int getVisitId(); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setDispositionService(DispositionService dispositionService); void setVisitQueryService(VisitQueryService visitQueryService); Encounter getAdmissionEncounter(); Encounter getLatestAdtEncounter(); boolean isActive(); @Deprecated // renamed to is Active boolean isOpen(); Encounter getMostRecentCheckInEncounter(); Encounter getEarliestCheckInEncounter(); @Deprecated // use getMostRecentCheckInEncounter, as this is a more accurate method name Encounter getCheckInEncounter(); Encounter getMostRecentEncounter(); @Deprecated //use getMostRecentEncounter because this method name doesn't make sense Encounter getLastEncounter(); Encounter getEarliestEncounter(); @Deprecated // we are standardizing on "Earliest" and "Most Recent" to the Encounter getOldestEncounter(); Encounter getMostRecentVisitNote(); Encounter getMostRecentVisitNoteAtLocation(Location location); boolean hasVisitNote(); boolean hasVisitNoteAtLocation(Location location); List<Encounter> getSortedEncounters(); List<Encounter> getSortedEncounters(SortOrder order); int getDifferenceInDaysBetweenCurrentDateAndStartDate(); Disposition getMostRecentDisposition(); List<Diagnosis> getDiagnosesFromMostRecentDispositionByType(DispositionType type); List<Diagnosis> getPrimaryDiagnoses(); List<Diagnosis> getUniqueDiagnoses(Boolean primaryOnly, Boolean confirmedOnly); @Deprecated List<Diagnosis> getUniqueDiagnosesLegacy(Boolean primaryOnly, Boolean confirmedOnly); boolean hasEncounters(); boolean hasEncounterWithoutSubsequentEncounter(EncounterType lookForEncounterType, EncounterType withoutSubsequentEncounterType); boolean isAdmitted(); boolean isAdmitted(Date onDate); boolean isAwaitingAdmission(); Location getInpatientLocation(Date onDate); Date getStartDatetime(); Date getStopDatetime(); Date getStartDate(); Date getStopDate(); VisitDomainWrapper addEncounter(Encounter encounter); void closeOnLastEncounterDatetime(); void errorIfOutsideVisit(Date checkDatetime, String errorMessage); Date getEncounterStopDateRange(); boolean verifyIfUserIsTheCreatorOfVisit(User currentUser); Object getVisitAttribute(String uuidOrName); } | @Test public void shouldUseTheStopDateOfTheVisitForEncounterStopDateRange() { DateTime visitEndDate = new DateTime(2013, 1, 15, 12, 12, 12); Visit visit = new Visit(); visit.setStopDatetime(visitEndDate.toDate()); VisitDomainWrapper wrapper = new VisitDomainWrapper(visit); assertThat(wrapper.getEncounterStopDateRange(), is(visitEndDate.toDate())); }
@Test public void shouldReturnNowForStopDateRangeIfStopDateOfTheVisitIsNull() { Visit visit = new Visit(); visit.setStopDatetime(null); VisitDomainWrapper wrapper = new VisitDomainWrapper(visit); assertThat(wrapper.getEncounterStopDateRange(), within(1, SECONDS, new Date())); } |
VisitDomainWrapper implements DomainWrapper { public Encounter getMostRecentEncounter() { List<Encounter> encounters = getSortedEncounters(SortOrder.MOST_RECENT_FIRST); if (encounters.size() > 0) return encounters.get(0); return null; } VisitDomainWrapper(); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties, DispositionService dispositionService); Visit getVisit(); void setVisit(Visit visit); int getVisitId(); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setDispositionService(DispositionService dispositionService); void setVisitQueryService(VisitQueryService visitQueryService); Encounter getAdmissionEncounter(); Encounter getLatestAdtEncounter(); boolean isActive(); @Deprecated // renamed to is Active boolean isOpen(); Encounter getMostRecentCheckInEncounter(); Encounter getEarliestCheckInEncounter(); @Deprecated // use getMostRecentCheckInEncounter, as this is a more accurate method name Encounter getCheckInEncounter(); Encounter getMostRecentEncounter(); @Deprecated //use getMostRecentEncounter because this method name doesn't make sense Encounter getLastEncounter(); Encounter getEarliestEncounter(); @Deprecated // we are standardizing on "Earliest" and "Most Recent" to the Encounter getOldestEncounter(); Encounter getMostRecentVisitNote(); Encounter getMostRecentVisitNoteAtLocation(Location location); boolean hasVisitNote(); boolean hasVisitNoteAtLocation(Location location); List<Encounter> getSortedEncounters(); List<Encounter> getSortedEncounters(SortOrder order); int getDifferenceInDaysBetweenCurrentDateAndStartDate(); Disposition getMostRecentDisposition(); List<Diagnosis> getDiagnosesFromMostRecentDispositionByType(DispositionType type); List<Diagnosis> getPrimaryDiagnoses(); List<Diagnosis> getUniqueDiagnoses(Boolean primaryOnly, Boolean confirmedOnly); @Deprecated List<Diagnosis> getUniqueDiagnosesLegacy(Boolean primaryOnly, Boolean confirmedOnly); boolean hasEncounters(); boolean hasEncounterWithoutSubsequentEncounter(EncounterType lookForEncounterType, EncounterType withoutSubsequentEncounterType); boolean isAdmitted(); boolean isAdmitted(Date onDate); boolean isAwaitingAdmission(); Location getInpatientLocation(Date onDate); Date getStartDatetime(); Date getStopDatetime(); Date getStartDate(); Date getStopDate(); VisitDomainWrapper addEncounter(Encounter encounter); void closeOnLastEncounterDatetime(); void errorIfOutsideVisit(Date checkDatetime, String errorMessage); Date getEncounterStopDateRange(); boolean verifyIfUserIsTheCreatorOfVisit(User currentUser); Object getVisitAttribute(String uuidOrName); } | @Test public void shouldReturnNullOnMostRecentEncounterIfNoEncounters() throws Exception { assertThat(new VisitDomainWrapper(new Visit()).getMostRecentEncounter(), is(nullValue())); } |
OrderMapper1_12 implements OrderMapper { @Override public EncounterTransaction.DrugOrder mapDrugOrder(DrugOrder openMRSDrugOrder) { EncounterTransaction.DrugOrder drugOrder = new EncounterTransaction.DrugOrder(); drugOrder.setUuid(openMRSDrugOrder.getUuid()); if (openMRSDrugOrder.getCareSetting() != null) { drugOrder.setCareSetting(CareSettingType.valueOf(openMRSDrugOrder.getCareSetting().getCareSettingType().toString())); } drugOrder.setAction(openMRSDrugOrder.getAction().name()); drugOrder.setOrderType(openMRSDrugOrder.getOrderType().getName()); Order previousOrder = openMRSDrugOrder.getPreviousOrder(); if (previousOrder != null && StringUtils.isNotBlank(previousOrder.getUuid())) { drugOrder.setPreviousOrderUuid(previousOrder.getUuid()); } drugOrder.setDrugNonCoded(openMRSDrugOrder.getDrugNonCoded()); if (openMRSDrugOrder.getDrug() != null){ EncounterTransaction.Drug encounterTransactionDrug = new DrugMapper1_12().map(openMRSDrugOrder.getDrug()); drugOrder.setDrug(encounterTransactionDrug); } drugOrder.setDosingInstructionType(openMRSDrugOrder.getDosingType().getName()); drugOrder.setDuration(openMRSDrugOrder.getDuration()); drugOrder.setDurationUnits(getConceptName(openMRSDrugOrder.getDurationUnits())); drugOrder.setConcept(conceptMapper.map(openMRSDrugOrder.getConcept())); drugOrder.setScheduledDate(openMRSDrugOrder.getScheduledDate()); drugOrder.setDateActivated(openMRSDrugOrder.getDateActivated()); drugOrder.setEffectiveStartDate(openMRSDrugOrder.getEffectiveStartDate()); drugOrder.setAutoExpireDate(openMRSDrugOrder.getAutoExpireDate()); drugOrder.setEffectiveStopDate(openMRSDrugOrder.getEffectiveStopDate()); drugOrder.setDateStopped(openMRSDrugOrder.getDateStopped()); EncounterTransaction.DosingInstructions dosingInstructions = new EncounterTransaction.DosingInstructions(); dosingInstructions.setDose(openMRSDrugOrder.getDose()); dosingInstructions.setDoseUnits(getConceptName(openMRSDrugOrder.getDoseUnits())); dosingInstructions.setRoute(getConceptName(openMRSDrugOrder.getRoute())); dosingInstructions.setAsNeeded(openMRSDrugOrder.getAsNeeded()); if (openMRSDrugOrder.getFrequency() != null) { dosingInstructions.setFrequency(openMRSDrugOrder.getFrequency().getName()); } if (openMRSDrugOrder.getQuantity() != null) { dosingInstructions.setQuantity(openMRSDrugOrder.getQuantity()); } dosingInstructions.setQuantityUnits(getConceptName(openMRSDrugOrder.getQuantityUnits())); dosingInstructions.setAdministrationInstructions(openMRSDrugOrder.getDosingInstructions()); drugOrder.setDosingInstructions(dosingInstructions); drugOrder.setInstructions(openMRSDrugOrder.getInstructions()); drugOrder.setCommentToFulfiller(openMRSDrugOrder.getCommentToFulfiller()); drugOrder.setVoided(openMRSDrugOrder.getVoided()); drugOrder.setVoidReason(openMRSDrugOrder.getVoidReason()); drugOrder.setOrderNumber(openMRSDrugOrder.getOrderNumber()); drugOrder.setOrderReasonConcept(conceptMapper.map(openMRSDrugOrder.getOrderReason())); drugOrder.setOrderReasonText(openMRSDrugOrder.getOrderReasonNonCoded()); OrderGroup openMRSOrderGroup = openMRSDrugOrder.getOrderGroup(); if(openMRSOrderGroup != null) { EncounterTransaction.OrderGroup orderGroup = new EncounterTransaction.OrderGroup(openMRSOrderGroup.getUuid()); EncounterTransaction.OrderSet orderSet = new EncounterTransaction.OrderSet(openMRSOrderGroup.getOrderSet().getUuid()); orderGroup.setOrderSet(orderSet); drugOrder.setOrderGroup(orderGroup); drugOrder.setSortWeight(openMRSDrugOrder.getSortWeight()); } return drugOrder; } @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); } | @Test public void shouldMapNewDrugOrder() throws ParseException, NoSuchFieldException, IllegalAccessException { DrugOrder openMrsDrugOrder = drugOrder(CareSetting.CareSettingType.OUTPATIENT, 3, "3-0-2", 5, "before meals", "boil in water", null, "ORD-100"); Concept concept = concept("newConcept", "newConceptDataType", "newConceptUuid"); openMrsDrugOrder.setConcept(concept); EncounterTransaction.DrugOrder drugOrder = orderMapper1_12.mapDrugOrder(openMrsDrugOrder); assertThat(drugOrder.getCareSetting(), is(equalTo(OUT_PATIENT_CARE_SETTING))); assertThat(drugOrder.getAction(), is(equalTo(Order.Action.NEW.name()))); assertThat(drugOrder.getDrug().getUuid(), is(equalTo(DRUG_UUID))); assertThat(drugOrder.getDosingInstructionType(), is(equalTo(SimpleDosingInstructions.class.getName()))); assertThat(drugOrder.getDuration(), is(equalTo(5))); assertThat(drugOrder.getDurationUnits(), is(equalTo(DAY_DURATION_UNIT))); assertThat(drugOrder.getDateActivated(), is(equalTo(new LocalDate().toDate()))); assertThat(drugOrder.getScheduledDate(), is(equalTo(new LocalDate().plusDays(3).toDate()))); assertThat(drugOrder.getEffectiveStartDate(), is(equalTo(new LocalDate().plusDays(3).toDate()))); assertThat(drugOrder.getAutoExpireDate(), is(equalTo(new LocalDate().plusDays(8).toDate()))); assertThat(drugOrder.getEffectiveStopDate(), is(equalTo(new LocalDate().plusDays(8).toDate()))); assertThat(drugOrder.getDosingInstructions().getDose(), is(equalTo(2.0))); assertThat(drugOrder.getDosingInstructions().getDoseUnits(), is(equalTo(CAPSULE_DOSE_UNIT))); assertThat(drugOrder.getDosingInstructions().getRoute(), is(equalTo(MOUTH_ROUTE))); assertTrue(drugOrder.getDosingInstructions().getAsNeeded()); assertThat(drugOrder.getDosingInstructions().getFrequency(), is(equalTo(TWICE_A_DAY_FREQUENCY))); assertThat(drugOrder.getDosingInstructions().getQuantity(), is(equalTo(1.0))); assertThat(drugOrder.getDosingInstructions().getQuantityUnits(), is(equalTo(TABLET_QUANTITY_UNIT))); assertThat(drugOrder.getDosingInstructions().getAdministrationInstructions(), is(equalTo("3-0-2"))); assertThat(drugOrder.getInstructions(), is(equalTo("before meals"))); assertThat(drugOrder.getCommentToFulfiller(), is(equalTo("boil in water"))); assertThat(drugOrder.getOrderNumber(), is(equalTo("ORD-100"))); assertThat(drugOrder.getConcept().getName(), is(equalTo("newConcept"))); assertThat(drugOrder.getConcept().getUuid(), is(equalTo("newConceptUuid"))); }
@Test public void shouldMapNewNonCodedDrugOrder() throws ParseException, NoSuchFieldException, IllegalAccessException { DrugOrder nonCodedDrugOrder = drugOrder(CareSetting.CareSettingType.OUTPATIENT, 3, "3-0-2", 5, "before meals", "boil in water", null, "ORD-100"); nonCodedDrugOrder.setDrugNonCoded(FREE_TEXT_DRUG_NAME); nonCodedDrugOrder.setDrug(null); EncounterTransaction.DrugOrder drugOrder = orderMapper1_12.mapDrugOrder(nonCodedDrugOrder); assertThat(drugOrder.getDrugNonCoded(), is(equalTo(FREE_TEXT_DRUG_NAME))); assertThat(drugOrder.getDrug(), is(equalTo(null))); }
@Test public void shouldSetPreviousDrugOrder() throws NoSuchFieldException, IllegalAccessException { DrugOrder openMrsDrugOrder = drugOrder(CareSetting.CareSettingType.OUTPATIENT, 3, "3-0-2", 5, "before meals", "boil in water", "previousOrderUuid", "ORD-100"); EncounterTransaction.DrugOrder drugOrder = orderMapper1_12.mapDrugOrder(openMrsDrugOrder); assertThat(drugOrder.getPreviousOrderUuid(), is(equalTo("previousOrderUuid"))); } |
VisitDomainWrapper implements DomainWrapper { public void closeOnLastEncounterDatetime() { Encounter mostRecentEncounter = getMostRecentEncounter(); if (mostRecentEncounter == null) { throw new IllegalStateException("Visit has no encounters"); } visit.setStopDatetime(mostRecentEncounter.getEncounterDatetime()); } VisitDomainWrapper(); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties, DispositionService dispositionService); Visit getVisit(); void setVisit(Visit visit); int getVisitId(); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setDispositionService(DispositionService dispositionService); void setVisitQueryService(VisitQueryService visitQueryService); Encounter getAdmissionEncounter(); Encounter getLatestAdtEncounter(); boolean isActive(); @Deprecated // renamed to is Active boolean isOpen(); Encounter getMostRecentCheckInEncounter(); Encounter getEarliestCheckInEncounter(); @Deprecated // use getMostRecentCheckInEncounter, as this is a more accurate method name Encounter getCheckInEncounter(); Encounter getMostRecentEncounter(); @Deprecated //use getMostRecentEncounter because this method name doesn't make sense Encounter getLastEncounter(); Encounter getEarliestEncounter(); @Deprecated // we are standardizing on "Earliest" and "Most Recent" to the Encounter getOldestEncounter(); Encounter getMostRecentVisitNote(); Encounter getMostRecentVisitNoteAtLocation(Location location); boolean hasVisitNote(); boolean hasVisitNoteAtLocation(Location location); List<Encounter> getSortedEncounters(); List<Encounter> getSortedEncounters(SortOrder order); int getDifferenceInDaysBetweenCurrentDateAndStartDate(); Disposition getMostRecentDisposition(); List<Diagnosis> getDiagnosesFromMostRecentDispositionByType(DispositionType type); List<Diagnosis> getPrimaryDiagnoses(); List<Diagnosis> getUniqueDiagnoses(Boolean primaryOnly, Boolean confirmedOnly); @Deprecated List<Diagnosis> getUniqueDiagnosesLegacy(Boolean primaryOnly, Boolean confirmedOnly); boolean hasEncounters(); boolean hasEncounterWithoutSubsequentEncounter(EncounterType lookForEncounterType, EncounterType withoutSubsequentEncounterType); boolean isAdmitted(); boolean isAdmitted(Date onDate); boolean isAwaitingAdmission(); Location getInpatientLocation(Date onDate); Date getStartDatetime(); Date getStopDatetime(); Date getStartDate(); Date getStopDate(); VisitDomainWrapper addEncounter(Encounter encounter); void closeOnLastEncounterDatetime(); void errorIfOutsideVisit(Date checkDatetime, String errorMessage); Date getEncounterStopDateRange(); boolean verifyIfUserIsTheCreatorOfVisit(User currentUser); Object getVisitAttribute(String uuidOrName); } | @Test(expected = IllegalStateException.class) public void shouldFailIfNoEncounters() throws Exception { Date startDate = new DateTime(2012,2,20,10,10).toDate(); Visit visit = new Visit(); visit.setStartDatetime(startDate); new VisitDomainWrapper(visit).closeOnLastEncounterDatetime(); } |
VisitDomainWrapper implements DomainWrapper { public Disposition getMostRecentDisposition() { if (dispositionService.dispositionsSupported()) { DispositionDescriptor dispositionDescriptor = dispositionService.getDispositionDescriptor(); for (Encounter encounter : getSortedEncounters(SortOrder.MOST_RECENT_FIRST)) { for (Obs obs : encounter.getObsAtTopLevel(false)) { if (dispositionDescriptor.isDisposition(obs)) { return dispositionService.getDispositionFromObsGroup(obs); } } } } return null; } VisitDomainWrapper(); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties, DispositionService dispositionService); Visit getVisit(); void setVisit(Visit visit); int getVisitId(); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setDispositionService(DispositionService dispositionService); void setVisitQueryService(VisitQueryService visitQueryService); Encounter getAdmissionEncounter(); Encounter getLatestAdtEncounter(); boolean isActive(); @Deprecated // renamed to is Active boolean isOpen(); Encounter getMostRecentCheckInEncounter(); Encounter getEarliestCheckInEncounter(); @Deprecated // use getMostRecentCheckInEncounter, as this is a more accurate method name Encounter getCheckInEncounter(); Encounter getMostRecentEncounter(); @Deprecated //use getMostRecentEncounter because this method name doesn't make sense Encounter getLastEncounter(); Encounter getEarliestEncounter(); @Deprecated // we are standardizing on "Earliest" and "Most Recent" to the Encounter getOldestEncounter(); Encounter getMostRecentVisitNote(); Encounter getMostRecentVisitNoteAtLocation(Location location); boolean hasVisitNote(); boolean hasVisitNoteAtLocation(Location location); List<Encounter> getSortedEncounters(); List<Encounter> getSortedEncounters(SortOrder order); int getDifferenceInDaysBetweenCurrentDateAndStartDate(); Disposition getMostRecentDisposition(); List<Diagnosis> getDiagnosesFromMostRecentDispositionByType(DispositionType type); List<Diagnosis> getPrimaryDiagnoses(); List<Diagnosis> getUniqueDiagnoses(Boolean primaryOnly, Boolean confirmedOnly); @Deprecated List<Diagnosis> getUniqueDiagnosesLegacy(Boolean primaryOnly, Boolean confirmedOnly); boolean hasEncounters(); boolean hasEncounterWithoutSubsequentEncounter(EncounterType lookForEncounterType, EncounterType withoutSubsequentEncounterType); boolean isAdmitted(); boolean isAdmitted(Date onDate); boolean isAwaitingAdmission(); Location getInpatientLocation(Date onDate); Date getStartDatetime(); Date getStopDatetime(); Date getStartDate(); Date getStopDate(); VisitDomainWrapper addEncounter(Encounter encounter); void closeOnLastEncounterDatetime(); void errorIfOutsideVisit(Date checkDatetime, String errorMessage); Date getEncounterStopDateRange(); boolean verifyIfUserIsTheCreatorOfVisit(User currentUser); Object getVisitAttribute(String uuidOrName); } | @Test public void shouldReturnDispositionFromObs() throws Exception { Encounter mostRecentEncounter = new Encounter(); mostRecentEncounter.setEncounterDatetime(new DateTime(2012,12,12,12,12).toDate()); Encounter secondMostRecentEncounter = new Encounter(); secondMostRecentEncounter.setEncounterDatetime(new DateTime(2012,11,11,11,11).toDate()); Encounter thirdMostRecentEncounter = new Encounter(); thirdMostRecentEncounter.setEncounterDatetime(new DateTime(2012, 10, 10, 10,10).toDate()); Obs mostRecentDispositionGroup = new Obs(); mostRecentDispositionGroup.setConcept(dispositionDescriptor.getDispositionSetConcept()); Obs mostRecentOtherObsGroup = new Obs(); mostRecentOtherObsGroup.setConcept(new Concept()); mostRecentEncounter.addObs(mostRecentDispositionGroup); mostRecentEncounter.addObs(mostRecentOtherObsGroup); Obs secondMostRecentDispositionGroup = new Obs(); secondMostRecentDispositionGroup.setConcept(dispositionDescriptor.getDispositionSetConcept()); secondMostRecentEncounter.addObs(secondMostRecentDispositionGroup); Obs thirdMostRecentDispositionObsGroup = new Obs(); thirdMostRecentDispositionObsGroup.setConcept(dispositionDescriptor.getDispositionSetConcept()); thirdMostRecentEncounter.addObs(thirdMostRecentDispositionObsGroup); Set<Encounter> encounters = new HashSet<Encounter>(); encounters.add(secondMostRecentEncounter); encounters.add(mostRecentEncounter); encounters.add(thirdMostRecentEncounter); when(visit.getEncounters()).thenReturn(encounters); visitDomainWrapper.getMostRecentDisposition(); verify(dispositionService).getDispositionFromObsGroup(mostRecentDispositionGroup); } |
VisitDomainWrapper implements DomainWrapper { public List<Diagnosis> getPrimaryDiagnoses() { List<Diagnosis> diagnoses = new ArrayList<Diagnosis>(); for (Encounter encounter : getSortedEncounters(SortOrder.MOST_RECENT_FIRST)) { diagnoses.addAll(getDiagnosesFromEncounter(encounter, Collections.singletonList(Diagnosis.Order.PRIMARY))); } return diagnoses; } VisitDomainWrapper(); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties, DispositionService dispositionService); Visit getVisit(); void setVisit(Visit visit); int getVisitId(); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setDispositionService(DispositionService dispositionService); void setVisitQueryService(VisitQueryService visitQueryService); Encounter getAdmissionEncounter(); Encounter getLatestAdtEncounter(); boolean isActive(); @Deprecated // renamed to is Active boolean isOpen(); Encounter getMostRecentCheckInEncounter(); Encounter getEarliestCheckInEncounter(); @Deprecated // use getMostRecentCheckInEncounter, as this is a more accurate method name Encounter getCheckInEncounter(); Encounter getMostRecentEncounter(); @Deprecated //use getMostRecentEncounter because this method name doesn't make sense Encounter getLastEncounter(); Encounter getEarliestEncounter(); @Deprecated // we are standardizing on "Earliest" and "Most Recent" to the Encounter getOldestEncounter(); Encounter getMostRecentVisitNote(); Encounter getMostRecentVisitNoteAtLocation(Location location); boolean hasVisitNote(); boolean hasVisitNoteAtLocation(Location location); List<Encounter> getSortedEncounters(); List<Encounter> getSortedEncounters(SortOrder order); int getDifferenceInDaysBetweenCurrentDateAndStartDate(); Disposition getMostRecentDisposition(); List<Diagnosis> getDiagnosesFromMostRecentDispositionByType(DispositionType type); List<Diagnosis> getPrimaryDiagnoses(); List<Diagnosis> getUniqueDiagnoses(Boolean primaryOnly, Boolean confirmedOnly); @Deprecated List<Diagnosis> getUniqueDiagnosesLegacy(Boolean primaryOnly, Boolean confirmedOnly); boolean hasEncounters(); boolean hasEncounterWithoutSubsequentEncounter(EncounterType lookForEncounterType, EncounterType withoutSubsequentEncounterType); boolean isAdmitted(); boolean isAdmitted(Date onDate); boolean isAwaitingAdmission(); Location getInpatientLocation(Date onDate); Date getStartDatetime(); Date getStopDatetime(); Date getStartDate(); Date getStopDate(); VisitDomainWrapper addEncounter(Encounter encounter); void closeOnLastEncounterDatetime(); void errorIfOutsideVisit(Date checkDatetime, String errorMessage); Date getEncounterStopDateRange(); boolean verifyIfUserIsTheCreatorOfVisit(User currentUser); Object getVisitAttribute(String uuidOrName); } | @Test public void shouldReturnAllPrimaryDiagnosesFromVisit() { Encounter encounter = new Encounter(); encounter.setEncounterDatetime(new DateTime(2012, 12, 12, 12, 12).toDate()); Encounter encounter2 = new Encounter(); encounter2.setEncounterDatetime(new DateTime(2012,11,11,11,11).toDate()); Diagnosis primaryDiagnosis1 = new Diagnosis(); Concept primaryDiagnosisConcept1 = new Concept(); primaryDiagnosis1.setDiagnosis(new CodedOrFreeTextAnswer(primaryDiagnosisConcept1)); primaryDiagnosis1.setOrder(Diagnosis.Order.PRIMARY); primaryDiagnosis1.setCertainty(Diagnosis.Certainty.CONFIRMED); encounter.addObs(diagnosisMetadata.buildDiagnosisObsGroup(primaryDiagnosis1)); Diagnosis primaryDiagnosis2 = new Diagnosis(); Concept primaryDiagnosisConcept2 = new Concept(); primaryDiagnosis2.setDiagnosis(new CodedOrFreeTextAnswer(primaryDiagnosisConcept2)); primaryDiagnosis2.setOrder(Diagnosis.Order.PRIMARY); primaryDiagnosis2.setCertainty(Diagnosis.Certainty.PRESUMED); encounter2.addObs(diagnosisMetadata.buildDiagnosisObsGroup(primaryDiagnosis2)); Diagnosis secondaryDiagnosis = new Diagnosis(); Concept secondaryDiagnosisConcept = new Concept(); secondaryDiagnosis.setDiagnosis(new CodedOrFreeTextAnswer(secondaryDiagnosisConcept)); secondaryDiagnosis.setOrder(Diagnosis.Order.SECONDARY); secondaryDiagnosis.setCertainty(Diagnosis.Certainty.PRESUMED); encounter2.addObs(diagnosisMetadata.buildDiagnosisObsGroup(secondaryDiagnosis)); Set<Encounter> encounters = new HashSet<Encounter>(); encounters.add(encounter); encounters.add(encounter2); when(visit.getEncounters()).thenReturn(encounters); List<Diagnosis> diagnoses = visitDomainWrapper.getPrimaryDiagnoses(); assertThat(diagnoses.size(), is(2)); assertThat(diagnoses, hasItem(primaryDiagnosis1)); assertThat(diagnoses, hasItem(primaryDiagnosis2)); }
@Test public void shouldReturnEmptyListIfNoDiagnoses() { Encounter encounter = new Encounter(); encounter.setEncounterDatetime(new DateTime(2012, 12, 12, 12, 12).toDate()); Set<Encounter> encounters = new HashSet<Encounter>(); encounters.add(encounter); when(visit.getEncounters()).thenReturn(encounters); List<Diagnosis> diagnoses = visitDomainWrapper.getPrimaryDiagnoses(); assertThat(diagnoses.size(), is(0)); } |
VisitDomainWrapper implements DomainWrapper { @Deprecated public List<Diagnosis> getUniqueDiagnosesLegacy(Boolean primaryOnly, Boolean confirmedOnly) { Map<CodedOrFreeTextAnswer, Diagnosis> diagnoses = new LinkedHashMap<CodedOrFreeTextAnswer, Diagnosis>(); for (Encounter encounter : getSortedEncounters(SortOrder.MOST_RECENT_FIRST)) { List<Diagnosis> diagnosesFromEncounter = getDiagnosesFromEncounter(encounter); if (diagnosesFromEncounter == null) { return null; } for (Diagnosis d : diagnosesFromEncounter) { if (!primaryOnly || d.getOrder() == Diagnosis.Order.PRIMARY) { if (!confirmedOnly || d.getCertainty() == Diagnosis.Certainty.CONFIRMED) { if (!diagnoses.containsKey(d.getDiagnosis())) { diagnoses.put(d.getDiagnosis(), d); } } } } } return new ArrayList<Diagnosis>(diagnoses.values()); } VisitDomainWrapper(); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties, DispositionService dispositionService); Visit getVisit(); void setVisit(Visit visit); int getVisitId(); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setDispositionService(DispositionService dispositionService); void setVisitQueryService(VisitQueryService visitQueryService); Encounter getAdmissionEncounter(); Encounter getLatestAdtEncounter(); boolean isActive(); @Deprecated // renamed to is Active boolean isOpen(); Encounter getMostRecentCheckInEncounter(); Encounter getEarliestCheckInEncounter(); @Deprecated // use getMostRecentCheckInEncounter, as this is a more accurate method name Encounter getCheckInEncounter(); Encounter getMostRecentEncounter(); @Deprecated //use getMostRecentEncounter because this method name doesn't make sense Encounter getLastEncounter(); Encounter getEarliestEncounter(); @Deprecated // we are standardizing on "Earliest" and "Most Recent" to the Encounter getOldestEncounter(); Encounter getMostRecentVisitNote(); Encounter getMostRecentVisitNoteAtLocation(Location location); boolean hasVisitNote(); boolean hasVisitNoteAtLocation(Location location); List<Encounter> getSortedEncounters(); List<Encounter> getSortedEncounters(SortOrder order); int getDifferenceInDaysBetweenCurrentDateAndStartDate(); Disposition getMostRecentDisposition(); List<Diagnosis> getDiagnosesFromMostRecentDispositionByType(DispositionType type); List<Diagnosis> getPrimaryDiagnoses(); List<Diagnosis> getUniqueDiagnoses(Boolean primaryOnly, Boolean confirmedOnly); @Deprecated List<Diagnosis> getUniqueDiagnosesLegacy(Boolean primaryOnly, Boolean confirmedOnly); boolean hasEncounters(); boolean hasEncounterWithoutSubsequentEncounter(EncounterType lookForEncounterType, EncounterType withoutSubsequentEncounterType); boolean isAdmitted(); boolean isAdmitted(Date onDate); boolean isAwaitingAdmission(); Location getInpatientLocation(Date onDate); Date getStartDatetime(); Date getStopDatetime(); Date getStartDate(); Date getStopDate(); VisitDomainWrapper addEncounter(Encounter encounter); void closeOnLastEncounterDatetime(); void errorIfOutsideVisit(Date checkDatetime, String errorMessage); Date getEncounterStopDateRange(); boolean verifyIfUserIsTheCreatorOfVisit(User currentUser); Object getVisitAttribute(String uuidOrName); } | @Test public void shouldReturnUniqueDiagnoses() { Encounter encounter = new Encounter(); encounter.setEncounterDatetime(new DateTime(2012, 12, 12, 12, 12).toDate()); Set<Encounter> encounters = new HashSet<Encounter>(); encounters.add(encounter); when(visit.getEncounters()).thenReturn(encounters); String diagnosis1 = "Diagnosis 1"; String diagnosis2 = "Diagnosis 2"; String diagnosis3 = "Diagnosis 3"; addDiagnosis(encounter, new CodedOrFreeTextAnswer(diagnosis1), Diagnosis.Order.PRIMARY, Diagnosis.Certainty.CONFIRMED); addDiagnosis(encounter, new CodedOrFreeTextAnswer(diagnosis1), Diagnosis.Order.SECONDARY, Diagnosis.Certainty.PRESUMED); assertThat(visitDomainWrapper.getUniqueDiagnosesLegacy(false, false).size(), is(1)); assertThat(visitDomainWrapper.getUniqueDiagnosesLegacy(true, false).size(), is(1)); addDiagnosis(encounter, new CodedOrFreeTextAnswer(diagnosis2), Diagnosis.Order.PRIMARY, Diagnosis.Certainty.CONFIRMED); assertThat(visitDomainWrapper.getUniqueDiagnosesLegacy(false, false).size(), is(2)); addDiagnosis(encounter, new CodedOrFreeTextAnswer(diagnosis3), Diagnosis.Order.SECONDARY, Diagnosis.Certainty.PRESUMED); assertThat(visitDomainWrapper.getUniqueDiagnosesLegacy(false, false).size(), is(3)); assertThat(visitDomainWrapper.getUniqueDiagnosesLegacy(true, false).size(), is(2)); assertThat(visitDomainWrapper.getUniqueDiagnosesLegacy(false, true).size(), is(2)); assertThat(visitDomainWrapper.getUniqueDiagnosesLegacy(true, true).size(), is(2)); } |
VisitDomainWrapper implements DomainWrapper { public List<Diagnosis> getDiagnosesFromMostRecentDispositionByType(DispositionType type) { if (dispositionService.dispositionsSupported()) { DispositionDescriptor dispositionDescriptor = dispositionService.getDispositionDescriptor(); for (Encounter encounter : getSortedEncounters(SortOrder.MOST_RECENT_FIRST)) { for (Obs obs : encounter.getObsAtTopLevel(false)) { if (dispositionDescriptor.isDisposition(obs) && dispositionService.getDispositionFromObsGroup(obs).getType() == type) { return getDiagnosesFromEncounter(encounter); } } } } return new ArrayList<Diagnosis>(); } VisitDomainWrapper(); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties, DispositionService dispositionService); Visit getVisit(); void setVisit(Visit visit); int getVisitId(); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setDispositionService(DispositionService dispositionService); void setVisitQueryService(VisitQueryService visitQueryService); Encounter getAdmissionEncounter(); Encounter getLatestAdtEncounter(); boolean isActive(); @Deprecated // renamed to is Active boolean isOpen(); Encounter getMostRecentCheckInEncounter(); Encounter getEarliestCheckInEncounter(); @Deprecated // use getMostRecentCheckInEncounter, as this is a more accurate method name Encounter getCheckInEncounter(); Encounter getMostRecentEncounter(); @Deprecated //use getMostRecentEncounter because this method name doesn't make sense Encounter getLastEncounter(); Encounter getEarliestEncounter(); @Deprecated // we are standardizing on "Earliest" and "Most Recent" to the Encounter getOldestEncounter(); Encounter getMostRecentVisitNote(); Encounter getMostRecentVisitNoteAtLocation(Location location); boolean hasVisitNote(); boolean hasVisitNoteAtLocation(Location location); List<Encounter> getSortedEncounters(); List<Encounter> getSortedEncounters(SortOrder order); int getDifferenceInDaysBetweenCurrentDateAndStartDate(); Disposition getMostRecentDisposition(); List<Diagnosis> getDiagnosesFromMostRecentDispositionByType(DispositionType type); List<Diagnosis> getPrimaryDiagnoses(); List<Diagnosis> getUniqueDiagnoses(Boolean primaryOnly, Boolean confirmedOnly); @Deprecated List<Diagnosis> getUniqueDiagnosesLegacy(Boolean primaryOnly, Boolean confirmedOnly); boolean hasEncounters(); boolean hasEncounterWithoutSubsequentEncounter(EncounterType lookForEncounterType, EncounterType withoutSubsequentEncounterType); boolean isAdmitted(); boolean isAdmitted(Date onDate); boolean isAwaitingAdmission(); Location getInpatientLocation(Date onDate); Date getStartDatetime(); Date getStopDatetime(); Date getStartDate(); Date getStopDate(); VisitDomainWrapper addEncounter(Encounter encounter); void closeOnLastEncounterDatetime(); void errorIfOutsideVisit(Date checkDatetime, String errorMessage); Date getEncounterStopDateRange(); boolean verifyIfUserIsTheCreatorOfVisit(User currentUser); Object getVisitAttribute(String uuidOrName); } | @Test public void shouldReturnAllDiagnosesFromMostRecentEncounterWithAdmitDisposition() { Encounter encounterWithTransferDisposition = new Encounter(); encounterWithTransferDisposition.setEncounterDatetime(new DateTime(2012, 12, 12, 12, 12).toDate()); Encounter mostRecentEncounterWithAdmitDisposition = new Encounter(); mostRecentEncounterWithAdmitDisposition.setEncounterDatetime(new DateTime(2012, 11, 11, 11, 11).toDate()); Encounter olderEncounterWithAdmitDisposition = new Encounter(); olderEncounterWithAdmitDisposition.setEncounterDatetime(new DateTime(2012, 10, 10, 10, 10).toDate()); Disposition transfer = new Disposition(); transfer.setType(DispositionType.TRANSFER); Disposition admit = new Disposition(); admit.setType(DispositionType.ADMIT); Obs transferDispositionObsGroup = new Obs(); transferDispositionObsGroup.setConcept(dispositionDescriptor.getDispositionSetConcept()); when(dispositionService.getDispositionFromObsGroup(transferDispositionObsGroup)).thenReturn(transfer); Obs mostRecentAdmitDispositionObsGroup = new Obs(); mostRecentAdmitDispositionObsGroup.setConcept(dispositionDescriptor.getDispositionSetConcept()); when(dispositionService.getDispositionFromObsGroup(mostRecentAdmitDispositionObsGroup)).thenReturn(admit); Obs olderAdmitDispositionObsGroup = new Obs(); olderAdmitDispositionObsGroup.setConcept(dispositionDescriptor.getDispositionSetConcept()); when(dispositionService.getDispositionFromObsGroup(olderAdmitDispositionObsGroup)).thenReturn(admit); Diagnosis primaryDiagnosis1 = new Diagnosis(); Concept primaryDiagnosisConcept1 = new Concept(); primaryDiagnosis1.setDiagnosis(new CodedOrFreeTextAnswer(primaryDiagnosisConcept1)); primaryDiagnosis1.setOrder(Diagnosis.Order.PRIMARY); primaryDiagnosis1.setCertainty(Diagnosis.Certainty.CONFIRMED); Diagnosis primaryDiagnosis2 = new Diagnosis(); Concept primaryDiagnosisConcept2 = new Concept(); primaryDiagnosis2.setDiagnosis(new CodedOrFreeTextAnswer(primaryDiagnosisConcept2)); primaryDiagnosis2.setOrder(Diagnosis.Order.PRIMARY); primaryDiagnosis2.setCertainty(Diagnosis.Certainty.PRESUMED); Diagnosis primaryDiagnosis3 = new Diagnosis(); Concept primaryDiagnosisConcept3 = new Concept(); primaryDiagnosis3.setDiagnosis(new CodedOrFreeTextAnswer(primaryDiagnosisConcept3)); primaryDiagnosis3.setOrder(Diagnosis.Order.PRIMARY); primaryDiagnosis3.setCertainty(Diagnosis.Certainty.PRESUMED); Diagnosis secondaryDiagnosis = new Diagnosis(); Concept secondaryDiagnosisConcept = new Concept(); secondaryDiagnosis.setDiagnosis(new CodedOrFreeTextAnswer(secondaryDiagnosisConcept)); secondaryDiagnosis.setOrder(Diagnosis.Order.SECONDARY); secondaryDiagnosis.setCertainty(Diagnosis.Certainty.PRESUMED); encounterWithTransferDisposition.addObs(transferDispositionObsGroup); encounterWithTransferDisposition.addObs(diagnosisMetadata.buildDiagnosisObsGroup(primaryDiagnosis1)); mostRecentEncounterWithAdmitDisposition.addObs(mostRecentAdmitDispositionObsGroup); mostRecentEncounterWithAdmitDisposition.addObs(diagnosisMetadata.buildDiagnosisObsGroup(primaryDiagnosis2)); mostRecentEncounterWithAdmitDisposition.addObs(diagnosisMetadata.buildDiagnosisObsGroup(secondaryDiagnosis)); olderEncounterWithAdmitDisposition.addObs(olderAdmitDispositionObsGroup); olderEncounterWithAdmitDisposition.addObs(diagnosisMetadata.buildDiagnosisObsGroup(primaryDiagnosis2)); Set<Encounter> encounters = new HashSet<Encounter>(); encounters.add(encounterWithTransferDisposition); encounters.add(mostRecentEncounterWithAdmitDisposition); encounters.add(olderEncounterWithAdmitDisposition); when(visit.getEncounters()).thenReturn(encounters); List<Diagnosis> diagnoses = visitDomainWrapper.getDiagnosesFromMostRecentDispositionByType(DispositionType.ADMIT); assertThat(diagnoses.size(), is(2)); assertThat(diagnoses, hasItem(secondaryDiagnosis)); assertThat(diagnoses, hasItem(primaryDiagnosis2)); }
@Test public void getDiagnosesFromMostRecentDispositionShouldNotFailIfDispositionHasNoType() { Encounter encounterWithDisposition = new Encounter(); encounterWithDisposition.setEncounterDatetime(new DateTime(2012, 12, 12, 12, 12).toDate()); Disposition dispositionWithoutType = new Disposition(); Obs dispositionObsGroup = new Obs(); dispositionObsGroup.setConcept(dispositionDescriptor.getDispositionSetConcept()); when(dispositionService.getDispositionFromObsGroup(dispositionObsGroup)).thenReturn(dispositionWithoutType); encounterWithDisposition.addObs(dispositionObsGroup); Set<Encounter> encounters = new HashSet<Encounter>(); encounters.add(encounterWithDisposition); when(visit.getEncounters()).thenReturn(encounters); List<Diagnosis> diagnoses = visitDomainWrapper.getDiagnosesFromMostRecentDispositionByType(DispositionType.ADMIT); } |
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); } | @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); } |
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); } | @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)); } |
PatientViewedEventListener implements EventListener { public void processMessage(Message message) throws Exception { MapMessage mapMessage = (MapMessage) message; String patientUuid = mapMessage.getString(EmrApiConstants.EVENT_KEY_PATIENT_UUID); String userUuid = mapMessage.getString(EmrApiConstants.EVENT_KEY_USER_UUID); Patient patientToAdd = Context.getPatientService().getPatientByUuid(patientUuid); if (patientToAdd == null || patientToAdd.getId() == null) { throw new APIException("failed to find a patient with uuid:" + patientUuid + " or the patient is not yet saved"); } UserService userService = Context.getUserService(); User user = userService.getUserByUuid(userUuid); if (user != null && patientToAdd != null) { EmrApiProperties emrProperties = Context.getRegisteredComponents(EmrApiProperties.class).iterator().next(); Integer limit = emrProperties.getLastViewedPatientSizeLimit(); List<Integer> patientIds = new ArrayList<Integer>(limit); if (limit > 0) { List<Patient> lastViewedPatients = GeneralUtils.getLastViewedPatients(user); patientIds.add(patientToAdd.getId()); for (Patient p : lastViewedPatients) { if (patientIds.size() == limit) break; if (patientIds.contains(p.getId())) continue; patientIds.add(p.getId()); } Collections.reverse(patientIds); } String property = StringUtils.join(patientIds, ","); if (StringUtils.isNotBlank(property) && property.length() > 255) { property = property.substring(property.indexOf(',', property.length() - 255) + 1); } userService.setUserProperty(user, EmrApiConstants.USER_PROPERTY_NAME_LAST_VIEWED_PATIENT_IDS, property); } } PatientViewedEventListener(DaemonToken token); @Override void onMessage(final Message message); void processMessage(Message message); } | @Test public void processMessage_shouldAddThePatientToTheLastViewedUserProperty() throws Exception { setInitialLastViewedPatients(Arrays.asList(2, 6, 7)); final Integer lastViewedPatientId = 8; Message message = createMessage(patientService.getPatient(lastViewedPatientId), user); listener.processMessage(message); List<Patient> lastViewed = GeneralUtils.getLastViewedPatients(user); assertEquals(lastViewedPatientId, lastViewed.get(0).getId()); assertEquals(7, lastViewed.get(1).getId().intValue()); assertEquals(6, lastViewed.get(2).getId().intValue()); assertEquals(2, lastViewed.get(3).getId().intValue()); }
@Test public void processMessage_shouldRemoveTheFirstPatientAndAddTheNewOneToTheStartIfTheListIsFull() throws Exception { final Integer newLimit = 3; GlobalProperty gp = new GlobalProperty(EmrApiConstants.GP_LAST_VIEWED_PATIENT_SIZE_LIMIT, newLimit.toString()); adminService.saveGlobalProperty(gp); final Integer patientIdToRemove = 2; setInitialLastViewedPatients(Arrays.asList(patientIdToRemove, 6, 7)); final Integer lastSeenPatientId = 8; MapMessage message = createMessage(patientService.getPatient(lastSeenPatientId), user); listener.processMessage(message); List<Patient> lastViewed = GeneralUtils.getLastViewedPatients(user); assertEquals(newLimit.intValue(), lastViewed.size()); assertEquals(lastSeenPatientId, lastViewed.get(0).getId()); assertEquals(7, lastViewed.get(1).getId().intValue()); assertEquals(6, lastViewed.get(2).getId().intValue()); }
@Test public void processMessage_shouldNotAddADuplicateAndShouldMoveTheExistingPatientToTheStart() throws Exception { final Integer duplicatePatientId = 2; List<Integer> initialPatientIds = Arrays.asList(duplicatePatientId, 6, 7, 8); final int initialSize = initialPatientIds.size(); setInitialLastViewedPatients(initialPatientIds); MapMessage message = createMessage(patientService.getPatient(duplicatePatientId), user); listener.processMessage(message); List<Patient> lastViewed = GeneralUtils.getLastViewedPatients(user); assertEquals(initialSize, lastViewed.size()); assertEquals(duplicatePatientId, lastViewed.get(0).getId()); assertEquals(8, lastViewed.get(1).getId().intValue()); assertEquals(7, lastViewed.get(2).getId().intValue()); assertEquals(6, lastViewed.get(3).getId().intValue()); }
@Test public void processMessage_shouldNotRemoveAnyPatientIfADuplicateIsAddedToAFullList() throws Exception { final Integer newLimit = 4; GlobalProperty gp = new GlobalProperty(EmrApiConstants.GP_LAST_VIEWED_PATIENT_SIZE_LIMIT, newLimit.toString()); adminService.saveGlobalProperty(gp); final Integer duplicatePatientId = 2; setInitialLastViewedPatients(Arrays.asList(6, duplicatePatientId, 7, 8)); MapMessage message = createMessage(patientService.getPatient(duplicatePatientId), user); listener.processMessage(message); List<Patient> lastViewed = GeneralUtils.getLastViewedPatients(user); assertEquals(newLimit.intValue(), lastViewed.size()); assertEquals(duplicatePatientId, lastViewed.get(0).getId()); assertEquals(8, lastViewed.get(1).getId().intValue()); assertEquals(7, lastViewed.get(2).getId().intValue()); assertEquals(6, lastViewed.get(3).getId().intValue()); } |
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); } | @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)); } |
EmrOrderServiceImpl_1_11 implements EmrOrderService { @Override public void save(List<EncounterTransaction.DrugOrder> drugOrders, Encounter encounter) { encounter.setOrders(new LinkedHashSet<org.openmrs.Order>(encounter.getOrders())); for (EncounterTransaction.DrugOrder drugOrder : drugOrders) { DrugOrder omrsDrugOrder = openMRSDrugOrderMapper.map(drugOrder, encounter); encounter.addOrder(omrsDrugOrder); } encounterService.saveEncounter(encounter); } @Autowired EmrOrderServiceImpl_1_11(OpenMRSDrugOrderMapper openMRSDrugOrderMapper, EncounterService encounterService, OpenMRSOrderMapper openMRSOrderMapper); @Override void save(List<EncounterTransaction.DrugOrder> drugOrders, Encounter encounter); @Override void saveOrders(List<EncounterTransaction.Order> orders, Encounter encounter); } | @Test public void shouldSaveNewDrugOrdersInTheSequenceOfOrdering() throws ParseException { EmrOrderServiceImpl_1_11 emrOrderService = new EmrOrderServiceImpl_1_11(openMRSDrugOrderMapper, encounterService, openMRSOrderMapper); EncounterTransaction.DrugOrder drugOrder1 = new DrugOrderBuilder().withDrugUuid("drug-uuid1").build(); EncounterTransaction.DrugOrder drugOrder2 = new DrugOrderBuilder().withDrugUuid("drug-uuid2").build(); DrugOrder mappedDrugOrder1 = new DrugOrder(); DrugOrder mappedDrugOrder2 = new DrugOrder(); Encounter encounter = new Encounter(); when(openMRSDrugOrderMapper.map(drugOrder1, encounter)).thenReturn(mappedDrugOrder1); when(openMRSDrugOrderMapper.map(drugOrder2, encounter)).thenReturn(mappedDrugOrder2); emrOrderService.save(Arrays.asList(drugOrder1, drugOrder2), encounter); ArgumentCaptor<Encounter> encounterArgumentCaptor = ArgumentCaptor.forClass(Encounter.class); verify(encounterService).saveEncounter(encounterArgumentCaptor.capture()); Encounter savedEncounter = encounterArgumentCaptor.getValue(); ArrayList<org.openmrs.Order> savedOrders = new ArrayList<org.openmrs.Order>(savedEncounter.getOrders()); assertThat(savedOrders.size(), is(2)); assertThat((DrugOrder)savedOrders.get(0), is(sameInstance(mappedDrugOrder1))); assertThat((DrugOrder)savedOrders.get(1), is(sameInstance(mappedDrugOrder2))); }
@Test public void shouldSaveNewDrugOrdersInTheSequenceOfOrderingToAnEncounterWithExistingOrders() throws ParseException { EmrOrderServiceImpl_1_11 emrOrderService = new EmrOrderServiceImpl_1_11(openMRSDrugOrderMapper, encounterService, openMRSOrderMapper); EncounterTransaction.DrugOrder drugOrder3 = new DrugOrderBuilder().withDrugUuid("drug-uuid3").build(); EncounterTransaction.DrugOrder drugOrder4 = new DrugOrderBuilder().withDrugUuid("drug-uuid4").build(); DrugOrder existingDrugOrder1 = new DrugOrder(); DrugOrder existingDrugOrder2 = new DrugOrder(); DrugOrder mappedDrugOrder3 = new DrugOrder(); DrugOrder mappedDrugOrder4 = new DrugOrder(); Encounter encounter = new Encounter(); encounter.addOrder(existingDrugOrder1); encounter.addOrder(existingDrugOrder2); when(openMRSDrugOrderMapper.map(drugOrder3, encounter)).thenReturn(mappedDrugOrder3); when(openMRSDrugOrderMapper.map(drugOrder4, encounter)).thenReturn(mappedDrugOrder4); emrOrderService.save(Arrays.asList(drugOrder3, drugOrder4), encounter); ArgumentCaptor<Encounter> encounterArgumentCaptor = ArgumentCaptor.forClass(Encounter.class); verify(encounterService).saveEncounter(encounterArgumentCaptor.capture()); Encounter savedEncounter = encounterArgumentCaptor.getValue(); ArrayList<org.openmrs.Order> savedOrders = new ArrayList<org.openmrs.Order>(savedEncounter.getOrders()); assertThat(savedOrders.size(), is(4)); assertThat((DrugOrder)savedOrders.get(2), is(sameInstance(mappedDrugOrder3))); assertThat((DrugOrder)savedOrders.get(3), is(sameInstance(mappedDrugOrder4))); } |
EmrOrderServiceImpl_1_11 implements EmrOrderService { @Override public void saveOrders(List<EncounterTransaction.Order> orders, Encounter encounter) { for (EncounterTransaction.Order order : orders) { Order omrsOrder = openMRSOrderMapper.map(order, encounter); encounter.addOrder(omrsOrder); } encounterService.saveEncounter(encounter); } @Autowired EmrOrderServiceImpl_1_11(OpenMRSDrugOrderMapper openMRSDrugOrderMapper, EncounterService encounterService, OpenMRSOrderMapper openMRSOrderMapper); @Override void save(List<EncounterTransaction.DrugOrder> drugOrders, Encounter encounter); @Override void saveOrders(List<EncounterTransaction.Order> orders, Encounter encounter); } | @Test public void shouldSaveOrders() throws ParseException { EmrOrderServiceImpl_1_11 emrOrderService = new EmrOrderServiceImpl_1_11(openMRSDrugOrderMapper, encounterService, openMRSOrderMapper); EncounterTransaction.Order order1 = new OrderBuilder().withConceptUuid("concept-uuid1").withComment("Comment").build(); EncounterTransaction.Order order2 = new OrderBuilder().withConceptUuid("concept-uuid2").withComment("Comment").build(); Order mappedOrder1 = new Order(); Concept concept = new Concept(); concept.setUuid("concept-uuid1"); mappedOrder1.setConcept(concept); mappedOrder1.setCommentToFulfiller("Comment"); Order mappedOrder2 = new Order(); concept = new Concept(); concept.setUuid("concept-uuid2"); mappedOrder2.setConcept(concept); mappedOrder2.setCommentToFulfiller("Comment"); Encounter encounter = new Encounter(); when(openMRSOrderMapper.map(order1,encounter)).thenReturn(mappedOrder1); when(openMRSOrderMapper.map(order2,encounter)).thenReturn(mappedOrder2); emrOrderService.saveOrders(Arrays.asList(order1, order2), encounter); ArgumentCaptor<Encounter> encounterArgumentCaptor = ArgumentCaptor.forClass(Encounter.class); verify(encounterService).saveEncounter(encounterArgumentCaptor.capture()); Encounter savedEncounter = encounterArgumentCaptor.getValue(); ArrayList<org.openmrs.Order> savedOrders = new ArrayList<org.openmrs.Order>(savedEncounter.getOrders()); assertThat(savedOrders.size(), is(2)); assertTrue(existsInOrdersList(mappedOrder1, savedOrders)); assertTrue(existsInOrdersList(mappedOrder2, savedOrders)); }
@Test public void shouldSaveOrdersToEncounterWithExistingOrders() throws ParseException { EmrOrderServiceImpl_1_11 emrOrderService = new EmrOrderServiceImpl_1_11(openMRSDrugOrderMapper, encounterService, openMRSOrderMapper); EncounterTransaction.Order order1 = new OrderBuilder().withConceptUuid("concept-uuid1").withComment("Comment").build(); EncounterTransaction.Order order2 = new OrderBuilder().withConceptUuid("concept-uuid2").withComment("Comment").build(); Order mappedOrder1 = new Order(); Concept concept = new Concept(); concept.setUuid("concept-uuid1"); mappedOrder1.setConcept(concept); mappedOrder1.setCommentToFulfiller("Comment"); Order mappedOrder2 = new Order(); concept = new Concept(); concept.setUuid("concept-uuid2"); mappedOrder2.setConcept(concept); mappedOrder2.setCommentToFulfiller("Comment"); Order existingOrder1 = new Order(); Order existingOrder2 = new Order(); Encounter encounter = new Encounter(); encounter.addOrder(existingOrder1); encounter.addOrder(existingOrder2); when(openMRSOrderMapper.map(order1,encounter)).thenReturn(mappedOrder1); when(openMRSOrderMapper.map(order2,encounter)).thenReturn(mappedOrder2); emrOrderService.saveOrders(Arrays.asList(order1, order2), encounter); ArgumentCaptor<Encounter> encounterArgumentCaptor = ArgumentCaptor.forClass(Encounter.class); verify(encounterService).saveEncounter(encounterArgumentCaptor.capture()); Encounter savedEncounter = encounterArgumentCaptor.getValue(); ArrayList<org.openmrs.Order> savedOrders = new ArrayList<org.openmrs.Order>(savedEncounter.getOrders()); assertThat(savedOrders.size(), is(4)); assertTrue(existsInOrdersList(mappedOrder1, savedOrders)); assertTrue(existsInOrdersList(mappedOrder2, savedOrders)); } |
EmrOrderServiceImpl_1_10 implements EmrOrderService { @Override public void save(List<EncounterTransaction.DrugOrder> drugOrders, Encounter encounter) { encounter.setOrders(new LinkedHashSet<org.openmrs.Order>(encounter.getOrders())); for (EncounterTransaction.DrugOrder drugOrder : drugOrders) { DrugOrder omrsDrugOrder = openMRSDrugOrderMapper.map(drugOrder, encounter); encounter.addOrder(omrsDrugOrder); } encounterService.saveEncounter(encounter); } @Autowired EmrOrderServiceImpl_1_10(OpenMRSDrugOrderMapper openMRSDrugOrderMapper, EncounterService encounterService, OpenMRSOrderMapper openMRSOrderMapper); @Override void save(List<EncounterTransaction.DrugOrder> drugOrders, Encounter encounter); @Override void saveOrders(List<EncounterTransaction.Order> orders, Encounter encounter); } | @Test public void shouldSaveNewDrugOrdersInTheSequenceOfOrdering() throws ParseException { EmrOrderServiceImpl_1_10 emrOrderService = new EmrOrderServiceImpl_1_10(openMRSDrugOrderMapper, encounterService, openMRSOrderMapper); EncounterTransaction.DrugOrder drugOrder1 = new DrugOrderBuilder().withDrugUuid("drug-uuid1").build(); EncounterTransaction.DrugOrder drugOrder2 = new DrugOrderBuilder().withDrugUuid("drug-uuid2").build(); DrugOrder mappedDrugOrder1 = new DrugOrder(); DrugOrder mappedDrugOrder2 = new DrugOrder(); Encounter encounter = new Encounter(); when(openMRSDrugOrderMapper.map(drugOrder1, encounter)).thenReturn(mappedDrugOrder1); when(openMRSDrugOrderMapper.map(drugOrder2, encounter)).thenReturn(mappedDrugOrder2); emrOrderService.save(Arrays.asList(drugOrder1, drugOrder2), encounter); ArgumentCaptor<Encounter> encounterArgumentCaptor = ArgumentCaptor.forClass(Encounter.class); verify(encounterService).saveEncounter(encounterArgumentCaptor.capture()); Encounter savedEncounter = encounterArgumentCaptor.getValue(); ArrayList<org.openmrs.Order> savedOrders = new ArrayList<org.openmrs.Order>(savedEncounter.getOrders()); assertThat(savedOrders.size(), is(2)); assertThat((DrugOrder)savedOrders.get(0), is(sameInstance(mappedDrugOrder1))); assertThat((DrugOrder)savedOrders.get(1), is(sameInstance(mappedDrugOrder2))); }
@Test public void shouldSaveNewDrugOrdersInTheSequenceOfOrderingToAnEncounterWithExistingOrders() throws ParseException { EmrOrderServiceImpl_1_10 emrOrderService = new EmrOrderServiceImpl_1_10(openMRSDrugOrderMapper, encounterService, openMRSOrderMapper); EncounterTransaction.DrugOrder drugOrder3 = new DrugOrderBuilder().withDrugUuid("drug-uuid3").build(); EncounterTransaction.DrugOrder drugOrder4 = new DrugOrderBuilder().withDrugUuid("drug-uuid4").build(); DrugOrder existingDrugOrder1 = new DrugOrder(); DrugOrder existingDrugOrder2 = new DrugOrder(); DrugOrder mappedDrugOrder3 = new DrugOrder(); DrugOrder mappedDrugOrder4 = new DrugOrder(); Encounter encounter = new Encounter(); encounter.addOrder(existingDrugOrder1); encounter.addOrder(existingDrugOrder2); when(openMRSDrugOrderMapper.map(drugOrder3, encounter)).thenReturn(mappedDrugOrder3); when(openMRSDrugOrderMapper.map(drugOrder4, encounter)).thenReturn(mappedDrugOrder4); emrOrderService.save(Arrays.asList(drugOrder3, drugOrder4), encounter); ArgumentCaptor<Encounter> encounterArgumentCaptor = ArgumentCaptor.forClass(Encounter.class); verify(encounterService).saveEncounter(encounterArgumentCaptor.capture()); Encounter savedEncounter = encounterArgumentCaptor.getValue(); ArrayList<org.openmrs.Order> savedOrders = new ArrayList<org.openmrs.Order>(savedEncounter.getOrders()); assertThat(savedOrders.size(), is(4)); assertThat((DrugOrder)savedOrders.get(2), is(sameInstance(mappedDrugOrder3))); assertThat((DrugOrder)savedOrders.get(3), is(sameInstance(mappedDrugOrder4))); } |
EmrOrderServiceImpl_1_10 implements EmrOrderService { @Override public void saveOrders(List<EncounterTransaction.Order> orders, Encounter encounter) { for (EncounterTransaction.Order order : orders) { Order omrsOrder = openMRSOrderMapper.map(order, encounter); encounter.addOrder(omrsOrder); } encounterService.saveEncounter(encounter); } @Autowired EmrOrderServiceImpl_1_10(OpenMRSDrugOrderMapper openMRSDrugOrderMapper, EncounterService encounterService, OpenMRSOrderMapper openMRSOrderMapper); @Override void save(List<EncounterTransaction.DrugOrder> drugOrders, Encounter encounter); @Override void saveOrders(List<EncounterTransaction.Order> orders, Encounter encounter); } | @Test public void shouldSaveOrders() throws ParseException { EmrOrderServiceImpl_1_10 emrOrderService = new EmrOrderServiceImpl_1_10(openMRSDrugOrderMapper, encounterService, openMRSOrderMapper); EncounterTransaction.Order order1 = new OrderBuilder().withConceptUuid("concept-uuid1").withComment("Comment").build(); EncounterTransaction.Order order2 = new OrderBuilder().withConceptUuid("concept-uuid2").withComment("Comment").build(); Order mappedOrder1 = new Order(); Concept concept = new Concept(); concept.setUuid("concept-uuid1"); mappedOrder1.setConcept(concept); mappedOrder1.setCommentToFulfiller("Comment"); Order mappedOrder2 = new Order(); concept = new Concept(); concept.setUuid("concept-uuid2"); mappedOrder2.setConcept(concept); mappedOrder2.setCommentToFulfiller("Comment"); Encounter encounter = new Encounter(); when(openMRSOrderMapper.map(order1,encounter)).thenReturn(mappedOrder1); when(openMRSOrderMapper.map(order2,encounter)).thenReturn(mappedOrder2); emrOrderService.saveOrders(Arrays.asList(order1, order2), encounter); ArgumentCaptor<Encounter> encounterArgumentCaptor = ArgumentCaptor.forClass(Encounter.class); verify(encounterService).saveEncounter(encounterArgumentCaptor.capture()); Encounter savedEncounter = encounterArgumentCaptor.getValue(); ArrayList<org.openmrs.Order> savedOrders = new ArrayList<org.openmrs.Order>(savedEncounter.getOrders()); assertThat(savedOrders.size(), is(2)); assertTrue(existsInOrdersList(mappedOrder1, savedOrders)); assertTrue(existsInOrdersList(mappedOrder2, savedOrders)); }
@Test public void shouldSaveOrdersToEncounterWithExistingOrders() throws ParseException { EmrOrderServiceImpl_1_10 emrOrderService = new EmrOrderServiceImpl_1_10(openMRSDrugOrderMapper, encounterService, openMRSOrderMapper); EncounterTransaction.Order order1 = new OrderBuilder().withConceptUuid("concept-uuid1").withComment("Comment").build(); EncounterTransaction.Order order2 = new OrderBuilder().withConceptUuid("concept-uuid2").withComment("Comment").build(); Order mappedOrder1 = new Order(); Concept concept = new Concept(); concept.setUuid("concept-uuid1"); mappedOrder1.setConcept(concept); mappedOrder1.setCommentToFulfiller("Comment"); Order mappedOrder2 = new Order(); concept = new Concept(); concept.setUuid("concept-uuid2"); mappedOrder2.setConcept(concept); mappedOrder2.setCommentToFulfiller("Comment"); Order existingOrder1 = new Order(); Order existingOrder2 = new Order(); Encounter encounter = new Encounter(); encounter.addOrder(existingOrder1); encounter.addOrder(existingOrder2); when(openMRSOrderMapper.map(order1,encounter)).thenReturn(mappedOrder1); when(openMRSOrderMapper.map(order2,encounter)).thenReturn(mappedOrder2); emrOrderService.saveOrders(Arrays.asList(order1, order2), encounter); ArgumentCaptor<Encounter> encounterArgumentCaptor = ArgumentCaptor.forClass(Encounter.class); verify(encounterService).saveEncounter(encounterArgumentCaptor.capture()); Encounter savedEncounter = encounterArgumentCaptor.getValue(); ArrayList<org.openmrs.Order> savedOrders = new ArrayList<org.openmrs.Order>(savedEncounter.getOrders()); assertThat(savedOrders.size(), is(4)); assertTrue(existsInOrdersList(mappedOrder1, savedOrders)); assertTrue(existsInOrdersList(mappedOrder2, savedOrders)); } |
OrderMapper1_12 implements OrderMapper { @Override public List<EncounterTransaction.DrugOrder> mapDrugOrders(Encounter encounter) { List<EncounterTransaction.DrugOrder> orders = new ArrayList<EncounterTransaction.DrugOrder>(); for (Order order : encounter.getOrders()) { order = HibernateUtil.getRealObjectFromProxy(order); if (DrugOrder.class.equals(order.getClass())) { orders.add(mapDrugOrder((DrugOrder) order)); } } sortByOrderNumber(orders); 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); } | @Test public void shouldReturnDrugOrdersSortedByOrderNumber() throws NoSuchFieldException, IllegalAccessException { DrugOrder drugOrder100 = drugOrder(CareSetting.CareSettingType.OUTPATIENT, 3, "3-0-2", 5, "before meals", "boil in water", null, "ORD-100"); DrugOrder drugOrder201 = drugOrder(CareSetting.CareSettingType.OUTPATIENT, 3, "3-0-2", 5, "before meals", "boil in water", null, "ORD-201"); DrugOrder drugOrder350 = drugOrder(CareSetting.CareSettingType.OUTPATIENT, 3, "3-0-2", 5, "before meals", "boil in water", null, "ORD-350"); Encounter encounter = new Encounter(); encounter.setOrders(new HashSet<Order>(Arrays.asList(drugOrder350, drugOrder100, drugOrder201))); List<EncounterTransaction.DrugOrder> sortedDrugOrders = orderMapper1_12.mapDrugOrders(encounter); assertEquals("ORD-100", sortedDrugOrders.get(0).getOrderNumber()); assertEquals("ORD-201", sortedDrugOrders.get(1).getOrderNumber()); assertEquals("ORD-350", sortedDrugOrders.get(2).getOrderNumber()); } |
ConditionMapper { public Condition map(org.openmrs.module.emrapi.conditionslist.Condition openmrsCondition) { Concept concept = mapConcept(openmrsCondition.getConcept()); Condition condition = new Condition(); condition.setUuid(openmrsCondition.getUuid()); condition.setAdditionalDetail(openmrsCondition.getAdditionalDetail()); condition.setStatus(openmrsCondition.getStatus()); condition.setConcept(concept); condition.setPatientUuid(openmrsCondition.getPatient().getUuid()); condition.setConditionNonCoded(openmrsCondition.getConditionNonCoded()); condition.setOnSetDate(openmrsCondition.getOnsetDate()); condition.setVoided(openmrsCondition.getVoided()); condition.setVoidReason(openmrsCondition.getVoidReason()); condition.setEndDate(openmrsCondition.getEndDate()); condition.setCreator(openmrsCondition.getCreator().getDisplayString()); condition.setDateCreated(openmrsCondition.getDateCreated()); if (openmrsCondition.getPreviousCondition() != null) { condition.setPreviousConditionUuid(openmrsCondition.getPreviousCondition().getUuid()); } if (openmrsCondition.getEndReason() != null) { condition.setEndReason(mapConcept(openmrsCondition.getEndReason())); } return condition; } Condition map(org.openmrs.module.emrapi.conditionslist.Condition openmrsCondition); org.openmrs.module.emrapi.conditionslist.Condition map(Condition condition); } | @Test public void shouldMapOpenmrsConditionToContractCondition() throws Exception { String uuid = "13a1234-asdf23-ad23425as-sas90"; Date today = new Date(); String conceptUuid = "10924-1294124-1284u12-12841"; String patientUuid = "13a1234-asdf23-ad2354-sas23"; String additionalDetail = "some notes"; String endReasonUuid = "end-reason-uuid-288a-asdf"; org.openmrs.module.emrapi.conditionslist.Condition prevOpenmrsCondition = new org.openmrs.module.emrapi.conditionslist.Condition(); org.openmrs.module.emrapi.conditionslist.Condition openmrsCondition = new org.openmrs.module.emrapi.conditionslist.Condition(); openmrsCondition.setDateCreated(new Date()); openmrsCondition.setPreviousCondition(prevOpenmrsCondition); openmrsCondition.setOnsetDate(today); openmrsCondition.setUuid(uuid); Concept concept = new Concept(); concept.setFullySpecifiedName(new ConceptName("dog bite", Locale.ENGLISH)); Concept endReason = new Concept(); endReason.setFullySpecifiedName(new ConceptName("end", Locale.ENGLISH)); endReason.setUuid(endReasonUuid); openmrsCondition.setEndReason(endReason); concept.setUuid(conceptUuid); Patient patient = new Patient(); patient.setUuid(patientUuid); openmrsCondition.setConcept(concept); openmrsCondition.setPatient(patient); openmrsCondition.setStatus(INACTIVE); openmrsCondition.setAdditionalDetail(additionalDetail); User creator = new User(); creator.setUsername("CREATOR"); openmrsCondition.setCreator(creator); Condition condition = conditionMapper.map(openmrsCondition); assertEquals(uuid, condition.getUuid()); assertEquals(prevOpenmrsCondition.getUuid(), condition.getPreviousConditionUuid()); assertEquals(conceptUuid, condition.getConcept().getUuid()); assertEquals(patientUuid, condition.getPatientUuid()); assertEquals(openmrsCondition.getDateCreated(), condition.getDateCreated()); assertEquals(today, condition.getOnSetDate()); assertEquals(additionalDetail, condition.getAdditionalDetail()); assertEquals(null, condition.getEndDate()); assertEquals(endReasonUuid, condition.getEndReason().getUuid()); assertEquals(INACTIVE, condition.getStatus()); assertEquals("(CREATOR)", condition.getCreator()); }
@Test public void shouldMapContractConditionToOpenmrsCondition() throws Exception { String uuid = "13a1234-asdf23-ad23425as-sas90"; Date today = new Date(); String conceptUuid = "10924-1294124-1284u12-12841"; String patientUuid = "13a1234-asdf23-ad2354-sas23"; String additionalDetail = "some notes"; String endReasonUuid = "end-reason-uuid-288a-asdf"; Condition condition = new Condition(); condition.setOnSetDate(today); condition.setUuid(uuid); Concept concept = new Concept(); Concept endReason = new Concept(); endReason.setUuid(endReasonUuid); condition.setEndReason(new org.openmrs.module.emrapi.conditionslist.contract.Concept(endReasonUuid, "somename")); condition.setEndDate(today); concept.setUuid(conceptUuid); Patient patient = new Patient(); patient.setUuid(patientUuid); condition.setConcept(new org.openmrs.module.emrapi.conditionslist.contract.Concept(conceptUuid, "somename")); condition.setPatientUuid(patientUuid); condition.setStatus(INACTIVE); condition.setAdditionalDetail(additionalDetail); when(patientService.getPatientByUuid(patientUuid)).thenReturn(patient); when(conceptService.getConceptByUuid(conceptUuid)).thenReturn(concept); when(conceptService.getConceptByUuid(endReasonUuid)).thenReturn(endReason); org.openmrs.module.emrapi.conditionslist.Condition openmrsCondition = conditionMapper.map(condition); assertEquals(uuid, openmrsCondition.getUuid()); assertEquals(conceptUuid, openmrsCondition.getConcept().getUuid()); assertEquals(patientUuid, openmrsCondition.getPatient().getUuid()); assertEquals(today, openmrsCondition.getOnsetDate()); assertEquals(additionalDetail, openmrsCondition.getAdditionalDetail()); assertEquals(today, openmrsCondition.getEndDate()); assertEquals(endReasonUuid, openmrsCondition.getEndReason().getUuid()); assertEquals(INACTIVE, openmrsCondition.getStatus()); }
@Test public void shouldUseDefaultLocaleWhenConceptNameNotInUseLocale() throws Exception{ String patientUuid = "13a1234-asdf23-ad2354-sas23"; Concept concept = new Concept(); String conceptUuid = "conceptUuid"; ConceptName conceptNameInUK = new ConceptName("Name in Uk", Locale.UK); concept.setUuid(conceptUuid); concept.setFullySpecifiedName(conceptNameInUK); org.openmrs.module.emrapi.conditionslist.Condition openmrsCondition = new org.openmrs.module.emrapi.conditionslist.Condition(); openmrsCondition.setConcept(concept); Patient patient = new Patient(); patient.setUuid(patientUuid); openmrsCondition.setPatient(patient); User creator = new User(); creator.setUsername("CREATOR"); openmrsCondition.setCreator(creator); when(Context.getLocale()).thenReturn(Locale.FRANCE); when(LocaleUtility.getDefaultLocale()).thenReturn(Locale.UK); Condition condition = conditionMapper.map(openmrsCondition); assertEquals(condition.getConcept().getName(),"Name in Uk"); } |
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); } | @Test public void shouldSavePatientProfile() throws Exception { PatientProfile patientProfile = emrPatientProfileService.save(constructPatientProfile()); assertNotNull(patientProfile); assertEquals(patientProfile.getRelationships().size(), 1); } |
ConditionHistoryMapper { public ConditionHistory map(org.openmrs.module.emrapi.conditionslist.ConditionHistory conditionHistory) { ConditionHistory conditionHistoryContract = new ConditionHistory(); conditionHistoryContract.setConceptUuid(conditionHistory.getCondition().getUuid()); ArrayList<Condition> conditions = new ArrayList<Condition>(); for (org.openmrs.module.emrapi.conditionslist.Condition condition : conditionHistory.getConditions()) { conditions.add(conditionMapper.map(condition)); } conditionHistoryContract.setConditions(conditions); conditionHistoryContract.setConditionNonCoded(conditionHistory.getNonCodedCondition()); return conditionHistoryContract; } ConditionHistoryMapper(ConditionMapper conditionMapper); ConditionHistory map(org.openmrs.module.emrapi.conditionslist.ConditionHistory conditionHistory); List<ConditionHistory> map(List<org.openmrs.module.emrapi.conditionslist.ConditionHistory> conditionHistories100); } | @Test public void shouldMapConditionHistoryModalToContract() throws Exception { org.openmrs.module.emrapi.conditionslist.ConditionHistory conditionHistory = new org.openmrs.module.emrapi.conditionslist.ConditionHistory(); org.openmrs.module.emrapi.conditionslist.Condition condition1 = getCondition("uuid_one"); org.openmrs.module.emrapi.conditionslist.Condition condition2 = getCondition("uuid_two"); org.openmrs.module.emrapi.conditionslist.Condition condition3 = getCondition("uuid_three"); conditionHistory.setConditions(Arrays.asList(condition1, condition2, condition3)); conditionHistory.setCondition(new Concept()); ConditionHistory conditionHistoryContract = conditionHistoryMapper.map(conditionHistory); assertEquals("uuid_one", conditionHistoryContract.getConditions().get(0).getUuid()); assertEquals("uuid_two", conditionHistoryContract.getConditions().get(1).getUuid()); assertEquals("uuid_three", conditionHistoryContract.getConditions().get(2).getUuid()); }
@Test public void shouldMapConditionHistoryModalsToListOfContracts() throws Exception { org.openmrs.module.emrapi.conditionslist.ConditionHistory conditionHistory1 = new org.openmrs.module.emrapi.conditionslist.ConditionHistory(); org.openmrs.module.emrapi.conditionslist.Condition condition1 = getCondition("uuid_one"); org.openmrs.module.emrapi.conditionslist.Condition condition2 = getCondition("uuid_two"); org.openmrs.module.emrapi.conditionslist.Condition condition3 = getCondition("uuid_three"); conditionHistory1.setConditions(Arrays.asList(condition1, condition2, condition3)); conditionHistory1.setCondition(new Concept()); org.openmrs.module.emrapi.conditionslist.ConditionHistory conditionHistory2 = new org.openmrs.module.emrapi.conditionslist.ConditionHistory(); org.openmrs.module.emrapi.conditionslist.Condition condition4 = getCondition("uuid_four"); org.openmrs.module.emrapi.conditionslist.Condition condition5 = getCondition("uuid_five"); org.openmrs.module.emrapi.conditionslist.Condition condition6 = getCondition("uuid_six"); conditionHistory2.setConditions(Arrays.asList(condition4, condition5, condition6)); conditionHistory2.setCondition(new Concept()); List<ConditionHistory> conditionHistoryContracts = conditionHistoryMapper.map(Arrays.asList(conditionHistory1, conditionHistory2)); List<Condition> conditions1 = conditionHistoryContracts.get(0).getConditions(); List<Condition> conditions2 = conditionHistoryContracts.get(1).getConditions(); assertEquals("uuid_one", conditions1.get(0).getUuid()); assertEquals("uuid_two", conditions1.get(1).getUuid()); assertEquals("uuid_three", conditions1.get(2).getUuid()); assertEquals("uuid_four", conditions2.get(0).getUuid()); assertEquals("uuid_five", conditions2.get(1).getUuid()); assertEquals("uuid_six", conditions2.get(2).getUuid()); } |
ConditionServiceImpl extends BaseOpenmrsService implements ConditionService { public List<ConditionHistory> getConditionHistory(Patient patient) { List<Condition> conditionList = conditionDAO.getConditionHistory(patient); Map<String, ConditionHistory> allConditions = new LinkedHashMap<String, ConditionHistory>(); for (Condition condition : conditionList) { Concept concept = condition.getConcept(); String nonCodedConceptUuid = administrationService.getGlobalProperty( ConditionListConstants.GLOBAL_PROPERTY_NON_CODED_UUID); String key = concept.getUuid().equals(nonCodedConceptUuid) ? condition.getConditionNonCoded() : concept.getUuid(); ConditionHistory conditionHistory = allConditions.get(key); if (conditionHistory != null) { conditionHistory.getConditions().add(condition); } else { conditionHistory = new ConditionHistory(); List<Condition> conditions = new ArrayList<Condition>(); conditions.add(condition); conditionHistory.setConditions(conditions); conditionHistory.setCondition(condition.getConcept()); if (concept.getUuid().equals(nonCodedConceptUuid)) { conditionHistory.setNonCodedCondition(condition.getConditionNonCoded()); } } allConditions.put(key, conditionHistory); } return new ArrayList<ConditionHistory>(allConditions.values()); } ConditionServiceImpl(ConditionDAO conditionDAO, ConceptService conceptService,
AdministrationService administrationService); @Override Condition save(Condition condition); List<ConditionHistory> getConditionHistory(Patient patient); @Override Condition voidCondition(Condition condition, String voidReason); @Override Condition getConditionByUuid(String uuid); @Override List<Condition> getActiveConditions(Patient patient); @Override @Transactional(readOnly = true) List<Concept> getEndReasonConcepts(); } | @Test public void shouldGetConditionHistoryReturnListOfConditionHistoryGroupedByConceptForPatient() { Patient patient = patientService.getPatient(3); List<ConditionHistory> conditionHistoryForPatient = conditionService.getConditionHistory(patient); assertEquals(conditionHistoryForPatient.size(), 4); assertThat(conditionHistoryForPatient, contains(new ConditionHistoryMatcher("severe", 1), new ConditionHistoryMatcher("pain", 1), new ConditionHistoryMatcher("Angina", 1), new ConditionHistoryMatcher("Tuberculosis", 1))); } |
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); } | @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); } |
PatientDomainWrapper implements DomainWrapper { public boolean isUnknownPatient() { boolean unknownPatient = false; PersonAttributeType unknownPatientAttributeType = emrApiProperties.getUnknownPatientPersonAttributeType(); if (patient != null) { PersonAttribute att = patient.getAttribute(unknownPatientAttributeType); if (att != null && "true".equals(att.getValue())) { unknownPatient = true; } } return unknownPatient; } PatientDomainWrapper(); @Deprecated // use the PatientDomainWrapperFactory component to instantiate a new PDW PatientDomainWrapper(Patient patient, EmrApiProperties emrApiProperties, AdtService adtService,
VisitService visitService, EncounterService encounterService, DiagnosisService diagnosisService, DomainWrapperFactory domainWrapperFactory); void setPatient(Patient patient); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setAdtService(AdtService adtService); void setVisitService(VisitService visitService); void setEncounterService(EncounterService encounterService); void setDiagnosisService(DiagnosisService diagnosisService); void setVisitQueryService(VisitQueryService visitQueryService); Patient getPatient(); Integer getId(); String getGender(); Integer getAge(); Integer getAgeInMonths(); Integer getAgeInDays(); Boolean getBirthdateEstimated(); Date getBirthdate(); String getTelephoneNumber(); PersonAddress getPersonAddress(); PatientIdentifier getPrimaryIdentifier(); List<PatientIdentifier> getPrimaryIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(); Encounter getLastEncounter(); VisitDomainWrapper getActiveVisit(Location location); int getCountOfEncounters(); int getCountOfVisits(); List<Encounter> getAllEncounters(); List<Visit> getVisitsByType(VisitType visitType); List<Visit> getAllVisits(); boolean hasOverlappingVisitsWith(Patient otherPatient); boolean isUnknownPatient(); List<VisitDomainWrapper> getVisitsByTypeUsingWrappers(VisitType visitType); List<VisitDomainWrapper> getAllVisitsUsingWrappers(); String getFormattedName(); PersonName getPersonName(); boolean isTestPatient(); List<Diagnosis> getDiagnosesSince(Date date); List<Diagnosis> getUniqueDiagnosesSince(Date date); } | @Test public void shouldVerifyIfPatientIsUnknown() { PersonAttributeType personAttributeType = new PersonAttributeType(); personAttributeType.setPersonAttributeTypeId(10); personAttributeType.setName(EmrApiConstants.UNKNOWN_PATIENT_PERSON_ATTRIBUTE_TYPE_NAME); personAttributeType.setFormat("java.lang.String"); PersonAttribute newAttribute = new PersonAttribute(personAttributeType, "true"); patient.addAttribute(newAttribute); when(emrApiProperties.getUnknownPatientPersonAttributeType()).thenReturn(personAttributeType); assertTrue(patientDomainWrapper.isUnknownPatient()); } |
PatientDomainWrapper implements DomainWrapper { public boolean isTestPatient() { boolean testPatient = false; PersonAttributeType testPatientPersonAttributeType = emrApiProperties.getTestPatientPersonAttributeType(); if (patient != null) { PersonAttribute att = patient.getAttribute(testPatientPersonAttributeType); if (att != null && "true".equals(att.getValue())) { testPatient = true; } } return testPatient; } PatientDomainWrapper(); @Deprecated // use the PatientDomainWrapperFactory component to instantiate a new PDW PatientDomainWrapper(Patient patient, EmrApiProperties emrApiProperties, AdtService adtService,
VisitService visitService, EncounterService encounterService, DiagnosisService diagnosisService, DomainWrapperFactory domainWrapperFactory); void setPatient(Patient patient); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setAdtService(AdtService adtService); void setVisitService(VisitService visitService); void setEncounterService(EncounterService encounterService); void setDiagnosisService(DiagnosisService diagnosisService); void setVisitQueryService(VisitQueryService visitQueryService); Patient getPatient(); Integer getId(); String getGender(); Integer getAge(); Integer getAgeInMonths(); Integer getAgeInDays(); Boolean getBirthdateEstimated(); Date getBirthdate(); String getTelephoneNumber(); PersonAddress getPersonAddress(); PatientIdentifier getPrimaryIdentifier(); List<PatientIdentifier> getPrimaryIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(); Encounter getLastEncounter(); VisitDomainWrapper getActiveVisit(Location location); int getCountOfEncounters(); int getCountOfVisits(); List<Encounter> getAllEncounters(); List<Visit> getVisitsByType(VisitType visitType); List<Visit> getAllVisits(); boolean hasOverlappingVisitsWith(Patient otherPatient); boolean isUnknownPatient(); List<VisitDomainWrapper> getVisitsByTypeUsingWrappers(VisitType visitType); List<VisitDomainWrapper> getAllVisitsUsingWrappers(); String getFormattedName(); PersonName getPersonName(); boolean isTestPatient(); List<Diagnosis> getDiagnosesSince(Date date); List<Diagnosis> getUniqueDiagnosesSince(Date date); } | @Test public void shouldVerifyIfPatientIsATest() { PersonAttributeType personAttributeType = new PersonAttributeType(); personAttributeType.setPersonAttributeTypeId(11); personAttributeType.setName("Test Patient"); personAttributeType.setFormat("java.lang.Boolean"); personAttributeType.setUuid(EmrApiConstants.TEST_PATIENT_ATTRIBUTE_UUID); PersonAttribute newAttribute = new PersonAttribute(personAttributeType, "true"); patient.addAttribute(newAttribute); when(emrApiProperties.getTestPatientPersonAttributeType()).thenReturn(personAttributeType); assertTrue(patientDomainWrapper.isTestPatient()); }
@Test public void shouldVerifyIfPatientIsNotATest() { PersonAttributeType personAttributeType = new PersonAttributeType(); personAttributeType.setPersonAttributeTypeId(11); personAttributeType.setName("Test Patient"); personAttributeType.setFormat("java.lang.Boolean"); personAttributeType.setUuid(EmrApiConstants.TEST_PATIENT_ATTRIBUTE_UUID); PersonAttribute newAttribute = new PersonAttribute(personAttributeType, "false"); patient.addAttribute(newAttribute); when(emrApiProperties.getTestPatientPersonAttributeType()).thenReturn(personAttributeType); assertFalse(patientDomainWrapper.isTestPatient()); } |
PatientDomainWrapper implements DomainWrapper { public List<VisitDomainWrapper> getAllVisitsUsingWrappers() { return getVisitsByTypeUsingWrappers(null); } PatientDomainWrapper(); @Deprecated // use the PatientDomainWrapperFactory component to instantiate a new PDW PatientDomainWrapper(Patient patient, EmrApiProperties emrApiProperties, AdtService adtService,
VisitService visitService, EncounterService encounterService, DiagnosisService diagnosisService, DomainWrapperFactory domainWrapperFactory); void setPatient(Patient patient); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setAdtService(AdtService adtService); void setVisitService(VisitService visitService); void setEncounterService(EncounterService encounterService); void setDiagnosisService(DiagnosisService diagnosisService); void setVisitQueryService(VisitQueryService visitQueryService); Patient getPatient(); Integer getId(); String getGender(); Integer getAge(); Integer getAgeInMonths(); Integer getAgeInDays(); Boolean getBirthdateEstimated(); Date getBirthdate(); String getTelephoneNumber(); PersonAddress getPersonAddress(); PatientIdentifier getPrimaryIdentifier(); List<PatientIdentifier> getPrimaryIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(); Encounter getLastEncounter(); VisitDomainWrapper getActiveVisit(Location location); int getCountOfEncounters(); int getCountOfVisits(); List<Encounter> getAllEncounters(); List<Visit> getVisitsByType(VisitType visitType); List<Visit> getAllVisits(); boolean hasOverlappingVisitsWith(Patient otherPatient); boolean isUnknownPatient(); List<VisitDomainWrapper> getVisitsByTypeUsingWrappers(VisitType visitType); List<VisitDomainWrapper> getAllVisitsUsingWrappers(); String getFormattedName(); PersonName getPersonName(); boolean isTestPatient(); List<Diagnosis> getDiagnosesSince(Date date); List<Diagnosis> getUniqueDiagnosesSince(Date date); } | @Test public void shouldCreateAListOfVisitDomainWrappersBasedOnVisitListFromVisitService() { when(visitService.getVisitsByPatient(patient, true, false)).thenReturn(asList(new Visit(), new Visit(), new Visit())); when(domainWrapperFactory.newVisitDomainWrapper(any(Visit.class))).thenReturn(new VisitDomainWrapper()); List<VisitDomainWrapper> visitDomainWrappers = patientDomainWrapper.getAllVisitsUsingWrappers(); assertThat(visitDomainWrappers.size(), is(3)); } |
PatientDomainWrapper implements DomainWrapper { public String getFormattedName() { return getPersonName().getFamilyName() + ", " + getPersonName().getGivenName(); } PatientDomainWrapper(); @Deprecated // use the PatientDomainWrapperFactory component to instantiate a new PDW PatientDomainWrapper(Patient patient, EmrApiProperties emrApiProperties, AdtService adtService,
VisitService visitService, EncounterService encounterService, DiagnosisService diagnosisService, DomainWrapperFactory domainWrapperFactory); void setPatient(Patient patient); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setAdtService(AdtService adtService); void setVisitService(VisitService visitService); void setEncounterService(EncounterService encounterService); void setDiagnosisService(DiagnosisService diagnosisService); void setVisitQueryService(VisitQueryService visitQueryService); Patient getPatient(); Integer getId(); String getGender(); Integer getAge(); Integer getAgeInMonths(); Integer getAgeInDays(); Boolean getBirthdateEstimated(); Date getBirthdate(); String getTelephoneNumber(); PersonAddress getPersonAddress(); PatientIdentifier getPrimaryIdentifier(); List<PatientIdentifier> getPrimaryIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(); Encounter getLastEncounter(); VisitDomainWrapper getActiveVisit(Location location); int getCountOfEncounters(); int getCountOfVisits(); List<Encounter> getAllEncounters(); List<Visit> getVisitsByType(VisitType visitType); List<Visit> getAllVisits(); boolean hasOverlappingVisitsWith(Patient otherPatient); boolean isUnknownPatient(); List<VisitDomainWrapper> getVisitsByTypeUsingWrappers(VisitType visitType); List<VisitDomainWrapper> getAllVisitsUsingWrappers(); String getFormattedName(); PersonName getPersonName(); boolean isTestPatient(); List<Diagnosis> getDiagnosesSince(Date date); List<Diagnosis> getUniqueDiagnosesSince(Date date); } | @Test public void shouldReturnFormattedName() { patient = mock(Patient.class); patientDomainWrapper = new PatientDomainWrapper(patient, emrApiProperties, mock(AdtService.class), visitService, mock(EncounterService.class), mock(DiagnosisService.class), mock(DomainWrapperFactory.class)); Set<PersonName> personNames = new HashSet<PersonName>(); PersonName personNamePreferred = createPreferredPersonName("John", "Dover"); personNames.add(personNamePreferred); when(patient.getNames()).thenReturn(personNames); String formattedName = patientDomainWrapper.getFormattedName(); assertThat(formattedName, is("Dover, John")); } |
PatientDomainWrapper implements DomainWrapper { public PersonName getPersonName() { Set<PersonName> names = patient.getNames(); if (names != null && names.size() > 0) { for (PersonName name : names) { if (name.isPreferred()) return name; } for (PersonName name : names) { return name; } } return null; } PatientDomainWrapper(); @Deprecated // use the PatientDomainWrapperFactory component to instantiate a new PDW PatientDomainWrapper(Patient patient, EmrApiProperties emrApiProperties, AdtService adtService,
VisitService visitService, EncounterService encounterService, DiagnosisService diagnosisService, DomainWrapperFactory domainWrapperFactory); void setPatient(Patient patient); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setAdtService(AdtService adtService); void setVisitService(VisitService visitService); void setEncounterService(EncounterService encounterService); void setDiagnosisService(DiagnosisService diagnosisService); void setVisitQueryService(VisitQueryService visitQueryService); Patient getPatient(); Integer getId(); String getGender(); Integer getAge(); Integer getAgeInMonths(); Integer getAgeInDays(); Boolean getBirthdateEstimated(); Date getBirthdate(); String getTelephoneNumber(); PersonAddress getPersonAddress(); PatientIdentifier getPrimaryIdentifier(); List<PatientIdentifier> getPrimaryIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(); Encounter getLastEncounter(); VisitDomainWrapper getActiveVisit(Location location); int getCountOfEncounters(); int getCountOfVisits(); List<Encounter> getAllEncounters(); List<Visit> getVisitsByType(VisitType visitType); List<Visit> getAllVisits(); boolean hasOverlappingVisitsWith(Patient otherPatient); boolean isUnknownPatient(); List<VisitDomainWrapper> getVisitsByTypeUsingWrappers(VisitType visitType); List<VisitDomainWrapper> getAllVisitsUsingWrappers(); String getFormattedName(); PersonName getPersonName(); boolean isTestPatient(); List<Diagnosis> getDiagnosesSince(Date date); List<Diagnosis> getUniqueDiagnosesSince(Date date); } | @Test public void shouldReturnPersonNameWhenThereAreTwoNamesAndOneOfThemIsPreferred() { patient = mock(Patient.class); patientDomainWrapper = new PatientDomainWrapper(patient, emrApiProperties, mock(AdtService.class), visitService, mock(EncounterService.class), mock(DiagnosisService.class), mock(DomainWrapperFactory.class)); Set<PersonName> personNames = new HashSet<PersonName>(); PersonName personNamePreferred = createPreferredPersonName("mario", "neissi"); personNames.add(personNamePreferred); PersonName personNameNonPreferred = createNonPreferredPersonName("Ana", "emerson"); personNames.add(personNameNonPreferred); when(patient.getNames()).thenReturn(personNames); PersonName returnedName = patientDomainWrapper.getPersonName(); assertSame(personNamePreferred, returnedName); }
@Test public void shouldReturnPersonNameWhenThereAreTwoNamesAndNoneOfThemIsPreferred() { patient = mock(Patient.class); patientDomainWrapper = new PatientDomainWrapper(patient, emrApiProperties, mock(AdtService.class), visitService, mock(EncounterService.class), mock(DiagnosisService.class), mock(DomainWrapperFactory.class)); Set<PersonName> personNames = new HashSet<PersonName>(); PersonName personNamePreferred = createNonPreferredPersonName("mario", "neissi"); personNames.add(personNamePreferred); PersonName personNameNonPreferred = createNonPreferredPersonName("Ana", "emerson"); personNames.add(personNameNonPreferred); when(patient.getNames()).thenReturn(personNames); PersonName returnedName = patientDomainWrapper.getPersonName(); assertNotNull(returnedName); } |
PatientDomainWrapper implements DomainWrapper { public Integer getAgeInMonths() { if (patient.getBirthdate() == null) { return null; } Date endDate = patient.isDead() ? patient.getDeathDate() : new Date(); return Months.monthsBetween(new DateTime(patient.getBirthdate()), new DateTime(endDate)).getMonths(); } PatientDomainWrapper(); @Deprecated // use the PatientDomainWrapperFactory component to instantiate a new PDW PatientDomainWrapper(Patient patient, EmrApiProperties emrApiProperties, AdtService adtService,
VisitService visitService, EncounterService encounterService, DiagnosisService diagnosisService, DomainWrapperFactory domainWrapperFactory); void setPatient(Patient patient); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setAdtService(AdtService adtService); void setVisitService(VisitService visitService); void setEncounterService(EncounterService encounterService); void setDiagnosisService(DiagnosisService diagnosisService); void setVisitQueryService(VisitQueryService visitQueryService); Patient getPatient(); Integer getId(); String getGender(); Integer getAge(); Integer getAgeInMonths(); Integer getAgeInDays(); Boolean getBirthdateEstimated(); Date getBirthdate(); String getTelephoneNumber(); PersonAddress getPersonAddress(); PatientIdentifier getPrimaryIdentifier(); List<PatientIdentifier> getPrimaryIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(); Encounter getLastEncounter(); VisitDomainWrapper getActiveVisit(Location location); int getCountOfEncounters(); int getCountOfVisits(); List<Encounter> getAllEncounters(); List<Visit> getVisitsByType(VisitType visitType); List<Visit> getAllVisits(); boolean hasOverlappingVisitsWith(Patient otherPatient); boolean isUnknownPatient(); List<VisitDomainWrapper> getVisitsByTypeUsingWrappers(VisitType visitType); List<VisitDomainWrapper> getAllVisitsUsingWrappers(); String getFormattedName(); PersonName getPersonName(); boolean isTestPatient(); List<Diagnosis> getDiagnosesSince(Date date); List<Diagnosis> getUniqueDiagnosesSince(Date date); } | @Test public void shouldCalculateCorrectAgeInMonthsForDeceasedPatient() { patient.setDead(true); Calendar cal = Calendar.getInstance(); cal.set(2012, 11, 4); patient.setBirthdate(cal.getTime()); cal.set(2013, 2, 1); patient.setDeathDate(cal.getTime()); assertThat(patientDomainWrapper.getAgeInMonths(), is(2)); } |
PatientDomainWrapper implements DomainWrapper { public Integer getAgeInDays() { if (patient.getBirthdate() == null) { return null; } Date endDate = patient.isDead() ? patient.getDeathDate() : new Date(); return Days.daysBetween(new DateTime(patient.getBirthdate()), new DateTime(endDate)).getDays(); } PatientDomainWrapper(); @Deprecated // use the PatientDomainWrapperFactory component to instantiate a new PDW PatientDomainWrapper(Patient patient, EmrApiProperties emrApiProperties, AdtService adtService,
VisitService visitService, EncounterService encounterService, DiagnosisService diagnosisService, DomainWrapperFactory domainWrapperFactory); void setPatient(Patient patient); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setAdtService(AdtService adtService); void setVisitService(VisitService visitService); void setEncounterService(EncounterService encounterService); void setDiagnosisService(DiagnosisService diagnosisService); void setVisitQueryService(VisitQueryService visitQueryService); Patient getPatient(); Integer getId(); String getGender(); Integer getAge(); Integer getAgeInMonths(); Integer getAgeInDays(); Boolean getBirthdateEstimated(); Date getBirthdate(); String getTelephoneNumber(); PersonAddress getPersonAddress(); PatientIdentifier getPrimaryIdentifier(); List<PatientIdentifier> getPrimaryIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(); Encounter getLastEncounter(); VisitDomainWrapper getActiveVisit(Location location); int getCountOfEncounters(); int getCountOfVisits(); List<Encounter> getAllEncounters(); List<Visit> getVisitsByType(VisitType visitType); List<Visit> getAllVisits(); boolean hasOverlappingVisitsWith(Patient otherPatient); boolean isUnknownPatient(); List<VisitDomainWrapper> getVisitsByTypeUsingWrappers(VisitType visitType); List<VisitDomainWrapper> getAllVisitsUsingWrappers(); String getFormattedName(); PersonName getPersonName(); boolean isTestPatient(); List<Diagnosis> getDiagnosesSince(Date date); List<Diagnosis> getUniqueDiagnosesSince(Date date); } | @Test public void shouldCalculateCorrectAgeInDaysForDeceasedPatient() { patient.setDead(true); Calendar cal = Calendar.getInstance(); cal.set(2013, 1, 26); patient.setBirthdate(cal.getTime()); cal.set(2013, 2, 1); patient.setDeathDate(cal.getTime()); assertThat(patientDomainWrapper.getAgeInDays(), is(3)); } |
PatientDomainWrapper implements DomainWrapper { public List<PatientIdentifier> getExtraIdentifiers() { return getExtraIdentifiers(null); } PatientDomainWrapper(); @Deprecated // use the PatientDomainWrapperFactory component to instantiate a new PDW PatientDomainWrapper(Patient patient, EmrApiProperties emrApiProperties, AdtService adtService,
VisitService visitService, EncounterService encounterService, DiagnosisService diagnosisService, DomainWrapperFactory domainWrapperFactory); void setPatient(Patient patient); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setAdtService(AdtService adtService); void setVisitService(VisitService visitService); void setEncounterService(EncounterService encounterService); void setDiagnosisService(DiagnosisService diagnosisService); void setVisitQueryService(VisitQueryService visitQueryService); Patient getPatient(); Integer getId(); String getGender(); Integer getAge(); Integer getAgeInMonths(); Integer getAgeInDays(); Boolean getBirthdateEstimated(); Date getBirthdate(); String getTelephoneNumber(); PersonAddress getPersonAddress(); PatientIdentifier getPrimaryIdentifier(); List<PatientIdentifier> getPrimaryIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(); Encounter getLastEncounter(); VisitDomainWrapper getActiveVisit(Location location); int getCountOfEncounters(); int getCountOfVisits(); List<Encounter> getAllEncounters(); List<Visit> getVisitsByType(VisitType visitType); List<Visit> getAllVisits(); boolean hasOverlappingVisitsWith(Patient otherPatient); boolean isUnknownPatient(); List<VisitDomainWrapper> getVisitsByTypeUsingWrappers(VisitType visitType); List<VisitDomainWrapper> getAllVisitsUsingWrappers(); String getFormattedName(); PersonName getPersonName(); boolean isTestPatient(); List<Diagnosis> getDiagnosesSince(Date date); List<Diagnosis> getUniqueDiagnosesSince(Date date); } | @Test public void shouldReturnExtraPatientIdentifiers() { PatientIdentifierType pit1 = new PatientIdentifierType(); PatientIdentifierType pit2 = new PatientIdentifierType(); PatientIdentifierType pit3 = new PatientIdentifierType(); PatientIdentifier identifier1 = new PatientIdentifier(); identifier1.setIdentifierType(pit1); PatientIdentifier identifier2 = new PatientIdentifier(); identifier2.setIdentifierType(pit2); PatientIdentifier identifier3 = new PatientIdentifier(); identifier3.setIdentifierType(pit3); patient.addIdentifier(identifier1); patient.addIdentifier(identifier2); patient.addIdentifier(identifier3); when(emrApiProperties.getExtraPatientIdentifierTypes()).thenReturn(Arrays.asList(pit1, pit2)); List<PatientIdentifier> identifiers = patientDomainWrapper.getExtraIdentifiers(); assertThat(identifiers.size(), is(2)); assertThat(identifiers, hasItems(identifier1, identifier2)); }
@Test public void shouldReturnExtraPatientIdentifiersRestrictedByLocation() { Location parentLocation = new Location(); Location childLocation1 = new Location(); Location childLocation2 = new Location(); parentLocation.addChildLocation(childLocation1); parentLocation.addChildLocation(childLocation2); PatientIdentifierType pit = new PatientIdentifierType(); pit.setLocationBehavior(PatientIdentifierType.LocationBehavior.REQUIRED); PatientIdentifier identifier1 = new PatientIdentifier(); identifier1.setIdentifierType(pit); identifier1.setLocation(parentLocation); PatientIdentifier identifier2 = new PatientIdentifier(); identifier2.setIdentifierType(pit); identifier2.setLocation(childLocation1); PatientIdentifier identifier3 = new PatientIdentifier(); identifier3.setIdentifierType(pit); identifier3.setLocation(childLocation2); patient.addIdentifier(identifier1); patient.addIdentifier(identifier2); patient.addIdentifier(identifier3); when(emrApiProperties.getExtraPatientIdentifierTypes()).thenReturn(Collections.singletonList(pit)); List<PatientIdentifier> identifiers = patientDomainWrapper.getExtraIdentifiers(childLocation2); assertThat(identifiers.size(), is(2)); assertThat(identifiers, hasItems(identifier1, identifier3)); }
@Test public void shouldReturnExtraPatientIdentifiersShouldNotRestrictLocationsForTypesWhereLocationIsNotRequired() { Location parentLocation = new Location(); Location childLocation1 = new Location(); Location childLocation2 = new Location(); parentLocation.addChildLocation(childLocation1); parentLocation.addChildLocation(childLocation2); PatientIdentifierType pit = new PatientIdentifierType(); PatientIdentifier identifier1 = new PatientIdentifier(); identifier1.setIdentifierType(pit); identifier1.setLocation(parentLocation); PatientIdentifier identifier2 = new PatientIdentifier(); identifier2.setIdentifierType(pit); identifier2.setLocation(childLocation1); PatientIdentifier identifier3 = new PatientIdentifier(); identifier3.setIdentifierType(pit); identifier3.setLocation(childLocation2); patient.addIdentifier(identifier1); patient.addIdentifier(identifier2); patient.addIdentifier(identifier3); when(emrApiProperties.getExtraPatientIdentifierTypes()).thenReturn(Collections.singletonList(pit)); List<PatientIdentifier> identifiers = patientDomainWrapper.getExtraIdentifiers(childLocation2); assertThat(identifiers.size(), is(3)); assertThat(identifiers, hasItems(identifier1, identifier2, identifier3)); } |
PatientDomainWrapper implements DomainWrapper { public Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(Location location) { Map<PatientIdentifierType, List<PatientIdentifier>> identifierMap = new HashMap<PatientIdentifierType, List<PatientIdentifier>>(); List<PatientIdentifier> patientIdentifiers = getExtraIdentifiers(location); if (patientIdentifiers != null) { for (PatientIdentifier patientIdentifier : patientIdentifiers) { if (!identifierMap.containsKey(patientIdentifier.getIdentifierType())) { identifierMap.put(patientIdentifier.getIdentifierType(), new ArrayList<PatientIdentifier>()); } identifierMap.get(patientIdentifier.getIdentifierType()).add(patientIdentifier); } } return identifierMap; } PatientDomainWrapper(); @Deprecated // use the PatientDomainWrapperFactory component to instantiate a new PDW PatientDomainWrapper(Patient patient, EmrApiProperties emrApiProperties, AdtService adtService,
VisitService visitService, EncounterService encounterService, DiagnosisService diagnosisService, DomainWrapperFactory domainWrapperFactory); void setPatient(Patient patient); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setAdtService(AdtService adtService); void setVisitService(VisitService visitService); void setEncounterService(EncounterService encounterService); void setDiagnosisService(DiagnosisService diagnosisService); void setVisitQueryService(VisitQueryService visitQueryService); Patient getPatient(); Integer getId(); String getGender(); Integer getAge(); Integer getAgeInMonths(); Integer getAgeInDays(); Boolean getBirthdateEstimated(); Date getBirthdate(); String getTelephoneNumber(); PersonAddress getPersonAddress(); PatientIdentifier getPrimaryIdentifier(); List<PatientIdentifier> getPrimaryIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(); Encounter getLastEncounter(); VisitDomainWrapper getActiveVisit(Location location); int getCountOfEncounters(); int getCountOfVisits(); List<Encounter> getAllEncounters(); List<Visit> getVisitsByType(VisitType visitType); List<Visit> getAllVisits(); boolean hasOverlappingVisitsWith(Patient otherPatient); boolean isUnknownPatient(); List<VisitDomainWrapper> getVisitsByTypeUsingWrappers(VisitType visitType); List<VisitDomainWrapper> getAllVisitsUsingWrappers(); String getFormattedName(); PersonName getPersonName(); boolean isTestPatient(); List<Diagnosis> getDiagnosesSince(Date date); List<Diagnosis> getUniqueDiagnosesSince(Date date); } | @Test public void shouldReturnExtraPatientIdentifiersMappedByType() { PatientIdentifierType pit1 = new PatientIdentifierType(); PatientIdentifierType pit2 = new PatientIdentifierType(); PatientIdentifierType pit3 = new PatientIdentifierType(); PatientIdentifier identifier1 = new PatientIdentifier(); identifier1.setId(1); identifier1.setIdentifier("1"); identifier1.setIdentifierType(pit1); PatientIdentifier identifier2 = new PatientIdentifier(); identifier2.setId(2); identifier2.setIdentifier("2"); identifier2.setIdentifierType(pit2); PatientIdentifier identifier3 = new PatientIdentifier(); identifier3.setId(3); identifier3.setIdentifier("3"); identifier3.setIdentifierType(pit2); PatientIdentifier identifier4 = new PatientIdentifier(); identifier4.setId(4); identifier4.setIdentifier("4"); identifier4.setIdentifierType(pit3); patient.addIdentifier(identifier1); patient.addIdentifier(identifier2); patient.addIdentifier(identifier3); patient.addIdentifier(identifier4); when(emrApiProperties.getExtraPatientIdentifierTypes()).thenReturn(Arrays.asList(pit1, pit2)); Map<PatientIdentifierType, List<PatientIdentifier>> identifierMap = patientDomainWrapper.getExtraIdentifiersMappedByType(); assertThat(identifierMap.keySet().size(), is(2)); assertTrue(identifierMap.containsKey(pit1)); assertTrue(identifierMap.containsKey(pit2)); assertThat(identifierMap.get(pit1).size(), is(1)); assertThat(identifierMap.get(pit1), hasItem(identifier1)); assertThat(identifierMap.get(pit2).size(), is(2)); assertThat(identifierMap.get(pit2), hasItems(identifier2, identifier3)); } |
AccountDomainWrapper implements DomainWrapper { public Boolean getUserEnabled() { if (user == null) { return null; } else { return !user.isRetired(); } } AccountDomainWrapper(); @Deprecated // use DomainWrapperFactory instead AccountDomainWrapper(Person person, AccountService accountService, UserService userService, ProviderService providerService,
ProviderManagementService providerManagementService, PersonService personService,
ProviderIdentifierGenerator providerIdentifierGenerator); void setAccountService(AccountService accountService); void setUserService(UserService userService); void setProviderService(ProviderService providerService); void setPersonService(PersonService personService); void setProviderManagementService(ProviderManagementService providerManagementService); void setProviderIdentifierGenerator(ProviderIdentifierGenerator providerIdentifierGenerator); void initializeWithPerson(Person person); Person getPerson(); User getUser(); Provider getProvider(); void setProviderRole(ProviderRole providerRole); ProviderRole getProviderRole(); void setGivenName(String givenName); String getGivenName(); void setFamilyName(String familyName); String getFamilyName(); void setGender(String gender); String getGender(); void setUsername(String username); String getUsername(); String getPassword(); void setPassword(String password); String getConfirmPassword(); void setConfirmPassword(String confirmPassword); void setDefaultLocale(Locale locale); Locale getDefaultLocale(); void setPrivilegeLevel(Role privilegeLevel); Role getPrivilegeLevel(); void setCapabilities(Set<Role> capabilities); Set<Role> getCapabilities(); void setUserEnabled(Boolean userEnabled); Boolean getUserEnabled(); boolean isLocked(); void unlock(); void save(); } | @Test public void shouldReturnFalseIfUserRetired() { Person person = new Person(); person.setId(1); User user = new User(); user.setPerson(person); user.setRetired(true); when(userService.getUsersByPerson(eq(person), eq(false))).thenReturn(Collections.singletonList(user)); AccountDomainWrapper account = initializeNewAccountDomainWrapper(person); Assert.assertFalse(account.getUserEnabled()); }
@Test public void shouldReturnTrueIfUserNotRetired() { Person person = new Person(); person.setId(1); User user = new User(); user.setPerson(person); user.setRetired(false); when(userService.getUsersByPerson(eq(person), eq(false))).thenReturn(Collections.singletonList(user)); AccountDomainWrapper account = initializeNewAccountDomainWrapper(person); Assert.assertTrue(account.getUserEnabled()); }
@Test public void shouldReturnNullIfNoUser() { Person person = new Person(); AccountDomainWrapper account = initializeNewAccountDomainWrapper(person); Assert.assertNull(account.getUserEnabled()); } |
AccountDomainWrapper implements DomainWrapper { public void save() { if (person != null) { personService.savePerson(person); } if (user != null) { boolean existingUser = (user.getUserId() != null); if (!existingUser) { userService.createUser(user, password); } else { try { Method saveUser = UserService.class.getDeclaredMethod("saveUser", User.class); saveUser.invoke(userService, user); } catch (Exception e) { userService.createUser(user, password); } } if (existingUser && StringUtils.isNotBlank(password) && StringUtils.isNotBlank(confirmPassword)) { userService.changePassword(user, password); } } if (provider != null) { providerService.saveProvider(provider); if (providerIdentifierGenerator != null && StringUtils.isBlank(provider.getIdentifier())) { provider.setIdentifier(providerIdentifierGenerator.generateIdentifier(provider)); providerService.saveProvider(provider); } } } AccountDomainWrapper(); @Deprecated // use DomainWrapperFactory instead AccountDomainWrapper(Person person, AccountService accountService, UserService userService, ProviderService providerService,
ProviderManagementService providerManagementService, PersonService personService,
ProviderIdentifierGenerator providerIdentifierGenerator); void setAccountService(AccountService accountService); void setUserService(UserService userService); void setProviderService(ProviderService providerService); void setPersonService(PersonService personService); void setProviderManagementService(ProviderManagementService providerManagementService); void setProviderIdentifierGenerator(ProviderIdentifierGenerator providerIdentifierGenerator); void initializeWithPerson(Person person); Person getPerson(); User getUser(); Provider getProvider(); void setProviderRole(ProviderRole providerRole); ProviderRole getProviderRole(); void setGivenName(String givenName); String getGivenName(); void setFamilyName(String familyName); String getFamilyName(); void setGender(String gender); String getGender(); void setUsername(String username); String getUsername(); String getPassword(); void setPassword(String password); String getConfirmPassword(); void setConfirmPassword(String confirmPassword); void setDefaultLocale(Locale locale); Locale getDefaultLocale(); void setPrivilegeLevel(Role privilegeLevel); Role getPrivilegeLevel(); void setCapabilities(Set<Role> capabilities); Set<Role> getCapabilities(); void setUserEnabled(Boolean userEnabled); Boolean getUserEnabled(); boolean isLocked(); void unlock(); void save(); } | @Test public void testSaveAccountWithOnlyPerson() throws Exception { Person person = new Person(); AccountDomainWrapper account = initializeNewAccountDomainWrapper(person); account.save(); verify(personService).savePerson(person); verify(userService, never()).createUser(any(User.class), anyString()); } |
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); } | @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)); } |
AccountValidator implements Validator { @Override public void validate(Object obj, Errors errors) { if (obj == null || !(obj instanceof AccountDomainWrapper)) throw new IllegalArgumentException("The parameter obj should not be null and must be of type" + AccountDomainWrapper.class); AccountDomainWrapper account = (AccountDomainWrapper) obj; User user = account.getUser(); checkIfGivenAndFamilyNameAreNotNull(errors, account); checkIfGenderIsNull(errors, account); checkIfProviderRoleIsNull(errors, account); if (account.getUser() != null) { checkIfUserNameIsCorrect(errors, account.getUsername()); checkIfDuplicateUsername(errors, account.getUser()); checkIfPrivilegeLevelIsCorrect(errors, account); checkIfNoCapabilities(errors, account); } if (checkIfUserWasCreated(user) || StringUtils.isNotBlank(account.getPassword()) || StringUtils.isNotBlank(account.getConfirmPassword())) { checkIfPasswordIsCorrect(errors, account); } } void setMessageSourceService(MessageSourceService messageSourceService); void setUserService(UserService userService); void setProviderManagementService(ProviderManagementService providerManagementService); @Override boolean supports(Class<?> clazz); @Override void validate(Object obj, Errors errors); static final String USERNAME_MIN_LENGTH; static final String USERNAME_MAX_LENGTH; } | @Test public void validate_shouldRejectAnEmptyGivenname() throws Exception { Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertTrue(errors.hasFieldErrors("givenName")); }
@Test public void validate_shouldRejectAnEmptyFamilyname() throws Exception { account.setGivenName("give name"); Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertTrue(errors.hasFieldErrors("familyName")); }
@Test public void validate_shouldRejectAnEmptyGender() throws Exception { account.setGivenName("givenName"); account.setFamilyName("familyName"); Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertTrue(errors.hasFieldErrors("gender")); }
@Test public void validate_shouldRejectAnEmptyPrivilegeLevelIfUserIsNotNull() throws Exception { account.setGivenName("give name"); account.setFamilyName("family name"); account.setGender("M"); account.setUsername("username"); Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertTrue(errors.hasFieldErrors("privilegeLevel")); }
@Test public void validate_shouldRejectAnEmptyPrivilegeLevelIfUserIsPersisted() throws Exception { account.setGivenName("give name"); account.setFamilyName("family name"); account.setGender("M"); account.setUsername("username"); account.getUser().setUserId(1); Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertTrue(errors.hasFieldErrors("privilegeLevel")); }
@Test public void validate_shouldRejectAnEmptyUsernameIfUserIsNotNull() throws Exception { account.setGivenName("give name"); account.setFamilyName("family name"); account.setGender("M"); account.setPrivilegeLevel(fullPrivileges); Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertTrue(errors.hasFieldErrors("username")); }
@Test public void validate_shouldRejectPasswordAndConfirmPasswordIfTheyDontMatch() throws Exception { account.setGivenName("give name"); account.setFamilyName("family name"); account.setGender("M"); account.setUsername("username"); account.setPassword("password"); account.setConfirmPassword("confirm password"); Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertTrue(errors.hasFieldErrors("password")); }
@Test public void shouldCreateErrorWhenConfirmPasswordIsNotProvided() throws Exception { account.setGivenName("give name"); account.setFamilyName("family name"); account.setGender("M"); account.setUsername("username"); account.setPassword("password"); Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertTrue(errors.hasFieldErrors("password")); assertTrue(errors.hasFieldErrors("confirmPassword")); }
@Test public void shouldCreateErrorWhenPasswordIsNotProvided() throws Exception { account.setGivenName("give name"); account.setFamilyName("family name"); account.setGender("M"); account.setUsername("username"); account.setConfirmPassword("password"); Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertTrue(errors.hasFieldErrors("password")); assertTrue(errors.hasFieldErrors("confirmPassword")); }
@Test public void validate_shouldFailIfNoProviderRoleSpecified() throws Exception { account.setUsername("username"); account.setGivenName("give name"); account.setFamilyName("family name"); account.setGender("M"); account.setPassword("Password123"); account.setConfirmPassword("Password123"); account.setPrivilegeLevel(fullPrivileges); account.setCapabilities(someCapabilitySet); Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertTrue(errors.hasFieldErrors("providerRole")); }
@Test public void validate_shouldPassForAValidAccount() throws Exception { account.setUsername("username"); account.setGivenName("give name"); account.setFamilyName("family name"); account.setGender("M"); account.setPassword("Password123"); account.setConfirmPassword("Password123"); account.setPrivilegeLevel(fullPrivileges); account.setCapabilities(someCapabilitySet); account.setProviderRole(someProviderRole); Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertFalse(errors.hasErrors()); }
@Test public void validate_shouldRequirePasswordsForNewAUserAccount() throws Exception { account.setUsername("username"); account.setGivenName("give name"); account.setFamilyName("family name"); account.setGender("M"); account.setUsername("username"); account.setPrivilegeLevel(fullPrivileges); Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertTrue(errors.hasFieldErrors("password")); assertTrue(errors.hasFieldErrors("confirmPassword")); }
@Test public void validate_shouldNotRequirePasswordsForExistingUserAccount() throws Exception { account.setUsername("username"); account.setGivenName("give name"); account.setFamilyName("family name"); account.setGender("M"); account.setUsername("username"); account.setPrivilegeLevel(fullPrivileges); account.getUser().setUserId(1); Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertFalse(errors.hasFieldErrors("password")); assertFalse(errors.hasFieldErrors("confirmPassword")); }
@Test public void shouldCreateAnErrorMessageWhenUsernameHasOnlyOneCharacter() { mockStatic(OpenmrsUtil.class); createAccountWithUsernameAs("a"); Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertTrue(errors.hasErrors()); List<FieldError> errorList = errors.getFieldErrors("username"); assertThat(errorList.size(), is(1)); }
@Test public void shouldCreateAnErrorMessageWhenUsernameHasMoreThanFiftyCharacters() { mockStatic(OpenmrsUtil.class); createAccountWithUsernameAs("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertTrue(errors.hasErrors()); List<FieldError> errorList = errors.getFieldErrors("username"); assertThat(errorList.size(), is(1)); }
@Test public void shouldCreateAnErrorMessageWhenUserNameCharactersAreNotValid() { mockStatic(OpenmrsUtil.class); createAccountWithUsernameAs("usern@me"); Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertTrue(errors.hasErrors()); List<FieldError> errorList = errors.getFieldErrors("username"); assertThat(errorList.size(), is(1)); }
@Test public void shouldValidateIfUserNameCharactersAreValid() { mockStatic(OpenmrsUtil.class); createAccountWithUsernameAs("usern.-_1"); Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertFalse(errors.hasErrors()); }
@Test public void shouldCreateAnErrorMessageWhenUserIsNullAndNoProviderRole() { mockStatic(OpenmrsUtil.class); account.setFamilyName("family name"); account.setGivenName("given Name"); Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertTrue(errors.hasErrors()); }
@Test public void shouldCreateErrorMessageIfUserWithNoCapabilities() { mockStatic(OpenmrsUtil.class); createAccountWithUsernameAs("username"); account.setCapabilities(new HashSet<Role>()); Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertTrue(errors.hasErrors()); List<FieldError> errorList = errors.getFieldErrors("capabilities"); assertThat(errorList.size(), is(1)); }
@Test public void shouldCreateErrorMessageIfDuplicateUsername() { mockStatic(OpenmrsUtil.class); createAccountWithUsernameAs("username"); when(userService.hasDuplicateUsername(account.getUser())).thenReturn(true); Errors errors = new BindException(account, "account"); validator.validate(account, errors); assertTrue(errors.hasErrors()); List<FieldError> errorList = errors.getFieldErrors("username"); assertThat(errorList.size(), is(1)); } |
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); } | @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)); } |
DispositionDescriptor extends ConceptSetDescriptor { public Obs buildObsGroup(Disposition disposition, EmrConceptService emrConceptService) { Obs dispoObs = new Obs(); dispoObs.setConcept(dispositionConcept); dispoObs.setValueCoded(emrConceptService.getConcept(disposition.getConceptCode())); Obs group = new Obs(); group.setConcept(dispositionSetConcept); group.addGroupMember(dispoObs); return group; } 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); } | @Test public void shouldBuildDispositionObsGroup() { Disposition admissionDisposition = new Disposition(); admissionDisposition.setConceptCode("ADMISSION"); Obs dispositionObsGroup = dispositionDescriptor.buildObsGroup(admissionDisposition, emrConceptService); assertThat(dispositionObsGroup.getConcept(), is(dispositionSetConcept)); assertTrue(dispositionObsGroup.hasGroupMembers()); assertThat(dispositionObsGroup.getGroupMembers().size(), is(1)); Obs dispositionObs = dispositionObsGroup.getGroupMembers().iterator().next(); assertThat(dispositionObs.getConcept(), is(dispositionConcept)); assertThat(dispositionObs.getValueCoded(), is(admissionConcept)); } |
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); } | @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)); } |
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); } | @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)); } |
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); } | @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)); } |
DispositionDescriptor extends ConceptSetDescriptor { public Location getAdmissionLocation(Obs obsGroup, LocationService locationService) { Obs admissionLocationObs = getAdmissionLocationObs(obsGroup); if (admissionLocationObs != null) { return locationService.getLocation(Integer.valueOf(admissionLocationObs.getValueText())); } else { return null; } } 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); } | @Test public void shouldFetchAdmissionLocationOffObsGroup() { Obs dispositionObsGroup = createDispositionObsGroup(); Obs admissionLocationObs = new Obs(); admissionLocationObs.setConcept(admissionLocationConcept); admissionLocationObs.setValueText(admissionLocation.getId().toString()); dispositionObsGroup.addGroupMember(admissionLocationObs); assertThat(dispositionDescriptor.getAdmissionLocation(dispositionObsGroup, locationService), is(admissionLocation)); }
@Test public void shouldNotFailIfNoMatchingObsWhenFetchingAdmissionLocation() { Obs dispositionObsGroup = createDispositionObsGroup(); assertNull(dispositionDescriptor.getAdmissionLocation(dispositionObsGroup, locationService)); } |
EmrOrderServiceImpl_1_12 implements EmrOrderService { @Override public void save(List<EncounterTransaction.DrugOrder> drugOrders, Encounter encounter) { Set<OrderGroup> orderGroups = new LinkedHashSet<OrderGroup>(); for (EncounterTransaction.DrugOrder drugOrder : drugOrders) { OrderGroup orderGroup = mapToOpenMRSOrderGroup(orderGroups, drugOrder.getOrderGroup(), encounter); DrugOrder omrsDrugOrder = openMRSDrugOrderMapper.map(drugOrder, encounter); omrsDrugOrder.setOrderGroup(orderGroup); encounter.addOrder(omrsDrugOrder); } encounterService.saveEncounter(encounter); } @Autowired EmrOrderServiceImpl_1_12(OpenMRSDrugOrderMapper openMRSDrugOrderMapper, EncounterService encounterService,
OpenMRSOrderMapper openMRSOrderMapper, OrderSetService orderSetService,
OpenMRSOrderGroupMapper openMRSOrderGroupMapper); @Override void save(List<EncounterTransaction.DrugOrder> drugOrders, Encounter encounter); @Override void saveOrders(List<EncounterTransaction.Order> orders, Encounter encounter); } | @Test public void shouldSaveNewDrugOrdersInTheSequenceOfOrdering() throws ParseException { EmrOrderServiceImpl_1_12 emrOrderService = new EmrOrderServiceImpl_1_12(openMRSDrugOrderMapper, encounterService, openMRSOrderMapper, orderSetService, openMRSOrderGroupMapper); EncounterTransaction.DrugOrder drugOrder1 = new DrugOrderBuilder().withDrugUuid("drug-uuid1").build(); EncounterTransaction.DrugOrder drugOrder2 = new DrugOrderBuilder().withDrugUuid("drug-uuid2").build(); DrugOrder mappedDrugOrder1 = new DrugOrder(); DrugOrder mappedDrugOrder2 = new DrugOrder(); Encounter encounter = new Encounter(); when(openMRSDrugOrderMapper.map(drugOrder1, encounter)).thenReturn(mappedDrugOrder1); when(openMRSDrugOrderMapper.map(drugOrder2, encounter)).thenReturn(mappedDrugOrder2); emrOrderService.save(Arrays.asList(drugOrder1, drugOrder2), encounter); ArgumentCaptor<Encounter> encounterArgumentCaptor = ArgumentCaptor.forClass(Encounter.class); verify(encounterService).saveEncounter(encounterArgumentCaptor.capture()); Encounter savedEncounter = encounterArgumentCaptor.getValue(); ArrayList<Order> savedOrders = new ArrayList<Order>(savedEncounter.getOrders()); assertThat(savedOrders.size(), is(2)); assertThat((DrugOrder)savedOrders.get(0), is(sameInstance(mappedDrugOrder1))); assertThat((DrugOrder)savedOrders.get(1), is(sameInstance(mappedDrugOrder2))); }
@Test public void shouldSaveNewDrugOrdersInTheSequenceOfOrderingToAnEncounterWithExistingOrders() throws ParseException { EmrOrderServiceImpl_1_12 emrOrderService = new EmrOrderServiceImpl_1_12(openMRSDrugOrderMapper, encounterService, openMRSOrderMapper, orderSetService, openMRSOrderGroupMapper); EncounterTransaction.DrugOrder drugOrder3 = new DrugOrderBuilder().withDrugUuid("drug-uuid3").build(); EncounterTransaction.DrugOrder drugOrder4 = new DrugOrderBuilder().withDrugUuid("drug-uuid4").build(); DrugOrder existingDrugOrder1 = new DrugOrder(); DrugOrder existingDrugOrder2 = new DrugOrder(); DrugOrder mappedDrugOrder3 = new DrugOrder(); DrugOrder mappedDrugOrder4 = new DrugOrder(); Encounter encounter = new Encounter(); encounter.addOrder(existingDrugOrder1); encounter.addOrder(existingDrugOrder2); when(openMRSDrugOrderMapper.map(drugOrder3, encounter)).thenReturn(mappedDrugOrder3); when(openMRSDrugOrderMapper.map(drugOrder4, encounter)).thenReturn(mappedDrugOrder4); emrOrderService.save(Arrays.asList(drugOrder3, drugOrder4), encounter); ArgumentCaptor<Encounter> encounterArgumentCaptor = ArgumentCaptor.forClass(Encounter.class); verify(encounterService).saveEncounter(encounterArgumentCaptor.capture()); Encounter savedEncounter = encounterArgumentCaptor.getValue(); ArrayList<Order> savedOrders = new ArrayList<Order>(savedEncounter.getOrders()); assertThat(savedOrders.size(), is(4)); assertThat((DrugOrder)savedOrders.get(2), is(sameInstance(mappedDrugOrder3))); assertThat((DrugOrder)savedOrders.get(3), is(sameInstance(mappedDrugOrder4))); } |
DispositionDescriptor extends ConceptSetDescriptor { public Location getInternalTransferLocation(Obs obsGroup, LocationService locationService) { Obs transferLocationObs = getInternalTransferLocationObs(obsGroup); if (transferLocationObs != null) { return locationService.getLocation(Integer.valueOf(transferLocationObs.getValueText())); } else { return null; } } 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); } | @Test public void shouldFetchTransferLocationOffObsGroup() { Obs dispositionObsGroup = createDispositionObsGroup(); Obs transferLocationObs = new Obs(); transferLocationObs.setConcept(transferLocationConcept); transferLocationObs.setValueText(transferLocation.getId().toString()); dispositionObsGroup.addGroupMember(transferLocationObs); assertThat(dispositionDescriptor.getInternalTransferLocation(dispositionObsGroup, locationService), is(transferLocation)); }
@Test public void shouldNotFailIfNoMatchingObsWhenFetchingTransferLocation() { Obs dispositionObsGroup = createDispositionObsGroup(); assertNull(dispositionDescriptor.getInternalTransferLocation(dispositionObsGroup, locationService)); } |
DispositionDescriptor extends ConceptSetDescriptor { public Date getDateOfDeath(Obs obsGroup) { Obs dateOfDeathObs = getDateOfDeathObs(obsGroup); if (dateOfDeathObs != null) { return dateOfDeathObs.getValueDate(); } else { return null; } } 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); } | @Test public void shouldFetchDateOfDeathOffObsGroup() { Obs dispositionObsGroup = createDispositionObsGroup(); Date dateOfDeath = new Date(); Obs dateOfDeathObs = new Obs(); dateOfDeathObs.setConcept(dateOfDeathConcept); dateOfDeathObs.setValueDate(dateOfDeath); dispositionObsGroup.addGroupMember(dateOfDeathObs); assertThat(dispositionDescriptor.getDateOfDeath(dispositionObsGroup), is(dateOfDeath)); }
@Test public void shouldNotFailIfNoMatchingObsWhenFetchingDateOfDeath() { Obs dispositionObsGroup = createDispositionObsGroup(); assertNull(dispositionDescriptor.getDateOfDeath(dispositionObsGroup)); } |
DispositionDescriptor extends ConceptSetDescriptor { public List<Obs> getAdditionalObs(Obs obsGroup) { List<Obs> notDisposition = new ArrayList<Obs>(); if (obsGroup.hasGroupMembers()) { for (Obs candidate : obsGroup.getGroupMembers()) { if (!candidate.getConcept().equals(dispositionConcept) && !candidate.getConcept().equals(admissionLocationConcept) && !candidate.getConcept().equals(internalTransferLocationConcept) && !candidate.getConcept().equals(dateOfDeathConcept)) { notDisposition.add(candidate); } } } return notDisposition; } 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); } | @Test public void shouldFetchAdditionalObsOffObsGroup() { Obs dispositionObsGroup = createDispositionObsGroup(); Obs admissionLocationObs = new Obs(); admissionLocationObs.setConcept(admissionLocationConcept); admissionLocationObs.setValueText(admissionLocation.getId().toString()); dispositionObsGroup.addGroupMember(admissionLocationObs); Obs transferLocationObs = new Obs(); transferLocationObs.setConcept(transferLocationConcept); transferLocationObs.setValueText(transferLocation.getId().toString()); dispositionObsGroup.addGroupMember(transferLocationObs); Date dateOfDeath = new Date(); Obs dateOfDeathObs = new Obs(); dateOfDeathObs.setConcept(dateOfDeathConcept); dateOfDeathObs.setValueDate(dateOfDeath); dispositionObsGroup.addGroupMember(dateOfDeathObs); Concept additionalObsConcept = new Concept(); Obs additionalObs = new Obs(); additionalObs.setConcept(additionalObsConcept); additionalObs.setValueText("some value"); dispositionObsGroup.addGroupMember(additionalObs); List<Obs> additionalObsList = Collections.singletonList(additionalObs); assertThat(dispositionDescriptor.getAdditionalObs(dispositionObsGroup), is(additionalObsList)); } |
TransferToSpecificLocationDispositionAction implements DispositionAction { @Override public void action(EncounterDomainWrapper encounterDomainWrapper, Obs dispositionObsGroupBeingCreated, Map<String, String[]> requestParameters) { VisitDomainWrapper visitDomainWrapper = adtService.wrap(encounterDomainWrapper.getVisit()); Location transferLocation = dispositionService.getDispositionDescriptor().getInternalTransferLocation(dispositionObsGroupBeingCreated, locationService); Location currentInpatientLocation = visitDomainWrapper.getInpatientLocation(encounterDomainWrapper.getEncounterDatetime()); if (transferLocation == null) { log.warn("Unable to create transfer action, no transfer location specified in obsgroup " + dispositionObsGroupBeingCreated); return; } if (currentInpatientLocation == null || !currentInpatientLocation.equals(transferLocation)) { AdtAction transfer = new AdtAction(encounterDomainWrapper.getVisit(), transferLocation, encounterDomainWrapper.getProviders(), TRANSFER); transfer.setActionDatetime(encounterDomainWrapper.getEncounter().getEncounterDatetime()); adtService.createAdtEncounterFor(transfer); } } void setLocationService(LocationService locationService); @Override void action(EncounterDomainWrapper encounterDomainWrapper, Obs dispositionObsGroupBeingCreated, Map<String, String[]> requestParameters); void setAdtService(AdtService adtService); void setDispositionService(DispositionService dispositionService); } | @Test public void testActionShouldCreateTransferAction() throws Exception { final Location toLocation = new Location(); final Visit visit = new Visit(); final Encounter encounter = new Encounter(); final Date encounterDate = (new DateTime(2013, 05, 13, 20, 26)).toDate(); encounter.setVisit(visit); encounter.addProvider(new EncounterRole(), new Provider()); encounter.setEncounterDatetime(encounterDate); final Obs dispositionObsGroup = new Obs(); dispositionObsGroup.setConcept(dispositionObsGroupConcept); encounter.addObs(dispositionObsGroup); Location anotherLocation = new Location(); when(visitDomainWrapper.isAdmitted(encounterDate)).thenReturn(true); when(visitDomainWrapper.getInpatientLocation(encounterDate)).thenReturn(anotherLocation); when(dispositionDescriptor.getInternalTransferLocation(dispositionObsGroup, locationService)).thenReturn(toLocation); action.action(new EncounterDomainWrapper(encounter), dispositionObsGroup, null); verify(adtService).createAdtEncounterFor(argThat(new ArgumentMatcher<AdtAction>() { @Override public boolean matches(Object argument) { AdtAction actual = (AdtAction) argument; return actual.getVisit().equals(visit) && actual.getLocation().equals(toLocation) && TestUtils.sameProviders(actual.getProviders(), encounter.getProvidersByRoles()) && actual.getActionDatetime().equals(encounterDate) && actual.getType().equals(AdtAction.Type.TRANSFER); } })); }
@Test public void testActionShouldDoNothingIfAlreadyAdmittedToTransferLocation() throws Exception { final Location toLocation = new Location(); final Visit visit = new Visit(); final Encounter encounter = new Encounter(); final Date encounterDate = (new DateTime(2013, 05, 13, 20, 26)).toDate(); encounter.setVisit(visit); encounter.addProvider(new EncounterRole(), new Provider()); encounter.setEncounterDatetime(encounterDate); final Obs dispositionObsGroup = new Obs(); dispositionObsGroup.setConcept(dispositionObsGroupConcept); encounter.addObs(dispositionObsGroup); when(visitDomainWrapper.isAdmitted(encounterDate)).thenReturn(true); when(visitDomainWrapper.getInpatientLocation(encounterDate)).thenReturn(toLocation); when(dispositionDescriptor.getInternalTransferLocation(dispositionObsGroup, locationService)).thenReturn(toLocation); action.action(new EncounterDomainWrapper(encounter), dispositionObsGroup, null); verify(adtService, never()).createAdtEncounterFor(any(AdtAction.class)); }
@Test public void testActionShouldCreateTransferEncounterIfPatientNotAdmitted() throws Exception { final Location toLocation = new Location(); final Visit visit = new Visit(); final Encounter encounter = new Encounter(); final Date encounterDate = (new DateTime(2013, 05, 13, 20, 26)).toDate(); encounter.setVisit(visit); encounter.addProvider(new EncounterRole(), new Provider()); encounter.setEncounterDatetime(encounterDate); final Obs dispositionObsGroup = new Obs(); dispositionObsGroup.setConcept(dispositionObsGroupConcept); encounter.addObs(dispositionObsGroup); when(visitDomainWrapper.isAdmitted(encounterDate)).thenReturn(false); when(dispositionDescriptor.getInternalTransferLocation(dispositionObsGroup, locationService)).thenReturn(toLocation); action.action(new EncounterDomainWrapper(encounter), dispositionObsGroup, null); verify(adtService).createAdtEncounterFor(argThat(new ArgumentMatcher<AdtAction>() { @Override public boolean matches(Object argument) { AdtAction actual = (AdtAction) argument; return actual.getVisit().equals(visit) && actual.getLocation().equals(toLocation) && TestUtils.sameProviders(actual.getProviders(), encounter.getProvidersByRoles()) && actual.getActionDatetime().equals(encounterDate) && actual.getType().equals(AdtAction.Type.TRANSFER); } })); } |
CloseCurrentVisitDispositionAction implements DispositionAction { @Override public void action(EncounterDomainWrapper encounterDomainWrapper, Obs dispositionObsGroupBeingCreated, Map<String, String[]> requestParameters){ if (encounterDomainWrapper.getVisit() == null) { return; } VisitDomainWrapper visitDomainWrapper = adtService.wrap(encounterDomainWrapper.getVisit()); if (visitDomainWrapper.isActive()) { Date mostRecentEncounterDatetime = visitDomainWrapper.getMostRecentEncounter().getEncounterDatetime(); if (!new DateMidnight(mostRecentEncounterDatetime).isAfter(new DateMidnight(encounterDomainWrapper.getEncounterDatetime()))) { visitDomainWrapper.closeOnLastEncounterDatetime(); visitService.saveVisit(visitDomainWrapper.getVisit()); } } } @Override void action(EncounterDomainWrapper encounterDomainWrapper, Obs dispositionObsGroupBeingCreated, Map<String, String[]> requestParameters); void setAdtService(AdtService adtService); void setVisitService(VisitService visitService); } | @Test public void shouldCloseActiveVisit() throws Exception { final Visit visit = new Visit(); final Encounter encounter = new Encounter(); final Date encounterDate = (new DateTime(2013, 05, 13, 20, 26)).toDate(); encounter.setVisit(visit); encounter.addProvider(new EncounterRole(), new Provider()); encounter.setEncounterDatetime(encounterDate); visit.addEncounter(encounter); when(visitDomainWrapper.isActive()).thenReturn(true); when(visitDomainWrapper.getVisit()).thenReturn(visit); when(visitDomainWrapper.getMostRecentEncounter()).thenReturn(encounter); action.action(new EncounterDomainWrapper(encounter), new Obs(), new HashMap<String, String[]>()); verify(visitDomainWrapper).closeOnLastEncounterDatetime(); verify(visitService).saveVisit(visit); }
@Test public void shouldCloseActiveVisitIfSubsequentEncountersButOnSameDay() throws Exception { final Visit visit = new Visit(); final Encounter encounter = new Encounter(); final Date encounterDate = (new DateTime(2013, 05, 13, 20, 26)).toDate(); encounter.setVisit(visit); encounter.addProvider(new EncounterRole(), new Provider()); encounter.setEncounterDatetime(encounterDate); visit.addEncounter(encounter); final Encounter subsequentEncounter = new Encounter(); final Date subsequentEncounterDate = (new DateTime(2013, 05, 13, 23, 23)).toDate(); subsequentEncounter.setVisit(visit); subsequentEncounter.addProvider(new EncounterRole(), new Provider()); subsequentEncounter.setEncounterDatetime(subsequentEncounterDate); visit.addEncounter(subsequentEncounter); when(visitDomainWrapper.isActive()).thenReturn(true); when(visitDomainWrapper.getVisit()).thenReturn(visit); when(visitDomainWrapper.getMostRecentEncounter()).thenReturn(subsequentEncounter); action.action(new EncounterDomainWrapper(encounter), new Obs(), new HashMap<String, String[]>()); verify(visitDomainWrapper).closeOnLastEncounterDatetime(); verify(visitService).saveVisit(visit); }
@Test public void shouldNotCloseActiveVisitIfSubsequentEncountersOnAnotherDay() throws Exception { final Visit visit = new Visit(); final Encounter encounter = new Encounter(); final Date encounterDate = (new DateTime(2013, 05, 13, 20, 26)).toDate(); encounter.setVisit(visit); encounter.addProvider(new EncounterRole(), new Provider()); encounter.setEncounterDatetime(encounterDate); visit.addEncounter(encounter); final Encounter subsequentEncounter = new Encounter(); final Date subsequentEncounterDate = (new DateTime(2013, 05, 14, 05, 05)).toDate(); subsequentEncounter.setVisit(visit); subsequentEncounter.addProvider(new EncounterRole(), new Provider()); subsequentEncounter.setEncounterDatetime(subsequentEncounterDate); visit.addEncounter(subsequentEncounter); when(visitDomainWrapper.isActive()).thenReturn(true); when(visitDomainWrapper.getVisit()).thenReturn(visit); when(visitDomainWrapper.getMostRecentEncounter()).thenReturn(subsequentEncounter); action.action(new EncounterDomainWrapper(encounter), new Obs(), new HashMap<String, String[]>()); verify(visitDomainWrapper, never()).closeOnLastEncounterDatetime(); verify(visitService, never()).saveVisit(visit); }
@Test public void shouldNotCloseVisitThatIsNotActive() throws Exception { final Visit visit = new Visit(); final Encounter encounter = new Encounter(); final Date encounterDate = (new DateTime(2013, 05, 13, 20, 26)).toDate(); encounter.setVisit(visit); encounter.addProvider(new EncounterRole(), new Provider()); encounter.setEncounterDatetime(encounterDate); visit.addEncounter(encounter); when(visitDomainWrapper.isActive()).thenReturn(false); when(visitDomainWrapper.getVisit()).thenReturn(visit); action.action(new EncounterDomainWrapper(encounter), new Obs(), new HashMap<String, String[]>()); verify(visitDomainWrapper, never()).closeOnLastEncounterDatetime(); verify(visitService, never()).saveVisit(visit); } |
DischargeIfAdmittedDispositionAction implements DispositionAction { @Override public void action(EncounterDomainWrapper encounterDomainWrapper, Obs dispositionObsGroupBeingCreated, Map<String, String[]> requestParameters) { Visit visit = encounterDomainWrapper.getVisit(); VisitDomainWrapper visitDomainWrapper = adtService.wrap(visit); if (visitDomainWrapper.isAdmitted()) { AdtAction discharge = new AdtAction(visit, encounterDomainWrapper.getLocation(), encounterDomainWrapper.getProviders(), DISCHARGE); discharge.setActionDatetime(encounterDomainWrapper.getEncounter().getEncounterDatetime()); adtService.createAdtEncounterFor(discharge); } } @Override void action(EncounterDomainWrapper encounterDomainWrapper, Obs dispositionObsGroupBeingCreated, Map<String, String[]> requestParameters); void setAdtService(AdtService adtService); void setEmrApiProperties(EmrApiProperties emrApiProperties); } | @Test public void testDischargesIfAdmitted() throws Exception { final Visit visit = new Visit(); final Encounter encounter = new Encounter(); final Date encounterDate = (new DateTime(2013, 05, 13, 20, 26)).toDate(); encounter.setVisit(visit); encounter.addProvider(new EncounterRole(), new Provider()); encounter.setEncounterDatetime(encounterDate); final Obs dispositionObsGroup = new Obs(); dispositionObsGroup.setConcept(dispositionObsGroupConcept); when(visitDomainWrapper.isAdmitted()).thenReturn(true); action.action(new EncounterDomainWrapper(encounter), dispositionObsGroup, null); verify(adtService).createAdtEncounterFor(argThat(new ArgumentMatcher<AdtAction>() { @Override public boolean matches(Object argument) { AdtAction actual = (AdtAction) argument; return actual.getVisit().equals(visit) && TestUtils.sameProviders(actual.getProviders(), encounter.getProvidersByRoles()) && actual.getActionDatetime().equals(encounterDate) && actual.getType().equals(AdtAction.Type.DISCHARGE); } })); }
@Test public void testDoesNotDischargesIfNotAdmitted() throws Exception { final Visit visit = new Visit(); final Encounter encounter = new Encounter(); final Date encounterDate = (new DateTime(2013, 05, 13, 20, 26)).toDate(); encounter.setVisit(visit); encounter.addProvider(new EncounterRole(), new Provider()); encounter.setEncounterDatetime(encounterDate); final Obs dispositionObsGroup = new Obs(); dispositionObsGroup.setConcept(dispositionObsGroupConcept); when(visitDomainWrapper.isAdmitted(encounterDate)).thenReturn(false); action.action(new EncounterDomainWrapper(encounter), dispositionObsGroup, null); verify(adtService, never()).createAdtEncounterFor(any(AdtAction.class)); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.