diff --git a/test/test_tosca_parser.py b/test/test_tosca_parser.py
index 9641380..051b1d0 100644
--- a/test/test_tosca_parser.py
+++ b/test/test_tosca_parser.py
@@ -1,4 +1,3 @@
-
 # Copyright 2017-present Open Networking Foundation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,119 +12,114 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
-from helpers import *
+from __future__ import absolute_import
+from . import helpers  # noqa: F401
 import unittest
-import os
 from tosca.parser import TOSCA_Parser
 
-class TOSCA_Parser_Test(unittest.TestCase):
 
+class TOSCA_Parser_Test(unittest.TestCase):
     def test_get_tosca_models_by_name(self):
         """
         [TOSCA_Parser] get_tosca_models_by_name: should extract models from the TOSCA recipe and store them in a dict
         """
+
         class FakeNode:
             def __init__(self, name):
                 self.name = name
 
         class FakeTemplate:
-            nodetemplates = [
-                FakeNode('model1'),
-                FakeNode('model2')
-            ]
-
+            nodetemplates = [FakeNode("model1"), FakeNode("model2")]
 
         res = TOSCA_Parser.get_tosca_models_by_name(FakeTemplate)
-        self.assertIsInstance(res['model1'], FakeNode)
-        self.assertIsInstance(res['model2'], FakeNode)
+        self.assertIsInstance(res["model1"], FakeNode)
+        self.assertIsInstance(res["model2"], FakeNode)
 
-        self.assertEqual(res['model1'].name, 'model1')
-        self.assertEqual(res['model2'].name, 'model2')
+        self.assertEqual(res["model1"].name, "model1")
+        self.assertEqual(res["model2"].name, "model2")
 
     def test_populate_dependencies(self):
         """
-        [TOSCA_Parser] populate_dependencies: if a recipe has dependencies, it should find the ID of the requirements and add it to the model
+        [TOSCA_Parser] populate_dependencies: if a recipe has dependencies, it
+        should find the ID of the requirements and add it to the model
         """
