For my particularly used case, I wanted something very lightweight and easy to integrate into my existing framework. I ended up going with QUnit, basically because it was (a) simple; (b) popular; (c) consisted of two files; and (d) had plenty of “getting started” articles I could template off. I’ve been very happy with it so far.

If you have JUnit background and are curious what a JavaScript testing library looks like, check out a sample test:

test("You can't handle the truth", function() {
  var someTrueExpression = true;
  ok( someTrueExpression, "True expressions" );
});

test("Equals, and not so much", function() {

  var actual, expected;
  actual = expected = 2;
  equal(expected, actual, "Basic comparison" );

  notEqual(expected, 3, "Asserting not equals");

});

One thing I really like about QUnit is that it makes things very easy to get started. Basically you create a html file with elements for each of the test results, and QUnit looks after the runner and markup of the output. Just add a single QUnit.js file and a supporting QUnit.css and you have a:

So what does a complete QUnit test page look like? Here’s something you can cut and paste and get started:

   

   

 

 



Basic QUnit Demo




test markup

JavaScript has some special language support around equality (the string example is a classic since 2 == “2″ in JavaScript, but 2 !== “2″). So you can do strict and non-strict equality:

test("Equals edge cases", function() {

  equal("2", 2, "Equals are not strict");

  // but this will fail...
  strictEqual("2", 2, "Strict type equals");

});

There’s also great support for test suites with the standard setup() and teardown() type functions you’re used to:

module("Control Flow", {
    setup: function() {
        console.log("Just some setup stuff")
    },
    teardown: function() {
        console.log("Just some teardown stuff")
    }

});

There’s also support for exception assertions that can be pretty handy:

test("Exceptional stuff", function() {
   raises(function() {
    throw new Error("World of pain");
  }, "Ensure error is thrown");
});

There’s certainly plenty to learn around the async parts of JavaScript (such as unit testing Ajax calls), and that’s next on my list for exploration (along with automated test runners for JavaScript testing).

But if you’re after a first exposure to how JavaScript unit testing libraries hang together, QUnit is definitely worth a look! Great stuff!

The issue with iPod/iPhone bookmarking is that the Safari Mobile bookmarking icon is so ambiguous that very few people know what it does! We were after a solution for allowing the user to easily add the bookmark to their Home screen, but not get too naggy. Enter a cool little JavaScript lib called Mobile Bookmark Bubble. Here’s the app in action:

The library does the appropriate content-sensing so that it only activates on iPhone/iPad/iPod touch, and make use of some HTML5 local storage to make sure that if you cancel it away, it won’t come back again (using a nice fadeout after a few seconds of display).

The library ships with some example code to get you up and running quickly, and let’s you use custom metadata elements to point to a custom icon for this app (in my case 128×128 since I’m re-using the standard apple-touch-icon.png mechanism and that size looks slick rescaled on the iPad).

Anyways, it’s a pretty niche lib that does what it does perfectly. Bravo! Just what I was after!

Anyways, I’ve been doing some client work on JEE6 lately, and I was so inspired by Adam Bien’s live coding talk at JavaOne 2010, I’m going to try and reproduce it locally! It’s no Grails, but EE6 gets a lot of things right! I’ve been very impressed with it. The abstract for the talk is:

Learn some of the new enterprise features in Java EE6 which can dramatically improve developer productivity by eliminating boilerplate code, fully embracing annotations and adopting the “convention over configuration” paradigm. In this live-coding workshop, we’ll develop a scalable, data-driven, multi-tier, REST-exposed, JSON-friendly Web2.0 application from scratch in under an hour!

Should be a really fun talk! I’m going to follow Adam’s pattern start from a clean slate and just code for an hour talking about EE6 features as I add them:

