Exemplo n.º 1
0
    def __init__(self,
                 base_url='https://tn-devel.appspot.com/tap',
                 trailing_slash_flag=True):
        "Constructor"
        Borg.__init__(self)
        if self.is_first_time():
            #Do these actions if this the first time this class is initialized
            self.screenshot_counter = 1
            self.set_directory_structure()
            self.set_screenshot_dir()  # Create screenshot directory
            self.image_url_list = []
            self.msg_list = []
            self.window_structure = {}
            self.testrail_flag = False
            self.browserstack_flag = False
            self.driver = None
            self.result_counter = 0  #Increment whenever success or failure are called
            self.pass_counter = 0  #Increment everytime success is called
            self.mini_check_counter = 0  #Increment when conditional_write is called
            self.mini_check_pass_counter = 0  #Increment when conditional_write is called with True
            self.failure_message_list = []

        #We assume relative URLs start without a / in the beginning
        if base_url[-1] != '/' and trailing_slash_flag is True:
            base_url += '/'
        self.base_url = base_url
        self.driver_obj = DriverFactory()
        self.log_obj = Base_Logging(level=logging.DEBUG)
        self.log_obj.set_stream_handler_level(self.log_obj.getStreamHandler(),
                                              level=logging.DEBUG)
        if self.driver is not None:
            self.start()  #Visit and initialize xpaths for the appropriate page
Exemplo n.º 2
0
 def clickFirstVideo(self):
     print("Clicking first video")
     idExpression = "video-title"
     elementExpression = (By.ID, idExpression)
     WebDriverWait(DriverFactory.getDriver(), 30).until(expected_conditions.visibility_of_element_located(elementExpression))
     firstVideo = DriverFactory.getDriver().find_element_by_id(idExpression)
     firstVideo.click()
     return VideoPage()
Exemplo n.º 3
0
def run_search_inbox_test(browser, conf, base_url, sauce_flag, browser_version,
                          platform, testrail_run_id):
    "Login to Gmail using the page object model"
    # get the test account credentials from the .credentials file
    credentials_file = os.path.join(os.path.dirname(__file__),
                                    'login.credentials')
    username = Conf_Reader.get_value(credentials_file, 'LOGIN_USER')
    password = Conf_Reader.get_value(credentials_file, 'LOGIN_PASSWORD')

    #Result flag used by TestRail
    result_flag = False

    #Setup a driver
    #create object of driver factory
    driver_obj = DriverFactory()
    driver = driver_obj.get_web_driver(browser, sauce_flag, browser_version,
                                       platform)
    driver.maximize_window()

    #Create a login page object
    login_obj = PageFactory.get_page_object("login", driver)
    if (login_obj.login(username, password)):
        msg = "Login was successful"
        result_flag = True
        login_obj.write(msg)
    else:
        msg = "Login failed"
        login_obj.write(msg)

    #Create an object for main page with header and menu
    main_obj = PageFactory.get_page_object("main", driver)
    main_obj.wait(3)

    #Search the inbox for message by subject 'POM' and open the message
    if main_obj.header_obj.search_by_subject('POM'):
        main_obj.write("Search successful")
        result_flag = True
    else:
        main_obj.write("Search text was not found")
        result_flag = False

    #Go to inbox
    main_obj.menu_obj.select_menu_item('inbox')

    #Update TestRail
    if testrail_run_id is not None:
        login_obj.write('About to update TestRail')
        case_id = 67
        Test_Rail.update_testrail(case_id,
                                  testrail_run_id,
                                  result_flag,
                                  msg=msg)

    main_obj.teardown()
Exemplo n.º 4
0
 def readVideoName(self):
     videoPage = VideoPage()
     try:
         videoPage.clickSkipAdvertisement()
     except:
         print("No Advertisement Found")
     cssExpression = "h1 .ytd-video-primary-info-renderer"
     elementExpression = (By.CSS_SELECTOR, cssExpression)
     WebDriverWait(DriverFactory.getDriver(), 5).until(
         expected_conditions.visibility_of_all_elements_located(
             elementExpression))
     videoHeader = DriverFactory.getDriver().find_element_by_css_selector(
         cssExpression)
     return videoHeader.text
