Meszaros G. xUnit Test Patterns Refactoring Test Code

Подождите немного. Документ загружается.

[RTC]

Refactoring Test Code

Paper presented at XP2001 in Sardinia, Italy

By: Arie van Deursen, Leon Moonen, Alex van den Bergh, and Gerard Kok

This paper was the ﬁ rst to apply the concept of “code smells” to test code.

It described a collection of 12 “test smells” and proposed a set of refac-

torings that could be used to improve the code. The original paper can be

found at http://homepages.cwi.nl/~leon/papers/xp2001/xp2001.pdf.

[RtP]

Refactoring to Patterns

Published by: Addison-Wesley (2005)

ISBN: 0-321-21335-1

By: Joshua Kerievsky

This book deals with the marriage of refactoring (the process of improving

the design of existing code) with patterns (the classic solutions to recurring

design problems). Refactoring to Patterns suggests that using patterns to

improve an existing design is a better approach than using patterns early in

a new design, whether the code is years old or minutes old. We can improve

designs with patterns by applying sequences of low-level design transfor-

mations, known as refactorings.

[SBPP]

Smalltalk Best Practice Patterns

Published by: Prentice Hall (1997)

ISBN: 0-13-476904-X

By: Kent Beck

This book describes low-level programming patterns that are used in good

object-oriented software. On the back cover, Martin Fowler wrote:

Kent’s Smalltalk style is the standard I aim to emulate in my

work. This book does not just set that standard, but also explains

why it is the standard. Every Smalltalk developer should have it

close at hand.

While Smalltalk is no longer the dominant object-oriented development

language, many of the patterns established by Smalltalk programmers have

been adopted as the standard way of doing things in the mainstream object-

oriented development languages. The patterns in this book remain highly

relevant even if the examples are in Smalltalk.

References

828

[SCMP]

Software Conﬁ guration Management Patterns: Effective Teamwork, Practical

Integration

Published by: Addison-Wesley (2003)

ISBN: 0-201-74117-1

By: Steve Berczuk (with Brad Appleton)

This book describes, in pattern form, the how’s and why’s of using a source

code conﬁ guration management system to synchronize the activities of

multiple developers on a project. The practices described here are equally

applicable to agile and traditional projects.

Further Reading

http://www.scmpatterns.com

http://www.scmpatterns.com/book/pattern-summary.html

[SoC]

Secrets of Consulting: A Guide to Giving and Getting Advice Successfully

Published by: Dorset House (1985)

ISBN: 0-932633-01-3

By: Gerald M. Weinberg

Full of Gerry’s laws and rules, such as “The Law of Raspberry Jam: The

farther you spread it, the thinner it gets.”

[TAM]

Test Automation Manifesto

http://TestAutomationManifesto.gerardmeszaros.com

By: Shaun Smith and Gerard Meszaros

This paper was presented at the August 2003 XP/Agile Universe meeting in

New Orleans, Louisiana. It describes a number of principles that should be

followed to make automated testing using xUnit cost-effective.

References

829

[TDD-APG]

Test-Driven Development: A Practical Guide

Published by: Prentice Hall (2004)

ISBN: 0-13-101649-0

By: David Astels

This book provides a good introduction to the process of driving software

development with unit tests. Part III of the book is an end-to-end example of

using tests to drive a small Java project.

[TDD-BE]

Test-Driven Development: By Example

Published by: Addison-Wesley (2003)

ISBN: 0-321-14653-0

By: Kent Beck

This book provides a good introduction to the process of driving software

development with unit tests. In the second part of the book, Kent illustrates

TDD by building a Test Automation Framework (page 298) in Python. In an

approach he likens to “doing brain surgery on yourself,” he uses the emerg-

ing framework to run the tests he writes for each new capability. It is a very

good example of both TDD and bootstrapping.

[TDD.Net]

Test-Driven Development in Microsoft .NET

Published by: Microsoft Press (2004)

ISBN: 0-735-61948-4

By: James W. Newkirk and Alexei A. Vorontsov

This book is a good introduction to the test-driven development process

and the tools used to do it in Microsoft’s. Net development environment.

[TI]

Test Infected

http://junit.sourceforge.net/doc/testinfected/testing.htm

By: Eric Gamma and Kent Beck

This article was ﬁ rst published in the Java Report issue called “Test Infected—

Programmers Love Writing Tests.” It has been credited by some as being what

led to the meteoric rise in JUnit’s popularity. This article is an excellent intro-

duction to the how’s and why’s of test automation using xUnit.

References

830

[TPS]

Toyota Production System: Beyond Large-Scale Production

Published by: Productivity Press (1995)

ISBN: 0-915-2991-4-3

By: Taiichi Ohno

This book, which was written by the father of just-in-time manufacturing,

