Let’s say you have interface Driveable:

public interface Driveable {
 public void accelerate();
 
 public void brake();
 
 public void tuneRadio();
}

Awesome. Now let’s say you have class AbstractDriveable:

public abstract class AbstractDriveable implements Driveable {
 public void accelerate() {
 Window.alert("Vroom vroom!");
 }
 public void brake() {
 Window.alert("Screeeeeech!");
 }
}

Totally cool.  And then you love your favorite FM station in ConcreteDriveable:

public class ConcreteDriveable extends AbstractDriveable {
 public void tuneRadio() {
 Window.alert("Rockin' the oldies!");
 }
}

Then we launch into development mode with whatever our application is, and…something explodes.

So we debug, and upon looking at the code that cleverly calls tuneRadio polymorphically – we notice that our debugger drops into a catch block for a NoSuchMethodError.

It appears that GWT seems to lose track of this common idiom – use an interface to define behavior, realize that interface on an abstract class to create default behaviors, and then strategize those behaviors in concrete implementations.

The workaround is simple: redeclare your unrealized interface method in the abstract class. But this is a pretty nasty little bug. The GWT guys know this, but it’s rather critical to GWT that it follow the practices of Java as best as possible. Otherwise it’s YAL.

A bland RPC implementation that was based on past work I’ve done was barfing all over me at GWT compile-time today:

Rebinding com.ryannorris.staffing.client.project.ProjectCreatorService

Invoking com.google.gwt.dev.javac.StandardGeneratorContext@9b32fe

Generating client proxy for remote service interface 'com.ryannorris.staffing.client.project.ProjectCreatorService'

[ERROR] com.ryannorris.staffing.client.Action<T> has no available instantiable subtypes. (reached via com.ryannorris.staffing.client.Action<T>)

[ERROR]    subtype com.ryannorris.staffing.client.Action<T> is not instantiable

[ERROR]    subtype com.ryannorris.staffing.client.project.ProjectCreatorAction is not assignable to 'com.google.gwt.user.client.rpc.IsSerializable' or 'java.io.Serializable' nor does it have a custom field serializer (reached via com.ryannorris.staffing.client.Action<T>)

[ERROR] com.ryannorris.staffing.client.project.ProjectCreatorAction is not assignable to 'com.google.gwt.user.client.rpc.IsSerializable' or 'java.io.Serializable' nor does it have a custom field serializer (reached via com.ryannorris.staffing.client.Action<T>)

I can’t say I ever had the pleasure of dealing with this bit of attention to detail from the GWT Compiler in the past.  And while I will readily admit I haven’t read every change to the underlying architecture that comes with 2.0, this would seem to be a piece that might be worthy of some special mention.

It is, of course, nearly common sense to make sure that your RPC objects can go across the wire in the proper way, and thus simply respecting the semantics of java.io.Serializable the same way we would in EJB per se, is pretty reasonable.  Just a little more heads up would have been nice.

Update 1: There seems to be some mention of fixing compiler feedback around RPC serialization here.  But this defect doesn’t suggest changes that might have actually altered behavior or requirements of the compiler since 1.7.

To get started, let’s break down our validation needs along the standard lines that we see in frameworks today.  Widgets need to be able to be Validatable.  That is to say, Widgets must be able to be externally seen as having the capability to execute logic which validates their current state.  In my approach, I’ve chosen to strategize my widgets rather than visit them in order to validate their data.  This decision is largely to enforce contract-driven development and ensure a high level of testability.

Validatable

package com.ryannorris.gwt.validation.client;
 
public interface Validatable {
	/**
	 * Execute validation on the implementing component
	 *
	 * @return true if validation succeeded, false if validation failed
	 */
	public boolean validate();
}

We also now need an interface that will provide the rules for how validation logic should occur.  Something that is Validatable should be able to validate itself with multiple sets of rules.  Our Validator interface gives us this flexible cardinality, and has a familiar ring to it.

Validator

package com.ryannorris.gwt.validation.client;
 
public interface Validator {
	/**
	 * Execute the implemented validation logic
	 *
	 * @return true if validation succeeded, false otherwise
	 */
	public boolean validate();
}

