Recording Tests Using Windows Internet Explorer and Playing Back
Using Mozilla Firefox
Using the Microsoft Visual Studio 2010 Feature Pack 2, you can use
Windows Internet Explorer 7 (or later versions) to record UI actions on a
website or a Web-based application and then play back the tests using the
Mozilla Firefox browser
·
Coded UI Tests: You can create automated tests of the user interface (UI)
known as coded UI tests. These tests provide
functional testing of the user interface and validation of user interface
controls. Coded UI tests let you test the functionality of a user interface.
They are quicker to run than manual tests. Therefore, you can run them more
frequently. Using the Microsoft Visual Studio 2010 Feature Pack 2, you can
record UI actions on a website or on a Web-based application. You can create
coded UI tests using Internet Explorer and then play back the tests using the
Firefox browser.
For more information
about coded UI tests, see Testing the User
Interface with Automated UI Tests.
·
Manual Tests: You can create manual test cases to test your application.
In a manual test case, you can document all the required test steps for a
specific scenario and any other information that you must have to run the
manual test. This might include attaching files to the manual test case. You
must add your manual test cases to a test plan to be able to run them using
Test Runner. By adding your manual test cases to a plan you can save the
results every time that you run your test. Using the Microsoft Visual Studio
2010 Feature Pack 2, you can create an action recording for manual test steps
that are performed on a website or on a Web-based application. You can record
the tests using Internet Explorer and then play back the tests using the
Firefox browser.
For more information
about manual tests, see Creating Manual
Test Cases and Running Manual
Tests Using Test Runner.
If you want to run your
coded UI tests remotely for your application, you must install the Microsoft
Visual Studio 2010 Feature Pack 2 on any computer that has a test agent or a
test controller that you will use to run the tests. For more information about
how to run coded UI tests, see How to: Set Up
Your Test Agent to Run Tests that Interact with the Desktop and Running
Automated Tests.
If you want to build the
test project that contains your Silverlight coded UI tests as part of team
build using a build agent, you must install the Microsoft Visual Studio 2010
Feature Pack 2 on any computer that has a build agent that is used to build the
test project. For more information about how to build and run tests, see How to:
Configure and Run Scheduled Tests After Building Your Application.
The user could have
multiple versions of Firefox installed and multiple languages of the same
version of Firefox installed. The playback lets the user choose the version and
language of Firefox on which the playback is supposed to occur. While doing
playback using the Microsoft Test Runner, all the Firefox versions that are
installed on the machine are displayed for the user to choose from. In case of
CodedUITest, the user can set the BrowserWindow.CurrentBrowser environment
attribute to any of the installed versions and playback will choose the
designated Firefox version for playback.
For example, if you set BrowserWindow.CurrentBrowser = “Firefox
3.5.7 (ar)” playback will use the 3.5.7 Arabic Version of Firefox. Setting the
CurrentBrowser property to “Firefox” would choose the default version of
Firefox installed for playback. Check the registry key under
HKEY_LOCAL_MACHINE\SOFTWARE\Mozilla\Mozilla Firefox to find the names of all
the Mozilla Firefox versions installed on your machine and use these names to
set the CurrentBrowser property. You can also specify the CurrentBrowser
property through CodedUITestCurrentBrowser Environment variable. Coded UI tests
would read this environment variable and set the CurrentBrowser property itself
as a part of test initialization. This is a better way to choose a browser for
playback because it wouldn’t involve changing your coded UI test. Additionally,
you can manipulate the browser for playback by using this environment variable.
Standered recording:
An analog recording is one where a property or
characteristic of a physical recording medium is made to vary in a manner
analogous to the variations in air pressure of the original sound. Generally,
the air pressure variations are first converted (by a transducer such as a microphone) into an
electrical analog signal in which either the instantaneous voltage or current
is directly proportional to the instantaneous air pressure (or is a function of
the pressure). The variations of the electrical signal in turn are converted to
variations in the recording medium by a recording machine such as a tape
recorder or record cutter—the variable property of the medium is modulated by the signal. Examples of properties
that are modified are the magnetization of magnetic tape or the deviation (or displacement) of
the groove of a gramophone disc from a smooth, flat spiral track.
A digital recording is produced by converting the physical
properties of the original sound into a sequence of numbers, which can then be
stored and read back for reproduction. Normally, the sound is transduced (as by
a microphone) to an analog signal in the same way as for analog recording, and
then the analog signal is digitized, or converted
to a digital signal, through an analog-to-digital converter and then recorded onto a digital
storage medium such as a compact disc or hard disk.
Both analog and digital systems have limitations. The bandwidth of
the digital system is limited, according to the Nyquist frequency, by
the sample rate used. The bandwidth of an analog
system is limited by the physical capabilities of the analog circuits and
recording medium. The signal-to-noise
ratio (S/N) of a
digital system is limited by the bit depth of the digitization process. In an
analog system, other natural analog noise sources exist, such as flicker noise and imperfections in the recording
medium.
QTP Low Level
Recording Tutorial
You can switch to Low Level Recording mode only
while recording a test. The option is not available while editing a test.
The
record mode changes to Low Level Recording and all of your keyboard input and mouse clicks are
recorded based on mouse coordinates. When QTP runs the test, the cursor
retraces the recorded clicks.
3.
When you are finished and want to return to normal
recording mode, click the Low Level Recording button or selectAutomation > Low Level
Recording to turn off
the option.
The
following examples illustrate the difference between the same operations
recorded using normal mode and Low Level Recording mode.
Suppose
you type the word tutorial into a user name edit box and then press the Tab key
while in normal recording mode. Your test is displayed as follows in the
Keyword View and Expert View:
Introduction to Descriptive Programming.
How to write Descriptive Programming?When and Where to use Descriptive programming?
Some points to note with Descriptive Programming.
Introduction to Descriptive Programming:Descriptive programming is used when we want to perform an operation on an object that is not present in the object repository. There can be various valid reason to do so. We will discuss them later in this article.
How to write Descriptive Programming?
How to write Descriptive Programming?When and Where to use Descriptive programming?
Some points to note with Descriptive Programming.
Introduction to Descriptive Programming:Descriptive programming is used when we want to perform an operation on an object that is not present in the object repository. There can be various valid reason to do so. We will discuss them later in this article.
How to write Descriptive Programming?
There are two ways in which descriptive programming can be used
1. By giving the description in form of the string arguments.
2. By creating properties collection object for the description.
1. By giving the description in form of the string arguments.
This is a more commonly used method for Descriptive Programming.
You can describe an object directly in a statement by specifying property:=value pairs describing the object instead of specifying an object’s
name. The general syntax is:
TestObject("PropertyName1:=PropertyValue1", "..." , "PropertyNameX:=PropertyValueX")
TestObject—the test object class could be WebEdit, WebRadioGroup etc….
PropertyName:=PropertyValue—the test object property and its value. Each property:=value pair should be separated by commas and quotation
marks. Note that you can enter a variable name as the property value if you want to find an object based on property values you retrieve during a run session.
Consider the HTML Code given below:
<--!input type="”textbox”" name="”txt_Name”"-->
<--!input type="”radio”" name="”txt_Name”"-->
Now to refer to the textbox the statement would be as given below
Browser(“Browser”).Page(“Page”).WebEdit(“Name:=txt_Name”,”html tag:=INPUT”).set “Test”
And to refer to the radio button the statement would be as given below
Browser(“Browser”).Page(“Page”).WebRadioGroup(“Name:=txt_Name”,”html tag:=INPUT”).set “Test”
If we refer to them as a web element then we will have to distinguish between the 2 using the index property
Browser(“Browser”).Page(“Page”).WebElement(“Name:=txt_Name”,”html tag:=INPUT”,”Index:=0”).set “Test” ‘ Refers to the textbox
Browser(“Browser”).Page(“Page”).WebElement(“Name:=txt_Name”,”html tag:=INPUT”,”Index:=1”).set “Test” ‘ Refers to the radio button
To determine which property and value pairs to use, you can use the Object Spy:
1. Go to Tools -> Object Spy.
2. Select the "Test Object Properties" radio button.
3. Spy on the desired object.
4. In the Properties list, find and write down the properties and values that can be used to identify the object.
2. By creating properties collection object for the description.
Properties collection also does the same thing as string arguments. The only difference is that it "collects" all the properties of a particular object in an instance of that object. Now that object can be referenced easily by using the instance, instead of writing "string arguments" again and again. It is my observation that people find "string arguments" [1] method much easier and intuitive to work with.
To use this method you need first to create an empty description
Dim obj_Desc ‘Not necessary to declare
Set obj_Desc = Description.Create
Now we have a blank description in “obj_Desc”. Each description has 3 properties “Name”, “Value” and “Regular Expression”.
obj_Desc(“html tag”).value= “INPUT”
When you use a property name for the first time the property is added to the collection and when you use it again the property is modified. By default each property that is defined is a regular expression. Suppose if we have the following description
obj_Desc(“html tag”).value= “INPUT”
obj_Desc(“name”).value= “txt.*”
This would mean an object with html tag as INPUT and name starting with txt. Now actually that “.*” was considered as regular expression. So, if you want the property “name” not to be recognized as a regular expression then you need to set the “regularexpression” property as FALSE
obj_Desc(“html tag”).value= “INPUT”
obj_Desc(“name”).value= “txt.*”
obj_Desc(“name”).regularexpression= “txt.*”
This is how we create a description. Now below is the way we can use it
Browser(“Browser”).Page(“Page”).WebEdit(obj_Desc).set “Test”
When we say .WebEdit(obj_Desc) we define one more property for our description that was not earlier defined that is it’s a text box (because QTPs WebEdit boxes map to text boxes in a web page).
If we know that we have more than 1 element with same description on the page then we must define “index” property for the that description
Consider the HTML code given below
<--!input type="”textbox”" name="”txt_Name”"-->
<--!input type="”textbox”" name="”txt_Name”"-->
Now the html code has two objects with same description. So distinguish between these 2 objects we will use the “index” property. Here is the description for both the object
For 1st textbox:
obj_Desc(“html tag”).value= “INPUT”
obj_Desc(“name”).value= “txt_Name”
obj_Desc(“index”).value= “0”
For 2nd textbox:
obj_Desc(“html tag”).value= “INPUT”
obj_Desc(“name”).value= “txt_Name”
obj_Desc(“index”).value= “1”
Consider the HTML Code given below:
<--!input type="”textbox”" name="”txt_Name”"-->
<--!input type="”radio”" name="”txt_Name”"-->
We can use the same description for both the objects and still distinguish between both of them
obj_Desc(“html tag”).value= “INPUT”
obj_Desc(“name”).value= “txt_Name”
When I want to refer to the textbox then I will use the inside a WebEdit object and to refer to the radio button I will use the description object with the WebRadioGroup object.
Browser(“Browser”).Page(“Page”).WebEdit(obj_Desc).set “Test” ‘Refers to the text box
Browser(“Browser”).Page(“Page”).WebRadioGroup(obj_Desc).set “Test” ‘Refers to the radio button
But if we use WebElement object for the description then we must define the “index” property because for a webelement the current description would return two objects.
Getting Child Object:
We can use description object to get all the objects on the page that matches that specific description. Suppose we have to check all the checkboxes present on a web page. So we will first create an object description for a checkboxe and then get all the checkboxes from the page
Dim obj_ChkDesc
Set obj_ChkDesc=Description.Create
obj_ChkDesc(“html tag”).value = “INPUT”
obj_ChkDesc(“type”).value = “checkbox”
Dim allCheckboxes, singleCheckBox
Set allCheckboxes = Browse(“Browser”).Page(“Page”).ChildObjects(obj_ChkDesc)
For each singleCheckBox in allCheckboxes
singleCheckBox.Set “ON”
Next
The above code will check all the check boxes present on the page. To get all the child objects we need to specify an object description.
If you wish to use string arguments [1], same thing can be accomplished by simple scripting.
Code for that would be:
i=0
Do While Browse(“Browser”).Page(“Page”).WebCheckBox("html tag:=INPUT",type:=checkbox, "index:="&i).Exist
Browse(“Browser”).Page(“Page”).WebCheckBox("html tag:=INPUT",type:=checkbox, "index:="&i).Set "ON"Loop
i=i+1
Possible Operation on Description Objects
Consider the below code for all the solutions
Dim obj_ChkDesc
Set obj_ChkDesc=Description.Create
obj_ChkDesc(“html tag”).value = “INPUT”
obj_ChkDesc(“type”).value = “checkbox”
Q: How to get the no. of description defined in a collection
A: obj_ChkDesc.Count ‘Will return 2 in our case
Q: How to remove a description from the collection
A: obj_ChkDesc.remove “html tag” ‘would delete the html tag property from the collection
Q: How do I check if property exists or not in the collection?
A: The answer is that it’s not possible. Because whenever we try to access a property which is not defined its automatically added to the collection. The only way to determine is to check its value that is use a if statement “if obj_ChkDesc(“html tag”).value = empty then”.
Q: How to browse through all the properties of a properties collection?
A: Two ways
1st:
For each desc in obj_ChkDesc
Name=desc.Name
Value=desc.Value
RE = desc.regularexpression
Next
2nd:
For i=0 to obj_ChkDesc.count - 1
Name= obj_ChkDesc(i).Name
Value= obj_ChkDesc(i).Value
RE = obj_ChkDesc(i).regularexpression
Next
Hierarchy of test description:
When using programmatic descriptions from a specific point within a test object hierarchy, you must continue to use programmatic descriptions
from that point onward within the same statement. If you specify a test object by its object repository name after other objects in the hierarchy have
been described using programmatic descriptions, QuickTest cannot identify the object.
For example, you can use Browser(Desc1).Page(Desc1).Link(desc3), since it uses programmatic descriptions throughout the entire test object hierarchy.
You can also use Browser("Index").Page(Desc1).Link(desc3), since it uses programmatic descriptions from a certain point in the description (starting
from the Page object description).
However, you cannot use Browser(Desc1).Page(Desc1).Link("Example1"), since it uses programmatic descriptions for the Browser and Page objects but
then attempts to use an object repository name for the Link test object (QuickTest tries to locate the Link object based on its name, but cannot
locate it in the repository because the parent objects were specified using programmatic descriptions).
When and Where to use Descriptive programming?
Below are some of the situations when Descriptive Programming can be considered useful:
1. One place where DP can be of significant importance is when you are creating functions in an external file. You can use these function in various actions directly , eliminating the need of adding object(s) in object repository for each action[If you are using per action object repository]
2. The objects in the application are dynamic in nature and need special handling to identify the object. The best example would be of clicking a link which changes according to the user of the application, Ex. “Logout <>”.
3. When object repository is getting huge due to the no. of objects being added. If the size of Object repository increases too much then it decreases the performance of QTP while recognizing a object. [For QTP8.2 and below Mercury recommends that OR size should not be greater than 1.5MB]
4. When you don’t want to use object repository at all. Well the first question would be why not Object repository? Consider the following scenario which would help understand why not Object repository
Scenario 1: Suppose we have a web application that has not been developed yet.Now QTP for recording the script and adding the objects to repository needs the application to be up, that would mean waiting for the application to be deployed before we can start of with making QTP scripts. But if we know the descriptions of the objects that will be created then we can still start off with the script writing for testing
Scenario 2: Suppose an application has 3 navigation buttons on each and every page. Let the buttons be “Cancel”, “Back” and “Next”. Now recording action on these buttons would add 3 objects per page in the repository. For a 10 page flow this would mean 30 objects which could have been represented just by using 3 objects. So instead of adding these 30 objects to the repository we can just write 3 descriptions for the object and use it on any page.
5. Modification to a test case is needed but the Object repository for the same is Read only or in shared mode i.e. changes may affect other scripts as well.
5. Modification to a test case is needed but the Object repository for the same is Read only or in shared mode i.e. changes may affect other scripts as well.
No comments:
Post a Comment