promonizr 1.13.2

data/spec/promonizr/promotion_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+require 'promonizr/companies'
+
+describe Promonizr::Promotion do
+  context '#show?' do
+    before(:context) do
+      @dummy_stage = 'dummy'
+      @dummy_url = '/dummy/url'
+    end
+
+    describe 'on proper values' do
+      describe 'returns true' do
+        it 'when expected stage is passed' do
+          promotion = described_class.new(display_config: { 'stage' => { 'landing' => true } })
+          expect(promotion.show?(@dummy_url, 'landing')).to be_truthy
+        end
+
+        it 'when one of multiple possible stages is passed' do
+          promotion = described_class.new(
+            display_config: { 'stage' => { 'landing' => true, 'results' => true } }
+          )
+          expect(promotion.show?(@dummy_url, 'landing')).to be_truthy
+
+          promotion = described_class.new(
+            display_config: { 'stage' => { 'landing' => true, 'results' => false } }
+          )
+          expect(promotion.show?(@dummy_url, 'landing')).to be_truthy
+        end
+
+        it 'when both expected stage and excluded url are passed' do
+          promotion = described_class.new(display_config: {
+            'stage' => { 'landing' => true, 'results' => true },
+            'url_exclusions' => ['/sample/url', '/another/url', '/foo/bar']
+          })
+          expect(promotion.show?(@dummy_url, 'landing')).to be_truthy
+          expect(promotion.show?(@dummy_url, 'results')).to be_truthy
+        end
+      end
+
+      describe 'returns false' do
+        it 'when passed stage is configure to be excluded' do
+          promotion = described_class.new(display_config: { 'stage' => { 'landing' => false } })
+          expect(promotion.show?(@dummy_url, 'landing')).to be_falsey
+        end
+
+        it 'when unexpected stage is passed' do
+          promotion = described_class.new(display_config: { 'stage' => { 'landing' => true } })
+          expect(promotion.show?(@dummy_url, @dummy_stage)).to be_falsey
+        end
+
+        it 'when stage check is ok but url is excluded' do
+          promotion = described_class.new(
+            display_config: { 'stage' => { 'landing' => true }, 'url_exclusions' => ['/sample/url'] }
+          )
+          expect(promotion.show?('/sample/url', 'landing')).to be_falsey
+        end
+
+        it 'when url check is ok but stage is excluded' do
+          promotion = described_class.new(
+            display_config: { 'stage' => { 'landing' => false }, 'url_exclusions' => ['/sample/url'] }
+          )
+          expect(promotion.show?(@dummy_url, 'landing')).to be_falsey
+          expect(promotion.show?(@dummy_url, @dummy_stage)).to be_falsey
+        end
+      end
+    end
+
+    describe 'on null, missing, or empty values' do
+      it 'returns true when display_config is nil' do
+        promotion = described_class.new(display_config: nil)
+        expect(promotion.show?(@dummy_url, @dummy_stage)).to be_truthy
+      end
+
+      it 'returns true when display_config is an empty Hash' do
+        promotion = described_class.new(display_config: {})
+        expect(promotion.show?(@dummy_url, @dummy_stage)).to be_truthy
+      end
+
+      it 'returns true when url_exclusions key is not present' do
+        promotion = described_class.new(display_config: { 'stage' => 'landing' })
+        expect(promotion.show?(@dummy_url, 'landing')).to be_truthy
+      end
+    end
+
+    describe 'on non valid scenarios' do
+      it 'raise an exception when not enough params are passed' do
+        promotion = described_class.new
+        expect{ promotion.show? }.to raise_error(ArgumentError)
+
+        promotion = described_class.new
+        expect{ promotion.show?(@dummy_url) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context '#featured?' do
+    describe 'on null, missing, or empty values' do
+      it 'returns false when display_config is nil' do
+        promotion = described_class.new(display_config: nil)
+        expect(promotion.featured?).to be_falsey
+      end
+
+      it 'returns false when display_config is an empty Hash' do
+        promotion = described_class.new(display_config: {})
+        expect(promotion.featured?).to be_falsey
+      end
+    end
+
+    describe 'on proper value' do
+      it 'returns true when is set as featured' do
+        promotion = described_class.new(display_config: { 'featured' => true } )
+        expect(promotion.featured?).to be_truthy
+      end
+
+      it 'returns false when is not set as featured' do
+        promotion = described_class.new(display_config: { 'featured' => false } )
+        expect(promotion.featured?).to be_falsey
+      end
+    end
+  end
+
+  context '#companies' do
+    it 'returns selected companies if they are filtered' do
+      allow(Promonizr::Companies).to receive(:by_url_names) { |names, country_code, product| names }
+      promotion = described_class.new(companies: ['some_company', 'some_other_company'])
+
+      expect(promotion.companies).to eq(['some_company', 'some_other_company'])
+    end
+
+    it 'returns all companies if they are not filtered' do
+      allow(Promonizr::Companies).to receive(:all).and_return(:all)
+      promotion = described_class.new
+
+      expect(promotion.companies).to eq(:all)
+    end
+  end
+
+  context '#image_url' do
+    it 'returns url for cloudfront' do
+      promotion = described_class.new(
+        image_url: 'https://comparaonline.s3.amazonaws.com/promotions/campaigns/121-promo-generic-27_%281%29.jpg'
+      )
+      expect(promotion.image_url).to eq('https://webimg.comparaonline.com/121-promo-generic-27_%281%29.jpg')
+    end
+  end
+
+  context '#featured_image_url' do
+    it 'returns url for cloudfront' do
+      promotion = described_class.new(
+        featured_image_url: 'https://comparaonline.s3.amazonaws.com/promotions/campaigns/108-promo-generic-12-featured_%281%29.jpg'
+      )
+      expect(promotion.featured_image_url).to eq('https://webimg.comparaonline.com/108-promo-generic-12-featured_%281%29.jpg')
+    end
+  end
+end

data/spec/promonizr/request_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Promonizr::Request do
+  it 'returns a default answer on timeout' do
+    allow(RestClient::Request).to receive(:execute) do |options|
+      sleep(Promonizr::Request::TIMEOUT_SECONDS + 0.1)
+    end
+
+    allow(Rails.logger = {}).to receive(:error)
+    expect(described_class.execute(:get, Faker::Internet.url))
+      .to eq(Promonizr::Request::DEFAULT_ANSWER)
+  end
+
+  it 'returns a default answer on an unhandled exception' do
+    allow(RestClient::Request).to receive(:execute) do |options|
+      raise StandardError.new
+    end
+
+    allow(Rails.logger = {}).to receive(:error)
+    expect(described_class.execute(:get, Faker::Internet.url))
+      .to eq(Promonizr::Request::DEFAULT_ANSWER)
+  end
+end

data/spec/promonizr/search_spec.rb

@@ -0,0 +1,343 @@
+require 'spec_helper'
+
+describe Promonizr::Search do
+  before(:example) do
+    @country_code = Promonizr::Campaigns::COUNTRY_CODES.sample
+    @product = Promonizr::Products::TYPE_CODES.sample
+    @company_name = 'some_company'
+  end
+
+  before(:context) do
+    @attributes = { age: 20, gender: 'male', company_name: @company_name}
+    @config = {}
+  end
+
+  context '#filter' do
+    it 'narrows by product and country_code' do
+      default_company_param = nil
+
+      stub_request(:post, Promonizr::Evaluations.api_url('evaluate'))
+        .with(
+          body: {
+            countryCode: @country_code,
+            product: @product,
+            form: {},
+            companyName: default_company_param
+          }
+        ).to_return(status: 200, body: [
+          build(:promotion, { country_code: @country_code, product: @product })
+        ].to_json)
+
+      result = Promonizr::Search.filter(@product, @country_code)
+      expect(result).to_not be_nil
+      expect(result).to_not be_empty
+    end
+
+    it 'narrows by attributes' do
+      stub_request(:post, Promonizr::Evaluations::api_url('evaluate'))
+        .with(
+          body: {
+            countryCode: @country_code,
+            product: @product,
+            form: @attributes,
+            companyName: @companyName
+          }
+        ).to_return(status: 200, body: [
+          build(:promotion, {
+            country_code: @country_code,
+            product: @product,
+            form: @attributes
+          })
+        ].to_json)
+
+      result = Promonizr::Search.filter(@product, @country_code, @config, @attributes)
+      expect(result).to_not be_nil
+      expect(result).to_not be_empty
+    end
+
+    it 'sorts ascendant by rules_size' do
+      rules_1 = {
+        'age' => { 'conditions' => [{ 'between' => [18, 65] }] },
+        'gender' => { 'conditions' => [{ 'eq' => 'male' }]},
+        'state' => { 'conditions' => [{ 'in' => ['Foo', 'Bar'] }] }
+      }
+
+      rules_2 = {
+        'age' => { 'conditions' => [{ 'between' => [18, 65] }] },
+        'gender' => { 'conditions' => [{ 'eq' => 'male' }]}
+      }
+
+      rules_3 = {
+        'age' => { 'conditions' => [{ 'between' => [18, 65] }] },
+        'gender' => { 'conditions' => [{ 'eq' => 'male' }]},
+        'state' => { 'conditions' => [{ 'in' => ['Foo', 'Bar'] }] },
+        'country_code' => { 'conditions' => [{ 'eq' => 'cl' }] }
+      }
+
+      promotion = lambda { |rules| build(:promotion, {
+        country_code: @country_code,
+        product: @product,
+        rules: rules
+      }) }
+
+      stub_request(:post, Promonizr::Evaluations.api_url('evaluate'))
+        .with(
+          body: {
+            countryCode: @country_code,
+            product: @product,
+            form: @attributes,
+            companyName: @companyName
+          },
+        ).to_return(status: 200, body: [
+          promotion.call(rules_1),
+          promotion.call(rules_2),
+          promotion.call(rules_3)
+        ].to_json)
+
+      promotions = Promonizr::Search.filter(@product, @country_code, @config, @attributes)
+
+      expect(promotions[0].rules.size).to eq(2)
+      expect(promotions[1].rules.size).to eq(3)
+      expect(promotions[2].rules.size).to eq(4)
+    end
+
+    it 'sorts rules descendant by end_date' do
+      rules = {
+        'age' => { 'conditions' => [{ 'between' => [18, 65] }] },
+        'gender' => { 'conditions' => [{ 'eq' => 'male' }]}
+      }
+
+      base_date = Faker::Date.forward
+      future_date_1 = base_date + 1.month
+      future_date_2 = base_date + 1.day
+      future_date_3 = base_date + 2.month
+
+      promotion = lambda { |date| build(:promotion, {
+        country_code: @country_code,
+        product: @product,
+        end_date: date,
+        rules: rules
+      }) }
+
+      stub_request(:post, Promonizr::Evaluations.api_url('evaluate'))
+        .with(
+          body: {
+            countryCode: @country_code,
+            product: @product,
+            form: @attributes,
+            companyName: @companyName
+          }
+        ).to_return(status: 200, body: [
+          promotion.call(future_date_1),
+          promotion.call(future_date_2),
+          promotion.call(future_date_3)
+        ].to_json)
+
+      promotions = Promonizr::Search.filter(@product, @country_code, @config, @attributes)
+
+      expect(promotions[0].end_date.to_date).to eq(future_date_2)
+      expect(promotions[1].end_date.to_date).to eq(future_date_1)
+      expect(promotions[2].end_date.to_date).to eq(future_date_3)
+    end
+  end
+
+  context '#for_results' do
+    it 'only returns promotions with stage results flag enabled' do
+      promotion = lambda { |display_config| build(:promotion, {
+        country_code: @country_code,
+        product: @product,
+        display_config: display_config
+      }) }
+
+      stub_request(:post, Promonizr::Evaluations.api_url('evaluate'))
+        .with(
+          body: {
+            countryCode: @country_code,
+            product: @product,
+            form: @attributes,
+            companyName: @companyName
+          }
+        ).to_return(status: 200, body: [
+          promotion.call('stage' => { 'landing' => true }),
+          promotion.call('stage' => { 'landing' => true, 'results' => true }),
+          promotion.call('stage' => { 'results' => true })
+        ].to_json)
+
+      expect(Promonizr::Search.for_results(@product, @country_code, @attributes).size).to eq(2)
+    end
+  end
+
+  context '#for_results_in_bulk' do
+    let(:url) { "#{@product}/#{@country_code}" }
+    let(:offer_id) { '1234' }
+    let(:unexisting_offer_id) { '4321' }
+    let(:without_promo_offer_id) { '2345' }
+    let(:company) { 'company' }
+    let(:form_data) do
+      {
+        destination: 31
+      }
+    end
+    let(:offers_data) do
+      [
+        { id: offer_id, company_name: company },
+        { id: without_promo_offer_id, company_name: company }
+      ]
+    end
+    let(:promotion) do
+      {
+        country_code: @country_code,
+        product: @product,
+        display_config: {stage: {results: true}}
+      }
+    end
+
+    before do
+      stub_request(:post, Promonizr::Evaluations.api_url("#{url}/campaigns_for_offers"))
+        .with(
+          body: {
+            form: form_data,
+            offers: offers_data
+          }
+        ).to_return(status: 200, body: {
+          offer_id => [promotion],
+          without_promo_offer_id => []
+        }.to_json)
+    end
+
+    it 'returns promotion for offer' do
+      promotions = Promonizr::Search.for_results_in_bulk(url, true, form_data, offers_data)
+      expect(promotions[offer_id].show_promotion?).to be_truthy
+    end
+
+    it 'returns non showable promotions if disabled' do
+      promotions = Promonizr::Search.for_results_in_bulk(url, false, form_data, offers_data)
+      expect(promotions[offer_id].show_promotion?).to be_falsey
+    end
+
+    it 'returns non showable promotions for offers without promotions' do
+      promotions = Promonizr::Search.for_results_in_bulk(url, true, form_data, offers_data)
+      expect(promotions[without_promo_offer_id].show_promotion?).to be_falsey
+    end
+
+    it 'returns non showable promotions for unexisting offers' do
+      promotions = Promonizr::Search.for_results_in_bulk(url, true, form_data, offers_data)
+      expect(promotions[unexisting_offer_id].show_promotion?).to be_falsey
+    end
+  end
+
+  context '#for_carousel' do
+    it 'only returns promotions with stage landing flag enabled' do
+      promotion = lambda { |display_config| build(:promotion, {
+        country_code: @country_code,
+        product: @product,
+        display_config: display_config,
+      }) }
+
+      stub_request(:post, Promonizr::Evaluations.api_url('evaluate'))
+        .with(
+          body: {
+            countryCode: @country_code,
+            product: @product,
+            form: @attributes,
+            companyName: @companyName
+          }
+        ).to_return(status: 200, body: [
+          promotion.call('stage' => { 'landing' => true }),
+          promotion.call('stage' => { 'landing' => true, 'results' => true }),
+          promotion.call('stage' => { 'results' => true })
+        ].to_json)
+
+      expect(Promonizr::Search.for_carousel(@product, @country_code, Faker::Internet.url, @attributes).size).to eq(2)
+    end
+
+    it 'only returns promotions with stage landing flag enabled filtering excluded_urls' do
+      promotion = lambda { |display_config| build(:promotion, {
+        country_code: @country_code,
+        product: @product,
+        display_config: display_config,
+      }) }
+      some_url = Faker::Internet.url('comparaonline.com')
+
+      stub_request(:post, Promonizr::Evaluations.api_url('evaluate'))
+        .with(
+          body: {
+            countryCode: @country_code,
+            product: @product,
+            form: @attributes,
+            companyName: @companyName
+          }
+        ).to_return(status: 200, body: [
+          promotion.call(
+            'stage' => { 'landing' => true },
+            'url_exclusions' => [Faker::Internet.url('foo.com'), Faker::Internet.url('bar.com')]
+          ),
+          promotion.call(
+            'stage' => { 'landing' => true, 'results' => true },
+            'url_exclusions' => [some_url, Faker::Internet.url]
+          ),
+          promotion.call('stage' => { 'results' => true })
+        ].to_json)
+
+      expect(Promonizr::Search.for_carousel(@product, @country_code, some_url, @attributes).size).to eq(1)
+    end
+  end
+
+  context '#featured' do
+    it 'returns the first promotion with featured flag enabled' do
+      promotion = lambda { |display_config| build(:promotion, {
+        country_code: @country_code,
+        product: @product,
+        display_config: display_config
+      })}
+
+      stub_request(:post, Promonizr::Evaluations.api_url('evaluate'))
+        .with(
+          body: {
+            countryCode: @country_code,
+            product: @product,
+            form: @attributes,
+            companyName: @companyName
+          }
+        ).to_return(status: 200, body: [
+          promotion.call({}),
+          promotion.call('featured' => true),
+          build(:promotion, display_config: { 'featured' => true, stage: 'landing' }, mark: true),
+          promotion.call('featured' => true, stage: 'landing'),
+          promotion.call('featured' => false),
+        ].to_json)
+
+      result = Promonizr::Search.featured(@product, @country_code, Faker::Internet.url, @attributes)
+
+      expect(result).to be_kind_of(Promonizr::Promotion)
+      expect(result.mark).to be_truthy
+    end
+
+    it 'returns the first promotion with featured flag enabled filtering excluded_urls' do
+      some_url = Faker::Internet.url('comparaonline.com')
+
+      stub_request(:post, Promonizr::Evaluations.api_url('evaluate'))
+        .with(
+          body: {
+            countryCode: @country_code,
+            product: @product,
+            form: @attributes,
+            companyName: @companyName
+          }
+        ).to_return(status: 200, body: [
+          build(:featured_promotion,
+            'url_exclusions' => [Faker::Internet.url('foo.com'), Faker::Internet.url('bar.com')],
+            mark: true
+          ),
+          build(:featured_promotion,
+            'url_exclusions' => [some_url, Faker::Internet.url]
+          ),
+          build(:featured_promotion)
+        ].to_json)
+
+      result = Promonizr::Search.featured(@product, @country_code, some_url, @attributes)
+      expect(result).to be_kind_of(Promonizr::Promotion)
+      expect(result.mark).to be_truthy
+    end
+  end
+end

data/spec/promonizr/utils_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe Promonizr::Utils do
+
+  describe '.cast_values' do
+    context 'hash with several truthy values' do
+      hash = { a: true, b: 'True', c: ' true ', d: 'TRUE',  e: 'true'}
+      casted_hash = Promonizr::Utils::cast_values(hash)
+      hash.keys.each do |k|
+        it { expect(casted_hash[k]).to be true }
+      end
+    end
+
+    context 'hash with mixed truthy and falsy values' do
+      hash = { a: true, b: 'True', c: ' true ', d: 'false',  e: 'False', f: false }
+      casted_hash = Promonizr::Utils::cast_values(hash)
+
+      it { expect(casted_hash[:a]).to be true }
+      it { expect(casted_hash[:b]).to be true }
+      it { expect(casted_hash[:c]).to be true }
+      it { expect(casted_hash[:d]).to be false }
+      it { expect(casted_hash[:e]).to be false }
+      it { expect(casted_hash[:f]).to be false }
+    end
+
+    context 'hash without truthy or falsy values' do
+      hash = { a: 1, b: 0, c: 'string', d: {},  e: [], f: nil, g: '' }
+      casted_hash = Promonizr::Utils::cast_values(hash)
+
+      it { expect(casted_hash[:a]).to eq(1) }
+      it { expect(casted_hash[:b]).to eq(0) }
+      it { expect(casted_hash[:c]).to eq('string') }
+      it { expect(casted_hash[:d]).to eq({}) }
+      it { expect(casted_hash[:e]).to eq([]) }
+      it { expect(casted_hash[:f]).to eq(nil) }
+      it { expect(casted_hash[:g]).to eq('') }
+    end
+
+    context 'truthy value inside of an array' do
+      hash = { 'multitravel' => { 'conditions'=> [ { 'eq' => 'true' } ] } }
+      casted_hash = Promonizr::Utils::cast_values(hash)
+
+      it do
+        expect(casted_hash['multitravel']['conditions'][0]['eq']).to be true
+      end
+    end
+
+    context 'hash with numeric values as strings' do
+      hash = { a: 1, b: '1', c: ' 1.00 ', d: '1.21',  e: ' 0.0 ', f: 2.14, g: '0' }
+      casted_hash = Promonizr::Utils::cast_values(hash)
+
+      it { expect(casted_hash[:a]).to be 1 }
+      it { expect(casted_hash[:b]).to be 1 }
+      it { expect(casted_hash[:c]).to be 1.00 }
+      it { expect(casted_hash[:d]).to be 1.21 }
+      it { expect(casted_hash[:e]).to be 0.0 }
+      it { expect(casted_hash[:f]).to be 2.14 }
+      it { expect(casted_hash[:g]).to be 0 }
+    end
+  end
+
+  describe '.transform_values' do
+    context 'hash deep == 1' do
+      hash = { a: 1, b: 2, c: 3 }
+      transformed = Promonizr::Utils::transform_values(hash) { |x| x ** 2 }
+      it { expect(transformed[:a]).to eq(1) }
+      it { expect(transformed[:b]).to eq(4) }
+      it { expect(transformed[:c]).to eq(9) }
+    end
+
+    context 'hash deep == 2' do
+      hash = { a: { b: 2, c: 3 } }
+      transformed = Promonizr::Utils::transform_values(hash) { |x| x ** 3 }
+
+      it { expect(transformed[:a]).to eq({ b: 8, c: 27 }) }
+      it { expect(transformed[:a][:b]).to eq(8) }
+      it { expect(transformed[:a][:c]).to eq(27) }
+    end
+
+    context 'hash deep == 3' do
+      hash = { a: { b: { c: 2, d: 3 } } }
+      transformed = Promonizr::Utils::transform_values(hash) { |x| x ** 2 }
+
+      it { expect(transformed[:a]).to eq({ b: { c: 4, d: 9 } })}
+    end
+
+    context 'hash contains an array with a hash' do
+      hash = { a: { b: [ { c: 2, d: 3 } ] } }
+      transformed = Promonizr::Utils::transform_values(hash) { |x| x ** 2 }
+
+      it { expect(transformed).to eq({ a: { b: [ { c: 4, d: 9 } ] } })}
+    end
+  end
+end

data/spec/promonizr_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Promonizr do
+  it 'has a version number' do
+    expect(Promonizr::VERSION).not_to be nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+ENV['RAILS_ENV'] = 'test'
+
+require 'rails'
+require 'rails/engine'
+require 'rails/railtie'
+require 'rest-client'
+
+require 'co_config'
+CoConfig.load("#{__dir__}/../config")
+
+require 'promonizr'
+
+require 'rspec-rails'
+require 'webmock/rspec'
+require 'support/factory_girl'
+require 'faker'

data/spec/support/factory_girl.rb

@@ -0,0 +1,9 @@
+require 'factory_girl'
+
+RSpec.configure do |config|
+  config.include FactoryGirl::Syntax::Methods
+
+  config.before(:suite) do
+    FactoryGirl.find_definitions
+  end
+end