Ejemplo n.º 1
0
 def test_task_delete_with_results(self):
     task_id = self._create_task()["uuid"]
     db.task_result_create(task_id, {task_id: task_id}, {task_id: task_id})
     res = db.task_result_get_all_by_uuid(task_id)
     self.assertEqual(len(res), 1)
     db.task_delete(task_id)
     res = db.task_result_get_all_by_uuid(task_id)
     self.assertEqual(len(res), 0)
Ejemplo n.º 2
0
    def test_task_get_detailed(self):
        validation_result = {
            "etype": "FooError",
            "msg": "foo message",
            "trace": "foo t/b",
        }
        task1 = self._create_task({
            "validation_result": validation_result,
            "tag": "bar"
        })
        key = {
            "name": "atata",
            "pos": 0,
            "kw": {
                "args": {
                    "a": "A"
                },
                "context": {
                    "c": "C"
                },
                "sla": {
                    "s": "S"
                },
                "runner": {
                    "r": "R",
                    "type": "T"
                }
            }
        }
        data = {
            "raw": [],
            "sla": [{
                "s": "S",
                "success": True
            }, {
                "1": "2",
                "success": True
            }, {
                "a": "A",
                "success": True
            }],
            "load_duration":
            13,
            "full_duration":
            42,
            "hooks": [],
        }

        db.task_result_create(task1["uuid"], key, data)
        task1_full = db.task_get_detailed(task1["uuid"])
        self.assertEqual(validation_result,
                         json.loads(task1_full["verification_log"]))
        self.assertEqual("bar", task1_full["tag"])
        results = task1_full["results"]
        self.assertEqual(1, len(results))
        self.assertEqual(key, results[0]["key"])
        self.assertEqual(data, results[0]["data"])
Ejemplo n.º 3
0
 def test_task_delete_with_results(self):
     task_id = self._create_task()["uuid"]
     db.task_result_create(task_id,
                           {task_id: task_id},
                           {task_id: task_id})
     res = db.task_result_get_all_by_uuid(task_id)
     self.assertEqual(len(res), 1)
     db.task_delete(task_id)
     res = db.task_result_get_all_by_uuid(task_id)
     self.assertEqual(len(res), 0)
Ejemplo n.º 4
0
    def test_task_get_detailed_last(self):
        task1 = self._create_task()
        key = {"name": "atata"}
        data = {"a": "b", "c": "d"}

        db.task_result_create(task1["uuid"], key, data)
        task1_full = db.task_get_detailed_last()
        results = task1_full["results"]
        self.assertEqual(len(results), 1)
        self.assertEqual(results[0]["key"], key)
        self.assertEqual(results[0]["data"], data)
Ejemplo n.º 5
0
    def test_task_get_detailed_last(self):
        task1 = self._create_task()
        key = {"name": "atata"}
        data = {"a": "b", "c": "d"}

        db.task_result_create(task1["uuid"], key, data)
        task1_full = db.task_get_detailed_last()
        results = task1_full["results"]
        self.assertEqual(len(results), 1)
        self.assertEqual(results[0]["key"], key)
        self.assertEqual(results[0]["data"], data)
Ejemplo n.º 6
0
    def test_task_result_get_all_by_uuid(self):
        task1 = self._create_task()["uuid"]
        task2 = self._create_task()["uuid"]

        for task_id in (task1, task2):
            db.task_result_create(task_id, {task_id: task_id},
                                  {task_id: task_id})

        for task_id in (task1, task2):
            res = db.task_result_get_all_by_uuid(task_id)
            data = {task_id: task_id}
            self.assertEqual(len(res), 1)
            self.assertEqual(res[0]["key"], data)
            self.assertEqual(res[0]["data"], data)
Ejemplo n.º 7
0
 def test_task_result_create(self):
     task_id = self._create_task()["uuid"]
     key = {
         "name": "atata",
         "pos": 0,
         "kw": {
             "args": {
                 "a": "A"
             },
             "context": {
                 "c": "C"
             },
             "sla": {
                 "s": "S"
             },
             "runner": {
                 "r": "R",
                 "type": "T"
             }
         }
     }
     data = {
         "raw": [{
             "error": "anError"
         }, {
             "duration": 1
         }, {
             "duration": 2
         }],
         "sla": [{
             "s": "S",
             "success": True
         }, {
             "1": "2",
             "success": True
         }, {
             "a": "A",
             "success": True
         }],
         "load_duration":
         13,
         "full_duration":
         42,
         "hooks": [],
     }
     db.task_result_create(task_id, key, data)
     res = db.task_result_get_all_by_uuid(task_id)
     self.assertEqual(1, len(res))
     self.assertEqual(data["raw"], res[0]["data"]["raw"])