Yes, these two interfaces are the same besides their name. They are both command interfaces, allowing us to abstract logic behind a single method that we can cope with polymorphically. The idea remember is that Validatable components can re-use many different Validator implementations.

So let’s write a simple Validator and Validatable interface.  In this case, we’ll be validating date input.

DateFormatValidator

package com.ryannorris.gwt.validation.client.validator;
 
import com.google.gwt.i18n.client.DateTimeFormat;
import com.google.gwt.user.client.ui.HasValue;
import com.ryannorris.gwt.validation.client.Validator;
 
public class DateFormatValidator implements Validator {
 
	private HasValue<String> _value;
	private DateTimeFormat _format;
 
	/**
	 * Create a validator that will verify that the given string is compliant
	 * with the pattern
	 *
	 * @param format
	 *            The format to validate against, per the specification in
	 *            {@link DateTimeFormat}
	 * @param value
	 *            The value to validate
	 */
	public DateFormatValidator(String pattern, HasValue<String> value) {
		_format = DateTimeFormat.getFormat(pattern);
	}
 
	/**
	 * Set the value to be validated
	 *
	 * @param value a string, nominally representing a date
	 */
	public void setValue(HasValue<String> value) {
		_value = value;
	}
 
	/*
	 * (non-Javadoc)
	 *
	 * @see com.ryannorris.gwt.validation.client.Validator#validate()
	 */
	@Override
	public boolean validate() {
		try {
			_format.parse(_value.getValue());
		} catch (IllegalArgumentException e) {
			// the value couldn't be parsed by the pattern, return false
			return false;
		}
 
		return true;
	}
}

So, now I have a Validator. How do I now make a widget, let’s say a simple TextBox, Validatable?

Harkon back earlier when I said I was chosing to strategize my Widgets.  That’s only partially true.  Because we’re aiming for good TDD, and hence we want to rely on dependency injection – we will in fact be decorating them as well.  We will strategize around their ability to be validated, while we will decorate them with the Validators that interest us.  This is important, as we wouldn’t want to have 20 different TextBox implementations that handle various Validation permutations.  We would rather one, decoratable TextBox that can be managed by the presenter in our MVP implementation.  So what does our initial stab at a ValidatableTextBox look like?

ValidatableTextBox

package com.ryannorris.gwt.validation.client.widget;
 
import com.google.gwt.user.client.ui.TextBox;
import com.ryannorris.gwt.validation.client.Validatable;
import com.ryannorris.gwt.validation.client.validator.DateFormatValidator;
 
public class ValidatableTextBox extends TextBox implements Validatable {
 
	@Override
	public boolean validate() {
		DateFormatValidator validator = new DateFormatValidator("mm/DD/yyyy",
				getText());
		return validator.validate();
	}
}

Wait, you say.  This isn’t at all what you just described!  This is a text box that will only execute one validator for one date pattern! Well, you’re right.  We need to find a way to enable decoration of our TextBox in a way that can be nicely tested and extensible.  GWT makes extensive use of decorator pattern, and really strives for testability.  We see this in the various Has interfaces, which are added to classes to give them additional behaviors (such as HasText or HasClickHandler).  So, we will follow suit and create our decorator interface HasValidators.

HasValidators

public interface HasValidators {
	/**
	 * Add a validator to the decorated component
	 *
	 * @param validator The validator to be added
	 */
	public void addValidator(Validator validator);
}

And now our updated ValidatableTextBox.

package com.ryannorris.gwt.validation.client.widget;
 
import java.util.Set;
 
import com.google.gwt.user.client.ui.TextBox;
import com.ryannorris.gwt.validation.client.HasValidators;
import com.ryannorris.gwt.validation.client.Validatable;
import com.ryannorris.gwt.validation.client.Validator;
 
public class ValidatableTextBox extends TextBox implements Validatable, HasValidators {
 
	private Set _validators;
 
	@Override
	public void addValidator(Validator validator) {
		_validators.add(validator);
	}
 
	@Override
	public boolean validate() {
		boolean valid = true;
 
		for(Validator validator : _validators) {
			if(! validator.validate()) {
				valid = false;
			}
		}
 
		return valid;
	}
}

