testdriven.com Wrangling quality out of chaos

The Testing Tools Project is a project in the Eclipse TPTP Top-Level Project, it addresses the testing phase of the application lifecycle. The Testing Tools Project provides frameworks for building testing tools by extending the TPTP Platform. The framework contains testing editors, deployment and execution of tests, execution environments and associated execution history analysis and reporting. The project also includes exemplary tools for JUnit based component testing tool, Web application performance testing tool, and a manual testing tool.

See also: [url=http://www-128.ibm.com/developerworks/views/opensource/libraryview.jsp?search_by=eclipse+test+performance+tools+platform]Ongoing series of articles on TPTP[/url]
link

In this article I will describe a scalable NUnit unit test suite for use on a tiered, database-driven .NET application. The suite will define sample generators used to easily create dummy data for tests, and it will use test fixture inheritance for increased scalability and to allow for easy testing of common functionality.

I will focus on testing of the domain model of a sample application. This is usually located in the "middle" of an application and is often called the business logic layer (BLL). It uses the data access layer (DAL) to mediate data transfer to and from the database and drives the behavior of one or more user interfaces (UI) with which the user interacts or in which data is displayed.

This article assumes knowledge of .NET and C#, but does not require experience with unit testing or NUnit in particular.

Author: Brett Daniel
Published: The Code Project, August 26, 2006
link

Directory of articles related to Agile software development.
link

The first annual Tulsa TechFest will be held on Saturday, October 14, 2006, and will feature several sessions in the scope of Test-Driven Development practices:

- Testing Objects In Isolation TDD with Mock Objects
- NUnit Extensibility
- Test Driven Development With .Net: A Primer
- Refactoring: A Primer
- Automate your User Acceptance Tests with FitNesse
- Continuous Integration
- Continuous Integration With CruiseControl.Net and NAnt
- Agile Project Experiences

The Tulsa TechFest is a free event. Visit the Tulsa TechFest 2006 website for more details.Testing Objects In Isolation TDD with Mock Objects – Jean-Paul (JP) Boodhoo
Often when people first encounter TDD, it is in the context of a trivial example that is completely non-representative of the types of projects they work on in their day to day jobs. Most applications developers work on are large manifestations of layers upon layers of indirection and business logic. How do you go about utilizing TDD to drive out the functionality of these types of application? One object at a time!! This session will discuss techniques that a test driven developer can employee to utilize TDD to test objects that may have intricate webs of dependencies.

NUnit Extensibility – Tim Rayburn
NUnit Extensibility NUnit is an immensely popular unit testing framework, but few people realize how extensible it is, allowing you to easily avoid writing repetitive code in your tests. This class will walk through the creation of a custom Asserter, and then also go over other techniques which can be used to reduce the amount of code you need to write.

Test Driven Development With .Net: A Primer – Jean-Paul (JP) Boodhoo
In this session developers will be introduced to the concepts, practices, and tools that can be utilized to start utilizing test driven development techniques. A simple example will be utilized to focus on the concepts and principles that can form the foundation for a solid grounding in TDD.

Refactoring: A Primer – Jean-Paul (JP) Boodhoo
Many people have heard of the term refactoring. Most developers practice refactoring without the knowledge that it is a named practice. This session will discuss the topic of refactoring and some non-trivial refactorings that can be exercised against enterprise code bases to allow for more readable, flexible code.

Automate your User Acceptance Tests with FitNesse – Tim Gifford
How does your team define when a feature is "done"? In this presentation, you’ll learn how to collaborate better with your business users by using the Framework for Integration Testing (FIT) and FitNesse. Discover how you can automate examples of business requirements to prove that your feature is complete.

Continuous Integration – Raymond Lewallen
The session will cover Continuous Integration using CruiseControl.Net. In this session, we will do an entire walkthough on setting up a continuous integration server. Tools that will be provided and covered are Subversion, Tortoise, NDepend, FxCop, NCover, NUnit (from TestDriven.Net), NAnt and CruiseControl.Net. We will cover each tool, what it does, why it is important and finally tying it all together into an automated build and integration process. Bring your laptop and walk away with an integration server running by the end of the session, including all the tools listed. Because of a single, small issue with running one of the tools under framework 2.0, we will be targeting framework 1.1. All tools listed are available under BSD or GPL, and are freely distributable and free to use.

Continuous Integration With CruiseControl.Net and NAnt – Jean-Paul (JP) Boodhoo
Whether you have bought into agile methodologies or not. It is hard to argue the value of having a repeatable automatable build process to streamline your development environment. This session will cover the use of CruiseControl.Net and NAnt as a good pair to introduce a continuous build process into you development environment.

Agile Project Experiences – Tim Gifford
Hear about a real world agile project – learn what worked, what didn’t and what we would have done differently. After the presentation, you’ll come away with tips on how to communicate and estimate a feature, track your project’s status, collaborate better with your business users and improve your team’s overall performance.

Thanks to the rise of test-driven development (TDD) and other agile approaches to software development, more and more IT pros have come to embrace testing as a way to accelerate development and improve overall quality levels. Now that development tools vendors [..] have started to deliver testing-friendly toolsets—complete with canned support for unit and functional testing during the application development process—it might be just a matter of time before QA testing comes down from its pointy-headed peak and back home to the programming pit.

Author: Stephen Swoyer
Published: Application Developer Trends, August 23, 2006
link

Agile Java™ Development With Spring, Hibernate and Eclipse is a book about robust technologies and effective methods which help bring simplicity back into the world of enterprise Java development. The three key technologies covered in this book, the Spring Framework, Hibernate and Eclipse, help reduce the complexity of enterprise Java development significantly.

Furthermore, these technologies enable plain old Java objects (POJOs) to be deployed in light-weight containers versus heavy-handed remote objects that require heavy EJB containers. This book also extensively covers technologies such as Ant, JUnit, JSP tag libraries and touches upon other areas such as such logging, GUI based debugging, monitoring using JMX, job scheduling, emailing, and more. Also, Extreme Programming (XP), Agile Model Driven Development (AMDD) and refactoring are methods that can expedite the software development projects by reducing the amount of up front requirements and design; hence these methods are embedded throughout the book but with just enough details and examples to not sidetrack the focus of this book.

In addition, this book contains well separated, subjective material (opinion sidebars), comic illustrations, tips and tricks, all of which provide real-world and practical perspectives on relevant topics. Last but not least, this book demonstrates the complete lifecycle by building and following a sample application, chapter-by-chapter, starting from conceptualization to production using the technology and processes covered in this book.

In summary, by using the technologies and methods covered in this book, the reader will be able to effectively develop enterprise-class Java applications, in an agile manner!

Author: Anil Hemrajani
Published: Sams, May 9, 2006
Sample chapter: [url=http://www.informit.com/articles/article.asp?p=518907&rl=1]How to Use XP and AMDD-Based Architecture and Design Modeling[/url]
link

AOP makes it easier than it’s ever been to write tests specific to your application’s crosscutting concerns. Find out why and how to do it, as Nicholas Lesiecki introduces you to the benefits of testing aspect-oriented code and presents a catalog of patterns for testing crosscutting behavior in AspectJ.

Author: Nicholas Lesiecki
Published: IBM developerWorks, November 1st, 2005
link

Software developers who have the ability to create and maintain quality software in a team environment are in high demand in today’s technology-driven economy. The number one challenge facing developers working in a team environment is reading and understanding software written by another developer. This article strives to help software development teams overcome this challenge.

This article illustrates five habits of software development teams that make them more effective and therefore more profitable. It first will describe the demands the business team puts on its software development team and the software they create. Next it will explain the important differences between state-changing logic and behavior logic. Finally, it will illustrate the five habits using a customer account scenario as a case study.

Author: Robert J. Miller
Published: Java.net, August 24, 2006
link

[img align=right]http://skillsmatter.com/images/system/logo.gif[/img]

Learn how to do test-driven development (TDD) and refactoring whilst applying the most popular open-source frameworks for TDD

[img align=left]http://skillsmatter.com/images/misc/craiglarman.jpg[/img]
This information-packed and hands-on seminar shows developers and technical leadership how to do test-driven development (TDD) and refactoring, apply the most popular open-source frameworks for TDD and use them within a popular IDE. TDD is powerful and practical. It’s the practice of always writing test code before the code to be tested. In addition to the obvious benefit that tests actually get written and executed for most code, a more subtle, but important, effect is that when we start by thinking very concretely—with code—in the role of a calling client to the new code, it clarifies our design.

Course Objectives
In this course you will learn how to think in and apply test-driven design and programming, and establish it as a consistent method for your development team. You’ll learn and work with popular TDD tools, JUnit for unit testing (if Java, otherwise, NUnit for .NET or CXXTest if C++), JWebUnit for functional testing, and Jemmy for Java Swing GUI testing (if appropriate to the audience). And you’ll learn about mock objects, and libraries of mock objects, to simplify setup for TDD.

Refactoring is a disciplined design improvement skill that relies on automated unit tests created via TDD, and applies automated refactoring tools built into popular IDEs or editors, such as Eclipse, Slick Edit, emacs, and Visual Studio.

In addition, you will learn to use the increasingly popular Fit and Fitnesse open-source acceptance testing frameworks that are integrated with a Wiki Web or spreadsheets for table-driven testing.
link

[img align=right]http://skillsmatter.com/images/system/logo.gif[/img]
[img align=left]http://skillsmatter.com/images/misc/craiglarman.jpg[/img]
This practical, information-packed two-day course on the Application of Agile and Iterative Project Management has been authored by Craig Larman.

The course summarises the key research, ideas, and practices of iterative development, for large or small projects, aimed at executive and project leadership.

There are many myths and misrepresentations concerning iterative and agile methods; among the most common are that they are new, that they have only been applied to small projects, and that there is no SW engineering evidence that iterative development works. But as this Agile and Iterative Project Management course will present, these are all misunderstandings – these practices have been applied for decades, on large projects worldwide, and there’s research to back them up.

This is a high-impact guide for managers and students to agile and iterative development methods: what they are, how they work, how to implement them – and why you should.

Course Objectives
The following topics are covered on this Agile & Iterative Project Management course:

* Evidence, history, and case studies that iterative methods reduce project risk
* Applying iterative methods on large projects
* Frequently asked questions
* Agile and iterative values and practices
* Dozens of useful iterative and agile practice tips, in requirements, design, and documentation
* New management skills for agile/iterative project leaders, from estimation to scheduling
* The Lean Manufacturing/Thinking movements and their application to software development
* Key practices of UP, FDD, Scrum, and other iterative methods
link

[img align=right]http://skillsmatter.com/images/system/logo.gif[/img]

Craig Larman’s Workshop on the practical application of Design Patterns

[img align=left]http://skillsmatter.com/images/misc/craiglarman.jpg[/img]
This popular, high-impact, and hands-on course on mastering advanced object-oriented design (OOD) and design patterns is aimed at architects and developers of OO systems, and is based on acclaimed industry leader Craig Larman’s extensive experience coaching and applying OOD since the mid 1980s.

Object-oriented (OO) design patterns are a critical and fundamental skill of successful OO developers to support design agility. Most modern OO systems are designed with patterns, and mastery of design patterns is considered a basic criterion of mature developers—and an absolute necessity for architects.

Various studies indicate that after initial release of a software system, at least 50% of effort and cost is spent in modification. To save money, it is skillful and economic to take a long-term view of product development and invest in skillful designs that reduce these costs.

You will leave this workshop with deeper skill to apply patterns and create quality object-oriented designs that have agility – that support reduced modification costs and increased comprehensibility, and hence support business agility.

Course Objectives
You will learn to design with patterns, apply visual modeling and the UML in an agile modeling approach, and a suite of related advanced design topics, including the design of packages.

At their worst, patterns appear like purely disparate ideas, without much cohesion, or connection to your problems. At their best, they are an elegant and practical language of design, offering a vocabulary of reusable solutions at points of complexity, instability, variation, or evolution in your systems.

This intensive workshop helps you acquire this cohesive vocabulary, and apply patterns at variation points. It provides examples and context for the most frequently used patterns, and includes a learning aid for guidance in their application. In short, we work hard and hands-on in this course. You will leave with the direct experience and confidence to actually do object design and apply patterns. Essential, high-use UML and agile modeling is taught in the context of design modeling. However, the emphasis is on object design, not on learning diagramming syntax (UML notation).
link

This very popular, high-impact, and hands-on course on mastering agile modeling combined with TDD and refactoring is aimed at developers of object-oriented systems, and is based on acclaimed industry leader Craig Larman’s extensive experience coaching and applying modeling and OO development for two decades.

Craig Larman is the author of the world’s best selling text on modeling, UML, and patterns: Applying UML and Patterns: An Intro to OOA/D and Iterative Development, used globally (in many languages) in universities and business, and also the leading text on agile methods, Agile and Iterative Development: A Manager’s Guide. He has coached and practiced modeling and OO development since the mid-1980s to literally thousands of developers, and brings his passion for excellence, professionalism, and a desire to add high-value to every customer he serves. His seminar approach is based on adult-education theory to maximize the learning value and fun for clients. Many clients cite this hands-on course as either the best or one of the best learning experiences they’ve had; You will not be disappointed – guaranteed!

Course Objectives
What really matters is not a set of UML diagrams, but a running system that meets the needs and constraints of various stakeholders. Thus, how can we effectively apply the UML or modeling in an agile value-adding practical approach, and how can it be integrated with programming and automated tests to create great OO software? And how to can we design software with technical agility to enable business agility? In this intensive hands-on seminar you will find the answer these questions. There is a little lecture time, but the majority of the time is spent in high-value-education small modeling teams at the whiteboards while I rotate and work with each team, coaching the case studies while applying agile modeling, UML and patterns. I also coach while we’re at computers coding useful automated tests and programming great OO designs with test-driven development. You will learn to:

* think in objects
* design with patterns
* apply visual modeling and the UML in an agile modeling approach
* do test-driven development
* apply refactorings and refactoring tools
* transform agile OO models into OO code and tests
* take a problem through requirements analysis, architectural analysis, design, automated tests, and well-crafted OO software in the context of an iterative process
link

Our first class will be on the topic of rSpec and is scheduled for Oct. 24-25. There will also be a one day Ruby Primer on Oct. 23 for anyone new to Ruby to get ramped up before heading into the rSpec class (of course… if you just want the one day Ruby Primer, that’s OK too).

More information here.

Multi-author weblog about agile methods. Includes several articles about quality and testing including an article called Quality is Not Negotiable that briefly discusses the author’s experiences with TDD and why it is so important.
link

A small consulting and training organization that specializes in Agile methods including Scrum.
link

Automated unit tests (A.K.A. "developer tests") and functional tests (A.K.A. "customer tests") are a cornerstone of many agile development methods (such as eXtreme Programming). The availability of automated, self-checking tests allows developers to be much bolder in how they modify existing software. They allow a more evolutionary form of software development that support incremental delivery of functionality to the customer (motto: Deliver early; deliver often!) that speeds up user feedback and improves the quality (both "fitness for purpose" and "software quality") of the software being built. The techniques are also spreading to less agile development methods via the introduction of "Test Driven Development" as a less extreme process alternative.

Automated test are more repeatable than manual tests because they execute exactly the same way every time. They don’t forget things after long weekends and vacations. They don’t leave to work on other projects. They don’t get sick or run over by a bus.

Automated tests take a lot less effort to run than manual tests. As a result, they are more likely to be run often. The more often the better. Fully assimilated agile developers run their tests pretty well every time they save and compile their code. And any time they need a quick vote of confidence! The tests act as a comforting "safety net" that promises to catch the developer’s mistakes. This allows them to work more quickly and with less paranoia and that makes them more productive despite the extra effort involved in writing the tests.

The XUnit patterns site was assembled to catalog the good practices in xUnit test automation the author has encountered over the years. It came about as a result of discussions Gerard Meszaros and Shaun Smith about the testing techniques they found themselves using over and over again to solve particular xUnit test automation problems.

Author: Gerard Meszaros
Published: Addison-Wesley Professional, May 21, 2007
833 pages
link

[img align=left]http://skillsmatter.com/images/system/logo.gif[/img]Craig Larman’s Agile Workshop Series, featuring Craig Larman – London – September 2006

Craig Larman, popular speaker at industry conferences and author of many best-selling books on Agile Development and Project Management, will come to the UK to present various intensive and advanced workshops on Agile Software Development, Agile Project Management, Advanced OO Design Patterns, Test Driven Development & Refactoring and Agile Modeling at Skills Matter in London in September 2006 — don’t miss it!

Test-driven development and unit tests are the latest way to make sure your code is behaving as you expect through changes and refactoring. Find out how to unit test your PHP code at the module, database, and user interface (UI) level.

Author: Jack D. Herrington
Published: IBM DeveloperWorks, August 15, 2006
link

Nag is a continuous integration monitor. It runs as a client continually monitoring the build status of integration servers such as Continuum and CruiseControl. On operating systems such as Windox and Linux, Nag can be run in the system tray. A standalone client is available for other Operating Systems.

Nag has grown out of an agile development environment where teams want to receive immediate feedback regarding the status of various builds. It provides audible and visual queues as to the status of various build.

Nag is currently in pre-alpha development. The project is sponsored by the Digital Focus Open Source Initiative.
link

A general principle of test-driven development is that you should test all published interfaces to a class. If a client can call a method or access a field, test it. However, many classes in the Java™ language have a published interface that’s easy to forget: the serialized objects generated from the class’s instances. Sometimes these classes implement Serializable explicitly. Sometimes they merely inherit it from a superclass. In either case, you should test their serialized forms. In this article I demonstrate the various ways to test object serialization.

Author: Elliotte Harold
Published: IBM DeveloperWorks, June 13, 2006
link

Zutubi is pleased to announce the immediate availability of free Small Team liceses for the Pulse continuous integration server. Small Team licenses are fully-featured licenses for up to two users and two projects on a single server. Zutubi has decided to make these licenses available to support small development teams and home users who would like to take advantage of continuous integration.

Small Team licenses are available from the Zutubi website. The licenses are free: there is no charge or obligation on your part. Enjoy using Pulse!

JSMock is a fully featured Mock Object library for JavaScript that provides the necessary tools to do effective interactive based testing.

JSMock provides expectation recording and matching, and has the ability to return, throw, and stub on object method calls. The interface is simple and easy to use, which makes testing easy.
link

JSMock is a fully featured Mock Object library for JavaScript that provides the necessary tools to do effective interactive-based testing.

JSMock provides expectation recording and matching, and has the ability to return, throw, and stub on object method calls. The interface is simple and easy to use, which makes testing easy.

Visit JSMock.

This article describes the approach used by British Telecom to move towards an Agile development process.

Author: Ian Evans
Published: Methods & Tools, Summer 2006 issue
link

When we write unit tests for our functions, we usually initialize some input data, call our function and then "assert" on the output data. But some functions take files as input or return their output in files. Where do you place these files so that tests will run on the integration server as well as all developer machines?

This was a problem we faced on our current project, and we solved it by putting the files inside the unit tests.

See how we did it on BestBrains.