Ejemplo n.º 8
0
    def test_task_result_get_all_by_uuid(self):
        task1 = self._create_task()["uuid"]
        task2 = self._create_task()["uuid"]

        for task_id in (task1, task2):
            db.task_result_create(task_id,
                                  {task_id: task_id},
                                  {task_id: task_id})

        for task_id in (task1, task2):
            res = db.task_result_get_all_by_uuid(task_id)
            data = {task_id: task_id}
            self.assertEqual(len(res), 1)
            self.assertEqual(res[0]["key"], data)
            self.assertEqual(res[0]["data"], data)
Ejemplo n.º 9
0
    def test_task_get_detailed_last(self):
        task1 = self._create_task()
        key = {
            "name": "atata",
            "pos": 0,
            "kw": {
                "args": {
                    "a": "A"
                },
                "context": {
                    "c": "C"
                },
                "sla": {
                    "s": "S"
                },
                "runner": {
                    "r": "R",
                    "type": "T"
                }
            }
        }
        data = {
            "raw": [],
            "sla": [{
                "s": "S",
                "success": True
            }, {
                "1": "2",
                "success": True
            }, {
                "a": "A",
                "success": True
            }],
            "load_duration":
            13,
            "full_duration":
            42,
            "hooks": [],
        }

        db.task_result_create(task1["uuid"], key, data)
        task1_full = db.task_get_detailed_last()
        results = task1_full["results"]
        self.assertEqual(1, len(results))
        self.assertEqual(key, results[0]["key"])
        self.assertEqual(data, results[0]["data"])
Ejemplo n.º 10
0
    def test_task_result_get_all_by_uuid(self):
        task1 = self._create_task()["uuid"]
        task2 = self._create_task()["uuid"]
        key = {
            "name": "atata",
            "pos": 0,
            "kw": {
                "args": {
                    "task_id": "task_id"
                },
                "context": {
                    "c": "C"
                },
                "sla": {
                    "s": "S"
                },
                "runner": {
                    "r": "R",
                    "type": "T"
                }
            }
        }
        data = {
            "raw": [],
            "sla": [{
                "success": True
            }],
            "load_duration": 13,
            "full_duration": 42,
            "hooks": [],
        }

        for task_id in (task1, task2):
            key["kw"]["args"]["task_id"] = task_id
            data["sla"][0] = {"success": True}
            db.task_result_create(task_id, key, data)

        for task_id in (task1, task2):
            res = db.task_result_get_all_by_uuid(task_id)
            key["kw"]["args"]["task_id"] = task_id
            data["sla"][0] = {"success": True}
            self.assertEqual(len(res), 1)
            self.assertEqual(res[0]["key"], key)
            self.assertEqual(res[0]["data"], data)
Ejemplo n.º 11
0
 def test_task_delete_with_results(self):
     task_id = self._create_task()["uuid"]
     key = {
         "name": "atata",
         "pos": 0,
         "kw": {
             "args": {
                 "a": "A"
             },
             "context": {
                 "c": "C"
             },
             "sla": {
                 "s": "S"
             },
             "runner": {
                 "r": "R",
                 "type": "T"
             }
         }
     }
     data = {
         "raw": [],
         "sla": [{
             "s": "S",
             "success": True
         }, {
             "1": "2",
             "success": True
         }, {
             "a": "A",
             "success": True
         }],
         "load_duration":
         13,
         "full_duration":
         42
     }
     db.task_result_create(task_id, key, data)
     res = db.task_result_get_all_by_uuid(task_id)
     self.assertEqual(len(res), 1)
     db.task_delete(task_id)
     res = db.task_result_get_all_by_uuid(task_id)
     self.assertEqual(len(res), 0)
Ejemplo n.º 12
0
 def append_results(self, key, value):
     db.task_result_create(self.task["uuid"], key, value)
Ejemplo n.º 13
0
 def append_results(self, key, value):
     db.task_result_create(self.task["uuid"], key, value)