book

Spock: Up and Running

Name: Spock: Up and Running
Author: Rob Fletcher
ISBN: 9781491923290

by Rob Fletcher

May 2017

Intermediate to advanced

370 pages

8h 6m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Introduction
Meet SpockA Short Background on GroovyWho Is This Book For?About This BookNavigating This BookConventions Used in This BookUsing Code ExamplesO’Reilly SafariHow to Contact UsAcknowledgments
I. Spock 101
1. The “Up and Running” Part
InstallationRunning with the JUnit RunnerRunning with GradleWhen Groovy Is Used in the ProjectSynchronizing Groovy Versions Between Main and Test ClasspathsRunning with Maven
2. Specification Basics
Anatomy of a SpecificationWhy Use Quoted Strings for Feature Method Names?An Introduction to Spock’s BlocksBlock TaxonomyBasic Block UsageThe Specification LifecycleFixture methods: setup and cleanupBlock Descriptionsand: blocksA Note on ComprehensibilitySummaryComparison with JUnit
3. Spock Assertions
The Importance of Good DiagnosticsThe Power AssertType Information in Power AssertsUsing Groovy for Effective AssertionsUsing List Comprehensions and List LiteralsAsserting Something About Every Item in a CollectionExpressive Assertions with Groovy OperatorsExpecting ExceptionsInterrogating the ExceptionGrouping Assertions on the Same ObjectSummary
4. Managing Resources
How (Not) to Approach Persistence TestingTesting a Persistence LayerManaging Resources with the Spock LifecycleSpecifications and InheritanceExecution Order of Lifecycle Methods in an Inheritance HierarchySummary
5. Interaction Testing
Asserting that a Method Is CalledSpecifying Invocation CardinalityDeclaring the Return Value from a Mocked MethodParameter PredicatesDisallowing Unexpected Calls or “Strict Mocking”Looser Matching with Wildcard ParametersWildcard ShortcutsDefining Behavior for Mocked MethodsRemoving Invocation Constraints with StubsWhen Should I Use a Mock and When Should I Use a Stub?Mixing Mocks and StubsSummary
6. Parameterized Specifications
Paramaterization in JUnitSpock’s where: blockSeparating Iteration Reporting by Using @UnrollAdding @Unroll Descriptions@Unroll Tokens in Feature Method NamesClass Level @Unroll AnnotationsMultiple Data PipesData TablesFields and Methods as Data ProvidersDerived ValuesClarifying @Unroll ExpressionsSummary
II. Advanced Spock
7. Idiomatic Spock
Organizing TestsThe “Test-per-Method” AntipatternWell-Factored SpecificationsSharing Helper MethodsSharing Methods by Using import staticSharing Methods with Groovy TraitsSharing Methods with DelegationHelper Methods and AssertionsHelper Methods and Mock InteractionsComparing “Before” and “After” ValuesThe Grammar of BlocksSeparation of Logic and Data with where: BlocksUsing when/then or given/expectSeparating PreconditionsSeparating Preconditions from ActionsMethod Parameter Capture with MocksUsing a Closure as a Parameter PredicateUsing Hamcrest for Parameter PredicatesParameter Capture Using a Mock Responder@Stepwise SpecificationsHow to Use @StepwiseDisadvantages of @StepwiseConditional SpecificationsMarking Pending FeaturesSelectively Executing TestsAutomatically Cleaning Up ResourcesDocumenting SpecificationsSummary

