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))