Stop Being Lazy and Test Your Software

Stop Being Lazy and Test Your Software!
Laura Frank
Software Engineer, Codeship

0.7.0
ImageLayers
Panamax
Berlin

Agenda
Continuous Delivery
Why Do We Test?
Testing with Docker Compose
Faster Testing with Docker

Why Do We Test?
Motivations and frustrations

Testing software has been
a practice since the very
first machines were used
for computing.

The women who
programmed the ENIAC to
calculate trajectories
periodically checked the
results with a correct,
hand-computed table.

working software
in production
testing
code reviews
version control
pair programming
high-availability architecture

Motivators
Update application without breaking things!
Validate functionality of updates
Be able to trust deployment checks (in CI/CD workflow)
Confirm that refactoring didn’t break existing functionality

Why do you skip tests?
45%
15%
5%
35% Too slow to run suite 35%
Annoying extra step 15%
Don’t see the point 5%
Slows down deployment 45%
10

Frustrators
It takes me an hour to write a single test
My new tests just duplicate existing coverages so there’s no
point (integration overlapping with unit)
My suite fails all the time for no apparent reason…?
It takes my test suite over 20 minutes to run, so I don’t run it
locally
Testing distracts me from my normal development workflow
Setting up a testing environment is a huge pain
It takes too long to deploy when I have a huge test suite

Using Docker can alleviate
some frustrations
associated with testing.

Testing with Docker
Compose
It’s easy, I promise

Docker and testing are a great pair.
❌ ✔

With Docker Compose, it is incredibly
easy to create consistent,
reproducible environments.
❌ ✔

Many of us already use
Docker Compose to set
up dev environments.

Use your Docker Compose
environment for testing
as well.

app:
build: .
command: rails server -p 3000 -b '0.0.0.0'
volumes:
- .:/app
ports:
- '3000:3000'
links:
- postgres
postgres:
image: postgres:9.4
A simple Rails app

?!
git clone && docker-compose up
hackity hack
How do I make tests happen?
Development workflow

app:
build: .
command: rspec spec
volumes:
- .:/app
ports:
- '3000:3000'
links:
- postgres
postgres:
image: postgres:9.4
A simple Rails app

In most cases, we need to
do a bit of setup
before running tests.

You might even need a
different Dockerfile.

Docker Compose makes this easy
app:
build: .
dockerfile: Dockerfile.test
command: rake test
volumes:
- .:/app

You can also run one-off
commands against a service
with Docker Compose.

docker-compose run -e "RAILS_ENV=test"
app rake db:setup
docker-compose run -e "RAILS_ENV=test"
app test-command path/to/spec.rb
docker-compose up #-d if you wish
Usual Docker Compose development
environment
Run rake task to set up db
Then run tests against Docker services

Additional Docker Compose Testing
Config Options
environment:
RACK_ENV: test

Additional Docker Compose Testing
Config Options
$ docker-compose up -d
$ ./run_tests
$ docker-compose stop
$ docker-compose rm –f

Docker delivers a
predictable, reproducible
testing environment. Period.

Continuous Integration,
Testing, and Docker
Fail fast and not in production!

Continuous integration and
testing go hand in hand.
👯

Relying on CI/CD without
adequate test coverage
is not a great idea.

Would you rather…
✔
💩
Find out your code is broken by
seeing a failed run of your CI/CD
system?
Find out your code is broken by
seeing 500s on 500s on 500s in
production?

What about running tests
like this…
…inside a container?

We run our unit tests in a
conatiner during development,
so we should do that during
deployment too, right?

And if we’re running our
services in containers
during development,
they should be running
in containers in
production, right?

—JérômePetazzoni
“Docker-in-Docker is not
100% made of sparkles,
ponies, and unicorns.
46

CAUTION!
YMMV
See https://jpetazzo.github.io
- Mixing file systems == bad time
- Shared build cache == bad time
- Lots of other stuff == bad time

Shared daemon – what we really want

We get this by binding the
Docker socket.

Parallel Testing with
Docker
Break it up.

Why do you skip tests?
45%
15%
5%
35% Too slow to run suite 35%
Annoying extra step 15%
Don’t see the point 5%
Slows down deployment 45%
52

When developing, it’s easy
to think of a container as
a small VM that runs a
specific workload.

But if we change our thinking
to treat containers as just
processes, then we can do
some pretty cool stuff.

A syntax similar to Docker Compose for
service definition…
57
web:
build:
image: my_app
dockerfile_path: Dockerfile
links:
- redis
- postgres
redis:
image: redis
postgres:
image: postgres

And use it to also define testing steps…
58
- type: parallel
steps:
- service: demo
command: ruby check.rb
- service: demo
command: rake teaspoon suite=jasmine
- service: demo
command: rake test

- type: parallel
steps:
- service: demo
command: some-test-command
- service: demo
command: another-test-command
- service: demo
command: yet-another-test-command
Each step is run independently in
a container
59

- service: demo
command: some-test-command
- service: demo
command: another-test-command
- service: demo
command: yet-another-test-command
And each container may be located in a
range of availability zones
60

Test compose context
Test runner
jet
test-1
test-0
test-3

Docker makes this possible by
providing the means to create
a predictable, reproducible
testing environment.

Super Cool Tip™
Because quality is everyone’s problem.

Add an additional
pipeline to fail builds if
quality decreases.

Two good examples are
code coverate and
linting errors.

#!/bin/bash
set –e
ALLOWED_WARNINGS=100 #some arbitrary threshold
warnings=`grep "offenses detected" rubocop.txt | cut -d " " –f4`
if [ $warnings -gt $ALLOWED_WARNINGS ]
then
echo -e "033[31mallowed warnings $ALLOWED_WARNINGS033[0m"
echo -e "033[31mactual warnings $warnings033[0m"
echo -e "033[31mToo many rubocop warnings033[0m"
echo -e "033[31mTry running 'bin/check_rubocop_against_master’033[0m"
exit 1
else
echo $warnings/$ALLOWED_WARNINGS is close enough ಠ_ಠ
exit 0
fi

—Solomon(moreorless)
“Improving quality is a
lot of unglamourous
work that really adds up.”
68

Highly recommended talks about development, testing,
and lots of interesting stuff: https://speakerdeck.com/searls
Ruby gem for parallel tests: grosser/parallel_tests
Parallel Docker testing: Jet (from Codeship)
CI/CD with Docker: http://pages.codeship.com/docker
Running commands with Docker Compose:
http://docs.docker.com/compose
The perils of Docker-In-Docker: https://jpetazzo.github.io
This talk: slideshare.net/rheinwein

—EdsgerDijkstra
“Testing can be a very
effective way to show the
presence of bugs, but is
hopelessly inadequate for
showing their absence.”
71

Testing does not
guarantee that
our software works.

We test to know
when our software is
definitely broken.

Work harder to know
when you’re wrong.

Thank you!
Laura Frank
@rhein_wein
laura@codeship.com

Stop Being Lazy and Test Your Software

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Stop Being Lazy and Test Your Software

Similaire à Stop Being Lazy and Test Your Software (20)

Plus de Laura Frank Tacho

Plus de Laura Frank Tacho (7)

Dernier

Dernier (20)

Stop Being Lazy and Test Your Software