describes how Toyota came up with the system driven by its need to pro-

duce a small number of cars while realizing economies of scale. Among the

techniques described here are “kanban” and the “ﬁ ve why’s.”

[UTF]

Unit Test Frameworks: Tools for High-Quality Software Development

Published by: O’Reilly (2004)

ISBN: 0-596-00689-6

By: Paul Hamill

This book is a brief introduction to the most popular implementations of

xUnit.

[UTwHCM]

Unit Testing with Hand-Crafted Mocks

http://refactoring.be/articles/mocks/mocks.html

By: Sven Gorts

This paper summarizes and names a number of idioms related to Hand-Built

Test Doubles (see Conﬁ gurable Test Double on page 522)—speciﬁ cally, Test

Stubs (page 529) and Mock Objects (page 544). Sven Gorts writes:

Many of the unit tests I wrote over the last couple of years use

mock objects in order to test the behavior of a component in

isolation of the rest of the system. So far, despite the availability

of various mocking frameworks, each of the mock classes I’ve

used has been handwritten. In this article I do some retrospection

and try to wrap up the mocking idioms I’ve found most useful.

References

831

832

[UTwJ]

Unit Testing in Java: How Tests Drive the Code

Published by: Morgan Kaufmann

ISBN: 1-55860-868-0

By: Johannes Link, with contributions by Peter Fröhlich

This book does a very nice job of introducing many of the concepts and

techniques of unit testing. It uses intertwined narratives and examples to

introduce a wide range of techniques. Unfortunately, due to the format, it

can be difﬁ cult to ﬁ nd something at a later time.

[VCTP]

The Virtual Clock Test Pattern

http://www.nusco.org/docs/virtual_clock.pdf

By: Paolo Perrotta

This paper describes a common example of a Responder called Virtual Clock

[VCTP]. The author uses the Virtual Clock Test Pattern as a Decorator [GOF]

for the real system clock, which allows the time to be “frozen” or resumed.

One could use a Hard-Coded Test Stub or a Conﬁ gurable Test Stub just as

easily for most tests. Paolo Perrotta summarizes the thrust of his article:

We can have a hard time unit-testing code that depends on

the system clock. This paper describes both the problem and a

common, reusable solution.

[WEwLC]

Working Effectively with Legacy Code

Published by: Prentice Hall (2005)

ISBN: 0-13-117705-2

By: Michael Feathers

This book describes how to get your legacy software system back under

control by retroﬁ tting automated unit tests. A key contribution is a set

of “dependency-breaking techniques”—mostly refactorings—that can help

you isolate the software for the purpose of automated testing.

References

833

Database Refactoring

[Wp]

Wikipedia

From Wikipedia [Wp]: “Wikipedia is a multilingual, Web-based free con-

tent encyclopedia project. The name Wikipedia is a blend of the words

‘wiki’ and ‘encyclopedia.’ Wikipedia is written collaboratively by volun-

teers, allowing most articles to be changed by almost anyone with access

to the Web site.”

[WWW]

World Wide Web

A reference annotation of [WWW] indicates that the information was

found on the World Wide Web. You can use your favorite search engine to

ﬁ nd a copy by searching for it by the title.

[XP123]

XP123

http://xp123.com

Web site hosted by: William Wake

A Web site hosting various resources for teams doing eXtreme Program-

ming.

[XPC]

XProgramming.com

http://xprogramming.com

Web site hosted by: Ron Jeffries

A Web site hosting various resources for teams doing eXtreme Program-

ming. One of the better places to look for links to software downloads for

unit test automation tools including members of the xUnit family.

834

References

[XPE]

eXtreme Programming Explained, Second Edition: Embrace Change

Published by: Addison-Wesley (2005)

ISBN: 0-321-27865-8

By: Kent Beck

This book kick-started the eXtreme Programming movement. The ﬁ rst edi-

tion (0-201-61641-6) described a recipe consisting of 12 practices backed

by principles and values. The second edition focuses more on the values

and principles. It breaks the practices into a primary set and a corollary set;

the latter set should be attempted only after the primary practices are mas-

tered. Among the practices both editions describe are pair programming

and test-driven development.

835

ABAP Object Unit, 747

ABAP Unit, 747

Abstract Setup Decorator

deﬁ ned, 449

example, 453

acceptance tests. See also

customer tests

deﬁ ned, 785

why test?, 19

accessor methods, 785

ACID, 785

acknowledgements, xxvii–xxviii

action components, 280

agile method

deﬁ ned, 785–786

property tests, 52

AllTests Suite

example, 594–595

introduction, 13

when to use, 593

annotation

deﬁ ned, 786

Test Methods, 351

Anonymous Creation Method

deﬁ ned, 417

example, 420

Hard-Coded Test Data

solution, 196

preface, xxi

anonymous inner class

