So I'm going to move on to some on-screen actions. So at this point we
have our environment setup and teardown taken care of, we have our basic
navigation of opening and closing notepad and getting the data that we
need to test the application. So now that we've done that you can see I have two
more utilities created here: one is input test data, one is a utility to interact
with the save dialog that appears, and one is to complete saving the data to a
file. So again, we've abstracted the actual logic of these so the
individual tests don't have to use this it's really just building the data
putting together the building blocks to create the test based off the utilities
that are created in the framework, and, as you can see, our get test data is being
passed around through the different utilities and it will basically what's
gonna happen here is when we get the data we assign certain things of the
data that are our input steps and so the utility here actually just sleeps
through all of our input data and then does a verification if you want it to.
And so this is what I'm saying if you need to add another column or more data
to your input you don't ever have to go update a single test you just need to
add a new line to your class for your test data object kind of same with the
save dialog we are abstracting the logic into the the framework so the main
options are save, don't save, cancel, none, and so this allows you know say the
dialog changes say it's you know not a dialog it's a new screen on the
application or something like that you can go and update these to just change
it in one spot and then all your tests that need to verify that something is
saved they still work again without having to worry about the logic. The
framework handles the logic and let's see we don't have any
verifications yet but we do have a few more things added to our contest
starting on test stop because we are now starting to get to the point where we
can actually save stuff and we're going to move on to verifications. This is
another part of environment setup and teardown and make sure the path that
we're going to save our results to is clean and empty so we don't run into any
overwrite errors or anything like that. I've also added a few extra utilities in
here it'll indent and outdent the log and add log folders for you,
logging our return data from our test data and added a few more things to our
setup environment and these are all still being used around everything else.
So at this point we can actually open up our smoke tests and you'll be able to
see that I have a few smoke tests created. So we have the verify open and
close, verify inputs text correctly, and verify that you can save. And if you
noticed none of these have any individual according we're just calling
the utilities and passing the data around
For more infomation >> Using On-Screen Actions: How to Build a Successful UI Automation Framework | TestComplete - Duration: 3:38.-------------------------------------------
How to Build a e-bike Battery pack from 18650 Li ion cells - DIY - Duration: 8:53.
For more infomation >> How to Build a e-bike Battery pack from 18650 Li ion cells - DIY - Duration: 8:53. -------------------------------------------
Setting Up Your Data & Prepping Your Environment: How to Build a Successful UI Automation Framework - Duration: 8:50.
So we're getting started if you look here in the source control repository I
have - I'm using - git which there is also I will post here in a little bit a link to a
github so you guys can pull down all of this info and see the kind of process
that I went through step by step. But the main thing we did here at first is
setting up just basic our basic structure we have our scripts which is
going to house all of our framework scripts so we have actions, data,
event handlers, different utilities, and verification scripts. We have templates
that we create a project template and that adds all of our scripts and our
name mapping files as existing items so you can then go in and clone the
template and it copies all these references so this allows you to update
only one script unit and have it propagate to all of your tests and then
some basic utilities nothing in here yet so the first step that I was talking
about is to get familiar with the application. So for my example I'm using
today I'm using notepad and then later I'll be using notepad plus plus to show
you how easy it is to switch between different versions and environments of
the application. So for today let's just assume the only requirement we have is
that you can pull test data, type it in, verify that what is on screen matches
what you typed in, that you can open and close the application, or you can save
what you typed in. And so we're gonna walk through process to create these
utilities that we need to make this happen. As you can see the first part
just kind of getting familiar with the application, I went through and just did
a straight record of all of the different elements that we're gonna be
interacting with just so I can kind of get an idea of what we're gonna be
working with here. So you know we can see how our menus are set up we can see that
we actually have a window edit the process name for notepad so on and so
forth. So let me go ahead and check out the branch where we have a little bit more
stuff going on a little more meat in our project here. So you can see here now we
have a smoke test project like I was saying that'll probably be one of the
first sets of tests that you want to create. We have a few more things in our
utilities now and we still have the same scripts that we had earlier. So in this
part you can see that we still don't have anything in action so we're not
even to on-screen actions yet but we do have some eventhandler stubbed out, we
have nothing else in the script genius yet. So we do have a name mapping
and what I've gone through is mapped the different elements of the test you can
see they're still hard-coded to very specific areas. The problem with this is if
we ever decided to run in a new environment or a you know different
version of the application and they put some different elements in between our
main window and our edit fields this test it's going to fail because it's
hard-coded to expect a certain way. So moving on to the next part we'll get
into the really fun stuff and that's setting up your data and prepping for
your environment so for the sake of time I'm going to skip through the first
couple parts of it and just get it to where we have some stuff working.
So you can see here now the name mapping that we had before we actually have
project variables set for the identification properties of some of
these. And this comes into play because the next part is setting up our
environment so you'll see I've used event handlers here. TestComplete's built
in a vest event handlers for starting the test and stopping the test and these
will fire off from a minute you could play until the test is from how many you
play it'll call the start start notepad test and when it stops it'll called the
stop notepad test. There's nothing in here right now what you do see we have
something in our utilities and it's called set up environment and so
basically what we have is a script here that will pull our environment data
based on two different versions of the application dev and test so I have pass
to our config files and we actually I'm using a Windows environment variables so
you can set this remotely you can set it to dev or test and then when you do that
it will open up or it will assign project variables to things like our
main app path the process we're expecting main window so on and so forth.
You don't have to use a config file the way I did you can pull it from database.
There's several different ways you can go about it but the main
important thing is to make sure that your tests can switch between
environments easily inside actions we have our open Notepad and close notepad
and what I did here is actually made both of these have an optional parameter
it's called verify so what this does is you'll see when we add test items later
the first one we're going to run first no custom verify the app can be open and
closed if it fails at any point in that then we'll stop the project log and say
hey there's no point running the rest of these tests because we can't even open
the application now. The thing is once you've ran that test you verify opens
you're not necessarily going to want to have to run those checkpoints every
single time it adds more time to the test it's really unneeded so that's why this
can be set to false and then it will just open the application and not try to
verify its existence. Down here you can see I've already started stubbing out
some actions for our main menu and so the like I said earlier our requirements
for this test for this application is just that you can open the application,
you can exit the application, and you can save. And the reason I set it up
with a JavaScript class for the properties for like the menu options and
everything like that it's so that your test can just call the, "hey, I want to do
the navigation option to save my document" well if that ever changes or
moves to a different menu or there's another dialog that pops up in there as
you're going through that process all you've got to do is update this one area.
Your logging stays consistent, you can now have your new path set up to
navigate to that part of the application and all of your tests are working again
without ever having to go touch an individual test.
Like I said, routine building blocks for tests here not the project for the tests
themselves so you can see we haven't added anything else to any of our other
tests yet except our data so we're gonna be inputting data and again here you
want to make sure your tests aren't responsible for the logic of getting
data all they need to be able to do is call a utility that returns the data
that you're expecting. I used classes here again and I'm setting I've set it
up to connect to an excel sheet as a database that's why you have the
different select statements here when the main reason I do it as an object or
a class in here as opposed to just referencing the data itself is you know
what happens if they decide they need to change a column name or what happens if
they say hey we need another column in our data in our environment
well the nice thing is if that happens all you have to do is just go modify
this one spot and it'll look through all the columns that you're inputting
without having to model by the tests themselves. I'll show a
little bit more about that here in a minute so that's kind of a basic set up
for our data and environment setup
-------------------------------------------
Parent Hack | How to build a kids toolbox set - DIY - Duration: 3:50.
today's parrot hack is about tools kids tools and playsets
that maybe your your kids are starting to get into this just like our kids are
I know Boston is he you know started getting into the timeframe of chasing me
around the house as I'm trying to repair a chair or fix a fix a table or a door
handle or something like that he's wanting to get all his little tool sets
like this and follow me around and he just you know eats that up that time
with Daddy so I'm making go Walmart you can go to you know Toys R Us and get you
know the Stanley the Black & Decker like these guys you know I don't Black &
Decker or something little kids tool sets but those kind of
get expensive you know 30 40 50 bucks and they just don't have the same effect
that the real tools have that he always wants to grab my drill and try to use it
so we came up with you know a nifty little trick here that as I ended up
using say screws or bolts or nails from the hardware store I just gave him my
empty box and so now he can put his little trinkets and Legos and anything
else that he wants to think that he's building and working on he can put it
right in this authentic you know box that's not a toy per se here were some
drill bits from you know craftsman another little thing I don't need it
anymore gave it to him this little container here used to have a bunch of
drill bits in it twenty-nine piece drill bits from Harbor Freight I organized my
drill bits in a different way in my shop so this box was going to get thrown away
I said well why not give it to Boston let him use this and he can really think
that he's got internal bits in here and he's you know going to town drilling
holes and all the furniture around this here I upgraded how I organized my drill
bits you know select a wall you know these are 10 bucks or something but set
it throwing it away I just gave it to him he can throw some more stuff in here
again it's the real deal for him he loves it and of course you know with
every home you know maintenance project you got to have safety glasses so we
just went ahead and got him the real safety glasses and you know he wears
these all the time he'll wear them even outside in the you know to the grocery
store even though he's not working he loves them so much
a couple other pair of hacks here for his tool kit which you know you can get
this little flashlight like this you know this is cool he loves that one but
let me tell you if you can get him this two dollar flashlight you know online or
from the hardware store at the checkout line get him one like this that you know
well it doesn't have batteries now but he just goes to town on this he loves it
it's the real flashlight you know some people call these Gator Clips potato
potato chip clips or whatever again he can just clip it on the stuff cost us
nothing these were giveaways at a trade show or something and he just he loves
them he can clip them on everything had a few extra bags you know accessory bags
that I got from the hardware store you know usually you can put a few things in
here and also in your tool bag or your your toolbox or whatnot but same thing
with him so I hope you all like these parent packs and you know stay tuned if
you want to learn more subscribe actually subscribe over here and we'll
put a few links down below to where we got some of those tools if you want to
pick them up talk to you soon
-------------------------------------------
How to build a LEGO Spaceship! - Duration: 2:15.
Hey guys, welcome to our channel,
and today we are going to show you how to build a LEGO spaceship.
the first piece we will need is this boat piece right here,
i dont actually know what its called, but it looks like this, so, (inhales for some reason) anyway
the next piece we will need is a 2x1 grey piece,
that goes right there in the middle of these six studs.
the next piece we will need is this inverted slope, that goes right there, along with a clawed 2x1 grey piece there
those go on the clawed piece
(this was where the editing got wonky, sorry)
next, we need a L-shaped clear piece, that goes on the clawed piece.
that completes that part of the spaceship.
next we are going to make the wings,
so for the wings, we will need these two grey wing pieces,
these come in most spaceship LEGO sets, they're pretty common
and also we will need two orange pieces.
we are using orange for our spaceship, but you can use any color you like.
so to make the wings, all we are going to do
is slide the orange wing under the grey wing and snap them together like this.
and it edited out that part too, i dont know why.
but, the next piece we will need is a grey 1x4 brick, with studs on the front
and next just a regular 1x4 brick goes behind it like this.
so now for the wings.
the wing that slants to the left goes on the right side, and
the wing that slants to the right goes on the left side.
and all i did here was add two 1x6 orange pieces to hold it all together.
and now i am using two orange wedges,
leaving a 2-stud wide gap in the middle.
and then i am putting a red 2x2 jump plate there, and
putting a red joystick on that.
and that completes our spaceship!
-------------------------------------------
Getting Started in TestComplete: How to Build a Successful UI Automation Framework - Duration: 4:54.
that's kind of what I'm gonna be talking about here today is how to set up a
really good reliable and useful and easily maintainable automation framework
for UI functional tests. So we're gonna what we're gonna talk about here
is the process that goes through it. Automation frameworks kind of follow
the same thing that we're just talking about earlier with define decompose and
decide, so you kind of do the same thing with an automation framework. You
want to keep your actual logic for how the application
flows separated from your individual tests. The main reason for doing this
is it allows you to easily update in one spot if application changes whether it
be how its laid out on screen actual flow for doing common test routines
basically anything so you can update in one spot and however many thousands of
tests you're running are not broken when you get a newer version of your
application. So I'm gonna walk through the agenda here in
the PowerPoint and then I will get into kind of more of a live demo and
presentation for how to actually go about this so first of all you should
always be using source control you want to get your project structure your test
asset structure all of that set up the get-go it'll make your life a lot easier
in the long run if you have a really good organized test asset. You want...
first thing you would want to do is familiarize yourself with
the application do some exploratory testing start working on some basic name
mapping or object identification if you're doing it that way and just kind
of take notes on what your common flows are and what you're going to need to
create as far as utilities for your tests to use. One of the biggest steps
is you know we live in a world where there's all kinds of data being passed
around we're running on different environments especially if you have some
kind of continuous integration set up so the first thing you want to do from the
get-go is make sure that your application can be set up tore down data
can be grabbed from your test databases web
services or however you want to do it and start sitting up a smoke test
project because that's going to be your most ran tests every time you get any
release you're gonna want to be running smoke test before you even kick off the
full regression of your new release. You want to keep kind of your data that
you're getting from the wherever you're pulling it from whether it be an excel
file a test database a love service and kind of abstract that data out into your
own objects with inside of your framework. This allows you to not have to
rely on the layout of the data being static doesn't allow so you didn't have
to rely on it being in the same place all the time and so your tests you focus
more on testing the functionality of the application not the logic behind how to
get the application running in the data you need. On-screen actions we're gonna
do basically the same kind of thing we do with the data we're gonna make sure
that the framework handles all of the actions that you're creating and so when
you get ready to start creating test you don't have to worry about that logic all
you're doing is putting in place different building blocks. I kind
of like to equate a UI automation framework is kind of like a mini
application where you're developing tools for other automation developers to
create the tests any actions that are going to be interacting with your data
you want to be able to use those same data objects that you're creating in
your data scripts so all you have to do is just pass one object around all of
your tests and you always know the data that you're gonna have is going to be
there you can verify your expected results and make sure your application
is meeting its requirements. You're gonna hear me say this a lot make sure
everything kind of interrupts together your verifications you know if you're
grabbing data and putting them into a text field and you want to verify that
the data is written correctly well you don't want to hard-code any of that you
want to use the data that you got and verify the application behaves specific
there behaves to meet the requirements. Again we're still everything kind of
works together we're making building blocks here and I'll show you what is
really useful and why this is a really good idea to do when I get into the live
presentation and then finally if you've set everything up properly it should be
very easy to ajust how you're logging exporting your
your test run logs to a specific network share or web server reporting being able
to send out emails to alert people that you know build failed hey we have
problems we need someone looking at this so that's kind of the the really high
level overview what I'm going to be talking about
-------------------------------------------
Creating Your Tests: How to Build a Successful UI Automation Framework | TestComplete - Duration: 6:46.
Let me go ahead and switch over to a printer that has our verifications
included and I'll show you just how easy it is to start writing tesst once you
have a good framework set up. Okay, so you can see here we have a few more
verifications; we have a new method to our data object that's calls verify
saved data and what that will actually do is take the expected data that is
built from our test data. When we save a file, it'll set properties on this object
to the path that it's safe to and then it will actually verify that the full
contents of the file matched what you typed in so for part of that we also
added in some verify that the files are saved inside of our save dialogue and
saved file scripts it sets properties of the data object that we have and then it
returns it again so I'll show you here just kind of how
easy it is to write a test you need to write a new test all you have to do is
drag over some options so open notepad we will get test data we're gonna get
test data that is a type of company
and if you remember that returns the test data object we're gonna do another
actions and we're gonna say input test data and for the data object we are
going to say that is the last result which was the test "get test data" and
we're also going to say true on this clear option. So basically what that's
going to do is it will clear out anything that is currently in notepad in
case there is and then we're also going to say verify and it will say true to
that and basically what that's going to do is everything we type in there it's
going to verify that it shows up on screen correctly and then for our last
action for this test we will do menu navigation and what was the option I
gave for that how did it go so many navigation and it's just exit that makes
sense. So that brings me actually to a another point that I want to make if you
know. I missed it even for me who wrote this sometimes it gets a little tricky
remembering where certain things live, what they do, what you need to call to do
certain actions on your application, so I highly recommend either building your
own or using some kind of free open-source tool to generate
documentation. I actually use one that's called es doc all you have to do is if
you have node.js installed it's an NPM package and what it does is it'll parse
your block comments and give you a nice clean web page for documenting all of
your framework utilities. So like I saw here the or I mentioned earlier the menu
navigation so it will say hey whether the option is and it's from the nav
options object so you can see here that we have X
and save. So within very little time at all I've created a test here that will
actually open up notepad get test data from our test database and put the data
in and exit the test so if you see here I actually still have that pop-up up so
and that's because I forgot to let's see did I not put that in yet so actually I
shouldn't have done the fall nav option I should have done close notepad because
if you see here that has a default of bypassing the save dialog. So let's go
ahead and remove that guy and do close dialogue or close notepad and if we run
that again it should actually close for us.
there we go so let's do a fun little test here, hopefully that'll work for me
better and then it did this morning when it didn't work for me so let's say we
just got a new version of the application from dev and or the purpose
of this demonstration I'm gonna say that the new version is just notepad plus
plus and so we actually set our environments with Windows environment
variables like I said before and so just to kind of show an example here, here's
what notepad plus plus looks like here's what notepad looks like. Looks like we're
probably not gonna be able to run the same test we just created, right?
So let's try it and see how it works.
And there we go! Aame test completely different application changes were made
to it but because we've set everything right up from the get-go we're still
verifying functionality of that you can see it's still putting in the keyboard
it's still verifying that the everything matches what we want same test exactly
completely new version of application with changes we didn't even have to
update anything except our environment config
Không có nhận xét nào:
Đăng nhận xét