8. Advanced where: Blocks
A Primary Key VerifierA Static Site Link CheckerJBake ConfigurationA Data Pipe Driven by a FileA Filtered Data PipeRelative FilepathsSummary
9. Asynchronous Testing
Blocking ConstructsBlockingVariableBlockingVariablesTesting Nonblocking APIs by Using CallbacksUsing BlockingVariable in a CallbackUsing a Reference to BlockingVariable.set as a CallbackAwaiting Multiple Values with BlockingVariablesPolling for Eventual StateUsing PollingConditions as a DelegateAsynchronous Interaction TestingAsynchronous Parameter CaptureExtending BlockingVariableSummary
10. Extending Spock
The Message TimelineHamcrest MatchersHamcrest Support in SpockJUnit RulesReusable Data CleanupSimplifying the Rule by Using ExternalResourceMaking the Cleanup Logic GenericSpock ExtensionsData Cleanup as a Spock ExtensionFurther StepsGlobal ExtensionsTaking it FurtherSummary
11. Test-Driven Development: The Diamond Kata
The Diamond KataImplementationFirst Step: The Pathological CaseThe Simplest Valid DiamondEnforcing InvariantsMatrix ContentSymmetryEliminating the Assertion LoopAdding Padding to the RowsRefinementSummary
III. Integrating Spock
12. Spock and Spring
What Do We Mean by “Integration Tests”?Container TestsSpring Compatibility@SpringBootTestTesting Annotation-Driven TransactionsTracking Who Is Mentioned in a MessageNon-Spring-Dependent TestsTesting a Transaction RollbackSetting Up the Spring ApplicationA First Integration TestConvenience and CostUnexpected Side EffectsForcing Spring to Re-Create the Application ContextA Better Way to Force ErrorsMock and Stub BeansMention EventsMock Beans Before Spock 1.1Mock Bean DelegatesDetached Mocks in the Spring ContextSpring Autoconfiguration and Test Configuration ClassesMock Beans in XML ConfigurationReplacing Application Beans with MocksDeclarative Test DataUsing the @Sql Annotation for Data FixturesGlobal Fixture DataCleaning Up Test Data Spring-StyleTests in TransactionsPropagated TransactionsSummary
13. Testing REST APIs
Defining the Application URLA First SpecificationWeb Application LifecycleCreating Data for End-to-End TestsBleeding Data Between TestsCreating Test Data on DemandCleaning Up Test DataRequests with DataFixture MethodsTesting for HTTP ErrorsVerifying Response DataTyped Response EntitiesMultiple HTTP Requests in a Feature MethodBackdoors or “Pure” API Testing?Handling Redirect ResponsesVerifying Redirect DetailsREST API SecurityAuthentication versus AuthorizationSummary
14. End-to-End Web Testing
GebGetting Started with GebA First Frontend TestIntroducing Page ModelsSetting the Base URLGeb’s Automatic DelegationAuthenticationEncapsulating Interactions by Using MethodsModulesParameterized PagesInteracting with FormsAccessing Form Elements by NameEncapsulating Interactions with MethodsForm Validation
15. Testing JavaScript Using Spock
Why Test JavaScript from the JVM?Setting Up Nashorn for TestsCalling JavaScript FunctionsJavaScript Functions as ObjectsSpecifying this in a JavaScript FunctionTesting an Isomorphic View ComponentAn Invocable Script Engine as a DelegatePassing Mocks to JavaScriptRendering a View with the Handlebars LibraryCompiling Handlebars TemplatesTesting Template RenderingHandling Properties That Don’t Convert to JavaScriptRegistering Handlebars Helper FunctionsComposing Templates with Handlebars PartialsPassing Iterable Values to JavaScriptSummary
16. Test Driving an RxJava Application
Tests, Behaviors, and PropertiesThe Skeleton ImplementationTest Driving the ImplementationDefining the BehaviorA First TestPolling at Regular IntervalsNo Sleep `Til the Test Goes GreenTesting Subscription to the StreamUnchunking the Message StreamRequesting Messages Since the Last ReceivedRecovering from Polling ErrorsRecovering from Downstream ErrorsFinal Implementation
A. Groovy Primer
HistorySyntactic and Semantic Differences to JavaSemicolonsImport StatementsClass LiteralsVisibilityExceptionsImplicit ReturnDefault ParametersMethod DispatchValid Java Code That Is Not Valid Groovy CodeDynamic-Typed VariablesList and Map literalsListsMapsRangesImmutabilityMaps as Named ArgumentsSet and Array LiteralsTruthinessPropertiesAccessing PropertiesProperties of Java ClassesStrings in GroovyTemplated StringsRegular Expression LiteralsThe “Dollar-Slashy” StringMultiline StringsOperator OverloadingUnary Math OperatorsComparison OperatorsMathematical OperatorsBitwise OperatorsShift OperatorsOperators Not Present in JavaSafe Dereference OperatorCall OperatorSubscript OperatorsElvis OperatorSpaceship OperatorSpread OperatorsRegular Expression OperatorsField Access OperatorMethod Pointer OperatorOperator-Like KeywordsClosuresDefining ClosuresMethods That Accept ClosuresClosure DelegatesParameter and Delegate Type InformationClosures and Java 8 Functional InterfacesThe Groovy Development KitFunctional Iterator MethodsChained Functional StyleAST TransformationsSummary
Bibliography
Index

Content preview from Spock: Up and Running

Chapter 12. Spock and Spring

In this chapter, we dive into integration testing with the Spring application framework.

In the examples in this chapter, we use Spring Boot 1.4 and Spock 1.1, which include some new features that streamline integration testing. In particular, until Spock 1.1, mocking beans in the application context of an integration test was awkward.

What Do We Mean by “Integration Tests”?

In unit tests, the specification class deals with a unit of code in isolation. Collaborators are mocked or stubbed.

With integration tests, the entire application—or a subset of it—is started and the behavior of the system as a whole is tested. Integration tests typically deal with the larger-scale behavior exhibited by units of code working together.

Integration tests are also a useful way to protect against incorrect assumptions about the way units interact that might have been made in unit tests. For example, if a mock collaborator in a unit test does not behave the way the real collaborator does, the unit test might be incorrect, and without any kind of integration test, this would not be obvious until someone tries to use the application.

Container Tests

Container tests are similar to integration tests in that the application or some subset of it is started; however, their intent is a little different. Container tests focus on how units of code interact with the functionality of the container or framework in which they run. They ensure the framework features have been properly ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781491923283Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design