feat: get_optimizely_config API to get static experiments and features data (#220)

## Summary
Added a `get_optimizely_config` API which returns static experiments and features data.

## Test plan
1. Manually tested thoroughly
2. Added Unit tests
3. Full Stack Integration tests passed

Author: zashraf1985

.rubocop_todo.yml

@@ -34,6 +34,7 @@ Naming/AccessorMethodName:
   Exclude:
     - 'lib/optimizely/config_manager/http_project_config_manager.rb'
     - 'spec/optimizely_factory_spec.rb'
+    - 'lib/optimizely.rb'
 
 # Offense count: 1
 # Configuration parameters: NamePrefix, NamePrefixBlacklist, NameWhitelist, MethodDefinitionMacros.

lib/optimizely.rb

@@ -33,6 +33,7 @@
 require_relative 'optimizely/helpers/variable_type'
 require_relative 'optimizely/logger'
 require_relative 'optimizely/notification_center'
+require_relative 'optimizely/optimizely_config'
 
 module Optimizely
   class Project
@@ -523,6 +524,52 @@ def close
       @event_processor.stop! if @event_processor.respond_to?(:stop!)
     end
 
+    def get_optimizely_config
+      # Get OptimizelyConfig object containing experiments and features data
+      # Returns Object
+      #
+      # OptimizelyConfig Object Schema
+      # {
+      #   'experimentsMap' => {
+      #     'my-fist-experiment' => {
+      #       'id' => '111111',
+      #       'key' => 'my-fist-experiment'
+      #       'variationsMap' => {
+      #         'variation_1' => {
+      #           'id' => '121212',
+      #           'key' => 'variation_1',
+      #           'variablesMap' => {
+      #             'age' => {
+      #               'id' => '222222',
+      #               'key' => 'age',
+      #               'type' => 'integer',
+      #               'value' => '0',
+      #             }
+      #           }
+      #         }
+      #       }
+      #     }
+      #   },
+      #   'featuresMap' => {
+      #     'awesome-feature' => {
+      #       'id' => '333333',
+      #       'key' => 'awesome-feature',
+      #       'experimentsMap' => Object,
+      #       'variablesMap' => Object,
+      #     }
+      #   },
+      #   'revision' => '13',
+      # }
+      #
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('get_optimizely_config').message)
+        return nil
+      end
+
+      optimizely_config = OptimizelyConfig.new(project_config)
+      optimizely_config.config
+    end
+
     private
 
     def get_variation_with_config(experiment_key, user_id, attributes, config)

lib/optimizely/optimizely_config.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+#    Copyright 2019, Optimizely and contributors
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+module Optimizely
+  class OptimizelyConfig
+    def initialize(project_config)
+      @project_config = project_config
+    end
+
+    def config
+      experiments_map_object = experiments_map
+      features_map = get_features_map(experiments_map_object)
+      {
+        'experimentsMap' => experiments_map_object,
+        'featuresMap' => features_map,
+        'revision' => @project_config.revision
+      }
+    end
+
+    private
+
+    def experiments_map
+      feature_variables_map = @project_config.feature_flags.reduce({}) do |result_map, feature|
+        result_map.update(feature['id'] => feature['variables'])
+      end
+      @project_config.experiments.reduce({}) do |experiments_map, experiment|
+        experiments_map.update(
+          experiment['key'] => {
+            'id' => experiment['id'],
+            'key' => experiment['key'],
+            'variationsMap' => experiment['variations'].reduce({}) do |variations_map, variation|
+              variation_object = {
+                'id' => variation['id'],
+                'key' => variation['key'],
+                'variablesMap' => get_merged_variables_map(variation, experiment['id'], feature_variables_map)
+              }
+              variation_object['featureEnabled'] = variation['featureEnabled'] if @project_config.feature_experiment?(experiment['id'])
+              variations_map.update(variation['key'] => variation_object)
+            end
+          }
+        )
+      end
+    end
+
+    # Merges feature key and type from feature variables to variation variables.
+    def get_merged_variables_map(variation, experiment_id, feature_variables_map)
+      feature_ids = @project_config.experiment_feature_map[experiment_id]
+      return {} unless feature_ids
+
+      experiment_feature_variables = feature_variables_map[feature_ids[0]]
+      # temporary variation variables map to get values to merge.
+      temp_variables_id_map = {}
+      if variation['variables']
+        temp_variables_id_map = variation['variables'].reduce({}) do |variables_map, variable|
+          variables_map.update(
+            variable['id'] => {
+              'id' => variable['id'],
+              'value' => variable['value']
+            }
+          )
+        end
+      end
+      experiment_feature_variables.reduce({}) do |variables_map, feature_variable|
+        variation_variable = temp_variables_id_map[feature_variable['id']]
+        variable_value = variation['featureEnabled'] && variation_variable ? variation_variable['value'] : feature_variable['defaultValue']
+        variables_map.update(
+          feature_variable['key'] => {
+            'id' => feature_variable['id'],
+            'key' => feature_variable['key'],
+            'type' => feature_variable['type'],
+            'value' => variable_value
+          }
+        )
+      end
+    end
+
+    def get_features_map(all_experiments_map)
+      @project_config.feature_flags.reduce({}) do |features_map, feature|
+        features_map.update(
+          feature['key'] => {
+            'id' => feature['id'],
+            'key' => feature['key'],
+            'experimentsMap' => feature['experimentIds'].reduce({}) do |experiments_map, experiment_id|
+              experiment_key = @project_config.experiment_id_map[experiment_id]['key']
+              experiments_map.update(experiment_key => all_experiments_map[experiment_key])
+            end,
+            'variablesMap' => feature['variables'].reduce({}) do |variables, variable|
+              variables.update(
+                variable['key'] => {
+                  'id' => variable['id'],
+                  'key' => variable['key'],
+                  'type' => variable['type'],
+                  'value' => variable['defaultValue']
+                }
+              )
+            end
+          }
+        )
+      end
+    end
+  end
+end

