workarea-core 3.5.8 → 3.5.13

data/test/lib/workarea/ext/freedom_patches/mongoid_localized_defaults_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+module Workarea
+  class MongoidLocalizedDefaultsTest < TestCase
+    class Foo
+      include Mongoid::Document
+
+      field :name, type: String, default: -> { 'foo' }, localize: true
+      field :config, type: Hash, default: { foo: 'bar' }, localize: true
+    end
+
+    def test_localized_defaults
+      set_locales(available: [:en, :es], default: :en, current: :en)
+
+      instance = Foo.new
+      assert_equal('foo', instance.name)
+      assert_equal({ foo: 'bar' }, instance.config)
+
+      I18n.locale = :es
+
+      assert_equal('foo', instance.name)
+      assert_equal({ foo: 'bar' }, instance.config)
+    end
+  end
+end

data/test/lib/workarea/geolocation_test.rb

@@ -94,10 +94,10 @@ module Workarea
         'HTTP_GEOIP_POSTAL_CODE' => '19106'
       )
 
-      assert_includes(location.names, 'US')
-      assert_includes(location.names, 'USA')
+      refute_includes(location.names, 'US')
+      refute_includes(location.names, 'USA')
       assert_includes(location.names, 'United States of America')
-      assert_includes(location.names, 'PA')
+      refute_includes(location.names, 'PA')
       assert_includes(location.names, 'Pennsylvania')
       assert_includes(location.names, 'Philadelphia')
       assert_includes(location.names, '19106')

data/test/models/workarea/releasable_test.rb

@@ -375,6 +375,19 @@ module Workarea
       in_release = model.in_release(nil)
       assert_equal('Foo', in_release.name)
       refute_equal(in_release.object_id, model.object_id)
+
+      Mongoid::QueryCache.cache do
+        cached = Foo.find(model.id) # a find to ensure it's in the cache table
+        cached.name = 'Bar' # so the cache table's instance has a change
+
+        in_release = model.in_release(nil)
+        assert_equal('Foo', in_release.name)
+        refute_equal(in_release.object_id, model.object_id)
+        refute_equal(cached.object_id, model.object_id)
+      end
+
+    ensure
+      Mongoid::QueryCache.clear_cache
     end
 
     def test_skip_changeset

data/test/models/workarea/search/storefront/product_releases_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+module Workarea
+  module Search
+    class Storefront
+      class ProductReleasesTest < TestCase
+        def test_product_changes
+          product = create_product(name: 'Foo')
+          release_one = create_release
+          release_one.as_current { product.update!(name: 'Bar') }
+
+          assert_equal([release_one], Product.new(product).releases)
+
+          release_one.update!(publish_at: 1.day.from_now)
+          release_two = create_release(publish_at: 3.days.from_now)
+          assert_equal([release_one, release_two], Product.new(product).releases)
+        end
+
+        def test_featured_product_changes
+          product = create_product
+          category = create_category
+
+          release_one = create_release
+          release_one.as_current { category.update!(product_ids: [product.id]) }
+          assert_equal([release_one], Product.new(product).releases)
+
+          release_one.update!(publish_at: 1.day.from_now)
+          release_two = create_release(publish_at: 3.days.from_now)
+          assert_equal([release_one, release_two], Product.new(product).releases)
+        end
+
+        def test_variant_changes
+          product = create_product(variants: [{ sku: 'SKU' }])
+          release = create_release
+          release.as_current { product.variants.first.update!(details: { color: 'Red' }) }
+          assert_equal([release], Product.new(product).releases)
+        end
+
+        def test_pricing_changes
+          product = create_product(variants: [{ sku: 'SKU' }])
+          pricing = Pricing::Sku.find('SKU')
+
+          release = create_release
+          release.as_current { pricing.prices.first.update!(regular: 10_000) }
+          assert_equal([release], Product.new(product).releases)
+        end
+
+        def test_changesets_with_missing_releases
+          product = create_product(name: 'Foo')
+          release = create_release
+          release.as_current { product.update!(name: 'Bar') }
+          release.delete
+
+          assert_nil(product.reload.changesets.first.release)
+          assert_equal([], Product.new(product).releases)
+        end
+      end
+    end
+  end
+end

