def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" %
self.__class__.__name__)
try:
try:
username = RHSMConstants().get_constant("username")
password = RHSMConstants().get_constant("password")
self.open_subscription_manager()
self.register_and_autosubscribe_in_gui(username, password)
self.click_view_system_facts_menu()
self.click_facts_view_tree("system")
if self.check_org_displayed_in_facts(username, password):
logger.info(
"It's successful to check orgs displayed in system facts in GUI "
)
else:
raise FailException(
"Test Faild - Failed to check orgs displayed in system facts in GUI"
)
if self.check_system_uuid_displayed_in_facts():
logger.info(
"It's successful to check system_uuid displayed in system facts in GUI "
)
else:
raise FailException(
"Test Faild - Failed to check system_uuid displayed in system facts in GUI"
)
self.assert_(True, case_name)
except Exception, e:
logger.error("Test Failed - ERROR Message:" + str(e))
self.assert_(False, case_name)
finally:
self.capture_image(case_name)
self.restore_gui_environment()
logger.info("========== End of Running Test Case: %s ==========" %
case_name)
def check_sku_in_consumed_subscriptions(self):
sku = None
cmd = "subscription-manager list --consumed | grep 'SKU'"
(ret,
output) = self.runcmd(cmd,
"check sku in the list consumed subscriptions")
print "output: \n", output[0]
if ret == 0:
sku = output.split(":")[1].strip()
return sku
else:
return sku
raise FailException(
"Test Failed - error happened when check sku in the list consumed subscriptions"
)
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" %
case_name)
try:
# modify values of configuration item for the system
# cmd="subscription-manager config --server.insecure=%s --server.proxy_port=%s --rhsm.insecure=%s --rhsm.proxy_port=%s --rhsmcertd.insecure=%s --rhsmcertd.proxy_port=%s"%(modinsecure, modproxyport, modinsecure, modproxyport, modinsecure, modproxyport)
cmd = "subscription-manager config --server.insecure=%s --server.proxy_port=%s" % (
self.modinsecure, self.modproxyport)
(ret, output) = self.runcmd(cmd, "modify values of config items")
if (self.is_configuration_modified()):
logger.info(
"Default values of configuration items(insecure and proxy_port) have been modified."
)
# remove values of configuration item for the system
# cmd="subscription-manager config --remove server.insecure --remove server.proxy_port --remove rhsm.insecure --remove rhsm.proxy_port --remove rhsmcertd.insecure --remove rhsmcertd.proxy_port"
cmd = "subscription-manager config --remove server.insecure --remove server.proxy_port"
(ret, output) = self.runcmd(cmd,
"remove values of config items")
if ret == 0 and "You have removed the value for section" in output and "The default value for" in output:
if self.is_configuration_removed():
logger.info(
"It's successful to remove current values of configuration item for the system."
)
else:
raise FailException(
"Test Failed - remove current values of configuration item are not correct."
)
else:
raise FailException(
"Failed to remove current values of configuration item."
)
self.assert_(True, case_name)
except Exception, e:
logger.error("Test Failed - ERROR Message:" + str(e))
self.assert_(False, case_name)
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" %
case_name)
try:
username = RHSMConstants().get_constant("username")
password = RHSMConstants().get_constant("password")
self.sub_register(username, password)
autosubprod = RHSMConstants().get_constant("autosubprod")
self.sub_autosubscribe(autosubprod)
productrepo = RHSMConstants().get_constant("productrepo")
cmd = "subscription-manager repos --list | grep %s" % productrepo
(ret, output) = self.runcmd(cmd, "check the repo %s" % productrepo)
if ret == 0 and productrepo in output:
logger.info(
"It's successful to check the repo %s which is available."
% productrepo)
# enable the repo in list
cmd = "subscription-manager repos --enable=%s" % productrepo
(ret, output) = self.runcmd(cmd,
"enable the repo %s" % productrepo)
if ret == 0 and "Repository '%s' is enabled for this system." % productrepo in output:
logger.info("It's successful to disable the repo %s." %
productrepo)
else:
raise FailException(
"Test Failed - Failed to enable the repo %s." %
productrepo)
else:
raise FailException(
"Test Failed - Fail to check the repo %s which should be available."
% productrepo)
self.assert_(True, case_name)
except Exception, e:
logger.error(str(e))
self.assert_(False, case_name)
def is_redhatrepo_exist(self, expectbool):
# check redhat.repo file exist or not
cmd = "ls /etc/yum.repos.d/"
(ret, output) = self.runcmd(cmd, "check redhat.repo exist")
if not expectbool:
existed = output.count("bak") == output.count("redhat.repo")
else:
existed = not (output.count("bak") == output.count("redhat.repo"))
if ret == 0 and existed:
logger.info(
"It's successful to check redhat.repo file exist: %s." %
expectbool)
else:
raise FailException(
"Test Failed - Failed to delete redhat.repo file.")
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" % case_name)
try:
# use identity command to show where system is registerd to
cmd = "subscription-manager identity"
(ret, output) = self.runcmd(cmd, "running identity command")
if ret != 0 and ("This system is not yet registered. Try 'subscription-manager register --help' for more information." in output):
logger.info("It's successful to check the output of identity command when the machine is not registered.")
else:
raise FailException("Test Failed - Failed to check the output of identity command when the machine is not registered.")
self.assert_(True, case_name)
except Exception, e:
logger.error(str(e))
self.assert_(False, case_name)
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" % case_name)
try:
username = RHSMConstants().get_constant("username")
password = RHSMConstants().get_constant("password")
self.sub_register(username, password)
autosubprod = RHSMConstants().get_constant("autosubprod")
self.sub_autosubscribe(autosubprod)
# set healfrequency = 1
self.sub_set_healfrequency(1)
# 1. Unsubscribe the subscription
self.sub_unsubscribe()
# 2. refresh the local data
cmd = 'subscription-manager refresh'
(ret, output) = self.runcmd(cmd, "reflash")
if ret == 0 and 'All local data refreshed' in output:
logger.info("It's successful to do refresh local data")
else:
raise FailException("Test Failed - Failed to do refresh.")
# 3. Restart the rhsmcertd service
cmd = 'service rhsmcertd restart'
self.runcmd(cmd, "restart rhsmcertd")
# 4. List the consumed
cmd = 'subscription-manager refresh'
(ret, output) = self.runcmd(cmd, "refresh rhsmcertd")
logger.info("Waiting 90 seconds for rhsmcertd service to take effect...")
time.sleep(90)
if self.sub_isconsumed(autosubprod):
logger.info("It's successful to list consumed.")
else:
raise FailException("Test Failed - Failed to list consumed.")
self.assert_(True, case_name)
except Exception, e:
logger.error("Test Failed - ERROR Message:" + str(e))
self.assert_(False, case_name)
def list_enddate(self, output):
datalines = output.splitlines()
segs = []
timeline = ""
for line in datalines:
if "Ends:" in line:
tmpline = line
segs.append(tmpline)
for aa in segs:
endtimeitem = aa.split(":")[0].replace(' ', '')
endtimevalue = aa.split(":")[1].strip()
if compare_time(endtimevalue) == 0:
logger.info("It's correct to list this subscription.")
else:
raise FailException("The subscription shouldn't be list")
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" %
case_name)
try:
username = RHSMConstants().get_constant("username")
password = RHSMConstants().get_constant("password")
self.sub_register(username, password)
# list availalbe entitlement pools
productid = RHSMConstants().get_constant("productid")
availpoollist = self.sub_listavailpools(productid)
# get an available entitlement pool to subscribe with random.sample
availpool = random.sample(availpoollist, 1)[0]
if "SubscriptionName" in availpool:
poolid = availpool["PoolID"]
subscriptionname = availpool["SubscriptionName"]
productid = availpool["SKU"]
# subscribe the product with poolid
cmd = "subscription-manager subscribe --pool=%s" % poolid
(ret, output) = self.runcmd(cmd, "subscribe with poolid")
expectout = "Successfully consumed a subscription for: %s" % subscriptionname
# expectoutnew is for rhel new feature output
expectoutnew = "Successfully attached a subscription for: %s" % subscriptionname
if 0 == ret and ((expectout in output) or
(expectoutnew in output)):
logger.info("It's successful to do subscribe to a pool")
else:
logger.error(
"Test Failed - error happened when do subscribe to a pool"
)
# get the number of entitlement cert
cmd = "ls /etc/pki/entitlement | grep -v key.pem | wc -l"
(ret, number) = self.runcmd(cmd,
"get the number of entitlement cert")
if (ret == 0) and (number.strip('\n') == "1"):
logger.info(
"It's successful to verify that only one entitlement certificate is produced for each subscription to an entitlement pool"
)
else:
raise FailException(
"Test Failed - Failed to verify that only one entitlement certificate is produced for each subscription to an entitlement pool"
)
self.assert_(True, case_name)
except Exception, e:
logger.error("Test Failed - ERROR Message:" + str(e))
self.assert_(False, case_name)
def check_autosub_result(self, autosubprod):
cmd = "subscription-manager subscribe --auto"
(ret, output) = self.runcmd(cmd, "check auto-subscribe result")
if ret != 0:
if "No Installed products on system. No need to attach subscriptions." in output:
logger.info(
"It's successful to check no need to update subscription for RHEL5 system."
)
elif ("Product Name:" not in output) and (autosubprod
not in output):
logger.info(
"It's successful to check no need to update subscription for RHEL6 system."
)
else:
raise FailException(
"Test Failed - check no need to update subscription.")
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" %
case_name)
try:
# register to and auto-attach
username = RHSMConstants().get_constant("username")
password = RHSMConstants().get_constant("password")
autosubprod = RHSMConstants().get_constant("autosubprod")
self.register_and_autosubscribe(username, password, autosubprod)
# get variables form ent_env
repoid = RHSMConstants().get_constant("productrepo")
pid = RHSMConstants().get_constant("pid")
pkgtoinstall = RHSMConstants().get_constant("pkgtoinstall")
# check repo exist
if self.is_enabled_repo(repoid):
# check package to be installed exist
self.check_givenpkg_avail(repoid, pkgtoinstall)
# install test-pkg
self.install_givenpkg(pkgtoinstall)
else:
raise FailException(
"Test Failed - The product repoid is not exist.")
# check the cert file exist.
certfile = pid + ".pem"
self.check_cert_file(certfile)
# check productid cert
self.sub_checkproductcert(pid)
# uninstall test-pkg
self.uninstall_givenpkg(pkgtoinstall)
#### install the same package when system expired ###
# make the system expired
self.set_system_date()
# install test-pkg again
self.install_givenpkg(pkgtoinstall)
# restore the system time
self.restore_system_time()
#### install the same package when system expired ###
# unsubscribe all subscriptions
self.sub_unsubscribe()
# install test-pkg again
self.install_givenpkg(pkgtoinstall)
self.assert_(True, case_name)
except Exception, e:
logger.error(str(e))
self.assert_(False, case_name)
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" % case_name)
try:
try:
username = RHSMConstants().get_constant("username")
password = RHSMConstants().get_constant("password")
self.open_subscription_manager()
self.register_in_gui(username, password)
raise FailException("Not completed yet ......")
self.assert_(True, case_name)
except Exception, e:
logger.error("Test Failed - ERROR Message:" + str(e))
self.assert_(False, case_name)
finally:
self.capture_image(case_name)
self.restore_gui_environment()
logger.info("========== End of Running Test Case: %s ==========" % case_name)
def uninstall_givenpkg(self, testpkg):
cmd = "rpm -qa | grep %s" % (testpkg)
(ret, output) = self.runcmd(cmd, "check package %s" % testpkg)
if ret == 1:
logger.info("There is no need to remove package")
else:
cmd = "yum remove -y %s" % (testpkg)
(ret, output) = self.runcmd(cmd,
"remove select package %s" % testpkg)
if ret == 0 and "Complete!" in output and "Removed" in output:
logger.info("The package %s is uninstalled successfully." %
(testpkg))
elif ret == 0 and "No package %s available" % testpkg in output:
logger.info("The package %s is not installed at all" %
(testpkg))
else:
raise FailException(
"Test Failed - The package %s is failed to uninstall." %
(testpkg))
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" %
case_name)
try:
cmd = "subscription-manager config --help | grep -A1 -- --proxy"
(ret, output) = self.runcmd(cmd, "check proxy option")
if ret != 0 and 'proxy' not in output:
logger.info(
"It's successful to check config should NOT have proxy options"
)
else:
raise FailException(
"Test Failed - Failed to check config should NOT have proxy options."
)
self.assert_(True, case_name)
except Exception, e:
logger.error("Test Failed - ERROR Message:" + str(e))
self.assert_(False, case_name)
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" %
self.__class__.__name__)
try:
try:
username = RHSMConstants().get_constant("username")
password = RHSMConstants().get_constant("password")
self.open_subscription_manager()
self.register_in_gui(username, password)
self.click_all_available_subscriptions_tab()
self.click_filters_button()
self.check_checkbox("filter-options-window",
"match-installed-checkbox")
self.uncheck_checkbox("filter-options-window",
"match-system-checkbox")
self.uncheck_checkbox("filter-options-window",
"do-not-overlap-checkbox")
self.click_filter_close_button()
self.click_filters_button()
if not (self.verifycheck_checkbox("filter-options-window",
"match-system-checkbox")
and self.verifycheck_checkbox(
"filter-options-window", "do-not-overlap-checkbox")
and not self.verifycheck_checkbox(
"filter-options-window",
"match-installed-checkbox")):
logger.info(
"It's successful to check filter_options_persisted_in_session"
)
else:
raise FailException(
"Test Faild - Failed to check filter_options_persisted_in_session"
)
self.assert_(True, case_name)
except Exception, e:
logger.error("Test Failed - ERROR Message:" + str(e))
self.assert_(False, case_name)
finally:
self.capture_image(case_name)
self.restore_gui_environment()
logger.info("========== End of Running Test Case: %s ==========" %
case_name)
def list_availalbe(self, direct):
cmd_list = "subscription-manager list --available"
(ret, output) = self.runcmd(cmd_list,
"list the available subscriptions")
if ret != 0:
if (direct == 'mess1' and
("This system is not yet registered" in output)) or (
direct == 'mess2' and ("bad base64 decode" in output)):
logger.info(
"It's successful to verify that no subscription is available with changed identity cert!"
)
elif direct == 'recover' and ret == 0:
logger.info(
"It's successful to verify that available subscription is listed with recovered identity cert!"
)
else:
raise FailException(
"Test Failed - error happened when list available subscriptions"
)
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" % case_name)
try:
username = RHSMConstants().get_constant("username")
password = RHSMConstants().get_constant("password")
self.sub_register(username, password)
autosubprod = RHSMConstants().get_constant("autosubprod")
self.sub_autosubscribe(autosubprod)
# run cmd unsubscribe --all
cmd = "subscription-manager unsubscribe --all"
(ret, output) = self.runcmd(cmd, "run cmd unsubscribe --all")
expectoutput = "This machine has been unsubscribed from 1 subscriptions"
expectoutputnew = "subscription removed from this system."
expectoutput5101 = "subscription removed at the server."
expectoutput5102 = "local certificate has been deleted."
if 0 == ret and ((expectoutput5101 in output and expectoutput5102 in output) or (expectoutput in output or expectoutputnew in output)):
firstresult = True
print "True\n"
else:
firstresult = False
print "False\n"
# unsubscribe before subscribe
cmd = "subscription-manager unsubscribe --all"
(ret, output) = self.runcmd(cmd, "run cmd unsubscribe --all again")
expectoutput = "This machine has been unsubscribed from 0 subscriptions"
expectoutputnew = "0 subscriptions removed from this system."
expectoutput510 = "subscriptions removed at the server."
if 0 == ret and (expectoutput510 in output or expectoutput in output or expectoutputnew in output):
secondresult = True
print "True\n"
else:
secondresult = False
print "False\n"
if firstresult and secondresult:
logger.info("It is successful to run cmd subscription-manager unsubscribe --all and check the output!")
else:
raise FailException("Test Faild - Failed to run cmd subscription-manager unsubscribe --all and check the output!")
self.assert_(True, case_name)
except Exception, e:
logger.error("Test Failed - ERROR Message:" + str(e))
self.assert_(False, case_name)
def get_subscription_status(self):
cmd = "subscription-manager list --consumed | grep Active"
(ret, output) = self.runcmd(cmd, "get subscription status")
if ret == 0:
if "False" in output:
logger.info(
"It's successful to get subscription status: the subscription is expired"
)
return "False"
elif "True" in output:
logger.info(
"It's successful to get subscription status: the subscription is not expired"
)
return "True"
else:
logger.info("nonsense status ")
return "None"
else:
raise FailException(
"Test Failed - Failed to get subscription status.")
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" % self.__class__.__name__)
try:
try:
self.open_subscription_manager()
self.click_about_menu()
if self.check_object_exist("about-subscription-manager-dialog", "about-subscription-manager-dialog"):
logger.info("It's successful to check open_subscription_manager_about_from_menu.")
else:
raise FailException("Test Faild - Failed to check open_subscription_manager_about_from_menu!")
self.assert_(True, case_name)
except Exception, e:
logger.error("Test Failed - ERROR Message:" + str(e))
self.assert_(False, case_name)
finally:
self.capture_image(case_name)
self.close_window("about-subscription-manager-dialog")
self.restore_gui_environment()
logger.info("========== End of Running Test Case: %s ==========" % case_name)
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" % case_name)
try:
username = RHSMConstants().get_constant("username")
password = RHSMConstants().get_constant("password")
self.sub_register(username, password)
# get service_level
service_level = RHSMConstants().get_constant("servicelevel")
# auto subscribe with one service level
cmd = "subscription-manager subscribe --auto --servicelevel=%s" % service_level
(ret, output) = self.runcmd(cmd, "autosubscribe with one service-level")
if ret == 0 and ("Status:Subscribed" in output) or re.search("Status:\s+Subscribed", output):
logger.info("It's successful to do autosubscribe with one service-level: %s." % service_level)
else:
raise FailException("Test Failed - Failed to auto subscribe with one service level.")
self.assert_(True, case_name)
except Exception, e:
logger.error("Test Failed - ERROR Message:" + str(e))
self.assert_(False, case_name)
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" % case_name)
try:
username = RHSMConstants().get_constant("username")
password = RHSMConstants().get_constant("password")
self.sub_register(username, password)
samhostip = RHSMConstants().samhostip
cmd = "subscription-manager environments --username=%s --password=%s" % (username, password)
(ret, output) = self.runcmd(cmd, "running environments command with no options")
if samhostip != None and ret == 0 and "Error: Server does not support environments" in output:
logger.info("It's successful to verify that SAM does not support environments")
elif ret != 0 and "Error: This command requires that you specify an organization with --org" in output :
logger.info("It's successful to check the error message when run environments with no options.")
else:
raise FailException("Test Failed - Failed to check the error message when run environments with no options.")
self.assert_(True, case_name)
except Exception, e:
logger.error("Test Failed - ERROR Message:" + str(e))
self.assert_(False, case_name)
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" % self.__class__.__name__)
try:
try:
self.open_subscription_manager()
self.click_gettingstarted_menu()
if self.check_window_open("subscription-manager-manual-window"):
logger.info("It's successful to check subscription_manager_help_maual.")
else:
raise FailException("Test Faild - Failed to check subscription_manager_help_maual!")
self.assert_(True, case_name)
except Exception, e:
logger.error("Test Failed - ERROR Message:" + str(e))
self.assert_(False, case_name)
finally:
self.capture_image(case_name)
self.close_window("subscription-manager-manual-window")
self.restore_gui_environment()
logger.info("========== End of Running Test Case: %s ==========" % case_name)
def install_givenpkg(self, testpkg):
cmd = "yum install -y %s" % (testpkg)
(ret, output) = self.runcmd(cmd,
"install selected package %s" % testpkg)
if ret == 0 and "Complete!" in output and "Error" not in output:
logger.info("The package %s is installed successfully." %
(testpkg))
elif ret == 1:
if ("The subscription for following product(s) has expired"
in output):
logger.info(
"It's successful to verify that system should not be able to access CDN bits through thumbslug proxy when the system is expired."
)
else:
logger.info(
"It's successful to verify that system should not be able to access CDN bits through thumbslug proxy when the system is not attach subscriptions"
)
else:
raise FailException(
"Test Failed - The package %s is failed to install." %
(testpkg))
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" %
case_name)
try:
cmd = 'subscription-manager list --available --help | egrep "no-overlap|match-installed" -A1'
(ret, output) = self.runcmd(
cmd,
"check subscription-manager man page for new list options")
if ret == 0 and "shows pools which provide products that are not" in output and "already covered; only used with --available" in output and "shows only subscriptions matching products that are" in output and "currently installed; only used with --available" in output:
logger.info(
"It's successful to check subscription-manager man page for new list options."
)
else:
raise FailException(
"Test Failed - Failed to check subscription-manager man page for new list options."
)
self.assert_(True, case_name)
except Exception, e:
logger.error("Test Failed - ERROR Message:" + str(e))
self.assert_(False, case_name)
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" %
case_name)
try:
# Check the description of rhsm-debug MODULE-NAME
cmd = "rhsm-debug --help | grep system"
(ret, output) = self.runcmd(cmd,
"check man page for repo-override")
if ret == 0 and "Assemble system information as a tar file or directory" in output:
logger.info(
"It's successful to Check the description of rhsm-debug MODULE-NAME."
)
else:
raise FailException(
"Test Failed - Failed to Check the description of rhsm-debug MODULE-NAME."
)
self.assert_(True, case_name)
except Exception, e:
logger.error("Test Failed - ERROR Message:" + str(e))
self.assert_(False, case_name)
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" % case_name)
try:
# config rhsmcertd in /etc/rhsm/rhsm.conf
self.sub_set_certfrequency(1)
self.sub_set_healfrequency(1)
cmd3 = 'service rhsmcertd restart'
(ret3, output3) = self.runcmd(cmd3, "restart rhsmcertd service")
cmd4 = 'tail -4 /var/log/rhsm/rhsmcertd.log'
(ret4, output4) = self.runcmd(cmd4, "restart rhsmcertd service")
if ret4 == 0 and "healing check started: interval = 1" and "cert check started: interval = 1" and "certificates updated" in output4:
logger.info("It's successful to logging rhsmcertd statements.")
else:
FailException("Test Failed - Failed to logging rhsmcertd statements.")
self.assert_(True, case_name)
except Exception, e:
logger.error(str(e))
self.assert_(False, case_name)
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" %
case_name)
try:
cmd = 'subscription-manager --help'
(ret,
output) = self.runcmd(cmd,
"list subscription-manager help manual!")
if ret == 0 and ('Primary Modules' and 'Other Modules' in output):
logger.info(
"Test Successful - It's successful to list subscription-manager help manual."
)
else:
raise FailException(
"Test Failed - Failed to list subscription-manager help manual."
)
self.assert_(True, case_name)
except Exception, e:
logger.error(str(e))
self.assert_(False, case_name)
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" %
case_name)
try:
# check the certificate version from facts
cmd = "subscription-manager facts | grep system.certificate_version"
(ret,
output) = self.runcmd(cmd,
"check the certificate version from facts")
if ret == 0 and "system.certificate_version: 3" in output:
logger.info(
"It's successful to check the certificate version from facts."
)
else:
raise FailException(
"Test Failed - Failed to check the certificate version from facts."
)
self.assert_(True, case_name)
except Exception, e:
logger.error(str(e))
self.assert_(False, case_name)
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" %
case_name)
try:
samhostip = RHSMConstants().samhostip
if samhostip == None:
logger.info(
"This case is just for SAM, no need to test against other servers!"
)
else:
username = RHSMConstants().get_constant("username")
password = RHSMConstants().get_constant("password")
# create a new org without available subscriptions in SAM
orgname = "test"
self.create_sam_org(samhostip, orgname)
# register and auto-attach by this account
cmd_to_test = "subscription-manager register --username=%s --password='******' --org=%s --auto-attach" % (
username, password, orgname)
(ret,
output) = self.runcmd(cmd_to_test,
"register with auto subscribe option")
if (ret != 0) and (
"The system has been registered with ID" in output
) and (
"Not Subscribed" in output
) and ("Unable to find available subscriptions for all your installed products"
in output):
logger.info(
"It's successful to verify registeration with auto subscribe option if there is no compatible subscription"
)
else:
raise FailException(
"Test Failed -Failed to verify registeration with auto subscribe option if there is no compatible subscription"
)
self.assert_(True, case_name)
except Exception, e:
logger.error("Test Failed - ERROR Message:" + str(e))
self.assert_(False, case_name)
def test_run(self):
case_name = self.__class__.__name__
logger.info("========== Begin of Running Test Case %s ==========" %
case_name)
try:
username = RHSMConstants().get_constant("username")
password = RHSMConstants().get_constant("password")
self.sub_register(username, password)
# get baseurl
baseurl = RHSMConstants().get_constant("baseurl")
if "8443" in baseurl:
baseurl = baseurl + "/candlepin"
elif RHSMConstants().samhostip == None:
baseurl = baseurl + "/subscription"
else:
baseurl = baseurl + "/sam/api"
# get consumerid
cmd = "subscription-manager identity | grep identity"
(ret, output) = self.runcmd(cmd, "get consumerid")
consumerid = output.split(':')[1].strip()
service_level = RHSMConstants().get_constant("servicelevel")
# call dry run bind to products by api
cmd = "curl -k --cert /etc/pki/consumer/cert.pem --key /etc/pki/consumer/key.pem %s/consumers/%s/entitlements/dry-run?service_level=%s && echo \"\r\"" % (
baseurl, consumerid, service_level)
(ret, output) = self.runcmd(cmd, "dry run bind by products api")
if ret == 0 and ('"value":"%s"' % service_level in output
or '"value":"%s"' %
(((service_level).lower()).upper()) in output):
logger.info(
"It's successful to dry run bind by products api with a specified SLA."
)
else:
raise FailException(
"Test Failed - Failed to dry run bind by products api with a specified SLA."
)
self.assert_(True, case_name)
except Exception, e:
logger.error("Test Failed - ERROR Message:" + str(e))
self.assert_(False, case_name)