• Implementing a simple EJB3.1 service (@Stateless)
• Invoking it from a JSF view layer via CDI (@Named)
• Injecting an EJB into a controller and binding form parameters (@EJB)
• Persisting and Typesafe Querying via JPA2 (@Entity and @NamedQuery)
• Exposing the EJB Restfully and invoking creates and qeuries through content negotiation (@Path, @Produces, @Consumes)
• Implementing a AOP-style logger over the EJB methods (@AroundAdvice)

It’s going to be a great time. So if you’re free and in Canberra on Wednesday the 14th October, drop on by the Dev Stream at the Oracle JUG at 10am for the talk.

The code will be flowing freely… I hope…

The plans for the Groovy and Grails BOF at JavaOne are coming together and it’s gonna be a “full on double rainbow all the way across the sky” experience. “But what does it mean?” Glad you asked.

This year we have our most comprehensive panel ever! We’ll have Peter Ledbrook (Grails Evangelist and Grails in Action co-author), Guillaume Laforge (Groovy lead), Andres Almiray (Griffon lead and Griffon in Action author), Dierk Koenig (Groovy in Action lead), and hopefully a few more surprises.

This is a fantastic opportunity to catch up on the latest product roadmaps for Groovy, Grails, and Griffon, and ask questions from the floor directly to the product leads themselves! It’s going to be one fantastic get-together for the Groovy community.

Of course we’ll be recording it all for a special edition of the Grails Podcast and we’ll be kicking on to a local haunt to test out our awesome Pool skills while shooting the breeze on metaclasses, mixins and other Groovy love.

Make sure you put it in your schedule (S313988) for 7:30 PM on Monday night! It’s gonna be fantastic! See you there!

First of all, Beginning Java EE6 with Glassfish 3 came at a time when one of our clients requested we implement some JPA2 infrastructure (around EJB3) for them to store some JAXB objects coming in via JAX WS. I’d worked with earlier versions of all of these technologies, but wasn’t across the latests spec changes in EE6 (which was their preferred stack). So this book was a $10 special on exactly the right day for me!

First of all, this a a sensational title if you have a background in Java EE. It was basically the single volume I needed to get up to speed with all the latest specs in a hurry. The examples are all Maven-based, the sample code is simple but genuinely representative of the kinds of issues I was facing, and the coverage is across the whole EE stack.

What I like most about this book, however, is the the author has done a lot of thinking about the ordering of concepts. The book progresses nicely from JPA2, through EJB3, Transactions, the Web Tier (JSF) and finally on to JMS, Web Services , REST, and JAXB. It’s all covered in the right order! (We spent a lot of time writing and rewriting in an attempt to get this right in Grails in Action so I appreciate the effort). The author is on the EE, JPA2 and EJB3.1 Expert Groups, and it shows in this material. Lots of useful tip and tricks covered along the way and heaps of things I didn’t know.

Be warned though, you need to know that this is a book on “Beginning Java EE6″ even though the byline is “From Novice to Professional”. Even in 450 pages, you won’t find a deep-dive on all the EE concepts, or detailed coverage of every JPA option. The only point this really bothered me was in JPA2 Criteria Queries. This is a pretty important new part of the spec, but doesn’t get a mention here. Even things like TypedQuery didn’t get a shout-out. (BTW, if you’re looking for a JPA2 Deepdive, Java Persistence with JPA is a great, albeit dry, alternative -which is also a $10 ebook!).

If you have some background in Java EE, but you haven’t made the switch to Java EE6, this is definitely a title that you’ll want in your library. A fantastic survey of all the APIs, with genuinely useful background tips, source code and discussion.

Interestingly, it seems that Apress have dumped their DRM protection on PDFs (used to have a password-based protection), which is great news for everyone using PDFs on their e-readers etc.

If you’re looking to step up to JEE6, this one is definitely worth having… and if you can snag it for $10 it’s a fantastic bargain!

Oh. And once you’ve had your fill of JEE6, go and grab a Grails Book and take your JEE productivity to a whole new level.

First, I’m super excited that there is now a title dedicated purely to Groovy DSLs. Every time I hear Guillaume or Paul talk about DSLs I get swamped with great ideas that I’ve never really had time to explore. This book gave me a reason.

