Selenium using python: unittest

Showing posts with label unittest. Show all posts

Friday, 23 January 2015

Handling Web Alerts

Web Alert are used to confirm the action taken by the user.
It take the focus away from the current window , and force the user to read the alert message.

Generally Web alerts consist of message and an OK, CANCEL button.

How does Selenium WebDriver handle Web Alert ??

In selenium WebDriver when an alert appears in the web-page ,
the control is still in the web-page hence we have to switch the control from
the web-page to alert window.

For accessing the Web Alert , we first have to create an alert object.

alert = browser.switch_to_alert()

Now we have control over the alert.
To perform action on the alert we need to know about alert class.

What is a Alert Class??

With the help of Alert Class we can interact with alerts.
With this class we can
accept the alert using accept()----method
reject the alert using dismiss()-----method
enter value in the alert box using send_keys()-----method
receive the text found in the alert using ".text"

Simple Alert Button

Lets handle a simple alert.In order to generate alert please copy the below html code,
and save it in ex1.html .

<!DOCTYPE html>
<html>
<body bgcolor="#E6E6FA">
<h1>
Basic Alert</h1>
<p>
click the button to see an alert</p>
<button onclick="myFunction()" name ="alert">Alert</button>

<p>
How to handle alerts</a>
<ul style="text-align: left;">
<li><span style="color: #6aa84f;">Open the page web-page</span></li>
<li><span style="color: #6aa84f;">switch the control from web-page to alert</span></li>
<li><span style="color: #6aa84f;">handle the alert</span></li>
</ul>
<br />
<span style="background-color: white; color: #6aa84f;"><br /></span>
<span style="background-color: white; color: #6aa84f;"><br /></span>
<br />
<br /></div>
<script>
function myFunction() {
    alert("Do you know me");
}
</script>

</body>
</html>

Navigate to folder where the file is saved and double click it.

The browser open with

Now before we write test scripts lets write test cases.

test_ex1.html

#Test the alert in ex1.html
import unittest
from selenium import webdriver
from selenium.webdriver.common.by   import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.common.exceptions import NoAlertPresentException
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.support import expected_conditions as EC

class TestAlert(unittest.TestCase):
    
    def setUp(self):

        self.browser = webdriver.Firefox()
        browser = self.browser
        browser.get("file:///E:/python_blog/python%20series/popups/alert.html")

    def tearDown(self):

       self.browser.close()

    def clicks(self,name):
        
        browser = self.browser
        button = WebDriverWait(browser,5).until(lambda browser: browser.find_element(By.NAME,name))
        button.click()

    def alert_wait(self):

        browser = self.browser
        try:
            WebDriverWait(browser, 3).until(EC.alert_is_present(),
                                   'Timed out waiting for PA creation ' +
                                   'confirmation popup to appear.')
        except TimeoutException:
            print("no alert")
            
    def test_raise_NoAlertPresentException(self):
        """When the button is not clicked no alert is generated,
        a NoAlertPresentException is raised ,
        when we try to switch to alert."""
        browser = self.browser
        
        try:
            #switch control to the alert box,by creating a alert object
            alert = browser.switch_to_alert()
            self.alert_wait()
            #accept the alert
            alert.accept()
        except NoAlertPresentException:
            print("no alert found")   

    def test_accept_alert(self):
        """we generate the alert and accept it"""
        browser = self.browser
        
        self.clicks("alert")
        #switch control to the alert box,by creating a alert object
        alert = browser.switch_to_alert()
        self.alert_wait()
        #accept the alert
        alert.accept()

    def test_alert_messge(self):
        """Verify the alert message"""
        
        msg = "Do you know me"
        browser = self.browser
        self.clicks("alert")
        #switch control to the alert box,by creating a alert object
        alert = browser.switch_to_alert()
        self.alert_wait()
        self.assertEqual(msg,alert.text,"string not equal")
        alert.accept()
        

if __name__ == "__main__":

    unittest.main(warnings = 'ignore')

Output in window's command prompt

Alert with OK & CANCEL Buttons

Save the below code in ex2.html

<!DOCTYPE html>
<html>
<body bgcolor="#E6E6FA">
<h1>
Alert with OK and CANCEL BUTTON</h1>
<p>
Click the button to display a confirmation box.</p>
<button onclick="myFunction()" name = "confirm">Confirm</button>

