Exemplo n.º 1
0
    def test_PUT_include_output(self):
        self.become_admin()
        script_set = self.make_scriptset()
        script_results = {}
        for _ in range(3):
            script_result = factory.make_ScriptResult(script_set=script_set)
            script_results[script_result.name] = script_result

        response = self.client.put(
            self.get_script_result_uri(script_set), {"include_output": True}
        )
        self.assertThat(response, HasStatusCode(http.client.OK))
        parsed_result = json_load_bytes(response.content)
        results = parsed_result.pop("results")

        self.assertDictEqual(
            {
                "id": script_set.id,
                "system_id": script_set.node.system_id,
                "type": script_set.result_type,
                "type_name": script_set.result_type_name,
                "last_ping": fmt_time(script_set.last_ping),
                "status": script_set.status,
                "status_name": script_set.status_name,
                "started": fmt_time(script_set.started),
                "ended": fmt_time(script_set.ended),
                "runtime": script_set.runtime,
                "resource_uri": "/MAAS/api/2.0/nodes/%s/results/%d/"
                % (script_set.node.system_id, script_set.id),
            },
            parsed_result,
        )
        for result in results:
            script_result = script_results[result["name"]]
            self.assertDictEqual(
                {
                    "id": script_result.id,
                    "name": script_result.name,
                    "created": fmt_time(script_result.created),
                    "updated": fmt_time(script_result.updated),
                    "status": script_result.status,
                    "status_name": script_result.status_name,
                    "exit_status": script_result.exit_status,
                    "started": fmt_time(script_result.started),
                    "ended": fmt_time(script_result.ended),
                    "runtime": script_result.runtime,
                    "starttime": script_result.starttime,
                    "endtime": script_result.endtime,
                    "estimated_runtime": script_result.estimated_runtime,
                    "parameters": script_result.parameters,
                    "script_id": script_result.script_id,
                    "script_revision_id": script_result.script_version_id,
                    "suppressed": script_result.suppressed,
                    "output": b64encode(script_result.output).decode(),
                    "stdout": b64encode(script_result.stdout).decode(),
                    "stderr": b64encode(script_result.stderr).decode(),
                    "result": b64encode(script_result.result).decode(),
                },
                result,
            )
Exemplo n.º 2
0
    def test_GET(self):
        script_set = self.make_scriptset()
        script_results = {}
        for _ in range(3):
            script_result = factory.make_ScriptResult(script_set=script_set)
            script_results[script_result.name] = script_result

        response = self.client.get(self.get_script_result_uri(script_set))
        self.assertThat(response, HasStatusCode(http.client.OK))
        parsed_result = json_load_bytes(response.content)
        results = parsed_result.pop('results')

        self.assertDictEqual(
            {
                'id':
                script_set.id,
                'system_id':
                script_set.node.system_id,
                'type':
                script_set.result_type,
                'type_name':
                script_set.result_type_name,
                'last_ping':
                fmt_time(script_set.last_ping),
                'status':
                script_set.status,
                'status_name':
                script_set.status_name,
                'started':
                fmt_time(script_set.started),
                'ended':
                fmt_time(script_set.ended),
                'runtime':
                script_set.runtime,
                'resource_uri':
                '/MAAS/api/2.0/nodes/%s/results/%d/' %
                (script_set.node.system_id, script_set.id),
            }, parsed_result)
        for result in results:
            script_result = script_results[result['name']]
            self.assertDictEqual(
                {
                    'id': script_result.id,
                    'name': script_result.name,
                    'created': fmt_time(script_result.created),
                    'updated': fmt_time(script_result.updated),
                    'status': script_result.status,
                    'status_name': script_result.status_name,
                    'exit_status': script_result.exit_status,
                    'started': fmt_time(script_result.started),
                    'ended': fmt_time(script_result.ended),
                    'runtime': script_result.runtime,
                    'starttime': script_result.starttime,
                    'endtime': script_result.endtime,
                    'estimated_runtime': script_result.estimated_runtime,
                    'parameters': script_result.parameters,
                    'script_id': script_result.script_id,
                    'script_revision_id': script_result.script_version_id,
                    'suppressed': script_result.suppressed,
                }, result)
