def setUpClass(self):
     #self.driver = webdriver.Ie('c:\\local\\bin\\IEDriverServer.exe')
     chrome_options = Options()
     chrome_options.add_argument("--start-maximized")
     #chrome_options.add_argument("--disable-native-events")
     #self.driver = webdriver.Chrome('c:\\local\\bin\\chromedriver.exe',chrome_options=chrome_options)
     self.driver = webdriver.Firefox()

def initiateChromeWithSize(width, height, pixelRatio=2.0):
    mobile_emulation = {
    "deviceMetrics": { "width": width, "height": height, "pixelRatio": pixelRatio },
    "userAgent": "Mozilla/5.0 (Linux; Android 4.2.1; en-us; Nexus 5 Build/JOP40D) AppleWebKit/535.19 (KHTML, like Gecko) Chrome/18.0.1025.166 Mobile Safari/535.19" }
    chrome_options = Options()
    chrome_options.add_experimental_option("mobileEmulation", mobile_emulation)
    return webdriver.Chrome(chrome_options=chrome_options)

    def take(self, location: Location) -> str:
        """
        Take a screenshot using chrome webdriver.

        Args:
            location: The location of the map's center point.

        Returns:
            The screenshot's full path.

        """
        context: Context = {
            "key": self.api_key,
            "latitude": location.latitude,
            "longitude": location.longitude,
            "zoom": location.zoom,
        }
        map_html = os.path.join(self._tmpdir, "map.html")
        render_template(os.path.join(self._template_dir, "map.j2"), context, map_html)

        options = Options()
        options.set_headless(headless=True)
        driver = webdriver.Chrome(
            executable_path=self.webdriver_path, chrome_options=options
        )
        driver.set_window_size(self.width, self.height)
        driver.get("file://%s" % map_html)
        time.sleep(5)
        self.path = os.path.join(self.output_dir, "map.png")
        driver.save_screenshot(self.path)
        driver.quit()
        return self.path

def get_games_id(comp):

    dates = [d for d in date_range(START_DATE, END_DATE)]
    games_id = []

    chrome_options = Options()
    chrome_options.add_argument('--dns-prefetch-disable')
    driver = Chrome(chrome_options=chrome_options)

    for day in dates:
        driver.get(
            'http://www.espn.com.ar/futbol/resultados/_/liga/{}/fecha/{}'.
            format(comp, day)
        )

        game_link_driver = driver.find_elements_by_class_name(
            'mobileScoreboardLink  '
        )

        for game_driver in game_link_driver:
            game_id = game_driver.get_attribute('href')[46:53]
            games_id.append((game_id, day))

        driver.quit

    # print(games_id)
    return games_id

    def setUp(self):

        chromium_path = '/usr/bin/chromium'
        chromedriver_path = './chromedriver'
        
        opts = Options()
        opts.binary_location = chromium_path
        opts.add_experimental_option("prefs", {
            "download.default_directory": "./test_downloaded", 
            "helperApps.neverAsk.saveToDisk": "octet/stream", 
            "directory_upgrade": True,
            "profile": {"default_content_settings": {"multiple-automatic-downloads": 1}}
            })
        
        self.driver = webdriver.Chrome(chrome_options=opts, executable_path=chromedriver_path)

        #self.driver = webdriver.Firefox()        
        url = os.getenv('TEST_URL', config.url)
        self.driver.get(url)

        self.__load_pages()

        # Sets up by redirecting to login page
        main_page = page.MainPage(self.driver)
        main_page.click_login_link()

 def _new_webdriver(self, browser=None, *args, **kwargs):
     browser = self.expand_browser_name(browser)
     # Setup display before creating the browser
     self.setup_display()
     def append_service_arg(arg):
         service_args = kwargs.get('service_args', [])
         service_args.append(arg)
         kwargs['service_args'] = service_args
     if browser == 'PhantomJS':
         append_service_arg('--ignore-ssl-errors=true')
     if (browser == 'Firefox'
     and self.global_settings.get('webdriver_firefox_profile')
     and not args and not kwargs.has_key('firefox_profile')):
         # Update with profile specified from config
         fp = webdriver.FirefoxProfile(self.global_settings.get('webdriver_firefox_profile'))
         kwargs['firefox_profile'] = fp
     if (browser == 'Chrome' and os.name == 'posix' and os.geteuid() == 0):
         self.log.w('Passing --no-sandbox flag to Chrome (running as root)')
         from selenium.webdriver.chrome.options import Options
         chrome_options = Options()
         chrome_options.add_argument('--no-sandbox')
         #self.log.w('Adding --disable-application-cache')
         #chrome_options.add_argument('--disable-application-cache')
         #chrome_options.add_argument('--incognito')
         kwargs['chrome_options'] = chrome_options
     driver = getattr(webdriver, browser)(*args, **kwargs)
     return driver