<p id="demo">
</p>
<script>
function myFunction() {
    var x;
    if (confirm("Do I know you") == true) {
        
        alert("I Know you")
        x = "You pressed OK!"

    } else {

        alert("who are you")
        y = "You pressed CANCEL"
    }
    document.getElementById("demo").innerHTML = x;
}
</script>

</body>
</html>

When we open ex2.html in a browser we get

The Test Cases for ex2.html are

test_ex2_v1.py

import unittest
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.support import expected_conditions as EC

class ConfirmationTestCase(unittest.TestCase):
    """Base class for ConfirmationTest,
    This class provide the setup ,teardown method for
    the test cases in ConfirmationTest class.
    It also provides helper function like clicking elements
    and waiting for pop-ups"""
    def setUp(self):

        self.browser = webdriver.Firefox()
        browser = self.browser
        browser.get("file:///E:/python_blog/python%20series/popups/ok_or_canel.html")
    
        self.clicks("confirm")
        self.alert_wait()
        self.alert = browser.switch_to_alert()

    def tearDown(self):

        self.alert_wait()
        self.alert.accept()
        self.browser.close()

    
    def clicks(self,name):
        
        browser = self.browser
        button = WebDriverWait(browser,5).until(lambda browser: browser.find_element(By.NAME,name))
        button.click()    

    def alert_wait(self):

        browser = self.browser
        try:
            WebDriverWait(browser, 3).until(EC.alert_is_present(),
                                   'Timed out waiting for PA creation ' +
                                   'confirmation popup to appear.')
        except TimeoutException:
            print("no alert")

    def alert_assertion(self,msg):

        self.assertEqual(msg,self.alert.text)
    
class ConfirmationTest(ConfirmationTestCase):
    """The test case are found in this class"""
    
    def test_click_confirm_verify_txt(self):
    
        msg = "Do I know you"
        self.alert_assertion(msg)
        
        self.alert_wait()
        self.alert.dismiss()
        
        

    def test_click_ok_verify_txt(self):

        self.alert.accept()
        self.alert_wait()

        msg = "I Know you"
        self.alert_assertion(msg)
        

    def test_click_cancel_verify_txt(self):
        
        self.alert.dismiss()
        self.alert_wait()

        msg = "who are you"
        self.alert_assertion(msg)
      
if __name__ == "__main__":
    
    unittest.main(warnings='ignore')

Lets us run test_ex2_v1.py in command line.

Structure of test_ex2_v1.py ,it has two class namely ConfirmationTestCase & ConfirmationTest

Now let us put the ConfirmationTestCase class in a file called ex2Base.py

import unittest
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.support import expected_conditions as EC

class ConfirmationTestCase(unittest.TestCase):
    """Base class for ConfirmationTest,
    This class provide the setup ,teardown method for
    the test cases in ConfirmationTest class.
    It also provides helper function like clicking elements
    and waiting for pop-ups"""
    def setUp(self):

        self.browser = webdriver.Firefox()
        browser = self.browser
        browser.get("file:///E:/python_blog/python%20series/popups/ok_or_canel.html")
    
        self.clicks("confirm")
        self.alert_wait()
        self.alert = browser.switch_to_alert()

    def tearDown(self):

        self.alert_wait()
        self.alert.accept()
        self.browser.close()

    
    def clicks(self,name):
        
        browser = self.browser
        button = WebDriverWait(browser,5).until(lambda browser: browser.find_element(By.NAME,name))
        button.click()    

    def alert_wait(self):

        browser = self.browser
        try:
            WebDriverWait(browser, 3).until(EC.alert_is_present(),
                                   'Timed out waiting for PA creation ' +
                                   'confirmation popup to appear.')
        except TimeoutException:
            print("no alert")

    def alert_assertion(self,msg):

        self.assertEqual(msg,self.alert.text)

Let us retain ConfirmationTest and save the file as ex2Test.py

import unittest
from ex2Base import ConfirmationTestCase

class ConfirmationTest(ConfirmationTestCase):
    """The test case are found in this class"""
    
    def test_click_confirm_verify_txt(self):
    
        msg = "Do I know you"
        self.alert_assertion(msg)
        
        self.alert_wait()
        self.alert.dismiss()
        
        

    def test_click_ok_verify_txt(self):

        self.alert.accept()
        self.alert_wait()

        msg = "I Know you"
        self.alert_assertion(msg)
        

    def test_click_cancel_verify_txt(self):
        
        self.alert.dismiss()
        self.alert_wait()

        msg = "who are you"
        self.alert_assertion(msg)
      