So, that’s pretty sweet. I have a collection of Validators as a member of the component – in fact I have a set of them as to ensure no Validator exists more than once on the component.  My validate method now loops through the set of validators and maintains the local state of the validation, allowing the entire validation to fail if any one Validator fails.

A highly testable passive view implementation with this component may look something like:

MySampleValidatableView

/**
 * 
 */
package com.ryannorris.gwt.validation.client;
 
import com.google.gwt.event.dom.client.HasKeyPressHandlers;
import com.google.gwt.user.client.ui.HasValue;
 
/**
 * @author ryan
 * 
 */
public interface MySampleValidatableView {
	/**
	 * Get the {@link HasValidators} behavior of the date box.
	 * 
	 * @return a {@link HasValidators} behavior
	 */
	public HasValidators getDateValidators();
 
	/**
	 * Get the {@link Validatable} behavior of the date box.
	 * 
	 * @return a {@link Validatable} behavior
	 */
	public Validatable getDateValidatable();
 
	/**
	 * Return the {@link HasValue} behavior of the date box. This allows us to
	 * access the value of the control.
	 * 
	 * @return a {@link HasValue} behavior
	 */
	public HasValue<String> getDate();
 
	/**
	 * Return the {@link HasKeyPressHandlers} behavior of the date box. When the
	 * user types a key in the field, we will use this event to validate the
	 * current value;
	 * 
	 * @return
	 */
	public HasKeyPressHandlers getDateKeyUp();
 
	/**
	 * Toggle the visual state of the date box so the user receives feedback
	 * when their date is valid
	 * 
	 * @param valid
	 *            Whether or not the control should reflect a valid date entry
	 *            (true) or an invalid one (false)
	 */
	public void toggleValidDateBox(boolean valid);
 
}

A lot going on here, and it’s seems verbose – but it’s not, it’s just highly testable! We need to be able to access the various behaviors of our text box so that we can test how our presenter collaborates with these behaviors.  We also need to be able to push the passive display functionality back to our view implementation so that our unit tests don’t inadvertently require a hosted environment to run.  So our presenter needs to be built to:

1. Create a DateFormatValidator with the appropriate pattern and a reference to the component holding the text value to validate;
2. Decorate the component in the view through the HasValidators behavior;
3. Execute validation whenever the user changes the value of the widget through the HasKeyPressHandlers interface;
4. Alter the visual display of the component by calling the toggleValidDateBox method.

So last but not least, our presenter:

MySamplePresenter

package com.ryannorris.gwt.validation.client;
 
import com.google.gwt.event.dom.client.KeyPressEvent;
import com.google.gwt.event.dom.client.KeyPressHandler;
import com.ryannorris.gwt.validation.client.validator.DateFormatValidator;
 
public class MySamplePresenter {
 
	public MySamplePresenter(final MySampleValidatableView view) {
 
		DateFormatValidator validator = new DateFormatValidator("mm/DD/yyyy",
				view.getDate());
		view.getDateValidators().addValidator(validator);
 
		view.getDateKeyUp().addKeyPressHandler(new KeyPressHandler() {
 
			@Override
			public void onKeyPress(KeyPressEvent event) {
				view.toggleValidDateBox(view.getDateValidatable().validate());
			}
		});
	}
}

So there you have it – a highly testable base for validation in a GWT application using MVP.

In my next post, I’ll add an event framework to validation, allowing asynchronous validation and abstraction between overall error handling and validation.

What Perl, PHP, Python, and Ruby have done for application development, particularly classic web application development, has been nothing short of revolutionary.  Take C out of the picture.  Facade it with modern concepts that young developers can take to quickly and get results with.  Lose all accountability for memory management.  Push the heavy lifting to the open source teams maintaining these languages, let them deal with security concerns.

