Commit f2bf316

@@ -27,7 +27,7 @@ describe("Registry", () => {
       expect(subject.resolve('item')).toBeInstanceOf(Item);
     });
 
-    it ("resolves an instance with a dependency", function() {
+    it ("resolves an instance with a dependency", () => {
       subject.register('item', () => { return new Item() });
       subject.register('dependent', (container) => {
         return new Dependent(container.resolve('item'));
@@ -57,7 +57,7 @@ describe("Registry", () => {
       expect(result.item).toEqual(item);
     })
 
-    it ("resolves constructor dependencies for a singleton", function() {
+    it ("resolves constructor dependencies for a singleton", () => {
       var item = new Item();
       subject.register('item', () => item);
       subject.register('dependent', Dependent).asSingleton();
@@ -68,11 +68,17 @@ describe("Registry", () => {
       expect(result).toBe(other);
     });
 
-    it ("resolves a constructor with zero dependencies", function() {
+    it ("resolves a constructor with zero dependencies", () => {
       subject.register('item', Item);
 
       expect(subject.resolve('item')).toBeInstanceOf(Item);
     });
+
+    it("raises an error when a component is not registered", () => {
+      expect(() => {
+        subject.resolve('unknown');
+      }).toThrow(/"unknown" is not registered/);
+    });
   });
 
   describe("#resolveAll", () => {

@@ -23,15 +23,18 @@ export class Resolver {
   }
 
   resolveDependenciesUsing(container) {
-    let parameters = this.parseConstructor(this.factory).slice(2)[0].split(',').filter(Boolean);
-    let dependencies = parameters.map((parameter) => container.resolve(parameter));
+    let ctor = this.parseConstructor(this.factory);
+    console.log(`Building: ${ctor[1]}`);
+    let parameters = ctor.slice(2)[0].split(',').filter(Boolean);
+    let dependencies = parameters.map((parameter) => {
+      return container.resolve(parameter.trim());
+    });
     return new this.factory(...dependencies);
   }
 }
 
 export class Registration {
-  constructor(key, factory) {
-    this.key = key;
+  constructor(factory) {
     this.factory = factory;
   }
 
@@ -60,17 +63,27 @@ export default class Registry {
     if (this.registrations[key] == undefined) {
       this.registrations[key] = [];
     }
-    let registration = new Registration(key, factory);
+    let registration = new Registration(factory);
     this.registrations[key].push(registration);
     return registration;
   }
 
+  isRegistered(key) {
+    return this.registrations.hasOwnProperty(key);
+  }
+
   resolve(key) {
+    if (!this.isRegistered(key)) {
+      throw `"${key}" is not registered`;
+    }
+
     try {
-      return this.registrations[key][0].create(this);
+      let registration = this.registrations[key][0];
+      return registration.create(this);
     } catch(error) {
-      console.error(`ERROR: Could Not Resolve ${key}`);
-      console.error(error);
+      console.error(`ERROR: Could not resolve "${key}" ${error}`);
+      console.log("REGISTERED:");
+      console.log(this.registrations);
       throw error;
     }
   }