def test_task(self):
     cfg = {
         "Dummy.dummy_random_fail_in_atomic": [
             {
                 "runner": {
                     "type": "constant",
                     "times": 100,
                     "concurrency": 5
                 }
             }
         ]
     }
     with mock.patch.dict("os.environ", utils.TEST_ENV):
         deployment_id = envutils.get_global("RALLY_DEPLOYMENT")
         config = utils.TaskConfig(cfg)
         output = self.rally(("task start --task %(task_file)s "
                              "--deployment %(deployment_id)s") %
                             {"task_file": config.filename,
                              "deployment_id": deployment_id})
         result = re.search(
             r"(?P<uuid>[0-9a-f\-]{36}): started", output)
         uuid = result.group("uuid")
         self.rally("use task --uuid %s" % uuid)
         current_task = envutils.get_global("RALLY_TASK")
         self.assertEqual(uuid, current_task)

 def test_use(self):
     rally = utils.Rally()
     with mock.patch.dict("os.environ", utils.TEST_ENV):
         deployment_id = envutils.get_global("RALLY_DEPLOYMENT")
         config = utils.TaskConfig(self._get_sample_task_config())
         output = rally(("task start --task %(task_file)s "
                         "--deployment %(deployment_id)s") %
                        {"task_file": config.filename,
                         "deployment_id": deployment_id})
         result = re.search(
             r"(?P<uuid>[0-9a-f\-]{36}): started", output)
         uuid = result.group("uuid")
         rally("task use --task %s" % uuid)
         current_task = envutils.get_global("RALLY_TASK")
         self.assertEqual(uuid, current_task)

    def show_verifier(self, api, verifier_id=None):
        """Show detailed information about a verifier."""

        verifier = api.verifier.get(verifier_id=verifier_id)
        fields = ["UUID", "Status", "Created at", "Updated at", "Active",
                  "Name", "Description", "Type", "Platform", "Source",
                  "Version", "System-wide", "Extra settings", "Location",
                  "Venv location"]
        used_verifier = envutils.get_global(envutils.ENV_VERIFIER)
        formatters = {
            "Created at": lambda v: v["created_at"].replace("T", " "),
            "Updated at": lambda v: v["updated_at"].replace("T", " "),
            "Active": lambda v: u"\u2714"
                                if v["uuid"] == used_verifier else None,
            "Extra settings": lambda v: (json.dumps(v["extra_settings"],
                                                    indent=4)
                                         if v["extra_settings"] else None),
            "Location": lambda v: self._get_location((v["uuid"]), "repo")
        }
        if not verifier["system_wide"]:
            formatters["Venv location"] = lambda v: self._get_location(
                v["uuid"], ".venv")
        cliutils.print_dict(verifier, fields=fields, formatters=formatters,
                            normalize_field_names=True, print_header=False,
                            table_label="Verifier")
        print("Attention! All you do in the verifier repository or verifier "
              "virtual environment, you do it at your own risk!")

 def test_deployment(self):
     with mock.patch.dict("os.environ", utils.TEST_ENV):
         output = self.rally(
             "deployment create --name t_create_env1 --fromenv")
         uuid = self._get_deployment_uuid(output)
         self.rally("deployment create --name t_create_env2 --fromenv")
         self.rally("use deployment --deployment %s" % uuid)
         current_deployment = envutils.get_global("RALLY_DEPLOYMENT")
         self.assertEqual(uuid, current_deployment)

 def test_use(self):
     with mock.patch.dict("os.environ", utils.TEST_ENV):
         output = self.rally(
             "deployment create --name t_create_env1 --fromenv")
         uuid = re.search(r"Using deployment: (?P<uuid>[0-9a-f\-]{36})",
                          output).group("uuid")
         self.rally("deployment create --name t_create_env2 --fromenv")
         self.rally("deployment use --deployment %s" % uuid)
         current_deployment = envutils.get_global("RALLY_DEPLOYMENT")
         self.assertEqual(uuid, current_deployment)

 def test_validate_is_invalid(self):
     rally = utils.Rally()
     with mock.patch.dict("os.environ", utils.TEST_ENV):
         deployment_id = envutils.get_global("RALLY_DEPLOYMENT")
     cfg = {"invalid": "config"}
     config = utils.TaskConfig(cfg)
     self.assertRaises(utils.RallyCliError,
                       rally,
                       ("task validate --task %(task_file)s "
                        "--deployment %(deployment_id)s") %
                       {"task_file": config.filename,
                        "deployment_id": deployment_id})

 def _test_start_abort_on_sla_failure(self, cfg, times):
     rally = utils.Rally()
     with mock.patch.dict("os.environ", utils.TEST_ENV):
         deployment_id = envutils.get_global("RALLY_DEPLOYMENT")
         config = utils.TaskConfig(cfg)
         rally(("task start --task %(task_file)s "
                "--deployment %(deployment_id)s --abort-on-sla-failure") %
               {"task_file": config.filename,
                "deployment_id": deployment_id})
         results = json.loads(rally("task results"))
     iterations_completed = len(results[0]["result"])
     self.assertTrue(iterations_completed < times)

 def test_start(self):
     rally = utils.Rally()
     with mock.patch.dict("os.environ", utils.TEST_ENV):
         deployment_id = envutils.get_global("RALLY_DEPLOYMENT")
         cfg = self._get_sample_task_config()
         config = utils.TaskConfig(cfg)
         output = rally(("task start --task %(task_file)s "
                         "--deployment %(deployment_id)s") %
                        {"task_file": config.filename,
                         "deployment_id": deployment_id})
     result = re.search(
         r"(?P<task_id>[0-9a-f\-]{36}): started", output)
     self.assertIsNotNone(result)

