tasks/format-code-task-000016/tests/test.patch

diff --git a/tests/tests_api.py b/tests/tests_api.py
index 79ff485..702b681 100755
--- a/tests/tests_api.py
+++ b/tests/tests_api.py
@@ -1,4 +1,7 @@
 #!/usr/bin/env python
+"""
+    This module implements all the tests for the API view.
+"""
 import os
 import unittest
 import tempfile
@@ -25,7 +28,7 @@ def setUp(self):
         with poli.app.app_context():
             api = APIControl()
             api.usercontrol.create("john", "password")
-        self.create_sample()
+        self._create_sample()
         poli.db.session.commit()
 
     def tearDown(self):
@@ -34,17 +37,17 @@ def tearDown(self):
         os.close(self.db_fd)
         os.unlink(self.fname)
 
-    def login(self, username, password):
+    def _login(self, username, password):
         return self.app.post("/login/",
                              data=dict(
                                  username=username,
                                  password=password),
                              follow_redirects=True)
 
-    def create_sample(self):
+    def _create_sample(self):
         with open("tests/example_pe.bin", "rb") as hfile:
             data = StringIO(hfile.read())
-        self.login("john", "password")
+        self._login("john", "password")
         retval = self.app.post("/samples/",
                                content_type='multipart/form-data',
                                data=dict({'file': (data, "toto")},
@@ -53,101 +56,20 @@ def create_sample(self):
         sleep(1)
         return retval
 
-    def push_comment(self, sid=1, address=None, comment=None):
-        retval = self.app.post('/api/1.0/samples/'+str(sid)+'/comments/',
-                               data=json.dumps(dict(address=address, comment=comment)),
-                               content_type="application/json")
-        return retval
-
-
-    def create_struct(self, sid=1, name=None):
-        retval = self.app.post('/api/1.0/samples/'+str(sid)+'/structs/',
-                            data=json.dumps(dict(name=name)),
-                            content_type="application/json")
-        return retval
-
-    def create_struct_member(self, sid=1, struct_id=None, mname=None, size=0, offset=0):
-        url = '/api/1.0/samples/' + str(sid)
-        url += '/structs/' + str(struct_id)
-        url += '/members/'
-        retval = self.app.post(url,
-                            data=json.dumps(dict(name=mname,
-                                                size=size,
-                                                offset=offset)),
-                            content_type="application/json")
-        return retval
-
-    def update_struct_member_name(self, sid=1, struct_id=None, mid=None, newname=""):
-        url = '/api/1.0/samples/' + str(sid)
-        url += '/structs/' + str(struct_id)
-        url += '/members/'
-        retval = self.app.patch(url,
-                            data=json.dumps(dict(mid=mid, newname=newname)),
-                            content_type="application/json")
-        return retval
-
-    def update_struct_member_size(self, sid=1, struct_id=None, mid=None, newsize=0):
-        url = '/api/1.0/samples/' + str(sid)
-        url += '/structs/' + str(struct_id)
-        url += '/members/'
-        retval = self.app.patch(url,
-                            data=json.dumps(dict(mid=mid, newsize=newsize)),
-                            content_type="application/json")
-        return retval
-
-
-
-    def get_all_structs(self, sid=1, name=None):
-        retval = self.app.get('/api/1.0/samples/' + str(sid) +
-                              '/structs/')
-        return retval
-
-    def get_one_struct(self, sid=1, struct_id=1):
-        url = '/api/1.0/samples/' + str(sid)
-        url += '/structs/'
-        url += str(struct_id) + '/'
-        retval = self.app.get(url)
-        return retval
-
-
-    def get_comment(self, sid=1, address=None):
-        retval = self.app.get('/api/1.0/samples/' + str(sid) +
-                              '/comments/',
-                              data=json.dumps({'address':address}),
-                              content_type="application/json")
-        return retval
-
-    def push_name(self, sid=1, address=None, name=None):
-        retval = self.app.post('/api/1.0/samples/'+str(sid)+'/names/',
-                               data=json.dumps(dict(address=address, name=name)),
-                               content_type="application/json")
-        return retval
-
-    def get_name(self, sid=1, address=None):
-        retval = self.app.get('/api/1.0/samples/' + str(sid) +
-                              '/names/')
-        return retval
-
-    def create_family(self, name, tlp_level=None, parent=None):
+    def _create_family(self, name, tlp_level=None, parent=None):
         data = dict(name=name, tlp_level=tlp_level)
         if parent is not None:
             data["parent"] = parent
         retval = self.app.post('/api/1.0/family/',
-                data=json.dumps(data),
-                content_type="application/json")
+                               data=json.dumps(data),
+                               content_type="application/json")
         return retval
 
-    def create_yara(self, name, rule, tlp_level=None):
-        retval = self.app.post('/api/1.0/yaras/',
-                data=json.dumps(dict(name=name, rule=rule, tlp_level=tlp_level)),
-                content_type="application/json")
-        return retval
 
-    def update_yara(self, name, rule, tlp_level=None):
-        retval = self.app.patch('/api/1.0/yaras/',
-                data=json.dumps(dict(name=name, rule=rule, tlp_level=tlp_level)),
-                content_type="application/json")
-        return retval
+class ApiSampleTests(ApiTestCase):
+    """
+        Tests cases relatives to sample analysis and metadata
+    """
 
     def test_get_sample_info(self):
         """
@@ -156,11 +78,14 @@ def test_get_sample_info(self):
         retval = self.app.get('/api/1.0/samples/1/')
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
-        self.assertEqual(len(data),1)
+        self.assertEqual(len(data), 1)
         data = data['samples']
         self.assertEqual(data['id'], 1)
 
     def test_get_sample_id(self):
+        """
+            Test access to the sample by using MD5, SHA1 and SHA256
+        """
         # test getting ID by MD5
         retval = self.app.get('/api/1.0/samples/0f6f0c6b818f072a7a6f02441d00ac69/')
         self.assertEqual(retval.status_code, 200)
@@ -179,15 +104,20 @@ def test_get_sample_id(self):
         data = json.loads(retval.data)
         self.assertEqual(data['sample_id'], 1)
 
-        # Bug when using incorrect value for hash
+    def test_wrong_sample_hash(self):
+        """
+            This triggered a bug when using incorrect value for hash
+        """
         url = "api/1.0/samples/abcdef/"
         retval = self.app.get(url)
         self.assertEqual(retval.status_code, 400)
         data = json.loads(retval.data)
         self.assertEqual(data['error'], 400)
 
-
     def test_get_multiples_sample_info(self):
+        """
+            Extract some expected informations from the API
+        """
         retval = self.app.get('/api/1.0/samples/')
         self.assertEqual(retval.status_code, 200)
 
@@ -243,11 +173,32 @@ def test_get_strings_data(self):
         data = json.loads(retval.data)
         self.assertEqual(len(data), 1)
 
+    def test_sample_abstract(self):
+        """
+            Sets and gets the sample abstract
+        """
+        data = json.dumps(dict(abstract="This is a test for abstract"))
+        retval = self.app.post('/api/1.0/samples/1/abstract/', data=data,
+                               content_type="application/json")
+        self.assertEqual(retval.status_code, 200)
+        result = json.loads(retval.data)
+        self.assertTrue(result['result'])
+
+        retval = self.app.get('/api/1.0/samples/1/abstract/')
+        self.assertEqual(retval.status_code, 200)
+        result = json.loads(retval.data)
+        self.assertIn(result['abstract'], 'This is a test for abstract')
+
+
+class ApiFamilyTests(ApiTestCase):
+    """
+        Tests the families creation, hierarchy and manipulation
+    """
     def test_family_creation(self):
         """
             This will test the families creation and access
         """
-        retval = self.create_family("TESTFAMILY1")
+        retval = self._create_family("TESTFAMILY1")
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
         self.assertEqual(data['family'], 1)
@@ -270,7 +221,7 @@ def test_family_tlp(self):
             Test the TLP level affectation for a family
         """
 
-        retval = self.create_family("TESTFAMILY2", tlp_level=5)
+        retval = self._create_family("TESTFAMILY2", tlp_level=5)
         self.assertEqual(retval.status_code, 200)
 
         retval = self.app.get('/api/1.0/family/1/')
@@ -283,7 +234,7 @@ def test_family_abstract(self):
         """
             Try to update the family abstract
         """
-        self.create_family("TESTFAMILY1")
+        self._create_family("TESTFAMILY1")
         data = json.dumps(dict(abstract="Test abstract"))
         retval = self.app.post("/api/1.0/family/1/abstract/", data=data,
                                content_type="application/json")
@@ -295,8 +246,11 @@ def test_family_abstract(self):
         self.assertIn(data["abstract"], "Test abstract")
 
     def test_subfamilies(self):
-        self.create_family("MOTHER FAMILY")
-        self.create_family("CHILD FAMILY", parent="MOTHER FAMILY")
+        """
+            Can we manage a hierarchical family organization?
+        """
+        self._create_family("MOTHER FAMILY")
+        self._create_family("CHILD FAMILY", parent="MOTHER FAMILY")
 
 
         retval = self.app.get('/api/1.0/family/1/')
@@ -309,11 +263,222 @@ def test_subfamilies(self):
         data = json.loads(retval.data)["family"]
         self.assertEqual(data["parent_id"], 1)
 
+
+class ApiYaraTests(ApiTestCase):
+    """
+        Yara rules creation and management
+    """
+    def _create_yara(self, name, rule, tlp_level=None):
+        retval = self.app.post('/api/1.0/yaras/',
+                               data=json.dumps(dict(name=name,
+                                                    rule=rule,
+                                                    tlp_level=tlp_level)),
+                               content_type="application/json")
+        return retval
+
+    def _update_yara(self, name, rule, tlp_level=None):
+        retval = self.app.patch('/api/1.0/yaras/',
+                                data=json.dumps(dict(name=name,
+                                                     rule=rule,
+                                                     tlp_level=tlp_level)),
+                                content_type="application/json")
+        return retval
+
+    def test_yara_creation(self):
+        """
+            Creates an example yara rule,
+            and try to get it back
+        """
+        rule_text = """rule toto{
+            strings:
+                $1 = {4D 5A}
+            condition:
+                $1 at 0
+        }"""
+        retval = self._create_yara("TESTYARA", rule_text)
+        self.assertEqual(retval.status_code, 200)
+        data = json.loads(retval.data)
+        self.assertEqual(data["id"], 1)
+
+        retval = self.app.get("/api/1.0/yaras/")
+        self.assertEqual(retval.status_code, 200)
+        data = json.loads(retval.data)
+        self.assertEqual(len(data['yara_rules']), 1)
+        rule = data['yara_rules'][0]
+        self.assertIn(rule['name'], "TESTYARA")
+        self.assertEqual(rule['TLP_sensibility'], 3)
+        self.assertIn(rule['raw_rule'], rule_text)
+
+    def test_yara_tlp(self):
+        """
+            Is the TLP correctly managed for a yara rule?
+        """
+        rule_text = """rule toto{
+            strings:
+                $1 = {4D 5A}
+            condition:
+                $1 at 0
+        }"""
+        retval = self._create_yara("TESTYARA", rule_text, tlp_level=4)
+        retval = self.app.get("/api/1.0/yaras/")
+        data = json.loads(retval.data)
+        rule = data['yara_rules'][0]
+        self.assertEqual(rule['TLP_sensibility'], 4)
+
+    def test_yara_family(self):
+        """
+            Test for correct affectation of a yara to a family
+        """
+        rule_text = """rule toto{
+            strings:
+                $1 = {4D 5A}
+            condition:
+                $1 at 0
+        }"""
+        retval = self._create_yara("TESTYARA", rule_text)
+        self._create_family("TESTFAMILY")
+        retval = self.app.post('/api/1.0/family/1/yaras/',
+                               data=json.dumps(dict(rule_name="TESTYARA")),
+                               content_type="application/json")
+        self.assertEqual(retval.status_code, 200)
+        data = json.loads(retval.data)
+        self.assertTrue(data["result"])
+
+        retval = self.app.get('/api/1.0/family/1/export/1/detection/yara')
+        self.assertEqual(retval.status_code, 200)
+        self.assertIn("TESTYARA", retval.data)
+        self.assertIn("4D 5A", retval.data)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class ApiIDAActionsTests(ApiTestCase):
+    """
+        Tests storage and synchronization for implemented IDA Pro types.
+    """
+    def _push_comment(self, sid=1, address=None, comment=None):
+        retval = self.app.post('/api/1.0/samples/'+str(sid)+'/comments/',
+                               data=json.dumps(dict(address=address, comment=comment)),
+                               content_type="application/json")
+        return retval
+
+    def _create_struct(self, sid=1, name=None):
+        retval = self.app.post('/api/1.0/samples/'+str(sid)+'/structs/',
+                               data=json.dumps(dict(name=name)),
+                               content_type="application/json")
+        return retval
+
+    def _create_struct_member(self, sid=1, struct_id=None, mname=None, size=0, offset=0):
+        url = '/api/1.0/samples/' + str(sid)
+        url += '/structs/' + str(struct_id)
+        url += '/members/'
+        retval = self.app.post(url,
+                               data=json.dumps(dict(name=mname,
+                                                    size=size,
+                                                    offset=offset)),
+                               content_type="application/json")
+        return retval
+
+    def _update_struct_member_name(self, sid=1, struct_id=None, mid=None, newname=""):
+        url = '/api/1.0/samples/' + str(sid)
+        url += '/structs/' + str(struct_id)
+        url += '/members/'
+        retval = self.app.patch(url,
+                                data=json.dumps(dict(mid=mid, newname=newname)),
+                                content_type="application/json")
+        return retval
+
+    def _update_struct_member_size(self, sid=1, struct_id=None, mid=None, newsize=0):
+        url = '/api/1.0/samples/' + str(sid)
+        url += '/structs/' + str(struct_id)
+        url += '/members/'
+        retval = self.app.patch(url,
+                                data=json.dumps(dict(mid=mid, newsize=newsize)),
+                                content_type="application/json")
+        return retval
+
+    def _get_all_structs(self, sid=1):
+        retval = self.app.get('/api/1.0/samples/' + str(sid) +
+                              '/structs/')
+        return retval
+
+    def _get_one_struct(self, sid=1, struct_id=1):
+        url = '/api/1.0/samples/' + str(sid)
+        url += '/structs/'
+        url += str(struct_id) + '/'
+        retval = self.app.get(url)
+        return retval
+
+    def _get_comment(self, sid=1, address=None):
+        retval = self.app.get('/api/1.0/samples/' + str(sid) +
+                              '/comments/',
+                              data=json.dumps({'address':address}),
+                              content_type="application/json")
+        return retval
+
+    def _push_name(self, sid=1, address=None, name=None):
+        retval = self.app.post('/api/1.0/samples/'+str(sid)+'/names/',
+                               data=json.dumps(dict(address=address, name=name)),
+                               content_type="application/json")
+        return retval
+
+    def _get_name(self, sid=1, address=None):
+        url = '/api/1.0/samples/' + str(sid) + '/names/'
+        if address is not None:
+            url += '?addr='
+            url += hex(address)
+        retval = self.app.get(url)
+        return retval
+
+    def _create_type(self, sid=1, address=None, typedef=None):
+        retval = self.app.post('/api/1.0/samples/'+str(sid)+'/types/',
+                               data=json.dumps(dict(address=address,
+                                                    typedef=typedef)),
+                               content_type="application/json")
+        return retval
+
+    def _get_type(self, sid=1, address=None):
+        url = '/api/1.0/samples/' + str(sid)
+        url += '/types/'
+        if address is not None:
+            url += "?addr="
+            url += hex(address)
+
+        return self.app.get(url)
+
+    @staticmethod
+    def _format_timedelta():
+        """
+        wrapper for strftime and 1 day offset
+        """
+        offset = datetime.datetime.now() + datetime.timedelta(days=1)
+        offset = datetime.datetime.strftime(offset, '%Y-%m-%dT%H:%M:%S.%f')
+        return offset
+
     def test_push_comments(self):
         """
             Can we push comments for a sample?
         """
-        retval = self.push_comment(address=0xDEADBEEF, comment="TESTCOMMENT1")
+        retval = self._push_comment(address=0xDEADBEEF, comment="TESTCOMMENT1")
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
         self.assertTrue(data['result'])
@@ -322,29 +487,29 @@ def test_get_comment(self):
         """
             This endpoint is used to get comments for a specific address
         """
-        retval = self.push_comment(address=0xDEADBEEF, comment="TESTCOMMENT1")
+        retval = self._push_comment(address=0xDEADBEEF, comment="TESTCOMMENT1")
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
         self.assertTrue(data['result'])
 
-        retval = self.get_comment(address=0xDEADBEEF)
+        retval = self._get_comment(address=0xDEADBEEF)
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
         self.assertIn(data['comments'][0]["data"], "TESTCOMMENT1")
         self.assertEqual(data['comments'][0]["address"], 0xDEADBEEF)
 
     def test_get_multiple_comments(self):
-        retval = self.push_comment(address=0xDEADBEEF, comment="TESTCOMMENT1")
+        retval = self._push_comment(address=0xDEADBEEF, comment="TESTCOMMENT1")
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
         self.assertTrue(data['result'])
 
-        retval = self.push_comment(address=0xBADF00D, comment="TESTCOMMENT2")
+        retval = self._push_comment(address=0xBADF00D, comment="TESTCOMMENT2")
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
         self.assertTrue(data['result'])
 
-        retval = self.get_comment()
+        retval = self._get_comment()
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
         self.assertEqual(len(data['comments']), 2)
@@ -353,21 +518,12 @@ def test_get_multiple_comments(self):
         self.assertIn(data['comments'][1]["data"], "TESTCOMMENT2")
         self.assertEqual(data['comments'][1]["address"], 0xBADF00D)
 
-    @staticmethod
-    def format_timedelta():
-        """
-        wrapper for strftime and 1 day offset
-        """
-        offset = datetime.datetime.now() + datetime.timedelta(days=1)
-        offset = datetime.datetime.strftime(offset, '%Y-%m-%dT%H:%M:%S.%f')
-        return offset
-
     def test_action_timestamp(self):
         """
             Test getting different results with different timestamps
         """
-        self.push_comment(address=0xDEADBEEF, comment="TESTCOMMENT1")
-        offset = self.format_timedelta()
+        self._push_comment(address=0xDEADBEEF, comment="TESTCOMMENT1")
+        offset = self._format_timedelta()
         retval = self.app.get('/api/1.0/samples/1/comments/?timestamp='+offset)
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
@@ -383,8 +539,8 @@ def test_action_timestamp(self):
         data = json.loads(retval.data)
         self.assertEqual(len(data["comments"]), 1)
 
-        self.push_name(address=0xDEADBEEF, name="TESTNAME")
-        offset = self.format_timedelta()
+        self._push_name(address=0xDEADBEEF, name="TESTNAME")
+        offset = self._format_timedelta()
         retval = self.app.get('/api/1.0/samples/1/names/?timestamp='+offset)
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
@@ -395,8 +551,8 @@ def test_action_timestamp(self):
         data = json.loads(retval.data)
         self.assertEqual(len(data["names"]), 1)
 
-        self.create_struct(name="TESTSTRUCTURE")
-        offset = self.format_timedelta()
+        self._create_struct(name="TESTSTRUCTURE")
+        offset = self._format_timedelta()
         retval = self.app.get('/api/1.0/samples/1/structs/?timestamp='+offset)
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
@@ -407,12 +563,11 @@ def test_action_timestamp(self):
         data = json.loads(retval.data)
         self.assertEqual(len(data["structs"]), 1)
 
-
     def test_push_name(self):
         """
             Simulate a renaming done from IDA
         """
-        retval = self.push_name(address=0xDEADBEEF, name="TESTNAME1")
+        retval = self._push_name(address=0xDEADBEEF, name="TESTNAME1")
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
         self.assertTrue(data['result'])
@@ -421,12 +576,12 @@ def test_get_names(self):
         """
             This endpoint is used to get names for a specific address
         """
-        retval = self.push_name(address=0xDEADBEEF, name="TESTNAME1")
+        retval = self._push_name(address=0xDEADBEEF, name="TESTNAME1")
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
         self.assertTrue(data['result'])
 
-        retval = self.get_name(address=0xDEADBEEF)
+        retval = self._get_name(address=0xDEADBEEF)
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
         self.assertIn(data['names'][0]["data"], "TESTNAME1")
@@ -436,20 +591,20 @@ def test_create_struct(self):
         """
             Simple structure creation and access
         """
-        retval = self.create_struct(sid=1, name="StructName1")
+        retval = self._create_struct(sid=1, name="StructName1")
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
         self.assertTrue(data["result"])
 
         # check if the structure is in the complete listing
-        retval = self.get_all_structs(sid=1)
+        retval = self._get_all_structs(sid=1)
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
         self.assertIn("StructName1", data["structs"][0]["name"])
         self.assertEqual(0, data["structs"][0]["size"])
 
         # check if we can access the structure alone
-        retval = self.get_one_struct(sid=1, struct_id=1)
+        retval = self._get_one_struct(sid=1, struct_id=1)
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
         struct = data["structs"]
@@ -461,17 +616,17 @@ def test_create_multiple_structs(self):
             This will test if we can access multiple structs for one sample
         """
         # create structs
-        retval = self.create_struct(sid=1, name="StructName1")
+        retval = self._create_struct(sid=1, name="StructName1")
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
         self.assertTrue(data["result"])
 
-        retval = self.create_struct(sid=1, name="StructName2")
+        retval = self._create_struct(sid=1, name="StructName2")
         data = json.loads(retval.data)
         self.assertTrue(data["result"])
 
         # get the structs
-        retval = self.get_all_structs(sid=1)
+        retval = self._get_all_structs(sid=1)
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
         self.assertEqual(2, len(data["structs"]))
@@ -482,25 +637,24 @@ def test_create_multiple_structs(self):
         self.assertEqual(0, struct1["size"])
         self.assertEqual(0, struct2["size"])
 
-
     def test_create_struct_member(self):
         """
             Member creation
         """
         # first create a structre
-        self.create_struct(sid=1, name="StructName1")
+        self._create_struct(sid=1, name="StructName1")
         # then add a member to it
-        retval = self.create_struct_member(struct_id=1,
-                mname="MemberName1",
-                size=4,
-                offset=0)
+        retval = self._create_struct_member(struct_id=1,
+                                            mname="MemberName1",
+                                            size=4,
+                                            offset=0)
         # Is the member OK?
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
         self.assertTrue(data["result"])
 
         # can we get the member in the structure
-        retval = self.get_one_struct(sid=1, struct_id=1)
+        retval = self._get_one_struct(sid=1, struct_id=1)
         data = json.loads(retval.data)
         struct = data["structs"]
 
@@ -511,32 +665,32 @@ def test_create_struct_member(self):
         self.assertEqual(4, member["size"])
         self.assertEqual(0, member["offset"])
 
-    def test_create_multiple_struct_members(self):
+    def test_create_struct_members(self):
         """
             Test for multiples members
         """
-        self.create_struct(sid=1, name="StructName1")
-        self.create_struct_member(struct_id=1,
-                mname="MemberName1",
-                size=4,
-                offset=0)
+        self._create_struct(sid=1, name="StructName1")
+        self._create_struct_member(struct_id=1,
+                                   mname="MemberName1",
+                                   size=4,
+                                   offset=0)
 
-        self.create_struct_member(struct_id=1,
-                mname="MemberName2",
-                size=2,
-                offset=4)
+        self._create_struct_member(struct_id=1,
+                                   mname="MemberName2",
+                                   size=2,
+                                   offset=4)
 
-        self.create_struct_member(struct_id=1,
-                mname="MemberName3",
-                size=2,
-                offset=6)
+        self._create_struct_member(struct_id=1,
+                                   mname="MemberName3",
+                                   size=2,
+                                   offset=6)
 
-        self.create_struct_member(struct_id=1,
-                mname="MemberName4",
-                size=4,
-                offset=8)
+        self._create_struct_member(struct_id=1,
+                                   mname="MemberName4",
+                                   size=4,
+                                   offset=8)
 
-        retval = self.get_one_struct(sid=1, struct_id=1)
+        retval = self._get_one_struct(sid=1, struct_id=1)
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
 
@@ -566,45 +720,83 @@ def test_create_multiple_struct_members(self):
         self.assertEqual(4, member["size"])
         self.assertEqual(8, member["offset"])
 
+    def test_idatypes(self):
+        """
+            IDA Types
+        """
+        ret = self._create_type(sid=1, address=0xDEADBEEF, typedef='void *')
+        self.assertEqual(ret.status_code, 200)
+        res = json.loads(ret.data)
+        self.assertTrue(res["result"])
+
+
+        ret = self._get_type(sid=1)
+        self.assertEqual(ret.status_code, 200)
+        types = json.loads(ret.data)['typedefs']
+        self.assertEqual(len(types), 1)
+        self.assertIn(types[0]["data"], 'void *')
+
+
+        ret = self._get_type(sid=1, address=0xDEADBEEF)
+        self.assertEqual(ret.status_code, 200)
+        types = json.loads(ret.data)['typedefs']
+        self.assertEqual(len(types), 1)
+        self.assertIn(types[0]["data"], 'void *')
+
+
+        ret = self._get_type(sid=1, address=0x1234)
+        self.assertEqual(ret.status_code, 200)
+        types = json.loads(ret.data)['typedefs']
+        self.assertEqual(len(types), 0)
+
+
+        self._create_type(sid=1, address=0xBADF00D, typedef='int testtype(int dwTest, char cType)')
+        ret = self._get_type(sid=1)
+        self.assertEqual(ret.status_code, 200)
+        types = json.loads(ret.data)['typedefs']
+        self.assertEqual(len(types), 2)
+        self.assertIn(types[0]["data"], 'void *')
+        self.assertIn(types[1]["data"], 'int testtype(int dwTest, char cType)')
+
 
     def test_struct_member_update(self):
         """
             Update size, name or offset
         """
-        self.create_struct(sid=1, name="StructName1")
-        self.create_struct_member(struct_id=1,
-                mname="MemberName1",
-                size=4,
-                offset=0)
+        self._create_struct(sid=1, name="StructName1")
+        self._create_struct_member(struct_id=1,
+                                   mname="MemberName1",
+                                   size=4,
+                                   offset=0)
 
-        self.create_struct_member(struct_id=1,
-                mname="MemberName2",
-                size=2,
-                offset=4)
+        self._create_struct_member(struct_id=1,
+                                   mname="MemberName2",
+                                   size=2,
+                                   offset=4)
 
-        retval = self.update_struct_member_name(struct_id=1,
-                mid=1,
-                newname="NewMemberName1")
+        retval = self._update_struct_member_name(struct_id=1,
+                                                 mid=1,
+                                                 newname="NewMemberName1")
 
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
         self.assertTrue(data['result'])
 
-        retval = self.get_one_struct(sid=1, struct_id=1)
+        retval = self._get_one_struct(sid=1, struct_id=1)
         data = json.loads(retval.data)
         mstruct = data['structs']
         member = mstruct['members'][0]
         self.assertIn('NewMemberName1', member['name'])
 
         # test when downgrading the size of first member
-        retval = self.update_struct_member_size(struct_id=1,
-                mid=1,
-                newsize=2)
+        retval = self._update_struct_member_size(struct_id=1,
+                                                 mid=1,
+                                                 newsize=2)
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
         self.assertTrue(data["result"])
 
-        retval = self.get_one_struct(sid=1, struct_id=1)
+        retval = self._get_one_struct(sid=1, struct_id=1)
         data = json.loads(retval.data)
         mstruct = data['structs']
         member = mstruct['members'][0]
@@ -612,10 +804,10 @@ def test_struct_member_update(self):
         self.assertEqual(mstruct['size'], 6)
 
         # test when downgrading the last member size
-        retval = self.update_struct_member_size(struct_id=1,
-                mid=2,
-                newsize=1)
-        retval = self.get_one_struct(sid=1, struct_id=1)
+        retval = self._update_struct_member_size(struct_id=1,
+                                                 mid=2,
+                                                 newsize=1)
+        retval = self._get_one_struct(sid=1, struct_id=1)
         data = json.loads(retval.data)
         mstruct = data['structs']
         member = mstruct['members'][1]
@@ -624,119 +816,26 @@ def test_struct_member_update(self):
 
 
         # test when upgrading the last member size
-        retval = self.update_struct_member_size(struct_id=1,
-                mid=2,
-                newsize=4)
+        retval = self._update_struct_member_size(struct_id=1,
+                                                 mid=2,
+                                                 newsize=4)
 
         self.assertEqual(retval.status_code, 200)
         data = json.loads(retval.data)
         self.assertTrue(data["result"])
 
-        retval = self.get_one_struct(sid=1, struct_id=1)
+        retval = self._get_one_struct(sid=1, struct_id=1)
 
         data = json.loads(retval.data)
         mstruct = data['structs']
         member = mstruct['members'][1]
         self.assertEqual(member['size'], 4)
         self.assertEqual(mstruct['size'], 8)
-
         # if upgrading the size and overlapping the next member,
         # adopt the same behavior as IDA and remove the second member
         # TODO!!!
         # self.assertTrue(False)
 
-    def test_sample_abstract(self):
-        data = json.dumps(dict(abstract="This is a test for abstract"))
-        retval = self.app.post('/api/1.0/samples/1/abstract/', data=data,
-                               content_type="application/json")
-        self.assertEqual(retval.status_code, 200)
-        result = json.loads(retval.data)
-        self.assertTrue(result['result'])
-
-        retval = self.app.get('/api/1.0/samples/1/abstract/')
-        self.assertEqual(retval.status_code, 200)
-        result = json.loads(retval.data)
-        self.assertIn(result['abstract'], 'This is a test for abstract')
-
-    def test_yara_creation(self):
-        rule_text = """rule toto{
-            strings:
-                $1 = {4D 5A}
-            condition:
-                $1 at 0
-        }"""
-        retval = self.create_yara("TESTYARA", rule_text)
-        self.assertEqual(retval.status_code, 200)
-        data = json.loads(retval.data)
-        self.assertEqual(data["id"], 1)
-
-        retval= self.app.get("/api/1.0/yaras/")
-        self.assertEqual(retval.status_code, 200)
-        data = json.loads(retval.data)
-        self.assertEqual(len(data['yara_rules']), 1)
-        rule = data['yara_rules'][0]
-        self.assertIn(rule['name'], "TESTYARA")
-        self.assertEqual(rule['TLP_sensibility'], 3)
-        self.assertIn(rule['raw_rule'], rule_text)
-
-    def test_yara_tlp(self):
-        rule_text = """rule toto{
-            strings:
-                $1 = {4D 5A}
-            condition:
-                $1 at 0
-        }"""
-        retval = self.create_yara("TESTYARA", rule_text, tlp_level=4)
-        retval= self.app.get("/api/1.0/yaras/")
-        data = json.loads(retval.data)
-        rule = data['yara_rules'][0]
-        self.assertEqual(rule['TLP_sensibility'], 4)
-
-    def test_yara_family(self):
-        """
-            Test for correct affectation of a yara to a family
-        """
-        rule_text = """rule toto{
-            strings:
-                $1 = {4D 5A}
-            condition:
-                $1 at 0
-        }"""
-        retval = self.create_yara("TESTYARA", rule_text)
-        self.create_family("TESTFAMILY")
-        retval = self.app.post('/api/1.0/family/1/yaras/',
-                               data=json.dumps(dict(rule_name="TESTYARA")),
-                               content_type="application/json")
-        self.assertEqual(retval.status_code, 200)
-        data = json.loads(retval.data)
-        self.assertTrue(data["result"])
-
-        retval = self.app.get('/api/1.0/family/1/export/1/detection/yara')
-        self.assertEqual(retval.status_code, 200)
-        self.assertIn("TESTYARA", retval.data)
-        self.assertIn("4D 5A", retval.data)
-
-
-#     def test_yara_update(self):
-        # rule_text = """rule toto{
-            # strings:
-                # $1 = {4D 5A}
-            # condition:
-                # $1 at 0
-        # }"""
-        # retval = self.create_yara("TESTYARA", rule_text, tlp_level=4)
-
-        # # Try to update the yara
-        # retval = self.update_yara("TESTYARA", rule_text.replace('$1', '$MZ'))
-        # self.assertEqual(retval.status_code, 200)
-        # data = json.loads(retval.data)
-        # self.assertTrue(data["result"])
-
-        # # Next check for the changes in the resulting data
-        # retval= self.app.get("/api/1.0/yaras/")
-        # data = json.loads(retval.data)
-        # rule = data['yara_rules'][0]
-        # self.assertIn(rule["raw_rule"], rule_text.replace('$1', '$MZ'))
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/mimo_build_env.tar.gz.b64 b/mimo_build_env.tar.gz.b64
new file mode 100644
--- /dev/null
+++ b/mimo_build_env.tar.gz.b64
@@ -0,0 +1,6 @@
+H4sIAAAAAAAAA+3STU+DQBAGYM78igly0AMfC2wxJh56MKkHY6O9N3ysQlJYAgux/96FJmqM2kuJ
+Mb7PZZeZWXbC4KZ9ucu3oh48Yy6+FnM+rdrnddozHjC2CBgPA8NnjMexQXy2jj7oO5W0REYrpfqp
+7lj+j3Lf569Ep7aZrKqkzt2uON0dx+YfRuHb/KMw0vOPFiwyyD9dC9/75/PPcpoGn4rcNM/oUSjq
+G2r2+oegJ9nSeq8KWVPgxqZ4aWSraL3crK4te3V/d+O5U6GXlvWVPcYtUwzJjiz7/PCGsi4VOU6T
+qOLi65wOHx6fdzLVaX2Ryy7HVh76mlQhaLm+pbHDThdOvTgV9frsGKO87DI5iJac7lBETkPWtNsm
+Tan7s8zf/sQAAAAAAAAAAAAAAAAAAAAAALN5BXSVXu8AKAAA
diff --git a/mimo_test_command.sh b/mimo_test_command.sh
new file mode 100755
--- /dev/null
+++ b/mimo_test_command.sh
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+set -uo pipefail
+cd /testbed || exit 1
+base64 -d mimo_build_env.tar.gz.b64 | tar -xzf - -C /testbed || exit 1
+exec bash -lc 'cd /testbed && bash -eo pipefail /testbed/.build_env/test_command.sh'