Example usage for org.springframework.data.gemfire IndexFactoryBean setDefine

Introduction

In this page you can find the example usage for org.springframework.data.gemfire IndexFactoryBean setDefine.

Prototype

public void setDefine(boolean define) 

Source Link

Document

Sets a boolean condition to indicate whether the Index declared and defined by this IndexFactoryBean will only be defined initially, or defined and created.

Usage

From source file:org.springframework.data.gemfire.IndexFactoryBeanTest.java

@Test
@SuppressWarnings("all")
public void afterPropertiesSetIsSuccessful() throws Exception {

    ConfigurableBeanFactory mockConfigurableBeanFactory = mock(ConfigurableBeanFactory.class);

    Index mockIndex = mock(Index.class, "testAfterPropertiesSetIsSuccessful.MockIndex");

    when(mockQueryService.createKeyIndex(eq("TestKeyIndex"), eq("id"), eq("/Example"))).thenReturn(mockIndex);

    IndexFactoryBean indexFactoryBean = newIndexFactoryBean();

    indexFactoryBean.setBeanFactory(mockConfigurableBeanFactory);
    indexFactoryBean.setBeanName("KeyIndexBean");
    indexFactoryBean.setDefine(false);
    indexFactoryBean.setExpression("id");
    indexFactoryBean.setFrom("/Example");
    indexFactoryBean.setName("TestKeyIndex");
    indexFactoryBean.setType("key");
    indexFactoryBean.afterPropertiesSet();

    assertThat(indexFactoryBean.getIndex()).isEqualTo(mockIndex);

    Index actualIndex = indexFactoryBean.getObject();

    assertThat(actualIndex).isEqualTo(mockIndex);
    assertThat(indexFactoryBean.getObject()).isSameAs(actualIndex);
    assertThat(Index.class).isAssignableFrom(indexFactoryBean.getObjectType());
    assertThat(indexFactoryBean.isSingleton()).isTrue();

    verify(indexFactoryBean, times(1)).getBeanName();
    verify(indexFactoryBean, never()).lookupQueryService();
    verify(mockConfigurableBeanFactory, times(1)).registerAlias(eq("KeyIndexBean"), eq("TestKeyIndex"));
    verify(mockQueryService, times(1)).createKeyIndex(eq("TestKeyIndex"), eq("id"), eq("/Example"));
    verifyZeroInteractions(mockCache);// w  w  w  .j  a  va2 s .  com
}

---

From source file:org.springframework.data.gemfire.IndexFactoryBeanTest.java

@Test
public void lookupQueryServiceFromCache() {

    QueryService mockQueryService = mockQueryService("testLookupQueryServiceFromCache.MockQueryService");

    when(mockBeanFactory.containsBean(eq(GemfireConstants.DEFAULT_GEMFIRE_INDEX_DEFINITION_QUERY_SERVICE)))
            .thenReturn(false);/*from w ww . j a  v a  2s .  com*/
    when(mockCache.getQueryService()).thenReturn(mockQueryService);

    IndexFactoryBean indexFactoryBean = newIndexFactoryBean();

    indexFactoryBean.setDefine(false);
    indexFactoryBean.setQueryService(null);

    assertThat(indexFactoryBean.lookupQueryService()).isSameAs(mockQueryService);

    verify(mockBeanFactory, times(1))
            .containsBean(eq(GemfireConstants.DEFAULT_GEMFIRE_INDEX_DEFINITION_QUERY_SERVICE));
    verify(mockBeanFactory, never()).getBean(
            eq(GemfireConstants.DEFAULT_GEMFIRE_INDEX_DEFINITION_QUERY_SERVICE), eq(QueryService.class));
    verify(mockCache, times(1)).getQueryService();
}

---

From source file:org.springframework.data.gemfire.IndexFactoryBeanTest.java

@Test
public void registerQueryServiceBeanWhenIndexIsCreated() {

    ConfigurableBeanFactory mockBeanFactory = mock(ConfigurableBeanFactory.class,
            "testRegisterQueryServiceBeanWhenIndexIsCreated.MockBeanFactory");

    IndexFactoryBean indexFactoryBean = newIndexFactoryBean();

    indexFactoryBean.setBeanFactory(mockBeanFactory);
    indexFactoryBean.setDefine(false);

    assertThat(indexFactoryBean.registerQueryServiceBean("queryServiceBeanName", mockQueryService))
            .isSameAs(mockQueryService);

    verify(mockBeanFactory, never()).registerSingleton(eq("queryServiceBeanName"), same(mockQueryService));
}

---

From source file:org.springframework.data.gemfire.IndexFactoryBeanTest.java

