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

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

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

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

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

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

JsTester allows validation of javaScript code inside java. It provides a group of assert methods like JUnit’s Assert, it also supports the validations described in http://javascript.crockford.com/remedial.html, and the ability to use your own validations (unary & binary predicates).

The project provides two ways of creating your tests: by inheritance (JsTestCase), and by composition (JsTester). Use JsTestCase as you would normally use any extension of TestCase. Use JsTester with JUnit4 and annotations, or inside another TestCase hierarchy.

The project was born as a necessitity to test JSON code generated by json-lib.
link

The Practical, Start-to-Finish Guide to Planning and Leading Iterative Software Projects

Iterative processes have gained widespread acceptance because they help software developers reduce risk and cost, manage change, improve productivity, and deliver more effective, timely solutions. But conventional project management techniques don’t work well in iterative projects, and newer iterative management techniques have been poorly documented. Managing Iterative Software Development Projects is the solution: a relentlessly practical guide to planning, organizing, estimating, staffing, and managing any iterative project, from start to finish.

Leading iterative development experts Kurt Bittner and Ian Spence introduce a proven, scalable approach that improves both agility and control at the same time, satisfying the needs of developers, managers, and the business alike. Their techniques are easy to understand, and easy to use with any iterative methodology, from Rational Unified Process to Extreme Programming to the Microsoft Solutions Framework.

Whatever your role–team leader, program manager, project manager, developer, sponsor, or user representative–this book will help you

- Understand the key drivers of success in iterative projects
- Leverage “time boxing” to define project lifecycles and measure results
- Use Unified Process phases to facilitate controlled iterative development
- Master core concepts of iterative project management, including layering and evolution
- Create project roadmaps, including release plans
- Discover key patterns of risk management, estimation, organization, and iteration planning
- Understand what must be controlled centrally, and what you can safely delegate
- Transition smoothly to iterative processes
- Scale iterative project management from the smallest to the largest projects
- Align software investments with the needs of the business

Whether you are interested in software development using RUP, OpenUP, or other agile processes, this book will help you reduce the anxiety and cost associated with software improvement by providing an easy, non-intrusive path toward improved results–without overwhelming you and your team.

Authors: Kurt Bittner & Ian Spence
Published: Addison-Wesley Professional, June 27, 2006
672 pages
link

Agile methodologies, such as XP, Scrum, Crystal, and Lean Software Development enable development organizations to deliver higher-quality software far more rapidly. However, for the “non-agile” development organization, transitioning to agility is an enormous leap, requiring radically new skills and presenting profound risks.

In this book, leading agile practitioner Carol A. Wellington introduces the first systematic, three-phase process for moving smoothly to agility. Just as developers have learned to refactor code to improve performance and maintainability, Wellington shows how to refactor processes to improve agility.

Using Wellington’s framework, you can gradually move toward agility, while maintaining full control and avoiding disruption. You’ll lay a solid foundation for agility, and then refactor more and more of your processes, systematically introducing agility wherever it delivers compelling value. You can retain current processes that work, and implement the best agile methods for your organization, regardless of their source. This practical approach can help you build organizational confidence in agility, drive measurable benefits, and minimize risk every step of the way.

Coverage includes

- Phase 1: Time-boxed iterations that deliver customer-visible functionality–not just components
- Phase 2: A lightweight measurement process to detect problems and evaluate changes withoutwasting too much time gathering and analyzing data
- Phase 3: Identifying your worst process “smells,” uncovering their true underlying causes, and fixing them
- Incrementally bringing agility to planning, estimation, analysis, design, development, and process management
- Eliminating tasks and processes that don’t add value
- Overcoming pitfalls and hidden interconnections that complicate your agile transition
- Learning to lead the transition to agility, gaining buy-in from team members, customers, and executives

Whatever your role, organization, or current methodology, Refactoring to Agility can help you reap powerful value from agile methods–without the risks.

Dr. Carol A. Wellington is a professor of computer science and the department chair at Shippensburg University of Pennsylvania. Prior to this position, she was a leader in large software development organizations, building operating systems and real-time embedded applications. Dr. Wellington currently uses this combination of academic and industrial experience as a consultant to help companies question their assumptions about development processes to improve their agility and product quality.

Author: Carol A. Wellington
Published: Addison Wesley Professional, July 20, 2006
PDF only, 118 pages
link

Unit testing is something we all need to do, but getting good code coverage can be a daunting task. In this article, Gary Tong focuses on one of the basic elements of unit tests: mock objects. Using a hybrid static/dynamic approach, he shows how flexible, useful mock objects can be written in a matter of minutes.

Author: Gary Tong
Published: JavaWorld, July 31, 2006
link

Testing Java code is increasingly a task taken on by developers rather than separate teams to which the programs are handed. Many Java developers are now familiar with JUnit and know the different between unit tests and integration tests. This has been driven largely by the focus on test-driven development (TDD) in extreme programming (XP) and other agile software development methodologies. While the industry-at-large has recognized the value of unit tests and has a new outlook on testing in general, for the most part, actual TDD (meaning, the tests are written first) is not usually practiced outside of hardcore agile shops.

Authors: Richard Cariens & John Evans
Published: Sys-con Australia, July 30, 2006
link

Since the late 1990s when the software revolution moved into the fast lane, development shops have endeavored to find a way to operate within the demands imposed by strict budgets, fierce deadlines, and uncompromised quality. As marketing, testing, usability, and development departments all sought to bring an idea into existence, programmers were expected to function as a cog rather than as the wheel. As a result, the focus on a given project was scattered across business groups, placing ownership on the outcome nowhere in particular. [..]

In 1999, Extreme Programming (XP) appeared on the horizon and, where it was adopted, everything changed.

Author: Nancy Corbett
Published: Developer.com, July 26, 2006
link