►
Description
Sebastian Daschner presents as part of JakartaOne Livestream 2020
For most projects, testing is not really fun. It’s boring, cumbersome, and takes time and effort – especially for distributed applications or when changes in existing functionality forces test scenarios to adapt. Still, software tests are crucial; so, how can we tackle them in an effective and productive way?
This session shows what is necessary to effectively test Jakarta microservices in an automated way. We’ll see which approaches work well, how to keep a fast feedback loop and constant velocity, how to manage complex test scenarios that involve multiple services, and how to verify our API contracts. One of the key aspects will be how to write maintainable test code with high quality that embraces principles of software craftsmanship. I’ll be live-coding test cases using Enterprise Java, Jakarta EE, MicroProfile, Docker, and Kubernetes. Join us to improve your testing flow experience.
Get Social!
Website: jakarta.ee
Subscribe: https://www.youtube.com/user/EclipseFdn
Follow us on Twitter: https://twitter.com/JakartaEE
Like us on Facebook: https://www.facebook.com/JakartaEE/
Join us on LinkedIn: https://www.linkedin.com/groups/13597
Tag us: #JakartaEE
A
B
C
C
B
A
That
is
fabulous
titles,
so
we
can-
and
I
don't
think
I
need
to
do
any
special
introductions
for
sebastian,
we're
all
familiar
with
you
and
and
your
fabulous
work,
and
we
know
based
on
the
logo
there,
who
are
you
working
for
that
that
fabulous
ibm
logo.
So
if
you
wanna
just
take
it
over
from
here,
that
would
be
great.
C
Well,
yeah
thanks
a
lot
for
the
introduction
and
yeah
for
everybody.
Welcome
from
my
side
as
well,
and
I'm
very
happy
to
be
here
on
the
second
edition
of
the
jakarta
one
live
stream.
I
even
have
some
pin
here
about
the
second
edition
and
some
about
yes,
very
excited,
so
jakarta
nine,
like
my
duke
really
likes
these
enjoys.
C
C
C
I
like
coffee,
so
today
what
I
will
show
you
is
some
coffee
shop
example
application,
and
it's
quite
important
to
me
for
this
testing
topic
that
we
share
something
or
that
I
show
you
some
examples
that
are
actually
a
little
bit
more
than
you
know
just
trivial,
hello
world,
but
so
we
actually
have
some
micro
services
where
there's
something
going
on.
Why?
Because
for
the
testing
perspective,
it's
quite
often
the
case.
C
I
use
quercus
to
run
that
and
also
we
have
some
database.
So,
even
in
our
quite
simplistic
example,
we
at
least
already
have
some
persistence
that,
of
course,
we
need
to
deal
with
when
testing
this
application
later
on
and
the
user
is
going
to
talk
to
that
application
via
http
http,
for
example-
and
you
know,
order
some
coffee.
So
that's
basically
the
scenario
we
would
like
to
have
some
coffee
and
then
also
just
to
make
it
a
little
bit
more
interesting.
C
We're
gonna
have
some
asynchronous
communication
with
that
barista
back
end,
so
you
know
the
friendly
person
who
brews
your
coffee
and
to
make
it
more
interesting.
We
have
an
asynchronous
communications
so
to
see.
Well,
if
we
set
up
a
more
complex
testing
scenario,
we
of
course
need
to
account
for
that
right.
We
need
to
make
sure
that
still
everything
works
also
from
a
more
complex
use
case
perspective,
and
now
that's
what
I
want
to
show
you
so
here
what
we
have
is
a
project
or
actually
this
one.
C
This
is
the
coffee
shop
project
and
I
have
well
two
projects,
this
coffee
shop
and
the
barista,
but
the
main
application
that
we
would
like
to
test
is
this
coffee
shop
application
and
what
I
have.
This
is
a
quercus
application.
So
probably
you
heard
about
this
interesting
technology.
That's
now
around
for
about
one
and
a
half
years,
supersonic
subatomic
java
that
that's
the
good
news
it
supports
jakarta
and
microprofile
apis,
so
you're,
probably
familiar
with
writing
some
cork
applications.
C
Here
you
can
check
out
that
website
quarkus.io
and
I
have
well
some
resources
there
for
you,
so
some
classes-
and
you
know
like
jax
or
s,
some
rest
communication,
but
instead
of
talking,
I
just
can
deploy
this
locally
and
show
to
you
how
we
actually
run
this
and
in
my
local
setup,
that's
already
the
interest
first
interesting
thing.
What
I
would
like
to
show
you
is
how
to
test
this
at
first
of
all
locally
and
a
manual
approach.
C
You
know
just
what
the
application
does
and
in
order
to
do
that,
I'm
gonna
deploy
it
locally.
So
that's
already
one
takeaway
to
test
something
with
efficiency
that
I
want
to
be
able
to
test
something
in
a
local
setup.
Not
all
of
the
applications
actually
have
to
set
up.
You
know
have
to
be
set
up
in
the
correct
way.
There
can
be
some
marks
instead
and
things
like
that.
So
we're
gonna
cover
that,
but
in
general
I
want
to
be
able
to
set
up
my
environment
just
very
quickly,
ideally
locally
thanks
to
containers.
C
I
can
actually
do
this,
so
what
I'm
gonna
have
now.
I
start
three
containers
locally
y3,
well,
one
for
the
coffee
shop,
one
for
the
barista
and
one
for
the
database.
So
if
I
start
this
and
I've
asked
docker,
it
shows
me
three
running
containers,
one
coffee
shop,
one
barista
and
one
coffee
shop
db,
which
is
actually
a
postgres
in
my
case.
So
I'm
going
to
start
this
up
awesome
and
I
have
some
locally
published
ports
so
by
a
local
host.
C
C
By
the
way,
it
shows
me
that
my
application
is
up
and
running
now,
so
my
coffee
shop
is
there
that's
good
news
and
I
can
show
you
well:
there
is
an
orders
resource
so
ultimately
we're
going
to
talk
about
coffee,
so
we
have
something
like
coffee
or
this
that
I
actually
can
persist
in
my
database
and
that
I
can
communicate
with
using
this
jaxarous
resource.
So
I
have
this
orders
resource
like
slash
orders
where
I
can.
C
You
know,
read
some
coffee
and
create
some
coffee
orders
by
posting
to
some
json
and
things
like
that,
and
then
we
can
briefly
walk
through
this
code
here
and
see.
Okay.
Actually,
this
is
you
know
a
jack
source
resource,
and
then
we
have
some
cdi
injected
beans.
So
I
have
a
coffee
shop
that
is
actually
a
transactional
application,
scoped
bean,
and
then
you
know
I
talk
to
my
database
and
so
on
and
so
forth
and
well
by
doing
so.
Okay,
let's
check
this
out.
C
I
can
actually
ask
my
orders
and
point
to
give
me
the
list
of
all
orders
so,
and
that
is
an
empty
array,
so
there's
no
order
in
the
system,
okay,
so
to
change
that,
I
would
like
to
post
some
json
to
the
application.
So
I
would
like
to
create
some
coffee
order.
Okay,
how
is
an
order
represented
in
json?
Let's
have
a
look
at
this,
so
there
is
just
a
class
here.
That's
a
jpa
entity
which
also
is
used
which
I
can
use
to
just
persist
it.
So
I
have
a
coffee
type.
C
That
is
something
like
a
drink
type
and
an
origin
that
is
like
you
know
the
country,
the
coffee
origin,
from
the
drink
that
I
would
like
to
order,
which
I
need
to
specify
at
my
order.
So
I
say
I
have
something
like
you
know:
an
espresso
and
the
origin
is
beautiful
country,
colombia,
okay,
let's
do
this,
and
now,
if
I
okay,
let's
do
it
again
and
ask
for
the
headers
two
one
created
okay,
great,
this
worked
now.
If
it
worked,
then,
actually,
if
I
ask
for
the
orders,
I
should
get
them
back
right.
C
Okay,
let's
test
this.
As
well,
okay,
awesome,
I
got
now
two
orders
in
the
system
with
some
you
know
origin
and
they
also
have
some
status.
Okay,
interesting
and
even
I
was
a
little
bit
too
slow.
If
I
make
it
immediately,
I
see
that
also
the
status
gets
updated.
Okay,
so
what's
what's
this?
Let's
try
it
again
at
first.
It
says
coffee
here
preparing,
then
it
says,
finished
and
then,
after
a
while
it
says
collected.
C
C
Okay,
so
well,
by
doing
so,
we
already
tested
it
right
like
manually,
that's
already,
typically
one
of
the
first
things
we
do
as
developers
right
we
write
something,
and
then
we
try
it
out
something
like
manually.
We
run
it
by
localhost.
We
run
some
main
method
whatever
and
well.
It
is,
if
you
argue
already
now
ready
for
production
right,
so
I
tested
it
manually.
I
checked
out
that
I
could
per
system
orders.
C
I
saw
that
the
order
is
in
the
system
here
I
could
also
test
you
know
if
I
shut
down
my
application
and
the
database
key
is
still
there
that
afterwards
my
order
is
still
available.
I
saw
that
the
status
transition
works
okay,
but
well,
of
course,
this
is
not
the
best
way
to
test
this
in
a
somewhat
efficient
way.
Why?
Because
this
was
a
manual
test
and
tomorrow,
if
I
change
something
in
the
features,
I
would
need
to
test
it
again.
C
So
of
course,
I
would
like
to
have
some
automated
test
and
what
I
would
like
to
start
with
is
a
so-called
system
test
or
some
sort
of
acceptance
test
where
I
actually
test
my
application
somewhat
similar
to
sorry
this
one
system
test
that
tests
actually
the
application,
the
coffee
shop
and
then
it
uses
also
the
barista
application.
It
can
be
the
actual
barista
like
I
used,
or
it
can
be
some
mock.
So
what
I?
What
I
would
like
to
test
now
is
similar.
C
What
I
did
on
a
command
line
is
to
just
examine
whether
my
coffee
shop,
microservice
behaves
correctly.
That
is
using
the
correct
deployment.
It
will
be
deployed
in
the
same
way
like
later
on
in
production
and
using
the
same
endpoints.
That
is
important
to
have
efficiency
right.
We
would
like
to
test
with
efficiency.
Why?
Because,
if
I
change
something
in
the
configuration,
if
I
run
my
application
a
little
bit
differently
to
production,
then
I
actually
need
to
test
it
again,
because
every
difference
that
I
have
might
later
on
just
fail.
C
So
that's
an
important
point
to
mention,
and
this
is
why,
in
my
system,
test
environment
and
locally,
I
could
argue
this
is
already
a
system
test
environment.
Why?
Because
I
run
docker
containers
and
the
containers
are
started
from
the
same
image
that
would
be
deployed
to
production.
So
that
is
something
that
I
can
already
start
with,
but
of
course,
instead
of
doing
the
command
line.
What
I
would
like
to
have
is
to
run
something
like
a
system
test
from
java.
Why
java?
C
Well,
because
I'm
a
java
developer,
it
doesn't
even
have
to
be
the
same
technology.
It
doesn't
even
have
to
be
java.
If
you
like,
you
know,
would
like
to
write
your
system
test
from
a
command
line.
You
can
do
that
as
well,
but
I
just
advise
to
use
you
know
technology
that
you're
familiar
with,
so
I
have
the
system
test
project
that
I
typically
like
to
separate.
Why?
C
Because,
then
not
accidentally,
I'm
reusing
some
sources
from
my
production
code
and
then
you
know
I
might
change
one
side,
and
I
forgot
that
I
changed
one
side
already
and
the
test
is
green,
although
it
should
be
red-
and
in
this
case
I
like
to
separate
them-
and
I
have
something
like
this
here-
which
is
called
great
order,
naive
test
I'll,
tell
you
in
a
second.
Why
naive?
C
But
this
is
basically
in
java
to
what
I
just
did
in
the
command
line
that
you
see
well
we're
going
to
connect
to
our
system,
which
here
is
localhost,
and
I
would
like
to
you
know,
create
some
order,
so
I
would
like
to
http
post
to
my
jakarta
application
and
then
post
something
so
here
what
I'm
going
to
do
create
verify
order.
This
is
this
method?
Okay,
let's
try
to
look
through
it
new
order,
okay,
so
http
post.
I
would
like
to
post
some
json
to
this
resource.
C
This
is
what
I
did
in
the
command
line.
If
you
remember,
I
have
this
orders
target.
So
what
is
this?
That's
a
jax
jaxars
client
api,
so
I
use
checksures
on
the
client
side.
I
could
use
any
http
client
that
I
want,
but
actually,
since
I'm
already
in
a
jakarta
project,
I
typically
like
to
reuse
these
apis
because
I'm
typically
familiar
with
them
and
so
is
the
team.
So
that's
usually
a
good
idea,
and
then
I
can
use
this
to
you
know
like
request.
C
This
http
post
then
check
whether
it's
successful
and
so
on
and
so
forth,
and
then
probably
you
saw
that
I
have
some
http
location
header.
So
once
I
post
some
new
coffee
order,
then
I
see
where
the
order
is
actually
where
the
order
resides
and
then
later
on,
I
can
get
some
more
information
like
type
origin
status.
C
C
So
I
assert
that
this
is
the
case
and
then
bonus
points.
If
I
list
all
orders
and
see
if
it's
inside
okay
now,
if
I
would
ask
you
who
has
seen
test
code
like
this,
then
probably
a
lot
of
you
would,
you
know,
say:
okay,
I've
probably
seen
or
written
some
system
tests
like
this.
You
know
like
just
one
step
after
another
which
comes
naturally,
if
I
would
like
to
replicate
what
I
just
did
in
a
command
line.
C
But
it's
actually
a
totally
different
question.
What
you
would
like
to
test-
and
this
is
one
of
the
biggest
challenges
that
I
see
in
test
code-
that
there
is
actually
that
there
are
test
methods
that
are
well
too
big
or
to
do
too
many
things
or
to
be
more
precise.
They
have
too
many
concerns.
They
are
on
too
many
abstraction
layers
at
the
same
time
and
what
is
wrong
with
this?
Well,
first
of
all,
you
don't
really
comprehend
it
at
the
first
class.
C
Now,
if
we
would
like
to
to
do
this,
then
of
course
what's
going
to
happen,
you
know
what
is
going
to
happen.
I
take
this
method
and
I'm
going
to
copy
and
paste
it
to
here
and
then
I
said:
okay
now
create
verify
order
from
a
different
country
or,
for
example,
for
cappuccino
right
so
create
verify
order
cappuccino.
Now
I
have
a
typo
here.
Intellij
complains
because
intellij
knows
about
coffee,
apparently
cappuccino.
That's
correct,
cappuccino,
nice
ide!
That
tells
me
that
my
coffee
spelling
is
incorrect.
That's
great!
C
Now
I
have
to
change
this
right
and
then
I
have
well
actually
to
read
my
method.
Is
there
another
occurrence
of
cappuccino
and
so
on
and
so
forth?
So
you
know
this
is
not
really
sustainable
because
what's
next
well,
guess
what
what?
What
if
I
change
the
country
as
well,
then
at
some
point
I
end
up
with
many
many
copy
and
pasted
lines
of
code,
which
is
just
a
bad
idea.
C
Okay,
what
is
actually
another
problem?
Well,
what?
If
we
change
the
communication
from
json
to
something
else,
or
you
know
http
to
something
else,
then
you
can
throw
away
this
whole
class
right,
because
it's
just
too
much
entangle
between
you
actually
test
actual
test
code,
test
scenario,
code
and
the
implementation,
and
the
missing
point
here
is
the
following
abstraction.
C
So
what
you
have
in
this
test
method?
You
have
too
many
layer
levels
of
abstraction
at
once.
It
does
too
many
things.
It
has
too
many
concerns.
So,
first
of
all,
it
has
the
concern
of
the
actual
test
scenario,
then
about
you
know
the
communication:
how
to
talk
to
my
back
and
how
the
orders
are
represented
in
json
and
so
on,
and
that's
a
bad
idea.
C
So
what
I
would
like
to
do.
Usually
I
like
to
start
from
a
blank
space
and
just
ask
myself
what
am
I
going
to
test?
So
if
I
have
some,
you
know
just
some
pseudo
test
here
and
if
I
say
well
actually
what
are
you
going
to
test
from
a
very
abstract
perspective
from
a
user's
perspective?
What
do
I
want
to
do?
C
C
Okay,
I
would
like
to
identify
it
somehow.
So
let's
say
I'm
going
to
save
the
coffee
order,
id
right
and
then
I
say
verify
that
the
coffee
order
so
and
so
has
espresso
from
colombia.
So
I
verify
that
the
persistence
is
correct
and
then
you
know
and
so
on
and
so
forth.
I
can
verify
that
the
list
has
this
coffee
order,
the
list
of
all
orders,
but
that's
it.
That's
actually
my
test
scenario
from
an
abstract
level.
C
What
I
would
like
to
test
for
the
user
and
now
then
like
we
can
talk
about
how
we
gonna
create
the
coffee
order,
how
that
is
implemented,
and
if
we
follow
this,
then
we
actually
end
up
with
the
test.
That
looks
a
little
bit
more
like
this,
so
that's
the
proper
create
order
test
where
we
say
actually.
Okay
create
verify
order
that
this
that
this
is
the
case
here
and
I
think
for
later
on,
not
for
my
test
to
fail.
I
actually
have
to
delete
them
again
for
the
cappuccino.
C
Let's
do
this
quickly
now,
what
I'm
going
to
do
instead
create
verify
order,
that's
the
same
method.
I
say:
nuke
order,
espresso,
columbia,
okay
and
then
coffee
or
the
system.
That's
a
delegate
here,
just
a
plain
java
class:
nothing
special,
no
magic
dot,
create
order,
okay,
how
it's
going
to
create
the
order.
I
have
no
clue
and
I
don't
want
to
know
I
now
care
about
my
test
scenario
and
then
coffee
or
the
system
get
the
order
load.
The
order
by
this
identifier.
C
I
use
a
uri
here
and
then
just
make
sure.
That's
actually,
you
know
that
the
information
matches
the
type
and
the
origin
and
so
on
and
so
forth,
and
that's
it-
and
this
is
my
test
method
that
I
would
like
to
verify.
And
now,
if
I'm
going
to
copy
and
paste
this
code,
then
it's
actually
comprehensive
comprehensible.
C
Because
I
see
what
information
I
have
here
there
that
there
is
just
an
espresso
and
columbia
here,
just
information.
I
see
it
immediately
and
you
know,
and
so
on
and
so
forth,
and
now,
if
I'm
interested
how
it's
going
to
be
created.
Well,
I
look
into
this
delegate.
Obviously,
so
I
look
into
this
lower
abstraction
layer
and
this
now
encloses
everything
that
is,
you
know
regarding
http
regarding
json,
but
not
regarding
my
actual
test
scenario.
So
I
separate
these
lives,
these
abstraction
layers
and
well.
C
Actually
there
shouldn't
be
anything
new
for
you
right
because
in
production
code
we
do
this
all
the
time
we
care
about
proper
test
code
quality,
but
I
can
tell
you
it's
not
forbidden
to
do
this
in
test
code.
It's
actually
a
good
idea
to
do
it
there
as
well
to
just
end
up
with
maintainable
tests.
Why
maintainable?
Because
now,
if
I
like,
I
told
you
if
something
in
the
test
scenario
changes
then
quite
quickly,
I
can
change
it
here
without
modifying
the
other
delegates.
C
So
if
I
talk
about
crate
order,
I
don't
say
you
know
json
anything
or
http
status.
I
don't
care
about
http
status.
I
just
see
new
order
and
the
order-
that's
actually
a
special
type
here,
just
for
the
test
test,
scope
or
my
test
project
here
it
can
be,
you
know
it
doesn't
have
to
be
strictly
type
or
whatever.
That's
fine
just
for
the
test
scenario,
but
I
make
sure
that
I
don't
leak
anything
here
for
the
underlying
details.
So
that's
quite
a.
A
C
Yes,
that's
a
very
good
question
so,
as
you
saw,
this
is
a
separate
project
st
that
stands
for
system
test,
or
you
know
like
some
specific
test
project.
Why
is
it
a
separate
project
so
here
this
is
also
java,
and
this
actually
uses
a
java
usual
made
in
surefire
test.
Like
you
know,
test
test,
why
is
it
separate
just
to
make
sure
that
I
don't
have
any
accidental
coupling
with
the
code?
So
with
my
test,
my
system
test
that
I
have
somewhere
here
here?
C
It
is
a
separate
project
and
it
should
not
be
entangled
to
the
production
code.
So
potentially
you
could
swap
it
to
any
other
technology.
If
you
would
like
to
to
write
your
system
test-
and
you
know
bash
scripts-
that's
also
fine.
It's
basically
what
I
did
on
a
command
line,
so
you
specifically
don't
want
to
have
any
coupling
to
your
production
code
to
basically
say
well,
I
really
want
to
test
my
system
from
the
outside,
so
I
only
and
exclusively
use
the
external
boundaries
for
this
test.
Why?
C
Because
now
I
want
to
simulate
what
the
user
is
going
to
see.
So
it's
the
same
thing
as
if
the
user
really
would
go
against
my
application,
using
coral
using
some
other
h2p
client
and
say
well,
please
post
some.
You
know
like
json
to
create
some
coffee
order,
so
in
this
case
I'm
not
tangly,
I'm
not
tangled
to
my
production
code
or
to
my
code
of
the
project
in
a
second,
we
will
see
some
example
for
actual
code
level
tests.
C
C
C
So
if
you
want
to
check
out
the
font
since
some
installation
in
this
one,
if
you
can
read
it,
jetpens
mono
the
latest
versions
of
intellij
shipped
this
per
default
and
what
I
did
because
I
really
liked
the
font
I
downloaded
it
and
also
included,
in
my
you
know,
command
line
and
in
my
editors
and
all
that,
so
I
use
this
font
now
everywhere.
It's
open
source,
as
far
as
I
know
and
yeah-
that's
a
really
nice
one.
So
thanks
for
the
question
you
can
check
this
out
yourself
and.
C
All
right,
so
that's
about
this,
this
test
now
one
more
thing
that
is
a
little
bit
more
interesting
now
if
we
also
test
the
communication
between
these
two
micro
services.
Why?
So?
We
also
have
you
know
some
communication
down
here
happening
between
the
coffee
shop
and
the
barista
and
well
we
want
to
see
whether
this
this
is
correctly.
C
This
is
correct
and
well.
It
is
not
that
easy
in
the
beginning.
Why?
Because
it's
an
asynchronous
communication,
and
just
because
we
right
now
created
some
coffee
order.
We
don't
know
whether
it's
there
immediately
or
just
some
time
later.
So
what
I
have
here,
I
have
a
second
delegate,
a
second
not
here,
but
here
second
component
in
my
test,
that
is
the
barista
system,
so
that
also
encapsulates
the
communication
with
my
barista
and,
of
course,
from
a
user
perspective,
I
don't
have
to
talk
to
the
barista
right.
C
That's
that's
an
internal
back
end,
but
now
for
my
system
test.
I
actually
do
why,
because
I
can
deploy
a
mock,
a
mock
service.
Why
should
I
do
this?
Well,
in
the
same
way
like
I
use
mocs
like
mokito
on
a
code
level
to
see
whether
this
interaction
is
correct,
so
I
can
control
and
verify
whether
all
of
the
communication
here
is
done
correctly.
C
So
what
I
can
do
I
use
in
my
case
wiremock,
so
instead
of
the
proper
barista
in
my
system
test
environment-
and
I
can
do
this
locally
as
well.
Thanks
to
containers,
I
can
actually
deploy
a
wire
mock.
That
is,
the
mocking
http
server
instead
of
the
actual
barista
and
just
say
well,
like
a
mock,
just
act
as
if
you
were
a
barista
and
then
you
know
respond
correctly
to
the
correct
http
invocations.
C
So
if
you
will
be
called
in
the
future
for
this
order,
id
then
please
say
preparing
status
and
afterwards
say
finish
status,
and
then
we
test
this
ping-pong
status
transition.
Whether
all
of
the
communication
is
correct,
so
what
I
have
to
do
in
the
meantime-
and
there
is
basically
no
better
way
for
this-
because
it's
asynchronous-
I
don't
know
when
it
happens.
I
basically
have
to
wait
for
the
invocation
to
happen
in
my
system
test.
C
So
I
say
well
in
a
loop
somewhat
see
if
it
already
has
been
invoked
for
this
specific
request
request
where
it
already
matched
and
if
that
is
the
case,
then
well
continue
with
some
timeout.
So
that's
basically
it
and
then
I
can
see
if
not
only
the
information
but
also
the
status
transition
is
correct.
So,
let's
test
this
here,
I'm
going
to
start
my
docker
containers
and
I'm
going
to
fire
up
a
system
test
environment
that
is
very
similar
to
what
I
just
did,
but
instead
of
the
correct
barista,
I
run
just
mock.
C
C
So,
let's
see
yes
now
it's
up
and
running
that's
good,
and
then
I
at
first
can
run
well
this
very
test,
so
I
can
run
it
of
course,
either
by
a
maven
from
the
command
line
or
by
my
ide.
So
this
is
again
a
surefire
test,
so
I
can
just
simply
say
a
maven
build
or
maybe
verify,
but
now
in
the
system
test
project
you
know
different
project.
C
C
Okay,
looks
good
so
now
this
is
this.
Is
there
I
can
do
it
again,
so
I
can
run
it
again
and
then
the
order
will
be
there
now
testing
with
efficiency
and
joy.
You
saw
how
quickly
I
could
start
up
my
test.
So
my
point
is
what
I
really
like:
are
environments
system,
test
environment,
where
I
separate
the
environment
life
cycle
from
a
test
life
cycle,
so
in
case
you're
wondering
why
this
is
just
applying
junit
test,
nothing,
fancy!
No!
C
You
know
like
run
with
annotation
or
a
test
extension
that
fires
up
a
lot
of
stuff.
Well,
that's
on
purpose!
Why?
Because
I
want
to
have
fast
results.
So
if
I
run
my
test
again
then
immediately
well
depends
on
how
fast
my
idea
is
immediately.
I
get
the
result
now.
It's
green.
Why?
Because
it
just
connects
against
the
already
running
environment,
so
I
don't
have
to
restart
and
wait
for
the
you
know
like
five
seconds
of
startup
time,
each
and
every
time
why?
C
In
this
case,
you
can
actually
make
use
of
these
features
like
quercus,
and
some
other
jakarta
runtimes
have
is
that
you
have
some
development
mode,
which
is
actually
the
case
for
me.
So
this
runs
now
in
a
development
mode
like
a
quarkx
application,
and
I
can
actually
make
some
changes.
So
let's
try
this
out.
I
can
say
there
is
some
builder
for
my
root
page
here.
So
at
first
I
have
some.
C
I
would
say
to
just
understand
that
I
would
like
to
separate
these
life
cycle
from
the
test
environment
to
the
test
scenario.
So
my
test
should
really
just
you
know,
fire
up
against
the
environment
that
is
already
running
and
later
on.
I
also
see
you
know
like
how
I
can
make
some.
You
know
some
more
enhanced
changes
for
that.
So
that's
this
is
really
helpful
and
as
a
so
I
always
have
fast
feedback.
I
don't
really
have
to
wait
here,
because
my
application,
just
you
know
whatever
change
I
make.
C
I
can
quickly
either
redeploy
super
fast
or
retest
retest
and
I
always
get
very
fast
feedback
within
you
know
a
second
or
two.
That's
really
really
a
nice
way
to
do
that,
all
right.
So
what
I
also
would
like
to
show
you
is,
and
then
I
can
stop
this
local
environment
is
to
do
the
system
test
against
a
kubernetes
cluster.
So
I
have
some
kubernetes
cluster
here
via
a
cloud
provisioning,
so
I
have
the
ibm
cloud
managed
kubernetes
service
with
a
kubernetes
cluster.
Why?
C
Well,
because,
sometimes
now
I
will
stop
my
local
environment
here.
Sometimes
I
have
to
test
against
some
environment
where
I
have
not
all
of
the
things
locally.
I
have
you
know
there
are
some
ways
to
get
that
up
and
running
as
well,
but
sometimes
it's
just
the
case
that
I
would
like
to
test
in
an
environment
that
is
just
you
know
like
closer
to
production,
with
some
login
or
authentication
service
being
provided
and
so
on
and
so
forth,
and
by
doing
so
I
can
actually
make
use
of
these
containers
and
of
my
proper
test.
C
C
So
what
I'm
going
to
create
is
well
actually
very
similar,
I'm
going
to
create
a
kubernetes
service
and
deployment
for
each
the
coffee
shop
and
the
barista
in
my
case
actually
also
wiremock
for
the
system
test
and
the
database.
So
once
that
is
the
case,
I
have
some
parts
running
and
some
you
know
services.
So
if
you're
familiar
with
some
kubernetes
environment,
this
might
probably
look
familiar
to
you
and
once
that
is
up
and
running,
I
can
actually
see
well.
C
C
So
I
will
point
of,
of
course
you
to
all
of
these
resources
how
to
try
this
out
yourself.
But
that
point
that
I
want
to
make
is
not
actually
deploying
to
kubernetes,
but
that
I
can
reuse
my
system
test
now
against
a
different
environment.
So
I
can
say:
well
actually
please
point
the
system
test
not
to
this
local
environment,
but
actually
to
something
else,
and
because
I
separated
my
life
cycles
here.
I
can
actually
say
well
use
this
barista
system
or
the
coffee
order
system
and
not
use
localhost,
but
just
something
else.
C
So
I
can
go
to
my
system
test
environment
and
say
now
on
the
command
line,
because
it's
easier
to
reconfigure,
if
I
say
verify,
made
and
verify
this
verify
starts
my
surefire
tests
and
I
can
say
please
point
these
environment
variables
to
the
ip
address
of
my
cluster
and
then
what
it's
going
to
do.
It
is
actually
going
to
create
some
coffee
orders
in
my
kubernetes
cluster
in
the
system
test
environment.
So
I
run
the
same
test
that
I
just
had
before,
and
it
now
uses
a
different
environment
to
test
against.
C
So
that's
a
nice
story.
I
can
reuse
the
test
that
I
just
wrote
by
you
know
having
the
separation
by
having
this
abstraction
in
place,
and
now,
if
I
ask
for
the
curl
orders
now
now,
it's
actually
being
filled
with
my
system
test
orders.
So
we
saw
that
it's
actually
using
this
a
production,
cluster
or
system
test
cluster
here
with
this
environment.
So
that's
really
helpful
to
be
able
to
reuse.
C
You
know
these
type
of
tests,
so
that's
I
was
a
pretty
cool
approach
to
test
with
again
efficiency
and
joy,
and
also
just
to
show
you
this
whole
approach
with
now
a
little
bit
this
different
test
scope.
So
now
we
have
just
the
system
test
against
either
local
development
environment
or
against
the
kubernetes
cluster,
and
I
showed
you
how
to
use.
C
So
now
I'm
gonna
show
you
some
tests
that
you're
probably
a
little
bit
more
familiar
with,
so
these
tests
actually
do
reside
now
in
my
project,
my
coffee
shop
project-
and
I
have
something
like
well
a
test
that,
for
example,
would
like
to
you
know
like
test
my
coffee
shop,
for
example.
So
I
have
a
class
that
is
here
a
cdi
class
and
then
I
can
see
whether
my
class
is
doing
all
that
stuff
correctly.
C
So
that
is
the
question
now.
Does
it
make
sense
to
write?
You
know
a
unit
test
like
this,
so
I
probably
have
seen
stuff.
I
use
typically
tests
without
any
other
test
runner
or
you
know
like
any
test
extension,
but
I
say
you
know
new,
so
I
can
invoke
classes
that
are
usually
enterprise
beans
on
a
test.
It
doesn't
matter
right.
It
just
ignores
these
annotations
and
then
I
can
set
you
know
some
dependencies
via
reflection
or
directly
and
use
mokita
and
things
like
that.
C
But
if
you
look
at
the
test,
is
this
really
good
idea?
Well,
not
necessarily
why?
Because,
while
it
depends
what
my
class
here
does,
if
it
doesn't
have
a
lot
of
proper
logic
or
you
know
if
it
has
not
the
correct
cohesion
to
be
tested
in
this
way,
if
it
just
is
more
like
delegation,
then
it
probably
doesn't
really
make
sense
to
to
write
an
a
unit
test
for
this.
C
What
I
would
like
to
have,
instead,
is
what
I
call
sometimes
component
tests
or
use
case
tests,
which
are
code
level
tests
that
test
the
correct
execution
of
my
code
path,
but
only
you
know
locally
as
a
code
level
test,
but
with
multiple
dependencies
or
multiple
classes
involved,
so
not
only
the
coffee
shop
but,
for
example,
the
coffee
shop,
plus
this
order,
processor
and
all
of
the
classes
that
are
part
of
this.
You
know
execution
of
my
use
case
like
creating
a
coffee
order.
C
So
for
that
what
I
have
actually
and
if
you
think
about
it,
I
could
use
some
fancy
test
framework
to
set
up
all
of
these
things
or,
for
example,
to
run
my
quark
is
now
in
an
embedded
mode.
But
then
again
I
have
this
life
cycle.
I
would
say
issue
that
I
have
to
wait
for
the
application
each
and
every
time,
even
if
it's
just
a
bunch
of
seconds,
but
it's
just
slower
than
running
everything,
just
in
plain
junit,
which
is
much
faster.
C
So
what
I
do
and
that's
some
approach
here
in
my
main
scope,
production
scope-
I
have
a
coffee,
shop
class
and
then
another
class,
and
now
I
do
a
td
a
test
dual,
as
in
the
test
code
that
I
use
within
a
use
case
test
that
sets
up
already
some.
You
know
test
related
wiring
like
some
marks,
and
you
know
verification
and
all
of
that.
So
what
I
have.
I
have
my
use
case
test
that
has
a
coffee
shop
test,
dual
which
extends.
I
know
this
looks
a
little
bit
weird.
C
C
So
I
can
do
the
lower
level
verification
logic
here
that
everything
still
you
know
is
very
readable
and
yet
runs
fast,
because
it's
just
a
plain
unit
test.
So
I
can
run
you
know
this
classes
here
and
once
my
ide
wakes
up,
this
runs
really
really
fast
and
plain
junit.
You
know
you
can
run
hundreds
of
tests
in
no
time.
So
this
is
just
an
approach
to
make
the
yeah
this
use
case
or
component
tests
a
little
bit
more.
You
know
a
little
bit
more
worthwhile,
a
little
bit
more
efficient.
C
So
with
that
being
said,
I
would
like
to
just
you
know
cover
some
key
takeaways
from
this,
and
probably
one
of
the
most
important
thing
is
that
test
code
quality
matters
a
lot,
so
it's
not
forbidden
to
include
some
tesco
quality
in
your
test
scope,
it's
actually
a
good
idea
and,
most
importantly,
abstraction
and
separations
of
concerns.
You
know
to
use
delegation
and
all
actually
all
of
these
things
that
we
do
all
the
time
in
production
code,
but
also
in
our
test
code
or
test
projects.
C
That's
a
good
idea,
so
create
reusable
test
components
and
especially
care
about
this
fast
feedback
and
turn
around
cycles,
and
we
get
this
by
separating
the
life
cycles.
So
I'm
really
quite
stringent
of
just
using
a
you
know:
easy
lower
level
test
technology
just
like
plane,
junit
that
runs
super
fast
and
I
rather
set
up
my
environment
locally.
Once
my
system
test
environment
to
say
you
know,
docker
run
three
times
for
me.
C
You
know
local
kubernetes,
cluster,
local,
openshift,
cluster
or
whatever,
but
I
I
would
say
it
makes
sense
to
be
a
little
bit
more
pragmatic
on
that
side
and
then
separate
these
life
cycles,
and
always
I
claim
the
proper
test
code
quality
and
these
approaches
are
much
more
important
than
which
test
frameworks
you
use.
So
this
is
why
I
showed
you
just
plain
junit
if
you
would
like
to
use
whatever
spock
testing
or
something
like
that.
If
it's
add
some
benefit
for
you
sure,
that's
that's
nice,
then
do
it.
C
I
claim
for
the
more
complex
your
project
becomes
actually
the
more
important
it
is
to
cover
this
tesco
quality
issue.
First,
so
that's
that's
more
crucial
from
from
my
experience
at
least
the
more
in
real
world
projects,
and
with
that
we
can
really
test.
You
know
with
efficiency
and
also
with
joy.
It's
really
fun
to
have
a
project,
that's
well
tested
with
maintainable
tests,
and
then
we
have
a
much
better
quality
and
I
think
that's
that's
a
good
thing.
C
So
then
we're
pretty
much
at
the
end
of
the
talk
thanks
a
lot
for
your
attention.
If
you
follow
the
first
link,
you
can
get
access
to
all
of
these
resources.
You
can
try
them
out
yourself.
It
also
tells
you
how
to
set
up.
You
know
these
kubernetes
environments
and
all
of
this,
and
you
can
check
out
my
book
on
modern
java
e
or
now
it
would
be
jakarta
e.
That
covers
a
lot
of
these
topics
here
as
well,
and
some
some
more
links
now
ivar
yeah.
C
Yes,
actually,
the
the
more
you
separate
these
life
cycles,
like
I
told
you
the
easier
it
is
to
integrate.
Why?
Because,
then,
you
can
very
easily
reconfigure
it
like,
with
these
system
system
variables
that
I
did
so
for
this.
What
I
had
here
with
the
maven
verify
this
would
be
something
that
you
would
run
in
your
ci
cd
pipeline.
Why?
Because
then
it
runs
basically
like
headless.
It
connects
to
some
other
environment
where,
in
you
know,
in
the
first
place
you
deploy
to
some
environment,
and
then
you
verify
against
this
environment.