@Before public void setupOnce() throws Exception { nativeMeta = new ConcreteBaseDatabaseMeta(); nativeMeta.setAccessType(DatabaseMeta.TYPE_ACCESS_NATIVE); odbcMeta = new ConcreteBaseDatabaseMeta(); nativeMeta.setAccessType(DatabaseMeta.TYPE_ACCESS_ODBC); jndiMeta = new ConcreteBaseDatabaseMeta(); KettleClientEnvironment.init(); }
@Test public void testCheckIndexExists() throws Exception { Database db = Mockito.mock(Database.class); ResultSet rs = Mockito.mock(ResultSet.class); DatabaseMetaData dmd = Mockito.mock(DatabaseMetaData.class); DatabaseMeta dm = Mockito.mock(DatabaseMeta.class); Mockito.when(dm.getQuotedSchemaTableCombination("", "FOO")).thenReturn("FOO"); Mockito.when(rs.next()) .thenAnswer( new Answer<Boolean>() { public Boolean answer(InvocationOnMock invocation) throws Throwable { rowCnt++; return new Boolean(rowCnt < 3); } }); Mockito.when(db.getDatabaseMetaData()).thenReturn(dmd); Mockito.when(dmd.getIndexInfo(null, null, "FOO", false, true)).thenReturn(rs); Mockito.when(rs.getString("COLUMN_NAME")) .thenAnswer( new Answer<String>() { @Override public String answer(InvocationOnMock invocation) throws Throwable { if (rowCnt == 1) { return "ROW1COL2"; } else if (rowCnt == 2) { return "ROW2COL2"; } else { return null; } } }); Mockito.when(db.getDatabaseMeta()).thenReturn(dm); assertTrue(odbcMeta.checkIndexExists(db, "", "FOO", new String[] {"ROW1COL2", "ROW2COL2"})); assertFalse(odbcMeta.checkIndexExists(db, "", "FOO", new String[] {"ROW2COL2", "NOTTHERE"})); assertFalse(odbcMeta.checkIndexExists(db, "", "FOO", new String[] {"NOTTHERE", "ROW1COL2"})); }
@SuppressWarnings("deprecation") @Test public void testDeprecatedItems() throws Exception { assertEquals( "'2016-08-11'", nativeMeta.getSQLValue(new ValueMetaDate("FOO"), new Date(116, 7, 11), "YYYY-MM-dd")); assertEquals( "\"FOO\".\"BAR\"", nativeMeta.getBackwardsCompatibleSchemaTableCombination("FOO", "BAR")); assertEquals( "\"null\".\"BAR\"", nativeMeta.getBackwardsCompatibleSchemaTableCombination( null, "BAR")); // not sure this is right ... assertEquals( "FOO\".\"BAR\"", nativeMeta.getBackwardsCompatibleSchemaTableCombination("FOO\"", "BAR")); assertEquals( "FOO\".BAR\"", nativeMeta.getBackwardsCompatibleSchemaTableCombination("FOO\"", "BAR\"")); assertEquals("\"FOO\"", nativeMeta.getBackwardsCompatibleTable("FOO")); assertEquals( "\"null\"", nativeMeta.getBackwardsCompatibleTable(null)); // not sure this should happen but it does assertEquals("FOO\"", nativeMeta.getBackwardsCompatibleTable("FOO\"")); assertEquals("\"FOO", nativeMeta.getBackwardsCompatibleTable("\"FOO")); }
@Test public void testDefaultSettings() throws Exception { // Note - this method should only use native or odbc. // The jndi meta is used for mutations of the meta, and it would // not be threadsafe in a multi-threaded testing environment // (each test run in its own thread). assertEquals(-1, nativeMeta.getDefaultDatabasePort()); assertTrue(nativeMeta.supportsSetCharacterStream()); assertTrue(nativeMeta.supportsAutoInc()); assertEquals("", nativeMeta.getLimitClause(5)); assertEquals(0, nativeMeta.getNotFoundTK(true)); assertEquals("", nativeMeta.getSQLNextSequenceValue("FOO")); assertEquals("", nativeMeta.getSQLCurrentSequenceValue("FOO")); assertEquals("", nativeMeta.getSQLSequenceExists("FOO")); assertTrue(nativeMeta.isFetchSizeSupported()); assertFalse(nativeMeta.needsPlaceHolder()); assertTrue(nativeMeta.supportsSchemas()); assertTrue(nativeMeta.supportsCatalogs()); assertTrue(nativeMeta.supportsEmptyTransactions()); assertEquals("SUM", nativeMeta.getFunctionSum()); assertEquals("AVG", nativeMeta.getFunctionAverage()); assertEquals("MIN", nativeMeta.getFunctionMinimum()); assertEquals("MAX", nativeMeta.getFunctionMaximum()); assertEquals("COUNT", nativeMeta.getFunctionCount()); assertEquals("\"", nativeMeta.getStartQuote()); assertEquals("\"", nativeMeta.getEndQuote()); assertEquals("FOO.BAR", nativeMeta.getSchemaTableCombination("FOO", "BAR")); assertEquals(DatabaseMeta.CLOB_LENGTH, nativeMeta.getMaxTextFieldLength()); assertEquals(DatabaseMeta.CLOB_LENGTH, nativeMeta.getMaxVARCHARLength()); assertTrue(nativeMeta.supportsTransactions()); assertFalse(nativeMeta.supportsSequences()); assertTrue(nativeMeta.supportsBitmapIndex()); assertTrue(nativeMeta.supportsSetLong()); assertArrayEquals(new String[] {}, nativeMeta.getReservedWords()); assertTrue(nativeMeta.quoteReservedWords()); assertFalse(nativeMeta.supportsRepository()); assertArrayEquals(new String[] {"TABLE"}, nativeMeta.getTableTypes()); assertArrayEquals(new String[] {"VIEW"}, nativeMeta.getViewTypes()); assertArrayEquals(new String[] {"SYNONYM"}, nativeMeta.getSynonymTypes()); assertFalse(nativeMeta.useSchemaNameForTableList()); assertTrue(nativeMeta.supportsViews()); assertFalse(nativeMeta.supportsSynonyms()); assertNull(nativeMeta.getSQLListOfProcedures()); assertNull(nativeMeta.getSQLListOfSequences()); assertTrue(nativeMeta.supportsFloatRoundingOnUpdate()); assertNull(nativeMeta.getSQLLockTables(new String[] {"FOO"})); assertNull(nativeMeta.getSQLUnlockTables(new String[] {"FOO"})); assertTrue(nativeMeta.supportsTimeStampToDateConversion()); assertTrue(nativeMeta.supportsBatchUpdates()); assertFalse(nativeMeta.supportsBooleanDataType()); assertFalse(nativeMeta.supportsTimestampDataType()); assertTrue(nativeMeta.preserveReservedCase()); assertTrue(nativeMeta.isDefaultingToUppercase()); Map<String, String> emptyMap = new HashMap<String, String>(); assertEquals(emptyMap, nativeMeta.getExtraOptions()); assertEquals(";", nativeMeta.getExtraOptionSeparator()); assertEquals("=", nativeMeta.getExtraOptionValueSeparator()); assertEquals(";", nativeMeta.getExtraOptionIndicator()); assertTrue(nativeMeta.supportsOptionsInURL()); assertNull(nativeMeta.getExtraOptionsHelpText()); assertTrue(nativeMeta.supportsGetBlob()); assertNull(nativeMeta.getConnectSQL()); assertTrue(nativeMeta.supportsSetMaxRows()); assertFalse(nativeMeta.isUsingConnectionPool()); assertEquals(ConnectionPoolUtil.defaultMaximumNrOfConnections, nativeMeta.getMaximumPoolSize()); assertEquals(ConnectionPoolUtil.defaultInitialNrOfConnections, nativeMeta.getInitialPoolSize()); assertFalse(nativeMeta.isPartitioned()); assertArrayEquals(new PartitionDatabaseMeta[0], nativeMeta.getPartitioningInformation()); Properties emptyProps = new Properties(); assertEquals(emptyProps, nativeMeta.getConnectionPoolingProperties()); assertTrue(nativeMeta.needsToLockAllTables()); assertTrue(nativeMeta.isStreamingResults()); assertFalse(nativeMeta.isQuoteAllFields()); assertFalse(nativeMeta.isForcingIdentifiersToLowerCase()); assertFalse(nativeMeta.isForcingIdentifiersToUpperCase()); assertFalse(nativeMeta.isUsingDoubleDecimalAsSchemaTableSeparator()); assertTrue(nativeMeta.isRequiringTransactionsOnQueries()); assertEquals( "org.pentaho.di.core.database.DatabaseFactory", nativeMeta.getDatabaseFactoryName()); assertNull(nativeMeta.getPreferredSchemaName()); assertFalse(nativeMeta.supportsSequenceNoMaxValueOption()); assertFalse(nativeMeta.requiresCreateTablePrimaryKeyAppend()); assertFalse(nativeMeta.requiresCastToVariousForIsNull()); assertFalse(nativeMeta.isDisplaySizeTwiceThePrecision()); assertTrue(nativeMeta.supportsPreparedStatementMetadataRetrieval()); assertFalse(nativeMeta.supportsResultSetMetadataRetrievalOnly()); assertFalse(nativeMeta.isSystemTable("FOO")); assertTrue(nativeMeta.supportsNewLinesInSQL()); assertNull(nativeMeta.getSQLListOfSchemas()); assertEquals(0, nativeMeta.getMaxColumnsInIndex()); assertTrue(nativeMeta.supportsErrorHandlingOnBatchUpdates()); assertTrue(nativeMeta.isExplorable()); assertNull(nativeMeta.getXulOverlayFile()); assertTrue(nativeMeta.onlySpaces(" \t \n \r ")); assertFalse(nativeMeta.isMySQLVariant()); assertTrue(nativeMeta.canTest()); assertTrue(nativeMeta.requiresName()); assertTrue(nativeMeta.releaseSavepoint()); Variables v = new Variables(); v.setVariable("FOOVARIABLE", "FOOVALUE"); DatabaseMeta dm = new DatabaseMeta(); dm.setDatabaseInterface(nativeMeta); assertEquals("", nativeMeta.getDataTablespaceDDL(v, dm)); assertEquals("", nativeMeta.getIndexTablespaceDDL(v, dm)); assertFalse(nativeMeta.useSafePoints()); assertTrue(nativeMeta.supportsErrorHandling()); assertEquals("'DATA'", nativeMeta.getSQLValue(new ValueMetaString("FOO"), "DATA", null)); assertEquals("'15'", nativeMeta.getSQLValue(new ValueMetaString("FOO"), "15", null)); assertEquals("_", nativeMeta.getFieldnameProtector()); assertEquals("_1ABC_123", nativeMeta.getSafeFieldname("1ABC 123")); BaseDatabaseMeta tmpSC = new ConcreteBaseDatabaseMeta() { @Override public String[] getReservedWords() { return new String[] {"SELECT"}; } }; assertEquals("SELECT_", tmpSC.getSafeFieldname("SELECT")); assertEquals("NOMAXVALUE", nativeMeta.getSequenceNoMaxValueOption()); assertTrue(nativeMeta.supportsAutoGeneratedKeys()); assertNull(nativeMeta.customizeValueFromSQLType(new ValueMetaString("FOO"), null, 0)); assertTrue(nativeMeta.fullExceptionLog(new RuntimeException("xxxx"))); }
@Test public void testGettersSetters() { // Note - this method should *ONLY* use the jndi meta and not the odbc or native ones. // This is the only method in this test class that mutates the meta. jndiMeta.setUsername("FOO"); assertEquals("FOO", jndiMeta.getUsername()); jndiMeta.setPassword("BAR"); assertEquals("BAR", jndiMeta.getPassword()); jndiMeta.setAccessType(DatabaseMeta.TYPE_ACCESS_JNDI); assertEquals("", jndiMeta.getUsername()); assertEquals("", jndiMeta.getPassword()); assertFalse(jndiMeta.isChanged()); jndiMeta.setChanged(true); assertTrue(jndiMeta.isChanged()); jndiMeta.setName("FOO"); assertEquals("FOO", jndiMeta.getName()); assertEquals("FOO", jndiMeta.getDisplayName()); jndiMeta.setName(null); assertNull(jndiMeta.getName()); assertEquals("FOO", jndiMeta.getDisplayName()); jndiMeta.setDisplayName(null); assertNull(jndiMeta.getDisplayName()); jndiMeta.setDatabaseName("FOO"); assertEquals("FOO", jndiMeta.getDatabaseName()); assertEquals("-1", jndiMeta.getDatabasePortNumberString()); jndiMeta.setDatabasePortNumberString("9876"); assertEquals("9876", jndiMeta.getDatabasePortNumberString()); jndiMeta.setDatabasePortNumberString(null); assertEquals( "9876", jndiMeta.getDatabasePortNumberString()); // not sure I agree with this behavior jndiMeta.setHostname("FOO"); assertEquals("FOO", jndiMeta.getHostname()); LongObjectId id = new LongObjectId(9876); jndiMeta.setObjectId(id); assertEquals(id, jndiMeta.getObjectId()); jndiMeta.setServername("FOO"); assertEquals("FOO", jndiMeta.getServername()); jndiMeta.setDataTablespace("FOO"); assertEquals("FOO", jndiMeta.getDataTablespace()); jndiMeta.setIndexTablespace("FOO"); assertEquals("FOO", jndiMeta.getIndexTablespace()); Properties attrs = jndiMeta.getAttributes(); Properties testAttrs = new Properties(); testAttrs.setProperty("FOO", "BAR"); jndiMeta.setAttributes(testAttrs); assertEquals(testAttrs, jndiMeta.getAttributes()); jndiMeta.setAttributes(attrs); // reset attributes back to what they were... jndiMeta.setSupportsBooleanDataType(true); assertTrue(jndiMeta.supportsBooleanDataType()); jndiMeta.setSupportsTimestampDataType(true); assertTrue(jndiMeta.supportsTimestampDataType()); jndiMeta.setPreserveReservedCase(false); assertFalse(jndiMeta.preserveReservedCase()); jndiMeta.addExtraOption("JNDI", "FOO", "BAR"); Map<String, String> expectedOptionsMap = new HashMap<String, String>(); expectedOptionsMap.put("JNDI.FOO", "BAR"); assertEquals(expectedOptionsMap, jndiMeta.getExtraOptions()); jndiMeta.setConnectSQL("SELECT COUNT(*) FROM FOO"); assertEquals("SELECT COUNT(*) FROM FOO", jndiMeta.getConnectSQL()); jndiMeta.setUsingConnectionPool(true); assertTrue(jndiMeta.isUsingConnectionPool()); jndiMeta.setMaximumPoolSize(15); assertEquals(15, jndiMeta.getMaximumPoolSize()); jndiMeta.setInitialPoolSize(5); assertEquals(5, jndiMeta.getInitialPoolSize()); jndiMeta.setPartitioned(true); assertTrue(jndiMeta.isPartitioned()); PartitionDatabaseMeta[] clusterInfo = new PartitionDatabaseMeta[1]; PartitionDatabaseMeta aClusterDef = new PartitionDatabaseMeta("FOO", "BAR", "WIBBLE", "NATTIE"); aClusterDef.setUsername("FOOUSER"); aClusterDef.setPassword("BARPASSWORD"); clusterInfo[0] = aClusterDef; jndiMeta.setPartitioningInformation(clusterInfo); PartitionDatabaseMeta[] gotPartitions = jndiMeta.getPartitioningInformation(); // MB: Can't use arrayEquals because the PartitionDatabaseMeta doesn't have a toString. :( // assertArrayEquals( clusterInfo, gotPartitions ); assertTrue(gotPartitions != null); if (gotPartitions != null) { assertEquals(1, gotPartitions.length); PartitionDatabaseMeta compareWith = gotPartitions[0]; // MB: Can't use x.equals(y) because PartitionDatabaseMeta doesn't override equals... :( assertEquals(aClusterDef.getClass(), compareWith.getClass()); assertEquals(aClusterDef.getDatabaseName(), compareWith.getDatabaseName()); assertEquals(aClusterDef.getHostname(), compareWith.getHostname()); assertEquals(aClusterDef.getPartitionId(), compareWith.getPartitionId()); assertEquals(aClusterDef.getPassword(), compareWith.getPassword()); assertEquals(aClusterDef.getPort(), compareWith.getPort()); assertEquals(aClusterDef.getUsername(), compareWith.getUsername()); } Properties poolProperties = new Properties(); poolProperties.put("FOO", "BAR"); poolProperties.put("BAR", "FOO"); poolProperties.put("ZZZZZZZZZZZZZZ", "Z.Z.Z.Z.Z.Z.Z.Z.a.a.a.a.a.a.a.a.a"); poolProperties.put("TOM", "JANE"); poolProperties.put("AAAAAAAAAAAAA", "BBBBB.BBB.BBBBBBB.BBBBBBBB.BBBBBBBBBBBBBB"); jndiMeta.setConnectionPoolingProperties(poolProperties); Properties compareWithProps = jndiMeta.getConnectionPoolingProperties(); assertEquals(poolProperties, compareWithProps); jndiMeta.setStreamingResults(false); assertFalse(jndiMeta.isStreamingResults()); jndiMeta.setQuoteAllFields(true); jndiMeta.setForcingIdentifiersToLowerCase(true); jndiMeta.setForcingIdentifiersToUpperCase(true); assertTrue(jndiMeta.isQuoteAllFields()); assertTrue(jndiMeta.isForcingIdentifiersToLowerCase()); assertTrue(jndiMeta.isForcingIdentifiersToUpperCase()); jndiMeta.setUsingDoubleDecimalAsSchemaTableSeparator(true); assertTrue(jndiMeta.isUsingDoubleDecimalAsSchemaTableSeparator()); jndiMeta.setPreferredSchemaName("FOO"); assertEquals("FOO", jndiMeta.getPreferredSchemaName()); }
@Test public void testDefaultSQLStatements() { // Note - this method should use only native or odbc metas. // Use of the jndi meta here could create a race condition // when test cases are run by multiple threads String lineSep = System.getProperty("line.separator"); String expected = "ALTER TABLE FOO DROP BAR" + lineSep; assertEquals( expected, odbcMeta.getDropColumnStatement("FOO", new ValueMetaString("BAR"), "", false, "", false)); assertEquals("TRUNCATE TABLE FOO", odbcMeta.getTruncateTableStatement("FOO")); assertEquals("SELECT * FROM FOO", odbcMeta.getSQLQueryFields("FOO")); assertEquals("SELECT 1 FROM FOO", odbcMeta.getSQLTableExists("FOO")); assertEquals("SELECT FOO FROM BAR", odbcMeta.getSQLColumnExists("FOO", "BAR")); assertEquals( "insert into \"FOO\".\"BAR\"(KEYFIELD, VERSIONFIELD) values (0, 1)", nativeMeta.getSQLInsertAutoIncUnknownDimensionRow( "\"FOO\".\"BAR\"", "KEYFIELD", "VERSIONFIELD")); assertEquals("select count(*) FROM FOO", nativeMeta.getSelectCountStatement("FOO")); assertEquals("COL9", nativeMeta.generateColumnAlias(9, "FOO")); assertEquals( "[SELECT 1, INSERT INTO FOO VALUES(BAR), DELETE FROM BAR]", nativeMeta .parseStatements("SELECT 1;INSERT INTO FOO VALUES(BAR);DELETE FROM BAR") .toString()); assertEquals("CREATE TABLE ", nativeMeta.getCreateTableStatement()); assertEquals("DROP TABLE IF EXISTS FOO", nativeMeta.getDropTableIfExistsStatement("FOO")); }