diff --git a/bin/Blueprints/CraftDependencyPackage.py b/bin/Blueprints/CraftDependencyPackage.py
index b0f5a8884..d52d4c848 100644
--- a/bin/Blueprints/CraftDependencyPackage.py
+++ b/bin/Blueprints/CraftDependencyPackage.py
@@ -1,99 +1,99 @@
 from enum import unique, Enum
 
 from CraftCore import CraftCore
 from Blueprints.CraftPackageObject import CraftPackageObject, BlueprintException
 from Blueprints.CraftVersion import CraftVersion
 
 
 @unique
 class DependencyType(Enum):
-    Runtime = 0
-    Buildtime = 1
-    Both = 2
+    Runtime = "runtime"
+    Buildtime = "buildtime"
+    Both = "both"
 
 
 class CraftDependencyPackage(CraftPackageObject):
     _packageCache = dict()
 
     @unique
     class State(Enum):
         Unvisited = 0
         Visiting = 1
         Visited = 2
 
     def __init__(self, path):
         CraftPackageObject.__init__(self, path)
         self._depenendencyType = None
         self.dependencies = [] # tuple (name, required version)
         self.state = CraftDependencyPackage.State.Unvisited
 
 
     @property
     def depenendencyType(self):
         return self._depenendencyType
 
     @depenendencyType.setter
     def depenendencyType(self, depenendencyType):
         if self._depenendencyType != depenendencyType:
             self._depenendencyType = depenendencyType
             self.dependencies = []
             self.__resolveDependencies()
 
     def __resolveDependencies(self):
         CraftCore.log.debug(f"solving package {self}")
         if not self.isCategory():
             subinfo = self.subinfo
             if self.depenendencyType in [DependencyType.Both, DependencyType.Runtime]:
                 self.dependencies.extend(self.__readDependenciesForChildren(subinfo.runtimeDependencies.items()))
             if self.depenendencyType in [DependencyType.Both, DependencyType.Buildtime]:
                 self.dependencies.extend(self.__readDependenciesForChildren(subinfo.buildDependencies.items()))
         else:
             self.dependencies.extend(self.__readDependenciesForChildren([(x, None) for x in self.children.values()]))
 
     def __readDependenciesForChildren(self, deps):
         children = []
         if deps:
             for packaheName, requiredVersion in deps:
                 if packaheName not in CraftDependencyPackage._packageCache:
                     package = CraftPackageObject.get(packaheName)
                     if not package:
                         raise BlueprintException(f"Failed to resolve {packaheName} as a dependency of {self}", self)
                     if requiredVersion and requiredVersion != "default" and CraftVersion(package.version) < CraftVersion(requiredVersion):
                         raise BlueprintException(f"{self} requries {package} version {requiredVersion!r} but {package.version!r} is installed", self)
 
                     p = CraftDependencyPackage(package)
                     CraftCore.log.debug(f"adding package {packaheName}")
                     CraftDependencyPackage._packageCache[packaheName] = p
                 else:
                     p = CraftDependencyPackage._packageCache[packaheName]
                 p.depenendencyType = self.depenendencyType
                 children.append(p)
         return children
 
     def __getDependencies(self, depenendencyType, ignoredPackages):
         """ returns all dependencies """
         if self.isIgnored():
             return []
 
         depList = []
 
         self.state = CraftDependencyPackage.State.Visiting
         for p in self.dependencies:
             if p.state != CraftDependencyPackage.State.Unvisited:
                 continue
             if not p.isIgnored() \
                     and (not ignoredPackages or p.path not in ignoredPackages):
                 depList.extend(p.__getDependencies(depenendencyType, ignoredPackages))
 
         if self.state != CraftDependencyPackage.State.Visited:
             self.state = CraftDependencyPackage.State.Visited
             if not self.isCategory():
                 depList.append(self)
         return depList
 
     def getDependencies(self, depType=DependencyType.Both, ignoredPackages=None):
         self.depenendencyType = depType
         for p in CraftDependencyPackage._packageCache.values():
             #reset visited state
             p.state = CraftDependencyPackage.State.Unvisited
         return self.__getDependencies(depType, ignoredPackages)
diff --git a/bin/test/test_Portage.py b/bin/test/test_Portage.py
index 3e6ff5e7b..dff0f6b2c 100644
--- a/bin/test/test_Portage.py
+++ b/bin/test/test_Portage.py
@@ -1,29 +1,32 @@
 import importlib
 
 import CraftConfig
 import CraftTestBase
 from Blueprints import CraftPackageObject, CraftDependencyPackage
 
 
 class CraftBlueprintTest(CraftTestBase.CraftTestBase):
     def blueprintTest(self, compiler):
         CraftConfig.CraftCore.settings.set("General", "ABI", compiler)
 
         importlib.reload(CraftPackageObject)  # clear cache
         installable = CraftPackageObject.CraftPackageObject.installables()
-        CraftDependencyPackage.CraftDependencyPackage(CraftPackageObject.CraftPackageObject.get("/")).getDependencies()
+        for _p in installable:
+            _p.instance
+
+            CraftDependencyPackage.CraftDependencyPackage(CraftPackageObject.CraftPackageObject.get("/")).getDependencies()
 
 
 
 class TestAPI(CraftBlueprintTest):
     def test_mingw_x86(self):
         self.blueprintTest("windows-mingw_86-gcc")
 
     def test_mingw_x64(self):
         self.blueprintTest("windows-mingw_64-gcc")
 
     def test_msvc2015_x86(self):
         self.blueprintTest("windows-msvc2015_86-cl")
 
     def test_msvc2015_x64(self):
         self.blueprintTest("windows-msvc2015_64-cl")