Test Studio Tutorial - Random Word Extract Contact Creation Video Lecture | Telerik TestStudio:Automated Testing made Easy - Software Testing

test studio by progress built with our
patented art of test free one and
Fiddler's core in this episode random
word extraction and passing variables in
today's session we're gonna be reviewing
an old favorite random word extraction
to create contacts in a sample CRM so
this will illustrate the use of test
2-step capabilities extracting variables
runtime variables from a live UI and
then using those to data drive inputs
passing the variables from one test to
the next so things that are very common
requests that we get also it illustrates
the use of a code list setup routine and
as the perpetual data option as well
so that's what we're gonna do we're
gonna build out three quick tests here
so I'll just start by with my add new
tests for web tests and this will be my
basic login and for this we'll just go
ahead and right click and hit record on
the basic login I already got the URL in
here so we'll just go ahead and choose
the URL or if you're new to that type
the URL and personally I do most of my
recording and in IE I can use Firefox
and Chrome sometimes but I find that the
element highlighter is best quickest and
easiest to work with I think and ie
personally that's my decision but will
it record that'll start the recording
process on my other screen here we'll
get it over onto this screen momentarily
now we're in a live record mode the
recorder is attached at the bottom shows
that we are currently recording and we
can pause and we can resume recording we
can operate the highlight element or the
element highlighter also there's lots of
things down here in the tool bar
generally speaking when we talk about
the test studio recording toolbar it's
this attachment this can also be docked
and undocked from the browser
of course we have the main website body
here and then the background I've got my
test studio test already open it's
captured that navigate step that we have
chosen and we're in a live record mode
so we'll just carry out the test
generally speaking as a best practice
you want to don't skip anything
don't take any shortcuts when you're
creating a test you don't want to do
autocompletes they don't typically carry
over from one browser to the next and we
are building cross browser compatible
tests so make sure you just give it the
full information there also you don't
need the tab that is something that we
do is users a lot of times but for test
creation part that's not necessary and
all you need to do is just click into a
field and type we will capture tab keys
there are just extra steps so you can
always leave them in there they won't
really do anything for you and then of
course clicking enter versus clicking
login you know you typically want to use
a mouse click instead of a keyboard
stroke just generally for for web
automation so those are a couple best
practices to point out along the way and
I've got a log in and of course what
good is a test without a verification to
prove if it's exceeded so quickly we'll
just create a verification to verify in
this case that the word logout is
visible and that becomes my verification
to prove that we've successfully logged
in right that'll also avoid some false
positives now for this application
there's a JavaScript handler I already
know about on the password field we're
going to go ahead and simulate real
typing for that and that will instrument
that correctly so there's our first sub
test and actually this will become our
second sub test but we're going to
create another one here which is to
create a contact
and we'll go ahead and just double click
into this to open it up now we have two
different tabs open and we've captured
the majority of this test over here so
far well now we're gonna continue
recording over here and what I'm doing
is basically leaving behind a nice
modularized login process that we'll use
later on and we can use in other tests
as well using tests to step but create a
contact will just pick up where we left
off in the recording browser and this is
just gonna take place at the bottom here
one thing I like to do when starting
into a test that relies on another test
we typically like to start with a
verification so let me just verify
before I try to do anything that this
element is visible the new contact
button ultimately that's what I'm going
to click so I'll turn off my element
highlighter we'll go ahead and click new
contact
this opens a pop-up in my application so
we'll see the recorder connect to the
pop-up
and what's that recording toolbar is
attached to the window will now be
capturing things inside this windows
well be aware that when you have a
pop-up window you should see a connect
pop-up window step record it and also be
aware that there may be dynamic
components within pop-up window URLs so
feel free if necessary if you need to be
a little bit more generic you can make
sure to use a partial and maybe trim any
kind of dynamic portion that might be
there that way we can continue to
connect to the pop-up window even though
there may be like a dynamic ID that
changes at the end okay all sorts of
settings in more details that you find
in our documentation on that but for now
we're gonna just jump back in here and
keep going creating a contact and this
is where we're gonna provide the first
name the last name there we go an email
address and we'll go ahead and hit
create contact at this point okay
now this is of course my issue with my
little application here but all the
things that we need are accomplished
within the test here so we'll go ahead
and close the recorder recording browser
here and that ends the recording for us
so we went through we log in to an
application and then in the next sub
test we create a user opening a pop-up
filling out first and last name email
which it looks like that did not oh
that's the click on email let's get into
the value for some reason didn't want to
capture that so let me go ahead and add
that in here there wheel and then submit
and then we close the pop-up so very
basic process what happens after that I
really don't care about right now but
this is what I want to show you is
actually data driving the first name in
the last name with randomly generated
names okay and we're going to get those
from another test so now we have a
complete process that's kind of spread
between two different sub tests here we
need one more test to help us which will
be the test that gives us the first and
last name so we'll go over here we'll
add a new test still a web test and this
will be my random word extraction now of
course you can generate random words
random variables datasets like that
through code of course tester you can
always do things through code it's just
behind the the steps here but it's
typically a rat a last resort we don't
most of the time don't need to use code
we try to minimize the code burden as
much as possible so we've got this
tooling built out for you to be able to
modify and maintain and create these
tests as code lessly as possible this
random word extraction represents one of
those options take it or leave it some
people like to go through code to do the
same thing but this is a setup routine
that I'm going to create and we'll jump
into this test we'll do record here
let's see do I have the appropriate URL
and I don't but I know where I can find
it I can actually find it in our
documentation in fact let me just jump
back I'll show you where to find the
documentation from the very beginning
which is to start from your help drop
down at the top there's tons of things
up here by the way our forums our
feedback portal if you want to vote on
what to do next in test studio please go
to submit feedback that's a great portal
you'll find our developers are in there
a lot of times to interacting with you
submitting tickets to support of course
if you need help with that and the user
guide of course is where I'm heading so
this pops up our online user guide if
you haven't used it before and it is
searchable
so for this I'm gonna do an extract
right so we'll type an extract and you
have create an extraction step and in
fact as you can see here there's an
example that uses this random word
generating website and that's the actual
site that I'm going to use myself so now
I have it you can see this is a PHP
application as well so now that I have
that borrowing that from our
documentation we'll come back here we'll
hit record and I've got a URL to paste
in there and will it record here and
we're off for running so this is a
really basic test in this test we're
just going to go to this random where
general website it's gonna spit out a
word for us eventually
if we want to we can even do a
verification to say wait until this
element goes away so we'll do that in
case it takes too long
that's a 30-second timeout to say wait
for that loading gif image to go away
before trying to do the next thing but I
have a feeling if I click that generator
in a ward button it might kick it into
gear here so there we go so we generate
the random work with the element
highlighter we can go float over that
area and this is a great way to learn
something learn about your application
and how test studio sees your
application turn on the element
highlighter and float around over the
elements of your application your
webpage you know I would recommend doing
this part in in IE you can do the same
thing in Chrome and Firefox but ie has a
little bit better way of giving you some
extrapolation of layers when there are
certain layers like a tree or a grid for
example and I'll show you that but for
this case what we want is just to flow
over this we're looking also this is a
large area that we're looking at but I
want to see in quick steps does it
contain the value I'm after and only
that value is there some way I can go
grab that particular value and it is
there so we don't want to verify it we
want to do is extract it so down here
when you float over with a highlighter
you've got your verifications your
weights and extracts and extract text
contains those are all right now the
important part to doing an extract step
is you are gonna get a runtime variable
out of it and you get to name that
variable whatever you'd like so we'll
call this random more than one there we
go but you also need to make sure that
where you're extracting your variable
from is not using the variable as an
identifier what does that mean well
here's the current fine logic the test
to do is using to locate that particular
element in the element in question
should be highlighting over here
which is this guy so currently it is
using the IDE combined with the tag name
and that is enough information to go
find it once we find it we extract its
text content at runtime well right now
that is this what I want to make sure of
is I don't want to use this to try to
find it because next time it's going to
be different it's not going to be the
sixth and we're not going to be able to
find whatever that is so when you're
doing an extraction you want to use
identification logic that's more generic
and maybe more position based versus
those that might be more content-based
okay so we've got good logic there and
of course if it's affecting multiple
tests you can make sure to update all
tests that are using that same element
across your project right so I just
updated all the tests that use that
element as well so we navigate we wait
we extract let's go ahead and just
repeat the process here let's see we're
highlighting or we're a turn off the
highlighter we'll hit generate random
word oops let me resume recording
they're real and so there's our submit
button I could also make sure to do that
right after the navigate it should load
the initial word more quickly but if we
want to it will just go copy and paste
this step in fact and we'll drag and
drop one of those up above so we'll
navigate we'll click yeah I guess I'll
throw this weight in there as well if we
need to and we'll do it there and then
we'll extract whatever's there and then
we'll click again and then we'll extract
that again so we'll just copy paste we
don't necessarily need to go back
because we're getting it from the same
place else we'll copy paste that step
and we'll just call this one random word
too and that's it for my test okay now
if we were to continue making some steps
here against this test like let's say we
were to back at the UI level here maybe
go do something else we'll do a quick
verification for instance you'll notice
that the steps that follow extraction in
the properties of the test step at the
top there's bindings and when there's a
data source inside the test you'll see
that it lives here it's in the drop-down
I can actually take what was extracted
in Step four and use that in step seven
or somewhere later in this test so
that's normally how extraction variables
become available following the
extraction step so if you have a test
that needs to extract a random variable
or a dynamic variable or an ID of some
kind from the UI at the creation phase
and you want to use that same item
throughout your crud operation you can
extract it into a variable and then feed
that back into that same test later on
just by using by selecting it and
setting it and then you basically
data-driven that interaction whether
it's an input or verification or even
data driven fine logic but for now
that's all we need from this test we've
created the variables we've created the
login we've created the contacts so I've
got my three different components I'm
going to add a fourth test here and this
will be my master so this will be my
master test and within this test I will
now bring together my sub tests okay and
this is important because this will
allow me to share the data from one test
to the next so first of all let me go
ahead and open up my master test it's
just a blank test here and using test
two step which is in the common section
of the step builder menu up at the top
we can go find all the existing tests
within our project these are all of my
tests my project I'm sure I have more
than one that's called basic login but
only one in this particular folder that
we're working out of so we'll select
that oops I almost forgot to throw in my
random word extract which needs to
happen first before we do the contact
creation process and actually before we
do the login to so let me go ahead and
get the random word extraction and of
course I've got a few of those as well
but we'll draw that above the login and
then last but not least our create a
contact okay so those are now are three
different sub tests under one master
test using tests two-step so you can
modularize these components especially
things like a login or logout and build
up many different scenarios from there
now that we've accomplished that we can
tie these two together we can take the
random extracted data from test number
one and utilize it in tests subtest
number three and the way we do that it's
basically the first part of that is done
by having them under the same common
test or relating the
some way as sisters or or children to
each other
akin a second we can go into the random
contact create then here is where we're
actually going to be data driving the
test steps so we'll highlight the test
step in question and under the bindings
properties you'll notice that there are
no drop-down variables here and that's
okay that's actually natural because
there are no variables associated to
this test itself we we haven't attached
datasource to it there are no
extractions inside of this particular
test so there is nothing in that
drop-down but there is the ability here
to call out across the tests across the
master test to say we need random word
one from that basic or from that random
word extraction test and if I've spelled
that correctly usually what I'll
typically do is go over to my test and
just copy and paste it out of here right
up this one here looks right but just in
case yeah cool so we've set that and
then on the last name we'll do the same
again this time though random word too
and we'll set that okay so now we have a
dynamically data-driven contact creation
process we'll go back to our master test
I'm going to turn on annotation here so
it slows down the playback and that also
initiates this 400 milliseconds between
test steps that's what that does and
you'll see the annotation as it starts
up here but we'll watch this now and
we'll run this here in Firefox I suppose
of course we'll want to run it across
all of them at some point maybe from a
test list and we'll see how we do
so the
annotation is going to show us step by
step and also down at the bottom it has
the step by step as well so there's our
first word or second word bonk an unsung
song French words they're up there's
three looks now we're in subtest two
we're logging in and here comes the
simulate real typing for the password
you'll notice it types in each character
rather than pasting in the entire string
which enables the login correctly and
allows me to login successfully now
we'll go into the third subtest to
create a contact and we should see our
old friends the extracted values from
subtest one as the first and last name
ensembl fillet list
voila so that is how you can accomplish
extraction using a UI but like this tool
here I've done many of these as well for
date calculators as well you know feel
free to reach out if you're interested
in something like that but some of our
airline customers utilize those very
same types of setups set up routines to
go and get dates calculate 60 days out
calculate 70 days out extract those or
go get today's date so there's lots of
different things you can do to automate
your setup routines to get your data
together in a way that's always going to
be fresh okay once I create that random
word contact creation process I can set
that on a cycle on a if I wanted to a
hourly cycle and have it create a new
random contact every hour and it'll
probably just keep running I don't know
when that would run out or if that would
ever run out of random words to use
right of course it probably fill up a
database eventually but lots of
different things you can do that really
just shows you I think a lot of the
flexibility of extraction and passing a
variable there is also an article on
this as I mentioned with the random word
generator here that we have
in our documentation we also have sorry
if I can find the appropriate browser
window but we also have document
specifically on the passing of a
variable as well maybe I'll go ahead and
just pull that back up there it is and
this talks about that as well using
extraction using tests this step the
parent the child kind of relationship
there this actually talks about exactly
what we've just done using that random
we're generating kind of option there
and essentially how you can pass that
from one test to the next so stay tuned
for more hopefully that helps you on
your journey of learning test studio and
learning how you can work with the tool
and build out some tests pretty quickly
and easily they're very powerful thanks
for checking it out and have a great day