spec/optimizely_config_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2019, Optimizely and contributors
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Optimizely::OptimizelyConfig do
+  let(:config_body_JSON) { OptimizelySpec::VALID_CONFIG_BODY_JSON }
+  let(:config_typed_audience_JSON) { JSON.dump(OptimizelySpec::CONFIG_DICT_WITH_TYPED_AUDIENCES) }
+  let(:error_handler) { Optimizely::NoOpErrorHandler.new }
+  let(:spy_logger) { spy('logger') }
+  let(:project_config) { Optimizely::DatafileProjectConfig.new(config_body_JSON, spy_logger, error_handler) }
+  let(:project_instance) { Optimizely::Project.new(config_body_JSON, nil, spy_logger, error_handler) }
+  let(:optimizely_config) { project_instance.get_optimizely_config }
+
+  it 'should return all experiments' do
+    experiments_map = optimizely_config['experimentsMap']
+    expect(experiments_map.length).to eq(11)
+    project_config.experiments.each do |experiment|
+      expect(experiments_map[experiment['key']]).to include(
+        'id' => experiment['id'],
+        'key' => experiment['key']
+      )
+      variations_map = experiments_map[experiment['key']]['variationsMap']
+      experiment['variations'].each do |variation|
+        expect(variations_map[variation['key']]).to include(
+          'id' => variation['id'],
+          'key' => variation['key']
+        )
+      end
+    end
+  end
+
+  it 'should return all feature flags' do
+    features_map = optimizely_config['featuresMap']
+    expect(features_map.length).to eq(8)
+    project_config.feature_flags.each do |feature_flag|
+      expect(features_map[feature_flag['key']]).to include(
+        'id' => feature_flag['id'],
+        'key' => feature_flag['key']
+      )
+      experiments_map = features_map[feature_flag['key']]['experimentsMap']
+      feature_flag['experimentIds'].each do |experiment_id|
+        experiment_key = project_config.get_experiment_key(experiment_id)
+        expect(experiments_map[experiment_key]).to be_truthy
+      end
+      variables_map = features_map[feature_flag['key']]['variablesMap']
+      feature_flag['variables'].each do |variable|
+        expect(variables_map[variable['key']]).to include(
+          'id' => variable['id'],
+          'key' => variable['key'],
+          'type' => variable['type'],
+          'value' => variable['defaultValue']
+        )
+      end
+    end
+  end
+
+  it 'should correctly merge all feature variables' do
+    project_config.feature_flags.each do |feature_flag|
+      feature_flag['experimentIds'].each do |experiment_id|
+        experiment = project_config.experiment_id_map[experiment_id]
+        variations = experiment['variations']
+        variations_map = optimizely_config['experimentsMap'][experiment['key']]['variationsMap']
+        variations.each do |variation|
+          feature_flag['variables'].each do |variable|
+            variable_to_assert = variations_map[variation['key']]['variablesMap'][variable['key']]
+            expect(variable).to include(
+              'id' => variable_to_assert['id'],
+              'key' => variable_to_assert['key'],
+              'type' => variable_to_assert['type']
+            )
+            expect(variable['defaultValue']).to eq(variable_to_assert['value']) unless variation['featureEnabled']
+          end
+        end
+      end
+    end
+  end
+
+  it 'should return correct config revision' do
+    expect(project_config.revision).to eq(optimizely_config['revision'])
+  end
+end