data/test/models/workarea/search/storefront_test.rb

@@ -25,6 +25,19 @@ module Workarea
         release.as_current { category.product_rules.first.update!(value: 'bar') }
         assert_equal(2, Storefront.new(category).changesets.size)
       end
+
+      def test_releases
+        category = create_category(name: 'Foo')
+        assert_empty(Storefront.new(category).as_document[:changeset_release_ids])
+
+        a = create_release(publish_at: 1.week.from_now)
+        a.as_current { category.update!(name: 'Bar') }
+        assert_equal([a.id], Storefront.new(category).as_document[:changeset_release_ids])
+
+        b = create_release(publish_at: 2.weeks.from_now)
+        assert_includes(Storefront.new(category).as_document[:changeset_release_ids], a.id)
+        assert_includes(Storefront.new(category).as_document[:changeset_release_ids], b.id)
+      end
     end
   end
 end

data/test/models/workarea/segment/rules/geolocation_test.rb

@@ -7,12 +7,15 @@ module Workarea
         def test_qualifies?
           refute(Geolocation.new.qualifies?(create_visit))
 
-          visit = create_visit('HTTP_GEOIP_REGION' => 'PA')
+          visit = create_visit(
+            'HTTP_GEOIP_REGION' => 'PA',
+            'HTTP_GEOIP_CITY_COUNTRY_CODE' => 'US'
+          )
           refute(Geolocation.new(locations: %w(NJ)).qualifies?(visit))