But in the last few years, web applications have changed.  The focus has shifted to moving state management and logic to the browser.  Rich internet applications aim to deliver experiences and tools that simply can’t be solved by these scripting languages or even their more heavy-handed older siblings, J2EE and ASP.Net.  Javascript is the new soup du jour.  A slew of abstractions have grown up around the limited facilities of Javascript, all trying to simplify this new mode of development through quirky but innovative approaches to DOM management, component reuse, and RPC.  But all of them are still Javascript.  All of them still take the code written by the engineer and with limited optimization execute it with the browser runtime.  As the complexity of these applications has scaled, the task of making them scalable and performant has become sisyphean.  Web developers have always needed to deal with issues of cross-browser compatibility, interactions with different operating systems, etc.  But now more and more we are talking about the limited capabilities of the browser itself and how it doesn’t manage memory in our Javascript applications the way that we are magically accustomed to.  For all the RIA frameworks we have today – Flash, Silverlight, JavaFX, etc., there’s still only one platform we can count on to deliver client-centric browser applications, and that’s Javascript.

So when the cost of delivering these solutions begins to increase incongruently with the complexity of the functionality we are looking to deliver, what are we to do?

An interesting thing happened the other day in the mobile application space.  iPhone development – typically the domain of pompous Mac owners like myself and a few willing Webkit jockeys, suddenly opened it’s doors to Adobe’s Flash platform.  After months – no, years of wrangling – Adobe has finally found a way to play on Apple’s lucrative mobile platform.  But this isn’t Keith Peters’ Flash.  This is Actionscript being compiled magically into native iPhone runtime applications.  It’s a stunning development, one drawing ire and concern about performance.  But it’s not the first time that a development platform hailed for it’s scalability and ease of entry now has been used to usurp a underlying native platform which has proven to be a barrier in and of itself into development for the target platform.

Google Web Toolkit started the latest generation of application development, with it’s seeds in Microsoft .Net’s CLR.

As I noted, Javascript development today is hard.  It requires a significant amount of skill and experience to do right, and there’s simply not enough talent around to deliver the types of applications that every web site should be delivering.  There are fantastic software platforms written in C – but as we saw in the initial explosion of web applications, C is not a language that lends itself well to a pool of experienced and cheap labor.  PHP was that language.  Perl was that language.  It distilled down the concepts an engineer needed to know about to deliver a reliable application and simplified those concepts – memory management, semaphores, I/O, etc.  It allowed engineers to focus on solving the business problems of the dot-com boom and subsequent flurries of enterprise IT demands.  Now that the nature of those problems have changed – PHP as a tool is simply a square peg for a round hole.  And given the dreadful performance of our target operating environment, an interpreted language on top of Javascript is not an option.  What is an option is another language platform that could be compiled into JavaScript, complete with optimizations for memory management and portability.  GWT made Java the potential language of choice when it came to RIA development in Javascript.  It once again gave power back to engineers to be able to focus less on the non-functional needs of the application and put the focus back on fulfilling the functional requirements.

While the performance of GWT is stunning and it’s architecture a stark deja vu of past optimizations approaches to software compilation – our other example may not quite have the grit.  Compiling ActionScript to Objective-C is a nice trick, but may only solve the problem of heterogeneous development environments for Flash developers who haven’t had the guts yet to get into Cocoa development.  Natively, Objective-C is rather optimized, with device performance on the iPhone of platform applications running remarkably well.  So the compiler optimizations that web applications gain from GWT development aren’t really there.

But guns are certainly drawn on the problems of complex platform development, whether it be the arcane and aging Javascript platform in the modern web browser or the stifled promise of mobile application development.  For years, the complexity of executing a piece of software on a mainframe (or older system) acted as a significant barrier to delivery of commercial software.  The innovation of the compiler changed all of that.  Fast-forward 50 years later and we see the same problem, and the same solution is staring right at us.  The odd natural selection of software languages will repeat itself it seems.  Once again, the compiler saves the day.

So understanding how a unit test is traceable back to a technical design on an agile team is really a key differentiation between an approach that more closely resembles cowboy coding and an approach which is relatively holistic.  No scrum master, project manager, or even architect would advocate full designs in an agile environment – instead we opt for lighter weight approaches to technical design that provide a blueprint to the code.  For many teams, this is a CRC card – a simply way of documenting the various dimensions of an object-oriented unit.

What is a CRC, and how does it relate back to tests?

Class

The core unit of code that we will refer to is the class, but this can be really any aggregation – a function library even.  This represents a loose collection of related functionality that leverages common resources, represents a concept of actions or identity, or extends existing functionality.

