My Python Notes: Decorators

Python is a hybrid programming language it support both object oriented programming as well as functional programming.

Like everything else in python function are also objects.

Functions and nested functions

In the above example dir() is used to display the objects.
                   
Lets Look at a simple function
                                                basicFunction1.py

Lets run it

Since function are object they can be assigned to variables.

  

                                       basicFunction2.py

In basicFunction2.py 

At step #1 we assign the variable fun with the function label funIn.

step #2 we call function funIn by adding () -- parentheses to the variable fun.

Now let  us consider a function within a function ie.. nested functions.

Moving on to a function which returns a function.

                                              nestedBasics1.py

The the above code has two function funOut()-- outer function & funIn() -- inner function.

At step #1 the funOut() return label of the inner function label

step #2 the variable funCall has the inner function label.

step #3 now the inner function can be called by just adding () -- parentheses to the funCall variable.

Lets us now consider a variation of  nestedBasics1.py 

                                     nestedBasics2.py[closures]

In the above code 

At step #1 we declare variable name.Function funIn() store this value.

 step #2 the funOut() return label of the inner function label

step #3 the variable funCall has the inner function label.

step #4 now the inner function can be called by just adding () -- parentheses to the funCall variable.

When the inner function is being called it is able to display the value of name, since funIn() was able to store name value at Runtime (as mentioned in step #1).

Now lets us make nestedBasics2.py more dynamic 

Advantage of Nested functions

Lets us examine nestedBasics2.py 

At step #1 we are creating a new object of the function funOut()

step #2 we are creating another object of the function funOut()

Now lets us consider the class version of nestedBasics2.py.

                                    funClass.py

In the above code funClass.py,

At step #1  we need define an initializer  method __init__() 

step #2 we need a regular  method to act on the class attribute name.

step #3 we are creating a object of class funOut

step #4 now in order to access regular method we are using .dot operator

If we are writing a class with one regular method, it better to used nested functions.

Function which takes another function

In the above code we have two functions avg() & cal()

cal() --takes a function as one of the input parameters.

*args , **kwargs

A function can have positional arguments which are also know as named and mandatory, the second type of arguments are default which are optional and are also know as keyword arguments.

Positional arguments

 

In the above code , the function man() take two argument name & age ie positional arguments..

At step #1 we interchange two argument but get the same results(named argument)

step #2 we pass one argument and we get an error message(mandatory argument)

Default(Keyword) arguments

In the above code the function we have has two default arguments

At step #3 when we don't pass any argument the function consider the default values

Output 

*args--takes an unlimited number of positional arguments.It prevent the program from crashing,and is used when we don't know the number of input arguments.

*kwargs-- takes an unlimited number of keyword arguments, and store the data in a dictionary.

*args and *kwargs

Decorators 

Function without arguments.

Till now we have seen that function are object and few example on nested functions.

Lets us now move on to decorators.

                                          decoratorsbasic1.py

In the above example decoratorsbasic1.py we have two function at runtime ie  wrapper() & name()

wrapper() does three things.

1) It take a function as parameter(myFunc)

2)wrapper has an inner function which calls the passed function(myFunc), and store it in variable(y).

3)Finally wrapper return the inner function label(innerFunc)

At step #1 in decoratorsbasic1.py 

The innerFunc label is assigned to name and this in turn when executed

 changes the return value of the function name().

A slight modification to decoratorsbasic1.py  would be done by adding decorator symbol(@)

with the wrapper function label just above the name function.

Lets us consider another example

Function with arguments

In the above code we have are applying a decorators which checks ,that both the input parameter are non-zero and +ve.

Now lets us consider a decorator which can handle any number of positional & keyword arguments.

Let us write a decorators which can only read data passed to the function,but not executed the decorated function itself.

There are two function at runtime ie wrapper() , man().

wrapper does two things

 At step #1 the inner function is designed to handle any function signature.

step #2 innerWrap is able to access the argument of the decorated function man()

but it does not executed the contents of man() function.

Now lets access the parameter passed to the function as well execute the function itself.

At step #1 we are able to access the contents of passed arguments.
step #2 two things happen one, is that we execute the function to be wrapped man()
and the other is that we modify the return value of wrapped function man().

CLASS-DECORATOR

Till Now we have seen decorators which are built using function ,lets try using CLASSES

In the above code foo1() & foo2() are passed as object to class myDecorator.
Now in myDecorator we have defined a __call__() method which gets called each time,
the decorated function gets called.

addOne class adds one to the return value of the decorated function foo()

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,

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