def findSnItemPrice(itemId):
  itemUrl = urlTemplate.replace('{itemId}', str(itemId))
  #print("itemUrl=%s" % itemUrl)
  

  #driver = webdriver.PhantomJS()
  chrome_options = Options()
  chrome_options.add_argument('--headless')
  chrome_options.add_argument('--disable-gpu')
  driver = webdriver.Chrome(chrome_options=chrome_options)
  driver.get(itemUrl)
  html = driver.page_source
  #print(html)  

  bsObj = BeautifulSoup(html,"html.parser")
  priceList=bsObj.findAll("span",{"class":"mainprice"})  
  itemNameList = bsObj.findAll("h1", {"id":"itemDisplayName"})
  itemName = itemNameList[0].get_text()
  promDescList = bsObj.findAll("h2", {"id":"promotionDesc"})
  promDesc = promDescList[0].get_text()
  #print(priceList)
  #print(itemNameList)
  if len(priceList)>0:
    for price in priceList:  
      strPrice = price.get_text().replace('¥','').replace('.00','')
      print("itemId=%s,price:%d,itemName:%s,promDesc:%s" % (itemId,int(strPrice), itemName, promDesc))
  else:
      strPrice = "-1"
      print("itemId=%s,price:%d,itemName:%s,promDesc:%s" % (itemId,int(strPrice), itemName, promDesc))

 def getDriver(self, browser, local=False):
     if browser == "firefox":
         cap = DesiredCapabilities.FIREFOX
     if browser == "ie":
         cap = DesiredCapabilities.INTERNETEXPLORER
     if browser == "chrome":
         cap = DesiredCapabilities.CHROME
         options = Options()
         options.add_argument("--disable-extensions")
         options.add_argument("test-type")
     if browser == "mobile chrome":
         cap = {}
         cap['browserName'] = "Chrome"
         cap['platformName'] = "Android"
         cap['deviceName'] = "android"
     if browser == "android":
         cap = {}
         cap['browserName'] = "Browser"
         cap['platformName'] = "Android"
         cap['deviceName'] = "android"
     if local:
       return webdriver.Chrome()
     else:
       return webdriver.Remote(
                               command_executor='http://10.238.242.50:4444/wd/hub',
                               desired_capabilities=cap
                              )

 def __init__(self, scenario, download_directory=default_download_directory,
              app_host=None, app_port=None, executable_path=None,
              pages=None):
     # Contract
     must_be(download_directory, "download_directory", (type(None), str))
     must_be(app_host, "app_host", (type(None), str))
     must_be(app_port, "app_port", (type(None), Number))
     must_be(executable_path, "executable_path", (type(None), str))
     must_be(pages, "pages", (dict, type(None)))
     # TODO[TJ]: This should be implemented as part of the future contracts
     # library
     if pages is not None:
         for key, value in pages.items():
             must_be(key, "pages key", str)
             must_be(value, "pages value", AppPage)
     #
     self.scenario = scenario
     if download_directory is not None:
         options = ChromeOptions()
         prefs = {"download.default_directory": download_directory}
         options.add_experimental_option('prefs', prefs)
     else:
         options = None
     if app_host is not None:
         self.app_host = app_host
     if app_port is not None:
         self.app_port = app_port
     if executable_path is not None:
         self.executable_path = executable_path
     self.pages = pages
     super(ChromeBrowser, self).__init__(
         executable_path=self.executable_path, chrome_options=options)
     register_exit(self.quit)

