def _fetch(self, inject=None):
""" Initialize / refresh test plan data.
Either fetch them from the server or use provided hash.
"""
TCMS._fetch(self, inject)
# Fetch the data hash from the server unless provided
if inject is None:
log.info("Fetching test plan " + self.identifier)
try:
inject = self._server.TestPlan.filter({'pk': self.id})[0]
except IndexError as error:
log.debug(error)
raise TCMSError(
"Failed to fetch test plan TP#{0}".format(self.id))
self._inject = inject
# Otherwise just initialize the id from inject
else:
self._id = inject["plan_id"]
log.debug("Initializing test plan " + self.identifier)
log.data(pretty(inject))
if "plan_id" not in inject:
log.data(pretty(inject))
raise TCMSError("Failed to initialize " + self.identifier)
# Set up attributes
self._author = User(inject["author_id"])
if inject["owner_id"] is not None:
self._owner = User(inject["owner_id"])
else:
self._owner = None
self._name = inject["name"]
self._product = Product({
"id": inject["product_id"],
"name": inject["product"]})
self._version = Version({
"id": inject["product_version_id"],
"value": inject["product_version"],
"product_id": inject["product_id"]})
self._type = PlanType(inject["type_id"])
self._status = PlanStatus(inject["is_active"] in ["True", True])
if inject["parent_id"] is not None:
self._parent = TestPlan(inject["parent_id"])
else:
self._parent = None
# Initialize containers
self._testcases = PlanCases(self)
self._testruns = PlanRuns(self)
self._children = ChildPlans(self)
# If all tags are cached, initialize them directly from the inject
if "tag" in inject and Tag._is_cached(inject["tag"]):
self._tags = PlanTags(
self, inset=[Tag(tag) for tag in inject["tag"]])
else:
self._tags = PlanTags(self)
# Index the fetched object into cache
self._index()
def _fetch(self, inject=None):
""" Initialize / refresh test run data.
Either fetch them from the server or use the provided hash.
"""
TCMS._fetch(self, inject)
# Fetch the data hash from the server unless provided
if inject is None:
log.info("Fetching test run {0}".format(self.identifier))
try:
inject = self._server.TestRun.filter({'pk': self.id})[0]
except IndexError as error:
log.debug(error)
raise TCMSError(
"Failed to fetch test run TR#{0}".format(self.id))
self._inject = inject
else:
self._id = inject["run_id"]
log.debug("Initializing test run {0}".format(self.identifier))
log.data(pretty(inject))
# Set up attributes
self._build = Build(inject["build_id"])
self._manager = User(inject["manager_id"])
self._notes = inject["notes"]
self._status = RunStatus(inject["stop_date"])
self._old_status = self._status
self._summary = inject["summary"]
self._tester = User(inject["default_tester_id"])
self._testplan = TestPlan(inject["plan_id"])
self._time = inject["estimated_time"]
try:
self._started = datetime.datetime.strptime(
inject["start_date"], "%Y-%m-%d %H:%M:%S")
except TypeError:
self._started = None
try:
self._finished = datetime.datetime.strptime(
inject["stop_date"], "%Y-%m-%d %H:%M:%S")
except TypeError:
self._finished = None
# Initialize containers
self._caseruns = RunCaseRuns(self)
self._testcases = RunCases(self)
self._tags = RunTags(self)
# Index the fetched object into cache
self._index()
def _fetch(self, inject=None, **kwargs):
""" Initialize / refresh test case run data.
Either fetch them from the server or use the supplied hashes.
"""
TCMS._fetch(self, inject)
# Fetch the data from the server unless inject provided
if inject is None:
log.info("Fetching case run {0}".format(self.identifier))
inject = self._server.TestCaseRun.filter({'pk': self.id})[0]
self._inject = inject
else:
self._id = inject["case_run_id"]
log.debug("Initializing case run {0}".format(self.identifier))
log.data(pretty(inject))
# Set up attributes
self._assignee = User(inject["assignee_id"])
self._build = Build(inject["build_id"])
self._notes = inject["notes"]
if inject["sortkey"] is not None:
self._sortkey = int(inject["sortkey"])
else:
self._sortkey = None
self._status = Status(inject["case_run_status_id"])
self._testrun = TestRun(inject["run_id"])
# Initialize attached test case (from dict, object or id)
testcaseinject = kwargs.get("testcaseinject", None)
if testcaseinject and isinstance(testcaseinject, dict):
self._testcase = TestCase(testcaseinject)
elif testcaseinject and isinstance(testcaseinject, TestCase):
self._testcase = testcaseinject
else:
self._testcase = TestCase(inject["case_id"])
# Initialize containers
self._bugs = CaseRunBugs(self)
# Index the fetched object into cache
self._index()
def _fetch(self, inject=None):
""" Initialize / refresh test case data.
Either fetch them from the server or use provided hash.
"""
TCMS._fetch(self, inject)
# Fetch the data hash from the server unless provided
if inject is None:
log.info("Fetching test case " + self.identifier)
try:
inject = self._server.TestCase.filter({'pk': self.id})[0]
except IndexError as error:
log.debug(error)
raise TCMSError(
"Failed to fetch test case TC#{0}".format(self.id))
self._inject = inject
else:
self._id = inject["case_id"]
log.debug("Initializing test case " + self.identifier)
log.data(pretty(inject))
# Set up attributes
self._arguments = inject["arguments"]
self._author = User(inject["author_id"])
self._category = Category(inject["category_id"])
if isinstance(inject["create_date"], str):
self._created = datetime.datetime.strptime(
inject["create_date"], "%Y-%m-%d %H:%M:%S")
else:
self._created = inject["create_date"]
self._link = inject["extra_link"]
self._notes = inject["notes"]
self._priority = Priority(inject["priority_id"])
self._requirement = inject["requirement"]
self._script = inject["script"]
self._status = CaseStatus(inject["case_status_id"])
self._summary = inject["summary"]
self._time = inject["estimated_time"]
if inject["default_tester_id"] is not None:
self._tester = User(inject["default_tester_id"])
else:
self._tester = None
# Handle manual, automated and autoproposed
self._automated = inject["is_automated"] in [1, '1', 2, '2']
self._manual = inject["is_automated"] in [0, '0', 2, '2']
self._autoproposed = inject["is_automated_proposed"]
# Empty script or arguments to be handled same as None
if self._script == "":
self._script = None
if self._arguments == "":
self._arguments = None
# Test case documentation
for attribute in ["setup", "action", "effect", "breakdown"]:
if "text" in inject:
setattr(self, "_" + attribute, inject["text"][attribute])
else:
setattr(self, "_" + attribute, None)
# Initialize containers
self._bugs = CaseBugs(self)
self._testplans = CasePlans(self)
self._components = CaseComponents(self)
# If all tags are cached, initialize them directly from the inject
if "tag" in inject and Tag._is_cached(inject["tag"]):
self._tags = CaseTags(
self, inset=[Tag(tag) for tag in inject["tag"]])
else:
self._tags = CaseTags(self)
# Index the fetched object into cache
self._index()
def _create(self, summary, category, **kwargs):
""" Create a new test case """
hash = {}
# Summary
hash["summary"] = summary
# If category provided as text, we need product as well
product = kwargs.get("product")
if isinstance(category, str) and not kwargs.get("product"):
raise TCMSError(
"Need product when category specified by name")
# Category & Product
if isinstance(category, str):
category = Category(category=category, product=product)
elif not isinstance(category, Category):
raise TCMSError("Invalid category '{0}'".format(category))
hash["category"] = category.id
hash["product"] = category.product.id
# Priority
priority = kwargs.get("priority")
if priority is None:
priority = Priority("P3")
elif not isinstance(priority, Priority):
priority = Priority(priority)
hash["priority"] = priority.id
# User
tester = kwargs.get("tester")
if tester:
if isinstance(tester, str):
tester = User(login=tester)
hash["default_tester"] = tester.login
# Script, arguments, requirement & reference link
hash["script"] = kwargs.get("script")
hash["arguments"] = kwargs.get("arguments")
hash["requirement"] = kwargs.get("requirement")
hash["extra_link"] = kwargs.get("link")
# Case Status
status = kwargs.get("status")
if status:
if isinstance(status, str):
status = CaseStatus(status)
hash["case_status"] = status.id
# Manual, automated and autoproposed
automated = kwargs.get("automated", True)
autoproposed = kwargs.get("autoproposed", False)
manual = kwargs.get("manual", False)
if automated and manual:
hash["is_automated"] = 2
elif automated:
hash["is_automated"] = 1
else:
hash["is_automated"] = 0
hash["is_automated_proposed"] = autoproposed
# Estimated time
hash["estimated_time"] = kwargs.get("time", '00:00:00')
# Notes
notes = kwargs.get("notes")
if notes:
hash["notes"] = notes
# Submit
log.info("Creating a new test case")
log.data(pretty(hash))
testcasehash = self._server.TestCase.create(hash)
log.data(pretty(testcasehash))
try:
self._id = testcasehash["case_id"]
except TypeError:
log.debug("Failed to create a new test case")
log.data(pretty(hash))
log.data(pretty(testcasehash))
raise TCMSError("Failed to create test case")
self._fetch(testcasehash)
log.info("Successfully created {0}".format(self))
def _create(self, testplan, product=None, version=None, build=None,
summary=None, notes=None, manager=None, tester=None, **kwargs):
""" Create a new test run """
hash = {}
# Test plan
if isinstance(testplan, int):
testplan = TestPlan(testplan)
hash["plan"] = testplan.id
# Product & version
if product is None:
product = testplan.product
elif not isinstance(product, Product):
product = Product(product)
hash["product"] = product.id
if version is None:
version = testplan.version
elif isinstance(version, int):
version = Version(version)
else:
version = Version(name=version, product=product)
hash["product_version"] = version.id
# Build
if build is None:
build = "unspecified"
if isinstance(build, str):
build = Build(build=build, product=product)
hash["build"] = build.id
# Summary & notes
if summary is None:
summary = "{0} on {1}".format(testplan.name, build)
if notes is None:
notes = ""
hash["summary"] = summary
hash["notes"] = notes
# Manager & tester (current user by default)
if not isinstance(manager, User):
manager = User(manager)
if not isinstance(tester, User):
tester = User(tester)
hash["manager"] = manager.id
hash["default_tester"] = tester.id
# Submit to the server and initialize
log.info("Creating a new test run based on {0}".format(testplan))
log.data(pretty(hash))
testrunhash = self._server.TestRun.create(hash)
log.data(pretty(testrunhash))
try:
self._id = testrunhash["run_id"]
except TypeError:
log.debug("Failed to create a new test run based on {0}".format(
testplan))
log.data(pretty(hash))
log.data(pretty(testrunhash))
raise TCMSError("Failed to create test run")
self._fetch(testrunhash)
# Add newly created test run to testplan.testruns container
if PlanRuns._is_cached(testplan.testruns):
testplan.testruns._fetch(list(testplan.testruns) + [self])
log.info("Successfully created {0}".format(self))