RSS Feed Subscribe to RSS Feed

 

Blog post summary: What test coverage means by John Gluck

In this What QA Wolf means by “test coverage” post, the author John Gluck starts with a simple definition of test coverage, discusses what tests to write and how, and ultimately cautions against using coverage targets as an end goal.

(more…)

Tags: , ,

Shift Left

Defining the term shift left to mean testing earlier in the development cycle feels antiquated since waiting until development is “complete” before testing is a plain ol’ anti-pattern at this point.

A better definition could be testing earlier and more frequently. Writing tests each sprint, and running those tests with every commit.

Perhaps better still is thinking of shift left as a movement of testing to earlier in the pipeline. Favor unit tests, which typically run in the pipeline first and fast. Heavier-weight tests, such as UI based and end-to-end tests, which are typically harder to write, slower to run, and run later in the pipeline, do have a place but should be used sparingly.

Another way to look at this is that shift left means shifting down the testing pyramid.

 

(more…)

Tags: , , , ,

Blog post summary: We need to talk about testing

I liked this “We need to talk about testing” post from Dan North. It’s about what testing actually means and how programmers and testers can work together. A summary (or copy & paste of the parts that I found most interesting, with some comments) below…

The purpose of testing is to increase confidence for stakeholders through evidence.

(more…)

Tags: , , , ,

Modern Software Testing

As a follow on from my last post about Martin Fowlers article on Testing Shapes e.g. Pyramid and Trophy), Tim Bray‘s post on modern software testing (or, “Testing in the Twenties” as he titled it) caught my eye. Bray believes that these Testing Shapes are “misshapen blobs” that are all “seriously wrong in important ways”. I do like people with opinions 🙂

(more…)

Tags: , , ,

Blog post summary: Test Shapes by Martin Fowler

In his post, “On the Diverse And Fantastical Shapes of Testing“, Martin Fowler talks about the Test Pyramid and Test Trophy, but concludes that the proportions suggested by each are much less important that writing fast, reliable, expressive tests with clear boundaries.

(more…)

Tags: , , , , , , ,

Running an individual unit test with maven

Individual tests can be run from maven. This must be done from within the folder that contains the source (as in the folder that contains src/test/java), which will likely be either be the root of your maven project, or in one of your modules.

For surefire (unit tests), to run a whole test class, this will be something like:

mvn -Dtest=com.your.package.YourTest test

or, to run a specific test method:

mvn -Dtest=com.your.package.YourTest#testMethod test

For failsafe (integration tests), it will be something like:

mvn -Dit.test=com.your.package.YourIT verify

This is covered in the maven surefire plugin docs and maven failesafe plugin docs respectively, but those examples don’t mention packages names, which are required.

Tags: , , , , , , ,

Unit Testing – the Hard Parts @ NYC Code Camp

Thanks to everyone who came to my “Unit Testing – the Hard Parts” presentation @ New York Code Camp. I really enjoyed it! Great crowd, lots of follow up questions. And cool Microsoft office space in Times Square. Thank you to all who attended. My slides are here: http://www.slideshare.net/shaunabram/unit-testing-the-hard-parts

Tags: , , , , , , , , ,

Test Doubles: mocks, dummies and stubs

Most classes have collaborators. When unit testing, you usually want to avoid using real implementations of those collaborators to avoid test brittleness and binding/coupling, and instead use Test Doubles: Mocks, Stubs and Doubles.

This article references two existing articles on the subject: Mocks Aren’t Stubs, by Martin Fowler and The Little Mocker, by “Uncle” Bob Martin. I recommend them both.

 

(more…)

Tags: , , , , , , , , , , ,

Testing private methods in .Net

Feeling the need to test private methods is usually a sign that your code needs refactoring. The recommended approach is that you test your code via it’s public interface. Since your private methods are only accessible via those public methods, it goes that if you have thoroughly testing via the public interface, your private methods will have been tested too.

Still, there can be times testing private methods can be useful. For example, while dealing with either legacy code or when using it as a temporary step while refactoring.

How do you do this in .Net?

(more…)

Tags: ,

Testing for expected exceptions in JUnit

Unit tests are used to verify that a piece of code operates as the developer expects it to. Sometimes, that means checking that the code throws expected exceptions too. JUnit is the standard for unit testing in Java and provides several mechanisms for verifying exceptions were thrown. This article explores the options and their relative merits.

(Note: There are other good options for testing for exceptions using AssertJ, rather than vanilla JUnit. See https://www.baeldung.com/assertj-exception-assertion)
(more…)

Tags: , , ,

Builder Pattern: Good for code, great for tests

I’ve found the builder design pattern occasionally useful in code, but frequently useful in tests. This article is a quick summary of the pattern in general, followed by look at a working example of using it in tests. See the code in github.
(more…)

Tags: , , ,

Software Quality via Unit Testing

The following post is based on a talk I gave at Desert Code Camp 2013. See also the associated slide deck.

Software quality is critical to consistently and continually delivering new features to our users. This articles covers the importance of software quality and how to deliver it via unit testing, Test Driven Development and clean code in general.
Read more

Tags: , , , , , , , , , ,

Spring MVC Hello World with Continuous Deployment

Oh dear, yet another ‘Hello World!’. But although the functionality is trivial, this little SpringMVC project is complete enough for me to use as a template to bootstrap more complex projects. It consists of:

  • HTML/JSP client
  • SpringMVC server using a Controller/Service/DAO design
  • Maven for build and dependency management

This is an updated version of an older project I created, with the following enhancements:

  • Added a full suite of automated tests (unit, integration and browser based)
  • Added placeholders for JavaScript and images (both can be a little tricky to put in the correct place with SpringMVC)
  • Incorporated into a continuous deployment environment

More details below, but you can find the full source code on this GitHub repository

(Previously I had the code deployed on a CloudBees instance at http://springmvc.shaunabram.cloudbees.net, but CloudBees have since unfortunately shut down their free tier).

Read more

Tags: , , , , , , , , , , ,

Add log4j logging for a unit test in IntelliJ

In IntelliJ

  • Click: Run -> Edit Configuration
  • Select your test configuration (or add a new one)
  • In VM parameters, add
    -Dlog4j.configuration=file:/C:/dev/config/log4j.xml
    (Or wherever your log4j properties file is)

That’s it. The test should now run with log4j logging (although obviously you need to have the necessary log4j jars available).
This example uses a windows file format, but will work equally well with *nix.

I use this approach for turning on MyBatis logging for individual tests. See here for a basic setup of a log4j.xml file to enable logging with MyBatis.

Tags: , , , ,

EasyMock

EasyMock is an open source library for creating, and defining the behavior of, mock objects as part of your unit tests. This article describes how to use EasyMock (v3.0), including its record/playback approach, after setting the context with an brief introduction to unit testing in general and the associated need for mock objects.
Read more

Tags: , ,