workarea-core 3.4.45 → 3.5.0.beta.1

data/test/lib/workarea/ext/mongoid/lookup_hash_test.rb

@@ -0,0 +1,86 @@
+require 'test_helper'
+
+module Mongoid
+  class LookupHashTest < Workarea::TestCase
+    class BsonIdModel
+      include Mongoid::Document
+    end
+
+    class IntegerModel
+      include Mongoid::Document
+      field :_id, type: Integer
+    end
+
+    class StringModel
+      include Mongoid::Document
+      field :_id, type: Integer
+    end
+
+    class StringIdModel
+      include Mongoid::Document
+      field :_id, type: Workarea::StringId
+    end
+
+    def test_bson_ids
+      one = BsonIdModel.create!
+      two = BsonIdModel.create!
+
+      results = BsonIdModel.to_lookup_hash
+      assert_equal(2, results.size)
+      assert_equal(results[one.id], one)
+      assert_equal(results[two.id], two)
+
+      results = BsonIdModel.where(id: one.id).to_lookup_hash
+      assert_equal(1, results.size)
+      assert_equal(results[one.id], one)
+      assert_equal(results[one.id.to_s], one)
+    end
+
+    def test_integers
+      one = IntegerModel.create!(id: 1)
+      two = IntegerModel.create!(id: 2)
+
+      results = IntegerModel.to_lookup_hash
+      assert_equal(2, results.size)
+      assert_equal(results[1], one)
+      assert_equal(results[2], two)
+
+      results = IntegerModel.where(:id.gt => 1).to_lookup_hash
+      assert_equal(1, results.size)
+      assert_equal(results[2], two)
+
+      results = IntegerModel.where(id: 1).to_lookup_hash
+      assert_equal(1, results.size)
+      assert_equal(results[1], one)
+      assert_equal(results['1'], one)
+    end
+
+    def test_strings
+      one = StringModel.create!(id: '1')
+      two = StringModel.create!(id: '2')
+
+      results = StringModel.to_lookup_hash
+      assert_equal(2, results.size)
+      assert_equal(results['1'], one)
+      assert_equal(results['2'], two)
+
+      results = StringModel.where(id: '1').to_lookup_hash
+      assert_equal(1, results.size)
+      assert_equal(results['1'], one)
+    end
+
+    def test_string_ids
+      one = StringIdModel.create!(id: '1')
+      two = StringIdModel.create!(id: '2')
+
+      results = StringIdModel.to_lookup_hash
+      assert_equal(2, results.size)
+      assert_equal(results['1'], one)
+      assert_equal(results['2'], two)
+
+      results = StringIdModel.where(id: '1').to_lookup_hash
+      assert_equal(1, results.size)
+      assert_equal(results['1'], one)
+    end
+  end
+end

data/test/lib/workarea/geolocation_test.rb

@@ -82,5 +82,25 @@ module Workarea
 
       assert_nil(location.region)
     end
+
+    def test_location_names
+      location = Geolocation.new
+      assert_equal([], location.names)
+
+      location = Geolocation.new(
+        'HTTP_GEOIP2_DATA_COUNTRY_CODE' => 'US',
+        'HTTP_GEOIP2_DATA_REGION_NAME' => 'Pennsylvania',
+        'HTTP_GEOIP2_DATA_CITY_NAME' => 'Philadelphia',
+        'HTTP_GEOIP_POSTAL_CODE' => '19106'
+      )
+
+      assert_includes(location.names, 'US')
+      assert_includes(location.names, 'USA')
+      assert_includes(location.names, 'United States of America')
+      assert_includes(location.names, 'PA')
+      assert_includes(location.names, 'Pennsylvania')
+      assert_includes(location.names, 'Philadelphia')
+      assert_includes(location.names, '19106')
+    end
   end
 end

data/test/mailers/workarea/application_mailer_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 module Workarea
-  class ApplicationMailerTest < IntegrationTest
+  class ApplicationMailerTest < MailerTest
     def test_from_address_changes
       order = create_placed_order
 
@@ -21,15 +21,5 @@ module Workarea
         assert_equal([changed_email], changed_mail.from)
       end
     end
-
-    def test_default_url_options
-      @current_options = Rails.application.config.action_mailer.default_url_options.deep_dup
-      Rails.application.config.action_mailer.default_url_options = { port: 12345 }
-
-      assert_equal(12345, ApplicationMailer.new.default_url_options[:port])
-
-    ensure
-      Rails.application.config.action_mailer.default_url_options = @current_options
-    end
   end
 end

