public static void assertFileListEquals(String message, Map<String, File> expectedFiles, Map<String, File> actualFiles) throws ArrayComparisonFailure, Exception { assertCollectionEquals("Actual file list (" + actualFiles.size() + " entries) differs from expected file list (" + expectedFiles.size() + " entries)", expectedFiles.keySet(), actualFiles.keySet()); for (Map.Entry<String, File> expectedFileEntry : expectedFiles.entrySet()) { File expectedFile = expectedFileEntry.getValue(); File actualFile = actualFiles.remove(expectedFileEntry.getKey()); assertFileEquals(expectedFile, actualFile); } }
public static void assertFileListEquals(Map<String, File> expectedFiles, Map<String, File> actualFiles) throws ArrayComparisonFailure, Exception { assertFileListEquals("File list does not match", expectedFiles, actualFiles); }
public static void assertSqlDatabaseEquals(File expectedDatabaseFile, File actualDatabaseFile) throws IOException, SQLException { // Compare tables + ignore columns String[][] compareTablesAndIgnoreColumns = new String[][] { new String[] { "chunk", "DATABASEVERSION_ID" }, new String[] { "databaseversion", "ID" }, new String[] { "databaseversion_vectorclock", "DATABASEVERSION_ID" }, new String[] { "filecontent", "DATABASEVERSION_ID" }, new String[] { "filecontent_chunk" }, new String[] { "filehistory", "DATABASEVERSION_ID" }, new String[] { "fileversion", "DATABASEVERSION_ID" }, // skipped known_databases new String[] { "multichunk", "DATABASEVERSION_ID" }, new String[] { "multichunk_chunk" } }; assertSqlDatabaseTablesEqual(expectedDatabaseFile, actualDatabaseFile, compareTablesAndIgnoreColumns); }
public static void assertDatabaseVersionEquals(DatabaseVersion expectedDatabaseVersion, DatabaseVersion actualDatabaseVersion) { assertVectorClockEquals(expectedDatabaseVersion.getVectorClock(), actualDatabaseVersion.getVectorClock()); compareDatabaseVersionChunks(expectedDatabaseVersion.getChunks(), actualDatabaseVersion.getChunks()); compareDatabaseVersionMultiChunks(expectedDatabaseVersion.getMultiChunks(), actualDatabaseVersion.getMultiChunks()); compareDatabaseVersionFileContents(expectedDatabaseVersion.getFileContents(), actualDatabaseVersion.getFileContents()); compareDatabaseVersionFileHistories(expectedDatabaseVersion.getFileHistories(), actualDatabaseVersion.getFileHistories()); }
@Test public void testConfigMachineNameInvalidChars() throws Exception { File localDir = new File("/some/folder"); ConfigTO configTO = new ConfigTO(); RepoTO repoTO = new RepoTO(); configTO.setMachineName("invalid machine name"); // Run! try { new Config(localDir, configTO, repoTO); fail("Machine name should not have been accepted."); } catch (ConfigException e) { TestAssertUtil.assertErrorStackTraceContains("Machine name", e); } }
public static void assertFileEquals(File expectedFile, File actualFile) throws ArrayComparisonFailure, Exception { assertFileEquals(expectedFile, actualFile, new FileChange[] { FileChange.CHANGED_PATH }); }
public static void assertXmlDatabaseFileEquals(File expectedDatabaseFile, File actualDatabaseFile, Transformer transformer) throws IOException { MemoryDatabase expectedDatabase = TestDatabaseUtil.readDatabaseFileFromDisk(expectedDatabaseFile, transformer); MemoryDatabase actualDatabase = TestDatabaseUtil.readDatabaseFileFromDisk(actualDatabaseFile, transformer); assertDatabaseEquals(expectedDatabase, actualDatabase); }
public static void assertDatabaseEquals(MemoryDatabase expectedDatabase, MemoryDatabase actualDatabase) { logger.log(Level.INFO, "--"); logger.log(Level.INFO, "Now comparing two databases."); logger.log(Level.INFO, "DON'T WORRY. This can take a long time or even overload the heap space."); List<DatabaseVersion> writtenDatabaseVersions = expectedDatabase.getDatabaseVersions(); List<DatabaseVersion> readDatabaseVersions = actualDatabase.getDatabaseVersions(); assertEquals("Different number of database versions.", writtenDatabaseVersions.size(), readDatabaseVersions.size()); for (DatabaseVersion writtenDatabaseVersion : writtenDatabaseVersions) { DatabaseVersion readDatabaseVersion = null; for (DatabaseVersion aReadDatabaseVersion : readDatabaseVersions) { if (aReadDatabaseVersion.equals(writtenDatabaseVersion)) { readDatabaseVersion = aReadDatabaseVersion; break; } } assertNotNull("Database version " + writtenDatabaseVersion + " does not exist in read database.", readDatabaseVersion); assertDatabaseVersionEquals(writtenDatabaseVersion, readDatabaseVersion); } logger.log(Level.INFO, "End of comparing databases"); logger.log(Level.INFO, "--"); }
@Test public void testConfigMachineNameInvalidNull() throws Exception { File localDir = new File("/some/folder"); ConfigTO configTO = new ConfigTO(); RepoTO repoTO = new RepoTO(); configTO.setMachineName(null); // <<< Invalid // Run! try { new Config(localDir, configTO, repoTO); fail("Machine name should not have been accepted."); } catch (ConfigException e) { TestAssertUtil.assertErrorStackTraceContains("Machine name", e); } }
@Test public void testConfigCipherTransformersInvalidType() throws Exception { // Setup File localDir = new File("/some/folder"); ConfigTO configTO = new ConfigTO(); RepoTO repoTO = new RepoTO(); configTO.setMachineName("somevalidmachinename"); // <<< valid repoTO.setChunkerTO(TestConfigUtil.createFixedChunkerTO()); // <<< valid repoTO.setMultiChunker(TestConfigUtil.createZipMultiChunkerTO()); // <<< valid repoTO.setRepoId(new byte[] { 0x01, 0x02 }); // <<< valid // Set invalid transformer TransformerTO invalidTransformerTO = new TransformerTO(); invalidTransformerTO.setType("invalid-typeXXX"); invalidTransformerTO.setSettings(new HashMap<String, String>()); List<TransformerTO> transformers = new ArrayList<TransformerTO>(); transformers.add(invalidTransformerTO); repoTO.setTransformers(transformers); // <<< INVALID ! // Run! try { new Config(localDir, configTO, repoTO); fail("Transformer should NOT have been found."); } catch (ConfigException e) { TestAssertUtil.assertErrorStackTraceContains("invalid-typeXXX", e); } }
public static void assertFileListEqualsExcludeLockedAndNoRead(File expectedFilesRoot, File actualFilesRoot) throws ArrayComparisonFailure, Exception { Map<String, File> expectedFiles = TestFileUtil.getLocalFilesExcludeLockedAndNoRead(expectedFilesRoot); Map<String, File> actualFiles = TestFileUtil.getLocalFilesExcludeLockedAndNoRead(actualFilesRoot); assertFileListEquals("File list does not match", expectedFiles, actualFiles); }
@Test public void testConfigMultiChunkerNull() throws Exception { // Setup File localDir = new File("/some/folder"); ConfigTO configTO = new ConfigTO(); RepoTO repoTO = new RepoTO(); configTO.setMachineName("somevalidmachinename"); // <<< valid repoTO.setChunkerTO(TestConfigUtil.createFixedChunkerTO()); // <<< valid repoTO.setRepoId(new byte[] { 0x01, 0x02 }); // <<< valid repoTO.setTransformers(null); // <<< valid repoTO.setMultiChunker(null); // <<< INVALID !! // Run! try { new Config(localDir, configTO, repoTO); fail("Config should not been have initialized."); } catch (ConfigException e) { TestAssertUtil.assertErrorStackTraceContains("No multichunker", e); } }
TestAssertUtil.assertErrorStackTraceContains("INVALIDXXXX", e);
@Test @Ignore // TODO [low] ChunkerTO is not used yet; so no test for it. public void testConfigChunkerNull() throws Exception { // Setup File localDir = new File("/some/folder"); ConfigTO configTO = new ConfigTO(); RepoTO repoTO = new RepoTO(); configTO.setMachineName("somevalidmachinename"); // <<< valid repoTO.setMultiChunker(TestConfigUtil.createZipMultiChunkerTO()); // <<< valid repoTO.setRepoId(new byte[] { 0x01, 0x02 }); // <<< valid repoTO.setTransformers(null); // <<< valid repoTO.setChunkerTO(null); // <<< INVALID !! // Run! try { new Config(localDir, configTO, repoTO); fail("Config should not been have initialized."); } catch (ConfigException e) { TestAssertUtil.assertErrorStackTraceContains("No multichunker", e); } }