def before_all(context):
    call( [ "killall", "-9", "chrome" ] )
    options = Options()
    options.add_extension(path_to_chrome_extension)
    #options.add_argument("--remote-debugging-port=9222")
    options.add_argument("--start-maximized")
    context.driver = webdriver.Chrome(executable_path=path_to_chrome_driver, chrome_options=options)

    def __init__(self):
        if(platform.system()=="Linux"):
            self.BASE_PATH = os.path.dirname(os.path.realpath(__file__))
            self.CHROMEDRIVER_PATH = r"%s/libs/selenium_drivers/chromedriver" % (self.BASE_PATH)
            self.WINDOW_SIZE = "1920,1080"

            self.chrome_options = Options()  
            self.chrome_options.add_argument("--headless") 
            self.chrome_options.add_argument("--no-sandbox")
            self.chrome_options.add_argument("--disable-dev-shm-usage") 
            self.chrome_options.add_argument("--window-size=%s" % self.WINDOW_SIZE)

        elif(platform.system()=="Windows"):
            self.BASE_PATH = os.path.dirname(os.path.realpath(__file__))
            self.CHROMEDRIVER_PATH = r"%s/libs/selenium_drivers/chromedriver.exe" % (self.BASE_PATH)
            self.WINDOW_SIZE = "1920,1080"

            self.chrome_options = Options()
            self.chrome_options.add_argument("--headless")
            self.chrome_options.add_argument("--window-size=%s" % self.WINDOW_SIZE)

        self.driver = webdriver.Chrome(
            executable_path=self.CHROMEDRIVER_PATH,
            chrome_options=self.chrome_options
        )

def makeConnection(SERVER, USER, PASSWORD):
    url = 'https://'+SERVER+'/'

    chrome_options = Options() 
    chrome_options.add_argument("--headless") 
    chrome_options.binary_location = '/usr/bin/chromium-browser' 
    driver = webdriver.Chrome(executable_path= os.path.expanduser('~/usr/local/bin/chromedriver') , chrome_options=chrome_options) 
    driver.get(url)
    time.sleep(1)
    driver.save_screenshot(os.path.join(os.path.dirname(os.path.realpath(__file__)), '/tmp', 'kk1.png'))


    elemU = driver.find_element_by_name("username")
    #while elemU:
    print("Identifying...")
    elemP = driver.find_element_by_name("password")
    elemU.clear()
    elemU.send_keys(USER)
    elemP.clear()
    elemP.send_keys(PASSWORD)

    driver.save_screenshot(os.path.join(os.path.dirname(os.path.realpath(__file__)), '/tmp', 'kk2.png'))

    elemP.send_keys(Keys.RETURN) 
    time.sleep(1)
    #    try: 
    #        elemU = driver.find_element_by_name("username").clear()
    #    except: 
    #        elemU = None

    driver.save_screenshot(os.path.join(os.path.dirname(os.path.realpath(__file__)), '/tmp', 'kk3.png'))

    return driver

def login(username, password):
    """
    Using the given username and password, logs into MyNEU through a
    selenium driver (firefox). Returns the driver object
    """
    opts = Options()
    opts.add_argument("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.71 Safari/537.36")

    driver = webdriver.Chrome(chrome_options=opts)
    # Go to the login page
    login_page = driver.get(LOGIN_PAGE)

    # Find the user and password forms
    user_form = driver.find_element_by_id("username")
    pass_form = driver.find_element_by_id("password")

    # Login in with the given credentias
    user_form.send_keys(username)
    pass_form.send_keys(password)

    # Click the login button
    #button_class = driver.find_element_by_class_name("buttons")
    button = driver.find_element_by_class_name("btn-submit")
    button.click()


    # Also change the size so it all works fine
    driver.set_window_size(1280, 800)
    # Return the driver so we can do more with it
    return driver

def before_feature(context, feature):
    chrome_options = Options()
    if 'headless' in context.tags:
        chrome_options.add_argument("--headless")
    chrome_options.add_argument("--window-size=1024,768")
    context.browser = webdriver.Chrome(
        chrome_options=chrome_options,
        executable_path="/home/sinan/Downloads/selenium/chromedriver")
        # C:\Users\sinan\Downloads\chromedriver_win32_2.0\chromedriver.exe
    context.browser.implicitly_wait(3)


    """ Kullanacağımız değişkenleri setleyelim. """
    context.STOREFRONT = {
        "homepage": "https://www.hepsiburada.com",
        "cart":     "/ayagina-gelsin/sepetim",
        "login":    "/ayagina-gelsin/giris"
    }

    context.CATEGORIES = {
        "uzaktan_kumanda": "/uzaktan-kumandali-arabalar-c-14001244"
    }

    context.LOGIN_INFO = {
        "mail":     "[email protected]",
        "password": "test112233"
    }