data/test/middleware/workarea/query_cache_middleware_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+module Workarea
+  class QueryCacheMiddlewareTest < TestCase
+    class FooWorker
+      class << self
+        def sidekiq_options=(value)
+          @sidekiq_options = value
+        end
+
+        def sidekiq_options
+          @sidekiq_options || {}
+        end
+      end
+    end
+
+    def test_call
+      QueryCacheMiddleware.new({}).call(FooWorker.new, {}, :foo) do
+        refute(Mongoid::QueryCache.enabled?)
+        refute(Elasticsearch::QueryCache.enabled?)
+      end
+
+      FooWorker.sidekiq_options = { 'query_cache' => true }
+
+      QueryCacheMiddleware.new({}).call(FooWorker.new, {}, :foo) do
+        assert(Mongoid::QueryCache.enabled?)
+        assert(Elasticsearch::QueryCache.enabled?)
+      end
+
+      FooWorker.sidekiq_options = { 'mongoid_query_cache' => true }
+
+      QueryCacheMiddleware.new({}).call(FooWorker.new, {}, :foo) do
+        assert(Mongoid::QueryCache.enabled?)
+        refute(Elasticsearch::QueryCache.enabled?)
+      end
+
+      FooWorker.sidekiq_options = { 'elasticsearch_query_cache' => true }
+
+      QueryCacheMiddleware.new({}).call(FooWorker.new, {}, :foo) do
+        refute(Mongoid::QueryCache.enabled?)
+        assert(Elasticsearch::QueryCache.enabled?)
+      end
+
+      FooWorker.sidekiq_options = {
+        'elasticsearch_query_cache' => true,
+        'mongoid_query_cache' => true
+      }
+
+      QueryCacheMiddleware.new({}).call(FooWorker.new, {}, :foo) do
+        assert(Mongoid::QueryCache.enabled?)
+        assert(Elasticsearch::QueryCache.enabled?)
+      end
+    end
+  end
+end

data/test/models/workarea/checkout/collect_payment_test.rb

@@ -38,13 +38,21 @@ module Workarea
       end
 
       def test_action
-        Workarea.with_config do |config|
-          config.auto_capture = false
-          assert_equal('authorize!', collect_payment.action)
+        Workarea.config.checkout_payment_action = {
+          not_shipped: 'foo!',
+          shipped: 'bar!',
+          mixed: 'baz!'
+        }
 
-          config.auto_capture = true
-          assert_equal('purchase!', collect_payment.action)
-        end
+        order.items.build(requires_shipping: false)
+        assert_equal('foo!', collect_payment.action)
+
+        order.items.build(requires_shipping: true)
+        assert_equal('baz!', collect_payment.action)
+
+        order.items.clear
+        order.items.build(requires_shipping: true)
+        assert_equal('bar!', collect_payment.action)
       end
     end
   end

data/test/models/workarea/checkout_test.rb

@@ -51,63 +51,6 @@ module Workarea
       refute_equal(payment_id, checkout.payment.object_id)
     end
 
-    def test_update
-      create_shipping_service
-      checkout = Checkout.new(@order)
-
-      checkout.start_as(:guest)
-
-      refute(
-        checkout.update(
-          email: 'test@workarea.com',
-          shipping_address: {
-            last_name: 'Crouse',
-            street: '22 S. 3rd St.',
-            street_2: 'Second Floor',
-            city: 'Philadelphia',
-            region: 'PA',
-            postal_code: '19106',
-            country: 'US'
-          },
-          billing_address: {
-            first_name: 'Ben',
-            street: '22 S. 3rd St.',
-            street_2: 'Second Floor',
-            city: 'Philadelphia',
-            region: 'PA',
-            postal_code: '19106',
-            country: 'US'
-          }
-        )
-      )
-
-      assert(
-        checkout.update(
-          email: 'test@workarea.com',
-          shipping_address: {
-            first_name: 'Ben',
-            last_name: 'Crouse',
-            street: '22 S. 3rd St.',
-            street_2: 'Second Floor',
-            city: 'Philadelphia',
-            region: 'PA',
-            postal_code: '19106',
-            country: 'US'
-          },
-          billing_address: {
-            first_name: 'Ben',
-            last_name: 'Crouse',
-            street: '22 S. 3rd St.',
-            street_2: 'Second Floor',
-            city: 'Philadelphia',
-            region: 'PA',
-            postal_code: '19106',
-            country: 'US'
-          }
-        )
-      )
-    end
-
     def test_continue_as
       checkout = Checkout.new(@order)
       checkout.continue_as(@user)
