Auto news on Youtube Mar 30 2018

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

For more infomation >> Setting Up Your Data & Prepping Your Environment: How to Build a Successful UI Automation Framework - Duration: 8:50.

-------------------------------------------

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

For more infomation >> Parent Hack | How to build a kids toolbox set - DIY - Duration: 3:50.

-------------------------------------------

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!

For more infomation >> How to build a LEGO Spaceship! - Duration: 2:15.

-------------------------------------------

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

For more infomation >> Getting Started in TestComplete: How to Build a Successful UI Automation Framework - Duration: 4:54.

-------------------------------------------

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