Responsibilities

The responsibilities of the class form it’s raison d’etre. Commonly, we can analogize responsibilities with methods, but they may be more coarse grained – and our refactoring may indeed refine the level of detail with which we understand the functional responsibilities of the class.

Collaborators

From an interestingness perspective, particularly in the context of unit testing and mocking (or stubbing), collaborators really take the cake.  When we talk about dependency injection as the core pattern of test-driven development with mocks, collaborators are indeed what we are injecting into our class to power it.

I always ask my green developers to think about these things before starting any sort of development.  Once their CRC is done and we agree on the approach, I ask them to build the programming interface, stub the implementation, and then start writing tests.  A common example I like to use when I get that befuddled look is the idea of a car.  A car has a lot of complex stuff going on that if I needed to test dependent functions of the car against, I wouldn’t want to have to concoct all of the function they provide.  For instance, the engine is a complex piece of machinery – but if I solely want to to test how my transmission reacts to engine behavior – it’s the transmission class I want to ultimately test, and it’s reactions to different engine behavior.

Let’s bring it up a level and talk about a Car as the core class.  We want our car to be able to do two things – to have two responsibilities: accelerate and stop.

public interface Car {
   int accelerate(int additionalVelocity);
 
   void setTireGrip(int gripFactor);
 
   int stop(int overDistance) throws CannotStopException;
}
 
public interface Motorable {
   int injectGasoline(int mlOfFuel);
}
 
public interface Stoppable {
   int applyBrakes() throws PadException, RotorException, WetRoadException;
}

So we’ve defined 3 interfaces. Let’s say that I’m really interested in a case where I test how the car reacts to different stopping conditions. Now, I’m demonstrating this in Java, so I’ll use syntax similar to Mockito – but the rules are the same: I’m interested in testing the requirements of the car observing the expected behavior of the brakes in those conditions. When the grip is set low, we expect the braking system to respond negatively and lock up.

We’ll also assume for now that I’ve stubbed out a skeletal implementation of the Car interface (meaning that everything throws a NotImplementedException for the time being).

@Test
public void testWetRoadConditionsWithLowFriction() {
 
   // arrange
   Stoppable s = mock(Stoppable.class);
   Motorable m = mock(Motorable.class);
 
   Car c = new CarImpl();
   c.setStopAbility(s);
   c.setMotor(m);
   c.setGripFactor(3);
 
   when(s.applyBrakes()).thenThrow(new WetRoadException());
 
   try {
      // act and assert - no real assertion, we're expecting an exception
      c.stop(100);
      fail("Should have seen a CannotStopException - there's not a lot of grip for road when road conditions are wet");
   } catch(CannotStopException e) {
      // do nothing, we're a success!
   }
}

As you can see, we’re not actually testing the brakes – we’re testing that under the given conditions that when the Stoppable interface throws an exception that prevents our car from stopping successfully that we are throw our own CannotStopException in response. The stoppable interface is a collaborator; we are not interested in this case in unit testing it, we are interested in asuming a known behavior from it, and testing how the stop() ability of the Car implementation reacts to the WetRoadException that we have stubbed.

The alternative in the past would have been to actually create the implementation of Stoppable. But having to unit test both items makes it difficult to isolate implementation issues.

So ultimately young developers, your unit tests need to test a single responsibility and not the responsibility of your collaborators. You may eventually test how the two implementations interact – that is an integration test. Ultimately though, there is more value in testing each individual unit and ensuring that the code is built to the spec of your lightweight design. Then you can isolate integration issues and write tests that specifically address finding integration problems.

While I’m still yet to try on some of the AJAX support – something that makes or breaks a web framework these days – Wicket‘s clear separation of concerns and robust architecture for MVP (right, ‘P’, as in Model-View-Presenter) has really impressed me.  Generally speaking, I have not been one to embrace convention over configuration in frameworks like RoR, simply because it seems non-scalable.  But given it’s pure focus on UI and it’s total flexibility to do whatever the hell I want with my middle tier, I’m feeling that when restricted to the presentation layer – the paradigm works.  Wicket is pretty programmer-centric, so unlike RoR, you’re not going to get off the ground without some skills or a scaffolding framework like Wicketopia, but I’m not at all convinced this isn’t a bad thing.