@@ -231,6 +174,20 @@ module Workarea
       refute(@order.reload.placed?)
     end
 
+    def test_place_order_fails_for_fraud
+      @order.email = 'decline@workarea.com'
+      checkout = Checkout.new(@order)
+
+      checkout.expects(:complete?).returns(true)
+      checkout.expects(:shippable?).returns(true)
+      checkout.expects(:payable?).returns(true)
+      checkout.inventory.expects(:purchase).never
+      checkout.payment_collection.expects(:purchase).never
+
+      refute(checkout.place_order)
+      refute(@order.reload.placed?)
+    end
+
     def test_place_order_fails_if_inventory_fails
       checkout = Checkout.new(@order)
 
@@ -315,5 +272,22 @@ module Workarea
       checkout.payment_collection.expects(:valid?).returns(true)
       assert(checkout.payable?)
     end
+
+    def test_adjust_tender_amounts!
+      checkout = Checkout.new(@order, @user)
+      assert_nil(checkout.adjust_tender_amounts!)
+
+      checkout.start_as(@user)
+      checkout.payment_profile.update(store_credit: 5.to_m)
+      checkout.payment.save!
+
+      @order.total_price = 2.to_m
+      assert(checkout.adjust_tender_amounts!)
+      assert_equal(2.to_m, checkout.payment.store_credit.amount)
+
+      @order.total_price = 3.to_m
+      assert(checkout.adjust_tender_amounts!)
+      assert_equal(3.to_m, checkout.payment.store_credit.amount)
+    end
   end
 end

data/test/models/workarea/configuration/params_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+module Workarea
+  module Configuration
+    class ParamsTest < TestCase
+      def test_to_h
+        Workarea.config.admin_definition = Administrable::Definition.new
+        Workarea::Configuration.define_fields do
+          field 'foo', type: :string
+          field 'bar', type: :string, default: 'test'
+          field 'baz', type: :string, allow_blank: true
+
+          field 'foo_hash', type: :hash, values_type: :integer
+          field 'bar_array', type: :array
+          field 'baz_duration', type: :duration
+        end
+
+        params = {
+          foo: 'string value',
+          bar: nil,
+          baz: '',
+          foo_hash: ['one', '1', 'two', '', '', ''],
+          bar_array: 'one, two, three',
+          baz_duration: %w(20 minutes)
+        }
+
+        result = Params.new(params).to_h
+        assert_equal('string value', result[:foo])
+        assert_equal('test', result[:bar])
+        assert_equal('', result[:baz])
+        assert_equal({ 'one' => 1 }, result[:foo_hash])
+        assert_equal(%w(one two three), result[:bar_array])
+        assert_equal(20.minutes, result[:baz_duration])
+      end
+    end
+  end
+end

data/test/models/workarea/data_file/csv_test.rb

@@ -47,10 +47,6 @@ module Workarea
         embedded_in :foo
       end
 
