workarea-storefront 3.4.12

data/test/view_models/workarea/storefront/product_view_model/sku_options_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class ProductViewModel::SkuOptionsTest < TestCase
+      setup :product, :sku_options
+
+      def test_options
+        option = ["SKU1 - Color: Red", "SKU1", { data: { sku_option_details: { 'color' => ['Red'] }.to_json } }]
+        assert_equal(option, sku_options.to_a.second)
+      end
+
+      private
+
+      def product
+        @product ||= create_product(
+          variants: [
+            {
+              sku: 'SKU1',
+              details: { 'Color' => ['Red'] }
+            },
+            {
+              sku: 'SKU2',
+              details: { 'Color' => ['Blue'] }
+            }
+          ]
+        )
+      end
+
+      def sku_options
+        @sku_options ||= ProductViewModel::SkuOptions.new(product.variants)
+      end
+    end
+  end
+end

data/test/view_models/workarea/storefront/product_view_model_test.rb

@@ -0,0 +1,235 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class ProductViewModelTest < TestCase
+      setup :set_product
+
+      def set_product
+        @product = create_product(name: 'test')
+      end
+
+      def test_wrap_finds_the_view_model_based_on_template
+        @product.template = 'option_selects'
+
+        view_model = ProductViewModel.wrap(@product, one: '1')
+        assert_instance_of(ProductTemplates::OptionSelectsViewModel, view_model)
+        assert_equal('1', view_model.options[:one])
+      end
+
+      def test_cache_key
+        cached_product = Catalog::Product.new(@product.as_document)
+
+        view_model = ProductViewModel.new(cached_product)
+        assert_match(/#{@product.id}/, view_model.cache_key)
+        assert_match(/#{@product.updated_at.utc.to_s(:nsec)}/, view_model.cache_key)
+
+        view_model = ProductViewModel.new(cached_product, via: '1/2/3')
+        assert_match(/1\/2\/3/, view_model.cache_key)
+
+        @product.variants.build(sku: 'SKU')
+        view_model = ProductViewModel.new(cached_product)
+        refute_match(/SKU/, view_model.cache_key)
+
+        view_model = ProductViewModel.new(cached_product, sku: 'SKU')
+        assert_match(/SKU/, view_model.cache_key)
+      end
+
+      def test_cache_key_with_options
+        variant = @product.variants.build(sku: 'SKU', details: { 'Color' => 'blue' })
+        cached_product = Catalog::Product.new(@product.as_document)
+        options = { action: 'show', sku: variant.sku }.merge(variant.details)
+        view_model = ProductViewModel.new(cached_product, options)
+
+        assert_includes(view_model.cache_key, variant.fetch_detail(:color))
+        refute_includes(view_model.cache_key, options[:action])
+      end
+
+      def test_variants_only_includes_variants_with_displayable_inventory
+        view_model = ProductViewModel.new(@product)
+        variant = @product.variants.build(sku: 'INVTEST')
+        create_inventory(id: 'INVTEST', policy: 'standard', available: 0)
+
+        refute_includes(view_model.variants, variant)
+      end
+
+      def test_current_sku
+        @product.variants.build(sku: 'test')
+
+        view_model = ProductViewModel.new(@product, sku: nil)
+        assert_nil(view_model.current_sku)
+
+        view_model = ProductViewModel.new(@product, sku: 'test')
+        assert_equal('test', view_model.current_sku)
+
+        view_model = ProductViewModel.new(@product, sku: '1234')
+        assert_equal('1234', view_model.current_sku)
+      end
+
+      def test_sku_options_uses_name
+        variant = @product.variants.build(sku: 'SKU', name: 'name', details: { 'foo' => 'bar' })
+        view_model = ProductViewModel.new(@product, sku: '1234')
+
+        assert_includes(view_model.sku_options, ["name", "SKU", data: { sku_option_details: variant.details.to_json }])
+      end
+
+      def test_sku_options_uses_details
+        variant = @product.variants.build(sku: 'SKU', name: 'SKU', details: { 'foo' => 'bar' })
+        view_model = ProductViewModel.new(@product, sku: '1234')
+
+        assert_includes(view_model.sku_options, ["SKU - Foo: bar", "SKU", data: { sku_option_details: variant.details.to_json }])
+      end
+
+      def test_sku_options_uses_comma_separates_arrays_in_details
+        variant = @product.variants.build(sku: 'SKU', name: 'SKU', details: { 'foo' => ['bar', 'baz'] })
+        view_model = ProductViewModel.new(@product, sku: '1234')
+
+        assert_includes(view_model.sku_options, ["SKU - Foo: bar, baz", "SKU", data: { sku_option_details: variant.details.to_json }])
+      end
+
+      def test_breadcrumbs_uses_the_default_category_if_no_via_param
+        category = create_category(product_ids: [@product.id])
+        result = ProductViewModel.new(@product).breadcrumbs.navigable
+        assert_equal(category, result)
+      end
+
+      def test_breadcrumbs_adds_the_product_name_as_the_last_breadcrumb
+        view_model = ProductViewModel.new(@product)
+        result = view_model.breadcrumbs.last
+        assert_equal(@product.name, result.name)
+      end
+
+      def test_one_price
+        @product.variants = [{ sku: 'SKU1' }]
+        pricing = create_pricing_sku(id: 'SKU1', msrp: 5)
+
+        pricing.set(prices: [])
+        refute(ProductViewModel.new(@product).one_price?)
+
+        pricing.prices = [{ regular: 3 }]
+        refute(ProductViewModel.new(@product).one_price?)
+
+        pricing.update_attributes!(msrp: 3)
+        assert(ProductViewModel.new(@product).one_price?)
+      end
+
+      def test_show_sell_range
+        @product.variants = [{ sku: 'SKU1' }, { sku: 'SKU2' }]
+        pricing_one = create_pricing_sku(id: 'SKU1')
+        pricing_two = create_pricing_sku(id: 'SKU2')
+
+        pricing_one.set(prices: [])
+        pricing_two.set(prices: [])
+        refute(ProductViewModel.new(@product).show_sell_range?)
+
+        pricing_one.prices = [{ regular: 3 }]
+        pricing_two.prices = [{ regular: 3 }]
+        refute(ProductViewModel.new(@product).show_sell_range?)
+
+        pricing_one.prices = [{ regular: 3 }]
+        pricing_two.prices = [{ regular: 5 }]
+        assert(ProductViewModel.new(@product).show_sell_range?)
+      end
+
+      def test_show_original_range
+        @product.variants = [{ sku: 'SKU1' }, { sku: 'SKU2' }]
+        pricing_one = create_pricing_sku(id: 'SKU1')
+        pricing_two = create_pricing_sku(id: 'SKU2')
+
+        pricing_one.set(prices: [])
+        pricing_two.set(prices: [])
+        refute(ProductViewModel.new(@product).show_original_range?)
+
+        pricing_one.prices = [{ regular: 3 }]
+        pricing_two.prices = [{ regular: 3 }]
+        refute(ProductViewModel.new(@product).show_original_range?)
+
+        pricing_one.prices = [{ regular: 3 }]
+        pricing_two.prices = [{ regular: 5 }]
+        assert(ProductViewModel.new(@product).show_original_range?)
+      end
+
+      def test_original_min_price
+        @product.variants = [{ sku: 'SKU1' }, { sku: 'SKU2' }]
+        pricing_one = create_pricing_sku(id: 'SKU1')
+        pricing_two = create_pricing_sku(id: 'SKU2')
+
+        pricing_one.update_attributes!(msrp: 5)
+        pricing_two.update_attributes!(msrp: 6)
+        pricing_one.prices = [{ regular: 3 }]
+        pricing_two.prices = [{ regular: 5 }]
+        assert_equal(5.to_m, ProductViewModel.new(@product).original_min_price)
+
+        pricing_one.update_attributes!(msrp: nil)
+        pricing_two.update_attributes!(msrp: nil)
+        assert_equal(3.to_m, ProductViewModel.new(@product).original_min_price)
+
+        pricing_one.update_attributes!(on_sale: true, msrp: 1)
+        pricing_two.update_attributes!(msrp: 6)
+        pricing_one.prices = [{ regular: 3, sale: 2 }]
+        pricing_two.prices = [{ regular: 5 }]
+        assert_equal(3.to_m, ProductViewModel.new(@product).original_min_price)
+      end
+
+      def test_original_max_price
+        @product.variants = [{ sku: 'SKU1' }, { sku: 'SKU2' }]
+        pricing_one = create_pricing_sku(id: 'SKU1')
+        pricing_two = create_pricing_sku(id: 'SKU2')
+
+        pricing_one.update_attributes!(msrp: 2)
+        pricing_two.update_attributes!(msrp: 1)
+        pricing_one.prices = [{ regular: 1 }]
+        pricing_two.prices = [{ regular: 1 }]
+        assert_equal(2.to_m, ProductViewModel.new(@product).original_max_price)
+
+        pricing_one.update_attributes!(msrp: nil)
+        pricing_two.update_attributes!(msrp: nil)
+        assert_equal(1.to_m, ProductViewModel.new(@product).original_max_price)
+
+        pricing_one.update_attributes!(on_sale: true, msrp: 1)
+        pricing_two.update_attributes!(msrp: nil)
+        pricing_one.prices = [{ regular: 2, sale: 2 }]
+        pricing_two.prices = [{ regular: 3 }]
+        assert_equal(3.to_m, ProductViewModel.new(@product).original_max_price)
+      end
+
+      def test_purchasable
+        assert(ProductViewModel.new(@product).purchasable?)
+        refute(ProductViewModel.new(Catalog::Product.new).purchasable?)
+      end
+
+      def test_pricing_only_has_pricing_for_the_selected_sku_if_present
+        @product.variants = [{ sku: 'SKU1' }, { sku: 'SKU2' }]
+        view_model = ProductViewModel.new(@product, sku: 'SKU1')
+        assert_equal(['SKU1'], view_model.pricing.skus)
+      end
+
+      def test_browser_title
+        assert_equal('test', ProductViewModel.new(@product).browser_title)
+      end
+
+      def test_meta_description
+        @product.description = 'foo bar'
+        assert_equal('foo bar', ProductViewModel.new(@product).meta_description)
+      end
+
+      def test_inventory_purchasable
+        product = create_product(variants: [{ sku: '1' }, { sku: '2' }])
+        create_inventory(id: '1', policy: 'standard', available: 5)
+        create_inventory(id: '2', policy: 'standard', available: 0)
+
+        view_model = ProductViewModel.wrap(product)
+        assert(view_model.inventory_purchasable?)
+        assert(view_model.purchasable?)
+
+        view_model = ProductViewModel.wrap(product, sku: '1')
+        assert(view_model.inventory_purchasable?)
+        assert(view_model.purchasable?)
+
+        view_model = ProductViewModel.wrap(product, sku: '2')
+        refute(view_model.inventory_purchasable?)
+        refute(view_model.purchasable?)
+      end
+    end
+  end
+end

data/test/view_models/workarea/storefront/recommendations_view_model_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class RecommendationsViewModelTest < TestCase
+      class FooRecommendations < RecommendationsViewModel
+        def product_ids
+          model
+        end
+
+        def result_count
+          options[:result_count] || 2
+        end
+      end
+
+      def test_respecting_active_products
+        one = create_product(id: '1')
+        create_product(id: '2', active: false)
+        three = create_product(id: '3')
+
+        view_model = FooRecommendations.new(%w(1 2 3))
+        assert(view_model.products.all? { |vm| vm.is_a?(ProductViewModel) })
+        assert_equal([one, three], view_model.products.map(&:model))
+      end
+
+      def test_respecting_purchasable_products
+        one = create_product(id: '1')
+        create_product(id: '2', purchasable: false)
+        three = create_product(id: '3')
+
+        view_model = FooRecommendations.new(%w(1 2 3))
+        assert(view_model.products.all? { |vm| vm.is_a?(ProductViewModel) })
+        assert_equal([one, three], view_model.products.map(&:model))
+      end
+
+      def test_falling_back_to_popular_products
+        one = create_product(id: '1')
+        create_product(id: '2')
+        create_product(id: '3')
+        create_top_products(results: [{ 'product_id' => '1' }])
+
+        view_model = FooRecommendations.new([])
+        assert(view_model.products.all? { |vm| vm.is_a?(ProductViewModel) })
+        assert_equal([one], view_model.products.map(&:model))
+      end
+
+      def test_uniquing_products
+        create_product(id: '1', name: 'Product One')
+        create_product(id: '2', name: 'Product Two')
+        create_top_products(
+          results: [
+            { 'product_id' => '1' },
+            { 'product_id' => '2' }
+          ]
+        )
+
+        view_model = FooRecommendations.new(%w(1 2), result_count: 4)
+        assert_equal(2, view_model.size)
+      end
+    end
+  end
+end

data/test/view_models/workarea/storefront/refund_view_model_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class RefundViewModelTest < TestCase
+      def test_tenders
+        order = create_placed_order
+        payment = Payment.find(order.id)
+        amounts = payment.tenders.reduce({}) { |m, t| m.merge(t.id => t.amount) }
+
+        Payment::Capture.new(payment: payment, amounts: amounts).complete!
+        refund = Payment::Refund
+                  .new(payment: payment, amounts: amounts)
+                  .tap(&:complete!)
+
+        view_model = RefundViewModel.wrap(refund)
+        assert_equal(1, view_model.tenders.size)
+        assert_equal(payment.credit_card, view_model.tenders.keys.first)
+        assert_equal(payment.credit_card.amount, view_model.tenders.values.first)
+      end
+    end
+  end
+end

data/test/view_models/workarea/storefront/search_suggestion_view_model_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class SearchSuggestionViewModelTest < TestCase
+      setup :set_asset_host_config
+      teardown :restore_asset_host_config
+
+      def set_asset_host_config
+        @current_asset_host = Rails.application.config.action_controller.asset_host
+        Rails.application.config.action_controller.asset_host = 'http://cdn.client.com'
+      end
+
+      def restore_asset_host_config
+        Rails.application.config.action_controller.asset_host = @current_asset_host
+      end
+
+      def test_image_handles_blank
+        search_suggestion = { '_source' => { 'cache' => { 'image' => '' } } }
+        view_model = SearchSuggestionViewModel.new(search_suggestion)
+        assert(view_model.image.nil?)
+      end
+
+      def test_image_handles_different_urls_from_index
+        possible_index_urls = %w(
+          /image.jpg
+          https://staging.client.com/image.jpg
+          http://cdn.client.com/image.jpg
+        )
+
+        possible_index_urls.each do |url_from_index|
+          search_suggestion = {
+            '_source' => { 'cache' => { 'image' => url_from_index } }
+          }
+
+          view_model = SearchSuggestionViewModel.new(search_suggestion)
+          assert_equal('http://cdn.client.com/image.jpg', view_model.image)
+        end
+      end
+    end
+  end
+end

data/test/view_models/workarea/storefront/search_view_model_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class SearchViewModelTest < TestCase
+      include SearchIndexing
+      include ProductBrowsingViewModelTest
+      include PaginationViewModelTest
+
+      def view_model_class
+        SearchViewModel
+      end
+      alias_method :pagination_view_model_class, :view_model_class
+      alias_method :search_content_view_model_class, :view_model_class
+      alias_method :product_browsing_view_model_class, :view_model_class
+
+      def create_search_response(options = {})
+        attributes = { params: {} }.merge(options)
+
+        result = Workarea::Search::StorefrontSearch::Response.new(attributes)
+        result.query = attributes[:query] if attributes[:query]
+        result
+      end
+
+      def test_product
+        products = [create_product(name: 'Foo 1'), create_product(name: 'Foo 2')]
+        BulkIndexProducts.perform_by_models(products)
+
+        search_query = Search::ProductSearch.new(q: 'foo')
+        response = create_search_response(query: search_query)
+        view_model = SearchViewModel.new(response)
+
+        assert(
+          view_model
+            .products
+            .first
+            .instance_of?(ProductViewModel)
+        )
+      end
+
+      def test_sorts
+        view_model = SearchViewModel.new(create_search_response)
+        assert_equal(['Relevance', :relevance], view_model.sorts.first)
+      end
+
+      def test_query_suggestions
+        response = create_search_response
+
+        Recommendation::Searches.expects(:find).returns(%w(one))
+        response.query.expects(:query_suggestions).returns(%w(two))
+
+        view_model = SearchViewModel.new(response)
+        assert_equal(%w(one two), view_model.query_suggestions)
+      end
+    end
+  end
+end