if __name__ == "__main__":
    
    unittest.main(warnings='ignore')

lets us run ex2Test.py from window command line.

Dialogue Box

Please copy the below code for generating a dialogue box as show above.

<!DOCTYPE html>
<html>
<body bgcolor="#E6E6FA">
<h1>
Dialogue Box</h1>
<p>
What your name ????</p>
<button onclick="myFunction()"name ="dialogueBox">Name</button>

<p id="demo">
</p>
<script>
function myFunction() {
    var person = prompt("Please enter your name", "Jude Job");
    
    if (person != null) {
        document.getElementById("demo").innerHTML =
        "Hello " + person + "! How are you today?";
        alert("Hello " + person + "! How are you today?")
    }
}
</script>

</body>
</html>

Now lets write the test cases

test_ex3.py

import unittest
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.support import expected_conditions as EC

class DialogueTest(unittest.TestCase):

    def setUp(self):

        self.browser = webdriver.Firefox()
        browser = self.browser
        browser.get("file:///E:/python_blog/python%20series/popups/accept_values.html")
        
        self.clicks("dialogueBox")
        self.alert_wait()

    def tearDown(self):

        self.browser.close()

    def clicks(self,name):
        
        browser = self.browser
        button = WebDriverWait(browser,5).until(lambda browser: browser.find_element(By.NAME,name))
        button.click()    

    def alert_wait(self):

        browser = self.browser
        try:
            WebDriverWait(browser, 3).until(EC.alert_is_present(),
                                   'Timed out waiting for PA creation ' +
                                   'confirmation popup to appear.')
        except TimeoutException:
            print("no alert")
            
    def test_send_keys(self):

        name ="James Bond"
        alert = self.browser.switch_to_alert()
        alert.send_keys(name)
        alert.accept()

        self.alert_wait()
        alert.accept()

    def test_verify_sent_keys(self):

        name ="James Bond"
        alert = self.browser.switch_to_alert()
        alert.send_keys(name)
        alert.accept()

        self.alert_wait()
        self.assertIn(name,alert.text)
        alert.accept()        
        
if __name__ == "__main__":
    unittest.main(warnings='ignore')

Now lets execute test_ex3.html from window command line,

Thursday, 15 January 2015

My Python Notes:class ToolKit & unittest Framework

What is a class ?

Class is way to represent Object found in the Real World.
The way we define a function using the keyword def ,class can be created using the keyword class.
So Lets create a class which describes the behavior of a human being using a Human class.

Syntax
class Human(object):

Class allow us to logical group data & functions and the data is know as attributes,functions is referred to as methods.

As humans we have a name & age these are attributes.

Now let create a class Human with name & age.To represent the behavior of the Human we have defined two method eat() & my_stomach().

human.py

With human.py we have create a human class ie... we have a blueprint for Humans

Function within a class are known as methods
Now lets create a who Human whose name is Jude Augustine,age 24 from the Human class ie... we are creating an object whose name is Jude Augustine & age 24

object.py

lets run object.py

What have we done we have create a new object from the Human class

Note:
__init__()--- is used to assign value to the object ie..initialize the attributes.
The INIT method doesn't have a return statement, but it return the object that was created.

__str__()--- it return information about the object.

Lets us talk to Jude why is he so sad.

Let write code it and save it in conversation1.py

Lets make Jude Happy....

Lets write the code for the above and save in conversation2.py

Creating Multiple Objects from Human Class

Create James & John whose ages are 21 &22 have a sister whose name is Lisa who is 18 year Old,lets
create them using the Human Class.

family.py

save the above code in family.py & run it
#1 in family.py we are importing the Human class from the file human.py

#2 we create a brother_james with name james & age 21.

#3 we create a brother_john which is an object of class Human with name John & is 22 years old.

Creating multiple objects using List-Comprehension

from the above code we notice that humans[0] ----> James,24
humans[1] ----> John,22
humans[2] ----> Lisa,18

Now lets test human.py using Unittest module

Lets now write the code for the above test cases.

testHuman.py

Now lets run it testHuman.py

Now lets write some negative test cases

lets write the code & save it in negative.py

TookKIT
Human Class with few TookkIT elements.

