unit on SWiK

lincolns hires outfit all london airports covered

Sat, 06 Sep 2008 03:59:35 -0700

mercedes hire

Sat, 06 Sep 2008 03:10:26 -0700

search engine placement company

Sat, 06 Sep 2008 01:57:19 -0700

limo reservig for books many destinations catered for

Sat, 06 Sep 2008 00:02:55 -0700

Limo London

Fri, 05 Sep 2008 23:56:58 -0700

search engine placement company

Fri, 05 Sep 2008 21:47:43 -0700

heathrow Airport Transfer

Fri, 05 Sep 2008 19:48:12 -0700

8 seater renting operation anniversary specialist

Hummer Limo

Fri, 05 Sep 2008 01:49:19 -0700

driver booking limited company luton stansted heathrow gatwick

London Airport Transfer

Thu, 04 Sep 2008 22:59:33 -0700

driver rental industries at heathrow and gatwick

scalacheck - A BDD Library for Scala

Thu, 04 Sep 2008 07:02:42 -0700

Dr Nic " Unit Testing iPhone apps with Ruby: rbiphonetest

Sun, 31 Aug 2008 18:01:42 -0700

The Best iPhone 3g Source Unit for Your Car, The Pioneer DEH-600UB

Sat, 30 Aug 2008 03:01:16 -0700

http://www.hirelimolondon.co.uk/index.html

Fri, 29 Aug 2008 20:41:36 -0700

Eclipse 3.3 - New and Noteworthy

Fri, 29 Aug 2008 08:59:38 -0700

This is the documentation of Eclipse 3.3 for users java

How to unit-test code that interacts with a database

Tue, 19 Aug 2008 19:03:09 -0700

I got some interesting comments on my previous article about unit testing Maatkit, including echoes of my own conversion to the unit-testing religion. One of the objections I’ve heard a lot about unit-testing is how it’s impossible to test code that talks to a database. “It’s too hard,” they say. “Oh, it’s easy to test a module that calculates a square root, but a database? Way too much work!”

Is it really impossible or even hard?

I disagree. In one of my previous articles I said The Rimm-Kaufman Group, my previous employer, has a comprehensive unit-test suite. When I say comprehensive I mean it: database interaction is fully tested, too. I know because I was heavily involved in building it. Even extremely complex things like big reports that are generated from lots of data are tested. And believe me, sharding the databases would have been much harder without complete code coverage. It’s really not that complicated to unit-test against a database, and it’s so worth it. Here are some hints about how you can do this.

There are many ways to do it, but I’ll just describe the basics of the system I helped build. There are several moving parts to the test suite (”smoke“), but one of them sets a magical environment variable. And then, all code that connects to a database server magically gets back a different database connection from the create_me_a_connection() function. This is because there is a database connection abstraction library that respects the environment variable. It’s really pretty simple for the most part; instead of doing DBI->connect(…) you just call this function, which is a thin wrapper that hands back a connection object.

This wrapper is itself unit-tested thoroughly, too. This ensures that when some code is being run from a test, it cannot (I mean cannot!) connect to a production database, and vice versa. There are some conventions about production and test servers that make sure the abstraction library can tell for sure. If there’s any confusion, of course, it will die in a non-recoverable way. Safety first.

Building a good development environment

Just as each developer has their own copy of the code from version control, each developer has their own private database server running on the dev machine. There are some simple conventions that make this possible: Unix user ID plus a constant for the port number, etc. It’s really quite easy. The private database server is a slightly modified version of Giuseppe Maxia’s MySQL Sandbox tool. It can be torn down and set up afresh as desired. It is wiped clean and re-filled at the start of every test, with a small, tightly focused dataset carefully chosen to represent the conditions the code is supposed to work with. (Each test has its own dataset).

