run_test.py

#!/usr/bin/env python
# encoding: utf-8

import sys
import os
from selenium import webdriver
import unittest
import nose
from nose.plugins.multiprocess import MultiProcess
from optparse import OptionParser
import new
import json
import httplib
import base64
from time import sleep

parser = OptionParser()
parser.add_option("-b", "--browsers", dest="browsers",
                  help="Browsers to run tests: ie6,ie7,ff2,ff3.6,gc,sf4,op10",
                  metavar="BROWSERS", default='ff8')
parser.add_option("-r", "--resolution", dest="resolution",
                  help="Resolution to run tests on", metavar="RESOLUTION",
                  default=None)
parser.add_option("-s", "--selenium", dest="sversion",
                  help="Selenium version to run tests on", metavar="VERSION",
                  default=None)
parser.add_option("-B", "--breakpoint", dest="breakpoint",
                  help="freeze test during execution", action="store_true",
                  default=False)
parser.add_option("-p", "--production",
                  action="store_true", dest="production", default=False,
                  help="Run tests in prod, using sso")
parser.add_option("-f", "--run-forever",
                  action="store_true", dest="run_forever", default=False,
                  help="Run tests in an infinite loop.")
parser.add_option("-n", "--node", dest="node", default=None,
                  help="specify a node to run test on")

(options, args) = parser.parse_args()

if options.production:
    user = os.environ['SAUCE_USER']
    key = os.environ['SAUCE_KEY']
    host = 'ondemand.saucelabs.com'
    port = 80
    url = 'https://saucelabs.com'
else:
    user = 'admin'
    key = ''
    host = 'scottdixon.dev.saucelabs.net'
    port = 4444
    url = 'https://scottdixon.dev.saucelabs.net'

chosen_browsers = (args[0] if len(args) else options.browsers).split(",")


class ManualTestSe2(unittest.TestCase):
    __test__ = False

    def setUp(self):
        dc = {'platform': self.os,
              'browserName': self.br,
              'version': self.version,
              'name': self.name,
              'selenium-version': options.sversion,
              'screen-resolution': options.resolution,
              'timeZone': 'Central',
              "maxDuration": 8000
              }
        if options.node:
            dc['_sauce-cloud-node'] = options.node
        self.driver = webdriver.Remote(desired_capabilities=dc,
                                       command_executor="http://%s:%s@%s:%s/wd/hub" %
                                       (user, key, host, port))
        self.driver.implicitly_wait(5)

    def test_basic(self):
        driver = self.driver
        if options.run_forever:
            while True:
                for i in range(4):
                    for url in ['http://www.google.com', 'http://www.twitter.com']:
                        driver.get(url)
                        sleep(5)

        for url in ['http://www.google.com', 'http://www.twitter.com']:
            driver.get(url)
            for i in range(30):
                if driver.title:
                    agent = driver.execute_script("return navigator.userAgent;")
                    print agent
                    if options.breakpoint:
                        self.driver.execute_script("sauce: break")
                    break
            else:
                self.fail("title never showed")

    def report_pass_fail(self):
        # Sauce doesn't really know what the test in your end does with the
        # browser, let us know
        base64string = base64.encodestring('%s:%s' % (user, key))[:-1]
        passed = sys.exc_info() == (None, None, None)
        if not passed:
            print "Job: https://saucelabs.com/jobs/%s" % self.driver.session_id
        result = json.dumps({'passed': passed})
        connection = httplib.HTTPConnection('saucelabs.com')
        connection.request('PUT', '/rest/v1/%s/jobs/%s' % (user,
                                                           self.driver.session_id),
                           result,
                           headers={"Authorization": "Basic %s" % base64string})
        result = connection.getresponse()
        return result.status == 200

    def tearDown(self):
        self.report_pass_fail()
        self.driver.quit()

oses = {'t': 'Windows 10',
        'p': 'Windows 2012 R2',
        's': 'Windows 2008',
        'e': 'Windows 2012',
        'x': 'Windows 2003',
        'l': 'Linux',
        'm': 'Mac 10.6',
        'i': 'Mac 10.8',
        'n': 'Mac 10.9',
        'y': 'Mac 10.10',
        'c': 'Mac 10.11',
        'a': 'ANY'}
classes = {}
for i, br in enumerate(chosen_browsers):

    test = ManualTestSe2
    browsers = {"ff": "firefox",
                "op": "opera",
                "ie": "internet explorer",
                "ed": "microsoftedge",
                "sa": "safari",
                "ip": "ipad",
                "ih": "iphone",
                "an": "android",
                "gc": "chrome"}

    browser = browsers[br[:2]]
    if br[-1] in oses:
        os = oses.get(br[-1])
        version = br[2:-1]
    else:
        os = None
        version = br[2:]
    name = "%s_%s_%s_%s_%s" % (test.__name__, i, os, browser, version)
    name = name.encode('ascii')
    if name.endswith("."):
        name = name[:-1]
    for x in ".-_":
        name = name.replace(x, " ")

    d = dict(test.__dict__)
    d.update({'__test__': True,
              '__name__': name,
              'name': name,
              'os': os,
              'br': browser,
              'version': version,
              })

    classes[name] = new.classobj(name, (test,), d)
globals().update(classes)

if __name__ == "__main__":
    nose.core.run(argv=['--nocapture', "-v", "--processes", len(chosen_browsers),
                        "--process-timeout", "1800", __file__],
                  plugins=[MultiProcess()])