-      class Qoo < Bar
-        field :qoo, type: String
-      end
-
       def test_merging_rows_for_embedded
         model = Foo.create!(
           bars: [{ name: '1' }, { name: '2' }],
@@ -214,19 +210,17 @@ module Workarea
       end
 
       def test_ignored_fields
-        Workarea.with_config do |config|
-          config.data_file_ignored_fields = %w(ignore)
+        Workarea.config.data_file_ignored_fields = %w(ignore)
 
-          model = Foo.create!(
-            bars: [{ name: '1', ignore: 1 }, { name: '2', ignore: 2 }]
-          )
+        model = Foo.create!(
+          bars: [{ name: '1', ignore: 1 }, { name: '2', ignore: 2 }]
+        )
 
-          csv = Csv.new.serialize(model)
-          results = CSV.parse(csv, headers: :first_row).map(&:to_h)
+        csv = Csv.new.serialize(model)
+        results = CSV.parse(csv, headers: :first_row).map(&:to_h)
 
-          assert_equal(2, results.size)
-          results.each { |r| refute(r.key?('bars_ignore')) }
-        end
+        assert_equal(2, results.size)
+        results.each { |r| refute(r.key?('bars_ignore')) }
       end
 
       def test_active_merchant_responses
@@ -407,65 +401,6 @@ module Workarea
           assert_equal("Bowl Light\u0099", product.name)
         end
       end
-
-      def test_bom_characters_in_unicode
-        csv = %(\xEF\xBB\xBF_id,name,slug,details_keywords\n653911,Bowl Light,Bowl_Light,"testing")
-        import = create_import(
-          model_type: Catalog::Product.name,
-          file: create_tempfile(csv, extension: 'csv'),
-          file_type: 'csv'
-        )
-
-        Csv.new(import).import!
-
-        product = Catalog::Product.find_by(slug: 'bowl_light')
-
-        assert_equal('653911', product.id)
-      end
-
-      def test_embedded_subclasses
-        model = Foo.create!(bars: [{ name: '1' }, { _type: Qoo.name, qoo: '2' }])
-        csv = Csv.new.serialize(model)
-        results = CSV.parse(csv, headers: :first_row).map(&:to_h)
-
-        assert_equal(2, results.size)
-        results.each { |r| assert_equal(model.id.to_s, r['_id']) }
-        assert_equal('1', results.first['bars_name'])
-        assert_equal(Qoo.name, results.second['bars_type'])
-        assert_equal('2', results.second['bars_qoo'])
-
-        import = create_import(
-          model_type: Foo.name,
-          file: create_tempfile(csv, extension: 'csv'),
-          file_type: 'csv'
-        )
-
-        model.destroy
-        Csv.new(import).import!
-
-        model = Foo.first
-        assert_equal(2, model.bars.size)
-        assert_equal(Bar, model.bars.first.class)
-        assert_equal('1', model.bars.first.name)
-        assert_equal(Qoo, model.bars.second.class)
-        assert_equal('2', model.bars.second.qoo)
-      end
-
-      def test_exclude_updated_at
-        original_date = 2.days.ago
-        model = Foo.create!(name: '1', updated_at: original_date)
-        model.name = '2'
-        csv = Csv.new.serialize(model)
-        import = create_import(
-          model_type: Foo.name,
-          file: create_tempfile(csv, extension: 'csv'),
-          file_type: 'csv'
-        )
-
-        assert_changes -> { model.reload.updated_at.to_date } do
-          Csv.new(import).import!
-        end
-      end
     end
   end
 end

data/test/models/workarea/data_file/import_test.rb

@@ -101,6 +101,37 @@ module Workarea
         assert(import.failure?)
         refute(import.successful?)
       end
+
+      def test_successful_process_for_a_release
+        sample = create_product(name: 'Test Product')
+        sample.name = 'Test Product Changed'
+        file = create_tempfile([sample].to_json, extension: 'json')
+        release = create_release
+
+        import = create_import(
+          model_type: Workarea::Catalog::Product,
+          file: file,
+          release_id: release.id
+        )
+
+        assert_equal('json', import.file_type)
+        assert_nothing_raised { import.process! }
+
+        sample.reload
+        assert_equal('Test Product', sample.name)
+
+        Release.with_current(release) do
+          assert_equal('Test Product Changed', sample.reload.name)
+        end
+
+        import.reload
+        assert_equal(1, import.total)
+        assert_equal(1, import.succeeded)
+        assert_equal(0, import.failed)
+        assert(import.complete?)
+        refute(import.error?)
+        assert(import.successful?)
+      end
     end
   end
 end

data/test/models/workarea/data_file/json_test.rb

@@ -7,29 +7,17 @@ module Workarea
         include ApplicationDocument
         field :name, type: String
         field :ignore, type: Integer
-
-        embeds_many :bars, class_name: Foo.name
-      end
-
-      class Bar
-        include ApplicationDocument
-
-        field :name, type: String
-
-        embedded_in :foo, class_name: Foo.name
       end
 
       def test_ignored_fields
-        Workarea.with_config do |config|
-          config.data_file_ignored_fields = %w(ignore)
+        Workarea.config.data_file_ignored_fields = %w(ignore)
 
-          model = Foo.create!(name: 'foo', ignore: 3)
-          results = JSON.parse(Json.new.serialize(model))
+        model = Foo.create!(name: 'foo', ignore: 3)
+        results = JSON.parse(Json.new.serialize(model))
 
-          assert_equal(1, results.size)
-          assert_equal(model.id.to_s, results.first['_id'])
-          refute(results.first.key?('ignore'))
-        end
+        assert_equal(1, results.size)
+        assert_equal(model.id.to_s, results.first['_id'])
+        refute(results.first.key?('ignore'))
       end
 
       def test_assign_password_when_provided
@@ -85,36 +73,6 @@ module Workarea
 
         assert_equal 'Bar', user.reload.first_name
       end
-
-      def test_exclude_updated_at
-        model = Foo.create!(name: '1', updated_at: 2.days.ago)
-        json = [model.as_json.merge(name: '2')].to_json
-        import = create_import(
-          model_type: Foo.name,
-          file: create_tempfile(json, extension: 'json'),
-          file_type: 'json'
-        )
-
-        assert_changes -> { model.reload.updated_at.to_date } do
-          Json.new(import).import!
-        end
-      end
-
-      def test_exclude_updated_at_when_embedded
-        original_date = 2.days.ago
-        parent = Foo.create!(updated_at: original_date)
-        model = parent.bars.create!(name: '1', updated_at: original_date)
-        json = [model.as_json.merge(name: '2')].to_json
-        import = create_import(
-          model_type: Foo.name,
-          file: create_tempfile(json, extension: 'json'),
-          file_type: 'json'
-        )
-
-        assert_changes -> { model.reload.updated_at.to_date } do
-          Json.new(import).import!
-        end
-      end
     end
   end
 end

data/test/models/workarea/data_file/tax_test.rb

@@ -22,6 +22,7 @@ module Workarea
         assert_equal(Country['US'], rate.country)
         assert_equal('19021', rate.postal_code)
         assert_equal(0.06, rate.percentage)
+        assert_equal(0.06, rate.region_percentage)
         assert_equal(true, rate.charge_on_shipping)
 
         rate = tax_category.rates.find_by(postal_code: '19106')
@@ -29,6 +30,8 @@ module Workarea
         assert_equal(Country['US'], rate.country)
         assert_equal('19106', rate.postal_code)
         assert_equal(0.08, rate.percentage)
+        assert_equal(0.06, rate.region_percentage)
+        assert_equal(0.02, rate.postal_code_percentage)
         assert_equal(0.to_m, rate.tier_min)
         assert_equal(10_000.to_m, rate.tier_max)
         assert_equal(false, rate.charge_on_shipping)

data/test/models/workarea/fulfillment/policies/download_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+module Workarea
+  class Fulfillment
+    module Policies
+      class DownloadTest < TestCase
+        def test_process
+          order = Order.new(user_id: '1234')
+          item = order.items.build(sku: 'SKU1')
+
+          fulfillment = Fulfillment.new(
+            id: order.id,
+            items: [{ order_item_id: item.id.to_s, quantity: 1 }]
+          )
+
+          sku = create_fulfillment_sku(
+            id: 'SKU1',
+            policy: 'download',
+            file: product_image_file
+          )
+
+          policy = Policies::Download.new(sku)
+          policy.process(order_item: item, fulfillment: fulfillment)
+
+          assert_equal(1, Fulfillment::Token.count)
+
+          token = Fulfillment::Token.first
+          assert_equal(order.id.to_s, token.order_id)
+          assert_equal(item.id.to_s, token.order_item_id)
+          assert_equal(sku.id, token.sku)
+
+          assert_equal(1, fulfillment.items.first.events.size)
+          assert_equal('shipped', fulfillment.items.first.events.first.status)
+          assert_equal(1, fulfillment.items.first.events.first.quantity)
+        end
+      end
+    end
+  end
+end

data/test/models/workarea/fulfillment/sku_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+module Workarea
+  class Fulfillment
+    class SkuTest < TestCase
+      def test_validation
+        sku = Sku.new(id: 'SKU1', policy: 'ignore')
+        assert(sku.valid?)
+
+        sku.policy = 'download'
+        refute(sku.valid?)
+        assert(sku.errors['file'].present?)
+
+        sku.file = product_image_file
+        assert(sku.valid?)
+      end
+
+      def test_find_or_initialize_all
+        create_fulfillment_sku(id: 'sku1', policy: 'ignore')
+        skus = Sku.find_or_initialize_all(%w(sku1 sku2))
+
+        assert(2, skus.size)
+        assert(skus.first.persisted?)
+        refute(skus.second.persisted?)
+      end
+
+      def test_process!
+        order = Order.new
+        item = order.items.build(sku: 'SKU1')
+
+        sku = Sku.new(id: 'SKU1', policy: 'ignore')
+        assert_nil(sku.process!(order_item: item))
+
+        sku = Sku.new(id: 'SKU1', policy: 'foobar')
+        assert_raises(Sku::InvalidPolicy) { sku.process!(order_item: item) }
+
+        sku = Sku.new(id: 'SKU1', policy: 'download')
+        sku.process!(order_item: item)
+        assert_equal(1, Fulfillment::Token.count)
+      end
+
+      def test_downloadable?
+        sku = Sku.new(id: 'SKU1', policy: 'ignore')
+        refute(sku.downloadable?)
+
+        sku.policy = 'download'
+        refute(sku.downloadable?)
+
+        sku.file = product_image_file
+        assert(sku.downloadable?)
+      end
+    end
+  end
+end