Exemplo n.º 5
0
def run_search_inbox_test(browser, conf, base_url, sauce_flag, browser_version, platform, testrail_run_id):
    "Login to Gmail using the page object model"
    # get the test account credentials from the .credentials file
    credentials_file = os.path.join(os.path.dirname(__file__), "login.credentials")
    username = Conf_Reader.get_value(credentials_file, "LOGIN_USER")
    password = Conf_Reader.get_value(credentials_file, "LOGIN_PASSWORD")

    # Result flag used by TestRail
    result_flag = False

    # Setup a driver
    # create object of driver factory
    driver_obj = DriverFactory()
    driver = driver_obj.get_web_driver(browser, sauce_flag, browser_version, platform)
    driver.maximize_window()

    # Create a login page object
    login_obj = PageFactory.get_page_object("login", driver)
    if login_obj.login(username, password):
        msg = "Login was successful"
        result_flag = True
        login_obj.write(msg)
    else:
        msg = "Login failed"
        login_obj.write(msg)

    # Create an object for main page with header and menu
    main_obj = PageFactory.get_page_object("main", driver)
    main_obj.wait(3)

    # Search the inbox for message by subject 'POM' and open the message
    if main_obj.header_obj.search_by_subject("POM"):
        main_obj.write("Search successful")
        result_flag = True
    else:
        main_obj.write("Search text was not found")
        result_flag = False

    # Go to inbox
    main_obj.menu_obj.select_menu_item("inbox")

    # Update TestRail
    if testrail_run_id is not None:
        login_obj.write("About to update TestRail")
        case_id = 67
        Test_Rail.update_testrail(case_id, testrail_run_id, result_flag, msg=msg)

    main_obj.teardown()
 def __init__(self, browser, locator_file):
     # self.driver = driver
     locator_file_path = os.path.join(os.path.driname(__file__), '..',
                                      'Locators', locator_file)
     self.driver = DriverFactory.get_driver(browser)
     self.header = Header(self.driver)
     self.page_locators = LocatorParser.get_Locators(locator_file_path)
Exemplo n.º 7
0
 def __init__(self, browser, url, locator_file):
     locator_file_path = os.path.join(os.path.dirname(__file__), '..', '..',
                                      '..', 'Resources', 'Locators',
                                      locator_file)
     self.driver = DriverFactory.get_driver(browser)
     self.driver.get(url)
     self.page_locators = LocatorParser.get_locators(locator_file_path)
 def clickSkipAdvertisement(self):
     print("Skipping Advertisement")
     cssExpression = ".videoAdUiExperimentalSkipIcon"
     skipButton = DriverFactory.getDriver().find_element_by_css_selector(
         cssExpression)
     skipButton.click()
     return self
Exemplo n.º 9
0
    def __init__(self, base_url='http://qxf2.com/', trailing_slash_flag=True):
        "Constructor"
        Borg.__init__(self)
        if self.is_first_time():
            #Do these actions if this the first time this class is initialized
            self.set_directory_structure()
            self.image_url_list = []
            self.msg_list = []
            self.current_console_log_errors = []
            self.window_structure = {}
            self.testrail_flag = False
            self.browserstack_flag = False

            self.reset()

        #We assume relative URLs start without a / in the beginning
        if base_url[-1] != '/' and trailing_slash_flag is True:
            base_url += '/'
        self.base_url = base_url
        self.driver_obj = DriverFactory()
        if self.driver is not None:
            self.start()  #Visit and initialize xpaths for the appropriate page
Exemplo n.º 10
0
 def goPreviousVideo(self):
     print("Clicking prev button")
     cssExpression = ".ytp-prev-button"
     prevButton = DriverFactory.getDriver().find_element_by_css_selector(
         cssExpression)
     prevButton.click()