There are a couple of things that I could get enthusiastic with around Wicket, were someone – including myself – to improve them.

1. Documentation. Look, I hate documenting things as much as the next guy – but in as much as I’ve enjoyed the fruits of my labor in Wicket, I have not enjoyed chasing down information to all ends of the globe.  I love the fact that this is working software, and the curve isn’t too steep – but try finding stuff on form validation, or the entire concept of mounting URL paths.
2. Callbacks, anyone? So, forms in Wicket generally appear to be processed by the onSubmit() method of the Form class.  You override this in your child class of form.  This is the very object-oriented way of doing things, but it seems a touch limiting out of the box to not be able to register callbacks on this method.  My Form class exists so that I can have more than one of these per page, no doubt (take THAT ASP.NET), but I still think that I’d like to be able to actually register callback handlers as I wish in each Page, thus allowing Forms to have different behaviors dependent on where they are used.  I’m pretty sure this isn’t the 80% use case, but I still am left with only one alternative out of the box, and that’s to keep extending the class hierarchy.  It’s nice to embrace strategy pattern and all, but to me this is where we really need an observer.

   So I was able to fudge this myself by creating a FormSubmitListener interface, subclass Form and implement it’s onSubmit() to call the formSubmitted() method from my new interface, it’s own implementation registered through the constructor on my Form subclass – but I think in an MVP or MVC framework, I still would like the ability to use OOP to handle the quirks of the page lifecycle (yeah, yeah – Wicket is unmanaged), but allow observers to actually handle pseudo-user events.

These two things aside, I feel pretty at peace with Wicket as my web framework for Java projects going forward (sorry Seam).

Another note – I’m really interested in the possibilities of packaging all of the resources for the web project in the JAR file.  While WAR’s are fine for deployment, JAR’s make the application open for truly modular design.

Now to refresh my memory on getting JTA running in a pure servlet container…

All in all, I’m very pleased.

The m2eclipse plugin is marvelous, finally.

The day has finally come where I’m no longer fighting Eclipse to build projects using Maven, as it should be.  Maven ties far too many niceties of the world together, and to not have it as the underlying, portable build tool within the IDE has always frustrated me.  The ability to quickly start a new Maven project, apply an archetype and go is fantastic.  The fact that it doesn’t require special jazz to get a WTP project up and running is even better.

Hey look, working with my database and some JPA implementation is really easy!

…well, almost easy.  I created a project for my middleware just using the quickstart archetype.  I was just going to throw Spring on top of it and avoid spoiling the good experience so far with EJB insanity.  The next thing I wanted to do was load up my database tables as ORM classes via Hibernate.

For whatever reason, this was cool on my Mac.  Project Properties…JPA Tools…Generate entities.  This is somehow not the way to do it over in windows.  So instead I tried to add JPA as a project facet.

My first problem was that I didn’t have Hibernate set up as my default JPA provider.  Unfortunately, you can only do this through the Maven-managed dependencies.  It has to be an Eclipse user library.  So I download the Entity Manager and wire it up into Eclipse.  Add the Java Facet (somehow not a default, probably Maven’s fault), added the JPA Facet (and am told I need to add the Utility Facet, so I do that).

Further configuration required.

Ok.  So I click into this further configuration and it reasonably wants to know how I connect to the database.  Fair enough.  I do all this, and it still won’t let me apply the change.

Eventually, it appears you need to add the Java project facet first, and then and only then can I reopen the properties page and apply the JPA facet.  A frustration point, but I figured it out.

Hey, nothing special to get a project with the Wicket archetype running in WTP.

I start a separate web project and use the Wicket archetype, interested in tackling what looks to be a nice, lightweight UI package for Java (though it looks like Spring integration isn’t trivial – which is basically unacceptable these days).  I start the project, I add a server configuration, and deploy…

Holy crap, it works out of the box!

I have a ways to go, but things feel more turnkey with Eclipse than I’ve ever experienced.  I did up some JUnits with Mockito, and that was easy, indicating that if I were to set up Cruise or some other CI tool, I could quickly get going with a full Agile project.  Exciting stuff.