Alda/new init api behavior (#194)

alda-optimizely · kellyroach-optimizely · commit 846bef6c856d · 2017-11-16T17:47:55.000-08:00
* Renamed the simplified APIs.

* Cleaned up the init method API calls in the demo app.

* Removed async and sync init APIs and moved the functionality to existing init methods. Also updated the logs.

* Updated logs for the new init APIs.

* Updated the demo app with the new init methods (i.e., remove the async and sync methods).

* Consolidated and cleaned up client initialization tests.

* Redefined how we get the bundled datafile. We are going to use the datafile from the manager builder instead of looking for a specific file name in the app resources. This solution is more clean and is applicable to fullstack SDKs as well.
diff --git a/OptimizelyDemoApp/AppDelegate.swift b/OptimizelyDemoApp/AppDelegate.swift
@@ -88,7 +88,7 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
                     }
                 }
             }
-
+            
             defaultNotificationCenter.addObserver(forName: NSNotification.Name("OptimizelyEventTracked"), object: nil, queue: nil) { (note) in
                 print("Received a tracking notification: \n", note)
                 if let userInfo : Dictionary<String, AnyObject> = note.userInfo as! Dictionary<String, AnyObject>? {
@@ -121,7 +121,7 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
         
         // ---- Create the Datafile Manager ----
         let datafileManager = OPTLYDatafileManagerDefault.init{(builder) in
-           // builder!.datafileFetchInterval = TimeInterval(self.datafileManagerDownloadInterval)
+            // builder!.datafileFetchInterval = TimeInterval(self.datafileManagerDownloadInterval)
             builder!.projectId = self.projectId
         }
         
@@ -134,25 +134,14 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
         
         // After creating the client, there are three different ways to intialize the manager:
         
-        // --- 1. Synchronous Initialization with fallback ----
-        //        let optimizelyClient = optimizelyManager?.initializeSync(projectId)
-        //        let variation = optimizelyClient?.activate(self.experimentKey, userId:self.userId, attributes: self.attributes)
-        //        self.setRootViewController(optimizelyClient: optimizelyClient, bucketedVariation:variation)
-        
-        // --- 2. Asynchronous Initialization with fallback ----
-        optimizelyManager?.initializeAsync(projectId, callback: { [weak self] (error, optimizelyClient) in
-            let variation = optimizelyClient?.activate((self?.experimentKey)!, userId:(self?.userId)!, attributes:(self?.attributes))
+        // ---- 1. Asynchronous Initialization -----
+        // initialize Optimizely Client from a datafile download
+        optimizelyManager?.initialize(callback: { [weak self] (error, optimizelyClient) in
+            let variation = optimizelyClient?.activate((self?.experimentKey)!, userId: (self?.userId)!, attributes: (self?.attributes))
             self?.setRootViewController(optimizelyClient: optimizelyClient, bucketedVariation:variation)
         })
         
-        // ---- 3. Asynchronous Initialization -----
-        // initialize Optimizely Client from a datafile download
-//        optimizelyManager?.initialize(callback: { [weak self] (error, optimizelyClient) in
-//            let variation = optimizelyClient?.activate((self?.experimentKey)!, userId: (self?.userId)!, attributes: (self?.attributes))
-//            self?.setRootViewController(optimizelyClient: optimizelyClient, bucketedVariation:variation)
-//        })
-        
-        // ---- 4. Synchronous Initialization with Datafile ----
+        // ---- 2. Synchronous Initialization with Datafile ----
         // load the datafile from the app bundle
         //        let bundle = Bundle.init(for: self.classForCoder)
         //        let filePath = bundle.path(forResource: datafileName, ofType: "json")
@@ -169,7 +158,7 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
         //        let variation = optimizelyClient?.activate(self.experimentKey, userId:self.userId, attributes: self.attributes)
         //        self.setRootViewController(optimizelyClient: optimizelyClient, bucketedVariation:variation)
         
-        // --- 5. Synchronous Initialization with Saved Datafile ----
+        // --- 3. Synchronous Initialization with Saved Datafile ----
         //        let optimizelyClient = optimizelyManager?.initialize()
         //        let variation = optimizelyClient?.activate(self.experimentKey, userId:self.userId, attributes: self.attributes)
         //        self.setRootViewController(optimizelyClient: optimizelyClient, bucketedVariation:variation)
diff --git a/OptimizelySDKCore/OptimizelySDKCore/OPTLYLoggerMessages.h b/OptimizelySDKCore/OptimizelySDKCore/OPTLYLoggerMessages.h
@@ -160,10 +160,10 @@ extern NSString *const OPTLYLoggerMessagesManagerEventDispatcherDoesNotConformTo
 extern NSString *const OPTLYLoggerMessagesManagerLoggerDoesNotConformToOPTLYLoggerProtocol;
 extern NSString *const OPTLYLoggerMessagesManagerMustBeInitializedWithProjectId;
 extern NSString *const OPTLYLoggerMessagesManagerProjectIdCannotBeEmptyString;
-extern NSString *const OPTLYLoggerMessagesManagerSyncInit;
-extern NSString *const OPTLYLoggerMessagesManagerAsyncInit;
-extern NSString *const OPTLYLoggerMessagesManagerAsyncInitErrorDatafileDownload;
-extern NSString *const OPTLYLoggerMessagesManagerAsyncInitNoDatafileUpdates;
+extern NSString *const OPTLYLoggerMessagesManagerInit;
+extern NSString *const OPTLYLoggerMessagesManagerInitWithCallback;
+extern NSString *const OPTLYLoggerMessagesManagerInitWithCallbackErrorDatafileDownload;
+extern NSString *const OPTLYLoggerMessagesManagerInitWithCallbackNoDatafileUpdates;
 extern NSString *const OPTLYLoggerMessagesManagerAttemptingBundleDataLoad;
 extern NSString *const OPTLYLoggerMessagesManagerBundleDataLoadError;
 extern NSString *const OPTLYLoggerMessagesManagerBundledDataLoaded;
diff --git a/OptimizelySDKCore/OptimizelySDKCore/OPTLYLoggerMessages.m b/OptimizelySDKCore/OptimizelySDKCore/OPTLYLoggerMessages.m
@@ -154,10 +154,10 @@
 NSString *const OPTLYLoggerMessagesManagerLoggerDoesNotConformToOPTLYLoggerProtocol = @"[MANAGER] Logger does not conform to the OPTLYLogger protocol.";
 NSString *const OPTLYLoggerMessagesManagerMustBeInitializedWithProjectId = @"[MANAGER] An Optimizely Manager instance must be initialized with a project ID.";
 NSString *const OPTLYLoggerMessagesManagerProjectIdCannotBeEmptyString = @"[MANAGER] The project ID for the Optimizely Manager instance cannot be an empty string";
-NSString *const OPTLYLoggerMessagesManagerSyncInit = @"[MANAGER] Synchronously initializing client with project ID %@.";
-NSString *const OPTLYLoggerMessagesManagerAsyncInit = @"[MANAGER] Asynchronously initializing client with project ID %@.";
-NSString *const OPTLYLoggerMessagesManagerAsyncInitErrorDatafileDownload = @"[MANAGER] Error downloading datafile: %@.";
-NSString *const OPTLYLoggerMessagesManagerAsyncInitNoDatafileUpdates = @"[MANAGER] Not downloading new datafile — no updates have been made.";
+NSString *const OPTLYLoggerMessagesManagerInit = @"[MANAGER] Initializing client for project %@.";
+NSString *const OPTLYLoggerMessagesManagerInitWithCallback = @"[MANAGER] Initializing client with callback for project %@.";
+NSString *const OPTLYLoggerMessagesManagerInitWithCallbackErrorDatafileDownload = @"[MANAGER] Error downloading datafile: %@.";
+NSString *const OPTLYLoggerMessagesManagerInitWithCallbackNoDatafileUpdates = @"[MANAGER] Not downloading new datafile — no updates have been made.";
 NSString *const OPTLYLoggerMessagesManagerAttemptingBundleDataLoad = @"[MANAGER] Attempting to load the bundled datafile.";
 NSString *const OPTLYLoggerMessagesManagerBundleDataLoadError = @"[MANAGER] Unabled to load the bundled datafile because of the following error: %@";
 NSString *const OPTLYLoggerMessagesManagerBundledDataLoaded = @"[MANAGER] The bundled datafile %@ was loaded.";
diff --git a/OptimizelySDKShared/OptimizelySDKShared/OPTLYManagerBase.h b/OptimizelySDKShared/OptimizelySDKShared/OPTLYManagerBase.h
@@ -70,63 +70,50 @@ typedef void (^OPTLYManagerBuilderBlock)(OPTLYManagerBuilder * _Nullable builder
 /// iOS App Version
 @property (nonatomic, readonly, strong, nonnull) NSString *appVersion;
 
-/*
- * Synchronous call that would retrieve the datafile from local cache. If it fails to load from local cache it will return a dummy instance
- */
-- (nullable OPTLYClient *)initialize;
-
-/**
- * Synchronous call that would instantiate the client from the datafile given
- * If the datafile is bad, then the client will try to get the datafile from local cache (if it exists). If it fails to load from local cache it will return a dummy instance
- */
-- (nullable OPTLYClient *)initializeWithDatafile:(nonnull NSData *)datafile;
-
-
-/**
- * Asynchronously gets the client from a datafile downloaded from the CDN.
- * If the client could not be initialized, the error will be set in the callback.
- */
-- (void)initializeWithCallback:(void(^ _Nullable)(NSError * _Nullable error, OPTLYClient * _Nullable client))callback;
 
 /**
  * Synchronously initializes the client using the latest
- * cached datafile with a bundled datafile as fallback.
- *
- * If the cached datafile fails to load, the bundled datafile is used.
+ * cached datafile with a fallback of the bundled datafile
+ * (i.e., the datafile provided in the OPTLYManagerBuilder
+ * during the manager initialization).
  *
- * In order for the bundled datafile to be properly loaded, the
- *  name should follow this format: optimizely_<projectID>.json
+ * If the cached datafile fails to load, the bundled datafile
+ * is used.
  *
- * @param projectId The ID of the project you want
- *   to initialize your client with.
  */
-- (nullable OPTLYClient *)initializeSync:(nonnull NSString *)projectId;
+- (nullable OPTLYClient *)initialize;
 
 /**
  * Asynchronously initializes the client using the latest
- * downloaded datafile with a bundled datafile as fallback.
+ * downloaded datafile with a fallback of the bundled datafile
+ * (i.e., the datafile provided in the OPTLYManagerBuilder
+ * during the manager initialization).
  *
  * In the case that there is an error in the datafile download,
  *  the latest cached datafile (if one exists) is used.
  *
  * If there are no updates in the datafile, then the datafile is not
  *  downloaded and the latest cached datafile is used.
  *
- * If the cached datafile fails to load, then the bundled datafile
- *  is used.
- *
- * In order for the bundled datafile to be properly loaded, the
- *  name should follow this format: optimizely_<projectID>.json
+ * If the cached datafile fails to load, then the datafile provided
+ *  in the manager builder is used.
  *
- * @param projectId The ID of the project you want
- *   to initialize your client with.
  * @param callback The block called following the initialization
  *   of the client.
  */
-- (void)initializeAsync:(nonnull NSString *)projectId
-               callback:(void(^ _Nullable)(NSError * _Nullable error,
-                                           OPTLYClient * _Nullable client))callback;
+- (void)initializeWithCallback:(void(^ _Nullable)(NSError * _Nullable error,
+                                      OPTLYClient * _Nullable client))callback;
 
+/**
+ * Synchronously instantiates the client from the provided datafile.
+ * If the datafile is invalid, then the client will attempt to retrieve
+ * the cached datafile. If getting the datafile from cache fails,
+ * then a dummy client instance will be returned (i.e., all method calls on the client
+ * will be NoOps).
+ *
+ * @param datafile The datafile used to instantiate the client.
+ */
+- (nullable OPTLYClient *)initializeWithDatafile:(nonnull NSData *)datafile;
 
 /*
  * Gets the cached Optimizely client.
diff --git a/OptimizelySDKShared/OptimizelySDKShared/OPTLYManagerBase.m b/OptimizelySDKShared/OptimizelySDKShared/OPTLYManagerBase.m
@@ -96,12 +96,24 @@ - (instancetype)init {
 #pragma mark - Client Getters
 
 - (OPTLYClient *)initialize {
-    // the datafile could have been set in the builder (this should take precedence over the saved datafile)
-    if (!self.datafile) {
-        self.datafile = [self.datafileManager getSavedDatafile:nil];
+    [self.logger logMessage:[NSString stringWithFormat:OPTLYLoggerMessagesManagerInit, self.projectId]
+                  withLevel:OptimizelyLogLevelInfo];
+    
+    NSData *data = nil;
+    
+    // get the cached datafile if the builder does not contain a datafile
+    if (data == nil) {
+        data = [self.datafileManager getSavedDatafile:nil];
     }
-    self.optimizelyClient = [self initializeClientWithManagerSettingsAndDatafile:self.datafile];
-    return self.optimizelyClient;
+    
+    // fall back to the datafile provided by the manager builder if we can't get the saved datafile
+    if (data == nil) {
+        data = self.datafile;
+    }
+    
+    OPTLYClient *client = [self initializeWithDatafile:data];
+
+    return client;
 }
 
 - (OPTLYClient *)initializeWithDatafile:(NSData *)datafile {
@@ -110,17 +122,34 @@ - (OPTLYClient *)initializeWithDatafile:(NSData *)datafile {
 }
 
 - (void)initializeWithCallback:(void (^)(NSError * _Nullable, OPTLYClient * _Nullable))callback {
-    [self.datafileManager downloadDatafile:self.projectId
-                         completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
-                             if ([(NSHTTPURLResponse *)response statusCode] == 304) {
-                                 data = [self.datafileManager getSavedDatafile:&error];
-                             }
-                             self.optimizelyClient = [self initializeClientWithManagerSettingsAndDatafile:data];
-                             
-                             if (callback) {
-                                 callback(error, self.optimizelyClient);
-                             }
-                         }];
+    [self.logger logMessage:[NSString stringWithFormat:OPTLYLoggerMessagesManagerInitWithCallback, self.projectId]
+                  withLevel:OptimizelyLogLevelInfo];
+    
+    [self.datafileManager downloadDatafile:self.projectId completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
+        if (error) {
+            [self.logger logMessage:[NSString stringWithFormat:OPTLYLoggerMessagesManagerInitWithCallbackErrorDatafileDownload, error.localizedDescription]
+                          withLevel:OptimizelyLogLevelError];
+            data = [self.datafileManager getSavedDatafile:&error];
+        } else {
+            // 304 response code means there is not datafile updates
+            if ([(NSHTTPURLResponse *)response statusCode] == 304) {
+                [self.logger logMessage:OPTLYLoggerMessagesManagerInitWithCallbackNoDatafileUpdates
+                              withLevel:OptimizelyLogLevelError];
+                data = [self.datafileManager getSavedDatafile:&error];
+            }
+        }
+        
+        // fall back to the datafile provided by the manager builder if we can't get the saved datafile
+        if (data == nil) {
+            data = self.datafile;
+        }
+        
+        OPTLYClient *client = [self initializeWithDatafile:data];
+        
+        if (callback) {
+            callback(error, client);
+        }
+    }];
 }
 
 - (OPTLYClient *)getOptimizely {
@@ -148,79 +177,8 @@ - (OPTLYClient *)initializeClientWithManagerSettingsAndDatafile:(NSData *)datafi
     return client;
 }
 
-- (nullable OPTLYClient *)initializeSync:(nonnull NSString *)projectId
-{
-    [self.logger logMessage:[NSString stringWithFormat:OPTLYLoggerMessagesManagerSyncInit, projectId]
-                  withLevel:OptimizelyLogLevelInfo];
-    
-    NSData *data = [self.datafileManager getSavedDatafile:nil];
-    
-    // fall back to the bundled datafile if we can't get the saved datafile
-    if (data == nil) {
-        data = [self loadBundleDatafile:projectId error:nil];
-    }
-    
-    OPTLYClient *client = [self initializeWithDatafile:data];
-    
-    return client;
-}
-
-- (void)initializeAsync:(nonnull NSString *)projectId
-               callback:(void(^ _Nullable)(NSError * _Nullable error, OPTLYClient * _Nullable client))callback
-{
-    [self.logger logMessage:[NSString stringWithFormat:OPTLYLoggerMessagesManagerAsyncInit, projectId]
-                  withLevel:OptimizelyLogLevelInfo];
-    
-    [self.datafileManager downloadDatafile:projectId completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
-        if (error) {
-            [self.logger logMessage:[NSString stringWithFormat:OPTLYLoggerMessagesManagerAsyncInitErrorDatafileDownload, error.localizedDescription]
-                          withLevel:OptimizelyLogLevelError];
-            data = [self.datafileManager getSavedDatafile:&error];
-        } else {
-            // 304 response code means there is not datafile updates
-            if ([(NSHTTPURLResponse *)response statusCode] == 304) {
-                [self.logger logMessage:OPTLYLoggerMessagesManagerAsyncInitNoDatafileUpdates
-                              withLevel:OptimizelyLogLevelError];
-                data = [self.datafileManager getSavedDatafile:&error];
-            }
-        }
-        
-        // fall back to the bundled datafile if we can't get the saved datafile
-        if (data == nil) {
-            data = [self loadBundleDatafile:projectId error:&error];
-        }
-        
-        OPTLYClient *client = [self initializeWithDatafile:data];
-        
-        if (callback) {
-            callback(error, client);
-        }
-    }];
-}
-
 #pragma mark - Helper Methods
 
-- (NSData *)loadBundleDatafile:(NSString *)projectId error:(NSError * __autoreleasing *)error {
-    
-    [self.logger logMessage:OPTLYLoggerMessagesManagerAttemptingBundleDataLoad
-                  withLevel:OptimizelyLogLevelInfo];
-    
-    NSString *datafileName = [NSString stringWithFormat:@"%@_%@", OptimizelyBundleDatafilePrefix, projectId];
-    NSString *filePath = [[NSBundle bundleForClass:[self class]] pathForResource:datafileName ofType:OptimizelyBundleDatafileFileTypeExtension];
-    NSString *fileContents =[NSString stringWithContentsOfFile:filePath encoding:NSUTF8StringEncoding error:error];
-    
-    if (error && *error) {
-        NSError *fileError = (NSError *)*error;
-        NSString *errorDescription = fileError.localizedDescription;
-        [self.logger logMessage:[NSString stringWithFormat:OPTLYLoggerMessagesManagerBundleDataLoadError, errorDescription]         withLevel:OptimizelyLogLevelError];
-    } else {
-        [self.logger logMessage:[NSString stringWithFormat:OPTLYLoggerMessagesManagerBundledDataLoaded, datafileName] withLevel:OptimizelyLogLevelInfo];
-    }
-    
-    NSData *jsonData = [fileContents dataUsingEncoding:NSUTF8StringEncoding];
-    return jsonData;
-}
-
 - (NSString *)description {
     return [NSString stringWithFormat:@"projectId: %@ \nclientEngine: %@\nclientVersion: %@\ndatafile:%@\nlogger:%@\nerrorHandler:%@\ndatafileManager:%@\neventDispatcher:%@\nuserProfile:%@", self.projectId, self.clientEngine, self.clientVersion, self.datafile, self.logger, self.errorHandler, self.datafileManager, self.eventDispatcher, self.userProfileService];
 }
diff --git a/OptimizelySDKShared/OptimizelySDKSharedTests/OPTLYManagerTest.m b/OptimizelySDKShared/OptimizelySDKSharedTests/OPTLYManagerTest.m