from DriverFactory import DriverFactory
from LoginPage import LoginPage
from PageFactory import PageFactory

if __name__ == "__main__":
    print("###################### Test Start #########################")
    driverFactory = DriverFactory()
    driver = driverFactory.driver
    wait = driverFactory.wait
    loginPage = LoginPage(driver, wait)
    loginPage.clickLogin(True)
    portalsComponents = PageFactory(driver,
                                    wait).getWorkCenters().getGuestAccess()
    portalsComponents.clickOnButtonByName("Portals & Components")
    portalsComponents = portalsComponents.getPortalsComponents()
    portalType = "Guest Portals"
    portalName = "testingAutomating"
    portalsComponents.leftSide.clickOnButtonByName(portalType)
    portalsComponents.actions.clickOnButtonByName(
        "Create", "Self-Registered Guest Portal")
    portalsComponents.innerPage.setTextboxValueByName(portalType, "Name",
                                                      portalName)
    portalsComponents.innerPage.setTextboxValueByName(portalType,
                                                      "Description", "desc")
    portalsComponents.innerPage.clickOnButtonByName("Portal Settings")
    portalsComponents.innerPage.setValueOfInputByName("HTTPS port", "8445")
    portalsComponents.innerPage.clickOnButtonByName("Login Page Settings")
    portalsComponents.innerPage.setValueOfInputByName("Include an AUP", True)
    portalsComponents.innerPage.clickOnButtonByName("Save")
    portalsComponents.innerPage.clickOnButtonByName("Close")
    portalsComponents.portals.verifyPortalByName(portalName)
Exemplo n.º 12
0
def run_demo_test(browser,conf,tconf,base_url,test_run_id=None,sauce_flag=None,browser_version=None,platform=None):
    "Demo Test Run"
       
    #Setup a driver
    driver_obj = DriverFactory()
    driver = driver_obj.get_web_driver(browser,sauce_flag,browser_version,platform)
    driver.implicitly_wait(10) # Some elements are taking long to load
    driver.maximize_window()

    #Result flag which will check if testrail.conf is present
    tconf_flag = check_file_exists(tconf)

    #Result flag used by TestRail
    result_flag = False
    
    #1. Create a home page object and choose Market
    #Create a login page object
    home_obj = PageFactory.get_page_object("home",driver)
    city_name = Conf_Reader.get_value(conf,'CITY_NAME')
    result_flag = home_obj.choose_market(city_name)
    if (result_flag):
        msg = "Market was set to %s"%city_name
    else:
        msg = "Could not set market to  %s"%city_name
    home_obj.write(msg)
    
    #Update TestRail
    #Get the case id from tesrail.conf file
    if tconf_flag:
        case_id = Conf_Reader.get_value(tconf,'CHOOSE_MARKET')
        Test_Rail.update_testrail(case_id,test_run_id,result_flag,msg=msg)


    #2. Filter by size on office space page
    #Create project space page object
    office_space_obj = PageFactory.get_page_object("office-space",driver)
    min_sqft = Conf_Reader.get_value(conf,'MIN_SQFT')
    max_sqft = Conf_Reader.get_value(conf,'MAX_SQFT')
    expected_result =Conf_Reader.get_value(conf,'EXPECTED_RESULT_FOR_SIZE')
    result_flag = office_space_obj.filter_by_size(min_sqft,max_sqft,expected_result)
    if (result_flag):
        msg = "Search results for filter by size matched the expected result of %s space(s)"%expected_result
    else:
        msg = "Actual result did not match the expected result %s space"%expected_result
    office_space_obj.write(msg)
    
    #Update TestRail
    #Get the case id from tesrail.conf file
    if tconf_flag:
        case_id = Conf_Reader.get_value(tconf,'OFFICESPACE_FILTER_SIZE')
        Test_Rail.update_testrail(case_id,test_run_id,result_flag,msg=msg) 
    

    #3.Open a listing on co-working page
    #Create co-working page object
    coworking_obj = PageFactory.get_page_object("coworking",driver)
    listing_name = Conf_Reader.get_value(conf,'LISTING_NAME_20MISSION')
    listing_href = Conf_Reader.get_value(conf,'LISTING_HREF_20MISSION')
    
    result_flag1 = coworking_obj.verify_listing(listing_name,listing_href)

    if result_flag1:
        result_flag2 = coworking_obj.click_listing(listing_href)
        if result_flag2:
            listing_obj = PageFactory.get_page_object("listing",driver)
            result_flag = listing_obj.verify_listing_name(listing_name)
    if (result_flag):
        msg = "Listing matched for %s"%listing_name
    else:
        msg = "Listing did not match or '0' coworking spaces"
    coworking_obj.write(msg)
    
    #Update TestRail
    #Get the case id from tesrail.conf file
    if tconf_flag:
        case_id = Conf_Reader.get_value(tconf,'COWORKING_LISTING')
        Test_Rail.update_testrail(case_id,test_run_id,result_flag,msg=msg)
          

    #Teardown
    home_obj.wait(3)
    home_obj.teardown() #You can use any page object to teardown  