@Test
public void registerQueryServiceBeanWhenIndexIsDefined() {

    ConfigurableBeanFactory mockBeanFactory = mock(ConfigurableBeanFactory.class,
            "testRegisterQueryServiceBeanWhenIndexIsDefined.MockBeanFactory");

    IndexFactoryBean indexFactoryBean = newIndexFactoryBean();

    indexFactoryBean.setBeanFactory(mockBeanFactory);
    indexFactoryBean.setDefine(true);

    assertThat(indexFactoryBean.registerQueryServiceBean("queryServiceBeanName", mockQueryService))
            .isSameAs(mockQueryService);

    verify(mockBeanFactory, times(1)).registerSingleton(eq("queryServiceBeanName"), same(mockQueryService));
}

---

From source file:org.springframework.data.gemfire.IndexFactoryBeanTest.java

@Test
public void defineMultipleIndexesWithSeparateIndexFactoryBeansSameSpringContext() throws Exception {

    ConfigurableBeanFactory mockBeanFactory = mock(ConfigurableBeanFactory.class,
            "testDefineMultipleIndexesWithSeparateIndexFactoryBeansSameSpringContext.MockBeanFactory");

    Cache mockCacheOne = mock(Cache.class,
            "testDefineMultipleIndexesWithSeparateIndexFactoryBeansSameSpringContext.MockCacheOne");

    Cache mockCacheTwo = mock(Cache.class,
            "testDefineMultipleIndexesWithSeparateIndexFactoryBeansSameSpringContext.MockCacheTwo");

    AtomicReference<QueryService> queryServiceReference = new AtomicReference<>(null);

    doAnswer(invocation -> (queryServiceReference.get() != null)).when(mockBeanFactory)
            .containsBean(eq(GemfireConstants.DEFAULT_GEMFIRE_INDEX_DEFINITION_QUERY_SERVICE));

    doAnswer(invocation -> queryServiceReference.get()).when(mockBeanFactory).getBean(
            eq(GemfireConstants.DEFAULT_GEMFIRE_INDEX_DEFINITION_QUERY_SERVICE), eq(QueryService.class));

    doAnswer(invocation -> {//from   w  w  w  .  ja  va  2s .com

        assertEquals(GemfireConstants.DEFAULT_GEMFIRE_INDEX_DEFINITION_QUERY_SERVICE,
                invocation.getArgument(0));

        queryServiceReference.compareAndSet(null, invocation.getArgument(1));

        return null;
    }).when(mockBeanFactory).registerSingleton(
            eq(GemfireConstants.DEFAULT_GEMFIRE_INDEX_DEFINITION_QUERY_SERVICE), any(QueryService.class));

    when(mockCacheOne.getQueryService()).thenReturn(mockQueryService);

    IndexFactoryBean indexFactoryBeanOne = new IndexFactoryBean();

    indexFactoryBeanOne.setBeanFactory(mockBeanFactory);
    indexFactoryBeanOne.setCache(mockCacheOne);
    indexFactoryBeanOne.setDefine(true);
    indexFactoryBeanOne.setExpression("id");
    indexFactoryBeanOne.setFrom("/People");
    indexFactoryBeanOne.setName("PersonIdIndex");
    indexFactoryBeanOne.setType("Key");
    indexFactoryBeanOne.afterPropertiesSet();

    IndexFactoryBean indexFactoryBeanTwo = new IndexFactoryBean();

    indexFactoryBeanTwo.setBeanFactory(mockBeanFactory);
    indexFactoryBeanTwo.setCache(mockCacheTwo);
    indexFactoryBeanTwo.setDefine(true);
    indexFactoryBeanTwo.setExpression("purchaseDate");
    indexFactoryBeanTwo.setFrom("/Orders");
    indexFactoryBeanTwo.setImports("org.example.Order");
    indexFactoryBeanTwo.setName("PurchaseDateIndex");
    indexFactoryBeanTwo.setType("HASH");
    indexFactoryBeanTwo.afterPropertiesSet();

    verify(mockBeanFactory, times(2))
            .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(mockBeanFactory, times(1)).registerSingleton(
            eq(GemfireConstants.DEFAULT_GEMFIRE_INDEX_DEFINITION_QUERY_SERVICE), same(mockQueryService));

    verify(mockCacheOne, times(1)).getQueryService();
    verify(mockCacheTwo, never()).getQueryService();

    verify(mockQueryService, times(1)).defineKeyIndex(eq("PersonIdIndex"), eq("id"), eq("/People"));

    verify(mockQueryService, times(1)).defineHashIndex(eq("PurchaseDateIndex"), eq("purchaseDate"),
            eq("/Orders"), eq("org.example.Order"));
}

---