First up, this book is intentionally targeted to straight Java devs, so you get a lot of space devoted to things that even casual Groovy guys will already know. There’s the inevitable chapters on Groovy essentials, using the standard builders, Java integration, and even a chapter devoted to teaching you Grails! (Some people spend entire books on just that.. but I digress. To be honest, this would not serve you well as your first book on Groovy, so I’m not sure some of that content was well served, but I can appreciate the publishing pressure of reaching the widest possible market, and the background material is well done.

What I was really hoping for was some coverage of DSLs from the ground up, and I was really happy. The author spends the whole of Chapter 3 just on closures. This is well worth it. There are tons of edge cases here that I wasn’t across and I really appreciated the dedicated coverage. Straight after you do the closure deepdive, you spend chapter 4 retrofitting Twitter4j with your own basic DSL. The examples were exactly at the right level here, and I was loving the gentle pace.

Chapter 5 moves on the standard Groovy builders to give you a feel for some of the standard DSL strategies, but this is space better covered in the Groovy in Action though usefully introduced here. Seasoned groovy programmers will find this fairly skippable, but Java guys will be served with a good grab-bag of examples to clarify their thinking.

Chapter 6 is another “examples” chapter, this time with Grails, Gant and a range of BDD tools (including Spock). Given the spread, the chapter is long but terse and I would liked to have seen chapters 5 and 6 collapsed into a tighter chapters of “DSLs to shape your thinking”.

Chapters 7 and 8 deep dive on Builders and writing your own DSLs – and these represent the heart of the book. Tons of good information in here that you’ll only find scattered across tons of Wiki pages. The book is worth it for just these chapters. You’ll get a feel for builder strategies, along with a “from scratch” DSL creation. Great info in here. I’ll reference these chapters a lot when I work up the keen-ness to tackle my own DSL.

Chapter 9 rounds out the book with a Java/Groovy integration chapter. Didn’t quite follow how this linked to the DSL concept, but if Packt were only going to release one Groovy book, I can see why this material would be good background.

Overall? I’m really glad there is now a dedicate DSL book! This a really solid book on Groovy DSLs that doesn’t shy away from the hardcore material, but still gives you the stepping stones to get there. To be honest, this book could be a lot better if the editing team took a knife to a lot of the non-DSL stuff and sharpened up the book’s vision. The material is well-written though, and I’m sure I’m going to be referencing this material.

While the next version of Groovy in Action promises a dedicated chapter on DSLs, this Packt title gives you a good fill of DSL-centric material to implement today. A solid book that’s definitely worth a look if you want to explore DSL creation more seriously.

Happy DSLing!

Converting your WSDL into a set of JAXB classes is super simple: Use your IDE or the very cool Maven Plugin to get you up and running. But annotating those generated classes with JPA annotations on the way through? That’s a little trickier. Fortunately wsimport just invokes the JAXB compiler (xjc) under the cover, and xjc support plugins! You know where we’re going here..

Enter hyperjaxb3. This very slick little library provides an xjc plugin to markup your JAXB classes with JPA annotations. It will even generate your persistence.xml file on the way through. Most importantly of all, it knows how to work around the known incompatibilities between JPA and JAXB (for example, that your xsd:date entries will get marshalled to javax.xml.datatype.XMLGregorianCalendar which is not a supported type for JPA).

Hyperjaxb3 works around things like this by providing @Transient getters and setters for the XMLGregorianCalendar methods, whilst generating native JPA getters and setter for standard java.util.Date classes. Very tricky.

Hyperjaxb will also handle collections cleverly, so List gets marshalled off into its own 1:m table. It means that complex graphs will generate lots of tables, but everything worked for my prototype which was a very complex schema. I’m super impressed.

It took several days to get all the dependencies right, and it did involve copying jaxb and jaxws jars into my jdk1.6.0/jre/lib/endorsed folder – so I thought I’d put up a sample POM below to save you some time. I’m not sure that the approach is even going to work under scale, given the complexity of the graph. I suspect we’d be better off writing a simple JPA wrapper class that we marshall via Dozer but it does give the client their preferred option to explore.

To save you some time, I’ll provide a Sample Maven POM that is wired up for everything you need to get yourself up and running. Just add your favorite IDE and you’re in business. Oh, and don’t forget that /jre/lib/endorsed thing.

Happy transformations! ]]> http://blogs.bytecode.com.au/glen/2010/07/29/from-wsdl-to-jaxb-to-jpa-with-a-single-schema-adventures-in-hyperjaxb3.html/feed 2 http://blogs.bytecode.com.au/glen/2010/07/15/my-nosql-for-java-devs-slides-are-now-online.html http://blogs.bytecode.com.au/glen/2010/07/15/my-nosql-for-java-devs-slides-are-now-online.html#comments Wed, 14 Jul 2010 23:53:00 +0000 Glen http://blogs.bytecode.com.au/glens/2010/07/15/my-nosql-for-java-devs-slides-are-now-online/ Had a fantastic time last night with the guys at my local Canberra JUG giving a presentation titled “NoSQL – Life Beyond the Outer Join”. I’ll embed the slides further down.

