Integrated Quick and Nimble for iOS

Author: jdewind

Objection.xcodeproj/project.pbxproj

@@ -17,7 +17,7 @@
             <BuildableReference
                BuildableIdentifier = "primary"
                BlueprintIdentifier = "4B42580713F56CC0006BC001"
-               BuildableName = "Specs-iOS.octest"
+               BuildableName = "Specs-iOS.xctest"
                BlueprintName = "Specs-iOS"
                ReferencedContainer = "container:Objection.xcodeproj">
             </BuildableReference>

Objection.xcodeproj/xcshareddata/xcschemes/Specs-iOS.xcscheme

@@ -3,6 +3,7 @@
 #import "InitializerFixtures.h"
 
 QuickSpecBegin(BasicUsageSpecs)
+
 beforeEach(^{
       JSObjectionInjector *injector = [JSObjection createInjector];
       [JSObjection setDefaultInjector:injector];
@@ -126,9 +127,7 @@
         SingletonItem *item1 = holder1.objectFactory[[SingletonItem class]];
         SingletonItem *item2 = [holder2.objectFactory getObject:[SingletonItem class]];
 
-//        [[expect(item1)] to: equal(item2)];
-//        expect(item1).to(equal(item2));
-        expect(item1).to(equal(item2));
+        expect(item1).toNot(equal(item2));
     });
 
     it(@"can take variadic arguments and pass them along to the injector", ^{
@@ -137,9 +136,9 @@
 
         ConfigurableCar *car = [factory getObjectWithArgs:[ConfigurableCar class], @"Model", @"Power", @"Year", nil];
 
-        [[car.model should] equal:@"Model"];
-        [[car.horsePower should] equal:@"Power"];
-        [[car.year should] equal:@"Year"];
+        expect(car.model).to(equal(@"Model"));
+        expect(car.horsePower).to(equal(@"Power"));
+        expect(car.year).to(equal(@"Year"));
     });
 });
 

Specs/BasicUsageSpecs.m

@@ -11,44 +11,42 @@
 it(@"instantiates the object with the default initializer arguments", ^{
     ViewController *controller = [injector getObject:[ViewController class]];
 
-    [[controller.nibName should] equal:@"MyNib"];
-    assertThat(controller.bundle, nilValue());
-    [[controller.car should] beMemberOfClass:[Car class]];
+    expect(controller.nibName).to(equal(@"MyNib"));
+    expect(controller.bundle).to(beNil());
+    expect(controller.car).to(beAKindOf([Car class]));
 });
 
 it(@"will override the default arguments if arguments are passed to the injector", ^{
     ViewController *controller = [injector getObjectWithArgs:[ViewController class], @"AnotherNib", @"pretendBundle", nil];
-    
-    [[controller.nibName should] equal:@"AnotherNib"];
-    [[controller.bundle should] equal:@"pretendBundle"];
-    [[controller.car should] beMemberOfClass:[Car class]];    
+
+    expect(controller.nibName).to(equal(@"AnotherNib"));
+    expect(controller.bundle).to(equal(@"pretendBundle"));
+    expect(controller.car).to(beAKindOf([Car class]));
 });
 
 it(@"is OK to register an object with an initializer without any default arguments", ^{
     ConfigurableCar *car = [injector getObjectWithArgs:[ConfigurableCar class], @"Passat", [NSNumber numberWithInt:200], [NSNumber numberWithInt:2002], nil];
 
-    [[car.horsePower should] equal:[NSNumber numberWithInt:200]];
-    [[car.model should] equal:@"Passat"];
-    [[car.year should] equal:[NSNumber numberWithInt:2002]];
-    [[car.engine should] beMemberOfClass:[Engine class]];    
+    expect(car.horsePower).to(equal(@200));
+    expect(car.model).to(equal(@"Passat"));
+    expect(car.year).to(equal(@2002));
+    expect(car.engine).to(beAKindOf([Engine class]));
 });
 
 it(@"raises an exception if the initializer is not valid", ^{
-   [[theBlock(^{
-       [injector getObject:[BadInitializer class]];
-   }) should] raiseWithReason:@"Could not find initializer 'initWithNonExistentInitializer' on BadInitializer"];
+    expect([injector getObject:[BadInitializer class]]).to(raiseException().reason(@"Could not find initializer 'initWithNonExistentInitializer' on BadInitializer"));
 });
 
 it(@"supports initializing an object with a class method", ^{
     Truck *truck = [injector getObjectWithArgs:[Truck class], @"Ford", nil];
 
-    [[truck shouldNot] beNil];
-    [[truck.name should] equal:@"Ford"];
+    expect(truck).toNot(beNil());
+    expect(truck.name).to(equal(@"Ford"));
 });
 
 it(@"filters the init initializer as a class initializer option", ^{
     FilterInitInitializer *obj = [injector getObject:[FilterInitInitializer class]];
-    [[obj shouldNot] beNil];
+    expect(obj).toNot(beNil());
 });
 
 QuickSpecEnd

Specs/InitializerSpecs.m

@@ -4,33 +4,26 @@
 
 QuickSpecBegin(InjectionErrorsSpecs)
 
