Sometime back now they added the support for TestListener which solves this issue.

Unitils – TestListerer API

I don’t work with conventional databases much now, but was intrigued to see this post explaining how to extend unitils and use TestListeners to test ldap.  Neat eh!

Extending Unitils to test LDap.

                          

Beach Hut - By Martin Harris

More and more I have been thinking about the effect of culture on Agile adoption. Then a friend tweeted this article on Agile Culture by Michael Sahota. Its a real eye opener and one key message is that it might be quicker to fit your process to the culture rather than the other way around.

There is some evidence to suggest that trying to introduce and Agile Development system into a culture that won’t naturally accept it is a recipe for failure.

For me its more complex that this. I am not 100% sure I am anywhere near a solution but these thoughts arise.

Evolution v Revolution and mandate
Without going into the detail which can be found on other posts the cultural fit is probably more important if you can’t change the culture. Most of the time we are somewhat restricted by our mandate. Its rare that someone senior wants this bad enough that they are prepared for the risk of revolutionary change.

If you were about to move in that direction, perhaps you can change the culture to fit. This path is also easier if your scope is small. i.e. if your dealing with a small group of people and not a multinational.

Otherwise perhaps initially selection of technique and Agile process should be culture driven.

The Kanban / Control argument
Its interesting to see Michael point out that Kanban is not Agile. At least by cultural definition. It occurred to me also that successful open source cultures might not be Agile either, they seem to fall into the “Craftsmanship” section.

Yet, were you to take a controlling culture and conduct Kanban with XP practices might it not over a long period of time begin to change. Perhaps towards craftsmanship as an appreciation of quality evolves?

So what now then Agile Coaches and CTO’s?
Well I for one have found the diagrams very useful. Just an awareness of this idea helps bring people to a higher view of what might be going on in their Agile Adoption process and that is no bad thing. Its too easy to get wrapped up in the daily Punch and Judy show forgetting about the bigger picture.

                          

InfoQ: Chet Hendrickson on the Need for Good Technical Practices.

                          

I have come to learn that there are several ways. Here are my favorites.

1. Build your own maven plugin to build .NET projects. Package 3rd party products as zips and put them in maven. Write a plugin that reads solution and project files and calls MSBuild with the appropriate flags.  Advantage, maximum flexibility.  Disadvantage, lots of effort.
2. Use the existing maven-dotnet-plugin.  Advantage, does a lot for you including various types of test and coverage systems, plus it can run sonar.  Disadvantage, Hard to get it to work on complex silverlight projects. In fact hard full stop.  The docs are not great.
3. Use NuGet.  Advantages, it has .NET pedigree and Microsoft Backing.  Adoption amongst .net developers is probably an easier sell than a java utility.  Disadvantages, Very early days for the project, as yet unproven.
4. Finally npanday.  Advantages, nice integration with Visual Studio.  Disadvantages, very hard to get it to work with silverlight.  Impossible in fact as MS have kindly removed the command line baml compile utility.

                          

The test needs to perform a check that the result of transforming some xml is correct.  A reference file is available so we can use XMLUnit to perform a difference.  In my file there is a seconds attribute and because seconds vary with each parse we choose to ignore the value.  There are other ways to achieve this, but its more complex and uses more XMLUnit code. Using a google predicate simplifies this check.

First produce your output file and load the sample and output into strings. Normally for a test I produce a smaller sample xml file. Then using XMLUnit difference engine get all differences.

    Diff d = new Diff(expectedAsString, outputAsString);
    DetailedDiff dd = new DetailedDiff(d);
    List listOfDifferences = dd.getAllDifferences();

Next call a function to check that the only differences found are within the seconds attribute. This uses a predicates from google to perform the matching.

    assertTrue(onlyDiffsMatchThisAttributeName("seconds",listOfDifferences));
    }

    private static boolean onlyDiffsMatchThisAttributeName(final String attrName, Iterable it) {

    Iterable filtered = Iterables.filter(it, new Predicate() {

        @Override
        public boolean apply(Difference input) {

                final NodeDetail testNodeDetail = input.getTestNodeDetail();
                if (nodeDetail == null) return false;

                final Node node = nodeDetail.getNode();
                if (node == null) return false;

                final String nodeName = node.getNodeName();
                if (nodeName == null) return false;

                return !nodeName.equals(attrName);
            }
        });
        return (newArrayList(filtered).isEmpty());
    }