If this sounds like a system that can’t work on a large scale, well, it does. That’s the secret sauce that I won’t reveal in this post. (It’s my past employer after all, and I can’t go revealing everything about them can I?) You just have to be smart about it. When a database is central to your business, you either figure out how to get this right, or you pay the consequences in lost time and poor code quality.

I and the other developers there (another secret: it’s a small team; small teams build great things) built several quick utilities to help develop unit tests against a database. There are utilities to get a minimal necessary dataset for testing and dump it into a file that can be loaded by the test. There are utilities that can migrate schemas and update the tests to match the schema changes. And so on, and so on. This is possible because of careful planning for testability, and really smart things like super-consistent and sensible naming conventions for database objects. (Ruby On Rails owes a lot of its success to simple things like this, too. Conventions are really powerful.) Maybe I’ll write about the database naming conventions some other time — I have to credit Alan Rimm-Kaufman a lot for designing those conventions. It was a stroke of genius.

Things to avoid

There are several things I do not recommend doing when you unit-test code that talks to a database. I’ll just mention a couple:

mock

test an implementation instead of a behavior

Never let a test connect to a production database. Never, ever. Worlds of hurt will follow. Not only are you risking your production data, but what about the risk to your code? You’re testing against things that will almost certainly change and break your tests; and you’re possibly polluting your live data with testing data and/or changing live data from the tests.
I also recommend developing unit tests for your current database functionality if you’re thinking about changing it much. Don’t like MySQL’s lax error handling? Plan to set the SQL_MODE to something stricter? Dive into that database abstraction library and make your tests run in strict mode first by setting SQL_MODE on every new connection that’s created when running inside a test; fix all the breakage in the test suite; feel sure that your code isn’t going to break in production. That was easy!

Summary

Once your creative juices get flowing, you’ll see tons of places your unit test suite can help you out.

If you’re in the Oracle or SQL Server world, or any other world where you can’t just set up and discard database instances at will due to licensing problems, you’re going to have to be a little more inventive. But you can still do it. (Don’t you wish you’d chosen Freedom?) And unit tests are just as beneficial for apps based on Oracle as they are for MySQL.

Have fun! Go forth and test some more!

mysql, Test Driven Development, testing a database, The Rimm Kaufman Group, unit testing

" Blog Archive " JMeter

Tue, 12 Aug 2008 10:04:33 -0700

MockMe: A new JavaScript mocking framework

Mon, 11 Aug 2008 07:13:03 -0700

Johannes Link is an Agile fellow who wasn't 100% happy with the existing JavaScript unit test frameworks, and he explained why. He gives an example:

PLAIN TEXT

JAVASCRIPT:

testDoubleSpeaker: function() { with(this) {
var actualMsg = null;
var mockSay = function(msg) {
actualMsg = msg;
};
Speaker.say = mockSay;
DoubleSpeaker.say('oops');
assertEqual('oopsoops', actualMsg);
}}

It works, but he discusses how this changes the global world, which is a bad thing. Would it be nicer to spy and end up with:

PLAIN TEXT

JAVASCRIPT:

testDoubleSpeaker: function() { with(this) {
mock(Speaker).andDo(function() {
DoubleSpeaker.say('oops');
verify(Speaker.say)('oopsoops');
});
}},

This is an example from his new framework, MockMe, which has the main features:

The basic granularity of mocking should be the function. If I want to, I can fake the behaviour of a single function without influencing the rest (of an object or a prototype or the global namespace or whatever).
Most of the time, spying is a better idea than mocking because it’s simpler. Spying basically means that, instead of specifying the expected interaction with your mock spy object before doing the test, you use the mock spy object to spy into the interaction as it happens and verify that afterwards. In that respect I borrowed heavily from mockito, a spying framework that’s gaining more and more attention in the Java world.

A few other examples:

PLAIN TEXT

JAVASCRIPT:

