method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
RunMonitor { public void putMonitor(String content) { long time = System.currentTimeMillis(); contentList.add(content); timeList.add(time); } RunMonitor(String type, String opCode); void putMonitor(String content); String toString(String opCode); @Override String toString(); }### Answer:
@Test public void testPutMonitor() { runMonitor.putMonitor("链接"); runMonitor.putMonitor("发送"); runMonitor.putMonitor("断开"); }
|
### Question:
ThreadMsgManager { public static boolean addMapping(String msgOpCode, int[] threadPriority) { if (msgOpcodeType.containsKey(msgOpCode)) { return false; } if (threadPriority != null) { msgOpcodeType.put(msgOpCode, threadPriority); } return true; } static boolean addMapping(String msgOpCode, int[] threadPriority); static boolean dispatchThreadMsg(String msgOpCode, Object data, Object otherData); static HashMap<String, int[]> msgOpcodeType; }### Answer:
@Test public void testAddMapping() throws InterruptedException { ThreadMsgManager.dispatchThreadMsg("createuser", 111, 222); ThreadMsgManager.dispatchThreadMsg("updateuser", 111, 222); Thread.sleep(1000); }
|
### Question:
KeyLockManager { public static Object lockMethod(String lockKey, String keyType, KeylockFunction func, Object... params) { boolean isKeyLockException = false; KeyLock keyLock = KeyLockManager.getKeyLock(keyType); try { keyLock.lock(lockKey); return func.apply(params); } catch (KeyLockException e) { isKeyLockException = true; if (KeyLockManager.log != null) { KeyLockManager.log.error("keylock自定义异常", e); } } catch (Exception e) { if (KeyLockManager.log != null) { KeyLockManager.log.error("业务异常", e); } } finally { if (!isKeyLockException) { keyLock.unlock(lockKey); } else { } } return null; } static void init(String[] types, int keyLockExpireTime, int keyLockCycleSleepTime, ILog log); static KeyLock getKeyLock(String type); static Object lockMethod(String lockKey, String keyType, KeylockFunction func, Object... params); static Object lockMethod(String lockKey1, String lockKey2, String keyType, KeylockFunction func, Object... params); static int KEY_LOCK_EXPIRE_TIME; static int KEY_LOCK_CYCLE_SLEEP_TIME; static Map<String, KeyLock> keyLockMap; }### Answer:
@Test public void testLockMethodOneKey() { String str = (String) KeyLockManager.lockMethod("111", TEST1, (params) -> lockFunction(params), new Object[] { "222", 111 }); assertEquals("222111", str); }
@Test public void testLockMethodTwoKey() { String str = (String) KeyLockManager.lockMethod("111", "222", TEST1, (params) -> lockFunction(params), new Object[] { "222", 111 }); assertEquals("222111", str); }
|
### Question:
AsyncThreadManager { public static boolean addHandle(IHandle handle, int threadId, int priority) { if (handle == null) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.warn("handle为空"); } return false; } AsyncThread asyncThread = asyncThreadMap.get(threadId); if (asyncThread == null) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.warn("不存在线程id：" + threadId); } return false; } AsyncHandleData asyncHandleData = asyncThread.asyncHandleDataMap.get(priority); if (asyncHandleData == null) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.warn("不存在优先级：" + priority); } return false; } try { asyncHandleData.waitHandleQueue.put(handle); return true; } catch (InterruptedException e) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.error("放入handle至异步线程列队失败", e); } return false; } } static void init(int asyncThreadCycleInterval, int asyncThreadNum, int asyncThreadPriorityNum, int lockThreadNum, ILog log); static boolean addHandle(IHandle handle, int threadId, int priority); static boolean addCycle(ICycle cycle, int threadId, int priority); static boolean removeCycle(ICycle cycle, int threadId, int priority); static int[] getRandomThreadPriority(); static int[] getRandomThread(); static int[] getLockThreadPriority(int lockNum); static void start(); }### Answer:
@Test public void testAddHandle() throws NoSuchMethodException, SecurityException, InterruptedException { PacketTest packetTest = new PacketTest(); Method method = HandlerManagerTest.class.getMethod("handle", new Class[] { Object.class }); ThreadHandle threadHandle = new ThreadHandle(packetTest, method, null); boolean result = AsyncThreadManager.addHandle(threadHandle, 1, 1); Thread.sleep(1000); assertEquals(true, result); }
|
### Question:
AsyncThreadManager { public static boolean addCycle(ICycle cycle, int threadId, int priority) { if (cycle == null) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.warn("ICycle为空"); } return false; } AsyncThread asyncThread = asyncThreadMap.get(threadId); if (asyncThread == null) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.warn("不存在线程id：" + threadId); } return false; } AsyncHandleData asyncHandleData = asyncThread.asyncHandleDataMap.get(priority); if (asyncHandleData == null) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.warn("不存在优先级：" + priority); } return false; } try { asyncHandleData.waitAddCycleQueue.put(cycle); return true; } catch (InterruptedException e) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.error("放入ICycle至异步线程列队失败", e); } return false; } } static void init(int asyncThreadCycleInterval, int asyncThreadNum, int asyncThreadPriorityNum, int lockThreadNum, ILog log); static boolean addHandle(IHandle handle, int threadId, int priority); static boolean addCycle(ICycle cycle, int threadId, int priority); static boolean removeCycle(ICycle cycle, int threadId, int priority); static int[] getRandomThreadPriority(); static int[] getRandomThread(); static int[] getLockThreadPriority(int lockNum); static void start(); }### Answer:
@Test public void testAddCycle() { CycleTest cycleTest = new CycleTest(); cycleTest.name = "testAddCycle"; boolean result = AsyncThreadManager.addCycle(cycleTest, 1, 1); assertEquals(true, result); }
|
### Question:
AsyncThreadManager { public static boolean removeCycle(ICycle cycle, int threadId, int priority) { if (cycle == null) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.warn("ICycle为空"); } return false; } AsyncThread asyncThread = asyncThreadMap.get(threadId); if (asyncThread == null) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.warn("不存在线程id：" + threadId); } return false; } AsyncHandleData asyncHandleData = asyncThread.asyncHandleDataMap.get(priority); if (asyncHandleData == null) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.warn("不存在优先级：" + priority); } return false; } try { asyncHandleData.waitRemoveCycleQueue.put(cycle); return true; } catch (InterruptedException e) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.error("移除ICycle至异步线程列队失败", e); } return false; } } static void init(int asyncThreadCycleInterval, int asyncThreadNum, int asyncThreadPriorityNum, int lockThreadNum, ILog log); static boolean addHandle(IHandle handle, int threadId, int priority); static boolean addCycle(ICycle cycle, int threadId, int priority); static boolean removeCycle(ICycle cycle, int threadId, int priority); static int[] getRandomThreadPriority(); static int[] getRandomThread(); static int[] getLockThreadPriority(int lockNum); static void start(); }### Answer:
@Test public void testRemoveCycle() { CycleTest cycleTest = new CycleTest(); cycleTest.name = "testRemoveCycle"; boolean result = AsyncThreadManager.addCycle(cycleTest, 1, 1); result = AsyncThreadManager.removeCycle(cycleTest, 1, 1); assertEquals(true, result); }
|
### Question:
AsyncThreadManager { public static int[] getRandomThreadPriority() { int thread = (int) (Math.random() * (asyncThreadNum - lockThreadNum) + 1); int priority = (int) (Math.random() * asyncThreadPriorityNum + 1); return new int[] { thread, priority }; } static void init(int asyncThreadCycleInterval, int asyncThreadNum, int asyncThreadPriorityNum, int lockThreadNum, ILog log); static boolean addHandle(IHandle handle, int threadId, int priority); static boolean addCycle(ICycle cycle, int threadId, int priority); static boolean removeCycle(ICycle cycle, int threadId, int priority); static int[] getRandomThreadPriority(); static int[] getRandomThread(); static int[] getLockThreadPriority(int lockNum); static void start(); }### Answer:
@Test public void testGetRandomThreadPriority() { int[] threadPriority = AsyncThreadManager.getRandomThreadPriority(); assertEquals(true, threadPriority != null); }
|
### Question:
AsyncThreadManager { public static int[] getRandomThread() { int thread = (int) (Math.random() * (asyncThreadNum - lockThreadNum) + 1); return new int[] { thread, 1 }; } static void init(int asyncThreadCycleInterval, int asyncThreadNum, int asyncThreadPriorityNum, int lockThreadNum, ILog log); static boolean addHandle(IHandle handle, int threadId, int priority); static boolean addCycle(ICycle cycle, int threadId, int priority); static boolean removeCycle(ICycle cycle, int threadId, int priority); static int[] getRandomThreadPriority(); static int[] getRandomThread(); static int[] getLockThreadPriority(int lockNum); static void start(); }### Answer:
@Test public void testGetRandomThread() { int[] threadPriority = AsyncThreadManager.getRandomThread(); assertEquals(true, threadPriority != null); }
|
### Question:
SpreadsheetDataSetProducer implements DataSetProducer { @Override public Schema getSchema() { return new Schema() { @Override public Table getTable(String name) { throw new UnsupportedOperationException("Cannot get the metadata of a table for a spreadsheet"); } @Override public boolean isEmptyDatabase() { return tables.isEmpty(); } @Override public boolean tableExists(String name) { return tables.containsKey(name); } @Override public Collection<String> tableNames() { return tables.keySet(); } @Override public Collection<Table> tables() { throw new UnsupportedOperationException("Cannot get the metadata of a table for a spreadsheet"); } @Override public boolean viewExists(String name) { return false; } @Override public View getView(String name) { throw new IllegalArgumentException("Invalid view [" + name + "]. Views are not supported in spreadsheets"); } @Override public Collection<String> viewNames() { return Collections.emptySet(); } @Override public Collection<View> views() { return Collections.emptySet(); } }; } SpreadsheetDataSetProducer(final InputStream... excelFiles); @Override Schema getSchema(); @Override void open(); @Override void close(); @Override Iterable<Record> records(String tableName); @Override boolean isTableEmpty(String tableName); }### Answer:
@Test public void testGetSchema() throws URISyntaxException { final SpreadsheetDataSetProducer producer = produceTestSpreadsheet(); Collection<String> tableNames = producer.getSchema().tableNames(); assertEquals("Number of tables found [" + tableNames + "]", 12, tableNames.size()); assertTrue("Tables correctly populated [" + tableNames + "]", tableNames.contains("AssetType")); assertTrue("Tables correctly populated [" + tableNames + "]", tableNames.contains("Allowance")); }
@Test public void testGetSchemaMethods() throws URISyntaxException { final SpreadsheetDataSetProducer producer = produceTestSpreadsheet(); try { producer.getSchema().getTable("Name"); fail("Exception should have been thrown"); } catch (UnsupportedOperationException e) { } try { producer.getSchema().tables(); fail("Exception should have been thrown"); } catch (UnsupportedOperationException e) { } assertFalse("Schema is not empty", producer.getSchema().isEmptyDatabase()); assertTrue("UsageMeterType table exists", producer.getSchema().tableExists("UsageMeterType")); }
|
### Question:
RemoveIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) return false; Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.indexesMatch(index, indexToBeRemoved)) { return false; } } return true; } RemoveIndex(String tableName, Index index); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); String getTableName(); Index getIndexToBeRemoved(); }### Answer:
@Test public void testRemovingIndexFromNonExistentTable() { Schema testSchema = schema(appleTable); removeIndex = new RemoveIndex("Sweets", index("Sweets_1").unique().columns("pieces")); removeIndex.isApplied(testSchema, MockConnectionResources.build()); }
@Test public void testRemovingIndexFromExistingTable() { Schema testSchema = schema(appleTable); removeIndex.isApplied(testSchema, MockConnectionResources.build()); }
|
### Question:
ExistingViewHashLoader { Optional<Map<String, String>> loadViewHashes(Schema schema) { if (!schema.tableExists(DEPLOYED_VIEWS_NAME)) { return Optional.empty(); } Map<String, String> result = Maps.newHashMap(); SelectStatement upgradeAuditSelect = select(field("name"), field("hash")).from(tableRef(DEPLOYED_VIEWS_NAME)); String sql = dialect.convertStatementToSQL(upgradeAuditSelect); if (log.isDebugEnabled()) log.debug("Loading " + DEPLOYED_VIEWS_NAME + " with SQL [" + sql + "]"); try (Connection connection = dataSource.getConnection(); java.sql.Statement statement = connection.createStatement(); ResultSet resultSet = statement.executeQuery(sql)) { while (resultSet.next()) { String dbViewName = resultSet.getString(1); String viewName = dbViewName.toUpperCase(); if (!result.containsKey(viewName) || dbViewName.equals(viewName)) { result.put(viewName, resultSet.getString(2)); } } } catch (SQLException e) { throw new RuntimeSqlException("Failed to load deployed views. SQL: [" + sql + "]", e); } return Optional.of(Collections.unmodifiableMap(result)); } ExistingViewHashLoader(DataSource dataSource, SqlDialect dialect); }### Answer:
@Test public void testNoDeployedViewsTable() { Schema schema = schema(table("SomeTable")); assertFalse(onTest.loadViewHashes(schema).isPresent()); }
@Test public void testFetch() throws SQLException { Schema schema = schema(table(DatabaseUpgradeTableContribution.DEPLOYED_VIEWS_NAME)); when(dataSource.getConnection()).thenReturn(connection); when(connection.createStatement()).thenReturn(statement); when(statement.executeQuery(anyString())).thenReturn(resultSet); when(resultSet.next()).thenAnswer(new Answer<Boolean>() { @Override public Boolean answer(InvocationOnMock invocation) throws Throwable { return recordIndex++ < 5; } }); when(resultSet.getString(anyInt())).thenAnswer(new Answer<String>() { @Override public String answer(InvocationOnMock invocation) throws Throwable { if (((Integer)invocation.getArguments()[0]).equals(1)) { switch (recordIndex) { case 1: return "VIEW1"; case 2: return "view2"; case 3: return "VIEW2"; case 4: return "View1"; case 5: return "view3"; default: throw new IllegalStateException("Unexpected index"); } } else { switch (recordIndex) { case 1: return "hash1"; case 2: return "HASH2"; case 3: return "hash2"; case 4: return "HASH1"; case 5: return "hash3"; default: throw new IllegalStateException("Unexpected index"); } } } }); Map<String, String> result = onTest.loadViewHashes(schema).get(); assertEquals("Result count", 3, result.size()); assertEquals("View 1 hash", "hash1", result.get("VIEW1")); assertEquals("View 2 hash", "hash2", result.get("VIEW2")); }
|
### Question:
RenameTable implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, oldTableName, newTableName); } RenameTable(String oldTableName, String newTableName); String getOldTableName(); String getNewTableName(); @Override Schema apply(Schema schema); @Override Schema reverse(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override void accept(SchemaChangeVisitor visitor); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testRenameTableNotExists() { Schema testSchema = schema(appleTable); RenameTable renameTable = new RenameTable("Pear", "Apple"); renameTable.apply(testSchema); }
@Test(expected = IllegalArgumentException.class) public void testRenameTableAlreadyExists() { Schema testSchema = schema(appleTable, orangeTable); RenameTable renameTable = new RenameTable("Apple", "Orange"); renameTable.apply(testSchema); }
|
### Question:
AuditRecordHelper { public static void addAuditRecord(SchemaChangeVisitor visitor, Schema schema, UUID uuid, String description) { if (!schema.tableExists("UpgradeAudit")) return; InsertStatement auditRecord = createAuditInsertStatement(uuid, description); visitor.visit(new ExecuteStatement(auditRecord)); } static void addAuditRecord(SchemaChangeVisitor visitor, Schema schema, UUID uuid, String description); static InsertStatement createAuditInsertStatement(UUID uuid, String description); }### Answer:
@Test public void testAddAuditRecord() throws ParseException { SchemaChangeVisitor visitor = mock(SchemaChangeVisitor.class); Schema schema = mock(Schema.class); UUID uuid = UUID.randomUUID(); String description = "Description"; given(schema.tableExists("UpgradeAudit")).willReturn(true); AuditRecordHelper.addAuditRecord(visitor, schema, uuid, description); ArgumentCaptor<ExecuteStatement> argument = ArgumentCaptor.forClass(ExecuteStatement.class); verify(visitor).visit(argument.capture()); InsertStatement statement = (InsertStatement) argument.getValue().getStatement(); assertAuditInsertStatement(uuid, description, statement); }
|
### Question:
AuditRecordHelper { public static InsertStatement createAuditInsertStatement(UUID uuid, String description) { InsertStatement auditRecord = new InsertStatement().into( new TableReference("UpgradeAudit")).values( new FieldLiteral(uuid.toString()).as("upgradeUUID"), new FieldLiteral(description).as("description"), cast(dateToYyyyMMddHHmmss(now())).asType(DataType.DECIMAL, 14).as("appliedTime") ); return auditRecord; } static void addAuditRecord(SchemaChangeVisitor visitor, Schema schema, UUID uuid, String description); static InsertStatement createAuditInsertStatement(UUID uuid, String description); }### Answer:
@Test public void createAuditInsertStatement() throws Exception { UUID uuid = UUID.randomUUID(); String description = "Description"; InsertStatement statement = AuditRecordHelper.createAuditInsertStatement(uuid, description); assertAuditInsertStatement(uuid, description, statement); }
|
### Question:
Deployment { public UpgradePath getPath(Schema targetSchema, Collection<Class<? extends UpgradeStep>> upgradeSteps) { final UpgradePath path = upgradePathFactory.create(sqlDialect); writeStatements(targetSchema, path); writeUpgradeSteps(upgradeSteps, path); return path; } @Inject Deployment(SqlDialect sqlDialect, SqlScriptExecutorProvider sqlScriptExecutorProvider, UpgradePathFactory upgradePathFactory); private Deployment(UpgradePathFactory upgradePathFactory, @Assisted ConnectionResources connectionResources); void deploy(Schema targetSchema); void deploy(Schema targetSchema, Collection<Class<? extends UpgradeStep>> upgradeSteps); static void deploySchema(Schema targetSchema, Collection<Class<? extends UpgradeStep>> upgradeSteps, ConnectionResources connectionResources); UpgradePath getPath(Schema targetSchema, Collection<Class<? extends UpgradeStep>> upgradeSteps); }### Answer:
@Test public void testGetPath() { Table testTable = table("Foo").columns(column("name", DataType.STRING, 32)); View testView = view("FooView", select(field("name")).from(tableRef("Foo"))); View testView2 = view("BarView", select(field("name")).from(tableRef("MooView")), "MooView"); View testView3 = view("MooView", select(field("name")).from(tableRef("FooView")), "FooView"); when(dialect.tableDeploymentStatements(same(testTable))).thenReturn(ImmutableList.of("A")); when(dialect.viewDeploymentStatements(same(testView))).thenReturn(ImmutableList.of("B")); when(dialect.viewDeploymentStatements(same(testView2))).thenReturn(ImmutableList.of("C")); when(dialect.viewDeploymentStatements(same(testView3))).thenReturn(ImmutableList.of("D")); Schema targetSchema = schema( schema(testTable), schema(testView, testView2, testView3) ); Deployment deployment = new Deployment(dialect, executorProvider, upgradePathFactory); UpgradePath path = deployment.getPath(targetSchema, Lists.<Class<? extends UpgradeStep>>newArrayList()); assertTrue("Steps to apply", path.hasStepsToApply()); assertEquals("Steps", "[]", path.getSteps().toString()); assertEquals("SQL", ImmutableList.of("A", "B", "D", "C"), path.getSql()); deployment.deploy(targetSchema); verify(executor).execute(ImmutableList.of("A", "B", "D", "C")); }
|
### Question:
UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public UpgradeStatus getStatus(Optional<DataSource> dataSource) { SelectStatement select = SqlUtils.select(SqlUtils.field(STATUS_COLUMN)).from(tableRef(UpgradeStatusTableService.UPGRADE_STATUS)); Connection connection = null; try { if (dataSource.isPresent()) { try { connection = dataSource.get().getConnection(); return sqlScriptExecutorProvider.get().executeQuery(sqlDialect.convertStatementToSQL(select), connection, resultSetProcessor()); } finally { if (connection != null) connection.close(); } } else { return sqlScriptExecutorProvider.get().executeQuery(sqlDialect.convertStatementToSQL(select), resultSetProcessor()); } } catch (RuntimeSqlException e) { log.debug("Unable to read column " + STATUS_COLUMN + " for upgrade status", e); return UpgradeStatus.NONE; } catch (SQLException e) { log.error("Unable to get a connection to retrieve upgrade status.", e); throw new RuntimeException("Unable to get a connection to retrieve upgrade status.", e); } } @Inject UpgradeStatusTableServiceImpl(SqlScriptExecutorProvider sqlScriptExecutor, SqlDialect sqlDialect); @Override int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus); @Override List<String> updateTableScript(UpgradeStatus fromStatus, UpgradeStatus toStatus); @Override UpgradeStatus getStatus(Optional<DataSource> dataSource); @Override void tidyUp(DataSource dataSource); }### Answer:
@SuppressWarnings("unchecked") @Test public void testGetStatusWhenTableNotPresent() { when(sqlScriptExecutor.executeQuery(anyString(), any(Connection.class), any(ResultSetProcessor.class))).thenThrow(RuntimeSqlException.class); assertEquals("Result", UpgradeStatus.NONE, upgradeStatusTableService.getStatus(Optional.of(dataSource))); }
@Test @SuppressWarnings({ "unchecked", "rawtypes" }) public void testGetStatusWhenTablePresent() throws SQLException { ArgumentCaptor<ResultSetProcessor> captor = ArgumentCaptor.forClass(ResultSetProcessor.class); ResultSet resultSet = mock(ResultSet.class); when(sqlScriptExecutor.executeQuery(anyString(), any(Connection.class), captor.capture())).thenAnswer(invocation -> { ResultSetProcessor processor = (ResultSetProcessor) invocation.getArguments()[2]; assertSame("Processor", captor.getValue(), processor); when(resultSet.getString(1)).thenReturn("IN_PROGRESS"); return processor.process(resultSet); }); assertEquals("Result", UpgradeStatus.IN_PROGRESS, upgradeStatusTableService.getStatus(Optional.of(dataSource))); verify(resultSet).next(); }
|
### Question:
ChangeIndex implements SchemaChange { @Override public Schema reverse(Schema schema) { return applyChange(schema, toIndex, fromIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @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 getFromIndex(); Index getToIndex(); }### Answer:
@Test public void testReverseChangeColumnType() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("Apple_3").unique().columns("colour", "pips"), index("Apple_3").columns("pips")); Schema updatedSchema = changeIndex.reverse(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade index count", 3, resultTable.indexes().size()); Index indexThree = resultTable.indexes().get(2); assertEquals("Post upgrade existing index 3 column count", 2, indexThree.columnNames().size()); assertEquals("Post upgrade existing index 3 uniqueness", true, indexThree.isUnique()); }
|
### Question:
ChangeIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.indexesMatch(index, toIndex)) { return true; } } return false; } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @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 getFromIndex(); Index getToIndex(); }### Answer:
@Test public void testChangeIndexOnNonExistentTable() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Sweets", index("Sweets_1").unique().columns("pieces"), index("Sweets_1").unique().columns("pieces")); changeIndex.isApplied(testSchema, MockConnectionResources.build()); }
@Test public void testChangeIndexOnExistingTable() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("Apple_1").unique().columns("pips"), index("Apple_1").unique().columns("pips")); changeIndex.isApplied(testSchema, MockConnectionResources.build()); }
|
### Question:
InlineTableUpgrader implements SchemaChangeVisitor { public void preUpgrade() { sqlStatementWriter.writeSql(sqlDialect.tableDeploymentStatements(idTable)); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatementWriter, Table idTable); void preUpgrade(); void postUpgrade(); @Override void visit(AddTable addTable); @Override void visit(RemoveTable removeTable); @Override void visit(AddIndex addIndex); @Override void visit(AddColumn addColumn); @Override void visit(ChangeColumn changeColumn); @Override void visit(RemoveColumn removeColumn); @Override void visit(RemoveIndex removeIndex); @Override void visit(ChangeIndex changeIndex); @Override void visit(final RenameIndex renameIndex); @Override void visit(ExecuteStatement executeStatement); @Override void visit(RenameTable renameTable); @Override void visit(ChangePrimaryKeyColumns changePrimaryKeyColumns); @Override void addAuditRecord(UUID uuid, String description); @Override void startStep(Class<? extends UpgradeStep> upgradeClass); @Override void visit(AddTableFrom addTableFrom); @Override void visit(AnalyseTable analyseTable); }### Answer:
@Test public void testPreUpgrade() { final ArgumentCaptor<Table> captor = ArgumentCaptor.forClass(Table.class); upgrader.preUpgrade(); verify(sqlDialect).tableDeploymentStatements(captor.capture()); assertTrue("Temporary table", captor.getValue().isTemporary()); }
|
### Question:
InlineTableUpgrader implements SchemaChangeVisitor { public void postUpgrade() { sqlStatementWriter.writeSql(sqlDialect.truncateTableStatements(idTable)); sqlStatementWriter.writeSql(sqlDialect.dropStatements(idTable)); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatementWriter, Table idTable); void preUpgrade(); void postUpgrade(); @Override void visit(AddTable addTable); @Override void visit(RemoveTable removeTable); @Override void visit(AddIndex addIndex); @Override void visit(AddColumn addColumn); @Override void visit(ChangeColumn changeColumn); @Override void visit(RemoveColumn removeColumn); @Override void visit(RemoveIndex removeIndex); @Override void visit(ChangeIndex changeIndex); @Override void visit(final RenameIndex renameIndex); @Override void visit(ExecuteStatement executeStatement); @Override void visit(RenameTable renameTable); @Override void visit(ChangePrimaryKeyColumns changePrimaryKeyColumns); @Override void addAuditRecord(UUID uuid, String description); @Override void startStep(Class<? extends UpgradeStep> upgradeClass); @Override void visit(AddTableFrom addTableFrom); @Override void visit(AnalyseTable analyseTable); }### Answer:
@Test public void testPostUpgrade() { final ArgumentCaptor<Table> truncateCaptor = ArgumentCaptor.forClass(Table.class); final ArgumentCaptor<Table> dropCaptor = ArgumentCaptor.forClass(Table.class); upgrader.postUpgrade(); verify(sqlDialect).truncateTableStatements(truncateCaptor.capture()); verify(sqlDialect).dropStatements(dropCaptor.capture()); assertTrue("Truncate temporary table", truncateCaptor.getValue().isTemporary()); assertTrue("Drop temporary table", dropCaptor.getValue().isTemporary()); }
|
### Question:
InlineTableUpgrader implements SchemaChangeVisitor { private void visitStatement(Statement statement) { writeStatements(sqlDialect.convertStatementToSQL(statement, currentSchema, idTable)); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatementWriter, Table idTable); void preUpgrade(); void postUpgrade(); @Override void visit(AddTable addTable); @Override void visit(RemoveTable removeTable); @Override void visit(AddIndex addIndex); @Override void visit(AddColumn addColumn); @Override void visit(ChangeColumn changeColumn); @Override void visit(RemoveColumn removeColumn); @Override void visit(RemoveIndex removeIndex); @Override void visit(ChangeIndex changeIndex); @Override void visit(final RenameIndex renameIndex); @Override void visit(ExecuteStatement executeStatement); @Override void visit(RenameTable renameTable); @Override void visit(ChangePrimaryKeyColumns changePrimaryKeyColumns); @Override void addAuditRecord(UUID uuid, String description); @Override void startStep(Class<? extends UpgradeStep> upgradeClass); @Override void visit(AddTableFrom addTableFrom); @Override void visit(AnalyseTable analyseTable); }### Answer:
@Test public void testVisitStatement() { ExecuteStatement executeStatement = mock(ExecuteStatement.class); Statement statement = mock(Statement.class); given(executeStatement.getStatement()).willReturn(statement); when(sqlDialect.convertStatementToSQL(eq(statement), any(Schema.class), any(Table.class))).thenCallRealMethod(); try { upgrader.visit(executeStatement); fail("UnsupportedOperationException expected"); } catch (UnsupportedOperationException e) { } }
|
### Question:
RenameIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); for (Index index : table.indexes()) { if (index.getName().equalsIgnoreCase(toIndexName)) { return true; } } return false; } RenameIndex(String tableName, String fromIndexName, String toIndexName); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); String getTableName(); String getFromIndexName(); String getToIndexName(); }### Answer:
@Test public void testRenameIndexOnNonExistentTable() { Schema testSchema = schema(appleTable); RenameIndex renameIndex = new RenameIndex("Sweets", "Sweets_1", "Sweets_2"); assertFalse("Should not be applied", renameIndex.isApplied(testSchema, MockConnectionResources.build())); }
@Test public void testRenameIndexOnNonExistentIndex() { Schema testSchema = schema(appleTable); RenameIndex renameIndex = new RenameIndex("Apple", "Apple_3", "Apple_4"); assertFalse("Should not be applied", renameIndex.isApplied(testSchema, MockConnectionResources.build())); }
|
### Question:
RenameIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } RenameIndex(String tableName, String fromIndexName, String toIndexName); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); String getTableName(); String getFromIndexName(); String getToIndexName(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testRenameIndexNoFromName() { Schema testSchema = schema(appleTable); RenameIndex renameIndex = new RenameIndex("Apple", " ", "Apple_3"); renameIndex.apply(testSchema); }
@Test(expected = IllegalArgumentException.class) public void testRenameIndexNoToName() { Schema testSchema = schema(appleTable); RenameIndex renameIndex = new RenameIndex("Apple", "Apple_1", " "); renameIndex.apply(testSchema); }
@Test(expected = IllegalArgumentException.class) public void testRenameIndexNotExists() { Schema testSchema = schema(appleTable); RenameIndex renameIndex = new RenameIndex("Apple", "Apple_3", "Apple_4"); renameIndex.apply(testSchema); }
@Test(expected = IllegalArgumentException.class) public void testRenameIndexAlreadyExists() { Schema testSchema = schema(appleTable); RenameIndex renameIndex = new RenameIndex("Apple", "Apple_1", "Apple_2"); renameIndex.apply(testSchema); }
|
### Question:
AddIndex implements SchemaChange { @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); if (original == null) { throw new IllegalArgumentException(String.format("Cannot add index [%s] to table [%s] as the table cannot be found", newIndex.getName(), tableName)); } List<String> indexes = new ArrayList<>(); for (Index index : original.indexes()) { if (index.getName().equals(newIndex.getName())) { throw new IllegalArgumentException(String.format("Cannot add index [%s] to table [%s] as the index already exists", newIndex.getName(), tableName)); } indexes.add(index.getName()); } indexes.add(newIndex.getName()); return new TableOverrideSchema(schema, new AlteredTable(original, null, null, indexes, Arrays.asList(new Index[] {newIndex}))); } AddIndex(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 getNewIndex(); }### Answer:
@Test public void testAddingIndex() { Schema testSchema = schema(appleTable); Schema updatedSchema = addIndex.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade index count", 1, resultTable.indexes().size()); assertEquals("Post upgrade index name", "Apple_1", resultTable.indexes().get(0).getName()); assertEquals("Post upgrade index column count", 1, resultTable.indexes().get(0).columnNames().size()); assertEquals("Post upgrade index column name", "pips", resultTable.indexes().get(0).columnNames().get(0)); }
@Test public void testAddIndexOfSameName() { appleTable = table("Apple").columns( column("pips", DataType.STRING, 10).nullable(), column("colour", DataType.STRING, 10).nullable() ).indexes( index("Apple_1").unique().columns("pips") ); addIndex = new AddIndex("Apple", index("Apple_1").unique().columns("pips")); Schema testSchema = schema(appleTable); try { addIndex.apply(testSchema); fail(); } catch (RuntimeException re) { assertTrue(re.getMessage().contains("Apple_1")); } }
@Test public void testMissingTable() { addIndex = new AddIndex("AppleX", index("Apple_1").unique().columns("pips")); Schema testSchema = schema(appleTable); try { addIndex.apply(testSchema); fail(); } catch (RuntimeException re) { assertTrue(re.getMessage(), re.getMessage().contains("Apple")); } }
|
### Question:
AddIndex implements SchemaChange { @Override public Schema reverse(Schema schema) { Table original = schema.getTable(tableName); List<String> indexeNames = new ArrayList<>(); boolean foundAndRemovedIndex = false; for (Index index : original.indexes()) { if (index.getName().equalsIgnoreCase(newIndex.getName())) { foundAndRemovedIndex = true; } else { indexeNames.add(index.getName()); } } if (!foundAndRemovedIndex) { throw new IllegalStateException("Error reversing AddIndex database change. Index [" + newIndex.getName() + "] not found in table [" + tableName + "] so it could not be reversed out"); } return new TableOverrideSchema(schema, new AlteredTable(original, null, null, indexeNames, null)); } AddIndex(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 getNewIndex(); }### Answer:
@Test public void testReverseAddingIndex() { appleTable = table("Apple").columns( column("pips", DataType.STRING, 10).nullable(), column("colour", DataType.STRING, 10).nullable() ).indexes( index("Apple_1").unique().columns("pips") ); Schema testSchema = schema(appleTable); Schema downGradedSchema = addIndex.reverse(testSchema); Table resultTable = downGradedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade index count", 0, resultTable.indexes().size()); }
@Test public void testRemovingNonExistantIndex() { Schema testSchema = schema(appleTable); try { addIndex.reverse(testSchema); fail("Should fail since index is not there"); } catch (Exception e) { } }
|
### Question:
AddIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.indexesMatch(index, newIndex)) { return true; } } return false; } AddIndex(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 getNewIndex(); }### Answer:
@Test public void testAddIndexToNonExistentTable() { Schema testSchema = schema(appleTable); addIndex = new AddIndex("Sweets", index("Sweets_1").unique().columns("pieces")); assertFalse("Index should not have been applied", addIndex.isApplied(testSchema, MockConnectionResources.build())); }
@Test public void testAddIndexToExistingTable() { Schema testSchema = schema(appleTable); assertFalse("Index should not have been applied", addIndex.isApplied(testSchema, MockConnectionResources.build())); }
|
### Question:
TableSetSchema implements Schema { @Override public boolean tableExists(final String name) { return tables.stream().anyMatch(table -> table.getName().equalsIgnoreCase(name)); } TableSetSchema(Collection<Table> tables); @Override Collection<Table> tables(); @Override Table getTable(final String name); @Override boolean isEmptyDatabase(); @Override boolean tableExists(final String name); @Override Collection<String> tableNames(); @Override boolean viewExists(String name); @Override View getView(String name); @Override Collection<String> viewNames(); @Override Collection<View> views(); }### Answer:
@Test public void testTableExists() { assertTrue(schema.tableExists("Apple")); assertFalse(schema.tableExists("Peach")); }
@Test public void testTableExistsNotCaseSensitive() { assertTrue(schema.tableExists("APPLE")); assertTrue(schema.tableExists("apple")); }
|
### Question:
TableSetSchema implements Schema { @Override public Table getTable(final String name) { return tables.stream() .filter(table -> table.getName().equalsIgnoreCase(name)) .findFirst() .orElseThrow(() -> new IllegalArgumentException(String.format("Requested table [%s] does not exist.", name))); } TableSetSchema(Collection<Table> tables); @Override Collection<Table> tables(); @Override Table getTable(final String name); @Override boolean isEmptyDatabase(); @Override boolean tableExists(final String name); @Override Collection<String> tableNames(); @Override boolean viewExists(String name); @Override View getView(String name); @Override Collection<String> viewNames(); @Override Collection<View> views(); }### Answer:
@Test public void testGetTable() { final String tableName = "Apple"; Table appleTable = schema.getTable(tableName); assertNotNull(appleTable); assertEquals(tableName, appleTable.getName()); }
@Test public void testGetTableCaseInsensitive() { final String tableName = "Apple"; Table uppercaseTable = schema.getTable(tableName.toUpperCase()); Table lowercaseTable = schema.getTable(tableName.toLowerCase()); assertNotNull(uppercaseTable); assertNotNull(lowercaseTable); }
@Test(expected = RuntimeException.class) public void testGetTableWhenTableDoesntExist() { final String wrongTable = "Peach"; schema.getTable(wrongTable); }
|
### Question:
Escaping { static String escapeCharacters(String recordValue) { int last = 0; StringBuilder escapedValue = new StringBuilder(recordValue.length()); for (int i=0; i<recordValue.length(); i++) { if (!isCharValidForXml(recordValue.charAt(i))) { escapedValue.append(recordValue.substring(last, i)); escapedValue.append(String.format("\\u%04x", (int)recordValue.charAt(i))); last=i+1; } if (recordValue.charAt(i) == '\\') { escapedValue.append(recordValue.substring(last, i)); escapedValue.append("\\\\"); last=i+1; } } escapedValue.append(recordValue.substring(last, recordValue.length())); return escapedValue.toString(); } }### Answer:
@Test public void testEscapeCharacters() { for (TestCase testCase : testCases) { assertEquals(testCase.escaped, escapeCharacters(testCase.unescaped)); } }
|
### Question:
Escaping { static String unescapeCharacters(String attributeValue) { if (attributeValue == null) return null; char[] attributeChars = attributeValue.toCharArray(); StringBuilder result = new StringBuilder(attributeChars.length); int from = 0; int len = 0; int i = 0; while (i < attributeChars.length) { if (attributeChars[i] == '\\') { result.append(attributeChars, from, len); len = 0; switch(attributeChars[i+1]) { case '\\' : result.append('\\'); i++; break; case '0' : result.append((char) 0); i++; break; case 'u' : result.append(decodeEscapedCharacter(attributeChars, i)); i+=5; break; default: throw new IllegalStateException("Illegal escape sequence at char [" + i + "] in [" + attributeValue + "]"); } from = i+1; } else { len++; } i++; } result.append(attributeChars, from, len); return result.toString(); } }### Answer:
@Test public void testUnescapeCharacters() { for (TestCase testCase : testCases) { assertEquals(testCase.unescaped, unescapeCharacters(testCase.escaped)); } assertEquals(string('a', 'b', 'c', (char) 0), unescapeCharacters("abc\0")); assertEquals(string('a', 'b', 'c', (char) 0), unescapeCharacters("abc\u0000")); }
|
### Question:
DataMaskingXmlDataSetConsumer extends XmlDataSetConsumer { @Override protected String getValue(Record record, Column column, String table) { if (tableColumnsToMask.containsKey(table) && tableColumnsToMask.get(table).contains(column.getName())) { return null; } return super.getValue(record, column, table); } DataMaskingXmlDataSetConsumer(File file, Map<String, Set<String>> tableColumnsToMask); DataMaskingXmlDataSetConsumer(XmlOutputStreamProvider xmlOutputStreamProvider, Map<String, Set<String>> tableColumnsToMask); }### Answer:
@Test public void getValue() { DummyXmlOutputStreamProvider dummyXmlOutputStreamProvider = new DummyXmlOutputStreamProvider(); DataSetConsumer testConsumer = new DataMaskingXmlDataSetConsumer(dummyXmlOutputStreamProvider, toMask); Table metaData = table("Test").columns( column("id", DataType.BIG_INTEGER).primaryKey().autoNumbered(123), versionColumn(), column("bar", DataType.STRING, 10).nullable(), column("baz", DataType.STRING, 10).nullable(), column("bob", DataType.DECIMAL, 13, 2).nullable() ).indexes( index("fizz").unique().columns("bar", "baz") ); testConsumer.open(); List<Record> mockRecords = new ArrayList<>(); mockRecords.add(record() .setInteger("id", 1) .setInteger("version", 1) .setString("bar", "abc") .setString("baz", "123") .setString("bob", "456.78")); testConsumer.table(metaData, mockRecords); testConsumer.close(CloseState.COMPLETE); assertEquals("Serialised data set", SourceXML.MASKED_SAMPLE, dummyXmlOutputStreamProvider.getXmlString().trim()); }
|
### Question:
Version2to4TransformingReader extends Reader { static int readVersion(BufferedReader bufferedReader) { try { bufferedReader.mark(1024); try { char[] buffer = new char[1024]; int read = bufferedReader.read(buffer); if (read == -1) { return -1; } String content = new String(buffer, 0, read); Pattern pattern = Pattern.compile("table\\sversion=\"(\\d+)\""); Matcher matcher = pattern.matcher(content); if (!matcher.find()) { return -1; } else { return Integer.parseInt(matcher.group(1)); } } finally { bufferedReader.reset(); } } catch (IOException e) { throw new RuntimeException(e); } } Version2to4TransformingReader(BufferedReader bufferedReader, int inputVersion); @Override int read(char[] cbuf, int off, int len); @Override void close(); }### Answer:
@Test public void testReadVersion() throws IOException { try (BufferedReader reader = new BufferedReader(new StringReader( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + "<table version=\"1\">\n" + " <metadata name=\"Foo\">" ))) { Assert.assertEquals(1, Version2to4TransformingReader.readVersion(reader)); } try (BufferedReader reader = new BufferedReader(new StringReader( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + "<table version=\"2\">\n" + " <metadata name=\"Foo\">" ))) { Assert.assertEquals(2, Version2to4TransformingReader.readVersion(reader)); } try (BufferedReader reader = new BufferedReader(new StringReader( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + "<table version=\"3\">\n" + " <metadata name=\"Foo\">" ))) { Assert.assertEquals(3, Version2to4TransformingReader.readVersion(reader)); } try (BufferedReader reader = new BufferedReader(new StringReader( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + "<table version=\"4\">\n" + " <metadata name=\"Foo\">" ))) { Assert.assertEquals(4, Version2to4TransformingReader.readVersion(reader)); } try (BufferedReader reader = new BufferedReader(new StringReader( "<?xml version=\"1.0\" encoding=\"UTF-8\"?><table version=\"2\">\n" + "<metadata name=\"SomeTable\">\n" ))) { Assert.assertEquals(2, Version2to4TransformingReader.readVersion(reader)); } try (BufferedReader reader = new BufferedReader(new StringReader( "foo" ))) { Assert.assertEquals(-1, Version2to4TransformingReader.readVersion(reader)); } }
|
### Question:
SchemaUtils { public static ColumnType type(DataType type) { return SchemaUtils.column(null, type); } private SchemaUtils(); static Column idColumn(); static Column versionColumn(); static Schema schema(); static Schema schema(Table... tables); static Schema schema(View... views); static Schema schema(Iterable<Table> tables); static Schema schema(Collection<View> views); static Schema schema(Schema... schema); static Schema copy(Schema schema); static Schema copy(Schema schema, Collection<String> exclusionRegExes); static TableBuilder table(String name); static Table copy(Table table); static Index copy(Index index); static ColumnBuilder column(String name, DataType type, int width, int scale); static ColumnBuilder column(String name, DataType type, int width); static ColumnBuilder column(String name, DataType type); static ColumnBuilder column(Column column); static Column autonumber(String name, int startFrom); static IndexBuilder index(String name); static View view(String viewName, SelectStatement selectStatement, String... dependencies); static View copy(View view); static ColumnType type(DataType type); static ColumnType type(DataType type, int width); static ColumnType type(DataType type, int width, int scale); static ColumnType type(DataType type, int width, int scale, boolean nullable); static List<Column> primaryKeysForTable(Table table); static List<Column> autoNumbersForTable(Table table); static List<String> namesOfColumns(List<Column> columns); static List<String> toUpperCase(List<String> listOfStrings); }### Answer:
@Test public void testCreatingAColumnTypeNotNullable() { ColumnType columnType = SchemaUtils.type(DataType.DECIMAL, 10, 4, false); assertTrue("ColumnType type incorrect", columnType.getType().equals(DataType.DECIMAL)); assertTrue("ColumnType width incorrect", columnType.getWidth() == 10); assertTrue("ColumnType scale incorrect", columnType.getScale() == 4); assertFalse("ColumnType should not be nullable", columnType.isNullable()); }
@Test public void testCreatingAColumnTypeNullable() { ColumnType columnType = SchemaUtils.type(DataType.STRING, 10, 0, true); assertTrue("ColumnType type incorrect", columnType.getType().equals(DataType.STRING)); assertTrue("ColumnType width incorrect", columnType.getWidth() == 10); assertTrue("ColumnType scale incorrect", columnType.getScale() == 0); assertTrue("ColumnType should be nullable", columnType.isNullable()); }
|
### Question:
SchemaUtils { public static List<String> toUpperCase(List<String> listOfStrings) { return FluentIterable.from(listOfStrings).transform(new Function<String, String>() { @Override public String apply(String value) { return value.toUpperCase(); } }).toList(); } private SchemaUtils(); static Column idColumn(); static Column versionColumn(); static Schema schema(); static Schema schema(Table... tables); static Schema schema(View... views); static Schema schema(Iterable<Table> tables); static Schema schema(Collection<View> views); static Schema schema(Schema... schema); static Schema copy(Schema schema); static Schema copy(Schema schema, Collection<String> exclusionRegExes); static TableBuilder table(String name); static Table copy(Table table); static Index copy(Index index); static ColumnBuilder column(String name, DataType type, int width, int scale); static ColumnBuilder column(String name, DataType type, int width); static ColumnBuilder column(String name, DataType type); static ColumnBuilder column(Column column); static Column autonumber(String name, int startFrom); static IndexBuilder index(String name); static View view(String viewName, SelectStatement selectStatement, String... dependencies); static View copy(View view); static ColumnType type(DataType type); static ColumnType type(DataType type, int width); static ColumnType type(DataType type, int width, int scale); static ColumnType type(DataType type, int width, int scale, boolean nullable); static List<Column> primaryKeysForTable(Table table); static List<Column> autoNumbersForTable(Table table); static List<String> namesOfColumns(List<Column> columns); static List<String> toUpperCase(List<String> listOfStrings); }### Answer:
@Test public void testToUpperCase() { assertEquals( Arrays.asList("ONE", "TWO", "THREE"), SchemaUtils.toUpperCase(Arrays.asList("One", "two", "thReE")) ); }
|
### Question:
CompositeSchema implements Schema { @Override public Table getTable(String name) { for (Schema schema : delegates) if (schema.tableExists(name)) return schema.getTable(name); throw new IllegalArgumentException("Unknown table [" + name + "]"); } CompositeSchema(Schema... schema); @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(); @Override String toString(); }### Answer:
@Test public void testOrdering() { assertSame("Bar table", schema1.getTable("Bar"), new CompositeSchema(schema1, schema2).getTable("Bar")); }
|
### Question:
TableHelper { public static Column columnWithName(Table table, String columnName) { for (Column currentColumn : table.columns()) { if (currentColumn.getName().equalsIgnoreCase(columnName)) { return currentColumn; } } return null; } static Column columnWithName(Table table, String columnName); static List<String> buildColumnNameList(Table table); static Index indexWithName(Table table, String indexName); }### Answer:
@Test public void testColumnWithName() { String columnName = "columnName"; Table table = table("tableName").columns( idColumn(), versionColumn(), column(columnName, DataType.STRING, 10).nullable() ); assertEquals("Incorrect column", TableHelper.columnWithName(table, columnName).getName(), columnName); }
|
### Question:
TableHelper { public static Index indexWithName(Table table, String indexName) { for (Index currentIndex : table.indexes()) { if (currentIndex.getName().equalsIgnoreCase(indexName)) { return currentIndex; } } return null; } static Column columnWithName(Table table, String columnName); static List<String> buildColumnNameList(Table table); static Index indexWithName(Table table, String indexName); }### Answer:
@Test public void testIndexWithName() { String indexName = "indexName"; Table table = table("tableName").indexes(index(indexName)); assertEquals("Incorrect index", TableHelper.indexWithName(table, indexName).getName(), indexName); }
|
### Question:
TableHelper { public static List<String> buildColumnNameList(Table table) { List<String> result = new ArrayList<String>(); for (Column currentColumn : table.columns()) { result.add(currentColumn.getName()); } return result; } static Column columnWithName(Table table, String columnName); static List<String> buildColumnNameList(Table table); static Index indexWithName(Table table, String indexName); }### Answer:
@Test public void testBuildColumnNameList() { Table table = table("tableName").columns( idColumn(), versionColumn(), column("columnName1", DataType.STRING, 10).nullable(), column("columnName2", DataType.STRING, 10).nullable() ); assertEquals("Column list", Arrays.asList("id", "version", "columnName1", "columnName2"), TableHelper.buildColumnNameList(table)); }
|
### Question:
SpreadsheetDataSetProducer implements DataSetProducer { private List<Record> getRecords(Sheet sheet) { try { long id = 1; int row = findHeaderRow(sheet); final Map<String, Integer> columnHeadingsMap = new HashMap<>(); for (int i = 0; i < countHeadings(sheet, row); i++) { columnHeadingsMap.put(columnName(sheet.getCell(i, row).getContents()), i); } final int translationColumn = getTranslationsColumnIndex(sheet, row); row++; List<Record> records = new LinkedList<>(); for (; row < sheet.getRows(); row++) { final Cell[] cells = sheet.getRow(row); if (allBlank(cells)) { break; } records.add(createRecord(id++, columnHeadingsMap, translationColumn, cells)); } return records; } catch (Exception e) { throw new RuntimeException("Failed to parse worksheet [" + sheet.getName() + "]", e); } } SpreadsheetDataSetProducer(final InputStream... excelFiles); @Override Schema getSchema(); @Override void open(); @Override void close(); @Override Iterable<Record> records(String tableName); @Override boolean isTableEmpty(String tableName); }### Answer:
@Test public void testGetRecords() throws URISyntaxException { final SpreadsheetDataSetProducer producer = produceTestSpreadsheet(); List<Record> records = Lists.newArrayList(producer.records("UsageMeterType")); assertEquals("Number of rows [" + records + "]", 2, records.size()); Record record = records.get(0); assertEquals("Usage Meter", "KM", record.getString("usageMeter")); assertEquals("Description", "Kilometers", record.getString("description")); assertEquals("Usage Meter Type", "M", record.getString("usageMeterType")); record = records.get(1); assertEquals("Usage Meter", "HOUR", record.getString("usageMeter")); assertEquals("Description", "Hours", record.getString("description")); assertEquals("Usage Meter Type", "", record.getString("usageMeterType")); }
|
### Question:
SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean schemasMatch(Schema schema1, Schema schema2, Collection<String> exclusionRegex); boolean tablesMatch(Table table1, Table table2); boolean columnsMatch(Column column1, Column column2); boolean indexesMatch(Index index1, Index index2); }### Answer:
@Test public void testDuplicate() { boolean match = schemaHomology.tablesMatch(appleTable, appleTableDuplicate); assertTrue(match); }
@Test public void testNameChange() { assertFalse(schemaHomology.tablesMatch(appleTable, appleNameChange)); }
@Test public void testAutonumbering() { assertFalse(schemaHomology.tablesMatch(appleTable, appleTableNotAutonumbered)); }
@Test public void testCaseInsensitivity() { boolean match = schemaHomology.tablesMatch(appleTable, appleTableChangeCase); assertTrue(match); }
@Test public void testExtraColumn() { assertFalse(schemaHomology.tablesMatch(appleTable, appleTableWithExtraColumn)); }
@Test public void testMissingColumn() { assertFalse(schemaHomology.tablesMatch(appleTable, appleTableWithMissingColumn)); }
@Test public void testRenameColumn() { assertFalse("Renamed column should cause tables to be different", schemaHomology.tablesMatch(appleTable, appleTableWithRenamedColumn)); }
@Test public void testMissingIndex() { assertFalse("Missing index should cause tables to be different", schemaHomology.tablesMatch(appleTable, appleTableMissingIndex)); }
@Test public void testRenamedIndex() { assertFalse(schemaHomology.tablesMatch(appleTable, appleTableRenamedIndex)); }
@Test public void testModifyWidth() { assertFalse(schemaHomology.tablesMatch(pearTable, pearTableModifiedWidth)); }
@Test public void testModifyScale() { assertFalse(schemaHomology.tablesMatch(pearTable, pearTableModifiedScale)); }
@Test public void testModifyNullable() { assertFalse(schemaHomology.tablesMatch(pearTable, pearTableModifiedNullable)); }
@Test public void testReorderedIndexes() { appleTable.indexes().clear(); appleTable.indexes().add(index("indexA").unique().columns("A", "B")); appleTable.indexes().add(index("indexB").unique().columns("B", "C")); appleTableDuplicate.indexes().clear(); appleTableDuplicate.indexes().add(index("indexB").unique().columns("B", "C")); appleTableDuplicate.indexes().add(index("indexA").unique().columns("A", "B")); boolean match = schemaHomology.tablesMatch(appleTable, appleTableDuplicate); assertTrue(match); }
@Test public void testPrimaryKeyColumnOrderIsChecked() { Table appleTableReOrdered= table("AppleTableWithComplexKey").columns( column("sweet", DataType.BOOLEAN).primaryKey(), column("flavour", DataType.DECIMAL).primaryKey(), column("colour", DataType.STRING).primaryKey() ).indexes( index("sweetness").unique().columns("colour") ); assertFalse("Tables should not match", schemaHomology.tablesMatch(appleTableWithComplexKey, appleTableReOrdered)); }
@Test public void testColumnOrderIsCheckedForDifferentNumberOfColumns() { Table appleTableReOrdered= table("appleTableWithComplexKey").columns( column("sweet", DataType.BOOLEAN).primaryKey(), column("flavour", DataType.DECIMAL).primaryKey() ).indexes( index("sweetness").unique().columns("colour") ); assertFalse("Tables should not match", schemaHomology.tablesMatch(appleTableWithComplexKey, appleTableReOrdered)); }
|
### Question:
SchemaHomology { public boolean columnsMatch(Column column1, Column column2) { noDifferences = true; checkColumn(null, column1, column2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean schemasMatch(Schema schema1, Schema schema2, Collection<String> exclusionRegex); boolean tablesMatch(Table table1, Table table2); boolean columnsMatch(Column column1, Column column2); boolean indexesMatch(Index index1, Index index2); }### Answer:
@Test public void testColumnsMatch() { assertTrue("columns should match", schemaHomology.columnsMatch(column("colour", DataType.STRING).nullable(), column("colour", DataType.STRING).nullable())); assertTrue("columns should match", schemaHomology.columnsMatch(column("colour", DataType.STRING).nullable(), column("COLOUR", DataType.STRING).nullable())); assertFalse("columns should not match", schemaHomology.columnsMatch(column("colour", DataType.STRING).nullable(), column("color", DataType.STRING).nullable())); }
@Test public void testColumnDefaultValueIsChecked() { assertTrue("columns should match", schemaHomology.columnsMatch(column("colour", DataType.STRING, 10), column("colour", DataType.STRING, 10))); assertTrue("columns should match", schemaHomology.columnsMatch(column("colour", DataType.STRING, 10).defaultValue("XYZ"), column("colour", DataType.STRING, 10).defaultValue("XYZ"))); assertFalse("columns should not match", schemaHomology.columnsMatch(column("colour", DataType.STRING, 10).defaultValue("XYZ"), column("colour", DataType.STRING, 10).defaultValue("ABC"))); assertFalse("columns should not match", schemaHomology.columnsMatch(column("colour", DataType.STRING, 10).defaultValue("XYZ"), column("colour", DataType.STRING, 10))); }
|
### Question:
SchemaHomology { public boolean indexesMatch(Index index1, Index index2) { noDifferences = true; checkIndex("unspecified", index1, index2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean schemasMatch(Schema schema1, Schema schema2, Collection<String> exclusionRegex); boolean tablesMatch(Table table1, Table table2); boolean columnsMatch(Column column1, Column column2); boolean indexesMatch(Index index1, Index index2); }### Answer:
@Test public void testIndexesMatch() { assertTrue("indexes should match", schemaHomology.indexesMatch(index("ABC").unique().columns("a", "b", "c"), index("ABC").unique().columns("a", "b", "c"))); assertFalse("indexes should match", schemaHomology.indexesMatch(index("ABC").unique().columns("a", "b", "c"), index("ABC").unique().columns("a", "c", "b"))); }
|
### Question:
SQLEntityNameValidationService { public boolean isNameConventional(String name) { return schemaValidator.isNameConventional(name); } @Inject SQLEntityNameValidationService(); boolean isReservedWord(String word); boolean isNameConventional(String name); boolean isEntityNameLengthValid(String name); }### Answer:
@Test @Parameters(method="getNamePatternTestSubjects") public void testValidNamePattern(String name, boolean expectedResult) { boolean result = sqlEntityNameValidationService.isNameConventional(name); assertEquals(format("%s should have been valid=%s but was valid=%s", name, expectedResult, result), expectedResult, result); }
|
### Question:
SQLEntityNameValidationService { public boolean isReservedWord(String word) { return schemaValidator.isSQLReservedWord(word); } @Inject SQLEntityNameValidationService(); boolean isReservedWord(String word); boolean isNameConventional(String name); boolean isEntityNameLengthValid(String name); }### Answer:
@Test @Parameters(method="getReservedWordTestSubjects") public void testReservedWord(String name, boolean expectedResult) { boolean result = sqlEntityNameValidationService.isReservedWord(name); assertEquals(format("%s should have been reserved=%s but was reserved=%s", name, expectedResult, result), expectedResult, result); }
|
### Question:
SQLEntityNameValidationService { public boolean isEntityNameLengthValid(String name) { return schemaValidator.isEntityNameLengthValid(name); } @Inject SQLEntityNameValidationService(); boolean isReservedWord(String word); boolean isNameConventional(String name); boolean isEntityNameLengthValid(String name); }### Answer:
@Test @Parameters(method="getNameLengthTestSubjects") public void testValidNameLength(String name, boolean expectedResult) { boolean result = sqlEntityNameValidationService.isEntityNameLengthValid(name); assertEquals(format("%s should have been valid=%s but was valid=%s", name, expectedResult, result), expectedResult, result); }
|
### Question:
UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public void tidyUp(DataSource dataSource) { try { new SqlScriptExecutorProvider(dataSource, sqlDialect).get().execute(sqlDialect.dropStatements(table(UpgradeStatusTableService.UPGRADE_STATUS))); } catch (RuntimeSqlException e) { if (getStatus(Optional.of(dataSource)) != NONE) { throw e; } } } @Inject UpgradeStatusTableServiceImpl(SqlScriptExecutorProvider sqlScriptExecutor, SqlDialect sqlDialect); @Override int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus); @Override List<String> updateTableScript(UpgradeStatus fromStatus, UpgradeStatus toStatus); @Override UpgradeStatus getStatus(Optional<DataSource> dataSource); @Override void tidyUp(DataSource dataSource); }### Answer:
@Test public void testTidyUp() throws SQLException { upgradeStatusTableService.tidyUp(dataSource); ArgumentCaptor<Table> tableCaptor = ArgumentCaptor.forClass(Table.class); verify(sqlDialect).dropStatements(tableCaptor.capture()); assertEquals("Table", tableCaptor.getValue().getName(), UPGRADE_STATUS); }
|
### Question:
UnionSetOperator implements SetOperator { @Override public Builder<SetOperator> deepCopy(DeepCopyTransformation transformer) { return TempTransitionalBuilderWrapper.<SetOperator>wrapper(new UnionSetOperator(getUnionStrategy(),transformer.deepCopy(getSelectStatement()))); } UnionSetOperator(UnionStrategy unionStrategy, SelectStatement parentSelect, SelectStatement childSelect); private UnionSetOperator(UnionStrategy unionStrategy, SelectStatement childSelect); @Override SelectStatement getSelectStatement(); UnionStrategy getUnionStrategy(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override void drive(ObjectTreeTraverser traverser); @Override Builder<SetOperator> deepCopy(DeepCopyTransformation transformer); }### Answer:
@Test public void testDeepCopy() { SelectStatement parentSelect = new SelectStatement(); SelectStatement childSelect = new SelectStatement(); UnionSetOperator original = new UnionSetOperator(ALL, parentSelect, childSelect); UnionSetOperator copy = (UnionSetOperator) original.deepCopy(noTransformation()).build(); assertNotSame(original, copy); assertEquals(original.getUnionStrategy(), copy.getUnionStrategy()); assertNotSame(childSelect, copy.getSelectStatement()); }
|
### Question:
BracketedExpression extends AliasedField implements Driver { public MathsField getInnerExpression() { return innerExpression; } BracketedExpression(MathsField innerExpression); private BracketedExpression(final String alias, MathsField innerExpression); @Override BracketedExpression as(String aliasName); MathsField getInnerExpression(); @Override void drive(ObjectTreeTraverser traverser); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testInnerExpression() { assertEquals(plus(literal(1), literal(2)), onTest.getInnerExpression()); }
|
### Question:
BracketedExpression extends AliasedField implements Driver { @Override public void drive(ObjectTreeTraverser traverser) { traverser.dispatch(getInnerExpression()); } BracketedExpression(MathsField innerExpression); private BracketedExpression(final String alias, MathsField innerExpression); @Override BracketedExpression as(String aliasName); MathsField getInnerExpression(); @Override void drive(ObjectTreeTraverser traverser); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testDrive() { ObjectTreeTraverser.Callback callback = mock(ObjectTreeTraverser.Callback.class); onTest.drive(ObjectTreeTraverser.forCallback(callback)); verify(callback).visit(onTest.getInnerExpression()); }
|
### Question:
FieldFromSelect extends AliasedField implements Driver { public SelectStatement getSelectStatement() { return selectStatement; } private FieldFromSelect(String alias, SelectStatement selectStatement); FieldFromSelect(SelectStatement selectStatement); SelectStatement getSelectStatement(); @Override void drive(ObjectTreeTraverser traverser); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testDeepCopyDetail() { SelectStatement statementWithTwoFields = new SelectStatement(new FieldReference("agreementNumber")).from(new TableReference("Schedule")) .where(Criterion.eq(new FieldReference(new TableReference("Schedule"), "agreementNumber"), "A001003657")); FieldFromSelect ffs = new FieldFromSelect(statementWithTwoFields); ffs.as("field_alias"); FieldFromSelect ffsCopy = (FieldFromSelect)ffs.deepCopy(); assertTrue("Should be different instances of SelectStatement", ffs.getSelectStatement() != ffsCopy.getSelectStatement()); assertEquals("Field names should match", ((FieldReference)ffs.getSelectStatement().getFields().get(0)).getName(), ((FieldReference)ffsCopy.getSelectStatement().getFields().get(0)).getName()); assertEquals("Table names should match", ffs.getSelectStatement().getTable().getName(), ffsCopy.getSelectStatement().getTable().getName()); assertEquals("Operators should match", ffs.getSelectStatement().getWhereCriterion().getOperator(), ffsCopy.getSelectStatement().getWhereCriterion().getOperator()); assertEquals("Criterion field names should match", ((FieldReference)ffs.getSelectStatement().getWhereCriterion().getField()).getName(), ((FieldReference)ffsCopy.getSelectStatement().getWhereCriterion().getField()).getName()); assertEquals("Criterion values should match", ((String) ffs.getSelectStatement().getWhereCriterion().getValue()).toUpperCase(), ((String) ffsCopy.getSelectStatement().getWhereCriterion().getValue()).toUpperCase()); assertEquals("Alias", ffs.getAlias(), ffsCopy.getAlias()); }
|
### Question:
TableReference implements DeepCopyableWithTransformation<TableReference,
Builder<TableReference>> { @Override public int hashCode() { return new HashCodeBuilder(1559, 887) .append(schemaName) .append(name) .append(alias) .append(temporary) .toHashCode(); } private TableReference(TableReference sourceTable, String alias); TableReference(String name); TableReference(String schemaName, String tableName); TableReference(String tableName, boolean temporary); TableReference as(String aliasName); String getName(); String getAlias(); String getSchemaName(); boolean isTemporary(); @Deprecated void setName(String name); @Override Builder<TableReference> deepCopy(DeepCopyTransformation transformer); TableReference deepCopy(); @Override String toString(); FieldReference field(String fieldName); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testHashCode() { assertEquals(isEqual.hashCode(), onTest.hashCode()); assertEquals(isEqualAliased.hashCode(), onTestAliased.hashCode()); }
|
### Question:
TableReference implements DeepCopyableWithTransformation<TableReference,
Builder<TableReference>> { @Override public boolean equals(Object obj) { if (obj == null) return false; if (obj == this) return true; if (!(obj instanceof TableReference)) return false; TableReference rhs = (TableReference)obj; return new EqualsBuilder() .append(schemaName, rhs.schemaName) .append(name, rhs.name) .append(alias, rhs.alias) .append(temporary, rhs.temporary) .isEquals(); } private TableReference(TableReference sourceTable, String alias); TableReference(String name); TableReference(String schemaName, String tableName); TableReference(String tableName, boolean temporary); TableReference as(String aliasName); String getName(); String getAlias(); String getSchemaName(); boolean isTemporary(); @Deprecated void setName(String name); @Override Builder<TableReference> deepCopy(DeepCopyTransformation transformer); TableReference deepCopy(); @Override String toString(); FieldReference field(String fieldName); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testEquals() { assertEquals(isEqual, onTest); assertFalse(onTest.equals(null)); assertNotEquals(notEqualDueToSchema, onTest); assertNotEquals(notEqualDueToName, onTest); assertNotEquals(notEqualDueToAlias, onTest); assertEquals(isEqualAliased, onTestAliased); assertNotEquals(differentSchema, onTestAliased); assertNotEquals(differentName, onTestAliased); assertNotEquals(differentAlias, onTestAliased); }
|
### Question:
TableReference implements DeepCopyableWithTransformation<TableReference,
Builder<TableReference>> { public TableReference as(String aliasName) { if (AliasedField.immutableDslEnabled()) { return new TableReference(this, aliasName); } else { this.alias = aliasName; return this; } } private TableReference(TableReference sourceTable, String alias); TableReference(String name); TableReference(String schemaName, String tableName); TableReference(String tableName, boolean temporary); TableReference as(String aliasName); String getName(); String getAlias(); String getSchemaName(); boolean isTemporary(); @Deprecated void setName(String name); @Override Builder<TableReference> deepCopy(DeepCopyTransformation transformer); TableReference deepCopy(); @Override String toString(); FieldReference field(String fieldName); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testAliasImmutability() { AliasedField.withImmutableBuildersEnabled(() -> { assertEquals(isEqual.as("A"), onTest.as("A")); assertEquals(isEqual.as("B").as("A"), onTest.as("A")); assertNotEquals(isEqual.as("A"), onTest.as("B")); assertNotSame(onTest, onTest.as("A")); }); }
@Test public void testAliasMutablity() { AliasedField.withImmutableBuildersDisabled(() -> { assertSame(onTest, onTest.as("A")); }); }
|
### Question:
TableReference implements DeepCopyableWithTransformation<TableReference,
Builder<TableReference>> { @Override public Builder<TableReference> deepCopy(DeepCopyTransformation transformer) { return TempTransitionalBuilderWrapper.wrapper(deepCopy()); } private TableReference(TableReference sourceTable, String alias); TableReference(String name); TableReference(String schemaName, String tableName); TableReference(String tableName, boolean temporary); TableReference as(String aliasName); String getName(); String getAlias(); String getSchemaName(); boolean isTemporary(); @Deprecated void setName(String name); @Override Builder<TableReference> deepCopy(DeepCopyTransformation transformer); TableReference deepCopy(); @Override String toString(); FieldReference field(String fieldName); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testDeepCopy() { TableReference deepCopy = onTest.deepCopy(); assertEquals(deepCopy, onTest); assertNotSame(deepCopy, onTest); }
@Test public void testDeepCopyAliased() { TableReference deepCopy = onTestAliased.deepCopy(); assertEquals(deepCopy, onTestAliased); assertNotSame(deepCopy, onTestAliased); }
|
### Question:
DatabaseMetaDataProviderUtils { public static int getAutoIncrementStartValue(String columnComment) { if (StringUtils.isNotEmpty(columnComment)) { Matcher matcher = AUTONUM_START_REGEX.matcher(columnComment); if (matcher.find()) { return Integer.parseInt(matcher.group(1)); } } return -1; } static int getAutoIncrementStartValue(String columnComment); static Optional<String> getDataTypeFromColumnComment(String columnComment); static boolean shouldIgnoreIndex(String indexName); }### Answer:
@Test public void testGetAutoIncrementStartValue() { assertEquals("Failed to fetch correct value", 1234, DatabaseMetaDataProviderUtils.getAutoIncrementStartValue("AUTONUMSTART:[1234]")); assertEquals("Failed to fetch correct value from large string", 1234, DatabaseMetaDataProviderUtils.getAutoIncrementStartValue(" dfdfg AUTONUMSTART:[1234] dsfdfg")); assertEquals("Failed to fetch correct value when multiple values exist", 1234, DatabaseMetaDataProviderUtils.getAutoIncrementStartValue("AUTONUMSTART:[1234]/AUTONUMSTART:[2345]")); assertEquals("Failed to fetch unset value", -1, DatabaseMetaDataProviderUtils.getAutoIncrementStartValue("AUTONUMSTART:[1234")); assertEquals("Failed to fetch missing value", -1, DatabaseMetaDataProviderUtils.getAutoIncrementStartValue("AUTONUMSTART:[]")); assertEquals("Failed to fetch malformed value", -1, DatabaseMetaDataProviderUtils.getAutoIncrementStartValue("AUTONUMSTART:[ABC]")); }
|
### Question:
DatabaseMetaDataProviderUtils { public static boolean shouldIgnoreIndex(String indexName) { return indexName.toUpperCase().matches(".*_PRF\\d+$"); } static int getAutoIncrementStartValue(String columnComment); static Optional<String> getDataTypeFromColumnComment(String columnComment); static boolean shouldIgnoreIndex(String indexName); }### Answer:
@Test public void shouldIgnoreIndex() { assertFalse(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Schedule_1")); assertFalse(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Fred")); assertFalse(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Schedule_PRF")); assertFalse(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Schedule_xPRF")); assertFalse(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Schedule_PRF1X")); assertTrue(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Schedule_PRF0")); assertTrue(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Schedule_PRF1")); assertTrue(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Schedule_PRF11")); assertTrue(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Fred_PRF2")); assertTrue(DatabaseMetaDataProviderUtils.shouldIgnoreIndex("Fred_prf2")); }
|
### Question:
SqlQueryDataSetProducer implements DataSetProducer { @Override public void open() { try { this.connection = dataSource.getConnection(); this.wasAutoCommit = connection.getAutoCommit(); wasAutoCommit = connection.getAutoCommit(); connection.setAutoCommit(false); } catch (SQLException e) { throw new RuntimeSqlException("Error opening connection", e); } } SqlQueryDataSetProducer(Table table, String query, DataSource dataSource, SqlDialect sqlDialect); @Override void open(); @Override void close(); @Override Schema getSchema(); @Override Iterable<Record> records(String tableName); @Override boolean isTableEmpty(String tableName); }### Answer:
@Test public void testOpen() throws SQLException { Table table = buildTable(); String query = "select column from table"; given(dataSource.getConnection()) .willReturn(connection); SqlQueryDataSetProducer producer = new SqlQueryDataSetProducer(table, query, dataSource, sqlDialect); producer.open(); verify(connection).setAutoCommit(false); }
|
### Question:
SqlQueryDataSetProducer implements DataSetProducer { @Override public void close() { if (connection == null) { return; } try { for (ResultSetIterator resultSetIterator : openResultSets) { resultSetIterator.close(); } openResultSets.clear(); connection.setAutoCommit(wasAutoCommit); connection.close(); connection = null; } catch (SQLException e) { throw new RuntimeException("Error closing result set", e); } } SqlQueryDataSetProducer(Table table, String query, DataSource dataSource, SqlDialect sqlDialect); @Override void open(); @Override void close(); @Override Schema getSchema(); @Override Iterable<Record> records(String tableName); @Override boolean isTableEmpty(String tableName); }### Answer:
@Test public void testClose() throws SQLException { Table table = buildTable(); String query = "select column from table"; given(dataSource.getConnection()) .willReturn(connection); given(connection.getAutoCommit()).willReturn(true); SqlQueryDataSetProducer producer = new SqlQueryDataSetProducer(table, query, dataSource, sqlDialect); producer.open(); producer.close(); verify(connection).setAutoCommit(false); verify(connection).setAutoCommit(true); verify(connection).close(); }
|
### Question:
SqlQueryDataSetProducer implements DataSetProducer { @Override public Iterable<Record> records(String tableName) { Table table = getSchema().getTable(tableName); return new Iterable<Record>() { @Override public Iterator<Record> iterator() { ResultSetIterator resultSetIterator = new ResultSetIterator(table, query, connection, sqlDialect); openResultSets.add(resultSetIterator); return resultSetIterator; } }; } SqlQueryDataSetProducer(Table table, String query, DataSource dataSource, SqlDialect sqlDialect); @Override void open(); @Override void close(); @Override Schema getSchema(); @Override Iterable<Record> records(String tableName); @Override boolean isTableEmpty(String tableName); }### Answer:
@Test public void testRecords() throws SQLException { Table table = buildTable(); String query = "select column from table"; given(dataSource.getConnection()) .willReturn(connection); ResultSet resultSet = mock(ResultSet.class); given(statement.executeQuery(query)).willReturn(resultSet); given(resultSet.findColumn("Column")).willReturn(1); SqlQueryDataSetProducer producer = new SqlQueryDataSetProducer(table, query, dataSource, sqlDialect); producer.open(); Iterable<Record> records = producer.records("table"); records.iterator(); }
|
### Question:
DatabaseExceptionHelper { public boolean isCausedByTimeoutException(Throwable throwable) { if (ExceptionUtils.indexOfType(throwable, SQLTimeoutException.class) != -1) { return true; } for (Throwable causeThrowable : ExceptionUtils.getThrowables(throwable)) { if (MYSQL_TIMEOUT_EXCEPTION_NAME.equals(causeThrowable.getClass().getSimpleName())) { return true; } } return false; } boolean isCausedByTimeoutException(Throwable throwable); }### Answer:
@Test public void testIsCausedByTimeoutForSQLTimeoutException() { assertEquals(true, databaseExceptionHelper.isCausedByTimeoutException(new ExtendsSQLTimeoutException())); }
@Test public void testIsCausedByTimeoutForMySQLTimeoutException() { assertEquals(true, databaseExceptionHelper.isCausedByTimeoutException(new MySQLTimeoutException())); }
|
### Question:
NamedParameterPreparedStatement implements AutoCloseable { public static ParseResult parse(String sql) { return new ParseResult(sql); } NamedParameterPreparedStatement(Connection connection, String query, Map<String, List<Integer>> indexMap, boolean queryOnly, ParseResult sql); static ParseResult parse(String sql); boolean execute(); ResultSet executeQuery(); int executeUpdate(); @Override void close(); void addBatch(); int[] executeBatch(); void clearBatch(); void setFetchSize(int rows); NamedParameterPreparedStatement setBoolean(SqlParameter parameter, final boolean value); NamedParameterPreparedStatement setObject(SqlParameter parameter, final Object value); NamedParameterPreparedStatement setDate(SqlParameter parameter, final Date value); NamedParameterPreparedStatement setBigDecimal(SqlParameter parameter, final BigDecimal value); NamedParameterPreparedStatement setString(SqlParameter parameter, final String value); NamedParameterPreparedStatement setInt(SqlParameter parameter, final int value); NamedParameterPreparedStatement setLong(SqlParameter parameter, final long value); NamedParameterPreparedStatement setBinaryStream(SqlParameter parameter, final InputStream value); NamedParameterPreparedStatement setBlob(SqlParameter parameter, final byte[] value); void setMaxRows(Integer maxRows); void setQueryTimeout(Integer queryTimeout); @Override String toString(); }### Answer:
@Test public void testParse() { ParseResult parseResult = NamedParameterPreparedStatement.parse( "SELECT :fee,:fi, :fo(:fum), ':eek' FROM :fum WHERE :fum AND :fo" ); assertThat("Parsed SQL", parseResult.getParsedSql(), equalTo("SELECT ?,?, ?(?), ':eek' FROM ? WHERE ? AND ?")); assertThat("fee", parseResult.getIndexesForParameter("fee"), contains(1)); assertThat("fi", parseResult.getIndexesForParameter("fi"), contains(2)); assertThat("fo", parseResult.getIndexesForParameter("fo"), contains(3, 7)); assertThat("fum", parseResult.getIndexesForParameter("fum"), contains(4, 5, 6)); assertThat("eek", parseResult.getIndexesForParameter("eek"), hasSize(0)); }
|
### Question:
SqlScriptExecutor { public int execute(final Iterable<String> sqlScript) { final Holder<Integer> holder = new Holder<>(-1); doWork(new Work() { @Override public void execute(Connection connection) throws SQLException { holder.set(SqlScriptExecutor.this.executeAndCommit(sqlScript, connection)); } }); return holder.get(); } SqlScriptExecutor(SqlScriptVisitor visitor, DataSource dataSource, SqlDialect sqlDialect); void doWork(Work work); int execute(final Iterable<String> sqlScript); int execute(Iterable<String> sqlScript, Connection connection); int executeAndCommit(Iterable<String> sqlScript, Connection connection); int execute(String sqlStatement, Connection connection); int execute(final String sqlStatement); int execute(String sqlStatement, Connection connection, Iterable<SqlParameter> parameterMetadata, DataValueLookup parameterData); int execute(final String sqlStatement, final Iterable<SqlParameter> parameterMetadata, final DataValueLookup parameterData); QueryBuilder executeQuery(SelectStatement query); QueryBuilder executeQuery(String query); T executeQuery(String sql, ResultSetProcessor<T> processor); T executeQuery(String sql, Connection connection, ResultSetProcessor<T> processor); T executeQuery(SelectStatement query, Iterable<SqlParameter> parameterMetadata,
DataValueLookup parameterData, Connection connection, ResultSetProcessor<T> resultSetProcessor); void executeStatementBatch(String sqlStatement, Iterable<SqlParameter> parameterMetadata, Iterable<? extends DataValueLookup> parameterData, Connection connection, boolean explicitCommit, int statementsPerFlush); }### Answer:
@Test public void testExecute() throws SQLException { when(statement.getUpdateCount()).thenReturn(5).thenReturn(2); int result = sqlScriptExecutor.execute(sqlScripts); assertEquals("Return value", 7, result); }
@Test public void testExecuteFailure() throws Exception { when(statement.execute(sqlScriptOne)).thenThrow(new SQLException()); try { sqlScriptExecutor.execute(sqlScripts); fail("Expected RuntimeSqlException"); } catch (RuntimeSqlException e) { assertTrue("Message", e.getMessage().startsWith("Error executing SQL [" + sqlScriptOne + "]")); assertEquals("Cause", SQLException.class, e.getCause().getClass()); } }
@Test public void testExecuteWithScriptAndConnectionParameters() throws SQLException { when(statement.getUpdateCount()).thenReturn(5).thenReturn(2); int result = sqlScriptExecutor.execute(sqlScripts, connection); assertEquals("Return value", 7, result); }
@Test public void testExecuteWithScriptAndConnectionParamatersFailure() throws Exception { when(statement.execute(sqlScriptOne)).thenThrow(new SQLException()); try { sqlScriptExecutor.execute(sqlScripts, connection); fail("Expected RuntimeSqlException"); } catch (RuntimeSqlException e) { assertTrue("Message", e.getMessage().startsWith("Error executing SQL [" + sqlScriptOne + "]")); assertEquals("Cause", SQLException.class, e.getCause().getClass()); } }
|
### Question:
SqlScriptExecutor { public int executeAndCommit(Iterable<String> sqlScript, Connection connection) { int result = 0; try { visitor.executionStart(); for (String sql : sqlScript) { result += executeInternal(sql, connection); connection.commit(); } visitor.executionEnd(); } catch (SQLException e) { throw reclassifiedRuntimeException(e, "Error with statement"); } return result; } SqlScriptExecutor(SqlScriptVisitor visitor, DataSource dataSource, SqlDialect sqlDialect); void doWork(Work work); int execute(final Iterable<String> sqlScript); int execute(Iterable<String> sqlScript, Connection connection); int executeAndCommit(Iterable<String> sqlScript, Connection connection); int execute(String sqlStatement, Connection connection); int execute(final String sqlStatement); int execute(String sqlStatement, Connection connection, Iterable<SqlParameter> parameterMetadata, DataValueLookup parameterData); int execute(final String sqlStatement, final Iterable<SqlParameter> parameterMetadata, final DataValueLookup parameterData); QueryBuilder executeQuery(SelectStatement query); QueryBuilder executeQuery(String query); T executeQuery(String sql, ResultSetProcessor<T> processor); T executeQuery(String sql, Connection connection, ResultSetProcessor<T> processor); T executeQuery(SelectStatement query, Iterable<SqlParameter> parameterMetadata,
DataValueLookup parameterData, Connection connection, ResultSetProcessor<T> resultSetProcessor); void executeStatementBatch(String sqlStatement, Iterable<SqlParameter> parameterMetadata, Iterable<? extends DataValueLookup> parameterData, Connection connection, boolean explicitCommit, int statementsPerFlush); }### Answer:
@Test public void testExecuteAndCommit() throws SQLException { when(statement.getUpdateCount()).thenReturn(5).thenReturn(2); int result = sqlScriptExecutor.executeAndCommit(sqlScripts, connection); assertEquals("Return value", 7, result); verify(connection, times(sqlScripts.size())).commit(); }
|
### Question:
InsertStatementDefaulter { public InsertStatement defaultMissingFields(InsertStatement statement) { if (statement.isParameterisedInsert()) { return statement; } Set<String> columnsWithValues = getColumnsWithValues(statement); return addColumnDefaults(statement, columnsWithValues); } protected InsertStatementDefaulter(Schema metadata); InsertStatement defaultMissingFields(InsertStatement statement); }### Answer:
@Test public void testInsertDefaultedDecimalValue() { InsertStatementDefaulter defaulter = new InsertStatementDefaulter(schema); InsertStatement statement = insert().into(new TableReference("Car")).values(new FieldLiteral("bob").as("name")).build(); statement = defaulter.defaultMissingFields(statement); assertEquals("Field default size", 3, statement.getFieldDefaults().size()); assertFieldValue("engineCapacity", "0", statement.getFieldDefaults()); }
@Test public void testInsertDefaultedStringValue() { InsertStatementDefaulter defaulter = new InsertStatementDefaulter(schema); InsertStatement statement = insert().into(new TableReference("Car")).values(new FieldLiteral(1.0).as("engineCapacity")).build(); statement = defaulter.defaultMissingFields(statement); assertEquals("Field default size", 3, statement.getFieldDefaults().size()); assertFieldValue("name", "", statement.getFieldDefaults()); }
@Test public void testInsertDefaultedVersion() { InsertStatementDefaulter defaulter = new InsertStatementDefaulter(schema); InsertStatement statement = insert().into(new TableReference("Car")).values(new FieldLiteral("bob").as("name")).build(); statement = defaulter.defaultMissingFields(statement); assertEquals("Field default size", 3, statement.getFieldDefaults().size()); assertFieldValue("version", "0", statement.getFieldDefaults()); }
@Test public void testFrom() { InsertStatementDefaulter defaulter = new InsertStatementDefaulter(schema); InsertStatement statement = insert().into(new TableReference("Test")).from(new TableReference("Other")).build(); statement = defaulter.defaultMissingFields(statement); assertEquals("Field default size", 4, statement.getFieldDefaults().size()); assertFieldValue("dateField", null, statement.getFieldDefaults()); assertFieldValue("booleanField", "false", statement.getFieldDefaults()); assertFieldValue("charField", "", statement.getFieldDefaults()); assertFieldValue("blobField", null, statement.getFieldDefaults()); }
|
### Question:
ResultSetMismatch { @Override public String toString(){ StringBuilder mismatchDetails = new StringBuilder(); if (key.length > 0) { mismatchDetails.append("Row key:").append(Arrays.toString(key)).append(" "); } mismatchDetails.append("Type:[").append(mismatchType) .append("] Column:[").append(mismatchColumnIndex); mismatchDetails.append("] Values:[").append(leftValue) .append(" <> ").append(rightValue).append("]"); return mismatchDetails.toString(); } ResultSetMismatch(MismatchType mismatchType, int mismatchColumnIndex, String leftValue, String rightValue, String... key); String[] getKey(); MismatchType getMismatchType(); int getMismatchColumnIndex(); String getLeftValue(); String getRightValue(); @Override String toString(); }### Answer:
@Test public void testToString(){ String[] keys = {"one", "two", "three"}; ResultSetMismatch unitUnderTest = new ResultSetMismatch(MismatchType.MISSING_LEFT, 3, "left", "rightValue", keys); String expectedString = "Row key:[one, two, three] Type:[MISSING_LEFT] Column:[3] Values:[left <> rightValue]"; assertEquals(expectedString, unitUnderTest.toString()); }
|
### Question:
RemoveColumn implements SchemaChange { @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); boolean foundColumn = false; List<String> columns = new ArrayList<>(); for (Column column : original.columns()) { if (column.getName().equalsIgnoreCase(columnDefinition.getName())) { foundColumn = true; continue; } columns.add(column.getName()); } if (!foundColumn) { throw new IllegalArgumentException("Cannot remove column [" + columnDefinition.getName() + "] as it does not exist on table [" + tableName + "]"); } return new TableOverrideSchema(schema, new AlteredTable(original, columns)); } RemoveColumn(String tableName, Column column); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); Column getColumnDefinition(); String getTableName(); }### Answer:
@Test public void testRemovingColumn() { Schema testSchema = schema(appleTable); Schema updatedSchema = removeColumn.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade column count", 3, resultTable.columns().size()); assertEquals("Post upgrade existing column name", "pips", resultTable.columns().get(2).getName()); }
@Test public void testRemovePrimaryKey() { Schema testSchema = schema(appleTable); RemoveColumn removeIdColumn = new RemoveColumn("Apple", column("id", DataType.BIG_INTEGER).primaryKey()); Schema updatedSchema = removeIdColumn.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade column count", 3, resultTable.columns().size()); }
@Test public void testRemovingNonExistantColumn() { Schema testSchema = schema(appleTable); try { removeColumn = new RemoveColumn("Apple", column("foo", DataType.STRING).nullable()); removeColumn.apply(testSchema); fail("Should fail since column is not there"); } catch (Exception e) { } }
|
### Question:
RemoveColumn implements SchemaChange { @Override public Schema reverse(Schema schema) { Table original = schema.getTable(tableName); List<String> columns = new ArrayList<>(); for (Column column : original.columns()) { columns.add(column.getName()); } columns.add(columnDefinition.getName()); return new TableOverrideSchema(schema, new AlteredTable(original, columns, Arrays.asList(new Column[] {columnDefinition}))); } RemoveColumn(String tableName, Column column); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); Column getColumnDefinition(); String getTableName(); }### Answer:
@Test public void testReverseAddingColumn() { appleTable.columns().remove(3); Schema testSchema = schema(appleTable); Schema downGradedSchema = removeColumn.reverse(testSchema); Table resultTable = downGradedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade column count", 4, resultTable.columns().size()); assertEquals("Post upgrade existing column name", "pips", resultTable.columns().get(2).getName()); assertEquals("Post upgrade existing column name", "colour", resultTable.columns().get(3).getName()); }
|
### Question:
RemoveTable implements SchemaChange { @Override public Schema reverse(Schema schema) { if(schema.tableExists(tableToBeRemoved.getName().toUpperCase())){ throw new IllegalArgumentException("Cannot perform reversal for for [" + tableToBeRemoved.getName() + "] table removal as it already exist."); } return new AugmentedSchema(schema, tableToBeRemoved); } RemoveTable(Table tableToBeRemoved); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); Table getTable(); }### Answer:
@Test public void testReverseRemovingTable() { Schema testSchema = schema(appleTable, mangoTable); testSchema.tables().remove(appleTable); Schema updatedSchema = removeTable.reverse(testSchema); assertEquals("Post upgrade table count", 2, updatedSchema.tables().size()); assertTrue(updatedSchema.tableExists("Apple")); assertTrue(updatedSchema.tableExists("Mango")); }
|
### Question:
RemoveTable implements SchemaChange { @Override public Schema apply(Schema schema) { if(!schema.tableExists(tableToBeRemoved.getName().toUpperCase())){ throw new IllegalArgumentException("Cannot remove table [" + tableToBeRemoved.getName() + "] as it does not exist."); } return new FilteredSchema(schema, tableToBeRemoved.getName()); } RemoveTable(Table tableToBeRemoved); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); Table getTable(); }### Answer:
@Test public void testRemovingNonExistantIndex() { Schema testSchema = schema(appleTable); try { Table table = table("Orange").columns( column("colour", DataType.STRING, 10).nullable(), column("totalValue", DataType.STRING, 10).nullable() ); removeTable = new RemoveTable(table); removeTable.apply(testSchema); fail("Should fail since column is not there"); } catch (Exception e) { } }
|
### Question:
AnalyseTable implements SchemaChange { @Override public Schema apply(Schema schema) { if (!schema.tableExists(tableName.toUpperCase())) { throw new IllegalArgumentException("Cannot analyse table [" + tableName + "] as it does not exist."); } return schema; } AnalyseTable(String tableName); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override Schema reverse(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); String getTableName(); }### Answer:
@Test public void testApplyDoesNotChangeSchema() { Schema testSchema = schema(appleTable); AnalyseTable analyseTable = new AnalyseTable("Apple"); Schema updatedSchema = analyseTable.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade column count", 3, resultTable.columns().size()); assertEquals("Post upgrade column count", testSchema, updatedSchema); }
@Test(expected = IllegalArgumentException.class) public void testAnalyseNonExistentTable() { Schema testSchema = schema(appleTable); AnalyseTable analyseTable = new AnalyseTable("Pear"); analyseTable.apply(testSchema); }
|
### Question:
SpreadsheetDataSetConsumer implements DataSetConsumer { @Override public void table(Table table, Iterable<Record> records) { Integer maxSampleRows = DEFAULT_SAMPLE_ROWS; if (rowsPerTable.isPresent()) { maxSampleRows = rowsPerTable.get().get(table.getName().toUpperCase()); } if (maxSampleRows == null) { log.info("File [" + table.getName() + "] excluded in configuration." ); } else if (tableOutputter.tableHasUnsupportedColumns(table)) { log.info("File [" + table.getName() + "] skipped - unsupported columns." ); } else { log.info("File [" + table.getName() + "] generating..." ); tableOutputter.table(maxSampleRows, workbook, table, records); } } SpreadsheetDataSetConsumer(OutputStream documentOutputStream); SpreadsheetDataSetConsumer(
OutputStream documentOutputStream,
Optional<Map<String, Integer>> rowsPerTable); SpreadsheetDataSetConsumer(
OutputStream documentOutputStream,
Optional<Map<String, Integer>> rowsPerTable,
AdditionalSchemaData additionalSchemaData); SpreadsheetDataSetConsumer(
OutputStream documentOutputStream,
Optional<Map<String, Integer>> rowsPerTable,
TableOutputter tableOutputter); @Override void open(); void createIndex(); @Override void close(CloseState closeState); @Override void table(Table table, Iterable<Record> records); }### Answer:
@Test public void testIgnoreTable() { final MockTableOutputter outputter = new MockTableOutputter(); final SpreadsheetDataSetConsumer consumer = new SpreadsheetDataSetConsumer( mock(OutputStream.class), Optional.<Map<String, Integer>>of(ImmutableMap.of("COMPANY", 5)), outputter ); consumer.table(table("NotCompany"), NO_RECORDS); assertNull("Table not passed through", outputter.tableReceived); }
@Test public void testUnsupportedColumns() { TableOutputter outputter = mock(TableOutputter.class); final SpreadsheetDataSetConsumer consumer = new SpreadsheetDataSetConsumer( mock(OutputStream.class), Optional.<Map<String, Integer>>empty(), outputter ); Table one = table("one"); Table two = table("two"); when(outputter.tableHasUnsupportedColumns(one)).thenReturn(true); when(outputter.tableHasUnsupportedColumns(two)).thenReturn(false); consumer.table(one, NO_RECORDS); consumer.table(two, NO_RECORDS); verify(outputter).table(anyInt(), any(WritableWorkbook.class), eq(two), eq(NO_RECORDS)); verify(outputter, times(0)).table(anyInt(), any(WritableWorkbook.class), eq(one), eq(NO_RECORDS)); }
@Test public void testIncludeTableWithSpecificRowCount() { final MockTableOutputter outputter = new MockTableOutputter(); SpreadsheetDataSetConsumer consumer = new SpreadsheetDataSetConsumer( mock(OutputStream.class), Optional.<Map<String, Integer>>of(ImmutableMap.of("COMPANY", 5)), outputter ); consumer.table(table("Company"), NO_RECORDS); assertEquals("Table passed through for output", "Company", outputter.tableReceived); assertEquals("Number of rows desired", Integer.valueOf(5), outputter.rowCountReceived); }
|
### Question:
UpgradePath implements SqlStatementWriter { public List<String> getSql() { List<String> results = Lists.newLinkedList(); if (!sql.isEmpty() || !upgradeScriptAdditions.isEmpty()) results.addAll(initialisationSql); results.addAll(sql); for (UpgradeScriptAddition addition : upgradeScriptAdditions) { Iterables.addAll(results, addition.sql()); } if (!results.isEmpty()) results.addAll(finalisationSql); return Collections.unmodifiableList(results); } UpgradePath(Set<UpgradeScriptAddition> upgradeScriptAdditions, SqlDialect sqlDialect, List<String> initialisationSql, List<String> finalisationSql); UpgradePath(Set<UpgradeScriptAddition> upgradeScriptAdditions, List<UpgradeStep> steps, SqlDialect sqlDialect, List<String> initialisationSql, List<String> finalisationSql); UpgradePath(UpgradeStatus upgradeStatus); List<UpgradeStep> getSteps(); @Override void writeSql(Collection<String> statements); List<String> getSql(); boolean hasStepsToApply(); boolean upgradeInProgress(); void logUpgradePathSQL(); void logUpgradePathSQL(Log logger); String getUpgradeSqlScript(); }### Answer:
@Test public void testSqlOrderingWhenEmpty() { Set<UpgradeScriptAddition> upgradeScriptAdditions = Collections.emptySet(); UpgradePath path = new UpgradePath(upgradeScriptAdditions, sqlDialect, ImmutableList.of("INIT1", "INIT2"), ImmutableList.of("FIN1", "FIN2")); List<String> sql = path.getSql(); assertEquals("Result", "[]", sql.toString()); }
|
### Question:
UpgradePath implements SqlStatementWriter { private void addCommentsToDropUpgradeStatusTable(final StringBuilder sqlOutput) { String separator = System.getProperty("line.separator"); sqlOutput.append("-- WARNING - This upgrade step creates a temporary table " + UpgradeStatusTableService.UPGRADE_STATUS + "." + separator); sqlOutput.append("-- WARNING - If the upgrade is run automatically, the table will be automatically removed at a later point." + separator); sqlOutput.append("-- WARNING - If this step is being applied manually, the table must be manually removed - to do so, uncomment the following SQL lines." + separator); sqlOutput.append("-- WARNING - Manual removal should not be applied during full deployment of the application to an empty database." + separator); for (String statement : sqlDialect.dropStatements(SchemaUtils.table(UpgradeStatusTableService.UPGRADE_STATUS))) { sqlOutput.append("-- " + statement + separator); } } UpgradePath(Set<UpgradeScriptAddition> upgradeScriptAdditions, SqlDialect sqlDialect, List<String> initialisationSql, List<String> finalisationSql); UpgradePath(Set<UpgradeScriptAddition> upgradeScriptAdditions, List<UpgradeStep> steps, SqlDialect sqlDialect, List<String> initialisationSql, List<String> finalisationSql); UpgradePath(UpgradeStatus upgradeStatus); List<UpgradeStep> getSteps(); @Override void writeSql(Collection<String> statements); List<String> getSql(); boolean hasStepsToApply(); boolean upgradeInProgress(); void logUpgradePathSQL(); void logUpgradePathSQL(Log logger); String getUpgradeSqlScript(); }### Answer:
@Test public void testAddCommentsToDropUpgradeStatusTable() { UpgradePath path = factory.create(ImmutableList.of(mock(UpgradeStep.class)), sqlDialect); path.writeSql(ImmutableList.of("ABC", "DEF")); when(sqlDialect.dropStatements(any(Table.class))).thenReturn(Arrays.asList("FLUSH UPGRADE TABLE","DROP UPGRADE TABLE")); String result = path.getUpgradeSqlScript(); assertTrue("At least one comment is missing.", result.contains("-- WARNING - If the upgrade is run automatically, the table will be automatically removed at a later point.")); assertTrue("At least one comment is missing.", result.contains("-- WARNING - Manual removal should not be applied during full deployment of the application to an empty database.")); assertTrue("Comment to flush table is missing.", result.contains("-- FLUSH UPGRADE TABLE")); assertTrue("Comment to drop table is missing.", result.contains("-- DROP UPGRADE TABLE")); }
|
### Question:
Upgrade { @Inject Upgrade(ConnectionResources connectionResources, DataSource dataSource, UpgradePathFactory factory, UpgradeStatusTableService upgradeStatusTableService) { super(); this.connectionResources = connectionResources; this.dataSource = dataSource; this.factory = factory; this.upgradeStatusTableService = upgradeStatusTableService; } @Inject Upgrade(ConnectionResources connectionResources, DataSource dataSource, UpgradePathFactory factory, UpgradeStatusTableService upgradeStatusTableService); static void performUpgrade(Schema targetSchema, Collection<Class<? extends UpgradeStep>> upgradeSteps, ConnectionResources connectionResources); static UpgradePath createPath(Schema targetSchema, Collection<Class<? extends UpgradeStep>> upgradeSteps, ConnectionResources connectionResources, UpgradeStatusTableService upgradeStatusTableService); UpgradePath findPath(Schema targetSchema, Collection<Class<? extends UpgradeStep>> upgradeSteps, Collection<String> exceptionRegexes); }### Answer:
@Test public void testUpgrade() throws SQLException { Table upgradeAudit = upgradeAudit(); Table car = originalCar(); Table driver = table("Driver") .columns( idColumn(), versionColumn(), column("name", DataType.STRING, 10).nullable(), column("address", DataType.STRING, 10).nullable() ); Table carUpgraded = upgradedCar(); Table driverUpgraded = table("Driver") .columns( idColumn(), versionColumn(), column("name", DataType.STRING, 10).nullable(), column("address", DataType.STRING, 10).nullable(), column("postCode", DataType.STRING, 8).nullable() ); Table excludedTable = table("Drivers"); Table prefixExcludeTable1 = table("EXCLUDE_TABLE1"); Table prefixExcludeTable2 = table("EXCLUDE_TABLE2"); Schema targetSchema = schema(upgradeAudit, carUpgraded, driverUpgraded); Collection<Class<? extends UpgradeStep>> upgradeSteps = new ArrayList<>(); upgradeSteps.add(ChangeCar.class); upgradeSteps.add(ChangeDriver.class); List<Table> tables = Arrays.asList(upgradeAudit, car, driver, excludedTable, prefixExcludeTable1, prefixExcludeTable2); ResultSet viewResultSet = mock(ResultSet.class); when(viewResultSet.next()).thenReturn(false); ResultSet upgradeResultSet = mock(ResultSet.class); when(upgradeResultSet.next()).thenReturn(true, true, false); when(upgradeResultSet.getString(1)).thenReturn("0fde0d93-f57e-405c-81e9-245ef1ba0594", "0fde0d93-f57e-405c-81e9-245ef1ba0595"); when(upgradeResultSet.next()).thenReturn(false); ConnectionResources mockConnectionResources = new MockConnectionResources(). withResultSet("SELECT upgradeUUID FROM UpgradeAudit", upgradeResultSet). withResultSet("SELECT name, hash FROM DeployedViews", viewResultSet). create(); SchemaResource schemaResource = mock(SchemaResource.class); when(mockConnectionResources.openSchemaResource(eq(mockConnectionResources.getDataSource()))).thenReturn(schemaResource); when(schemaResource.tables()).thenReturn(tables); when(upgradeStatusTableService.getStatus(Optional.of(mockConnectionResources.getDataSource()))).thenReturn(NONE); UpgradePath results = new Upgrade(mockConnectionResources, mockConnectionResources.getDataSource(), upgradePathFactory(), upgradeStatusTableService).findPath(targetSchema, upgradeSteps, Lists.newArrayList("^Drivers$", "^EXCLUDE_.*$")); assertEquals("Should be two steps.", 2, results.getSteps().size()); assertEquals("Number of SQL statements", 18, results.getSql().size()); }
|
### Question:
AddColumn implements SchemaChange { @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); List<String> columns = new ArrayList<>(); for (Column column : original.columns()) { if (column.getName().equalsIgnoreCase(newColumnDefinition.getName())) { throw new IllegalStateException("Column [" + newColumnDefinition.getName() + "] is already present on table [" + tableName + "] so cannot be added."); } columns.add(column.getName()); } columns.add(newColumnDefinition.getName()); return new TableOverrideSchema(schema, new AlteredTable(original, columns, Arrays.asList(new Column[] {newColumnDefinition}))); } AddColumn(String tableName, Column column); @Override Schema reverse(Schema metadata); @Override Schema apply(Schema schema); String getTableName(); @Override boolean isApplied(Schema schema, ConnectionResources database); Column getNewColumnDefinition(); @Override void accept(SchemaChangeVisitor visitor); }### Answer:
@Test public void testAddingColumn() { Schema testSchema = schema(appleTable); Schema updatedSchema = addColumn.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade column count", 4, resultTable.columns().size()); assertEquals("Post upgrade existing column name", "pips", resultTable.columns().get(2).getName()); assertEquals("Post upgrade new column name", "colour", resultTable.columns().get(3).getName()); }
|
### Question:
AddColumn implements SchemaChange { @Override public Schema reverse(Schema metadata) { Table original = metadata.getTable(tableName); List<String> columns = new ArrayList<>(); boolean found = false; for (Column column : original.columns()) { if (column.getName().equalsIgnoreCase(newColumnDefinition.getName())) { found = true; } else { columns.add(column.getName()); } } if (!found) { String columnsInTargetTable = original.columns().toString(); throw new IllegalStateException( "Column [" + newColumnDefinition + "] not found in table [" + tableName + "] so it could not be removed.\n" + "Columns in target table [" + tableName + "]:\n" + columnsInTargetTable.replace(",", ",\n") ); } return new TableOverrideSchema(metadata, new AlteredTable(original, columns)); } AddColumn(String tableName, Column column); @Override Schema reverse(Schema metadata); @Override Schema apply(Schema schema); String getTableName(); @Override boolean isApplied(Schema schema, ConnectionResources database); Column getNewColumnDefinition(); @Override void accept(SchemaChangeVisitor visitor); }### Answer:
@Test public void testReverseAddingColumn() { appleTable = table("Apple") .columns( idColumn(), versionColumn(), column("pips", DataType.STRING, 10).nullable(), column("colour", DataType.STRING, 10).nullable() ); Schema testSchema = schema(appleTable); Schema downGradedSchema = addColumn.reverse(testSchema); Table resultTable = downGradedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade column count", 3, resultTable.columns().size()); assertEquals("Post upgrade existing column name", "pips", resultTable.columns().get(2).getName()); }
@Test public void testRemovingNonExistantColumn() { Schema testSchema = schema(appleTable); try { addColumn.reverse(testSchema); fail("Should fail since column is not there"); } catch (Exception e) { } }
|
### Question:
HumanReadableStatementHelper { public static String 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); }### Answer:
@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)); }
|
### Question:
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); }### Answer:
@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"))); }
|
### Question:
HumanReadableStatementHelper { public static String generateAddIndexString(final String tableName, final Index index) { return String.format("Add %s index called %s to %s", generateUniqueIndexString(index), index.getName(), tableName); } static String generateChangePrimaryKeyColumnsString(String tableName, List<String> oldPrimaryKeyColumns, List<String> newPrimaryKeyColumns); static String generateChangePrimaryKeyColumnsString(String tableName, List<String> newPrimaryKeyColumns); static String generateAddColumnString(final String tableName, final Column definition); static String generateAddColumnString(final String tableName, final Column definition, final FieldLiteral defaultValue); static String generateAddIndexString(final String tableName, final Index index); static String generateAddTableString(final Table definition); static String generateAddTableFromString(final Table definition, final SelectStatement selectStatement); static String generateAnalyseTableFromString(String tableName); static String generateRenameTableString(String from, String to); static String generateChangeColumnString(final String tableName, final Column fromDefinition, final Column toDefinition); static String generateChangeIndexString(final String tableName, final Index fromIndex, final Index toIndex); static String generateRenameIndexString(final String tableName, final String fromIndexName, final String toIndexName); static String generateRemoveColumnString(final String tableName, final Column definition); static String generateRemoveIndexString(final String tableName, final Index index); static String generateRemoveTableString(final Table table); static String generateDataUpgradeString(final Statement statement, final String preferredSQLDialect); }### Answer:
@Test public void testAddIndexGeneration() { assertEquals("Should have correct text - Unique", "Add unique index called my_table_1 to my_table", HumanReadableStatementHelper.generateAddIndexString("my_table", index("my_table_1").unique().columns("columnOne", "columnTwo"))); assertEquals("Should have correct text - Unique", "Add non-unique index called my_table_1 to my_table", HumanReadableStatementHelper.generateAddIndexString("my_table", index("my_table_1").columns("columnOne", "columnTwo"))); }
|
### Question:
HumanReadableStatementHelper { public static String 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); }### Answer:
@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))) ); }
|
### Question:
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); }### Answer:
@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"))); }
|
### Question:
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(); }### Answer:
@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(); } }
|
### Question:
HumanReadableStatementHelper { public static String generateRemoveColumnString(final String tableName, final Column definition) { return String.format("Remove column %s from %s", definition.getName(), tableName); } static String generateChangePrimaryKeyColumnsString(String tableName, List<String> oldPrimaryKeyColumns, List<String> newPrimaryKeyColumns); static String generateChangePrimaryKeyColumnsString(String tableName, List<String> newPrimaryKeyColumns); static String generateAddColumnString(final String tableName, final Column definition); static String generateAddColumnString(final String tableName, final Column definition, final FieldLiteral defaultValue); static String generateAddIndexString(final String tableName, final Index index); static String generateAddTableString(final Table definition); static String generateAddTableFromString(final Table definition, final SelectStatement selectStatement); static String generateAnalyseTableFromString(String tableName); static String generateRenameTableString(String from, String to); static String generateChangeColumnString(final String tableName, final Column fromDefinition, final Column toDefinition); static String generateChangeIndexString(final String tableName, final Index fromIndex, final Index toIndex); static String generateRenameIndexString(final String tableName, final String fromIndexName, final String toIndexName); static String generateRemoveColumnString(final String tableName, final Column definition); static String generateRemoveIndexString(final String tableName, final Index index); static String generateRemoveTableString(final Table table); static String generateDataUpgradeString(final Statement statement, final String preferredSQLDialect); }### Answer:
@Test public void testRemoveColumnGeneration() { assertEquals("Should have the correct text - Simple", "Remove column columnOne from my_table", HumanReadableStatementHelper.generateRemoveColumnString("my_table", column("columnOne", DataType.STRING, 10))); }
|
### Question:
HumanReadableStatementHelper { public static String generateRemoveIndexString(final String tableName, final Index index) { return String.format("Remove index %s from %s", index.getName(), tableName); } static String generateChangePrimaryKeyColumnsString(String tableName, List<String> oldPrimaryKeyColumns, List<String> newPrimaryKeyColumns); static String generateChangePrimaryKeyColumnsString(String tableName, List<String> newPrimaryKeyColumns); static String generateAddColumnString(final String tableName, final Column definition); static String generateAddColumnString(final String tableName, final Column definition, final FieldLiteral defaultValue); static String generateAddIndexString(final String tableName, final Index index); static String generateAddTableString(final Table definition); static String generateAddTableFromString(final Table definition, final SelectStatement selectStatement); static String generateAnalyseTableFromString(String tableName); static String generateRenameTableString(String from, String to); static String generateChangeColumnString(final String tableName, final Column fromDefinition, final Column toDefinition); static String generateChangeIndexString(final String tableName, final Index fromIndex, final Index toIndex); static String generateRenameIndexString(final String tableName, final String fromIndexName, final String toIndexName); static String generateRemoveColumnString(final String tableName, final Column definition); static String generateRemoveIndexString(final String tableName, final Index index); static String generateRemoveTableString(final Table table); static String generateDataUpgradeString(final Statement statement, final String preferredSQLDialect); }### Answer:
@Test public void testRemoveIndexGeneration() { assertEquals("Should have the correct text - Simple", "Remove index my_table_1 from my_table", HumanReadableStatementHelper.generateRemoveIndexString("my_table", index("my_table_1").unique().columns("columnOne", "columnTwo"))); }
|
### Question:
HumanReadableStatementHelper { public static String generateRemoveTableString(final Table table) { return String.format("Remove table %s", table.getName()); } static String generateChangePrimaryKeyColumnsString(String tableName, List<String> oldPrimaryKeyColumns, List<String> newPrimaryKeyColumns); static String generateChangePrimaryKeyColumnsString(String tableName, List<String> newPrimaryKeyColumns); static String generateAddColumnString(final String tableName, final Column definition); static String generateAddColumnString(final String tableName, final Column definition, final FieldLiteral defaultValue); static String generateAddIndexString(final String tableName, final Index index); static String generateAddTableString(final Table definition); static String generateAddTableFromString(final Table definition, final SelectStatement selectStatement); static String generateAnalyseTableFromString(String tableName); static String generateRenameTableString(String from, String to); static String generateChangeColumnString(final String tableName, final Column fromDefinition, final Column toDefinition); static String generateChangeIndexString(final String tableName, final Index fromIndex, final Index toIndex); static String generateRenameIndexString(final String tableName, final String fromIndexName, final String toIndexName); static String generateRemoveColumnString(final String tableName, final Column definition); static String generateRemoveIndexString(final String tableName, final Index index); static String generateRemoveTableString(final Table table); static String generateDataUpgradeString(final Statement statement, final String preferredSQLDialect); }### Answer:
@Test public void testRemoveTableGeneration() { assertEquals("Should have the correct text - Simple", "Remove table my_table", HumanReadableStatementHelper.generateRemoveTableString(table("my_table"))); }
|
### Question:
HumanReadableStatementHelper { public static String generateRenameTableString(String from, String to) { StringBuilder renameTableBuilder = new StringBuilder(); renameTableBuilder.append(String.format("Rename table %s to %s", from, to)); return renameTableBuilder.toString(); } static String generateChangePrimaryKeyColumnsString(String tableName, List<String> oldPrimaryKeyColumns, List<String> newPrimaryKeyColumns); static String generateChangePrimaryKeyColumnsString(String tableName, List<String> newPrimaryKeyColumns); static String generateAddColumnString(final String tableName, final Column definition); static String generateAddColumnString(final String tableName, final Column definition, final FieldLiteral defaultValue); static String generateAddIndexString(final String tableName, final Index index); static String generateAddTableString(final Table definition); static String generateAddTableFromString(final Table definition, final SelectStatement selectStatement); static String generateAnalyseTableFromString(String tableName); static String generateRenameTableString(String from, String to); static String generateChangeColumnString(final String tableName, final Column fromDefinition, final Column toDefinition); static String generateChangeIndexString(final String tableName, final Index fromIndex, final Index toIndex); static String generateRenameIndexString(final String tableName, final String fromIndexName, final String toIndexName); static String generateRemoveColumnString(final String tableName, final Column definition); static String generateRemoveIndexString(final String tableName, final Index index); static String generateRemoveTableString(final Table table); static String generateDataUpgradeString(final Statement statement, final String preferredSQLDialect); }### Answer:
@Test public void testRenameTableGeneration() { assertEquals("Should have the correct text - Simple", "Rename table my_table to your_table", HumanReadableStatementHelper.generateRenameTableString("my_table", "your_table")); }
|
### Question:
HumanReadableStatementHelper { public static String generateRenameIndexString(final String tableName, final String fromIndexName, final String toIndexName) { return String.format("Rename index %s on %s to %s", fromIndexName, tableName, toIndexName); } static String generateChangePrimaryKeyColumnsString(String tableName, List<String> oldPrimaryKeyColumns, List<String> newPrimaryKeyColumns); static String generateChangePrimaryKeyColumnsString(String tableName, List<String> newPrimaryKeyColumns); static String generateAddColumnString(final String tableName, final Column definition); static String generateAddColumnString(final String tableName, final Column definition, final FieldLiteral defaultValue); static String generateAddIndexString(final String tableName, final Index index); static String generateAddTableString(final Table definition); static String generateAddTableFromString(final Table definition, final SelectStatement selectStatement); static String generateAnalyseTableFromString(String tableName); static String generateRenameTableString(String from, String to); static String generateChangeColumnString(final String tableName, final Column fromDefinition, final Column toDefinition); static String generateChangeIndexString(final String tableName, final Index fromIndex, final Index toIndex); static String generateRenameIndexString(final String tableName, final String fromIndexName, final String toIndexName); static String generateRemoveColumnString(final String tableName, final Column definition); static String generateRemoveIndexString(final String tableName, final Index index); static String generateRemoveTableString(final Table table); static String generateDataUpgradeString(final Statement statement, final String preferredSQLDialect); }### Answer:
@Test public void testRenameIndexGeneration() { assertEquals("Should have the correct text - Simple", "Rename index SomeBadlyNamedTable_1 on SomeBadlyNamedTable to ABetterNamedTable_1", HumanReadableStatementHelper.generateRenameIndexString("SomeBadlyNamedTable", "SomeBadlyNamedTable_1", "ABetterNamedTable_1")); }
|
### Question:
OracleMetaDataProvider implements Schema { @Override public Collection<String> tableNames() { return tableMap().keySet(); } OracleMetaDataProvider(Connection connection, String schemaName); @Override boolean isEmptyDatabase(); @Override boolean tableExists(String name); @Override Table getTable(String name); @Override Collection<String> tableNames(); @Override Collection<Table> tables(); @Override boolean viewExists(String name); @Override View getView(String name); @Override Collection<String> viewNames(); @Override Collection<View> views(); }### Answer:
@Test public void testIgnoreSystemTables() throws SQLException { final PreparedStatement statement = mock(PreparedStatement.class, RETURNS_SMART_NULLS); when(connection.prepareStatement(anyString())).thenReturn(statement); when(statement.executeQuery()).thenAnswer(new ReturnTablesMockResultSet(1)).thenAnswer(new ReturnTablesMockResultSet(8)); final Schema oracleMetaDataProvider = oracle.openSchema(connection, "TESTDATABASE", "TESTSCHEMA"); assertEquals("Table names", "[AREALTABLE]", oracleMetaDataProvider.tableNames().toString()); assertFalse("Table names", oracleMetaDataProvider.tableNames().toString().contains("DBMS")); }
|
### Question:
RemoveIndex implements SchemaChange { @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); boolean foundIndex = false; List<String> indexes = new ArrayList<>(); for (Index index : original.indexes()) { if (index.getName().equalsIgnoreCase(indexToBeRemoved.getName())) { foundIndex = true; continue; } indexes.add(index.getName()); } if (!foundIndex) { throw new IllegalArgumentException("Cannot remove index [" + indexToBeRemoved.getName() + "] as it does not exist on table [" + tableName + "]"); } return new TableOverrideSchema(schema, new AlteredTable(original, null, null, indexes, null)); } RemoveIndex(String tableName, Index index); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); String getTableName(); Index getIndexToBeRemoved(); }### Answer:
@Test public void testRemovingIndex() { Schema testSchema = schema(appleTable); assertEquals("Pre upgrade index count", 1, testSchema.getTable("Apple").indexes().size()); Schema updatedSchema = removeIndex.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade index count", 0, resultTable.indexes().size()); }
@Test public void testRemovingNonExistantIndex() { Schema testSchema = schema(appleTable); try { removeIndex = new RemoveIndex("Apple", index("foo").unique().columns("bar")); removeIndex.apply(testSchema); fail("Should fail since column is not there"); } catch (Exception e) { } }
|
### Question:
RemoveIndex implements SchemaChange { @Override public Schema reverse(Schema schema) { Table original = schema.getTable(tableName); List<String> indexes = new ArrayList<>(); for (Index index : original.indexes()) { indexes.add(index.getName()); } indexes.add(indexToBeRemoved.getName()); return new TableOverrideSchema(schema, new AlteredTable(original, null, null, indexes, Arrays.asList(new Index[] {indexToBeRemoved}))); } RemoveIndex(String tableName, Index index); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); String getTableName(); Index getIndexToBeRemoved(); }### Answer:
@Test public void testReverseRemovingIndex() { appleTable.indexes().remove(0); Schema testSchema = schema(appleTable); Schema downGradedSchema = removeIndex.reverse(testSchema); Table resultTable = downGradedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade index count", 1, resultTable.indexes().size()); }
|
### Question:
RenameTable implements SchemaChange { public RenameTable(String oldTableName, String newTableName) { this.oldTableName = oldTableName; this.newTableName = newTableName; } RenameTable(String oldTableName, String newTableName); String getOldTableName(); String getNewTableName(); @Override Schema apply(Schema schema); @Override Schema reverse(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override void accept(SchemaChangeVisitor visitor); }### Answer:
@Test public void testRenameTable() { Schema testSchema = schema(appleTable); RenameTable renameTable = new RenameTable("Apple", "Pear"); Schema updatedSchema = renameTable.apply(testSchema); assertTrue("Rename should be applied", renameTable.isApplied(updatedSchema, MockConnectionResources.build())); Table resultTable = updatedSchema.getTable("Pear"); assertNotNull(resultTable); }
|
### Question:
ByteArraySchema implements DeserializationSchema<byte[]>, SerializationSchema<byte[]> { @Override public TypeInformation<byte[]> getProducedType() { return PrimitiveArrayTypeInfo.BYTE_PRIMITIVE_ARRAY_TYPE_INFO; } @Override byte[] deserialize(byte[] message); @Override boolean isEndOfStream(byte[] nextElement); @Override byte[] serialize(byte[] element); @Override TypeInformation<byte[]> getProducedType(); }### Answer:
@Test public void testSerializability() throws Exception { final ByteArraySchema schema = new ByteArraySchema(); final ByteArraySchema copy = CommonTestUtils.createCopySerializable(schema); assertEquals(schema.getProducedType(), copy.getProducedType()); }
|
### Question:
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(); }### Answer:
@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()); }
|
### Question:
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); }### Answer:
@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))); }
|
### Question:
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(); }### Answer:
@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); }
|
### Question:
GeneralUtils { public static Locale getDefaultLocale(User user) { if (user != null && user.getUserProperties() != null && user.getUserProperties().containsKey(OpenmrsConstants.USER_PROPERTY_DEFAULT_LOCALE)) { String localeString = user.getUserProperty(OpenmrsConstants.USER_PROPERTY_DEFAULT_LOCALE); Locale locale = normalizeLocale(localeString); return locale; } return null; } static Locale getDefaultLocale(User user); static Locale normalizeLocale(String localeString); static PatientIdentifierType getPatientIdentifierType(String id); static PatientIdentifierType getPatientIdentifierType(String id, PatientService patientService); static boolean isValidUuidFormat(String uuid); static String getPersonAddressProperty(PersonAddress address, String property); static PatientIdentifier getPatientIdentifier(Patient patient, PatientIdentifierType patientIdentifierType, Location location); static boolean setPropertyIfDifferent(Object bean, String propertyName, Object newValue); static List<Patient> getLastViewedPatients(User user); static Date getCurrentDateIfNull(Date date); }### Answer:
@Test public void shouldGetDefaultLocaleForUser() { User user = new User(); user.setUserProperty(OpenmrsConstants.USER_PROPERTY_DEFAULT_LOCALE, "ht"); Assert.assertEquals("ht", GeneralUtils.getDefaultLocale(user).toString()); }
|
### Question:
GeneralUtils { public static boolean setPropertyIfDifferent(Object bean, String propertyName, Object newValue) { try { Object currentValue = PropertyUtils.getProperty(bean, propertyName); if (OpenmrsUtil.nullSafeEquals(currentValue, newValue)) { return false; } else { PropertyUtils.setProperty(bean, propertyName, newValue); return true; } } catch (Exception ex) { throw new RuntimeException(ex); } } static Locale getDefaultLocale(User user); static Locale normalizeLocale(String localeString); static PatientIdentifierType getPatientIdentifierType(String id); static PatientIdentifierType getPatientIdentifierType(String id, PatientService patientService); static boolean isValidUuidFormat(String uuid); static String getPersonAddressProperty(PersonAddress address, String property); static PatientIdentifier getPatientIdentifier(Patient patient, PatientIdentifierType patientIdentifierType, Location location); static boolean setPropertyIfDifferent(Object bean, String propertyName, Object newValue); static List<Patient> getLastViewedPatients(User user); static Date getCurrentDateIfNull(Date date); }### Answer:
@Test public void setPropertyIfDifferent_shouldChangePropertyWhenDifferent() throws Exception { Date date = new Date(); Patient p = new Patient(); boolean changed = GeneralUtils.setPropertyIfDifferent(p, "birthdate", date); assertThat(changed, is(true)); assertThat(p.getBirthdate(), is(date)); }
@Test public void setPropertyIfDifferent_shouldNotChangePropertyWhenAlreadySet() throws Exception { Date date = new Date(); Patient p = new Patient(); p.setBirthdate(date); boolean changed = GeneralUtils.setPropertyIfDifferent(p, "birthdate", date); assertThat(changed, is(false)); assertThat(p.getBirthdate(), is(date)); }
|
### Question:
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); }### Answer:
@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); }
|
### Question:
DateMapper { public Date convertUTCToDate(String date) { if (!StringUtils.isBlank(date)) { try { DateFormat utcFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"); utcFormat.setTimeZone(TimeZone.getTimeZone("UTC")); return utcFormat.parse(date); } catch (ParseException e) { throw new RuntimeException("Date format needs to be in UTC format. Incorrect Date:" + date + ".", e); } } return null; } Date convertUTCToDate(String date); }### Answer:
@Test public void shouldConvertUTCformatToDate() throws Exception { String utcDateString = "2015-07-30T18:30:00.000Z"; SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd"); simpleDateFormat.setTimeZone(TimeZone.getTimeZone("IST")); Date actualDate = new DateMapper().convertUTCToDate(utcDateString); assertNotNull(actualDate); assertEquals("2015-07-31", simpleDateFormat.format(actualDate)); }
@Test(expected = RuntimeException.class) public void shouldThrowExceptionForWrongUTCformat() throws Exception { String utcDateString = "2015-07-30T11:00:00.000"; Date actualDate = new DateMapper().convertUTCToDate(utcDateString); }
|
### Question:
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); }### Answer:
@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); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.