def launch_verification_once(launch_parameters):
    """Launch verification and show results in different formats."""
    results = call_rally("verify start %s" % launch_parameters)
    results["uuid"] = envutils.get_global(envutils.ENV_VERIFICATION)
    results["result_in_html"] = call_rally("verify results",
                                           output_type="html")
    results["result_in_json"] = call_rally("verify results",
                                           output_type="json")
    results["show"] = call_rally("verify show")
    results["show_detailed"] = call_rally("verify show --detailed")
    # NOTE(andreykurilin): we need to clean verification uuid from global
    # environment to be able to load it next time(for another verification).
    envutils.clear_global(envutils.ENV_VERIFICATION)
    return results

def setup(): 
    if CONF.profile:
        profile = CONF.profile
    else:
        profile = envutils.get_global("RALLY_PROFILE")
        if profile == None:
            profile = PROFILE_OPENSTACK
            
    if not profile in PROFILE_ALL_LIST:
        raise InvalidArgumentsException("Unknown profile %s" % profile)
    
    fileutils.update_globals_file("RALLY_PROFILE", profile)
    
    print("Using profile: %s" % profile)    

    def list(self, api, deployment_list=None):
        """List existing deployments."""

        headers = ["uuid", "created_at", "name", "status", "active"]
        current_deployment = envutils.get_global("RALLY_DEPLOYMENT")
        deployment_list = deployment_list or api.deployment.list()

        table_rows = []
        if deployment_list:
            for t in deployment_list:
                r = [str(t[column]) for column in headers[:-1]]
                r.append("" if t["uuid"] != current_deployment else "*")
                table_rows.append(utils.Struct(**dict(zip(headers, r))))
            cliutils.print_list(table_rows, headers,
                                sortby_index=headers.index("created_at"))
        else:
            print("There are no deployments. To create a new deployment, use:"
                  "\nrally deployment create")

 def list(self, api, to_json=False):
     """List existing environments."""
     envs = env_mgr.EnvManager.list()
     if to_json:
         print(json.dumps([env.cached_data for env in envs], indent=2))
     elif not envs:
         print(self.MSG_NO_ENVS)
     else:
         cur_env = envutils.get_global(envutils.ENV_ENV)
         table = prettytable.PrettyTable()
         fields = ["uuid", "name", "status", "created_at", "description"]
         table.field_names = fields + ["default"]
         for env in envs:
             row = [env.cached_data[f] for f in fields]
             row.append(cur_env == env.cached_data["uuid"] and "*" or "")
             table.add_row(row)
         table.sortby = "created_at"
         table.reversesort = True
         table.align = "l"
         print(table.get_string())

    def list_verifiers(self, api, status=None):
        """List all verifiers."""

        verifiers = api.verifier.list(status=status)
        if verifiers:
            fields = ["UUID", "Name", "Type", "Platform", "Created at",
                      "Updated at", "Status", "Version", "System-wide",
                      "Active"]
            cv = envutils.get_global(envutils.ENV_VERIFIER)
            formatters = {
                "Created at": lambda v: v["created_at"],
                "Updated at": lambda v: v["updated_at"],
                "Active": lambda v: u"\u2714" if v["uuid"] == cv else "",
            }
            cliutils.print_list(verifiers, fields, formatters=formatters,
                                normalize_field_names=True, sortby_index=4)
        elif status:
            print("There are no verifiers with status '%s'." % status)
        else:
            print("There are no verifiers. You can create verifier, using "
                  "command `rally verify create-verifier`.")

 def test_get_task_id_with_none(self, mock_load_env_file):
     self.assertIsNone(envutils.get_global("RALLY_TASK"))
     mock_load_env_file.assert_called_once_with(os.path.expanduser(
         "~/.rally/globals"))

 def test_get_task_id_in_env(self):
     self.assertEqual("my_task_id", envutils.get_global(envutils.ENV_TASK))

 def test_get_deployment_id_in_env(self):
     deployment_id = envutils.get_global(envutils.ENV_DEPLOYMENT)
     self.assertEqual("my_deployment_id", deployment_id)

 def test_get_deployment_id_with_none(self, mock_load_env_file):
     self.assertIsNone(envutils.get_global(envutils.ENV_DEPLOYMENT))
     mock_load_env_file.assert_called_once_with(os.path.expanduser(
         "~/.rally/globals"))

    def results(self, uuids=None, output_file=None,
                output_html=False, output_json=False, output_csv=False):
        """Display results of verifications.

        :param verification: UUID of a verification
        :param output_file: Path to a file to save results
        :param output_json: Display results in JSON format (Default)
        :param output_html: Display results in HTML format
        :param output_csv: Display results in CSV format
        """
        if not uuids:
            uuid = envutils.get_global(envutils.ENV_VERIFICATION)
            if not uuid:
                raise exceptions.InvalidArgumentsException(
                    "Verification UUID is missing")
            uuids = [uuid]
        data = []
        for uuid in uuids:
            try:
                verification = api.Verification.get(uuid)
            except exceptions.NotFoundException as e:
                print(six.text_type(e))
                return 1
            data.append(verification)

        if output_json + output_html + output_csv > 1:
            print(_("Please specify only one format option from %s.")
                  % "--json, --html, --csv")
            return 1

        verifications = {}
        for ver in data:
            uuid = ver.db_object["uuid"]
            res = ver.get_results() or {}
            tests = {}
            for test in list(res.get("test_cases", {}).values()):
                name = test["name"]
                if name in tests:
                    mesg = ("Duplicated test in verification "
                            "%(uuid)s: %(test)s" % {"uuid": uuid,
                                                    "test": name})
                    raise exceptions.RallyException(mesg)
                tests[name] = {"tags": test["tags"],
                               "status": test["status"],
                               "duration": test["time"],
                               "details": (test.get("traceback", "").strip()
                                           or test.get("reason"))}
            verifications[uuid] = {
                "tests": tests,
                "duration": res.get("time", 0),
                "total": res.get("tests", 0),
                "skipped": res.get("skipped", 0),
                "success": res.get("success", 0),
                "expected_failures": res.get("expected_failures", 0),
                "unexpected_success": res.get("unexpected_success", 0),
                "failures": res.get("failures", 0),
                "started_at": ver.db_object[
                    "created_at"].strftime("%Y-%d-%m %H:%M:%S"),
                "finished_at": ver.db_object[
                    "updated_at"].strftime("%Y-%d-%m %H:%M:%S"),
                "status": ver.db_object["status"],
                "set_name": ver.db_object["set_name"]
            }

        if output_html:
            result = report.VerificationReport(verifications).to_html()
        elif output_csv:
            result = report.VerificationReport(verifications).to_csv()
        else:
            result = report.VerificationReport(verifications).to_json()

        if output_file:
            output_file = os.path.expanduser(output_file)
            with open(output_file, "wb") as f:
                f.write(result)
        else:
            print(result)