In the talk we looked at four different types of NoSQL options for Java guys: Simple Key/Value in-memory stores (Memcached), sophisticated distributed key/value stores (Voldemort), Document Databases (CouchDB), and Graph Databases (Neo4j).

We also had a play with the common java clients that are used to access them: Spy for Memcached, Ektorp for CouchDb, and the bundled libs for Neo4j and Voldemort.

I’ve put all the source up on a Bitbucket Project which you can clone. It’s all Mavenized, so you can knock yourself out with whatever IDE works for you. If you’re on Windows, I’ve also included links to the download pages of the various servers on the BitBucket Wiki Page for the project.

Thanks to the bunch of folk that turned up on the night. It was great crowd full of interesting questions and discussions!

Happy NoSQLing!

Hmnmm… That’s ok, so I thought I’d just open it up as a “free-form” Netbeans project, but that’s no good either, since Netbeans complains that it’s already a Netbeans project! After a bunch of mucking around, I found out the problem, I was missing a plugin! But which one?

If you open up the nbproject/project.xml file will have something like this:

    org.netbeans.modules.j2ee.earproject
     ...

So that type element gives you the skinny. In this case I was missing the EAR project plugin. Once that was installed, the project opened up just fine. Thought I’d blog it up to save you some google time down the track.

Happy recognised projects!

Will slideshare up the slides, and bitbucket up the source, once I’ve done the presento. Till then, here’s the blurb for the night:

Abstract

The NoSQL (Not Only SQL) movement has been gaining a lot of press over the last year as a means of scaling massive data storage, complex relationships and lightening fast retrieval for the Web’s biggest sites. This month we’re taking a trip to the big end of town and looking at some of the backend technologies that are powering sites like Twitter, Facebook, LinkedIn, Reddit, Digg and Google.

We’ll be looking at popular Java clients and servers that play in the NoSQL space and have a brief survey of the following popular NoSQL platforms: Document Databases (MongoDB/CouchDB), Sophisticated Key/Value Stores (Cassandra), Graph Databases (Neo4j), and simple Key/Value stores (Memcached). It’l be a lightening tour of what each technology offers, some source code on how it works, and lots of headshifts about how to store data such that you don’t ever need another Left Outer Join!

We’ll have a lot of fun, you’ll pick up a bunch of new buzzwords to impress your peers, and you can take the source away and play at home. Put it in your diary now!

About Glen

Glen is a hardcore Java trainer and speaker, co-author of Grails in Action from Manning, co-host of the Grails Podcast and a former winner of Australian Masterchef. He blogs at http://blogs.bytecode.com.au/glen and Twitters at http://www.twitter.com/glen_a_smith.