+
         class FakeRecipe:
             requirements = [
                 {
-                    'site': {
-                        'node': 'site_onlab',
-                        'relationship': 'tosca.relationship.BelongsToOne'
+                    "site": {
+                        "node": "site_onlab",
+                        "relationship": "tosca.relationship.BelongsToOne",
                     }
                 }
             ]
 
         class FakeSite:
             id = 1
-            name = 'onlab'
+            name = "onlab"
 
         class FakeModel:
-            name = 'test@opencord.org'
+            name = "test@opencord.org"
 
-        saved_models = {
-            'site_onlab': FakeSite
-        }
+        saved_models = {"site_onlab": FakeSite}
 
-        model = TOSCA_Parser.populate_dependencies(FakeModel, FakeRecipe.requirements, saved_models)
+        model = TOSCA_Parser.populate_dependencies(
+            FakeModel, FakeRecipe.requirements, saved_models
+        )
         self.assertEqual(model.site_id, 1)
 
     def test_get_ordered_models_template(self):
         """
         [TOSCA_Parser] get_ordered_models_template: Create a list of templates based on topsorted models
         """
-        ordered_models = ['foo', 'bar']
+        ordered_models = ["foo", "bar"]
 
-        templates = {
-            'foo': 'foo_template',
-            'bar': 'bar_template'
-        }
+        templates = {"foo": "foo_template", "bar": "bar_template"}
 
-        ordered_templates = TOSCA_Parser.get_ordered_models_template(ordered_models, templates)
+        ordered_templates = TOSCA_Parser.get_ordered_models_template(
+            ordered_models, templates
+        )
 
-        self.assertEqual(ordered_templates[0], 'foo_template')
-        self.assertEqual(ordered_templates[1], 'bar_template')
+        self.assertEqual(ordered_templates[0], "foo_template")
+        self.assertEqual(ordered_templates[1], "bar_template")
 
     def test_topsort_dependencies(self):
         """
         [TOSCA_Parser] topsort_dependencies: Create a list of models based on dependencies
         """
+
         class FakeTemplate:
             def __init__(self, name, deps):
                 self.name = name
-                self.dependencies_names =  deps
-
+                self.dependencies_names = deps
 
         templates = {
-            'deps': FakeTemplate('deps', ['main']),
-            'main': FakeTemplate('main', []),
+            "deps": FakeTemplate("deps", ["main"]),
+            "main": FakeTemplate("main", []),
         }
 
         sorted = TOSCA_Parser.topsort_dependencies(templates)
 
-        self.assertEqual(sorted[0], 'main')
-        self.assertEqual(sorted[1], 'deps')
+        self.assertEqual(sorted[0], "main")
+        self.assertEqual(sorted[1], "deps")
 
     def test_compute_dependencies(self):
         """
-        [TOSCA_Parser] compute_dependencies: augment the TOSCA nodetemplate with information on requirements (aka related models)
+        [TOSCA_Parser] compute_dependencies: augment the TOSCA nodetemplate
+        with information on requirements (aka related models)
         """
 
-        parser = TOSCA_Parser('', 'user', 'pass')
+        parser = TOSCA_Parser("", "user", "pass")
 
         class FakeNode:
             def __init__(self, name, requirements):
                 self.name = name
                 self.requirements = requirements
 
-        main = FakeNode('main', [])
-        dep = FakeNode('dep', [{'relation': {'node': 'main'}}])
+        main = FakeNode("main", [])
+        dep = FakeNode("dep", [{"relation": {"node": "main"}}])
 
-        models_by_name = {
-            'main': main,
-            'dep': dep
-        }
+        models_by_name = {"main": main, "dep": dep}
 
         class FakeTemplate:
             nodetemplates = [dep, main]
@@ -137,8 +131,8 @@
         augmented_main = templates[1]
 
         self.assertIsInstance(augmented_dep.dependencies[0], FakeNode)
-        self.assertEqual(augmented_dep.dependencies[0].name, 'main')
-        self.assertEqual(augmented_dep.dependencies_names[0], 'main')
+        self.assertEqual(augmented_dep.dependencies[0].name, "main")
+        self.assertEqual(augmented_dep.dependencies_names[0], "main")
 
         self.assertEqual(len(augmented_main.dependencies), 0)
         self.assertEqual(len(augmented_main.dependencies_names), 0)
@@ -147,19 +141,16 @@
         """
         [TOSCA_Parser] populate_model: augment the GRPC model with data from TOSCA
         """
+
         class FakeModel:
             pass
 
-        data = {
-            'name': 'test',
-            'foo': 'bar',
-            'number': 1
-        }
+        data = {"name": "test", "foo": "bar", "number": 1}
 
         model = TOSCA_Parser.populate_model(FakeModel, data)
 
-        self.assertEqual(model.name, 'test')
-        self.assertEqual(model.foo, 'bar')
+        self.assertEqual(model.name, "test")
+        self.assertEqual(model.foo, "bar")
         self.assertEqual(model.number, 1)
 
     def test_populate_model_error(self):
@@ -172,23 +163,21 @@
             model_name = "FakeModel"
 
             def __setattr__(self, name, value):
-                if name == 'foo':
-                    raise TypeError('reported exception')
+                if name == "foo":
+                    raise TypeError("reported exception")
                 else:
                     super(FakeModel, self).__setattr__(name, value)
 
-        data = {
-            'name': 'test',
-            'foo': None,
-            'number': 1
-        }
-
+        data = {"name": "test", "foo": None, "number": 1}
 
         model = FakeModel()
 
         with self.assertRaises(Exception) as e:
             model = TOSCA_Parser.populate_model(model, data)
-        self.assertEqual(e.exception.message, 'Failed to set None on field foo for class FakeModel, Exception was: "reported exception"')
+        self.assertEqual(
+            str(e.exception),
+            'Failed to set None on field foo for class FakeModel, Exception was: "reported exception"',
+        )
 
     def test_translate_exception(self):
         """
@@ -197,7 +186,8 @@
         e = TOSCA_Parser._translate_exception("Non tosca exception")
         self.assertEqual(e, "Non tosca exception")
 
-        e = TOSCA_Parser._translate_exception("""        
+        e = TOSCA_Parser._translate_exception(
+            """
 MissingRequiredFieldError: some message
     followed by unreadable
     and mystic
@@ -212,10 +202,14 @@
     followed by useless things
 TypeMismatchError: with some message
     followed by useless things
-        """)
-        self.assertEqual(e, """MissingRequiredFieldError: some message
+        """
+        )
+        self.assertEqual(
+            e,
+            """MissingRequiredFieldError: some message
 UnknownFieldError: with some message
 ImportError: with some message
 InvalidTypeError: with some message
 TypeMismatchError: with some message
-""")
+""",
+        )