class Human(object): """Being a human i have a name & age. We can eat using the eat()--method. The my_stomach return the food_list found in the stomach. """ heart = 1 #Class variable def init(self,name,age): """(object,string,number)-> object This method initalize the human object whose name is name and age is age """ self.name = name #instance variables self.age = age self.food_list = [] def str(self): """Return the name & age of the object""" s = "My name is %s. "%self.name s +="I am %d year old."%self.age return s def eat(self,food): """ (object,string)->None Add the food eaten to the food_list """ self.food_list.append(food) def my_stomach(self): #Regular Methods """ (object) ->list contents of my stomach""" talk ="" if self.food_list: talk ="I ate" else: talk ="i am hungry" print(talk,','.join(self.food_list)) return self.food_list @staticmethod #static method def heart_beat_sound(): return("lap--dubp--lap-dubp")

1)Instance Variables are defined within the init ()--method.

Information about Instance variable may vary as we can see from the multiple objects code.

Eg for Human class , name & age are instance variables.

2)Regular methods----function within a class are know are methods

Eg---- __init__(), __str__() ,eat() , my_stomach() are all methods

all the above method use self ,ie method using self are a parameter are known as Regular Methods.

3)Class Variables--- as human being we all have a heart & every being has One Heart.

Eg-- heart = 1

4)Static Methods-- method that dont need self as a paramter, because they dont modify the Instance variables.They are helper function which can be used by other Regular Method.
They are added to class using decorators.

Eg @staticmethod
def heart_sound():
print("lup--dup--lup---dup")

How does you heartBeat

the code for the above scenario

heart.py

from human import Human

doctor = Human("DR Andrew",45)
patient = Human("joseph",30)

print("patient::>> how is my heart beat ")
#doctor refers the patients static method
print("Doctors::>>",patient.heart_beat_sound())

Run it

Wednesday, 17 December 2014

Unit Testing With Python

Unit Test Framework
Selenium is used for Web UI automation ,
To write and to maintain test cases a framework is required.
Here in this case Unitest is used for this purpose

About Unittest

Unittest module started life as the third-party module PyUnit.
Unittest support fixtures,test suites and a test runner to enable automated testing.

Core Class of unittest

TestCase
TestSuite
TestLoader
TextTestRunner
TestResults

TestCase

TestCase is a one of the core classes of unittest module.
TestCase has to be inherited from unittest module
All the test routines or methods must start with "test".
Only then will they be executed, Test case can be in a different file,if so the module to be tested must be imported.

#We need to import the unittest module
import unittest

#Testcase
class TestLoginPage(unittest.TestCase):

    """We are testing the loginpage"""
    
    def test_case_1(self):
        print ("I am test case no 1")

    def test_case_2(self):
        print ("I am test example 2")

    def test_case_3(self):
        print ("I am test example 3")


#To execute the unittest

if __name__ == "__main__":
    
    unittest.main(exit=False)
#Parameter for exit is set as False since this code is executed in IDLE

Example 1

#Save the below code in lowercasevowel.py
def count_lower_case_vowels(s):
    """(str) -> number

    Return the number of lower case vowels found in the input string s
    """

    no_of_vowels = 0

    for vowels in s:
        if vowels in "aeiou":
            no_of_vowels +=1
    return no_of_vowels

Unit test for lowercasevowel.py

#Save the below code in unit_for_lowercasevowel.py
#import the required modules
import lowercasevowel
import unittest

#Testcase
class TestingLowerCaseVowels(unittest.TestCase):

    """We are testing the lowercasevowel.py"""
    
    def test_case_1(self):
        actual   = lowercasevowel.count_lower_case_vowels("b")
        expected = 0
 
        self.assertEqual(actual,expected)

    def test_case_2(self):
        
        actual   = lowercasevowel.count_lower_case_vowels("aeiou")
        expected = 5
 
        self.assertEqual(actual,expected)

    def test_case_3(self):
        
        actual   = lowercasevowel.count_lower_case_vowels("jude")
        expected = 2
 
        self.assertEqual(actual,expected)



#To execute the unittest
if __name__ == "__main__":
    
    unittest.main(exit=False)
#Parameter for exit is set as False since this code is executed in IDLE

Output

>>> 
...
----------------------------------------------------------------------
Ran 3 tests in 0.047s

OK
>>>

Note: each "." represents testcase successfully executed ,if test case fails "F" instead of "."

