JUnit Testing
When creating unit tests with data grid you will use an Embedded Space Where GigaSpaces data is stored. It is the logical cache that holds data objects in memory and might also hold them in layered in tiering. Data is hosted from multiple SoRs, consolidated as a unified data model.
that is internally represented by the IntegratedProcessingUnitContainer
class and a reference to this Space will be available through a class implementing the GigaSpace
interface. This allows you to read / write objects to that Space just as you normally would in any data grid application.
Simple test
Here is an example of a simple JUnit test:
@SpaceClass
public class SpaceData {
private UUID id;
private Long category;
private String name;
@SpaceId
public UUID getId() {
return id;
}
public void setId(UUID id) {
this.id = id;
}
@SpaceRouting
public Long getCategory() {
return category;
}
public void setCategory(Long category) {
this.category = category;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xmlns:os-core="http://www.openspaces.org/schema/core" xmlns:os-jms="http://www.openspaces.org/schema/jms"
xmlns:os-events="http://www.openspaces.org/schema/events"
xmlns:os-remoting="http://www.openspaces.org/schema/remoting"
xmlns:os-sla="http://www.openspaces.org/schema/sla" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.openspaces.org/schema/core http://www.openspaces.org/schema/17.0.0/core/openspaces-core.xsd
http://www.openspaces.org/schema/events http://www.openspaces.org/schema/17.0.0/events/openspaces-events.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.openspaces.org/schema/remoting http://www.openspaces.org/schema/17.0.0/remoting/openspaces-remoting.xsd">
<os-core:embedded-space id="aSpace" space-name="processingSpace" />
<os-core:giga-space id="processingSpace" space="aSpace" />
</beans>
And here is the JUnit test case
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:META-INF/application-context.xml" })
public class TestXAP {
@Autowired
private GigaSpace processingSpace;
@Test
public void simpleUnitTest() {
SpaceData data = new SpaceData();
data.setId(UUID.randomUUID());
data.setCategory(1L);
data.setName("Test data");
processingSpace.write(data);
SQLQuery<SpaceData> query = new SQLQuery<SpaceData>(SpaceData.class, "");
SpaceData[] result = processingSpace.readMultiple(query);
Assert.assertEquals(result.length, 1);
}
@Before
public void init() {
processingSpace.clear(null);
}
}
Partition/Routing test
Testing partitioning and routing The mechanism that is in charge of routing the objects into and out of the corresponding partitions. The routing is based on a designated attribute inside the objects that are written to the Space, called the Routing Index. can be accomplished by using the IntegratedProcessingUnitContainerProvider
. You can start multiple partitions by defining with the ClusterInfo
the number of members of a cluster.
In the example below 4 partitions are started.
public class ClusterTest {
private GigaSpace space;
@Test
public void testCluster() {
for (int i = 0; i < 4; i++) {
SpaceData data = new SpaceData();
data.setId(UUID.randomUUID());
data.setName("Space Data " + i);
data.setCategory(new Long(i));
space.write(data);
}
SQLQuery<SpaceData> query = new SQLQuery<SpaceData>(SpaceData.class, "");
SpaceData[] result = space.readMultiple(query);
Assert.assertEquals(result.length, 4);
}
@Before
public void init() {
IntegratedProcessingUnitContainerProvider provider = new IntegratedProcessingUnitContainerProvider();
provider.addConfigLocation("classpath:META-INF/application-context.xml");
ClusterInfo clusterInfo = new ClusterInfo();
clusterInfo.setSchema("partitioned");
clusterInfo.setNumberOfInstances(4);
provider.setClusterInfo(clusterInfo);
ProcessingUnitContainer c = provider.createContainer();
space = new GigaSpaceConfigurer(new SpaceProxyConfigurer("processingSpace")).gigaSpace();
}
}
You can verify that the 4 partitions exists by starting the Management Center
Lookup Service
The StandaloneProcessingUnitContainer automatically starts an embedded Lookup service. If you intend to use a separate Lookup service you can disable the embedded Lookup service by passing the setting the com.j_spaces.core.container.directory_services.jini_lus.enabled
system property to false. This property can also be set within the Space definition:
<os-core:embedded-space id="space" space-name="mySpace">
<os-core:properties>
<props>
<prop key="com.j_spaces.core.container.directory_services.jini_lus.start-embedded-lus">false</prop>
</props>
</os-core:properties>
</os-core:embedded-space>