In our last video while we were working the release pipeline we also did the selenium UI test automation
and we also saw that the report was also coming with the runs tab as we saw in our previous video.
So the runs tab actually showed us the exploratory session that happened.
So basically it is not the manual test or any desktops run test which happened basically it is happening
from our pipelines of releases.
So this is where the test actually happened.
And we also saw that report coming in something like this.
And we also saw that it's all gone past which is pretty good and it should feel like we are doing something
on the automation testing side.
And we have some sort of track of what the test is actually doing.
But now that we will go back to our test plan which is available within a year or ops and we'll see
what actually the test plan is actually doing.
So if you remember what we're trying to use this particular test plan in the early sections we saw that
the discipline actually required some sort of licenses like you need to have at least a license or you
need to have an exploratory test so to see this particular tab very with all the details.
We now have the results in the runs.
And that's the reason we are actually seeing this particular test plan itself.
So you can see that now we can able to see what's really happening with our executions and things of
that nature.
But now that if you remember in our previous videos we also created this particular test entire feature
within our feature.
And if we just open this particular test the entire feature you can see that it is currently in the
ready state and you can also see that this particular feature have eyes closed basically while we ran
this particular this particular chicken and you can also see that it has a complete development track
list of what really happened for that particular for that particular feature for the test and diet feature
test case was belonging to this particular Google author mechanism and this particular Google mechanism
actually was part of the feature.
And once we completed this feature it also closed this particular test case and then you can see that
it is completed kind of but you to see that we can also add some sort of test cases in automation so
you can do something like a planned test case for the automation you can do that and also you can add
some test to steps for this particular test cases.
Again this is exactly the same sort of test cases that you can use in the BSD yes or in the Test Manager
of Visual Studio which was there while Visual Studio 2010 released and it's exactly the same in combinations
of the edited versions but just that you can now see that it has even more details of what really happened
with that particular associated work items.
So you can see that it's completing the pull request to us all of the work items so we also did this
particular one once we completed that it just came in here and it also closes this particular test case
so quickly tried to add a few test cases or here and we can also associate this particular test case
with our existing test or something like that.
So you again See you can also associate the automated test if you want or here.
But since we don't really have any I'm not going to be assigning that and now I'm going to say like
open the application navigate all the menu items click the home page verify if the home page exist name
home something like that.
So you can see that if I put this particular at home you can also get that particular stuff in the pad
meters or here.
So basically the at home it turns into a perimeter based value so you can just say at home or something
like that.
So that's what is this.
This particular part of me is going to be doing.
It can also say like new home.
So it's going to run the test for like two times pretty much like how the cucumbers example actually
works.
So I'm done with all these things right now.
I can also do save and close.
So this bigger test is right now ready for us to do the testing.
So if you're going to run this particular test for a web application so you can just run something like
this for the web app and you can see that that test comes in here for our test case that will be running.
And now you can also do the side by side test and see what's really happening.
So basically our application is deployed in the local host eighty one.
So I'm just going to be testing this as if like I'm testing the application instead so opening the application
is working fine and then getting to all the menu items.
So you can go to the home just working about is working and contact is where.
So I will say that this is working fine as well.
And again I'm going to click the home.
So I would say that this is working fine.
And verify if the home page exists with the name at home.
Of course it doesn't really exist.
But I can still say Yeah it's working fine.
I can save on close.
But if for some reason if I feel like that home is not there with the at home or something like that
let's say for the next iteration I'm going to say everything is working fine just that for the home
it is not that if the name s new home that I'm going to say this as failed I want to say no such home
page exist.
And also I can take a screenshot and even I can create a buck to an existing bug I can attach that and
I can just say like it is not working as something like that create bug and you can see that the create
bug window is gonna show us a pretty cool window here and you can see that this is this has got failed
as well.
Home page fast no intended value add this to the development.
So I'm just gonna say that this is found in the branch in the master branch and I'm going to hit OK
and you can see that I can able to associate that with the master branch and also you can see that for
which that pattern is gonna be assigned so it's gonna be basically for the Google auto mechanics I'm
just crazy.
You don't really have to do this way and I'm gonna just save and close this guy and I'm gonna stay in
close this as well so you can see that this particular test has got failed so the next time I tried
to run this piece up test cases you should make sure that particular issue has been resolved on something
like that.
Right.
So you can do all that jazz here.
So for instance this is like ready and now I'm gonna be running this particular test case I can just
run this in the web browser once again and I feel like this particular test case is not working.
Final thought on your problem.
I'm going to go next to the next iteration and I'm going to say OK.
The new home page existence will save and close.
So this way that this has got past and now if you just open this particular guy here you can see that
there's just not an issue now and I can also get that closed which means the test has successfully completed.
Right.
So this how we can do a manual testing with our test to plan off I sure do ops and we can also see the
automated test over here and also we can see the exploratory test over here in this particular run as
how we did in our previous video.
So you can see that for this particular test and there is like need in investigation and there is a
there is this parentheses it says like manual testing and you can see that report like what's really
happening and why it has got failed in the report.
And if you see this guy that run I.T. this one has got passed and you can see everything is working
fine as expected.
So you can see that I'd like to test runs no one has not failed and one has got past right.
Cool.
So this is how we can work with the test plans and how we can do the mental testing.
And again if I can run this in for the desktop you can click that and you can see that it is going to
ask you that you need to install the desktop application so that you can test the desktop applications
as well.
But since I'm going to be showing you the desktop application I don't think this really matters for
now but you can still do that as well.
So that's this guy.
This whole began to work with a test plan you know next video we'll see how to work with a load testing
just available for free for at least less than 250 virtual users.