Exemplo n.º 3
0
    def test_GET_filters(self):
        scripts = [factory.make_Script() for _ in range(10)]
        script_set = self.make_scriptset()
        script_results = {}
        for script in scripts:
            script_result = factory.make_ScriptResult(
                script_set=script_set, script=script)
            script_results[script_result.name] = script_result
        results_list = list(script_results.values())
        filtered_results = [random.choice(results_list) for _ in range(3)]

        response = self.client.get(
            self.get_script_result_uri(script_set),
            {'filters': '%s,%s,%d' % (
                filtered_results[0].name,
                random.choice(filtered_results[1].script.tags),
                filtered_results[2].id)})
        self.assertThat(response, HasStatusCode(http.client.OK))
        parsed_result = json_load_bytes(response.content)
        results = parsed_result.pop('results')

        self.assertDictEqual({
            'id': script_set.id,
            'system_id': script_set.node.system_id,
            'type': script_set.result_type,
            'type_name': script_set.result_type_name,
            'last_ping': fmt_time(script_set.last_ping),
            'status': script_set.status,
            'status_name': script_set.status_name,
            'started': fmt_time(script_set.started),
            'ended': fmt_time(script_set.ended),
            'runtime': script_set.runtime,
            'resource_uri': '/api/2.0/nodes/%s/results/%d/' % (
                script_set.node.system_id, script_set.id),
            }, parsed_result)
        for result in results:
            self.assertIn(
                result['name'],
                [script_result.name for script_result in filtered_results])
            script_result = script_results[result['name']]
            self.assertDictEqual({
                'id': script_result.id,
                'name': script_result.name,
                'created': fmt_time(script_result.created),
                'updated': fmt_time(script_result.updated),
                'status': script_result.status,
                'status_name': script_result.status_name,
                'exit_status': script_result.exit_status,
                'started': fmt_time(script_result.started),
                'ended': fmt_time(script_result.ended),
                'runtime': script_result.runtime,
                'script_id': script_result.script_id,
                'script_revision_id': script_result.script_version_id,
                }, result)
Exemplo n.º 4
0
    def test_PUT_filters(self):
        self.become_admin()
        scripts = [factory.make_Script() for _ in range(10)]
        script_set = self.make_scriptset()
        script_results = {}
        for script in scripts:
            script_result = factory.make_ScriptResult(script_set=script_set,
                                                      script=script)
            script_results[script_result.name] = script_result
        results_list = list(script_results.values())
        filtered_results = [random.choice(results_list) for _ in range(3)]

        response = self.client.get(
            self.get_script_result_uri(script_set),
            {
                "filters":
                "%s,%s,%d" % (
                    filtered_results[0].name,
                    random.choice([
                        tag for tag in filtered_results[1].script.tags
                        if "tag" in tag
                    ]),
                    filtered_results[2].id,
                )
            },
        )
        self.assertThat(response, HasStatusCode(http.client.OK))
        parsed_result = json_load_bytes(response.content)
        results = parsed_result.pop("results")

        self.assertDictEqual(
            {
                "id":
                script_set.id,
                "system_id":
                script_set.node.system_id,
                "type":
                script_set.result_type,
                "type_name":
                script_set.result_type_name,
                "last_ping":
                fmt_time(script_set.last_ping),
                "status":
                script_set.status,
                "status_name":
                script_set.status_name,
                "started":
                fmt_time(script_set.started),
                "ended":
                fmt_time(script_set.ended),
                "runtime":
                script_set.runtime,
                "resource_uri":
                "/MAAS/api/2.0/nodes/%s/results/%d/" %
                (script_set.node.system_id, script_set.id),
            },
            parsed_result,
        )
        for result in results:
            self.assertIn(
                result["name"],
                [script_result.name for script_result in filtered_results],
            )
            script_result = script_results[result["name"]]
            self.assertDictEqual(
                {
                    "id": script_result.id,
                    "name": script_result.name,
                    "created": fmt_time(script_result.created),
                    "updated": fmt_time(script_result.updated),
                    "status": script_result.status,
                    "status_name": script_result.status_name,
                    "exit_status": script_result.exit_status,
                    "started": fmt_time(script_result.started),
                    "ended": fmt_time(script_result.ended),
                    "runtime": script_result.runtime,
                    "starttime": script_result.starttime,
                    "endtime": script_result.endtime,
                    "estimated_runtime": script_result.estimated_runtime,
                    "parameters": script_result.parameters,
                    "script_id": script_result.script_id,
                    "script_revision_id": script_result.script_version_id,
                    "suppressed": script_result.suppressed,
                },
                result,
            )