-          assert(Geolocation.new(locations: %w(pa)).qualifies?(visit))
-          assert(Geolocation.new(locations: %w(PA)).qualifies?(visit))
-          assert(Geolocation.new(locations: %w(NJ PA)).qualifies?(visit))
-          refute(Geolocation.new(locations: %w(NJ NY)).qualifies?(visit))
+          assert(Geolocation.new(locations: %w(us-pa)).qualifies?(visit))
+          assert(Geolocation.new(locations: %w(US-PA)).qualifies?(visit))
+          assert(Geolocation.new(locations: %w(US-NJ US-pa)).qualifies?(visit))
+          refute(Geolocation.new(locations: %w(US-NJ US-NY)).qualifies?(visit))
 
           visit = create_visit(
             'HTTP_GEOIP_REGION' => 'PA',
@@ -26,14 +29,13 @@ module Workarea
           assert(Geolocation.new(locations: %w(Philadelphia)).qualifies?(visit))
           assert(Geolocation.new(locations: %w(Philadelphia US)).qualifies?(visit))
           refute(Geolocation.new(locations: %w(Harrisburg)).qualifies?(visit))
-          refute(Geolocation.new(locations: %w(Harrisburg PA)).qualifies?(visit))
+          refute(Geolocation.new(locations: %w(Harrisburg US-PA)).qualifies?(visit))
           assert(Geolocation.new(locations: %w(Philadelphia Harrisburg)).qualifies?(visit))
           refute(Geolocation.new(locations: %w(Pittsburgh Harrisburg)).qualifies?(visit))
 
           visit = create_visit('HTTP_GEOIP_CITY_COUNTRY_CODE' => 'US')
           refute(Geolocation.new(locations: %w(CA)).qualifies?(visit))
           assert(Geolocation.new(locations: %w(US)).qualifies?(visit))
-          assert(Geolocation.new(locations: %w(USA)).qualifies?(visit))
           assert(Geolocation.new(locations: ['United States of America']).qualifies?(visit))
           assert(Geolocation.new(locations: %w(Philadelphia US)).qualifies?(visit))
           assert(Geolocation.new(locations: %w(US CA)).qualifies?(visit))

data/test/models/workarea/user/password_reset_test.rb

@@ -4,14 +4,22 @@ module Workarea
   class User
     class PasswordResetTest < TestCase
       def user
-        @user ||= create_user
+        @user ||= create_user(email: 'one@workarea.com')
       end
 
       def test_setup!
-        PasswordReset.setup!(user.email)
+        2.times do
+          PasswordReset.setup!(user.email)
 
-        assert_equal(1, PasswordReset.count)
-        assert_equal(user.id, PasswordReset.first.user_id)
+          assert_equal(1, PasswordReset.count)
+          assert_equal(user.id, PasswordReset.first.user_id)
+        end
+
+        two = create_user(email: 'two@workarea.com')
+        PasswordReset.setup!('two@workarea.com')
+
+        assert_equal(2, PasswordReset.count)
+        assert_equal(two.id, PasswordReset.last.user_id)
       end
 
       def test_complete

data/test/queries/workarea/search/category_browse_test.rb

@@ -382,6 +382,29 @@ module Workarea
           refute_includes(result_ids, product_five.id)
         end
       end
+
+      def test_featured_product_changes_in_a_release
+        one = create_product
+        two = create_product
+        three = create_product(name: 'Foo', active: false)
+        category = create_category(product_ids: [one.id, two.id], product_rules: [])
+        release = create_release(publish_at: 1.week.from_now)
+
+        release.as_current do
+          three.update!(name: 'Bar', active: true, default_category_id: category.id)
+          category.update!(product_ids: [three.id, one.id, two.id])
+          search = CategoryBrowse.new(sort: %w(featured), category_ids: [category.id])
+          sorts = search.results.pluck(:raw).pluck('_source').pluck('sorts').pluck(category.id.to_s)
+          assert_equal([0, 1, 2], sorts)
+        end
+
+        release.as_current do
+          category.update!(product_ids: [one.id, two.id, three.id])
+          search = CategoryBrowse.new(sort: %w(featured), category_ids: [category.id])
+          sorts = search.results.pluck(:raw).pluck('_source').pluck('sorts').pluck(category.id.to_s)
+          assert_equal([0, 1, 2], sorts)
+        end
+      end
     end
   end
 end

data/test/queries/workarea/search/pagination_test.rb

@@ -19,6 +19,15 @@ module Workarea
         assert_equal(1, Paginate.new(page: 'asdf').page)
       end
 
+      def test_per_page
+        assert_equal(Workarea.config.per_page, Paginate.new.per_page)
+        assert_equal(2, Paginate.new(per_page: 2).per_page)
+        assert_equal(Workarea.config.per_page, Paginate.new(per_page: -1).per_page)
+        assert_equal(Workarea.config.per_page, Paginate.new(per_page: 0).per_page)
+        assert_equal(3, Paginate.new(per_page: '3').per_page)
+        assert_equal(Workarea.config.per_page, Paginate.new(per_page: 'asdf').per_page)
+      end
+
       def test_from
         Workarea.config.per_page = 30
         assert_equal(0, Paginate.new(page: 1).from)

data/test/queries/workarea/search/product_entries_test.rb

@@ -36,6 +36,17 @@ module Workarea
         assert_equal(release.id, results.first.release_id)
         refute_equal(product.object_id, results.first.model.object_id)
       end
+
+      def test_entry_flattening
+        products = Array.new(2) { create_product }
+        release = create_release
+        release.as_current { products.first.update!(name: 'Bar') }
+
+        instance = ProductEntries.new(products)
+        instance.stubs(:index_entries_for).returns([:foo, :bar])
+
+        assert_equal([:foo, :bar, :foo, :bar, :foo, :bar], instance.entries)
+      end
     end
   end
 end

data/test/queries/workarea/search/product_search_test.rb

@@ -425,6 +425,22 @@ module Workarea
           assert_equal([product], ProductSearch.new(q: '*').results.pluck(:model))
         end
       end
+
+      def test_locale
+        # No simple way to run this test without fallbacks or localized fields
+        return unless Workarea.config.localized_active_fields
+
+        set_locales(available: [:en, :es], default: :en, current: :en)
+        Search::Storefront.reset_indexes!
+
+        product = create_product(active_translations: { 'en' => true, 'es' => false })
+
+        I18n.locale = :es
+        assert_equal([], ProductSearch.new(q: '*').results.pluck(:model))
+
+        I18n.locale = :en
+        assert_equal([product], ProductSearch.new(q: '*').results.pluck(:model))
+      end
     end
   end
 end

data/test/services/workarea/direct_upload_test.rb

@@ -108,11 +108,28 @@ module Workarea
       ).returns(true)
 
       assert(DirectUpload.ensure_cors!('http://test.host/admin/content_assets'))