Exemplo n.º 13
0
                    # code around cases where columns merge together...

                    for j in range(len(data)):
                        record = data[j].split()
                        if len(record) == columns:
                            self._loggraph[current]['data'].append(record)

            return self._loggraph                
        
    return CCP4Decorator()

if __name__ == '__main__':
    if not os.environ.has_key('XIA2CORE_ROOT'):
        raise RuntimeError, 'XIA2CORE_ROOT not defined'

    sys.path.append(os.path.join(os.environ['XIA2CORE_ROOT'],
                                 'Python',
                                 'Driver'))
    
    from DriverFactory import DriverFactory    

    d = DriverFactory.Driver('script')

    d = CCP4DecoratorFactory(d)

    from pydoc import help

    print help(d.__class__)
    
Exemplo n.º 14
0
class Mobile_Base_Page(Borg, unittest.TestCase):
    "Page class that all page models can inherit from"

    def __init__(self,
                 base_url='https://tn-devel.appspot.com/tap',
                 trailing_slash_flag=True):
        "Constructor"
        Borg.__init__(self)
        if self.is_first_time():
            #Do these actions if this the first time this class is initialized
            self.screenshot_counter = 1
            self.set_directory_structure()
            self.set_screenshot_dir()  # Create screenshot directory
            self.image_url_list = []
            self.msg_list = []
            self.window_structure = {}
            self.testrail_flag = False
            self.browserstack_flag = False
            self.driver = None
            self.result_counter = 0  #Increment whenever success or failure are called
            self.pass_counter = 0  #Increment everytime success is called
            self.mini_check_counter = 0  #Increment when conditional_write is called
            self.mini_check_pass_counter = 0  #Increment when conditional_write is called with True
            self.failure_message_list = []

        #We assume relative URLs start without a / in the beginning
        if base_url[-1] != '/' and trailing_slash_flag is True:
            base_url += '/'
        self.base_url = base_url
        self.driver_obj = DriverFactory()
        self.log_obj = Base_Logging(level=logging.DEBUG)
        self.log_obj.set_stream_handler_level(self.log_obj.getStreamHandler(),
                                              level=logging.DEBUG)
        if self.driver is not None:
            self.start()  #Visit and initialize xpaths for the appropriate page

    def switch_page(self, page_name):
        "Switch the underlying class to the required Page"
        self.__class__ = PageFactory.get_page_object(
            page_name, base_url=self.base_url).__class__

    def register_driver(self, sauce_flag, os_name, os_version, browser,
                        browser_version):
        "Register the driver with Page"
        self.driver = self.driver_obj.get_web_driver(sauce_flag, os_name,
                                                     os_version, browser,
                                                     browser_version)
        self.driver.implicitly_wait(5)
        self.driver.maximize_window()
        self.start()

    def register_mobile_driver(self):
        "Register the mobile driver"
        self.driver = self.driver_obj.run_mobile()
        self.start()

    def get_current_driver(self):
        "Return current driver"
        return self.driver

    def get_console_log(self):
        "Return current browser's console logs from driver"
        return self.driver.get_log('browser')

    def get_driver_title(self):
        "Return the title of the current page"
        return self.driver.title

    def get_current_url(self):
        "Return the current url"
        return self.driver.current_url

    def register_testrail(self):
        "Register TestRail with Page"
        self.testrail_flag = True
        self.tr_obj = Test_Rail()
        self.write('Automation registered with TestRail', level='debug')

    def register_browserstack(self):
        "Register Browser Stack with Page"
        self.browserstack_flag = True
        self.browserstack_obj = BrowserStack_Library()

    def set_locator_conf(self, locator_path):
        "Set the path of the configuration file with locators"
        self.xpath_conf_file = locator_path

    def start(self):
        "Dummy method to be over-written by child classes"
        pass

    def _screenshot(func):
        "Decorator for taking screenshot"

        def wrapper(*args, **kwargs):
            result = func(*args, **kwargs)
            screenshot_name = '%003d' % args[
                0].screenshot_counter + '_' + func.__name__
            args[0].screenshot_counter += 1
            args[0].save_screenshot(screenshot_name)
            return result

        return wrapper

    def _exceptionHandler(f):
        "Decorator to handle exceptions"
        argspec = getargspec(f)

        def inner(*args, **kwargs):
            try:
                return f(*args, **kwargs)
            except Exception, e:
                args[0].write('You have this exception')
                args[0].write('Exception in method: %s' % str(f.__name__))
                args[0].write('PYTHON SAYS: %s' % str(e))

        return inner
