def init_test(total_tests, config=None, hostname=None, build=None):
isinstance(config, dict)
VasTestCase.totalTests = total_tests
VasTestCase.version = build
VasTestCase.logger = logging.getLogger(hostname)
if config.has_key("usesite"):
VasTestCase.useSite = config["usesite"]
else:
VasTestCase.useSite = False
osinfo = eval(config.get('osinfo', "{}"))
# Domains
VasTestCase.domain = config.get("domain", "a.sb")
VasTestCase.crossdomain = config.get("crossdomain", "b.sb")
VasTestCase.crossforest = config.get("crossforest", "c.sb")
VasTestCase.schemalessDomain = config.get("schemalessdomain", "d.sb")
VasTestCase.noqacdomain = config.get("noqacdomain", "e.sb")
VasTestCase.onewayTrustDomain = config.get("onewaytrustdomain", "g.sb")
VasTestCase.nowayTrustDomain = config.get("nowaytrustdomain", "l.sb")
VasTestCase.rodcDomain = config.get("rodc", "r.sb")
VasTestCase.defaultDomain = domain_ext(VasTestCase.domain)
VasTestCase.crossdomain = domain_ext(VasTestCase.crossdomain)
VasTestCase.crossforest = domain_ext(VasTestCase.crossforest)
VasTestCase.schemalessDomain = domain_ext(VasTestCase.schemalessDomain)
VasTestCase.noqacdomain = domain_ext(VasTestCase.noqacdomain)
VasTestCase.onewayTrustDomain = domain_ext(VasTestCase.onewayTrustDomain)
VasTestCase.nowayTrustDomain = domain_ext(VasTestCase.nowayTrustDomain)
VasTestCase.rodcDomain = domain_ext(VasTestCase.rodcDomain)
# Windows user
VasTestCase.winUser = config.get("winuser", "Administrator")
VasTestCase.winPasswd = config.get("winpasswd", "Omega3butter")
VasTestCase.domainAdmin = User("{}@{}".format(VasTestCase.winUser, VasTestCase.domain), VasTestCase.winPasswd)
VasTestCase.previousBuild = config.get("previousVersion", "4.0.3.184")
VasTestCase.loginuserpasswd = config.get("loginuserpasswd", "test123")
username = config.get("username", "root")
password = config.get("password", "test123")
VasTestCase.upnMode = config.get("upnmode", False)
VasTestCase.mount = config.get("mount", True)
# Test Group
VasTestCase.testgroup = config.get("testgroup", "QAS - {}".format(build))
# Create computer
VasTestCase.computer = create_computer_with_hostname(hostname, username, password, VasComputer,
domainAdmin=VasTestCase.domainAdmin, domain=VasTestCase.defaultDomain,
prod_version=VasTestCase.version, **osinfo)
assert VasTestCase.computer.is_connected, "Unable to log into {}".format(hostname)
def init_test(config, hostname, build):
isinstance(config, dict)
osinfo = eval(config.get('osinfo'))
pangaeaTestCase.version = build
pangaeaTestCase.logger = logging.getLogger(hostname)
pangaeaTestCase.server = config.get("server")
pangaeaTestCase.spath = config.get("scriptpath", "H:\\")
pangaeaTestCase.drive_letter = config.get("driveletter", "p:")
pangaeaTestCase.previousBuild = config.get("previousVersion", "5.6.0.040")
# Users
pangaeaTestCase.winUser = config.get("winuser", "Administrator")
pangaeaTestCase.winPassword = config.get("winpassword", "test123")
# Domain
pangaeaTestCase.domain = config.get("domain", "h.qas")
pangaeaTestCase.defaultDomain = domain_ext(pangaeaTestCase.domain)
# Open connections to test computer and peers
if osinfo == {}:
print "Please add 'osinfo = {'os':'[value]','distro':'[value]','osversion':[value],'arch':'[value]'}' to your ini file"
connected = False
else:
if osinfo["os"] != "Windows":
pangaeaTestCase.logger.error("Pangaea UI tests will be ran on Windows only")
connected = False
else:
pangaeaTestCase.computer = create_computer_with_hostname(hostname, pangaeaTestCase.winUser, pangaeaTestCase.winPassword, pangaeaComputer, domain=pangaeaTestCase.defaultDomain, **osinfo)
connected = pangaeaTestCase.computer.is_connected
assert connected, 'There was a problem trying to connect to computer'
# We need to mount the share
#pangaeaTestCase.computer.net_use_map_drive("\\\\slcflsl01.prod.quest.corp\RD-PANGAEA-DEV-BUILD", pangaeaTestCase.drive_letter, auth=True)
# We also need to mount hal because thats where the powershell scripts are located.
# Everything is now under this location
pangaeaTestCase.computer.net_use_map_drive("hal9000.vintela.com:/automation/powershell", pangaeaTestCase.drive_letter)
# Set execution policy
pangaeaTestCase.computer.remoteShell.run("Set-ExecutionPolicy bypass -force")
return pangaeaTestCase
def init_test(total_tests, config=None, hostname=None, build=None):
isinstance(config, dict)
mcuTest.total_tests = total_tests
mcuTest.logger = logging.getLogger(hostname)
# Web browser
mcuTest.remoteWebBrowser = config.get("remotewebbrowser", None)
mcuTest.browser = config.get("browser", None)
# Computers
mcuTest.qpmserver = config.get("qpmserver", None)
mcuTest.qpmuserver = config.get("qpmuserver", None)
mcuTest.managedClient = config.get("managedclient", None)
mcuTest.cliComputer = config.get("cliComputer", None)
mcuTest.powershellComputer = config.get("powershellcomputer", None)
# Domain
mcuTest.serverPlatform = config.get("serverplatform", "Linux")
mcuTest.domain = config.get("domain", "h.qas")
mcuTest.defaultDomain = domain_ext(mcuTest.domain)
# Users
mcuTest.linuxUser = config.get("linuxUser", "root")
mcuTest.password = config.get("password", "test123")
mcuTest.winUser = config.get("winuser", "Administrator")
mcuTest.winPassword = config.get("winpassword", "test123")
#mcuTest.server = create_computer_with_hostname(winserver, wu, wp)
# Versions
mcuTest.version = build
mcuTest.qasVersion = config.get("qasversion", "4.0.3.92")
mcuTest.qpm4sVersion = config.get("qpm4sversion", None)
mcuTest.mcuInstalledjvm = config.get("mcuinstalledjvm","32-bit")
# Logging and debug
mcuTest.logDirectory = config.get("logdirectory", "/var/www/MCU")
mcuTest.runWithDebug = config.get("runwithdebug", True)
shelltype = "powershell"
# Package Location
mcuTest.packagePath = config.get("packagepath", None)
if mcuTest.runWithDebug == "True":
mcuTest.runWithDebug = True
else:
mcuTest.runWithDebug = False
# Test Group
mcuTest.testgroup = config.get("testgroup", "MCU - {}".format(build))
mcuTest.pkgs_needed_list = []
# Opens the bullseye server connection
mcuTest.logger.info("\nOpening connection | MCU Server...")
mcuTest.logger.info("-----------------------------------------------")
if mcuTest.serverPlatform == "Windows":
mcuTest.computer = create_computer_with_hostname(hostname, mcuTest.winUser, mcuTest.winPassword, mcuComputer, shelltype, domain=mcuTest.defaultDomain)
else:
mcuTest.computer = create_computer_with_hostname(hostname, mcuTest.linuxUser, mcuTest.password, mcuComputer, domain=mcuTest.defaultDomain)
mcuTest.computer.lock_on_computer()
assert mcuTest.computer.is_connected, 'There was a problem trying to connect to computer'
mcuTest.pkgs_needed_list.append(mcuTest.computer.os)
mcuTest.computer.check_and_mount_default_mounts()
# Open the connection to the managed client
if mcuTest.managedClient != None:
mcuTest.logger.info("\nOpening connection | managed client...")
mcuTest.logger.info("-----------------------------------------------")
mcuTest.mc_computer = create_computer_with_hostname(mcuTest.managedClient, mcuTest.linuxUser, mcuTest.password, mcuComputer, domain=mcuTest.defaultDomain)
assert mcuTest.mc_computer.is_connected, 'There was a problem trying to connect to the managed client'
mcuTest.pkgs_needed_list.append(mcuTest.mc_computer.os)
mcuTest.mc_computer.check_and_mount_default_mounts()
# If there is a qpm4s and qpm4u server then open connection
# Open the connection to the qpm server
if mcuTest.qpmserver != None:
mcuTest.logger.info("\nOpening connection | qpm server...")
mcuTest.logger.info("-----------------------------------------------")
mcuTest.qpm_computer = create_computer_with_hostname(mcuTest.qpmserver, mcuTest.linuxUser, mcuTest.password, mcuComputer, domain=mcuTest.defaultDomain)
assert mcuTest.qpm_computer.is_connected, 'There was a problem trying to connect to the qpm server'
mcuTest.pkgs_needed_list.append(mcuTest.qpm_computer.os)
mcuTest.qpm_computer.check_and_mount_default_mounts()
# Open the connection to qpm4u server
if mcuTest.qpmuserver != None:
mcuTest.logger.info("\nOpening connection | qpm4u server...")
mcuTest.logger.info("-----------------------------------------------")
mcuTest.qpm4u_computer = create_computer_with_hostname(mcuTest.qpmuserver, mcuTest.linuxUser, mcuTest.password, mcuComputer, domain=mcuTest.defaultDomain)
assert mcuTest.qpm4u_computer.is_connected, 'There was a problem trying to connect to the qpm4u server'
mcuTest.pkgs_needed_list.append(mcuTest.qpm4u_computer.os)
mcuTest.qpm4u_computer.check_and_mount_default_mounts()
# Open a web browser for testing
if mcuTest.browser != None:
mcuTest.logger.info("\nOpening up internet browser | {}".format(mcuTest.browser))
mcuTest.logger.info("-----------------------------------------------")
mcuTest.mcuConsole = pagehandler.mcuPage.mcuPage(mcuTest.remoteWebBrowser, mcuTest.computer.hostname, mcuTest.browser, mcuTest.logDirectory, mcuTest.logger, mcuTest.version)
assert mcuTest.mcuConsole.page != None, 'Did not open a browser'
mcuTest.webdriverVersion = selenium.__version__
# Get the most current version of qpm4s
if mcuTest.qpm4sVersion == None:
version, qpmBuild = mcu.getLatestVersion("qpm4s")
mcuTest.qpm4sVersion = version + "." + qpmBuild
host = "%-15s \t%-1s" % ("Test Computer:", hostname)
mc = "%-15s \t%-1s" % ("Managed Client:", mcuTest.managedClient)
qs = "%-15s \t%-1s" % ("qpm_computer:", mcuTest.qpmserver)
qu = "%-15s \t%-1s" % ("qpm4u_computer:", mcuTest.qpmuserver)
mcv = "%-15s \t%-1s" % ("MCU Version:", mcuTest.version)
if mcuTest.browser != None:
br = "%-15s \t%-1s" % ("Browser Name:", mcuTest.mcuConsole.page.capabilities['browserName'])
bv = "%-15s \t%-1s" % ("Browser Version:", mcuTest.mcuConsole.page.capabilities['version'])
bl = "%-15s \t%-1s" % ("Browser Location:", mcuTest.remoteWebBrowser)
wv = "%-15s \t%-1s" % ("Webdriver Version:", mcuTest.webdriverVersion)
mcuTest.test_information = "{} \n{} \n{} \n{} \n{} \n{} \n{} \n{} \n{}".format(host, mc, qs, qu, mcv, br, bv, bl, wv)
else:
mcuTest.test_information = "{} \n{} \n{} \n{} \n{}".format(host, mc, qs, qu, mcv)
mcuTest.computer.logger.info("\n--------------------------------------------------")
mcuTest.computer.logger.info(" Test Information ")
mcuTest.computer.logger.info("--------------------------------------------------")
mcuTest.computer.logger.info(mcuTest.test_information)
mcuTest.computer.logger.info("--------------------------------------------------")
return mcuTest
def init_test(total_tests, config, hostname, build):
isinstance(config, dict)
integrationTestCase.version = build
integrationTestCase.total_tests = total_tests
# Web browser
integrationTestCase.remoteWebBrowser = config.get("remotewebbrowser", None)
integrationTestCase.browser = config.get("browser", None)
# MCU Computers
integrationTestCase.managedClient = config.get("managedclient", None)
# QPM Computers
integrationTestCase.qpms_server = config.get("qpmserver", None)
integrationTestCase.qpmu_server = config.get("qpmuserver", None)
# QAS Computer
integrationTestCase.qas_computer = config.get("qascomputer", None)
# Users
integrationTestCase.linuxUser = config.get("linuxUser", "root")
integrationTestCase.password = config.get("password", "test123")
integrationTestCase.winUser = config.get("winuser", "Administrator")
integrationTestCase.loginuserpasswd = config.get("loginuserpasswd", "test123")
integrationTestCase.winPassword = config.get("winpassword", "test123")
username = config.get("username", "root")
password = config.get("password", "test123")
integrationTestCase.logger = logging.getLogger(hostname)
integrationTestCase.spath = config.get("scriptpath","/mnt/qpm4u/smoke/")
integrationTestCase.previousBuild = config.get("previousVersion", "5.6.0.040")
integrationTestCase.devb = config.get("devb", "/mnt/qpm4u/dev-builds")
# QAS Stuff
integrationTestCase.upnMode = config.get("upnmode", False)
integrationTestCase.mount = config.get("mount", True)
# Test Group
integrationTestCase.testgroup = config.get("testgroup", "Integration - {}".format(build))
# Logging and debug
integrationTestCase.logDirectory = config.get("logdirectory", "/var/www/MCU")
integrationTestCase.runWithDebug = config.get("runwithdebug", True)
# Domain
integrationTestCase.domain = config.get("domain", "h.qas")
integrationTestCase.defaultDomain = domain_ext(integrationTestCase.domain)
# install Path
integrationTestCase.install_sh_path = config.get("installshpath", "/mnt/integratedIso/dev-builds")
integrationTestCase.install_sh_build_path = "{}/{}".format(integrationTestCase.install_sh_path, integrationTestCase.version)
integrationTestCase.mcuInstalledjvm = config.get("mcuinstalledjvm","32-bit")
computer_list = []
computer_list.append(hostname)
computer_list.append(config.get("qpmserver"))
computer_list.append(config.get("qpmuserver"))
computer_list.append(config.get("qascomputer"))
sorted_list = set(computer_list)
mcu_comp = False
qas_comp = False
qpms_comp = False
qpmu_comp = None
# Find out what computers we have
integrationTestCase.open_computers = []
for comp in sorted_list:
# We should always have at least this computer
# MCU | Open connections to mcu computers ----------------------------------------------------------------------
if comp == hostname:
mcu_comp = hostname
integrationTestCase.mcu_computer = _open_and_setup_computer(mcu_comp, username, password, integrationComputer, integrationTestCase.defaultDomain)
# QPM4S | Open connections to QPM4S computer ----------------------------------------------------------------------
elif comp == config.get("qpmserver"):
qpms_comp = config.get("qpmserver")
integrationTestCase.qpms_server = _open_and_setup_computer(qpms_comp, "root", "test123", integrationComputer, integrationTestCase.defaultDomain)
# QPM4U | Open connections to QPM4U computer ----------------------------------------------------------------------
elif comp == config.get("qpmuserver"):
qpmu_comp = config.get("qpmuserver")
integrationTestCase.qpmu_server = _open_and_setup_computer(qpmu_comp, "root", "test123", integrationComputer, integrationTestCase.defaultDomain)
# QAS | Open connections to QPM4U computer ----------------------------------------------------------------------
elif comp == config.get("qascomputer"):
qas_comp = config.get("qascomputer")
integrationTestCase.qas_computer = _open_and_setup_computer(qas_comp, "root", "test123", integrationComputer, integrationTestCase.defaultDomain)
# Now we need to assign other computers that did not get opened
if not qas_comp:
for comp in integrationTestCase.open_computers:
if comp.hostname == config.get("qascomputer"):
integrationTestCase.qas_computer = comp
break
if not qpms_comp:
for comp in integrationTestCase.open_computers:
if comp.hostname == config.get("qpmserver"):
integrationTestCase.qpms_server = comp
break
if not qpmu_comp:
for comp in integrationTestCase.open_computers:
if comp.hostname == config.get("qpmuserver"):
integrationTestCase.qpmu_server = comp
break
# Run this to set the env variables.
if integrationTestCase.qpms_server.hostname == integrationTestCase.qpmu_server.hostname:
# If they are the same computer then we only need to run it once
set_devb(integrationTestCase.qpmu_server, integrationTestCase.devb)
else:
# If they are different then run on each box.
set_devb(integrationTestCase.qpms_server, integrationTestCase.devb)
set_devb(integrationTestCase.qpmu_server, integrationTestCase.devb)
# WEB Browser | Open a web browser for testing ----------------------------------------------------------------------
if integrationTestCase.browser != None:
integrationTestCase.logger.info("\nOpening up internet browser | {}".format(integrationTestCase.browser))
integrationTestCase.logger.info("-----------------------------------------------")
integrationTestCase.mcuConsole = pagehandler.mcuPage.mcuPage(integrationTestCase.remoteWebBrowser, integrationTestCase.mcu_computer.hostname, integrationTestCase.browser, integrationTestCase.logDirectory, integrationTestCase.logger, integrationTestCase.version)
assert integrationTestCase.mcuConsole.page != None, 'Did not open a browser'
integrationTestCase.webdriverVersion = selenium.__version__
return integrationComputer
def init_test(config, hostname, build):
isinstance(config, dict)
QpmTestCase.version = build
QpmTestCase.logger = logging.getLogger(hostname)
QpmTestCase.server = config.get("server")
QpmTestCase.secondary = config.get("secondary")
QpmTestCase.client = config.get("client")
QpmTestCase.spath = config.get("scriptpath","/mnt/qpm4u/smoke/")
QpmTestCase.previousBuild = config.get("previousVersion", "5.6.0.040")
QpmTestCase.devb = config.get("devb", "/mnt/qpm4u/dev-builds")
osinfo = eval(config.get('osinfo','{}'))
serverinfo = eval(config.get('serverinfo'))
username = config.get("username", "root")
password = config.get("password", "test123")
# Domain
QpmTestCase.domain = config.get("domain", "h.qas")
QpmTestCase.defaultDomain = domain_ext(QpmTestCase.domain)
# Open connections to test computer and peers
QpmTestCase.computer = create_computer_with_hostname(hostname, username, password, QpmComputer, domain=QpmTestCase.defaultDomain, **osinfo)
assert QpmTestCase.computer.is_connected, 'There was a problem trying to connect to computer'
# Check Mount after opening computer
QpmTestCase.computer.check_and_mount_custom("hal9000.vintela.com:/automation/packages", "/mnt/packages")
# Lock computer after mounts are setup
QpmTestCase.computer.lock_on_computer()
set_devb(QpmTestCase.computer, QpmTestCase.devb)
# Setup PATH
run(QpmTestCase.computer, "PATH=$PATH:/opt/quest/bin:/opt/quest/sbin; export PATH");
# See if testing is using the box
dont_smoke = "/tmp/.dont_smoke"
counter = 0
while QpmTestCase.computer.fileExists(dont_smoke):
QpmTestCase.computer.logger.info("There is a lock file from testing: {}".format(dont_smoke))
if counter % 3600 == 0:
QpmTestCase.computer.remoteShell.run("echo Please wrap it up so smoke can run. Remove {} | wall".format(dont_smoke))
counter+=120
if counter % 10800 == 0:
QpmTestCase.computer.remoteShell.run("rm -f {0}; echo Done waiting, removing file {0}. Smoke will resume in 120 seconds | wall".format(dont_smoke))
time.sleep(120)
QpmTestCase.computer.remoteShell.run("echo QPM4S Smoke has been ordered to run | wall".format(dont_smoke))
QpmTestCase.servercomp = create_computer_with_hostname(username="******", password="******", computerclass=QpmComputer, **serverinfo)
assert QpmTestCase.servercomp.is_connected, 'There was a problem trying to connect to the computer'
QpmTestCase.servercomp.check_and_mount_custom("hal9000.vintela.com:/automation/packages", "/mnt/packages")
QpmTestCase.servercomp.lock_on_computer()
set_devb(QpmTestCase.servercomp, QpmTestCase.devb)
# Setup PATH
run(QpmTestCase.servercomp, "PATH=$PATH:/opt/quest/bin:/opt/quest/sbin; export PATH");
# Clean the the server beforehand
QpmTestCase.logger.info("\n\nCleaning {}. Cleaning off the server, agent and client".format(QpmTestCase.servercomp.hostname))
QpmTestCase.servercomp.remoteShell.run(QpmTestCase.spath + "clean-server.sh", timeout=500)
QpmTestCase.servercomp.remoteShell.run(QpmTestCase.spath + "clean-agent.sh", timeout=500)
QpmTestCase.servercomp.remoteShell.run(QpmTestCase.spath + "clean-client.sh", timeout=500)
# Prep the peers
QpmTestCase.logger.info("\n\n{} | Installing and configuring server...".format(QpmTestCase.servercomp.hostname))
QpmTestCase.servercomp.remoteShell.run(QpmTestCase.spath + "install-server.sh {}".format(build), timeout=500)
QpmTestCase.servercomp.remoteShell.run(QpmTestCase.spath + "config-server-001.sh -f {}".format(QpmTestCase.spath + "sudoers/default"), timeout=500)
# Cleanup test computer
QpmTestCase.logger.info("\n\nCleaning test computer: {}".format(QpmTestCase.computer.hostname))
QpmTestCase.computer.remoteShell.run(QpmTestCase.spath + "clean-server.sh", timeout=500)
QpmTestCase.computer.remoteShell.run(QpmTestCase.spath + "clean-client.sh", timeout=500)
QpmTestCase.computer.remoteShell.run(QpmTestCase.spath + "clean-agent.sh", timeout=500)
return QpmTestCase
