@Test public void importSelectorsWithNestedGroupSameDeferredImport() { DefaultListableBeanFactory beanFactory = spy(new DefaultListableBeanFactory()); AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(beanFactory); context.register(ParentConfiguration2.class); context.refresh(); InOrder ordered = inOrder(beanFactory); ordered.verify(beanFactory).registerBeanDefinition(eq("b"), any()); ordered.verify(beanFactory).registerBeanDefinition(eq("d"), any()); assertThat(TestImportGroup.instancesCount.get(), equalTo(2)); assertThat(TestImportGroup.allImports().size(), equalTo(2)); assertThat(TestImportGroup.allImports(), hasEntry( is(ParentConfiguration2.class.getName()), IsIterableContainingInOrder.contains(DeferredImportSelector2.class.getName(), ChildConfiguration2.class.getName()))); assertThat(TestImportGroup.allImports(), hasEntry( is(ChildConfiguration2.class.getName()), IsIterableContainingInOrder.contains(DeferredImportSelector2.class.getName()))); }
@Test public void singleNullValue() { Object k1 = generateKey(new Object[] { null }); Object k2 = generateKey(new Object[] { null }); Object k3 = generateKey(new Object[] { "different" }); assertThat(k1.hashCode(), equalTo(k2.hashCode())); assertThat(k1.hashCode(), not(equalTo(k3.hashCode()))); assertThat(k1, equalTo(k2)); assertThat(k1, not(equalTo(k3))); assertThat(k1, instanceOf(SimpleKey.class)); }
@Test void nullToStringIsNotAllowed() { Object testValue = mock( Object.class ); when( testValue.toString() ).thenReturn( null ); IllegalArgumentException iae = assertThrows( IllegalArgumentException.class, () -> INSTANCE.validate( testValue ) ); assertThat( iae.getMessage(), containsString( "has null toString" ) ); }
@Test public void testSpr12701() throws Exception { ResolvableType resolvableType = ResolvableType.forClassWithGenerics(Callable.class, String.class); Type type = resolvableType.getType(); assertThat(type, is(instanceOf(ParameterizedType.class))); assertThat(((ParameterizedType) type).getRawType(), is(equalTo(Callable.class))); assertThat(((ParameterizedType) type).getActualTypeArguments().length, is(equalTo(1))); assertThat(((ParameterizedType) type).getActualTypeArguments()[0], is(equalTo(String.class))); }
private void assertHasEnvironment(ApplicationContext ctx, Environment expectedEnv) { // ensure the custom environment took Environment actualEnv = ctx.getEnvironment(); assertThat(actualEnv, notNullValue()); assertThat(actualEnv, is(expectedEnv)); // ensure environment is registered as a bean assertThat(ctx.containsBean(ENVIRONMENT_BEAN_NAME), is(true)); }
private void assertHasStandardEnvironment(ApplicationContext ctx) { Environment defaultEnv = ctx.getEnvironment(); assertThat(defaultEnv, notNullValue()); assertThat(defaultEnv, instanceOf(StandardEnvironment.class)); }
@Test public void testWindowAssignment() { WindowAssigner.WindowAssignerContext mockContext = mock(WindowAssigner.WindowAssignerContext.class); SessionWindowTimeGapExtractor<String> extractor = mock(SessionWindowTimeGapExtractor.class); when(extractor.extract(eq("gap5000"))).thenReturn(5000L); when(extractor.extract(eq("gap4000"))).thenReturn(4000L); when(extractor.extract(eq("gap9000"))).thenReturn(9000L); DynamicEventTimeSessionWindows<String> assigner = DynamicEventTimeSessionWindows.withDynamicGap(extractor); assertThat(assigner.assignWindows("gap5000", 0L, mockContext), contains(timeWindow(0, 5000))); assertThat(assigner.assignWindows("gap4000", 4999L, mockContext), contains(timeWindow(4999, 8999))); assertThat(assigner.assignWindows("gap9000", 5000L, mockContext), contains(timeWindow(5000, 14000))); }
@Test public void testProperties() { SessionWindowTimeGapExtractor extractor = mock(SessionWindowTimeGapExtractor.class); when(extractor.extract(any())).thenReturn(5000L); DynamicEventTimeSessionWindows assigner = DynamicEventTimeSessionWindows.withDynamicGap(extractor); assertTrue(assigner.isEventTime()); assertEquals(new TimeWindow.Serializer(), assigner.getWindowSerializer(new ExecutionConfig())); assertThat(assigner.getDefaultTrigger(mock(StreamExecutionEnvironment.class)), instanceOf(EventTimeTrigger.class)); } }
@Test public void shouldPropagateReturnValueFromVisitFileFailed() throws IOException { for ( FileVisitResult result : FileVisitResult.values() ) { when( wrapped.visitFileFailed( any(), any() ) ).thenReturn( result ); assertThat( decorator.visitFileFailed( null, null ), is( result ) ); } }
@Test public void mustCreateAndCacheNewTokens() throws Exception { when( creator.createToken( "token" ) ).thenReturn( 42 ); assertThat( holder.getOrCreateId( "token" ), is( 42 ) ); assertThat( holder.getOrCreateId( "token" ), is( 42 ) ); // Verify implies that the call only happens once. verify( creator ).createToken( "token" ); verifyNoMoreInteractions( creator ); }
@Test public void configureMessageConvertersCustom() { final MessageConverter testConverter = mock(MessageConverter.class); AbstractMessageBrokerConfiguration config = new BaseTestMessageBrokerConfig() { @Override protected boolean configureMessageConverters(List<MessageConverter> messageConverters) { messageConverters.add(testConverter); return false; } }; CompositeMessageConverter compositeConverter = config.brokerMessageConverter(); assertThat(compositeConverter.getConverters().size(), Matchers.is(1)); Iterator<MessageConverter> iterator = compositeConverter.getConverters().iterator(); assertThat(iterator.next(), Matchers.is(testConverter)); }
@Test public void resourceChain() throws Exception { ResourceResolver mockResolver = Mockito.mock(ResourceResolver.class); ResourceTransformer mockTransformer = Mockito.mock(ResourceTransformer.class); this.registration.resourceChain(true).addResolver(mockResolver).addTransformer(mockTransformer); ResourceHttpRequestHandler handler = getHandler("/resources/**"); List<ResourceResolver> resolvers = handler.getResourceResolvers(); assertThat(resolvers.toString(), resolvers, Matchers.hasSize(4)); assertThat(resolvers.get(0), Matchers.instanceOf(CachingResourceResolver.class)); CachingResourceResolver cachingResolver = (CachingResourceResolver) resolvers.get(0); assertThat(cachingResolver.getCache(), Matchers.instanceOf(ConcurrentMapCache.class)); assertThat(resolvers.get(1), Matchers.equalTo(mockResolver)); assertThat(resolvers.get(2), Matchers.instanceOf(WebJarsResourceResolver.class)); assertThat(resolvers.get(3), Matchers.instanceOf(PathResourceResolver.class)); List<ResourceTransformer> transformers = handler.getResourceTransformers(); assertThat(transformers, Matchers.hasSize(2)); assertThat(transformers.get(0), Matchers.instanceOf(CachingResourceTransformer.class)); assertThat(transformers.get(1), Matchers.equalTo(mockTransformer)); }
@Test public void whenJacksonException_thenNotInternalServerError_NoErrorsLogged() { mapper= new GeneralExceptionMapper(mockLogger, true); assertThat(mapper.toResponse(new MyLocalException()).getStatus(), is((Status.INTERNAL_SERVER_ERROR.getStatusCode()))); verify(mockLogger, times(0)).error(any(String.class), any(Object[].class)); verify(mockLogger, times(0)).error(any(String.class), any(Throwable.class), any(Object[].class)); }
@Test public void configureMessageConvertersCustomAndDefault() { final MessageConverter testConverter = mock(MessageConverter.class); AbstractMessageBrokerConfiguration config = new BaseTestMessageBrokerConfig() { @Override protected boolean configureMessageConverters(List<MessageConverter> messageConverters) { messageConverters.add(testConverter); return true; } }; CompositeMessageConverter compositeConverter = config.brokerMessageConverter(); assertThat(compositeConverter.getConverters().size(), Matchers.is(4)); Iterator<MessageConverter> iterator = compositeConverter.getConverters().iterator(); assertThat(iterator.next(), Matchers.is(testConverter)); assertThat(iterator.next(), Matchers.instanceOf(StringMessageConverter.class)); assertThat(iterator.next(), Matchers.instanceOf(ByteArrayMessageConverter.class)); assertThat(iterator.next(), Matchers.instanceOf(MappingJackson2MessageConverter.class)); }
@Test public void importSelectorsWithGroup() { DefaultListableBeanFactory beanFactory = spy(new DefaultListableBeanFactory()); AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(beanFactory); context.register(GroupedConfig.class); context.refresh(); InOrder ordered = inOrder(beanFactory); ordered.verify(beanFactory).registerBeanDefinition(eq("a"), any()); ordered.verify(beanFactory).registerBeanDefinition(eq("b"), any()); ordered.verify(beanFactory).registerBeanDefinition(eq("c"), any()); ordered.verify(beanFactory).registerBeanDefinition(eq("d"), any()); assertThat(TestImportGroup.instancesCount.get(), equalTo(1)); assertThat(TestImportGroup.imports.size(), equalTo(1)); assertThat(TestImportGroup.imports.values().iterator().next().size(), equalTo(2)); }
@Test public void registerDestructionCallbackAfterSessionCompleted() { this.simpAttributes.sessionCompleted(); this.thrown.expect(IllegalStateException.class); this.thrown.expectMessage(containsString("already completed")); this.simpAttributes.registerDestructionCallback("name1", Mockito.mock(Runnable.class)); }
@Test public void headerContainsWithMissingHeader() throws Exception { AssertionError error = assertThrows(AssertionError.class, () -> MockRestRequestMatchers.header("foo", containsString("baz")).match(this.request)); assertThat(error.getMessage(), containsString("but was null")); }
@Test public void testLoadArrayOfString() { YamlPropertiesFactoryBean factory = new YamlPropertiesFactoryBean(); factory.setResources(new ByteArrayResource("foo:\n- bar\n- baz".getBytes())); Properties properties = factory.getObject(); assertThat(properties.getProperty("foo[0]"), equalTo("bar")); assertThat(properties.getProperty("foo[1]"), equalTo("baz")); assertThat(properties.get("foo"), is(nullValue())); }
@Test public void getAttributes() { assertThat(SimpAttributesContextHolder.getAttributes(), nullValue()); SimpAttributesContextHolder.setAttributes(this.simpAttributes); assertThat(SimpAttributesContextHolder.getAttributes(), sameInstance(this.simpAttributes)); }
@Test public void getAttributeOverrideNameFromWrongTargetAnnotation() throws Exception { Method attribute = AliasedComposedContextConfig.class.getDeclaredMethod("xmlConfigFile"); assertThat("xmlConfigFile is not an alias for @Component.", getAttributeOverrideName(attribute, Component.class), is(nullValue())); }