-      assert_equal('true', Workarea.redis.get('cors_http_test_host'))
       assert(DirectUpload.ensure_cors!('http://localhost:3000/admin/content_assets'))
-      assert_equal('true', Workarea.redis.get('cors_http_localhost_3000'))
       assert(DirectUpload.ensure_cors!('https://example.com/admin/direct_uploads'))
-      assert_equal('true', Workarea.redis.get('cors_https_example_com'))
+    end
+
+    def test_ensure_cors_with_no_existing_configuration
+      Workarea.s3.expects(:get_bucket_cors)
+                 .raises(Excon::Errors::NotFound.new('CORS configuration does not exist'))
+
+
+      Workarea.s3.expects(:put_bucket_cors).with(
+        Configuration::S3.bucket,
+        'CORSConfiguration' => [
+          {
+            'ID' => "direct_upload_http://test.host",
+            'AllowedMethod' => 'PUT',
+            'AllowedOrigin' => 'http://test.host',
+            'AllowedHeader' => '*'
+          }
+        ]
+      ).returns(true)
+
+      assert(DirectUpload.ensure_cors!('http://test.host/admin/content_assets'))
     end
 
     private

data/test/services/workarea/hash_update_test.rb

@@ -2,23 +2,23 @@ require 'test_helper'
 
 module Workarea
   class HashUpdateTest < TestCase
-    def test_apply
-      hash = { 'foo' => 'bar' }
+    def test_result
+      original = { 'foo' => 'bar' }
 
-      HashUpdate.new(adds: %w(key value)).apply(hash)
-      assert_equal(%w(value), hash['key'])
+      result = HashUpdate.new(original: original, adds: %w(key value)).result
+      assert_equal(%w(value), result['key'])
 
-      HashUpdate.new(updates: %w(foo baz)).apply(hash)
-      assert_equal(%w(baz), hash['foo'])
+      result = HashUpdate.new(original: original, updates: %w(foo baz)).result
+      assert_equal(%w(baz), result['foo'])
 
-      HashUpdate.new(removes: %w(foo)).apply(hash)
-      refute_includes(hash.keys, 'foo')
+      result = HashUpdate.new(original: original, removes: %w(foo)).result
+      refute_includes(result.keys, 'foo')
 
-      HashUpdate.new(adds: ['key', 'one, two ']).apply(hash)
-      assert_equal(%w(one two), hash['key'])
+      result = HashUpdate.new(original: original, adds: ['key', 'one, two ']).result
+      assert_equal(%w(one two), result['key'])
 
-      HashUpdate.new(updates: ['key', 'one,  two, three ']).apply(hash)
-      assert_equal(%w(one two three), hash['key'])
+      result = HashUpdate.new(original: original, updates: ['key', 'one,  two, three ']).result
+      assert_equal(%w(one two three), result['key'])
     end
   end
 end

data/test/workers/workarea/process_import_test.rb

@@ -53,5 +53,11 @@ module Workarea
         t('workarea.admin.data_file_mailer.import_failure.errors')
       )
     end
+
+    def test_perform_with_missing_import
+      assert_raises Mongoid::Errors::DocumentNotFound do
+        ProcessImport.new.perform('foo')
+      end
+    end
   end
 end

data/test/workers/workarea/reindex_release_test.rb

