►
From YouTube: Webinar: The KUbernetes Test TooL (kuttl)
Description
The KUbernetes Test TooL (kuttl) is a new tool from the creators of KUDO for declarative testing of Kubernetes and Cloud Native software. kuttl empowers developers and end users to test operators, Helm charts, Kubernetes distributions, and Kubernetes itself. In this webinar, we will introduce kuttl, walk through examples, and show how D2iQ, Red Hat, and the Kubernetes community at large are using kuttl to power conformance for anything related to Kubernetes.
Presenter:
Gerred Dillon, Principal Engineer @D2iQ
Ken Sipe, Distributed Application Engineer @D2iQ
A
A
A
Are
we
I
would
like
to
think
and
welcome
our
presenters
today,
girl
Dillon,
who
is
a
principal
engineer
at
DTU
IQ
and
can
Sipe,
who
is
a
distributed
application
engineer,
DT
IQ
before
we
set
some
housekeeping
items
during
the
webinar,
you
know
not
allowed
to
talk
to
the
attendees,
though
there
is
a
Q&A
box
at
the
bottom
of
your
screen.
Please
feel
free
to
drop
any
questions
and
they
will
be
answered
during
the
presentation
or
at
the
end,
in
the
Q&A
session.
A
Also
keep
in
mind
that
that's
official
since
EF
webinar
as
such
is
a
subjective
since,
if
Code
of
Conduct,
please
do
not
add
anything
to
the
charge.
The
questions
we've
are
letting
the
Code
of
Conduct
basically
be
respectful
for
everyone
and
follow
the
principles
and
present
this.
With
that
I'll
hand
over
to
Gareth
and
Ken
to
kick
off
today's
presentation
go
ahead,
guys.
B
B
My
name
is
Jared
doing
like
I
said:
I'm
a
member
of
technical
staff
at
D
2iq,
where
I
work
heavily
on
upstream
kubernetes
the
cure,
a
universal
declarative
operator,
which
we've
done
another
scene
in
CF
webinar,
as
well
as
cuddle
and
in
other
tooling,
related
to
the
kubernetes
workload
ecosystem.
On
top
of
that
I'm,
a
developer
working
on
closure
and
go
and
there's
my
Twitter
and
stuff
and
then
Ken
site
I'll
turn
it
over
to
you
to
to
introduce
yourself
yeah.
C
B
Sounds
great
so
so
what
is
cuddle
cuddle
breaks
out
to
the
kubernetes
test
tool
and
it
has
its
origins
in
the
kubernetes
universal
declarative
operator,
and-
and
this
is
very
important,
because
what
Kudo
is
it's
a
tool
for
for
orchestrating
together,
rubriz
workloads,
building
operators
using
an
entirely
declared
language
and
done
done
entirely
with
CRTs
and
in
order
to
we
needed
a
way
to
test
these
up
in
production?
So
we
wrote
a
declarative
framework
for
testing
called
kudo
tests
and
and
quickly.
B
We
realized
the
utility
of
that
and
decided
to
break
it
out
into
its
own
tool
called
cuddle,
and
that
name
came
about
partially
cuz.
We
wanted
to
be
able
to
say
cute
cuddle
cuddle
there
we
go
I've
made
the
joke,
but
but
really
because
we
saw
utility
beyond
just
operators,
we'll
talk
about
that
a
little
bit
more
in
a
bit
now
we
say
this
is
a
test
tool.
If
you
go
to
the
next
slide.
What
does
that
exactly
mean?
B
So
if
you
think
about
all
your
levels
of
testing
you
unit
tests
that
operate
at
a
you
know
a
single,
isolated
functionality,
test
of
a
single
unit
like
a
function,
you
have
integration
which
starts
to
look
at
a
larger
system
or
around
a
certain
system
as
well
as
end
end
testing,
which
verifies
that
the
entire
system
in
a
live
environment
behaves
as
expected.
So
cuddle
is
a
test
tool
really
for
your
integration
and
end
testing,
and
that
is
because
it
runs
on
actually
live
clusters.
B
So
our
goal
was
to
end
up
with
being
able
to
write
portable
and
an
integration
and
conformance
tests
for
kubernetes,
without
needing
to
write
any
code
without
having
to
jump
in
to
go
tests
without
having
to
write
out
a
separate
your
bash
testing
framework
that
does
a
whole
bunch
of
applies
and
checks
and
sorts
on
them.
We
really
wanted
to
feel
native
to
kubernetes,
and
that
was
very
important
and
you'll
see
that
in
the
API
decisions
we
we
we
made
with
that
next
next
slide.
So
how
do
you
get
started?
B
C
B
What
will
you
know
well
we'll
make
sure
we'll
check
on
that?
That
should
be
an
open
issue,
but
but
really
like,
like
you,
can
either
do
that
you
can
get
it
via
crew,
which
is
the
the
coop
CTL
plugin
package
manager,
or
you
could
get
it
from
a
releases
page
directly
and
then,
if
you
want
to
integrate
with
it
as
an
API,
you
can
just
go
get
it.
C
Be
joking
too
much
probably,
but
if
there's
any
time
you
know
anybody
work
on
kubernetes
and
making
deployments
and
having
a
fast
rate
of
releases
of
kubernetes
itself
and
trying
to
keep
up
with
it.
It
can
cause
some
some
blood
pressure
challenges.
So
if
you
look
up
cuddling,
you
might
find
that
it's
scientifically
proven
to
have
a
cocktail
of
hormones
that
provide
lower
blood
pressure
and
heart
rate,
and
so
I
made
up
this
fake
Wikipedia
entry.
For
what
cuddle
will
help
you
do
with
testing
release
platform
I.
C
B
B
Yes,
yon
would
Jo
Jane.
Would
you
mind
asking
in
the
Q&A
section
and
then
I'll
make
sure
that
that
gets
answered
just
so
not
everyone
sees
no,
not
everyone.
Seeing
the
chat.
I
just
happen
to
have
it
open,
but
I
just
wanted
to
give
a
shout
out
to
you
know
the
current
kudo
team
and
contributors.
You
know
a
lot
of
work
went
into
building
this
anyone's
welcome
to
join
our
team.
B
It's
open,
open
governance
and,
and
so
we
follow
very
similar
process
to
operating
within
the
kubernetes
space,
and
we
have
our
first
question
so
from
Jane
or
yon
I'm.
Sorry
I
have
one
way
or
another
III
butchered
your
name
there,
but
the
question
is:
isn't
a
cute
cuddle
crew
install
cuddle,
instead
of
GL
I,
will
have
to
check,
will
will
send
out
an
updated
tweet.
If
that's
the
case,
it
will
make
sure
that's
correct
to
the
slides
before
we
send
it
out.
I
just
forget
what
the
crew
entry
we
have
is.
Yes,
I.
B
Perfect
next
slide,
please
perfect,
so
quick
agenda
of
what
we're
going
to
talk
about
today.
Why
would
I
even
do
this
right?
Why
would
I
even
use
cuddle
and
what?
What
does
the
the
first
experience
was
kind
of
look
like
ways
you
might
want
to
interact
with
cuddle?
Where
you're
going
to
want
to
do
this
and
then
the
the
anatomy
of
a
cuddle
operator,
and
then
how
do
we?
How
do
we
take
cuddle
and
turn
it
into
an
operator
or
how
do
we?
B
How
do
we
run
cuddle
in
on
an
operator
a
little
bit
cuddle
an
action
we'll
do
a
demo
and
we'll
talk
about
the
release
and
everything
else
at
next
slide,
please
so,
first
off!
Why
would
we
even
want
to
do
this
right
and
it
really
comes
back
down
to
this
notion
of
building
a
declarative
testing
framework
and
and
running
our
tests
declaratively.
B
We
talk
a
lot
about
kubernetes
about
wanting
to
be
very
declarative
and
ever
everything
we
do
and-
and
we
believe
it
should
be
able
to
apply
to
you
to
testing
as
well
next
slide,
please.
So
what
is
that
in
fact
mean
right?
Cuddle
is
entirely
based
around
your
kubernetes
resources,
so
this
right
here
is
a
cuddle
test.
B
It's
interesting,
you
wouldn't
think
this
is
a
test
right.
There
there's
a
bit
of
an
implicit
work
going
on
here,
but
this
will
validate
that
when
this
is
created
in
a
cluster,
it
looks
exactly
the
same
as
you
created
it
and
you
might
be
going
okay.
Well,
why
would
I
want?
Why
would
I
care
about
that
right?
So
next
slide,
please!
B
You
know
this
is
a
nice
step
to
ative
search
right,
because
here
we're
actually
asserting
the
same
exact
thing
came
out
on
the
other
end
and
we
can
assert
on
any
partial
piece
of
yeah
Mille
or
object
that
you
want
to
assert
on.
So
this
might
be.
Has
status
we'll
see
some
examples
of
that
later.
This
might
be
an
event
if
I'm
running
an
operator,
my
operator
is
creating
other
objects.
B
B
So,
let's
go
over
a
couple
different
terms
and
and
how
this
all
comes
together.
So
we
have
a
test
suite
and
and
a
testament
you
can
think
of
in
a
couple
of
ways,
one
it's
the
folder
where
all
your
tests
are
in,
but
it's
also
an
object
where
you
can
actually
configure
how
your
test
Suites
run
right.
What
cluster
you're
gonna
run
it
in
to
you,
I'm,
not
gonna,
start
kind
am
I,
just
gonna
start
a
control
plane.
How
do
I
want
to
point?
What
are
my
timeouts?
B
But
it's
also
that
configuration
file-
and
you
can
see
here
we're
saying:
okay,
we
only
want
to
start
a
configuration
plane
or
control
plane
and
we
want
some
parallelism
there,
and
this
becomes
very
useful.
We
can
talk
about
the
control
plane
in
a
little
bit,
but
there's
many
ways
to
actually
use
kuddle,
depending
on
what
your
speed
is
and
how
potentially
real
you
want
the
results
to
be
at
the
end
of
the
day.
Next
slide,
please.
B
B
We
have
a
test
step
that
is
going
to
run
a
command
and
it's
your
your
gateway
into
running
things
fairly
raw
right,
you
so
this
this
you
can
use
to
to
spin
up
an
operator
before
you
actually
do
anything
and
and
so
or
anything
else
that
you
might
want
to
do
right.
This
is
your
side
effect
mechanism
into
cuttle
so
that
you
can
bring
it
home
to
your
environment
without
just
having
it
be
a
bunch
of
gamma
like
goes
back
and
forth
next
slide.
Please,
and
now
we
have
an
assertion
on
this
command.
B
We
just
ran
right,
so
we
have
we've
set
on
our
test,
assert
that
we're
going
to
timeout
for
20
seconds
and
we're
going
to
do
a
partial
assertion
on
the
pod
that
we
expect
to
have
been
created
by
that
step.
So
here
we
have,
we
want.
We
want
to
make
sure
we
have
a
pod
named
test2
and
we
want
to
make
sure
that
head
has
some
some
status,
some
reasonable
status
there,
that
we
can
assert
on
next
slide,
please
so
once
we
have
that
we
just
run
it
right.
B
Yeah
cube,
kado,
cut
all
tests
and
the
folder
you
want
to
test
against
the
suite
you
want
to
test
against
and
it
runs
the
whole
suite.
So
if
you've
used
go
test,
this
looks
really
familiar
right.
This
is
we
follow
the
same
format.
Err.
Do
we
have
any
plans
right
now
can
for
a
J
unit
or
any
other
formatting?
B
B
And
you
can
actually,
this
is
all
open.
You
can
go
into
our
circle
CI
and
see
that
reported
output
so
that
it
looks
nice
and
inside
of
our
our
our
CI
system.
So,
okay,
great!
What's
what's
your
first
Connell
test?
Look
like
let's
walk
through
this,
so
first
we're
gonna
set
up
a
test
case
right:
you're,
gonna,
you're
gonna
set
up
your
your
in
the
end
test
directory.
This
might
be
in
your
helm,
chart
this
might
be
in
your
operator
repository.
This
might
just
sit
in
the
folder
of
or
you
a
random
folder.
B
If
that's
my
stuff,
it
doesn't
really
matter
where
it
sits.
It
does.
It
could
even
be
in
the
known
repository,
but
you
do
need
a
place
where
that
Suites
its
so
once
we
have
our
folder,
we
can
start
to
create
our
first
step
right.
So
here,
instead
of
having
a
test
step,
we're
just
going
to
have
a
pod,
and
this
is
going
to
implicitly
create
that
pod
right.
So
we're
saying
we
want
an
engine
X
1.7.9
pod,
with
with
the
one
container
in
it,
and
then
okay
great
you've
written
this.
B
What's
that
start
control
plane
flag
there,
so
you
may
have
seen
that
in
a
prior
screenshot,
but
this
is
another
way
to
indicate
to
cuddle.
I
only
want
to
start
the
control,
plane
and
I
want
to
operate
against
a
mocks
control
plane.
Now
that's
a
real
cube,
API
server
and
a
real
@cd
that
gets
stood
up,
but
it's
only
those
components
right.
B
It's
a
minimum
amount
to
actually
run
API
commands
against
the
API
server
very
great
for
really
fast
sanity
tests,
but
not
so
great
if
you're
testing
for
side
effects,
because
you
need
a
controller
running
right.
So
in
those
instances
you're
gonna
want
to,
we
have
we,
you
can
start
up
kind
and
you
can
start
up
or
point
at
a
real
cluster
in
order
to
test
skin
testing,
it's
more
real
environments.
Next
slides,
please
actually
can
I
think
with
that
I'm
going
to
turn
it
over
to
you
to
go
through
ways
to
cuddle.
Okay,.
C
B
C
On
this
slide,
the
the
thing
could
not
be
missed
is:
oh,
yes,
usually
a
test.
We
can
have
a
any
number
of
tests,
in
other
words
folders
that
represent
tests,
but
sometimes
you
might
want
to
just
verify
one,
and
this
is
pointing
to
that
same
directory.
But
it's
saying
well
within
that
directory
just
run
this
this
one
test,
which
is
the
example
test,
no
controls
over
the
number
of
steps.
It's
going
to
be
all
steps
that
are
defined
within
that,
but
there's
ways
to
reduce
the
scope,
which
is
a
common
interest.
B
Before
before
before
we
do
have
another
question,
so
do
the
assert
resources
like
parties,
the
same
pod
spec
or
can
they
have
additional
properties?
And
the
answer
is
no,
they
do
not
have
to
be
the
same.
This
is
really
important
right
because
we'll
go
through
it
can
we'll
go
through
a
lot
of
examples
of
this,
but
you
know
right
now,
you're
doing
an
exact
match,
but
if
you
go
any
if
we
go
back
up
to
slide
slide
where's
the
one
with
the
status
here,
we
go
slide.
21.
B
Alright
worrier
yep
perfect,
so,
if
you
look
here
are
our
assertion
is
on
action
on
lines
5
through
10
and
here
we're
asserting
against
the
status.
Now
when
we
created
that
pod,
that
would
not
have
had
that
property
right,
because
you
you,
the
only
thing
that
you
can
control
going
to
the
cluster
is,
is
the
API
version
kind
metadata
stack
right,
so
status
is
something
that
would
have
been
set
by
it
by
controller
manager
or
scheduler
once
that
pod
got
got
scheduled
out
to
a
cube
light.
B
This
all
looks
together
when
we're
doing
our
initial
demos,
but
the
intent
with
kudo
is
you
do
test,
potentially
other
properties
that
would
not
show
up
in
your
initial
pot
step
just
to
make
sure
that
you
know
the
world
around.
You
is
working
in
and
your
controllers
and
your
operators
are
behaving
as
as
expected.
Yeah.
C
Yeah,
in
fact,
if
we
went
back
one
more
slide
and
we
we
talked
about
the
test
step
itself.
Well,
this
is
different
because
it's
a
command,
but
when
we're
talking
about
a
test
step,
the
guarantees
that
kuddle
makes
is
that
the
object,
if
it
does
not
exist,
will
be
created.
But
if
the
object
does
exist,
it
will
do
a
strategic,
merge
patch
into
that.
C
So
you
can
actually
be
very
terse
in
a
lot
of
your
your
secondary
steps
or
our
steps
after
setup,
where
you
could
just
modify
the
ones
the
one
field,
the
one
property
that
you're
interested
in
and
it
would
be,
it
would
be
patched.
So
that's
very
common
also
on
the
assert
the
assert
after
it
makes
the
selection
on
the
you
know,
the
the
group
version
kind.
C
It
is
just
asserting
the
things
that
are
defined
in
the
mo,
so
it's
not
a
it's,
not
guaranteeing
anything
else,
and
if
you
took
a
look
at
our
our
sample
that
we
have
for
our
first
cuddle,
it's
a
little
bit
of
cheating
right,
like
the
pod
here
on
setup,
looks
just
like
the
assertion
and
there
are
no
other
guarantees.
As
long
as
that
pod
is
in
the
at
CD,
this
would
pass
so
this
would
probably
work
fine
under
a
Mach
control
plane
with
no
side
effects.
But,
as
Jared
pointed
out,
that's
probably
not
the
assertion.
C
B
C
B
Won
election
in
action,
actually,
you
know
what,
let's
all
ayats
are
real,
quick
and
then
we'll
hold
on
some
questions
for
a
few,
but
how
to
find
out
what
the
properties
are.
That
can
be
asserted.
That
would
be
in
the
CR
D
spec
if
it's
a
CR
D
or
the
kubernetes
open,
API
spec
for
anything
else,
and
for
that
you
can
actually
use
the
cube.
Ctl
explain
command
to
actually
dive
into
all
the
fields
on
on
any
object,
but
you'll
find
that
in
in
the
actual
kubernetes
api
or
your
CA
c
RDA
api
documentation.
B
C
Ways
to
cuddle
there's
a
couple
of
thoughts
here.
One
is
you
know
we
can
use
the
what
we
call
the
test
harness
the
test.
Harness
is
invoked
by
using
cuddle,
and
you
can
see
the
limited
commands
that
we
have
really.
As
you
can
see
what
version
you
have
and
then
run
tests.
We
can
also
connect
in
through
the
API
and
our
open
source
cuddle
the
open
source
project
of
cuddle.
Has
this
as
well?
It's
a
it's
a
good
example
of
this,
but
the
core
of
what
you
would
need.
It's
broken
into
three
blocks
here.
C
The
first
are
imports
that
you
need
to
have
or
likely
to
have.
Then
you
have
this
strong
interest
in
this
thing
called
test
suite
which
we're
going
to
look
at
in
just
a
few
minutes,
actually
next
slide
and
then
and
then
we
have
this
run
command
where
we're
going
to
actually
do
a
run
on
the
harness,
and
then
you
can
control
certain
aspects
or
the
setups
of
this,
or
if
you
have
some
different
way
of
either
outputting
or
inputting
values,
then
you
would
have
control
over
it.
So
cuddle
also
is
a
library
and
it.
C
C
C
Or
a
collaboration
with
kind,
and
because
of
that
we
actually
you
know,
do
you
want
to
start
kind
and
it'll
actually
start
up
an
instance
of
it?
Do
you
you
know:
do
you
have
a
special
kind
configuration?
Probably
the
most
useful
thing
on
here?
First
of
all,
most
of
the
documentation
would
want
around
kind.
You
should
probably
look
at
the
kind
documentation,
but
we've
got
links
to
help
provide
some
connectivity
through
cuddle.
The
last
point,
though,
is
this
kind
of
containers.
C
Comma
can
be
used
in
a
number
of
different
ways:
we've
talked
at
length
about
e
to
e
or
in
testing
and
and
even
portable
kind
of
conformance
testing,
which
is
super
great.
But
if
you
have
a
I,
don't
know
like
a
mixed
workload
test
like
we
do
or
some
environment
that
you
want
to
establish
and
then
assert
that
it
meets
certain
criteria.
You
could
use
cuddle
cuddle
for
that
and
then
say,
go
ahead
and
skip
the
deletion,
so
in
other
words,
when
a
test
is
complete,
don't
delete
those
artifacts.
C
Just
leave
them
in
place
just
verify
that
what
what
I've
asserted
to
be
true
is
true
and
then
leave
them
alone
same
thing
with
leaving
the
cluster
behind.
In
this
particular
case,
we
don't
delete
external
clusters
anyway,
but
sometimes,
if
you're
debugging,
and
having
a
challenge
with
your
kind
cluster,
you
don't
want
your
kind
cluster
to
go
away
before
you
inspect
it,
so
that
generally,
the
purpose
of
that
a
highly
using
our
configuration
is
the
timeout.
C
So
if
you
have
a
need
for
long
running
tests,
then
you're
going
to
want
to
make
modifications
in
that
space
parallel
as
you.
Yes,
you
might
expect
how
many
tests
do
we
want
to
run
in
parallel,
and
then
we
can
change
the
output
to
of
the
artifacts
directory
and
then
the
last
thing
is
dis
commands
now
I've
newly
added
an
feature
into
commands.
C
Generally
speaking,
these
are
commands
that
you
want
to
have
done
as
a
pre
step
to
testing
to
happen,
but
we've
added
in
the
ability
to
have
background
commands
so
usually,
if
you're
running
a
controller,
you're
gonna
run
something
that's
already
been
released
and
it's
probably
in
dr.
hub
or
something
like
that,
but
occasionally
you're
actually
wanting
around
a
controller,
and
that
controller
is
in
development
and
it's
not
released
so
being
able
to
run
a
command
and
background.
That
is
the
controller
and
your
test.
This
can
be
very
useful.
You
see,
there's
a
open
question.
C
B
B
C
Not
present,
yes,
we
have
the
concept
of
a
file
which
is
the
assert.
We
also
have
the
the
kind
called
a
test
assert.
Those
can
assert
that
something
is
present.
We
also
have
a
file
called
heirs
and
heirs
is
essentially
things
that
should
not
be
present.
It's
the
opposite,
so
it
would.
It
would
validate,
or
only
be
true
or
assert,
to
be
true
in
the
absence
of
some
value.
So
we
do
have
a
mechanism
for
that
for
reg,
X
I'm,
not
sure
I'm
gonna
have
to
pass
on
that
for
now.
C
I
do
know
that
we
do
reg
X
testing
with
cuddle
in
our
environment,
so
I
should
just
say.
The
short
answer
is
yes,
but
I'm
almost
positive,
it's
necessary
to
call
out
to
a
command
right
now
to
actually
do
that.
Reg,
X
comparison
and
I
have
it
in
mind,
or
we
have
it
in
mind.
That
might
be
a
good
feature
to
add
an
effect.
C
Sometimes,
there's
a
need
to
do
a
reg,
X
comparison
or
there's
at
least
a
couple
of
use
cases
that
have
been
presented
to
us
where
you
want
to
do
a
reg
X
comparison
against
a
pod
log
output.
So
in
the
pod
log,
there's
some
confirmation
of
a
process
either
being
complete
or
duck
in
the
case
of
Cassandra,
using
a
node
tool
to
do
some
activity.
There's
a
log
that
indicates
that
that
that
has
been
accomplished
so
probably
look
forward
to
seeing
some
some
features
being
added
in
to
help
support
that
and
they.
C
C
To
the
test
suite,
but
we
also
have
configuration
capabilities
as
well
as
a
very
senior
number
of
times,
it's
very
common
for
me
when
I'm
building
out
a
cuddle,
especially
a
new,
to
leave
out
this
like
start
kind
or
start
control,
plane
I
can
just
specify
that
as
a
flag,
the
flag
will
override
this.
So
it
is
possible
to
just
leave
it
in
here
and
overwrite
it
with
like
a
false
or
something
so.
I
I
tend
to
make
this
minimalistic
if
possible,
but
this
should
adhere
to
the
constraints
that
we
just
we
just.
C
And
then
we
have
the
cuddle
old
CLI.
What
what
I'm
showing
here
actually
is
what
you
get
as
an
output
but
shows
a
number
of
different
options
if
your
manifest
I'm.
Sorry,
if
your
test
suite
R&E,
is
fully
documented,
if
it's
complete,
then
you
would
be
able
to
just
say
cuddle
test.
If
you
want
to
change
the
test
suite,
you
could
say
that
the
configuration
file
is
somewhere
else
and
there's
a
variety
of
different
configurations.
You
can
see
here.
You
can
be
fully
declarative
on
the
command
line
as
well.
Oh.
C
C
C
Great
okay,
so
back
to
where
I
left
off.
Where
do
you
want
to
cuddle?
This
becomes
super
important
I.
Imagine
for
lots
of
people.
The
first
is
this
is
designed
to
work
against
life
clusters.
So
as
long
as
you
can
provide
us
with
a
cute
config,
and
we
also
have
a
config
flag
that
will
test
up
against
any
presumably
any
version
that
we
match
with
the
client
go
up
against
a
live
cluster.
C
We
also
have,
as
we
indicated,
an
integration
with
kind,
so
you
could
say:
go
ahead
and
start
a
kind
cluster
it'll
be
automatic
created
for
you,
and
then
we
have
the
ability
to
have
a
mic,
a
mock
control
plane,
which
I
think
Jared
went
over
a
little
bit,
and
this
is
the
concept
where
we
just
have
essentially
the
API
server
at
CD,
and
that's
it
limited
uses
there
and
I
would
consider
that
to
be
more
of
an
integration
test
and
not
not
and
of
the
other.
Two
are
nice
good.
C
You
know
very
good
and
n
tests
and
just
to
give
you
some
figures
that
just
came
across
my
desk
this
week
we
are
running
tests
against
our
flavor
of
kubernetes
as
an
end-to-end
test
in
a
production
environment
and
the
creation
of
that
testing
of
that
and
teardown
of
that
takes
an
hour
and
six
minutes
and,
of
course,
takes
cloud
time.
Meaning
cloud
dollars
that
same
sort
of
tests
on
kind
is
three
minutes
and
40
seconds.
I
believe
is
what
it
was.
C
So
we
believe
that
there's
you
know
Greek
value
and
having
these
really
fast
and
and
testing
using
kind,
getting
the
value
out
of
that
and,
of
course,
we're
going
to
test
against
a
live
cluster,
but
we
can
reduce
our
cost
and
time
of
context
switching
for
developers.
So
the
wind,
when
I
believe
when
we're
working
with
a
kind
of
cluster
we
can
make
the
configurations
again,
I
would
advertise
that
going
out
to
the
kind
documentation
for
what
can
be
configured
is
where
to
go
for
that
detail.
But
we
do
support
it.
C
A
C
An
integration
with
crying
it's
possible
to
use
any
other
type
of
cluster.
As
long
as
that
configuration
or
that
creation
of
that
cluster
is
created
ahead
of
using
code,
so
I
would
say
they
do
support
that,
but
the
nice
integration
of
having
it
just
created
for
you
is
only
supported
with
kind
at
this
point
and,
of
course,
it's
open
source.
So
all
pull
requests
are
welcome,
full
evaluate
based
on
demand,
but
we
do
support
it
and
it's
just
a
matter
of
you
know:
automating
the
creation
process,
alright,
so
steps.
C
This
is
really
just
a
breakdown
of
the
things
that
Jared
went
through
and
a
little
bit
more
fine
detail.
We
do
support
amel
and
a
couple
of
different
extension
things
if
we
do
also
support
files
being
in
those
test.
Directories
that
are
not
animals,
they'll
be
basically
ignored
and
that's
a
great
place
for
documentation
to
explain
what
this
test
is
doing
and
how
it
you
know
any
preconditions
or
expectations,
things
of
that
nature.
There
is
a
nomenclature
associated
with
a
file
name,
which
is
the
index
so
zero.
C
Zero
is
probably
what
you've
seen
examples
of
there's
one
on
screen
in
some
name,
and
one
would
expect
it's
a
name,
that's
meaningful
to
you.
It
is
arbitrary,
but
it's
just
like
naming
a
test
and
it
does
show
up
in
the
output
of
the
test
runs
so
you'll
see
a
test
starting
and
I'd
be
the
file
that
is
I'm,
sorry,
the
directory
name,
that
is
output
and
then
you'll,
see
each
step,
and
you
might
even
see
if
you
have
a
failure
or
an
assertion.
Failure
you'll
see
in
which
that
that
was
failed
and.
C
A
C
Common
to
see
yellow
assets
that
are
used
across
tests,
in
which
case
today,
we
commonly
would
say
who
use
the
command
to
do
an
apply,
and
that's
one
of
the
next
features
will
probably
be
added
into
cuddle.
Is
the
ability
to
specify
that
from
a
test
step
declaration
as
opposed
to
forcing
anyone
to
use
a
command?
It's
just
one
of
those
things
that
we've
realized.
It's.
C
Well,
cuddle
came
out
of
Kudo
and
has
been
around
for
a
year,
so
we
just
had
a
release
in
March.
It
was
our
first
cuddle
release.
They
could
feel
like
these
are
fresh
bits
and
in
some
cases
it's
true,
but
this
has
been
around
for
a
year
of
time,
roughly
steps-
oh
so
I
mentioned
this
earlier,
but
these
are
creator
updates.
If
the
object
already
exists,
you
can
just
Express
the
minimum
amount
of
updates.
C
If
you
want
to
delete,
then
you'll
need
to
actually
declare
that
in
a
test
step
and
then
it's
possible
to
delete
things,
and
we
have
another
of
good
examples
of
doing
that
as
well
right
here,
in
fact,
so
the
one
difference
is,
we
can't
just
assume
a
manifest
is
delete.
They
actually
assume
that
it's
an
update
or
create.
However,
if
you
want
to
take
control
over
a
delete,
it's
possible
with
just
a
private
list
of
things
that
you
want
to
delete
in
a
given
test
step.
C
And
then
commands,
as
mentioned
when
I
want
to
reuse
something
or
in
this
case,
I
want
to
use
something
from
the
web
as
opposed
to
a
relative
path.
It
is
possible
to
provide
that
information
within
a
test
step,
and
so
you
know
one
way
that
you
might
install
a
suit
keeper
operator
using
cuddle
is
to
actually
invoke
the
cute
cuddle
install
on
zoo
keeper.
In
this
case
it
skips
the
instance,
but
it
does
get
this
year
and
instances
the
crs
in
place.
C
It's
worth
pointing
out
that,
of
course,
the
commands
are
a
run
that
there
is
a
requirement
that
the
paths
be
resolvable
or
channel.
Hopefully,
here
is
reasonable
and
then
again
answering
an
earlier
question.
We
do
have
the
ability
to
assert,
but
we
also
have
errors.
So
if
we
have
an
heiress
file,
it's
it's
basically
an
assertion
that
the
state
does
not
exist
and
if
it
does
exist,
it's
in
here
so
after
giving
time
out
and
and
everything
is
eventual
consistency.
C
C
C
C
The
next
step
would
be
some
tips,
so
cuddling
tips
would
include
things
like
we
work
with
everything
associated
with
kubernetes,
so
the
kubernetes
events
are
objects
and
they
are
also
assertable,
so
we
can
assert
that
they
exist
or
don't
exist.
Another
tip
is
that
we
can
wait
for
CRTs,
so
we
wait
for
CRVs
automatically
within
the
the
test
suite.
But
if
you
create
your
own
CRD
within
a
certain
step,
you
might
want
to
wait
for
that.
C
So
one
way
to
do
that
is
to
actually,
as
you
see
on
the
right,
we
are
wanting
to
create
the
instance
or
use
an
instance
of
a
CRD,
but
what
you
would
do
is
in
the
setup
step,
four
zero
zero
is,
you
would
create
it
and
then
you
would
assert
that
it
true.
So
in
this
example,
we
see
the
status
is
that
it's
available
that
where
we
see
that
the
kinda
spicy
Rd,
and
so
we
have
this
pretty
little
documented
on
the
safe.
C
We
also
work
with
home
and
when
working
with
helm,
you
can
see
examples
of
basically
using
the
command.
So
we
know
native
integration
with
helm
with.
We
do
work
pretty
pretty
successfully
with
using
helm
to
do
a
nets
or
deletes
or
any
kind
of
other
operations.
And
then
you
know
the
next
step
might
be
asserting
that
something
is
available
or
true.
C
B
C
You
know
having
manifest
files
is
that
we
have
a
we
have
something
we
want
to
wait
for,
that's
being
created,
so
here's
just
an
example
of
what
we've
done
within
Kudo
in
kudo.
We
have
the
ability
to
have
CR
DS
created
on
an
it,
so
we
have
a
command
within
Kudo
and
then
we
will
say,
wait
and
the
wait
in
this
particular
example
we'll
basically
block
moving
forward
within
the
test
until
the
command
is
complete,
the
command
will
be
complete
when
Kudo
is
ready.
So
this
is
a
simple
example.
C
It
works
great
for,
like
a
released
version.
We
also
have
this
ability,
where
we're
gonna
insert
the
CR
knees,
but
then
we're
actually
running
in
development,
so
we're
running
in
our
CI
environment
and
within
CI
environment.
We
want
to
run
what
was
built
and
not
potentially
not
necessarily
released
on
docker.
C
In
this
example,
we
have
it
set
for
background
equals.
True.
So
at
that
particular
point
commands
on
the
like
line
6,
we
wait
until
it's
complete
with
things
that
are
marked
with
the
background
are
started,
and
we
don't
wait
for
them.
You
would
have
to
have
some
other
mechanism
after
the
manager
at
this
point
to
indicate
that
the
manager
is
ready.
C
C
So
this
is
this
is
the
test
suite?
This
is
the
test.
If
we
look
at
list
pods,
you
can
see
that
I
have
my
pod
and
then
I
have
my
assert-
and
this
came
right
out
of
our
example
that
we
have
and
it
doesn't
really
test
against
status,
but
this
is
designed
to
run
up
against
a
mock
test.
However,
this
might
be
largely
different
than
our
CRD
in
step
with
the
CRD
I
have
a
C
or
D.
B
C
Asserting
that
that
is
true
with
a
status
that
indicates
that
it's
in
existence
then
I'm
actually
using
it,
then
I'm
actually
confirming
that
that
that
occurred.
So
this
is
basically
apply,
and
although
this
looks
the
same,
but
this
is
confirming
that
the
that
I
can
apply
so
and
then
again
as
a
quick
example.
Here's
our
test
I
want
to
bring
it
to
the
top
so
cuddle
test
in
the
directory,
and
then
we
run
in
this
particular
case.
C
It's
spell
equals
false
in
this
case,
I
would
have
to
have
a
cluster
that
I'm
connecting
to
but
I'm
switching
it
out,
I'm
overriding.
Essentially
the
configuration.
That's
there
in
that
particular
case.
It
won't
work
because
I
don't
have
a
running
cluster.
I
would
also
add
that
we
have
I,
think
reasonable
documentation.
C
Obviously
open
to
pull
requests
and
feedback
would
love
it.
But
details
about
running
your
first
cuddle
details
around
the
seal
on
how
to
use
it,
but
probably,
more
importantly,
is
probably
deeper
explanations
of
asserts
and
errors
and
what's
possible,
along
with
details
on
steps
and
and
changes
and
modifications
you
can
make
within
there.
So.
C
We
have
a
road
map
in
place
to
do
some
pretty
active
development
over
the
next
several
months
to
have
any
features
that
we
specifically
are
interested
in,
but
we're
also
very,
very
interested
in
what
the
community
might
want
or
need
as
a
comparison.
I,
don't
think
I
have
this
available.
Yet
if
you
look
at
the
oh,
maybe
I
can
hop
forward
on
the
fly
right.
C
By
comparison,
if
we
look
at
what
we
have
and
kubernetes
proper
and
I'm,
not
what
would
you
see
what
what
what
people
have
been
doing
to
do
similar
things
like
just
a
simple
get
right?
The
simple
get
I
mean
this
is
all
essentially
batch
scripts
and
I'm,
not
I
mean
I'll.
Let
everybody
else
be.
The
judge
is
what's
easier
to
read
whether
it's
just
a
layout
of
gamal
or
or
this,
but
this
is
the
kind
of
this
to
me.
This
feels
like
the
target
of
hey.
We
could
make
this.
C
Perhaps
we
can
make
this
easier
to
read
and
and
cheaper
ownership,
so
that's
that's
kind
of
where
I'm
going
with
future
of
cuddle
and
also
I,
also
envision,
potentially
I,
also
envision
making
a
test.
Folder,
I'm,
sorry,
I,
test,
sweet
folder,
an
artifact
like
a
tarball,
and
then
those
conformity
tests
or
portable
and
I
can
use
them
on
any
given
cluster
and
potentially
hand
them
to
end-users
to
validate
things
are
as
expected,
or
maybe
even
provide
asserts
as
to
what
I
expected
and
get
diffs
back
as
to
why
it
was
different
than
my
expectation.
C
So
with
that,
we
did
have
a
release
and
March
as
indicated.
However,
it's
been
a
year
in
development
and
I
think
we
could
open
up
for
some
Q&A.
The
cuddle
is
available
online.
It's
open
source,
we
are
active,
we
haven't
had
enough
activity
or
community
activity
with
with
cuddle
specifically
to
warrant
to
its
own
select
channel.
C
We've
still
been
managing
that
within
the
Kudo
channel
and
so
far
that's
worked
out
very
well,
but
if
we've
seen
a
if
we
get
an
uptick
in
and
demand,
we're
obviously
going
to
go
out
there
and
make
sure
that
we
provide
the
best
experience
with
connecting
to
the
team.
We
do
have
a
kept
process.
I
will
add
that
that's
more
of
a
kudo
enhancement
process
and
all
that
means
is
it's
a
kubernetes
enhancement
process.
A
A
B
One
thing
I'll
add
in
the
meantime,
while
we're
waiting
for
questions,
you
know
where
there's
there's
a
couple
groups
that
we've
been
talking
to
you
to
power.
This
we've
introduced
this
to
Korean.
Stick
testing
as
the
potential
option
there
to
to
help
make
things
were
more
robust.
We've
also
been
in
talking
to
red
hat
a
lot
and
the
about
ways
that
the
operator
hub
and
and
cuddle
can
work
together,
and
they
are
very
active
participants
in
our
project
as
well
Orlin.
Yes,
we
can
hear
you
and.
B
And
the
D
2
IQ
itself
also
is
using
it
to
power
everything
from
conformance
of
operators
to
two
other
tooling,
and
we
have
a
lot
of
other
users
as
well,
who
are
coming
out
and
using
it
for
very
simple
thing
and
then
one
thing
I'll
actually
volunteer
out.
There
is
there's
another
great
tool
out
there
called
contest
and
contest
and
could
a
differ
in
a
very
significant
way.
B
Yeah.
It's
it's
one
of
the
things
that
I
I
kind
of
asked
myself.
What
I
like
like
I
go,
which
tool
should
I
use
contest,
is
really
about
the
the
static
asserts
and
then
Kudo
or
cuddle
is
really
about
testing.
How
does
this
actually
run
in
my
inner
in
a
real
live
environment?
So,
if
you're
looking
for
a
unit
testing
framework
along
this
contest
is
a
great
option
there
in
the
in
in
cuddle,
is
more
of
your
integration
and
end
side
of
that
equation.
B
C
A
Alright
looks
like
they're
no
questions
submitted
so
with
this
one
think
again,
girl
thinkin
for
great
presentation.
That's
that's
all!
For
today,
thanks
everyone
for
joining
us
do
ever
that
will
be
recorded.
It's
recorded
and
the
slides
will
be
online
later
today.
We're
looking
forward,
seeing
you
in
the
future,
seen
CF
webinars
and
have
a
great
day
evening
afternoon
depends
on
which
part
of
the
globe
you
are.
Thank
you,
everyone
and
see
you
next
time,
bye,
bye,
I
liked.
So
much.
Thank
you.
Bye,
bye,.