F
======================================================================
FAIL: test_google_search (__main__.GoogleSearch)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "D:\coursera\selenium\google.py", line 21, in test_google_search
    self.assertIn(self.browser.title,"Go")
AssertionError: 'Google' not found in 'Go'

----------------------------------------------------------------------
Ran 1 test in 28.112s

FAILED (failures=1)
>>>

Structure of TestCase Class of unittest

setUp() where pre-condition for executing the test case are written down.
tearDown() here clean up ,which is required after each test case is written down.
skipTest() will skip the current test.
fail() will fail the test explicitly ie..It will fail the test an raise AssertionError.
id() Return a string containing the name of the TestCase object and of the test method.
shortDescription() Return the Docstring present in the Test case method.

Note:setUp() get executed before all the test_case() method and tearDown() after each test_case()
methods.

Example 2
Let us use the setUp() and tearDown() methods

#General test case Template
#imports
import unittest
from selenium import webdriver

#Test case class
class GeneralTemplate(unittest.TestCase):

    def setUp(self):
        """Here we create browser object and access a url if needed"""
        print("I am setUp")
     
 
    def tearDown(self):
        """Here we close the browser 
           ie..clean up process after the test case """
        print("I am Tear down")

    def test_caseNo1(self):
       """Here the code is written for the testing the Web UI """
       print("I am test case no1")

Example 3
Let us use the setUp() and tearDown() id() & shortDescription() methods

import unittest

class LearningUnittest(unittest.TestCase):

    def setUp(self):
        testName = self.shortDescription()

        if testName == "test case 1":
            print("start of test case 1")

        elif testName == "test case 2":
            print("start of test case 2")

        elif testName == "test case 3":
            print("start of test case 3")    

        else:
            print("unknown test case starting")


    def tearDown(self):
        testName = self.shortDescription()

        if testName == "test case 1":
            print("stop of test case 1")

        elif testName == "test case 2":
            print("stop of test case 2")

        elif testName == "test case 3":
            print("start of test case 3")    

        else:
            print("unknown test case stop")

    def test_case_1(self):
        """test case 1"""

        print("hello here i am 1")

    def test_case_2(self):
        """test case 2"""

        print("hello here i am 2")

    def test_case_3(self):
        """test case 3 """
        self.fail("test case 3 fail")

if __name__ == "__main__":
    unittest.main()

Problem 1
Search for a python tutorial on youtube ?

Answer

Open a browser (firefox)

#we need to create webdriver object
#To do that we need to import webdriver from selenium
from selenium import webdriver
#Now we create a webdriver
browser = webdriver.Firefox()

Nagivate to "http://www.youtube.com"

#To nagivate any web-page in the browser we can use the get command
browser.get("http://www.youtube.com")

Verify that youtube page is opened

#we use assert if the assert fails
#The execution will stop at the assert point in the test case
#An AssertionError is raised, but the tearDown method is always called.
assertIn("YouTube",browser.title)

Locate the search Box and type in Python Tutorials

#Let us locate search box using id 
#Using Firebug we can inspect the search box's id
searchElement = browser.find_element_by_id("masthead-search-term")
#Let us enter "python tutorials"
searchElement.send_keys("python tutorials")
#Press the enter key
searchElement.send_keys(Keys.RETURN)

To take a screenshot

 
browser.screenshot('YoutubeSearch.png')
#The screenshot is stored as YoutubeSearch.png
#In the same directory as youtube.py

The complete solution with unittest as Framework

#Save the below code in youtube.py
import unittest
from selenium import webdriver
from selenium.webdriver.common.keys import Keys

class YoutubeSearch(unittest.TestCase):

    def setUp(self):

        print("-----Starting setup------")
        self.browser = webdriver.Firefox()
        self.browser.get("http://www.youtube.com")
        print("-----setup complete-----")
        
    def tearDown(self):
        print("-----starting teardown------")
        self.browser.screenshot('YouTubeSearch.png')
        self.browser.quit()
        print("----teardown complete-------")
        
    def test_youtube_search(self):
        
        print("-----in the test------")
        self.assertIn("YouTube",self.browser.title)
        searchElement = self.browser.find_element_by_id("masthead-search-term")
        searchElement.send_keys("python tutorials")
        searchElement.send_keys(Keys.RETURN)
        print("----test case complete----")


if __name__ == "__main__":

    unittest.main(exit=False,warnings = 'ignore')


#Parameter for exit is set as False since this code is executed in IDLE