@Test public void testShowTablesLike() { assertThat(computeActual("SHOW TABLES LIKE 'or%'").getOnlyColumnAsSet()) .contains("orders") .allMatch(tableName -> ((String) tableName).startsWith("or")); }
@Test public void should_group_by_category_on_annotation_plugin() { PropertyDefinitions def = new PropertyDefinitions(ByCategory.class); assertThat(def.propertiesByCategory(null).keySet()).contains(new Category("catglobal1"), new Category("catglobal2")); assertThat(def.propertiesByCategory(Qualifiers.PROJECT).keySet()).containsOnly(new Category("catproject")); assertThat(def.propertiesByCategory(Qualifiers.MODULE).keySet()).containsOnly(new Category("catmodule")); }
@Test public void testShowTablesLikeWithEscape() { assertQueryFails("SHOW TABLES IN a LIKE '%$_%' ESCAPE", "line 1:36: mismatched input '<EOF>'. Expecting: <string>"); assertQueryFails("SHOW TABLES LIKE 't$_%' ESCAPE ''", "Escape string must be a single character"); assertQueryFails("SHOW TABLES LIKE 't$_%' ESCAPE '$$'", "Escape string must be a single character"); Set<Object> allTables = computeActual("SHOW TABLES FROM information_schema").getOnlyColumnAsSet(); assertEquals(allTables, computeActual("SHOW TABLES FROM information_schema LIKE '%_%'").getOnlyColumnAsSet()); Set<Object> result = computeActual("SHOW TABLES FROM information_schema LIKE '%$_%' ESCAPE '$'").getOnlyColumnAsSet(); assertNotEquals(allTables, result); assertThat(result).contains("table_privileges").allMatch(schemaName -> ((String) schemaName).contains("_")); }
@Test public void testShowSchemasLikeWithEscape() { assertQueryFails("SHOW SCHEMAS IN foo LIKE '%$_%' ESCAPE", "line 1:39: mismatched input '<EOF>'. Expecting: <string>"); assertQueryFails("SHOW SCHEMAS LIKE 't$_%' ESCAPE ''", "Escape string must be a single character"); assertQueryFails("SHOW SCHEMAS LIKE 't$_%' ESCAPE '$$'", "Escape string must be a single character"); Set<Object> allSchemas = computeActual("SHOW SCHEMAS").getOnlyColumnAsSet(); assertEquals(allSchemas, computeActual("SHOW SCHEMAS LIKE '%_%'").getOnlyColumnAsSet()); Set<Object> result = computeActual("SHOW SCHEMAS LIKE '%$_%' ESCAPE '$'").getOnlyColumnAsSet(); assertNotEquals(allSchemas, result); assertThat(result).contains("information_schema").allMatch(schemaName -> ((String) schemaName).contains("_")); }
@Test public void contributing_plugin_list() { initModel(); Collection<String> contributingPluginList = underTest.getContributingPluginList(); assertThat(contributingPluginList.size()).isEqualTo(2); assertThat(contributingPluginList).contains("csharp", "java"); }
@Test public void gettersReturnCorrectData() { UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken( "Test", "Password", AuthorityUtils.createAuthorityList("ROLE_ONE", "ROLE_TWO")); assertThat(token.getPrincipal()).isEqualTo("Test"); assertThat(token.getCredentials()).isEqualTo("Password"); assertThat(AuthorityUtils.authorityListToSet(token.getAuthorities())).contains("ROLE_ONE"); assertThat(AuthorityUtils.authorityListToSet(token.getAuthorities())).contains("ROLE_TWO"); }
@Test public void testCommit() throws SQLException { try (Connection connection = createConnection()) { connection.setAutoCommit(false); try (Statement statement = connection.createStatement()) { statement.execute("CREATE TABLE test_commit (x bigint)"); } try (Connection otherConnection = createConnection()) { assertThat(listTables(otherConnection)).doesNotContain("test_commit"); } connection.commit(); } try (Connection connection = createConnection()) { assertThat(listTables(connection)).contains("test_commit"); } }
@Test public void testSuccessfulAuthenticationCreatesObject() { RemoteAuthenticationProvider provider = new RemoteAuthenticationProvider(); provider.setRemoteAuthenticationManager( new MockRemoteAuthenticationManager(true)); Authentication result = provider .authenticate(new UsernamePasswordAuthenticationToken("rod", "password")); assertThat(result.getPrincipal()).isEqualTo("rod"); assertThat(result.getCredentials()).isEqualTo("password"); assertThat(AuthorityUtils.authorityListToSet(result.getAuthorities())).contains("foo"); }
@Test public void getFormulaMetrics_include_the_dependent_metrics() { for (IssueMetricFormula formula : underTest.getFormulas()) { assertThat(underTest.getFormulaMetrics()).contains(formula.getMetric()); for (Metric dependentMetric : formula.getDependentMetrics()) { assertThat(underTest.getFormulaMetrics()).contains(dependentMetric); } } }
@Test public void testGetFilteredExtensionWithExtensionMatcher() { final Sensor sensor1 = new FakeSensor(); final Sensor sensor2 = new FakeSensor(); ModuleSensorExtensionDictionnary selector = newSelector(sensor1, sensor2); Collection<Sensor> sensors = selector.select(Sensor.class, true, extension -> extension.equals(sensor1)); assertThat(sensors).contains(sensor1); assertEquals(1, sensors.size()); }
@Test public void guavaBuildSet() { HashSet<String> set1 = SetUtil.newHashSet(); HashSet<String> set2 = SetUtil.newHashSetWithCapacity(10); HashSet<String> set3 = SetUtil.newHashSet("1", "2", "2"); assertThat(set3).hasSize(2).contains("1", "2"); HashSet<String> set4 = SetUtil.newHashSet(ListUtil.newArrayList("1", "2", "2")); assertThat(set4).hasSize(2).contains("1", "2"); TreeSet<String> set5 = SetUtil.newSortedSet(); TreeSet<String> set6 = SetUtil.newSortedSet(Ordering.natural()); ConcurrentHashSet set7 = SetUtil.newConcurrentHashSet(); }
@Test public void delete_existing_index() { underTest.deleteIndexes("a"); assertThat(loadExistingIndices()) .doesNotContain("a") .contains("b", "c"); assertThat(logTester.logs(LoggerLevel.INFO)) .contains("Drop Elasticsearch index [a]"); }
@Test public void ignore_indices_that_do_not_exist() { underTest.deleteIndexes("a", "xxx", "c"); assertThat(loadExistingIndices()) .doesNotContain("a", "c") .contains("b"); assertThat(logTester.logs(LoggerLevel.INFO)) .contains("Drop Elasticsearch index [a]", "Drop Elasticsearch index [c]") .doesNotContain("Drop Elasticsearch index [xxx]"); }
@Test public void testCheckDaoOnlyReturnsGrantedAuthoritiesGrantedToUser() throws Exception { JdbcDaoImpl dao = makePopulatedJdbcDao(); UserDetails user = dao.loadUserByUsername("scott"); assertThat(user.getAuthorities()).hasSize(1); assertThat(AuthorityUtils.authorityListToSet(user.getAuthorities())) .contains("ROLE_TELLER"); }
@Test public void parsingMinimalConfigurationIsSuccessful() { setContext("<filter-security-metadata-source id='fids' use-expressions='false'>" + " <intercept-url pattern='/**' access='ROLE_A'/>" + "</filter-security-metadata-source>"); DefaultFilterInvocationSecurityMetadataSource fids = (DefaultFilterInvocationSecurityMetadataSource) this.appContext .getBean("fids"); Collection<ConfigAttribute> cad = fids .getAttributes(createFilterInvocation("/anything", "GET")); assertThat(cad).contains(new SecurityConfig("ROLE_A")); }
private void verify_sum_aggregation(String metricKey) { measureRepository.addRawMeasure(FILE_1_REF, metricKey, newMeasureBuilder().create(10)); measureRepository.addRawMeasure(FILE_2_REF, metricKey, newMeasureBuilder().create(40)); underTest.execute(new TestComputationStepContext()); assertThat(measureRepository.getAddedRawMeasure(FILE_1_REF, metricKey)).isNotPresent(); assertThat(measureRepository.getAddedRawMeasure(FILE_2_REF, metricKey)).isNotPresent(); int expectedNonFileValue = 50; assertThat(toEntries(measureRepository.getAddedRawMeasures(DIRECTORY_REF))).contains(entryOf(metricKey, newMeasureBuilder().create(expectedNonFileValue))); assertThat(toEntries(measureRepository.getAddedRawMeasures(ROOT_REF))).contains(entryOf(metricKey, newMeasureBuilder().create(expectedNonFileValue))); }
private void verify_average_compute_and_aggregation(String metricKey, String mainMetric, String byMetric) { measureRepository.addRawMeasure(FILE_1_REF, mainMetric, newMeasureBuilder().create(5)); measureRepository.addRawMeasure(FILE_1_REF, byMetric, newMeasureBuilder().create(2)); measureRepository.addRawMeasure(FILE_2_REF, mainMetric, newMeasureBuilder().create(1)); measureRepository.addRawMeasure(FILE_2_REF, byMetric, newMeasureBuilder().create(1)); underTest.execute(new TestComputationStepContext()); assertThat(toEntries(measureRepository.getAddedRawMeasures(FILE_1_REF))).contains(entryOf(metricKey, newMeasureBuilder().create(2.5, 1))); assertThat(toEntries(measureRepository.getAddedRawMeasures(FILE_2_REF))).contains(entryOf(metricKey, newMeasureBuilder().create(1d, 1))); double expectedNonFileValue = 2d; assertThat(toEntries(measureRepository.getAddedRawMeasures(DIRECTORY_REF))).contains(entryOf(metricKey, newMeasureBuilder().create(expectedNonFileValue, 1))); assertThat(toEntries(measureRepository.getAddedRawMeasures(ROOT_REF))).contains(entryOf(metricKey, newMeasureBuilder().create(expectedNonFileValue, 1))); }
private void verify_distribution_aggregation(String metricKey) { measureRepository.addRawMeasure(FILE_1_REF, metricKey, newMeasureBuilder().create("0.5=3;3.5=5;6.5=9")); measureRepository.addRawMeasure(FILE_2_REF, metricKey, newMeasureBuilder().create("0.5=0;3.5=2;6.5=1")); underTest.execute(new TestComputationStepContext()); assertThat(measureRepository.getAddedRawMeasure(FILE_1_REF, metricKey)).isNotPresent(); assertThat(measureRepository.getAddedRawMeasure(FILE_2_REF, metricKey)).isNotPresent(); String expectedNonFileValue = "0.5=3;3.5=7;6.5=10"; assertThat(toEntries(measureRepository.getAddedRawMeasures(DIRECTORY_REF))).contains(entryOf(metricKey, newMeasureBuilder().create(expectedNonFileValue))); assertThat(toEntries(measureRepository.getAddedRawMeasures(ROOT_REF))).contains(entryOf(metricKey, newMeasureBuilder().create(expectedNonFileValue))); }
private void verify_computation_of_measures_for_new_conditions(MetricKeys metricKeys) { treeRootHolder.setRoot(FILE_COMPONENT); defineNewLinesAndMeasures(FILE_COMPONENT, metricKeys, new MeasureValues(3, 4, 1), new MeasureValues(0, 3, 2)); underTest.execute(new TestComputationStepContext()); assertThat(toEntries(measureRepository.getAddedRawMeasures(FILE_COMPONENT.getReportAttributes().getRef()))).contains( entryOf(metricKeys.newLinesToCover, createMeasure(5d)), entryOf(metricKeys.newUncoveredLines, createMeasure(3d)), entryOf(metricKeys.newConditionsToCover, createMeasure(7d)), entryOf(metricKeys.newUncoveredConditions, createMeasure(4d))); }
private void verify_computation_of_measures_for_new_lines(String coverageLineHitsData, String newLinesToCover, String newUncoveredLines, String newConditionsToCover, String newUncoveredConditions) { treeRootHolder.setRoot(FILE_COMPONENT); setNewLines(FILE_1, 1, 2, 4); measureRepository.addRawMeasure(FILE_COMPONENT.getReportAttributes().getRef(), coverageLineHitsData, newMeasureBuilder().create("2=0;3=2;4=3")); underTest.execute(new TestComputationStepContext()); assertThat(toEntries(measureRepository.getAddedRawMeasures(FILE_COMPONENT.getReportAttributes().getRef()))).contains( entryOf(newLinesToCover, createMeasure(2d)), entryOf(newUncoveredLines, createMeasure(1d)), entryOf(newConditionsToCover, createMeasure(0d)), entryOf(newUncoveredConditions, createMeasure(0d))); }