Test Driven Development – A Win-Win strategy

Agile practitioners talk about Test Driven Development(TDD), so do lot of developers who care about their code quality and workability. And I once upon a time, not so long ago managed to read about TDD. The crux of TDD as I have understood is:

  1. Write Test, and fail
  2. Code, make the tests succeed
  3. Automate the tests
  4. Refactor the code to improve the quality
  5. Repeat

Pretty easy to understand. A annoyed developer shouts- “A developer writing tests? How can you expect us to develop and test and yet finish the feature in time?”. After all developers dont want to do the boring testing work. I have been a developer for around 2 years know and there were times when I reacted that way, during those initial days. But with time, I have started to understand the crux of software development. And this time around I thought of trying out TDD.

My work involves wiring up the data in the db with the UI using an Java EE web framework- A typical web application work.

Let me explain my testing strategy before I adopted TDD:

  1. Write the complete code which includes- PLSQL procedures, Java code to invoke PLSQL procedures, Java code for the UI bindings and the JSP page itself.
  2. Manually test the functioning of the db layer and the UI layer code. It involves navigating to the page and then testing various operations. In this case both the UI issues and the Backend code issues would crop up.
  3. As I would play around with the UI further, I would unearth few bugs in the code, otherwise write a selenium test to automate testing of a few use-cases.

With the above 3 steps, I spent a lot of time-

  1. waiting for the backend code to compile and the restart the server for the UI to reflect the changes. Even if its a simple 1 word/1 statement change I had to wait for approximately upto 5 minutes and in some cases 8 minutes. While I would wait for this to restart, I would have lost focus to some other task and there by take sometime to come back to the main task.
  2. trying to debug and find out if the exception/bug is due to the UI code issue or the backend code issue.
  3. in waiting for the pages to load and navigate through the pages to the right page.

Ok, those were the pre-historic times. Now coming to the Modern Age. I thought TDD would not have been possible in the kind of work I do, it was because I wrote a badly coupled backend and UI code. I couldn’t think of ways to test my back end code independently and then move to the UI code and then test it via selenium tests. Keeping aside these notions, I gave it a shot. I know I wasn’t very close to the actual TDD, but I felt somewhat closer.

  1. I had a fair idea of how to implement the logic, created a basic implementation and let it compile successfully.
  2. Created a few data population tests to get the kind of data to be used for the testing.
  3. Created JUnits to tests the basic functionality. Mostly in terms of the correct execution of PLSQL procedure via the Java API.
  4. Updated the JUnits to add more tests to test out the actual functionality required and updated the code to implement those functionalities.
  5. Refactor the code to remove bad smells and then run JUnits to see to it that nothing is broken.

The reasons why I felt excited, why I felt it was a Win-Win strategy:

  • I began to think in terms for the user of the API more than its creator. This kept me away from adding hacks which could fix the issue but would be difficult to test. This tremendously improved the code structure then what I had written before.
  • No server restarts, no wasting of ~ 8 minutes per restart, no wasting of navigating to the pages. I just had to edit the code, run the junits and see the tests decide the fate. This is more useful for the backend code I have written.
  • No loss in focus as I am deeply involved in Code-Test cycles.
  • Sense of achievement as I see the tests show up green bars.
  • Possibility of creating a code with good unit tests to test the backend features, which also helps in refactoring the code more easily.

Now I just have to write the glue code for the UI and the backend and test the glue code via the selenium tests.

Anyone had any similar experiences when they started to use TDD?

Reference: My First steps in Test Driven Development- A Win-Win strategy from our JCG partner Mohamed Sanaulla at the Experiences Unlimited blog.

Related Whitepaper:

Functional Programming in Java: Harnessing the Power of Java 8 Lambda Expressions

Get ready to program in a whole new way!

Functional Programming in Java will help you quickly get on top of the new, essential Java 8 language features and the functional style that will change and improve your code. This short, targeted book will help you make the paradigm shift from the old imperative way to a less error-prone, more elegant, and concise coding style that’s also a breeze to parallelize. You’ll explore the syntax and semantics of lambda expressions, method and constructor references, and functional interfaces. You’ll design and write applications better using the new standards in Java 8 and the JDK.

Get it Now!  

3 Responses to "Test Driven Development – A Win-Win strategy"

  1. Romain Touzé says:

    I could have written this article since I experimented TDD in quite the same situation as you did. Nowadays, I’m using JUnit to test drive plsql development. Not so bad!

  2. Neo Lite says:

    From what I understand you had the basic API ready for the same. Then you wrote tests around the same and continually applied the red/green/refactor phases. Isn’t it different from what TDD advocates?

    NeoLite
    http://designwithneo.blogspot.com
    writeToMe: neolite77@gmail.com

  3. Shouldn’t you write the tests first and refactor your code based on each passed/failed test?

Leave a Reply


seven × = 56



Java Code Geeks and all content copyright © 2010-2014, Exelixis Media Ltd | Terms of Use
All trademarks and registered trademarks appearing on Java Code Geeks are the property of their respective owners.
Java is a trademark or registered trademark of Oracle Corporation in the United States and other countries.
Java Code Geeks is not connected to Oracle Corporation and is not sponsored by Oracle Corporation.

Sign up for our Newsletter

15,153 insiders are already enjoying weekly updates and complimentary whitepapers! Join them now to gain exclusive access to the latest news in the Java world, as well as insights about Android, Scala, Groovy and other related technologies.

As an extra bonus, by joining you will get our brand new e-books, published by Java Code Geeks and their JCG partners for your reading pleasure! Enter your info and stay on top of things,

  • Fresh trends
  • Cases and examples
  • Research and insights
  • Two complimentary e-books