He also mentioned using the admin api to do full end to end integration testing.  The admin api has huge potential as its able to control gigaspace containers, deploy into them and collect statistics.  Its a powerful api.

This is documented on their site: http://www.gigaspaces.com/wiki/display/XAP7/Administration+and+Monitoring+API

Example unit test using GigaSpaceFactoryBean

The GigaSpaceFactoryBean does have javadoc: http://www.gigaspaces.com/docs/JavaDoc7.1/index.html. It can be used to provide a unit test with a gigaspace implementation for the duration of the test.

Step 1 Provide a spring definition of the GigaSpaceFactoryBean

<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-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:util="http://www.springframework.org/schema/util"
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.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.5.xsd
http://www.openspaces.org/schema/core http://www.openspaces.org/schema/core/openspaces-core.xsd
http://www.openspaces.org/schema/events http://www.openspaces.org/schema/events/openspaces-events.xsd
http://www.openspaces.org/schema/remoting http://www.openspaces.org/schema/remoting/openspaces-remoting.xsd
http://www.openspaces.org/schema/sla http://www.openspaces.org/schema/sla/openspaces-sla.xsd">

<os-core:local-tx-manager id="gs.transactionManager" space="testGigaSpace" default-timeout="1000" />
<os-core:space id="testGigaSpace" url="/./my-test-pu" />

<bean id="gigaSpace">
<property name="space" ref="testGigaSpace" />
<property name="transactionManager" ref="gs.transactionManager" />
</bean>

Follow with other beans needed by the test. I.e service beans and their dependencies.  Note that the space defined here will also need to be injected into services that need it.  So you will need to use the same bean id.  Careful separation of the spring files means you will be able to substitute a test space for the real one during testing.

Step 2 Write a unit test

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:/somewhere/sometest-pu.xml")
public class SomeGigaspaceTest {

    @Resource
	private ServiceUnderTest myservice;

    @Resource
    private GigaSpace gigaSpace;

    @Before
    public void setUp() {

        // Setup anything you may wish to be
        // in the space before the test starts.
        this.gigaSpace.write(stuff);

    }

    @Test
    public void testSomething() throws InterruptedException {

        ImmutableSet dataFromGS = this.myservice.getStuff();
        assertFalse(dataFromGS.isEmpty());
        assertThat(dataFromGS.size(), is(100));

    }

                          

<T> LeaseContext<T> write(T entry,
                          long lease,
                          long timeout,
                          int modifiers)
                      throws DataAccessException

These are the things I dislike about it:

• The long timeout and lease don’t have units declared. See my previous blog where I show a good way to supply durations.
• The documentation is terrible, it does not mention what units the timeout are in, I had to navigate to LeaseContext to understand the lease, and find  Lease.FOREVER.  As I write this I still do not know how to set a maximum or minimum timeout.  Perhaps 0, null?  Not sure.  What happens if you set a minus value?
• The method has a mode in the form of modifiers.  Modifiers is a bad name but I would rather delete it than change the name.  The mode is not a great way to communicate what your method does, but this one is particularly bad because it can effect what might be returned and possibly the types of exception that might get thrown.

UpdateModifiers.UPDATE_OR_WRITE .  If your very lucky you might get a lease back.  If you have successfully written (a new object or object with no id.) you get null.  If you update the lease contains the previous value.  But hang on there is a flag!  I hate flags.  The NoWriteLease if set causes the method to return null in all situations.  I wonder how you set that, the documentation has no link.

UpdateModifiers.WRITE_ONLY
Could throw EntryAlreadyInSpaceException for objects that have an id and your writing a duplicate.

So as you can see, if I call this method changing the mode might mean I have to change the post execution traps, null handling etc.  Very easy to introduce a bug inadvertently.

If anyone from GigaSpace or OpenSpace is reading, sorry but its been a long day and I had to walk 4 miles through the snow to get home!  While you amending the API onto an otherwise excellent product, could you update your more general documentaiton.  Its very use case based.  This is great when my use case matches your documentation, but most of the time this is not the case.  So it becomes a nightmare picking pieces from here and there hoping its all going to work.  I drive everything from tests but it gets a bit tedious when my tests fail because my assumptions are wrong.

• UpdateModifiers is also not an enum but a constants class. As such the evil modifier is not even type or boundary safe.

Anyway before this blog turns into a rant. It may already be too late, sorry.

For discussion – Suggestion for a new API

write(T entry
    , long lease, TimeUnit leaseUnit
    , long timeout, TimeUnit timeoutUnit)

writeOrUpdate(T entry
    , long lease, TimeUnit leaseUnit
    , long timeout, TimeUnit timeoutUnit)

update(T entry
    , long lease, TimeUnit leaseUnit
    , long timeout, TimeUnit timeoutUnit)

partialUpdate(T entry
    , long lease, TimeUnit leaseUnit
    , long timeout, TimeUnit timeoutUnit)

                          

Look at these two setters. Setter methods like the first example are very common. Take a look at the second its so much better. With the second the responsibility to convert is neatly delegated to another class instead of forcing the user of the api to work it out. In addition the programmer can supply hours, minutes or any other that TimeUnit supports.

public void setDuration(long durationInMs) {
    this.duration = durationInMs;
}

public void setDuration(long duration, TimeUnit timeUnit) {
    this.duration = timeUnit.toMillis(duration);
}

TimeUnit was brought to you by: java.util.concurrent.TimeUnit! Its handy, so use it!