deﬁ ned, 786

Test Stub examples, 535–536

Ant, 753

AntHill, 753

anti-pattern (AP)

deﬁ ned, 786

test smells, xxxv

AOP (aspect-oriented programming)

deﬁ ned, 786

Dependency Injection, 681

retroﬁ tting testability, 148

API (application programming inter-

face)

Creation Methods, 416

database as SUT, 336

deﬁ ned, 786

Test Utility Method, 600

architecture, design for testability.

See design-for-testability

arguments

messages describing, 371–372

as parameters (Dummy

Arguments), 729

role-describing, 725

Index

836

Index

Arguments, Dummy, 729

Ariane 5 rocket, 218

aspect-oriented programming (AOP)

deﬁ ned, 786

Dependency Injection, 681

retroﬁ tting testability, 148

Assertion Message

of Assertion Method, 364

pattern description, 370–372

Assertion Method

Assertion Messages, 364

calling built-in, 363–364

choosing right, 364–365

Equality Assertions, 365

examples, 368–369

Expected Exception

Assertions, 366

Fuzzy Equality Assertions,

365–366

implementation, 363

as macros, 364

motivating example, 367–368

overview, 362–363

refactoring, 368

Single-Outcome Assertions,

366–367

Stated Outcome Assertions, 366

Assertion Roulette

Eager Tests, 224–226

impact, 224

introduction, 14

Missing Assertion Message,

226–227

symptoms, 224

assertions

Built-in, 110–111

custom. See Custom Assertion

deﬁ ned, 786

diagramming notation, xlii

Domain Assertions, 476,

481–482

improperly coded in Neverfail

Tests, 274

introduction, 77

Missing Assertion Messages,

226–227

reducing Test Code Duplication,

114–119

refactoring, xlvi–xlix

Self-Checking Tests, 107–108

unit testing, 6

Verify One Condition per Test,

46–47

assumptions, xxxix–xl

Astels, Dave, 110

asynchronous tests

deﬁ ned, 787

Hard-To-Test Code, 210–211

Humble Object, 696–697

Slow Tests, 255–256

testability, 70–71

Attachment Method

deﬁ ned, 418

example, 421

attributes

deﬁ ned, 787

dummy, 729

hiding unnecessary, 303–304

One Bad Attribute. See One

Bad Attribute

parameters as, 608

Suite Fixture Setup, 442–443

Test Discovery using, 397

Test Selection, 403–405

Automated Exercise Teardown

deﬁ ned, 505

example, 508

Automated Fixture Teardown,

504–505

Automated Teardown

ensuring Repeatable Tests, 27

examples, 507–508

837

Index

implementation, 504–505

Interacting Test Suites, 232

Interacting Tests solution, 231

motivating example, 505–506

overview, 503–504

of persistent ﬁ xtures, 99–100

refactoring, 506–507

resource leakage solution, 233

when to use, 504

automated unit testing

author’s motivation, xxiv–xxv

fragile test problem, xxxi–xxxii

introduction, xxx–xxxii

back door, deﬁ ned, 787

Back Door Manipulation

control/observation points, 66–67

database as SUT API, 336

Expected State Speciﬁ cation, 464

ﬁ xture setup, 333–335

implementation, 330–332

motivating example, 332

overview, 327–328

refactoring, 333

setup, 329

teardown, 330

veriﬁ cation, 329–330

veriﬁ cation using Test Spy, 333

when to use, 328

Back Door Setup

controlling indirect inputs, 128

ﬁ xture design, 59

Prebuilt Fixtures, 430–431

transient ﬁ xtures, 86

Back Door Veriﬁ cation, 130–133

BDUF (big design upfront)

deﬁ ned, 787

design for testability, 65

test automation strategy, 49

Beck, Kent, xxii

sniff test, xxxviii

Test Automation Frameworks,

301

test smells, 9

Testcase Class per Class, 618

xUnit, 57

Behavior Sensitivity

cause of Fragile Tests, 242–243

caused by Overspeciﬁ ed

Software, 246

deﬁ ned, xxxi

smells, 14

behavior smells, 223–247

Assertion Roulette. See

Assertion Roulette

deﬁ ned, 10–11, 788

Erratic Tests. See Erratic Test

Fragile Tests. See Fragile Test

Frequent Debugging. See

Frequent Debugging

Manual Intervention. See

Manual Intervention

overview, 13–15

Slow Tests. See Slow Tests

Behavior Veriﬁ cation

approach to Self-Checking

Tests, 108

examples, 472–473

implementation, 469–471

indirect outputs, 179–180

motivating example, 471–472

overview, 468–469

refactoring, 472

vs. state, 36

test results, 112–114

using Mock Objects. See

Mock Object

using Test Spies. See Test Spy

using Use the Front Door

First, 40