src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
BasicHttpClient extends AbstractHttpClient { public JSONObject Get(URL targetUrl) throws Exception { return Get(targetUrl.toURI()); } BasicHttpClient(URL url, String userName, String password); BasicHttpClient(URL url, String userName, String password, Map<String, String> config); void auth(HttpRequest req); @Override CloseableHttpResponse execute(HttpUriRequest req); JSONObject put(URL targetUrl, String data); JSONObject put(URL targetUrl, String data, String accessKey, String value); void setHeader(HttpPut httpput); void addHeader(HttpGet httpGet, String Key, String Value); void setPutEntity(String xmlstr, HttpPut httpput); JSONObject post(URL targetUrl, String payload); JSONObject post(URL targetUrl, File toUplod, String key, String value); JSONObject post(URL targetUrl, File toUplod); JSONObject put(URL targetUrl, File toUplod); JSONObject post(URL targetUrl, List<NameValuePair> parameters); JSONObject post(URL targetUrl, String data, File toUplod); void setHeader(HttpPost httppost); @Override HttpResponse doPost(HttpPost httpPost); HttpResponse doPost(HttpPost httpPost, String key, String value); void setPostEntity(File toUplod, HttpPost httppost); void setPutEntity(File toUplod, HttpPut httpput); void setPostEntityJ(File toUplod, HttpPost httppost); void setPostEntity(String data, File file, HttpPost httppost); void setPostEntity(String jsonStr, HttpPost httppost); void setPostEntity(List<NameValuePair> params, HttpPost httppost); JSONObject patch(URL targetUrl, String payload); void setHeader(HttpPatch httppatch); void setPatchEntity(String jsonStr, HttpPatch httppatch); JSONObject Get(URL targetUrl); JSONObject Get(URL targetUrl, String key, String val); JSONObject Get(URL targetUrl, String key, String val, String empty); JSONObject Get(URL targetUrl, boolean isJwtToken, String key, String val ); JSONObject Get(URL targetUrl, String jsonStr); void setHeader(HttpGet httpGet); final URL url; } | @Test(enabled = false,description = "http-get of remote address") public void testGetHttp() throws Exception { System.out.println("Get-http"); URL targetUrl = new URL("http: BasicHttpClient instance = new BasicHttpClient(targetUrl, "anon", "anon"); JSONObject result = instance.Get(targetUrl, getArgs.toJSONString()); assertEquals(result.get("args"), getArgs); }
@Test(enabled = false,description = "https-get of remote address") public void testGetHttps() throws Exception { System.out.println("Get-https"); URL targetUrl = new URL("https: BasicHttpClient instance = new BasicHttpClient(targetUrl, "anon", "anon"); JSONObject result = instance.Get(targetUrl, getArgs.toJSONString()); assertEquals(result.get("args"), getArgs); }
@Test(enabled = false,description = "http-get of local address") public void testGetHttpLocal() throws Exception { System.out.println("Get-http-local"); URL targetUrl = new URL("http: BasicHttpClient instance = new BasicHttpClient(targetUrl, "anon", "anon"); JSONObject result = instance.Get(targetUrl, "data", "vola"); assertEquals(result.toString(), "{\"data\":\"vola\"}"); } |
DriverSettings extends AbstractPropSettings { public String getChromeDriverPath() { return getProperty("ChromeDriverPath", chromeDriverPath); } DriverSettings(String location); void setFirefoxBinaryPath(String path); void setGeckcoDriverPath(String path); void setChromeDriverPath(String path); void setIEDriverPath(String path); void setEdgeDriverPath(String path); String getFirefoxBinaryPath(); String getGeckcoDriverPath(); String getChromeDriverPath(); String getIEDriverPath(); String getEdgeDriverPath(); Boolean useProxy(); } | @Test public void testGetChromeDriverPath() { String expResult; if (isWin) { expResult = "./lib/Drivers/chromedriver.exe"; } else { expResult = "./lib/Drivers/chromedriver"; } String result = ds.getChromeDriverPath(); assertEquals(result, expResult); } |
JIRAClient { public boolean isConnected() { try { DLogger.Log(client.Get(new URL(client.url + PROJECT)).toString()); return true; } catch (Exception ex) { LOG.log(Level.SEVERE, ex.getMessage(), ex); return false; } } JIRAClient(String urlStr, String userName, String password, Map options); int updateResult(int status, String tc, String ts, String rc,
String proj); void updateResult(int status, int eid); String addAttachment(int eid, File attachment); @SuppressWarnings("unchecked") JSONObject createIssue(JSONObject issue, List<File> attachments); @SuppressWarnings("unchecked") static JSONObject getJsonified(LinkedHashMap<String, String> dataMap); boolean containsProject(String project); boolean isConnected(); static final String ISSUE; } | @Test(enabled = false) public void testConnection() throws MalformedURLException { JIRASync sync = new JIRASync(Data.server, Data.uname, Data.pass, Data.project); Assert.assertTrue(sync.isConnected()); } |
JIRAClient { @SuppressWarnings("unchecked") public JSONObject createIssue(JSONObject issue, List<File> attachments) { JSONObject res = null; try { res = client.post(new URL(client.url + ISSUE), issue.toString()); String restAttach = ISSUE_ATTACHMENTS.replace("issuekey", (String) res.get("id")); if (attachments != null && !attachments.isEmpty()) { List<JSONObject> attchRes = new ArrayList<>(); res.put("Attachments", attchRes); for (File f : attachments) { attchRes.add(client.post(new URL(client.url + restAttach), f)); } } else { LOG.log(Level.INFO, "no attachments to upload"); } LOG.log(Level.INFO, "issue response {0}", res.toString()); } catch (Exception ex) { LOG.log(Level.SEVERE, ex.getMessage(), ex); } return res; } JIRAClient(String urlStr, String userName, String password, Map options); int updateResult(int status, String tc, String ts, String rc,
String proj); void updateResult(int status, int eid); String addAttachment(int eid, File attachment); @SuppressWarnings("unchecked") JSONObject createIssue(JSONObject issue, List<File> attachments); @SuppressWarnings("unchecked") static JSONObject getJsonified(LinkedHashMap<String, String> dataMap); boolean containsProject(String project); boolean isConnected(); static final String ISSUE; } | @Test(enabled = false) public void testCreateIssue_JSONObject_List() throws MalformedURLException { JSONObject res = null; JIRAClient jc = new JIRAClient(Data.server, Data.uname, Data.pass, null); Map issue = getIssue(Data.project); List<File> attach = null; res = jc.createIssue((JSONObject) issue, attach); } |
DriverSettings extends AbstractPropSettings { public String getIEDriverPath() { return getProperty("IEDriverPath", "./lib/Drivers/IEDriverServer.exe"); } DriverSettings(String location); void setFirefoxBinaryPath(String path); void setGeckcoDriverPath(String path); void setChromeDriverPath(String path); void setIEDriverPath(String path); void setEdgeDriverPath(String path); String getFirefoxBinaryPath(); String getGeckcoDriverPath(); String getChromeDriverPath(); String getIEDriverPath(); String getEdgeDriverPath(); Boolean useProxy(); } | @Test public void testGetIEDriverPath() { String expResult = "./lib/Drivers/IEDriverServer.exe"; String result = ds.getIEDriverPath(); assertEquals(result, expResult); } |
DriverSettings extends AbstractPropSettings { public String getEdgeDriverPath() { return getProperty("EdgeDriverPath", "./lib/Drivers/MicrosoftWebDriver.exe"); } DriverSettings(String location); void setFirefoxBinaryPath(String path); void setGeckcoDriverPath(String path); void setChromeDriverPath(String path); void setIEDriverPath(String path); void setEdgeDriverPath(String path); String getFirefoxBinaryPath(); String getGeckcoDriverPath(); String getChromeDriverPath(); String getIEDriverPath(); String getEdgeDriverPath(); Boolean useProxy(); } | @Test public void testGetEdgeDriverPath() { String expResult = "./lib/Drivers/MicrosoftWebDriver.exe"; String result = ds.getEdgeDriverPath(); assertEquals(result, expResult); } |
DriverSettings extends AbstractPropSettings { public void setGeckcoDriverPath(String path) { setProperty("GeckoDriverPath", path); } DriverSettings(String location); void setFirefoxBinaryPath(String path); void setGeckcoDriverPath(String path); void setChromeDriverPath(String path); void setIEDriverPath(String path); void setEdgeDriverPath(String path); String getFirefoxBinaryPath(); String getGeckcoDriverPath(); String getChromeDriverPath(); String getIEDriverPath(); String getEdgeDriverPath(); Boolean useProxy(); } | @Test public void testSetGeckcoDriverPath() { String path = "./lib/gk"; ds.setGeckcoDriverPath(path); assertEquals(ds.getGeckcoDriverPath(), path); } |
DriverSettings extends AbstractPropSettings { public void setChromeDriverPath(String path) { setProperty("ChromeDriverPath", path); } DriverSettings(String location); void setFirefoxBinaryPath(String path); void setGeckcoDriverPath(String path); void setChromeDriverPath(String path); void setIEDriverPath(String path); void setEdgeDriverPath(String path); String getFirefoxBinaryPath(); String getGeckcoDriverPath(); String getChromeDriverPath(); String getIEDriverPath(); String getEdgeDriverPath(); Boolean useProxy(); } | @Test public void testSetChromeDriverPath() { String path = "./lib/chrome"; ds.setChromeDriverPath(path); assertEquals(ds.getChromeDriverPath(), path); } |
DriverSettings extends AbstractPropSettings { public void setIEDriverPath(String path) { setProperty("IEDriverPath", path); } DriverSettings(String location); void setFirefoxBinaryPath(String path); void setGeckcoDriverPath(String path); void setChromeDriverPath(String path); void setIEDriverPath(String path); void setEdgeDriverPath(String path); String getFirefoxBinaryPath(); String getGeckcoDriverPath(); String getChromeDriverPath(); String getIEDriverPath(); String getEdgeDriverPath(); Boolean useProxy(); } | @Test public void testSetIEDriverPath() { String path = "./lib/ie"; ds.setIEDriverPath(path); assertEquals(ds.getIEDriverPath(), path); } |
DriverSettings extends AbstractPropSettings { public void setEdgeDriverPath(String path) { setProperty("EdgeDriverPath", path); } DriverSettings(String location); void setFirefoxBinaryPath(String path); void setGeckcoDriverPath(String path); void setChromeDriverPath(String path); void setIEDriverPath(String path); void setEdgeDriverPath(String path); String getFirefoxBinaryPath(); String getGeckcoDriverPath(); String getChromeDriverPath(); String getIEDriverPath(); String getEdgeDriverPath(); Boolean useProxy(); } | @Test public void testSetEdgeDriverPath() { String path = "./lib/edge"; ds.setEdgeDriverPath(path); assertEquals(ds.getEdgeDriverPath(), path); } |
FParser { public static List<String> getFuncList() { return FUNCTIONS; } static List<String> getFuncList(); static Object eval(String s); static String evaljs(String script); static List<String> FUNCTIONS; } | @Test public void testGetFuncList() { System.out.println("getFuncList"); String[] vals = {"Concat", "Random", "Round", "Pow", "Min", "Max", "Date"}; List<String> expResult = Arrays.asList(vals); Collections.sort(expResult); List<String> result = FParser.getFuncList(); Collections.sort(result); assertEquals(expResult.toString(), result.toString()); } |
RedisAppender implements Appender { public RedisThrottlerJmxBean getJmxBean() { return throttler.getJmxBean(); } private RedisAppender(Builder builder); Configuration getConfig(); @Override String getName(); @Override Layout<? extends Serializable> getLayout(); @Override boolean ignoreExceptions(); @Override ErrorHandler getHandler(); @Override void setHandler(ErrorHandler errorHandler); @Override State getState(); RedisThrottlerJmxBean getJmxBean(); @Override void append(LogEvent event); @Override void initialize(); @Override void start(); @Override synchronized void stop(); @Override boolean isStarted(); @Override boolean isStopped(); @Override String toString(); @PluginBuilderFactory static Builder newBuilder(); } | @Test public void test_messages_are_enqueued_to_redis() throws InterruptedException { LOGGER.debug("creating the logger"); Logger logger = LOGGER_CONTEXT_RESOURCE .getLoggerContext() .getLogger(RedisAppenderTest.class.getCanonicalName()); int expectedMessageCount = MIN_MESSAGE_COUNT + RANDOM.nextInt(MAX_MESSAGE_COUNT - MIN_MESSAGE_COUNT); LOGGER.debug("logging %d messages", expectedMessageCount); LogMessage[] expectedLogMessages = LogMessage.createRandomArray(expectedMessageCount); for (LogMessage expectedLogMessage : expectedLogMessages) { logger.log(expectedLogMessage.level, expectedLogMessage.message); } LOGGER.debug("waiting for throttler to kick in"); Thread.sleep(1_000); LOGGER.debug("checking logged messages"); Jedis redisClient = REDIS_CLIENT_RESOURCE.getClient(); for (int messageIndex = 0; messageIndex < expectedMessageCount; messageIndex++) { LogMessage expectedLogMessage = expectedLogMessages[messageIndex]; String expectedSerializedMessage = String.format( "%s %s", expectedLogMessage.level, expectedLogMessage.message); String actualSerializedMessage = redisClient.lpop(RedisAppenderTestConfig.REDIS_KEY); try { assertThat(actualSerializedMessage).isEqualTo(expectedSerializedMessage); } catch (ComparisonFailure comparisonFailure) { String message = String.format( "comparison failure (messageIndex=%d, messageCount=%d)", messageIndex, expectedMessageCount); throw new RuntimeException(message, comparisonFailure); } } Appender appender = LOGGER_CONTEXT_RESOURCE .getLoggerContext() .getConfiguration() .getAppender(RedisAppenderTestConfig.LOG4J2_APPENDER_NAME); assertThat(appender).isInstanceOf(RedisAppender.class); RedisThrottlerJmxBean jmxBean = ((RedisAppender) appender).getJmxBean(); assertThat(jmxBean.getTotalEventCount()).isEqualTo(expectedMessageCount); assertThat(jmxBean.getIgnoredEventCount()).isEqualTo(0); assertThat(jmxBean.getEventRateLimitFailureCount()).isEqualTo(0); assertThat(jmxBean.getByteRateLimitFailureCount()).isEqualTo(0); assertThat(jmxBean.getUnavailableBufferSpaceFailureCount()).isEqualTo(0); assertThat(jmxBean.getRedisPushSuccessCount()).isEqualTo(expectedMessageCount); assertThat(jmxBean.getRedisPushFailureCount()).isEqualTo(0); } |
KeyLockManager { public static KeyLock getKeyLock(String type) { return keyLockMap.get(type); } 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; } | @Test public void testGetKeyLock() { KeyLock keylock = KeyLockManager.getKeyLock(TEST1); assertEquals(true, keylock != null); }
@Test public void testLockPartOneKey() { boolean isKeyLockException = false; KeyLock keyLock = KeyLockManager.getKeyLock(TEST1); String lockKey = "111"; boolean result = false; try { keyLock.lock(lockKey); result = true; } catch (KeyLockException e) { isKeyLockException = true; } catch (Exception e) { } finally { if (!isKeyLockException) { keyLock.unlock(lockKey); } else { } } assertEquals(true, result); }
@Test public void testLockPartTwoKey() { boolean isKeyLockException = false; KeyLock keyLock = KeyLockManager.getKeyLock(TEST1); String lockKey1 = "11"; String lockKey2 = "22"; boolean result = false; try { keyLock.lock(lockKey1, lockKey2); result = true; } catch (KeyLockException e) { isKeyLockException = true; } catch (Exception e) { } finally { if (!isKeyLockException) { keyLock.unlock(lockKey1, lockKey2); } else { } } assertEquals(true, result); } |
MsgManager { public static boolean addMsgListener(IMsgListener msgListener) throws Exception { Map<String, String> msgs = msgListener.getMsgs(); if (msgs != null) { Object[] msgKeyArray = msgs.keySet().toArray(); for (int i = 0; i < msgKeyArray.length; i++) { String msg = String.valueOf(msgKeyArray[i]); Method method = msgListener.getClass().getMethod(msgs.get(msg), new Class[] { MsgPacket.class }); if (msg == null || msg.equals("")) { if (MsgManager.log != null) { MsgManager.log.warn("消息类型为空，无法注册"); } continue; } ArrayList<Method> methodList = msgListenerMap.get(msg); if (methodList == null) { methodList = new ArrayList<Method>(); msgListenerMap.put(msg, methodList); } if (!methodList.contains(method)) { methodList.add(method); } else { if (MsgManager.log != null) { MsgManager.log.warn("IMsgListener：" + method.getClass().getName() + "注册多遍，请及时处理"); } } if (!msgInstanceMap.containsKey(method)) { msgInstanceMap.put(method, msgListener); } else { if (MsgManager.log != null) { MsgManager.log.warn(method.getName() + "已经被实例化注册过，请及时处理"); } } msgClassInstanceMap.put(msgListener.getClass(), msgListener); } return true; } else { if (MsgManager.log != null) { MsgManager.log.warn("IMsgListener：" + msgListener.getClass().getName() + "监控数据为空"); } return false; } } static void init(boolean useMsgMonitor, ILog log); static boolean addMsgListener(IMsgListener msgListener); static boolean dispatchMsg(String msgOpCode, Object data, Object otherData); static boolean handleMsg(MsgPacket msgPacket); static Map<String, ArrayList<Method>> msgListenerMap; static Map<Class<?>, Object> msgClassInstanceMap; static boolean USE_MSG_MONITOR; static ILog log; static Method method; } | @Test public void testAddMsgListener() throws Exception { TestMsgListener testMsgListener = new TestMsgListener(); boolean result = MsgManager.addMsgListener(testMsgListener); MsgManager.dispatchMsg("createuser", 111, 222); assertEquals(true, result); } |
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(); } | @Test public void testPutMonitor() { runMonitor.putMonitor("链接"); runMonitor.putMonitor("发送"); runMonitor.putMonitor("断开"); } |
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; } | @Test public void testAddMapping() throws InterruptedException { ThreadMsgManager.dispatchThreadMsg("createuser", 111, 222); ThreadMsgManager.dispatchThreadMsg("updateuser", 111, 222); Thread.sleep(1000); } |
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; } | @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); } |
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(); } | @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); } |
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(); } | @Test public void testAddCycle() { CycleTest cycleTest = new CycleTest(); cycleTest.name = "testAddCycle"; boolean result = AsyncThreadManager.addCycle(cycleTest, 1, 1); assertEquals(true, result); } |
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(); } | @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); } |
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(); } | @Test public void testGetRandomThreadPriority() { int[] threadPriority = AsyncThreadManager.getRandomThreadPriority(); assertEquals(true, threadPriority != null); } |
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(); } | @Test public void testGetRandomThread() { int[] threadPriority = AsyncThreadManager.getRandomThread(); assertEquals(true, threadPriority != null); } |
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); } | @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")); } |
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(); } | @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()); } |
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); } | @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")); } |
UpgradePathFinder { public SchemaChangeSequence determinePath(Schema current, Schema target, Collection<String> exceptionRegexes) throws NoUpgradePathExistsException { SchemaChangeSequence schemaChangeSequence = getSchemaChangeSequence(); Schema trialUpgradedSchema = schemaChangeSequence.applyToSchema(current); if (!schemasMatch(target, trialUpgradedSchema, "target domain schema", "trial upgraded schema", exceptionRegexes)) { throw new NoUpgradePathExistsException(); } Schema reversal = schemaChangeSequence.applyInReverseToSchema(trialUpgradedSchema); if (!schemasMatch(reversal, current, "upgraded schema reversal", "current schema", exceptionRegexes)) { throw new IllegalStateException("Upgrade reversals are invalid"); } return schemaChangeSequence; } UpgradePathFinder(Collection<Class<? extends UpgradeStep>> availableUpgradeSteps, Set<java.util.UUID> stepsAlreadyApplied); boolean hasStepsToApply(); SchemaChangeSequence getSchemaChangeSequence(); SchemaChangeSequence determinePath(Schema current, Schema target, Collection<String> exceptionRegexes); static java.util.UUID readUUID(Class<? extends UpgradeStep> upgradeStepClass); static java.util.UUID readOnlyWithUUID(Class<? extends UpgradeStep> upgradeStepClass); } | @Test public void testExactPath() { List<Class<? extends UpgradeStep>> upgradeSteps = new ArrayList<>(); upgradeSteps.add(AddJamType.class); upgradeSteps.add(AddCakeTable.class); upgradeSteps.add(AddDiameter.class); upgradeSteps.add(InsertAVictoriaSpongeRowUsingDSL.class); UpgradePathFinder pathFinder = makeFinder(upgradeSteps, appliedSteps()); Schema current = schema(sconeTable); Schema target = schema(upgradedSconeTable, cakeTable); List<UpgradeStep> path = pathFinder.determinePath(current, target, Sets.<String>newHashSet()).getUpgradeSteps(); assertEquals("Number of upgrades steps", 4, path.size()); assertSame("First upgrades step", AddCakeTable.class, path.get(0).getClass()); assertSame("Second upgrades step", AddDiameter.class, path.get(1).getClass()); assertSame("Third upgrades step", AddJamType.class, path.get(2).getClass()); }
@Test public void testConditionalUpgradeStepIsExecuted() { List<Class<? extends UpgradeStep>> upgradeSteps = new ArrayList<>(); upgradeSteps.add(AddJamType.class); upgradeSteps.add(AddDiameter.class); upgradeSteps.add(AddJamAmount.class); upgradeSteps.add(AddJamAmountUnit.class); UpgradePathFinder pathFinder = makeFinder(upgradeSteps, appliedSteps()); Schema current = schema(sconeTable); Schema target = schema(upgradedSconeTableWithJamAmount); List<UpgradeStep> path = pathFinder.determinePath(current, target, Sets.<String>newHashSet()).getUpgradeSteps(); assertEquals("Number of upgrades steps", 4, path.size()); assertSame("First", AddDiameter.class, path.get(0).getClass()); assertSame("Second", AddJamType.class, path.get(1).getClass()); assertSame("Third", AddJamAmountUnit.class, path.get(2).getClass()); assertSame("Last", AddJamAmount.class, path.get(3).getClass()); }
@Test public void testConditionalUpgradeStepNotExecuted() { List<Class<? extends UpgradeStep>> upgradeSteps = new ArrayList<>(); upgradeSteps.add(AddJamType.class); upgradeSteps.add(AddDiameter.class); upgradeSteps.add(AddJamAmount.class); upgradeSteps.add(AddJamAmountUnit.class); UpgradePathFinder pathFinder = makeFinder(upgradeSteps, appliedSteps(AddJamType.class, AddDiameter.class)); Schema current = schema(upgradedSconeTable); Schema target = schema(upgradedSconeTable); List<UpgradeStep> path = pathFinder.determinePath(current, target, Sets.<String>newHashSet()).getUpgradeSteps(); assertEquals("Number of upgrades steps", 0, path.size()); }
@Test public void testLinearPath() { List<Class<? extends UpgradeStep>> upgradeSteps = new ArrayList<>(); upgradeSteps.add(AddWeight.class); upgradeSteps.add(AddJamType.class); upgradeSteps.add(AddCakeTable.class); upgradeSteps.add(AddDiameter.class); upgradeSteps.add(InsertAVictoriaSpongeRowUsingDSL.class); UpgradePathFinder pathFinder = makeFinder(upgradeSteps, appliedSteps(AddWeight.class)); Schema current = schema(sconeTable); Schema target = schema(upgradedSconeTable, cakeTable); List<UpgradeStep> path = pathFinder.determinePath(current, target, Sets.<String>newHashSet()).getUpgradeSteps(); assertEquals("Number of upgrades steps", 4, path.size()); assertSame("Second upgrades step", AddCakeTable.class, path.get(0).getClass()); assertSame("Third upgrades step", AddDiameter.class, path.get(1).getClass()); assertSame("First upgrades step", AddJamType.class, path.get(2).getClass()); assertSame("Fourth upgrade step", InsertAVictoriaSpongeRowUsingDSL.class, path.get(3).getClass()); }
@Test public void testAddColumnFailsWhenItAlreadyExists() { List<Class<? extends UpgradeStep>> upgradeSteps = new ArrayList<>(); upgradeSteps.add(AddWeight.class); UpgradePathFinder pathFinder = makeFinder(upgradeSteps, appliedSteps()); Schema current = schema(sconeTable); Schema target = schema(upgradedSconeTable); try { pathFinder.determinePath(current, target, Sets.<String>newHashSet()); fail(); } catch(RuntimeException rte) { Throwable ex = rte; while(ex != null) { if (ex.getMessage().contains("[weight]")) return; ex = ex.getCause(); } throw rte; } }
@Test public void testAddDeleteSameColumn() { List<Class<? extends UpgradeStep>> upgradeSteps = new ArrayList<>(); upgradeSteps.add(AddStars.class); upgradeSteps.add(AddRating.class); upgradeSteps.add(DeleteRating.class); UpgradePathFinder pathFinder = makeFinder(upgradeSteps, appliedSteps()); Schema current = schema(cakeTable); Schema target = schema(cakeTablev2); List<UpgradeStep> path = pathFinder.determinePath(current, target, Sets.<String>newHashSet()).getUpgradeSteps(); assertEquals("Should only be one upgrade setep.", 3, path.size()); }
@Test public void testSchemasMatchWithUnappliedDataChange() { List<Class<? extends UpgradeStep>> upgradeSteps = new ArrayList<>(); upgradeSteps.add(AddRating.class); upgradeSteps.add(DeleteRating.class); upgradeSteps.add(InsertAVictoriaSpongeRowUsingDSL.class); UpgradePathFinder pathFinder = makeFinder(upgradeSteps, appliedSteps()); Schema current = schema(cakeTable); Schema target = schema(cakeTable); List<UpgradeStep> path = pathFinder.determinePath(current, target, Sets.<String>newHashSet()).getUpgradeSteps(); assertEquals("Should only be one upgrade step.", 3, path.size()); assertEquals("Upgrade step 1 should be Insert row using DSL.", InsertAVictoriaSpongeRowUsingDSL.class, path.get(0).getClass()); }
@Test public void testUpgradeWithSkippedStep() { List<Class<? extends UpgradeStep>> upgradeSteps = new ArrayList<>(); upgradeSteps.add(AddWeight.class); upgradeSteps.add(AddJamType.class); upgradeSteps.add(AddCakeTable.class); upgradeSteps.add(AddDiameter.class); UpgradePathFinder pathFinder = makeFinder(upgradeSteps, appliedSteps(AddWeight.class, AddDiameter.class)); Table newScone = table("Scone").columns( column("raisins", DataType.BOOLEAN).nullable(), column("flour", DataType.STRING).nullable(), column("weight", DataType.DECIMAL).nullable(), column("diameter", DataType.DECIMAL).nullable() ); Schema current = schema(newScone); Schema target = schema(upgradedSconeTable, cakeTable); List<UpgradeStep> path = pathFinder.determinePath(current, target, Sets.<String>newHashSet()).getUpgradeSteps(); assertEquals("Number of upgrades steps", 2, path.size()); assertSame("Second upgrades step", AddCakeTable.class, path.get(0).getClass()); assertSame("First upgrades step", AddJamType.class, path.get(1).getClass()); }
@Test public void testNoUpgradeExists() { List<Class<? extends UpgradeStep>> upgradeSteps = new ArrayList<>(); upgradeSteps.add(AddJamType.class); upgradeSteps.add(AddCakeTable.class); UpgradePathFinder pathFinder = makeFinder(upgradeSteps, appliedSteps()); Schema current = schema(sconeTable); Schema target = schema(upgradedSconeTable, cakeTable); try { pathFinder.determinePath(current, target, Sets.<String>newHashSet()); fail("No upgrade path exists so an exception should be thrown"); } catch (NoUpgradePathExistsException e) { assertEquals("Message text", "No upgrade path exists", e.getMessage()); assertTrue("Message is instance of IllegalStateException", e instanceof IllegalStateException); } }
@Test public void testInterdependentSequence() { List<Class<? extends UpgradeStep>> upgradeSteps = new ArrayList<>(); upgradeSteps.add(AddJamType.class); upgradeSteps.add(AddDiameter.class); upgradeSteps.add(ChangeGramsToWeight.class); upgradeSteps.add(AddGrams.class); upgradeSteps.add(AddCakeTable.class); upgradeSteps.add(InsertAVictoriaSpongeRowUsingDSL.class); UpgradePathFinder pathFinder = makeFinder(upgradeSteps, appliedSteps(AddDiameter.class, AddJamType.class, AddGrams.class, ChangeGramsToWeight.class)); Schema current = schema(upgradedSconeTable); Schema target = schema(upgradedSconeTable, cakeTable); List<UpgradeStep> path = pathFinder.determinePath(current, target, Sets.<String>newHashSet()).getUpgradeSteps(); assertEquals("Number of upgrade steps", 2, path.size()); assertEquals("Type of upgrade step", AddCakeTable.class, path.get(0).getClass()); }
@Test public void testAddAssumedUUIDWhenUpgradeAuditUUIDPresent() { List<Class<? extends UpgradeStep>> upgradeSteps = new ArrayList<>(); upgradeSteps.add(MockAddUpgradeAudit.class); upgradeSteps.add(MockProvisionHistoryUpgrade.class); upgradeSteps.add(MockWidenIndustryCodeUpgrade.class); UpgradePathFinder pathFinder = makeFinder(upgradeSteps, appliedSteps(MockAddUpgradeAudit.class)); List<UpgradeStep> path = pathFinder.determinePath(schema(), schema(), Sets.<String>newHashSet()).getUpgradeSteps(); assertEquals("There should be no upgrade steps - all the ones in 5.0.18 and earlier should be assumed to be applied.", 0, path.size()); }
@Test public void testDontAddAssumedUUIDWhenEarlierStepsPresent() { List<Class<? extends UpgradeStep>> upgradeSteps = new ArrayList<>(); upgradeSteps.add(MockAddUpgradeAudit.class); upgradeSteps.add(MockProvisionHistoryUpgrade.class); upgradeSteps.add(MockWidenIndustryCodeUpgrade.class); UpgradePathFinder pathFinder = makeFinder(upgradeSteps, appliedSteps(MockAddUpgradeAudit.class, MockProvisionHistoryUpgrade.class)); List<UpgradeStep> path = pathFinder.determinePath(schema(), schema(), Sets.<String>newHashSet()).getUpgradeSteps(); assertEquals("Earlier steps should be applied", 1, path.size()); assertEquals("Earlier steps should be applied", MockWidenIndustryCodeUpgrade.class, path.get(0).getClass()); } |
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); } | @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); } |
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); } | @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); } |
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); } | @Test public void createAuditInsertStatement() throws Exception { UUID uuid = UUID.randomUUID(); String description = "Description"; InsertStatement statement = AuditRecordHelper.createAuditInsertStatement(uuid, description); assertAuditInsertStatement(uuid, description, statement); } |
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); } | @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")); } |
ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); String getTableName(); Column getFromColumn(); Column getToColumn(); } | @Test public void testIncreaseColumnLength() { Schema testSchema = schema(appleTable); ChangeColumn changeColumn = new ChangeColumn("Apple", column("colour", DataType.STRING, 10).nullable(), column("colour", DataType.STRING, 35).nullable()); Schema updatedSchema = changeColumn.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade column count", 9, resultTable.columns().size()); Column columnOne = resultTable.columns().get(0); Column columnTwo = resultTable.columns().get(1); Column columnThree = resultTable.columns().get(2); Column columnFour = resultTable.columns().get(3); Column columnFive = resultTable.columns().get(4); Column columnSix = resultTable.columns().get(5); Column columnSeven = resultTable.columns().get(6); Column columnEight = resultTable.columns().get(7); Column columnNine = resultTable.columns().get(8); assertEquals("Post upgrade existing column name 1", "id", columnOne.getName()); assertEquals("Post upgrade existing column name 2", "version", columnTwo.getName()); assertEquals("Post upgrade existing column name 3", "colour", columnThree.getName()); assertEquals("Post upgrade existing column name 4", "variety", columnFour.getName()); assertEquals("Post upgrade existing column name 5", "ispoisoned", columnFive.getName()); assertEquals("Post upgrade existing column name 6", "datecreated", columnSix.getName()); assertEquals("Post upgrade existing column name 7", "numberavailable", columnSeven.getName()); assertEquals("Post upgrade existing column name 8", "totalvalue", columnEight.getName()); assertEquals("Post upgrade existing column name 9", "nullcheck", columnNine.getName()); assertEquals("Width should have changed", 35, columnThree.getWidth()); assertEquals("Width should not have changed", 15, columnFour.getWidth()); assertEquals("Width should not have changed", 5, columnSeven.getWidth()); assertEquals("Width should not have changed", 9, columnEight.getWidth()); assertEquals("Width should not have changed", 9, columnNine.getWidth()); assertEquals("Scale should not have changed", 0, columnThree.getScale()); assertEquals("Scale should not have changed", 0, columnFour.getScale()); assertEquals("Scale should not have changed", 0, columnFive.getScale()); assertEquals("Scale should not have changed", 0, columnSeven.getScale()); assertEquals("Scale should not have changed", 2, columnEight.getScale()); assertEquals("Scale should not have changed", 0, columnNine.getScale()); assertEquals("Type should not have changed", DataType.STRING, columnThree.getType()); assertEquals("Type should not have changed", DataType.STRING, columnFour.getType()); assertEquals("Type should not have changed", DataType.BOOLEAN, columnFive.getType()); assertEquals("Type should not have changed", DataType.DATE, columnSix.getType()); assertEquals("Type should not have changed", DataType.DECIMAL, columnSeven.getType()); assertEquals("Type should not have changed", DataType.DECIMAL, columnEight.getType()); assertEquals("Type should not have changed", DataType.DECIMAL, columnNine.getType()); assertTrue("Nullable should not have changed", columnThree.isNullable()); assertTrue("Nullable should not have changed", columnFour.isNullable()); assertTrue("Nullable should not have changed", columnFive.isNullable()); assertTrue("Nullable should not have changed", columnSix.isNullable()); assertFalse("Nullable should not have changed", columnSeven.isNullable()); assertFalse("Nullable should not have changed", columnEight.isNullable()); assertTrue("Nullable should not have changed", columnNine.isNullable()); }
@Test public void testChangeColumnType() { Schema testSchema = schema(appleTable); ChangeColumn changeColumn = new ChangeColumn("Apple", column("numberavailable", DataType.DECIMAL, 5), column("numberavailable", DataType.BIG_INTEGER)); Schema updatedSchema = changeColumn.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); Table expectedAppleTable = table("Apple").columns( idColumn(), versionColumn(), column("colour", DataType.STRING, 10).nullable(), column("variety", DataType.STRING, 15).nullable(), column("ispoisoned", DataType.BOOLEAN).nullable(), column("datecreated", DataType.DATE).nullable(), column("numberavailable", DataType.BIG_INTEGER), column("totalvalue", DataType.DECIMAL, 9, 2), column("nullcheck", DataType.DECIMAL, 9, 0).nullable() ).indexes( index("Apple_1").columns("colour") ); assertTrue(new SchemaHomology(new ThrowingDifferenceWriter(), "expected", "result").tablesMatch(expectedAppleTable, resultTable)); }
@Test public void testChangeColumnName() { Schema testSchema = schema(appleTable); ChangeColumn changeColumn = new ChangeColumn("Apple", column("variety", DataType.STRING, 15).nullable(), column("brand", DataType.STRING, 15).nullable()); Schema updatedSchema = changeColumn.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade column count", 9, resultTable.columns().size()); Column columnOne = resultTable.columns().get(2); Column columnTwo = resultTable.columns().get(3); Column columnThree = resultTable.columns().get(4); Column columnFour = resultTable.columns().get(5); Column columnFive = resultTable.columns().get(6); Column columnSix = resultTable.columns().get(7); Column columnSeven = resultTable.columns().get(8); assertEquals("Post upgrade existing column name 1", "colour", columnOne.getName()); assertEquals("Post upgrade existing column name 2", "brand", columnTwo.getName()); assertEquals("Post upgrade existing column name 3", "ispoisoned", columnThree.getName()); assertEquals("Post upgrade existing column name 4", "datecreated", columnFour.getName()); assertEquals("Post upgrade existing column name 5", "numberavailable", columnFive.getName()); assertEquals("Post upgrade existing column name 6", "totalvalue", columnSix.getName()); assertEquals("Post upgrade existing column name 7", "nullcheck", columnSeven.getName()); assertEquals("Width should not have changed", 10, columnOne.getWidth()); assertEquals("Width should not have changed", 15, columnTwo.getWidth()); assertEquals("Width should not have changed", 5, columnFive.getWidth()); assertEquals("Width should not have changed", 9, columnSix.getWidth()); assertEquals("Width should not have changed", 9, columnSeven.getWidth()); assertEquals("Scale should not have changed", 0, columnOne.getScale()); assertEquals("Scale should not have changed", 0, columnTwo.getScale()); assertEquals("Scale should not have changed", 0, columnFive.getScale()); assertEquals("Scale should not have changed", 2, columnSix.getScale()); assertEquals("Scale should not have changed", 0, columnSeven.getScale()); assertEquals("Type should not have changed", DataType.STRING, columnOne.getType()); assertEquals("Type should not have changed", DataType.STRING, columnTwo.getType()); assertEquals("Type should not have changed", DataType.BOOLEAN, columnThree.getType()); assertEquals("Type should not have changed", DataType.DATE, columnFour.getType()); assertEquals("Type should not have changed", DataType.DECIMAL, columnFive.getType()); assertEquals("Type should not have changed", DataType.DECIMAL, columnSix.getType()); assertEquals("Type should not have changed", DataType.DECIMAL, columnSeven.getType()); assertTrue("Nullable should not have changed", columnOne.isNullable()); assertTrue("Nullable should not have changed", columnTwo.isNullable()); assertTrue("Nullable should not have changed", columnThree.isNullable()); assertTrue("Nullable should not have changed", columnFour.isNullable()); assertFalse("Nullable should not have changed", columnFive.isNullable()); assertFalse("Nullable should not have changed", columnSix.isNullable()); assertTrue("Nullable should not have changed", columnSeven.isNullable()); }
@Test public void testChangeColumnNullable() { Schema testSchema = schema(appleTable); ChangeColumn changeColumn = new ChangeColumn("Apple", column("nullcheck", DataType.DECIMAL, 9, 0).nullable(), column("nullcheck", DataType.DECIMAL, 9, 0)); Schema updatedSchema = changeColumn.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade column count", 9, resultTable.columns().size()); Column columnOne = resultTable.columns().get(2); Column columnTwo = resultTable.columns().get(3); Column columnThree = resultTable.columns().get(4); Column columnFour = resultTable.columns().get(5); Column columnFive = resultTable.columns().get(6); Column columnSix = resultTable.columns().get(7); Column columnSeven = resultTable.columns().get(8); assertEquals("Post upgrade existing column name 1", "colour", columnOne.getName()); assertEquals("Post upgrade existing column name 2", "variety", columnTwo.getName()); assertEquals("Post upgrade existing column name 3", "ispoisoned", columnThree.getName()); assertEquals("Post upgrade existing column name 4", "datecreated", columnFour.getName()); assertEquals("Post upgrade existing column name 5", "numberavailable", columnFive.getName()); assertEquals("Post upgrade existing column name 6", "totalvalue", columnSix.getName()); assertEquals("Post upgrade existing column name 7", "nullcheck", columnSeven.getName()); assertEquals("Width should not have changed", 10, columnOne.getWidth()); assertEquals("Width should not have changed", 15, columnTwo.getWidth()); assertEquals("Width should not have changed", 5, columnFive.getWidth()); assertEquals("Width should not have changed", 9, columnSix.getWidth()); assertEquals("Width should not have changed", 9, columnSeven.getWidth()); assertEquals("Scale should not have changed", 0, columnOne.getScale()); assertEquals("Scale should not have changed", 0, columnTwo.getScale()); assertEquals("Scale should not have changed", 0, columnFive.getScale()); assertEquals("Scale should not have changed", 2, columnSix.getScale()); assertEquals("Scale should not have changed", 0, columnSeven.getScale()); assertEquals("Type should not have changed", DataType.STRING, columnOne.getType()); assertEquals("Type should not have changed", DataType.STRING, columnTwo.getType()); assertEquals("Type should not have changed", DataType.BOOLEAN, columnThree.getType()); assertEquals("Type should not have changed", DataType.DATE, columnFour.getType()); assertEquals("Type should not have changed", DataType.DECIMAL, columnFive.getType()); assertEquals("Type should not have changed", DataType.DECIMAL, columnSix.getType()); assertEquals("Type should not have changed", DataType.DECIMAL, columnSeven.getType()); assertTrue("Nullable should not have changed", columnOne.isNullable()); assertTrue("Nullable should not have changed", columnTwo.isNullable()); assertTrue("Nullable should not have changed", columnThree.isNullable()); assertTrue("Nullable should not have changed", columnFour.isNullable()); assertFalse("Nullable should not have changed", columnFive.isNullable()); assertFalse("Nullable should not have changed", columnSix.isNullable()); assertFalse("Nullable should not have changed", columnSeven.isNullable()); }
@Test public void testChangeMissingField() { Schema testSchema = schema(appleTable); ChangeColumn changeColumn = new ChangeColumn("Apple", column("doesntexist", DataType.STRING, 10).nullable(), column("doesntexist", DataType.STRING, 35).nullable()); try { changeColumn.apply(testSchema); fail("Should have failed to change a non existant column on apply"); } catch(Exception e) { } }
@Test public void testChangeFieldIsCaseInsensitive() { Schema testSchema = schema(appleTable); ChangeColumn changeColumn = new ChangeColumn("APPLE", column("VARIETY", DataType.STRING, 15).nullable(), column("Variety", DataType.STRING, 35).nullable()); Schema result = changeColumn.apply(testSchema); Table newTable = result.getTable("Apple"); assertNotNull("Table not found", newTable); Column changedColumn = null; for (Column column : newTable.columns()) { if (column.getName().equals("Variety")) { assertEquals("Changed column length", 35, column.getWidth()); changedColumn = column; } } assertNotNull("Column not found", changedColumn); }
@Test public void testChangeFieldNameToExistingField() { Schema testSchema = schema(appleTable); ChangeColumn changeColumn = new ChangeColumn("Apple", column("ispoisoned", DataType.STRING, 10).nullable(), column("colour", DataType.STRING, 35).nullable()); try { changeColumn.apply(testSchema); fail("Should have failed to change name to match an existing field on apply"); } catch(Exception e) { } }
@Test public void testChangeFieldNameInIndex() { Schema testSchema = schema(pearTable); ChangeColumn changeColumn = new ChangeColumn("Pear", column("color", DataType.STRING, 35).nullable(), column("colour", DataType.STRING, 35).nullable()); try { changeColumn.apply(testSchema); fail("Should have failed to change name to match an existing field on apply"); } catch(IllegalArgumentException e) { } }
@Test public void testChangePrimaryKey() { Schema testSchema = schema(appleTable); ChangeColumn changeColumn = new ChangeColumn("Apple", column("id", DataType.BIG_INTEGER).primaryKey(), column("id", DataType.BIG_INTEGER)); Schema updatedSchema = changeColumn.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade column count", 9, resultTable.columns().size()); Column columnOne = resultTable.columns().get(0); assertEquals("Post upgrade existing column name 1", "id", columnOne.getName()); assertFalse("Primary key should have changed", columnOne.isPrimaryKey()); }
@Test public void testCannotRenameColumnThatAppearsInIndexes() { Schema testSchema = schema(pearTable); try { new ChangeColumn("Pear", column("colour", DataType.STRING, 10).nullable(), column("hue", DataType.STRING, 10).nullable() ).apply(testSchema); fail("Expect IllegalArgumentException"); } catch(IllegalArgumentException iae) { assertTrue(iae.getMessage().contains("colour")); } try { new ChangeColumn("Pear", column("COLOUR", DataType.STRING, 10).nullable(), column("HUE", DataType.STRING, 10).nullable() ).apply(testSchema); fail("Expect IllegalArgumentException"); } catch(IllegalArgumentException iae) { assertTrue(iae.getMessage().contains("COLOUR")); } } |
ChangeColumn implements SchemaChange { @Override public Schema reverse(Schema schema) { return applyChange(schema, toColumn, fromColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); String getTableName(); Column getFromColumn(); Column getToColumn(); } | @Test public void testReverseChangeLength() { appleTable = table("Apple").columns( idColumn(), versionColumn(), column("colour", DataType.STRING, 35).nullable(), column("variety", DataType.STRING, 15).nullable(), column("ispoisoned", DataType.BOOLEAN).nullable(), column("datecreated", DataType.DATE).nullable(), column("numberavailable", DataType.DECIMAL, 5, 0), column("totalvalue", DataType.DECIMAL, 9, 2), column("nullcheck", DataType.DECIMAL, 9, 0).nullable() ); Schema testSchema = schema(appleTable); ChangeColumn changeColumn = new ChangeColumn("Apple", column("colour", DataType.STRING, 10).nullable(), column("colour", DataType.STRING, 35).nullable()); Schema updatedSchema = changeColumn.reverse(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade column count", 9, resultTable.columns().size()); Column columnOne = resultTable.columns().get(2); assertEquals("Post upgrade existing column name 1", "colour", columnOne.getName()); assertEquals("Width should not have changed", 10, columnOne.getWidth()); assertEquals("Scale should not have changed", 0, columnOne.getScale()); assertEquals("Type should not have changed", DataType.STRING, columnOne.getType()); assertTrue("Nullable should not have changed", columnOne.isNullable()); }
@Test public void testReverseChangeColumnType() { Table alreadyChangedTable = table("Apple").columns( idColumn(), versionColumn(), column("colour", DataType.STRING, 10).nullable(), column("variety", DataType.STRING, 15).nullable(), column("ispoisoned", DataType.BOOLEAN).nullable(), column("datecreated", DataType.DATE).nullable(), column("numberavailable", DataType.BIG_INTEGER), column("totalvalue", DataType.DECIMAL, 9, 2), column("nullcheck", DataType.DECIMAL, 9, 0).nullable() ).indexes( index("Apple_1").columns("colour") ); Schema testSchema = schema(alreadyChangedTable); ChangeColumn changeColumn = new ChangeColumn("Apple", column("numberavailable", DataType.DECIMAL, 5), column("numberavailable", DataType.BIG_INTEGER)); Schema updatedSchema = changeColumn.reverse(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertTrue(new SchemaHomology(new ThrowingDifferenceWriter(), "expected", "result").tablesMatch(appleTable, resultTable)); }
@Test public void testReverseChangeColumnName() { appleTable = table("Apple").columns( idColumn(), versionColumn(), column("colour", DataType.STRING, 10).nullable(), column("brand", DataType.STRING, 15).nullable(), column("ispoisoned", DataType.BOOLEAN).nullable(), column("datecreated", DataType.DATE).nullable(), column("numberavailable", DataType.DECIMAL, 5, 0), column("totalvalue", DataType.DECIMAL, 9, 2), column("nullcheck", DataType.DECIMAL, 9, 0).nullable() ); Schema testSchema = schema(appleTable); ChangeColumn changeColumn = new ChangeColumn("Apple", column("variety", DataType.STRING, 15).nullable(), column("brand", DataType.STRING, 15).nullable()); Schema updatedSchema = changeColumn.reverse(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade column count", 9, resultTable.columns().size()); Column columnTwo = resultTable.columns().get(3); assertEquals("Post upgrade existing column name 2", "variety", columnTwo.getName()); assertEquals("Width should not have changed", 15, columnTwo.getWidth()); assertEquals("Scale should not have changed", 0, columnTwo.getScale()); assertEquals("Type should not have changed", DataType.STRING, columnTwo.getType()); assertTrue("Nullable should not have changed", columnTwo.isNullable()); }
@Test public void testReverseChangeColumnNullable() { appleTable = table("Apple").columns( idColumn(), versionColumn(), column("colour", DataType.STRING, 10).nullable(), column("variety", DataType.STRING, 15).nullable(), column("ispoisoned", DataType.BOOLEAN).nullable(), column("datecreated", DataType.DATE).nullable(), column("numberavailable", DataType.DECIMAL, 5, 0), column("totalvalue", DataType.DECIMAL, 9, 2), column("nullcheck", DataType.DECIMAL, 9, 0) ); Schema testSchema = schema(appleTable); ChangeColumn changeColumn = new ChangeColumn("Apple", column("nullcheck", DataType.DECIMAL, 9, 0).nullable(), column("nullcheck", DataType.DECIMAL, 9, 0)); Schema updatedSchema = changeColumn.reverse(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade column count", 9, resultTable.columns().size()); Column columnSeven = resultTable.columns().get(8); assertEquals("Post upgrade existing column name 7", "nullcheck", columnSeven.getName()); assertEquals("Width should not have changed", 9, columnSeven.getWidth()); assertEquals("Scale should not have changed", 0, columnSeven.getScale()); assertEquals("Type should not have changed", DataType.DECIMAL, columnSeven.getType()); assertTrue("Nullable should not have changed", columnSeven.isNullable()); } |
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); } | @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(); } |
ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } 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(); } | @Test public void testChangeIndexColumns() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("Apple_1").columns("pips"), index("Apple_1").columns("totalValue")); Schema updatedSchema = changeIndex.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade index count", 3, resultTable.indexes().size()); Index indexOne = resultTable.indexes().get(0); Index indexTwo = resultTable.indexes().get(1); assertEquals("Post upgrade existing index name 1", "Apple_1", indexOne.getName()); assertEquals("Post upgrade existing index name 2", "Apple_2", indexTwo.getName()); assertEquals("Number of columns should be 1", 1, indexOne.columnNames().size()); assertEquals("Number of columns should be 1", 1, indexTwo.columnNames().size()); assertEquals("Column name should have changed", "totalValue", indexOne.columnNames().get(0)); assertEquals("Column name should not have changed", "colour", indexTwo.columnNames().get(0)); assertEquals("Uniqueness should have changed", false, indexOne.isUnique()); assertEquals("Uniqueness should not have changed", true, indexTwo.isUnique()); }
@Test public void testAddingColumnToIndex() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("Apple_1").unique().columns("pips"), index("Apple_1").columns("pips", "totalValue")); Schema updatedSchema = changeIndex.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade index count", 3, resultTable.indexes().size()); Index indexOne = resultTable.indexes().get(0); Index indexTwo = resultTable.indexes().get(1); Index indexThree = resultTable.indexes().get(2); assertEquals("Post upgrade existing index name 1", "Apple_1", indexOne.getName()); assertEquals("Post upgrade existing index name 2", "Apple_2", indexTwo.getName()); assertEquals("Post upgrade existing index name 3", "Apple_3", indexThree.getName()); assertEquals("Number of columns should be 2", 2, indexOne.columnNames().size()); assertEquals("Number of columns should be 1", 1, indexTwo.columnNames().size()); assertEquals("Number of columns should be 2", 2, indexThree.columnNames().size()); assertEquals("Column 1 name should have changed", "pips", indexOne.columnNames().get(0)); assertEquals("Column 2 should exist", "totalValue", indexOne.columnNames().get(1)); assertEquals("Column name should not have changed", "colour", indexTwo.columnNames().get(0)); assertEquals("Column name should not have changed", "colour", indexThree.columnNames().get(0)); assertEquals("Column name should not have changed", "pips", indexThree.columnNames().get(1)); assertEquals("Uniqueness should have changed", false, indexOne.isUnique()); assertEquals("Uniqueness should not have changed", true, indexTwo.isUnique()); assertEquals("Uniqueness should not have changed", true, indexThree.isUnique()); }
@Test public void testRemovingColumnFromIndex() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("Apple_3").unique().columns("colour", "pips"), index("Apple_3").unique().columns("pips")); Schema updatedSchema = changeIndex.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade index count", 3, resultTable.indexes().size()); Index indexOne = resultTable.indexes().get(0); Index indexTwo = resultTable.indexes().get(1); Index indexThree = resultTable.indexes().get(2); assertEquals("Post upgrade existing index name 1", "Apple_1", indexOne.getName()); assertEquals("Post upgrade existing index name 2", "Apple_2", indexTwo.getName()); assertEquals("Post upgrade existing index name 3", "Apple_3", indexThree.getName()); assertEquals("Number of columns should be 1", 1, indexOne.columnNames().size()); assertEquals("Number of columns should be 1", 1, indexTwo.columnNames().size()); assertEquals("Number of columns should be 1", 1, indexThree.columnNames().size()); assertEquals("Column name for index 1", "pips", indexOne.columnNames().get(0)); assertEquals("Column name for index 2", "colour", indexTwo.columnNames().get(0)); assertEquals("Column name for index 3", "pips", indexThree.columnNames().get(0)); assertEquals("Uniqueness should have changed", true, indexOne.isUnique()); assertEquals("Uniqueness should have changed", true, indexTwo.isUnique()); assertEquals("Uniqueness should not have changed", true, indexThree.isUnique()); }
@Test public void testChangeIndexName() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("Apple_3").unique().columns("colour", "pips"), index("Apple_4").unique().columns("colour", "pips")); Schema updatedSchema = changeIndex.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade index count", 3, resultTable.indexes().size()); Index indexOne = resultTable.indexes().get(0); Index indexTwo = resultTable.indexes().get(1); Index indexThree = resultTable.indexes().get(2); assertEquals("Post upgrade existing index name 1", "Apple_1", indexOne.getName()); assertEquals("Post upgrade existing index name 2", "Apple_2", indexTwo.getName()); assertEquals("Post upgrade existing index name 3", "Apple_4", indexThree.getName()); assertEquals("Number of columns should be 1", 1, indexOne.columnNames().size()); assertEquals("Number of columns should be 1", 1, indexTwo.columnNames().size()); assertEquals("Number of columns should be 2", 2, indexThree.columnNames().size()); assertEquals("Column name for index 1", "pips", indexOne.columnNames().get(0)); assertEquals("Column name for index 2", "colour", indexTwo.columnNames().get(0)); assertEquals("Column 1 name for index 3", "colour", indexThree.columnNames().get(0)); assertEquals("Column 2 name for index 3", "pips", indexThree.columnNames().get(1)); assertEquals("Uniqueness should have changed", true, indexOne.isUnique()); assertEquals("Uniqueness should have changed", true, indexTwo.isUnique()); assertEquals("Uniqueness should not have changed", true, indexThree.isUnique()); }
@Test public void testChangeMissingIndex() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("doesNotExist").unique().columns("colour", "pips"), index("doesNotExist").unique().columns("colour", "pips")); try { changeIndex.apply(testSchema); fail("Should have failed to change a non existant column on apply"); } catch(Exception e) { } }
@Test public void testChangeFieldNameToExistingField() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("Apple_1").unique().columns("pips"), index("Apple_2").unique().columns("pips")); try { changeIndex.apply(testSchema); fail("Should have failed to change name to match an existing index on apply"); } catch(Exception e) { } }
@Test public void testNullChangeIndex() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("Apple_1").unique().columns("pips"), null); try { changeIndex.apply(testSchema); fail("Attempting to change an index to null should result in an exception on apply"); } catch(Exception e) { } changeIndex = new ChangeIndex("Apple", null, index("Apple_1").unique().columns("pips")); try { changeIndex.apply(testSchema); fail("Attempting to change an index from null should result in an exception on apply"); } catch(Exception e) { } } |
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(); } | @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()); } |
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(); } | @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()); } |
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); } | @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()); } |
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); } | @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()); } |
InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } 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); } | @Test public void testVisitAddTable() { AddTable addTable = mock(AddTable.class); given(addTable.apply(schema)).willReturn(schema); upgrader.visit(addTable); verify(addTable).apply(schema); verify(sqlDialect, atLeastOnce()).tableDeploymentStatements(any(Table.class)); verify(sqlStatementWriter).writeSql(anyCollectionOf(String.class)); }
@Test public void testVisitRemoveTable() { RemoveTable removeTable = mock(RemoveTable.class); given(removeTable.apply(schema)).willReturn(schema); upgrader.visit(removeTable); verify(removeTable).apply(schema); verify(sqlDialect).dropStatements(any(Table.class)); verify(sqlStatementWriter).writeSql(anyCollectionOf(String.class)); }
@Test public void testVisitAddIndex() { AddIndex addIndex = mock(AddIndex.class); given(addIndex.apply(schema)).willReturn(schema); upgrader.visit(addIndex); verify(addIndex).apply(schema); verify(sqlDialect).addIndexStatements(any(Table.class), any(Index.class)); verify(sqlStatementWriter).writeSql(anyCollectionOf(String.class)); }
@Test public void testVisitAddColumn() { AddColumn addColumn = mock(AddColumn.class); given(addColumn.apply(schema)).willReturn(schema); upgrader.visit(addColumn); verify(addColumn).apply(schema); verify(sqlDialect).alterTableAddColumnStatements(any(Table.class), any(Column.class)); verify(sqlStatementWriter).writeSql(anyCollectionOf(String.class)); }
@Test public void testVisitChangeColumn() { ChangeColumn changeColumn = mock(ChangeColumn.class); given(changeColumn.apply(schema)).willReturn(schema); upgrader.visit(changeColumn); verify(changeColumn).apply(schema); verify(sqlDialect).alterTableChangeColumnStatements(any(Table.class), any(Column.class), any(Column.class)); verify(sqlStatementWriter).writeSql(anyCollectionOf(String.class)); }
@Test public void testVisitRemoveColumn() { RemoveColumn removeColumn = mock(RemoveColumn.class); given(removeColumn.apply(schema)).willReturn(schema); upgrader.visit(removeColumn); verify(removeColumn).apply(schema); verify(sqlDialect).alterTableDropColumnStatements(any(Table.class), any(Column.class)); verify(sqlStatementWriter).writeSql(anyCollectionOf(String.class)); }
@Test public void testVisitRemoveIndex() { RemoveIndex removeIndex = mock(RemoveIndex.class); given(removeIndex.apply(schema)).willReturn(schema); upgrader.visit(removeIndex); verify(removeIndex).apply(schema); verify(sqlDialect).indexDropStatements(any(Table.class), any(Index.class)); verify(sqlStatementWriter).writeSql(anyCollectionOf(String.class)); }
@Test public void testVisitChangeIndex() { ChangeIndex changeIndex = mock(ChangeIndex.class); given(changeIndex.apply(schema)).willReturn(schema); upgrader.visit(changeIndex); verify(changeIndex).apply(schema); verify(sqlDialect).indexDropStatements(any(Table.class), any(Index.class)); verify(sqlDialect).addIndexStatements(any(Table.class), any(Index.class)); verify(sqlStatementWriter, times(2)).writeSql(anyCollectionOf(String.class)); }
@Test public void testVisitInsertStatement() { ExecuteStatement executeStatement = mock(ExecuteStatement.class); InsertStatement insertStatement = mock(InsertStatement.class); given(executeStatement.getStatement()).willReturn(insertStatement); when(sqlDialect.convertStatementToSQL(eq((Statement)insertStatement), any(Schema.class), any(Table.class))).thenCallRealMethod(); upgrader.visit(executeStatement); ArgumentCaptor<SqlDialect.IdTable> captor = ArgumentCaptor.forClass(SqlDialect.IdTable.class); verify(sqlDialect).convertStatementToSQL(Mockito.eq(insertStatement), Mockito.eq(schema), captor.capture()); assertEquals("Id Table name differed", ID_TABLE_NAME, captor.getValue().getName()); verify(sqlStatementWriter).writeSql(anyCollectionOf(String.class)); }
@Test public void testVisitUpdateStatement() { ExecuteStatement executeStatement = mock(ExecuteStatement.class); UpdateStatement updateStatement = mock(UpdateStatement.class); given(executeStatement.getStatement()).willReturn(updateStatement); when(sqlDialect.convertStatementToSQL(eq((Statement)updateStatement), any(Schema.class), any(Table.class))).thenCallRealMethod(); upgrader.visit(executeStatement); verify(sqlDialect).convertStatementToSQL(updateStatement); verify(sqlStatementWriter).writeSql(anyCollectionOf(String.class)); }
@Test public void testVisitDeleteStatement() { ExecuteStatement executeStatement = mock(ExecuteStatement.class); DeleteStatement deleteStatement = mock(DeleteStatement.class); given(executeStatement.getStatement()).willReturn(deleteStatement); when(sqlDialect.convertStatementToSQL(eq((Statement)deleteStatement), any(Schema.class), any(Table.class))).thenCallRealMethod(); upgrader.visit(executeStatement); verify(sqlDialect).convertStatementToSQL(deleteStatement); verify(sqlStatementWriter).writeSql(anyCollectionOf(String.class)); }
@Test public void testVisitMergeStatement() { ExecuteStatement executeStatement = mock(ExecuteStatement.class); MergeStatement mergeStatement = mock(MergeStatement.class); given(executeStatement.getStatement()).willReturn(mergeStatement); when(sqlDialect.convertStatementToSQL(eq((Statement)mergeStatement), any(Schema.class), any(Table.class))).thenCallRealMethod(); upgrader.visit(executeStatement); verify(sqlDialect).convertStatementToSQL(mergeStatement); verify(sqlStatementWriter).writeSql(anyCollectionOf(String.class)); }
@Test public void testExecutePortableSqlStatement() { ExecuteStatement executeStatement = mock(ExecuteStatement.class); PortableSqlStatement statement = mock(PortableSqlStatement.class); given(executeStatement.getStatement()).willReturn(statement); DatabaseType databaseType = mock(DatabaseType.class); given(databaseType.identifier()).willReturn("Foo"); given(sqlDialect.getDatabaseType()).willReturn(databaseType); upgrader.visit(executeStatement); verify(statement).getStatement(eq("Foo"), anyString()); verify(sqlStatementWriter).writeSql(anyCollectionOf(String.class)); }
@Test public void testAnalyseTableStatment(){ AnalyseTable analyseTable = mock(AnalyseTable.class); given(analyseTable.apply(schema)).willReturn(schema); upgrader.visit(analyseTable); verify(sqlDialect).getSqlForAnalyseTable(any(Table.class)); verify(sqlStatementWriter).writeSql(anyCollectionOf(String.class)); } |
UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e) { UpgradeStatus currentStatus = getStatus(Optional.empty()); log.debug("Caught exception trying to move from [" + fromStatus + "] to [" + toStatus + "]; current status = [" + currentStatus + "]", e); if (currentStatus.equals(toStatus)) { return 0; } else if (currentStatus.equals(fromStatus)) { return sqlScriptExecutorProvider.get().execute(script); } else { 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); } | @Test public void testUpdateFromNoneToInProgress() { upgradeStatusTableService.writeStatusFromStatus(UpgradeStatus.NONE, UpgradeStatus.IN_PROGRESS); ArgumentCaptor<Table> tableCaptor = ArgumentCaptor.forClass(Table.class); verify(sqlDialect).tableDeploymentStatements(tableCaptor.capture()); assertEquals("Table name", tableCaptor.getValue().getName(), UpgradeStatusTableService.UPGRADE_STATUS); String expectedStmt = insert().into(upgradeStatusTable).values(literal(UpgradeStatus.IN_PROGRESS.name()).as(STATUS_COLUMN)).toString(); ArgumentCaptor<InsertStatement> stmtCaptor = ArgumentCaptor.forClass(InsertStatement.class); verify(sqlDialect).convertStatementToSQL(stmtCaptor.capture()); assertEquals("SQL", expectedStmt, stmtCaptor.getValue().toString()); }
@Test public void testUpdateFromInProgressToTransferRequired() { upgradeStatusTableService.writeStatusFromStatus(UpgradeStatus.IN_PROGRESS, UpgradeStatus.DATA_TRANSFER_REQUIRED); ArgumentCaptor<UpdateStatement> stmtCaptor = ArgumentCaptor.forClass(UpdateStatement.class); verify(sqlDialect).convertStatementToSQL(stmtCaptor.capture()); String expectedStmt = update(upgradeStatusTable).set(literal(UpgradeStatus.DATA_TRANSFER_REQUIRED.name()).as(STATUS_COLUMN)) .where(upgradeStatusTable.field(STATUS_COLUMN).eq(UpgradeStatus.IN_PROGRESS.name())).toString(); assertEquals("SQL", expectedStmt, stmtCaptor.getValue().toString()); }
@Test public void testUpdateFromTransferRequiredToDataTransferInProgress() { upgradeStatusTableService.writeStatusFromStatus(UpgradeStatus.DATA_TRANSFER_REQUIRED, UpgradeStatus.DATA_TRANSFER_IN_PROGRESS); ArgumentCaptor<UpdateStatement> stmtCaptor = ArgumentCaptor.forClass(UpdateStatement.class); verify(sqlDialect).convertStatementToSQL(stmtCaptor.capture()); String expectedStmt = update(upgradeStatusTable).set(literal(UpgradeStatus.DATA_TRANSFER_IN_PROGRESS.name()).as(STATUS_COLUMN)) .where(upgradeStatusTable.field(STATUS_COLUMN).eq(UpgradeStatus.DATA_TRANSFER_REQUIRED.name())).toString(); assertEquals("SQL", expectedStmt, stmtCaptor.getValue().toString()); }
@Test public void testUpdateFromDataTransferInProgressToCompleted() { when(sqlScriptExecutor.executeQuery(any(), any())).thenReturn(UpgradeStatus.DATA_TRANSFER_IN_PROGRESS); upgradeStatusTableService.writeStatusFromStatus(UpgradeStatus.DATA_TRANSFER_IN_PROGRESS, UpgradeStatus.COMPLETED); ArgumentCaptor<UpdateStatement> stmtCaptor = ArgumentCaptor.forClass(UpdateStatement.class); verify(sqlDialect).convertStatementToSQL(stmtCaptor.capture()); String expectedStmt = update(upgradeStatusTable).set(literal(UpgradeStatus.COMPLETED.name()).as(STATUS_COLUMN)) .where(upgradeStatusTable.field(STATUS_COLUMN).eq(UpgradeStatus.DATA_TRANSFER_IN_PROGRESS.name())).toString(); assertEquals("SQL", expectedStmt, stmtCaptor.getValue().toString()); }
@Test public void testUpdateFromDataTransferRequiredToCompleted() { when(sqlScriptExecutor.executeQuery(any(), any())).thenReturn(UpgradeStatus.DATA_TRANSFER_REQUIRED); upgradeStatusTableService.writeStatusFromStatus(UpgradeStatus.DATA_TRANSFER_REQUIRED, UpgradeStatus.COMPLETED); ArgumentCaptor<UpdateStatement> stmtCaptor = ArgumentCaptor.forClass(UpdateStatement.class); verify(sqlDialect).convertStatementToSQL(stmtCaptor.capture()); String expectedStmt = update(upgradeStatusTable).set(literal(UpgradeStatus.COMPLETED.name()).as(STATUS_COLUMN)) .where(upgradeStatusTable.field(STATUS_COLUMN).eq(UpgradeStatus.DATA_TRANSFER_REQUIRED.name())).toString(); assertEquals("SQL", expectedStmt, stmtCaptor.getValue().toString()); }
@Test public void testUpdateFromDataTransferRequiredToCompletedFail() { when(sqlScriptExecutor.executeQuery(any(), any())).thenReturn(UpgradeStatus.DATA_TRANSFER_IN_PROGRESS); int result = upgradeStatusTableService.writeStatusFromStatus(UpgradeStatus.DATA_TRANSFER_REQUIRED, UpgradeStatus.COMPLETED); assertEquals("Result", 0 , result); }
@Test public void testUpdateFromDataTransferRequiredToCompletedNone() { when(sqlScriptExecutor.executeQuery(any(), any())).thenReturn(UpgradeStatus.NONE); int result = upgradeStatusTableService.writeStatusFromStatus(UpgradeStatus.DATA_TRANSFER_REQUIRED, UpgradeStatus.COMPLETED); assertEquals("Result", 0, result); }
@SuppressWarnings("unchecked") @Test public void testWriteStatusFromStatusWithCurrentStatusEqualsToStatus() { when(sqlScriptExecutor.executeQuery(any(), any())).thenReturn(UpgradeStatus.DATA_TRANSFER_REQUIRED); when(sqlScriptExecutor.execute(anyList())).thenThrow(new RuntimeSqlException(new SQLException())); int result = upgradeStatusTableService.writeStatusFromStatus(UpgradeStatus.IN_PROGRESS, UpgradeStatus.DATA_TRANSFER_REQUIRED); assertEquals("Result", 0, result); }
@Test public void testWriteStatusFromStatusWithCurrentStatusEqualsFromStatus() { when(sqlScriptExecutor.executeQuery(any(), any())).thenReturn(UpgradeStatus.IN_PROGRESS); when(sqlScriptExecutor.execute(anyListOf(String.class))) .thenThrow(new RuntimeSqlException(new SQLException())) .thenReturn(0); upgradeStatusTableService.writeStatusFromStatus(UpgradeStatus.IN_PROGRESS, UpgradeStatus.DATA_TRANSFER_REQUIRED); verify(sqlScriptExecutor, times(2)).execute(anyListOf(String.class)); }
@Test public void testWriteStatusFromStatusWithCurrentStatusNotEqualsFromStatusOrToStatus() { RuntimeSqlException triggeringException = new RuntimeSqlException(new SQLException()); when(sqlScriptExecutor.executeQuery(any(), any())).thenReturn(UpgradeStatus.DATA_TRANSFER_IN_PROGRESS); when(sqlScriptExecutor.execute(anyListOf(String.class))) .thenThrow(triggeringException) .thenReturn(0); try { upgradeStatusTableService.writeStatusFromStatus(UpgradeStatus.IN_PROGRESS, UpgradeStatus.DATA_TRANSFER_REQUIRED); fail("Expected RuntimeSqlException"); } catch (RuntimeSqlException e) { verify(sqlScriptExecutor, times(1)).execute(anyListOf(String.class)); assertSame("Exception", triggeringException, e); } } |
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); } | @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) { } } |
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(); } | @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())); } |
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(); } | @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); } |
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(); } | @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")); } } |
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(); } | @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) { } } |
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(); } | @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())); } |
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(); } | @Test public void testTableExists() { assertTrue(schema.tableExists("Apple")); assertFalse(schema.tableExists("Peach")); }
@Test public void testTableExistsNotCaseSensitive() { assertTrue(schema.tableExists("APPLE")); assertTrue(schema.tableExists("apple")); } |
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(); } | @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); } |
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(); } } | @Test public void testEscapeCharacters() { for (TestCase testCase : testCases) { assertEquals(testCase.escaped, escapeCharacters(testCase.unescaped)); } } |
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(); } } | @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")); } |
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); } | @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()); } |
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(); } | @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)); } } |
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); } | @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()); } |
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); } | @Test public void testToUpperCase() { assertEquals( Arrays.asList("ONE", "TWO", "THREE"), SchemaUtils.toUpperCase(Arrays.asList("One", "two", "thReE")) ); } |
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(); } | @Test public void testOrdering() { assertSame("Bar table", schema1.getTable("Bar"), new CompositeSchema(schema1, schema2).getTable("Bar")); } |
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); } | @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); } |
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); } | @Test public void testIndexWithName() { String indexName = "indexName"; Table table = table("tableName").indexes(index(indexName)); assertEquals("Incorrect index", TableHelper.indexWithName(table, indexName).getName(), indexName); } |
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); } | @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)); } |
SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } | @Test public void testValidSchema() { Schema validSchema = schema(simpleValidTable, edgeCaseValidTable); SchemaValidator validator = new SchemaValidator(); validator.validate(validSchema); }
@Test public void testInvalidTableName() { Schema invalidTableNameSchema = schema(simpleValidTable, invalidTableNameTable); try { SchemaValidator validator = new SchemaValidator(); validator.validate(invalidTableNameSchema); fail("Expected a RuntimeException for an invalid table name"); } catch (RuntimeException e) { assertTrue("Expected [" + INVALID_NAME_31_CHARACTERS + "] in error message", e.getMessage().contains(INVALID_NAME_31_CHARACTERS)); } }
@Test public void testValidTableNames() { SchemaValidator validator = new SchemaValidator(); validator.validate( table("Table_with_underscores").columns( column("id", DataType.BIG_INTEGER).primaryKey() ) ); }
@Test public void testValidViewNames() { SchemaValidator validator = new SchemaValidator(); validator.validate(view("View_with_underscores", null)); validator.validate(view(EDGE_CASE_VALID_NAME_30_CHARACTERS, null)); validator.validate(view("ABCDEFGHIJKLMNOPQRSTUVWXYZ", null)); validator.validate(view("abcdefghijklmnopqrstuvwxyz", null)); validator.validate(view("a1234567890", null)); }
@Test public void testInvalidViewNames() { try { SchemaValidator validator = new SchemaValidator(); validator.validate(view(INVALID_NAME_31_CHARACTERS, null)); fail("should have thrown an exception"); } catch (RuntimeException e) { assertTrue("Expected [ " + INVALID_NAME_31_CHARACTERS + "] in error message", e.getMessage().contains(INVALID_NAME_31_CHARACTERS)); } final String badViewName = "NameWithBadCharacter!"; try { SchemaValidator validator = new SchemaValidator(); validator.validate(view(badViewName, null)); fail("should have thrown an exception"); } catch (RuntimeException e) { assertTrue("Expected [ " + badViewName + "] in error message", e.getMessage().contains(badViewName)); } }
@Test public void testValidViewColumnNames() { SchemaValidator validator = new SchemaValidator(); TableReference table = tableRef("Foo"); SelectStatement selectStatement = select(table.field(EDGE_CASE_VALID_NAME_30_CHARACTERS), table.field("Column_with_underscores"), table.field("ABCDEFGHIJKLMNOPQRSTUVWXYZ"), table.field("abcdefghijklmnopqrstuvwxyz"), table.field("a1234567890")); validator.validate(view("SimpleView", selectStatement)); }
@Test public void testInvalidViewColumnNames() { final String columnWithBadCharacters = "Column_with?!"; final String columnWithReservedWords = "operator"; try { TableReference table = tableRef("Foo"); SelectStatement selectStatement = select(table.field(INVALID_NAME_31_CHARACTERS), table.field(columnWithBadCharacters), table.field(columnWithReservedWords)); SchemaValidator validator = new SchemaValidator(); validator.validate(view("SimpleView", selectStatement)); fail("should have thrown an exception"); } catch (RuntimeException e) { assertTrue("Expected [ " + INVALID_NAME_31_CHARACTERS + "] in error message", e.getMessage().contains(INVALID_NAME_31_CHARACTERS)); assertTrue("Expected [ " + columnWithBadCharacters + "] in error message", e.getMessage().contains(columnWithBadCharacters)); assertTrue("Expected [ " + columnWithReservedWords + "] in error message", e.getMessage().contains(columnWithReservedWords)); } }
@Test public void testInvalidIndexName() { Schema invalidIndexNameSchema = schema(simpleValidTable, invalidIndexNameTable); try { SchemaValidator validator = new SchemaValidator(); validator.validate(invalidIndexNameSchema); fail("Expected a RuntimeException for an invalid index name"); } catch (RuntimeException e) { assertTrue("Expected [InvalidIndexName31CharactersXxx] in error message", e.getMessage().contains("InvalidIndexName31CharactersXxx")); } }
@Test public void testInvalidColumnName() { Schema invalidColumnNameSchema = schema(simpleValidTable, invalidColumnNameTable); try { SchemaValidator validator = new SchemaValidator(); validator.validate(invalidColumnNameSchema); fail("Expected a RuntimeException for an invalid column name"); } catch (RuntimeException e) { assertTrue("Expected [Invalid31CharacterColumnNameXxx] in error message: "+e.getMessage(), e.getMessage().contains("Invalid31CharacterColumnNameXxx")); } }
@Test public void testIndexesThatDuplicatesId() { Schema schema = schema( table("SomeValidTableName") .columns( column("column1", DataType.STRING).nullable() ).indexes( index("badIndex").unique().columns("id") ) ); try { new SchemaValidator().validate(schema); fail("Expected a RuntimeException for an invalid index: [badIndex]"); } catch (RuntimeException e) { assertTrue("Expected badIndex in error message", e.getMessage().contains("badIndex")); } }
@Test public void testDuplicateIndexes() { Schema schema = schema( table("SomeValidTableName") .columns( column("column1", DataType.STRING).nullable(), column("column2", DataType.STRING).nullable() ).indexes( index("index1").unique().columns("column1", "column2"), index("index2").unique().columns("column1", "column2") ) ); try { new SchemaValidator().validate(schema); fail("Expected a RuntimeException for an duplicate index: [index1] [index2]"); } catch (RuntimeException e) { assertTrue("Expected index1 in error message", e.getMessage().contains("index1")); assertTrue("Expected index2 in error message", e.getMessage().contains("index2")); } }
@Test public void testIndexesThatDuplicatesPrimaryIndex() { Schema schema = schema( table("SomeValidTableName") .columns( column("column1", DataType.STRING, 15).primaryKey() ).indexes( index("index1").unique().columns("column1") ) ); try { new SchemaValidator().validate(schema); fail("Expected a RuntimeException for an duplicate index: [index1] [PRIMARY]"); } catch (RuntimeException e) { assertTrue("Expected index1 in error message", e.getMessage().contains("index1")); assertTrue("Expected index2 in error message", e.getMessage().contains("PRIMARY")); } }
@Test public void testIndexesThatDuplicatesCompositePrimaryIndex() { Schema schema = schema( table("SomeValidTableName") .columns( column("column1", DataType.STRING, 15).primaryKey(), column("column2", DataType.STRING, 15).primaryKey(), column("column3", DataType.STRING, 15) ).indexes( index("index1").unique().columns("column1", "column2") ) ); try { new SchemaValidator().validate(schema); fail("Expected a RuntimeException for an duplicate index: [index1]"); } catch (RuntimeException e) { assertTrue("Expected index1 in error message", e.getMessage().contains("index1")); assertTrue("Expected index2 in error message", e.getMessage().contains("PRIMARY")); } }
@Test public void testInvalidColumnWidthTable() { Schema schema = schema(table("InvalidColumnWidthTable") .columns( column("myName", DataType.STRING, 20).nullable(), column("dateOfBirth", DataType.DECIMAL, 8).nullable(), column("gender", DataType.STRING, 0).nullable(), column("vo2Max", DataType.DECIMAL, 0).nullable(), column("restingHeartRate", DataType.INTEGER, 0).nullable() ) ); try { new SchemaValidator().validate(schema); fail("Expected a RuntimeException for an invalid zero width column"); } catch (RuntimeException e) { assertTrue("Expected column gender in error message: "+e.getMessage(), e.getMessage().contains("[gender]")); assertTrue("Expected column vo2Max in error message", e.getMessage().contains("[vo2Max]")); assertFalse("Don't expect column myName in error message", e.getMessage().contains("myName")); assertFalse("Don't expect column dateOfBirth in error message", e.getMessage().contains("dateOfBirth")); assertFalse("Don't expect column restingHeartRate in error message", e.getMessage().contains("restingHeartRate")); } }
@Test public void testInvalidPrimaryKeyAndNullableColumn() { Table invalidPkAndNullable = table("InvalidColumn") .columns( column("pkandnullable", DataType.STRING, 10).nullable().primaryKey() ); try { new SchemaValidator().validate(schema(invalidPkAndNullable)); fail(); } catch (RuntimeException e) { assertTrue(e.getMessage().contains("pkandnullable")); assertTrue(e.getMessage().contains("InvalidColumn")); } try { new SchemaValidator().validate(invalidPkAndNullable); fail(); } catch (RuntimeException e) { assertTrue(e.getMessage().contains("pkandnullable")); assertTrue(e.getMessage().contains("InvalidColumn")); } } |
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); } | @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")); } |
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); } | @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)); } |
SchemaHomology { public boolean schemasMatch(Schema schema1, Schema schema2, Collection<String> exclusionRegex) { noDifferences = true; HashMap<String, Table> schema2Tables = new HashMap<String, Table>(); for (Table table : schema2.tables()) { schema2Tables.put(table.getName().toUpperCase(), table); } Set<String> additionalTablesInSchema1 = Sets.newHashSet(); Set<String> additionalTablesInSchema2 = Sets.newHashSet(); for (Table table : schema1.tables()) { Table table2 = schema2Tables.remove(table.getName().toUpperCase()); if (table2 == null) { additionalTablesInSchema1.add(table.getName().toUpperCase()); } else { checkTable(table, table2); } } for (Table table : schema2Tables.values()) { additionalTablesInSchema2.add(table.getName().toUpperCase()); } for (String currentRegex : exclusionRegex) { Pattern currentPattern; try { currentPattern = Pattern.compile(currentRegex, CASE_INSENSITIVE); } catch (PatternSyntaxException e) { throw new RuntimeException(String.format("Could not compile regular expression: [%s]", currentRegex), e); } for (Iterator<String> iterator = additionalTablesInSchema1.iterator(); iterator.hasNext(); ) { String tableName = iterator.next(); if (currentPattern.matcher(tableName).matches()) { log.info(String.format("Table [%s] is not present in %s but was ignored as it matches the exclusion pattern [%s]", tableName, schema2, currentRegex)); iterator.remove(); } } for (Iterator<String> iterator = additionalTablesInSchema2.iterator(); iterator.hasNext(); ) { String tableName = iterator.next(); if (currentPattern.matcher(tableName).matches()) { log.info(String.format("Table [%s] is not present in %s but was ignored as it matches the exclusion pattern [%s]", tableName, schema1, currentRegex)); iterator.remove(); } } } for (String tableName : additionalTablesInSchema1) { difference("Table [" + tableName + "] is present in " + schema1Name + " but was not found in " + schema2Name); } for (String tableName : additionalTablesInSchema2) { difference("Table [" + tableName + "] is present in " + schema2Name + " but was not found in " + schema1Name); } 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); } | @Test public void testIdenticalSchemas() { Schema schema1 = schema(appleTable, pearTable, simpleTable); Schema schema2 = schema(appleTable, pearTable, simpleTable); boolean match = schemaHomology.schemasMatch(schema1, schema2, Sets.<String>newHashSet()); assertTrue(match); }
@Test public void testSchemasWithDifferentTables() { Schema schema1 = schema(appleTable, pearTable, simpleTable); Schema schema2 = schema(appleTable, pearTable); assertFalse(schemaHomology.schemasMatch(schema1, schema2, Sets.<String>newHashSet())); assertEquals(ImmutableSet.of("Table [MYTABLE] is present in SCHEMA1 but was not found in SCHEMA2"), differences); }
@Test public void testSchemasWithDifferentTablesReversed() { Schema schema1 = schema(appleTable, pearTable); Schema schema2 = schema(appleTable, pearTable, simpleTable); assertFalse(schemaHomology.schemasMatch(schema1, schema2, Sets.<String>newHashSet())); assertEquals(ImmutableSet.of("Table [MYTABLE] is present in SCHEMA2 but was not found in SCHEMA1"), differences); }
@Test public void testSchemasWithDifferentTableDefinitions() { Schema schema1 = schema(appleTable, pearTable, simpleTable); Schema schema2 = schema(appleTableMissingIndex, pearTable, simpleTable); assertFalse(schemaHomology.schemasMatch(schema1, schema2, Sets.<String>newHashSet())); }
@Test public void testDifferingSchemasWithExcludedTablesMatch() { Schema schema1 = schema(appleTable, pearTable, simpleTable); Schema schema2 = schema(appleTable, pearTable); Set<String> exclusionRegex = Sets.newHashSet("MYTABLE"); assertTrue("Schemas", schemaHomology.schemasMatch(schema1, schema2, exclusionRegex)); }
@Test public void testDifferingSchemasWithoutExcludedTablesDoNotMatch() { Schema schema1 = schema(appleTable, pearTable, simpleTable); Schema schema2 = schema(appleTable, pearTable); assertFalse("Schemas", schemaHomology.schemasMatch(schema1, schema2, Sets.<String>newHashSet())); }
@Test public void testSchemasDoNotMatchWhenNoMatchingRegexIsFound() { Schema schema1 = schema(appleTable, pearTable, simpleTable); Schema schema2 = schema(appleTable, pearTable); Set<String> exclusionRegex = Sets.newHashSet(".*YOURTABLE"); assertFalse("Schemas", schemaHomology.schemasMatch(schema1, schema2, exclusionRegex)); }
@Test public void testSchemasMatchWhenRegexMatchesMultipleTables() { Table table1 = table("AbcTable"); Table table2 = table("AbcChair"); Table table3 = table("AbcSofa"); Set<String> exclusionRegex = Sets.newHashSet("^ABC.*"); Schema schema1 = schema(appleTable, pearTable, table1, table2, table3); Schema schema2 = schema(appleTable, pearTable); assertTrue("Schemas", schemaHomology.schemasMatch(schema1, schema2, exclusionRegex)); }
@Test public void testRegexesAreCaseInsensitive() { Table table1 = table("AbcTable"); Table table2 = table("AbcChair"); Table table3 = table("AbcSofa"); Set<String> exclusionRegex = Sets.newHashSet("^aBc.*"); Schema schema1 = schema(appleTable, pearTable, table1, table2, table3); Schema schema2 = schema(appleTable, pearTable); assertTrue("Schemas", schemaHomology.schemasMatch(schema1, schema2, exclusionRegex)); }
@Test public void testSchemasDoNotMatchWhenOneTableIsMisMatchedButIsAlsoCoveredBhTheExclusionRegex() { Set<String> exclusionRegex = Sets.newHashSet("APPLE"); Schema schema1 = schema(appleTable, pearTable); Schema schema2 = schema(appleTableWithExtraColumn, pearTable); assertFalse("Schemas", schemaHomology.schemasMatch(schema1, schema2, exclusionRegex)); }
@Test(expected=RuntimeException.class) public void testRuntimeExceptionThrownWhenGivenInvalidRegex() { Set<String> exclusionRegex = Sets.newHashSet("(A-B)+++++++++"); Schema schema1 = schema(appleTable, pearTable); Schema schema2 = schema(appleTable, pearTable, simpleTable); schemaHomology.schemasMatch(schema1, schema2, exclusionRegex); fail("Did not throw RuntimeException"); } |
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); } | @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))); } |
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); } | @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"))); } |
SQLEntityNameValidationService { public boolean isNameConventional(String name) { return schemaValidator.isNameConventional(name); } @Inject SQLEntityNameValidationService(); boolean isReservedWord(String word); boolean isNameConventional(String name); boolean isEntityNameLengthValid(String name); } | @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); } |
SQLEntityNameValidationService { public boolean isReservedWord(String word) { return schemaValidator.isSQLReservedWord(word); } @Inject SQLEntityNameValidationService(); boolean isReservedWord(String word); boolean isNameConventional(String name); boolean isEntityNameLengthValid(String name); } | @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); } |
SQLEntityNameValidationService { public boolean isEntityNameLengthValid(String name) { return schemaValidator.isEntityNameLengthValid(name); } @Inject SQLEntityNameValidationService(); boolean isReservedWord(String word); boolean isNameConventional(String name); boolean isEntityNameLengthValid(String name); } | @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); } |
DataSetUtils { public static RecordBuilder record() { return new RecordBuilderImpl(); } static RecordBuilder record(); static StatementParametersBuilder statementParameters(); static DataSetProducerBuilder dataSetProducer(Schema schema); } | @Test public void testIntegerGetters() { assertEquals(-1, record().setInteger(INTEGER_COLUMN, -1).getInteger(INTEGER_COLUMN).intValue()); assertEquals(0, record().setInteger(INTEGER_COLUMN, 0).getInteger(INTEGER_COLUMN).intValue()); assertEquals(1, record().setInteger(INTEGER_COLUMN, 1).getInteger(INTEGER_COLUMN).intValue()); assertEquals(INTEGER, BASE_RECORD.getInteger(INTEGER_COLUMN)); assertEquals(INTEGER.longValue(), BASE_RECORD.getLong(INTEGER_COLUMN).longValue()); assertEquals(INTEGER.doubleValue(), BASE_RECORD.getDouble(INTEGER_COLUMN).doubleValue(), 0.00001); assertEquals(new BigDecimal(INTEGER), BASE_RECORD.getBigDecimal(INTEGER_COLUMN)); }
@Test public void testBigDecimalGetters() { assertEquals(BigDecimal.ZERO, record().setBigDecimal(BIG_DECIMAL_COLUMN, BigDecimal.ZERO).getBigDecimal(BIG_DECIMAL_COLUMN)); assertEquals(BigDecimal.ONE, record().setBigDecimal(BIG_DECIMAL_COLUMN, BigDecimal.ONE).getBigDecimal(BIG_DECIMAL_COLUMN)); assertEquals(BIG_DECIMAL.longValue(), BASE_RECORD.getLong(BIG_DECIMAL_COLUMN).longValue()); assertEquals(BIG_DECIMAL.intValue(), BASE_RECORD.getInteger(BIG_DECIMAL_COLUMN).intValue()); assertEquals(BIG_DECIMAL.doubleValue(), BASE_RECORD.getDouble(BIG_DECIMAL_COLUMN).doubleValue(), 0.00001); assertEquals(BIG_DECIMAL, BASE_RECORD.getBigDecimal(BIG_DECIMAL_COLUMN)); }
@Test public void testLongGetters() { assertEquals(-1L, record().setLong(LONG_COLUMN, -1L).getLong(LONG_COLUMN).longValue()); assertEquals(0L, record().setLong(LONG_COLUMN, 0L).getLong(LONG_COLUMN).longValue()); assertEquals(1L, record().setLong(LONG_COLUMN, 1L).getLong(LONG_COLUMN).longValue()); assertEquals(LONG, BASE_RECORD.getLong(LONG_COLUMN)); assertEquals(LONG.intValue(), BASE_RECORD.getInteger(LONG_COLUMN).intValue()); assertEquals(LONG.doubleValue(), BASE_RECORD.getDouble(LONG_COLUMN).doubleValue(), 0.00001); assertEquals(new BigDecimal(LONG), BASE_RECORD.getBigDecimal(LONG_COLUMN)); }
@Test public void testDoubleGetters() { String col = "CoL"; assertEquals(0.1123D, record().setDouble(col, 0.1123D).getDouble(col).doubleValue(), 0.00001); assertEquals(new BigDecimal("0.1123"), record().setDouble(col, 0.1123D).getBigDecimal(col).setScale(4, RoundingMode.HALF_UP)); }
@Test public void testStringGetters() { String col = "CoL"; assertEquals("010.00", record().setString(col, "010.00").getString(col)); assertEquals(10L, record().setString(col, "10") .getLong(col).longValue()); assertEquals(10, record().setString(col, "10") .getInteger(col).intValue()); assertEquals(10D, record().setString(col, "10") .getDouble(col).doubleValue(), 0.00001); assertEquals(new BigDecimal("10.00"), record().setString(col, "010.00").getBigDecimal(col)); assertEquals(new LocalDate(2009, 12, 31), record().setString(col, "2009-12-31").getLocalDate(col)); assertEquals(java.sql.Date.valueOf("2009-12-31"), record().setString(col, "2009-12-31").getDate(col)); assertEquals(true, record().setString(col, "true") .getBoolean(col)); assertEquals(false, record().setString(col, "false").getBoolean(col)); assertEquals(false, record().setString(col, "tru") .getBoolean(col)); byte[] blobValue = new byte[] { 1, 2, 3, 4, 5 }; assertEquals(encodeToBase64String(blobValue), record().setString(col, encodeToBase64String(blobValue)).getString(col)); assertArrayEquals(blobValue, record().setString(col, encodeToBase64String(blobValue)).getByteArray(col)); }
@Test public void testBooleanGetters() { String col = "CoL"; assertEquals(true, record().setBoolean(col, true).getBoolean(col)); assertEquals(false, record().setBoolean(col, false).getBoolean(col)); assertEquals("true", record().setBoolean(col, true).getString(col)); assertEquals("false", record().setBoolean(col, false).getString(col)); }
@Test public void testDateGetters() { String col = "CoL"; Date dateValue = java.sql.Date.valueOf("1977-10-10"); LocalDate localDateValue = new LocalDate(1977, 10, 10); assertEquals(dateValue, record().setDate(col, dateValue).getDate(col)); assertEquals(dateValue.toString(), record().setDate(col, dateValue).getString(col)); assertEquals(localDateValue, record().setDate(col, dateValue).getLocalDate(col)); }
@Test public void testLocalDateGetters() { String col = "CoL"; Date dateValue = java.sql.Date.valueOf("1977-10-10"); LocalDate localDateValue = new LocalDate(1977, 10, 10); assertEquals(localDateValue, record().setLocalDate(col, localDateValue).getLocalDate(col)); assertEquals(localDateValue.toString(), record().setLocalDate(col, localDateValue).getString(col)); assertEquals(dateValue, record().setLocalDate(col, localDateValue).getDate(col)); }
@Test public void testNoValueFromDecorator() { assertNull(RecordDecorator.of(record()).getInteger(INTEGER_COLUMN)); }
@Test public void testNullValueFromDecorator() { assertNull(RecordDecorator.of(record().setInteger(INTEGER_COLUMN, null)).getInteger(INTEGER_COLUMN)); }
@Test public void testNullOverrideFromDecorator() { assertNull(RecordDecorator.of(record().setInteger(INTEGER_COLUMN, 3)).setInteger(INTEGER_COLUMN, null).getInteger(INTEGER_COLUMN)); }
@Test public void testOverwriteValue() { assertEquals("B", record().setString("a", "A").setString("a", "B").getString("a")); }
@SuppressWarnings("deprecation") @Test public void testOverwriteValueWithNull() { assertNull(record().setString("a", "A").value("a", null).getString("a")); }
@SuppressWarnings("deprecation") @Test public void testOverwriteNullWithValue() { assertEquals("B", record().setString("a", null).value("a", "B").getString("a")); }
@Test public void testInternedMetadataAfterDeserialization() throws ClassNotFoundException, IOException { RecordBuilderImpl original = (RecordBuilderImpl) record() .setString("one", "1") .setString("two", "2") .setString("three", "3"); RecordBuilderImpl copy = (RecordBuilderImpl) serializeAndDeserialize(original); original.setString("four", "4"); copy.setString("four", "4"); assertThat(copy, equalTo(original)); assertTrue(original.hasSameMetadata(copy)); } |
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); } | @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); } |
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); } | @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()); } |
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); } | @Test public void testInnerExpression() { assertEquals(plus(literal(1), literal(2)), onTest.getInnerExpression()); } |
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); } | @Test public void testDrive() { ObjectTreeTraverser.Callback callback = mock(ObjectTreeTraverser.Callback.class); onTest.drive(ObjectTreeTraverser.forCallback(callback)); verify(callback).visit(onTest.getInnerExpression()); } |
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); } | @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()); } |
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(); } | @Test public void testHashCode() { assertEquals(isEqual.hashCode(), onTest.hashCode()); assertEquals(isEqualAliased.hashCode(), onTestAliased.hashCode()); } |
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(); } | @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); } |
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(); } | @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")); }); } |
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(); } | @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); } |
ExistingViewStateLoader { public Result viewChanges(Schema sourceSchema, Schema targetSchema) { Map<String, View> viewsToDrop = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); for (View view : sourceSchema.views()) { viewsToDrop.put(view.getName().toUpperCase(), view); } Set<View> viewsToDeploy = new HashSet<>(targetSchema.views()); Optional<Map<String, String>> deployedViews = existingViewHashLoader.loadViewHashes(sourceSchema); if (deployedViews.isPresent()) { for (View view : targetSchema.views()) { String targetViewName = view.getName().toUpperCase(); if (viewsToDrop.containsKey(targetViewName)) { String existingHash = deployedViews.get().get(targetViewName); String newHash = dialect.convertStatementToHash(view.getSelectStatement()); if (existingHash == null) { log.info(String.format("View [%s] exists but hash not present in %s", targetViewName, DEPLOYED_VIEWS_NAME)); } else if (newHash.equals(existingHash)) { viewsToDrop.remove(targetViewName); viewsToDeploy.remove(view); } else { log.info( String.format( "View [%s] exists in %s, but hash [%s] does not match target schema [%s]", targetViewName, DEPLOYED_VIEWS_NAME, existingHash, newHash ) ); } } else { if (deployedViews.get().containsKey(targetViewName)) { log.info(String.format("View [%s] is missing, but %s entry exists. The view may have been deleted.", targetViewName, DEPLOYED_VIEWS_NAME)); viewsToDrop.put(targetViewName, view); } else { log.info(String.format("View [%s] is missing", targetViewName)); } } } } return new Result(viewsToDrop.values(), viewsToDeploy); } ExistingViewStateLoader(SqlDialect dialect, ExistingViewHashLoader existingViewHashLoader); Result viewChanges(Schema sourceSchema, Schema targetSchema); } | @Test public void testNoChanges() { Schema sourceSchema = schema( view("View1", select(literal("x")).from(tableRef("a"))), view("VIEW2", select(literal("y")).from(tableRef("b"))), view("view3", select(literal("z")).from(tableRef("c"))) ); Schema targetSchema = schema( view("VIEW1", select(literal("x")).from(tableRef("a"))), view("view2", select(literal("y")).from(tableRef("b"))), view("View3", select(literal("z")).from(tableRef("c"))) ); when(existingViewHashLoader.loadViewHashes(sourceSchema)).thenReturn(Optional.<Map<String, String>>of(ImmutableMap.of( "VIEW1", "xa", "VIEW2", "yb", "VIEW3", "zc" ))); assertTrue("No changes", onTest.viewChanges(sourceSchema, targetSchema).isEmpty()); }
@Test public void testNoChangesButNoDeployedViewsTable() { View sourceView1 = view("View1", select(literal("x")).from(tableRef("a"))); View sourceView2 = view("VIEW2", select(literal("y")).from(tableRef("b"))); View sourceView3 = view("view3", select(literal("z")).from(tableRef("c"))); Schema sourceSchema = schema(sourceView1, sourceView2, sourceView3); View targetView1 = view("VIEW1", select(literal("x")).from(tableRef("a"))); View targetView2 = view("view2", select(literal("y")).from(tableRef("b"))); View targetView3 = view("View3", select(literal("z")).from(tableRef("c"))); Schema targetSchema = schema(targetView1, targetView2, targetView3); when(existingViewHashLoader.loadViewHashes(sourceSchema)).thenReturn(Optional.<Map<String, String>>empty()); Result viewChanges = onTest.viewChanges(sourceSchema, targetSchema); assertThat( "Deploying all target views", viewChanges.getViewsToDeploy(), containsInAnyOrder(targetView1, targetView2, targetView3) ); assertThat( "Dropping all source views", viewChanges.getViewsToDrop(), containsInAnyOrder(sourceView1, sourceView2, sourceView3) ); }
@Test public void testNoChangesButEmptyDeployedViewsTable() { View sourceView1 = view("View1", select(literal("x")).from(tableRef("a"))); View sourceView2 = view("VIEW2", select(literal("y")).from(tableRef("b"))); Schema sourceSchema = schema(sourceView1, sourceView2); View targetView1 = view("VIEW1", select(literal("x")).from(tableRef("a"))); View targetView2 = view("view2", select(literal("y")).from(tableRef("b"))); Schema targetSchema = schema(targetView1, targetView2); when(existingViewHashLoader.loadViewHashes(sourceSchema)).thenReturn(Optional.<Map<String, String>>of(ImmutableMap.<String, String>of())); Result viewChanges = onTest.viewChanges(sourceSchema, targetSchema); assertThat( "Deploying all target views", viewChanges.getViewsToDeploy(), containsInAnyOrder(targetView1, targetView2) ); assertThat( "Dropping all source views", viewChanges.getViewsToDrop(), containsInAnyOrder(sourceView1, sourceView2) ); }
@Test public void testDropUnwantedViews() { View sourceView1 = view("View1", select(literal("x")).from(tableRef("a"))); View sourceView2 = view("VIEW2", select(literal("y")).from(tableRef("b"))); View sourceViewOld1= view("Old1", select(literal("z")).from(tableRef("c"))); View sourceViewOld2= view("Old2", select(literal("z")).from(tableRef("c"))); Schema sourceSchema = schema(sourceView1, sourceView2, sourceViewOld1, sourceViewOld2); View targetView1 = view("VIEW1", select(literal("x")).from(tableRef("a"))); View targetView2 = view("view2", select(literal("y")).from(tableRef("b"))); Schema targetSchema = schema(targetView1, targetView2); when(existingViewHashLoader.loadViewHashes(sourceSchema)).thenReturn(Optional.<Map<String, String>>of(ImmutableMap.of( "VIEW1", "xa", "VIEW2", "yb" ))); Result viewChanges = onTest.viewChanges(sourceSchema, targetSchema); assertThat("Nothing to deploy", viewChanges.getViewsToDeploy(), Matchers.hasSize(0)); assertThat("Dropping unnecessary view", viewChanges.getViewsToDrop(), containsInAnyOrder(sourceViewOld1, sourceViewOld2)); }
@Test public void testDeployMissingViews() { View sourceView1 = view("View1", select(literal("x")).from(tableRef("a"))); View sourceView2 = view("VIEW2", select(literal("y")).from(tableRef("b"))); Schema sourceSchema = schema(sourceView1, sourceView2); View targetView1 = view("VIEW1", select(literal("x")).from(tableRef("a"))); View targetView2 = view("view2", select(literal("y")).from(tableRef("b"))); View targetViewNew1= view("New1", select(literal("z")).from(tableRef("c"))); View targetViewNew2= view("New2", select(literal("z")).from(tableRef("c"))); Schema targetSchema = schema(targetView1, targetView2, targetViewNew1, targetViewNew2); when(existingViewHashLoader.loadViewHashes(sourceSchema)).thenReturn(Optional.<Map<String, String>>of(ImmutableMap.of( "VIEW1", "xa", "VIEW2", "yb" ))); Result viewChanges = onTest.viewChanges(sourceSchema, targetSchema); assertThat("Deploy new views", viewChanges.getViewsToDeploy(), containsInAnyOrder(targetViewNew1, targetViewNew2)); assertThat("Nothing to drop", viewChanges.getViewsToDrop(), Matchers.hasSize(0)); }
@Test public void testDeployMissingViewsAndCleanUpOrphanedDeployedViewsRecord() { View sourceView1 = view("View1", select(literal("x")).from(tableRef("a"))); View sourceView2 = view("VIEW2", select(literal("y")).from(tableRef("b"))); Schema sourceSchema = schema(sourceView1, sourceView2); View targetView1 = view("VIEW1", select(literal("x")).from(tableRef("a"))); View targetView2 = view("view2", select(literal("y")).from(tableRef("b"))); View targetViewNew1= view("New1", select(literal("z")).from(tableRef("c"))); View targetViewNew2= view("New2", select(literal("z")).from(tableRef("c"))); Schema targetSchema = schema(targetView1, targetView2, targetViewNew1, targetViewNew2); when(existingViewHashLoader.loadViewHashes(sourceSchema)).thenReturn(Optional.<Map<String, String>>of(ImmutableMap.of( "VIEW1", "xa", "VIEW2", "yb", "NEW1", "zc", "NEW2", "zc" ))); Result viewChanges = onTest.viewChanges(sourceSchema, targetSchema); assertThat("Deploy new views", viewChanges.getViewsToDeploy(), containsInAnyOrder(targetViewNew1, targetViewNew2)); assertThat("Drop the orphaned DeployedViews records", viewChanges.getViewsToDrop(), containsInAnyOrder(targetViewNew1, targetViewNew2)); }
@Test public void testMismatchedHash() { View sourceView1 = view("View1", select(literal("x")).from(tableRef("a"))); View sourceView2 = view("VIEW2", select(literal("y")).from(tableRef("b"))); View sourceView3 = view("view3", select(literal("z")).from(tableRef("c"))); Schema sourceSchema = schema(sourceView1, sourceView2, sourceView3); View targetView1 = view("VIEW1", select(literal("CHANGED")).from(tableRef("a"))); View targetView2 = view("view2", select(literal("y")).from(tableRef("b"))); View targetView3 = view("View3", select(literal("z")).from(tableRef("CHANGED"))); Schema targetSchema = schema(targetView1, targetView2, targetView3); when(existingViewHashLoader.loadViewHashes(sourceSchema)).thenReturn(Optional.<Map<String, String>>of(ImmutableMap.of( "VIEW1", "xa", "VIEW2", "yb", "VIEW3", "zc" ))); Result viewChanges = onTest.viewChanges(sourceSchema, targetSchema); assertThat("Deploy new views", viewChanges.getViewsToDeploy(), containsInAnyOrder(targetView1, targetView3)); assertThat("Drop the orphaned DeployedViews records", viewChanges.getViewsToDrop(), containsInAnyOrder(sourceView1, sourceView3)); } |
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); } | @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]")); } |
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); } | @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")); } |
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); } | @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); } |
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); } | @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(); } |
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); } | @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(); } |
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); } | @Test public void testIsCausedByTimeoutForSQLTimeoutException() { assertEquals(true, databaseExceptionHelper.isCausedByTimeoutException(new ExtendsSQLTimeoutException())); }
@Test public void testIsCausedByTimeoutForMySQLTimeoutException() { assertEquals(true, databaseExceptionHelper.isCausedByTimeoutException(new MySQLTimeoutException())); } |
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(); } | @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)); } |
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); } | @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()); } } |
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); } | @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(); } |
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); } | @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()); } |
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(); } | @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()); } |
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(); } | @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) { } } |
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(); } | @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()); } |
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(); } | @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")); } |
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(); } | @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) { } } |
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(); } | @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); } |
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); } | @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); } |
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(); } | @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()); } |
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(); } | @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")); } |
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); } | @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()); } |
Upgrade { public UpgradePath findPath(Schema targetSchema, Collection<Class<? extends UpgradeStep>> upgradeSteps, Collection<String> exceptionRegexes) { final List<String> upgradeStatements = new ArrayList<>(); UpgradeStatus status = upgradeStatusTableService.getStatus(Optional.of(dataSource)); if (status != UpgradeStatus.NONE) { return new UpgradePath(status); } new SchemaValidator().validate(targetSchema); log.info("Reading current schema"); Schema sourceSchema = copySourceSchema(connectionResources, dataSource, exceptionRegexes); SqlDialect dialect = connectionResources.sqlDialect(); log.info("Examining current views"); ExistingViewStateLoader existingViewState = new ExistingViewStateLoader(dialect, new ExistingViewHashLoader(dataSource, dialect)); Result viewChangeInfo = existingViewState.viewChanges(sourceSchema, targetSchema); ViewChanges viewChanges = new ViewChanges(targetSchema.views(), viewChangeInfo.getViewsToDrop(), viewChangeInfo.getViewsToDeploy()); log.info("Searching for upgrade path from [" + sourceSchema + "] to [" + targetSchema + "]"); ExistingTableStateLoader existingTableState = new ExistingTableStateLoader(dataSource, dialect); UpgradePathFinder pathFinder = new UpgradePathFinder(upgradeSteps, existingTableState.loadAppliedStepUUIDs()); SchemaChangeSequence schemaChangeSequence; status = upgradeStatusTableService.getStatus(Optional.of(dataSource)); if (status != UpgradeStatus.NONE) { return new UpgradePath(status); } try { schemaChangeSequence = pathFinder.determinePath(sourceSchema, targetSchema, exceptionRegexes); } catch (NoUpgradePathExistsException e) { log.debug("No upgrade path found - checking upgrade status", e); status = upgradeStatusTableService.getStatus(Optional.of(dataSource)); if (status != UpgradeStatus.NONE) { log.info("Schema differences found, but upgrade in progress - no action required until upgrade is complete"); return new UpgradePath(status); } else { throw e; } } if (!schemaChangeSequence.getUpgradeSteps().isEmpty()) { InlineTableUpgrader upgrader = new InlineTableUpgrader(sourceSchema, dialect, new SqlStatementWriter() { @Override public void writeSql(Collection<String> sql) { upgradeStatements.addAll(sql); } }, SqlDialect.IdTable.withPrefix(dialect, "temp_id_")); upgrader.preUpgrade(); schemaChangeSequence.applyTo(upgrader); upgrader.postUpgrade(); } List<UpgradeStep> upgradesToApply = new ArrayList<>(schemaChangeSequence.getUpgradeSteps()); if (upgradesToApply.isEmpty() && !viewChanges.isEmpty()) { upgradesToApply.add(new UpgradeStep() { @Override public String getJiraId() { return "\u2014"; } @Override public String getDescription() { return "Update database views"; } @Override public void execute(SchemaEditor schema, DataEditor data) { } }); } else if (!upgradesToApply.isEmpty()) { viewChanges = viewChanges.droppingAlso(sourceSchema.views()).deployingAlso(targetSchema.views()); } return buildUpgradePath(dialect, sourceSchema, targetSchema, upgradeStatements, viewChanges, upgradesToApply); } @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); } | @Test public void testUpgradeWithTriggerMessage() throws SQLException { ResultSet viewResultSet = mock(ResultSet.class); when(viewResultSet.next()).thenReturn(true, true, false); when(viewResultSet.getString(1)).thenReturn("FooView", "OldView"); when(viewResultSet.getString(2)).thenReturn("XXX"); ResultSet upgradeResultSet = mock(ResultSet.class); when(upgradeResultSet.next()).thenReturn(false); SqlDialect dialect = spy(new MockDialect()); when(dialect.rebuildTriggers(any(Table.class))).thenReturn(ImmutableList.of("A")); ConnectionResources connection = new MockConnectionResources(). withSchema(schema(upgradeAudit(), deployedViews(), originalCar())). withResultSet("SELECT upgradeUUID FROM UpgradeAudit", upgradeResultSet). withResultSet("SELECT name, hash FROM DeployedViews", viewResultSet). create(); when(upgradeStatusTableService.getStatus(Optional.of(connection.getDataSource()))).thenReturn(NONE); when(connection.sqlDialect()).thenReturn(dialect); UpgradePath results = new Upgrade(connection, connection.getDataSource(), upgradePathFactory(), upgradeStatusTableService).findPath( schema(upgradeAudit(), deployedViews(), upgradedCar()), ImmutableSet.<Class<? extends UpgradeStep>>of(ChangeCar.class), new HashSet<String>()); assertTrue("Trigger rebuild comment is missing.", results.getSql().contains("-- Upgrades executed. Rebuilding all triggers to account for potential changes to autonumbered columns")); }
@Test public void testUpgradeWithNoStepsToApply() { Table upgradeAudit = upgradeAudit(); Schema targetSchema = schema(upgradeAudit); Collection<Class<? extends UpgradeStep>> upgradeSteps = new ArrayList<>(); ConnectionResources mockConnectionResources = mock(ConnectionResources.class, RETURNS_DEEP_STUBS); SchemaResource schemaResource = mock(SchemaResource.class); when(mockConnectionResources.openSchemaResource(eq(mockConnectionResources.getDataSource()))).thenReturn(schemaResource); when(schemaResource.tables()).thenReturn(Arrays.asList(upgradeAudit)); UpgradePath results = new Upgrade(mockConnectionResources, mockConnectionResources.getDataSource(), upgradePathFactory(), upgradeStatusTableService).findPath(targetSchema, upgradeSteps, new HashSet<String>()); assertTrue("No steps to apply", results.getSteps().isEmpty()); assertTrue("No SQL statements", results.getSql().isEmpty()); }
@Test public void testUpgradeWithOnlyViewsToDeploy() { Table upgradeAudit = upgradeAudit(); View testView = view("FooView", select(field("name")).from(tableRef("Foo"))); Schema sourceSchema = schema(upgradeAudit); Schema targetSchema = schema( schema(upgradeAudit), schema(testView) ); Collection<Class<? extends UpgradeStep>> upgradeSteps = Collections.emptySet(); ConnectionResources connection = mock(ConnectionResources.class, RETURNS_DEEP_STUBS); when(connection.sqlDialect().viewDeploymentStatements(same(testView))).thenReturn(ImmutableList.of("A")); when(connection.sqlDialect().rebuildTriggers(any(Table.class))).thenReturn(Collections.<String>emptyList()); when(connection.openSchemaResource(eq(connection.getDataSource()))).thenReturn(new StubSchemaResource(sourceSchema)); when(upgradeStatusTableService.getStatus(Optional.of(connection.getDataSource()))).thenReturn(NONE); UpgradePath result = new Upgrade(connection, connection.getDataSource(), upgradePathFactory(), upgradeStatusTableService).findPath(targetSchema, upgradeSteps, new HashSet<String>()); assertEquals("Steps to apply " + result.getSteps(), 1, result.getSteps().size()); assertEquals("Marker step JIRA ID", "\u2014", result.getSteps().get(0).getJiraId()); assertEquals("Marker step description", "Update database views", result.getSteps().get(0).getDescription()); assertEquals("SQL", "[A]", result.getSql().toString()); }
@Test public void testUpgradeWithChangedViewsToDeploy() { Table upgradeAudit = upgradeAudit(); View otherView = view("OldView", select(field("name")).from(tableRef("Old"))); View testView = view("FooView", select(field("name")).from(tableRef("Foo"))); Schema sourceSchema = schema( schema(upgradeAudit), schema(otherView) ); Schema targetSchema = schema( schema(upgradeAudit), schema(testView) ); Collection<Class<? extends UpgradeStep>> upgradeSteps = Collections.emptySet(); ConnectionResources connection = mock(ConnectionResources.class, RETURNS_DEEP_STUBS); when(connection.sqlDialect().dropStatements(any(View.class))).thenReturn(ImmutableList.of("X")); when(connection.sqlDialect().viewDeploymentStatements(same(testView))).thenReturn(ImmutableList.of("A")); when(connection.sqlDialect().rebuildTriggers(any(Table.class))).thenReturn(Collections.<String>emptyList()); when(connection.openSchemaResource(eq(connection.getDataSource()))).thenReturn(new StubSchemaResource(sourceSchema)); when(upgradeStatusTableService.getStatus(Optional.of(connection.getDataSource()))).thenReturn(NONE); UpgradePath result = new Upgrade(connection, connection.getDataSource(), upgradePathFactory(), upgradeStatusTableService).findPath(targetSchema, upgradeSteps, new HashSet<String>()); assertEquals("Steps to apply " + result.getSteps(), 1, result.getSteps().size()); assertEquals("Marker step JIRA ID", "\u2014", result.getSteps().get(0).getJiraId()); assertEquals("Marker step description", "Update database views", result.getSteps().get(0).getDescription()); assertEquals("SQL", "[X, A]", result.getSql().toString()); }
@Test public void testUpgradeWithUpgradeStepsAndViewDeclaredButNotPresent() throws SQLException { View testView = view("FooView", select(field("name")).from(tableRef("Foo"))); Schema sourceSchema = schema( schema(upgradeAudit(), deployedViews(), originalCar()) ); Schema targetSchema = schema( schema(upgradeAudit(), deployedViews(), upgradedCar()), schema(testView) ); Collection<Class<? extends UpgradeStep>> upgradeSteps = ImmutableSet.<Class<? extends UpgradeStep>>of(ChangeCar.class); SqlDialect sqlDialect = mock(SqlDialect.class); when(sqlDialect.convertStatementToHash(any(SelectStatement.class))).thenReturn("XXX"); when(sqlDialect.dropStatements(any(View.class))).thenReturn(ImmutableList.of("X")); when(sqlDialect.viewDeploymentStatements(same(testView))).thenReturn(ImmutableList.of("A")); when(sqlDialect.convertStatementToSQL(any(InsertStatement.class), same(targetSchema))).thenReturn("C"); when(sqlDialect.convertStatementToSQL(any(DeleteStatement.class))).thenReturn("D"); when(sqlDialect.convertStatementToSQL(any(InsertStatement.class), any(Schema.class), any(Table.class))).thenReturn(new ArrayList<String>()); when(sqlDialect.dropStatements(any(Table.class))).thenReturn(new HashSet<String>()); when(sqlDialect.truncateTableStatements(any(Table.class))).thenReturn(new HashSet<String>()); when(sqlDialect.convertStatementToSQL(any(DeleteStatement.class))).thenReturn("G"); when(sqlDialect.convertCommentToSQL(any(String.class))).thenReturn("CM"); when(sqlDialect.convertStatementToSQL(any(SelectStatement.class))).then(new Answer<String>() { @Override public String answer(InvocationOnMock invocation) throws Throwable { return new MockDialect().convertStatementToSQL((SelectStatement) invocation.getArguments()[0]); } }); when(sqlDialect.tableDeploymentStatements(any(Table.class))).thenAnswer(new Answer<Collection<String>>() { @Override public Collection<String> answer(InvocationOnMock invocation) throws Throwable { return ImmutableList.of(StringUtils.defaultString(((Table)invocation.getArguments()[0]).getName(), invocation.getArguments()[0].getClass().getSimpleName())); } }); ResultSet viewResultSet = mock(ResultSet.class); when(viewResultSet.next()).thenReturn(true, true, false); when(viewResultSet.getString(1)).thenReturn("FooView", "OldView"); when(viewResultSet.getString(2)).thenReturn("XXX"); ResultSet upgradeResultSet = mock(ResultSet.class); when(upgradeResultSet.next()).thenReturn(false); ConnectionResources connection = new MockConnectionResources(). withDialect(sqlDialect). withSchema(sourceSchema). withResultSet("SELECT upgradeUUID FROM UpgradeAudit", upgradeResultSet). withResultSet("SELECT name, hash FROM DeployedViews", viewResultSet). create(); when(upgradeStatusTableService.getStatus(Optional.of(connection.getDataSource()))).thenReturn(NONE); UpgradePath result = new Upgrade(connection, connection.getDataSource(), upgradePathFactory(), upgradeStatusTableService).findPath(targetSchema, upgradeSteps, new HashSet<String>()); assertEquals("Steps to apply " + result.getSteps(), 1, result.getSteps().size()); assertEquals("Upgrade class", ChangeCar.class, result.getSteps().get(0).getClass()); assertEquals("SQL", "[G, IdTable, CM, A, C]", result.getSql().toString()); }
@Test public void testUpgradeWithUpgradeStepsAndViewDeclared() throws SQLException { View testView = view("FooView", select(field("name")).from(tableRef("Foo"))); Schema sourceSchema = schema( schema(upgradeAudit(), deployedViews(), originalCar()), schema(testView) ); Schema targetSchema = schema( schema(upgradeAudit(), deployedViews(), upgradedCar()), schema(testView) ); Collection<Class<? extends UpgradeStep>> upgradeSteps = ImmutableSet.<Class<? extends UpgradeStep>>of(ChangeCar.class); SqlDialect sqlDialect = mock(SqlDialect.class); when(sqlDialect.convertStatementToHash(any(SelectStatement.class))).thenReturn("XXX"); when(sqlDialect.dropStatements(any(View.class))).thenReturn(ImmutableList.of("X")); when(sqlDialect.viewDeploymentStatements(same(testView))).thenReturn(ImmutableList.of("A")); when(sqlDialect.convertStatementToSQL(any(InsertStatement.class), same(targetSchema))).thenReturn("C"); when(sqlDialect.convertStatementToSQL(any(DeleteStatement.class))).thenReturn("D"); when(sqlDialect.convertStatementToSQL(any(InsertStatement.class), any(Schema.class), any(Table.class))).thenReturn(new ArrayList<String>()); when(sqlDialect.dropStatements(any(Table.class))).thenReturn(new HashSet<String>()); when(sqlDialect.truncateTableStatements(any(Table.class))).thenReturn(new HashSet<String>()); when(sqlDialect.convertStatementToSQL(any(DeleteStatement.class))).thenReturn("G"); when(sqlDialect.convertCommentToSQL(any(String.class))).thenReturn("CM"); when(sqlDialect.convertStatementToSQL(any(SelectStatement.class))).then(new Answer<String>() { @Override public String answer(InvocationOnMock invocation) throws Throwable { return new MockDialect().convertStatementToSQL((SelectStatement) invocation.getArguments()[0]); } }); when(sqlDialect.tableDeploymentStatements(any(Table.class))).thenAnswer(new Answer<Collection<String>>() { @Override public Collection<String> answer(InvocationOnMock invocation) throws Throwable { return ImmutableList.of(StringUtils.defaultString(((Table)invocation.getArguments()[0]).getName(), invocation.getArguments()[0].getClass().getSimpleName())); } }); ResultSet viewResultSet = mock(ResultSet.class); when(viewResultSet.next()).thenReturn(true, true, false); when(viewResultSet.getString(1)).thenReturn("FooView", "OldView"); when(viewResultSet.getString(2)).thenReturn("XXX"); ResultSet upgradeResultSet = mock(ResultSet.class); when(upgradeResultSet.next()).thenReturn(false); ConnectionResources connection = new MockConnectionResources(). withDialect(sqlDialect). withSchema(sourceSchema). withResultSet("SELECT upgradeUUID FROM UpgradeAudit", upgradeResultSet). withResultSet("SELECT name, hash FROM DeployedViews", viewResultSet). create(); when(upgradeStatusTableService.getStatus(Optional.of(connection.getDataSource()))).thenReturn(NONE); UpgradePath result = new Upgrade(connection, connection.getDataSource(), upgradePathFactory(), upgradeStatusTableService).findPath(targetSchema, upgradeSteps, new HashSet<String>()); assertEquals("Steps to apply " + result.getSteps(), 1, result.getSteps().size()); assertEquals("Upgrade class", ChangeCar.class, result.getSteps().get(0).getClass()); assertEquals("SQL", "[X, G, IdTable, CM, A, C]", result.getSql().toString()); }
@Test public void testUpgradeWithViewDeclaredButNotPresent() throws SQLException { Table upgradeAudit = upgradeAudit(); Table deployedViews = deployedViews(); View testView = view("FooView", select(field("name")).from(tableRef("Foo"))); Schema sourceSchema = schema( schema(upgradeAudit, deployedViews) ); Schema targetSchema = schema( schema(upgradeAudit, deployedViews), schema(testView) ); Collection<Class<? extends UpgradeStep>> upgradeSteps = Collections.emptySet(); SqlDialect sqlDialect = mock(SqlDialect.class); when(sqlDialect.convertStatementToHash(any(SelectStatement.class))).thenReturn("XXX"); when(sqlDialect.dropStatements(any(View.class))).thenReturn(ImmutableList.of("X")); when(sqlDialect.viewDeploymentStatements(same(testView))).thenReturn(ImmutableList.of("A")); when(sqlDialect.convertStatementToSQL(any(InsertStatement.class), same(targetSchema))).thenReturn("C"); when(sqlDialect.convertStatementToSQL(any(DeleteStatement.class))).thenReturn("D"); when(sqlDialect.convertStatementToSQL(any(SelectStatement.class))).then(new Answer<String>() { @Override public String answer(InvocationOnMock invocation) throws Throwable { return new MockDialect().convertStatementToSQL((SelectStatement) invocation.getArguments()[0]); } }); ResultSet viewResultSet = mock(ResultSet.class); when(viewResultSet.next()).thenReturn(true, true, false); when(viewResultSet.getString(1)).thenReturn("FooView", "OldView"); when(viewResultSet.getString(2)).thenReturn("XXX"); ResultSet upgradeResultSet = mock(ResultSet.class); when(upgradeResultSet.next()).thenReturn(false); ConnectionResources connection = new MockConnectionResources(). withDialect(sqlDialect). withSchema(sourceSchema). withResultSet("SELECT upgradeUUID FROM UpgradeAudit", upgradeResultSet). withResultSet("SELECT name, hash FROM DeployedViews", viewResultSet). create(); when(upgradeStatusTableService.getStatus(Optional.of(connection.getDataSource()))).thenReturn(NONE); UpgradePath result = new Upgrade(connection, connection.getDataSource(), upgradePathFactory(), upgradeStatusTableService).findPath(targetSchema, upgradeSteps, new HashSet<String>()); assertEquals("Steps to apply " + result.getSteps(), 1, result.getSteps().size()); assertEquals("Marker step JIRA ID", "\u2014", result.getSteps().get(0).getJiraId()); assertEquals("Marker step description", "Update database views", result.getSteps().get(0).getDescription()); assertEquals("SQL", "[D, A, C]", result.getSql().toString()); }
@Test public void testUpgradeWithOnlyViewsToDeployWithExistingDeployedViews() { Table upgradeAudit = upgradeAudit(); Table deployedViews = table("DeployedViews").columns(column("name", DataType.STRING, 30), column("hash", DataType.STRING, 64)); View testView = view("FooView", select(field("name")).from(tableRef("Foo"))); Schema sourceSchema = schema(upgradeAudit, deployedViews); Schema targetSchema = schema( schema(upgradeAudit, deployedViews), schema(testView) ); Collection<Class<? extends UpgradeStep>> upgradeSteps = Collections.emptySet(); ConnectionResources connection = mock(ConnectionResources.class, RETURNS_DEEP_STUBS); when(connection.sqlDialect().viewDeploymentStatements(same(testView))).thenReturn(ImmutableList.of("A")); when(connection.sqlDialect().convertStatementToSQL(any(InsertStatement.class), same(targetSchema))).thenReturn("C"); when(connection.sqlDialect().rebuildTriggers(any(Table.class))).thenReturn(Collections.<String>emptyList()); when(connection.openSchemaResource(eq(connection.getDataSource()))).thenReturn(new StubSchemaResource(sourceSchema)); when(upgradeStatusTableService.getStatus(Optional.of(connection.getDataSource()))).thenReturn(NONE); UpgradePath result = new Upgrade(connection, connection.getDataSource(), upgradePathFactory(), upgradeStatusTableService).findPath(targetSchema, upgradeSteps, new HashSet<String>()); assertEquals("Steps to apply " + result.getSteps(), 1, result.getSteps().size()); assertEquals("Marker step JIRA ID", "\u2014", result.getSteps().get(0).getJiraId()); assertEquals("Marker step description", "Update database views", result.getSteps().get(0).getDescription()); assertEquals("SQL", "[A, C]", result.getSql().toString()); }
@Test public void testUpgradeWithToDeployAndNewDeployedViews() throws SQLException { Table upgradeAudit = upgradeAudit(); Table deployedViews = deployedViews(); View otherView = view("OldView", select(field("name")).from(tableRef("Old"))); View testView = view("FooView", select(field("name")).from(tableRef("Foo"))); View staticView = view("StaticView", select(field("name")).from(tableRef("Unchanged"))); Schema sourceSchema = schema( schema(upgradeAudit), schema(otherView, staticView) ); Schema targetSchema = schema( schema(upgradeAudit, deployedViews), schema(testView, staticView) ); Collection<Class<? extends UpgradeStep>> upgradeSteps = ImmutableList.<Class<? extends UpgradeStep>>of(CreateDeployedViews.class); SqlDialect sqlDialect = mock(SqlDialect.class); when(sqlDialect.convertStatementToHash(any(SelectStatement.class))).thenReturn("XXX"); when(sqlDialect.viewDeploymentStatements(any(View.class))).thenReturn(ImmutableList.of("A")); when(sqlDialect.dropStatements(any(View.class))).thenReturn(ImmutableList.of("B")); when(sqlDialect.convertStatementToSQL(any(InsertStatement.class), same(targetSchema))).thenReturn("C"); when(sqlDialect.convertStatementToSQL(any(DeleteStatement.class))).thenReturn("D"); when(sqlDialect.convertStatementToSQL(any(InsertStatement.class), any(Schema.class), any(Table.class))).thenReturn(new ArrayList<String>()); when(sqlDialect.dropStatements(any(Table.class))).thenReturn(new HashSet<String>()); when(sqlDialect.convertCommentToSQL(any(String.class))).thenReturn("CM"); when(sqlDialect.truncateTableStatements(any(Table.class))).thenReturn(new HashSet<String>()); when(sqlDialect.convertStatementToSQL(any(SelectStatement.class))).then(new Answer<String>() { @Override public String answer(InvocationOnMock invocation) throws Throwable { return new MockDialect().convertStatementToSQL((SelectStatement) invocation.getArguments()[0]); } }); when(sqlDialect.tableDeploymentStatements(any(Table.class))).thenAnswer(new Answer<Collection<String>>() { @Override public Collection<String> answer(InvocationOnMock invocation) throws Throwable { return ImmutableList.of(StringUtils.defaultString(((Table)invocation.getArguments()[0]).getName(), invocation.getArguments()[0].getClass().getSimpleName())); } }); ResultSet viewResultSet = mock(ResultSet.class); when(viewResultSet.next()).thenReturn(true, true, false); when(viewResultSet.getString(1)).thenReturn("OtherView", "StaticView"); when(viewResultSet.getString(2)).thenReturn("XXX"); ResultSet upgradeResultSet = mock(ResultSet.class); when(upgradeResultSet.next()).thenReturn(false); ConnectionResources connection = new MockConnectionResources(). withDialect(sqlDialect). withSchema(sourceSchema). withResultSet("SELECT upgradeUUID FROM UpgradeAudit", upgradeResultSet). withResultSet("SELECT name, hash FROM DeployedViews", viewResultSet). create(); when(upgradeStatusTableService.getStatus(Optional.of(connection.getDataSource()))).thenReturn(NONE); UpgradePath result = new Upgrade(connection, connection.getDataSource(), upgradePathFactory(), upgradeStatusTableService).findPath(targetSchema, upgradeSteps, new HashSet<String>()); assertEquals("Steps to apply " + result.getSteps(), 1, result.getSteps().size()); assertEquals("JIRA ID", "WEB-18348", result.getSteps().get(0).getJiraId()); assertEquals("Description", "Foo", result.getSteps().get(0).getDescription()); assertEquals("SQL", "[B, B, IdTable, CM, DeployedViews, A, C, A, C]", result.getSql().toString()); }
@Test public void testUpgradeWithStepsToApplyRebuildTriggers() throws SQLException { Schema sourceSchema = schema( schema(upgradeAudit(), deployedViews(), originalCar()) ); Schema targetSchema = schema( schema(upgradeAudit(), deployedViews(), upgradedCar()) ); Collection<Class<? extends UpgradeStep>> upgradeSteps = ImmutableSet.<Class<? extends UpgradeStep>>of(ChangeCar.class); ResultSet viewResultSet = mock(ResultSet.class); when(viewResultSet.next()).thenReturn(true, true, false); when(viewResultSet.getString(1)).thenReturn("FooView", "OldView"); when(viewResultSet.getString(2)).thenReturn("XXX"); ResultSet upgradeResultSet = mock(ResultSet.class); when(upgradeResultSet.next()).thenReturn(false); ConnectionResources connection = new MockConnectionResources(). withSchema(sourceSchema). withResultSet("SELECT upgradeUUID FROM UpgradeAudit", upgradeResultSet). withResultSet("SELECT name, hash FROM DeployedViews", viewResultSet). create(); when(upgradeStatusTableService.getStatus(Optional.of(connection.getDataSource()))).thenReturn(NONE); new Upgrade(connection, connection.getDataSource(), upgradePathFactory(), upgradeStatusTableService).findPath(targetSchema, upgradeSteps, new HashSet<String>()); ArgumentCaptor<Table> tableArgumentCaptor = ArgumentCaptor.forClass(Table.class); verify(connection.sqlDialect(), times(3)).rebuildTriggers(tableArgumentCaptor.capture()); List<Table> rebuildTriggerTables = tableArgumentCaptor.getAllValues(); List<String> rebuildTriggerTableNames = Lists.transform(rebuildTriggerTables, new Function<Table, String>() { @Override public String apply(Table input) { return input.getName(); } }); assertThat("Rebuild trigger table arguments are wrong", rebuildTriggerTableNames, containsInAnyOrder("UpgradeAudit", "Car", "DeployedViews")); } |
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); } | @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()); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.