src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
SpringContextBootstrappingInitializer implements Declarable, ApplicationListener<ApplicationContextEvent> { public static void setBeanClassLoader(ClassLoader beanClassLoader) { if (isApplicationContextInitializable()) { beanClassLoaderReference.set(beanClassLoader); } else { throw new IllegalStateException("A Spring ApplicationContext has already been initialized"); } } static synchronized ConfigurableApplicationContext getApplicationContext(); static void setBeanClassLoader(ClassLoader beanClassLoader); static T register(T listener); static boolean register(Class<?> annotatedClass); static T unregister(T listener); static boolean unregister(Class<?> annotatedClass); @Override @SuppressWarnings("deprecation") void init(Properties parameters); void init(Cache cache, Properties parameters); @Override void onApplicationEvent(ApplicationContextEvent event); static final String BASE_PACKAGES_PARAMETER; static final String CONTEXT_CONFIG_LOCATIONS_PARAMETER; }
|
@Test public void setBeanClassLoaderWithCurrentThreadContextClassLoader() { assertThat(SpringContextBootstrappingInitializer.applicationContext, is(nullValue())); SpringContextBootstrappingInitializer.setBeanClassLoader(Thread.currentThread().getContextClassLoader()); }
@Test public void setBeanClassLoaderWithCurrentThreadContextClassLoaderWhenApplicationContextIsInactive() { ConfigurableApplicationContext mockApplicationContext = mock(ConfigurableApplicationContext.class,"MockApplicationContext"); when(mockApplicationContext.isActive()).thenReturn(false); SpringContextBootstrappingInitializer.applicationContext = mockApplicationContext; SpringContextBootstrappingInitializer.setBeanClassLoader(Thread.currentThread().getContextClassLoader()); verify(mockApplicationContext, times(1)).isActive(); }
@Test(expected = IllegalStateException.class) public void setBeanClassLoaderWithCurrentThreadContextClassLoaderWhenApplicationContextIsActive() { ConfigurableApplicationContext mockApplicationContext = mock(ConfigurableApplicationContext.class,"MockApplicationContext"); when(mockApplicationContext.isActive()).thenReturn(true); try { SpringContextBootstrappingInitializer.applicationContext = mockApplicationContext; SpringContextBootstrappingInitializer.setBeanClassLoader(Thread.currentThread().getContextClassLoader()); } catch (IllegalStateException expected) { assertThat(expected.getMessage(), containsString("A Spring ApplicationContext has already been initialized")); assertThat(expected.getCause(), is(nullValue(Throwable.class))); throw expected; } finally { verify(mockApplicationContext, times(1)).isActive(); } }
|
SpringContextBootstrappingInitializer implements Declarable, ApplicationListener<ApplicationContextEvent> { protected ConfigurableApplicationContext createApplicationContext(String[] basePackages, String[] configLocations) { String message = "'AnnotatedClasses', 'basePackages' or 'configLocations' must be specified" + " in order to construct and configure an instance of the ConfigurableApplicationContext"; Assert.isTrue(isConfigurable(registeredAnnotatedClasses, basePackages, configLocations), message); Class<?>[] annotatedClasses = registeredAnnotatedClasses.toArray(new Class<?>[0]); ConfigurableApplicationContext applicationContext = createApplicationContext(configLocations); return scanBasePackages(registerAnnotatedClasses(applicationContext, annotatedClasses), basePackages); } static synchronized ConfigurableApplicationContext getApplicationContext(); static void setBeanClassLoader(ClassLoader beanClassLoader); static T register(T listener); static boolean register(Class<?> annotatedClass); static T unregister(T listener); static boolean unregister(Class<?> annotatedClass); @Override @SuppressWarnings("deprecation") void init(Properties parameters); void init(Cache cache, Properties parameters); @Override void onApplicationEvent(ApplicationContextEvent event); static final String BASE_PACKAGES_PARAMETER; static final String CONTEXT_CONFIG_LOCATIONS_PARAMETER; }
|
@Test(expected = IllegalArgumentException.class) public void createApplicationContextWhenAnnotatedClassesBasePackagesAndConfigLocationsAreUnspecified() { try { new SpringContextBootstrappingInitializer().createApplicationContext(null, null); } catch (IllegalArgumentException expected) { assertThat(expected.getMessage(), containsString("'AnnotatedClasses', 'basePackages' or 'configLocations' must be specified" + " in order to construct and configure an instance of the ConfigurableApplicationContext")); assertThat(expected.getCause(), is(nullValue(Throwable.class))); throw expected; } }
@Test public void createXmlBasedApplicationContext() { ConfigurableApplicationContext mockAnnotationApplicationContext = mock(ConfigurableApplicationContext.class,"MockAnnotationApplicationContext"); ConfigurableApplicationContext mockXmlApplicationContext = mock(ConfigurableApplicationContext.class,"MockXmlApplicationContext"); SpringContextBootstrappingInitializer initializer = new SpringContextBootstrappingInitializer() { @Override ConfigurableApplicationContext createApplicationContext(final String[] configLocations) { return ObjectUtils.isEmpty(configLocations) ? mockAnnotationApplicationContext : mockXmlApplicationContext; } }; ConfigurableApplicationContext actualApplicationContext = initializer.createApplicationContext(null, new String[] { "/path/to/application/context.xml" }); assertThat(actualApplicationContext, is(sameInstance(mockXmlApplicationContext))); }
|
SpringContextBootstrappingInitializer implements Declarable, ApplicationListener<ApplicationContextEvent> { protected ConfigurableApplicationContext initApplicationContext(ConfigurableApplicationContext applicationContext) { Assert.notNull(applicationContext, "ConfigurableApplicationContext must not be null"); applicationContext.addApplicationListener(this); applicationContext.registerShutdownHook(); return setClassLoader(applicationContext); } static synchronized ConfigurableApplicationContext getApplicationContext(); static void setBeanClassLoader(ClassLoader beanClassLoader); static T register(T listener); static boolean register(Class<?> annotatedClass); static T unregister(T listener); static boolean unregister(Class<?> annotatedClass); @Override @SuppressWarnings("deprecation") void init(Properties parameters); void init(Cache cache, Properties parameters); @Override void onApplicationEvent(ApplicationContextEvent event); static final String BASE_PACKAGES_PARAMETER; static final String CONTEXT_CONFIG_LOCATIONS_PARAMETER; }
|
@Test public void initApplicationContext() { AbstractApplicationContext mockApplicationContext = mock(AbstractApplicationContext.class,"MockApplicationContext"); SpringContextBootstrappingInitializer.setBeanClassLoader(Thread.currentThread().getContextClassLoader()); SpringContextBootstrappingInitializer initializer = new SpringContextBootstrappingInitializer(); assertSame(mockApplicationContext, initializer.initApplicationContext(mockApplicationContext)); verify(mockApplicationContext, times(1)).addApplicationListener(same(initializer)); verify(mockApplicationContext, times(1)).registerShutdownHook(); verify(mockApplicationContext, times(1)).setClassLoader(eq(Thread.currentThread().getContextClassLoader())); }
@Test(expected = IllegalArgumentException.class) public void initApplicationContextWithNull() { try { new SpringContextBootstrappingInitializer().initApplicationContext(null); } catch (IllegalArgumentException expected) { assertThat(expected.getMessage(), containsString("ConfigurableApplicationContext must not be null")); assertThat(expected.getCause(), is(nullValue(Throwable.class))); throw expected; } }
|
SpringContextBootstrappingInitializer implements Declarable, ApplicationListener<ApplicationContextEvent> { protected ConfigurableApplicationContext refreshApplicationContext(ConfigurableApplicationContext applicationContext) { Assert.notNull(applicationContext, "ConfigurableApplicationContext must not be null"); applicationContext.refresh(); return applicationContext; } static synchronized ConfigurableApplicationContext getApplicationContext(); static void setBeanClassLoader(ClassLoader beanClassLoader); static T register(T listener); static boolean register(Class<?> annotatedClass); static T unregister(T listener); static boolean unregister(Class<?> annotatedClass); @Override @SuppressWarnings("deprecation") void init(Properties parameters); void init(Cache cache, Properties parameters); @Override void onApplicationEvent(ApplicationContextEvent event); static final String BASE_PACKAGES_PARAMETER; static final String CONTEXT_CONFIG_LOCATIONS_PARAMETER; }
|
@Test public void refreshApplicationContext() { ConfigurableApplicationContext mockApplicationContext = mock(ConfigurableApplicationContext.class,"MockApplicationContext"); assertThat(new SpringContextBootstrappingInitializer().refreshApplicationContext(mockApplicationContext), is(sameInstance(mockApplicationContext))); verify(mockApplicationContext, times(1)).refresh(); }
@Test(expected = IllegalArgumentException.class) public void refreshApplicationContextWithNull() { try { new SpringContextBootstrappingInitializer().refreshApplicationContext(null); } catch (IllegalArgumentException expected) { assertThat(expected.getMessage(), containsString("ConfigurableApplicationContext must not be null")); assertThat(expected.getCause(), is(nullValue(Throwable.class))); throw expected; } }
|
CacheFactoryBean extends AbstractFactoryBeanSupport<GemFireCache> implements DisposableBean, InitializingBean, PersistenceExceptionTranslator, Phased { protected Properties resolveProperties() { return Optional.ofNullable(getProperties()).orElseGet(() -> setAndGetProperties(new Properties())); } @Override void afterPropertiesSet(); @Override void destroy(); @Override DataAccessException translateExceptionIfPossible(RuntimeException exception); GemfireBeanFactoryLocator getBeanFactoryLocator(); void setCacheXml(Resource cacheXml); Resource getCacheXml(); @Override GemFireCache getObject(); @Override Class<? extends GemFireCache> getObjectType(); @SuppressWarnings("rawtypes") void setCacheFactoryInitializer(CacheFactoryInitializer cacheFactoryInitializer); @SuppressWarnings("rawtypes") CacheFactoryInitializer getCacheFactoryInitializer(); void setProperties(Properties properties); Properties getProperties(); void setClose(boolean close); boolean isClose(); PeerCacheConfigurer getCompositePeerCacheConfigurer(); void setCopyOnRead(Boolean copyOnRead); Boolean getCopyOnRead(); void setCriticalHeapPercentage(Float criticalHeapPercentage); Float getCriticalHeapPercentage(); void setCriticalOffHeapPercentage(Float criticalOffHeapPercentage); Float getCriticalOffHeapPercentage(); void setEnableAutoReconnect(Boolean enableAutoReconnect); Boolean getEnableAutoReconnect(); void setEvictionHeapPercentage(Float evictionHeapPercentage); Float getEvictionHeapPercentage(); void setEvictionOffHeapPercentage(Float evictionOffHeapPercentage); Float getEvictionOffHeapPercentage(); void setGatewayConflictResolver(GatewayConflictResolver gatewayConflictResolver); GatewayConflictResolver getGatewayConflictResolver(); void setJndiDataSources(List<JndiDataSource> jndiDataSources); List<JndiDataSource> getJndiDataSources(); void setLockLease(Integer lockLease); Integer getLockLease(); void setLockTimeout(Integer lockTimeout); Integer getLockTimeout(); void setMessageSyncInterval(Integer messageSyncInterval); Integer getMessageSyncInterval(); @Override int getPhase(); void setPdxDiskStoreName(String pdxDiskStoreName); String getPdxDiskStoreName(); void setPdxIgnoreUnreadFields(Boolean pdxIgnoreUnreadFields); Boolean getPdxIgnoreUnreadFields(); void setPdxPersistent(Boolean pdxPersistent); Boolean getPdxPersistent(); void setPdxReadSerialized(Boolean pdxReadSerialized); Boolean getPdxReadSerialized(); void setPdxSerializer(PdxSerializer serializer); PdxSerializer getPdxSerializer(); void setPeerCacheConfigurers(PeerCacheConfigurer... peerCacheConfigurers); void setPeerCacheConfigurers(List<PeerCacheConfigurer> peerCacheConfigurers); void setSearchTimeout(Integer searchTimeout); Integer getSearchTimeout(); void setSecurityManager(SecurityManager securityManager); SecurityManager getSecurityManager(); void setTransactionListeners(List<TransactionListener> transactionListeners); List<TransactionListener> getTransactionListeners(); void setTransactionWriter(TransactionWriter transactionWriter); TransactionWriter getTransactionWriter(); void setUseBeanFactoryLocator(boolean use); boolean isUseBeanFactoryLocator(); void setUseClusterConfiguration(Boolean useSharedConfiguration); Boolean getUseClusterConfiguration(); }
|
@Test public void resolveProperties() { Properties gemfireProperties = new Properties(); CacheFactoryBean cacheFactoryBean = new CacheFactoryBean(); cacheFactoryBean.setProperties(gemfireProperties); assertThat(cacheFactoryBean.resolveProperties(), is(sameInstance(gemfireProperties))); }
|
SpringContextBootstrappingInitializer implements Declarable, ApplicationListener<ApplicationContextEvent> { ConfigurableApplicationContext registerAnnotatedClasses(ConfigurableApplicationContext applicationContext, Class<?>[] annotatedClasses) { return applicationContext instanceof AnnotationConfigApplicationContext && !ObjectUtils.isEmpty(annotatedClasses) ? doRegister(applicationContext, annotatedClasses) : applicationContext; } static synchronized ConfigurableApplicationContext getApplicationContext(); static void setBeanClassLoader(ClassLoader beanClassLoader); static T register(T listener); static boolean register(Class<?> annotatedClass); static T unregister(T listener); static boolean unregister(Class<?> annotatedClass); @Override @SuppressWarnings("deprecation") void init(Properties parameters); void init(Cache cache, Properties parameters); @Override void onApplicationEvent(ApplicationContextEvent event); static final String BASE_PACKAGES_PARAMETER; static final String CONTEXT_CONFIG_LOCATIONS_PARAMETER; }
|
@Test public void registerAnnotatedClasses() { AnnotationConfigApplicationContext mockApplicationContext = mock(AnnotationConfigApplicationContext.class,"MockApplicationContext"); Class<?>[] annotatedClasses = { TestAppConfigOne.class, TestAppConfigTwo.class }; SpringContextBootstrappingInitializer initializer = spy(new SpringContextBootstrappingInitializer()); doReturn(mockApplicationContext) .when(initializer).doRegister(any(ConfigurableApplicationContext.class), any(Class[].class)); assertThat(initializer.registerAnnotatedClasses(mockApplicationContext, annotatedClasses), is(sameInstance(mockApplicationContext))); verify(initializer, times(1)) .doRegister(eq(mockApplicationContext), eq(annotatedClasses)); }
|
SpringContextBootstrappingInitializer implements Declarable, ApplicationListener<ApplicationContextEvent> { ConfigurableApplicationContext scanBasePackages(ConfigurableApplicationContext applicationContext, String[] basePackages) { return applicationContext instanceof AnnotationConfigApplicationContext && !ObjectUtils.isEmpty(basePackages) ? doScan(applicationContext, basePackages) : applicationContext; } static synchronized ConfigurableApplicationContext getApplicationContext(); static void setBeanClassLoader(ClassLoader beanClassLoader); static T register(T listener); static boolean register(Class<?> annotatedClass); static T unregister(T listener); static boolean unregister(Class<?> annotatedClass); @Override @SuppressWarnings("deprecation") void init(Properties parameters); void init(Cache cache, Properties parameters); @Override void onApplicationEvent(ApplicationContextEvent event); static final String BASE_PACKAGES_PARAMETER; static final String CONTEXT_CONFIG_LOCATIONS_PARAMETER; }
|
@Test public void scanBasePackages() { AnnotationConfigApplicationContext mockApplicationContext = mock(AnnotationConfigApplicationContext.class, "MockApplicationContext"); SpringContextBootstrappingInitializer initializer = spy(new SpringContextBootstrappingInitializer()); doReturn(mockApplicationContext) .when(initializer).doScan(any(ConfigurableApplicationContext.class), any(String[].class)); String[] basePackages = { "org.example.app", "org.example.plugins" }; assertThat(initializer.scanBasePackages(mockApplicationContext, basePackages), is(sameInstance(mockApplicationContext))); verify(initializer, times(1)).doScan(eq(mockApplicationContext), eq(basePackages)); }
|
SpringContextBootstrappingInitializer implements Declarable, ApplicationListener<ApplicationContextEvent> { ConfigurableApplicationContext setClassLoader(ConfigurableApplicationContext applicationContext) { ClassLoader beanClassLoader = beanClassLoaderReference.get(); if (applicationContext instanceof DefaultResourceLoader && beanClassLoader != null) { ((DefaultResourceLoader) applicationContext).setClassLoader(beanClassLoader); } return applicationContext; } static synchronized ConfigurableApplicationContext getApplicationContext(); static void setBeanClassLoader(ClassLoader beanClassLoader); static T register(T listener); static boolean register(Class<?> annotatedClass); static T unregister(T listener); static boolean unregister(Class<?> annotatedClass); @Override @SuppressWarnings("deprecation") void init(Properties parameters); void init(Cache cache, Properties parameters); @Override void onApplicationEvent(ApplicationContextEvent event); static final String BASE_PACKAGES_PARAMETER; static final String CONTEXT_CONFIG_LOCATIONS_PARAMETER; }
|
@Test public void setClassLoader() { AbstractApplicationContext mockApplicationContext = mock(AbstractApplicationContext.class, "MockApplicationContext"); SpringContextBootstrappingInitializer.setBeanClassLoader(Thread.currentThread().getContextClassLoader()); assertThat(new SpringContextBootstrappingInitializer().setClassLoader(mockApplicationContext), is(sameInstance(mockApplicationContext))); verify(mockApplicationContext, times(1)) .setClassLoader(eq(Thread.currentThread().getContextClassLoader())); }
|
SpringContextBootstrappingInitializer implements Declarable, ApplicationListener<ApplicationContextEvent> { String nullSafeGetApplicationContextId(ApplicationContext applicationContext) { return applicationContext != null ? applicationContext.getId() : null; } static synchronized ConfigurableApplicationContext getApplicationContext(); static void setBeanClassLoader(ClassLoader beanClassLoader); static T register(T listener); static boolean register(Class<?> annotatedClass); static T unregister(T listener); static boolean unregister(Class<?> annotatedClass); @Override @SuppressWarnings("deprecation") void init(Properties parameters); void init(Cache cache, Properties parameters); @Override void onApplicationEvent(ApplicationContextEvent event); static final String BASE_PACKAGES_PARAMETER; static final String CONTEXT_CONFIG_LOCATIONS_PARAMETER; }
|
@Test public void nullSafeGetApplicationContextIdWithNullReference() { assertThat(new SpringContextBootstrappingInitializer().nullSafeGetApplicationContextId(null), is(nullValue())); }
@Test public void nullSafeGetApplicationContextIdWithNonNullReference() { ApplicationContext mockApplicationContext = mock(ApplicationContext.class, "MockApplicationContext"); when(mockApplicationContext.getId()).thenReturn("123"); assertThat(new SpringContextBootstrappingInitializer().nullSafeGetApplicationContextId(mockApplicationContext), is(equalTo("123"))); }
|
SpringContextBootstrappingInitializer implements Declarable, ApplicationListener<ApplicationContextEvent> { @Override @SuppressWarnings("deprecation") public void init(Properties parameters) { init(CacheUtils.getCache(), parameters); } static synchronized ConfigurableApplicationContext getApplicationContext(); static void setBeanClassLoader(ClassLoader beanClassLoader); static T register(T listener); static boolean register(Class<?> annotatedClass); static T unregister(T listener); static boolean unregister(Class<?> annotatedClass); @Override @SuppressWarnings("deprecation") void init(Properties parameters); void init(Cache cache, Properties parameters); @Override void onApplicationEvent(ApplicationContextEvent event); static final String BASE_PACKAGES_PARAMETER; static final String CONTEXT_CONFIG_LOCATIONS_PARAMETER; }
|
@Test(expected = ApplicationContextException.class) public void testInitWhenBasePackagesAndContextConfigLocationsParametersAreUnspecified() { assertThat(SpringContextBootstrappingInitializer.applicationContext, is(nullValue())); try { Properties parameters = createParameters(createParameters( SpringContextBootstrappingInitializer.CONTEXT_CONFIG_LOCATIONS_PARAMETER, ""), SpringContextBootstrappingInitializer.BASE_PACKAGES_PARAMETER, " "); new SpringContextBootstrappingInitializer().init(this.mockCache, parameters); } catch (ApplicationContextException expected) { assertThat(expected.getMessage(), containsString("Failed to bootstrap the Spring ApplicationContext")); assertThat(expected.getCause(), is(instanceOf(IllegalArgumentException.class))); throw expected; } }
@SuppressWarnings("all") @Test(expected = IllegalStateException.class) public void testInitLogsErrors() throws Throwable { Logger mockLog = mock(Logger.class, "testInitLogsErrors.MockLog"); SpringContextBootstrappingInitializer initializer = new SpringContextBootstrappingInitializer() { @Override protected Logger initLogger() { return mockLog; } @Override protected ConfigurableApplicationContext createApplicationContext(String[] basePackages, String[] configLocations) { throw new IllegalStateException("TEST"); } }; try { Properties parameters = createParameters(SpringContextBootstrappingInitializer.CONTEXT_CONFIG_LOCATIONS_PARAMETER, "classpath/to/spring/application/context.xml"); initializer.init(this.mockCache, parameters); } catch (ApplicationContextException expected) { assertTrue(expected.getMessage().contains("Failed to bootstrap the Spring ApplicationContext")); assertTrue(expected.getCause() instanceof IllegalStateException); assertEquals("TEST", expected.getCause().getMessage()); throw expected.getCause(); } finally { verify(mockLog, times(1)) .error(eq("Failed to bootstrap the Spring ApplicationContext"), any(RuntimeException.class)); } }
|
GatewayReceiverFactoryBean extends AbstractWANComponentFactoryBean<GatewayReceiver> { @Override protected void doInit() { GatewayReceiverFactory gatewayReceiverFactory = this.cache.createGatewayReceiverFactory(); StreamSupport.stream(CollectionUtils.nullSafeIterable(this.gatewayReceiverConfigurers).spliterator(), false) .forEach(it -> it.configure(getName(), this)); Optional.ofNullable(this.bindAddress) .filter(StringUtils::hasText) .ifPresent(gatewayReceiverFactory::setBindAddress); Optional.ofNullable(this.hostnameForSenders) .filter(StringUtils::hasText) .ifPresent(gatewayReceiverFactory::setHostnameForSenders); int localStartPort = defaultPort(this.startPort, GatewayReceiver.DEFAULT_START_PORT); int localEndPort = defaultPort(this.endPort, GatewayReceiver.DEFAULT_END_PORT); Assert.isTrue(localStartPort <= localEndPort, String.format("[startPort] must be less than or equal to [%d]", localEndPort)); gatewayReceiverFactory.setStartPort(localStartPort); gatewayReceiverFactory.setEndPort(localEndPort); gatewayReceiverFactory.setManualStart(this.manualStart); Optional.ofNullable(this.maximumTimeBetweenPings).ifPresent(gatewayReceiverFactory::setMaximumTimeBetweenPings); Optional.ofNullable(this.socketBufferSize).ifPresent(gatewayReceiverFactory::setSocketBufferSize); CollectionUtils.nullSafeList(this.transportFilters).forEach(gatewayReceiverFactory::addGatewayTransportFilter); this.gatewayReceiver = gatewayReceiverFactory.create(); } GatewayReceiverFactoryBean(Cache cache); @Override GatewayReceiver getObject(); @Override Class<?> getObjectType(); void setGatewayReceiver(GatewayReceiver gatewayReceiver); void setGatewayReceiverConfigurers(List<GatewayReceiverConfigurer> gatewayReceiverConfigurers); void setBindAddress(String bindAddress); void setHostnameForSenders(String hostnameForSenders); void setStartPort(Integer startPort); void setEndPort(Integer endPort); void setManualStart(Boolean manualStart); void setMaximumTimeBetweenPings(Integer maximumTimeBetweenPings); void setSocketBufferSize(Integer socketBufferSize); void setTransportFilters(List<GatewayTransportFilter> transportFilters); Collection<? extends GatewayTransportFilter> getTransportFilters(); }
|
@Test public void testDoInit() throws Exception { Cache mockCache = mock(Cache.class, "testDoInit.Cache"); GatewayReceiverFactory mockGatewayReceiverFactory = mock(GatewayReceiverFactory.class, "testDoInit.GatewayReceiverFactory"); GatewayTransportFilter mockGatewayTransportFilter = mock(GatewayTransportFilter.class, "testDoInit.GatewayTransportFilter"); when(mockCache.createGatewayReceiverFactory()).thenReturn(mockGatewayReceiverFactory); GatewayReceiverFactoryBean factoryBean = new GatewayReceiverFactoryBean(mockCache); factoryBean.setBindAddress("10.224.112.77"); factoryBean.setHostnameForSenders("skullbox"); factoryBean.setStartPort(2048); factoryBean.setEndPort(4096); factoryBean.setManualStart(true); factoryBean.setMaximumTimeBetweenPings(5000); factoryBean.setName("testDoInit"); factoryBean.setSocketBufferSize(16384); factoryBean.setTransportFilters(Collections.singletonList(mockGatewayTransportFilter)); factoryBean.afterPropertiesSet(); verify(mockGatewayReceiverFactory).setBindAddress(eq("10.224.112.77")); verify(mockGatewayReceiverFactory).setHostnameForSenders(eq("skullbox")); verify(mockGatewayReceiverFactory).setStartPort(eq(2048)); verify(mockGatewayReceiverFactory).setEndPort(eq(4096)); verify(mockGatewayReceiverFactory).setManualStart(eq(true)); verify(mockGatewayReceiverFactory).setMaximumTimeBetweenPings(eq(5000)); verify(mockGatewayReceiverFactory).setSocketBufferSize(eq(16384)); verify(mockGatewayReceiverFactory).addGatewayTransportFilter(same(mockGatewayTransportFilter)); verify(mockGatewayReceiverFactory).create(); }
|
CacheFactoryBean extends AbstractFactoryBeanSupport<GemFireCache> implements DisposableBean, InitializingBean, PersistenceExceptionTranslator, Phased { protected Object createFactory(Properties gemfireProperties) { return new CacheFactory(gemfireProperties); } @Override void afterPropertiesSet(); @Override void destroy(); @Override DataAccessException translateExceptionIfPossible(RuntimeException exception); GemfireBeanFactoryLocator getBeanFactoryLocator(); void setCacheXml(Resource cacheXml); Resource getCacheXml(); @Override GemFireCache getObject(); @Override Class<? extends GemFireCache> getObjectType(); @SuppressWarnings("rawtypes") void setCacheFactoryInitializer(CacheFactoryInitializer cacheFactoryInitializer); @SuppressWarnings("rawtypes") CacheFactoryInitializer getCacheFactoryInitializer(); void setProperties(Properties properties); Properties getProperties(); void setClose(boolean close); boolean isClose(); PeerCacheConfigurer getCompositePeerCacheConfigurer(); void setCopyOnRead(Boolean copyOnRead); Boolean getCopyOnRead(); void setCriticalHeapPercentage(Float criticalHeapPercentage); Float getCriticalHeapPercentage(); void setCriticalOffHeapPercentage(Float criticalOffHeapPercentage); Float getCriticalOffHeapPercentage(); void setEnableAutoReconnect(Boolean enableAutoReconnect); Boolean getEnableAutoReconnect(); void setEvictionHeapPercentage(Float evictionHeapPercentage); Float getEvictionHeapPercentage(); void setEvictionOffHeapPercentage(Float evictionOffHeapPercentage); Float getEvictionOffHeapPercentage(); void setGatewayConflictResolver(GatewayConflictResolver gatewayConflictResolver); GatewayConflictResolver getGatewayConflictResolver(); void setJndiDataSources(List<JndiDataSource> jndiDataSources); List<JndiDataSource> getJndiDataSources(); void setLockLease(Integer lockLease); Integer getLockLease(); void setLockTimeout(Integer lockTimeout); Integer getLockTimeout(); void setMessageSyncInterval(Integer messageSyncInterval); Integer getMessageSyncInterval(); @Override int getPhase(); void setPdxDiskStoreName(String pdxDiskStoreName); String getPdxDiskStoreName(); void setPdxIgnoreUnreadFields(Boolean pdxIgnoreUnreadFields); Boolean getPdxIgnoreUnreadFields(); void setPdxPersistent(Boolean pdxPersistent); Boolean getPdxPersistent(); void setPdxReadSerialized(Boolean pdxReadSerialized); Boolean getPdxReadSerialized(); void setPdxSerializer(PdxSerializer serializer); PdxSerializer getPdxSerializer(); void setPeerCacheConfigurers(PeerCacheConfigurer... peerCacheConfigurers); void setPeerCacheConfigurers(List<PeerCacheConfigurer> peerCacheConfigurers); void setSearchTimeout(Integer searchTimeout); Integer getSearchTimeout(); void setSecurityManager(SecurityManager securityManager); SecurityManager getSecurityManager(); void setTransactionListeners(List<TransactionListener> transactionListeners); List<TransactionListener> getTransactionListeners(); void setTransactionWriter(TransactionWriter transactionWriter); TransactionWriter getTransactionWriter(); void setUseBeanFactoryLocator(boolean use); boolean isUseBeanFactoryLocator(); void setUseClusterConfiguration(Boolean useSharedConfiguration); Boolean getUseClusterConfiguration(); }
|
@Test public void createFactory() { Properties gemfireProperties = new Properties(); Object cacheFactoryReference = new CacheFactoryBean().createFactory(gemfireProperties); assertThat(cacheFactoryReference, is(instanceOf(CacheFactory.class))); assertThat(gemfireProperties.isEmpty(), is(true)); CacheFactory cacheFactory = (CacheFactory) cacheFactoryReference; cacheFactory.set("name", "TestCreateCacheFactory"); assertThat(gemfireProperties.containsKey("name"), is(true)); assertThat(gemfireProperties.getProperty("name"), is(equalTo("TestCreateCacheFactory"))); }
|
CacheFactoryBean extends AbstractFactoryBeanSupport<GemFireCache> implements DisposableBean, InitializingBean, PersistenceExceptionTranslator, Phased { @SuppressWarnings("unchecked") protected <T extends GemFireCache> T createCache(Object factory) { return (T) ((CacheFactory) factory).create(); } @Override void afterPropertiesSet(); @Override void destroy(); @Override DataAccessException translateExceptionIfPossible(RuntimeException exception); GemfireBeanFactoryLocator getBeanFactoryLocator(); void setCacheXml(Resource cacheXml); Resource getCacheXml(); @Override GemFireCache getObject(); @Override Class<? extends GemFireCache> getObjectType(); @SuppressWarnings("rawtypes") void setCacheFactoryInitializer(CacheFactoryInitializer cacheFactoryInitializer); @SuppressWarnings("rawtypes") CacheFactoryInitializer getCacheFactoryInitializer(); void setProperties(Properties properties); Properties getProperties(); void setClose(boolean close); boolean isClose(); PeerCacheConfigurer getCompositePeerCacheConfigurer(); void setCopyOnRead(Boolean copyOnRead); Boolean getCopyOnRead(); void setCriticalHeapPercentage(Float criticalHeapPercentage); Float getCriticalHeapPercentage(); void setCriticalOffHeapPercentage(Float criticalOffHeapPercentage); Float getCriticalOffHeapPercentage(); void setEnableAutoReconnect(Boolean enableAutoReconnect); Boolean getEnableAutoReconnect(); void setEvictionHeapPercentage(Float evictionHeapPercentage); Float getEvictionHeapPercentage(); void setEvictionOffHeapPercentage(Float evictionOffHeapPercentage); Float getEvictionOffHeapPercentage(); void setGatewayConflictResolver(GatewayConflictResolver gatewayConflictResolver); GatewayConflictResolver getGatewayConflictResolver(); void setJndiDataSources(List<JndiDataSource> jndiDataSources); List<JndiDataSource> getJndiDataSources(); void setLockLease(Integer lockLease); Integer getLockLease(); void setLockTimeout(Integer lockTimeout); Integer getLockTimeout(); void setMessageSyncInterval(Integer messageSyncInterval); Integer getMessageSyncInterval(); @Override int getPhase(); void setPdxDiskStoreName(String pdxDiskStoreName); String getPdxDiskStoreName(); void setPdxIgnoreUnreadFields(Boolean pdxIgnoreUnreadFields); Boolean getPdxIgnoreUnreadFields(); void setPdxPersistent(Boolean pdxPersistent); Boolean getPdxPersistent(); void setPdxReadSerialized(Boolean pdxReadSerialized); Boolean getPdxReadSerialized(); void setPdxSerializer(PdxSerializer serializer); PdxSerializer getPdxSerializer(); void setPeerCacheConfigurers(PeerCacheConfigurer... peerCacheConfigurers); void setPeerCacheConfigurers(List<PeerCacheConfigurer> peerCacheConfigurers); void setSearchTimeout(Integer searchTimeout); Integer getSearchTimeout(); void setSecurityManager(SecurityManager securityManager); SecurityManager getSecurityManager(); void setTransactionListeners(List<TransactionListener> transactionListeners); List<TransactionListener> getTransactionListeners(); void setTransactionWriter(TransactionWriter transactionWriter); TransactionWriter getTransactionWriter(); void setUseBeanFactoryLocator(boolean use); boolean isUseBeanFactoryLocator(); void setUseClusterConfiguration(Boolean useSharedConfiguration); Boolean getUseClusterConfiguration(); }
|
@Test public void createCacheWithCacheFactory() { CacheFactory mockCacheFactory = mock(CacheFactory.class); when(mockCacheFactory.create()).thenReturn(mockCache); CacheFactoryBean cacheFactoryBean = new CacheFactoryBean(); Cache actualCache = cacheFactoryBean.createCache(mockCacheFactory); assertThat(actualCache, is(equalTo(mockCache))); verify(mockCacheFactory, times(1)).create(); verifyZeroInteractions(mockCache); }
|
CacheFactoryBean extends AbstractFactoryBeanSupport<GemFireCache> implements DisposableBean, InitializingBean, PersistenceExceptionTranslator, Phased { @Override public Class<? extends GemFireCache> getObjectType() { Cache cache = getCache(); return cache != null ? cache.getClass() : Cache.class; } @Override void afterPropertiesSet(); @Override void destroy(); @Override DataAccessException translateExceptionIfPossible(RuntimeException exception); GemfireBeanFactoryLocator getBeanFactoryLocator(); void setCacheXml(Resource cacheXml); Resource getCacheXml(); @Override GemFireCache getObject(); @Override Class<? extends GemFireCache> getObjectType(); @SuppressWarnings("rawtypes") void setCacheFactoryInitializer(CacheFactoryInitializer cacheFactoryInitializer); @SuppressWarnings("rawtypes") CacheFactoryInitializer getCacheFactoryInitializer(); void setProperties(Properties properties); Properties getProperties(); void setClose(boolean close); boolean isClose(); PeerCacheConfigurer getCompositePeerCacheConfigurer(); void setCopyOnRead(Boolean copyOnRead); Boolean getCopyOnRead(); void setCriticalHeapPercentage(Float criticalHeapPercentage); Float getCriticalHeapPercentage(); void setCriticalOffHeapPercentage(Float criticalOffHeapPercentage); Float getCriticalOffHeapPercentage(); void setEnableAutoReconnect(Boolean enableAutoReconnect); Boolean getEnableAutoReconnect(); void setEvictionHeapPercentage(Float evictionHeapPercentage); Float getEvictionHeapPercentage(); void setEvictionOffHeapPercentage(Float evictionOffHeapPercentage); Float getEvictionOffHeapPercentage(); void setGatewayConflictResolver(GatewayConflictResolver gatewayConflictResolver); GatewayConflictResolver getGatewayConflictResolver(); void setJndiDataSources(List<JndiDataSource> jndiDataSources); List<JndiDataSource> getJndiDataSources(); void setLockLease(Integer lockLease); Integer getLockLease(); void setLockTimeout(Integer lockTimeout); Integer getLockTimeout(); void setMessageSyncInterval(Integer messageSyncInterval); Integer getMessageSyncInterval(); @Override int getPhase(); void setPdxDiskStoreName(String pdxDiskStoreName); String getPdxDiskStoreName(); void setPdxIgnoreUnreadFields(Boolean pdxIgnoreUnreadFields); Boolean getPdxIgnoreUnreadFields(); void setPdxPersistent(Boolean pdxPersistent); Boolean getPdxPersistent(); void setPdxReadSerialized(Boolean pdxReadSerialized); Boolean getPdxReadSerialized(); void setPdxSerializer(PdxSerializer serializer); PdxSerializer getPdxSerializer(); void setPeerCacheConfigurers(PeerCacheConfigurer... peerCacheConfigurers); void setPeerCacheConfigurers(List<PeerCacheConfigurer> peerCacheConfigurers); void setSearchTimeout(Integer searchTimeout); Integer getSearchTimeout(); void setSecurityManager(SecurityManager securityManager); SecurityManager getSecurityManager(); void setTransactionListeners(List<TransactionListener> transactionListeners); List<TransactionListener> getTransactionListeners(); void setTransactionWriter(TransactionWriter transactionWriter); TransactionWriter getTransactionWriter(); void setUseBeanFactoryLocator(boolean use); boolean isUseBeanFactoryLocator(); void setUseClusterConfiguration(Boolean useSharedConfiguration); Boolean getUseClusterConfiguration(); }
|
@Test @SuppressWarnings("unchecked") public void getObjectType() { assertThat(new CacheFactoryBean().getObjectType(), is(equalTo(Cache.class))); }
|
CacheFactoryBean extends AbstractFactoryBeanSupport<GemFireCache> implements DisposableBean, InitializingBean, PersistenceExceptionTranslator, Phased { @Override public void destroy() { if (isClose()) { close(fetchCache()); destroyBeanFactoryLocator(); } } @Override void afterPropertiesSet(); @Override void destroy(); @Override DataAccessException translateExceptionIfPossible(RuntimeException exception); GemfireBeanFactoryLocator getBeanFactoryLocator(); void setCacheXml(Resource cacheXml); Resource getCacheXml(); @Override GemFireCache getObject(); @Override Class<? extends GemFireCache> getObjectType(); @SuppressWarnings("rawtypes") void setCacheFactoryInitializer(CacheFactoryInitializer cacheFactoryInitializer); @SuppressWarnings("rawtypes") CacheFactoryInitializer getCacheFactoryInitializer(); void setProperties(Properties properties); Properties getProperties(); void setClose(boolean close); boolean isClose(); PeerCacheConfigurer getCompositePeerCacheConfigurer(); void setCopyOnRead(Boolean copyOnRead); Boolean getCopyOnRead(); void setCriticalHeapPercentage(Float criticalHeapPercentage); Float getCriticalHeapPercentage(); void setCriticalOffHeapPercentage(Float criticalOffHeapPercentage); Float getCriticalOffHeapPercentage(); void setEnableAutoReconnect(Boolean enableAutoReconnect); Boolean getEnableAutoReconnect(); void setEvictionHeapPercentage(Float evictionHeapPercentage); Float getEvictionHeapPercentage(); void setEvictionOffHeapPercentage(Float evictionOffHeapPercentage); Float getEvictionOffHeapPercentage(); void setGatewayConflictResolver(GatewayConflictResolver gatewayConflictResolver); GatewayConflictResolver getGatewayConflictResolver(); void setJndiDataSources(List<JndiDataSource> jndiDataSources); List<JndiDataSource> getJndiDataSources(); void setLockLease(Integer lockLease); Integer getLockLease(); void setLockTimeout(Integer lockTimeout); Integer getLockTimeout(); void setMessageSyncInterval(Integer messageSyncInterval); Integer getMessageSyncInterval(); @Override int getPhase(); void setPdxDiskStoreName(String pdxDiskStoreName); String getPdxDiskStoreName(); void setPdxIgnoreUnreadFields(Boolean pdxIgnoreUnreadFields); Boolean getPdxIgnoreUnreadFields(); void setPdxPersistent(Boolean pdxPersistent); Boolean getPdxPersistent(); void setPdxReadSerialized(Boolean pdxReadSerialized); Boolean getPdxReadSerialized(); void setPdxSerializer(PdxSerializer serializer); PdxSerializer getPdxSerializer(); void setPeerCacheConfigurers(PeerCacheConfigurer... peerCacheConfigurers); void setPeerCacheConfigurers(List<PeerCacheConfigurer> peerCacheConfigurers); void setSearchTimeout(Integer searchTimeout); Integer getSearchTimeout(); void setSecurityManager(SecurityManager securityManager); SecurityManager getSecurityManager(); void setTransactionListeners(List<TransactionListener> transactionListeners); List<TransactionListener> getTransactionListeners(); void setTransactionWriter(TransactionWriter transactionWriter); TransactionWriter getTransactionWriter(); void setUseBeanFactoryLocator(boolean use); boolean isUseBeanFactoryLocator(); void setUseClusterConfiguration(Boolean useSharedConfiguration); Boolean getUseClusterConfiguration(); }
|
@Test @SuppressWarnings("unchecked") public void destroy() throws Exception { AtomicBoolean fetchCacheCalled = new AtomicBoolean(false); Cache mockCache = mock(Cache.class, "GemFireCache"); GemfireBeanFactoryLocator mockGemfireBeanFactoryLocator = mock(GemfireBeanFactoryLocator.class); when(mockCache.isClosed()).thenReturn(false); CacheFactoryBean cacheFactoryBean = spy(new CacheFactoryBean()); doAnswer(invocation -> { fetchCacheCalled.set(true); return mockCache; }).when(cacheFactoryBean).fetchCache(); doReturn(mockGemfireBeanFactoryLocator).when(cacheFactoryBean).getBeanFactoryLocator(); cacheFactoryBean.setClose(true); cacheFactoryBean.setUseBeanFactoryLocator(true); cacheFactoryBean.destroy(); assertThat(fetchCacheCalled.get(), is(true)); verify(mockCache, times(1)).isClosed(); verify(mockCache, times(1)).close(); verify(mockGemfireBeanFactoryLocator, times(1)).destroy(); }
|
CacheFactoryBean extends AbstractFactoryBeanSupport<GemFireCache> implements DisposableBean, InitializingBean, PersistenceExceptionTranslator, Phased { protected void close(GemFireCache cache) { Optional.ofNullable(cache) .filter(it -> !it.isClosed()) .ifPresent(RegionService::close); setCache(null); } @Override void afterPropertiesSet(); @Override void destroy(); @Override DataAccessException translateExceptionIfPossible(RuntimeException exception); GemfireBeanFactoryLocator getBeanFactoryLocator(); void setCacheXml(Resource cacheXml); Resource getCacheXml(); @Override GemFireCache getObject(); @Override Class<? extends GemFireCache> getObjectType(); @SuppressWarnings("rawtypes") void setCacheFactoryInitializer(CacheFactoryInitializer cacheFactoryInitializer); @SuppressWarnings("rawtypes") CacheFactoryInitializer getCacheFactoryInitializer(); void setProperties(Properties properties); Properties getProperties(); void setClose(boolean close); boolean isClose(); PeerCacheConfigurer getCompositePeerCacheConfigurer(); void setCopyOnRead(Boolean copyOnRead); Boolean getCopyOnRead(); void setCriticalHeapPercentage(Float criticalHeapPercentage); Float getCriticalHeapPercentage(); void setCriticalOffHeapPercentage(Float criticalOffHeapPercentage); Float getCriticalOffHeapPercentage(); void setEnableAutoReconnect(Boolean enableAutoReconnect); Boolean getEnableAutoReconnect(); void setEvictionHeapPercentage(Float evictionHeapPercentage); Float getEvictionHeapPercentage(); void setEvictionOffHeapPercentage(Float evictionOffHeapPercentage); Float getEvictionOffHeapPercentage(); void setGatewayConflictResolver(GatewayConflictResolver gatewayConflictResolver); GatewayConflictResolver getGatewayConflictResolver(); void setJndiDataSources(List<JndiDataSource> jndiDataSources); List<JndiDataSource> getJndiDataSources(); void setLockLease(Integer lockLease); Integer getLockLease(); void setLockTimeout(Integer lockTimeout); Integer getLockTimeout(); void setMessageSyncInterval(Integer messageSyncInterval); Integer getMessageSyncInterval(); @Override int getPhase(); void setPdxDiskStoreName(String pdxDiskStoreName); String getPdxDiskStoreName(); void setPdxIgnoreUnreadFields(Boolean pdxIgnoreUnreadFields); Boolean getPdxIgnoreUnreadFields(); void setPdxPersistent(Boolean pdxPersistent); Boolean getPdxPersistent(); void setPdxReadSerialized(Boolean pdxReadSerialized); Boolean getPdxReadSerialized(); void setPdxSerializer(PdxSerializer serializer); PdxSerializer getPdxSerializer(); void setPeerCacheConfigurers(PeerCacheConfigurer... peerCacheConfigurers); void setPeerCacheConfigurers(List<PeerCacheConfigurer> peerCacheConfigurers); void setSearchTimeout(Integer searchTimeout); Integer getSearchTimeout(); void setSecurityManager(SecurityManager securityManager); SecurityManager getSecurityManager(); void setTransactionListeners(List<TransactionListener> transactionListeners); List<TransactionListener> getTransactionListeners(); void setTransactionWriter(TransactionWriter transactionWriter); TransactionWriter getTransactionWriter(); void setUseBeanFactoryLocator(boolean use); boolean isUseBeanFactoryLocator(); void setUseClusterConfiguration(Boolean useSharedConfiguration); Boolean getUseClusterConfiguration(); }
|
@Test public void closeCache() { GemFireCache mockCache = mock(GemFireCache.class, "testCloseCache.MockCache"); new CacheFactoryBean().close(mockCache); verify(mockCache, times(1)).close(); }
|
IndexFactoryBean extends AbstractFactoryBeanSupport<Index> implements InitializingBean { @Override public void afterPropertiesSet() throws Exception { this.indexName = resolveIndexName(); applyIndexConfigurers(this.indexName); this.cache = resolveCache(); this.queryService = resolveQueryService(); assertIndexDefinitionConfiguration(); this.index = createIndex(this.queryService, this.indexName); registerAlias(getBeanName(), this.indexName); } @Override void afterPropertiesSet(); Index getIndex(); @Override Index getObject(); @Override Class<?> getObjectType(); void setCache(RegionService cache); void setName(String name); void setQueryService(QueryService service); void setDefine(boolean define); void setExpression(String expression); void setFrom(String from); void setImports(String imports); void setIgnoreIfExists(boolean ignore); boolean isIgnoreIfExists(); @SuppressWarnings("unused") void setIndexConfigurers(IndexConfigurer... indexConfigurers); void setIndexConfigurers(List<IndexConfigurer> indexConfigurers); void setOverride(boolean override); boolean isOverride(); void setType(String type); void setType(IndexType type); static final String BASIC_INDEX_DEFINITION; static final String DETAILED_INDEX_DEFINITION; }
|
@Test(expected = IllegalArgumentException.class) public void afterPropertiesSetWithNoIndexName() throws Exception { try { newIndexFactoryBean().afterPropertiesSet(); } catch (IllegalArgumentException expected) { assertThat(expected).hasMessage("Index name is required"); assertThat(expected).hasNoCause(); throw expected; } }
|
AnnotationBasedExpiration implements BeanFactoryAware, CustomExpiry<K, V> { protected BeanFactory getBeanFactory() { BeanFactory localBeanFactory = BEAN_FACTORY_REFERENCE.get(); Assert.state(localBeanFactory != null, "beanFactory was not properly initialized"); return localBeanFactory; } AnnotationBasedExpiration(); AnnotationBasedExpiration(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forIdleTimeout(); static AnnotationBasedExpiration<K, V> forIdleTimeout(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forTimeToLive(); static AnnotationBasedExpiration<K, V> forTimeToLive(ExpirationAttributes defaultExpirationAttributes); @Override void setBeanFactory(BeanFactory beanFactory); void setDefaultExpirationAttributes(ExpirationAttributes defaultExpirationAttributes); @Override ExpirationAttributes getExpiry(Region.Entry<K, V> entry); @Override void close(); }
|
@Test(expected = IllegalStateException.class) public void getUninitializedBeanFactory() { new AnnotationBasedExpiration<Object, Object>().getBeanFactory(); }
|
IndexFactoryBean extends AbstractFactoryBeanSupport<Index> implements InitializingBean { RegionService resolveCache() { RegionService resolvedCache = this.cache != null ? this.cache : GemfireUtils.resolveGemFireCache(); return Optional.ofNullable(resolvedCache) .orElseThrow(() -> newIllegalStateException("Cache is required")); } @Override void afterPropertiesSet(); Index getIndex(); @Override Index getObject(); @Override Class<?> getObjectType(); void setCache(RegionService cache); void setName(String name); void setQueryService(QueryService service); void setDefine(boolean define); void setExpression(String expression); void setFrom(String from); void setImports(String imports); void setIgnoreIfExists(boolean ignore); boolean isIgnoreIfExists(); @SuppressWarnings("unused") void setIndexConfigurers(IndexConfigurer... indexConfigurers); void setIndexConfigurers(List<IndexConfigurer> indexConfigurers); void setOverride(boolean override); boolean isOverride(); void setType(String type); void setType(IndexType type); static final String BASIC_INDEX_DEFINITION; static final String DETAILED_INDEX_DEFINITION; }
|
@Test public void resolveCacheFromCacheProperty() { assertThat(newIndexFactoryBean().resolveCache()).isSameAs(mockCache); }
|
IndexFactoryBean extends AbstractFactoryBeanSupport<Index> implements InitializingBean { QueryService doLookupQueryService() { Supplier<QueryService> queryServiceSupplier = () -> this.cache instanceof ClientCache ? ((ClientCache) this.cache).getLocalQueryService() : this.cache.getQueryService(); return Optional.ofNullable(this.queryService) .orElseGet(queryServiceSupplier); } @Override void afterPropertiesSet(); Index getIndex(); @Override Index getObject(); @Override Class<?> getObjectType(); void setCache(RegionService cache); void setName(String name); void setQueryService(QueryService service); void setDefine(boolean define); void setExpression(String expression); void setFrom(String from); void setImports(String imports); void setIgnoreIfExists(boolean ignore); boolean isIgnoreIfExists(); @SuppressWarnings("unused") void setIndexConfigurers(IndexConfigurer... indexConfigurers); void setIndexConfigurers(List<IndexConfigurer> indexConfigurers); void setOverride(boolean override); boolean isOverride(); void setType(String type); void setType(IndexType type); static final String BASIC_INDEX_DEFINITION; static final String DETAILED_INDEX_DEFINITION; }
|
@Test public void doLookupQueryService() { QueryService mockQueryServiceOne = mockQueryService("testDoLookupQueryService.MockQueryService.One"); IndexFactoryBean indexFactoryBean = newIndexFactoryBean(); indexFactoryBean.setQueryService(mockQueryServiceOne); assertThat(indexFactoryBean.doLookupQueryService()).isSameAs(mockQueryServiceOne); verify(mockCache, never()).getQueryService(); }
|
IndexFactoryBean extends AbstractFactoryBeanSupport<Index> implements InitializingBean { QueryService lookupQueryService() { String queryServiceBeanName = GemfireConstants.DEFAULT_GEMFIRE_INDEX_DEFINITION_QUERY_SERVICE; return Optional.ofNullable(getBeanFactory()) .filter(beanFactory -> beanFactory.containsBean(queryServiceBeanName)) .map(beanFactory -> beanFactory.getBean(queryServiceBeanName, QueryService.class)) .orElseGet(() -> registerQueryServiceBean(queryServiceBeanName, doLookupQueryService())); } @Override void afterPropertiesSet(); Index getIndex(); @Override Index getObject(); @Override Class<?> getObjectType(); void setCache(RegionService cache); void setName(String name); void setQueryService(QueryService service); void setDefine(boolean define); void setExpression(String expression); void setFrom(String from); void setImports(String imports); void setIgnoreIfExists(boolean ignore); boolean isIgnoreIfExists(); @SuppressWarnings("unused") void setIndexConfigurers(IndexConfigurer... indexConfigurers); void setIndexConfigurers(List<IndexConfigurer> indexConfigurers); void setOverride(boolean override); boolean isOverride(); void setType(String type); void setType(IndexType type); static final String BASIC_INDEX_DEFINITION; static final String DETAILED_INDEX_DEFINITION; }
|
@Test public void lookupQueryServiceFromBeanFactory() { QueryService mockQueryService = mockQueryService("testLookupQueryServiceFromBeanFactory.MockQueryService"); when(mockBeanFactory.containsBean(eq(GemfireConstants.DEFAULT_GEMFIRE_INDEX_DEFINITION_QUERY_SERVICE))) .thenReturn(true); when(mockBeanFactory.getBean(eq(GemfireConstants.DEFAULT_GEMFIRE_INDEX_DEFINITION_QUERY_SERVICE), eq(QueryService.class))).thenReturn(mockQueryService); IndexFactoryBean indexFactoryBean = newIndexFactoryBean(); assertThat(indexFactoryBean.lookupQueryService()).isSameAs(mockQueryService); verify(mockBeanFactory, times(1)).containsBean( eq(GemfireConstants.DEFAULT_GEMFIRE_INDEX_DEFINITION_QUERY_SERVICE)); verify(mockBeanFactory, times(1)).getBean( eq(GemfireConstants.DEFAULT_GEMFIRE_INDEX_DEFINITION_QUERY_SERVICE), eq(QueryService.class)); verify(mockCache, never()).getQueryService(); }
|
IndexFactoryBean extends AbstractFactoryBeanSupport<Index> implements InitializingBean { QueryService resolveQueryService() { QueryService resolvedQueryService = this.queryService != null ? this.queryService : lookupQueryService(); return Optional.ofNullable(resolvedQueryService) .orElseThrow(() -> newIllegalStateException("QueryService is required to create an Index")); } @Override void afterPropertiesSet(); Index getIndex(); @Override Index getObject(); @Override Class<?> getObjectType(); void setCache(RegionService cache); void setName(String name); void setQueryService(QueryService service); void setDefine(boolean define); void setExpression(String expression); void setFrom(String from); void setImports(String imports); void setIgnoreIfExists(boolean ignore); boolean isIgnoreIfExists(); @SuppressWarnings("unused") void setIndexConfigurers(IndexConfigurer... indexConfigurers); void setIndexConfigurers(List<IndexConfigurer> indexConfigurers); void setOverride(boolean override); boolean isOverride(); void setType(String type); void setType(IndexType type); static final String BASIC_INDEX_DEFINITION; static final String DETAILED_INDEX_DEFINITION; }
|
@Test public void resolveQueryServiceReturnsIndexFactoryBeanConfiguredQueryService() { assertThat(newIndexFactoryBean().resolveQueryService()).isSameAs(mockQueryService); }
|
IndexFactoryBean extends AbstractFactoryBeanSupport<Index> implements InitializingBean { void registerAlias(String beanName, String indexName) { Optional.ofNullable(getBeanFactory()) .filter(ConfigurableBeanFactory.class::isInstance) .filter(it -> beanName != null && !beanName.equals(indexName)) .map(ConfigurableBeanFactory.class::cast) .ifPresent(it -> it.registerAlias(beanName, indexName)); } @Override void afterPropertiesSet(); Index getIndex(); @Override Index getObject(); @Override Class<?> getObjectType(); void setCache(RegionService cache); void setName(String name); void setQueryService(QueryService service); void setDefine(boolean define); void setExpression(String expression); void setFrom(String from); void setImports(String imports); void setIgnoreIfExists(boolean ignore); boolean isIgnoreIfExists(); @SuppressWarnings("unused") void setIndexConfigurers(IndexConfigurer... indexConfigurers); void setIndexConfigurers(List<IndexConfigurer> indexConfigurers); void setOverride(boolean override); boolean isOverride(); void setType(String type); void setType(IndexType type); static final String BASIC_INDEX_DEFINITION; static final String DETAILED_INDEX_DEFINITION; }
|
@Test public void registerAliasWhenBeanFactoryIsNull() { IndexFactoryBean indexFactoryBean = newIndexFactoryBean(); indexFactoryBean.setBeanFactory(null); indexFactoryBean.registerAlias("IndexBean", "TestIndex"); }
@Test public void registerAliasWhenBeanFactoryIsNotConfigurable() { IndexFactoryBean indexFactoryBean = newIndexFactoryBean(); indexFactoryBean.registerAlias("IndexBean", "TestIndex"); verifyZeroInteractions(mockBeanFactory); }
@Test public void registerAliasWhenBeanNameAndIndexNameMatch() { ConfigurableBeanFactory mockConfigurableBeanFactory = mock(ConfigurableBeanFactory.class); IndexFactoryBean indexFactoryBean = newIndexFactoryBean(); indexFactoryBean.setBeanFactory(mockConfigurableBeanFactory); indexFactoryBean.registerAlias("TestIndex", "TestIndex"); assertThat(indexFactoryBean.getBeanFactory()).isSameAs(mockConfigurableBeanFactory); verifyZeroInteractions(mockConfigurableBeanFactory); }
@Test public void registerAliasWhenBeanNameAndIndexNameAreDifferent() { ConfigurableBeanFactory mockConfigurableBeanFactory = mock(ConfigurableBeanFactory.class); IndexFactoryBean indexFactoryBean = newIndexFactoryBean(); indexFactoryBean.setBeanFactory(mockConfigurableBeanFactory); indexFactoryBean.registerAlias("IndexBean", "TestIndex"); assertThat(indexFactoryBean.getBeanFactory()).isSameAs(mockConfigurableBeanFactory); verify(mockConfigurableBeanFactory, times(1)) .registerAlias(eq("IndexBean"), eq("TestIndex")); }
|
IndexFactoryBean extends AbstractFactoryBeanSupport<Index> implements InitializingBean { Index createFunctionalIndex(QueryService queryService, String indexName, String expression, String from, String imports) throws Exception { boolean hasImports = StringUtils.hasText(imports); if (isDefine()) { if (hasImports) { queryService.defineIndex(indexName, expression, from , imports); } else { queryService.defineIndex(indexName, expression, from); } return new IndexWrapper(queryService, indexName); } else { if (hasImports) { return queryService.createIndex(indexName, expression, from, imports); } else { return queryService.createIndex(indexName, expression, from); } } } @Override void afterPropertiesSet(); Index getIndex(); @Override Index getObject(); @Override Class<?> getObjectType(); void setCache(RegionService cache); void setName(String name); void setQueryService(QueryService service); void setDefine(boolean define); void setExpression(String expression); void setFrom(String from); void setImports(String imports); void setIgnoreIfExists(boolean ignore); boolean isIgnoreIfExists(); @SuppressWarnings("unused") void setIndexConfigurers(IndexConfigurer... indexConfigurers); void setIndexConfigurers(List<IndexConfigurer> indexConfigurers); void setOverride(boolean override); boolean isOverride(); void setType(String type); void setType(IndexType type); static final String BASIC_INDEX_DEFINITION; static final String DETAILED_INDEX_DEFINITION; }
|
@Test public void createFunctionalIndex() throws Exception { Index mockIndex = mockIndex("testCreateFunctionalIndex.MockIndex"); when(mockQueryService.createIndex(eq("FunctionalIndex"), eq("purchaseDate"), eq("/Orders"))) .thenReturn(mockIndex); Index actualIndex = indexFactoryBean.createFunctionalIndex(mockQueryService, "FunctionalIndex", "purchaseDate", "/Orders", null); assertThat(actualIndex).isSameAs(mockIndex); verify(mockQueryService, times(1)) .createIndex(eq("FunctionalIndex"), eq("purchaseDate"), eq("/Orders")); verify(mockQueryService, never()).defineIndex(anyString(), anyString(), anyString()); }
|
IndexFactoryBean extends AbstractFactoryBeanSupport<Index> implements InitializingBean { Index createHashIndex(QueryService queryService, String indexName, String expression, String from, String imports) throws Exception { boolean hasImports = StringUtils.hasText(imports); if (isDefine()) { if (hasImports) { queryService.defineHashIndex(indexName, expression, from, imports); } else { queryService.defineHashIndex(indexName, expression, from); } return new IndexWrapper(queryService, indexName); } else { if (hasImports) { return queryService.createHashIndex(indexName, expression, from, imports); } else { return queryService.createHashIndex(indexName, expression, from); } } } @Override void afterPropertiesSet(); Index getIndex(); @Override Index getObject(); @Override Class<?> getObjectType(); void setCache(RegionService cache); void setName(String name); void setQueryService(QueryService service); void setDefine(boolean define); void setExpression(String expression); void setFrom(String from); void setImports(String imports); void setIgnoreIfExists(boolean ignore); boolean isIgnoreIfExists(); @SuppressWarnings("unused") void setIndexConfigurers(IndexConfigurer... indexConfigurers); void setIndexConfigurers(List<IndexConfigurer> indexConfigurers); void setOverride(boolean override); boolean isOverride(); void setType(String type); void setType(IndexType type); static final String BASIC_INDEX_DEFINITION; static final String DETAILED_INDEX_DEFINITION; }
|
@Test public void createHashIndex() throws Exception { Index mockIndex = mockIndex("testCreateHashIndex.MockIndex"); when(mockQueryService.createHashIndex(eq("HashIndex"), eq("name"), eq("/People"))) .thenReturn(mockIndex); Index actualIndex = indexFactoryBean.createHashIndex(mockQueryService, "HashIndex", "name", "/People", " "); assertThat(actualIndex).isSameAs(mockIndex); verify(mockQueryService, times(1)) .createHashIndex(eq("HashIndex"), eq("name"), eq("/People")); verify(mockQueryService, never()).defineHashIndex(anyString(), anyString(), anyString()); }
@Test public void createHashIndexWithImports() throws Exception { Index mockIndex = mockIndex("testCreateHashIndexWithImports.MockIndex"); when(mockQueryService.createHashIndex(eq("HashIndexWithImports"), eq("name"), eq("/People"), eq("example.Person"))).thenReturn(mockIndex); Index actualIndex = indexFactoryBean.createHashIndex(mockQueryService, "HashIndexWithImports", "name", "/People", "example.Person"); assertThat(actualIndex).isSameAs(mockIndex); verify(mockQueryService, times(1)).createHashIndex(eq("HashIndexWithImports"), eq("name"), eq("/People"), eq("example.Person")); verify(mockQueryService, never()).defineHashIndex(anyString(), anyString(), anyString(), anyString()); }
|
AnnotationBasedExpiration implements BeanFactoryAware, CustomExpiry<K, V> { @Override public ExpirationAttributes getExpiry(Region.Entry<K, V> entry) { return newExpirationAttributes(getExpirationMetaData(entry)); } AnnotationBasedExpiration(); AnnotationBasedExpiration(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forIdleTimeout(); static AnnotationBasedExpiration<K, V> forIdleTimeout(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forTimeToLive(); static AnnotationBasedExpiration<K, V> forTimeToLive(ExpirationAttributes defaultExpirationAttributes); @Override void setBeanFactory(BeanFactory beanFactory); void setDefaultExpirationAttributes(ExpirationAttributes defaultExpirationAttributes); @Override ExpirationAttributes getExpiry(Region.Entry<K, V> entry); @Override void close(); }
|
@Test public void getExpiryCallsGetExpirationMetaDataOnRegionEntryFollowedByNewExpirationAttributes() { final ExpirationAttributes expectedExpirationAttributes = new ExpirationAttributes(60, ExpirationAction.LOCAL_DESTROY); final Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry"); AnnotationBasedExpiration expiration = new AnnotationBasedExpiration() { @Override protected ExpirationMetaData getExpirationMetaData(Region.Entry entry) { assertThat(entry, is(sameInstance(mockRegionEntry))); return ExpirationMetaData.from(expectedExpirationAttributes); } @Override protected ExpirationAttributes newExpirationAttributes(ExpirationMetaData expirationMetaData) { assertThat(expirationMetaData.timeout(), is(equalTo(expectedExpirationAttributes.getTimeout()))); assertThat(expirationMetaData.expirationAction(), is(equalTo(expectedExpirationAttributes.getAction()))); return expectedExpirationAttributes; } }; assertThat(expiration.getExpiry(mockRegionEntry), is(equalTo(expectedExpirationAttributes))); }
|
IndexFactoryBean extends AbstractFactoryBeanSupport<Index> implements InitializingBean { Index createKeyIndex(QueryService queryService, String indexName, String expression, String from) throws Exception { if (isDefine()) { queryService.defineKeyIndex(indexName, expression, from); return new IndexWrapper(queryService, indexName); } else { return queryService.createKeyIndex(indexName, expression, from); } } @Override void afterPropertiesSet(); Index getIndex(); @Override Index getObject(); @Override Class<?> getObjectType(); void setCache(RegionService cache); void setName(String name); void setQueryService(QueryService service); void setDefine(boolean define); void setExpression(String expression); void setFrom(String from); void setImports(String imports); void setIgnoreIfExists(boolean ignore); boolean isIgnoreIfExists(); @SuppressWarnings("unused") void setIndexConfigurers(IndexConfigurer... indexConfigurers); void setIndexConfigurers(List<IndexConfigurer> indexConfigurers); void setOverride(boolean override); boolean isOverride(); void setType(String type); void setType(IndexType type); static final String BASIC_INDEX_DEFINITION; static final String DETAILED_INDEX_DEFINITION; }
|
@Test public void createKeyIndex() throws Exception { Index mockIndex = mockIndex("testCreateKeyIndex.MockKeyIndex"); when(mockQueryService.createKeyIndex(eq("KeyIndex"), eq("id"), eq("/Example"))) .thenReturn(mockIndex); Index actualIndex = indexFactoryBean.createKeyIndex(mockQueryService, "KeyIndex", "id", "/Example"); assertThat(actualIndex).isSameAs(mockIndex); verify(mockQueryService, times(1)) .createKeyIndex(eq("KeyIndex"), eq("id"), eq("/Example")); verify(mockQueryService, never()).defineKeyIndex(anyString(), anyString(), anyString()); }
|
IndexFactoryBean extends AbstractFactoryBeanSupport<Index> implements InitializingBean { Optional<Index> tryToFindExistingIndexByDefinition(QueryService queryService, String expression, String fromClause, IndexType indexType) { for (Index index : nullSafeCollection(queryService.getIndexes())) { if (index.getIndexedExpression().equalsIgnoreCase(expression) && index.getFromClause().equalsIgnoreCase(fromClause) && indexType.equals(IndexType.valueOf(index.getType()))) { return Optional.of(index); } } return Optional.empty(); } @Override void afterPropertiesSet(); Index getIndex(); @Override Index getObject(); @Override Class<?> getObjectType(); void setCache(RegionService cache); void setName(String name); void setQueryService(QueryService service); void setDefine(boolean define); void setExpression(String expression); void setFrom(String from); void setImports(String imports); void setIgnoreIfExists(boolean ignore); boolean isIgnoreIfExists(); @SuppressWarnings("unused") void setIndexConfigurers(IndexConfigurer... indexConfigurers); void setIndexConfigurers(List<IndexConfigurer> indexConfigurers); void setOverride(boolean override); boolean isOverride(); void setType(String type); void setType(IndexType type); static final String BASIC_INDEX_DEFINITION; static final String DETAILED_INDEX_DEFINITION; }
|
@Test public void tryToFindExistingIndexByDefinitionReturnsIndex() { Index mockIndexOne = mockIndexWithDefinition("PrimaryIndex", "id", "/People", IndexType.HASH); Index mockIndexTwo = mockIndexWithDefinition("SecondaryIndex", "id", "/People", IndexType.PRIMARY_KEY); Index mockIndexThree = mockIndexWithDefinition("TernaryIndex", "purchaseDate", "/Orders", IndexType.FUNCTIONAL); when(mockQueryService.getIndexes()).thenReturn(Arrays.asList(mockIndexOne, mockIndexTwo, mockIndexThree)); assertThat(indexFactoryBean.tryToFindExistingIndexByDefinition(mockQueryService, "id", "/People", IndexType.PRIMARY_KEY).orElse(null)).isSameAs(mockIndexTwo); assertThat(indexFactoryBean.tryToFindExistingIndexByDefinition(mockQueryService, "purchaseDate", "/Orders", IndexType.FUNCTIONAL).orElse(null)).isSameAs(mockIndexThree); assertThat(indexFactoryBean.tryToFindExistingIndexByDefinition(mockQueryService, "id", "/People", IndexType.HASH).orElse(null)).isSameAs(mockIndexOne); verify(mockQueryService, times(3)).getIndexes(); }
@Test public void tryToFindExistingIndexByDefinitionReturnsNull() { Index mockIndex = mockIndexWithDefinition("PrimaryIndex", "id", "/People", IndexType.HASH); when(mockQueryService.getIndexes()).thenReturn(Collections.singletonList(mockIndex)); assertThat(indexFactoryBean.tryToFindExistingIndexByDefinition(mockQueryService, "key", "/People", IndexType.HASH).orElse(null)).isNull(); assertThat(indexFactoryBean.tryToFindExistingIndexByDefinition(mockQueryService, "id", "/Persons", IndexType.HASH).orElse(null)).isNull(); assertThat(indexFactoryBean.tryToFindExistingIndexByDefinition(mockQueryService, "id", "/People", IndexType.KEY).orElse(null)).isNull(); verify(mockQueryService, times(3)).getIndexes(); }
@Test public void tryToFindExistingIndexByDefinitionWithQueryServiceHavingNoIndexesReturnsNull() { when(mockQueryService.getIndexes()).thenReturn(Collections.emptyList()); assertThat(indexFactoryBean.tryToFindExistingIndexByDefinition(mockQueryService, "id", "/People", IndexType.KEY).orElse(null)).isNull(); verify(mockQueryService, times(1)).getIndexes(); }
@Test public void tryToFindExistingIndexByDefinitionWithQueryServiceReturningNullIndexesReturnsNull() { when(mockQueryService.getIndexes()).thenReturn(null); assertThat(indexFactoryBean.tryToFindExistingIndexByDefinition(mockQueryService, "id", "/People", IndexType.KEY).orElse(null)).isNull(); verify(mockQueryService, times(1)).getIndexes(); }
|
IndexFactoryBean extends AbstractFactoryBeanSupport<Index> implements InitializingBean { Optional<Index> tryToFindExistingIndexByName(QueryService queryService, String indexName) { for (Index index : nullSafeCollection(queryService.getIndexes())) { if (index.getName().equalsIgnoreCase(indexName)) { return Optional.of(index); } } return Optional.empty(); } @Override void afterPropertiesSet(); Index getIndex(); @Override Index getObject(); @Override Class<?> getObjectType(); void setCache(RegionService cache); void setName(String name); void setQueryService(QueryService service); void setDefine(boolean define); void setExpression(String expression); void setFrom(String from); void setImports(String imports); void setIgnoreIfExists(boolean ignore); boolean isIgnoreIfExists(); @SuppressWarnings("unused") void setIndexConfigurers(IndexConfigurer... indexConfigurers); void setIndexConfigurers(List<IndexConfigurer> indexConfigurers); void setOverride(boolean override); boolean isOverride(); void setType(String type); void setType(IndexType type); static final String BASIC_INDEX_DEFINITION; static final String DETAILED_INDEX_DEFINITION; }
|
@Test public void tryToFindExistingIndexByNameReturnsIndex() { Index mockIndexOne = mockIndex("PrimaryIndex"); Index mockIndexTwo = mockIndex("SecondaryIndex"); Index mockIndexThree = mockIndex("TernaryIndex"); when(mockQueryService.getIndexes()).thenReturn(Arrays.asList(mockIndexOne, mockIndexTwo, mockIndexThree)); assertThat(indexFactoryBean.tryToFindExistingIndexByName(mockQueryService, "PRIMARYINDEX") .orElse(null)).isSameAs(mockIndexOne); assertThat(indexFactoryBean.tryToFindExistingIndexByName(mockQueryService, "SecondaryIndex") .orElse(null)).isSameAs(mockIndexTwo); assertThat(indexFactoryBean.tryToFindExistingIndexByName(mockQueryService, "ternaryindex") .orElse(null)).isSameAs(mockIndexThree); verify(mockQueryService, times(3)).getIndexes(); }
@Test public void tryToFindExistingIndexByNameReturnsNull() { Index mockIndexOne = mockIndex("PrimaryIndex"); Index mockIndexTwo = mockIndex("SecondaryIndex"); Index mockIndexThree = mockIndex("TernaryIndex"); when(mockQueryService.getIndexes()).thenReturn(Arrays.asList(mockIndexOne, mockIndexTwo, mockIndexThree)); assertThat(indexFactoryBean.tryToFindExistingIndexByName(mockQueryService, null) .orElse(null)).isNull(); assertThat(indexFactoryBean.tryToFindExistingIndexByName(mockQueryService, "") .orElse(null)).isNull(); assertThat(indexFactoryBean.tryToFindExistingIndexByName(mockQueryService, " ") .orElse(null)).isNull(); assertThat(indexFactoryBean.tryToFindExistingIndexByName(mockQueryService, "Primary Index") .orElse(null)).isNull(); assertThat(indexFactoryBean.tryToFindExistingIndexByName(mockQueryService, "Secondary_Index") .orElse(null)).isNull(); assertThat(indexFactoryBean.tryToFindExistingIndexByName(mockQueryService, "QuadIndex") .orElse(null)).isNull(); verify(mockQueryService, times(6)).getIndexes(); }
@Test public void tryToFindExistingIndexByNameWithQueryServiceHavingNoIndexesReturnsNull() { when(mockQueryService.getIndexes()).thenReturn(Collections.emptyList()); assertThat(indexFactoryBean.tryToFindExistingIndexByName(mockQueryService, "TestIndex") .orElse(null)).isNull(); assertThat(indexFactoryBean.tryToFindExistingIndexByName(mockQueryService, "KeyIndex") .orElse(null)).isNull(); assertThat(indexFactoryBean.tryToFindExistingIndexByName(mockQueryService, "IdIndex") .orElse(null)).isNull(); verify(mockQueryService, times(3)).getIndexes(); }
@Test public void tryToFindExistingIndexByNameWithQueryServiceReturningNullIndexesReturnsNull() { when(mockQueryService.getIndexes()).thenReturn(null); assertThat(indexFactoryBean.tryToFindExistingIndexByName(mockQueryService, "TestIndex") .orElse(null)).isNull(); assertThat(indexFactoryBean.tryToFindExistingIndexByName(mockQueryService, "KeyIndex") .orElse(null)).isNull(); assertThat(indexFactoryBean.tryToFindExistingIndexByName(mockQueryService, "IdIndex") .orElse(null)).isNull(); verify(mockQueryService, times(3)).getIndexes(); }
|
AnnotationBasedExpiration implements BeanFactoryAware, CustomExpiry<K, V> { protected boolean isExpirationConfigured(Region.Entry<K, V> entry) { return entry != null && isExpirationConfigured(entry.getValue()); } AnnotationBasedExpiration(); AnnotationBasedExpiration(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forIdleTimeout(); static AnnotationBasedExpiration<K, V> forIdleTimeout(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forTimeToLive(); static AnnotationBasedExpiration<K, V> forTimeToLive(ExpirationAttributes defaultExpirationAttributes); @Override void setBeanFactory(BeanFactory beanFactory); void setDefaultExpirationAttributes(ExpirationAttributes defaultExpirationAttributes); @Override ExpirationAttributes getExpiry(Region.Entry<K, V> entry); @Override void close(); }
|
@Test public void isExpirationConfiguredWithGenericExpirationBasedRegionEntry() { Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry"); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithGenericExpiration()); assertThat(noDefaultExpiration.isExpirationConfigured(mockRegionEntry), is(true)); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutGenericExpiration()); assertThat(noDefaultExpiration.isExpirationConfigured(mockRegionEntry), is(true)); verify(mockRegionEntry, times(2)).getValue(); }
@Test public void isExpirationConfiguredWithNoGenericExpirationRegionEntry() { Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry"); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutExpiration()); assertThat(noDefaultExpiration.isExpirationConfigured(mockRegionEntry), is(false)); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithNoExpiration()); assertThat(noDefaultExpiration.isExpirationConfigured(mockRegionEntry), is(false)); verify(mockRegionEntry, times(2)).getValue(); }
|
IndexFactoryBean extends AbstractFactoryBeanSupport<Index> implements InitializingBean { @Override public Class<?> getObjectType() { Index index = getIndex(); return index != null ? index.getClass() : Index.class; } @Override void afterPropertiesSet(); Index getIndex(); @Override Index getObject(); @Override Class<?> getObjectType(); void setCache(RegionService cache); void setName(String name); void setQueryService(QueryService service); void setDefine(boolean define); void setExpression(String expression); void setFrom(String from); void setImports(String imports); void setIgnoreIfExists(boolean ignore); boolean isIgnoreIfExists(); @SuppressWarnings("unused") void setIndexConfigurers(IndexConfigurer... indexConfigurers); void setIndexConfigurers(List<IndexConfigurer> indexConfigurers); void setOverride(boolean override); boolean isOverride(); void setType(String type); void setType(IndexType type); static final String BASIC_INDEX_DEFINITION; static final String DETAILED_INDEX_DEFINITION; }
|
@Test public void getObjectTypeReturnsIndexClassType() { assertThat(newIndexFactoryBean().getObjectType()).isEqualTo(Index.class); }
|
SubscriptionAttributesFactoryBean implements FactoryBean<SubscriptionAttributes>, InitializingBean { @Override public boolean isSingleton() { return true; } @Override void afterPropertiesSet(); @Override SubscriptionAttributes getObject(); @Override Class<?> getObjectType(); @Override boolean isSingleton(); void setInterestPolicy(InterestPolicy interestPolicy); InterestPolicy getInterestPolicy(); }
|
@Test public void testIsSingleton() { assertTrue(new SubscriptionAttributesFactoryBean().isSingleton()); }
|
EvictionAttributesFactoryBean implements FactoryBean<EvictionAttributes>, InitializingBean { public boolean isSingleton() { return true; } void afterPropertiesSet(); EvictionAttributes getObject(); Class<?> getObjectType(); boolean isSingleton(); void setAction(final EvictionAction action); EvictionAction getAction(); void setObjectSizer(final ObjectSizer objectSizer); ObjectSizer getObjectSizer(); void setThreshold(final Integer threshold); Integer getThreshold(); void setType(final EvictionPolicyType type); EvictionPolicyType getType(); }
|
@Test public void testIsSingleton() { assertTrue(new EvictionAttributesFactoryBean().isSingleton()); }
|
LookupRegionFactoryBean extends ResolvableRegionFactoryBean<K, V> { @Override public void afterPropertiesSet() throws Exception { super.afterPropertiesSet(); Optional.ofNullable(getRegion().getAttributesMutator()).ifPresent(attributesMutator -> { getConfiguredAsyncEventQueueIds().forEach(attributesMutator::addAsyncEventQueueId); Arrays.stream(nullSafeArray(this.cacheListeners, CacheListener.class)) .forEach(attributesMutator::addCacheListener); Optional.ofNullable(this.cacheLoader).ifPresent(attributesMutator::setCacheLoader); Optional.ofNullable(this.cacheWriter).ifPresent(attributesMutator::setCacheWriter); Optional.ofNullable(this.cloningEnabled).ifPresent(attributesMutator::setCloningEnabled); Optional.ofNullable(attributesMutator.getEvictionAttributesMutator()) .ifPresent(evictionAttributesMutator -> Optional.ofNullable(this.evictionMaximum) .ifPresent(evictionAttributesMutator::setMaximum)); if (isStatisticsEnabled()) { assertStatisticsEnabled(); Optional.ofNullable(this.customEntryIdleTimeout).ifPresent(attributesMutator::setCustomEntryIdleTimeout); Optional.ofNullable(this.customEntryTimeToLive).ifPresent(attributesMutator::setCustomEntryTimeToLive); Optional.ofNullable(this.entryIdleTimeout).ifPresent(attributesMutator::setEntryIdleTimeout); Optional.ofNullable(this.entryTimeToLive).ifPresent(attributesMutator::setEntryTimeToLive); Optional.ofNullable(this.regionIdleTimeout).ifPresent(attributesMutator::setRegionIdleTimeout); Optional.ofNullable(this.regionTimeToLive).ifPresent(attributesMutator::setRegionTimeToLive); } getConfiguredGatewaySenderIds().forEach(attributesMutator::addGatewaySenderId); }); } @Override void afterPropertiesSet(); @Override final boolean isLookupEnabled(); void setAsyncEventQueues(AsyncEventQueue[] asyncEventQueues); void setAsyncEventQueueIds(String[] asyncEventQueueIds); void setCacheListeners(CacheListener<K, V>[] cacheListeners); void setCacheLoader(CacheLoader<K, V> cacheLoader); void setCacheWriter(CacheWriter<K, V> cacheWriter); void setCloningEnabled(Boolean cloningEnabled); void setCustomEntryIdleTimeout(CustomExpiry<K, V> customEntryIdleTimeout); void setCustomEntryTimeToLive(CustomExpiry<K, V> customEntryTimeToLive); void setEntryIdleTimeout(ExpirationAttributes entryIdleTimeout); void setEntryTimeToLive(ExpirationAttributes entryTimeToLive); void setEvictionMaximum(final Integer evictionMaximum); void setGatewaySenders(GatewaySender[] gatewaySenders); void setGatewaySenderIds(String[] gatewaySenderIds); void setRegionIdleTimeout(ExpirationAttributes regionIdleTimeout); void setRegionTimeToLive(ExpirationAttributes regionTimeToLive); void setStatisticsEnabled(Boolean enableStatistics); }
|
@Test @SuppressWarnings("unchecked") public void testAfterPropertiesSet() throws Exception { Cache mockCache = mock(Cache.class, "testAfterPropertiesSet.MockCache"); Region<Object, Object> mockRegion = mock(Region.class, "testAfterPropertiesSet.MockRegion"); RegionAttributes<Object, Object> mockRegionAttributes = mock(RegionAttributes.class, "testAfterPropertiesSet.MockRegionAttributes"); EvictionAttributesMutator mockEvictionAttributesMutator = mock(EvictionAttributesMutator.class, "testAfterPropertiesSet.EvictionAttributesMutator"); AttributesMutator<Object, Object> mockAttributesMutator = mock(AttributesMutator.class, "testAfterPropertiesSet.MockAttributesMutator"); when(mockCache.getRegion(eq("Example"))).thenReturn(mockRegion); when(mockRegion.getFullPath()).thenReturn("/Example"); when(mockRegion.getName()).thenReturn("Example"); when(mockRegion.getAttributes()).thenReturn(mockRegionAttributes); when(mockRegionAttributes.getStatisticsEnabled()).thenReturn(true); when(mockRegion.getAttributesMutator()).thenReturn(mockAttributesMutator); when(mockAttributesMutator.getEvictionAttributesMutator()).thenReturn(mockEvictionAttributesMutator); AsyncEventQueue mockAsyncEventQueueOne = mockAsyncEventQueue("AEQ1"); AsyncEventQueue mockAsyncEventQueueTwo = mockAsyncEventQueue("AEQ2"); CacheListener mockCacheListenerZero = mock(CacheListener.class, "testAfterPropertiesSet.MockCacheListener.0"); CacheListener mockCacheListenerOne = mock(CacheListener.class, "testAfterPropertiesSet.MockCacheListener.1"); CacheListener mockCacheListenerTwo = mock(CacheListener.class, "testAfterPropertiesSet.MockCacheListener.2"); CacheLoader mockCacheLoader = mock(CacheLoader.class, "testAfterPropertiesSet.MockCacheLoader"); CacheWriter mockCacheWriter = mock(CacheWriter.class, "testAfterPropertiesSet.MockCacheWriter"); CustomExpiry mockCustomExpiryTti = mock(CustomExpiry.class, "testAfterPropertiesSet.MockCustomExpiry.TTI"); CustomExpiry mockCustomExpiryTtl = mock(CustomExpiry.class, "testAfterPropertiesSet.MockCustomExpiry.TTL"); ExpirationAttributes mockExpirationAttributesEntryTti = mock(ExpirationAttributes.class, "testAfterPropertiesSet.MockExpirationAttributes.Entry.TTI"); ExpirationAttributes mockExpirationAttributesEntryTtl = mock(ExpirationAttributes.class, "testAfterPropertiesSet.MockExpirationAttributes.Entry.TTL"); ExpirationAttributes mockExpirationAttributesRegionTti = mock(ExpirationAttributes.class, "testAfterPropertiesSet.MockExpirationAttributes.Region.TTI"); ExpirationAttributes mockExpirationAttributesRegionTtl = mock(ExpirationAttributes.class, "testAfterPropertiesSet.MockExpirationAttributes.Region.TTL"); GatewaySender mockGatewaySender = mockGatewaySender("GWS1"); LookupRegionFactoryBean factoryBean = new LookupRegionFactoryBean(); factoryBean.setAsyncEventQueues(new AsyncEventQueue[] { mockAsyncEventQueueOne, mockAsyncEventQueueTwo }); factoryBean.setBeanName("Example"); factoryBean.setCache(mockCache); factoryBean.setCacheLoader(mockCacheLoader); factoryBean.setCacheWriter(mockCacheWriter); factoryBean.setCloningEnabled(true); factoryBean.setCustomEntryIdleTimeout(mockCustomExpiryTti); factoryBean.setCustomEntryTimeToLive(mockCustomExpiryTtl); factoryBean.setEntryIdleTimeout(mockExpirationAttributesEntryTti); factoryBean.setEntryTimeToLive(mockExpirationAttributesEntryTtl); factoryBean.setGatewaySenders(new GatewaySender[] { mockGatewaySender }); factoryBean.setEvictionMaximum(1000); factoryBean.setRegionIdleTimeout(mockExpirationAttributesRegionTti); factoryBean.setRegionTimeToLive(mockExpirationAttributesRegionTtl); factoryBean.setStatisticsEnabled(true); factoryBean.setCacheListeners(new CacheListener[] { mockCacheListenerZero, mockCacheListenerOne, mockCacheListenerTwo }); factoryBean.afterPropertiesSet(); verify(mockAttributesMutator, times(1)).addAsyncEventQueueId(eq("AEQ1")); verify(mockAttributesMutator, times(1)).addAsyncEventQueueId(eq("AEQ2")); verify(mockAttributesMutator, times(1)).addCacheListener(same(mockCacheListenerZero)); verify(mockAttributesMutator, times(1)).addCacheListener(same(mockCacheListenerOne)); verify(mockAttributesMutator, times(1)).addCacheListener(same(mockCacheListenerTwo)); verify(mockAttributesMutator, times(1)).setCacheLoader(same(mockCacheLoader)); verify(mockAttributesMutator, times(1)).setCacheWriter(same(mockCacheWriter)); verify(mockAttributesMutator, times(1)).setCloningEnabled(eq(true)); verify(mockAttributesMutator, times(1)).setCustomEntryIdleTimeout(same(mockCustomExpiryTti)); verify(mockAttributesMutator, times(1)).setCustomEntryTimeToLive(same(mockCustomExpiryTtl)); verify(mockAttributesMutator, times(1)).setEntryIdleTimeout(same(mockExpirationAttributesEntryTti)); verify(mockAttributesMutator, times(1)).setEntryTimeToLive(same(mockExpirationAttributesEntryTtl)); verify(mockAttributesMutator, times(1)).addGatewaySenderId(eq("GWS1")); verify(mockEvictionAttributesMutator, times(1)).setMaximum(eq(1000)); verify(mockAttributesMutator, times(1)).setRegionIdleTimeout(same(mockExpirationAttributesRegionTti)); verify(mockAttributesMutator, times(1)).setRegionTimeToLive(same(mockExpirationAttributesRegionTtl)); }
|
LookupRegionFactoryBean extends ResolvableRegionFactoryBean<K, V> { @Override public final boolean isLookupEnabled() { return true; } @Override void afterPropertiesSet(); @Override final boolean isLookupEnabled(); void setAsyncEventQueues(AsyncEventQueue[] asyncEventQueues); void setAsyncEventQueueIds(String[] asyncEventQueueIds); void setCacheListeners(CacheListener<K, V>[] cacheListeners); void setCacheLoader(CacheLoader<K, V> cacheLoader); void setCacheWriter(CacheWriter<K, V> cacheWriter); void setCloningEnabled(Boolean cloningEnabled); void setCustomEntryIdleTimeout(CustomExpiry<K, V> customEntryIdleTimeout); void setCustomEntryTimeToLive(CustomExpiry<K, V> customEntryTimeToLive); void setEntryIdleTimeout(ExpirationAttributes entryIdleTimeout); void setEntryTimeToLive(ExpirationAttributes entryTimeToLive); void setEvictionMaximum(final Integer evictionMaximum); void setGatewaySenders(GatewaySender[] gatewaySenders); void setGatewaySenderIds(String[] gatewaySenderIds); void setRegionIdleTimeout(ExpirationAttributes regionIdleTimeout); void setRegionTimeToLive(ExpirationAttributes regionTimeToLive); void setStatisticsEnabled(Boolean enableStatistics); }
|
@Test public void testIsLookupEnabledAlways() { LookupRegionFactoryBean factoryBean = new LookupRegionFactoryBean(); assertTrue(factoryBean.isLookupEnabled()); factoryBean.setLookupEnabled(false); assertTrue(factoryBean.isLookupEnabled()); }
|
WiringInstantiator extends Instantiator implements BeanFactoryAware, InitializingBean, DisposableBean { @Override public DataSerializable newInstance() { DataSerializable instance = createInstance(); configurer.configureBean(instance); return instance; } WiringInstantiator(Instantiator instantiator); WiringInstantiator(Class<? extends DataSerializable> c, int classId); void afterPropertiesSet(); void destroy(); void setBeanFactory(BeanFactory beanFactory); @Override DataSerializable newInstance(); void setConfigurer(BeanConfigurerSupport configurer); void setAutoRegister(boolean autoRegister); void setDistribute(boolean distribute); }
|
@Test public void testAutowiredBean() { Object instance = instantiator.newInstance(); assertNotNull(instance); assertTrue(instance instanceof AnnotatedBean); AnnotatedBean bean = (AnnotatedBean) instance; assertNotNull(bean.point); assertNotNull(bean.shape); assertSame(bean.point, applicationContext.getBean("point")); assertSame(bean.shape, applicationContext.getBean("area")); }
|
DefaultGemfireEntityInformation extends PersistentEntityInformation<T, ID> implements GemfireEntityInformation<T, ID> { @Override public String getRegionName() { return entity.getRegionName(); } DefaultGemfireEntityInformation(GemfirePersistentEntity<T> entity); @Override String getRegionName(); }
|
@Test public void interfaceBasedEntity() { GemfireEntityInformation<Algorithm, String> entityInfo = newEntityInformation(newPersistentEntity(Algorithm.class)); assertNotNull(entityInfo); assertEquals("Algorithms", entityInfo.getRegionName()); assertTrue(Algorithm.class.isAssignableFrom(entityInfo.getJavaType())); assertEquals(String.class, entityInfo.getIdType()); assertThat(entityInfo.getId(new QuickSort())).isEqualTo("QuickSort"); assertThat(entityInfo.getId(newAlgorithm("Quick Sort"))).isEqualTo("Quick Sort"); }
@Test public void classBasedEntity() { GemfireEntityInformation<Animal, Long> entityInfo = newEntityInformation(newPersistentEntity(Animal.class)); assertNotNull(entityInfo); assertEquals("Animal", entityInfo.getRegionName()); assertEquals(Animal.class, entityInfo.getJavaType()); assertEquals(Long.class, entityInfo.getIdType()); assertThat(entityInfo.getId(newAnimal(1L, "Tyger"))).isEqualTo(1L); }
@Test public void confusedDomainEntityTypedWithLongId() { GemfireEntityInformation<ConfusedDomainEntity, Long> entityInfo = newEntityInformation(newPersistentEntity(ConfusedDomainEntity.class)); assertNotNull(entityInfo); assertEquals("ConfusedDomainEntity", entityInfo.getRegionName()); assertEquals(ConfusedDomainEntity.class, entityInfo.getJavaType()); assertEquals(Long.class, entityInfo.getIdType()); assertThat(entityInfo.getId(new ConfusedDomainEntity(123L))).isEqualTo(123L); }
@Test @SuppressWarnings("all") public void confusedDomainEntityTypedStringId() { GemfireEntityInformation<ConfusedDomainEntity, ?> entityInfo = newEntityInformation(newPersistentEntity(ConfusedDomainEntity.class)); assertNotNull(entityInfo); assertEquals("ConfusedDomainEntity", entityInfo.getRegionName()); assertEquals(ConfusedDomainEntity.class, entityInfo.getJavaType()); assertTrue(Long.class.equals(entityInfo.getIdType())); assertThat(entityInfo.getId(new ConfusedDomainEntity(123L))).isEqualTo(123L); assertThat(entityInfo.getId(new ConfusedDomainEntity("248"))).isEqualTo(248L); }
|
StringBasedGemfireRepositoryQuery extends GemfireRepositoryQuery { Collection<?> toCollection(Object source) { if (source instanceof SelectResults) { return ((SelectResults<?>) source).asList(); } if (source instanceof Collection) { return (Collection<?>) source; } if (source == null) { return Collections.emptyList(); } return source.getClass().isArray() ? CollectionUtils.arrayToList(source) : Collections.singletonList(source); } StringBasedGemfireRepositoryQuery(); StringBasedGemfireRepositoryQuery(GemfireQueryMethod queryMethod, GemfireTemplate template); StringBasedGemfireRepositoryQuery(String query, GemfireQueryMethod queryMethod, GemfireTemplate template); StringBasedGemfireRepositoryQuery asUserDefinedQuery(); boolean isUserDefinedQuery(); @Override Object execute(Object[] arguments); }
|
@Test @SuppressWarnings("unchecked") public void testToCollectionWithSelectResults() { SelectResults<String> mockSelectResults = mock(SelectResults.class); List<String> expectedList = Arrays.asList("one", "two", "three"); when(mockSelectResults.asList()).thenReturn(expectedList); Collection<?> actualList = this.repositoryQuery.toCollection(mockSelectResults); assertSame(expectedList, actualList); }
@Test public void testToCollectionWithCollection() { List<String> expectedList = Arrays.asList("x", "y", "z"); Collection<?> actualList = this.repositoryQuery.toCollection(expectedList); assertSame(expectedList, actualList); }
@Test public void testToCollectionWithArray() { Object[] array = { 1, 2, 3 }; Collection<?> list = repositoryQuery.toCollection(array); assertNotNull(list); assertNotSame(array, list); assertTrue(list instanceof List); assertEquals(array.length, list.size()); assertTrue(list.containsAll(Arrays.asList(array))); }
@Test public void testToCollectionWithSingleObject() { Collection<?> list = repositoryQuery.toCollection("test"); assertTrue(list instanceof List); assertFalse(list.isEmpty()); assertEquals(1, list.size()); assertEquals("test", ((List<?>) list).get(0)); }
@Test public void testToCollectionWithNull() { Collection<?> list = repositoryQuery.toCollection(null); assertNotNull(list); assertTrue(list.isEmpty()); }
|
StringBasedGemfireRepositoryQuery extends GemfireRepositoryQuery { Object postProcess(QueryMethod queryMethod, SelectResults<?> selectResults) { Collection<?> collection = toCollection(selectResults); if (queryMethod.isCollectionQuery()) { return collection; } else if (queryMethod.isQueryForEntity()) { if (collection.isEmpty()) { return null; } else if (collection.size() == 1) { return collection.iterator().next(); } else { throw new IncorrectResultSizeDataAccessException(1, collection.size()); } } else if (isSingleNonEntityResult(queryMethod, collection)) { return collection.iterator().next(); } else { throw newIllegalStateException("Unsupported query: %s", query.toString()); } } StringBasedGemfireRepositoryQuery(); StringBasedGemfireRepositoryQuery(GemfireQueryMethod queryMethod, GemfireTemplate template); StringBasedGemfireRepositoryQuery(String query, GemfireQueryMethod queryMethod, GemfireTemplate template); StringBasedGemfireRepositoryQuery asUserDefinedQuery(); boolean isUserDefinedQuery(); @Override Object execute(Object[] arguments); }
|
@Test public void applyAllQueryAnnotationExtensions() { GemfireQueryMethod mockQueryMethod = mock(GemfireQueryMethod.class, "MockGemfireQueryMethod"); when(mockQueryMethod.hasHint()).thenReturn(true); when(mockQueryMethod.getHints()).thenReturn(Arrays.asList("IdIdx", "NameIdx").toArray(new String[2])); when(mockQueryMethod.hasImport()).thenReturn(true); when(mockQueryMethod.getImport()).thenReturn("org.example.domain.Type"); when(mockQueryMethod.hasLimit()).thenReturn(true); when(mockQueryMethod.getLimit()).thenReturn(10); when(mockQueryMethod.hasTrace()).thenReturn(true); QueryString queryString = QueryString.of("SELECT * FROM /Example"); assertThat(queryString.toString(), is(equalTo("SELECT * FROM /Example"))); StringBasedGemfireRepositoryQuery repositoryQuery = new StringBasedGemfireRepositoryQuery(); String postProcessedQueryString = repositoryQuery.getQueryPostProcessor() .postProcess(mockQueryMethod, queryString.toString()); assertThat(postProcessedQueryString, is(notNullValue())); assertThat(postProcessedQueryString, is(equalTo("<TRACE> <HINT 'IdIdx', 'NameIdx'> IMPORT org.example.domain.Type; SELECT * FROM /Example LIMIT 10"))); verify(mockQueryMethod, times(1)).hasHint(); verify(mockQueryMethod, times(1)).getHints(); verify(mockQueryMethod, times(1)).hasImport(); verify(mockQueryMethod, times(1)).getImport(); verify(mockQueryMethod, times(1)).hasLimit(); verify(mockQueryMethod, times(1)).getLimit(); verify(mockQueryMethod, times(1)).hasTrace(); }
@Test public void applyHintLimitAndTraceQueryAnnotationExtensionsWithExistingHintAndLimit() { GemfireQueryMethod mockQueryMethod = mock(GemfireQueryMethod.class, "MockGemfireQueryMethod"); when(mockQueryMethod.hasHint()).thenReturn(true); when(mockQueryMethod.getHints()).thenReturn(Collections.singletonList("FirstNameIdx").toArray(new String[1])); when(mockQueryMethod.hasImport()).thenReturn(false); when(mockQueryMethod.hasLimit()).thenReturn(true); when(mockQueryMethod.getLimit()).thenReturn(50); when(mockQueryMethod.hasTrace()).thenReturn(true); QueryString queryString = new QueryString("<HINT 'LastNameIdx'> SELECT * FROM /Example LIMIT 25"); assertThat(queryString.toString(), is(equalTo("<HINT 'LastNameIdx'> SELECT * FROM /Example LIMIT 25"))); StringBasedGemfireRepositoryQuery repositoryQuery = new StringBasedGemfireRepositoryQuery(); String postProcessedQueryString = repositoryQuery.getQueryPostProcessor().postProcess(mockQueryMethod, queryString.toString()); assertThat(postProcessedQueryString, is(notNullValue())); assertThat(postProcessedQueryString, is(equalTo("<TRACE> <HINT 'LastNameIdx'> SELECT * FROM /Example LIMIT 25"))); verify(mockQueryMethod, times(1)).hasHint(); verify(mockQueryMethod, never()).getHints(); verify(mockQueryMethod, times(1)).hasImport(); verify(mockQueryMethod, never()).getImport(); verify(mockQueryMethod, times(1)).hasLimit(); verify(mockQueryMethod, never()).getLimit(); verify(mockQueryMethod, times(1)).hasTrace(); }
@Test public void applyImportAndTraceQueryAnnotationExtensionsWithExistingTrace() { GemfireQueryMethod mockQueryMethod = mock(GemfireQueryMethod.class, "MockGemfireQueryMethod"); when(mockQueryMethod.hasHint()).thenReturn(false); when(mockQueryMethod.hasImport()).thenReturn(true); when(mockQueryMethod.getImport()).thenReturn("org.example.domain.Type"); when(mockQueryMethod.hasLimit()).thenReturn(false); when(mockQueryMethod.hasTrace()).thenReturn(true); QueryString queryString = new QueryString("<TRACE> SELECT * FROM /Example"); assertThat(queryString.toString(), is(equalTo("<TRACE> SELECT * FROM /Example"))); StringBasedGemfireRepositoryQuery repositoryQuery = new StringBasedGemfireRepositoryQuery(); String postProcessedQueryString = repositoryQuery.getQueryPostProcessor().postProcess(mockQueryMethod, queryString.toString()); assertThat(postProcessedQueryString, is(notNullValue())); assertThat(postProcessedQueryString, is(equalTo("IMPORT org.example.domain.Type; <TRACE> SELECT * FROM /Example"))); verify(mockQueryMethod, times(1)).hasHint(); verify(mockQueryMethod, never()).getHints(); verify(mockQueryMethod, times(1)).hasImport(); verify(mockQueryMethod, times(1)).getImport(); verify(mockQueryMethod, times(1)).hasLimit(); verify(mockQueryMethod, never()).getLimit(); verify(mockQueryMethod, times(1)).hasTrace(); }
|
GemfireRepositoryConfigurationExtension extends RepositoryConfigurationExtensionSupport { @Override protected Collection<Class<? extends Annotation>> getIdentifyingAnnotations() { return Region.REGION_ANNOTATION_TYPES; } @Override String getRepositoryFactoryBeanClassName(); @Override void postProcess(BeanDefinitionBuilder builder, RepositoryConfigurationSource source); @Override void postProcess(BeanDefinitionBuilder builder, AnnotationRepositoryConfigurationSource configurationSource); @Override void postProcess(BeanDefinitionBuilder builder, XmlRepositoryConfigurationSource configurationSource); @Override void registerBeansForRoot(BeanDefinitionRegistry registry, RepositoryConfigurationSource configurationSource); }
|
@Test public void identifyingAnnotationsIncludesRegionAnnotation() { Collection<Class<? extends Annotation>> identifyingAnnotations = repositoryConfigurationExtension.getIdentifyingAnnotations(); assertThat(identifyingAnnotations, is(notNullValue(Collection.class))); assertThat(identifyingAnnotations.contains(Region.class), is(true)); }
|
GemfireRepositoryConfigurationExtension extends RepositoryConfigurationExtensionSupport { @Override protected Collection<Class<?>> getIdentifyingTypes() { return Collections.singleton(GemfireRepository.class); } @Override String getRepositoryFactoryBeanClassName(); @Override void postProcess(BeanDefinitionBuilder builder, RepositoryConfigurationSource source); @Override void postProcess(BeanDefinitionBuilder builder, AnnotationRepositoryConfigurationSource configurationSource); @Override void postProcess(BeanDefinitionBuilder builder, XmlRepositoryConfigurationSource configurationSource); @Override void registerBeansForRoot(BeanDefinitionRegistry registry, RepositoryConfigurationSource configurationSource); }
|
@Test public void identifyingTypesContainsGemfireRepositoryAnnotation() { Collection<Class<?>> identifyingTypes = repositoryConfigurationExtension.getIdentifyingTypes(); assertThat(identifyingTypes, is(notNullValue(Collection.class))); assertThat(identifyingTypes.contains(GemfireRepository.class), is(true)); }
|
AnnotationBasedExpiration implements BeanFactoryAware, CustomExpiry<K, V> { protected boolean isIdleTimeoutConfigured(Region.Entry<K, V> entry) { return entry != null && isIdleTimeoutConfigured(entry.getValue()); } AnnotationBasedExpiration(); AnnotationBasedExpiration(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forIdleTimeout(); static AnnotationBasedExpiration<K, V> forIdleTimeout(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forTimeToLive(); static AnnotationBasedExpiration<K, V> forTimeToLive(ExpirationAttributes defaultExpirationAttributes); @Override void setBeanFactory(BeanFactory beanFactory); void setDefaultExpirationAttributes(ExpirationAttributes defaultExpirationAttributes); @Override ExpirationAttributes getExpiry(Region.Entry<K, V> entry); @Override void close(); }
|
@Test public void isIdleTimeoutConfiguredWithIdleTimeoutExpirationBasedRegionEntry() { Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry"); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithIdleTimeoutExpiration()); assertThat(noDefaultExpiration.isIdleTimeoutConfigured(mockRegionEntry), is(true)); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutGenericExpiration()); assertThat(noDefaultExpiration.isIdleTimeoutConfigured(mockRegionEntry), is(true)); verify(mockRegionEntry, times(2)).getValue(); }
@Test public void isIdleTimeoutConfiguredWithNoIdleTimeoutExpirationRegionEntry() { Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry"); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveGenericExpiration()); assertThat(noDefaultExpiration.isIdleTimeoutConfigured(mockRegionEntry), is(false)); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithNoExpiration()); assertThat(noDefaultExpiration.isIdleTimeoutConfigured(mockRegionEntry), is(false)); verify(mockRegionEntry, times(2)).getValue(); }
|
GemfireRepositoryConfigurationExtension extends RepositoryConfigurationExtensionSupport { @Override protected String getModulePrefix() { return GEMFIRE_MODULE_PREFIX; } @Override String getRepositoryFactoryBeanClassName(); @Override void postProcess(BeanDefinitionBuilder builder, RepositoryConfigurationSource source); @Override void postProcess(BeanDefinitionBuilder builder, AnnotationRepositoryConfigurationSource configurationSource); @Override void postProcess(BeanDefinitionBuilder builder, XmlRepositoryConfigurationSource configurationSource); @Override void registerBeansForRoot(BeanDefinitionRegistry registry, RepositoryConfigurationSource configurationSource); }
|
@Test public void modulePrefixIsGemFire() { assertThat(repositoryConfigurationExtension.getModulePrefix(), is(equalTo("gemfire"))); }
|
GemfireRepositoryConfigurationExtension extends RepositoryConfigurationExtensionSupport { @Override public String getRepositoryFactoryBeanClassName() { return GemfireRepositoryFactoryBean.class.getName(); } @Override String getRepositoryFactoryBeanClassName(); @Override void postProcess(BeanDefinitionBuilder builder, RepositoryConfigurationSource source); @Override void postProcess(BeanDefinitionBuilder builder, AnnotationRepositoryConfigurationSource configurationSource); @Override void postProcess(BeanDefinitionBuilder builder, XmlRepositoryConfigurationSource configurationSource); @Override void registerBeansForRoot(BeanDefinitionRegistry registry, RepositoryConfigurationSource configurationSource); }
|
@Test public void repositoryFactoryClassNameIsGemfireRepositoryFactoryBean() { assertThat(repositoryConfigurationExtension.getRepositoryFactoryBeanClassName(), is(equalTo(GemfireRepositoryFactoryBean.class.getName()))); }
|
GemfireRepositoryConfigurationExtension extends RepositoryConfigurationExtensionSupport { @Override public void postProcess(BeanDefinitionBuilder builder, RepositoryConfigurationSource source) { super.postProcess(builder, source); builder.addPropertyReference("cache", GemfireConstants.DEFAULT_GEMFIRE_CACHE_NAME); } @Override String getRepositoryFactoryBeanClassName(); @Override void postProcess(BeanDefinitionBuilder builder, RepositoryConfigurationSource source); @Override void postProcess(BeanDefinitionBuilder builder, AnnotationRepositoryConfigurationSource configurationSource); @Override void postProcess(BeanDefinitionBuilder builder, XmlRepositoryConfigurationSource configurationSource); @Override void registerBeansForRoot(BeanDefinitionRegistry registry, RepositoryConfigurationSource configurationSource); }
|
@Test public void postProcessWithAnnotationRepositoryConfigurationSource() { AnnotationRepositoryConfigurationSource mockRepositoryConfigurationSource = mock(AnnotationRepositoryConfigurationSource.class); when(mockRepositoryConfigurationSource.getAttribute(eq("mappingContextRef"))) .thenReturn(Optional.of("testMappingContext")); BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(); repositoryConfigurationExtension.postProcess(beanDefinitionBuilder, mockRepositoryConfigurationSource); Object mappingContextRef = getPropertyValue(beanDefinitionBuilder, "gemfireMappingContext"); assertThat(mappingContextRef, is(instanceOf(RuntimeBeanReference.class))); assertThat(((RuntimeBeanReference) mappingContextRef).getBeanName(), is(equalTo("testMappingContext"))); verify(mockRepositoryConfigurationSource, times(1)).getAttribute(eq("mappingContextRef")); }
@Test public void postProcessWithAnnotationRepositoryConfigurationSourceHavingNoMappingContextRefAttribute() { AnnotationRepositoryConfigurationSource mockRepositoryConfigurationSource = mock(AnnotationRepositoryConfigurationSource.class); when(mockRepositoryConfigurationSource.getAttribute(eq("mappingContextRef"))) .thenReturn(Optional.empty()); BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(); repositoryConfigurationExtension.postProcess(beanDefinitionBuilder, mockRepositoryConfigurationSource); Object mappingContextRef = getPropertyValue(beanDefinitionBuilder, "gemfireMappingContext"); assertThat(mappingContextRef, is(instanceOf(RuntimeBeanReference.class))); assertThat(((RuntimeBeanReference) mappingContextRef).getBeanName(), is(equalTo(GemfireRepositoryConfigurationExtension.DEFAULT_MAPPING_CONTEXT_BEAN_NAME))); verify(mockRepositoryConfigurationSource, times(1)).getAttribute(eq("mappingContextRef")); }
@Test public void postProcessWithXmlRepositoryConfigurationSource() { Element mockElement = mockElement(); when(mockElement.getAttribute(eq("mapping-context-ref"))).thenReturn("testMappingContext"); XmlRepositoryConfigurationSource repositoryConfigurationSource = new XmlRepositoryConfigurationSource( mockElement, mockParserContext(), mockEnvironment()); BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(); repositoryConfigurationExtension.postProcess(beanDefinitionBuilder, repositoryConfigurationSource); Object mappingContextRef = getPropertyValue(beanDefinitionBuilder, "gemfireMappingContext"); assertThat(mappingContextRef, is(instanceOf(RuntimeBeanReference.class))); assertThat(((RuntimeBeanReference) mappingContextRef).getBeanName(), is(equalTo("testMappingContext"))); verify(mockElement, times(1)).getAttribute(eq("mapping-context-ref")); }
@Test public void postProcessWithXmlRepositoryConfigurationSourceHavingNoMappingContextRefAttribute() { Element mockElement = mockElement(); when(mockElement.getAttribute(eq("mapping-context-ref"))).thenReturn(null); XmlRepositoryConfigurationSource repositoryConfigurationSource = new XmlRepositoryConfigurationSource( mockElement, mockParserContext(), mockEnvironment()); BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(); repositoryConfigurationExtension.postProcess(beanDefinitionBuilder, repositoryConfigurationSource); Object mappingContextRef = getPropertyValue(beanDefinitionBuilder, "gemfireMappingContext"); assertThat(mappingContextRef, is(instanceOf(RuntimeBeanReference.class))); assertThat(((RuntimeBeanReference) mappingContextRef).getBeanName(), is(equalTo(GemfireRepositoryConfigurationExtension.DEFAULT_MAPPING_CONTEXT_BEAN_NAME))); verify(mockElement, times(1)).getAttribute(eq("mapping-context-ref")); }
|
GemfireRepositoryBean extends CdiRepositoryBean<T> { @SuppressWarnings("unchecked") protected <S> S getDependencyInstance(Bean<S> bean, Type type) { return (S) beanManager.getReference(bean, type, beanManager.createCreationalContext(bean)); } @SuppressWarnings("unchecked") GemfireRepositoryBean(BeanManager beanManager, Class<T> repositoryType, Set<Annotation> qualifiers,
CustomRepositoryImplementationDetector detector, Bean<GemfireMappingContext> gemfireMappingContextBean,
Set<Bean<Region>> regionBeans); }
|
@Test public void getDependencyInstanceGetsReference() { Bean<Region> mockRegionBean = mock(Bean.class); CreationalContext<Region> mockCreationalContext = mock(CreationalContext.class); Region mockRegion = mock(Region.class); when(mockBeanManager.createCreationalContext(eq(mockRegionBean))).thenReturn(mockCreationalContext); when(mockBeanManager.getReference(eq(mockRegionBean), eq(Region.class), eq(mockCreationalContext))) .thenReturn(mockRegion); GemfireRepositoryBean<PersonRepository> repositoryBean = new GemfireRepositoryBean<>(this.mockBeanManager, PersonRepository.class, Collections.emptySet(), newCustomRepositoryImplementationDetector(), null, null); assertThat(repositoryBean.getDependencyInstance(mockRegionBean, Region.class), is(equalTo(mockRegion))); verify(mockBeanManager, times(1)).createCreationalContext(eq(mockRegionBean)); verify(mockBeanManager, times(1)) .getReference(eq(mockRegionBean), eq(Region.class), eq(mockCreationalContext)); }
|
GemfireRepositoryBean extends CdiRepositoryBean<T> { GemfireMappingContext resolveGemfireMappingContext() { return (gemfireMappingContextBean != null ? getDependencyInstance(gemfireMappingContextBean, GemfireMappingContext.class) : DEFAULT_GEMFIRE_MAPPING_CONTEXT); } @SuppressWarnings("unchecked") GemfireRepositoryBean(BeanManager beanManager, Class<T> repositoryType, Set<Annotation> qualifiers,
CustomRepositoryImplementationDetector detector, Bean<GemfireMappingContext> gemfireMappingContextBean,
Set<Bean<Region>> regionBeans); }
|
@Test public void resolveGemfireMappingContextUsesDefault() { GemfireRepositoryBean<PersonRepository> repositoryBean = new GemfireRepositoryBean<>(this.mockBeanManager, PersonRepository.class, Collections.emptySet(), newCustomRepositoryImplementationDetector(), null, null); assertThat(repositoryBean.resolveGemfireMappingContext(), is(equalTo(GemfireRepositoryBean.DEFAULT_GEMFIRE_MAPPING_CONTEXT))); }
@Test public void resolveGemfireMappingContextUsesQualifiedMappingContext() { Bean<GemfireMappingContext> mockMappingContextBean = mock(Bean.class); CreationalContext<GemfireMappingContext> mockCreationalContext = mock(CreationalContext.class); GemfireMappingContext expectedGemfireMappingContext = new GemfireMappingContext(); when(mockBeanManager.createCreationalContext(eq(mockMappingContextBean))).thenReturn(mockCreationalContext); when(mockBeanManager.getReference(eq(mockMappingContextBean), eq(GemfireMappingContext.class), eq(mockCreationalContext))).thenReturn(expectedGemfireMappingContext); GemfireRepositoryBean<PersonRepository> repositoryBean = new GemfireRepositoryBean<>(this.mockBeanManager, PersonRepository.class, Collections.emptySet(), newCustomRepositoryImplementationDetector(), mockMappingContextBean, null); GemfireMappingContext actualGemfireMappingContext = repositoryBean.resolveGemfireMappingContext(); assertThat(actualGemfireMappingContext, is(equalTo(expectedGemfireMappingContext))); verify(mockBeanManager, times(1)).createCreationalContext(eq(mockMappingContextBean)); verify(mockBeanManager, times(1)).getReference(eq(mockMappingContextBean), eq(GemfireMappingContext.class), eq(mockCreationalContext)); }
|
GemfireRepositoryBean extends CdiRepositoryBean<T> { Iterable<Region<?, ?>> resolveGemfireRegions() { Set<Region<?, ?>> regions = new HashSet<Region<?, ?>>(regionBeans.size()); for (Bean<Region> regionBean : regionBeans) { regions.add(getDependencyInstance(regionBean, resolveType(regionBean, Region.class))); } return regions; } @SuppressWarnings("unchecked") GemfireRepositoryBean(BeanManager beanManager, Class<T> repositoryType, Set<Annotation> qualifiers,
CustomRepositoryImplementationDetector detector, Bean<GemfireMappingContext> gemfireMappingContextBean,
Set<Bean<Region>> regionBeans); }
|
@Test public void resolveGemfireRegions() { Region mockRegionOne = mock(Region.class); Region mockRegionTwo = mock(Region.class); CreationalContext<Bean<Region>> mockCreationalContext = mock(CreationalContext.class); Bean<Region> mockRegionBeanOne = mock(Bean.class); Bean<Region> mockRegionBeanTwo = mock(Bean.class); when(mockRegionBeanOne.getTypes()).thenReturn(CollectionUtils.asSet((Type) Region.class)); when(mockRegionBeanTwo.getTypes()).thenReturn(CollectionUtils.asSet((Type) Region.class)); when(mockBeanManager.createCreationalContext(any(Bean.class))).thenReturn(mockCreationalContext); when(mockBeanManager.getReference(eq(mockRegionBeanOne), eq(Region.class), eq(mockCreationalContext))) .thenReturn(mockRegionOne); when(mockBeanManager.getReference(eq(mockRegionBeanTwo), eq(Region.class), eq(mockCreationalContext))) .thenReturn(mockRegionTwo); GemfireRepositoryBean repositoryBean = new GemfireRepositoryBean(this.mockBeanManager, PersonRepository.class, Collections.emptySet(), newCustomRepositoryImplementationDetector(), null, CollectionUtils.asSet(mockRegionBeanOne, mockRegionBeanTwo)); Iterable<Region> regions = repositoryBean.resolveGemfireRegions(); assertThat(regions, is(notNullValue())); assertThat(toSet(regions).containsAll(CollectionUtils.asSet(mockRegionOne, mockRegionTwo)), is(true)); verify(mockRegionBeanOne, times(1)).getTypes(); verify(mockRegionBeanTwo, times(1)).getTypes(); verify(mockBeanManager, times(1)).createCreationalContext(eq(mockRegionBeanOne)); verify(mockBeanManager, times(1)).createCreationalContext(eq(mockRegionBeanTwo)); verify(mockBeanManager, times(1)).getReference(eq(mockRegionBeanOne), eq(Region.class), eq(mockCreationalContext)); verify(mockBeanManager, times(1)).getReference(eq(mockRegionBeanTwo), eq(Region.class), eq(mockCreationalContext)); }
|
GemfireRepositoryBean extends CdiRepositoryBean<T> { @SuppressWarnings("unchecked") protected <S> Type resolveType(Bean<S> bean, Class<S> targetType) { for (Type type : bean.getTypes()) { Type assignableType = (type instanceof ParameterizedType ? ((ParameterizedType) type).getRawType() : type); if (assignableType instanceof Class && targetType.isAssignableFrom((Class) assignableType)) { return type; } } throw new IllegalStateException(String.format( "unable to resolve bean instance of type [%1$s] from bean definition [%2$s]", targetType, bean)); } @SuppressWarnings("unchecked") GemfireRepositoryBean(BeanManager beanManager, Class<T> repositoryType, Set<Annotation> qualifiers,
CustomRepositoryImplementationDetector detector, Bean<GemfireMappingContext> gemfireMappingContextBean,
Set<Bean<Region>> regionBeans); }
|
@Test public void resolveTypeFindsTargetComponentType() { Bean mockBean = mock(Bean.class); when(mockBean.getTypes()) .thenReturn(CollectionUtils.asSet((Type) Object.class, Map.class, ConcurrentMap.class, Region.class)); GemfireRepositoryBean<PersonRepository> repositoryBean = new GemfireRepositoryBean<>(this.mockBeanManager, PersonRepository.class, Collections.emptySet(), newCustomRepositoryImplementationDetector(), null, null); assertThat(repositoryBean.resolveType(mockBean, Region.class), is(equalTo(Region.class))); assertThat(repositoryBean.resolveType(mockBean, Map.class), isIn(asArray((Type) Map.class, ConcurrentMap.class, Region.class))); verify(mockBean, times(2)).getTypes(); }
@Test public void resolveTypeWithParameterizedType() { Bean<Map> mockBean = mock(Bean.class); Map<Long, Object> parameterizedTypeMap = Collections.emptyMap(); ParameterizedType mockParameterizedType = mock(ParameterizedType.class); assertThat(parameterizedTypeMap.getClass(), is(instanceOf(Type.class))); assertThat(parameterizedTypeMap.getClass().getGenericSuperclass(), is(instanceOf(ParameterizedType.class))); assertThat(parameterizedTypeMap.getClass().getTypeParameters().length, is(equalTo(2))); when(mockBean.getTypes()).thenReturn(CollectionUtils.asSet((Type) mockParameterizedType)); when(mockParameterizedType.getRawType()).thenReturn(parameterizedTypeMap.getClass()); GemfireRepositoryBean<PersonRepository> repositoryBean = new GemfireRepositoryBean<>(this.mockBeanManager, PersonRepository.class, Collections.emptySet(), newCustomRepositoryImplementationDetector(), null, null); assertThat(repositoryBean.resolveType(mockBean, Map.class), is(equalTo(mockParameterizedType))); verify(mockBean, times(1)).getTypes(); verify(mockParameterizedType, times(1)).getRawType(); }
@Test public void resolveTypeWithUnresolvableType() { Bean mockBean = mock(Bean.class); when(mockBean.getTypes()).thenReturn(CollectionUtils.asSet((Type) Map.class, Object.class)); GemfireRepositoryBean<PersonRepository> repositoryBean = new GemfireRepositoryBean<>(this.mockBeanManager, PersonRepository.class, Collections.emptySet(), newCustomRepositoryImplementationDetector(), null, null); try { expectedException.expect(IllegalStateException.class); expectedException.expectCause(is(nullValue(Throwable.class))); expectedException.expectMessage(is(equalTo(String.format( "unable to resolve bean instance of type [%1$s] from bean definition [%2$s]", Region.class, mockBean)))); repositoryBean.resolveType(mockBean, Region.class); } finally { verify(mockBean, times(1)).getTypes(); } }
|
GemfireRepositoryExtension extends CdiRepositoryExtensionSupport { @SuppressWarnings("unchecked") <X> void processBean(@Observes ProcessBean<X> processBean) { Bean<X> bean = processBean.getBean(); for (Type type : bean.getTypes()) { Type resolvedType = type instanceof ParameterizedType ? ((ParameterizedType) type).getRawType() : type; if (resolvedType instanceof Class<?>) { Class<?> classType = (Class<?>) resolvedType; if (Region.class.isAssignableFrom(classType)) { logger.debug("Found Region bean with name {}", bean.getName()); this.regionBeans.add((Bean<Region>) bean); } else if (GemfireMappingContext.class.isAssignableFrom(classType)) { logger.debug("Discovered {} bean with types {} having qualifiers {}", GemfireMappingContext.class.getName(), bean.getTypes(), bean.getQualifiers()); this.mappingContexts.put(bean.getQualifiers(), (Bean<GemfireMappingContext>) bean); } } } } GemfireRepositoryExtension(); }
|
@Test public void processBeanIdentifiesAndProcessesRegionBeanCorrectly() { ProcessBean<Region> mockProcessBean = mock(ProcessBean.class); Bean<Region> mockBean = mock(Bean.class); when(mockProcessBean.getBean()).thenReturn(mockBean); when(mockBean.getTypes()).thenReturn(Collections.singleton((Type) Region.class)); assertThat(repositoryExtension.regionBeans.isEmpty(), is(true)); repositoryExtension.processBean(mockProcessBean); assertThat(repositoryExtension.regionBeans.contains(mockBean), is(true)); verify(mockProcessBean, times(1)).getBean(); verify(mockBean, times(1)).getTypes(); }
@Test public void processBeanIdentifiesAndProcessesGemfireMappingContextBeanCorrectly() { ProcessBean<GemfireMappingContext> mockProcessBean = mock(ProcessBean.class); Bean<GemfireMappingContext> mockBean = mock(Bean.class); Set<Annotation> expectedQualifiers = asSet(mockAnnotation(SpringDataRepo.class), mockAnnotation(GemfireRepo.class)); when(mockProcessBean.getBean()).thenReturn(mockBean); when(mockBean.getTypes()).thenReturn(Collections.singleton((Type) GemfireMappingContext.class)); when(mockBean.getQualifiers()).thenReturn(expectedQualifiers); assertThat(repositoryExtension.mappingContexts.isEmpty(), is(true)); repositoryExtension.processBean(mockProcessBean); assertThat(repositoryExtension.mappingContexts.containsKey(expectedQualifiers), is(true)); assertThat(repositoryExtension.mappingContexts.get(expectedQualifiers), is(equalTo(mockBean))); verify(mockProcessBean, times(1)).getBean(); verify(mockBean, times(2)).getTypes(); verify(mockBean, times(2)).getQualifiers(); }
@Test public void processBeanIgnoresNonRegionNonGemfireMappingContextBeansProperly() { ProcessBean<Object> mockProcessBean = mock(ProcessBean.class); Bean<Object> mockBean = mock(Bean.class); when(mockProcessBean.getBean()).thenReturn(mockBean); when(mockBean.getTypes()).thenReturn(Collections.singleton((Type) Object.class)); assertThat(repositoryExtension.mappingContexts.isEmpty(), is(true)); assertThat(repositoryExtension.regionBeans.isEmpty(), is(true)); repositoryExtension.processBean(mockProcessBean); assertThat(repositoryExtension.mappingContexts.isEmpty(), is(true)); assertThat(repositoryExtension.regionBeans.isEmpty(), is(true)); verify(mockProcessBean, times(1)).getBean(); verify(mockBean, times(1)).getTypes(); }
|
GemfireRepositoryExtension extends CdiRepositoryExtensionSupport { void afterBeanDiscovery(@Observes AfterBeanDiscovery afterBeanDiscovery, BeanManager beanManager) { for (Map.Entry<Class<?>, Set<Annotation>> entry : getRepositoryTypes()) { Class<?> repositoryType = entry.getKey(); Set<Annotation> qualifiers = entry.getValue(); CdiRepositoryBean<?> repositoryBean = createRepositoryBean(beanManager, repositoryType, qualifiers); logger.info("Registering bean for '{}' with qualifiers {}.", repositoryType.getName(), qualifiers); registerBean(repositoryBean); afterBeanDiscovery.addBean(repositoryBean); } } GemfireRepositoryExtension(); }
|
@Test public void afterBeanDiscoveryRegistersRepositoryBean() { AfterBeanDiscovery mockAfterBeanDiscovery = mock(AfterBeanDiscovery.class); final Set<Annotation> expectedQualifiers = asSet(mockAnnotation(SpringDataRepo.class), mockAnnotation(GemfireRepo.class)); doAnswer(new Answer<Void>() { public Void answer(final InvocationOnMock invocation) throws Throwable { GemfireRepositoryBean<?> repositoryBean = invocation.getArgument(0); assertThat(repositoryBean, is(notNullValue())); assertThat((Class<TestRepository>) repositoryBean.getBeanClass(), is(equalTo(TestRepository.class))); assertThat(repositoryBean.getQualifiers(), is(equalTo(expectedQualifiers))); return null; } }).when(mockAfterBeanDiscovery).addBean(isA(GemfireRepositoryBean.class)); GemfireRepositoryExtension repositoryExtension = new GemfireRepositoryExtension() { @Override protected Iterable<Map.Entry<Class<?>, Set<Annotation>>> getRepositoryTypes() { return Collections.<Class<?>, Set<Annotation>>singletonMap(TestRepository.class, expectedQualifiers).entrySet(); } }; repositoryExtension.afterBeanDiscovery(mockAfterBeanDiscovery, mock(BeanManager.class)); verify(mockAfterBeanDiscovery, times(1)).addBean(isA(GemfireRepositoryBean.class)); }
|
GemfireRepositoryFactoryBean extends RepositoryFactoryBeanSupport<T, S, ID> implements ApplicationContextAware { @Override public void afterPropertiesSet() { configureRegions(); resolveGemfireMappingContext(); super.afterPropertiesSet(); } GemfireRepositoryFactoryBean(Class<? extends T> repositoryInterface); @Override void setApplicationContext(@Nullable ApplicationContext applicationContext); void setCache(@Nullable GemFireCache cache); @Autowired(required = false) void setGemfireMappingContext(@Nullable MappingContext<? extends GemfirePersistentEntity<?>, GemfirePersistentProperty> mappingContext); @Override void afterPropertiesSet(); }
|
@Test public void rejectsMappingContextNotSet() { exception.expect(IllegalStateException.class); exception.expectMessage("GemfireMappingContext"); repositoryFactoryBean.afterPropertiesSet(); }
|
PeerRegionFactoryBean extends ConfigurableRegionFactoryBean<K, V> implements DisposableBean, EvictingRegionFactoryBean, ExpiringRegionFactoryBean<K, V>, SmartLifecycle { protected boolean isPersistent() { return Boolean.TRUE.equals(this.persistent); } @Override void destroy(); void setAsyncEventQueues(@NonNull AsyncEventQueue[] asyncEventQueues); void setAsyncEventQueueIds(@NonNull String[] asyncEventQueueIds); void addAsyncEventQueues(@NonNull AsyncEventQueue[] asyncEventQueues); void addAsyncEventQueueIds(@NonNull String[] asyncEventQueueIds); void setAttributes(RegionAttributes<K, V> attributes); RegionAttributes<K, V> getAttributes(); void setCacheListeners(CacheListener<K, V>[] cacheListeners); void setCacheLoader(CacheLoader<K, V> cacheLoader); void setCacheWriter(CacheWriter<K, V> cacheWriter); void setClose(boolean close); void setCompressor(Compressor compressor); void setCustomEntryIdleTimeout(CustomExpiry<K, V> customEntryIdleTimeout); void setCustomEntryTimeToLive(CustomExpiry<K, V> customEntryTimeToLive); void setDestroy(boolean destroy); void setDataPolicy(DataPolicy dataPolicy); DataPolicy getDataPolicy(); void setDiskStoreName(String diskStoreName); void setEntryIdleTimeout(ExpirationAttributes entryIdleTimeout); void setEntryTimeToLive(ExpirationAttributes entryTimeToLive); void setEvictionAttributes(EvictionAttributes evictionAttributes); void setGatewaySenders(@NonNull GatewaySender[] gatewaySenders); void setGatewaySenderIds(@NonNull String[] gatewaySenderIds); void addGatewaySenders(@NonNull GatewaySender[] gatewaySenders); void addGatewaySendersIds(@NonNull String[] gatewaySenderIds); void setOffHeap(Boolean offHeap); Boolean getOffHeap(); boolean isOffHeap(); void setKeyConstraint(Class<K> keyConstraint); void setPersistent(Boolean persistent); void setRegionIdleTimeout(ExpirationAttributes regionIdleTimeout); void setRegionTimeToLive(ExpirationAttributes regionTimeToLive); void setScope(Scope scope); Scope getScope(); void setShortcut(RegionShortcut shortcut); RegionShortcut getShortcut(); void setStatisticsEnabled(Boolean statisticsEnabled); Boolean getStatisticsEnabled(); boolean isStatisticsEnabled(); void setValueConstraint(Class<V> valueConstraint); @Override @SuppressWarnings("all") void start(); @Override void stop(Runnable callback); @Override @SuppressWarnings("all") void stop(); @Override boolean isRunning(); @Override int getPhase(); @Override boolean isAutoStartup(); }
|
@Test public void testIsPersistent() { PeerRegionFactoryBean<?, ?> factoryBean = new TestRegionFactoryBean<>(); assertFalse(factoryBean.isPersistent()); factoryBean.setPersistent(false); assertFalse(factoryBean.isPersistent()); factoryBean.setPersistent(true); assertTrue(factoryBean.isPersistent()); }
|
PeerRegionFactoryBean extends ConfigurableRegionFactoryBean<K, V> implements DisposableBean, EvictingRegionFactoryBean, ExpiringRegionFactoryBean<K, V>, SmartLifecycle { protected boolean isNotPersistent() { return Boolean.FALSE.equals(this.persistent); } @Override void destroy(); void setAsyncEventQueues(@NonNull AsyncEventQueue[] asyncEventQueues); void setAsyncEventQueueIds(@NonNull String[] asyncEventQueueIds); void addAsyncEventQueues(@NonNull AsyncEventQueue[] asyncEventQueues); void addAsyncEventQueueIds(@NonNull String[] asyncEventQueueIds); void setAttributes(RegionAttributes<K, V> attributes); RegionAttributes<K, V> getAttributes(); void setCacheListeners(CacheListener<K, V>[] cacheListeners); void setCacheLoader(CacheLoader<K, V> cacheLoader); void setCacheWriter(CacheWriter<K, V> cacheWriter); void setClose(boolean close); void setCompressor(Compressor compressor); void setCustomEntryIdleTimeout(CustomExpiry<K, V> customEntryIdleTimeout); void setCustomEntryTimeToLive(CustomExpiry<K, V> customEntryTimeToLive); void setDestroy(boolean destroy); void setDataPolicy(DataPolicy dataPolicy); DataPolicy getDataPolicy(); void setDiskStoreName(String diskStoreName); void setEntryIdleTimeout(ExpirationAttributes entryIdleTimeout); void setEntryTimeToLive(ExpirationAttributes entryTimeToLive); void setEvictionAttributes(EvictionAttributes evictionAttributes); void setGatewaySenders(@NonNull GatewaySender[] gatewaySenders); void setGatewaySenderIds(@NonNull String[] gatewaySenderIds); void addGatewaySenders(@NonNull GatewaySender[] gatewaySenders); void addGatewaySendersIds(@NonNull String[] gatewaySenderIds); void setOffHeap(Boolean offHeap); Boolean getOffHeap(); boolean isOffHeap(); void setKeyConstraint(Class<K> keyConstraint); void setPersistent(Boolean persistent); void setRegionIdleTimeout(ExpirationAttributes regionIdleTimeout); void setRegionTimeToLive(ExpirationAttributes regionTimeToLive); void setScope(Scope scope); Scope getScope(); void setShortcut(RegionShortcut shortcut); RegionShortcut getShortcut(); void setStatisticsEnabled(Boolean statisticsEnabled); Boolean getStatisticsEnabled(); boolean isStatisticsEnabled(); void setValueConstraint(Class<V> valueConstraint); @Override @SuppressWarnings("all") void start(); @Override void stop(Runnable callback); @Override @SuppressWarnings("all") void stop(); @Override boolean isRunning(); @Override int getPhase(); @Override boolean isAutoStartup(); }
|
@Test public void testIsNotPersistent() { PeerRegionFactoryBean<?, ?> factoryBean = new TestRegionFactoryBean<>(); assertFalse(factoryBean.isNotPersistent()); factoryBean.setPersistent(true); assertFalse(factoryBean.isNotPersistent()); factoryBean.setPersistent(false); assertTrue(factoryBean.isNotPersistent()); }
|
AnnotationBasedExpiration implements BeanFactoryAware, CustomExpiry<K, V> { protected boolean isTimeToLiveConfigured(Region.Entry<K, V> entry) { return entry != null && isTimeToLiveConfigured(entry.getValue()); } AnnotationBasedExpiration(); AnnotationBasedExpiration(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forIdleTimeout(); static AnnotationBasedExpiration<K, V> forIdleTimeout(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forTimeToLive(); static AnnotationBasedExpiration<K, V> forTimeToLive(ExpirationAttributes defaultExpirationAttributes); @Override void setBeanFactory(BeanFactory beanFactory); void setDefaultExpirationAttributes(ExpirationAttributes defaultExpirationAttributes); @Override ExpirationAttributes getExpiry(Region.Entry<K, V> entry); @Override void close(); }
|
@Test public void isTimeToLiveConfiguredWithTimeToLiveExpirationBasedRegionEntry() { Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry"); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveExpiration()); assertThat(noDefaultExpiration.isTimeToLiveConfigured(mockRegionEntry), is(true)); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutGenericExpiration()); assertThat(noDefaultExpiration.isTimeToLiveConfigured(mockRegionEntry), is(true)); verify(mockRegionEntry, times(2)).getValue(); }
|
PeerRegionFactoryBean extends ConfigurableRegionFactoryBean<K, V> implements DisposableBean, EvictingRegionFactoryBean, ExpiringRegionFactoryBean<K, V>, SmartLifecycle { protected RegionFactory<K, V> createRegionFactory(Cache cache) { if (this.shortcut != null) { RegionFactory<K, V> regionFactory = mergeRegionAttributes(cache.createRegionFactory(this.shortcut), this.attributes); setDataPolicy(getDataPolicy(regionFactory, this.shortcut)); return regionFactory; } else if (this.attributes != null) { return cache.createRegionFactory(this.attributes); } else { return cache.createRegionFactory(); } } @Override void destroy(); void setAsyncEventQueues(@NonNull AsyncEventQueue[] asyncEventQueues); void setAsyncEventQueueIds(@NonNull String[] asyncEventQueueIds); void addAsyncEventQueues(@NonNull AsyncEventQueue[] asyncEventQueues); void addAsyncEventQueueIds(@NonNull String[] asyncEventQueueIds); void setAttributes(RegionAttributes<K, V> attributes); RegionAttributes<K, V> getAttributes(); void setCacheListeners(CacheListener<K, V>[] cacheListeners); void setCacheLoader(CacheLoader<K, V> cacheLoader); void setCacheWriter(CacheWriter<K, V> cacheWriter); void setClose(boolean close); void setCompressor(Compressor compressor); void setCustomEntryIdleTimeout(CustomExpiry<K, V> customEntryIdleTimeout); void setCustomEntryTimeToLive(CustomExpiry<K, V> customEntryTimeToLive); void setDestroy(boolean destroy); void setDataPolicy(DataPolicy dataPolicy); DataPolicy getDataPolicy(); void setDiskStoreName(String diskStoreName); void setEntryIdleTimeout(ExpirationAttributes entryIdleTimeout); void setEntryTimeToLive(ExpirationAttributes entryTimeToLive); void setEvictionAttributes(EvictionAttributes evictionAttributes); void setGatewaySenders(@NonNull GatewaySender[] gatewaySenders); void setGatewaySenderIds(@NonNull String[] gatewaySenderIds); void addGatewaySenders(@NonNull GatewaySender[] gatewaySenders); void addGatewaySendersIds(@NonNull String[] gatewaySenderIds); void setOffHeap(Boolean offHeap); Boolean getOffHeap(); boolean isOffHeap(); void setKeyConstraint(Class<K> keyConstraint); void setPersistent(Boolean persistent); void setRegionIdleTimeout(ExpirationAttributes regionIdleTimeout); void setRegionTimeToLive(ExpirationAttributes regionTimeToLive); void setScope(Scope scope); Scope getScope(); void setShortcut(RegionShortcut shortcut); RegionShortcut getShortcut(); void setStatisticsEnabled(Boolean statisticsEnabled); Boolean getStatisticsEnabled(); boolean isStatisticsEnabled(); void setValueConstraint(Class<V> valueConstraint); @Override @SuppressWarnings("all") void start(); @Override void stop(Runnable callback); @Override @SuppressWarnings("all") void stop(); @Override boolean isRunning(); @Override int getPhase(); @Override boolean isAutoStartup(); }
|
@Test public void testCreateRegionFactory() { Cache mockCache = mock(Cache.class); RegionFactory mockRegionFactory = createMockRegionFactory(); when(mockCache.createRegionFactory()).thenReturn(mockRegionFactory); PeerRegionFactoryBean factoryBean = new TestRegionFactoryBean(); factoryBean.setAttributes(null); factoryBean.setShortcut(null); assertSame(mockRegionFactory, factoryBean.createRegionFactory(mockCache)); verify(mockCache).createRegionFactory(); }
|
PeerRegionFactoryBean extends ConfigurableRegionFactoryBean<K, V> implements DisposableBean, EvictingRegionFactoryBean, ExpiringRegionFactoryBean<K, V>, SmartLifecycle { protected <K, V> RegionFactory<K, V> mergeRegionAttributes(RegionFactory<K, V> regionFactory, RegionAttributes<K, V> regionAttributes) { if (regionAttributes != null) { validateRegionAttributes(regionAttributes); CollectionUtils.nullSafeSet(regionAttributes.getAsyncEventQueueIds()).stream() .filter(StringUtils::hasText) .forEach(regionFactory::addAsyncEventQueueId); regionFactory.setCloningEnabled(regionAttributes.getCloningEnabled()); regionFactory.setCompressor(regionAttributes.getCompressor()); regionFactory.setConcurrencyChecksEnabled(regionAttributes.getConcurrencyChecksEnabled()); regionFactory.setConcurrencyLevel(regionAttributes.getConcurrencyLevel()); regionFactory.setCustomEntryIdleTimeout(regionAttributes.getCustomEntryIdleTimeout()); regionFactory.setCustomEntryTimeToLive(regionAttributes.getCustomEntryTimeToLive()); regionFactory.setDiskSynchronous(regionAttributes.isDiskSynchronous()); regionFactory.setEnableAsyncConflation(regionAttributes.getEnableAsyncConflation()); regionFactory.setEnableSubscriptionConflation(regionAttributes.getEnableSubscriptionConflation()); regionFactory.setEntryIdleTimeout(regionAttributes.getEntryIdleTimeout()); regionFactory.setEntryTimeToLive(regionAttributes.getEntryTimeToLive()); if (isUserSpecifiedEvictionAttributes(regionAttributes)) { regionFactory.setEvictionAttributes(regionAttributes.getEvictionAttributes()); } CollectionUtils.nullSafeSet(regionAttributes.getGatewaySenderIds()).stream() .filter(StringUtils::hasText) .forEach(regionFactory::addGatewaySenderId); regionFactory.setIgnoreJTA(regionAttributes.getIgnoreJTA()); regionFactory.setIndexMaintenanceSynchronous(regionAttributes.getIndexMaintenanceSynchronous()); regionFactory.setInitialCapacity(regionAttributes.getInitialCapacity()); regionFactory.setKeyConstraint(regionAttributes.getKeyConstraint()); regionFactory.setLoadFactor(regionAttributes.getLoadFactor()); regionFactory.setLockGrantor(regionAttributes.isLockGrantor()); regionFactory.setMembershipAttributes(regionAttributes.getMembershipAttributes()); regionFactory.setMulticastEnabled(regionAttributes.getMulticastEnabled()); regionFactory.setOffHeap(regionAttributes.getOffHeap()); mergePartitionAttributes(regionFactory, regionAttributes); regionFactory.setPoolName(regionAttributes.getPoolName()); regionFactory.setRegionIdleTimeout(regionAttributes.getRegionIdleTimeout()); regionFactory.setRegionTimeToLive(regionAttributes.getRegionTimeToLive()); regionFactory.setStatisticsEnabled(regionAttributes.getStatisticsEnabled()); regionFactory.setSubscriptionAttributes(regionAttributes.getSubscriptionAttributes()); regionFactory.setValueConstraint(regionAttributes.getValueConstraint()); } return regionFactory; } @Override void destroy(); void setAsyncEventQueues(@NonNull AsyncEventQueue[] asyncEventQueues); void setAsyncEventQueueIds(@NonNull String[] asyncEventQueueIds); void addAsyncEventQueues(@NonNull AsyncEventQueue[] asyncEventQueues); void addAsyncEventQueueIds(@NonNull String[] asyncEventQueueIds); void setAttributes(RegionAttributes<K, V> attributes); RegionAttributes<K, V> getAttributes(); void setCacheListeners(CacheListener<K, V>[] cacheListeners); void setCacheLoader(CacheLoader<K, V> cacheLoader); void setCacheWriter(CacheWriter<K, V> cacheWriter); void setClose(boolean close); void setCompressor(Compressor compressor); void setCustomEntryIdleTimeout(CustomExpiry<K, V> customEntryIdleTimeout); void setCustomEntryTimeToLive(CustomExpiry<K, V> customEntryTimeToLive); void setDestroy(boolean destroy); void setDataPolicy(DataPolicy dataPolicy); DataPolicy getDataPolicy(); void setDiskStoreName(String diskStoreName); void setEntryIdleTimeout(ExpirationAttributes entryIdleTimeout); void setEntryTimeToLive(ExpirationAttributes entryTimeToLive); void setEvictionAttributes(EvictionAttributes evictionAttributes); void setGatewaySenders(@NonNull GatewaySender[] gatewaySenders); void setGatewaySenderIds(@NonNull String[] gatewaySenderIds); void addGatewaySenders(@NonNull GatewaySender[] gatewaySenders); void addGatewaySendersIds(@NonNull String[] gatewaySenderIds); void setOffHeap(Boolean offHeap); Boolean getOffHeap(); boolean isOffHeap(); void setKeyConstraint(Class<K> keyConstraint); void setPersistent(Boolean persistent); void setRegionIdleTimeout(ExpirationAttributes regionIdleTimeout); void setRegionTimeToLive(ExpirationAttributes regionTimeToLive); void setScope(Scope scope); Scope getScope(); void setShortcut(RegionShortcut shortcut); RegionShortcut getShortcut(); void setStatisticsEnabled(Boolean statisticsEnabled); Boolean getStatisticsEnabled(); boolean isStatisticsEnabled(); void setValueConstraint(Class<V> valueConstraint); @Override @SuppressWarnings("all") void start(); @Override void stop(Runnable callback); @Override @SuppressWarnings("all") void stop(); @Override boolean isRunning(); @Override int getPhase(); @Override boolean isAutoStartup(); }
|
@Test public void testMergeRegionAttributes() throws Exception { EvictionAttributes testEvictionAttributes = EvictionAttributes.createLRUEntryAttributes(); ExpirationAttributes testExpirationAttributes = new ExpirationAttributes(120, ExpirationAction.LOCAL_DESTROY); MembershipAttributes testMembershipAttributes = new MembershipAttributes(); PartitionAttributes testPartitionAttributes = createPartitionAttributes("TestRegion", 1024000, 15000L, 0, 45000L, 2048000000L, 97); SubscriptionAttributes testSubscriptionAttributes = new SubscriptionAttributes(); RegionAttributes mockRegionAttributes = mock(RegionAttributes.class); RegionFactory<Long, String> mockRegionFactory = (RegionFactory<Long, String>) createMockRegionFactory(); when(mockRegionAttributes.getCloningEnabled()).thenReturn(false); when(mockRegionAttributes.getConcurrencyChecksEnabled()).thenReturn(true); when(mockRegionAttributes.getConcurrencyLevel()).thenReturn(51); when(mockRegionAttributes.getCustomEntryIdleTimeout()).thenReturn(null); when(mockRegionAttributes.getCustomEntryTimeToLive()).thenReturn(null); when(mockRegionAttributes.isDiskSynchronous()).thenReturn(true); when(mockRegionAttributes.getEnableAsyncConflation()).thenReturn(false); when(mockRegionAttributes.getEnableSubscriptionConflation()).thenReturn(false); when(mockRegionAttributes.getEntryIdleTimeout()).thenReturn(testExpirationAttributes); when(mockRegionAttributes.getEntryTimeToLive()).thenReturn(testExpirationAttributes); when(mockRegionAttributes.getEvictionAttributes()).thenReturn(testEvictionAttributes); when(mockRegionAttributes.getIgnoreJTA()).thenReturn(false); when(mockRegionAttributes.getIndexMaintenanceSynchronous()).thenReturn(false); when(mockRegionAttributes.getInitialCapacity()).thenReturn(1024); when(mockRegionAttributes.getKeyConstraint()).thenReturn(Long.class); when(mockRegionAttributes.getLoadFactor()).thenReturn(0.90f); when(mockRegionAttributes.isLockGrantor()).thenReturn(true); when(mockRegionAttributes.getMembershipAttributes()).thenReturn(testMembershipAttributes); when(mockRegionAttributes.getMulticastEnabled()).thenReturn(false); when(mockRegionAttributes.getOffHeap()).thenReturn(true); when(mockRegionAttributes.getPartitionAttributes()).thenReturn(testPartitionAttributes); when(mockRegionAttributes.getPoolName()).thenReturn("swimming"); when(mockRegionAttributes.getRegionIdleTimeout()).thenReturn(testExpirationAttributes); when(mockRegionAttributes.getRegionTimeToLive()).thenReturn(testExpirationAttributes); when(mockRegionAttributes.getStatisticsEnabled()).thenReturn(true); when(mockRegionAttributes.getSubscriptionAttributes()).thenReturn(testSubscriptionAttributes); PeerRegionFactoryBean factoryBean = new PeerRegionFactoryBean() { @Override boolean isUserSpecifiedEvictionAttributes(final RegionAttributes regionAttributes) { return true; } @Override void validateRegionAttributes(final RegionAttributes regionAttributes) { } }; factoryBean.mergeRegionAttributes(mockRegionFactory, mockRegionAttributes); verify(mockRegionFactory).setCloningEnabled(eq(false)); verify(mockRegionFactory).setConcurrencyChecksEnabled(eq(true)); verify(mockRegionFactory).setConcurrencyLevel(eq(51)); verify(mockRegionFactory).setCustomEntryIdleTimeout(null); verify(mockRegionFactory).setCustomEntryTimeToLive(null); verify(mockRegionFactory).setDiskSynchronous(eq(true)); verify(mockRegionFactory).setEnableAsyncConflation(eq(false)); verify(mockRegionFactory).setEnableSubscriptionConflation(eq(false)); verify(mockRegionFactory).setEntryIdleTimeout(same(testExpirationAttributes)); verify(mockRegionFactory).setEntryTimeToLive(same(testExpirationAttributes)); verify(mockRegionFactory).setEvictionAttributes(same(testEvictionAttributes)); verify(mockRegionFactory).setIgnoreJTA(eq(false)); verify(mockRegionFactory).setIndexMaintenanceSynchronous(eq(false)); verify(mockRegionFactory).setInitialCapacity(eq(1024)); verify(mockRegionFactory).setKeyConstraint(Long.class); verify(mockRegionFactory).setLoadFactor(eq(0.90f)); verify(mockRegionFactory).setLockGrantor(eq(true)); verify(mockRegionFactory).setMembershipAttributes(same(testMembershipAttributes)); verify(mockRegionFactory).setMulticastEnabled(eq(false)); verify(mockRegionFactory).setOffHeap(eq(true)); verify(mockRegionFactory).setPartitionAttributes(eq(testPartitionAttributes)); verify(mockRegionFactory).setPoolName(eq("swimming")); verify(mockRegionFactory).setRegionIdleTimeout(same(testExpirationAttributes)); verify(mockRegionFactory).setRegionTimeToLive(same(testExpirationAttributes)); verify(mockRegionFactory).setStatisticsEnabled(eq(true)); verify(mockRegionFactory).setSubscriptionAttributes(same(testSubscriptionAttributes)); }
|
PeerRegionFactoryBean extends ConfigurableRegionFactoryBean<K, V> implements DisposableBean, EvictingRegionFactoryBean, ExpiringRegionFactoryBean<K, V>, SmartLifecycle { @SuppressWarnings("rawtypes") protected <K, V> void mergePartitionAttributes(RegionFactory<K, V> regionFactory, RegionAttributes<K, V> regionAttributes) { if (regionAttributes.getPartitionAttributes() != null) { PartitionAttributes partitionAttributes = regionAttributes.getPartitionAttributes(); PartitionAttributesFactory partitionAttributesFactory = new PartitionAttributesFactory(partitionAttributes); RegionShortcutWrapper shortcutWrapper = RegionShortcutWrapper.valueOf(shortcut); if (shortcutWrapper.isRedundant() && partitionAttributes.getRedundantCopies() == 0) { partitionAttributesFactory.setRedundantCopies(1); } if (shortcutWrapper.isProxy()) { partitionAttributesFactory.setLocalMaxMemory(0); } regionFactory.setPartitionAttributes(partitionAttributesFactory.create()); } } @Override void destroy(); void setAsyncEventQueues(@NonNull AsyncEventQueue[] asyncEventQueues); void setAsyncEventQueueIds(@NonNull String[] asyncEventQueueIds); void addAsyncEventQueues(@NonNull AsyncEventQueue[] asyncEventQueues); void addAsyncEventQueueIds(@NonNull String[] asyncEventQueueIds); void setAttributes(RegionAttributes<K, V> attributes); RegionAttributes<K, V> getAttributes(); void setCacheListeners(CacheListener<K, V>[] cacheListeners); void setCacheLoader(CacheLoader<K, V> cacheLoader); void setCacheWriter(CacheWriter<K, V> cacheWriter); void setClose(boolean close); void setCompressor(Compressor compressor); void setCustomEntryIdleTimeout(CustomExpiry<K, V> customEntryIdleTimeout); void setCustomEntryTimeToLive(CustomExpiry<K, V> customEntryTimeToLive); void setDestroy(boolean destroy); void setDataPolicy(DataPolicy dataPolicy); DataPolicy getDataPolicy(); void setDiskStoreName(String diskStoreName); void setEntryIdleTimeout(ExpirationAttributes entryIdleTimeout); void setEntryTimeToLive(ExpirationAttributes entryTimeToLive); void setEvictionAttributes(EvictionAttributes evictionAttributes); void setGatewaySenders(@NonNull GatewaySender[] gatewaySenders); void setGatewaySenderIds(@NonNull String[] gatewaySenderIds); void addGatewaySenders(@NonNull GatewaySender[] gatewaySenders); void addGatewaySendersIds(@NonNull String[] gatewaySenderIds); void setOffHeap(Boolean offHeap); Boolean getOffHeap(); boolean isOffHeap(); void setKeyConstraint(Class<K> keyConstraint); void setPersistent(Boolean persistent); void setRegionIdleTimeout(ExpirationAttributes regionIdleTimeout); void setRegionTimeToLive(ExpirationAttributes regionTimeToLive); void setScope(Scope scope); Scope getScope(); void setShortcut(RegionShortcut shortcut); RegionShortcut getShortcut(); void setStatisticsEnabled(Boolean statisticsEnabled); Boolean getStatisticsEnabled(); boolean isStatisticsEnabled(); void setValueConstraint(Class<V> valueConstraint); @Override @SuppressWarnings("all") void start(); @Override void stop(Runnable callback); @Override @SuppressWarnings("all") void stop(); @Override boolean isRunning(); @Override int getPhase(); @Override boolean isAutoStartup(); }
|
@Test public void testMergePartitionAttributes() { RegionAttributes mockRegionAttributes = mock(RegionAttributes.class); RegionFactory mockRegionFactory = createMockRegionFactory(); when(mockRegionAttributes.getPartitionAttributes()).thenReturn(null); factoryBean.setShortcut(null); factoryBean.mergePartitionAttributes(mockRegionFactory, mockRegionAttributes); verify(mockRegionAttributes, times(1)).getPartitionAttributes(); verify(mockRegionFactory, never()).setPartitionAttributes(any(PartitionAttributes.class)); }
|
NoopSpanNameProvider implements MongoSpanNameProvider { @Override public String generateName(CommandStartedEvent event) { return event != null && event.getCommandName() != null ? event.getCommandName() : NO_OPERATION; } @Override String generateName(CommandStartedEvent event); }
|
@Test public void testOperationNameExists() { assertEquals("insert", provider.generateName(TEST_EVENT)); }
@Test public void testNullOperationName() { assertEquals("unknown", provider.generateName(null)); }
|
TracingCommandListener implements CommandListener { Span buildSpan(CommandStartedEvent event) { for (ExcludedCommand excludedCommand : excludedCommands) { boolean skip = true; for (Entry<String, BsonValue> entry : excludedCommand.entrySet()) { if (!event.getCommand().containsKey(entry.getKey())) { skip = false; break; } if (entry.getValue() != BsonNull.VALUE && !entry.getValue().equals(event.getCommand().get(entry.getKey()))) { skip = false; break; } } if (skip) { return null; } } Tracer.SpanBuilder spanBuilder = tracer .buildSpan(mongoSpanNameProvider.generateName(event)) .withTag(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_CLIENT); Span span = spanBuilder.start(); for (SpanDecorator decorator : decorators) { decorator.commandStarted(event, span); } return span; } TracingCommandListener(Tracer tracer, MongoSpanNameProvider customNameProvider,
List<ExcludedCommand> excludedCommands); TracingCommandListener(Tracer tracer, MongoSpanNameProvider customNameProvider,
List<ExcludedCommand> excludedCommands, List<SpanDecorator> decorators); @Override void commandStarted(CommandStartedEvent event); @Override void commandSucceeded(CommandSucceededEvent event); @Override void commandFailed(CommandFailedEvent event); static final String COMPONENT_NAME; }
|
@Test public void testDefaultDecorator() { span = withoutProvider.buildSpan(event); MockSpan mockSpan = (MockSpan) span; assertEquals(((mockSpan).tags().get(Tags.COMPONENT.getKey())), TracingCommandListener.COMPONENT_NAME); }
@Test public void testCustomDecorator() { span = withCustomDecorators.buildSpan(event); MockSpan mockSpan = (MockSpan) span; assertEquals(((mockSpan).tags().get(Tags.COMPONENT.getKey())), FOO); assertEquals(((mockSpan).tags().get(FOO)), FOO); }
@Test public void testDefault() { span = withoutProvider.buildSpan(event); MockSpan mockSpan = (MockSpan) span; assertEquals(mockSpan.operationName(), operationName.generateName(event)); }
@Test public void testPrefix() { span = withProvider.buildSpan(event); MockSpan mockSpan = (MockSpan) span; assertEquals(mockSpan.operationName(), prefixSpanName.generateName(event)); }
|
OperationCollectionSpanNameProvider extends NoopSpanNameProvider { @Override public String generateName(CommandStartedEvent event) { if (event == null || event.getCommand() == null) { return NO_OPERATION; } final BsonDocument cmd = event.getCommand(); BsonValue firstKey = cmd.get(cmd.getFirstKey()); if (firstKey.isString()) { String collectionName = firstKey.asString().getValue(); return super.generateName(event) + " " + collectionName; } else { return super.generateName(event); } } @Override String generateName(CommandStartedEvent event); }
|
@Test public void testOperationNameExists() { assertEquals("insert collection-name", provider.generateName(INSERT_TEST_EVENT)); }
@Test public void testNullOperationName() { assertEquals("unknown", provider.generateName(null)); }
@Test public void testOperationNameNotString() { assertEquals("buildInfo", provider.generateName(BUILD_INFO_TEST_EVENT)); }
|
PrefixSpanNameProvider implements MongoSpanNameProvider { @Override public String generateName(CommandStartedEvent event) { final String operationName = event != null && event.getCommandName() != null ? event.getCommandName() : NO_OPERATION; return ((prefix == null) ? "" : prefix) + operationName; } PrefixSpanNameProvider(String prefix); @Override String generateName(CommandStartedEvent event); }
|
@Test public void testOperationNameExists() { assertEquals("mongo.insert", provider.generateName(TEST_EVENT)); }
@Test public void testNullOperationName() { assertEquals("mongo.unknown", provider.generateName(null)); }
@Test public void testNullPrefixName() { assertEquals("insert", new PrefixSpanNameProvider(null).generateName(TEST_EVENT)); }
|
BeanPropertiesMapper implements NodePropertiesMapper<T> { public T mapNodeProperties(final NodeRef nodeRef, final Map<QName, Serializable> properties) { try { T mappedObject = this.mappedClass.newInstance(); BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(mappedObject); afterBeanWrapperInitialized(bw); for (Map.Entry<QName, PropertyDescriptor> entry : mappedQNames.entrySet()) { QName qName = entry.getKey(); PropertyDescriptor pd = entry.getValue(); if (pd != null) { bw.setPropertyValue(pd.getName(), properties.get(qName)); } } if (configurer != null) { configurer.configure(nodeRef, mappedObject); } return mappedObject; } catch (Throwable e) { throw new RuntimeException(e); } } protected BeanPropertiesMapper(final NamespaceService namespaceService, final DictionaryService dictionaryService); protected BeanPropertiesMapper(final NamespaceService namespaceService, final DictionaryService dictionaryService,
final boolean reportNamespaceException, Class<T> mappedClass); protected BeanPropertiesMapper(final NamespaceService namespaceService, final DictionaryService dictionaryService,
final boolean reportNamespaceException); @SuppressWarnings("unchecked") protected BeanPropertiesMapper(final NamespaceService namespaceService, final DictionaryService dictionaryService,
final BeanPropertiesMapperConfigurer<T> configurer, final boolean reportNamespaceException); BeanPropertiesMapperConfigurer<T> getConfigurer(); T mapNodeProperties(final NodeRef nodeRef, final Map<QName, Serializable> properties); @Override Set<QName> getMappedQnames(); Class<T> getMappedClass(); }
|
@Test public void mapNodeProperties_withCorrectData() { CmFolder cmFolder = mapper.mapNodeProperties(NODE_REF, ImmutableMap.of(ContentModel.PROP_TITLE, "Test Title value", ContentModel.PROP_DESCRIPTION, "Test Description value")); assertEquals("Test Title value", cmFolder.getCmTitle()); assertEquals("Test Description value", cmFolder.getCmDescription()); assertEquals(NODE_REF.getId(), cmFolder.getRef()); assertNull(cmFolder.getCustomNamespaceData()); }
@Test public void mapNodeProperties_withCustomNamespaceCorrectData() { Date testDate = new Date(); CmFolder cmFolder = mapper.mapNodeProperties(NODE_REF, ImmutableMap.of(QName.createQName("custom_uri", "namespaceData"), testDate)); assertNull(cmFolder.getCmDescription()); assertNull(cmFolder.getCmTitle()); assertEquals(NODE_REF.getId(), cmFolder.getRef()); assertEquals(testDate, cmFolder.getCustomNamespaceData()); }
@Test public void mapNodeProperties_withNonExistingProperty_reportException() { Assertions.assertThrows(NamespaceException.class, () -> { BeanPropertiesMapper<NonExistingNodeProperties> mapperWrong = new BeanPropertiesMapperBuilder<NonExistingNodeProperties>() .mappedClass(NonExistingNodeProperties.class).namespaceService(namespaceService) .dictionaryService(dictionaryService).reportNamespaceException(true).build(); mapperWrong.mapNodeProperties(NODE_REF, ImmutableMap.of()); }); }
@Test public void mapNodeProperties_withNonExistingProperty_doNotReportException() { BeanPropertiesMapper<NonExistingNodeProperties> mapperWrong = new BeanPropertiesMapperBuilder<NonExistingNodeProperties>() .mappedClass(NonExistingNodeProperties.class).namespaceService(namespaceService) .dictionaryService(dictionaryService).build(); NonExistingNodeProperties nonExistingNodeProperties = mapperWrong.mapNodeProperties(NODE_REF, ImmutableMap.of()); assertNull(nonExistingNodeProperties.getNonexistingData()); }
@Test public void registry_withCorrectDataAndConfigurer() { Date testDate = new Date(); BeanPropertiesMapper<CmFolder> mapper = new BeanPropertiesMapperRegistry(namespaceService, dictionaryService) .addBeanPropertiesMapper(this.mapper).getForClass(CmFolder.class); CmFolder cmFolder = mapper.mapNodeProperties(NODE_REF, ImmutableMap.of(QName.createQName("custom_uri", "namespaceData"), testDate, ContentModel.PROP_TITLE, "Test Title value", ContentModel.PROP_DESCRIPTION, "Test Description value")); assertEquals("Test Title value", cmFolder.getCmTitle()); assertEquals("Test Description value", cmFolder.getCmDescription()); assertEquals(NODE_REF.getId(), cmFolder.getRef()); assertEquals(testDate, cmFolder.getCustomNamespaceData()); }
@Test public void registry_withCorrectData() { Date testDate = new Date(); BeanPropertiesMapper<CmFolder> mapper = new BeanPropertiesMapperRegistry(namespaceService, dictionaryService) .getForClass(CmFolder.class); CmFolder cmFolder = mapper.mapNodeProperties(NODE_REF, ImmutableMap.of(QName.createQName("custom_uri", "namespaceData"), testDate, ContentModel.PROP_TITLE, "Test Title value", ContentModel.PROP_DESCRIPTION, "Test Description value")); assertEquals("Test Title value", cmFolder.getCmTitle()); assertEquals("Test Description value", cmFolder.getCmDescription()); assertNull(cmFolder.getRef()); assertEquals(testDate, cmFolder.getCustomNamespaceData()); }
|
AnnotationScanner { public static String getName(AccessibleObject member) { if (member instanceof Field) { return ((Field)member).getName(); } else if (member instanceof Method) { Method method = (Method)member; String name = method.getName(); if (!name.startsWith("set")) { return null; } return lowerCamelCase(name.substring(3)); } throw new IllegalArgumentException(); } List<AccessibleObject> getJpaAnnotatedMembers(Class<?> c, Class<? extends Annotation> annotation); static String getName(AccessibleObject member); static Class<?> getType(AccessibleObject member); }
|
@Test public void getNameTest() throws NoSuchMethodException, SecurityException, NoSuchFieldException { Assert.assertEquals("em", AnnotationScanner.getName(setEmMethod)); Assert.assertEquals("em", AnnotationScanner.getName(emField)); Assert.assertEquals("emf", AnnotationScanner.getName(setEmfMethod)); Assert.assertEquals("emf", AnnotationScanner.getName(emfField)); }
|
AnnotationScanner { public static Class<?> getType(AccessibleObject member) { if (member instanceof Field) { return ((Field)member).getType(); } else if (member instanceof Method) { return ((Method)member).getParameterTypes()[0]; } throw new IllegalArgumentException(); } List<AccessibleObject> getJpaAnnotatedMembers(Class<?> c, Class<? extends Annotation> annotation); static String getName(AccessibleObject member); static Class<?> getType(AccessibleObject member); }
|
@Test public void getTypeTest() { Assert.assertEquals(EntityManager.class, AnnotationScanner.getType(setEmMethod)); Assert.assertEquals(EntityManager.class, AnnotationScanner.getType(emField)); Assert.assertEquals(EntityManagerFactory.class, AnnotationScanner.getType(setEmfMethod)); Assert.assertEquals(EntityManagerFactory.class, AnnotationScanner.getType(emfField)); }
|
AnnotationScanner { public List<AccessibleObject> getJpaAnnotatedMembers(Class<?> c, Class<? extends Annotation> annotation) { final List<AccessibleObject> jpaAnnotated = new ArrayList<AccessibleObject>(); for (Class<?> cl = c; cl != Object.class && cl != null; cl = cl.getSuperclass()) { parseClass(annotation, jpaAnnotated, cl); } return jpaAnnotated; } List<AccessibleObject> getJpaAnnotatedMembers(Class<?> c, Class<? extends Annotation> annotation); static String getName(AccessibleObject member); static Class<?> getType(AccessibleObject member); }
|
@Test public void getFactoryTest() { AnnotationScanner scanner = new AnnotationScanner(); List<AccessibleObject> members = scanner.getJpaAnnotatedMembers(TestInterface.class, PersistenceUnit.class); Assert.assertEquals(0, members.size()); }
|
EMFTracker extends ServiceTracker { public static EntityManager createProxy(final EmSupplier emSupplier) { ClassLoader loader = EntityManager.class.getClassLoader(); Class<?>[] ifAr = { EntityManager.class }; return (EntityManager)Proxy.newProxyInstance(loader, ifAr, new EmProxy(emSupplier)); } @SuppressWarnings("unchecked") EMFTracker(BundleContext context, Coordinator coordinator); @SuppressWarnings("unchecked") @Override Object addingService(ServiceReference reference); @Override void removedService(ServiceReference reference, Object trackedO); static EntityManager createProxy(final EmSupplier emSupplier); }
|
@Test(expected=PersistenceException.class) public void testOriginalExceptionThrown() { EmSupplier emSupplier = mock(EmSupplier.class); EntityManager em = mock(EntityManager.class); when(emSupplier.get()).thenReturn(em); doThrow(new PersistenceException("Message")).when(em).flush(); EntityManager emProxy = EMFTracker.createProxy(emSupplier); emProxy.flush(); }
|
DataSourceTracker extends ServiceTracker<DataSource, DataSource> { static Filter createFilter(BundleContext context, String dsName, String puName) { if (dsName == null) { throw new IllegalArgumentException("No DataSource supplied in persistence.xml"); } String subFilter = getSubFilter(dsName); String filter = String.format("(&(objectClass=%s)%s)", DataSource.class.getName(), subFilter); LOGGER.info("Tracking DataSource for punit " + puName + " with filter " + filter); try { return context.createFilter(filter); } catch (InvalidSyntaxException e) { throw new IllegalArgumentException(e); } } DataSourceTracker(BundleContext context, AriesEntityManagerFactoryBuilder builder,
String dsName); @Override DataSource addingService(ServiceReference<DataSource> reference); @Override void removedService(ServiceReference<DataSource> reference, DataSource ds); }
|
@Test public void testCreateFilterFull() throws InvalidSyntaxException { BundleContext context = mock(BundleContext.class); DataSourceTracker.createFilter(context, "osgi:service/javax.sql.DataSource/(osgi.jndi.service.name=tasklist)", "test"); verify(context, atLeastOnce()).createFilter(Mockito.eq("(&(objectClass=javax.sql.DataSource)(osgi.jndi.service.name=tasklist))")); }
@Test public void testCreateFilterSimple() throws InvalidSyntaxException { BundleContext context = mock(BundleContext.class); DataSourceTracker.createFilter(context, "tasklist", "test"); verify(context, atLeastOnce()).createFilter(Mockito.eq("(&(objectClass=javax.sql.DataSource)(osgi.jndi.service.name=tasklist))")); }
|
ManagedEMF implements ManagedService { @Override public void updated(Dictionary<String, ?> properties) throws ConfigurationException { if(properties == null) { if(configured.getAndSet(false)) { if (LOGGER.isDebugEnabled()) { LOGGER.debug("The configuration has been deleted for persistence unit {}. Destroying the EMF", pUnitName); } builder.closeEMF(); } else { if (LOGGER.isDebugEnabled()) { LOGGER.debug("Ignoring the unset configuration for persistence unit {}", pUnitName); } return; } } Map<String, Object> overrides = (properties != null) ? asMap(properties) : null; LOGGER.info("Configuration received for persistence unit {}", pUnitName); if (LOGGER.isDebugEnabled()) { LOGGER.debug("Using properties override {}", overrides); } builder.createEntityManagerFactory(overrides); configured.set(true); } ManagedEMF(AriesEntityManagerFactoryBuilder builder, String name); @Override void updated(Dictionary<String, ?> properties); }
|
@Test public void testEmfWithoutProps() throws InvalidSyntaxException, ConfigurationException { ManagedEMF emf = new ManagedEMF(builder, "test"); emf.updated(null); Mockito.verifyZeroInteractions(builder); Hashtable<String, Object> props = new Hashtable<String, Object>(); emf.updated(props); verify(builder).createEntityManagerFactory(props); emf.updated(null); verify(builder).closeEMF(); }
@Test public void testEmfWithProps() throws InvalidSyntaxException, ConfigurationException { ManagedEMF emf = new ManagedEMF(builder, "test"); Dictionary<String, Object> props = new Hashtable<String, Object>(); props.put("hibernate.hbm2ddl.auto", "create-drop"); emf.updated(props); verify(builder).createEntityManagerFactory(Collections.<String, Object>singletonMap( "hibernate.hbm2ddl.auto", "create-drop")); }
|
Scheduler { @NonNull public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit) { final Worker w = createWorker(); final Runnable decoratedRun = RxJavaCommonPlugins.onSchedule(run); PeriodicDirectTask periodicTask = new PeriodicDirectTask(decoratedRun, w); Disposable d = w.schedulePeriodically(periodicTask, initialDelay, period, unit); if (d == REJECTED) { return d; } return periodicTask; } static long clockDriftTolerance(); @NonNull abstract Worker createWorker(); long now(@NonNull TimeUnit unit); void start(); void shutdown(); @NonNull Disposable scheduleDirect(@NonNull Runnable run); @NonNull Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit); @NonNull Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit); static final Disposable REJECTED; }
|
@Test public void defaultPeriodicTask() { final int[] count = { 0 }; TestScheduler scheduler = new TestScheduler(); Disposable d = scheduler.schedulePeriodicallyDirect(new Runnable() { @Override public void run() { count[0]++; } }, 100, 100, TimeUnit.MILLISECONDS); assertEquals(0, count[0]); assertFalse(d.isDisposed()); scheduler.advanceTimeBy(200, TimeUnit.MILLISECONDS); assertEquals(2, count[0]); d.dispose(); assertTrue(d.isDisposed()); scheduler.advanceTimeBy(200, TimeUnit.MILLISECONDS); assertEquals(2, count[0]); }
@Test(expected = TestException.class) public void periodicDirectThrows() { TestScheduler scheduler = new TestScheduler(); scheduler.schedulePeriodicallyDirect(new Runnable() { @Override public void run() { throw new TestException(); } }, 100, 100, TimeUnit.MILLISECONDS); scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS); }
@Test public void disposePeriodicDirect() { final int[] count = { 0 }; TestScheduler scheduler = new TestScheduler(); Disposable d = scheduler.schedulePeriodicallyDirect(new Runnable() { @Override public void run() { count[0]++; } }, 100, 100, TimeUnit.MILLISECONDS); d.dispose(); assertEquals(0, count[0]); assertTrue(d.isDisposed()); scheduler.advanceTimeBy(200, TimeUnit.MILLISECONDS); assertEquals(0, count[0]); assertTrue(d.isDisposed()); }
@Test public void disposeSelfPeriodicDirect() { final int[] count = { 0 }; TestScheduler scheduler = new TestScheduler(); final SequentialDisposable sd = new SequentialDisposable(); Disposable d = scheduler.schedulePeriodicallyDirect(new Runnable() { @Override public void run() { count[0]++; sd.dispose(); } }, 100, 100, TimeUnit.MILLISECONDS); sd.set(d); assertEquals(0, count[0]); assertFalse(d.isDisposed()); scheduler.advanceTimeBy(400, TimeUnit.MILLISECONDS); assertEquals(1, count[0]); assertTrue(d.isDisposed()); }
@Test public void periodicDirectTaskRace() { final TestScheduler scheduler = new TestScheduler(); for (int i = 0; i < 100; i++) { final Disposable d = scheduler.schedulePeriodicallyDirect(Functions.EMPTY_RUNNABLE, 1, 1, TimeUnit.MILLISECONDS); Runnable r1 = new Runnable() { @Override public void run() { d.dispose(); } }; Runnable r2 = new Runnable() { @Override public void run() { scheduler.advanceTimeBy(1, TimeUnit.SECONDS); } }; TestCommonHelper.race(r1, r2, Schedulers.io()); } }
@Test public void periodicDirectTaskRaceIO() throws Exception { final Scheduler scheduler = Schedulers.io(); for (int i = 0; i < 100; i++) { final Disposable d = scheduler.schedulePeriodicallyDirect( Functions.EMPTY_RUNNABLE, 0, 0, TimeUnit.MILLISECONDS); Thread.sleep(1); d.dispose(); } }
@Test public void defaultSchedulePeriodicallyDirectRejects() { Scheduler s = new Scheduler() { @NonNull @Override public Worker createWorker() { return new Worker() { @NonNull @Override public Disposable schedule(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) { return Scheduler.REJECTED; } @Override public void dispose() { } @Override public boolean isDisposed() { return false; } }; } }; assertSame(Scheduler.REJECTED, s.schedulePeriodicallyDirect(Functions.EMPTY_RUNNABLE, 1, 1, TimeUnit.MILLISECONDS)); }
|
RxJavaCommonPlugins { @NonNull public static Scheduler createSingleScheduler(@NonNull ThreadFactory threadFactory) { return new SingleScheduler(ObjectHelper.requireNonNull(threadFactory, "threadFactory is null")); } private RxJavaCommonPlugins(); static void lockdown(); static boolean isLockdown(); static void setFailOnNonBlockingScheduler(boolean enable); static boolean isFailOnNonBlockingScheduler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getComputationSchedulerHandler(); @Nullable static Consumer<? super Throwable> getErrorHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitComputationSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitIoSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitNewThreadSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitSingleSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getIoSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getNewThreadSchedulerHandler(); @Nullable static Function<? super Runnable, ? extends Runnable> getScheduleHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getSingleSchedulerHandler(); @NonNull static Scheduler initComputationScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initNewThreadScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initSingleScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler onComputationScheduler(@NonNull Scheduler defaultScheduler); static void onError(@NonNull Throwable error); @NonNull static Scheduler onIoScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Scheduler onNewThreadScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Runnable onSchedule(@NonNull Runnable run); @NonNull static Scheduler onSingleScheduler(@NonNull Scheduler defaultScheduler); static void reset(); static void setComputationSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setErrorHandler(@Nullable Consumer<? super Throwable> handler); static void setInitComputationSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitIoSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitNewThreadSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitSingleSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setIoSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setNewThreadSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setScheduleHandler(@Nullable Function<? super Runnable, ? extends Runnable> handler); static void setSingleSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static boolean onBeforeBlocking(); static void setOnBeforeBlocking(@Nullable BooleanSupplier handler); @Nullable static BooleanSupplier getOnBeforeBlocking(); @NonNull static Scheduler createComputationScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createIoScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createNewThreadScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createSingleScheduler(@NonNull ThreadFactory threadFactory); }
|
@Test public void createSingleScheduler() { final String name = "SingleSchedulerTest"; ThreadFactory factory = new ThreadFactory() { @Override public Thread newThread(Runnable r) { return new Thread(r, name); } }; final Scheduler customScheduler = RxJavaCommonPlugins.createSingleScheduler(factory); RxJavaCommonPlugins.setSingleSchedulerHandler(new Function<Scheduler, Scheduler>() { @Override public Scheduler apply(Scheduler scheduler) throws Exception { return customScheduler; } }); try { verifyThread(Schedulers.single(), name); } finally { customScheduler.shutdown(); RxJavaCommonPlugins.reset(); } }
|
RxJavaCommonPlugins { public static boolean onBeforeBlocking() { BooleanSupplier f = onBeforeBlocking; if (f != null) { try { return f.getAsBoolean(); } catch (Throwable ex) { throw ExceptionHelper.wrapOrThrow(ex); } } return false; } private RxJavaCommonPlugins(); static void lockdown(); static boolean isLockdown(); static void setFailOnNonBlockingScheduler(boolean enable); static boolean isFailOnNonBlockingScheduler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getComputationSchedulerHandler(); @Nullable static Consumer<? super Throwable> getErrorHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitComputationSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitIoSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitNewThreadSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitSingleSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getIoSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getNewThreadSchedulerHandler(); @Nullable static Function<? super Runnable, ? extends Runnable> getScheduleHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getSingleSchedulerHandler(); @NonNull static Scheduler initComputationScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initNewThreadScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initSingleScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler onComputationScheduler(@NonNull Scheduler defaultScheduler); static void onError(@NonNull Throwable error); @NonNull static Scheduler onIoScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Scheduler onNewThreadScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Runnable onSchedule(@NonNull Runnable run); @NonNull static Scheduler onSingleScheduler(@NonNull Scheduler defaultScheduler); static void reset(); static void setComputationSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setErrorHandler(@Nullable Consumer<? super Throwable> handler); static void setInitComputationSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitIoSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitNewThreadSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitSingleSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setIoSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setNewThreadSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setScheduleHandler(@Nullable Function<? super Runnable, ? extends Runnable> handler); static void setSingleSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static boolean onBeforeBlocking(); static void setOnBeforeBlocking(@Nullable BooleanSupplier handler); @Nullable static BooleanSupplier getOnBeforeBlocking(); @NonNull static Scheduler createComputationScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createIoScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createNewThreadScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createSingleScheduler(@NonNull ThreadFactory threadFactory); }
|
@Test public void onBeforeBlocking() { try { RxJavaCommonPlugins.setOnBeforeBlocking(new BooleanSupplier() { @Override public boolean getAsBoolean() throws Exception { throw new IllegalArgumentException(); } }); try { RxJavaCommonPlugins.onBeforeBlocking(); fail("Should have thrown"); } catch (IllegalArgumentException ex) { } } finally { RxJavaCommonPlugins.reset(); } }
|
RxJavaCommonPlugins { static boolean isBug(Throwable error) { if (error instanceof OnErrorNotImplementedException) { return true; } if (error instanceof MissingBackpressureException) { return true; } if (error instanceof IllegalStateException) { return true; } if (error instanceof NullPointerException) { return true; } if (error instanceof IllegalArgumentException) { return true; } if (error instanceof CompositeException) { return true; } return false; } private RxJavaCommonPlugins(); static void lockdown(); static boolean isLockdown(); static void setFailOnNonBlockingScheduler(boolean enable); static boolean isFailOnNonBlockingScheduler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getComputationSchedulerHandler(); @Nullable static Consumer<? super Throwable> getErrorHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitComputationSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitIoSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitNewThreadSchedulerHandler(); @Nullable static Function<? super Callable<Scheduler>, ? extends Scheduler> getInitSingleSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getIoSchedulerHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getNewThreadSchedulerHandler(); @Nullable static Function<? super Runnable, ? extends Runnable> getScheduleHandler(); @Nullable static Function<? super Scheduler, ? extends Scheduler> getSingleSchedulerHandler(); @NonNull static Scheduler initComputationScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initNewThreadScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler initSingleScheduler(@NonNull Callable<Scheduler> defaultScheduler); @NonNull static Scheduler onComputationScheduler(@NonNull Scheduler defaultScheduler); static void onError(@NonNull Throwable error); @NonNull static Scheduler onIoScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Scheduler onNewThreadScheduler(@NonNull Scheduler defaultScheduler); @NonNull static Runnable onSchedule(@NonNull Runnable run); @NonNull static Scheduler onSingleScheduler(@NonNull Scheduler defaultScheduler); static void reset(); static void setComputationSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setErrorHandler(@Nullable Consumer<? super Throwable> handler); static void setInitComputationSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitIoSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitNewThreadSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setInitSingleSchedulerHandler(@Nullable Function<? super Callable<Scheduler>, ? extends Scheduler> handler); static void setIoSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setNewThreadSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static void setScheduleHandler(@Nullable Function<? super Runnable, ? extends Runnable> handler); static void setSingleSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler); static boolean onBeforeBlocking(); static void setOnBeforeBlocking(@Nullable BooleanSupplier handler); @Nullable static BooleanSupplier getOnBeforeBlocking(); @NonNull static Scheduler createComputationScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createIoScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createNewThreadScheduler(@NonNull ThreadFactory threadFactory); @NonNull static Scheduler createSingleScheduler(@NonNull ThreadFactory threadFactory); }
|
@Test public void isBug() { assertFalse(RxJavaCommonPlugins.isBug(new RuntimeException())); assertFalse(RxJavaCommonPlugins.isBug(new IOException())); assertFalse(RxJavaCommonPlugins.isBug(new InterruptedException())); assertFalse(RxJavaCommonPlugins.isBug(new InterruptedIOException())); assertTrue(RxJavaCommonPlugins.isBug(new NullPointerException())); assertTrue(RxJavaCommonPlugins.isBug(new IllegalArgumentException())); assertTrue(RxJavaCommonPlugins.isBug(new IllegalStateException())); assertTrue(RxJavaCommonPlugins.isBug(new MissingBackpressureException())); assertTrue(RxJavaCommonPlugins.isBug(new ProtocolViolationException(""))); assertTrue(RxJavaCommonPlugins.isBug(new UndeliverableException(new TestException()))); assertTrue(RxJavaCommonPlugins.isBug(new CompositeException(new TestException()))); assertTrue(RxJavaCommonPlugins.isBug(new OnErrorNotImplementedException(new TestException()))); }
|
DisposableCompletableObserver implements CompletableObserver, Disposable { @Override public final boolean isDisposed() { return s.get() == DisposableHelper.DISPOSED; } @Override final void onSubscribe(@NonNull Disposable s); @Override final boolean isDisposed(); @Override final void dispose(); }
|
@Test public void normal() { TestCompletable tc = new TestCompletable(); assertFalse(tc.isDisposed()); assertEquals(0, tc.start); assertEquals(0, tc.complete); assertTrue(tc.errors.isEmpty()); Completable.complete().subscribe(tc); assertFalse(tc.isDisposed()); assertEquals(1, tc.start); assertEquals(1, tc.complete); assertTrue(tc.errors.isEmpty()); }
|
DisposableCompletableObserver implements CompletableObserver, Disposable { @Override public final void dispose() { DisposableHelper.dispose(s); } @Override final void onSubscribe(@NonNull Disposable s); @Override final boolean isDisposed(); @Override final void dispose(); }
|
@Test public void dispose() { TestCompletable tc = new TestCompletable(); tc.dispose(); assertTrue(tc.isDisposed()); Disposable d = Disposables.empty(); tc.onSubscribe(d); assertTrue(d.isDisposed()); assertEquals(0, tc.start); }
|
SerializedObserver implements Observer<T>, Disposable { public SerializedObserver(@NonNull Observer<? super T> actual) { this(actual, false); } SerializedObserver(@NonNull Observer<? super T> actual); SerializedObserver(@NonNull Observer<? super T> actual, boolean delayError); @Override void onSubscribe(@NonNull Disposable s); @Override void dispose(); @Override boolean isDisposed(); @Override void onNext(@NonNull T t); @Override void onError(@NonNull Throwable t); @Override void onComplete(); }
|
@Test public void testMultiThreadedBasic() { TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three"); Observable<String> w = Observable.unsafeCreate(onSubscribe); BusyObserver busySubscriber = new BusyObserver(); Observer<String> aw = serializedObserver(busySubscriber); w.subscribe(aw); onSubscribe.waitToFinish(); assertEquals(3, busySubscriber.onNextCount.get()); assertFalse(busySubscriber.onError); assertTrue(busySubscriber.onComplete); assertTrue(onSubscribe.maxConcurrentThreads.get() > 1); assertEquals(1, busySubscriber.maxConcurrentThreads.get()); }
@Test(timeout = 1000) public void testMultiThreadedWithNPE() throws InterruptedException { TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three", null); Observable<String> w = Observable.unsafeCreate(onSubscribe); BusyObserver busySubscriber = new BusyObserver(); Observer<String> aw = serializedObserver(busySubscriber); w.subscribe(aw); onSubscribe.waitToFinish(); busySubscriber.terminalEvent.await(); System.out.println("OnSubscribe maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get() + " Observer maxConcurrentThreads: " + busySubscriber.maxConcurrentThreads.get()); assertTrue(busySubscriber.onNextCount.get() < 4); assertTrue(busySubscriber.onError); assertFalse(busySubscriber.onComplete); assertTrue(onSubscribe.maxConcurrentThreads.get() > 1); assertEquals(1, busySubscriber.maxConcurrentThreads.get()); }
@Test public void testMultiThreadedWithNPEinMiddle() { int n = 10; for (int i = 0; i < n; i++) { TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine"); Observable<String> w = Observable.unsafeCreate(onSubscribe); BusyObserver busySubscriber = new BusyObserver(); Observer<String> aw = serializedObserver(busySubscriber); w.subscribe(aw); onSubscribe.waitToFinish(); System.out.println("OnSubscribe maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get() + " Observer maxConcurrentThreads: " + busySubscriber.maxConcurrentThreads.get()); assertTrue(onSubscribe.maxConcurrentThreads.get() > 1); assertEquals(1, busySubscriber.maxConcurrentThreads.get()); System.out.println("onNext count: " + busySubscriber.onNextCount.get()); assertFalse(busySubscriber.onComplete); assertTrue(busySubscriber.onError); assertTrue(busySubscriber.onNextCount.get() < 9); } }
@Test public void runOutOfOrderConcurrencyTest() { ExecutorService tp = Executors.newFixedThreadPool(20); try { TestConcurrencySubscriber tw = new TestConcurrencySubscriber(); Observer<String> w = serializedObserver(new SafeObserver<String>(tw)); Future<?> f1 = tp.submit(new OnNextThread(w, 12000)); Future<?> f2 = tp.submit(new OnNextThread(w, 5000)); Future<?> f3 = tp.submit(new OnNextThread(w, 75000)); Future<?> f4 = tp.submit(new OnNextThread(w, 13500)); Future<?> f5 = tp.submit(new OnNextThread(w, 22000)); Future<?> f6 = tp.submit(new OnNextThread(w, 15000)); Future<?> f7 = tp.submit(new OnNextThread(w, 7500)); Future<?> f8 = tp.submit(new OnNextThread(w, 23500)); Future<?> f10 = tp.submit(new CompletionThread(w, TestConcurrencySubscriberEvent.onComplete, f1, f2, f3, f4)); try { Thread.sleep(1); } catch (InterruptedException e) { } Future<?> f11 = tp.submit(new CompletionThread(w, TestConcurrencySubscriberEvent.onComplete, f4, f6, f7)); Future<?> f12 = tp.submit(new CompletionThread(w, TestConcurrencySubscriberEvent.onComplete, f4, f6, f7)); Future<?> f13 = tp.submit(new CompletionThread(w, TestConcurrencySubscriberEvent.onComplete, f4, f6, f7)); Future<?> f14 = tp.submit(new CompletionThread(w, TestConcurrencySubscriberEvent.onComplete, f4, f6, f7)); Future<?> f15 = tp.submit(new CompletionThread(w, TestConcurrencySubscriberEvent.onError, f1, f2, f3, f4)); Future<?> f16 = tp.submit(new CompletionThread(w, TestConcurrencySubscriberEvent.onError, f1, f2, f3, f4)); Future<?> f17 = tp.submit(new CompletionThread(w, TestConcurrencySubscriberEvent.onError, f1, f2, f3, f4)); Future<?> f18 = tp.submit(new CompletionThread(w, TestConcurrencySubscriberEvent.onError, f1, f2, f3, f4)); waitOnThreads(f1, f2, f3, f4, f5, f6, f7, f8, f10, f11, f12, f13, f14, f15, f16, f17, f18); @SuppressWarnings("unused") int numNextEvents = tw.assertEvents(null); } catch (Throwable e) { fail("Concurrency test failed: " + e.getMessage()); e.printStackTrace(); } finally { tp.shutdown(); try { tp.awaitTermination(5000, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { e.printStackTrace(); } } }
|
SerializedObserver implements Observer<T>, Disposable { @Override public void onNext(@NonNull T t) { if (done) { return; } if (t == null) { s.dispose(); onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources.")); return; } synchronized (this) { if (done) { return; } if (emitting) { AppendOnlyLinkedArrayList<Object> q = queue; if (q == null) { q = new AppendOnlyLinkedArrayList<Object>(QUEUE_LINK_SIZE); queue = q; } q.add(NotificationLite.next(t)); return; } emitting = true; } actual.onNext(t); emitLoop(); } SerializedObserver(@NonNull Observer<? super T> actual); SerializedObserver(@NonNull Observer<? super T> actual, boolean delayError); @Override void onSubscribe(@NonNull Disposable s); @Override void dispose(); @Override boolean isDisposed(); @Override void onNext(@NonNull T t); @Override void onError(@NonNull Throwable t); @Override void onComplete(); }
|
@Test @Ignore("Null values not permitted") public void testSerializeNull() { final AtomicReference<Observer<Integer>> serial = new AtomicReference<Observer<Integer>>(); TestObserver<Integer> to = new TestObserver<Integer>() { @Override public void onNext(Integer t) { if (t != null && t == 0) { serial.get().onNext(null); } super.onNext(t); } }; SerializedObserver<Integer> sobs = new SerializedObserver<Integer>(to); serial.set(sobs); sobs.onNext(0); to.assertValues(0, null); }
@Test @Ignore("Null values no longer permitted") public void testSerializeDrainPhaseThrows() { final AtomicReference<Observer<Integer>> serial = new AtomicReference<Observer<Integer>>(); TestObserver<Integer> to = new TestObserver<Integer>() { @Override public void onNext(Integer t) { if (t != null && t == 0) { serial.get().onNext(null); } else if (t == null) { throw new TestException(); } super.onNext(t); } }; SerializedObserver<Integer> sobs = new SerializedObserver<Integer>(to); serial.set(sobs); sobs.onNext(0); to.assertError(TestException.class); to.assertNotComplete(); }
|
Scheduler { @NonNull public Disposable scheduleDirect(@NonNull Runnable run) { return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS); } static long clockDriftTolerance(); @NonNull abstract Worker createWorker(); long now(@NonNull TimeUnit unit); void start(); void shutdown(); @NonNull Disposable scheduleDirect(@NonNull Runnable run); @NonNull Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit); @NonNull Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit); static final Disposable REJECTED; }
|
@Test public void customScheduleDirectDisposed() { CustomScheduler scheduler = new CustomScheduler(); Disposable d = scheduler.scheduleDirect(Functions.EMPTY_RUNNABLE, 1, TimeUnit.MINUTES); assertFalse(d.isDisposed()); d.dispose(); assertTrue(d.isDisposed()); }
@Test public void scheduleDirect() { final int[] count = { 0 }; TestScheduler scheduler = new TestScheduler(); scheduler.scheduleDirect(new Runnable() { @Override public void run() { count[0]++; } }, 100, TimeUnit.MILLISECONDS); assertEquals(0, count[0]); scheduler.advanceTimeBy(200, TimeUnit.MILLISECONDS); assertEquals(1, count[0]); }
@Test public void scheduleDirectThrows() throws Exception { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { Schedulers.io().scheduleDirect(new Runnable() { @Override public void run() { throw new TestException(); } }); Thread.sleep(250); assertEquals(1, list.size()); TestCommonHelper.assertUndeliverable(list, 0, TestException.class, null); } finally { RxJavaCommonPlugins.reset(); } }
|
SerializedObserver implements Observer<T>, Disposable { @Override public void dispose() { s.dispose(); } SerializedObserver(@NonNull Observer<? super T> actual); SerializedObserver(@NonNull Observer<? super T> actual, boolean delayError); @Override void onSubscribe(@NonNull Disposable s); @Override void dispose(); @Override boolean isDisposed(); @Override void onNext(@NonNull T t); @Override void onError(@NonNull Throwable t); @Override void onComplete(); }
|
@Test public void dispose() { TestObserver<Integer> ts = new TestObserver<Integer>(); SerializedObserver<Integer> so = new SerializedObserver<Integer>(ts); Disposable d = Disposables.empty(); so.onSubscribe(d); assertFalse(so.isDisposed()); ts.cancel(); assertTrue(so.isDisposed()); assertTrue(d.isDisposed()); }
|
ResourceSingleObserver implements SingleObserver<T>, Disposable { public final void add(@NonNull Disposable resource) { ObjectHelper.requireNonNull(resource, "resource is null"); resources.add(resource); } final void add(@NonNull Disposable resource); @Override final void onSubscribe(@NonNull Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }
|
@Test(expected = NullPointerException.class) public void nullResource() { TestResourceSingleObserver<Integer> rso = new TestResourceSingleObserver<Integer>(); rso.add(null); }
|
ResourceSingleObserver implements SingleObserver<T>, Disposable { @Override public final boolean isDisposed() { return DisposableHelper.isDisposed(s.get()); } final void add(@NonNull Disposable resource); @Override final void onSubscribe(@NonNull Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }
|
@Test public void normal() { TestResourceSingleObserver<Integer> rso = new TestResourceSingleObserver<Integer>(); assertFalse(rso.isDisposed()); assertEquals(0, rso.start); assertNull(rso.value); assertTrue(rso.errors.isEmpty()); Single.just(1).subscribe(rso); assertTrue(rso.isDisposed()); assertEquals(1, rso.start); assertEquals(Integer.valueOf(1), rso.value); assertTrue(rso.errors.isEmpty()); }
@Test public void error() { TestResourceSingleObserver<Integer> rso = new TestResourceSingleObserver<Integer>(); assertFalse(rso.isDisposed()); assertEquals(0, rso.start); assertNull(rso.value); assertTrue(rso.errors.isEmpty()); final RuntimeException error = new RuntimeException("error"); Single.<Integer>error(error).subscribe(rso); assertTrue(rso.isDisposed()); assertEquals(1, rso.start); assertNull(rso.value); assertEquals(1, rso.errors.size()); assertTrue(rso.errors.contains(error)); }
|
ResourceSingleObserver implements SingleObserver<T>, Disposable { @Override public final void dispose() { if (DisposableHelper.dispose(s)) { resources.dispose(); } } final void add(@NonNull Disposable resource); @Override final void onSubscribe(@NonNull Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }
|
@Test public void dispose() { TestResourceSingleObserver<Integer> rso = new TestResourceSingleObserver<Integer>(); rso.dispose(); Disposable d = Disposables.empty(); rso.onSubscribe(d); assertTrue(d.isDisposed()); assertEquals(0, rso.start); }
|
ResourceMaybeObserver implements MaybeObserver<T>, Disposable { public final void add(@NonNull Disposable resource) { ObjectHelper.requireNonNull(resource, "resource is null"); resources.add(resource); } final void add(@NonNull Disposable resource); @Override final void onSubscribe(@NonNull Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }
|
@Test(expected = NullPointerException.class) public void nullResource() { TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<Integer>(); rmo.add(null); }
|
ResourceMaybeObserver implements MaybeObserver<T>, Disposable { @Override public final boolean isDisposed() { return DisposableHelper.isDisposed(s.get()); } final void add(@NonNull Disposable resource); @Override final void onSubscribe(@NonNull Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }
|
@Test public void normal() { TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<Integer>(); assertFalse(rmo.isDisposed()); assertEquals(0, rmo.start); assertNull(rmo.value); assertTrue(rmo.errors.isEmpty()); Maybe.just(1).subscribe(rmo); assertTrue(rmo.isDisposed()); assertEquals(1, rmo.start); assertEquals(Integer.valueOf(1), rmo.value); assertEquals(0, rmo.complete); assertTrue(rmo.errors.isEmpty()); }
@Test public void empty() { TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<Integer>(); assertFalse(rmo.isDisposed()); assertEquals(0, rmo.start); assertNull(rmo.value); assertTrue(rmo.errors.isEmpty()); Maybe.<Integer>empty().subscribe(rmo); assertTrue(rmo.isDisposed()); assertEquals(1, rmo.start); assertNull(rmo.value); assertEquals(1, rmo.complete); assertTrue(rmo.errors.isEmpty()); }
@Test public void error() { TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<Integer>(); assertFalse(rmo.isDisposed()); assertEquals(0, rmo.start); assertNull(rmo.value); assertTrue(rmo.errors.isEmpty()); final RuntimeException error = new RuntimeException("error"); Maybe.<Integer>error(error).subscribe(rmo); assertTrue(rmo.isDisposed()); assertEquals(1, rmo.start); assertNull(rmo.value); assertEquals(0, rmo.complete); assertEquals(1, rmo.errors.size()); assertTrue(rmo.errors.contains(error)); }
|
Exceptions { public static void throwIfFatal(@NonNull Throwable t) { if (t instanceof VirtualMachineError) { throw (VirtualMachineError) t; } else if (t instanceof ThreadDeath) { throw (ThreadDeath) t; } else if (t instanceof LinkageError) { throw (LinkageError) t; } } private Exceptions(); @NonNull static RuntimeException propagate(@NonNull Throwable t); static void throwIfFatal(@NonNull Throwable t); }
|
@Test public void manualThrowIfFatal() { try { Exceptions.throwIfFatal(new ThreadDeath()); fail("Didn't throw fatal exception"); } catch (ThreadDeath ex) { } try { Exceptions.throwIfFatal(new LinkageError()); fail("Didn't throw fatal error"); } catch (LinkageError ex) { } try { ExceptionHelper.wrapOrThrow(new LinkageError()); fail("Didn't propagate Error"); } catch (LinkageError ex) { } }
|
ResourceMaybeObserver implements MaybeObserver<T>, Disposable { @Override public final void dispose() { if (DisposableHelper.dispose(s)) { resources.dispose(); } } final void add(@NonNull Disposable resource); @Override final void onSubscribe(@NonNull Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }
|
@Test public void dispose() { TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<Integer>(); rmo.dispose(); Disposable d = Disposables.empty(); rmo.onSubscribe(d); assertTrue(d.isDisposed()); assertEquals(0, rmo.start); }
|
DisposableObserver implements Observer<T>, Disposable { @Override public final boolean isDisposed() { return s.get() == DisposableHelper.DISPOSED; } @Override final void onSubscribe(@NonNull Disposable s); @Override final boolean isDisposed(); @Override final void dispose(); }
|
@Test public void normal() { TestDisposableObserver<Integer> tc = new TestDisposableObserver<Integer>(); assertFalse(tc.isDisposed()); assertEquals(0, tc.start); assertTrue(tc.values.isEmpty()); assertTrue(tc.errors.isEmpty()); Observable.just(1).subscribe(tc); assertFalse(tc.isDisposed()); assertEquals(1, tc.start); assertEquals(1, tc.values.get(0).intValue()); assertTrue(tc.errors.isEmpty()); }
|
DisposableObserver implements Observer<T>, Disposable { @Override public final void dispose() { DisposableHelper.dispose(s); } @Override final void onSubscribe(@NonNull Disposable s); @Override final boolean isDisposed(); @Override final void dispose(); }
|
@Test public void dispose() { TestDisposableObserver<Integer> tc = new TestDisposableObserver<Integer>(); assertFalse(tc.isDisposed()); tc.dispose(); assertTrue(tc.isDisposed()); Disposable d = Disposables.empty(); tc.onSubscribe(d); assertTrue(d.isDisposed()); assertEquals(0, tc.start); }
|
ResourceCompletableObserver implements CompletableObserver, Disposable { public final void add(@NonNull Disposable resource) { ObjectHelper.requireNonNull(resource, "resource is null"); resources.add(resource); } final void add(@NonNull Disposable resource); @Override final void onSubscribe(@NonNull Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }
|
@Test(expected = NullPointerException.class) public void nullResource() { TestResourceCompletableObserver rco = new TestResourceCompletableObserver(); rco.add(null); }
|
ResourceCompletableObserver implements CompletableObserver, Disposable { @Override public final boolean isDisposed() { return DisposableHelper.isDisposed(s.get()); } final void add(@NonNull Disposable resource); @Override final void onSubscribe(@NonNull Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }
|
@Test public void normal() { TestResourceCompletableObserver rco = new TestResourceCompletableObserver(); assertFalse(rco.isDisposed()); assertEquals(0, rco.start); assertTrue(rco.errors.isEmpty()); Completable.complete().subscribe(rco); assertTrue(rco.isDisposed()); assertEquals(1, rco.start); assertEquals(1, rco.complete); assertTrue(rco.errors.isEmpty()); }
@Test public void error() { TestResourceCompletableObserver rco = new TestResourceCompletableObserver(); assertFalse(rco.isDisposed()); assertEquals(0, rco.start); assertTrue(rco.errors.isEmpty()); final RuntimeException error = new RuntimeException("error"); Completable.error(error).subscribe(rco); assertTrue(rco.isDisposed()); assertEquals(1, rco.start); assertEquals(0, rco.complete); assertEquals(1, rco.errors.size()); assertTrue(rco.errors.contains(error)); }
|
ResourceCompletableObserver implements CompletableObserver, Disposable { @Override public final void dispose() { if (DisposableHelper.dispose(s)) { resources.dispose(); } } final void add(@NonNull Disposable resource); @Override final void onSubscribe(@NonNull Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }
|
@Test public void dispose() { TestResourceCompletableObserver rco = new TestResourceCompletableObserver(); rco.dispose(); Disposable d = Disposables.empty(); rco.onSubscribe(d); assertTrue(d.isDisposed()); assertEquals(0, rco.start); }
|
ResourceObserver implements Observer<T>, Disposable { public final void add(@NonNull Disposable resource) { ObjectHelper.requireNonNull(resource, "resource is null"); resources.add(resource); } final void add(@NonNull Disposable resource); @Override final void onSubscribe(Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }
|
@Test(expected = NullPointerException.class) public void nullResource() { TestResourceObserver<Integer> ro = new TestResourceObserver<Integer>(); ro.add(null); }
|
ResourceObserver implements Observer<T>, Disposable { @Override public final boolean isDisposed() { return DisposableHelper.isDisposed(s.get()); } final void add(@NonNull Disposable resource); @Override final void onSubscribe(Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }
|
@Test public void normal() { TestResourceObserver<Integer> tc = new TestResourceObserver<Integer>(); assertFalse(tc.isDisposed()); assertEquals(0, tc.start); assertTrue(tc.values.isEmpty()); assertTrue(tc.errors.isEmpty()); Observable.just(1).subscribe(tc); assertTrue(tc.isDisposed()); assertEquals(1, tc.start); assertEquals(1, tc.values.get(0).intValue()); assertTrue(tc.errors.isEmpty()); }
@Test public void error() { TestResourceObserver<Integer> tc = new TestResourceObserver<Integer>(); assertFalse(tc.isDisposed()); assertEquals(0, tc.start); assertTrue(tc.values.isEmpty()); assertTrue(tc.errors.isEmpty()); final RuntimeException error = new RuntimeException("error"); Observable.<Integer>error(error).subscribe(tc); assertTrue(tc.isDisposed()); assertEquals(1, tc.start); assertTrue(tc.values.isEmpty()); assertEquals(1, tc.errors.size()); assertTrue(tc.errors.contains(error)); }
|
Exceptions { @NonNull public static RuntimeException propagate(@NonNull Throwable t) { throw ExceptionHelper.wrapOrThrow(t); } private Exceptions(); @NonNull static RuntimeException propagate(@NonNull Throwable t); static void throwIfFatal(@NonNull Throwable t); }
|
@Test public void manualPropagate() { try { Exceptions.propagate(new InternalError()); fail("Didn't throw exception"); } catch (InternalError ex) { } try { throw Exceptions.propagate(new IllegalArgumentException()); } catch (IllegalArgumentException ex) { } try { throw ExceptionHelper.wrapOrThrow(new IOException()); } catch (RuntimeException ex) { if (!(ex.getCause() instanceof IOException)) { fail(ex.toString() + ": should have thrown RuntimeException(IOException)"); } } }
|
ResourceObserver implements Observer<T>, Disposable { @Override public final void dispose() { if (DisposableHelper.dispose(s)) { resources.dispose(); } } final void add(@NonNull Disposable resource); @Override final void onSubscribe(Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }
|
@Test public void dispose() { TestResourceObserver<Integer> tc = new TestResourceObserver<Integer>(); tc.dispose(); Disposable d = Disposables.empty(); tc.onSubscribe(d); assertTrue(d.isDisposed()); assertEquals(0, tc.start); }
|
SafeObserver implements Observer<T>, Disposable { @Override public void onNext(@NonNull T t) { if (done) { return; } if (s == null) { onNextNoSubscription(); return; } if (t == null) { Throwable ex = new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."); try { s.dispose(); } catch (Throwable e1) { Exceptions.throwIfFatal(e1); onError(new CompositeException(ex, e1)); return; } onError(ex); return; } try { actual.onNext(t); } catch (Throwable e) { Exceptions.throwIfFatal(e); try { s.dispose(); } catch (Throwable e1) { Exceptions.throwIfFatal(e1); onError(new CompositeException(e, e1)); return; } onError(e); } } SafeObserver(@NonNull Observer<? super T> actual); @Override void onSubscribe(@NonNull Disposable s); @Override void dispose(); @Override boolean isDisposed(); @Override void onNext(@NonNull T t); @Override void onError(@NonNull Throwable t); @Override void onComplete(); }
|
@Test public void onNextFailure() { AtomicReference<Throwable> onError = new AtomicReference<Throwable>(); try { OBSERVER_ONNEXT_FAIL(onError).onNext("one"); fail("expects exception to be thrown"); } catch (Exception e) { assertNull(onError.get()); assertTrue(e instanceof SafeObserverTestException); assertEquals("onNextFail", e.getMessage()); } }
@Test public void onNextOnErrorFailure() { try { OBSERVER_ONNEXT_ONERROR_FAIL().onNext("one"); fail("expects exception to be thrown"); } catch (Exception e) { e.printStackTrace(); assertTrue(e instanceof SafeObserverTestException); assertEquals("onNextFail", e.getMessage()); } }
@Test @Ignore("Observers can't throw") public void onNextOnErrorFailureSafe() { try { new SafeObserver<String>(OBSERVER_ONNEXT_ONERROR_FAIL()).onNext("one"); fail("expects exception to be thrown"); } catch (Exception e) { e.printStackTrace(); assertTrue(e instanceof RuntimeException); assertEquals("Error occurred when trying to propagate error to Observer.onError", e.getMessage()); Throwable e2 = e.getCause(); assertTrue(e2 instanceof CompositeException); List<Throwable> innerExceptions = ((CompositeException) e2).getExceptions(); assertEquals(2, innerExceptions.size()); Throwable e3 = innerExceptions.get(0); assertTrue(e3 instanceof SafeObserverTestException); assertEquals("onNextFail", e3.getMessage()); Throwable e4 = innerExceptions.get(1); assertTrue(e4 instanceof SafeObserverTestException); assertEquals("onErrorFail", e4.getMessage()); } }
@Test public void onNextWithoutOnSubscribe() { TestObserver<Integer> ts = new TestObserver<Integer>(); SafeObserver<Integer> so = new SafeObserver<Integer>(ts); so.onNext(1); ts.assertFailureAndMessage(NullPointerException.class, "Subscription not set!"); }
@Test public void onNextOnSubscribeCrash() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(true, 1, false, false, false); SafeObserver<Object> so = cd.toSafe(); so.onNext(1); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Throwable> ce = TestCommonHelper.compositeList(list.get(0)); TestCommonHelper.assertError(ce, 0, NullPointerException.class, "Subscription not set!"); TestCommonHelper.assertError(ce, 1, TestException.class, "onSubscribe()"); } finally { RxJavaCommonPlugins.reset(); } }
@Test public void noSubscribeOnErrorCrashes() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(false, 1, true, false, false); SafeObserver<Object> so = cd.toSafe(); so.onNext(1); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Throwable> ce = TestCommonHelper.compositeList(list.get(0)); TestCommonHelper.assertError(ce, 0, NullPointerException.class, "Subscription not set!"); TestCommonHelper.assertError(ce, 1, TestException.class, "onError(java.lang.NullPointerException: Subscription not set!)"); } finally { RxJavaCommonPlugins.reset(); } }
|
SafeObserver implements Observer<T>, Disposable { @Override public void onComplete() { if (done) { return; } done = true; if (s == null) { onCompleteNoSubscription(); return; } try { actual.onComplete(); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(e); } } SafeObserver(@NonNull Observer<? super T> actual); @Override void onSubscribe(@NonNull Disposable s); @Override void dispose(); @Override boolean isDisposed(); @Override void onNext(@NonNull T t); @Override void onError(@NonNull Throwable t); @Override void onComplete(); }
|
@Test public void onCompleteFailure() { AtomicReference<Throwable> onError = new AtomicReference<Throwable>(); try { OBSERVER_ONCOMPLETED_FAIL(onError).onComplete(); fail("expects exception to be thrown"); } catch (Exception e) { assertNull(onError.get()); assertTrue(e instanceof SafeObserverTestException); assertEquals("onCompleteFail", e.getMessage()); } }
@Test @Ignore("Observers can't throw") public void testOnCompletedThrows() { final AtomicReference<Throwable> error = new AtomicReference<Throwable>(); SafeObserver<Integer> s = new SafeObserver<Integer>(new DefaultObserver<Integer>() { @Override public void onNext(Integer t) { } @Override public void onError(Throwable e) { error.set(e); } @Override public void onComplete() { throw new TestException(); } }); try { s.onComplete(); Assert.fail(); } catch (RuntimeException e) { assertNull(error.get()); } }
@Test public void onCompleteWithoutOnSubscribe() { TestObserver<Integer> ts = new TestObserver<Integer>(); SafeObserver<Integer> so = new SafeObserver<Integer>(ts); so.onComplete(); ts.assertFailureAndMessage(NullPointerException.class, "Subscription not set!"); }
@Test public void onCompleteteNoSubscribeCrash() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(true, 1, false, true, false); SafeObserver<Object> so = cd.toSafe(); so.onComplete(); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Throwable> ce = TestCommonHelper.compositeList(list.get(0)); TestCommonHelper.assertError(ce, 0, NullPointerException.class, "Subscription not set!"); TestCommonHelper.assertError(ce, 1, TestException.class, "onSubscribe()"); } finally { RxJavaCommonPlugins.reset(); } }
@Test public void onCompleteteNoSubscribeOnErrorCrash() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(false, 1, true, true, false); SafeObserver<Object> so = cd.toSafe(); so.onComplete(); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Throwable> ce = TestCommonHelper.compositeList(list.get(0)); TestCommonHelper.assertError(ce, 0, NullPointerException.class, "Subscription not set!"); TestCommonHelper.assertError(ce, 1, TestException.class); } finally { RxJavaCommonPlugins.reset(); } }
|
SafeObserver implements Observer<T>, Disposable { @Override public void onError(@NonNull Throwable t) { if (done) { RxJavaCommonPlugins.onError(t); return; } done = true; if (s == null) { Throwable npe = new NullPointerException("Subscription not set!"); try { actual.onSubscribe(EmptyDisposable.INSTANCE); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(new CompositeException(t, npe, e)); return; } try { actual.onError(new CompositeException(t, npe)); } catch (Throwable e) { Exceptions.throwIfFatal(e); RxJavaCommonPlugins.onError(new CompositeException(t, npe, e)); } return; } if (t == null) { t = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources."); } try { actual.onError(t); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); RxJavaCommonPlugins.onError(new CompositeException(t, ex)); } } SafeObserver(@NonNull Observer<? super T> actual); @Override void onSubscribe(@NonNull Disposable s); @Override void dispose(); @Override boolean isDisposed(); @Override void onNext(@NonNull T t); @Override void onError(@NonNull Throwable t); @Override void onComplete(); }
|
@Test public void onErrorFailure() { try { OBSERVER_ONERROR_FAIL().onError(new SafeObserverTestException("error!")); fail("expects exception to be thrown"); } catch (Exception e) { assertTrue(e instanceof SafeObserverTestException); assertEquals("onErrorFail", e.getMessage()); } }
@Test @Ignore("Observers can't throw") public void onErrorFailureSafe() { try { new SafeObserver<String>(OBSERVER_ONERROR_FAIL()).onError(new SafeObserverTestException("error!")); fail("expects exception to be thrown"); } catch (Exception e) { e.printStackTrace(); assertTrue(e instanceof RuntimeException); assertEquals("Error occurred when trying to propagate error to Observer.onError", e.getMessage()); Throwable e2 = e.getCause(); assertTrue(e2 instanceof CompositeException); List<Throwable> innerExceptions = ((CompositeException) e2).getExceptions(); assertEquals(2, innerExceptions.size()); Throwable e3 = innerExceptions.get(0); assertTrue(e3 instanceof SafeObserverTestException); assertEquals("error!", e3.getMessage()); Throwable e4 = innerExceptions.get(1); assertTrue(e4 instanceof SafeObserverTestException); assertEquals("onErrorFail", e4.getMessage()); } }
@Test @Ignore("Observers can't throw") public void onErrorNotImplementedFailureSafe() { try { new SafeObserver<String>(OBSERVER_ONERROR_NOTIMPLEMENTED()).onError(new SafeObserverTestException("error!")); fail("expects exception to be thrown"); } catch (Exception e) { assertTrue(e.getCause() instanceof SafeObserverTestException); assertEquals("error!", e.getCause().getMessage()); } }
@Test public void onErrorWithoutOnSubscribe() { TestObserver<Integer> ts = new TestObserver<Integer>(); SafeObserver<Integer> so = new SafeObserver<Integer>(ts); so.onError(new TestException()); ts.assertFailure(CompositeException.class); TestHelper.assertError(ts, 0, TestException.class); TestHelper.assertError(ts, 1, NullPointerException.class, "Subscription not set!"); }
@Test public void onErrorNoSubscribeCrash() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(true, 1, false, false, false); SafeObserver<Object> so = cd.toSafe(); so.onError(new TestException()); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Throwable> ce = TestCommonHelper.compositeList(list.get(0)); TestCommonHelper.assertError(ce, 0, TestException.class); TestCommonHelper.assertError(ce, 1, NullPointerException.class, "Subscription not set!"); } finally { RxJavaCommonPlugins.reset(); } }
@Test public void onErrorNoSubscribeOnErrorCrash() { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { CrashDummy cd = new CrashDummy(false, 1, true, false, false); SafeObserver<Object> so = cd.toSafe(); so.onError(new TestException()); TestCommonHelper.assertError(list, 0, CompositeException.class); List<Throwable> ce = TestCommonHelper.compositeList(list.get(0)); TestCommonHelper.assertError(ce, 0, TestException.class); TestCommonHelper.assertError(ce, 1, NullPointerException.class, "Subscription not set!"); TestCommonHelper.assertError(ce, 2, TestException.class); } finally { RxJavaCommonPlugins.reset(); } }
|
SafeObserver implements Observer<T>, Disposable { @Override public void dispose() { s.dispose(); } SafeObserver(@NonNull Observer<? super T> actual); @Override void onSubscribe(@NonNull Disposable s); @Override void dispose(); @Override boolean isDisposed(); @Override void onNext(@NonNull T t); @Override void onError(@NonNull Throwable t); @Override void onComplete(); }
|
@Test public void dispose() { TestObserver<Integer> ts = new TestObserver<Integer>(); SafeObserver<Integer> so = new SafeObserver<Integer>(ts); Disposable d = Disposables.empty(); so.onSubscribe(d); ts.dispose(); assertTrue(d.isDisposed()); assertTrue(so.isDisposed()); }
|
CompositeException extends RuntimeException { @Override @NonNull public String getMessage() { return message; } CompositeException(@NonNull Throwable... exceptions); CompositeException(@NonNull Iterable<? extends Throwable> errors); @NonNull List<Throwable> getExceptions(); @Override @NonNull String getMessage(); @Override @NonNull synchronized Throwable getCause(); @Override void printStackTrace(); @Override void printStackTrace(PrintStream s); @Override void printStackTrace(PrintWriter s); int size(); }
|
@Test public void testEmptyErrors() { try { new CompositeException(); fail("CompositeException should fail if errors is empty"); } catch (IllegalArgumentException e) { assertEquals("errors is empty", e.getMessage()); } try { new CompositeException(new ArrayList<Throwable>()); fail("CompositeException should fail if errors is empty"); } catch (IllegalArgumentException e) { assertEquals("errors is empty", e.getMessage()); } }
@Test public void messageCollection() { CompositeException compositeException = new CompositeException(ex1, ex3); assertEquals("2 exceptions occurred. ", compositeException.getMessage()); }
@Test public void messageVarargs() { CompositeException compositeException = new CompositeException(ex1, ex2, ex3); assertEquals("3 exceptions occurred. ", compositeException.getMessage()); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.