/** * {@inheritDoc} */ @Override protected void initHook(Map<String, Object> parameters) { preparedStatementParameterHook = new PreparedStatementParameterHook(statementStorage); }
@Override public ConnectionMetaData call() throws Exception { ConnectionMetaData data = dataExtractor.parse(connection); return data != null ? data : EMPTY; } });
/** * {@inheritDoc} */ @Override protected void initHook(Map<String, Object> parameters) { connectionHook = new ConnectionHook(statementStorage); }
@Test public void addSQLWithParameterAndAddWrongIndex() { // Setup StatementStorage storage = new StatementStorage(); storage.addSql("SELECT * FROM CARS WHERE CAR_ID = ?"); Object marker = "I am the prepared Statement"; storage.addPreparedStatement(marker); storage.addParameter(marker, 1, "1"); List<String> result = storage.getParameters(marker); assertThat(result, is(not(equalTo(null)))); assertThat(result, contains(equalTo(null))); }
@Test public void extractorReturnsNull() { Object connectionObject = ""; when(extractor.parse(connectionObject)).thenReturn(null); storage.populate(sqlStatementData, connectionObject); // we have one now as adding empty assertThat(storage.storage.size(), is(1L)); // re-trying should not touch the storage storage.populate(sqlStatementData, connectionObject); assertThat(storage.storage.size(), is(1L)); // in any case no sql touching verifyZeroInteractions(sqlStatementData); }
/** * Retrieves the target/url from the jdbc connection string. * * @param databaseMetaDataClass * the meta information class. * @param databaseMetaData * the meta information object of the connection. * @return the target/url from the jdbc connection string. */ private String parseTarget(Class<?> databaseMetaDataClass, Object databaseMetaData) { String url = (String) cache.invokeMethod(databaseMetaDataClass, GET_URL, null, databaseMetaData, null, null, JAVA_SQL_DATABASE_META_DATA_FQN); return urlExtractor.extractURLfromJDBCURL(url); }
@BeforeMethod public void init() { extractor = new ConnectionMetaDataExtractor(); JDBCUrlExtractor jdbExtractor = mock(JDBCUrlExtractor.class); when(jdbExtractor.extractURLfromJDBCURL(anyString())).thenReturn(URL); ConnectionMetaDataExtractor.urlExtractor = jdbExtractor; }
/** * {@inheritDoc} */ @Override protected void initHook(Map<String, Object> parameters) { preparedStatementHook = new PreparedStatementHook(timer, platformManager, statementStorage, connectionMetaDataStorage, statementReflectionCache, parameters); }
/** * {@inheritDoc} */ @Override public void beforeBody(long methodId, long sensorTypeId, Object object, Object[] parameters, RegisteredSensorConfig rsc) { String sql = (String) parameters[0]; statementStorage.addSql(sql); }
/** * {@inheritDoc} */ @Override protected void initHook(Map<String, Object> parameters) { statementHook = new StatementHook(timer, platformManager, connectionMetaDataStorage, statementReflectionCache, parameters); }
/** * {@inheritDoc} */ @Override public void secondAfterBody(ICoreService coreService, long methodId, long sensorTypeId, Object object, Object[] parameters, Object result, boolean exception, RegisteredSensorConfig rsc) { // NOCHK:8-params statementStorage.removeSql(); }
/** * Retrieves the connection. * * @param statementClass * the class of the statement instance. * @param statementInstance * the instance of the statement. * @return the associated connection. */ public Connection getConnection(Class<?> statementClass, Object statementInstance) { return (Connection) invokeMethod(statementClass, GET_CONNECTION_METHOD_NAME, null, statementInstance, null, null, JAVA_SQL_STATEMENT_FQN); } }
/** * Returns a stored parameters for the object. * * @param object * The object which will be used to look up in the map. * @return The list of parameters or <code> null </code> if there is no container for the given * SQL statement or there are no parameters captured within this SQL statement. */ protected List<String> getParameters(Object object) { QueryInformation queryAndParameters = preparedStatements.getIfPresent(object); if (null == queryAndParameters) { return null; } else { return queryAndParameters.getParametersAsList(); } }
@BeforeMethod public void init() { MockitoAnnotations.initMocks(this); storage = new ConnectionMetaDataStorage(); storage.dataExtractor = extractor; }
@BeforeTest public void init() { extractor = new JDBCUrlExtractor(); }
/** * Populates the given SQL Statement data with the meta information from the storage if this * data exist. * * @param sqlData * the data object to populate. * @param connection * the connection. */ public void populate(SqlStatementData sqlData, Object connection) { ConnectionMetaData connectionMetaData = get(connection); if ((null != connectionMetaData) && (EMPTY != connectionMetaData)) { // NOPMD == on purpose sqlData.setDatabaseProductName(connectionMetaData.product); sqlData.setDatabaseProductVersion(connectionMetaData.version); sqlData.setDatabaseUrl(connectionMetaData.url); } }
@Test public void invalidFormat() { String invalid = "this is just an invalid format"; String result = extractor.extractURLfromJDBCURL(invalid); assertThat(result, is(invalid)); }
/** * Initializes the test class. */ @BeforeMethod public void initTestClass() { preparedStatementParameterHook = new PreparedStatementParameterHook(statementStorage); }
@Test(dataProvider = "differentVendors") public void extractFromFormat(String input, String expected) { String result = extractor.extractURLfromJDBCURL(input); assertThat(result, is(expected)); }
@Test public void urlIsNull() { String result = extractor.extractURLfromJDBCURL(null); assertThat(result, isEmptyString()); } }