when(f)('in').thenReturn('out');
assertEqual('out', f('in'));
when(f)({name: 'hello'}).thenReturn('yeah');
assertEqual('yeah', f({name: 'hello'}));
when(f)(any()).thenReturn('yeah');
assertEqual('yeah', f(1));
verify(times(2), f)(1); //succeeds
useMockerFor(function(mocker)) {
mocker.within(MyObject).mock('f1');
when(MyObject.f1)().thenReturn(5);
assertEqual(7, MyObject.f2());
} // Here everything you mocked will automatically be restored
assertEqual(3, MyObject.f2());

specs - Google Code

Sat, 09 Aug 2008 16:12:11 -0700

http://www.w3.org/2007/ont/unit

Sat, 09 Aug 2008 07:09:17 -0700

Spring-Loaded

Thu, 07 Aug 2008 13:18:49 -0700

Cobertura Command Line Reference

Thu, 07 Aug 2008 13:12:59 -0700

Cobertura Command Line Reference

Sat, 26 Jul 2008 11:00:34 -0700

Spring Tips: Unit test with Spring Dynamic Modules

Wed, 23 Jul 2008 08:54:40 -0700

Spring Tips: Unit test with Spring Dynamic Modules

Wed, 23 Jul 2008 08:54:31 -0700

Ruby Programming/Unit testing - Wikibooks, collection of open-content textbooks

Sun, 20 Jul 2008 22:47:37 -0700

google-toolbox-for-mac - Google Code

Sun, 20 Jul 2008 21:47:28 -0700

Unit Testing C++ Programs using CppUnit in Eclipse IDE on Windows

Sat, 19 Jul 2008 12:45:08 -0700

Ruby Programming/Unit testing - Wikibooks, collection of open-content textbooks

Fri, 18 Jul 2008 08:53:33 -0700

As in other languages, Ruby provides a framework for setting up, organizing, and running tests called Test::Unit.

Stun Gun with Flashlight!

Fri, 18 Jul 2008 06:00:06 -0700

Definitely in today’s society, you might want to consider getting a Stun Gun to protect yourself. Of course, a gun can do the same job but it may kill someone while the Stun Gun doesn’t.

This Stun Gun is made of high quality ABS engineered plastic, this unit functions as a very powerful high voltage (200K) shock generator and a extremely bright flashlight in a very small and light weight package.

Very powerful and loud discharge will surely scare away any potential attacker.

via spygadgets

Brought to you by: Zedomax.com

Stun Gun with Flashlight!

Embedded JBoss / Embedded EJB3 - Shrubbery

Fri, 18 Jul 2008 03:58:02 -0700

unit on SWiK

lincolns hires outfit all london airports covered

mercedes hire

search engine placement company

limo reservig for books many destinations catered for

Limo London

search engine placement company

heathrow Airport Transfer

Hummer Limo

London Airport Transfer

scalacheck - A BDD Library for Scala

Dr Nic " Unit Testing iPhone apps with Ruby: rbiphonetest

The Best iPhone 3g Source Unit for Your Car, The Pioneer DEH-600UB

http://www.hirelimolondon.co.uk/index.html

Eclipse 3.3 - New and Noteworthy

How to unit-test code that interacts with a database

Is it really impossible or even hard?

Building a good development environment

Things to avoid

Summary

" Blog Archive " JMeter

MockMe: A new JavaScript mocking framework

specs - Google Code

http://www.w3.org/2007/ont/unit

Spring-Loaded

Cobertura Command Line Reference

Cobertura Command Line Reference

Spring Tips: Unit test with Spring Dynamic Modules

Spring Tips: Unit test with Spring Dynamic Modules

Ruby Programming/Unit testing - Wikibooks, collection of open-content textbooks

google-toolbox-for-mac - Google Code

Unit Testing C++ Programs using CppUnit in Eclipse IDE on Windows

Ruby Programming/Unit testing - Wikibooks, collection of open-content textbooks

Stun Gun with Flashlight!

Related posts

Embedded JBoss / Embedded EJB3 - Shrubbery