Code coverage improvement. (#241)

yasirfolio3 · jaeopt · commit 466ce132a0e3 · 2019-06-26T10:55:25.000-07:00
* Fixes to improve code-coverage.

* fixes according to review.
diff --git a/OptimizelySDK/OptimizelyTests/OptimizelyTests-APIs/OptimizelyClientTests_DatafileHandler.swift b/OptimizelySDK/OptimizelyTests/OptimizelyTests-APIs/OptimizelyClientTests_DatafileHandler.swift
@@ -64,12 +64,9 @@ class OptimizelyClientTests_DatafileHandler: XCTestCase {
         let expectation = XCTestExpectation(description: "get datafile from cache")
         
         client.start() { (result) in
-            switch result {
-            case .success(let data):
+            if case let .success(data) = result{
                 XCTAssert(!data.isEmpty)
                 expectation.fulfill()
-            case .failure:
-                XCTAssert(false)
             }
         }
         
diff --git a/OptimizelySDK/OptimizelyTests/OptimizelyTests-APIs/OptimizelyClientTests_ObjcAPIs.m b/OptimizelySDK/OptimizelyTests/OptimizelyTests-APIs/OptimizelyClientTests_ObjcAPIs.m
@@ -215,8 +215,16 @@ - (void)testCustomizationAPIs {
     NSData *datafileData = [datafile dataUsingEncoding:NSUTF8StringEncoding];
 
     TestOPTLogger *logger = [[TestOPTLogger alloc] init];
+    XCTAssertEqual(TestOPTLogger.logLevel, OptimizelyLogLevelInfo);
+    
     TestOPTEventDispatcher *eventDispatcher = [[TestOPTEventDispatcher alloc] init];
+    EventForDispatch *event = [[EventForDispatch alloc] initWithUrl:nil body:[[NSData alloc] init]];
+    [eventDispatcher dispatchEventWithEvent:event completionHandler:nil];
+    [eventDispatcher flushEvents];
+    
     TestOPTUserProfileService *userProfileService = [[TestOPTUserProfileService alloc] init];
+    (void)[userProfileService lookupWithUserId:@"dummy"];
+    [userProfileService saveWithUserProfile:@{}];
     
     // check all SDK initialization APIs for ObjC
     self.optimizely = [[OptimizelyClient alloc] initWithSdkKey:kSdkKey];
@@ -228,7 +236,7 @@ - (void)testCustomizationAPIs {
                                        periodicDownloadInterval:@(50)
                                                  defaultLogLevel:OptimizelyLogLevelInfo];
     
-    [self.optimizely startWithCompletion:^(NSData * _Nullable data, NSError * _Nullable error) {}];
+    [self.optimizely startWithCompletion:nil];
     
     [self.optimizely startWithDatafile:datafile error:nil];
     
diff --git a/OptimizelySDK/OptimizelyTests/OptimizelyTests-APIs/OptimizelyClientTests_ObjcOthers.m b/OptimizelySDK/OptimizelyTests/OptimizelyTests-APIs/OptimizelyClientTests_ObjcOthers.m
@@ -226,11 +226,7 @@ - (void)testCustomEventDispatcher_DefaultEventDispatcher {
     
     __block BOOL status = false;
     [eventDispatcher dispatchEventWithEvent:event completionHandler:^(NSData * data, NSError * error) {
-        if(data != nil) {
-            status = true;
-        } else {
-            status = false;
-        }
+        status = (data != nil);
         
         [expectation fulfill];
     }];
@@ -251,6 +247,7 @@ - (void)testCustomEventDispatcher {
     
     // check DefaultEventDispatcher work OK with ObjC clients
     MockOPTEventDispatcher *customEventDispatcher = [[MockOPTEventDispatcher alloc] init];
+    [customEventDispatcher flushEvents];
     
     OptimizelyClient *optimizely = [[OptimizelyClient alloc] initWithSdkKey:[self randomSdkKey]
                                                                      logger:nil
diff --git a/OptimizelySDK/OptimizelyTests/OptimizelyTests-APIs/OptimizelyClientTests_Others.swift b/OptimizelySDK/OptimizelyTests/OptimizelyTests-APIs/OptimizelyClientTests_Others.swift
@@ -227,21 +227,18 @@ class OptimizelyClientTests_Others: XCTestCase {
         let optimizely = OptimizelyClient(sdkKey: kNotRealSdkKey)
         
         let exp = expectation(description: "a")
-        
+        var failureOccured = false
         optimizely.start { result in
-            switch result {
-            case .success:
-                XCTAssert(false)
-            case .failure(OptimizelyError.dataFileVersionInvalid):
-                XCTAssert(true)
-            case .failure(let error):
-                XCTAssert(false, "wrong error type: \(error)")
+            
+            if case .failure(OptimizelyError.dataFileVersionInvalid) = result  {
+                failureOccured = true
             }
             
             exp.fulfill()
         }
 
         wait(for: [exp], timeout: 10)
+        XCTAssertTrue(failureOccured)
     }
     
     func testHandlerReinitializeOnBackgroundDatafileUpdate() {
diff --git a/OptimizelySDK/OptimizelyTests/OptimizelyTests-Common/BatchEventBuilderTest.swift b/OptimizelySDK/OptimizelyTests/OptimizelyTests-Common/BatchEventBuilderTest.swift
@@ -29,12 +29,7 @@ class BatchEventBuilderTests: XCTestCase {
         optimizely = OptimizelyClient(sdkKey: "", periodicDownloadInterval: 0)
         
         let datafile = OTUtils.loadJSONDatafile(datafileName)
-        do {
-            try optimizely?.start(datafile: datafile!)
-        } catch {
-            print(error)
-            XCTAssert(false)
-        }
+        XCTAssertNoThrow(try optimizely?.start(datafile: datafile!))
     }
 
     override func tearDown() {
diff --git a/OptimizelySDK/OptimizelyTests/OptimizelyTests-Common/BucketTests_BucketVariation.swift b/OptimizelySDK/OptimizelyTests/OptimizelyTests-Common/BucketTests_BucketVariation.swift
@@ -132,11 +132,7 @@ extension BucketTests_BucketVariation {
 
         for (idx, test) in tests.enumerated() {
             variation = bucketer.bucketExperiment(config: self.config, experiment: experiment, bucketingId: test["userId"]!)
-            if let _ = test["expect"] {
-                XCTAssertEqual(test["expect"], variation?.key, "test[\(idx)] failed")
-            } else {
-                XCTAssertNil(experiment)
-            }
+            XCTAssertEqual(test["expect"], variation?.key, "test[\(idx)] failed")
         }
     }
     
@@ -154,11 +150,7 @@ extension BucketTests_BucketVariation {
 
         for (idx, test) in tests.enumerated() {
             variation = bucketer.bucketExperiment(config: self.config, experiment: experiment, bucketingId: test["userId"]!)
-            if let _ = test["expect"] {
-                XCTAssertEqual(test["expect"], variation?.key, "test[\(idx)] failed")
-            } else {
-                XCTAssertNil(experiment)
-            }
+            XCTAssertEqual(test["expect"], variation?.key, "test[\(idx)] failed")
         }
     }
     
@@ -196,11 +188,7 @@ extension BucketTests_BucketVariation {
 
         for (idx, test) in tests.enumerated() {
             variation = bucketer.bucketExperiment(config: self.config, experiment: experiment, bucketingId: test["userId"]!)
-            if let _ = test["expect"] {
-                XCTAssertEqual(test["expect"], variation?.key, "test[\(idx)] failed")
-            } else {
-                XCTAssertNil(experiment)
-            }
+            XCTAssertEqual(test["expect"], variation?.key, "test[\(idx)] failed")
         }
     }
     
diff --git a/OptimizelySDK/OptimizelyTests/OptimizelyTests-Common/BucketTests_Others.swift b/OptimizelySDK/OptimizelyTests/OptimizelyTests-Common/BucketTests_Others.swift
@@ -26,11 +26,7 @@ class BucketTests_Others: XCTestCase {
     override func setUp() {
         // Put setup code here. This method is called before the invocation of each test method in the class.
         let data = OTUtils.loadJSONDatafile("grouped_experiments")
-        do {
-            config = try ProjectConfig(datafile: data!)
-        } catch {
-            print(error.localizedDescription)
-        }
+        config = try? ProjectConfig(datafile: data!)
     }
 
     override func tearDown() {
@@ -84,11 +80,7 @@ extension BucketTests_Others {
         
         for test in tests {
             let experiment = bucketer.bucketToExperiment(config: config!, group: group!, bucketingId: test["userId"]!)
-            if let _ = test["expect"] {
-                XCTAssertEqual(test["expect"]!, experiment?.key)
-            } else {
-                XCTAssertNil(experiment)
-            }
+            XCTAssertEqual(test["expect"]!, experiment?.key)
         }
     }
     
diff --git a/OptimizelySDK/OptimizelyTests/OptimizelyTests-Common/DatafileHandlerTests.swift b/OptimizelySDK/OptimizelyTests/OptimizelyTests-Common/DatafileHandlerTests.swift
@@ -108,12 +108,10 @@ class DatafileHandlerTests: XCTestCase {
         // initiate download task which should pass back a 304 but still return non nil
         // since the datafile was not in cache.
         handler.downloadDatafile(sdkKey: "localcdnTestSDKKey") { (result) in
-            switch result {
-            case .success(let data):
+            
+            if case let .success(data) = result  {
                 XCTAssert(data != nil)
                 expectation.fulfill()
-            case .failure(let error):
-                XCTAssert(error.errorDescription != nil)
             }
         }
         
@@ -155,13 +153,10 @@ class DatafileHandlerTests: XCTestCase {
         // initiate download task which should pass back a 304 but still return non nil
         // since the datafile was not in cache.
         handler.downloadDatafile(sdkKey: "localcdnTestSDKKey") { (result) in
-            switch result {
-            case .success(let data):
+            if case let .success(data) = result  {
                 // should come back as nil since got 304 and datafile in cache.
                 XCTAssert(data == nil)
                 expectation.fulfill()
-            case .failure(let error):
-                XCTAssert(error.errorDescription != nil)
             }
         }
         
@@ -236,18 +231,16 @@ class DatafileHandlerTests: XCTestCase {
         
         let expectation = XCTestExpectation(description: "should fail before 10")
         handler.downloadDatafile(sdkKey: "invalidKey1212121", resourceTimeoutInterval: 3) { (result) in
-            switch result {
-            case .failure(let error):
+            
+            if case let .failure(error) = result  {
                 print(error)
                 XCTAssert(true)
                 expectation.fulfill()
-            case .success(_):
-                XCTAssert(false)
             }
         }
         
         wait(for: [expectation], timeout: 5.0)
-        
+
     }
     
     func testDownloadWithoutTimeout() {
@@ -256,11 +249,8 @@ class DatafileHandlerTests: XCTestCase {
         
         let expectation = XCTestExpectation(description: "will wait for response.")
         handler.downloadDatafile(sdkKey: "invalidKeyXXXXX") { (result) in
-            switch result {
-            case .failure(let error):
-                print(error)
-                XCTAssert(false)
-            case .success(let data):
+            
+            if case let .success(data) = result  {
                 print(data ?? "")
                 XCTAssert(true)
                 expectation.fulfill()
diff --git a/OptimizelySDK/OptimizelyTests/OptimizelyTests-DataModel/AttributeValueTests.swift b/OptimizelySDK/OptimizelyTests/OptimizelyTests-DataModel/AttributeValueTests.swift
@@ -340,43 +340,46 @@ extension AttributeValueTests {
     
     func testIsExactMatchWithInvalid() {
         let attr = AttributeValue.string("string")
+        var tmpError: Error?
         do {
             _ = try attr.isExactMatch(with: ["invalidType"])
-            XCTAssert(false)
         } catch {
-            XCTAssert(true)
+            tmpError = error
         }
+        XCTAssertTrue(tmpError != nil)
     }
     
     func testIsGreaterWithInvalid() {
         let attr = AttributeValue.string("string")
+        var tmpError: Error?
         do {
             _ = try attr.isSubstring(of: ["invalidType"])
-            XCTAssert(false)
         } catch {
-            XCTAssert(true)
+            tmpError = error
         }
+        XCTAssertTrue(tmpError != nil)
     }
 
     func testIsLessWithInvalid() {
         let attr = AttributeValue.double(100.23)
+        var tmpError: Error?
         do {
             _ = try attr.isGreater(than: ["invalidType"])
-            XCTAssert(false)
         } catch {
-            XCTAssert(true)
+            tmpError = error
         }
+        XCTAssertTrue(tmpError != nil)
     }
     
     func testIsSubstringWithInvalid() {
         let attr = AttributeValue.double(100.23)
+        var tmpError: Error?
         do {
             _ = try attr.isLess(than: ["invalidType"])
-            XCTAssert(false)
         } catch {
-            XCTAssert(true)
+            tmpError = error
         }
+        XCTAssertTrue(tmpError != nil)
     }
     
-
 }
diff --git a/OptimizelySDK/OptimizelyTests/OptimizelyTests-DataModel/ConditionHolderTests.swift b/OptimizelySDK/OptimizelyTests/OptimizelyTests-DataModel/ConditionHolderTests.swift
@@ -292,23 +292,15 @@ extension ConditionHolderTests {
 extension ConditionHolderTests {
 
     func testDecode_Invalid() {
-        do {
-            let _: ConditionHolder = try OTUtils.model(from: [120])
-            XCTAssert(false)
-        } catch {
-            XCTAssert(true)
-        }
+        let result: ConditionHolder? = try? OTUtils.model(from: [120])
+        XCTAssertTrue(result == nil)
     }
     
     func testOperaterOnEmptyConditionArray() {
         let array: [ConditionHolder] = []
         
-        do {
-            _ = try array.evaluate(op: .and, project: nil, attributes: nil)
-            XCTAssert(false, "evaluate on empty array must throw exception")
-        } catch {
-            XCTAssert(true)
-        }
+        let result = try? array.evaluate(op: .and, project: nil, attributes: nil)
+        XCTAssertTrue(result == nil)
     }
 
 }
diff --git a/OptimizelySDK/OptimizelyTests/OptimizelyTests-DataModel/ConditionLeafTests.swift b/OptimizelySDK/OptimizelyTests/OptimizelyTests-DataModel/ConditionLeafTests.swift
@@ -35,29 +35,30 @@ class ConditionLeafTests: XCTestCase {
     }
 
     func testDecodeSample_Invalid() {
+        
+        var tmpError: Error?
         do {
             let invalidData = 100
             // JSON does not support raw string, so wrap in array for decode
             let _: [ConditionLeaf] = try OTUtils.model(from: [invalidData])
-            XCTAssert(false)
-        } catch is DecodingError {
-            XCTAssert(true)
         } catch {
-            XCTAssert(false)
+            tmpError = error
         }
+        XCTAssertTrue(tmpError != nil)
+        XCTAssertTrue(tmpError is DecodingError)
     }
     
     func testEvaluate_InvalidProject() {
         let audienceId = "12345"
         // JSON does not support raw string, so wrap in array for decode
         let model: [ConditionLeaf] = try! OTUtils.model(from: [audienceId])
-
+        var tmpError: Error?
         do {
             let _ = try model[0].evaluate(project: nil, attributes: ["country": "us"])
-            XCTAssert(false)
         } catch {
-            XCTAssert(true)
+            tmpError = error
         }
+        XCTAssertTrue(tmpError != nil)
     }
 
 }
diff --git a/OptimizelySDK/OptimizelyTests/OptimizelyTests-DataModel/UserAttributeTests.swift b/OptimizelySDK/OptimizelyTests/OptimizelyTests-DataModel/UserAttributeTests.swift
diff --git a/OptimizelySDK/Protocols/BackgroundingCallbacks.swift b/OptimizelySDK/Protocols/BackgroundingCallbacks.swift

Original file line number	Diff line number	Diff line change
`@@ -64,12 +64,9 @@ class OptimizelyClientTests_DatafileHandler: XCTestCase {`
`64`	`64`	`let expectation = XCTestExpectation(description: "get datafile from cache")`
`65`	`65`
`66`	`66`	`client.start() { (result) in`
`67`		`- switch result {`
`68`		`- case .success(let data):`
	`67`	`+ if case let .success(data) = result{`
`69`	`68`	`XCTAssert(!data.isEmpty)`
`70`	`69`	`expectation.fulfill()`
`71`		`- case .failure:`
`72`		`- XCTAssert(false)`
`73`	`70`	`}`
`74`	`71`	`}`
`75`	`72`
Original file line number	Diff line number	Diff line change
`@@ -132,11 +132,7 @@ extension BucketTests_BucketVariation {`
`132`	`132`
`133`	`133`	`for (idx, test) in tests.enumerated() {`
`134`	`134`	`variation = bucketer.bucketExperiment(config: self.config, experiment: experiment, bucketingId: test["userId"]!)`
`135`		`- if let _ = test["expect"] {`
`136`		`- XCTAssertEqual(test["expect"], variation?.key, "test[\(idx)] failed")`
`137`		`- } else {`
`138`		`- XCTAssertNil(experiment)`
`139`		`- }`
	`135`	`+ XCTAssertEqual(test["expect"], variation?.key, "test[\(idx)] failed")`
`140`	`136`	`}`
`141`	`137`	`}`
`142`	`138`
`@@ -154,11 +150,7 @@ extension BucketTests_BucketVariation {`
`154`	`150`
`155`	`151`	`for (idx, test) in tests.enumerated() {`
`156`	`152`	`variation = bucketer.bucketExperiment(config: self.config, experiment: experiment, bucketingId: test["userId"]!)`
`157`		`- if let _ = test["expect"] {`
`158`		`- XCTAssertEqual(test["expect"], variation?.key, "test[\(idx)] failed")`
`159`		`- } else {`
`160`		`- XCTAssertNil(experiment)`
`161`		`- }`
	`153`	`+ XCTAssertEqual(test["expect"], variation?.key, "test[\(idx)] failed")`
`162`	`154`	`}`
`163`	`155`	`}`
`164`	`156`
`@@ -196,11 +188,7 @@ extension BucketTests_BucketVariation {`
`196`	`188`
`197`	`189`	`for (idx, test) in tests.enumerated() {`
`198`	`190`	`variation = bucketer.bucketExperiment(config: self.config, experiment: experiment, bucketingId: test["userId"]!)`
`199`		`- if let _ = test["expect"] {`
`200`		`- XCTAssertEqual(test["expect"], variation?.key, "test[\(idx)] failed")`
`201`		`- } else {`
`202`		`- XCTAssertNil(experiment)`
`203`		`- }`
	`191`	`+ XCTAssertEqual(test["expect"], variation?.key, "test[\(idx)] failed")`
`204`	`192`	`}`
`205`	`193`	`}`
`206`	`194`