@@ -0,0 +1,81 @@
+require 'test_helper'
+
+module Workarea
+  class ReindexReleaseTest < TestCase
+    include TestCase::SearchIndexing
+
+    setup :set_product
+
+    def set_product
+      @product = create_product(name: 'Foo')
+    end
+
+    def test_reschedule
+      a = create_release(name: 'A', publish_at: 1.week.from_now)
+      b = create_release(name: 'B', publish_at: 2.weeks.from_now)
+      c = create_release(name: 'C', publish_at: 4.weeks.from_now)
+
+      b.as_current { @product.update!(name: 'Bar') }
+      IndexProduct.perform(@product)
+
+      a.as_current { assert_empty(Search::ProductSearch.new(q: 'bar').results.pluck(:model)) }
+      b.as_current { assert_equal([@product], Search::ProductSearch.new(q: 'bar').results.pluck(:model)) }
+      c.as_current { assert_equal([@product], Search::ProductSearch.new(q: 'bar').results.pluck(:model)) }
+
+      # Changing publish_at via `update` causes the release to publish due to Sidekiq inline
+      previous_publish_at = b.publish_at
+      b.set(publish_at: 5.weeks.from_now)
+
+      Sidekiq::Callbacks.enable(IndexProduct) { ReindexRelease.new.perform(b.id, previous_publish_at, b.publish_at) }
+
+      a.as_current { assert_empty(Search::ProductSearch.new(q: 'bar').results.pluck(:model)) }
+      b.as_current { assert_equal([@product], Search::ProductSearch.new(q: 'bar').results.pluck(:model)) }
+      c.as_current { assert_empty(Search::ProductSearch.new(q: 'bar').results.pluck(:model)) }
+    end
+
+    def test_removing_from_schedule
+      a = create_release(name: 'A', publish_at: 1.week.from_now)
+      b = create_release(name: 'B', publish_at: 2.weeks.from_now)
+      c = create_release(name: 'C', publish_at: 4.weeks.from_now)
+
+      b.as_current { @product.update!(name: 'Bar') }
+      IndexProduct.perform(@product)
+
+      a.as_current { assert_empty(Search::ProductSearch.new(q: 'bar').results.pluck(:model)) }
+      b.as_current { assert_equal([@product], Search::ProductSearch.new(q: 'bar').results.pluck(:model)) }
+      c.as_current { assert_equal([@product], Search::ProductSearch.new(q: 'bar').results.pluck(:model)) }
+
+      # Changing publish_at via `update` causes the release to publish due to Sidekiq inline
+      previous_publish_at = b.publish_at
+      b.set(publish_at: nil)
+
+      Sidekiq::Callbacks.enable(IndexProduct) { ReindexRelease.new.perform(b.id, previous_publish_at, nil) }
+
+      a.as_current { assert_empty(Search::ProductSearch.new(q: 'bar').results.pluck(:model)) }
+      b.as_current { assert_equal([@product], Search::ProductSearch.new(q: 'bar').results.pluck(:model)) }
+      c.as_current { assert_empty(Search::ProductSearch.new(q: 'bar').results.pluck(:model)) }
+    end
+
+    def test_adding_to_schedule
+      a = create_release(name: 'A', publish_at: 1.week.from_now)
+      b = create_release(name: 'B')
+      c = create_release(name: 'C', publish_at: 4.weeks.from_now)
+
+      b.as_current { @product.update!(name: 'Bar') }
+      IndexProduct.perform(@product)
+
+      a.as_current { assert_empty(Search::ProductSearch.new(q: 'bar').results.pluck(:model)) }
+      b.as_current { assert_equal([@product], Search::ProductSearch.new(q: 'bar').results.pluck(:model)) }
+      c.as_current { assert_empty(Search::ProductSearch.new(q: 'bar').results.pluck(:model)) }
+
+      # Changing publish_at via `update` causes the release to publish due to Sidekiq inline
+      b.set(publish_at: 2.weeks.from_now)
+
+      Sidekiq::Callbacks.enable(IndexProduct) { ReindexRelease.new.perform(b.id, nil, b.publish_at) }
+
+      a.as_current { assert_empty(Search::ProductSearch.new(q: 'bar').results.pluck(:model)) }
+      b.as_current { assert_equal([@product], Search::ProductSearch.new(q: 'bar').results.pluck(:model)) }
+      c.as_current { assert_equal([@product], Search::ProductSearch.new(q: 'bar').results.pluck(:model)) }
+    end
+  end
+end