Exemplo n.º 15
0
from DriverFactory import DriverFactory
from easygui import enterbox
from PlaylistPage import PlaylistPage
from constants import programName
from PlaylistPanel import App

driver = DriverFactory.getDriver()
playListUrl = enterbox("Please enter youtube playlist url below.", programName)
driver.get(playListUrl)
playlistPage = PlaylistPage()
videoPage = playlistPage.clickFirstVideo()
app = App()
DriverFactory.getDriver().close()
Exemplo n.º 16
0
 def goNextVideo(self):
     print("Clicking next button")
     cssExpression = ".ytp-next-button"
     nextButton = DriverFactory.getDriver().find_element_by_css_selector(
         cssExpression)
     nextButton.click()
Exemplo n.º 17
0
 def stopVideo(self):
     print("Clicking stop button")
     cssExpression = ".ytp-play-button"
     playButton = DriverFactory.getDriver().find_element_by_css_selector(
         cssExpression)
     playButton.click()
Exemplo n.º 18
0
def run_demo_test(browser,config_file,base_url,test_run_id=None,sauce_flag=None,browser_version=None,platform=None):
    "Demo Test Run"
    #Setup a driver
    driver_obj = DriverFactory()
    driver = driver_obj.get_web_driver(browser,sauce_flag,browser_version,platform)

    #a) Login
    # get the test account credentials from the .credentials file
    PY_SCRIPTS_PATH=os.path.dirname(__file__)
    dotenv.load_dotenv(os.path.join(PY_SCRIPTS_PATH,"login.credentials"))
    USERNAME = os.environ['LOGIN_USER']
    PASSWORD = os.environ['LOGIN_PASSWORD']
    login_obj = PageFactory.get_page_object("login",driver)
    
    if login_obj.verify_header_text():
        login_obj.write('PASS: Verifed the header text on login page')
    else:
        login_obj.write('FAIL: Header text is not matching on login page')
        
    if login_obj.login(USERNAME,PASSWORD):
        login_obj.write('PASS: Login was successful')
    else:
        login_obj.write('FAIL: Login failed')

    #Create a Bills Page object, verify all fields
    bills_obj = PageFactory.get_page_object('bills',driver)

    #b) Search for a category
    category_name = Conf_Reader.get_value(config_file,'CATEGORY')
    if bills_obj.search_bills(category_name):
        bills_obj.write('PASS: Searched for the bill category: %s.'%category_name)
    else:
        bills_obj.write('FAIL: Was not able to Search for the bill category: %s.'%category_name)

    #c) Go to a specific bill
    bill_number = Conf_Reader.get_value(config_file,'BILL_NUMBER')
    if bills_obj.goto_specific_bill(bill_number):
        bills_obj.write('PASS: Clicked on bill number: %s'%bill_number)
    else:
        bills_obj.write('FAIL: Unable to click on bill number: %s'%bill_number)
        
    #Verify the bill number 
    if bills_obj.verify_bill_number(bill_number):
        bills_obj.write('PASS: Obtained the expected bill number: %s'%bill_number)
    else:
        bills_obj.write('FAIL: Obtained an unexpected bill number: %s'%bills_obj.get_bill_number())
        bills_obj.write('\t\tEXPECTED: %s'%bill_number)
        
    #Verify the state name
    state_name = Conf_Reader.get_value(config_file,'STATE_NAME')
    if bills_obj.verify_state_name(state_name):
        bills_obj.write('PASS: Obtained the expected state name: %s'%state_name)
    else:
        bills_obj.write('FAIL: Obtained an unexpected state name: %s'%bills_obj.get_state_name())
        bills_obj.write('\t\tEXPECTED: %s'%state_name)
    
    #Verify the session
    session_name = Conf_Reader.get_value(config_file,'SESSION')
    if bills_obj.verify_session_name(session_name):
        bills_obj.write('PASS: Obtained the expected session: %s'%session_name)
    else:
        bills_obj.write('FAIL: Obtained an unexpected session: %s'%bills_obj.get_session())
        bills_obj.write('\t\tEXPECTED: %s'%session_name)

    #Verify the title
    title_name = Conf_Reader.get_value(config_file,'TITLE')
    if bills_obj.verify_title_name(title_name):
        bills_obj.write('PASS: Obtained the expected title: %s'%title_name)
    else:
        bills_obj.write('FAIL: Obtained an unexpected title: %s'%bills_obj.get_title())
        bills_obj.write('\t\tEXPECTED: %s'%title_name)

    #Verify the description
    description_name = Conf_Reader.get_value(config_file,'DESCRIPTION')
    if bills_obj.verify_description_name(description_name):
        bills_obj.write('PASS: Obtained the expected description: %s'%description_name)
    else:
        bills_obj.write('FAIL: Obtained an unexpected description: %s'%bills_obj.get_description())
        bills_obj.write('\t\tEXPECTED: %s'%description_name)

    #Verify the category
    category_name = Conf_Reader.get_value(config_file,'CATEGORIES')
    if bills_obj.verify_category_name(category_name):
        bills_obj.write('PASS: Obtained the expected category: %s'%category_name)
    else:
        bills_obj.write('FAIL: Obtained an unexpected category: %s'%bills_obj.get_category())
        bills_obj.write('\t\tEXPECTED: %s'%category_name)

    #{?)Verify the forecast - we expect this to change
    #We wont know how to design a good check until we know the underlying algorithm
    fiscalnote_forecast = Conf_Reader.get_value(config_file,'FISCALNOTE_FORECAST')
    if bills_obj.verify_fiscalnote_forecast(fiscalnote_forecast):
        bills_obj.write('PASS: Obtained the expected forecast: %s'%fiscalnote_forecast)
    else:
        bills_obj.write('FAIL: Obtained an unexpected forecast: %s'%bills_obj.get_forecast())
        bills_obj.write('\t\tEXPECTED: %s'%fiscalnote_forecast)

    #(?)Verify the floor - we expect this to change
    #We wont know how to design a good check until we know the underlying algorithm
    floor = Conf_Reader.get_value(config_file,'FLOOR')
    if bills_obj.verify_floor(floor):
        bills_obj.write('PASS: Obtained the expected floor: %s'%floor)
    else:
        bills_obj.write('FAIL: Obtained an unexpected floor: %s'%bills_obj.get_floor())
        bills_obj.write('\t\tEXPECTED: %s'%floor)

    #W00t! Close the browser
    driver.quit()
