Rspec is the most enjoyable of the three, and it has one convinence feature that neither of the other 2 has: you can mock individual methods of a objects while still leaving the other methods intact. So, for example:
What you can do in Rspec is mock out the method do_that, but still leave do_this intact. Then what you do is call do_this and verify that the mocked out do_that was called. Below is how it's done:
var control = new MockControl()
var mock = control.createMock(MyObject)
The magic happens on line 3 which replaces the doThis() method of the mock with the real doThis() method coming from MyObject's prototype(If you don't know that a prototype is, watch Douglas Crockford's videos).
Mockist testing in Java really sucks compared to Ruby, this is because you have to create a interface for everything single method that you want to mock independently. This causes interface-iitis(as promoted by the spring people and practiced my the eclipse people), which I really detest.
There are things that are not that easy to test still with mocks. This is especially true for Java. What I did with Java was extract 3 or 4 interfaces just so that I could test them, but there are methods that I wish to against each other in the same class independently but just don't want to extract yet another interface, for that I really don't know what to do, maybe I'll just have to do that as an integration test.
I also reread Martin Fowler's essay: Stubs Ain't Mocks which gave me a lot of insight and reaffirmed some of the experiences I was having(the first read was quite confusing not having any hands on experience). I think at the end there's a balance somewhere about which approach to take(classic or mockist), and it depends on the situation.
More updates to come. I have just gotten started with this, so I am sure I'll learn more as I go.