def instantiate_webdriver(webdriver_class):
    if webdriver_class is Firefox:
        def webdriver_class():
            profile = FirefoxProfile()

            # Make sure Firefox WebDriver addon works, even if it could not be verified
            profile.set_preference('xpinstall.signatures.required', False)
            webdriver = Firefox(profile)
            return webdriver

    elif webdriver_class is Chrome:
        options = ChromeOptions()

        # If popup blocking is enabled spawning new window handles via JavaScript won't work!
        options.add_argument('disable-popup-blocking')
        webdriver_class = functools.partial(webdriver_class, chrome_options=options)
    elif webdriver_class is PhantomJS:
        def webdriver_class():
            webdriver = PhantomJS()
            # Fix Selenium PermissionError when trying to delete PhantomJS cookie files by simply not creating a cookie
            # file.
            webdriver.service._cookie_temp_file = None
            return webdriver

    try:
        return webdriver_class()
    # Selenium raises Exception directly in some WebDriver classes...
    except Exception:
        pytest.skip('WebDriver not available')

 def get_driver(self):
     executable_path = self.exec_path
     opts = Options()
     opts.add_argument('--incognito')
     if self.mobile:
         opts.add_argument('user-agent=' + _MOBILE_BROWSER_USER_AGENT)
     return webdriver.Chrome(self.exec_path, chrome_options = opts)

def start_up():
    global driver
    chrome_options = Options()
    chrome_options.add_argument('load-extension=../')
    print 'Opening a Chrome browser'
    driver = webdriver.Chrome(chrome_options=chrome_options)
    time.sleep(1)

def play_video_1(proxy, av):
    # print(i)
    print(proxy)
    # av = "av41724649"
    chrome_options = Options()
    chrome_options.add_argument("--proxy-server=http://{0}".format(proxy))

    drive = webdriver.Chrome(options=chrome_options)
    # drive = webdriver.Chrome()
    av_url = "https://www.bilibili.com/video/{0}/?spm_id_from=333.788.videocard.4".format(av)
    print(av_url)

    # drive.get("https://www.bilibili.com/video/av41724649/")
    try:
        drive.get(av_url)
        video = WebDriverWait(drive, 10, 0.5).until(
            EC.presence_of_element_located((By.XPATH, "//*[@id='bilibiliPlayer']/div[1]/div[1]/div[8]/video")))  # 找到视频
        url = drive.execute_script("return arguments[0].currentSrc;", video)  # 打印视频地址
        print(url)

        print("start")
        drive.execute_script("return arguments[0].play()", video)  # 开始播放
        time.sleep(10)

        print("stop")
        drive.execute_script("return arguments[0].pause()", video)  # 暂停
    except Exception as e:
        print('except: {0}'.format(e))
    finally:
        drive.close()

    def newDriver():
        if os.getenv('TRAVIS') == 'true':
            options = Options()
            options.add_argument("--no-sandbox")
            return webdriver.Chrome(chrome_options=options)

        return webdriver.Chrome()

def loginToInterface(isMac, chrome, driver, host, port=8686, username='admin', password='[email protected]#123'):
    logCommon.info('Will start web browser and perform test case.')
    chromeDriver = os.path.normpath(driver)
    logCommon.info('Browser driver path: ' + str(chromeDriver))
    os.environ["webdriver.chrome.driver"] = chromeDriver
    opts = Options()
    if (not isMac):
        opts = Options()
        opts.binary_location = os.path.normpath(chrome)
    else:
        opts.add_argument("--start-maximized")
    driver = webdriver.Chrome(chromeDriver, chrome_options=opts)
    # options.add_argument("--start-maximized")
    # driver.set_window_size(1024, 600)
    driver.maximize_window()
    # go to the google home page
    index = 'http://' + str(host) + ':' + str(port) + '/XOAM/login/index.html'
    logCommon.info('Web page: ' + str(index))
    driver.get(index)
    driver.find_element_by_id('loginUsername').clear()
    driver.find_element_by_id('loginUsername').send_keys(username)
    driver.find_element_by_id('loginPassword').clear()
    driver.find_element_by_id('loginPassword').send_keys(password)
    driver.find_element_by_id('submit').click()
    try:
        WebDriverWait(driver, 20).until(EC.presence_of_element_located((By.ID, "ebBtnSearch")))
        logCommon.info('Login to the InterfaceManagement page successfully.')
    except Exception as e:
        logCommon.error('Login to the InterfaceManagement page failed.')
        return False
    return driver