Note that what is happening here is the predicate is filtering away all the seconds matches. If anything remains in the list false is returned. Neat huh!

                          

Even my mum uses it!

I am very happy with the choice.  In the original posts I managed to setup three home machines, one Linux one windows and a mackbook.  Since then I added the iMac that I keep at my parents.  This is a sign of how easy crashplan is to maintain.  In a nutshell once you have set it up, you just forget about it.  This has to be one of the most important things about backing up.  It does not require any maintenance whatsoever.  This is encouraging when your several hundred miles away from one of the machines.  I can use the web to see if its backed up, and get alerts if a period goes by and it fails.  I just checked it now, 100% backed up today.

What else?

The backup client allows you to set how much bandwidth and CPU its allowed to use.  I use the default as I have never found it hogging either.  I am probably lucky that so far several backups on different machines have not started at the same time.  If it did its easily curable.

In summary

If you have anything worthwhile keeping, and want off-site backup – get a crashplan account.  If you have friends with space, use crashplan for free and backup to each others machines.  In fact do both!

                          

Please comment here I am very interested in hearing what other programmers do for .NET dependency management.

Links for the Java world of dependency management

http://maven.apache.org/

http://ant.apache.org/ivy/

http://www.gradle.org/

                          

# unitils.properties

# Assign the SpringDataSourceFactory DataSource.
org.unitils.database.config.DataSourceFactory.implClassName= com.tek.design.unitils.SpringDataSourceFactory

Write your SpringDataSourceFactory and implement both DataSourceFactory and springs ApplicationContextAware interfaces. Then in the init method you will be able to fetch your spring DataSource bean from the application context using a service look up. Not ideal, but until future releases it will do just fine.

package com.tek.design.unitils;

import java.util.Properties;
import javax.sql.DataSource;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.unitils.database.config.DataSourceFactory;

/**
 *
 * Unitil's provides a way to override the default DataSourceFactory.  This class provides facility to
 * spring wire in the same datasource used by your ORM by fetching it from the ApplicationContext.
 *
 * Use the org.unitils.database.config.DataSourceFactory.implClassName property to supply this factory to unitils.
 *
 */
public class SpringDataSourceFactory implements DataSourceFactory, ApplicationContextAware {

    private static ApplicationContext appContext;

    private DataSource dataSource;

    @Override
    public DataSource createDataSource() {
        return this.dataSource;
    }

    @Override
    public void init(Properties arg0) {

        if (null == this.dataSource) {
            String dataSourceBeanName = "TekDesignDataSource";
            this.dataSource = (DataSource) appContext.getBean(dataSourceBeanName);
            if (this.dataSource == null) {
                throw new SpringBeanLookupException(DataSource.class, "Cant find bean named " + dataSourceName);
            }
        }

    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        appContext = applicationContext;

    }

}

Full unitils properties file:

# unitils.properties

# Provide a CSV of all used database schemas. ie schema1,schema2.
# The first schema name is the default one.
# If no schema name is specified in a dbunit data set the default one is used.
#
# A schema names are case sensitive when surrounded by database identifier quotes (e.g. “” for oracle)
#
# Example unitils description using a schema
#
#<dataset xmlns:frt=”FRUIT”>
#   <frt:APPLE NAME=”COX”
#                           DESCRIPTION=”[null]” />
#</dataset>
#
database.schemaNames=fruit,veg

# This property specifies the underlying DBMS implementation. Supported values are ‘oracle’, ‘db2′, ‘mysql’, ‘hsqldb’,
# ‘postgresql’, ‘derby’ and ‘mssql’. The value of this property defines which vendor specific implementations of
# DbSupport and ConstraintsDisabler are chosen.
database.dialect=oracle

# The dao tests often share the same data in the setup files, so its important to
# rollback between tests otherwise constraints will be violated.
DatabaseModule.Transactional.value.default=rollback

# Assign the SpringDataSourceFactory DataSource.
org.unitils.database.config.DataSourceFactory.implClassName=
com.tek.design.unitils.SpringDataSourceFactory

                          

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));

    }