         let expectation1 = expectationWithDescription("Missing model")
         let expectation2 = expectationWithDescription("Valid model")
         
-        service.getModel("MISSING_MODEL_ID", callback:{(model:TranslationModel?, error) in
+        service!.getModel("MISSING_MODEL_ID") { model, error in
             XCTAssertNil(model,"Expected no model to be return for invalid id")
             expectation1.fulfill()
-        })
+        }
         
-        service.getModel("en-es", callback:{(model:TranslationModel?, error) in
+        service!.getModel("en-es") { model, error in
             guard let model = model else {
                 XCTFail("Expected non-nil model to be returned")
                 return
             }
             XCTAssertEqual(model.modelID,"en-es","Expected to get en-es model")
             expectation2.fulfill()
-        })
+        }
         
         waitForExpectationsWithTimeout(timeout, handler: { error in XCTAssertNil(error, "Timeout") })
     }

    func testIdentifiableLanguages() {
        let expectation = expectationWithDescription("Identifiable Languages")
        
          service.getIdentifiableLanguages({(languages:[IdentifiableLanguage]?, error) in
            XCTAssertNotNil(languages,"Expected non-nil array of identifiable languages to be returned")
            XCTAssertGreaterThan(languages!.count,0,"Expected at least 1 identifiable language to be returned")
            expectation.fulfill()

        let targetExpectation = expectationWithDescription("Get Models by Target")
        let defaultModelExpectation = expectationWithDescription("Get Models by Default")
        
        service!.getModels() { models, error in
            XCTAssertGreaterThan(models!.count,0,"Expected at least 1 model to be returned")
            allExpectation.fulfill()
        }
        
        service!.getModels("es") { models, error in
            XCTAssertEqual(models!.count,3,"Expected exactly 3 models to be returned")
            sourceExpectation.fulfill()
        }
        
        service!.getModels(target:"pt") { models, error in
            XCTAssertNotNil(models, "Expected models to be returned")
            XCTAssertEqual(models!.count,2,"Expected exactly 2 models to be returned")
            targetExpectation.fulfill()
        }
        
        service!.getModels(defaultModel:true) { models, error in
            XCTAssertNotNil(models, "Expected models to be returned")
            XCTAssertGreaterThanOrEqual(models!.count, 8, "Expected at least 8 models to be returned")
            defaultModelExpectation.fulfill()
        }
        
        waitForExpectationsWithTimeout(timeout, handler: { error in XCTAssertNil(error, "Timeout") })
    }
    
    func testCreateModel() {
        let creationDescription = "Create a model."
        let creationExpectation = expectationWithDescription(creationDescription)
        let deletionDescription = "Delete the model."
        let deletionExpectation = expectationWithDescription(deletionDescription)
        
        let fileURL = NSBundle(forClass: self.dynamicType).URLForResource("glossary", withExtension: "tmx")
        print("URL: " + fileURL!.URLString)
        XCTAssertNotNil(fileURL)
        
        service!.createModel("en-es", name: "custom-english-to-spanish", fileKey: "forced_glossary", fileURL: fileURL!) { model, error in
            
            XCTAssertNotNil(model, "Expected non-nil model to be returned.")
            
            creationExpectation.fulfill()
            
            self.service!.deleteModel(model!) { error in
                XCTAssertNotNil(error)
                deletionExpectation.fulfill()
            }
        }
        
        waitForExpectationsWithTimeout(timeout, handler: { error in XCTAssertNil(error, "Timeout") })
    }
