►
Description
In this episode of Kongcast, @ViktorGamov , a principal developer advocate at @KongInc joined by @shelajev , Head of DevRel at @atomicjar to talk about testing complex infrastructures (data systems, microservices, messaging systems) using containers, and specifically open source library called Testcontainers.
00:00 - cold opening
00:13 - welcome to Kongcast, intros
19:02 - demo
33:25 - outro
▬▬▬▬▬▬ ABOUT KONGCAST ▬▬▬▬▬▬
Hosted by Viktor Gamov and Kaitlyn Barnard, we interview software developers and technology leaders at the top of their game every other week. We’ll also give you the tools, tactics and strategies you need to take your distributed architectures to the next level. Kongcast goes beyond the buzzwords and dissects real-life applications and success stories so that you can tackle your biggest connectivity challenges.
▬▬▬▬▬▬ KONG COMMUNITY ▬▬▬▬▬▬
⭐ https://github.com/Kong/kong
🐦 https://twitter.com/thekonginc
🌎 https://konghq.com/community/
🍻 https://www.meetup.com/pro/kong
❓ ️https://discuss.konghq.com/
💯 https://konghq.com/kong-champions/
A
B
Hello
and
welcome
to
this
episode
of
Comcast,
my
name
is
Victor
garof
and
I'm
a
developer
with
get
here
with
Kong
we're
recording
this
episode
in
Atlanta
in
April
of
2022
at
the
conference
called
devanexes
and
today.
I'm
super
excited
here
to
have
my
dear
friend
Alexia,
live
from
Atomic
jar
to
talk
to
us
something
about
about
Atomic
jar
and.
A
A
So
Atomic
drawer
is
a
small
startup
that
was
created
by
the
maintainers
of
the
test.
Interns,
Java,
Library
and
test
containers
in
general.
That's
kind
of
Jama
is
a
Java
implementation
of
the
test
containers
and
there
are
others
for
other
languages.
What
the
library
does
it's
a?
It
provides
you
with
a
neat
API
that
integrates
on
one
hand
with
Docker
yep,
and
it
allows
you
to
run
well
anything
that
runs
in
Docker.
A
It
runs
programmatically
with
a
flexible
API
and
the
main
use
case
that
we
are
currently
seeing
for
that
is
to
use
that
in
the
integration
test
of
your
applications.
So
if
you,
for
example,
need
a
Kafka
service
and
your
application
needs
a
Kafka
to
to
run,
you
can
for
the
integration
test,
you
don't
need
to
set
up
Kafka
externally,
but
you
just
need
to
provide
an
access
to
Docker,
runtime
and
test
containers
will
create
a
Kafka
for
you
configure
your
application.
A
On
the
other
end,
it
will
integrate
with
your
application
framework
or
provided
with
the
configuration,
how
to
reach
that
Kafka
or
database,
so
mongodb
or
k3s
container,
or
anything
that
runs
in
the
docker
and
then
then,
with
the
API.
To
like
create
your
data
schema
or
try
the
proper
configuration
or
the
bridge
several
several
containers
together
using
the
same
Docker
Network.
So
it's
a
very,
very
flexible
solution
and
it
allows
you
to
to
describe
the
environment
necessary
for
an
integration
test
from
the
code
itself.
A
A
B
Actually,
a
few
few
questions
here
so,
first
of
all,
for
many
people,
the
docker
looks
like
a
black
box,
like
you
run
the
containers
and
do
stuff
like
a
Docker
run
and
for
many
people
they
don't
really
care
what
happens
like
behind
the
scenes
right
and
not
many
people
surprisingly.
They
know
that
it's
actually
door
care
is
sort
of
like
a
client,
server
type
of
architecture
when
you're
running
Docker,
you're,
actually
running
Docker
client,
which
interacts
with
your
Docker
demon.
That
runs
this
right.
Yes,.
A
Yes,
so
there
is
a
runtime
that
is
responsible
for
running
your
containers
and
managing
them,
and
obviously,
when
you
run
your
like
Docker
pool,
commands
or
Docker
run
something
it's
a
it's.
A
common
Line
application
that
will
talk
to
the
docker
demon
using
you
can
find
a
configuration
where
your
demon
is
running.
B
And
only
the
important
point
to
understand
for
many
of
our
listeners
is
here
that,
like
when
you're
using
like
this
client,
it's
only
like
limited
things
that
you
can
do
there
limited
to
what
you
can
do
by
developers
of
this
command
line
tool.
Once
you
have
access
to
this
API
either
through
libraries
like
test
containers
or
through
the
docker
API
wrapper
libraries
that
available
for
different
language
languages.
You
can
do
like
a
lot
of
a
lot
of
things.
You
know
for
customizing
all
this
kind
of
stuff
right.
A
A
It's
a
very
interesting
question
and
there
are
no
easy
answer
to
that,
but
in
short,
yes,
so
how
test
containers
works?
It
actually
wraps
the
project
called
Docker
Java,
which
will
also
our
Engineers
maintain,
or
at
least
the
partially
support
and
maintain
which
wraps
the
docker
API
provided
by
the
by
Docker
into
a
Java
code.
So
now
you
can
control
your
your
Docker
runtime
from
your
Java
code,
so
you
can
write
whatever
commands
you
want
and
then
you
can.
You
can
run
them
from
a
script
for
for
to
give
commands
like.
B
A
Can
create
scripts
that
will
that
will
set
up
your
environment
as
you
want,
and
you
can
run
them
either
via,
like
you
can
run
it
as
a
part
of
your
application.
You
can
have
like
a
standalone
little
script,
say,
for
example,
using
test
Contours,
node
yeah,
and
you
can
set
up
and
say
like,
oh
because
no,
it
is
very
simple
because
you
don't
need
to
compile
anything.
You
just
write
the
Javascript
file
and
you
say,
like
oh
give
me
give
me
a
k3s
container.
B
B
B
A
A
B
B
A
They
are,
they
are
all
they're
all
working
there.
There
are
people
in
projects
using
all
of
them.
As
far
as
we
know,
they
are
indeed
at
the
different
level
of
support
and
feature
completeness
compared
to
the
docker
Java,
but
most
of
the
things
are
supposed
to
work
and
we
would
love
atomic
Java
would
love
to
provide
more
help
to
the
maintainers
of
those
different
language
implementations
and
as
the
company
grows,
hopefully
we're
going
to
be
able
to
get
more
hands
to
help
with
the
with
the
different
implementations.
A
Even
currently
we
are
trying
to.
We
are
trying
to
make
them
all
on
par,
but
you
I
would
expect
that
they're
all
usable
and
I
would
expect
that
there
is
a
a
lively
and
like
a
live
Community
for
for
all
of
them
yeah.
So
there
are
a
number
of
things
like
one
interesting
thing.
There
is,
and
just
as
an
example,
most
of
the
for
integration
tests
right
if
we
are
not
talking
about
running
your
containers
once
and
leaving
them
run
forever,
because
that's
not
what
you
want
for
integration
tests.
A
You
want
to
control
the
whole
life
cycle,
including
the
proper
cleanup
of
the
resulting
artifacts
like
so
when
your
test
run
is
done.
You
want
to
stop
the
containers
yeah.
You
want
to
clean
up
the
images
exactly
you
want
to
do
that,
not
just
when
your
test
passed
completely
normally
right,
but
also,
if
something
abruptly
fails
or
the
test
fail
or
everything
is
in
error
and
everything
just
crashes.
You
still
want
to
do
the
cleanup,
because
otherwise,
well
as
a
developer,
you.
B
B
A
Well,
with
the
cloud
cloud
offers
different
trade-offs
right,
so
there's
a
limited
scale,
but
there
are
yes
the
subscription
like
the
well,
it's
a
paid
Service,
it's
a
different
set
so
like.
If
you
have
the
fully
isolated
environments-
and
you
clean
up,
is
sort
of
on
the
cloud
level,
so
you
just
get
a
VM
and
then
you
destroy
the
VM.
Maybe
you
don't
need
to
you
like
clean
up
the
containers
within
the
VM,
because
you're
gonna
destroy
the
whole
the
whole
machine
all
together,
but
in
general
you
want
to
have
a
cleanup.
A
A
In
the
world
of
it's
sort
of
like
a
sidecarish
thing,
and
then
it
will
control
the
life
cycle
of
the
containers.
So
even
if
you
test
or
you
process
the
original
process,
right
kind
of
finishes,
then
it
can
see
that
and
then
it
will
clean
up
the
resources
from
the
docker
environment
itself
and
then
it
will
stop
itself.
A
So
that's
a
it's
a
very
nice
nice
environment
and,
for
example,
most
of
the
implementations
of
test
containers,
use
that
and
and
then
there's
some
because
we
started
this
question
with
how
different
the
different
implementations
are
yeah.
So
we
are
trying
and
the
implementations
are
trying
to
be
language,
idiomatic
yeah.
So,
for
example,
Java
is
very
big
on
on
abstractions
and
reusing
different
abstractions.
A
B
It's
a
similar,
like
I,
have
like
a
similar
situation
when
I
was
writing
my
the
Quan
Quant
module
where
I
was
like.
If
you
follow
this
channel
full
of
this
YouTube
channel,
you
know
that
I'm
running
this
coin,
Builders
live
stream,
where
I'm
breaking
down
like
different
Technologies.
One
of
the
things
like
I
did
a
few
episodes
on
task
containers
and
how
you
can
use
this
awesome
technology.
That
Alex
is
describing
right
now
with
technology
that
we
we
built.
B
A
Like
a
script
style
like
all
jvm
languages,
for
example,
work
the
same
but
the
best
thing.
Because
of
that,
so
your
end
users,
the
the
developers
who
would
run
and
would
like
to
use
Concord
test
their
applications
with
with
con
as
a
dependency.
They
don't
need
to
actually
have
a
perfect
under
standing.
What
Kong
needs
to
run
which
ports
it
needs.
A
Yes,
yes,
so
like
to
expose
admin
API,
you
can
offer
like
a
like
a
utility
method
on
the
say,
con
container,
like
object,
yeah,
and
then
anyone
who
uses
that
will
just
like
type
the
dot
and
then
look
at
the
what
the
ID
provides
them
and
it
will
be.
This
is
how
I
enable
admin
API
very
nice.
So
as
a
as
a
as
somebody
who,
on
the
vendor
size
side
of
the
of
the
technology,
you
can
embed
the
best
practices
of
how
to
test
against
Kong
in
the
module
right
and.
A
A
Compose,
for
example,
yes,
so
that's!
This
is
a
little
bit,
so
the
goal
length
and
I'm,
not
a
very
expert
in
go
right.
My
exposure
to
go
is
a
little
bit
limited,
but
what's
what's
the
the
the
sort
of
a
philosophy
of
go?
Is
that
a
little
bit
of
coping
is
better
than
a
little
bit
of
abstraction
right.
A
System,
so
so
for
for
the
test,
containers
go
as
far
as
I
know.
There
are
no
concept
of.
There
are
some
discussions
about
counting
trees
modules
into
into
the
goal
yeah,
but
currently
it
operates
more
on
the
like
samples
description.
So
if
you,
if
you
say
I,
want
to
run
my
elasticsearch
container,
so
you
can
see
the
in
the
documentation
or
in
the
tests
that
are
a
part
of
the
test.
Continuous
core
project
you
can
see
like.
A
A
They
will
only
be
initialized
and
kind
of
provide
an
impact
when
you
actually
uses
them
yeah,
but
in
go.
You
need
to
build
a
library,
so
if
you
have
like
a
hundred
different
module
implementations
that
will
that
will
blow
up
the
size
considerably.
So
this
is
maybe
not
the
ideal
situation
and
there
are
some
discussions
about
telling
to
introduce
the
modules
for
the
test.
Containers
go,
but
it's
more
for
the
go
Community
using
test
containers
to
kind
of
figure
that
out
and
from
our
site
we
would.
B
One
of
the
things
that
we
do
at
the
Chromecast
is
we
asking
our
guests
to
demo
something,
but
they
it
is
not
going
to
be
like
a
possible
to
do
in
a
conference
setting
but
Oleg.
We
would
with
the
magic
of
editing
we
will
switch
to
some
of
the
demos
instead
of
Oleg
would
be.
You
know
telling
us
about
all
this
technology.
B
He
will
show
us
about
this
technology
and
how
we
can
start
this
I
like
what
you're
going
to
be
showing
to
our
listeners
as
a
as
after
after
this,
the
show
I
heard,
there's
interesting
thing
that
I
personally
interesting,
because
I'm
recently
started
getting
a
the
Mac
computer.
Yes,
so
with
the
Mac
computer,
so
I
I
noticed
that
not
all
images
apparently
would
be
translated.
As
is
you
know,
Quant
works
fine
in
the
compatibility
mode
and
we're
working
right
now
actively
working
on
support
like
arm
native
images,
but
things
like
Kafka.
A
B
A
So,
like
you
actually
have
like
two
yeah
and
it's
not
something
that
is
like.
You
need
to
understand
exactly
why
things
are
like
not
working
to
fix
those.
So
it's
not
like
very
easy
and
I
know.
Other
Technologies
also
have
some
struggles.
Sometimes
it
works.
Sometimes
it
doesn't
work.
I've
heard
George
long
in
the
from
the
spring
spring
Community.
He.
A
Yes,
he
told
me
that
he
was
some
troubles
with
running
mongodb
on
his
own,
his
arm
Mac,
but
one
thing
that
we're
currently
doing
at
Atomic
jar
yeah
as
a
product
we're
creating
test
containers
Cloud,
which
is
not
yet
available
publicly
for
anyone.
But
what
it
is.
It's
a
cloud
version
of
it's
a
like
a
software
as
a
service
version
of
your
Docker
runtime.
B
A
So
when
you
run
your
when
you're
running
a
test
with
test
containers,
your
tests
run
locally
on
your
machine,
but
the
docker
containers
are
running
in
the
cloud
environment.
So
you
are
not
using
your
local
Docker,
so
you're
not
limited
to
by
your
architecture
or
by
your
resources.
But
you
get
like
a
very
seamless
integration
with
the
cloud
VM
and
then
your
your
Docker
commands
are
proxied
there
by
a
small,
like
user
space.
Application
installed
your
machine
or
in
your
CI
an
agent.
B
A
A
B
A
But
in
a
nutshell,
what
we're
gonna
do
is
we're
gonna,
install
a
very
small
application
and
we're
gonna
run
it
and
then
we're
going
to
run
the
test.
It
will
proxy
all
the
docker
commands
to
the
cloud
environment
and
it's
it's.
There
are
a
number
of
cool
things
that
we
do
there.
It's
an
age
deployment,
so
the
the
cluster
where
you
run
your
Docker
containers
is
as
close
to
you
as
possible
to
limit
the
latency,
but
in
general
it
provides
you,
the
the
independence
from
your
architecture
on
your
machine.
B
A
Let's
look
at
how
test
containers
libraries
can
help
you
create
better
integration
tests
and
connect
your
application
to
Source
dependencies
like
databases,
message,
Brokers
and
everything
else
run
in
Docker
containers
in
your
environment,
excellent,
excellent,
excellent
tool
and
let's
take
a
look
at
it
in
practice.
So
here
we
have
a
normal
spring
application.
It's
a
very
simple:
it
just
talks
about
the
very
basic
model
of
a
rating
for
the
talk
and
it
has
a
value,
but
it
has
a
very
interesting
third-party
dependencies
service
dependencies.
A
We
have
a
rating
controller
that
talks
to
Kafka
through
Kafka
template.
So
when
we
submit
the
ratings
to
the
application,
they
will
go
through
Kafka
and
then
we
have
a
ratings
repository
which
stored
ratings
in
the
redis
database
and
then
the
talks
repository
for
the
actual
talks
are
stored
and
is
using
the
jdbc.
So
it
needs
the
database.
There
are
three
components
there
and
we
need
all
of
them
for
the
tests.
A
We
can
run
this
application
if
the
environment
is
proper
and
we
even
have
some
tests
here
which
we
can
run.
We
can
try
running
them,
but
they
will
all
fail
because
the
environment
for
this
application
is
not
up
so
I.
Don't
have
my
database
running
I,
don't
have
my
redis
I,
don't
have
Kafka,
and
my
tests
will
all
fail
one
by
one,
because
my
application
kind
of
function
so
let's
create
that
environment
specifically
for
the
integration
tasks
using
test
containers.
The
first
thing
that
we
need
to
do.
A
We
need
to
add
a
bunch
of
dependencies
on
the
libraries.
So
we
do
that
using
this
is
a
maven
project,
so
we
just
pull
the
maven
Central
dependencies
by
the
org
test,
containers
group
ID
and
we're
going
to
pull
a
bunch
of
modules,
for
example,
we're
going
to
pull
the
the
J
unit,
junit
5
integration
and
we're
going
to
have
a
bunch
of
modules
for
elastics
search,
mongodb,
k3s
cluster,
past
grass,
Kafka
all
those
Technologies,
the
integration
between
test
containers
and
those
comes
as
different
application.
Libraries
that
you
can
pull
independently.
A
A
The
main
thing
that
we
want
to
concern
ourselves
is:
is
the
generic
container?
Let's
say
we're
going
to
do
the
redis
first,
what
we
can
do,
we
can
say
we
want
a
new
generic
container
and
it
it
wants
us
to
provide
the
docker
image
name
for
for
this
to
work.
So
what
I
can
do?
Just
I
can
say,
write
this
and
then,
whatever
tax
tags
we're
looking
at
radius
6.
What
do
we
have?
A
Six
Alpine
probably
is
good,
and
now
the
good
thing
is
the
generic
container
abstracts
away
anything
that
we
can
run
in
docker
and,
of
course
it
exposes
all
the
configuration
that
we
want
to
do
on
a
Docker
container
that
we
want
to
so.
For
example,
we
can
expose
some
internal
ports
to
our
host
machine
we
can
specify
which
command
we
want
to
run.
If
we
want
to
override
that,
we
can
specify
which
files
we
want
to
copy
from
and
into
container
they
create
the
environment.
A
All
all
the
things
that
you
can
do
with
with
the
docker
container
you
can
do
here
without
leaving
the
comfort
of
your
ID
without
doing
yaml
or
configuring
it
anyhow.
Besides,
using
your
favorite
programming
language
note
that
test
contains
libraries
are
exist
in
different
programming
languages,
so
we
have
a
version
for
go
for
node,
so
you
can
do
JavaScript
typescript,
but
there
is
Task
and
there's
python
testcontinux.net.
A
So
this
gives
you
a
very,
very
nice
fluent
API
for
configuring,
your
containers
so
for
the
radius
I
know
we
that
we
run
radius
through
networks,
so
we
need
to
expose
the
container
port
and
the
radio
sports
that
binds
the
port
where
radius
binds
on
is
six
three
seven
nine.
This
is
a
little
bit
of
internal
knowledge
for
the
configuration
that
I
need
to
use
if
I
want
to
use
the
the
generic
container
with
any
particular
any
like
arbitrary
Docker
image.
A
Naturally,
this
configuration
can
abstract
it
away.
If
I
would
like
to
create
a
library
for
redis,
I
would
create
a
like
an
abstraction
called
like
a
radius
container
or
something
and
I
will
hide
this
implementation
detail
for
the
exposed
port
in
the
implementation
details.
Now
we
will
have
the
radius
now.
We
have
need
to
do
two
things
so
one
what
we
need
to
do.
We
need
to
somehow
start
this
right,
I
think
so
redis
we
have
the
lifecycle,
control
methods,
for
example,
start
or
stop,
and
we
can
do
that
manually.
A
We
can
bind
this
through
annotations
to
the
junit
test
life
cycles.
So,
for
example,
we
can
do
the
test
container
sanitation
on
the
class
and
then
the
container
annotation
container
annotation
on
the
instance
field,
and
then
this
container
will
be
recreated
and
restarted
for
every
individual
test
method.
We're
doing
here
in
the
abstract
class.
A
But
for
here
for
every
test
we
would
have
one
new
radius
container
created,
started,
stopped
cleaned
up
automatically
played
by
test
containers
and
for
the
next
next
test
we
will
have
the
new
one.
A
static
field
will
make
it
recreated
only
once
per
test
class,
but
there
is
totally
an
integration
where
you
can
tie
the
life
cycle
of
the
containers
to
your
genuine
tests.
A
We're
not
going
to
do
that.
We're
going
to
use
this
spring
specific
configuration
setup
here,
because
I
want
to
show
you
another
thing.
One
thing
is
to
integrate
with
Docker
and
be
able
to
run
containers
and
manipulate
the
containers
as
you
want.
The
other
thing
is
that
for
your
application
tests,
what
you
want
to
have
you
want
to
have
an
integration
with
the
framework
you
want
somehow
to
configure
your
application
to
use
those
service
dependencies
in
the
containers
that
you
just
created,
rather
than
rather
than
some
hard-coded
property
strings
for
string
for
spring
I'm.
A
So
after
this
we
just
need
to
start
the
thing
so
we're
going
to
stay,
startable
start
radius
and
join
this
and
then,
when
the
radius
will
start
we're
going
to
configure
our
application
as
simple
as
that.
Now,
if
we
want
to
do
say,
Kafka,
it's
even
easier.
Kafka
container
is
pretty
initialized
and
abstracted
Away
into
the
Kafka
container
class,
so
somebody
who
knows
how
to
run
Kafka
thought
about
this
and
confluent
Inc
CPE
Kafka
I,
wonder
what
versions
We
have
here
available.
A
Docker
image
name
parse:
we
can
use
the
additional
abstraction
and
then
I'm
sure
content
assist,
will
work
here.
Yeah
we're
gonna,
do
this
right,
so
we're
going
to
parse
this
Docker
image,
name
full
image
name
and
we're
going
to
feed
it
into
the
Kafka
container
and
Kafka
container
has
the
whole
bunch
of
configuration
for
Kafka
specific
deployments
how
to
run
Kafka
in
a
Docker
environment
already
abstracted
away
in
the
library.
So
you
don't
have
to
think
about
that.
You
don't
need
to
know
how
to
run
Kafka.
A
You
don't
even
need
to
know
what
exactly
needs
to
be
configured
on
the
application
side.
You
can
just
say
start
my
Kafka
and
then
you
you
don't
need
to
know
how
to
connect
your
application
to
Kafka
so
for
spring.
That
would
be
Kafka
boots,
strap
servers,
and
then
we
just
do
right.
We
do
Kafka
get
bootstrap
servers.
A
How
exactly
that
URL
is
created,
we
don't
know,
but
the
Kafka
container
abstraction
knows
for
us
and
you
can
do
all
kinds
of
things
right.
So
you
can
do
new
postgres
container
if
you
want
and
provide
the
postgres
image
or
you
can
do
new
k3s
container.
If
you
want
to
work
with
the
kubernetes
cluster
or
you
can
do
new
elasticsearch
container,
all
those
libraries
come
from
the
dependencies
from
the
modules
in
the
task
containers
ecosystem
and
you
can
use
them
freely.
A
So
we
also
need
a
database
for
our
application
and
I
could
have
created
the
postgres
here.
Just
like
I
wanted,
postgres
container
and
then
postgres,
but
I
will
show
you
the
integration
with
the
jdbc
databases,
so
databases
go
through
jdbc
and
test
containers
exposes
a
special
jdbc
driver
that
will
give
us
a
chance
to
just
spin
up
the
containers
automatically
without
any
configuration
from
our
environment.
So
what
I'm
going
to
do?
A
I'm
gonna
say
spring
data
source
data
source
URL
and
we
need
the
jdbc
Euro,
and
this
is
normally
jdbc
and
then
we're
going
to
instrument
it
with
the
testing
hairs
and
instead
of
providing
URL,
we
will
actually
see
what
Docker
image
we're
going
to
run.
So
it's
post
postgres.
This
is
the
hardest
postgres.
We
say:
I
want
to
Alpine
version
for
that,
and
then
the
database
name
and
anything
here
it
doesn't
matter
at
all.
A
So
what
all
we
need
to
have
is
just
the
container
name
now,
when
the
application,
the
application
will
start
for
the
tests
spring,
will
request
the
jdbc
driver
to
connect
to
that
URL
and
the
test
containers.
That
arrival
will
create
the
docker
container
with
the
postgres
for
us
and
configure
spring
application.
So
we
don't
even
have
to
manually,
create
this
right.
Let's
try
to
run
our
tests
and
see
the
output
for
those.
A
A
It
is
currently
downloading
Kafka,
because
environment
in
my
in
my
environment,
there
is
no
Kafka
image
pre-pooled,
but
it's
very
very
fast,
and
that
image
will
be
cached
locally.
So
on
the
next
run,
I
don't
need
to
pull
the
images
again,
obviously
because
they
are
already
in
the
local
registry.
In
my
machine
available
and
after
that,
we
can
run
the
tests.
A
You
can
see
here
that
the
database
started
on
the
random
high-level
port,
which
unfortunately
disappears
from
us,
and
you
can
see
our
tests
passing
the
test
suit
here
is
is
not
the
particularly
important,
but
it
does
talk
through
the
database
and
it
does
sends
requests
to
the
weather.
Application
is
healthy
and
actually
uses
the
HTTP
queries
to
post
the
ratings,
so
it
verifies
the
application
Behavior.
A
But
what
I
wanted
to
show
you
that
it's
with
test
containers,
it's
very,
very
easy
to
create
the
environment,
even
the
most
complex
environment,
for
your
integration
tests,
and
if
you
want
even
more
complex,
you
can
go
there.
So,
for
example,
you
can
create
the
network
from
test
containers
and
then
put
different
containers
on
the
network.
You
can
build
the
containers
from
a
Docker
file.
You
can
work
with
them.
A
Naturally,
in
the
application
here
you
can
also
run
the
scenarios
which
we
want,
for
example,
copy
file
from
container
if
you
want
after
the
tests
has
been
running.
So
if
you
want
any
debug
files
or
you
can
exec
in
container,
if
you
want
to
execute
a
random
command
in
container,
it
gives
you
the
full
flexibility
to
do
anything
you
want
with
those
containers,
and
it
gives
you
the
excellent
API
for
your
integration
tests.
That
was
a
short
demo,
I
hope.
I
hope.
It
illustrates
why
test
containers
such
an
exciting
and
excellent
project.
B
Okay,
Oleg.
Thank
you.
So
much
for
being
the
part
of
Chromecast,
you
learned
a
little
bit
about
the
School
Technology.
Give
it
give
it
a
shot,
give
it
a
try.
Maybe
it
will
solve
some
of
the
some
of
the
things
go
check
the
episodes
of
Kong
Builders
when
I
show
how
we
can
use
quality
with
this
and
make
sure
again,
if
you
listen
on
us
using
audio,
get
back
to
our
YouTube
channel
watch
Olex
demo,
and
with
this
all
like.
Thank
you
so
much
for
being
a
part
of
aquancast.