From 1d897ad3d653ca90d50c9027aa4b95d9fee9f5fd Mon Sep 17 00:00:00 2001 From: Abbas-khaliq Date: Mon, 25 Apr 2022 15:57:40 +0530 Subject: [PATCH] refactor(sdk): rubocop warnings fixed, code properly linted --- .rubocop.yml | 13 + CHANGELOG.md | 8 + Gemfile | 4 +- lib/vwo.rb | 541 +++----- lib/vwo/constants.rb | 4 +- lib/vwo/core/bucketer.rb | 44 +- lib/vwo/core/variation_decider.rb | 436 +++--- lib/vwo/enums.rb | 35 +- lib/vwo/logger.rb | 5 +- lib/vwo/schemas/settings_file.rb | 12 +- lib/vwo/services/batch_events_dispatcher.rb | 40 +- lib/vwo/services/batch_events_queue.rb | 70 +- lib/vwo/services/event_dispatcher.rb | 52 +- lib/vwo/services/hooks_manager.rb | 20 +- lib/vwo/services/segment_evaluator.rb | 13 +- lib/vwo/services/settings_file_manager.rb | 10 +- lib/vwo/services/settings_file_processor.rb | 2 +- lib/vwo/services/usage_stats.rb | 9 +- lib/vwo/utils/campaign.rb | 76 +- lib/vwo/utils/custom_dimensions.rb | 4 +- lib/vwo/utils/data_location_manager.rb | 11 +- lib/vwo/utils/feature.rb | 4 +- lib/vwo/utils/impression.rb | 66 +- lib/vwo/utils/log_message.rb | 53 +- lib/vwo/utils/request.rb | 16 +- lib/vwo/utils/utility.rb | 78 +- lib/vwo/utils/validations.rb | 77 +- tests/test_all_tests.rb | 2 +- tests/test_bucketer.rb | 80 +- tests/test_event_dispatcher.rb | 38 +- tests/test_helper.rb | 2 +- tests/test_impression.rb | 294 ++--- tests/test_logger.rb | 5 +- tests/test_mutually_exclusive.rb | 663 +++++----- tests/test_segment_evaluator.rb | 2 +- tests/test_settings_file_manager.rb | 9 +- tests/test_utility.rb | 21 +- tests/test_variation_decider.rb | 27 +- tests/test_vwo.rb | 1323 +++++++++---------- vwo-sdk.gemspec | 18 +- 40 files changed, 2017 insertions(+), 2170 deletions(-) diff --git a/.rubocop.yml b/.rubocop.yml index ea0dd3a..30f46ba 100644 --- a/.rubocop.yml +++ b/.rubocop.yml @@ -10,10 +10,15 @@ Metrics/AbcSize: Max: 100 Metrics/ParameterLists: Max: 10 + MaxOptionalParameters: 5 Metrics/CyclomaticComplexity: Max: 30 Metrics/PerceivedComplexity: Max: 30 +Metrics/ModuleLength: + Max: 225 +Style/RedundantBegin: + Enabled: false Style/Documentation: Enabled: false Style/ZeroLengthPredicate: @@ -30,3 +35,11 @@ Style/MutableConstant: Enabled: false Style/FrozenStringLiteralComment: Enabled: false +Style/OptionalBooleanParameter: + AllowedMethods: ['initialize', 'get_variation_if_whitelisting_passed', 'whitelisting_or_storage_for_grouped_campaigns?', 'presegmentation?', 'get_variation_allotted', 'save_user_storage', 'get_stored_variation', 'get_variation_of_campaign_for_user', 'get_user_storage', 'evaluate_whitelisting', 'flush', 'log', 'generator_for', 'evaluate', 'get_settings_file', 'user_part_of_campaign?', 'bucket_user_to_variation', 'get_bucket_value_for_user'] +Style/DoubleNegation: + Enabled: false +Style/CombinableLoops: + Enabled: false +Security/JSONLoad: + Enabled: false \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index 86325b0..e800f0a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,8 +4,16 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [1.37.1] - 2022-25-04 + +### Changed + +- Code properly linted, fixed rubocop warnings and errors + ## [1.36.0] - 2022-04-04 +### Changed + - Fix resolving `vwo_sdk_log_messages` dependency ## [1.35.0] - 2022-03-28 diff --git a/Gemfile b/Gemfile index 640c1da..9bb6cc7 100644 --- a/Gemfile +++ b/Gemfile @@ -2,10 +2,10 @@ source 'http://rubygems.org' gem 'json-schema', '~>2.8.1' gem 'murmurhash3', '~>0.1.6' -gem "vwo_log_messages", '~>0.7.4' +gem 'vwo_log_messages', '~>0.7.4' # gem 'codecov', require: false, group: 'test' -# gem 'rubocop', require: false, group: 'test' +gem 'rubocop', require: false, group: 'test' group :development, :test do gem 'mocha', '~> 1.13' diff --git a/lib/vwo.rb b/lib/vwo.rb index a4046d6..952fc83 100644 --- a/lib/vwo.rb +++ b/lib/vwo.rb @@ -36,6 +36,7 @@ class VWO attr_accessor :is_instance_valid, :logging, :settings_file_manager, :variation_decider attr_reader :usage_stats + include Enums include Utils::Validations include Utils::Feature @@ -128,34 +129,21 @@ def initialize( @is_instance_valid = true @config = VWO::Services::SettingsFileProcessor.new(get_settings) - #Process the settings file + # Process the settings file @config.process_settings_file @settings_file = @config.get_settings_file - DataLocationManager.get_instance().set_settings(@settings_file) + DataLocationManager.get_instance.set_settings(@settings_file) @usage_stats = VWO::Services::UsageStats.new(usage_stats, @is_development_mode) if options.key?(:batch_events) if options[:batch_events].is_a?(Hash) - unless is_valid_batch_event_settings(options[:batch_events], ApiMethods::LAUNCH) + unless valid_batch_event_settings(options[:batch_events], ApiMethods::LAUNCH) @is_instance_valid = false return end @batch_event_dispatcher = VWO::Services::BatchEventsDispatcher.new(@is_development_mode) - def dispatcher (events, callback) - @batch_event_dispatcher.dispatch( - { - ev: events - }, - callback, - { - a: @account_id, - sd: SDK_NAME, - sv: SDK_VERSION, - env: @sdk_key - }.merge(@usage_stats.usage_stats) - ) - end + @batch_events_queue = VWO::Services::BatchEventsQueue.new( options[:batch_events].merge( { @@ -192,7 +180,22 @@ def dispatcher (events, callback) @logger.log( LogLevelEnum::INFO, 'SDK_INITIALIZED', - {'{file}' => FILE} + { '{file}' => FILE } + ) + end + + def dispatcher(events, callback) + @batch_event_dispatcher.dispatch( + { + ev: events + }, + callback, + { + a: @account_id, + sd: SDK_NAME, + sv: SDK_VERSION, + env: @sdk_key + }.merge(@usage_stats.usage_stats) ) end @@ -210,9 +213,7 @@ def get_settings(settings_file = nil) # VWO get_settings method to get settings for a particular account_id def get_and_update_settings_file @logger.set_api_name(ApiMethods::GET_AND_UPDATE_SETTINGS_FILE) - if is_opted_out(ApiMethods::GET_AND_UPDATE_SETTINGS_FILE) - return false - end + return false if opted_out?(ApiMethods::GET_AND_UPDATE_SETTINGS_FILE) unless @is_instance_valid @logger.log( @@ -245,7 +246,7 @@ def get_and_update_settings_file rescue StandardError => e @logger.log( LogLevelEnum::ERROR, - '({file}): {api} API error: ' + e.message, + "({file}): {api} API error: #{e.message}", { '{file}' => FILE, '{api}' => ApiMethods::GET_AND_UPDATE_SETTINGS_FILE @@ -273,9 +274,7 @@ def get_and_update_settings_file def activate(campaign_key, user_id, options = {}) @logger.set_api_name(ApiMethods::ACTIVATE) - if is_opted_out(ApiMethods::ACTIVATE) - return nil - end + return nil if opted_out?(ApiMethods::ACTIVATE) unless @is_instance_valid @logger.log( @@ -296,7 +295,7 @@ def activate(campaign_key, user_id, options = {}) # Validate input parameters unless valid_string?(campaign_key) && valid_string?(user_id) && (custom_variables.nil? || valid_hash?(custom_variables)) && - (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables)) + (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables)) @logger.log( LogLevelEnum::ERROR, 'API_BAD_PARAMETERS', @@ -339,7 +338,7 @@ def activate(campaign_key, user_id, options = {}) '{api}' => ApiMethods::ACTIVATE, '{userId}' => user_id, '{campaignKey}' => campaign_key, - '{campaignType}' => campaign_type, + '{campaignType}' => campaign_type } ) return @@ -358,11 +357,9 @@ def activate(campaign_key, user_id, options = {}) ) # Check if variation_name has been assigned - if variation.nil? - return - end + return if variation.nil? - if is_eligible_to_send_impression() + if eligible_to_send_impression? if defined?(@batch_events) impression = create_bulk_event_impression( @settings_file, @@ -371,7 +368,7 @@ def activate(campaign_key, user_id, options = {}) user_id ) @batch_events_queue.enqueue(impression) - elsif is_event_arch_enabled + elsif event_arch_enabled? properties = get_events_base_properties(@settings_file, EventEnum::VWO_VARIATION_SHOWN, @usage_stats.usage_stats) payload = get_track_user_payload_data(@settings_file, user_id, EventEnum::VWO_VARIATION_SHOWN, campaign['id'], variation['id']) @event_dispatcher.dispatch_event_arch_post(properties, payload) @@ -387,18 +384,8 @@ def activate(campaign_key, user_id, options = {}) nil, # revenue usage_stats: @usage_stats.usage_stats ) - if @event_dispatcher.dispatch(impression) - @logger.log( - LogLevelEnum::INFO, - 'IMPRESSION_SUCCESS', - { - '{file}' => FILE, - '{mainKeys}' => JSON.generate({'campaignId' => campaign['id'], 'variationId' => variation['id']}), - '{accountId}' => @account_id, - '{endPoint}' => EVENTS::TRACK_USER - } - ) - end + main_keys = { 'campaignId' => campaign['id'], 'variationId' => variation['id'] } + @event_dispatcher.dispatch(impression, main_keys, EVENTS::TRACK_USER) end else @logger.log( @@ -416,7 +403,7 @@ def activate(campaign_key, user_id, options = {}) rescue StandardError => e @logger.log( LogLevelEnum::ERROR, - '({file}): {api} API error: ' + e.message, + "({file}): {api} API error: #{e.message}", { '{file}' => FILE, '{api}' => ApiMethods::ACTIVATE @@ -444,9 +431,7 @@ def activate(campaign_key, user_id, options = {}) # def get_variation_name(campaign_key, user_id, options = {}) @logger.set_api_name(ApiMethods::GET_VARIATION_NAME) - if is_opted_out(ApiMethods::GET_VARIATION_NAME) - return nil - end + return nil if opted_out?(ApiMethods::GET_VARIATION_NAME) unless @is_instance_valid @logger.log( @@ -466,7 +451,7 @@ def get_variation_name(campaign_key, user_id, options = {}) # Validate input parameters unless valid_string?(campaign_key) && valid_string?(user_id) && (custom_variables.nil? || valid_hash?(custom_variables)) && - (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables)) + (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables)) @logger.log( LogLevelEnum::ERROR, 'API_BAD_PARAMETERS', @@ -506,7 +491,23 @@ def get_variation_name(campaign_key, user_id, options = {}) '{api}' => ApiMethods::GET_VARIATION_NAME, '{userId}' => user_id, '{campaignKey}' => campaign_key, - '{campaignType}' => campaign_type, + '{campaignType}' => campaign_type + } + ) + return + end + + case campaign_type + when CampaignTypes::FEATURE_ROLLOUT + @logger.log( + LogLevelEnum::ERROR, + 'API_NOT_APPLICABLE', + { + '{file}' => FILE, + '{api}' => ApiMethods::GET_VARIATION_NAME, + '{userId}' => user_id, + '{campaignKey}' => campaign_key, + '{campaignType}' => campaign_type } ) return @@ -515,15 +516,13 @@ def get_variation_name(campaign_key, user_id, options = {}) variation = @variation_decider.get_variation(user_id, campaign, ApiMethods::GET_VARIATION_NAME, campaign_key, custom_variables, variation_targeting_variables) # Check if variation_name has been assigned - unless valid_value?(variation) - return - end + return unless valid_value?(variation) variation['name'] rescue StandardError => e @logger.log( LogLevelEnum::ERROR, - '({file}): {api} API error: ' + e.message, + "({file}): {api} API error: #{e.message}", { '{file}' => FILE, '{api}' => ApiMethods::GET_VARIATION_NAME @@ -543,15 +542,12 @@ def get_variation_name(campaign_key, user_id, options = {}) # @param[String] :campaign_key Unique campaign key # @param[String] :user_id ID assigned to a user # @param[String] :goal_identifier Unique campaign's goal identifier - # @param[Hash] :options Contains revenue value and custom variables - # @param[Numeric|String] :revenue_value It is the revenue generated on triggering the goal + # @param[Hash] :options Contains revenue value and custom variables # def track(campaign_key, user_id, goal_identifier, options = {}) @logger.set_api_name(ApiMethods::TRACK) - if is_opted_out(ApiMethods::TRACK) - return false - end + return false if opted_out?(ApiMethods::TRACK) unless @is_instance_valid @logger.log( @@ -572,168 +568,59 @@ def track(campaign_key, user_id, goal_identifier, options = {}) goal_type_to_track = get_goal_type_to_track(options) # Check for valid args - unless (valid_string?(campaign_key) || campaign_key.is_a?(Array) || campaign_key.nil?) && valid_string?(user_id) && valid_string?(goal_identifier) && (custom_variables.nil? || valid_hash?(custom_variables)) && - (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables)) && (GOAL_TYPES.key? (goal_type_to_track)) - # log invalid params - @logger.log( - LogLevelEnum::ERROR, - 'API_BAD_PARAMETERS', - { - '{file}' => FILE, - '{api}' => ApiMethods::TRACK - } - ) - return false - end + return false unless valid_track_api_params?(user_id, campaign_key, custom_variables, variation_targeting_variables, goal_type_to_track, goal_identifier) # Get campaigns settings campaigns = get_campaigns(@settings_file, campaign_key, goal_identifier, goal_type_to_track) # Validate campaign - if campaigns.nil? - return nil - end + return nil if campaigns.nil? metric_map = {} revenue_props = [] result = {} - batch_event_data = {"ev" => []} + batch_event_data = { 'ev' => [] } campaigns.each do |campaign| begin campaign_type = campaign['type'] + result[campaign['key']] = false - if campaign_type == CampaignTypes::FEATURE_ROLLOUT - @logger.log( - LogLevelEnum::ERROR, - 'API_NOT_APPLICABLE', - { - '{file}' => FILE, - '{api}' => ApiMethods::TRACK, - '{userId}' => user_id, - '{campaignKey}' => campaign_key, - '{campaignType}' => campaign_type, - } - ) - result[campaign['key']] = false - next - end + next unless valid_campaign_for_track_api?(user_id, campaign_key, campaign_type) variation = @variation_decider.get_variation(user_id, campaign, ApiMethods::TRACK, campaign['key'], custom_variables, variation_targeting_variables, goal_identifier) if variation goal = get_campaign_goal(campaign, goal_identifier) - if goal.nil? || !goal["id"] - @logger.log( - LogLevelEnum::ERROR, - 'TRACK_API_GOAL_NOT_FOUND', - { - '{file}' => FILE, - '{goalIdentifier}' => goal_identifier, - '{userId}' => user_id, - '{campaignKey}' => campaign['key'] - } - ) - result[campaign['key']] = false - next - elsif goal['type'] == GoalTypes::REVENUE && !valid_value?(revenue_value) - @logger.log( - LogLevelEnum::ERROR, - 'TRACK_API_REVENUE_NOT_PASSED_FOR_REVENUE_GOAL', - { - '{file}' => FILE, - '{userId}' => user_id, - '{goalIdentifier}' => goal_identifier, - '{campaignKey}' => campaign['key'] - } - ) - result[campaign['key']] = false - next - elsif goal['type'] == GoalTypes::CUSTOM - revenue_value = nil - end + next unless valid_goal?(goal, campaign, user_id, goal_identifier, revenue_value) - if variation['goal_identifier'] - identifiers = variation['goal_identifier'].split(VWO_DELIMITER) - else - variation['goal_identifier'] = '' - identifiers = [] - end + revenue_value = nil if goal['type'] == GoalTypes::CUSTOM + identifiers = get_variation_identifiers(variation) - if !identifiers.include? goal_identifier - updated_goal_identifier = variation['goal_identifier'] - updated_goal_identifier += VWO_DELIMITER + goal_identifier - @variation_decider.save_user_storage(user_id, campaign['key'], campaign['name'], variation['name'], updated_goal_identifier) if variation['name'] - # set variation at user storage - else - @logger.log( - LogLevelEnum::INFO, - 'CAMPAIGN_GOAL_ALREADY_TRACKED', - { - '{file}' => FILE, - '{userId}' => user_id, - '{campaignKey}' => campaign['key'], - '{goalIdentifier}' => goal_identifier - } - ) - result[campaign['key']] = false - next - end + next if campaign_goal_already_tracked?(user_id, campaign, identifiers, goal_identifier) + + @variation_decider.update_goal_identifier(user_id, campaign, variation, goal_identifier) + # set variation at user storage if defined?(@batch_events) - impression = create_bulk_event_impression( - @settings_file, - campaign['id'], - variation['id'], - user_id, - goal['id'], - revenue_value - ) + impression = create_bulk_event_impression(@settings_file, campaign['id'], variation['id'], user_id, goal['id'], revenue_value) @batch_events_queue.enqueue(impression) - elsif is_event_arch_enabled + elsif event_arch_enabled? metric_map[campaign['id']] = goal['id'] - if goal['type'] == GoalTypes::REVENUE && !(revenue_props.include? goal['revenueProp']) - revenue_props << goal['revenueProp'] - end + revenue_props << goal['revenueProp'] if goal['type'] == GoalTypes::REVENUE && !(revenue_props.include? goal['revenueProp']) elsif campaigns.count == 1 - impression = create_impression( - @settings_file, - campaign['id'], - variation['id'], - user_id, - @sdk_key, - goal['id'], - revenue_value - ) - if @event_dispatcher.dispatch(impression) - @logger.log( - LogLevelEnum::INFO, - 'IMPRESSION_SUCCESS', - { - '{file}' => FILE, - '{mainKeys}' => JSON.generate({'campaignId' => campaign['id'], 'variationId' => variation['id'], 'goalId' => goal['id']}), - '{accountId}' => @account_id, - '{endPoint}' => EVENTS::TRACK_GOAL - } - ) - end + impression = create_impression(@settings_file, campaign['id'], variation['id'], user_id, @sdk_key, goal['id'], revenue_value) + main_keys = { 'campaignId' => campaign['id'], 'variationId' => variation['id'], 'goalId' => goal['id'] } + @event_dispatcher.dispatch(impression, main_keys, EVENTS::TRACK_GOAL) else - batch_event_data["ev"] << create_bulk_event_impression( - @settings_file, - campaign['id'], - variation['id'], - user_id, - goal['id'], - revenue_value - ) + batch_event_data['ev'] << create_bulk_event_impression(@settings_file, campaign['id'], variation['id'], user_id, goal['id'], revenue_value) end result[campaign['key']] = true next end - result[campaign['key']] = false rescue StandardError => e @logger.log( LogLevelEnum::ERROR, - '({file}): {api} API error: ' + e.message, + "({file}): {api} API error: #{e.message}", { '{file}' => FILE, '{api}' => ApiMethods::TRACK @@ -742,26 +629,23 @@ def track(campaign_key, user_id, goal_identifier, options = {}) end end - multiple_call_response = false # use for normal call when track multiple goals in single call - if is_event_arch_enabled + if event_arch_enabled? properties = get_events_base_properties(@settings_file, goal_identifier) payload = get_track_goal_payload_data(@settings_file, user_id, goal_identifier, revenue_value, metric_map, revenue_props) @event_dispatcher.dispatch_event_arch_post(properties, payload) - elsif batch_event_data["ev"].count != 0 + elsif batch_event_data['ev'].count != 0 paramters = get_batch_event_query_params(@settings_file['accountId'], @sdk_key, @usage_stats.usage_stats) batch_events_dispatcher = VWO::Services::BatchEventsDispatcher.new(@is_development_mode) - multiple_call_response = batch_events_dispatcher.dispatch(batch_event_data, nil, paramters) + return nil unless batch_events_dispatcher.dispatch(batch_event_data, nil, paramters) end - if result.length() == 0 || (batch_event_data["ev"].count != 0 && !multiple_call_response) - return nil - end + return nil if result.length == 0 result rescue StandardError => e @logger.log( LogLevelEnum::ERROR, - '({file}): {api} API error: ' + e.message, + "({file}): {api} API error: #{e.message}", { '{file}' => FILE, '{api}' => ApiMethods::TRACK @@ -769,7 +653,6 @@ def track(campaign_key, user_id, goal_identifier, options = {}) ) false end - # This API method: Identifies whether the user becomes a part of feature rollout/test or not. # 1. Validates the arguments being passed # 2. Checks if user is eligible to get bucketed into the feature test/rollout, @@ -785,9 +668,7 @@ def track(campaign_key, user_id, goal_identifier, options = {}) def feature_enabled?(campaign_key, user_id, options = {}) @logger.set_api_name(ApiMethods::IS_FEATURE_ENABLED) - if is_opted_out(ApiMethods::IS_FEATURE_ENABLED) - return false - end + return false if opted_out?(ApiMethods::IS_FEATURE_ENABLED) unless @is_instance_valid @logger.log( @@ -808,7 +689,7 @@ def feature_enabled?(campaign_key, user_id, options = {}) # Validate input parameters unless valid_string?(campaign_key) && valid_string?(user_id) && (custom_variables.nil? || valid_hash?(custom_variables)) && - (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables)) + (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables)) @logger.log( LogLevelEnum::ERROR, 'API_BAD_PARAMETERS', @@ -850,7 +731,7 @@ def feature_enabled?(campaign_key, user_id, options = {}) '{api}' => ApiMethods::IS_FEATURE_ENABLED, '{userId}' => user_id, '{campaignKey}' => campaign_key, - '{campaignType}' => campaign_type, + '{campaignType}' => campaign_type } ) return false @@ -864,7 +745,7 @@ def feature_enabled?(campaign_key, user_id, options = {}) # if campaign type is feature_test Send track call to server - if is_eligible_to_send_impression() + if eligible_to_send_impression? if defined?(@batch_events) impression = create_bulk_event_impression( @settings_file, @@ -873,7 +754,7 @@ def feature_enabled?(campaign_key, user_id, options = {}) user_id ) @batch_events_queue.enqueue(impression) - elsif is_event_arch_enabled + elsif event_arch_enabled? properties = get_events_base_properties(@settings_file, EventEnum::VWO_VARIATION_SHOWN, @usage_stats.usage_stats) payload = get_track_user_payload_data(@settings_file, user_id, EventEnum::VWO_VARIATION_SHOWN, campaign['id'], variation['id']) @event_dispatcher.dispatch_event_arch_post(properties, payload) @@ -889,17 +770,8 @@ def feature_enabled?(campaign_key, user_id, options = {}) usage_stats: @usage_stats.usage_stats ) - @event_dispatcher.dispatch(impression) - @logger.log( - LogLevelEnum::INFO, - 'IMPRESSION_SUCCESS', - { - '{file}' => FILE, - '{mainKeys}' => JSON.generate({'campaignId' => impression[:experiment_id]}), - '{accountId}' => @account_id, - '{endPoint}' => EVENTS::TRACK_USER - } - ) + main_keys = { 'campaignId' => impression[:experiment_id] } + @event_dispatcher.dispatch(impression, main_keys, EVENTS::TRACK_USER) end else @@ -914,11 +786,11 @@ def feature_enabled?(campaign_key, user_id, options = {}) } ) end - if campaign_type == CampaignTypes::FEATURE_ROLLOUT - result = true - else - result = variation['isFeatureEnabled'] - end + result = if campaign_type == CampaignTypes::FEATURE_ROLLOUT + true + else + variation['isFeatureEnabled'] + end if result @logger.log( @@ -948,7 +820,7 @@ def feature_enabled?(campaign_key, user_id, options = {}) rescue StandardError => e @logger.log( LogLevelEnum::ERROR, - '({file}): {api} API error: ' + e.message, + "({file}): {api} API error: #{e.message}", { '{file}' => FILE, '{api}' => ApiMethods::IS_FEATURE_ENABLED @@ -978,9 +850,7 @@ def feature_enabled?(campaign_key, user_id, options = {}) def get_feature_variable_value(campaign_key, variable_key, user_id, options = {}) @logger.set_api_name(ApiMethods::GET_FEATURE_VARIABLE_VALUE) - if is_opted_out(ApiMethods::GET_FEATURE_VARIABLE_VALUE) - return nil - end + return nil if opted_out?(ApiMethods::GET_FEATURE_VARIABLE_VALUE) unless @is_instance_valid @logger.log( @@ -1000,7 +870,7 @@ def get_feature_variable_value(campaign_key, variable_key, user_id, options = {} variation_targeting_variables = options[:variation_targeting_variables] unless valid_string?(campaign_key) && valid_string?(variable_key) && valid_string?(user_id) && - (custom_variables.nil? || valid_hash?(custom_variables)) && (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables)) + (custom_variables.nil? || valid_hash?(custom_variables)) && (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables)) @logger.log( LogLevelEnum::ERROR, 'API_BAD_PARAMETERS', @@ -1041,7 +911,7 @@ def get_feature_variable_value(campaign_key, variable_key, user_id, options = {} '{api}' => ApiMethods::GET_FEATURE_VARIABLE_VALUE, '{userId}' => user_id, '{campaignKey}' => campaign_key, - '{campaignType}' => campaign_type, + '{campaignType}' => campaign_type } ) return @@ -1052,32 +922,33 @@ def get_feature_variable_value(campaign_key, variable_key, user_id, options = {} # Check if variation has been assigned to user return unless variation - if campaign_type == CampaignTypes::FEATURE_ROLLOUT + case campaign_type + when CampaignTypes::FEATURE_ROLLOUT variables = campaign['variables'] - elsif campaign_type == CampaignTypes::FEATURE_TEST + when CampaignTypes::FEATURE_TEST if !variation['isFeatureEnabled'] @logger.log( - LogLevelEnum::INFO, - 'FEATURE_STATUS', - { - '{file}' => FILE, - '{userId}' => user_id, - '{campaignKey}' => campaign_key, - '{status}' => 'disabled' - } - ) + LogLevelEnum::INFO, + 'FEATURE_STATUS', + { + '{file}' => FILE, + '{userId}' => user_id, + '{campaignKey}' => campaign_key, + '{status}' => 'disabled' + } + ) variation = get_control_variation(campaign) else @logger.log( - LogLevelEnum::INFO, - 'FEATURE_STATUS', - { - '{file}' => FILE, - '{userId}' => user_id, - '{campaignKey}' => campaign_key, - '{status}' => 'enabled' - } - ) + LogLevelEnum::INFO, + 'FEATURE_STATUS', + { + '{file}' => FILE, + '{userId}' => user_id, + '{campaignKey}' => campaign_key, + '{status}' => 'enabled' + } + ) end variables = variation['variables'] end @@ -1105,14 +976,14 @@ def get_feature_variable_value(campaign_key, variable_key, user_id, options = {} '{variableKey}' => variable_key, '{variableValue}' => variable['value'], '{campaignKey}' => campaign_key, - '{userId}' => user_id, + '{userId}' => user_id } ) get_type_casted_feature_value(variable['value'], variable['type']) rescue StandardError => e @logger.log( LogLevelEnum::ERROR, - '({file}): {api} API error: ' + e.message, + "({file}): {api} API error: #{e.message}", { '{file}' => FILE, '{api}' => ApiMethods::GET_FEATURE_VARIABLE_VALUE @@ -1131,9 +1002,7 @@ def get_feature_variable_value(campaign_key, variable_key, user_id, options = {} def push(tag_key, tag_value, user_id = nil) @logger.set_api_name(ApiMethods::PUSH) - if is_opted_out(ApiMethods::PUSH) - return {} - end + return {} if opted_out?(ApiMethods::PUSH) unless @is_instance_valid @logger.log( @@ -1169,42 +1038,42 @@ def push(tag_key, tag_value, user_id = nil) end result = {} - custom_dimension_map.each do |tag_key, tag_value| - if !tag_key.is_a?(Symbol) || !tag_value.is_a?(String) - custom_dimension_map.delete(tag_key) - result[tag_key] = false + custom_dimension_map.each do |tagkey, tagvalue| + if !tagkey.is_a?(Symbol) || !tagvalue.is_a?(String) + custom_dimension_map.delete(tagkey) + result[tagkey] = false next end - if tag_key.length > PushApi::TAG_KEY_LENGTH || tag_key.length == 0 + if tagkey.length > PushApi::TAG_KEY_LENGTH || tagkey.length == 0 @logger.log( LogLevelEnum::ERROR, 'TAG_KEY_LENGTH_EXCEEDED', { '{file}' => FILE, '{userId}' => user_id, - '{tagKey}' => tag_key + '{tagKey}' => tagkey } ) - custom_dimension_map.delete(tag_key) - result[tag_key] = false + custom_dimension_map.delete(tagkey) + result[tagkey] = false next end - if tag_value.length > PushApi::TAG_VALUE_LENGTH || tag_value.length == 0 - @logger.log( - LogLevelEnum::ERROR, - 'TAG_VALUE_LENGTH_EXCEEDED', - { - '{file}' => FILE, - '{userId}' => user_id, - '{tagKey}' => tag_key, - '{tagValue}' => tag_value - } - ) - custom_dimension_map.delete(tag_key) - result[tag_key] = false - end + next unless tagvalue.length > PushApi::TAG_VALUE_LENGTH || tagvalue.length == 0 + + @logger.log( + LogLevelEnum::ERROR, + 'TAG_VALUE_LENGTH_EXCEEDED', + { + '{file}' => FILE, + '{userId}' => user_id, + '{tagKey}' => tagkey, + '{tagValue}' => tagvalue + } + ) + custom_dimension_map.delete(tagkey) + result[tagkey] = false end if custom_dimension_map.count == 0 @@ -1220,62 +1089,51 @@ def push(tag_key, tag_value, user_id = nil) end if defined?(@batch_events) - custom_dimension_map.each do |tag_key, tag_value| - impression = get_batch_event_url_params(@settings_file, tag_key, tag_value, user_id) + custom_dimension_map.each do |tagkey, tagvalue| + impression = get_batch_event_url_params(@settings_file, tagkey, tagvalue, user_id) @batch_events_queue.enqueue(impression) end resp = true - elsif is_event_arch_enabled + elsif event_arch_enabled? properties = get_events_base_properties(@settings_file, EventEnum::VWO_SYNC_VISITOR_PROP) payload = get_push_payload_data(@settings_file, user_id, EventEnum::VWO_SYNC_VISITOR_PROP, custom_dimension_map) resp = @event_dispatcher.dispatch_event_arch_post(properties, payload) elsif custom_dimension_map.count == 1 - custom_dimension_map.each do |tag_key, tag_value| - impression = get_url_params(@settings_file, tag_key, tag_value, user_id, @sdk_key) - result[tag_key] = @event_dispatcher.dispatch(impression) - @logger.log( - LogLevelEnum::INFO, - 'IMPRESSION_SUCCESS', - { - '{file}' => FILE, - '{endPoint}' => ApiMethods::PUSH, - '{accountId}' => @settings_file['accountId'], - '{mainKeys}' => JSON.generate({'tags' => impression['tags']}), - } - ) + custom_dimension_map.each do |tagkey, tagvalue| + impression = get_url_params(@settings_file, tagkey, tagvalue, user_id, @sdk_key) + main_keys = { 'tags' => impression['tags'] } + result[tagkey] = @event_dispatcher.dispatch(impression, main_keys, EVENTS::PUSH) end resp = true else - batch_event_data = {"ev" => []} - custom_dimension_map.each do |tag_key, tag_value| - batch_event_data["ev"] << get_batch_event_url_params(@settings_file, tag_key, tag_value, user_id) + batch_event_data = { 'ev' => [] } + custom_dimension_map.each do |tagkey, tagvalue| + batch_event_data['ev'] << get_batch_event_url_params(@settings_file, tagkey, tagvalue, user_id) end paramters = get_batch_event_query_params(@settings_file['accountId'], @sdk_key, @usage_stats.usage_stats) batch_events_dispatcher = VWO::Services::BatchEventsDispatcher.new(@is_development_mode) resp = batch_events_dispatcher.dispatch(batch_event_data, nil, paramters) end - return prepare_push_response(custom_dimension_map, resp, result) + prepare_push_response(custom_dimension_map, resp, result) rescue StandardError => e @logger.log( LogLevelEnum::ERROR, - '({file}): push API error: ' + e.message, - {'{file}' => FILE} + "({file}): push API error: #{e.message}", + { '{file}' => FILE } ) false end - def is_eligible_to_send_impression() + def eligible_to_send_impression? !@user_storage || !@variation_decider.has_stored_variation end # Manually flush impression events to VWO which are queued in batch queue as per batchEvents config - # @return[bool] + # @return[bool] def flush_events @logger.set_api_name(ApiMethods::FLUSH_EVENTS) - if is_opted_out(ApiMethods::FLUSH_EVENTS) - return false - end + return false if opted_out?(ApiMethods::FLUSH_EVENTS) unless @is_instance_valid @logger.log( @@ -1297,7 +1155,7 @@ def flush_events rescue StandardError => e @logger.log( LogLevelEnum::ERROR, - '({file}): {api} API error: ' + e.message, + "({file}): {api} API error: #{e.message}", { '{file}' => FILE, '{api}' => ApiMethods::FLUSH_EVENTS @@ -1309,24 +1167,20 @@ def flush_events def get_goal_type_to_track(options) goal_type_to_track = nil if !options.key?(:goal_type_to_track) - if @goal_type_to_track - goal_type_to_track = @goal_type_to_track - else - goal_type_to_track = GOAL_TYPES['ALL'] - end + goal_type_to_track = @goal_type_to_track || GOAL_TYPES['ALL'] elsif GOAL_TYPES.key? options[:goal_type_to_track] goal_type_to_track = options[:goal_type_to_track] else @logger.log( - LogLevelEnum::ERROR, - 'CONFIG_PARAMETER_INVALID', - { - '{file}' => FILE, - '{parameter}' => 'goal_type_to_track', - '{type}' => 'string(REVENUE, CUSTOM, ALL)', - '{api}' => 'init' - } - ) + LogLevelEnum::ERROR, + 'CONFIG_PARAMETER_INVALID', + { + '{file}' => FILE, + '{parameter}' => 'goal_type_to_track', + '{type}' => 'string(REVENUE, CUSTOM, ALL)', + '{api}' => 'init' + } + ) end goal_type_to_track end @@ -1336,38 +1190,37 @@ def get_goal_type_to_track(options) # return[bool] # def set_opt_out - @logger.set_api_name(ApiMethods::OPT_OUT) - @logger.log( - LogLevelEnum::INFO, - 'OPT_OUT_API_CALLED', - { - '{file}' => FILE - } - ) - if defined?(@batch_events) && !@batch_events_queue.nil? - @batch_events_queue.flush(manual: true) - @batch_events_queue.kill_thread - end + @logger.set_api_name(ApiMethods::OPT_OUT) + @logger.log( + LogLevelEnum::INFO, + 'OPT_OUT_API_CALLED', + { + '{file}' => FILE + } + ) + if defined?(@batch_events) && !@batch_events_queue.nil? + @batch_events_queue.flush(manual: true) + @batch_events_queue.kill_thread + end - @is_opted_out = true - @settings_file = nil - @user_storage = nil - @event_dispatcher = nil - @variation_decider = nil - @config = nil - @usage_stats = nil - @batch_event_dispatcher = nil - @batch_events_queue = nil - @batch_events = nil - - return @is_opted_out + @is_opted_out = true + @settings_file = nil + @user_storage = nil + @event_dispatcher = nil + @variation_decider = nil + @config = nil + @usage_stats = nil + @batch_event_dispatcher = nil + @batch_events_queue = nil + @batch_events = nil + + @is_opted_out end - # Check if VWO SDK is manually opted out # @param[String] :api_name api_name is used in logging # @return[bool] - def is_opted_out(api_name) + def opted_out?(api_name) if @is_opted_out @logger.log( LogLevelEnum::INFO, @@ -1378,10 +1231,10 @@ def is_opted_out(api_name) } ) end - return @is_opted_out + @is_opted_out end - def is_event_arch_enabled - return @settings_file.key?('isEventArchEnabled') && @settings_file['isEventArchEnabled'] + def event_arch_enabled? + @settings_file.key?('isEventArchEnabled') && @settings_file['isEventArchEnabled'] end end diff --git a/lib/vwo/constants.rb b/lib/vwo/constants.rb index d75d511..0837498 100644 --- a/lib/vwo/constants.rb +++ b/lib/vwo/constants.rb @@ -19,7 +19,7 @@ module CONSTANTS SEED_VALUE = 1 MAX_TRAFFIC_PERCENT = 100 MAX_TRAFFIC_VALUE = 10_000 - MAX_RANGE = 10000 + MAX_RANGE = 10_000 STATUS_RUNNING = 'RUNNING' # rubocop:disable Style/ExpandPathArguments LIBRARY_PATH = File.expand_path('../..', __FILE__) @@ -27,7 +27,7 @@ module CONSTANTS HTTP_PROTOCOL = 'http://' HTTPS_PROTOCOL = 'https://' URL_NAMESPACE = '6ba7b811-9dad-11d1-80b4-00c04fd430c8' - SDK_VERSION = '1.36.0' + SDK_VERSION = '1.37.1' SDK_NAME = 'ruby' VWO_DELIMITER = '_vwo_' MAX_EVENTS_PER_REQUEST = 5000 diff --git a/lib/vwo/core/bucketer.rb b/lib/vwo/core/bucketer.rb index f1c6552..a2771b3 100644 --- a/lib/vwo/core/bucketer.rb +++ b/lib/vwo/core/bucketer.rb @@ -31,7 +31,7 @@ class Bucketer # Source - https://stackoverflow.com/a/20766900/2494535 U_MAX_32_BIT = 0xFFFFFFFF MAX_HASH_VALUE = 2**32 - FILE = FileNameEnum::Bucketer + FILE = FileNameEnum::BUCKETER def initialize @logger = VWO::Utils::Logger @@ -49,16 +49,14 @@ def user_part_of_campaign?(user_id, campaign, disable_logs = false) LogLevelEnum::ERROR, 'USER_ID_INVALID', { - '{file}' => FILE, - '{userId}' => user_id + '{file}' => FILE, + '{userId}' => user_id } ) return false end - if campaign.nil? - return false - end + return false if campaign.nil? traffic_allocation = campaign['percentTraffic'] value_assigned_to_user = get_bucket_value_for_user(user_id, campaign, nil, disable_logs) @@ -92,21 +90,17 @@ def bucket_user_to_variation(user_id, campaign, disable_logs = false) LogLevelEnum::ERROR, 'USER_ID_INVALID', { - '{file}' => FILE, - '{userId}' => user_id + '{file}' => FILE, + '{userId}' => user_id } ) return end - unless campaign - return - end + return unless campaign user_id_for_hash_value = user_id - if campaign['isBucketingSeedEnabled'] - user_id_for_hash_value = campaign['id'].to_s + "_" + user_id - end + user_id_for_hash_value = "#{campaign['id']}_#{user_id}" if campaign['isBucketingSeedEnabled'] hash_value = MurmurHash3::V32.str_hash(user_id_for_hash_value, SEED_VALUE) & U_MAX_32_BIT normalize = MAX_TRAFFIC_VALUE.to_f / campaign['percentTraffic'] multiplier = normalize / 100 @@ -120,12 +114,12 @@ def bucket_user_to_variation(user_id, campaign, disable_logs = false) LogLevelEnum::DEBUG, 'USER_CAMPAIGN_BUCKET_VALUES', { - '{file}' => FILE, - '{campaignKey}' => campaign['key'], - '{userId}' => user_id, - '{percentTraffic}' => campaign['percentTraffic'], - '{hashValue}' => hash_value, - '{bucketValue}' => bucket_value, + '{file}' => FILE, + '{campaignKey}' => campaign['key'], + '{userId}' => user_id, + '{percentTraffic}' => campaign['percentTraffic'], + '{hashValue}' => hash_value, + '{bucketValue}' => bucket_value }, disable_logs ) @@ -156,9 +150,9 @@ def get_variation(variations, bucket_value) def get_bucket_value_for_user(user_id, campaign = {}, group_id = nil, disable_logs = false) user_id_for_hash_value = user_id if group_id - user_id_for_hash_value = group_id.to_s + "_" + user_id + user_id_for_hash_value = "#{group_id}_#{user_id}" elsif campaign['isBucketingSeedEnabled'] - user_id_for_hash_value = campaign['id'].to_s + "_" + user_id + user_id_for_hash_value = "#{campaign['id']}_#{user_id}" end hash_value = MurmurHash3::V32.str_hash(user_id_for_hash_value, SEED_VALUE) & U_MAX_32_BIT bucket_value = get_bucket_value(hash_value, MAX_TRAFFIC_PERCENT) @@ -198,11 +192,9 @@ def get_bucket_value(hash_value, max_value, multiplier = 1) # @return[Hash|nil] # def get_campaign_using_range(range_for_campaigns, campaigns) - range_for_campaigns = range_for_campaigns * 100 + range_for_campaigns *= 100 campaigns.each do |campaign| - if campaign["max_range"] && campaign["max_range"] >= range_for_campaigns && campaign["min_range"] <= range_for_campaigns - return campaign - end + return campaign if campaign['max_range'] && campaign['max_range'] >= range_for_campaigns && campaign['min_range'] <= range_for_campaigns end nil end diff --git a/lib/vwo/core/variation_decider.rb b/lib/vwo/core/variation_decider.rb index da82dc2..7b0a842 100644 --- a/lib/vwo/core/variation_decider.rb +++ b/lib/vwo/core/variation_decider.rb @@ -33,7 +33,7 @@ class VariationDecider include VWO::CONSTANTS include VWO::Utils::UUID - FILE = FileNameEnum::VariationDecider + FILE = FileNameEnum::VARIATION_DECIDER # Initializes various services # @param[Hash] - Settings file @@ -66,43 +66,17 @@ def get_variation(user_id, campaign, api_name, campaign_key, custom_variables = return unless campaign - is_campaign_part_of_group = @settings_file && is_part_of_group(@settings_file, campaign["id"]) + is_campaign_part_of_group = @settings_file && part_of_group?(@settings_file, campaign['id']) @has_stored_variation = false - decision = { - :campaign_id => campaign['id'], - :campaign_key => campaign_key, - :campaign_type => campaign['type'], - # campaign segmentation conditions - :custom_variables => custom_variables, - # event name - :event => Hooks::DECISION_TYPES['CAMPAIGN_DECISION'], - # goal tracked in case of track API - :goal_identifier => goal_identifier, - # campaign whitelisting flag - :is_forced_variation_enabled => campaign['isForcedVariationEnabled'] ? campaign['isForcedVariationEnabled'] : false, - :sdk_version => SDK_VERSION, - # API name which triggered the event - :source => api_name, - # Passed in API - :user_id => user_id, - # Campaign Whitelisting conditions - :variation_targeting_variables => variation_targeting_variables, - :is_user_whitelisted => false, - :from_user_storage_service => false, - :is_feature_enabled => true, - # VWO generated UUID based on passed UserId and Account ID - :vwo_user_id => generator_for(user_id, @settings_file['accountId']) - } + decision = initialize_decision_properties(user_id, campaign, api_name, custom_variables, variation_targeting_variables, goal_identifier) - if campaign.has_key?("name") - decision[:campaign_name] = campaign['name'] - end + decision[:campaign_name] = campaign['name'] if campaign.key?('name') if is_campaign_part_of_group - group_id = @settings_file["campaignGroups"][campaign["id"].to_s] + group_id = @settings_file['campaignGroups'][campaign['id'].to_s] decision[:group_id] = group_id - group_name = @settings_file["groups"][group_id.to_s]["name"] + group_name = @settings_file['groups'][group_id.to_s]['name'] decision[:group_name] = group_name end @@ -110,21 +84,17 @@ def get_variation(user_id, campaign, api_name, campaign_key, custom_variables = variation = get_variation_if_whitelisting_passed(user_id, campaign, variation_targeting_variables, api_name, decision, true) return variation if variation && variation['name'] - if campaign.has_key?("isAlwaysCheckSegment") - is_presegmentation = check_presegmentation(campaign, user_id, custom_variables, api_name) - return get_variationIfPreSegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision) + if campaign.key?('isAlwaysCheckSegment') + is_presegmentation = presegmentation?(campaign, user_id, custom_variables, api_name) + return get_variation_if_presegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision) else user_campaign_map = get_user_storage(user_id, campaign_key) variation = get_stored_variation(user_id, campaign_key, user_campaign_map) if valid_hash?(user_campaign_map) + variation = variation.dup if variation # deep copy + if variation - variation = variation.dup # deep copy - end - - if variation - if valid_string?(user_campaign_map['goal_identifier']) && api_name == ApiMethods::TRACK - variation['goal_identifier'] = user_campaign_map['goal_identifier'] - end + variation['goal_identifier'] = user_campaign_map['goal_identifier'] if valid_string?(user_campaign_map['goal_identifier']) && api_name == ApiMethods::TRACK @has_stored_variation = true @logger.log( LogLevelEnum::INFO, @@ -137,16 +107,8 @@ def get_variation(user_id, campaign, api_name, campaign_key, custom_variables = } ) decision[:from_user_storage_service] = !!variation['name'] - if variation - if campaign['type'] == CampaignTypes::VISUAL_AB || campaign['type'] == CampaignTypes::FEATURE_TEST - decision[:variation_name] = variation['name'] - decision[:variation_id] = variation['id'] - if campaign['type'] == CampaignTypes::FEATURE_TEST - decision[:is_feature_enabled] = variation['isFeatureEnabled'] - end - end - @hooks_manager.execute(decision) - end + decision = add_variation_to_decision_properties(decision, campaign, variation) + @hooks_manager.execute(decision) return variation else @logger.log( @@ -158,48 +120,20 @@ def get_variation(user_id, campaign, api_name, campaign_key, custom_variables = '{userId}' => user_id } ) - - if ([ApiMethods::TRACK, ApiMethods::GET_VARIATION_NAME, ApiMethods::GET_FEATURE_VARIABLE_VALUE].include? api_name) && @user_storage_service - @logger.log( - LogLevelEnum::WARNING, - 'CAMPAIGN_NOT_ACTIVATED', - { - '{file}' => FILE, - '{campaignKey}' => campaign_key, - '{userId}' => user_id, - '{api}' => api_name - } - ) - - @logger.log( - LogLevelEnum::INFO, - 'CAMPAIGN_NOT_ACTIVATED', - { - '{file}' => FILE, - '{campaignKey}' => campaign_key, - '{userId}' => user_id, - '{reason}' => api_name == ApiMethods::TRACK ? 'track it' : 'get the decision/value' - } - ) - return - end + + return if campaign_not_activated?(user_id, campaign_key, api_name) end end - - # Pre-segmentation - is_presegmentation = check_presegmentation(campaign, user_id, custom_variables, api_name) + is_presegmentation = presegmentation?(campaign, user_id, custom_variables, api_name) is_presegmentation_and_traffic_passed = is_presegmentation && @bucketer.user_part_of_campaign?(user_id, campaign) - unless is_presegmentation_and_traffic_passed - return nil - end + return nil unless is_presegmentation_and_traffic_passed if is_presegmentation_and_traffic_passed && is_campaign_part_of_group group_campaigns = get_group_campaigns(@settings_file, group_id) if group_campaigns - is_any_campaign_whitelisted_or_stored = check_whitelisting_or_storage_for_grouped_campaigns(user_id, campaign, group_campaigns, group_name, variation_targeting_variables, true) - if is_any_campaign_whitelisted_or_stored + if whitelisting_or_storage_for_grouped_campaigns?(user_id, campaign, group_campaigns, group_name, variation_targeting_variables, true) @logger.log( LogLevelEnum::INFO, 'MEG_CALLED_CAMPAIGN_NOT_WINNER', @@ -207,7 +141,7 @@ def get_variation(user_id, campaign, api_name, campaign_key, custom_variables = '{file}' => FILE, '{campaignKey}' => campaign_key, '{userId}' => user_id, - '{groupName}' => group_name, + '{groupName}' => group_name } ) return nil @@ -220,8 +154,8 @@ def get_variation(user_id, campaign, api_name, campaign_key, custom_variables = { '{file}' => FILE, '{userId}' => user_id, - '{eligibleCampaignKeys}' => get_eligible_campaigns_key(eligible_campaigns).join(","), - '{inEligibleText}' => non_eligible_campaigns_key ? ("campaigns:" + non_eligible_campaigns_key.join("'")) : "no campaigns", + '{eligibleCampaignKeys}' => get_eligible_campaigns_key(eligible_campaigns).join(','), + '{inEligibleText}' => non_eligible_campaigns_key ? "campaigns: + #{non_eligible_campaigns_key.join("'")}" : 'no campaigns', '{groupName}' => group_name } ) @@ -245,47 +179,123 @@ def get_variation(user_id, campaign, api_name, campaign_key, custom_variables = { '{file}' => FILE, '{userId}' => user_id, - '{campaignKey}' => winner_campaign["key"], - '{groupName}' => group_name, + '{campaignKey}' => winner_campaign['key'], + '{groupName}' => group_name } ) - if winner_campaign && winner_campaign["id"] == campaign["id"] - variation = get_variation_allotted(user_id, campaign, true) - if variation && variation['name'] - save_user_storage(user_id, campaign_key, campaign['type'], variation['name'], goal_identifier, true) if variation['name'] - else - return nil - end - else - @logger.log( - LogLevelEnum::INFO, - 'MEG_CALLED_CAMPAIGN_NOT_WINNER', - { - '{file}' => FILE, - '{campaignKey}' => campaign_key, - '{userId}' => user_id, - '{groupName}' => group_name, - } - ) - return nil - end + return if meg_called_campaign_not_winner?(user_id, group_name, campaign, winner_campaign) + + variation = get_variation_allotted(user_id, campaign, true) + return nil unless variation && variation['name'] + + save_user_storage(user_id, campaign_key, campaign['type'], variation['name'], goal_identifier, true) if variation['name'] end end - if variation - if campaign['type'] == CampaignTypes::VISUAL_AB || campaign['type'] == CampaignTypes::FEATURE_TEST - decision[:variation_name] = variation['name'] - decision[:variation_id] = variation['id'] - if campaign['type'] == CampaignTypes::FEATURE_TEST - decision[:is_feature_enabled] = variation['isFeatureEnabled'] - end - end - @hooks_manager.execute(decision) - return variation + variation ||= get_variation_if_presegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision) + return unless variation + + decision = add_variation_to_decision_properties(decision, campaign, variation) + @hooks_manager.execute(decision) + variation + end + + def campaign_not_activated?(user_id, campaign_key, api_name) + if ([ApiMethods::TRACK, ApiMethods::GET_VARIATION_NAME, ApiMethods::GET_FEATURE_VARIABLE_VALUE].include? api_name) && @user_storage_service + @logger.log( + LogLevelEnum::WARNING, + 'CAMPAIGN_NOT_ACTIVATED', + { + '{file}' => FILE, + '{campaignKey}' => campaign_key, + '{userId}' => user_id, + '{api}' => api_name + } + ) + + @logger.log( + LogLevelEnum::INFO, + 'CAMPAIGN_NOT_ACTIVATED', + { + '{file}' => FILE, + '{campaignKey}' => campaign_key, + '{userId}' => user_id, + '{reason}' => api_name == ApiMethods::TRACK ? 'track it' : 'get the decision/value' + } + ) + return true + end + false + end + + def meg_called_campaign_not_winner?(user_id, group_name, campaign, winner_campaign) + unless winner_campaign && winner_campaign['id'] == campaign['id'] + @logger.log( + LogLevelEnum::INFO, + 'MEG_CALLED_CAMPAIGN_NOT_WINNER', + { + '{file}' => FILE, + '{campaignKey}' => campaign['key'], + '{userId}' => user_id, + '{groupName}' => group_name + } + ) + return true end + false + end - return get_variationIfPreSegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision) + # Intitialize decision properties for hook manager + # + # @param[String] :user_id The unique ID assigned to User + # @param[Hash] :campaign Campaign hash itself + # @param[String] :api_name Name of the current api call + # @param[String] :goal_identifier The unique campaign's goal identifier + # @param[Hash] :custom_variables Key/value pair for segmentation + # @param[Hash] :variation_targeting_variables Key/value pair for whitelisting + # @return[Hash] Decision properties for the callback by hook manager + def initialize_decision_properties(user_id, campaign, api_name, custom_variables = {}, variation_targeting_variables = {}, goal_identifier = '') + { + campaign_id: campaign['id'], + campaign_key: campaign['key'], + campaign_type: campaign['type'], + # campaign segmentation conditions + custom_variables: custom_variables, + # event name + event: Hooks::DECISION_TYPES['CAMPAIGN_DECISION'], + # goal tracked in case of track API + goal_identifier: goal_identifier, + # campaign whitelisting flag + is_forced_variation_enabled: campaign['isForcedVariationEnabled'] || false, + sdk_version: SDK_VERSION, + # API name which triggered the event + source: api_name, + # Passed in API + user_id: user_id, + # Campaign Whitelisting conditions + variation_targeting_variables: variation_targeting_variables, + is_user_whitelisted: false, + from_user_storage_service: false, + is_feature_enabled: true, + # VWO generated UUID based on passed UserId and Account ID + vwo_user_id: generator_for(user_id, @settings_file['accountId']) + } + end + + # Add variation details to decision properties for hook manager + # + # @param[Hash] :campaign Campaign details + # @param[Hash] :variation Variation assigned to user + # @param[Hash] :decision Decision properties + # @return[Hash] :decision Decision properties + def add_variation_to_decision_properties(decision, campaign, variation) + if campaign['type'] == CampaignTypes::VISUAL_AB || campaign['type'] == CampaignTypes::FEATURE_TEST + decision[:variation_name] = variation['name'] + decision[:variation_id] = variation['id'] + end + decision[:is_feature_enabled] = variation['isFeatureEnabled'] if campaign['type'] == CampaignTypes::FEATURE_TEST + decision end # Get variation by murmur logic if pre segmentation pass @@ -297,10 +307,9 @@ def get_variation(user_id, campaign, api_name, campaign_key, custom_variables = # @param[Hash] :decision data containing campaign info passed to hooks manager # # @return[Hash] - def get_variationIfPreSegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision) - unless is_presegmentation - return nil - end + def get_variation_if_presegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision) + return nil unless is_presegmentation + campaign_key = campaign['key'] variation = get_variation_allotted(user_id, campaign) if variation && variation['name'] @@ -318,13 +327,7 @@ def get_variationIfPreSegmentation_applied(is_presegmentation, campaign, user_id end if variation - if campaign['type'] == CampaignTypes::VISUAL_AB || campaign['type'] == CampaignTypes::FEATURE_TEST - decision[:variation_name] = variation['name'] - decision[:variation_id] = variation['id'] - if campaign['type'] == CampaignTypes::FEATURE_TEST - decision[:is_feature_enabled] = variation['isFeatureEnabled'] - end - end + decision = add_variation_to_decision_properties(decision, campaign, variation) @hooks_manager.execute(decision) end variation @@ -352,8 +355,8 @@ def get_variation_allotted(user_id, campaign, disable_logs = false) end if @bucketer.user_part_of_campaign?(user_id, campaign, true) - variation = get_variation_of_campaign_for_user(user_id, campaign, disable_logs) - variation + get_variation_of_campaign_for_user(user_id, campaign, disable_logs) + else # not part of campaign @logger.log( @@ -385,7 +388,7 @@ def get_variation_of_campaign_for_user(user_id, campaign, disable_logs = false) 'USER_VARIATION_ALLOCATION_STATUS', { '{file}' => FILE, - '{status}' => variation ? 'got variation:' + variation['name'] : 'did not get any variation', + '{status}' => variation ? "got variation: + #{variation['name']}" : 'did not get any variation', '{userId}' => user_id, '{campaignKey}' => campaign['key'] }, @@ -418,12 +421,12 @@ def get_variation_of_campaign_for_user(user_id, campaign, disable_logs = false) # @param[Boolean] :disable_logs optional: disable logs if True # @return[Boolean] true if found otherwise false - def save_user_storage(user_id, campaign_key, campaign_type, variation_name, goal_identifier, disable_logs = false) + def save_user_storage(user_id, campaign_key, _campaign_type, variation_name, goal_identifier, disable_logs = false) unless @user_storage_service @logger.log( LogLevelEnum::DEBUG, 'USER_STORAGE_SERVICE_NOT_CONFIGURED', - {'{file}' => FILE}, + { '{file}' => FILE }, disable_logs ) return false @@ -432,9 +435,7 @@ def save_user_storage(user_id, campaign_key, campaign_type, variation_name, goal new_campaign_user_mapping['campaign_key'] = campaign_key new_campaign_user_mapping['user_id'] = user_id new_campaign_user_mapping['variation_name'] = variation_name - if !goal_identifier.empty? - new_campaign_user_mapping['goal_identifier'] = goal_identifier - end + new_campaign_user_mapping['goal_identifier'] = goal_identifier unless goal_identifier.empty? @user_storage_service.set(new_campaign_user_mapping) @@ -463,6 +464,12 @@ def save_user_storage(user_id, campaign_key, campaign_type, variation_name, goal false end + def update_goal_identifier(user_id, campaign, variation, goal_identifier) + updated_goal_identifier = variation['goal_identifier'] + updated_goal_identifier += VWO_DELIMITER + goal_identifier + save_user_storage(user_id, campaign['key'], campaign['name'], variation['name'], updated_goal_identifier) if variation['name'] + end + private # Evaluate all the variations in the campaign to find @@ -476,20 +483,18 @@ def save_user_storage(user_id, campaign_key, campaign_type, variation_name, goal # # @return[Hash] - def evaluate_whitelisting(user_id, campaign, api_name, campaign_key, variation_targeting_variables = {}, disable_logs = false) - if campaign.key?('isUserListEnabled') && campaign["isUserListEnabled"] + def evaluate_whitelisting(user_id, campaign, _api_name, campaign_key, variation_targeting_variables = {}, disable_logs = false) + if campaign.key?('isUserListEnabled') && campaign['isUserListEnabled'] vwo_user_id = generator_for(user_id, @settings_file['accountId'], true) if variation_targeting_variables.nil? variation_targeting_variables = { _vwo_user_id: vwo_user_id } else variation_targeting_variables[:_vwo_user_id] = vwo_user_id end + elsif variation_targeting_variables.nil? + variation_targeting_variables = { _vwo_user_id: user_id } else - if variation_targeting_variables.nil? - variation_targeting_variables = { _vwo_user_id: user_id } - else - variation_targeting_variables[:_vwo_user_id] = user_id - end + variation_targeting_variables[:_vwo_user_id] = user_id end targeted_variations = [] @@ -513,7 +518,11 @@ def evaluate_whitelisting(user_id, campaign, api_name, campaign_key, variation_t '{customVariables}' => variation_targeting_variables, '{status}' => status, '{segmentationType}' => SegmentationTypeEnum::WHITELISTING, - '{variation}' => status == StatusEnum::PASSED ? (campaign['type'] == CampaignTypes::FEATURE_ROLLOUT ? 'and hence becomes part of the rollout' : variation['name'] + ' and hence becomes part of the rollout') : '', + '{variation}' => if status == StatusEnum::PASSED + campaign['type'] == CampaignTypes::FEATURE_ROLLOUT ? 'and hence becomes part of the rollout' : "#{variation['name']} and hence becomes part of the rollout" + else + '' + end }, disable_logs ) @@ -525,7 +534,7 @@ def evaluate_whitelisting(user_id, campaign, api_name, campaign_key, variation_t '{file}' => FILE, '{campaignKey}' => campaign_key, '{userId}' => user_id, - '{variation}' => campaign['type'] == CampaignTypes::FEATURE_ROLLOUT ? '' : 'for variation:' + variation['name'] + '{variation}' => campaign['type'] == CampaignTypes::FEATURE_ROLLOUT ? '' : "for variation:#{variation['name']}" }, disable_logs ) @@ -582,7 +591,7 @@ def scale_variation_weights(variations) end def scale_campaigns_weight(campaigns) - normalize_weight = 100/campaigns.length + normalize_weight = 100 / campaigns.length campaigns.each do |campaign| campaign['weight'] = normalize_weight end @@ -600,7 +609,7 @@ def get_user_storage(user_id, campaign_key, disable_logs = false) @logger.log( LogLevelEnum::DEBUG, 'USER_STORAGE_SERVICE_NOT_CONFIGURED', - {'{file}' => FILE}, + { '{file}' => FILE }, disable_logs ) return false @@ -643,7 +652,7 @@ def get_user_storage(user_id, campaign_key, disable_logs = false) # # @return[Object, nil] if found then variation settings object otherwise None - def get_stored_variation(user_id, campaign_key, user_campaign_map, disable_logs = false) + def get_stored_variation(_user_id, campaign_key, user_campaign_map, _disable_logs = false) return unless user_campaign_map['campaign_key'] == campaign_key variation_name = user_campaign_map['variation_name'] @@ -664,15 +673,13 @@ def get_stored_variation(user_id, campaign_key, user_campaign_map, disable_logs # @param[Boolean] :disable_logs optional: disable logs if True # # @return[Boolean] - def check_presegmentation(campaign, user_id, custom_variables, api_name, disable_logs = false) + def presegmentation?(campaign, user_id, custom_variables, _api_name, disable_logs = false) campaign_key = campaign['key'] segments = get_segments(campaign) is_valid_segments = valid_value?(segments) if is_valid_segments - unless custom_variables - custom_variables = {} - end + custom_variables ||= {} response = @segment_evaluator.evaluate(campaign_key, user_id, segments, custom_variables, disable_logs) @logger.log( LogLevelEnum::INFO, @@ -732,11 +739,11 @@ def get_eligible_campaigns(user_id, group_campaigns, called_campaign, custom_var eligible_campaigns = [] group_campaigns.each do |campaign| - if called_campaign["id"] == campaign["id"] || check_presegmentation(campaign, user_id, custom_variables, '', true) && @bucketer.user_part_of_campaign?(user_id, campaign, true) + if called_campaign['id'] == campaign['id'] || presegmentation?(campaign, user_id, custom_variables, '', true) && @bucketer.user_part_of_campaign?(user_id, campaign, true) eligible_campaigns.push(campaign) end end - return eligible_campaigns + eligible_campaigns end # Finds and returns the winner campaign from eligible_campaigns list. @@ -746,14 +753,12 @@ def get_eligible_campaigns(user_id, group_campaigns, called_campaign, custom_var # # @return[Hash] def get_winner_campaign(user_id, eligible_campaigns, group_id) - if eligible_campaigns.length == 1 - return eligible_campaigns[0] - end + return eligible_campaigns[0] if eligible_campaigns.length == 1 eligible_campaigns = scale_campaigns_weight(eligible_campaigns) eligible_campaigns = set_campaign_allocation(eligible_campaigns) bucket_value = @bucketer.get_bucket_value_for_user(user_id, {}, group_id, true) - return @bucketer.get_campaign_using_range(bucket_value, eligible_campaigns) + @bucketer.get_campaign_using_range(bucket_value, eligible_campaigns) end # Get campaign keys of all eligible Campaigns. @@ -764,7 +769,7 @@ def get_winner_campaign(user_id, eligible_campaigns, group_id) def get_eligible_campaigns_key(eligible_campaigns) eligible_campaigns_key = [] eligible_campaigns.each do |campaign| - eligible_campaigns_key.push(campaign["key"]) + eligible_campaigns_key.push(campaign['key']) end eligible_campaigns_key end @@ -778,9 +783,7 @@ def get_eligible_campaigns_key(eligible_campaigns) def get_non_eligible_campaigns_key(eligible_campaigns, group_campaigns) non_eligible_campaigns_key = [] group_campaigns.each do |campaign| - unless eligible_campaigns.include? campaign - non_eligible_campaigns_key.push(campaign["key"]) - end + non_eligible_campaigns_key.push(campaign['key']) unless eligible_campaigns.include? campaign end non_eligible_campaigns_key end @@ -795,54 +798,54 @@ def get_non_eligible_campaigns_key(eligible_campaigns, group_campaigns) # @param[Boolean] :disable_logs optional: disable logs if True # @return[Boolean] - def check_whitelisting_or_storage_for_grouped_campaigns(user_id, called_campaign, group_campaigns, group_name, variation_targeting_variables, disable_logs = false) + def whitelisting_or_storage_for_grouped_campaigns?(user_id, called_campaign, group_campaigns, group_name, variation_targeting_variables, disable_logs = false) group_campaigns.each do |campaign| - if called_campaign["id"] != campaign["id"] - targeted_variation = evaluate_whitelisting( - user_id, - campaign, - '', - campaign["key"], - variation_targeting_variables, - true - ) - if targeted_variation - @logger.log( - LogLevelEnum::INFO, - 'OTHER_CAMPAIGN_SATISFIES_WHITELISTING_STORAGE', - { - '{file}' => FILE, - '{campaignKey}' => campaign["key"], - '{userId}' => user_id, - '{groupName}' => group_name, - '{type}' => "whitelisting" - }, - disable_logs - ) - return true - end - end + next unless called_campaign['id'] != campaign['id'] + + targeted_variation = evaluate_whitelisting( + user_id, + campaign, + '', + campaign['key'], + variation_targeting_variables, + true + ) + next unless targeted_variation + + @logger.log( + LogLevelEnum::INFO, + 'OTHER_CAMPAIGN_SATISFIES_WHITELISTING_STORAGE', + { + '{file}' => FILE, + '{campaignKey}' => campaign['key'], + '{userId}' => user_id, + '{groupName}' => group_name, + '{type}' => 'whitelisting' + }, + disable_logs + ) + return true end group_campaigns.each do |campaign| - if called_campaign["id"] != campaign["id"] - user_storage_data = get_user_storage(user_id, campaign["key"], true) - if user_storage_data - @logger.log( - LogLevelEnum::INFO, - 'OTHER_CAMPAIGN_SATISFIES_WHITELISTING_STORAGE', - { - '{file}' => FILE, - '{campaignKey}' => campaign["key"], - '{userId}' => user_id, - '{groupName}' => group_name, - '{type}' => "user storag" - }, - disable_logs - ) - return true - end - end + next unless called_campaign['id'] != campaign['id'] + + user_storage_data = get_user_storage(user_id, campaign['key'], true) + next unless user_storage_data + + @logger.log( + LogLevelEnum::INFO, + 'OTHER_CAMPAIGN_SATISFIES_WHITELISTING_STORAGE', + { + '{file}' => FILE, + '{campaignKey}' => campaign['key'], + '{userId}' => user_id, + '{groupName}' => group_name, + '{type}' => 'user storag' + }, + disable_logs + ) + return true end false end @@ -880,22 +883,16 @@ def get_variation_if_whitelisting_passed(user_id, campaign, variation_targeting_ '{file}' => FILE, '{campaignKey}' => campaign_key, '{userId}' => user_id, - '{customVariables}' => variation_targeting_variables ? variation_targeting_variables : {}, + '{customVariables}' => variation_targeting_variables || {}, '{status}' => status, '{segmentationType}' => SegmentationTypeEnum::WHITELISTING, - '{variation}' => (status == StatusEnum::PASSED && campaign['type'] != CampaignTypes::FEATURE_ROLLOUT) ? "for variation:#{variation['name']}" : ' ' + '{variation}' => status == StatusEnum::PASSED && campaign['type'] != CampaignTypes::FEATURE_ROLLOUT ? "for variation:#{variation['name']}" : ' ' }, disable_logs ) if variation - if campaign['type'] == CampaignTypes::VISUAL_AB || campaign['type'] == CampaignTypes::FEATURE_TEST - decision[:variation_name] = variation['name'] - decision[:variation_id] = variation['id'] - if campaign['type'] == CampaignTypes::FEATURE_TEST - decision[:is_feature_enabled] = variation['isFeatureEnabled'] - end - end + decision = add_variation_to_decision_properties(decision, campaign, variation) decision[:is_user_whitelisted] = true @hooks_manager.execute(decision) end @@ -917,7 +914,6 @@ def get_variation_if_whitelisting_passed(user_id, campaign, variation_targeting_ end nil end - end end end diff --git a/lib/vwo/enums.rb b/lib/vwo/enums.rb index 0ab0e81..ed540b4 100644 --- a/lib/vwo/enums.rb +++ b/lib/vwo/enums.rb @@ -12,8 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. -# rubocop:disable Metrics/LineLength - require 'logger' class VWO @@ -64,23 +62,23 @@ module FileNameEnum VWO_PATH = 'vwo' UTIL_PATH = 'vwo/utils' - VWO = VWO_PATH + '/vwo' - Bucketer = VWO_PATH + '/core/bucketer' - VariationDecider = VWO_PATH + '/core/variation_decider' - EventDispatcher = VWO_PATH + '/services/event_dispatcher' - SegmentEvaluator = VWO_PATH + '/services/segment_evaluator' - Logger = VWO_PATH + '/logger' - SettingsFileProcessor = VWO_PATH + '/services/settings_file_processor' - BatchEventsQueue = VWO_PATH + '/services/batch_events_queue' - BatchEventsDispatcher = VWO_PATH + '/services/batch_events_dispatcher' + VWO = "#{VWO_PATH}/vwo" + BUCKETER = "#{VWO_PATH}/core/bucketer" + VARIATION_DECIDER = "#{VWO_PATH}/core/variation_decider" + EVENT_DISPATCHER = "#{VWO_PATH}/services/event_dispatcher" + SEGMENT_EVALUATOR = "#{VWO_PATH}/services/segment_evaluator" + LOGGER = "#{VWO_PATH}/logger" + SETTINGS_FILE_PROCESSOR = "#{VWO_PATH}/services/settings_file_processor" + BATCH_EVENTS_QUEUE = "#{VWO_PATH}/services/batch_events_queue" + BATCH_EVENTS_DISPATCHER = "#{VWO_PATH}/services/batch_events_dispatcher" - CampaignUtil = UTIL_PATH + '/campaign' - FunctionUtil = UTIL_PATH + '/function' - FeatureUtil = UTIL_PATH + '/feature' - ImpressionUtil = UTIL_PATH + '/impression' - UuidUtil = UTIL_PATH + '/uuid' - ValidateUtil = UTIL_PATH + '/validations' - CustomDimensionsUtil = UTIL_PATH + '/custom_dimensions_util' + CAMPAIGN_UTIL = "#{UTIL_PATH}/campaign" + FUNCTION_UTIL = "#{UTIL_PATH}/function" + FEATURE_UTIL = "#{UTIL_PATH}/feature" + IMPRESSION_UTIL = "#{UTIL_PATH}/impression" + UUID_UTIL = "#{UTIL_PATH}/uuid" + VALIDATE_UTIL = "#{UTIL_PATH}/validations" + CUSTOM_DIMENSTIONS_UTIL = "#{UTIL_PATH}/custom_dimensions_util" end module LogLevelEnum @@ -91,4 +89,3 @@ module LogLevelEnum end end end -# rubocop:enable Metrics/LineLength diff --git a/lib/vwo/logger.rb b/lib/vwo/logger.rb index afca72c..38969b7 100644 --- a/lib/vwo/logger.rb +++ b/lib/vwo/logger.rb @@ -16,7 +16,6 @@ class VWO class Logger - DEBUG = ::Logger::DEBUG INFO = ::Logger::INFO ERROR = ::Logger::ERROR @@ -30,12 +29,12 @@ def self.get_instance(logger_instance = nil) end def initialize(logger_instance) - @@logger_instance = logger_instance || ::Logger.new(STDOUT) + @@logger_instance = logger_instance || ::Logger.new($stdout) end # Override this method to handle logs in a custom manner def log(level, message) - @@logger_instance.log(level, message) + @@logger_instance.log(level, message) end def instance diff --git a/lib/vwo/schemas/settings_file.rb b/lib/vwo/schemas/settings_file.rb index 0ebc471..84c563d 100644 --- a/lib/vwo/schemas/settings_file.rb +++ b/lib/vwo/schemas/settings_file.rb @@ -61,12 +61,12 @@ module Schema weight: { type: %w[number string] }, - variables: { - type: 'array', - items: { - '$ref' => '#/definitions/variables_schema' - } - } + variables: { + type: 'array', + items: { + '$ref' => '#/definitions/variables_schema' + } + } }, required: %w[id name weight] }, diff --git a/lib/vwo/services/batch_events_dispatcher.rb b/lib/vwo/services/batch_events_dispatcher.rb index ee49c6b..daef8d0 100644 --- a/lib/vwo/services/batch_events_dispatcher.rb +++ b/lib/vwo/services/batch_events_dispatcher.rb @@ -42,25 +42,26 @@ def dispatch(impression, callback, query_params) url = CONSTANTS::HTTPS_PROTOCOL + get_url(CONSTANTS::ENDPOINTS::BATCH_EVENTS) account_id = query_params[:a] resp = VWO::Utils::Request.post(url, query_params, impression) - if resp.code == '200' + case resp.code + when '200' @logger.log( LogLevelEnum::INFO, 'IMPRESSION_BATCH_SUCCESS', { '{file}' => FILE, '{endPoint}' => url, - '{accountId}' => account_id, + '{accountId}' => account_id } ) message = nil - elsif resp.code == '413' + when '413' @logger.log( LogLevelEnum::DEBUG, 'CONFIG_BATCH_EVENT_LIMIT_EXCEEDED', { - '{file}' => FileNameEnum::BatchEventsDispatcher, + '{file}' => FileNameEnum::BATCH_EVENTS_DISPATCHER, '{endPoint}' => url, - '{eventsPerRequest}' => impression.length(), + '{eventsPerRequest}' => impression.length, '{accountId}' => impression[:a] } ) @@ -69,7 +70,7 @@ def dispatch(impression, callback, query_params) LogLevelEnum::ERROR, 'IMPRESSION_FAILED', { - '{file}' => FileNameEnum::BatchEventsDispatcher, + '{file}' => FileNameEnum::BATCH_EVENTS_DISPATCHER, '{err}' => resp.message, '{endPoint}' => url } @@ -79,43 +80,40 @@ def dispatch(impression, callback, query_params) @logger.log( LogLevelEnum::INFO, 'IMPRESSION_BATCH_FAILED', - {'{file}' => FileNameEnum::BatchEventsDispatcher} + { '{file}' => FileNameEnum::BATCH_EVENTS_DISPATCHER } ) @logger.log( LogLevelEnum::ERROR, 'IMPRESSION_FAILED', { - '{file}' => FileNameEnum::BatchEventsDispatcher, + '{file}' => FileNameEnum::BATCH_EVENTS_DISPATCHER, '{err}' => resp.message, '{endPoint}' => url } ) message = resp.message end - if callback - callback.call(message, impression) - end + callback&.call(message, impression) true rescue StandardError => e @logger.log( LogLevelEnum::DEBUG, 'IMPRESSION_BATCH_FAILED', - {'{file}' => FileNameEnum::BatchEventsDispatcher} + { '{file}' => FileNameEnum::BATCH_EVENTS_DISPATCHER } ) @logger.log( - LogLevelEnum::ERROR, - 'IMPRESSION_FAILED', - { - '{file}' => FileNameEnum::BatchEventsDispatcher, - '{err}' => e.message, - '{endPoint}' => url - } - ) + LogLevelEnum::ERROR, + 'IMPRESSION_FAILED', + { + '{file}' => FileNameEnum::BATCH_EVENTS_DISPATCHER, + '{err}' => e.message, + '{endPoint}' => url + } + ) false end - end end end diff --git a/lib/vwo/services/batch_events_queue.rb b/lib/vwo/services/batch_events_queue.rb index a90bed8..7b14415 100644 --- a/lib/vwo/services/batch_events_queue.rb +++ b/lib/vwo/services/batch_events_queue.rb @@ -36,9 +36,9 @@ def initialize(batch_config, is_development_mode = false) LogLevelEnum::INFO, 'EVENT_BATCH_DEFAULTS', { - '{file}' => FileNameEnum::BatchEventsQueue, + '{file}' => FileNameEnum::BATCH_EVENTS_QUEUE, '{parameter}' => 'request_time_interval', - '{defaultValue}' => @request_time_interval.to_s + ' ms' + '{defaultValue}' => "#{@request_time_interval} ms" } ) end @@ -51,7 +51,7 @@ def initialize(batch_config, is_development_mode = false) LogLevelEnum::INFO, 'EVENT_BATCH_DEFAULTS', { - '{file}' => FileNameEnum::BatchEventsQueue, + '{file}' => FileNameEnum::BATCH_EVENTS_QUEUE, '{parameter}' => 'events_per_request', '{defaultValue}' => @events_per_request.to_s } @@ -59,9 +59,7 @@ def initialize(batch_config, is_development_mode = false) end @flush_callback = nil - if batch_config.key?(:flushCallback) && batch_config[:flushCallback].is_a?(Method) - @flush_callback = batch_config[:flushCallback] - end + @flush_callback = batch_config[:flushCallback] if batch_config.key?(:flushCallback) && batch_config[:flushCallback].is_a?(Method) @dispatcher = batch_config[:dispatcher] end @@ -72,35 +70,34 @@ def create_new_batch_timer def enqueue(event) return true if @is_development_mode + @queue.push(event) update_queue_metadata(event) unless @timer create_new_batch_timer - @thread = Thread.new{flush_when_request_times_up} - end - if @events_per_request === @queue.length() - flush - kill_old_thread + @thread = Thread.new { flush_when_request_times_up } end + return unless @events_per_request == @queue.length + + flush + kill_old_thread end def flush_when_request_times_up - while @timer > Time.now - sleep(1) - end + sleep(1) while @timer > Time.now flush kill_old_thread end def flush(manual = false) - if @queue.length() > 0 + if @queue.length > 0 @logger.log( LogLevelEnum::DEBUG, 'EVENT_BATCH_BEFORE_FLUSHING', { - '{file}' => FileNameEnum::BatchEventsQueue, + '{file}' => FileNameEnum::BATCH_EVENTS_QUEUE, '{manually}' => manual ? 'manually' : '', - '{length}' => @queue.length(), + '{length}' => @queue.length, '{timer}' => manual ? 'Timer will be cleared and registered again,' : '', '{accountId}' => @batch_config[:account_id] } @@ -112,9 +109,9 @@ def flush(manual = false) LogLevelEnum::INFO, 'EVENT_BATCH_After_FLUSHING', { - '{file}' => FileNameEnum::BatchEventsQueue, + '{file}' => FileNameEnum::BATCH_EVENTS_QUEUE, '{manually}' => manual ? 'manually,' : '', - '{length}' => @queue.length() + '{length}' => @queue.length } ) @queue_metadata = {} @@ -123,16 +120,12 @@ def flush(manual = false) @logger.log( LogLevelEnum::INFO, 'Batch queue is empty. Nothing to flush.', - {'{file}' => FILE} + { '{file}' => FILE } ) end clear_request_timer - unless manual - if @thread - @old_thread = @thread - end - end + @old_thread = @thread if !manual && @thread true end @@ -141,32 +134,23 @@ def clear_request_timer end def kill_thread - if @thread - @thread.kill - end + @thread&.kill end def kill_old_thread - if @old_thread - @old_thread.kill - end + @old_thread&.kill end def update_queue_metadata(event) - if event[:eT] == 1 - unless @queue_metadata.key?(VWO::EVENTS::TRACK_USER) - @queue_metadata[VWO::EVENTS::TRACK_USER] = 0 - end + case event[:eT] + when 1 + @queue_metadata[VWO::EVENTS::TRACK_USER] = 0 unless @queue_metadata.key?(VWO::EVENTS::TRACK_USER) @queue_metadata[VWO::EVENTS::TRACK_USER] = @queue_metadata[VWO::EVENTS::TRACK_USER] + 1 - elsif event[:eT] == 2 - unless @queue_metadata.key?(VWO::EVENTS::TRACK_GOAL) - @queue_metadata[VWO::EVENTS::TRACK_GOAL] = 0 - end + when 2 + @queue_metadata[VWO::EVENTS::TRACK_GOAL] = 0 unless @queue_metadata.key?(VWO::EVENTS::TRACK_GOAL) @queue_metadata[VWO::EVENTS::TRACK_GOAL] = @queue_metadata[VWO::EVENTS::TRACK_GOAL] + 1 - elsif event[:eT] == 3 - unless @queue_metadata.key?(VWO::EVENTS::PUSH) - @queue_metadata[VWO::EVENTS::PUSH] = 0 - end + when 3 + @queue_metadata[VWO::EVENTS::PUSH] = 0 unless @queue_metadata.key?(VWO::EVENTS::PUSH) @queue_metadata[VWO::EVENTS::PUSH] = @queue_metadata[VWO::EVENTS::PUSH] + 1 end end diff --git a/lib/vwo/services/event_dispatcher.rb b/lib/vwo/services/event_dispatcher.rb index 5bd88fd..452c480 100644 --- a/lib/vwo/services/event_dispatcher.rb +++ b/lib/vwo/services/event_dispatcher.rb @@ -43,7 +43,7 @@ def initialize(is_development_mode = false) # the request to be dispatched to the VWO server # @return[Boolean] # - def dispatch(impression) + def dispatch(impression, main_keys, end_point) return true if @is_development_mode modified_event = impression.reject do |key, _value| @@ -52,13 +52,23 @@ def dispatch(impression) resp = VWO::Utils::Request.get(impression['url'], modified_event) if resp.code == '200' + @logger.log( + LogLevelEnum::INFO, + 'IMPRESSION_SUCCESS', + { + '{file}' => FILE, + '{endPoint}' => end_point, + '{accountId}' => impression['account_id'] || impression[:account_id], + '{mainKeys}' => JSON.generate(main_keys) + } + ) true else @logger.log( LogLevelEnum::ERROR, 'IMPRESSION_FAILED', { - '{file}' => FileNameEnum::BatchEventsDispatcher, + '{file}' => FileNameEnum::BATCH_EVENTS_DISPATCHER, '{err}' => resp.message, '{endPoint}' => impression['url'] } @@ -67,14 +77,14 @@ def dispatch(impression) end rescue StandardError => e @logger.log( - LogLevelEnum::ERROR, - 'IMPRESSION_FAILED', - { - '{file}' => FileNameEnum::BatchEventsDispatcher, - '{err}' => e.message, - '{endPoint}' => impression['url'] - } - ) + LogLevelEnum::ERROR, + 'IMPRESSION_FAILED', + { + '{file}' => FileNameEnum::BATCH_EVENTS_DISPATCHER, + '{err}' => e.message, + '{endPoint}' => impression['url'] + } + ) false end @@ -88,8 +98,8 @@ def dispatch_event_arch_post(params, post_data) LogLevelEnum::INFO, 'IMPRESSION_SUCCESS_FOR_EVENT_ARCH', { - '{file}' => FileNameEnum::BatchEventsDispatcher, - '{event}' => 'visitor property:' + JSON.generate(post_data[:d][:visitor][:props]), + '{file}' => FileNameEnum::BATCH_EVENTS_DISPATCHER, + '{event}' => "visitor property:#{JSON.generate(post_data[:d][:visitor][:props])}", '{endPoint}' => url, '{accountId}' => params[:a] } @@ -100,7 +110,7 @@ def dispatch_event_arch_post(params, post_data) LogLevelEnum::ERROR, 'IMPRESSION_FAILED', { - '{file}' => FileNameEnum::EventDispatcher, + '{file}' => FileNameEnum::EVENT_DISPATCHER, '{err}' => resp.message, '{endPoint}' => url } @@ -109,14 +119,14 @@ def dispatch_event_arch_post(params, post_data) end rescue StandardError => e @logger.log( - LogLevelEnum::ERROR, - 'IMPRESSION_FAILED', - { - '{file}' => FileNameEnum::EventDispatcher, - '{err}' => e.message, - '{endPoint}' => url - } - ) + LogLevelEnum::ERROR, + 'IMPRESSION_FAILED', + { + '{file}' => FileNameEnum::EVENT_DISPATCHER, + '{err}' => e.message, + '{endPoint}' => url + } + ) false end end diff --git a/lib/vwo/services/hooks_manager.rb b/lib/vwo/services/hooks_manager.rb index d71b854..e365014 100644 --- a/lib/vwo/services/hooks_manager.rb +++ b/lib/vwo/services/hooks_manager.rb @@ -15,22 +15,18 @@ class VWO module Services class HooksManager - # Hooks Manager is responsible for triggering callbacks useful to the end-user based on certain lifecycle events. - # Possible use with integrations when the user intends to send an event when a visitor is part of the experiment. + # Hooks Manager is responsible for triggering callbacks useful to the end-user based on certain lifecycle events. + # Possible use with integrations when the user intends to send an event when a visitor is part of the experiment. def initialize(config) @logger = VWO::Logger.get_instance - if config.key?(:integrations) && config[:integrations].key?(:callback) && config[:integrations][:callback].is_a?(Method) - @callback = config[:integrations][:callback] - end + @callback = config[:integrations][:callback] if config.key?(:integrations) && config[:integrations].key?(:callback) && config[:integrations][:callback].is_a?(Method) end - # Executes the callback - # @param[Hash] properties Properties from the callback - def execute(properties) - if @callback - @callback.call(properties) - end - end + # Executes the callback + # @param[Hash] properties Properties from the callback + def execute(properties) + @callback&.call(properties) + end end end end diff --git a/lib/vwo/services/segment_evaluator.rb b/lib/vwo/services/segment_evaluator.rb index 176710a..a98825c 100644 --- a/lib/vwo/services/segment_evaluator.rb +++ b/lib/vwo/services/segment_evaluator.rb @@ -43,15 +43,16 @@ def initialize # def evaluate_util(dsl, custom_variables) operator, sub_dsl = get_key_value(dsl) - if operator == OperatorTypes::NOT + case operator + when OperatorTypes::NOT !evaluate_util(sub_dsl, custom_variables) - elsif operator == OperatorTypes::AND + when OperatorTypes::AND sub_dsl.all? { |y| evaluate_util(y, custom_variables) } - elsif operator == OperatorTypes::OR + when OperatorTypes::OR sub_dsl.any? { |y| evaluate_util(y, custom_variables) } - elsif operator == OperandTypes::CUSTOM_VARIABLE + when OperandTypes::CUSTOM_VARIABLE @operand_evaluator.evaluate_custom_variable?(sub_dsl, custom_variables) - elsif operator == OperandTypes::USER + when OperandTypes::USER @operand_evaluator.evaluate_user?(sub_dsl, custom_variables) end end @@ -75,7 +76,7 @@ def evaluate(campaign_key, user_id, dsl, custom_variables, disable_logs = false) LogLevelEnum::ERROR, 'SEGMENTATION_ERROR', { - '{file}' => FileNameEnum::SegmentEvaluator, + '{file}' => FileNameEnum::SEGMENT_EVALUATOR, '{userId}' => user_id, '{campaignKey}' => campaign_key, '{variation}' => '', diff --git a/lib/vwo/services/settings_file_manager.rb b/lib/vwo/services/settings_file_manager.rb index d1b4205..2f70ec1 100644 --- a/lib/vwo/services/settings_file_manager.rb +++ b/lib/vwo/services/settings_file_manager.rb @@ -47,11 +47,11 @@ def get_settings_file(is_via_webhook = false) return '{}' end - if is_via_webhook - path = ::VWO::CONSTANTS::ENDPOINTS::WEBHOOK_SETTINGS_URL - else - path = ::VWO::CONSTANTS::ENDPOINTS::SETTINGS_URL - end + path = if is_via_webhook + ::VWO::CONSTANTS::ENDPOINTS::WEBHOOK_SETTINGS_URL + else + ::VWO::CONSTANTS::ENDPOINTS::SETTINGS_URL + end vwo_server_url = "#{PROTOCOL}://#{HOSTNAME}#{path}" settings_file_response = ::VWO::Utils::Request.get(vwo_server_url, params) diff --git a/lib/vwo/services/settings_file_processor.rb b/lib/vwo/services/settings_file_processor.rb index de45632..9892c8d 100644 --- a/lib/vwo/services/settings_file_processor.rb +++ b/lib/vwo/services/settings_file_processor.rb @@ -41,7 +41,7 @@ def process_settings_file LogLevelEnum::DEBUG, 'SETTINGS_FILE_PROCESSED', { - '{file}' => FileNameEnum::SettingsFileProcessor, + '{file}' => FileNameEnum::SETTINGS_FILE_PROCESSOR, '{accountId}' => @settings_file['accountId'] } ) diff --git a/lib/vwo/services/usage_stats.rb b/lib/vwo/services/usage_stats.rb index bb92cac..a0c9c47 100644 --- a/lib/vwo/services/usage_stats.rb +++ b/lib/vwo/services/usage_stats.rb @@ -16,13 +16,14 @@ class VWO module Services class UsageStats attr_reader :usage_stats + # Initialize the UsageStats def initialize(stats, is_development_mode = false) @usage_stats = {} - unless is_development_mode - @usage_stats = stats - @usage_stats[:_l] = 1 if @usage_stats.length > 0 - end + return if is_development_mode + + @usage_stats = stats + @usage_stats[:_l] = 1 if @usage_stats.length > 0 end end end diff --git a/lib/vwo/utils/campaign.rb b/lib/vwo/utils/campaign.rb index 80771d1..4b488ea 100644 --- a/lib/vwo/utils/campaign.rb +++ b/lib/vwo/utils/campaign.rb @@ -45,7 +45,7 @@ def set_variation_allocation(campaign) LogLevelEnum::DEBUG, 'VARIATION_RANGE_ALLOCATION', { - '{file}' => FileNameEnum::CampaignUtil, + '{file}' => FileNameEnum::CAMPAIGN_UTIL, '{campaignKey}' => campaign['key'], '{variationName}' => variation['name'], '{variationWeight}' => variation['weight'], @@ -177,21 +177,19 @@ def get_campaigns(settings_file, campaign_key, goal_identifier, goal_type_to_tra campaigns = get_campaigns_from_campaign_keys(campaign_key, settings_file, goal_identifier, goal_type_to_track) elsif campaign_key.is_a?(String) campaign = get_campaign_for_campaign_key_and_goal(campaign_key, settings_file, goal_identifier, goal_type_to_track) - if campaign - campaigns = [campaign] - end + campaigns = [campaign] if campaign end - if campaigns.length() == 0 + if campaigns.length == 0 Utils::Logger.log( LogLevelEnum::ERROR, 'CAMPAIGN_NOT_FOUND_FOR_GOAL', { - '{file}' => FileNameEnum::CampaignUtil, + '{file}' => FileNameEnum::CAMPAIGN_UTIL, '{goalIdentifier}' => goal_identifier } ) end - return campaigns + campaigns end # fetch all running campaigns (having goal identifier goal_type_to_track and goal type CUSTOM|REVENUE|ALL) from settings @@ -204,38 +202,31 @@ def get_campaigns_for_goal(settings_file, goal_identifier, goal_type_to_track = campaigns = [] if settings_file settings_file['campaigns'].each do |campaign| - if campaign.key?(:status) && campaign[:status] != 'RUNNING' - next - end + next if campaign.key?(:status) && campaign[:status] != 'RUNNING' + goal = get_campaign_goal(campaign, goal_identifier) - if validate_goal(goal, goal_type_to_track) - campaigns.push(campaign) - end + campaigns.push(campaign) if validate_goal(goal, goal_type_to_track) end end campaigns end def validate_goal(goal, goal_type_to_track) - result = goal && ( + goal && ( goal_type_to_track == 'ALL' || ( - GOAL_TYPES.has_value?(goal['type']) && + GOAL_TYPES.value?(goal['type']) && (GOAL_TYPES.key? goal_type_to_track) && goal['type'] == GOAL_TYPES[goal_type_to_track] ) ) - return result end def get_campaigns_from_campaign_keys(campaign_keys, settings_file, goal_identifier, goal_type_to_track = 'ALL') campaigns = [] campaign_keys.each do |campaign_key| - campaign = get_campaign_for_campaign_key_and_goal(campaign_key, settings_file, goal_identifier, goal_type_to_track) - if campaign - campaigns.push(campaign) - end + campaigns.push(campaign) if campaign end campaigns end @@ -244,9 +235,7 @@ def get_campaign_for_campaign_key_and_goal(campaign_key, settings_file, goal_ide campaign = get_running_campaign(campaign_key, settings_file) if campaign goal = get_campaign_goal(campaign, goal_identifier) - if validate_goal(goal, goal_type_to_track) - return campaign - end + return campaign if validate_goal(goal, goal_type_to_track) end nil end @@ -265,7 +254,7 @@ def get_running_campaign(campaign_key, settings_file) ) nil end - return campaign + campaign end # Checks whether a campaign is part of a group. @@ -273,10 +262,9 @@ def get_running_campaign(campaign_key, settings_file) # @param[Hash] :settings_file Settings file for the project # @param[Integer] :campaign_id Id of campaign which is to be checked # @return[Boolean] - def is_part_of_group(settings_file, campaign_id) - if settings_file["campaignGroups"] && (settings_file["campaignGroups"].has_key?(campaign_id.to_s)) - return true - end + def part_of_group?(settings_file, campaign_id) + return true if settings_file['campaignGroups']&.key?(campaign_id.to_s) + false end @@ -288,24 +276,34 @@ def is_part_of_group(settings_file, campaign_id) def get_group_campaigns(settings_file, group_id) group_campaign_ids = [] group_campaigns = [] - groups = settings_file["groups"] + groups = settings_file['groups'] - if groups && groups.has_key?(group_id.to_s) - group_campaign_ids = groups[group_id.to_s]["campaigns"] - end + group_campaign_ids = groups[group_id.to_s]['campaigns'] if groups&.key?(group_id.to_s) - if group_campaign_ids - group_campaign_ids.each do |campaign_id| - settings_file["campaigns"].each do |campaign| - if campaign["id"] == campaign_id && campaign["status"] == STATUS_RUNNING - group_campaigns.push(campaign) - end - end + group_campaign_ids&.each do |campaign_id| + settings_file['campaigns'].each do |campaign| + group_campaigns.push(campaign) if campaign['id'] == campaign_id && campaign['status'] == STATUS_RUNNING end end group_campaigns end + def campaign_goal_already_tracked?(user_id, campaign, identifiers, goal_identifier) + if identifiers.include? goal_identifier + @logger.log( + LogLevelEnum::INFO, + 'CAMPAIGN_GOAL_ALREADY_TRACKED', + { + '{file}' => FILE, + '{userId}' => user_id, + '{campaignKey}' => campaign['key'], + '{goalIdentifier}' => goal_identifier + } + ) + return true + end + false + end end end end diff --git a/lib/vwo/utils/custom_dimensions.rb b/lib/vwo/utils/custom_dimensions.rb index 718c6c2..6e08412 100644 --- a/lib/vwo/utils/custom_dimensions.rb +++ b/lib/vwo/utils/custom_dimensions.rb @@ -40,7 +40,7 @@ def get_url_params(settings_file, tag_key, tag_value, user_id, sdk_key) LogLevelEnum::DEBUG, 'IMPRESSION_FOR_PUSH', { - '{file}' => FileNameEnum::CustomDimensionsUtil, + '{file}' => FileNameEnum::CUSTOM_DIMENSTIONS_UTIL, '{properties}' => JSON.generate(params) } ) @@ -63,7 +63,7 @@ def get_batch_event_url_params(settings_file, tag_key, tag_value, user_id) LogLevelEnum::DEBUG, 'IMPRESSION_FOR_PUSH', { - '{file}' => FileNameEnum::CustomDimensionsUtil, + '{file}' => FileNameEnum::CUSTOM_DIMENSTIONS_UTIL, '{properties}' => JSON.generate(params) } ) diff --git a/lib/vwo/utils/data_location_manager.rb b/lib/vwo/utils/data_location_manager.rb index 92f43a5..a61dd08 100644 --- a/lib/vwo/utils/data_location_manager.rb +++ b/lib/vwo/utils/data_location_manager.rb @@ -12,29 +12,22 @@ # See the License for the specific language governing permissions and # limitations under the License. - require_relative '../constants' # Utility module for generating uuid class VWO module Utils class DataLocationManager - @@instance = nil def self.get_instance - if @@instance.nil? - @@instance = self.new - end + @@instance = new if @@instance.nil? @@instance end - def get_data_location url = VWO::CONSTANTS::ENDPOINTS::BASE_URL - if @settings.key?("collectionPrefix") - url = url + '/' + @settings["collectionPrefix"] - end + url = "#{url}/#{@settings['collectionPrefix']}" if @settings.key?('collectionPrefix') url end diff --git a/lib/vwo/utils/feature.rb b/lib/vwo/utils/feature.rb index 6515c59..ca66823 100644 --- a/lib/vwo/utils/feature.rb +++ b/lib/vwo/utils/feature.rb @@ -40,10 +40,10 @@ def get_type_casted_feature_value(value, variable_type) return !value || value == 0 ? false : true if variable_type == VariableTypes.BOOLEAN return value if variable_type == VariableTypes::JSON - rescue StandardError => _e + rescue StandardError => e Logger.log( LogLevelEnum::ERROR, - 'unable to type cast variable value: ' + _e.message, + "unable to type cast variable value: #{e.message}", { '{file}' => FILE } diff --git a/lib/vwo/utils/impression.rb b/lib/vwo/utils/impression.rb index 1fffe51..18d3441 100644 --- a/lib/vwo/utils/impression.rb +++ b/lib/vwo/utils/impression.rb @@ -67,8 +67,6 @@ def create_impression(settings_file, campaign_id, variation_id, user_id, sdk_key impression = usage_stats.merge(impression) - logger = VWO::Logger.get_instance - if is_track_user_api impression['ed'] = JSON.generate(p: 'server') impression['url'] = HTTPS_PROTOCOL + get_url(ENDPOINTS::TRACK_USER) @@ -76,7 +74,7 @@ def create_impression(settings_file, campaign_id, variation_id, user_id, sdk_key LogLevelEnum::DEBUG, 'IMPRESSION_FOR_TRACK_USER', { - '{file}' => FileNameEnum::ImpressionUtil, + '{file}' => FileNameEnum::IMPRESSION_UTIL, '{properties}' => remove_sensitive_properties(impression) } ) @@ -88,7 +86,7 @@ def create_impression(settings_file, campaign_id, variation_id, user_id, sdk_key LogLevelEnum::DEBUG, 'IMPRESSION_FOR_TRACK_GOAL', { - '{file}' => FileNameEnum::ImpressionUtil, + '{file}' => FileNameEnum::IMPRESSION_UTIL, '{properties}' => JSON.generate(impression) } ) @@ -129,6 +127,7 @@ def get_common_properties(user_id, settings_file) # Else Properties(dict) def create_bulk_event_impression(settings_file, campaign_id, variation_id, user_id, goal_id = nil, revenue = nil) return unless valid_number?(campaign_id) && valid_string?(user_id) + is_track_user_api = true is_track_user_api = false unless goal_id.nil? account_id = settings_file['accountId'] @@ -139,13 +138,13 @@ def create_bulk_event_impression(settings_file, campaign_id, variation_id, user_ u: generator_for(user_id, account_id, true), sId: get_current_unix_timestamp } - logger = VWO::Logger.get_instance + if is_track_user_api Logger.log( LogLevelEnum::DEBUG, 'IMPRESSION_FOR_TRACK_USER', { - '{file}' => FileNameEnum::ImpressionUtil, + '{file}' => FileNameEnum::IMPRESSION_UTIL, '{properties}' => remove_sensitive_properties(impression) } ) @@ -156,7 +155,7 @@ def create_bulk_event_impression(settings_file, campaign_id, variation_id, user_ LogLevelEnum::DEBUG, 'IMPRESSION_FOR_TRACK_GOAL', { - '{file}' => FileNameEnum::ImpressionUtil, + '{file}' => FileNameEnum::IMPRESSION_UTIL, '{properties}' => JSON.generate(impression) } ) @@ -179,12 +178,10 @@ def get_events_base_properties(settings_file, event_name, usage_stats = {}) env: settings_file['sdkKey'], eTime: get_current_unix_timestamp_in_millis, random: get_random_number, - p: "FS" + p: 'FS' } - if event_name == EventEnum::VWO_VARIATION_SHOWN - properties = properties.merge(usage_stats) - end + properties = properties.merge(usage_stats) if event_name == EventEnum::VWO_VARIATION_SHOWN properties end @@ -193,10 +190,10 @@ def get_events_base_properties(settings_file, event_name, usage_stats = {}) # @param[Hash] :settings_file # @param[String] :user_id # @param[String] :event_name - # @param[Hash] :usage_stats + # @param[Hash] :_usage_stats # @return[Hash] :properties # - def get_event_base_payload(settings_file, user_id, event_name, usage_stats = {}) + def get_event_base_payload(settings_file, user_id, event_name, _usage_stats = {}) uuid = generator_for(user_id, (settings_file['accountId']), true) sdk_key = settings_file['sdkKey'] @@ -211,12 +208,12 @@ def get_event_base_payload(settings_file, user_id, event_name, usage_stats = {}) } # if usage_stats - # props = props.merge(usage_stats) + # props = props.merge(_usage_stats) # end - properties = { + { d: { - msgId: uuid + '_' + Time.now.to_i.to_s, + msgId: "#{uuid} + '_' + #{Time.now.to_i}", visId: uuid, sessionId: Time.now.to_i, event: { @@ -231,8 +228,6 @@ def get_event_base_payload(settings_file, user_id, event_name, usage_stats = {}) } } } - - properties end # Builds payload to track the visitor. @@ -242,27 +237,26 @@ def get_event_base_payload(settings_file, user_id, event_name, usage_stats = {}) # @param[String] :event_name # @param[Integer] :campaign_id # @param[Integer] :variation_id - # @param[Hash] :usage_stats + # @param[Hash] :_usage_stats # @return[Hash] :properties # - def get_track_user_payload_data(settings_file, user_id, event_name, campaign_id, variation_id, usage_stats = {}) + def get_track_user_payload_data(settings_file, user_id, event_name, campaign_id, variation_id, _usage_stats = {}) properties = get_event_base_payload(settings_file, user_id, event_name) properties[:d][:event][:props][:id] = campaign_id properties[:d][:event][:props][:variation] = variation_id - #this is currently required by data-layer team, we can make changes on DACDN and remove it from here + # this is currently required by data-layer team, we can make changes on DACDN and remove it from here properties[:d][:event][:props][:isFirst] = 1 - logger = VWO::Logger.get_instance Logger.log( - LogLevelEnum::DEBUG, - 'IMPRESSION_FOR_EVENT_ARCH_TRACK_USER', - { - '{file}' => FileNameEnum::ImpressionUtil, - '{accountId}' => settings_file['accountId'], - '{userId}' => user_id, - '{campaignId}' => campaign_id.to_s - } + LogLevelEnum::DEBUG, + 'IMPRESSION_FOR_EVENT_ARCH_TRACK_USER', + { + '{file}' => FileNameEnum::IMPRESSION_UTIL, + '{accountId}' => settings_file['accountId'], + '{userId}' => user_id, + '{campaignId}' => campaign_id.to_s + } ) properties end @@ -281,15 +275,14 @@ def get_track_user_payload_data(settings_file, user_id, event_name, campaign_id, def get_track_goal_payload_data(settings_file, user_id, event_name, revenue_value, metric_map, revenue_props = []) properties = get_event_base_payload(settings_file, user_id, event_name) - logger = VWO::Logger.get_instance metric = {} metric_map.each do |campaign_id, goal_id| - metric[('id_' + campaign_id.to_s).to_sym] = ['g_' + goal_id.to_s] + metric["id_#{campaign_id}".to_sym] = ["g_#{goal_id}"] Logger.log( LogLevelEnum::DEBUG, 'IMPRESSION_FOR_EVENT_ARCH_TRACK_GOAL', { - '{file}' => FileNameEnum::ImpressionUtil, + '{file}' => FileNameEnum::IMPRESSION_UTIL, '{accountId}' => settings_file['accountId'], '{goalName}' => event_name, '{userId}' => user_id, @@ -302,7 +295,7 @@ def get_track_goal_payload_data(settings_file, user_id, event_name, revenue_valu metric: metric } - if revenue_props.length() != 0 && revenue_value + if revenue_props.length != 0 && revenue_value revenue_props.each do |revenue_prop| properties[:d][:event][:props][:vwoMeta][revenue_prop.to_sym] = revenue_value end @@ -330,12 +323,11 @@ def get_push_payload_data(settings_file, user_id, event_name, custom_dimension_m properties[:d][:visitor][:props][tag_key] = tag_value end - logger = VWO::Logger.get_instance Logger.log( LogLevelEnum::DEBUG, 'IMPRESSION_FOR_EVENT_ARCH_PUSH', { - '{file}' => FileNameEnum::ImpressionUtil, + '{file}' => FileNameEnum::IMPRESSION_UTIL, '{accountId}' => settings_file['accountId'], '{userId}' => user_id, '{property}' => JSON.generate(custom_dimension_map) @@ -345,7 +337,7 @@ def get_push_payload_data(settings_file, user_id, event_name, custom_dimension_m end def get_batch_event_query_params(account_id, sdk_key, usage_stats = {}) - return { + { a: account_id, sd: SDK_NAME, sv: SDK_VERSION, diff --git a/lib/vwo/utils/log_message.rb b/lib/vwo/utils/log_message.rb index 9b6eab7..37cc4cd 100644 --- a/lib/vwo/utils/log_message.rb +++ b/lib/vwo/utils/log_message.rb @@ -19,7 +19,6 @@ class VWO module Utils class Logger - DEBUG = ::Logger::DEBUG INFO = ::Logger::INFO ERROR = ::Logger::ERROR @@ -32,43 +31,37 @@ def self.set_api_name(api_name) @@api_name = api_name end - def self.get_log_message(logsType, message_type) - if @@logs.nil? - @@logs = VwoLogMessages.getMessage - end + def self.get_log_message(logs_type, message_type) + @@logs = VwoLogMessages.getMessage if @@logs.nil? - if !@@logs[logsType].key?(message_type) - return message_type - end - return @@logs[logsType][message_type] + return message_type unless @@logs[logs_type].key?(message_type) + + @@logs[logs_type][message_type] end def self.log(level, message_type, params, disable_logs = false) - if disable_logs - return - end - if level == DEBUG - message = get_log_message('debug_logs', message_type) - elsif level == INFO - message = get_log_message('info_logs', message_type) - elsif level == ERROR - message = get_log_message('error_logs', message_type) - elsif level == WARN - message = get_log_message('warning_logs', message_type) - else - message = "" - end + return if disable_logs + + message = case level + when DEBUG + get_log_message('debug_logs', message_type) + when INFO + get_log_message('info_logs', message_type) + when ERROR + get_log_message('error_logs', message_type) + when WARN + get_log_message('warning_logs', message_type) + else + '' + end message = message.dup if message && !message.empty? - params.each { - |key, value| - if message.include? key - message[key.to_s]= value.to_s - end - } + params.each do |key, value| + message[key.to_s] = value.to_s if message.include? key + end end - message = '[' + @@api_name + '] ' + message + message = "[#{@@api_name}] #{message}" VWO::Logger.get_instance.log(level, message) end end diff --git a/lib/vwo/utils/request.rb b/lib/vwo/utils/request.rb index e97cbaf..6e217b1 100644 --- a/lib/vwo/utils/request.rb +++ b/lib/vwo/utils/request.rb @@ -31,12 +31,11 @@ def self.post(url, params, post_data) http.use_ssl = true uri.query = URI.encode_www_form(params) headers = { - 'Authorization'=>params[:env], - 'Content-Type' =>'application/json', - 'Accept'=>'application/json' + 'Authorization' => params[:env], + 'Content-Type' => 'application/json', + 'Accept' => 'application/json' } - response = http.post(uri, post_data.to_json, headers) - response + http.post(uri, post_data.to_json, headers) end def self.event_post(url, params, post_data, user_agent_value) @@ -46,11 +45,10 @@ def self.event_post(url, params, post_data, user_agent_value) uri.query = URI.encode_www_form(params) headers = { 'User-Agent' => user_agent_value, - 'Content-Type' =>'application/json', - 'Accept'=>'application/json' + 'Content-Type' => 'application/json', + 'Accept' => 'application/json' } - response = http.post(uri, post_data.to_json, headers) - response + http.post(uri, post_data.to_json, headers) end end end diff --git a/lib/vwo/utils/utility.rb b/lib/vwo/utils/utility.rb index 99e32ca..c34c699 100644 --- a/lib/vwo/utils/utility.rb +++ b/lib/vwo/utils/utility.rb @@ -19,44 +19,54 @@ # Generic utility module class VWO - module Utils - module Utility - include Validations - include VWO::Utils - include VWO::CONSTANTS + module Utils + module Utility + include Validations + include VWO::Utils + include VWO::CONSTANTS - # converting hash with keys as strings into hash with keys as strings - # @param[Hash] - # @return[Hash] - def convert_to_symbol_hash(hashObject) - hashObject ||= {} - convertedHash = {} - hashObject.each do |key, value| - if valid_hash?(value) - convertedHash[key.to_sym] = convert_to_symbol_hash(value) - else - convertedHash[key.to_sym] = value - end - end - convertedHash - end + # converting hash with keys as strings into hash with keys as strings + # @param[Hash] + # @return[Hash] + def convert_to_symbol_hash(hash_object) + hash_object ||= {} + converted_hash = {} + hash_object.each do |key, value| + converted_hash[key.to_sym] = if valid_hash?(value) + convert_to_symbol_hash(value) + else + value + end + end + converted_hash + end + + def remove_sensitive_properties(properties) + properties.delete('env') + properties.delete('env'.to_sym) + JSON.generate(properties) + end - def remove_sensitive_properties(properties) - properties.delete("env") - properties.delete("env".to_sym) - JSON.generate(properties) - end + def get_url(endpoint) + DataLocationManager.get_instance.get_data_location + endpoint + end - def get_url(endpoint) - return DataLocationManager.get_instance().get_data_location + endpoint - end + def prepare_push_response(custom_dimension_map, resp, result) + custom_dimension_map.each do |tag_key, _tag_value| + result[tag_key] = resp + end + result + end - def prepare_push_response(custom_dimension_map, resp, result) - custom_dimension_map.each do |tag_key, tag_value| - result[tag_key] = resp - end - result - end + def get_variation_identifiers(variation) + if variation['goal_identifier'] + identifiers = variation['goal_identifier'].split(VWO_DELIMITER) + else + variation['goal_identifier'] = '' + identifiers = [] end + identifiers + end end + end end diff --git a/lib/vwo/utils/validations.rb b/lib/vwo/utils/validations.rb index 103f099..3b9eace 100644 --- a/lib/vwo/utils/validations.rb +++ b/lib/vwo/utils/validations.rb @@ -23,6 +23,7 @@ class VWO module Utils module Validations include Enums + include CONSTANTS # Validates the settings_file # @param [Hash]: JSON object received from VWO server # must be JSON. @@ -70,7 +71,7 @@ def valid_basic_data_type?(val) # api_name [String]: current api name # # @return: [Boolean]: True if all conditions are passed else False - def is_valid_batch_event_settings(batch_events, api_name) + def valid_batch_event_settings(batch_events, api_name) events_per_request = batch_events[:events_per_request] request_time_interval = batch_events[:request_time_interval] @@ -79,12 +80,12 @@ def is_valid_batch_event_settings(batch_events, api_name) return false end - if (request_time_interval && !valid_number?(request_time_interval)) + if request_time_interval && !valid_number?(request_time_interval) invalid_config_log('batch_events', 'object', api_name) return false end - if (events_per_request && !valid_number?(events_per_request)) + if events_per_request && !valid_number?(events_per_request) invalid_config_log('batch_events', 'object', api_name) return false end @@ -132,7 +133,7 @@ def valid_config_log(parameter, type) LogLevelEnum::INFO, 'CONFIG_PARAMETER_USED', { - '{file}' => VWO::FileNameEnum::ValidateUtil, + '{file}' => VWO::FileNameEnum::VALIDATE_UTIL, '{parameter}' => parameter, '{type}' => type } @@ -144,13 +145,79 @@ def invalid_config_log(parameter, type, api_name) LogLevelEnum::ERROR, 'CONFIG_PARAMETER_INVALID', { - '{file}' => VWO::FileNameEnum::ValidateUtil, + '{file}' => VWO::FileNameEnum::VALIDATE_UTIL, '{parameter}' => parameter, '{type}' => type, '{api}' => api_name } ) end + + def valid_goal?(goal, campaign, user_id, goal_identifier, revenue_value) + if goal.nil? || !goal['id'] + Logger.log( + LogLevelEnum::ERROR, + 'TRACK_API_GOAL_NOT_FOUND', + { + '{file}' => FILE, + '{goalIdentifier}' => goal_identifier, + '{userId}' => user_id, + '{campaignKey}' => campaign['key'] + } + ) + return false + elsif goal['type'] == GoalTypes::REVENUE && !valid_value?(revenue_value) + Logger.log( + LogLevelEnum::ERROR, + 'TRACK_API_REVENUE_NOT_PASSED_FOR_REVENUE_GOAL', + { + '{file}' => FILE, + '{userId}' => user_id, + '{goalIdentifier}' => goal_identifier, + '{campaignKey}' => campaign['key'] + } + ) + return false + end + true + end + end + + def valid_campaign_for_track_api?(user_id, campaign_key, campaign_type) + if campaign_type == CONSTANTS::CampaignTypes::FEATURE_ROLLOUT + Logger.log( + LogLevelEnum::ERROR, + 'API_NOT_APPLICABLE', + { + '{file}' => FILE, + '{api}' => ApiMethods::TRACK, + '{userId}' => user_id, + '{campaignKey}' => campaign_key, + '{campaignType}' => campaign_type + } + ) + return false + end + true + end + + def valid_track_api_params?(user_id, campaign_key, custom_variables, variation_targeting_variables, goal_type_to_track, goal_identifier) + unless (valid_string?(campaign_key) || campaign_key.is_a?(Array) || campaign_key.nil?) && + valid_string?(user_id) && valid_string?(goal_identifier) && + (custom_variables.nil? || valid_hash?(custom_variables)) && + (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables)) && CONSTANTS::GOAL_TYPES.key?(goal_type_to_track) + # log invalid params + Logger.log( + LogLevelEnum::ERROR, + 'API_BAD_PARAMETERS', + { + '{file}' => FILE, + '{api}' => ApiMethods::TRACK + } + ) + return false + end + true end end end diff --git a/tests/test_all_tests.rb b/tests/test_all_tests.rb index 84bf57e..ae677b4 100644 --- a/tests/test_all_tests.rb +++ b/tests/test_all_tests.rb @@ -13,4 +13,4 @@ # limitations under the License. require_relative './test_helper' -Dir[File.dirname(File.absolute_path(__FILE__)) + '/**/test_*.rb'].each {|file| require file } +Dir["#{File.dirname(File.absolute_path(__FILE__))}/**/test_*.rb"].sort.each { |file| require file } diff --git a/tests/test_bucketer.rb b/tests/test_bucketer.rb index fc23d90..6316e64 100644 --- a/tests/test_bucketer.rb +++ b/tests/test_bucketer.rb @@ -101,7 +101,7 @@ def test_bucket_user_to_variation_return_control assert_equal(result['name'], 'Control') end - def test_bucket_user_to_variation_return_varitaion_1 + def test_bucket_user_to_variation_return_varitaion1 user_id = 'Varun' # Varun, with above campaign settings, will get hashValue:69650962 and # bucketValue:326. So, MUST be a part of Variation-1, as per campaign @@ -113,47 +113,47 @@ def test_bucket_user_to_variation_return_varitaion_1 def test_get_variation_return_none campaign = ::SETTINGS_FILE_1['AB_T_50_W_50_50']['campaigns'][0] set_variation_allocation(campaign) - result = @bucketer.send(:get_variation, campaign['variations'], 10001) + result = @bucketer.send(:get_variation, campaign['variations'], 10_001) assert_equal(result, nil) end def test_get_bucket_value_for_user_25_someonemailcom - campaign = {'id' => 1, 'isBucketingSeedEnabled' => true} - bucket_value = @bucketer.get_bucket_value_for_user("someone@mail.com", campaign) - assert_equal(bucket_value, 25) - - campaign['isBucketingSeedEnabled'] = false - bucket_value = @bucketer.get_bucket_value_for_user("someone@mail.com", campaign) - assert_equal(bucket_value, 64) - end - - def test_get_bucket_value_for_user_1111111111111111 - campaign = {'id' => 1, 'isBucketingSeedEnabled' => true} - bucket_value = @bucketer.get_bucket_value_for_user("1111111111111111", campaign) - assert_equal(bucket_value, 82) - - campaign['isBucketingSeedEnabled'] = false - bucket_value = @bucketer.get_bucket_value_for_user("1111111111111111", campaign) - assert_equal(bucket_value, 50) - end - - def test_get_bucket_value_for_user_25_someonemailcom_when_bucketing_seed_passed_as_symbol - campaign = {'id' => 1, isBucketingSeedEnabled: true} - bucket_value = @bucketer.get_bucket_value_for_user("someone@mail.com", campaign) - assert_equal(bucket_value, 64) - - campaign[:isBucketingSeedEnabled] = false - bucket_value = @bucketer.get_bucket_value_for_user("someone@mail.com", campaign) - assert_equal(bucket_value, 64) - end - - def test_get_bucket_value_for_user_1111111111111111_when_bucketing_seed_passed_as_symbol - campaign = {'id' => 1, isBucketingSeedEnabled: true} - bucket_value = @bucketer.get_bucket_value_for_user("1111111111111111", campaign) - assert_equal(bucket_value, 50) - - campaign[:isBucketingSeedEnabled] = false - bucket_value = @bucketer.get_bucket_value_for_user("1111111111111111", campaign) - assert_equal(bucket_value, 50) - end + campaign = { 'id' => 1, 'isBucketingSeedEnabled' => true } + bucket_value = @bucketer.get_bucket_value_for_user('someone@mail.com', campaign) + assert_equal(bucket_value, 25) + + campaign['isBucketingSeedEnabled'] = false + bucket_value = @bucketer.get_bucket_value_for_user('someone@mail.com', campaign) + assert_equal(bucket_value, 64) + end + + def test_get_bucket_value_for_user1111111111111111 + campaign = { 'id' => 1, 'isBucketingSeedEnabled' => true } + bucket_value = @bucketer.get_bucket_value_for_user('1111111111111111', campaign) + assert_equal(bucket_value, 82) + + campaign['isBucketingSeedEnabled'] = false + bucket_value = @bucketer.get_bucket_value_for_user('1111111111111111', campaign) + assert_equal(bucket_value, 50) + end + + def test_get_bucket_value_for_user_25_someonemailcom_when_bucketing_seed_passed_as_symbol + campaign = { 'id' => 1, isBucketingSeedEnabled: true } + bucket_value = @bucketer.get_bucket_value_for_user('someone@mail.com', campaign) + assert_equal(bucket_value, 64) + + campaign[:isBucketingSeedEnabled] = false + bucket_value = @bucketer.get_bucket_value_for_user('someone@mail.com', campaign) + assert_equal(bucket_value, 64) + end + + def test_get_bucket_value_for_user_1111111111111111_when_bucketing_seed_passed_as_symbol + campaign = { 'id' => 1, isBucketingSeedEnabled: true } + bucket_value = @bucketer.get_bucket_value_for_user('1111111111111111', campaign) + assert_equal(bucket_value, 50) + + campaign[:isBucketingSeedEnabled] = false + bucket_value = @bucketer.get_bucket_value_for_user('1111111111111111', campaign) + assert_equal(bucket_value, 50) + end end diff --git a/tests/test_event_dispatcher.rb b/tests/test_event_dispatcher.rb index c158cae..4245a8b 100644 --- a/tests/test_event_dispatcher.rb +++ b/tests/test_event_dispatcher.rb @@ -18,14 +18,11 @@ require 'net/http' class DummyResponse - def initialize(code) @code = code end - def code - @code - end + attr_reader :code end class EventDispatcherTest < Test::Unit::TestCase @@ -36,27 +33,27 @@ def setup # Test that dispatch event fires off requests call with provided URL and params. def test_dispatch_fires_request Net::HTTP.class_eval do - def self.get_response(*args) - return DummyResponse.new('200') + def self.get_response(*_args) + DummyResponse.new('200') end end properties = { 'env' => 'dummyKey', 'combination' => 1, - 'url' => 'https://dev.visualwebsiteoptimizer.com/server-side/track-user', + 'url' => 'https://dev.visualwebsiteoptimizer.com/server-side/track-user', 'ed' => '{"p": "server"}', 'random' => 0.7382938446947298, 'ap' => 'server', 'u' => '09CD6107E42B51F9BFC3DD97EA900990', 'experiment_id' => 229, - 'sId' => 1565949670, + 'sId' => 1_565_949_670, 'sdk-v' => '1.0.2', 'sdk' => 'python', - 'account_id' => 60781, + 'account_id' => 60_781 } - result = @dispatcher.dispatch(properties) + result = @dispatcher.dispatch(properties, {}, 'end_point') assert_equal(result, true) properties['url'] @@ -67,35 +64,34 @@ def self.get_response(*args) # Test that dispatch returns false if status_code != 200 def test_dispatch_error_status_code Net::HTTP.class_eval do - def self.get_response(*args) - return DummyResponse.new('503') + def self.get_response(*_args) # rubocop:todo Lint/DuplicateMethods + DummyResponse.new('503') end end properties = { 'env' => 'dummyKey', 'combination' => 1, - 'url' => 'https://dev.visualwebsiteoptimizer.com/server-side/track-user', # noqa: E501 + 'url' => 'https://dev.visualwebsiteoptimizer.com/server-side/track-user', # noqa: E501 'ed' => '{"p": "server"}', 'random' => 0.7382938446947298, 'ap' => 'server', 'u' => '09CD6107E42B51F9BFC3DD97EA900990', 'experiment_id' => 229, - 'sId' => 1565949670, + 'sId' => 1_565_949_670, 'sdk-v' => '1.0.2', 'sdk' => 'python', - 'account_id' => 60781, + 'account_id' => 60_781 } - result = @dispatcher.dispatch(properties) + result = @dispatcher.dispatch(properties, {}, 'end_point') assert_equal(result, false) end # Test that dispatch returns False if exception occurs. def test_dispatch_with_exception - Net::HTTP.class_eval do - def self.get_response(*args) + def self.get_response(*_args) # rubocop:todo Lint/DuplicateMethods raise end end @@ -109,13 +105,13 @@ def self.get_response(*args) 'ap' => 'server', 'u' => '09CD6107E42B51F9BFC3DD97EA900990', 'experiment_id' => 229, - 'sId' => 1565949670, + 'sId' => 1_565_949_670, 'sdk-v' => '1.0.2', 'sdk' => 'python', - 'account_id' => 60781, + 'account_id' => 60_781 } - result = @dispatcher.dispatch(properties) + result = @dispatcher.dispatch(properties, {}, 'end_point') assert_equal(result, false) end end diff --git a/tests/test_helper.rb b/tests/test_helper.rb index cce94cc..705c86a 100644 --- a/tests/test_helper.rb +++ b/tests/test_helper.rb @@ -20,4 +20,4 @@ # SimpleCov.formatter = SimpleCov::Formatter::Codecov require 'test/unit' -$LOAD_PATH.unshift File.expand_path('../lib', __FILE__) +$LOAD_PATH.unshift File.expand_path('lib', __dir__) diff --git a/tests/test_impression.rb b/tests/test_impression.rb index ec87083..4ab43fc 100644 --- a/tests/test_impression.rb +++ b/tests/test_impression.rb @@ -20,172 +20,168 @@ require 'mocha/test_unit' class ImpressionTest < Test::Unit::TestCase - include VWO::Utils::Impression - include VWO::Enums - EVENT_ARCH_QUERY_PARAMS = ['a', 'en', 'eTime', 'random', 'env', 'p'] + include VWO::Utils::Impression + include VWO::Enums + EVENT_ARCH_QUERY_PARAMS = %w[a en eTime random env p] - def test_build_event_arch_payload_for_visitor - account_id = 1 - sdk_key = '12345' - config = {"accountId" => account_id, "sdkKey" => sdk_key} - query_params = get_events_base_properties(config, EventEnum::VWO_VARIATION_SHOWN) - properties = get_track_user_payload_data(config, 'Ashley', EventEnum::VWO_VARIATION_SHOWN, 20, 3) + def test_build_event_arch_payload_for_visitor + account_id = 1 + sdk_key = '12345' + config = { 'accountId' => account_id, 'sdkKey' => sdk_key } + query_params = get_events_base_properties(config, EventEnum::VWO_VARIATION_SHOWN) + properties = get_track_user_payload_data(config, 'Ashley', EventEnum::VWO_VARIATION_SHOWN, 20, 3) - expected_properties = { - d: { - msgId: "string", - visId: "string", - sessionId: 123, - event: { - props: { - sdkName: "string", - sdkVersion: "string", - id: 12, - isFirst: 1233, - variation: 2, - '$visitor': { - props: { - vwo_fs_environment: "string" - } - }, - }, - name: "string", - time: 12345 - }, - visitor: { - props: { - vwo_fs_environment: "string" - } - } + expected_properties = { + d: { + msgId: 'string', + visId: 'string', + sessionId: 123, + event: { + props: { + sdkName: 'string', + sdkVersion: 'string', + id: 12, + isFirst: 1233, + variation: 2, + '$visitor': { + props: { + vwo_fs_environment: 'string' + } } + }, + name: 'string', + time: 12_345 + }, + visitor: { + props: { + vwo_fs_environment: 'string' + } } + } + } - is_valid = check_all_properties_present(query_params, EVENT_ARCH_QUERY_PARAMS) - assert_equal(true, is_valid) - is_valid = check_all_properties_present_and_their_types(properties, expected_properties) - assert_equal(true, is_valid) - end + is_valid = check_all_properties_present(query_params, EVENT_ARCH_QUERY_PARAMS) + assert_equal(true, is_valid) + is_valid = check_all_properties_present_and_their_types(properties, expected_properties) + assert_equal(true, is_valid) + end - def test_build_event_arch_payload_for_goal - account_id = 1 - sdk_key = '12345' - config = {"accountId" => account_id, "sdkKey" => sdk_key} - goal_identifier = 'goalIdentifier' - metric_map = { - "1": 10, - "2": 20, - "5": 30 - } - dummy_revenue_property = ['dummyRevenueProperty1', 'dummyRevenueProperty2']; - query_params = get_events_base_properties(config, goal_identifier) - properties = get_track_goal_payload_data(config, 'Ashley', goal_identifier, 12, metric_map, dummy_revenue_property) + def test_build_event_arch_payload_for_goal + account_id = 1 + sdk_key = '12345' + config = { 'accountId' => account_id, 'sdkKey' => sdk_key } + goal_identifier = 'goalIdentifier' + metric_map = { + "1": 10, + "2": 20, + "5": 30 + } + dummy_revenue_property = %w[dummyRevenueProperty1 dummyRevenueProperty2] + query_params = get_events_base_properties(config, goal_identifier) + properties = get_track_goal_payload_data(config, 'Ashley', goal_identifier, 12, metric_map, dummy_revenue_property) - expected_properties = { - d: { - msgId: "string", - visId: "string", - sessionId: 123, - event: { - props: { - sdkName: "string", - sdkVersion: "string", - vwoMeta: { - metric: { - id_1: ["g_10"], - id_2: ["g_20"], - id_5: ["g_30"] - }, - dummyRevenueProperty1: 12, - dummyRevenueProperty2: 12 - }, - isCustomEvent: true, - '$visitor': { - props: { - vwo_fs_environment: "string" - } - }, - }, - name: "string", - time: 12345 - }, - visitor: { - props: { - vwo_fs_environment: "string" - } - } + expected_properties = { + d: { + msgId: 'string', + visId: 'string', + sessionId: 123, + event: { + props: { + sdkName: 'string', + sdkVersion: 'string', + vwoMeta: { + metric: { + 'id_1'.to_sym => ['g_10'], + 'id_2'.to_sym => ['g_20'], + 'id_5'.to_sym => ['g_30'] + }, + dummyRevenueProperty1: 12, + dummyRevenueProperty2: 12 + }, + isCustomEvent: true, + '$visitor': { + props: { + vwo_fs_environment: 'string' + } } + }, + name: 'string', + time: 12_345 + }, + visitor: { + props: { + vwo_fs_environment: 'string' + } } + } + } - is_valid = check_all_properties_present(query_params, EVENT_ARCH_QUERY_PARAMS) - assert_equal(true, is_valid) - is_valid = check_all_properties_present_and_their_types(properties, expected_properties) - assert_equal(true, is_valid) - end + is_valid = check_all_properties_present(query_params, EVENT_ARCH_QUERY_PARAMS) + assert_equal(true, is_valid) + is_valid = check_all_properties_present_and_their_types(properties, expected_properties) + assert_equal(true, is_valid) + end - def test_build_event_arch_payload_for_push - account_id = 1 - sdk_key = '12345' - config = {"accountId" => account_id, "sdkKey" => sdk_key} - query_params = get_events_base_properties(config, EventEnum::VWO_SYNC_VISITOR_PROP) - properties = get_push_payload_data(config, 'Ashley', EventEnum::VWO_SYNC_VISITOR_PROP, { tagKey1: "tagValue1", tagKey2: 'tagValue2'}) + def test_build_event_arch_payload_for_push + account_id = 1 + sdk_key = '12345' + config = { 'accountId' => account_id, 'sdkKey' => sdk_key } + query_params = get_events_base_properties(config, EventEnum::VWO_SYNC_VISITOR_PROP) + properties = get_push_payload_data(config, 'Ashley', EventEnum::VWO_SYNC_VISITOR_PROP, { tagKey1: 'tagValue1', tagKey2: 'tagValue2' }) - expected_properties = { - d: { - msgId: "string", - visId: "string", - sessionId: 123, - event: { - props: { - sdkName: "string", - sdkVersion: "string", - isCustomEvent: true, - '$visitor': { - props: { - vwo_fs_environment: "string", - tagKey1: "tagValue1", - tagKey2: 'tagValue2' - } - }, - }, - name: "string", - time: 12345 - }, - visitor: { - props: { - vwo_fs_environment: "string", - tagKey1: "tagValue1", - tagKey2: 'tagValue2' - } - } + expected_properties = { + d: { + msgId: 'string', + visId: 'string', + sessionId: 123, + event: { + props: { + sdkName: 'string', + sdkVersion: 'string', + isCustomEvent: true, + '$visitor': { + props: { + vwo_fs_environment: 'string', + tagKey1: 'tagValue1', + tagKey2: 'tagValue2' + } } + }, + name: 'string', + time: 12_345 + }, + visitor: { + props: { + vwo_fs_environment: 'string', + tagKey1: 'tagValue1', + tagKey2: 'tagValue2' + } } + } + } - is_valid = check_all_properties_present(query_params, EVENT_ARCH_QUERY_PARAMS) - assert_equal(true, is_valid) - is_valid = check_all_properties_present_and_their_types(properties, expected_properties) - assert_equal(true, is_valid) - end + is_valid = check_all_properties_present(query_params, EVENT_ARCH_QUERY_PARAMS) + assert_equal(true, is_valid) + is_valid = check_all_properties_present_and_their_types(properties, expected_properties) + assert_equal(true, is_valid) + end - def check_all_properties_present(properties, expected_properties) - expected_properties.each do |field| - unless properties.key? (field.to_sym) - return false - end - end - true + def check_all_properties_present(properties, expected_properties) + expected_properties.each do |field| + return false unless properties.key?(field.to_sym) end + true + end + + def check_all_properties_present_and_their_types(properties, expected_properties) + expected_properties.each do |key, _value| + return false if !(properties.key? key) || (properties[key]).class != (expected_properties[key]).class - def check_all_properties_present_and_their_types(properties, expected_properties) - expected_properties.each do |key, value| - if !(properties.key? key) || (properties[key]).class != (expected_properties[key]).class - return false - elsif (properties[key]).is_a?(Hash) - is_valid = check_all_properties_present_and_their_types(properties[key], expected_properties[key]) - unless is_valid - return false - end - end - end - true + if (properties[key]).is_a?(Hash) + is_valid = check_all_properties_present_and_their_types(properties[key], expected_properties[key]) + return false unless is_valid + end end + true + end end diff --git a/tests/test_logger.rb b/tests/test_logger.rb index fd990e7..3fb52c6 100644 --- a/tests/test_logger.rb +++ b/tests/test_logger.rb @@ -21,14 +21,13 @@ class VWO class Logger - def log(level, message) - $stdout.puts(message) + def log(_level, message) + $stdout.puts(message) end end end class LoggerTest < Test::Unit::TestCase - def setup @logger_instance = VWO::Logger.get_instance end diff --git a/tests/test_mutually_exclusive.rb b/tests/test_mutually_exclusive.rb index 434ed39..cfa2c64 100644 --- a/tests/test_mutually_exclusive.rb +++ b/tests/test_mutually_exclusive.rb @@ -21,340 +21,339 @@ MEG_SETTINGS_FILE = JSON.load(File.open(File.join(File.dirname(__FILE__), 'data/settings_meg.json'))) class MutuallyExclusiveTest < Test::Unit::TestCase - - def test_variation_return_as_whitelisting - campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) - options = { - variation_targeting_variables: { - "chrome" => "false" - } - } - # called campaign satisfies the whitelisting - variation = vwo_instance.activate(campaign_key, 'Ashley', options) - variation_name = vwo_instance.get_variation_name(campaign_key, 'Ashley', options) - is_goal_tracked = vwo_instance.track(campaign_key, 'Ashley', 'CUSTOM', options)[campaign_key] - assert_equal(variation, 'Variation-1') - assert_equal(variation_name, 'Variation-1') - assert_equal(is_goal_tracked, true) - end - - def test_null_variation_as_other_campaign_satisfies_whitelisting - campaign_key = MEG_SETTINGS_FILE['campaigns'][3]['key'] - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) - options = { - variation_targeting_variables: { - "chrome" => "false" - } - } - - variation = vwo_instance.activate(campaign_key, 'Ashley', options) - is_goal_tracked = vwo_instance.track(campaign_key, 'Ashley', 'CUSTOM', options) - variation_name = vwo_instance.get_variation_name(campaign_key, 'Ashley', options) - assert_equal(nil, variation) - assert_equal(nil, variation_name) - assert_equal(false, is_goal_tracked[campaign_key]) - end - - def test_variation_for_called_campaign - campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, CustomUserStorage.new, true, JSON.generate(MEG_SETTINGS_FILE)) - - variation = vwo_instance.activate(campaign_key, 'Ashley') - is_goal_tracked = vwo_instance.track(campaign_key, 'Ashley', 'CUSTOM')[campaign_key] - variation_name = vwo_instance.get_variation_name(campaign_key, 'Ashley') - assert_equal('Control', variation) - assert_equal('Control', variation_name) - assert_equal(true, is_goal_tracked) - end - - def test_null_variation_as_other_campaign_satisfies_storage - campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] - variation_info = { - "user_id" => 'Ashley', - "name" => 'Control', - "campaign_key" => campaign_key - } - user_storage = CustomUserStorage.new - user_storage.set(variation_info) - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, user_storage, true, JSON.generate(MEG_SETTINGS_FILE)) - - variation = vwo_instance.activate(campaign_key, 'Ashley') - is_goal_tracked = vwo_instance.track(campaign_key, 'Ashley', 'CUSTOM')[campaign_key] - variation_name = vwo_instance.get_variation_name(campaign_key, 'Ashley') - assert_equal('Control', variation) - assert_equal('Control', variation_name) - assert_equal(true, is_goal_tracked) - - campaign_key = MEG_SETTINGS_FILE['campaigns'][3]['key'] - variation = vwo_instance.activate(campaign_key, 'Ashley') - is_goal_tracked = vwo_instance.track(campaign_key, 'Ashley', 'CUSTOM')[campaign_key] - variation_name = vwo_instance.get_variation_name(campaign_key, 'Ashley') - assert_equal(nil, variation) - assert_equal(nil, variation_name) - assert_equal(false, is_goal_tracked) - user_storage.remove('Ashley') - end - - def test_variation_for_called_campaign_in_storage_and_other_campaign_satisfies_whitelisting - campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, CustomUserStorage.new, true, JSON.generate(MEG_SETTINGS_FILE)) - options = { - variation_targeting_variables: { - "browser" => "chrome" - } - } - - segment_passed = { - "or" => [ - "custom_variable"=> { - "browser"=> "chrome" - } - ] - } - - variation = vwo_instance.activate(campaign_key, 'Ashley') - assert_equal('Control', variation) - vwo_instance.get_settings['campaigns'][1]['segments'] = segment_passed - variation = vwo_instance.activate(campaign_key, 'Ashley', options) - assert_equal('Control', variation) - end - - def test_nil_variation_when_campaign_not_in_group - campaign_key = MEG_SETTINGS_FILE['campaigns'][4]['key'] - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) - - variation = vwo_instance.activate(campaign_key, 'Ashley') - variation_name = vwo_instance.get_variation_name(campaign_key, 'Ashley') - is_goal_tracked = vwo_instance.track(campaign_key, 'Ashley', 'CUSTOM')[campaign_key] - assert_equal(nil, variation) - assert_equal(nil, variation_name) - assert_equal(false, is_goal_tracked) - end - - def test_no_campaigns_satisfies_presegmentation - campaign_key = MEG_SETTINGS_FILE['campaigns'][0]['key'] - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) - options = { - customVariables: { - "browser" => "chrome" - } - } - segment_passed = { - "or" => [ - [ - custom_variable: { - chrome: "false" - } - ] - ] - } - - vwo_instance.get_settings['campaigns'][0]['segments'] = segment_passed - vwo_instance.get_settings['campaigns'][1]['segments'] = segment_passed - - variation = vwo_instance.feature_enabled?(campaign_key, 'Ashley', options) - variable_value = vwo_instance.get_feature_variable_value(campaign_key, 'STRING_VARIABLE', 'Ashley', options) - assert_equal(false, variation) #debug - assert_equal(nil, variable_value) #debug - - #implementing the same condition with zero traffic percentage - vwo_instance.get_settings['campaigns'][0]['percentTraffic'] = 0 - vwo_instance.get_settings['campaigns'][1]['percentTraffic'] = 0 - variation = vwo_instance.feature_enabled?(campaign_key, 'Ashley', options) - variable_value = vwo_instance.get_feature_variable_value(campaign_key, 'STRING_VARIABLE', 'Ashley', options) - assert_equal(false, variation) - assert_equal(nil, variable_value) - end - - def test_called_campaign_not_satisfying_presegmentation - campaign_key = MEG_SETTINGS_FILE['campaigns'][0]['key'] - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) - options = { - customVariables: { - "browser" => "chrome" - } + def test_variation_return_as_whitelisting + campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) + options = { + variation_targeting_variables: { + 'chrome' => 'false' + } + } + # called campaign satisfies the whitelisting + variation = vwo_instance.activate(campaign_key, 'Ashley', options) + variation_name = vwo_instance.get_variation_name(campaign_key, 'Ashley', options) + is_goal_tracked = vwo_instance.track(campaign_key, 'Ashley', 'CUSTOM', options)[campaign_key] + assert_equal(variation, 'Variation-1') + assert_equal(variation_name, 'Variation-1') + assert_equal(is_goal_tracked, true) + end + + def test_null_variation_as_other_campaign_satisfies_whitelisting + campaign_key = MEG_SETTINGS_FILE['campaigns'][3]['key'] + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) + options = { + variation_targeting_variables: { + 'chrome' => 'false' + } + } + + variation = vwo_instance.activate(campaign_key, 'Ashley', options) + is_goal_tracked = vwo_instance.track(campaign_key, 'Ashley', 'CUSTOM', options) + variation_name = vwo_instance.get_variation_name(campaign_key, 'Ashley', options) + assert_equal(nil, variation) + assert_equal(nil, variation_name) + assert_equal(false, is_goal_tracked[campaign_key]) + end + + def test_variation_for_called_campaign + campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, CustomUserStorage.new, true, JSON.generate(MEG_SETTINGS_FILE)) + + variation = vwo_instance.activate(campaign_key, 'Ashley') + is_goal_tracked = vwo_instance.track(campaign_key, 'Ashley', 'CUSTOM')[campaign_key] + variation_name = vwo_instance.get_variation_name(campaign_key, 'Ashley') + assert_equal('Control', variation) + assert_equal('Control', variation_name) + assert_equal(true, is_goal_tracked) + end + + def test_null_variation_as_other_campaign_satisfies_storage + campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] + variation_info = { + 'user_id' => 'Ashley', + 'name' => 'Control', + 'campaign_key' => campaign_key + } + user_storage = CustomUserStorage.new + user_storage.set(variation_info) + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, user_storage, true, JSON.generate(MEG_SETTINGS_FILE)) + + variation = vwo_instance.activate(campaign_key, 'Ashley') + is_goal_tracked = vwo_instance.track(campaign_key, 'Ashley', 'CUSTOM')[campaign_key] + variation_name = vwo_instance.get_variation_name(campaign_key, 'Ashley') + assert_equal('Control', variation) + assert_equal('Control', variation_name) + assert_equal(true, is_goal_tracked) + + campaign_key = MEG_SETTINGS_FILE['campaigns'][3]['key'] + variation = vwo_instance.activate(campaign_key, 'Ashley') + is_goal_tracked = vwo_instance.track(campaign_key, 'Ashley', 'CUSTOM')[campaign_key] + variation_name = vwo_instance.get_variation_name(campaign_key, 'Ashley') + assert_equal(nil, variation) + assert_equal(nil, variation_name) + assert_equal(false, is_goal_tracked) + user_storage.remove('Ashley') + end + + def test_variation_for_called_campaign_in_storage_and_other_campaign_satisfies_whitelisting + campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, CustomUserStorage.new, true, JSON.generate(MEG_SETTINGS_FILE)) + options = { + variation_targeting_variables: { + 'browser' => 'chrome' + } + } + + segment_passed = { + 'or' => [ + 'custom_variable' => { + 'browser' => 'chrome' } - segment_failed = { - "or" => [ - [ - custom_variable: { - chrome: "false" - } - ] - ] + ] + } + + variation = vwo_instance.activate(campaign_key, 'Ashley') + assert_equal('Control', variation) + vwo_instance.get_settings['campaigns'][1]['segments'] = segment_passed + variation = vwo_instance.activate(campaign_key, 'Ashley', options) + assert_equal('Control', variation) + end + + def test_nil_variation_when_campaign_not_in_group + campaign_key = MEG_SETTINGS_FILE['campaigns'][4]['key'] + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) + + variation = vwo_instance.activate(campaign_key, 'Ashley') + variation_name = vwo_instance.get_variation_name(campaign_key, 'Ashley') + is_goal_tracked = vwo_instance.track(campaign_key, 'Ashley', 'CUSTOM')[campaign_key] + assert_equal(nil, variation) + assert_equal(nil, variation_name) + assert_equal(false, is_goal_tracked) + end + + def test_no_campaigns_satisfies_presegmentation + campaign_key = MEG_SETTINGS_FILE['campaigns'][0]['key'] + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) + options = { + customVariables: { + 'browser' => 'chrome' + } + } + segment_passed = { + 'or' => [ + [ + custom_variable: { + chrome: 'false' + } + ] + ] + } + + vwo_instance.get_settings['campaigns'][0]['segments'] = segment_passed + vwo_instance.get_settings['campaigns'][1]['segments'] = segment_passed + + variation = vwo_instance.feature_enabled?(campaign_key, 'Ashley', options) + variable_value = vwo_instance.get_feature_variable_value(campaign_key, 'STRING_VARIABLE', 'Ashley', options) + assert_equal(false, variation) # debug + assert_equal(nil, variable_value) # debug + + # implementing the same condition with zero traffic percentage + vwo_instance.get_settings['campaigns'][0]['percentTraffic'] = 0 + vwo_instance.get_settings['campaigns'][1]['percentTraffic'] = 0 + variation = vwo_instance.feature_enabled?(campaign_key, 'Ashley', options) + variable_value = vwo_instance.get_feature_variable_value(campaign_key, 'STRING_VARIABLE', 'Ashley', options) + assert_equal(false, variation) + assert_equal(nil, variable_value) + end + + def test_called_campaign_not_satisfying_presegmentation + campaign_key = MEG_SETTINGS_FILE['campaigns'][0]['key'] + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) + options = { + customVariables: { + 'browser' => 'chrome' + } + } + segment_failed = { + 'or' => [ + [ + custom_variable: { + chrome: 'false' + } + ] + ] + } + + segment_passed = { + 'or' => [ + [ + custom_variable: { + browser: 'chrome' + } + ] + ] + } + + vwo_instance.get_settings['campaigns'][0]['segments'] = segment_failed + vwo_instance.get_settings['campaigns'][1]['segments'] = segment_passed + variation = vwo_instance.feature_enabled?(campaign_key, 'Ashley', options) + variable_value = vwo_instance.get_feature_variable_value(campaign_key, 'STRING_VARIABLE', 'Ashley', options) + assert_equal(false, variation) + assert_equal(nil, variable_value) + + # implementing the same condition with different traffic percentage + vwo_instance.get_settings['campaigns'][0]['percentTraffic'] = 0 + vwo_instance.get_settings['campaigns'][1]['percentTraffic'] = 100 + variation = vwo_instance.feature_enabled?(campaign_key, 'Ashley', options) + variable_value = vwo_instance.get_feature_variable_value(campaign_key, 'STRING_VARIABLE', 'Ashley', options) + assert_equal(false, variation) + assert_equal(nil, variable_value) + end + + def test_only_called_campaign_satisfy_presegmentation + campaign_key = MEG_SETTINGS_FILE['campaigns'][0]['key'] + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) + options = { + custom_variables: { + 'browser' => 'chrome' + } + } + segment_failed = { + 'or' => [ + 'custom_variable' => { + 'chrome' => 'false' } + ] + } - segment_passed = { - "or" => [ - [ - custom_variable: { - browser: "chrome" - } - ] - ] + segment_passed = { + 'or' => [ + 'custom_variable' => { + 'browser' => 'chrome' } - - vwo_instance.get_settings['campaigns'][0]['segments'] = segment_failed - vwo_instance.get_settings['campaigns'][1]['segments'] = segment_passed - variation = vwo_instance.feature_enabled?(campaign_key, 'Ashley', options) - variable_value = vwo_instance.get_feature_variable_value(campaign_key, 'STRING_VARIABLE', 'Ashley', options) - assert_equal(false, variation) - assert_equal(nil, variable_value) - - #implementing the same condition with different traffic percentage - vwo_instance.get_settings['campaigns'][0]['percentTraffic'] = 0 - vwo_instance.get_settings['campaigns'][1]['percentTraffic'] = 100 - variation = vwo_instance.feature_enabled?(campaign_key, 'Ashley', options) - variable_value = vwo_instance.get_feature_variable_value(campaign_key, 'STRING_VARIABLE', 'Ashley', options) - assert_equal(false, variation) - assert_equal(nil, variable_value) - end - - def test_only_called_campaign_satisfy_presegmentation - campaign_key = MEG_SETTINGS_FILE['campaigns'][0]['key'] - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) - options = { - custom_variables: { - "browser" => "chrome" - } - } - segment_failed = { - "or" => [ - "custom_variable"=> { - "chrome"=> "false" - } - ] - } - - segment_passed = { - "or" => [ - "custom_variable"=> { - "browser"=> "chrome" - } - ] - } - - vwo_instance.get_settings['campaigns'][0]['segments'] = segment_passed - vwo_instance.get_settings['campaigns'][1]['segments'] = segment_failed - - variation = vwo_instance.feature_enabled?(campaign_key, 'Ashley', options) - variable_value = vwo_instance.get_feature_variable_value(campaign_key, 'STRING_VARIABLE', 'Ashley', options) - assert_equal(true, variation) - assert_equal('Control string', variable_value) - - # #implementing the same condition with different traffic percentage - vwo_instance.get_settings['campaigns'][0]['percentTraffic'] = 100 - vwo_instance.get_settings['campaigns'][1]['percentTraffic'] = 0 - variation = vwo_instance.feature_enabled?(campaign_key, 'Ashley', options) - variable_value = vwo_instance.get_feature_variable_value(campaign_key, 'STRING_VARIABLE', 'Ashley', options) - assert_equal(true, variation) - assert_equal('Control string', variable_value) - end - - def test_called_campaign_winner_campaign - campaign_key = MEG_SETTINGS_FILE['campaigns'][0]['key'] - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) - - # implementing the same condition with same traffic distribution - vwo_instance.get_settings['campaigns'][0]['percentTraffic'] = 100 - vwo_instance.get_settings['campaigns'][1]['percentTraffic'] = 100 - variation = vwo_instance.feature_enabled?(campaign_key, 'Ashley') - variable_value = vwo_instance.get_feature_variable_value(campaign_key, 'STRING_VARIABLE', 'Ashley') - assert_equal(true, variation) - assert_equal('Control string', variable_value) - - campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] - variation = vwo_instance.activate(campaign_key, 'Ashley') - variation_name = vwo_instance.get_variation_name(campaign_key, 'Ashley') - is_goal_tracked = vwo_instance.track(campaign_key, 'Ashley', 'CUSTOM')[campaign_key] - assert_equal('Control', variation) - assert_equal('Control', variation_name) - assert_equal(true, is_goal_tracked) - end - - def test_called_campaign_not_winner_campaign - campaign_key = MEG_SETTINGS_FILE['campaigns'][0]['key'] - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) - - # implementing the same condition with same traffic distribution - vwo_instance.get_settings['campaigns'][0]['percentTraffic'] = 100 - vwo_instance.get_settings['campaigns'][1]['percentTraffic'] = 100 - variation = vwo_instance.feature_enabled?(campaign_key, 'lisa') - assert_equal(false, variation) - - campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] - variation = vwo_instance.activate(campaign_key, 'lisa') - assert_equal("Variation-1", variation) - end - - def test_when_equal_traffic_among_eligible_campaigns - campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) - - # implementing the same condition with different traffic distribution - vwo_instance.get_settings['campaigns'][2]['percentTraffic'] = 80 - vwo_instance.get_settings['campaigns'][3]['percentTraffic'] = 50 - variation = vwo_instance.activate(campaign_key, 'Ashley') - assert_equal('Variation-1', variation) - end - - def test_when_both_campaigns_new_to_user - campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) - variation = vwo_instance.activate(campaign_key, 'Ashley') - assert_equal('Control', variation) - # campaigns are newly added to MEG. - # user could be a part of any one of the campaign. - campaign_key = MEG_SETTINGS_FILE['campaigns'][3]['key'] - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) - variation = vwo_instance.activate(campaign_key, 'Ashley') - assert_equal(nil, variation) - end - - def test_when_user_already_part_of_campaign_and_new_campaign_added_to_group - campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] - variationInfo = { - "user_id" => 'Ashley', - "variation_name" => 'Control', - "campaign_key" => campaign_key - } - user_storage = CustomUserStorage.new - user_storage.set(variationInfo) - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, user_storage, true, JSON.generate(MEG_SETTINGS_FILE)) - # user is already a part of a campaign - variation = vwo_instance.activate(campaign_key, 'Ashley') - assert_equal('Control', variation) - - # new campaign is added to the group - vwo_instance.get_settings['campaignGroups']['164'] = 2 - vwo_instance.get_settings['groups']["2"]['campaigns'].push(164) - campaign_key = MEG_SETTINGS_FILE['campaigns'][4]['key'] - variation = vwo_instance.activate(campaign_key, 'Ashley') - assert_equal(nil, variation) - end - - def test_when_viewed_campaign_removed_from_group - campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] - - variation_info = { - "user_id" => 'Ashley', - "variation_name" => 'Control', - "campaign_key" => campaign_key - } - user_storage = CustomUserStorage.new - user_storage.set(variation_info) - - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, user_storage, true, JSON.generate(MEG_SETTINGS_FILE)) - - # user is already a part of a campaign - variation = vwo_instance.activate(campaign_key, 'Ashley') - assert_equal('Control', variation) - - # old campaign is removed from the group - vwo_instance.get_settings['groups']["2"]['campaigns'] = [163] - # since user has already seen that campaign, they will continue to become part of that campaign - variation = vwo_instance.activate(campaign_key, 'Ashley') - assert_equal('Control', variation) - end + ] + } + + vwo_instance.get_settings['campaigns'][0]['segments'] = segment_passed + vwo_instance.get_settings['campaigns'][1]['segments'] = segment_failed + + variation = vwo_instance.feature_enabled?(campaign_key, 'Ashley', options) + variable_value = vwo_instance.get_feature_variable_value(campaign_key, 'STRING_VARIABLE', 'Ashley', options) + assert_equal(true, variation) + assert_equal('Control string', variable_value) + + # #implementing the same condition with different traffic percentage + vwo_instance.get_settings['campaigns'][0]['percentTraffic'] = 100 + vwo_instance.get_settings['campaigns'][1]['percentTraffic'] = 0 + variation = vwo_instance.feature_enabled?(campaign_key, 'Ashley', options) + variable_value = vwo_instance.get_feature_variable_value(campaign_key, 'STRING_VARIABLE', 'Ashley', options) + assert_equal(true, variation) + assert_equal('Control string', variable_value) + end + + def test_called_campaign_winner_campaign + campaign_key = MEG_SETTINGS_FILE['campaigns'][0]['key'] + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) + + # implementing the same condition with same traffic distribution + vwo_instance.get_settings['campaigns'][0]['percentTraffic'] = 100 + vwo_instance.get_settings['campaigns'][1]['percentTraffic'] = 100 + variation = vwo_instance.feature_enabled?(campaign_key, 'Ashley') + variable_value = vwo_instance.get_feature_variable_value(campaign_key, 'STRING_VARIABLE', 'Ashley') + assert_equal(true, variation) + assert_equal('Control string', variable_value) + + campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] + variation = vwo_instance.activate(campaign_key, 'Ashley') + variation_name = vwo_instance.get_variation_name(campaign_key, 'Ashley') + is_goal_tracked = vwo_instance.track(campaign_key, 'Ashley', 'CUSTOM')[campaign_key] + assert_equal('Control', variation) + assert_equal('Control', variation_name) + assert_equal(true, is_goal_tracked) + end + + def test_called_campaign_not_winner_campaign + campaign_key = MEG_SETTINGS_FILE['campaigns'][0]['key'] + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) + + # implementing the same condition with same traffic distribution + vwo_instance.get_settings['campaigns'][0]['percentTraffic'] = 100 + vwo_instance.get_settings['campaigns'][1]['percentTraffic'] = 100 + variation = vwo_instance.feature_enabled?(campaign_key, 'lisa') + assert_equal(false, variation) + + campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] + variation = vwo_instance.activate(campaign_key, 'lisa') + assert_equal('Variation-1', variation) + end + + def test_when_equal_traffic_among_eligible_campaigns + campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) + + # implementing the same condition with different traffic distribution + vwo_instance.get_settings['campaigns'][2]['percentTraffic'] = 80 + vwo_instance.get_settings['campaigns'][3]['percentTraffic'] = 50 + variation = vwo_instance.activate(campaign_key, 'Ashley') + assert_equal('Variation-1', variation) + end + + def test_when_both_campaigns_new_to_user + campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) + variation = vwo_instance.activate(campaign_key, 'Ashley') + assert_equal('Control', variation) + # campaigns are newly added to MEG. + # user could be a part of any one of the campaign. + campaign_key = MEG_SETTINGS_FILE['campaigns'][3]['key'] + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(MEG_SETTINGS_FILE)) + variation = vwo_instance.activate(campaign_key, 'Ashley') + assert_equal(nil, variation) + end + + def test_when_user_already_part_of_campaign_and_new_campaign_added_to_group + campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] + variation_info = { + 'user_id' => 'Ashley', + 'variation_name' => 'Control', + 'campaign_key' => campaign_key + } + user_storage = CustomUserStorage.new + user_storage.set(variation_info) + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, user_storage, true, JSON.generate(MEG_SETTINGS_FILE)) + # user is already a part of a campaign + variation = vwo_instance.activate(campaign_key, 'Ashley') + assert_equal('Control', variation) + + # new campaign is added to the group + vwo_instance.get_settings['campaignGroups']['164'] = 2 + vwo_instance.get_settings['groups']['2']['campaigns'].push(164) + campaign_key = MEG_SETTINGS_FILE['campaigns'][4]['key'] + variation = vwo_instance.activate(campaign_key, 'Ashley') + assert_equal(nil, variation) + end + + def test_when_viewed_campaign_removed_from_group + campaign_key = MEG_SETTINGS_FILE['campaigns'][2]['key'] + + variation_info = { + 'user_id' => 'Ashley', + 'variation_name' => 'Control', + 'campaign_key' => campaign_key + } + user_storage = CustomUserStorage.new + user_storage.set(variation_info) + + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, user_storage, true, JSON.generate(MEG_SETTINGS_FILE)) + + # user is already a part of a campaign + variation = vwo_instance.activate(campaign_key, 'Ashley') + assert_equal('Control', variation) + + # old campaign is removed from the group + vwo_instance.get_settings['groups']['2']['campaigns'] = [163] + # since user has already seen that campaign, they will continue to become part of that campaign + variation = vwo_instance.activate(campaign_key, 'Ashley') + assert_equal('Control', variation) + end end diff --git a/tests/test_segment_evaluator.rb b/tests/test_segment_evaluator.rb index 2b66d75..9e3288e 100644 --- a/tests/test_segment_evaluator.rb +++ b/tests/test_segment_evaluator.rb @@ -28,7 +28,7 @@ def test_segmentation_expectations custom_variables = test_case_value['custom_variables'] || test_case_value['variation_targeting_variables'] dsl = test_case_value['dsl'] expectation = test_case_value['expectation'] - result = VWO::Services::SegmentEvaluator.new.evaluate("dummyCampaignKey", "dummyUserId", dsl, custom_variables) + result = VWO::Services::SegmentEvaluator.new.evaluate('dummyCampaignKey', 'dummyUserId', dsl, custom_variables) assert_equal(result, expectation) end end diff --git a/tests/test_settings_file_manager.rb b/tests/test_settings_file_manager.rb index c382d94..34e3eb3 100644 --- a/tests/test_settings_file_manager.rb +++ b/tests/test_settings_file_manager.rb @@ -17,6 +17,7 @@ class GetDummyResponse attr_reader :code, :body + def initialize(code, body) @code = code @body = body @@ -29,14 +30,14 @@ def initialize end end -ACCOUNT_ID = 60781 +ACCOUNT_ID = 60_781 SDK_KEY = 'ea87170ad94079aa190bc7c9b85d26fb' class SettingsFileManagerTest < Test::Unit::TestCase # Test that VWO::GetSettings.new fires off requests call with provided account_id and sdk_key. def test_get_settings_fires_request Net::HTTP.class_eval do - def self.get_response(*args) + def self.get_response(*_args) GetDummyResponse.new('200', 'dummy_setting_file') end end @@ -58,7 +59,7 @@ def self.get_response(*args) # Test that VWO::GetSettings.new returns nil if status_code != 200. def test_get_settings_error_status_code Net::HTTP.class_eval do - def self.get_response(*args) + def self.get_response(*_args) # rubocop:todo Lint/DuplicateMethods GetDummyResponse.new('400', 'dummy_setting_file') end end @@ -68,7 +69,7 @@ def self.get_response(*args) def test_get_settings_with_exception Net::HTTP.class_eval do - def self.get_response(*args) + def self.get_response(*_args) # rubocop:todo Lint/DuplicateMethods DummyErrorResponse.new end end diff --git a/tests/test_utility.rb b/tests/test_utility.rb index d997e11..d235467 100644 --- a/tests/test_utility.rb +++ b/tests/test_utility.rb @@ -23,36 +23,35 @@ class UtilityTest < Test::Unit::TestCase include VWO::CONSTANTS def test_convert_to_symbol_hash_with_valid_hash - hashObject = { 'name': 'CUSTOM' } + hash_object = { 'name': 'CUSTOM' } expectation = { name: 'CUSTOM' } - result = convert_to_symbol_hash(hashObject) + result = convert_to_symbol_hash(hash_object) assert_equal(expectation, result) end def test_convert_to_symbol_hash_with_empty_hash - hashObject = {} + hash_object = {} expectation = {} - result = convert_to_symbol_hash(hashObject) + result = convert_to_symbol_hash(hash_object) assert_equal(expectation, result) end def test_convert_to_symbol_hash_with_nil - hashObject = nil + hash_object = nil expectation = {} - result = convert_to_symbol_hash(hashObject) + result = convert_to_symbol_hash(hash_object) assert_equal(expectation, result) end def test_get_url_without settings = {} - DataLocationManager.get_instance().set_settings(settings) + DataLocationManager.get_instance.set_settings(settings) assert_equal(ENDPOINTS::BASE_URL, get_url('')) end def test_get_url_with_data - settings = {"collectionPrefix" => "eu"} - DataLocationManager.get_instance().set_settings(settings) - assert_equal(ENDPOINTS::BASE_URL+"/eu", get_url('')) + settings = { 'collectionPrefix' => 'eu' } + DataLocationManager.get_instance.set_settings(settings) + assert_equal("#{ENDPOINTS::BASE_URL}/eu", get_url('')) end - end diff --git a/tests/test_variation_decider.rb b/tests/test_variation_decider.rb index ce107eb..64d494a 100644 --- a/tests/test_variation_decider.rb +++ b/tests/test_variation_decider.rb @@ -28,8 +28,8 @@ def get(user_id, campaign_key) end def set(user_storage_obj) - @@client_db[user_storage_obj['user_id']] = {} - @@client_db[user_storage_obj['user_id']][user_storage_obj['campaign_key']] = user_storage_obj + @@client_db[user_storage_obj['user_id']] = {} + @@client_db[user_storage_obj['user_id']][user_storage_obj['campaign_key']] = user_storage_obj end def remove(user_id) @@ -41,7 +41,7 @@ class BrokenUserStorage @@client_db = {} def get(user_id, campaign_key) - return @@client_db[user_id][campaign_key] + @@client_db[user_id][campaign_key] end def set(_user_storage_obj) @@ -113,7 +113,7 @@ def test_get_variation_of_campaign_for_user_none_campaing_passed assert_nil(variation) end - def test_get_variation_of_campaign_for_user_should_return_Control + def test_get_variation_of_campaign_for_user_should_return_control user_id = 'Sarah' # Sarah, with above campaign settings, will get hashValue:69650962 # and bucketValue:326. So, MUST be a part of Control, as per campaign @@ -123,7 +123,7 @@ def test_get_variation_of_campaign_for_user_should_return_Control assert_equal(variation['name'], 'Control') end - def test_get_variation_of_campaign_for_user_should_return_Variation + def test_get_variation_of_campaign_for_user_should_return_variation user_id = 'Varun' # Varun, with above campaign settings, will get hashValue:2025462540 # and bucketValue:9433. So, MUST be a part of Variation, as per campaign @@ -138,7 +138,7 @@ def test_get_none_userid_passed end def test_get_none_campaign_passed - variation = @variation_decider.get_variation(@user_id, nil, '', @campaign_key) + variation = @variation_decider.get_variation(@user_id, nil, '', @campaign_key) assert_nil(variation) end @@ -207,33 +207,32 @@ def test_get_with_user_storage_but_no_stored_variation assert_equal(variation['name'], 'Control') end - def test_Variation_data_for_real_time_pre_segmentation + def test_variation_data_for_real_time_pre_segmentation user_id = 'Sarah' settings_file = VWO_SETTINGS_FILE['REAL_TIME_PRE_SEGEMENTATION'] campaign = settings_file['campaigns'][0] campaign_key = campaign['key'] set_variation_allocation(campaign) variation_decider = VWO::Core::VariationDecider.new(settings_file) - variation = variation_decider.get_variation(user_id, campaign, 'test_cases', campaign_key, {a: 123}) + variation = variation_decider.get_variation(user_id, campaign, 'test_cases', campaign_key, { a: 123 }) assert_equal(variation['name'], 'Control') - storage = CustomUserStorage.new + storage = CustomUserStorage.new new_campaign_user_mapping = {} new_campaign_user_mapping['campaign_key'] = campaign_key new_campaign_user_mapping['user_id'] = user_id new_campaign_user_mapping['variation_name'] = 'Variation-1' # setting variation-1 in storage then we get variation-1 when isAlwaysCheckSegment flag not there storage.set(new_campaign_user_mapping) - campaign.delete("isAlwaysCheckSegment") + campaign.delete('isAlwaysCheckSegment') variation_decider = VWO::Core::VariationDecider.new(settings_file, storage) assert_equal(storage.get(user_id, campaign_key)['variation_name'], new_campaign_user_mapping['variation_name']) - variation = variation_decider.get_variation(user_id, campaign, 'test_cases', campaign_key, {a: 123}) + variation = variation_decider.get_variation(user_id, campaign, 'test_cases', campaign_key, { a: 123 }) assert_equal(variation['name'], new_campaign_user_mapping['variation_name']) # variation-1 is there in storage but we get Control when isAlwaysCheckSegment flag is set - campaign["isAlwaysCheckSegment"] = true - variation = variation_decider.get_variation(user_id, campaign, 'test_cases', campaign_key, {a: 123}) + campaign['isAlwaysCheckSegment'] = true + variation = variation_decider.get_variation(user_id, campaign, 'test_cases', campaign_key, { a: 123 }) assert_equal(variation['name'], 'Control') - end end diff --git a/tests/test_vwo.rb b/tests/test_vwo.rb index 340f16b..375c5ab 100644 --- a/tests/test_vwo.rb +++ b/tests/test_vwo.rb @@ -20,7 +20,7 @@ class Object def stub_and_raise(fn_name, raise_error) - self.singleton_class.send(:define_method, fn_name.to_s) do + singleton_class.send(:define_method, fn_name.to_s) do raise raise_error end end @@ -32,7 +32,6 @@ def stub_and_raise(fn_name, raise_error) SETTINGS_FILE = JSON.load(File.open(File.join(File.dirname(__FILE__), 'data/settings.json'))) USER_EXPECTATIONS = JSON.load(File.open(File.join(File.dirname(__FILE__), 'data/user_expectations.json'))) - class VWO class Logger def log(level, message) @@ -42,10 +41,9 @@ def log(level, message) end class VWOTest < Test::Unit::TestCase - def set_up(config_variant = 'AB_T_50_W_50_50') @user_id = rand.to_s - @vwo = VWO.new(888888, '1234567ad94079aa190bc7c9b7654321', nil, nil, true, JSON.generate(SETTINGS_FILE[config_variant] || {})) + @vwo = VWO.new(888_888, '1234567ad94079aa190bc7c9b7654321', nil, nil, true, JSON.generate(SETTINGS_FILE[config_variant] || {})) @campaign_key = config_variant begin @goal_identifier = SETTINGS_FILE[config_variant]['campaigns'][0]['goals'][0]['identifier'] @@ -55,20 +53,18 @@ def set_up(config_variant = 'AB_T_50_W_50_50') end def mock_track(campaign_key, user_id, goal_identifier, options = {}) - revenue_value = nil - custom_variables = nil revenue_value = options['revenue_value'] || options[:revenue_value] custom_variables = options['custom_variables'] || options[:custom_variables] - if custom_variables - return { - 'campaign_key' => campaign_key, - 'user_id' => user_id, - 'goal_identifier' => goal_identifier, - 'revenue_value' => revenue_value, - 'custom_variables' => custom_variables - } - end + return unless custom_variables + + { + 'campaign_key' => campaign_key, + 'user_id' => user_id, + 'goal_identifier' => goal_identifier, + 'revenue_value' => revenue_value, + 'custom_variables' => custom_variables + } end # Test initialization @@ -95,16 +91,14 @@ def test_get_variation_invalid_config assert_equal(@vwo.get_variation_name(@user_id, 'some_campaign'), nil) end - - def test_get_variation_against_campaign_traffic_50_and_split_50_50 + def test_get_variation_against_campaign_traffic_50_and_split_50_50_percent set_up('AB_T_50_W_50_50') USER_EXPECTATIONS[@campaign_key].each do |test| assert_equal(@vwo.get_variation_name(@campaign_key, test['user']), test['variation']) end end - - def test_get_variation_against_campaign_traffic_100_and_split_50_50 + def test_get_variation_against_campaign_traffic_100_and_split_50_50_percent set_up('AB_T_100_W_50_50') USER_EXPECTATIONS[@campaign_key].each do |test| assert_equal(@vwo.get_variation_name(@campaign_key, test['user']), test['variation']) @@ -118,21 +112,21 @@ def test_get_variation_against_campaign_traffic_100_and_split_25_25_25_25_with_f end end - def test_get_variation_against_campaign_traffic_100_and_split_20_80 + def test_get_variation_against_campaign_traffic_100_and_split_20_80_percent set_up('AB_T_100_W_20_80') USER_EXPECTATIONS[@campaign_key].each do |test| assert_equal(@vwo.get_variation_name(@campaign_key, test['user']), test['variation']) end end - def test_get_variation_against_campaign_traffic_20_and_split_10_90 + def test_get_variation_against_campaign_traffic_20_and_split_10_90_percent set_up('AB_T_20_W_10_90') USER_EXPECTATIONS[@campaign_key].each do |test| assert_equal(@vwo.get_variation_name(@campaign_key, test['user']), test['variation']) end end - def test_get_variation_against_campaign_traffic_100_and_split_0_100 + def test_get_variation_against_campaign_traffic_100_and_split_0_100_percent set_up('AB_T_100_W_0_100') USER_EXPECTATIONS[@campaign_key].each do |test| assert_equal(@vwo.get_variation_name(@campaign_key, test['user']), test['variation']) @@ -146,7 +140,7 @@ def test_get_variation_against_campaign_traffic_100_and_split_33_x3 end end - def test_get_variation_name_against_campaign_traffic_75_and_split_10_TIMES_10 + def test_get_variation_name_against_campaign_traffic_75_and_split_10_times_10_percent set_up('T_75_W_10_TIMES_10') USER_EXPECTATIONS[@campaign_key].each do |test| assert_equal(@vwo.get_variation_name(@campaign_key, test['user']), test['variation']) @@ -155,7 +149,7 @@ def test_get_variation_name_against_campaign_traffic_75_and_split_10_TIMES_10 # Test activate def test_activate_invalid_params - set_up() + set_up assert_equal(@vwo.activate(123, 456), nil) end @@ -171,35 +165,35 @@ def test_activate_with_no_campaign_key_found end end - def test_activate_against_campaign_traffic_50_and_split_50_50 + def test_activate_against_campaign_traffic_50_and_split_50_50_percent set_up('AB_T_50_W_50_50') USER_EXPECTATIONS[@campaign_key].each do |test| assert_equal(@vwo.activate(@campaign_key, test['user']), test['variation']) end end - def test_activate_against_campaign_traffic_100_and_split_50_50 + def test_activate_against_campaign_traffic_100_and_split_50_50_percent set_up('AB_T_100_W_50_50') USER_EXPECTATIONS[@campaign_key].each do |test| assert_equal(@vwo.activate(@campaign_key, test['user']), test['variation']) end end - def test_activate_against_campaign_traffic_100_and_split_20_80 + def test_activate_against_campaign_traffic_100_and_split_20_80_percent set_up('AB_T_100_W_20_80') USER_EXPECTATIONS[@campaign_key].each do |test| assert_equal(@vwo.activate(@campaign_key, test['user']), test['variation']) end end - def test_activate_against_campaign_traffic_20_and_split_10_90 + def test_activate_against_campaign_traffic_20_and_split_10_90_percent set_up('AB_T_20_W_10_90') USER_EXPECTATIONS[@campaign_key].each do |test| assert_equal(@vwo.activate(@campaign_key, test['user']), test['variation']) end end - def test_activate_against_campaign_traffic_100_and_split_0_100 + def test_activate_against_campaign_traffic_100_and_split_0_100_percent set_up('AB_T_100_W_0_100') USER_EXPECTATIONS[@campaign_key].each do |test| assert_equal(@vwo.activate(@campaign_key, test['user']), test['variation']) @@ -209,13 +203,13 @@ def test_activate_against_campaign_traffic_100_and_split_0_100 def test_activate_against_campaign_traffic_100_and_split_33_x3 set_up('AB_T_100_W_33_33_33') USER_EXPECTATIONS[@campaign_key].each do |test| - assert_equal(@vwo.activate(@campaign_key,test['user']), test['variation']) + assert_equal(@vwo.activate(@campaign_key, test['user']), test['variation']) end end # Test track def test_track_invalid_params - set_up() + set_up assert_equal(@vwo.track(123, 456, 789), false) end @@ -244,10 +238,10 @@ def test_track_wrong_campaign_type_passed assert_equal(result, nil) end - def test_track_against_campaign_traffic_50_and_split_50_50 + def test_track_against_campaign_traffic_50_and_split_50_50_percent set_up('AB_T_50_W_50_50') USER_EXPECTATIONS[@campaign_key].each do |test| - assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier), {@campaign_key => !test['variation'].nil?}) + assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier), { @campaign_key => !test['variation'].nil? }) end end @@ -255,7 +249,7 @@ def test_track_against_campaign_traffic_100_and_split_50_50_r_int # It's goal_type is revenue, so test revenue set_up('AB_T_100_W_50_50') USER_EXPECTATIONS[@campaign_key].each do |test| - assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier, {revenue_value: 23}), {@campaign_key => !test['variation'].nil?}) + assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier, { revenue_value: 23 }), { @campaign_key => !test['variation'].nil? }) end end @@ -263,7 +257,7 @@ def test_track_against_campaign_traffic_100_and_split_50_50_r_float # It's goal_type is revenue, so test revenue set_up('AB_T_100_W_50_50') USER_EXPECTATIONS[@campaign_key].each do |test| - assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier, {revenue_value: 23.3}), {@campaign_key => !test['variation'].nil?}) + assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier, { revenue_value: 23.3 }), { @campaign_key => !test['variation'].nil? }) end end @@ -271,7 +265,7 @@ def test_track_against_campaign_traffic_100_and_split_50_50_r_str # It's goal_type is revenue, so test revenue set_up('AB_T_100_W_50_50') USER_EXPECTATIONS[@campaign_key].each do |test| - assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier, {revenue_value: '23.3'}), {@campaign_key => !test['variation'].nil?}) + assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier, { revenue_value: '23.3' }), { @campaign_key => !test['variation'].nil? }) end end @@ -279,7 +273,7 @@ def test_track_against_campaign_traffic_100_and_split_50_50_no_r # It's goal_type is revenue, so test revenue set_up('AB_T_100_W_50_50') USER_EXPECTATIONS[@campaign_key].each do |test| - assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier), {@campaign_key => false}) + assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier), { @campaign_key => false }) end end @@ -287,49 +281,49 @@ def test_track_against_campaign_traffic_100_and_split_50_50_options # It's goal_type is revenue, so test revenue set_up('AB_T_100_W_50_50') USER_EXPECTATIONS[@campaign_key].each do |test| - assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier, { 'revenue_value' => 23 }), {@campaign_key => !test['variation'].nil?}) + assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier, { 'revenue_value' => 23 }), { @campaign_key => !test['variation'].nil? }) end end - def test_track_against_campaign_traffic_100_and_split_20_80 + def test_track_against_campaign_traffic_100_and_split_20_80_percent set_up('AB_T_100_W_20_80') USER_EXPECTATIONS[@campaign_key].each do |test| - assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier), {@campaign_key => !test['variation'].nil?}) + assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier), { @campaign_key => !test['variation'].nil? }) end end - def test_track_against_campaign_traffic_20_and_split_10_90 + def test_track_against_campaign_traffic_20_and_split_10_90_percent set_up('AB_T_20_W_10_90') USER_EXPECTATIONS[@campaign_key].each do |test| - assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier), {@campaign_key => !test['variation'].nil?}) + assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier), { @campaign_key => !test['variation'].nil? }) end end - def test_track_against_campaign_traffic_100_and_split_0_100 + def test_track_against_campaign_traffic_100_and_split_0_100_percent set_up('AB_T_100_W_0_100') USER_EXPECTATIONS[@campaign_key].each do |test| - assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier), {@campaign_key => !test['variation'].nil?}) + assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier), { @campaign_key => !test['variation'].nil? }) end end def test_track_against_campaign_traffic_100_and_split_33_x3 set_up('AB_T_100_W_33_33_33') USER_EXPECTATIONS[@campaign_key].each do |test| - assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier), {@campaign_key => !test['variation'].nil?}) + assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier), { @campaign_key => !test['variation'].nil? }) end end def test_track_custom_goal set_up('AB_T_100_W_0_100') USER_EXPECTATIONS[@campaign_key].each do |test| - assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier, {goal_type_to_track: 'CUSTOM'}), {@campaign_key => !test['variation'].nil?}) + assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier, { goal_type_to_track: 'CUSTOM' }), { @campaign_key => !test['variation'].nil? }) end end def test_track_for_invalid_goal_type_to_track set_up('AB_T_100_W_0_100') USER_EXPECTATIONS[@campaign_key].each do |test| - assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier, {goal_type_to_track: 'fs'}), false) + assert_equal(@vwo.track(@campaign_key, test['user'], @goal_identifier, { goal_type_to_track: 'fs' }), false) end end @@ -361,42 +355,42 @@ def test_feature_enabled_wrong_parmas_passed assert_equal(@vwo.feature_enabled?(123, 456), false) end - def test_feature_enabled_FR_W_0 + def test_feature_enabled_fr_w_zero set_up('FR_T_0_W_100') USER_EXPECTATIONS['T_0_W_10_20_30_40'].each do |test| assert_equal(@vwo.feature_enabled?('FR_T_0_W_100', test['user']), !test['variation'].nil?) end end - def test_feature_enabled_FR_W_25 + def test_feature_enabled_fr_w25 set_up('FR_T_25_W_100') USER_EXPECTATIONS['T_25_W_10_20_30_40'].each do |test| assert_equal(@vwo.feature_enabled?('FR_T_25_W_100', test['user']), !test['variation'].nil?) end end - def test_feature_enabled_FR_W_50 + def test_feature_enabled_fr_w50 set_up('FR_T_50_W_100') USER_EXPECTATIONS['T_50_W_10_20_30_40'].each do |test| assert_equal(@vwo.feature_enabled?('FR_T_50_W_100', test['user']), !test['variation'].nil?) end end - def test_feature_enabled_FR_W_75 + def test_feature_enabled_fr_w75 set_up('FR_T_75_W_100') USER_EXPECTATIONS['T_75_W_10_20_30_40'].each do |test| assert_equal(@vwo.feature_enabled?('FR_T_75_W_100', test['user']), !test['variation'].nil?) end end - def test_feature_enabled_FR_W_100 + def test_feature_enabled_fr_w100 set_up('FR_T_100_W_100') USER_EXPECTATIONS['T_100_W_10_20_30_40'].each do |test| assert_equal(@vwo.feature_enabled?('FR_T_100_W_100', test['user']), !test['variation'].nil?) end end - def test_feature_enabled_FT_T_75_W_10_20_30_40 + def test_feature_enabled_ft_t_75_w_10_20_30_40_percent set_up('FT_T_75_W_10_20_30_40') is_feature_not_enabled_variations = ['Control'] USER_EXPECTATIONS['T_75_W_10_20_30_40'].each do |test| @@ -462,9 +456,8 @@ def test_get_feature_variable_value_type_integer_from_rollout assert_equal(result, integer_value) if result end - # Test get_feature_variable_value from feature test from different feature splits - def test_get_feature_variable_value_type_string_from_feature_test_t_0 + def test_get_feature_variable_value_type_string_from_feature_test_t0 set_up('FT_T_0_W_10_20_30_40') result = nil string_variable = USER_EXPECTATIONS['STRING_VARIABLE'] @@ -478,7 +471,7 @@ def test_get_feature_variable_value_type_string_from_feature_test_t_0 assert_equal(result, string_variable[test['variation']]) if result end - def test_get_feature_variable_value_type_string_from_feature_test_t_25 + def test_get_feature_variable_value_type_string_from_feature_test_t25 set_up('FT_T_25_W_10_20_30_40') result = nil string_variable = USER_EXPECTATIONS['STRING_VARIABLE'] @@ -492,7 +485,7 @@ def test_get_feature_variable_value_type_string_from_feature_test_t_25 assert_equal(result, string_variable[test['variation']]) if result end - def test_get_feature_variable_value_type_string_from_feature_test_t_50 + def test_get_feature_variable_value_type_string_from_feature_test_t50 set_up('FT_T_50_W_10_20_30_40') string_variable = USER_EXPECTATIONS['STRING_VARIABLE'] USER_EXPECTATIONS['T_50_W_10_20_30_40'].each do |test| @@ -505,7 +498,7 @@ def test_get_feature_variable_value_type_string_from_feature_test_t_50 end end - def test_get_feature_variable_value_type_string_from_feature_test_t_75 + def test_get_feature_variable_value_type_string_from_feature_test_t75 set_up('FT_T_75_W_10_20_30_40') string_variable = USER_EXPECTATIONS['STRING_VARIABLE'] USER_EXPECTATIONS['T_75_W_10_20_30_40'].each do |test| @@ -518,7 +511,7 @@ def test_get_feature_variable_value_type_string_from_feature_test_t_75 end end - def test_get_feature_variable_value_type_string_from_feature_test_t_100 + def test_get_feature_variable_value_type_string_from_feature_test_t100 set_up('FT_T_100_W_10_20_30_40') string_variable = USER_EXPECTATIONS['STRING_VARIABLE'] USER_EXPECTATIONS['T_100_W_10_20_30_40'].each do |test| @@ -531,7 +524,7 @@ def test_get_feature_variable_value_type_string_from_feature_test_t_100 end end - def test_get_feature_variable_value_type_string_from_feature_test_t_100_isFeatureEnalbed + def test_get_feature_variable_value_type_string_from_feature_test_t_100_is_feature_enabled # isFeatureEnalbed is false for variation-1 and variation-3, # should return variable from Control set_up('FT_T_100_W_10_20_30_40_IFEF') @@ -543,7 +536,7 @@ def test_get_feature_variable_value_type_string_from_feature_test_t_100_isFeatur test['user'] ) variation_name = test['variation'] - variation_name = 'Control' if ['Variation-1', 'Variation-3'].include?(variation_name) + variation_name = 'Control' if %w[Variation-1 Variation-3].include?(variation_name) assert_equal(result, string_variable[variation_name]) if result end end @@ -551,13 +544,13 @@ def test_get_feature_variable_value_type_string_from_feature_test_t_100_isFeatur def test_get_feature_variable_wrong_variable_types set_up('FR_WRONG_VARIABLE_TYPE') tests = [ - ["STRING_TO_INTEGER", 123, "integer", Integer], - ["STRING_TO_FLOAT", 123.456, "double", Float], - ["BOOLEAN_TO_STRING", "true", "string", String], - ["INTEGER_TO_STRING", "24", "string", String], - ["INTEGER_TO_FLOAT", 24.0, "double", Float], - ["FLOAT_TO_STRING", "24.24", "string", String], - ["FLOAT_TO_INTEGER", 24, "integer", Integer] + ['STRING_TO_INTEGER', 123, 'integer', Integer], + ['STRING_TO_FLOAT', 123.456, 'double', Float], + ['BOOLEAN_TO_STRING', 'true', 'string', String], + ['INTEGER_TO_STRING', '24', 'string', String], + ['INTEGER_TO_FLOAT', 24.0, 'double', Float], + ['FLOAT_TO_STRING', '24.24', 'string', String], + ['FLOAT_TO_INTEGER', 24, 'integer', Integer] ] tests.each do |test| result = @vwo.get_feature_variable_value( @@ -574,7 +567,7 @@ def test_get_feature_variable_wrong_variable_types def test_get_feature_variable_wrong_variable_types_return_none set_up('FR_WRONG_VARIABLE_TYPE') - tests = [["WRONG_BOOLEAN", nil, "boolean", nil]] + tests = [['WRONG_BOOLEAN', nil, 'boolean', nil]] tests.each do |test| result = @vwo.get_feature_variable_value( 'FR_WRONG_VARIABLE_TYPE', @@ -631,55 +624,55 @@ def test_get_feature_variable_invalid_campaing_type # end def test_get_variation_name_raises_exception - set_up() + set_up @vwo.stub_and_raise(:valid_string?, StandardError) assert_equal(nil, @vwo.get_variation_name('SOME_CAMPAIGN', 'USER')) end def test_track_raises_exception - set_up() + set_up @vwo.stub_and_raise(:valid_string?, StandardError) assert_equal(false, @vwo.track('SOME_CAMPAIGN', 'USER', 'GOAL')) end def test_feature_enabled_raises_exception - set_up() + set_up @vwo.stub_and_raise(:valid_string?, StandardError) assert_equal(false, @vwo.feature_enabled?('SOME_CAMPAIGN', 'USER')) end def test_get_feature_variable_raises_exception - set_up() + set_up @vwo.stub_and_raise(:valid_string?, StandardError) - assert_equal(nil, @vwo.get_feature_variable_value('SOME_CAMPAIGN','VARIABLE_KEY','USER_ID')) + assert_equal(nil, @vwo.get_feature_variable_value('SOME_CAMPAIGN', 'VARIABLE_KEY', 'USER_ID')) end def test_push_raises_exception - set_up() + set_up @vwo.stub_and_raise(:valid_string?, StandardError) - assert_equal(false, @vwo.push('SOME_CAMPAIGN', 'VARIABLE_KEY','USER_ID')) + assert_equal(false, @vwo.push('SOME_CAMPAIGN', 'VARIABLE_KEY', 'USER_ID')) end - def test_vwo_initialized_with_provided_log_level_DEBUG - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), { log_level: Logger::DEBUG }) + def test_vwo_initialized_with_provided_log_level_debug + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), { log_level: Logger::DEBUG }) assert_equal(vwo_instance.logging.level, Logger::DEBUG) end - def test_vwo_initialized_with_provided_log_level_WARNING - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), { log_level: Logger::WARN }) + def test_vwo_initialized_with_provided_log_level_warning + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), { log_level: Logger::WARN }) assert_equal(vwo_instance.logging.level, Logger::WARN) end # test activate with pre-segmentation def test_activate_with_no_custom_variables_fails - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_50_W_50_50_WS']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_50_W_50_50_WS']), { log_level: Logger::DEBUG }) USER_EXPECTATIONS['AB_T_50_W_50_50'].each do |test| assert_equal(vwo_instance.activate('T_50_W_50_50_WS', test['user']), nil) end end def test_activate_with_no_dsl_remains_unaffected - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), { log_level: Logger::DEBUG }) true_custom_variables = { 'a' => 987.1234, 'hello' => 'world' @@ -693,7 +686,7 @@ def test_activate_with_no_dsl_remains_unaffected end def test_activate_with_presegmentation_true - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_100_W_50_50_WS']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_100_W_50_50_WS']), { log_level: Logger::DEBUG }) true_custom_variables = { 'a' => 987.1234, 'hello' => 'world' @@ -708,9 +701,9 @@ def test_activate_with_presegmentation_true end def test_activate_with_presegmentation_false - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_100_W_50_50_WS']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_100_W_50_50_WS']), { log_level: Logger::DEBUG }) false_custom_variables = { - 'a' => 987123, + 'a' => 987_123, 'world' => 'hello' } USER_EXPECTATIONS['AB_T_100_W_50_50'].each do |test| @@ -722,7 +715,7 @@ def test_activate_with_presegmentation_false end def test_get_variation_name_with_no_custom_variables_fails - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_100_W_50_50_WS']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_100_W_50_50_WS']), { log_level: Logger::DEBUG }) USER_EXPECTATIONS['AB_T_50_W_50_50'].each do |test| assert_equal( vwo_instance.get_variation_name('T_50_W_50_50_WS', test['user']), @@ -732,7 +725,7 @@ def test_get_variation_name_with_no_custom_variables_fails end def test_get_variation_name_with_no_dsl_remains_unaffected - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_50_W_50_50_WS']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_50_W_50_50_WS']), { log_level: Logger::DEBUG }) true_custom_variables = { 'a' => 987.1234, 'hello' => 'world' @@ -746,7 +739,7 @@ def test_get_variation_name_with_no_dsl_remains_unaffected end def test_get_variation_name_with_presegmentation_true - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_100_W_50_50_WS']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_100_W_50_50_WS']), { log_level: Logger::DEBUG }) true_custom_variables = { 'a' => 987.1234, 'hello' => 'world' @@ -760,9 +753,9 @@ def test_get_variation_name_with_presegmentation_true end def test_get_variation_name_with_presegmentation_false - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_100_W_50_50_WS']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_100_W_50_50_WS']), { log_level: Logger::DEBUG }) false_custom_variables = { - 'a' => 987123, + 'a' => 987_123, 'world' => 'hello' } USER_EXPECTATIONS['AB_T_100_W_50_50'].each do |test| @@ -774,14 +767,14 @@ def test_get_variation_name_with_presegmentation_false end def test_track_with_with_no_custom_variables_fails - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_100_W_50_50_WS']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_100_W_50_50_WS']), { log_level: Logger::DEBUG }) USER_EXPECTATIONS['AB_T_100_W_50_50'].each do |test| - assert_equal(vwo_instance.track('T_100_W_50_50_WS', test['user'], 'ddd'), { "T_100_W_50_50_WS" => false}) + assert_equal(vwo_instance.track('T_100_W_50_50_WS', test['user'], 'ddd'), { 'T_100_W_50_50_WS' => false }) end end def test_track_revenue_value_and_custom_variables_passed_in_args - arguments_to_track = { + arguments_to_track = { 'campaign_key' => 'TEST_TRACK', 'user_id' => 'user_id', 'goal_identifier' => 'GOAL_ID', @@ -796,15 +789,15 @@ def test_track_revenue_value_and_custom_variables_passed_in_args arguments_to_track['user_id'], arguments_to_track['goal_identifier'], { - "revenue_value" => arguments_to_track['revenue_value'], - "custom_variables" => arguments_to_track['custom_variables'] - }), + 'revenue_value' => arguments_to_track['revenue_value'], + 'custom_variables' => arguments_to_track['custom_variables'] + } + ), arguments_to_track ) end def test_track_revenue_value_and_custom_variables_passed_in_args_as_hash - arguments_to_track = { 'campaign_key' => 'TEST_TRACK', 'user_id' => 'user_id', @@ -820,54 +813,55 @@ def test_track_revenue_value_and_custom_variables_passed_in_args_as_hash arguments_to_track['user_id'], arguments_to_track['goal_identifier'], { - "revenue_value" => arguments_to_track['revenue_value'], - "custom_variables" => arguments_to_track['custom_variables'] - }), + 'revenue_value' => arguments_to_track['revenue_value'], + 'custom_variables' => arguments_to_track['custom_variables'] + } + ), arguments_to_track ) end def test_track_with_presegmentation_true - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_50_W_50_50_WS']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_50_W_50_50_WS']), { log_level: Logger::DEBUG }) true_custom_variables = { 'a' => 987.1234, 'hello' => 'world' } USER_EXPECTATIONS['AB_T_50_W_50_50'].each do |test| - assert_equal(vwo_instance.track('T_50_W_50_50_WS', test['user'], 'ddd', { custom_variables: true_custom_variables}), { "T_50_W_50_50_WS" => !test['variation'].nil?}) + assert_equal(vwo_instance.track('T_50_W_50_50_WS', test['user'], 'ddd', { custom_variables: true_custom_variables }), { 'T_50_W_50_50_WS' => !test['variation'].nil? }) end end def test_track_with_presegmentation_false - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_50_W_50_50_WS']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_50_W_50_50_WS']), { log_level: Logger::DEBUG }) false_custom_variables = { 'a' => 987.12, 'hello' => 'world_world' } USER_EXPECTATIONS['AB_T_50_W_50_50'].each do |test| - assert_equal(vwo_instance.track('T_50_W_50_50_WS', test['user'], 'ddd', { custom_variables: false_custom_variables }), {"T_50_W_50_50_WS" => false}) + assert_equal(vwo_instance.track('T_50_W_50_50_WS', test['user'], 'ddd', { custom_variables: false_custom_variables }), { 'T_50_W_50_50_WS' => false }) end end def test_track_with_no_dsl_remains_unaffected - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), { log_level: Logger::DEBUG }) true_custom_variables = { 'a' => 987.1234, 'hello' => 'world' } USER_EXPECTATIONS['AB_T_50_W_50_50'].each do |test| - assert_equal(vwo_instance.track('AB_T_50_W_50_50', test['user'], 'CUSTOM', { custom_variables: true_custom_variables }), {"AB_T_50_W_50_50" => !test['variation'].nil?}) + assert_equal(vwo_instance.track('AB_T_50_W_50_50', test['user'], 'CUSTOM', { custom_variables: true_custom_variables }), { 'AB_T_50_W_50_50' => !test['variation'].nil? }) end end def test_track_with_no_custom_variables_fails - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_50_W_50_50_WS']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['T_50_W_50_50_WS']), { log_level: Logger::DEBUG }) USER_EXPECTATIONS['AB_T_50_W_50_50'].each do |test| - assert_equal(vwo_instance.track('T_50_W_50_50_WS', test['user'], 'ddd'), {'T_50_W_50_50_WS' => false}) + assert_equal(vwo_instance.track('T_50_W_50_50_WS', test['user'], 'ddd'), { 'T_50_W_50_50_WS' => false }) end end - def test_feature_enabled_FT_T_75_W_10_20_30_40_WS_true + def test_feature_enabled_ft_t_75_w_10_20_30_40_ws_true set_up('FT_T_75_W_10_20_30_40_WS') is_feature_not_enabled_variations = ['Control'] true_custom_variables = { @@ -876,12 +870,11 @@ def test_feature_enabled_FT_T_75_W_10_20_30_40_WS_true } USER_EXPECTATIONS['T_75_W_10_20_30_40'].each do |test| assert_equal(@vwo.feature_enabled?('FT_T_75_W_10_20_30_40_WS', test['user'], { custom_variables: true_custom_variables }), - !test['variation'].nil? && !is_feature_not_enabled_variations.include?(test['variation']) - ) + !test['variation'].nil? && !is_feature_not_enabled_variations.include?(test['variation'])) end end - def test_feature_enabled_FT_T_75_W_10_20_30_40_WS_false + def test_feature_enabled_ft_t_75_w_10_20_30_40_ws_false set_up('FT_T_75_W_10_20_30_40_WS') false_custom_variables = { 'a' => 987.12, @@ -889,11 +882,12 @@ def test_feature_enabled_FT_T_75_W_10_20_30_40_WS_false } USER_EXPECTATIONS['T_75_W_10_20_30_40'].each do |test| assert_equal( - @vwo.feature_enabled?('FT_T_75_W_10_20_30_40_WS', test['user'], { custom_variables: false_custom_variables }), false) + @vwo.feature_enabled?('FT_T_75_W_10_20_30_40_WS', test['user'], { custom_variables: false_custom_variables }), false + ) end end - def test_feature_enabled_FT_T_75_W_10_20_30_40_WS_false_custom_variables_in_options + def test_feature_enabled_ft_t_75_w_10_20_30_40_ws_false_custom_variables_in_options set_up('FT_T_75_W_10_20_30_40_WS') false_custom_variables = { 'a' => 987.12, @@ -901,11 +895,12 @@ def test_feature_enabled_FT_T_75_W_10_20_30_40_WS_false_custom_variables_in_opti } USER_EXPECTATIONS['T_75_W_10_20_30_40'].each do |test| assert_equal( - @vwo.feature_enabled?('FT_T_75_W_10_20_30_40_WS', test['user'], { custom_variables: false_custom_variables }), false) + @vwo.feature_enabled?('FT_T_75_W_10_20_30_40_WS', test['user'], { custom_variables: false_custom_variables }), false + ) end end - def test_get_feature_variable_value_type_string_from_feature_test_t_75_WS_true_options + def test_get_feature_variable_value_type_string_from_feature_test_t_75_ws_true_options set_up('FT_T_75_W_10_20_30_40_WS') string_variable = USER_EXPECTATIONS['STRING_VARIABLE'] true_custom_variables = { @@ -923,7 +918,7 @@ def test_get_feature_variable_value_type_string_from_feature_test_t_75_WS_true_o end end - def test_get_feature_variable_value_type_string_from_feature_test_t_75_WS_true + def test_get_feature_variable_value_type_string_from_feature_test_t_75_ws_true set_up('FT_T_75_W_10_20_30_40_WS') string_variable = USER_EXPECTATIONS['STRING_VARIABLE'] true_custom_variables = { @@ -941,7 +936,7 @@ def test_get_feature_variable_value_type_string_from_feature_test_t_75_WS_true end end - def test_get_feature_variable_value_type_string_from_feature_test_t_75_WS_false + def test_get_feature_variable_value_type_string_from_feature_test_t_75_ws_false set_up('FT_T_75_W_10_20_30_40_WS') false_custom_variables = { 'a' => 987.12, @@ -960,52 +955,52 @@ def test_get_feature_variable_value_type_string_from_feature_test_t_75_WS_false def test_push_corrupted_settings_file set_up('DUMMY_SETTINGS') - assert_equal({}, @vwo.push("1234", '12435t4', '12343')) + assert_equal({}, @vwo.push('1234', '12435t4', '12343')) end def test_push_true - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) assert_equal(true, vwo_instance.push('browser', 'chrome', '12345')[:browser]) end def test_push_int_value_false - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) assert_equal(false, vwo_instance.push('browser', 1, '12345')[:browser]) end def test_push_longer_than_255_value_false - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) assert_equal(false, vwo_instance.push('browser', 'a' * 256, '12345')[:browser]) end def test_push_exact_255_value_true - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) assert_equal(true, vwo_instance.push('browser', 'a' * 255, '12345')[:browser]) end def test_push_longer_than_255_key_false - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) assert_equal(false, vwo_instance.push('a' * 256, 'browser', '12345')[('a' * 256).to_sym]) end def test_push_exact_255_key_true - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) assert_equal(true, vwo_instance.push('a' * 255, 'browser', '12345')[('a' * 255).to_sym]) end def test_push_for_multiple_custom_dimension - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) - custom_dimension_map = {'browser' => 'chrome', 'key' => 'value'} + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) + custom_dimension_map = { 'browser' => 'chrome', 'key' => 'value' } result = vwo_instance.push(custom_dimension_map, '12345') - result.each do |tag_key, tag_value| + result.each do |_tag_key, tag_value| assert_equal(true, tag_value) end end def test_push_for_some_invalid_multiple_custom_dimension - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) - custom_dimension_map = {'browser' => 'chrome', "number" => 1243, "a" * 256 => "hello", "hi" => "a" * 256} - expected = {'browser' => true, "number" => false, "a" * 256 => false, "hi" => false} + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) + custom_dimension_map = { 'browser' => 'chrome', 'number' => 1243, 'a' * 256 => 'hello', 'hi' => 'a' * 256 } + expected = { 'browser' => true, 'number' => false, 'a' * 256 => false, 'hi' => false } result = vwo_instance.push(custom_dimension_map, '12345') expected.each do |tag_key, tag_value| @@ -1014,657 +1009,621 @@ def test_push_for_some_invalid_multiple_custom_dimension end def test_vwo_initialized_with_no_logger_no_log_level - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), { log_level: Logger::DEBUG }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), { log_level: Logger::DEBUG }) assert_equal(vwo_instance.logging.level, Logger::DEBUG) end def test_vwo_initialized_with_logger_as_false - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50'])) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50'])) assert_equal(vwo_instance.logging.level, Logger::DEBUG) end def test_vwo_initialized_with_loglevel_as_false - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), { log_level: false }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), { log_level: false }) assert_equal(vwo_instance.logging.level, Logger::DEBUG) end def test_vwo_initialized_with_loglevel_as_anything_bad - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), { log_level: 'bad' }) + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), { log_level: 'bad' }) assert_equal(vwo_instance.logging.level, Logger::DEBUG) end def test_update_settings_file_for_invalid_sdk_key - vwo_instance = VWO.new(88888888, 1, nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50'])) + vwo_instance = VWO.new(88_888_888, 1, nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50'])) latest_settings = vwo_instance.get_and_update_settings_file assert_equal({}, latest_settings) end def test_update_settings_file - vwo_instance = VWO.new(88888888, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50'])) + vwo_instance = VWO.new(88_888_888, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50'])) old_settings = vwo_instance.get_settings - manager = mock() + manager = mock manager.stubs(:get_settings_file).with(true).returns(JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50'])) vwo_instance.settings_file_manager = manager latest_settings = vwo_instance.get_and_update_settings_file assert_not_equal(old_settings, latest_settings.to_json) old_settings = vwo_instance.get_settings - manager = mock() + manager = mock manager.stubs(:get_settings_file).with(true).returns(JSON.generate(old_settings)) vwo_instance.settings_file_manager = manager latest_settings = vwo_instance.get_and_update_settings_file assert_equal(old_settings, latest_settings) end + def test_track_for_already_track_user + vwo_instance = VWO.new(88_888_888, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50'])) + vwo_instance.stubs(:is_eligible_to_send_impression).returns(false) + variation_data = {} + variation_data['id'] = 2 + variation_data['name'] = 'variation-1' + variation_data['goal_identifier'] = '_vwo_CUSTOM' + variation_decider = mock + variation_decider.stubs(:get_variation).returns(variation_data) + vwo_instance.variation_decider = variation_decider + assert_equal(vwo_instance.track('AB_T_50_W_50_50', 'Ashley', 'CUSTOM'), { 'AB_T_50_W_50_50' => false }) + end - def test_track_for_already_track_user - vwo_instance = VWO.new(88888888, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50'])) - vwo_instance.stubs(:is_eligible_to_send_impression).returns(false) - variation_data = Hash.new - variation_data["id"] = 2 - variation_data["name"] = "variation-1" - variation_data["goal_identifier"] = "_vwo_CUSTOM" - variation_decider = mock() - variation_decider.stubs(:get_variation).returns(variation_data) - vwo_instance.variation_decider = variation_decider - assert_equal(vwo_instance.track("AB_T_50_W_50_50", "Ashley", 'CUSTOM'), {"AB_T_50_W_50_50" => false}) - end - - def test_feature_enabled_for_already_track_user - vwo_instance = VWO.new(123456, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['FT_T_75_W_10_20_30_40'])) - vwo_instance.stubs(:is_eligible_to_send_impression).returns(false) - assert_equal(vwo_instance.feature_enabled?("FT_T_75_W_10_20_30_40", "Ashley"), true) - end - + def test_feature_enabled_for_already_track_user + vwo_instance = VWO.new(123_456, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['FT_T_75_W_10_20_30_40'])) + vwo_instance.stubs(:is_eligible_to_send_impression).returns(false) + assert_equal(vwo_instance.feature_enabled?('FT_T_75_W_10_20_30_40', 'Ashley'), true) + end - def get_batch_events_option - def flush_callback(message, events) - end + def flush_callback(message, events); end - { - batch_events: { - events_per_request: 3, - request_time_interval: 5, - flushCallback: method(:flush_callback) - } + def get_batch_events_option + { + batch_events: { + events_per_request: 3, + request_time_interval: 5, + flushCallback: method(:flush_callback) } - end - - def initialize_vwo_with_batch_events_option(camp_key, option) - return VWO.new(88888888, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE[camp_key]), option) - end + } + end - # activate, track, feature_enabled? api when vwo object initialized with batch_events options - def test_api_with_batch_events - vwo_instance = initialize_vwo_with_batch_events_option('AB_T_50_W_50_50', get_batch_events_option) - assert_equal(vwo_instance.activate("AB_T_50_W_50_50", "Ashley", {}), "Variation-1") - assert_equal(vwo_instance.activate("AB_T_50_W_50_50", "Ashley", {}), "Variation-1") - assert_equal(vwo_instance.track("AB_T_50_W_50_50", "Ashley", 'CUSTOM', {})["AB_T_50_W_50_50"], true) - vwo_instance = initialize_vwo_with_batch_events_option('FT_T_100_W_10_20_30_40', get_batch_events_option) - assert_equal(vwo_instance.feature_enabled?("FT_T_100_W_10_20_30_40", "Ashley", {}), true) - end + def initialize_vwo_with_batch_events_option(camp_key, option) + VWO.new(88_888_888, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE[camp_key]), option) + end - # push api when vwo object initialized with batch_events options - def test_push_true_for_batch_events - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), get_batch_events_option) - assert_equal(true, vwo_instance.push('browser', 'chrome', '12345')[:browser]) - end + # activate, track, feature_enabled? api when vwo object initialized with batch_events options + def test_api_with_batch_events + vwo_instance = initialize_vwo_with_batch_events_option('AB_T_50_W_50_50', get_batch_events_option) + assert_equal(vwo_instance.activate('AB_T_50_W_50_50', 'Ashley', {}), 'Variation-1') + assert_equal(vwo_instance.activate('AB_T_50_W_50_50', 'Ashley', {}), 'Variation-1') + assert_equal(vwo_instance.track('AB_T_50_W_50_50', 'Ashley', 'CUSTOM', {})['AB_T_50_W_50_50'], true) + vwo_instance = initialize_vwo_with_batch_events_option('FT_T_100_W_10_20_30_40', get_batch_events_option) + assert_equal(vwo_instance.feature_enabled?('FT_T_100_W_10_20_30_40', 'Ashley', {}), true) + end - def test_without_events_per_request - def flush_callback(events) - end + # push api when vwo object initialized with batch_events options + def test_push_true_for_batch_events + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), get_batch_events_option) + assert_equal(true, vwo_instance.push('browser', 'chrome', '12345')[:browser]) + end - options = { - "batch_events" => { - "request_time_interval" => 5, - "flushCallback" => method(:flush_callback) - } + def test_without_events_per_request + options = { + 'batch_events' => { + 'request_time_interval' => 5, + 'flushCallback' => method(:flush_callback) } - vwo_instance = initialize_vwo_with_batch_events_option('AB_T_50_W_50_50', options) - assert_equal(vwo_instance.activate("AB_T_50_W_50_50", "Ashley", {}), "Variation-1") - end - - def test_without_request_time_interval - def flush_callback(events) - end + } + vwo_instance = initialize_vwo_with_batch_events_option('AB_T_50_W_50_50', options) + assert_equal(vwo_instance.activate('AB_T_50_W_50_50', 'Ashley', {}), 'Variation-1') + end - options = { - batch_events: { - events_per_request: 3, - flushCallback: method(:flush_callback) - } + def test_without_request_time_interval + options = { + batch_events: { + events_per_request: 3, + flushCallback: method(:flush_callback) } - vwo_instance = initialize_vwo_with_batch_events_option('AB_T_50_W_50_50', options) - assert_equal(vwo_instance.activate("AB_T_50_W_50_50", "Ashley", {}), "Variation-1") - end - - def test_without_flush_callback - def flush_callback(events) - end + } + vwo_instance = initialize_vwo_with_batch_events_option('AB_T_50_W_50_50', options) + assert_equal(vwo_instance.activate('AB_T_50_W_50_50', 'Ashley', {}), 'Variation-1') + end - options = { - batch_events: { - events_per_request: 3, - request_time_interval: 5 - } + def test_without_flush_callback + options = { + batch_events: { + events_per_request: 3, + request_time_interval: 5 } - vwo_instance = initialize_vwo_with_batch_events_option('AB_T_50_W_50_50', options) - assert_equal(vwo_instance.activate("AB_T_50_W_50_50", "Ashley", {}), "Variation-1") - end - - def test_flush_events - def flush_callback(events) - end + } + vwo_instance = initialize_vwo_with_batch_events_option('AB_T_50_W_50_50', options) + assert_equal(vwo_instance.activate('AB_T_50_W_50_50', 'Ashley', {}), 'Variation-1') + end - options = { - batch_events: { - events_per_request: 3, - request_time_interval: 5 - } + def test_flush_events + options = { + batch_events: { + events_per_request: 3, + request_time_interval: 5 } - vwo_instance = initialize_vwo_with_batch_events_option('AB_T_50_W_50_50', options) - assert_equal(vwo_instance.flush_events, true) - end + } + vwo_instance = initialize_vwo_with_batch_events_option('AB_T_50_W_50_50', options) + assert_equal(vwo_instance.flush_events, true) + end - def test_flush_events_with_corrupted_vwo_instance - set_up('EMPTY_SETTINGS_FILE') - assert_equal(@vwo.flush_events, false) - end + def test_flush_events_with_corrupted_vwo_instance + set_up('EMPTY_SETTINGS_FILE') + assert_equal(@vwo.flush_events, false) + end - def test_flush_events_raises_exception - set_up() - @vwo.stub_and_raise(:valid_string?, StandardError) - assert_equal(@vwo.flush_events, false) - end + def test_flush_events_raises_exception + set_up + @vwo.stub_and_raise(:valid_string?, StandardError) + assert_equal(@vwo.flush_events, false) + end - def test_activate_for_hooks - def integrations_callback(properties) - end - options = { - integrations: { - callback: method(:integrations_callback) - } + def integrations_callback(properties); end + + def test_activate_for_hooks + options = { + integrations: { + callback: method(:integrations_callback) } - vwo_instance = VWO.new(88888888, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), options) - assert_equal(vwo_instance.activate("AB_T_50_W_50_50", "Ashley", {}), "Variation-1") - vwo_instance = VWO.new(88888888, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['FT_T_75_W_10_20_30_40']), options) - assert_equal(vwo_instance.feature_enabled?("FT_T_75_W_10_20_30_40", "Ashley", {}), true) - end - - def test_additional_data_during_vwo_instantiation - def integrations_callback(properties) - end - options = { - log_level: Logger::DEBUG, - integrations: { - callback: method(:integrations_callback) - } + } + vwo_instance = VWO.new(88_888_888, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), options) + assert_equal(vwo_instance.activate('AB_T_50_W_50_50', 'Ashley', {}), 'Variation-1') + vwo_instance = VWO.new(88_888_888, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['FT_T_75_W_10_20_30_40']), options) + assert_equal(vwo_instance.feature_enabled?('FT_T_75_W_10_20_30_40', 'Ashley', {}), true) + end + + def test_additional_data_during_vwo_instantiation + options = { + log_level: Logger::DEBUG, + integrations: { + callback: method(:integrations_callback) } - vwo_instance = VWO.new(88888888, 'someuniquestuff1234567', VWO::Logger.get_instance, VWO::UserStorage.new, false, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), options) - additional_data = vwo_instance.usage_stats.usage_stats - assert_equal(1, additional_data[:ig]) - assert_equal(1, additional_data[:cl]) - assert_equal(1, additional_data[:ss]) - assert_equal(1, additional_data[:ll]) - assert_equal(nil, additional_data[:eb]) - assert_equal(1, additional_data[:_l]) - end - - def test_additional_data_during_vwo_instantiation_for_non_symbol_hash - def flush_callback(events) - end - - def integrations_callback(properties) - end - - options = { - "batch_events" => { - "events_per_request" => 3, - "request_time_interval" => 5, - "flushCallback" => method(:flush_callback) - }, - "log_level": Logger::DEBUG, - "integrations" => { - "callback" => method(:integrations_callback) - } + } + vwo_instance = VWO.new(88_888_888, 'someuniquestuff1234567', VWO::Logger.get_instance, VWO::UserStorage.new, false, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), options) + additional_data = vwo_instance.usage_stats.usage_stats + assert_equal(1, additional_data[:ig]) + assert_equal(1, additional_data[:cl]) + assert_equal(1, additional_data[:ss]) + assert_equal(1, additional_data[:ll]) + assert_equal(nil, additional_data[:eb]) + assert_equal(1, additional_data[:_l]) + end + + def test_additional_data_during_vwo_instantiation_for_non_symbol_hash + options = { + 'batch_events' => { + 'events_per_request' => 3, + 'request_time_interval' => 5, + 'flushCallback' => method(:flush_callback) + }, + "log_level": Logger::DEBUG, + 'integrations' => { + 'callback' => method(:integrations_callback) } - vwo_instance = VWO.new(88888888, 'someuniquestuff1234567', VWO::Logger.get_instance, VWO::UserStorage.new, false, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), options) - additional_data = vwo_instance.usage_stats.usage_stats - assert_equal(1, additional_data[:ig]) - assert_equal(1, additional_data[:cl]) - assert_equal(1, additional_data[:ss]) - assert_equal(1, additional_data[:ll]) - assert_equal(1, additional_data[:eb]) - assert_equal(1, additional_data[:_l]) - end - - - def test_additional_data_for_logging_and_integrations - def integrations_callback(properties) - end - options = { - log_level: Logger::DEBUG, - integrations: { - callback: method(:integrations_callback) - } + } + vwo_instance = VWO.new(88_888_888, 'someuniquestuff1234567', VWO::Logger.get_instance, VWO::UserStorage.new, false, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), options) + additional_data = vwo_instance.usage_stats.usage_stats + assert_equal(1, additional_data[:ig]) + assert_equal(1, additional_data[:cl]) + assert_equal(1, additional_data[:ss]) + assert_equal(1, additional_data[:ll]) + assert_equal(1, additional_data[:eb]) + assert_equal(1, additional_data[:_l]) + end + + def test_additional_data_for_logging_and_integrations + options = { + log_level: Logger::DEBUG, + integrations: { + callback: method(:integrations_callback) } - vwo_instance = VWO.new(88888888, 'someuniquestuff1234567', VWO::Logger.get_instance, nil, false, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), options) - additional_data = vwo_instance.usage_stats.usage_stats - assert_equal(1, additional_data[:ig]) - assert_equal(1, additional_data[:cl]) - assert_equal(nil, additional_data[:ss]) - assert_equal(1, additional_data[:ll]) - assert_equal(nil, additional_data[:eb]) - assert_equal(1, additional_data[:_l]) - end - - def test_additional_data_for_user_storage - options = {} - vwo_instance = VWO.new(88888888, 'someuniquestuff1234567', nil, VWO::UserStorage.new, false, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), options) - additional_data = vwo_instance.usage_stats.usage_stats - assert_equal(nil, additional_data[:ig]) - assert_equal(nil, additional_data[:cl]) - assert_equal(1, additional_data[:ss]) - assert_equal(nil, additional_data[:ll]) - assert_equal(nil, additional_data[:eb]) - assert_equal(1, additional_data[:_l]) - end - - def test_additional_data_for_logging - vwo_instance = VWO.new(88888888, 'someuniquestuff1234567', VWO::Logger.get_instance, nil, false, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50'])) - additional_data = vwo_instance.usage_stats.usage_stats - assert_equal(nil, additional_data[:ig]) - assert_equal(1, additional_data[:cl]) - assert_equal(nil, additional_data[:ss]) - assert_equal(nil, additional_data[:ll]) - assert_equal(nil, additional_data[:eb]) - assert_equal(1, additional_data[:_l]) - end - - def test_additional_data_for_event_batching - def flush_callback(events) - end - options = { - batch_events: { - events_per_request: 3, - flushCallback: method(:flush_callback) - } + } + vwo_instance = VWO.new(88_888_888, 'someuniquestuff1234567', VWO::Logger.get_instance, nil, false, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), options) + additional_data = vwo_instance.usage_stats.usage_stats + assert_equal(1, additional_data[:ig]) + assert_equal(1, additional_data[:cl]) + assert_equal(nil, additional_data[:ss]) + assert_equal(1, additional_data[:ll]) + assert_equal(nil, additional_data[:eb]) + assert_equal(1, additional_data[:_l]) + end + + def test_additional_data_for_user_storage + options = {} + vwo_instance = VWO.new(88_888_888, 'someuniquestuff1234567', nil, VWO::UserStorage.new, false, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), options) + additional_data = vwo_instance.usage_stats.usage_stats + assert_equal(nil, additional_data[:ig]) + assert_equal(nil, additional_data[:cl]) + assert_equal(1, additional_data[:ss]) + assert_equal(nil, additional_data[:ll]) + assert_equal(nil, additional_data[:eb]) + assert_equal(1, additional_data[:_l]) + end + + def test_additional_data_for_logging + vwo_instance = VWO.new(88_888_888, 'someuniquestuff1234567', VWO::Logger.get_instance, nil, false, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50'])) + additional_data = vwo_instance.usage_stats.usage_stats + assert_equal(nil, additional_data[:ig]) + assert_equal(1, additional_data[:cl]) + assert_equal(nil, additional_data[:ss]) + assert_equal(nil, additional_data[:ll]) + assert_equal(nil, additional_data[:eb]) + assert_equal(1, additional_data[:_l]) + end + + def test_additional_data_for_event_batching + options = { + batch_events: { + events_per_request: 3, + flushCallback: method(:flush_callback) } - vwo_instance = VWO.new(88888888, 'someuniquestuff1234567', nil, nil, false, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), options) - additional_data = vwo_instance.usage_stats.usage_stats - assert_equal(nil, additional_data[:ig]) - assert_equal(nil, additional_data[:cl]) - assert_equal(nil, additional_data[:ss]) - assert_equal(nil, additional_data[:ll]) - assert_equal(1, additional_data[:eb]) - assert_equal(1, additional_data[:_l]) - end + } + vwo_instance = VWO.new(88_888_888, 'someuniquestuff1234567', nil, nil, false, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), options) + additional_data = vwo_instance.usage_stats.usage_stats + assert_equal(nil, additional_data[:ig]) + assert_equal(nil, additional_data[:cl]) + assert_equal(nil, additional_data[:ss]) + assert_equal(nil, additional_data[:ll]) + assert_equal(1, additional_data[:eb]) + assert_equal(1, additional_data[:_l]) + end - def initialize_vwo_with_custom_goal_type_to_track(goal_type) - return VWO.new(88888888, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_100_W_50_50']), {goal_type_to_track: goal_type}) - end + def initialize_vwo_with_custom_goal_type_to_track(goal_type) + VWO.new(88_888_888, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_100_W_50_50']), { goal_type_to_track: goal_type }) + end - def test_track_with_custom_goal_type_to_track - vwo_instance = initialize_vwo_with_custom_goal_type_to_track("CUSTOM") - assert_equal(vwo_instance.track("AB_T_100_W_50_50", "Ashley", "CUSTOM", {}), {"AB_T_100_W_50_50" => true}) - end + def test_track_with_custom_goal_type_to_track + vwo_instance = initialize_vwo_with_custom_goal_type_to_track('CUSTOM') + assert_equal(vwo_instance.track('AB_T_100_W_50_50', 'Ashley', 'CUSTOM', {}), { 'AB_T_100_W_50_50' => true }) + end - def test_track_with_wrong_goal_type_to_track - vwo_instance = initialize_vwo_with_custom_goal_type_to_track("WRONG_GOAL_TYPE") - assert_equal(vwo_instance.track("AB_T_100_W_50_50", "Ashley", "CUSTOM", {}), false) - end + def test_track_with_wrong_goal_type_to_track + vwo_instance = initialize_vwo_with_custom_goal_type_to_track('WRONG_GOAL_TYPE') + assert_equal(vwo_instance.track('AB_T_100_W_50_50', 'Ashley', 'CUSTOM', {}), false) + end - def test_track_with_revenue_goal_type_to_track - vwo_instance = initialize_vwo_with_custom_goal_type_to_track("REVENUE") - assert_equal(vwo_instance.track("AB_T_100_W_50_50", "Ashley", "abcd", {revenue_value: 10}), {"AB_T_100_W_50_50" => true}) - end + def test_track_with_revenue_goal_type_to_track + vwo_instance = initialize_vwo_with_custom_goal_type_to_track('REVENUE') + assert_equal(vwo_instance.track('AB_T_100_W_50_50', 'Ashley', 'abcd', { revenue_value: 10 }), { 'AB_T_100_W_50_50' => true }) + end - def test_track_with_wrong_campaign_key_type - vwo_instance = initialize_vwo_with_custom_goal_type_to_track("REVENUE") - assert_equal(vwo_instance.track(1, "Ashley", "REVENUE_TRACKING", {revenue_value: 10}), false) - end + def test_track_with_wrong_campaign_key_type + vwo_instance = initialize_vwo_with_custom_goal_type_to_track('REVENUE') + assert_equal(vwo_instance.track(1, 'Ashley', 'REVENUE_TRACKING', { revenue_value: 10 }), false) + end - def test_track_with_campaign_keys_array - vwo_instance = initialize_vwo_with_custom_goal_type_to_track("CUSTOM") - assert_equal(vwo_instance.track(["AB_T_100_W_50_50"], "Ashley", "CUSTOM"), {"AB_T_100_W_50_50" => true}) - end + def test_track_with_campaign_keys_array + vwo_instance = initialize_vwo_with_custom_goal_type_to_track('CUSTOM') + assert_equal(vwo_instance.track(['AB_T_100_W_50_50'], 'Ashley', 'CUSTOM'), { 'AB_T_100_W_50_50' => true }) + end - def test_track_with_campaign_keys_nil - vwo_instance = initialize_vwo_with_custom_goal_type_to_track("CUSTOM") - assert_equal(vwo_instance.track(nil, "Ashley", "CUSTOM"), {"AB_T_100_W_50_50" => true}) - end + def test_track_with_campaign_keys_nil + vwo_instance = initialize_vwo_with_custom_goal_type_to_track('CUSTOM') + assert_equal(vwo_instance.track(nil, 'Ashley', 'CUSTOM'), { 'AB_T_100_W_50_50' => true }) + end - def test_validate_variables_without_json_variable - set_up('FR_T_50_W_100') - assert_equal(@vwo.is_instance_valid, true) - json_variable = @vwo.get_feature_variable_value('FR_T_50_W_100_WITH_INVALID_JSON_VARIABLE', 'JSON_VARIABLE', 'Ashley', {}) - assert_equal(json_variable, nil) - end + def test_validate_variables_without_json_variable + set_up('FR_T_50_W_100') + assert_equal(@vwo.is_instance_valid, true) + json_variable = @vwo.get_feature_variable_value('FR_T_50_W_100_WITH_INVALID_JSON_VARIABLE', 'JSON_VARIABLE', 'Ashley', {}) + assert_equal(json_variable, nil) + end - def test_validate_variables_with_complete_data - set_up('FR_T_50_W_100_WITH_JSON_VARIABLE') - assert_equal(@vwo.is_instance_valid, true) - json_variable = @vwo.get_feature_variable_value('FR_T_50_W_100_WITH_JSON_VARIABLE', 'JSON_VARIABLE', 'Ashley', {}) - assert_equal(json_variable, {"data"=>123}) - end + def test_validate_variables_with_complete_data + set_up('FR_T_50_W_100_WITH_JSON_VARIABLE') + assert_equal(@vwo.is_instance_valid, true) + json_variable = @vwo.get_feature_variable_value('FR_T_50_W_100_WITH_JSON_VARIABLE', 'JSON_VARIABLE', 'Ashley', {}) + assert_equal(json_variable, { 'data' => 123 }) + end - def test_validate_variables_with_wrong_json_variable - set_up('FR_T_50_W_100_WITH_INVALID_JSON_VARIABLE') - assert_equal(@vwo.is_instance_valid, true) - json_variable = @vwo.get_feature_variable_value('FR_T_50_W_100_WITH_INVALID_JSON_VARIABLE', 'JSON_VARIABLE', 'Ashley', {}) - assert_equal(json_variable, nil) - end + def test_validate_variables_with_wrong_json_variable + set_up('FR_T_50_W_100_WITH_INVALID_JSON_VARIABLE') + assert_equal(@vwo.is_instance_valid, true) + json_variable = @vwo.get_feature_variable_value('FR_T_50_W_100_WITH_INVALID_JSON_VARIABLE', 'JSON_VARIABLE', 'Ashley', {}) + assert_equal(json_variable, nil) + end - def test_get_feature_variable_value_fail_prior_campaign_activation_for_feature_rollout - vwo_instance = VWO.new(88888888, 'someuniquestuff1234567', VWO::Logger.get_instance, VWO::UserStorage.new, false, JSON.generate(SETTINGS_FILE['FR_T_50_W_100']), {}) - string_variable = vwo_instance.get_feature_variable_value('FR_T_50_W_100', 'STRING_VARIABLE', 'Ashley', {}) - assert_equal(string_variable, nil) - end + def test_get_feature_variable_value_fail_prior_campaign_activation_for_feature_rollout + vwo_instance = VWO.new(88_888_888, 'someuniquestuff1234567', VWO::Logger.get_instance, VWO::UserStorage.new, false, JSON.generate(SETTINGS_FILE['FR_T_50_W_100']), {}) + string_variable = vwo_instance.get_feature_variable_value('FR_T_50_W_100', 'STRING_VARIABLE', 'Ashley', {}) + assert_equal(string_variable, nil) + end - def test_get_feature_variable_value_pass_after_campaign_activation_for_feature_rollout - vwo_instance = VWO.new(88888888, 'someuniquestuff1234567', VWO::Logger.get_instance, VWO::UserStorage.new, false, JSON.generate(SETTINGS_FILE['FR_T_50_W_100']), {}) - variation_data = Hash.new - variation_data["id"] = 1 - variation_data["name"] = "website" - variation_decider = mock() - variation_decider.stubs(:get_variation).returns(variation_data) - vwo_instance.variation_decider = variation_decider - string_variable = vwo_instance.get_feature_variable_value('FR_T_50_W_100', 'STRING_VARIABLE', 'Ashley', {log_level: Logger::DEBUG}) - assert_equal(string_variable, "this_is_a_string") - end + def test_get_feature_variable_value_pass_after_campaign_activation_for_feature_rollout + vwo_instance = VWO.new(88_888_888, 'someuniquestuff1234567', VWO::Logger.get_instance, VWO::UserStorage.new, false, JSON.generate(SETTINGS_FILE['FR_T_50_W_100']), {}) + variation_data = {} + variation_data['id'] = 1 + variation_data['name'] = 'website' + variation_decider = mock + variation_decider.stubs(:get_variation).returns(variation_data) + vwo_instance.variation_decider = variation_decider + string_variable = vwo_instance.get_feature_variable_value('FR_T_50_W_100', 'STRING_VARIABLE', 'Ashley', { log_level: Logger::DEBUG }) + assert_equal(string_variable, 'this_is_a_string') + end - def test_apis_with_hash_version_1 - set_up('T_50_W_50_50_WS') - true_custom_variables = { - 'a' => 987.1234, - 'hello' => 'world' - } - goal_identifier = 'ddd' - options = { "custom_variables" => true_custom_variables } - assert_equal(@vwo.activate('T_50_W_50_50_WS', 'Ashley', options), "Variation-1") - assert_equal(@vwo.get_variation_name('T_50_W_50_50_WS', 'Ashley', options), "Variation-1") - assert_equal(@vwo.track('T_50_W_50_50_WS', 'Ashley', goal_identifier, options), { "T_50_W_50_50_WS" => true}) - - set_up('FT_T_75_W_10_20_30_40_WS') - assert_equal(@vwo.feature_enabled?('FT_T_75_W_10_20_30_40_WS', 'Ashley', options), true) - result = @vwo.get_feature_variable_value('FT_T_75_W_10_20_30_40_WS', 'STRING_VARIABLE', 'Ashley', options) - assert_equal(result, "Variation-3 string") if result - assert_equal(@vwo.get_variation_name('FT_T_75_W_10_20_30_40_WS', 'Ashley', options), "Variation-3") - end - - def test_apis_with_hash_version_1_2 - set_up('T_50_W_50_50_WS') - true_custom_variables = { - a: 987.1234, - hello: 'world' - } - goal_identifier = 'ddd' - options = { "custom_variables"=> true_custom_variables } - assert_equal(@vwo.activate('T_50_W_50_50_WS', 'Ashley', options), "Variation-1") - assert_equal(@vwo.get_variation_name('T_50_W_50_50_WS', 'Ashley', options), "Variation-1") - assert_equal(@vwo.track('T_50_W_50_50_WS', 'Ashley', goal_identifier, options), { "T_50_W_50_50_WS" => true}) - - set_up('FT_T_75_W_10_20_30_40_WS') - assert_equal(@vwo.feature_enabled?('FT_T_75_W_10_20_30_40_WS', 'Ashley', options), true) - result = @vwo.get_feature_variable_value('FT_T_75_W_10_20_30_40_WS', 'STRING_VARIABLE', 'Ashley', options) - assert_equal(result, "Variation-3 string") if result - assert_equal(@vwo.get_variation_name('FT_T_75_W_10_20_30_40_WS', 'Ashley', options), "Variation-3") - end - - def test_apis_with_hash_version_2 - set_up('T_50_W_50_50_WS') - true_custom_variables = { - 'a' => 987.1234, - 'hello' => 'world' - } - goal_identifier = 'ddd' - options = { custom_variables: true_custom_variables } - assert_equal(@vwo.activate('T_50_W_50_50_WS', 'Ashley', options), "Variation-1") - assert_equal(@vwo.get_variation_name('T_50_W_50_50_WS', 'Ashley', options), "Variation-1") - assert_equal(@vwo.track('T_50_W_50_50_WS', 'Ashley', goal_identifier, options), { "T_50_W_50_50_WS" => true}) - - set_up('FT_T_75_W_10_20_30_40_WS') - assert_equal(@vwo.feature_enabled?('FT_T_75_W_10_20_30_40_WS', 'Ashley', options), true) - result = @vwo.get_feature_variable_value('FT_T_75_W_10_20_30_40_WS', 'STRING_VARIABLE', 'Ashley', options) - assert_equal(result, "Variation-3 string") if result - assert_equal(@vwo.get_variation_name('FT_T_75_W_10_20_30_40_WS', 'Ashley', options), "Variation-3") - end - - def test_apis_with_hash_version_2_2 - set_up('T_50_W_50_50_WS') - true_custom_variables = { - a: 987.1234, - hello: 'world' - } - goal_identifier = 'ddd' - options = { custom_variables: true_custom_variables } - assert_equal(@vwo.activate('T_50_W_50_50_WS', 'Ashley', options), "Variation-1") - assert_equal(@vwo.get_variation_name('T_50_W_50_50_WS', 'Ashley', options), "Variation-1") - assert_equal(@vwo.track('T_50_W_50_50_WS', 'Ashley', goal_identifier, options), { "T_50_W_50_50_WS" => true}) - - set_up('FT_T_75_W_10_20_30_40_WS') - assert_equal(@vwo.feature_enabled?('FT_T_75_W_10_20_30_40_WS', 'Ashley', options), true) - result = @vwo.get_feature_variable_value('FT_T_75_W_10_20_30_40_WS', 'STRING_VARIABLE', 'Ashley', options) - assert_equal(result, "Variation-3 string") if result - assert_equal(@vwo.get_variation_name('FT_T_75_W_10_20_30_40_WS', 'Ashley', options), "Variation-3") - end - - def test_vwo_instantiation_with_string_type_hash - def integrations_callback(properties) - end - options = { - "log_level" => Logger::DEBUG, - "integrations" => { - "callback" => method(:integrations_callback) - } - } - vwo_instance = VWO.new(88888888, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), options) - assert_equal(vwo_instance.activate("AB_T_50_W_50_50", "Ashley", {}), "Variation-1") - assert_equal(vwo_instance.track("AB_T_50_W_50_50", "Ashley", 'CUSTOM')["AB_T_50_W_50_50"], true) - end - - def test_vwo_instantiation_with_symbolize_hash - def integrations_callback(properties) - end - options = { - log_level: Logger::DEBUG, - integrations: { - callback: method(:integrations_callback) - } - } - vwo_instance = VWO.new(88888888, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), options) - assert_equal(vwo_instance.activate("AB_T_50_W_50_50", "Ashley", {}), "Variation-1") - assert_equal(vwo_instance.track("AB_T_50_W_50_50", "Ashley", 'CUSTOM')["AB_T_50_W_50_50"], true) - end - - def test_fr_whitelisting - campaign_key = 'FR_T_100_W_100_WHITELISTING' - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['FR_T_100_W_100_WHITELISTING'])) - options = { - variation_targeting_variables: { - "chrome" => "false" - } - } + def test_apis_with_hash_version1 + set_up('T_50_W_50_50_WS') + true_custom_variables = { + 'a' => 987.1234, + 'hello' => 'world' + } + goal_identifier = 'ddd' + options = { 'custom_variables' => true_custom_variables } + assert_equal(@vwo.activate('T_50_W_50_50_WS', 'Ashley', options), 'Variation-1') + assert_equal(@vwo.get_variation_name('T_50_W_50_50_WS', 'Ashley', options), 'Variation-1') + assert_equal(@vwo.track('T_50_W_50_50_WS', 'Ashley', goal_identifier, options), { 'T_50_W_50_50_WS' => true }) + + set_up('FT_T_75_W_10_20_30_40_WS') + assert_equal(@vwo.feature_enabled?('FT_T_75_W_10_20_30_40_WS', 'Ashley', options), true) + result = @vwo.get_feature_variable_value('FT_T_75_W_10_20_30_40_WS', 'STRING_VARIABLE', 'Ashley', options) + assert_equal(result, 'Variation-3 string') if result + assert_equal(@vwo.get_variation_name('FT_T_75_W_10_20_30_40_WS', 'Ashley', options), 'Variation-3') + end + + def test_apis_with_hash_version_1and2 + set_up('T_50_W_50_50_WS') + true_custom_variables = { + a: 987.1234, + hello: 'world' + } + goal_identifier = 'ddd' + options = { 'custom_variables' => true_custom_variables } + assert_equal(@vwo.activate('T_50_W_50_50_WS', 'Ashley', options), 'Variation-1') + assert_equal(@vwo.get_variation_name('T_50_W_50_50_WS', 'Ashley', options), 'Variation-1') + assert_equal(@vwo.track('T_50_W_50_50_WS', 'Ashley', goal_identifier, options), { 'T_50_W_50_50_WS' => true }) + + set_up('FT_T_75_W_10_20_30_40_WS') + assert_equal(@vwo.feature_enabled?('FT_T_75_W_10_20_30_40_WS', 'Ashley', options), true) + result = @vwo.get_feature_variable_value('FT_T_75_W_10_20_30_40_WS', 'STRING_VARIABLE', 'Ashley', options) + assert_equal(result, 'Variation-3 string') if result + assert_equal(@vwo.get_variation_name('FT_T_75_W_10_20_30_40_WS', 'Ashley', options), 'Variation-3') + end - boolean_variable = USER_EXPECTATIONS['ROLLOUT_VARIABLES']['BOOLEAN_VARIABLE'] - USER_EXPECTATIONS[campaign_key].each do |test| - is_feature_enabled = vwo_instance.feature_enabled?(campaign_key, test['user'], options) - assert_equal(is_feature_enabled, true) - result = vwo_instance.get_feature_variable_value(campaign_key, 'BOOLEAN_VARIABLE', test['user'], options) - assert_equal(result, boolean_variable) - end - end - - def test_fr_whitelisting_passed_when_Traffic_zero - campaign_key = 'FR_T_100_W_100_WHITELISTING' - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['FR_T_100_W_100_WHITELISTING'])) - vwo_instance.get_settings['campaigns'][0]['percentTraffic'] = 0 - options = { - variation_targeting_variables: { - "chrome" => "false" - } + def test_apis_with_hash_version2 + set_up('T_50_W_50_50_WS') + true_custom_variables = { + 'a' => 987.1234, + 'hello' => 'world' + } + goal_identifier = 'ddd' + options = { custom_variables: true_custom_variables } + assert_equal(@vwo.activate('T_50_W_50_50_WS', 'Ashley', options), 'Variation-1') + assert_equal(@vwo.get_variation_name('T_50_W_50_50_WS', 'Ashley', options), 'Variation-1') + assert_equal(@vwo.track('T_50_W_50_50_WS', 'Ashley', goal_identifier, options), { 'T_50_W_50_50_WS' => true }) + + set_up('FT_T_75_W_10_20_30_40_WS') + assert_equal(@vwo.feature_enabled?('FT_T_75_W_10_20_30_40_WS', 'Ashley', options), true) + result = @vwo.get_feature_variable_value('FT_T_75_W_10_20_30_40_WS', 'STRING_VARIABLE', 'Ashley', options) + assert_equal(result, 'Variation-3 string') if result + assert_equal(@vwo.get_variation_name('FT_T_75_W_10_20_30_40_WS', 'Ashley', options), 'Variation-3') + end + + def test_apis_with_hash_version_2and2 + set_up('T_50_W_50_50_WS') + true_custom_variables = { + a: 987.1234, + hello: 'world' + } + goal_identifier = 'ddd' + options = { custom_variables: true_custom_variables } + assert_equal(@vwo.activate('T_50_W_50_50_WS', 'Ashley', options), 'Variation-1') + assert_equal(@vwo.get_variation_name('T_50_W_50_50_WS', 'Ashley', options), 'Variation-1') + assert_equal(@vwo.track('T_50_W_50_50_WS', 'Ashley', goal_identifier, options), { 'T_50_W_50_50_WS' => true }) + + set_up('FT_T_75_W_10_20_30_40_WS') + assert_equal(@vwo.feature_enabled?('FT_T_75_W_10_20_30_40_WS', 'Ashley', options), true) + result = @vwo.get_feature_variable_value('FT_T_75_W_10_20_30_40_WS', 'STRING_VARIABLE', 'Ashley', options) + assert_equal(result, 'Variation-3 string') if result + assert_equal(@vwo.get_variation_name('FT_T_75_W_10_20_30_40_WS', 'Ashley', options), 'Variation-3') + end + + def test_vwo_instantiation_with_string_type_hash + options = { + 'log_level' => Logger::DEBUG, + 'integrations' => { + 'callback' => method(:integrations_callback) } + } + vwo_instance = VWO.new(88_888_888, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), options) + assert_equal(vwo_instance.activate('AB_T_50_W_50_50', 'Ashley', {}), 'Variation-1') + assert_equal(vwo_instance.track('AB_T_50_W_50_50', 'Ashley', 'CUSTOM')['AB_T_50_W_50_50'], true) + end - boolean_variable = USER_EXPECTATIONS['ROLLOUT_VARIABLES']['BOOLEAN_VARIABLE'] - USER_EXPECTATIONS[campaign_key].each do |test| - is_feature_enabled = vwo_instance.feature_enabled?(campaign_key, test['user'], options) - assert_equal(is_feature_enabled, true) - result = vwo_instance.get_feature_variable_value(campaign_key, 'BOOLEAN_VARIABLE', test['user'], options) - assert_equal(result, boolean_variable) - end - end - - def test_fr_whitelisting_not_passed - campaign_key = 'FR_T_100_W_100_WHITELISTING' - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['FR_T_100_W_100_WHITELISTING'])) - options = { - variation_targeting_variables: { - "chrome" => "true" - } + def test_vwo_instantiation_with_symbolize_hash + options = { + log_level: Logger::DEBUG, + integrations: { + callback: method(:integrations_callback) } + } + vwo_instance = VWO.new(88_888_888, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_50_W_50_50']), options) + assert_equal(vwo_instance.activate('AB_T_50_W_50_50', 'Ashley', {}), 'Variation-1') + assert_equal(vwo_instance.track('AB_T_50_W_50_50', 'Ashley', 'CUSTOM')['AB_T_50_W_50_50'], true) + end - boolean_variable = USER_EXPECTATIONS['ROLLOUT_VARIABLES']['BOOLEAN_VARIABLE'] - USER_EXPECTATIONS[campaign_key].each do |test| - is_feature_enabled = vwo_instance.feature_enabled?(campaign_key, test['user'], options) - assert_equal(is_feature_enabled, true) - result = vwo_instance.get_feature_variable_value(campaign_key, 'BOOLEAN_VARIABLE', test['user'], options) - assert_equal(result, boolean_variable) - end - end - - def test_fr_whitelisting_not_passed_and_Traffic_10 - campaign_key = 'FR_T_100_W_100_WHITELISTING' - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['FR_T_100_W_100_WHITELISTING'])) - vwo_instance.get_settings['campaigns'][0]['percentTraffic'] = 10 - options = { - variation_targeting_variables: { - "chrome" => "true" - } + def test_fr_whitelisting + campaign_key = 'FR_T_100_W_100_WHITELISTING' + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['FR_T_100_W_100_WHITELISTING'])) + options = { + variation_targeting_variables: { + 'chrome' => 'false' } + } - boolean_variable = USER_EXPECTATIONS['ROLLOUT_VARIABLES']['BOOLEAN_VARIABLE'] - USER_EXPECTATIONS['FR_T_10_W_100_WHITELISTING_FAIL'].each do |test| - is_feature_enabled = vwo_instance.feature_enabled?(campaign_key, test['user'], options) - assert_equal(is_feature_enabled, test['is_feature_enabled']) - result = vwo_instance.get_feature_variable_value(campaign_key, 'BOOLEAN_VARIABLE', test['user'], options) - assert_equal(result, test["boolean_variable_value"]) - end + boolean_variable = USER_EXPECTATIONS['ROLLOUT_VARIABLES']['BOOLEAN_VARIABLE'] + USER_EXPECTATIONS[campaign_key].each do |test| + is_feature_enabled = vwo_instance.feature_enabled?(campaign_key, test['user'], options) + assert_equal(is_feature_enabled, true) + result = vwo_instance.get_feature_variable_value(campaign_key, 'BOOLEAN_VARIABLE', test['user'], options) + assert_equal(result, boolean_variable) end + end + + def test_fr_whitelisting_passed_when_traffic_zero + campaign_key = 'FR_T_100_W_100_WHITELISTING' + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['FR_T_100_W_100_WHITELISTING'])) + vwo_instance.get_settings['campaigns'][0]['percentTraffic'] = 0 + options = { + variation_targeting_variables: { + 'chrome' => 'false' + } + } - def test_activate_with_event_arch - set_up('AB_T_100_W_50_50') - @vwo.get_settings['isEventArchEnabled'] = true - USER_EXPECTATIONS[@campaign_key].each do |test| - assert_equal(@vwo.activate(@campaign_key, test['user']), test['variation']) - end + boolean_variable = USER_EXPECTATIONS['ROLLOUT_VARIABLES']['BOOLEAN_VARIABLE'] + USER_EXPECTATIONS[campaign_key].each do |test| + is_feature_enabled = vwo_instance.feature_enabled?(campaign_key, test['user'], options) + assert_equal(is_feature_enabled, true) + result = vwo_instance.get_feature_variable_value(campaign_key, 'BOOLEAN_VARIABLE', test['user'], options) + assert_equal(result, boolean_variable) end + end - def test_feature_enabled_with_event_arch - set_up('FR_T_100_W_100') - @vwo.get_settings['isEventArchEnabled'] = true + def test_fr_whitelisting_not_passed + campaign_key = 'FR_T_100_W_100_WHITELISTING' + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['FR_T_100_W_100_WHITELISTING'])) + options = { + variation_targeting_variables: { + 'chrome' => 'true' + } + } - USER_EXPECTATIONS['T_100_W_10_20_30_40'].each do |test| - assert_equal(@vwo.feature_enabled?('FR_T_100_W_100', test['user']), !test['variation'].nil?) - end + boolean_variable = USER_EXPECTATIONS['ROLLOUT_VARIABLES']['BOOLEAN_VARIABLE'] + USER_EXPECTATIONS[campaign_key].each do |test| + is_feature_enabled = vwo_instance.feature_enabled?(campaign_key, test['user'], options) + assert_equal(is_feature_enabled, true) + result = vwo_instance.get_feature_variable_value(campaign_key, 'BOOLEAN_VARIABLE', test['user'], options) + assert_equal(result, boolean_variable) end + end - def test_track_with_event_arch - set_up('AB_T_100_W_50_50') - @vwo.get_settings['isEventArchEnabled'] = true - @vwo.get_settings['campaigns'][0]['goals'][0]['revenueProp'] = 'dummyRevenueProperty' - USER_EXPECTATIONS[@campaign_key].each do |test| - result = @vwo.track(@campaign_key, test['user'], @goal_identifier, {revenue_value: '23.3'}) - assert_equal(result, {@campaign_key => !test['variation'].nil?}) - end - end + def test_fr_whitelisting_not_passed_and_traffic10 + campaign_key = 'FR_T_100_W_100_WHITELISTING' + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['FR_T_100_W_100_WHITELISTING'])) + vwo_instance.get_settings['campaigns'][0]['percentTraffic'] = 10 + options = { + variation_targeting_variables: { + 'chrome' => 'true' + } + } - def test_push_true_with_event_arch - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) - vwo_instance.get_settings['isEventArchEnabled'] = true - assert_equal(true, vwo_instance.push('browser', 'chrome', '12345')[:browser]) + USER_EXPECTATIONS['FR_T_10_W_100_WHITELISTING_FAIL'].each do |test| + is_feature_enabled = vwo_instance.feature_enabled?(campaign_key, test['user'], options) + assert_equal(is_feature_enabled, test['is_feature_enabled']) + result = vwo_instance.get_feature_variable_value(campaign_key, 'BOOLEAN_VARIABLE', test['user'], options) + assert_equal(result, test['boolean_variable_value']) end + end - def test_push_int_value_false_with_event_arch - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) - vwo_instance.get_settings['isEventArchEnabled'] = true - assert_equal(false, vwo_instance.push('browser', 1, '12345')[:browser]) + def test_activate_with_event_arch + set_up('AB_T_100_W_50_50') + @vwo.get_settings['isEventArchEnabled'] = true + USER_EXPECTATIONS[@campaign_key].each do |test| + assert_equal(@vwo.activate(@campaign_key, test['user']), test['variation']) end + end - def test_push_true_with_two_arg_and_with_event_arch - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) - vwo_instance.get_settings['isEventArchEnabled'] = true - assert_equal(true, vwo_instance.push({'browser' => 'chrome'}, '12345')[:browser]) - end + def test_feature_enabled_with_event_arch + set_up('FR_T_100_W_100') + @vwo.get_settings['isEventArchEnabled'] = true - def test_push_true_with_two_arg - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) - assert_equal(true, vwo_instance.push({'browser' => 'chrome'}, '12345')[:browser]) + USER_EXPECTATIONS['T_100_W_10_20_30_40'].each do |test| + assert_equal(@vwo.feature_enabled?('FR_T_100_W_100', test['user']), !test['variation'].nil?) end + end - def test_push_int_value_false_with_two_arg_and_with_event_arch - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) - vwo_instance.get_settings['isEventArchEnabled'] = true - assert_equal(false, vwo_instance.push({'browser' => 1}, '12345')[:browser]) + def test_track_with_event_arch + set_up('AB_T_100_W_50_50') + @vwo.get_settings['isEventArchEnabled'] = true + @vwo.get_settings['campaigns'][0]['goals'][0]['revenueProp'] = 'dummyRevenueProperty' + USER_EXPECTATIONS[@campaign_key].each do |test| + result = @vwo.track(@campaign_key, test['user'], @goal_identifier, { revenue_value: '23.3' }) + assert_equal(result, { @campaign_key => !test['variation'].nil? }) end + end - def test_push_int_value_false_with_two_arg - vwo_instance = VWO.new(60781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) - assert_equal(false, vwo_instance.push({'browser' => 1}, '12345')[:browser]) - end + def test_push_true_with_event_arch + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) + vwo_instance.get_settings['isEventArchEnabled'] = true + assert_equal(true, vwo_instance.push('browser', 'chrome', '12345')[:browser]) + end - def test_get_variation_as_user_hash_passes_whitelisting - vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_100_W_25_25_25_25'])) + def test_push_int_value_false_with_event_arch + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) + vwo_instance.get_settings['isEventArchEnabled'] = true + assert_equal(false, vwo_instance.push('browser', 1, '12345')[:browser]) + end - vwo_instance.get_settings['campaigns'][0]['isUserListEnabled'] = true - vwo_instance.get_settings['campaigns'][0]['variations'][1]['segments'] = { - "or" => [ - "user" => "78A6CEDE959A518491D7DCEDC0A01686" - ] - } - assert_equal(vwo_instance.get_variation_name('AB_T_100_W_25_25_25_25', 'Rohit'), 'Variation-1') - end + def test_push_true_with_two_arg_and_with_event_arch + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) + vwo_instance.get_settings['isEventArchEnabled'] = true + assert_equal(true, vwo_instance.push({ 'browser' => 'chrome' }, '12345')[:browser]) + end - def test_set_opt_out_api - set_up('T_50_W_50_50_WS') - assert_equal(@vwo.set_opt_out, true) - end + def test_push_true_with_two_arg + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) + assert_equal(true, vwo_instance.push({ 'browser' => 'chrome' }, '12345')[:browser]) + end - def test_apis_when_set_opt_out_called - set_up('T_50_W_50_50_WS') + def test_push_int_value_false_with_two_arg_and_with_event_arch + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) + vwo_instance.get_settings['isEventArchEnabled'] = true + assert_equal(false, vwo_instance.push({ 'browser' => 1 }, '12345')[:browser]) + end - assert_equal(@vwo.set_opt_out, true) - assert_equal(@vwo.activate('T_50_W_50_50_WS', 'Ashley', {}), nil) - assert_equal(@vwo.get_variation_name('T_50_W_50_50_WS', 'Ashley', {}), nil) - goal_identifier = 'ddd' - assert_equal(@vwo.track('T_50_W_50_50_WS', 'Ashley', goal_identifier, {}), false) - assert_equal(@vwo.feature_enabled?('T_50_W_50_50_WS', 'Ashley', {}), false) - assert_equal(@vwo.get_feature_variable_value('FT_T_75_W_10_20_30_40_WS', 'STRING_VARIABLE', 'Ashley', {}), nil) - assert_equal(@vwo.get_and_update_settings_file, false) - assert_equal(@vwo.push('tagKey', 'tagValue', 'Ashley'), {}) - assert_equal(@vwo.flush_events, false) - end + def test_push_int_value_false_with_two_arg + vwo_instance = VWO.new(60_781, 'ea87170ad94079aa190bc7c9b85d26fb', nil, nil, true, JSON.generate(SETTINGS_FILE['DUMMY_SETTINGS_FILE']), { log_level: Logger::DEBUG }) + assert_equal(false, vwo_instance.push({ 'browser' => 1 }, '12345')[:browser]) + end - def test_apis_when_set_opt_out_called_with_event_batch - def flush_callback(events) - end + def test_get_variation_as_user_hash_passes_whitelisting + vwo_instance = VWO.new(1, 'someuniquestuff1234567', nil, nil, true, JSON.generate(SETTINGS_FILE['AB_T_100_W_25_25_25_25'])) - options = { - batch_events: { - events_per_request: 3, - request_time_interval: 5 - } + vwo_instance.get_settings['campaigns'][0]['isUserListEnabled'] = true + vwo_instance.get_settings['campaigns'][0]['variations'][1]['segments'] = { + 'or' => [ + 'user' => '78A6CEDE959A518491D7DCEDC0A01686' + ] + } + assert_equal(vwo_instance.get_variation_name('AB_T_100_W_25_25_25_25', 'Rohit'), 'Variation-1') + end + + def test_set_opt_out_api + set_up('T_50_W_50_50_WS') + assert_equal(@vwo.set_opt_out, true) + end + + def test_apis_when_set_opt_out_called + set_up('T_50_W_50_50_WS') + + assert_equal(@vwo.set_opt_out, true) + assert_equal(@vwo.activate('T_50_W_50_50_WS', 'Ashley', {}), nil) + assert_equal(@vwo.get_variation_name('T_50_W_50_50_WS', 'Ashley', {}), nil) + goal_identifier = 'ddd' + assert_equal(@vwo.track('T_50_W_50_50_WS', 'Ashley', goal_identifier, {}), false) + assert_equal(@vwo.feature_enabled?('T_50_W_50_50_WS', 'Ashley', {}), false) + assert_equal(@vwo.get_feature_variable_value('FT_T_75_W_10_20_30_40_WS', 'STRING_VARIABLE', 'Ashley', {}), nil) + assert_equal(@vwo.get_and_update_settings_file, false) + assert_equal(@vwo.push('tagKey', 'tagValue', 'Ashley'), {}) + assert_equal(@vwo.flush_events, false) + end + + def test_apis_when_set_opt_out_called_with_event_batch + options = { + batch_events: { + events_per_request: 3, + request_time_interval: 5 } - vwo_instance = initialize_vwo_with_batch_events_option('AB_T_50_W_50_50', options) - - assert_equal(vwo_instance.set_opt_out, true) - assert_equal(vwo_instance.activate('T_50_W_50_50_WS', 'Ashley', {}), nil) - assert_equal(vwo_instance.get_variation_name('T_50_W_50_50_WS', 'Ashley', {}), nil) - goal_identifier = 'ddd' - assert_equal(vwo_instance.track('T_50_W_50_50_WS', 'Ashley', goal_identifier, {}), false) - assert_equal(vwo_instance.feature_enabled?('T_50_W_50_50_WS', 'Ashley', {}), false) - assert_equal(vwo_instance.get_feature_variable_value('FT_T_75_W_10_20_30_40_WS', 'STRING_VARIABLE', 'Ashley', {}), nil) - assert_equal(vwo_instance.get_and_update_settings_file, false) - assert_equal(vwo_instance.push('tagKey', 'tagValue', 'Ashley'), {}) - assert_equal(vwo_instance.flush_events, false) - end + } + vwo_instance = initialize_vwo_with_batch_events_option('AB_T_50_W_50_50', options) + + assert_equal(vwo_instance.set_opt_out, true) + assert_equal(vwo_instance.activate('T_50_W_50_50_WS', 'Ashley', {}), nil) + assert_equal(vwo_instance.get_variation_name('T_50_W_50_50_WS', 'Ashley', {}), nil) + goal_identifier = 'ddd' + assert_equal(vwo_instance.track('T_50_W_50_50_WS', 'Ashley', goal_identifier, {}), false) + assert_equal(vwo_instance.feature_enabled?('T_50_W_50_50_WS', 'Ashley', {}), false) + assert_equal(vwo_instance.get_feature_variable_value('FT_T_75_W_10_20_30_40_WS', 'STRING_VARIABLE', 'Ashley', {}), nil) + assert_equal(vwo_instance.get_and_update_settings_file, false) + assert_equal(vwo_instance.push('tagKey', 'tagValue', 'Ashley'), {}) + assert_equal(vwo_instance.flush_events, false) + end end diff --git a/vwo-sdk.gemspec b/vwo-sdk.gemspec index f3b50d2..4c14509 100644 --- a/vwo-sdk.gemspec +++ b/vwo-sdk.gemspec @@ -8,8 +8,8 @@ Gem::Specification.new do |spec| spec.authors = ['VWO'] spec.email = ['dev@wingify.com'] - spec.summary = "Ruby SDK for VWO FullStack testing" - spec.description = "Ruby SDK for VWO FullStack testing." + spec.summary = 'Ruby SDK for VWO FullStack testing' + spec.description = 'Ruby SDK for VWO FullStack testing.' spec.homepage = 'https://vwo.com/fullstack/server-side-testing/' spec.license = 'Apache-2.0' @@ -17,18 +17,18 @@ Gem::Specification.new do |spec| spec.require_paths = ['lib'] spec.metadata = { - "bug_tracker_uri" => "https://github.com/wingify/vwo-ruby-sdk/issues", - "changelog_uri" => "https://github.com/wingify/vwo-ruby-sdk/blob/master/CHANGELOG.md", - "documentation_uri" => "https://developers.vwo.com/docs/ruby-sdk-reference", - "homepage_uri" => "https://github.com/wingify/vwo-ruby-sdk", - "source_code_uri" => "https://github.com/wingify/vwo-ruby-sdk" + 'bug_tracker_uri' => 'https://github.com/wingify/vwo-ruby-sdk/issues', + 'changelog_uri' => 'https://github.com/wingify/vwo-ruby-sdk/blob/master/CHANGELOG.md', + 'documentation_uri' => 'https://developers.vwo.com/docs/ruby-sdk-reference', + 'homepage_uri' => 'https://github.com/wingify/vwo-ruby-sdk', + 'source_code_uri' => 'https://github.com/wingify/vwo-ruby-sdk' } - spec.required_ruby_version = '>= 2.2.10' + spec.required_ruby_version = '>= 2.2.10' # rubocop:todo Gemspec/RequiredRubyVersion spec.add_development_dependency 'codecov', '~> 0.4.3' - spec.add_development_dependency 'rubocop', '~> 0.70' spec.add_development_dependency 'mocha', '~>1.13.0' + spec.add_development_dependency 'rubocop', '~> 0.70' spec.add_runtime_dependency 'json-schema', '~> 2.8' spec.add_runtime_dependency 'murmurhash3', '~> 0.1'