►
From YouTube: CI/CD UX Team Design Review | 3 December 2019
Description
Second Design Review session of CI/CD UX Team.
- Dimitrie Hoekstra | 01:11
Adding child pipelines to the parent one (in one view).
- Juan J. Ramirez | 29:20
Selenium Tests artefacts display for GitLab CI.
A
Awesome
so
yeah
I
am
actually
excited
for
this
for
this
week's
session.
If
we
we
skipped
last
week
because
of
the
holiday
period,
the
first
design
review
for
CIC
Dux
team
was
amazing.
I
think
we
have
been
looking
at
at
the
work
of
one
and
Ian
and
were
some
of
the
great
design
world
were
also
amazing
feedback
shared
so
I'm.
B
It
has
a
pipeline
starting
a
pipeline
in
another
project
which
are
both
equally
independent
pipelines,
but
when
it's
triggered
by
the
other,
we
refer
to
those
as
the
upstream
of
being
the
pipeline
that
triggers
a
downstream
so
upstream
and
downstream,
with
parent-child
pipelines.
We
are
gearing
towards
the
customers
that
have
you
know
larger
repositories
such
as
mana
repose,
and
they
want
to
do
some
more
or
have
more
advanced
inner
structuring
of
their
pipeline
within
the
same
project.
So
they
do
not
want
to.
You
know,
jump
between
micro-services.
B
They
want
to
have
you
know:
CI
configuration
capabilities
within
the
current
project
and
parent-child
pipelines,
basically,
is
what
it
says.
I
know
it's
kind
of
this,
but
it
is
a
pipeline
living
inside
of
another
pipeline
or
even
multiple
pipelines
living
inside
like
a
main
pipeline.
There
are
some
considerations:
the
child
pipeline,
as
we
currently
defined.
The
scope
goes
only
one
level
deep,
so
child
penguins
cannot
have
child
out
the
apartments
of
their
own.
This
will
be
discovered
later
on.
B
We
decided
in
the
past
that
the
trigger
job,
as
it
does
not
have
a
real
job
log
of
itself,
just
trigger
something
internally.
It
is
not
clickable,
it's
not
navigable.
It's
like
a
a
spoof
job,
but
it
allows
us
to
see.
Am
I
all
right
in
which
stage,
for
example,
that
does
the
crimp
on
trigger
and
downstream
I'm
going
to
quickly
navigate
towards
a
pipeline?
To
give
you
an
indication
of
how
it
looks
like
give.
A
Me
to
you
an
actually
a
question:
I
was
starting
it,
but
let
me
just
ask
it
since
you
paused
I,
can't
give
a
like
a
real-life
example
of
in
what
case
a
child
pipeline
is
created.
Does
it
mean
that
it's
like
a
smaller
piece
of
functionality
is
being
kicked
off
as
as
the
bigger
part
of
like
code
or
yeah.
B
So
it
allows
us
where
the
person
people
creating
a
pipeline
to
have
a.
So
let
me
see
how
I
should
explain
this
so
in
a
pipeline
we'll
grab
a
example
here
is
disregarded,
reacquiring,
but
what
basically
happens
in
a
pipe
once?
You've
got
stages
and
these
stages
have
different
jobs
inside
of
them,
and
these
jobs
inside
of
the
same
stage
are
run
concurrently,
so
they
they
all
start
at
the
same
time,
and
they
wait
before
moving
on
towards
the
stage
until
they're
all
finished,
either
failed
or
successful
with
a
child
pipeline.
B
What
you'll
be
able
to
do
is
that,
instead
of
just
aligning
with
those
different
stages,
you
will
be
taking
off
an
independent
pipeline
within
the
current
pipeline,
which
allows
for
further
customization
as
to
which
jobs
depend
on
which
other
job,
because
that
sub
pipeline
will
have
its
own
stage
structure.
Basically,
you
can
go
even
deeper
into
that
with
a
directive.
The
cyclic
rafts,
which
is
another
functionality
which
allows
jobs
to
independently
rely
on
other
jobs
within
the
pipeline.
B
So
for
a
pipeline
to
be
configurable,
you
need
to
get
up,
see
IMO.
We
have
a
few
options
there.
We
have
an
include,
basically
which
allows
you
to
include
another
file
into
the
main
configuration
file
and
in
which
child
types
that
will
actually
work.
Similarly,
because
a
child
pipeline
will
have
its
own
configuration
file
which
will
be
referenced
in
the
main
gitlab
CI
ml
file
in
with
the
turret
job.
Basically,
so
the
trigger
job
says
hey
Brenda
summer
pipeline
as
well,
which
has
its
own
Duncan
lepsy
IMO
file.
Basically,
there's
an
answer.
A
Yeah
I
was
the
toss
and
I
was
actually
more
kind
of
like
interested.
In
a
real-life
example,
doesn't
mean:
did
you
know
that
yeah,
it's
kind
of
like
a
part
of
application
being
being
being
published
within
a
part
of
another
like
over
the
bigger
application
or
something
more
like
a
real
case
scenario?
So
less
technical
terms
but
like
I,
know
an
example
from
a
real
live
when
the
user
would
need
to
use
child
pipeline.
B
Yes,
so
for
sure
say
say
that
a
in
a
real-life
example,
you
might
want
to
have
a
docker
container
bill
and
that
docker
container
bill
is
an
additional
deliverable
from
the
Curt
project.
Say
that
it's
a
release
from
a
library
or
something
like
that.
But
that's
docker
container,
is,
for
example,
targeting
and
firemen
in
which
a
iOS
application
can
be
built
and
there's
another
one.
That
you
know
creates
a
dr.
Taylor
for
Android
development
right
and
they
will
independently
be
able
to
publish
their.
B
B
So
this
this
little
wireframe
kind
of
depicts
how
the
trigger
job
that
will
refer
to
a
child
pipeline
will
look
like,
will
have
a
label
or
tag
attached
to
it,
which
makes
it
a
little
bit
different
from
all
the
others,
because
a
trigger
job
referring
to
a
child
pipeline
were
basically
which
triggers
the
child
will
be
navigatable
as
the
pipe
one
actually
lives
inside
of
the
current
pipeline
from
a
cognate
cognitive
model.
Basically,
the
point
now
is
and
here's
what
I'm
gonna
gonna
go
to
now
I
want
to.
B
B
B
C
B
That's
that's
the
thing
I
want
to
talk
about,
so
the
initial
idea
where
this
design
was
that
as
a
child
pipeline
lives
within
the
current
pipeline
is
not
in
fact
a
downstream
pipeline,
which
would
be
a
you
know.
Another
pipeline
within
another
project
I
would
not
want
to
display
it
there
because
also
in
another
there's
some
consideration
so
in
another
pipeline
in
another
issue.
B
We're
editing
this
graph
to
be
more
specific
in
its
we're
more
usable
in
its
design,
and
these
things
will
actually
display
the
project
information
as
well
as
the
child
pipeline
lives
within
the
current
project
and
the
Curtin
pipeline.
That
information
is
not
necessary
and
therefore
I.
The
idea
was
for
to
have
the
trigger
job,
be
the
navigation
element
to
navigate
towards
the
child
pipeline.
The
point
is
that
engineering
has
stated
that
if
we
want
to
display
the
child
pipeline
in
the
downstream
column,
we
basically
get
it
for
free.
This
gives
us
a
few
upsides.
B
The
upsides
is
that
it
will
be
viewable
inside
of
this
stage
inside
of
this
column,
and
if
you
click
on
it,
it
will
expand
in
line.
So,
basically,
if
you
watch
this
well,
the
further
shown
to
us
I
think
just
one.
Let
me
see
if
they
they're
not
gonna
click
on
it
I
think
they
should
so
here
you
see
that
they
clicked
on
it
and
inside
of
that
pipeline.
There
are
there's
this
one
stage,
which
has
two
two
jobs,
basically
so
you're
able
to
expand
in
line
where
I'm
unsure.
B
B
D
A
B
E
B
Suggestion
by
engineering
is
that
they
would
like
to
implement
it,
and
their
suggestion
is
to
make
it
more
clear
that
it's
a
child
parent
relationship
instead
of
a
most
project,
relationship
and
I,
think
it's
a
sound.
That's
why
I
wanted
to
pass
it
by?
What
do
you
think
if
that
is
the
only
thing
necessary
to
do,
and
just
to
give
a
small
example
of
how
to
multiply
20
years
here
we
are
looking
at
a
pipeline
which,
which
has
a
pair
a
upstream
pipeline.
B
This
is
actually
an
interesting
case,
because
our
week
on
is
the
child
pipeline
will
never
be
surfaced
within
the
Richard
Quest
widgets,
which
is
something
I
need
to
discuss
with
with
the
engineers
here,
but
that
I
think
I,
don't
think
they.
This
is
basically
mock
data,
so
it
wouldn't
make
sense
to
have
it
fully
configure
this.
We
wanted
en.
E
E
E
The
thing
that's
always
plugged
me
about
this
pipeline
view
is
like
what
is
its
use.
You
don't
I'm
saying
it
is
a
very
complex.
What
is
the
user
really
trying
to
get
out
of
this
view?
Is
it
details
about
the
the
jobs
and
the
you
know
the
status
of
things
so
I
kind
of
feel?
Maybe
no
right,
because
the
other
view
the
jobs
for
you?
Is
it
probably
better?
You
know
like
status
of
what
so
to
me.
It's
it's
really
like.
E
The
goal
of
this
is
to
understand
how
these
things
are
connected,
because
writing
a
see
IMO
file,
especially
a
complex
one.
You
know
with
dependencies
and
parents
and
dag
right.
It's
your
writing
code
that
is
difficult
to
visualize.
So
to
me,
I
think,
that's.
The
point
of
this
view
is
is
to
help
you
unravel
what
you
have
written.
Would
you
agree
with
that
statement?
E
B
Agree,
though,
it
does
not
cover
everything
as
I
would
say
that
that
is
including
for
the
person
that
is
configuring
the
pipeline
for
a
person
that
is
actually
writing
the
code
tested
by
the
pipeline.
They
would
be
more
interested
in
making
it
the
information
that,
like
that,
the
error
information
right
like
why
Department
failed
accessible.
B
B
E
A
So
it
more
like
would
open
up
in
the
horizontal
way,
not
in
the
vertical
one,
because
what
if
it
has
more
stages
right,
because
the
border
between
the
parent
and
the
child
wasn't
really
visible,
and
if
you
would
not
say
that
was
a
my
point.
If
I
would
be
a
new
new
géza,
I
probably
would
never
figure
that
out.
If,
especially,
if
that
would
not
be
saying
child
1
child
2,
so
more
kind
of
like
put
it
somewhere
like
down.
But
that's
it
dreaming.
If
I
da
ting
here
I.
B
B
You
know
if
I
have
to
roll
back
to
the
scope
of
this
issue
will
not
be
able
to
do
much
about
the
current
displaying
of
the
pipeline
graph,
but
perhaps
there
is
some
in-between
ground
that
we
can,
for
example,
have
a
separate
column
for
child
pipelines
and
a
second
column
for
downstream
pipelines,
and
that
way
differentiating
between
the
two
in
some
way.
Yeah.
You
just.
C
B
C
B
Yeah
I'll
see
how
I
am
I'll,
see
how
that
works.
I'm
going
to
visualize
it
for
myself
to
make
sure
that
is.
That
is
a
good
indication
because,
currently,
with
a
downstream
pipeline
like
how
it's
visualized-
it's
not
so
so
much
on
this,
but
currently
that
the
whole
column
is
called
down
streams
basically,
which
makes
it
slightly
different.
Perhaps
we
can
say
like
perhaps
you
can
just
get
rid
of
this
and
just
you
know
put
in
a
tag.
E
B
B
Dynamically
generated,
Caleb
CI
animals
will
be
currently
will
be
limited
by
it.
So,
for
example,
if
a
kid
lopsy
IMO
configures
another
dog,
Caleb
CI
llamo
within
child
park
lines,
we
will
not
immediately
support
that,
but
that
is
let's
go
to
it
to
the
far
end
of
configurations
for
CI.
That
is
a
that's
making
it
even
more
complex.
Under
this
I.
Don't.
E
B
It
applies
the
current
problem,
space
so
much
I'm
sorry
I
chose
such
a
difficult
topic.
It's
it's
been
hard
to
really
visualize
and
give
it
a
good
overview
of
what
the
design
decision
is
to
be
made,
and,
and
some
of
this
I
would
say
it's
also
just
up
to
thrust
and
try
out
some
degree
see
how
it
works
out.
I
do
agree
that
there's
lots
to
be
done
for
a
cut
line
graph
view.
E
A
No
problem
with
selecting
such
a
tough
one
for
a
change.
Why
not-
and
this
is
why
these
sessions
are
here,
I
hope
we
gave
you
some
useful
thoughts
and
the
I
made
all
of
the
notes
in
the
document
so
feel
free
to
review
them
and
yeah.
Hopefully,
this
will
give
you
a
little
bit
of
a
push
to
any
of
the
directions.
A
B
C
All
right
so
I'm
gonna
just
also
keep
like
a
little
bit
of
a
quick
introduction
like
what
I'm,
what
I
want
to
get
feedback
on,
but
it's
gonna
provide
first,
some
context,
so
yeah.
So
basically
what
you're
seeing
here
is
like
a
typical
CI
CD
pipeline
right.
So
it's
a
pipeline
that
has
a
source
station
build
stage
a
test
station,
then
at
the
police
station
right.
So
that's
pretty
typical.
This
is
what
most
customers
are
doing
in
one
way
or
another.
C
C
The
the
important
thing
here
is
to
understand
that
this
testing
happens
in
the
context
of
a
browser
and
it's
important
to
know
because
it's
different
from
other
type
of
tests,
which,
like
are
probably
looking
at
the
code
or
looking
at
like
at
the
API,
is
actually
looking
at
a
browser
or
like
simulating
the
app
in
a
browser.
So
that's,
basically
what
it
is
is
right,
like
this.
C
Only
happens
for
web
applications
and
it's
very
common
that
in
these
web
applications,
you
add
certain
point:
you
want
to
test
the
UI
and
the
app
functionality,
so
many
organizations
the
way
that
they
do
it
is
that
they
hire
QA
s
and
the
QA
is
basically
like
when
they
receive
a
branch
from
the
developer.
So
this
is
very
manual
like
many
people
still
do
it
in
a
very
manual
way.
We
see
the
they
build
it
then
they
load
it
on
a
browser
and
the
server
like
basically
running
some
like
manual
tasks.
C
You
know
like
like
is
the
thing
that
this
person
just
push
doing
what
it
expect
to
do
and
they're
like
basically
testing
many
other
things
on
the
UI.
The
problem
with
that
approach
is
that,
like,
first
of
all
like
you,
never
you
never
have
the
ability
to
like
have
like
a
wide
range
of
tests
like
when
you
do
it
manually,
because
sometimes
you
can
change
something
and
it
breaks
another
thing.
You
know,
so
it's
very
common
that
you
make
a
small
UI
change,
that
it
looks
good.
C
Maybe
like
a
CSS
stylesheet
that
you
change
and
then
like
it
looks
we
don't
that
thing,
but
you
didn't
know
that
that's
also
affecting
another
component,
but
it's
out
of
the
scope
of
that
video
scene,
so
that
class
probably
damages
another
view
so
for
the
QA
tester
to
know
that
it's
like
they
have
some
tools.
I
allow
them
to
do
that,
but
it's
kind
of
painful.
So,
at
the
end
of
the
day,
what
most
organizations
want
to
do?
Is
they
they?
Don't
they
don't
wanna
do
this
manually
they?
C
What
do
you
want
to
do
is
like,
basically,
if
you
want
to
run
a
UI
testing
or
like
functionality,
testing
for
your
web
applications.
What
you
want
to
do
is
I
use
an
automated
browser
or
like
a
browser,
automation
and
basically
what
that
means
is
that
you
get
a
browser
and
the
browser
loads,
the
app
and
then
they
are.
C
The
browser
will
run
the
tasks
right
so
like,
instead
of
like
the
the
QA
doing
that
manually,
there's
like
an
instruction
set
about
what
needs
to
be
done
so
that
instruction
set
could
be
things
like
click
on
this
button.
Wait
for
the
page
to
load
five
seconds
then
see
if
this
element
loaded
or
showed
up.
If
you
didn't
show
up,
do
these
blah
blah
blah
it's
like
and
like
this
trip
can
be
as
long
as
you
need.
C
It
can
be
as
complex
that
you,
as
actually
as
you
want,
so
this
is
very
important
because
it
allows
organizations
to
catch
different
regressions.
It
are
also
great
sessions
to
test
functionality
that
it's
being
shaped
or
released
like
in
very
specific
ways,
and
it
allows
organized
to
also
find
how
like
new
functionality,
it's
creating
like
issues
for
regressions
in
other
areas,
because
at
the
end
of
the
day,
what's
good
about
browser
automation
is
the
browser
automation.
C
It's
not
only
gonna
test
against
the
view
that
you
just
change,
is
gonna
run
tests
again
select
multiple
views,
ideally
against
the
foe
up.
You
know,
like
the
whole
app
is
gonna
be
tested,
and
then,
like
is
if
there's
regressions
or
if
there's
box
like,
hopefully
it's
gonna
catch,
those
so
yeah,
that's
basically
what
it
is
it's
you
can
automate
any
of
these
browsers.
C
It
depends
on
the
framework
that
you're
using
there's
many
like
there's.
Some
popular
frameworks
and
there's
some
popular
options
to
do
these
there's
actually
many
ways
to
do
it
that
are
not
only
using
frameworks.
There's
companies
that
like
have
like
this
approach
of
light,
actually
spinning
out
real
desktops,
like
virtual
machines
and
then
like
running
those
tests
manually
like
like
not
manually,
like
randos
tests,
like
as
if
it
was
a
person
doing
that.
C
There's
also
like
this
all
new
train
about
our
PA,
which
is
robot
process,
automation
that
it's
kind
of
like
another
big
trend
on
how
these
things
can
get
out.
I
made
it
and
I
tested.
So
there's
many
things
going
on
only
space,
which
is
always
interesting
for
this
particular
case,
like
what
I,
what
I'm
gonna
be
showing
it's
very
specific
to
selenium.
So
selenium
is
one
framework
that
it's
used
by
many
companies
by
it's,
nonetheless
really
doing
the
industry
standard,
but
it's
widely
adopted
and
widely
used
by
many
companies.
C
C
So
when
you
do
all
these
things,
selenium
is
gonna
need
like
a
way
to
report
that
back
to
to
report
that
back
to
to
like
the
customer
and
the
way
that
they
do.
It
is
to
our
X.
You
need
report,
so
X
you
need
is
like
a
type
of
like
testing
report,
language,
whatever
you
want
to
call
it
and
there's
many
many
many
of
these
types
of
languages,
but
they
all
kind
of
like
respect
a
similar
nomenclature
and
I
like
to
similar
way
of
doing
things
and
that's
called
the
X
unit.
A
A
C
So,
like
your
artifacts
that
are
produced
from
these
are
usually
files
or
like
are
out,
you
know
lock
what's
important
about.
This
is
basically
the
the
format
right
like
you
get
these
kind
of
like
an
XML
type
of
a
file
that
it's
possible
when
you
can
like
use
that
later,
to
show
it
in
a
more
like,
so
when
in
a
graph
like
show
it
somewhere,
you
know
it's
a
that's
cool.
C
C
So
I'm
gonna
be
sharing
some
designs
and
I
need
to
give
a
little
bit
of
extra
context
before
I
actually
jump
into
this
I
know
when
I
talk
over
this.
So
yes,
I,
said
to
selenium
is
like
a
part
of
this.
You
know.
So
what
we're
working
on
on
testing
is
basically
testing
right
now
on
get
lab.
Has
the
ability
of
using
selenium
right
so
there's
a
selenium
server
that
you
can
there's
ways
to
actually
test
against
selenium,
so
you
can
bring
selenium
into
your
testing.
C
So,
as
you
know,
like
every
job
that
you
run
in
get
lab
is
going
to
produce
an
artifact.
In
this
particular
case,
the
artifacts
that
are
produced
by
selenium
job
are
the
X.
You
need
report
and
I,
sometimes
the
screenshots
and
that's
an
important
part
of
what
I'm
gonna
be
talking
about.
So
sometimes
the
jobs
like
the
selenium
job
is
gonna
screenshot.
The
browser
to
see
like
basically
like
a
B
for
regression
I
like
to
find
an
issue,
usually
most
QA
people
or
like
people
were
writing,
assists
this
free
shot
at
failure
time.
C
C
As
you
guys
know,
there's
a
when
when
you
go
into
the
CI
CD
area
and
get
lab
and
you
go
to
the
jobs
and
you
click
in
a
job.
Usually
what
you
will
see
is
what
you'll
see
it's
basically
this
view,
but
with
a
runner
with
the
runner
lover,
so
the
runner
lover
is
gonna.
Show
you
all
the
things
that
happen
in
that
job.
It's
gonna
like
show
some
logs,
usually
when
you
are
like
running
tests
like
r-spec
tests
or
whatever
it
tells
you
what's
failing.
C
What's
passing
in
the
context
of
that,
the
problem
with
what
the
way
that
we
currently
do,
selenium
tests
is
like,
first
of
all,
it's
very
hard
to
parse
that
data
that
is
being
showing
the
runner,
logger
and
second
of
all,
like
sometimes
like
the
screenshots,
are
extremely
important
to
see.
What's
going
on
all
right
and
the
way
that
you
currently
find
those
issues
in
like
those
artifacts
like
those
screenshots,
is
by
basically
browsing
the
artifact
and
then
like
it's
basically
hidden
into
like
multiple
folders
down
or
you
got
a
download
the
artifact.
C
And
then
you
gotta
do
the
same
in
your
machine.
Just
to
see
an
image
which
is
very
painful
right
like
that,
doesn't
make
too
much
sense
and
then
the
other
thing
is
that
the
X
unit
report
by
itself-
it's
also
not
very
helpful,
because
you
also
have
to
download
it
or
you
also
have
to
open
it
in
your
browser.
You
have
to
expect
what's
going
on
and
fight
the
issues,
so
it's
not
super
efficient.
So
what
we're
doing
in
testing
is
like
okay.
We
know
that
this
is
a
very
important
part
of
testing.
C
C
So
this
is
basically
the
bean
like
there's
many
things
going
on
here,
so
I'm
gonna
start
from
the
top,
so
the
first
thing
that
I
actually
talked
with
Nattie
about
these,
but
the
the
first
thing
that
I'm
doing
here
is
that
I
created
these
tabs
so
like
the
runner
locks,
will
be
the
classic
view
where
you
will
see
the
runner
logger
and
then
there
will
be
disturbed.
It's
called
a
selenium
job.
Summary
the
text
is
indicative,
like
it
doesn't
mean
that
that's
gonna
be
the
final
name
by
like
that.
C
For
the
sake
of
the
of
the
explanation,
that's
the
name
and
then
there's
gonna,
be
this
module,
that's
basically
showing
everything
that
happened
on
the
selenium
test
right.
So
if
your
selenium
test
has
multiple
sessions,
you
can
change
the
sessions
here.
Maybe
you're
running
sessions
again
is
Firefox
and
Chrome
or
different
versions
of
Chrome.
C
And
then
you
could
change
those
there
right
and
then
we
have
these
filters
right
so
like
basically,
what
you
can
do
here
is
I
can
filter
by
status.
One
thing
that
I
did
here
is
hide
the
past,
because
sometimes
as
I
as
a
developer
or
a
tester,
you
don't
care
about
the
past.
We
tell
you
care
about
the
failed
right.
C
So
if
you,
if
you
click
this
toggle,
that
will
like
hide
all
the
past
tests
and
you
will
just
show
the
little
ones
and
then
there's
this
toggle
expand
screenshot,
we
I'm
gonna,
show
you
a
little
bit
of
white
dust
and
then
like
there's
this
summary
of
the
test
right,
like
there's.
Nine
tests
like
four
fail.
Five
pass
right.
C
These
styles,
like
I,
got
these
from
like
an
other
dashboard,
the
security
dashboard,
so
like
I'm
kind
of
trying
to
stay
like
through
to
what
we
already
do
in
other
places
in
Hitler,
so
yeah
I
didn't
come
up
with
these,
just
if
people
were
wondering
and
then
like.
Finally,
we
have
the
like
the
two
beers
like.
Why
is
the
rich,
like
the
rich
view
is
gonna?
C
C
You
can
basically
like
stand
it,
and
she
like,
like
that,
my
what
I'm
thinking
is
that,
ideally
initially,
this
is
always
toggled
on
like
this
expand
screenshots.
So
what
that
means
is
that
every
time
that
you
open
this
view,
you're
gonna
see
all
the
expanded
screenshots
on
right
so
like
in
this
case,
we
with
two
two
screenshots
in
two
failed
cases,
and
then
we
have
the
screenshot.
We
have
the
URL
so
like
if
you're
running
the
issue.
C
Of
course,
if
you
close
these
like,
if
you
click
these
and
like
it
closes
this,
if
you
click
one
of
these
guys,
they're
like
it
just
expands
that
one,
so
that's
pretty
much
the
instructions
and
then
the
other
part
of
this
is
seen
the
raw
logs
so
like
this
is
like
an
enriched
view,
but
maybe
sometimes
you
want
to
see
like
the
wrong
things
of
what
happened.
So
in
this
particular
case,
this
is
showing
similar
to
the
logger
is
showing
like
all
the
locks
on
like
I
robbed
you
right.
C
So
sometimes
it
is
important
as
well,
because
you
want
to
find
like
some
new
answer.
I
still,
don't
know
if
we're
gonna
like
show
it
like
this
plane
or
like
we're.
Gonna
have
like
some
flavor
to
these,
but
either
way
I.
Think,
like
that's
like
the
whole
point
of
the
role
is
just
getting
the
the
log
as
deep
as
it
is.
So
that's
that's
what
we'll
be
showing
here.
C
C
The
other
thing
that
I
wanted
to
show
is
like
this
treatment
right
so
and
I
talked
with
not
about
these
last
week,
so
she
suggested
the
the
tabs
and
that's
what
I
did
and
I'm
kinda
happy
with
the
tabs.
However,
I
was
exploring
another
way
of
doing
it,
which
is
it's
not
do
tabs.
Let's
basically
have
the
two
modules
in
just
one
view.
C
So
in
this
case
what
I
was
thinking
is
the
runner
lock
could
be.
What
we
could
do
is
basically
collapse
these
and
then
like.
If
you
need
to
sweep
see
this
for
me,
then
you
can
expand
it
and
then
you
can
also
kind
of
like
basically
collapse
this
one.
So
this
by
default,
when
it's
a
selenium
job
like
this
one
will
be
collapsed
and
this
one
will
be
expand,
but
you
can
you
you
could
play
with
a
that.
You
can
basically
no
I
don't
want
to
see
these
I
just
want
to
see.
You
know
maybe.
A
D
E
D
C
I
was
kind
of
leaning
to
that
at
the
beginning,
however,
like
I
also
don't
like
I
agree
with
you
like
this
can
be
confusing,
but
I
also
feel
that
there's
gonna
be
instances
in
which
we
cannot
skate
this
pattern
of
like
tab
and
tab.
I
think
what
I
told
Nadia
last
week
we
were
talking
about
is
like
we
should
probably
like
somewhere
in
pajamas,
specify
the
like.
You
shouldn't,
never
do
more
than
three.
You
know
like.
Maybe
two
is
the
top.
You
know
but
see
I'm,
not
saying
that
this
is
not
good.
A
Was
when
I
wouldn't
move
in
earlier
talking
was
fun.
Is
that
what
if,
for
example,
a
browser
is
remembering
that
collapsing
and
collapsing
state
and
if
you
would
have
the
first
like
when
you
say
the
first
component
and
collapse
and
you
basically
by
default
missing,
what's
downstairs?
This
is
why
I'm
not
a
big
fan
of
this
collapse
and
collapse,
components
but
yeah,
but
I'm
also
not
sure
if
you're
using
and
you're
remembering
states.
F
D
C
Now,
that's
that's
a
great
question.
I
think
that
okay,
so
prior
art,
like
things
up,
were
like
don't
before
my
time
here
and
like
that
we're
touching
on
this
topic.
They
didn't
have
the
runner
locks
and
the
I'm
talking
about
like
customer,
provided
marks
right
like
contributions
from
the
community,
so
I
think,
like
implicitly,
I.
Believe
people
don't
care
too
much
about
the
runner
locks.
C
If
you
have
the
selenium
job
summary,
however,
I
don't
think
that
that's
a
good
reason
for
like
hiding
them
like
removing
them
or
not,
showing
them,
because
the
runner
locks
are
also
showing
you
behavior,
that
happens
outside
of
the
selenium
before
you
load,
selenium,
there's
other
stuff
happening
right,
like
selenium,
is
being
downloaded.
The
container
is
being
like
configure,
there's
many
things
so
like
the
runner
locks
are
still
important
when
you
are
debugging
the
job
or
when
you're
setting
up
the
job.
C
When
you
were
like
trying
to
like
debug
the
whole
pipeline,
and
you
know
so,
I
I,
don't
think
I,
don't
think
it's
a
good
idea
to
like
dip
like
demote.
The
importance
of
them
like
at
least
not
like
in
a
major
way.
So
I
think
like
it's
either
like
taps
right,
I,
don't
know
but
again
I
get
the
nature
of
your
and
I
know
where
you're
going,
but.
B
Can
it
be
perhaps
be
separated
out
my
personas
using
it
so
yeah
there's
a
set
up
persona
person
who
actually
sets
up
the
selenium
tests
and
then
there's
the
consumer
persona
who
actually
you
consume
the
test
on
a
regular
basis
which
would
be
similar
as,
for
example,
setting
up
CI
is
not
the
same
persona
as
the
one
that
extry
is
going
to
let
their
code
test.
There's
a
separation.
C
Like
there's
like
there's,
definitely
like
persona
like
different
personas
that,
like
like
there's,
definitely
like
one
type
of
person
of
them,
will
benefit
out
of
lock
and
there's.
Definitely
one
persona
will
be
like
I.
Don't
care
about
these?
What
I'm,
not
entirely
sure,
is
how
do
we
currently
differentiate
that
at
the
app
level
you
know
at
the
UI
configurable
UI,
basically
like
a
yeah
which.
B
We
do
not
support
that,
so
get
lobbies
a
it
fits
everyone
and
you
just
use
the
features
that
are.
You
know
useful
to
you.
There's
no
personalization
of
you
know
features
become
visible
to
only
you,
for
example,
as
being
a
support
engineer
at
a
you
only
interested
in
certain
things
versus
you
know,
a
designer
who
is
only
going
to
be
interested
in
in
in
in
mostly
issues,
but
still
really
there's
always
going
to
be
some
overlap.
B
C
C
I,
don't
think
it's
a
big
deal
to
do
it
this
way,
either
at
the
end
of
the
day,
what's
gonna
happen,
like
it's
kinda
like
coming
back
to
what
you're
saying
Demetri
the
persona
its
owns
at
this
level,
it's
almost
gonna
dilute
completely
because
once
you
click
on
a
selenium
job,
almost
everyone
has
the
same
goal,
which
is
like
see.
What
happens
if
you
happen
to
be
like
a
DevOps
engineer
needs
to
be
bucked.
The
job
you're
gonna
find
the
runner
locks
fight.
C
E
And
I
hate
to
point
out
a
problem
without
a
suggestion
on
how
to
solve
it,
but
there
is
a
bit
of
a
namespace
collision
here
in
so
now
you
have
passed
and
failed
of
the
selenium
tests,
but
the
test
itself
has
a
pass
and
failed
as
well.
So
I
don't
know
how
to
solve
that.
But
there
could
be
definitely
some
confusion
about.
What's
like
what
is
passed
mean,
does
it
mean
to
pass
all
those
pasts
or
does
it
mean
it
successfully
ran?
Yes,.
C
C
C
That's
an
excellent
question
that
I'm
going
to
answer
in
just
like
30
seconds,
some
like
ideally
the
ideally
the
job.
If
it
fails
here,
it
should
report
back
to
like
the
upper
job
that
it
fails
like
they
should
be
failed.
So
you
and
no
instance,
you
should
have
like
fail
or
fail
things
here
that
pass
here.
So
I
didn't
maybe
like
a
defect
of
the
mark,
but
there
could
be
situations
in
which,
like
he's
passed
on
like
there's,
failed
things
and
I
need
more
into
that.
B
Have
a
quick
one
to
consider,
but
let's,
let's
not
dive
into
it.
In
that
case
we
have
the
other
meaty,
but
the
UX
raw
or
the
raw
output
of
the
case
you
scroll
to
the
right.
So
here
you
have
the
raw
output.
Isn't
that
the
same
as
the
runner
logs
to
some
extent
is
a
duplication
of
contents
and
in
that
way
exactly
what
is
it
mean
it?
You
just
show
the
rich
rich
version
and
that
developer
that
sets
it
up
has
enough
with
the
rim
of
logs
and
so
yeah.