Exemplo n.º 19
0
class Base_Page(Borg, unittest.TestCase):
    "Page class that all page models can inherit from"

    def __init__(self, base_url='http://qxf2.com/', trailing_slash_flag=True):
        "Constructor"
        Borg.__init__(self)
        if self.is_first_time():
            #Do these actions if this the first time this class is initialized
            self.set_directory_structure()
            self.image_url_list = []
            self.msg_list = []
            self.current_console_log_errors = []
            self.window_structure = {}
            self.testrail_flag = False
            self.browserstack_flag = False

            self.reset()

        #We assume relative URLs start without a / in the beginning
        if base_url[-1] != '/' and trailing_slash_flag is True:
            base_url += '/'
        self.base_url = base_url
        self.driver_obj = DriverFactory()
        if self.driver is not None:
            self.start()  #Visit and initialize xpaths for the appropriate page

    def reset(self):
        "Reset the base page object"
        self.driver = None
        self.result_counter = 0  #Increment whenever success or failure are called
        self.pass_counter = 0  #Increment everytime success is called
        self.mini_check_counter = 0  #Increment when conditional_write is called
        self.mini_check_pass_counter = 0  #Increment when conditional_write is called with True
        self.failure_message_list = []
        self.screenshot_counter = 1

    def get_failure_message_list(self):
        "Return the failure message list"
        return self.failure_message_list

    def switch_page(self, page_name):
        "Switch the underlying class to the required Page"
        self.__class__ = PageFactory.PageFactory.get_page_object(
            page_name, base_url=self.base_url).__class__

    def register_driver(self, browserstack_flag, os_name, os_version, browser,
                        browser_version):
        "Register the driver with Page"
        self.driver = self.driver_obj.get_web_driver(browserstack_flag,
                                                     os_name, os_version,
                                                     browser, browser_version)
        self.set_screenshot_dir()  # Create screenshot directory
        self.log_obj = Base_Logging(level=logging.DEBUG)
        self.log_obj.set_stream_handler_level(self.log_obj.getStreamHandler(),
                                              level=logging.DEBUG)
        self.driver.implicitly_wait(5)
        self.driver.maximize_window()
        if (browserstack_flag.lower() == 'y'):
            print "Before registering bs"
            self.register_browserstack()
            self.session_url = self.browserstack_obj.get_session_url()
            self.browserstack_msg = 'BrowserStack session URL:'
            self.write(self.browserstack_msg + '\n' + str(self.session_url))
        self.start()

    def get_current_driver(self):
        "Return current driver"

        return self.driver

    def register_testrail(self):
        "Register TestRail with Page"
        self.testrail_flag = True
        self.tr_obj = Test_Rail()

    def register_browserstack(self):
        "Register Browser Stack with Page"
        self.browserstack_flag = True
        self.browserstack_obj = BrowserStack_Library()

    def get_calling_module(self):
        "Get the name of the calling module"
        calling_file = inspect.stack()[-1][1]
        if 'runpy' in calling_file:
            calling_file = inspect.stack()[5][1]
        calling_filename = calling_file.split(os.sep)

        #This logic bought to you by windows + cygwin + git bash
        if len(calling_filename) == 1:  #Needed for
            calling_filename = calling_file.split('/')

        self.calling_module = calling_filename[-1].split('.')[0]

        return self.calling_module

    def set_directory_structure(self):
        "Setup the required directory structure if it is not already present"
        try:
            screenshots_parent_dir = os.path.abspath(
                os.path.join(os.path.dirname(__file__), '..', 'screenshots'))
            if not os.path.exists(screenshots_parent_dir):
                os.makedirs(screenshots_parent_dir)
        except Exception, e:
            self.write("Exception when trying to set directory structure")
            self.write(str(e))