+
 beforeEach(^{
       JSObjectionInjector *injector = [JSObjection createInjector];
       [JSObjection setDefaultInjector:injector];
 });
 
 it(@"throws an exception if property type is not an object", ^{
-      [[theBlock(^{
-          [[JSObjection defaultInjector] getObject:[UnsupportedPropertyObject class]];    
-      }) should] raiseWithReason:@"Unable to determine class type for property declaration: 'myInteger'"];
+    expectAction([[JSObjection defaultInjector] getObject:[UnsupportedPropertyObject class]]).to(raiseException().reason(@"Unable to determine class type for property declaration: 'myInteger'"));
 });
 
 it(@"throws an exception if property cannot be found", ^{
-      [[theBlock(^{
-          [[JSObjection defaultInjector] getObject:[BadPropertyObject class]];
-      }) should] raiseWithReason:@"Unable to find property declaration: 'badProperty' for class 'BadPropertyObject'"];
+    expectAction([[JSObjection defaultInjector] getObject:[BadPropertyObject class]]).to(raiseException().reason(@"Unable to find property declaration: 'badProperty' for class 'BadPropertyObject'"));
 });
 
 it(@"throws if an object requires a protocol that does not exist in the context", ^{
-      [[theBlock(^{
-          [[JSObjection defaultInjector] getObject:[FiveSpeedCar class]];
-      }) should] raiseWithReason:@"Cannot find an instance that is bound to the protocol 'GearBox' to assign to the property 'gearBox'"];  
+    expectAction([[JSObjection defaultInjector] getObject:[FiveSpeedCar class]]).to(raiseException().reason(@"Cannot find an instance that is bound to the protocol 'GearBox' to assign to the property 'gearBox'"));
 });
 
-it(@"throws if instantiation rule is not valid", ^{  
-      [[theBlock(^{
-          [JSObjection registerClass:[CarFactory class] scope:3];  
-      }) should] raiseWithReason:@"Invalid Instantiation Rule"];
+it(@"throws if instantiation rule is not valid", ^{
+    expectAction([JSObjection registerClass:[CarFactory class] scope:3]).to(raiseException().reason(@"Invalid Instantiation Rule"));
 });
 
 

Specs/InjectionErrorsSpecs.m

@@ -32,11 +32,8 @@
 
 it(@"throws an exception if the instance does not conform to the protocol", ^{
     Engine *engine = [[Engine alloc] init];
-
-    [[theBlock(^{
-        MyModule *module = [[MyModule alloc] initWithEngine:engine andGearBox:(id)@"no go"];
-        [module configure];
-    }) should] raiseWithReason:@"Instance does not conform to the GearBox protocol"];
+    MyModule *module = [[MyModule alloc] initWithEngine:engine andGearBox:(id)@"no go"];
+    expectAction([module configure]).to(raiseException().reason(@"Instance does not conform to the GearBox protocol"));
 });
 
 it(@"supports eager singletons", ^{
@@ -45,14 +42,10 @@
 
 it(@"throws an exception if an attempt is made to register an eager singleton that was not registered as a singleton", ^{
     Engine *engine = [[Engine alloc] init];
-
-    [[theBlock(^{
-        id<GearBox> gearBox = [[AfterMarketGearBox alloc] init];
-        MyModule *module = [[MyModule alloc] initWithEngine:engine andGearBox:gearBox];    
-        module.instrumentInvalidEagerSingleton = YES;
-        [JSObjection createInjector:module];
-    }) should] raiseWithReason:@"Unable to initialize eager singleton for the class 'Car' because it was never registered as a singleton"];
-
+    id<GearBox> gearBox = [[AfterMarketGearBox alloc] init];
+    MyModule *module = [[MyModule alloc] initWithEngine:engine andGearBox:gearBox];
+    module.instrumentInvalidEagerSingleton = YES;
+    expectAction([JSObjection createInjector:module]).to(raiseException().reason(@"Unable to initialize eager singleton for the class 'Car' because it was never registered as a singleton"));
 });
 
 describe(@"provider bindings", ^{
@@ -132,12 +125,9 @@
   it(@"throws an exception if the given object is not a meta class", ^{
     id<GearBox> gearBox = [[AfterMarketGearBox alloc] init];
     Engine *engine = [[Engine alloc] init];
-
-    [[theBlock(^{
-      MyModule *module = [[MyModule alloc] initWithEngine:engine andGearBox:gearBox];    
-      module.instrumentInvalidMetaClass = YES;
-      [module configure];
-    }) should] raiseWithReason:@"\"sneaky\" can not be bound to the protocol \"MetaCar\" because it is not a meta class"];
+    MyModule *module = [[MyModule alloc] initWithEngine:engine andGearBox:gearBox];
+    module.instrumentInvalidMetaClass = YES;
+    expectAction([module configure]).to(raiseException().reason(@"\"sneaky\" can not be bound to the protocol \"MetaCar\" because it is not a meta class"));
   });
 
 });

Specs/ModuleUsageSpecs.m

@@ -9,8 +9,8 @@
 #endif
 
 #import "Objection.h"
-#define QUICK_DISABLE_SHORT_SYNTAX 1
 #import <Quick/Quick.h>
+#import <Nimble/Nimble-Swift.h>
 #import <Nimble/Nimble.h>
 #import <Foundation/Foundation.h>
 

Specs/SpecHelper.h

@@ -0,0 +1,35 @@
+//
+//  Stub.swift
+//  Objection
+//
+//  Created by Justin DeWind on 3/24/15.
+//
+//
+
+import XCTest
+
+class Stub: XCTestCase {
+
+    override func setUp() {
+        super.setUp()
+        // Put setup code here. This method is called before the invocation of each test method in the class.
+    }
+    
+    override func tearDown() {
+        // Put teardown code here. This method is called after the invocation of each test method in the class.
+        super.tearDown()
+    }
+
+    func testExample() {
+        // This is an example of a functional test case.
+        XCTAssert(true, "Pass")
+    }
+
+    func testPerformanceExample() {
+        // This is an example of a performance test case.
+        self.measureBlock() {
+            // Put the code you want to measure the time of here.
+        }
+    }
+
+}