         let targetExpectation = expectationWithDescription("Get Models by Target")
         let defaultModelExpectation = expectationWithDescription("Get Models by Default")
         
-        service.getModels(callback:{(models:[TranslationModel], error) in
-            XCTAssertGreaterThan(models.count,0,"Expected at least 1 model to be returned")
+        service!.getModels() { models, error in
+            XCTAssertGreaterThan(models!.count,0,"Expected at least 1 model to be returned")
             allExpectation.fulfill()
-        })
+        }
         
-        service.getModels("es", callback:{(models:[TranslationModel], error) in
-            XCTAssertEqual(models.count,3,"Expected exactly 3 models to be returned")
+        service!.getModels("es") { models, error in
+            XCTAssertEqual(models!.count,3,"Expected exactly 3 models to be returned")
             sourceExpectation.fulfill()
-        })
+        }
         
-        service.getModels(target:"pt", callback:{(models:[TranslationModel], error) in
-            XCTAssertEqual(models.count,2,"Expected exactly 2 models to be returned")
+        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, callback:{(models:[TranslationModel], error) in
-            XCTAssertEqual(models.count,8,"Expected exactly 8 models to be returned")
+        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 deleteExpectation = self.expectationWithDescription("Delete model")
+        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!, callback:{(model:TranslationModel?, error) in
-            guard let _ = model else {
-                XCTFail("Expected non-nil model to be returned")
-//                deleteExpectation.fulfill()
-                return
+        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()
             }
-            
-            //Delete model after creating it
-//            Log.sharedLogger.error("HERE IS THE MODELLLLLLLLLLLLL\(model)")
-//            self.service.deleteModel(model.modelID!, callback:{response in
-//                deleteExpectation.fulfill()
-//            })
-        })
+        }
         
         waitForExpectationsWithTimeout(timeout, handler: { error in XCTAssertNil(error, "Timeout") })
     }

        super.setUp()
        if let url = NSBundle(forClass: self.dynamicType).pathForResource("Credentials", ofType: "plist") {
            if let dict = NSDictionary(contentsOfFile: url) as? Dictionary<String, String> {
                service.setUsernameAndPassword(dict["LanguageTranslationUsername"]!, password: dict["LanguageTranslationPassword"]!)
            } else {
                XCTFail("Unable to extract dictionary from plist")
            }

        let emptyExpectation = expectationWithDescription("Empty")
        let validExpectation = expectationWithDescription("Valid")
        
        service!.identify("") { languages, error in
            XCTAssertNil(languages, "Expected empty result when passing in an empty string to identify()")
            emptyExpectation.fulfill()
        }
        
        service!.identify("hola") { languages, error in
            if let firstLanguage = languages?.first {
                XCTAssertEqual(firstLanguage.language,"es", "Expected 'hola' to be identified as 'es' language")
            }
            else {
                XCTFail("Identified languages returned empty array")
            }
            validExpectation.fulfill()
        }
        
        waitForExpectationsWithTimeout(timeout, handler: { error in XCTAssertNil(error, "Timeout") })
    }
