workarea-storefront 3.4.45 → 3.5.0.beta.1

data/test/integration/workarea/storefront/login_integration_test.rb

@@ -12,12 +12,6 @@ module Workarea
         )
       end
 
-      def response_cookies
-        ActionDispatch::Cookies::CookieJar
-          .build(request, response.cookies)
-          .signed
-      end
-
       def test_can_login_a_user
         post storefront.login_path,
           params: {
@@ -26,7 +20,7 @@ module Workarea
           }
 
         assert_redirected_to(storefront.users_account_path)
-        assert(response_cookies[:user_id].present?)
+        assert(session[:user_id].present?)
 
         @user.reload
         assert(@user.last_login_at.present?)
@@ -39,7 +33,7 @@ module Workarea
             password: 'foo'
           }
 
-        assert(response_cookies[:user_id].blank?)
+        assert(session[:user_id].blank?)
 
         @user.reload
         assert(@user.last_login_at.blank?)
@@ -146,7 +140,7 @@ module Workarea
         delete storefront.logout_path
 
         assert_redirected_to(storefront.login_path)
-        assert(response_cookies[:user_id].blank?)
+        assert(session[:user_id].blank?)
 
         get storefront.current_user_path(format: 'json')
         results = JSON.parse(response.body)

data/test/integration/workarea/storefront/order_data_integration_test.rb

@@ -38,13 +38,6 @@ module Workarea
         )
       end
 
-      def complete_checkout(email = nil, password = nil)
-        put storefront.recent_views_path,
-          params: { product_id: product.id }
-
-        super
-      end
-
       def test_order_info_saving
         complete_checkout
 
@@ -54,7 +47,6 @@ module Workarea
         assert_equal(order.email, 'bcrouse@workarea.com')
         assert_equal('127.0.0.1', order.ip_address)
         assert_equal('Mozilla', order.user_agent)
-        assert(order.user_activity_id.present?)
 
         assert_equal(1, order.items.length)
         assert_equal(@product.id, order.items.first.product_id)
@@ -108,7 +100,7 @@ module Workarea
         assert_equal('Test Card', payment.credit_card.issuer)
         assert_equal('XXXX-XXXX-XXXX-1', payment.credit_card.display_number)
         assert_equal(1, payment.credit_card.month)
-        assert_equal(next_year, payment.credit_card.year)
+        assert_equal(2020, payment.credit_card.year)
         refute(payment.credit_card.token.blank?)
         assert(payment.credit_card.saved_card_id.blank?)
 

data/test/integration/workarea/storefront/place_order_integration_test.rb

@@ -3,9 +3,7 @@ require 'test_helper'
 module Workarea
   module Storefront
     class PlaceOrderIntegrationTest < Workarea::IntegrationTest
-      setup :setup_checkout
-
-      def setup_checkout
+      setup do
         create_tax_category(
           name: 'Sales Tax',
           code: '001',
@@ -68,7 +66,7 @@ module Workarea
             credit_card: {
               number: '1',
               month:  1,
-              year:   next_year,
+              year:   2020,
               cvv:    '999'
             }
           }
@@ -83,7 +81,7 @@ module Workarea
             credit_card: {
               number: '2',
               month:  1,
-              year:   next_year,
+              year:   2020,
               cvv:    '999'
             }
           }
@@ -99,7 +97,7 @@ module Workarea
             credit_card: {
               number: '1',
               month:  1,
-              year:   next_year,
+              year:   2020,
               cvv:    '999'
             }
           }
@@ -119,7 +117,7 @@ module Workarea
             credit_card: {
               number: '1',
               month:  1,
-              year:   next_year,
+              year:   2020,
               cvv:    '999'
             }
           }

data/test/integration/workarea/storefront/placing_order_integration_test.rb

@@ -76,7 +76,7 @@ module Workarea
             credit_card: {
               number: '1',
               month: 1,
-              year: next_year,
+              year: 2020,
               cvv: '999'
             }
           }

data/test/integration/workarea/storefront/recent_views_integration_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class RecentViewsIntegrationTest < Workarea::IntegrationTest
+      def test_show
+        password = 'W3bl1nc!'
+        user = create_user(password: password)
+        category = create_category
+        product = create_product
+        Metrics::User.save_affinity(
+          id: user.email,
+          action: 'viewed',
+          product_ids: [product.id]
+        )
+
+        post storefront.login_path,
+          params: { email: user.email, password: password }
+
+        assert_redirected_to(storefront.users_account_path)
+        refute(session[:user_id].blank?)
+
+        product_url = storefront.product_path(product, via: category.id)
+        get storefront.recent_views_path(via: category.id)
+        assert_select(%(.product-summary__name a[href="#{product_url}"]))
+      end
+    end
+  end
+end

data/test/integration/workarea/storefront/releases_integration_test.rb

@@ -0,0 +1,132 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class ReleasesIntegrationTest < Workarea::IntegrationTest
+      def test_previewing_releases
+        first = create_release(publish_at: 1.day.from_now)
+        second = create_release(publish_at: 2.days.from_now)
+
+        product = create_product(name: 'Foo', template: 'generic', description: 'One')
+        first.as_current { product.update_attributes!(name: 'Bar', description: 'Two') }
+        second.as_current { product.update_attributes!(name: 'Baz') }
+
+        set_current_user(create_user(super_admin: true))
+
+        post admin.release_session_path, params: { release_id: first.id }
+        get storefront.product_path(product)
+        assert(response.body.include?('Bar'))
+        assert(response.body.include?('Two'))
+
+        post admin.release_session_path, params: { release_id: second.id }
+        get storefront.product_path(product)
+        assert(response.body.include?('Baz'))
+        assert(response.body.include?('Two'))
+      end
+
+      def test_browsing_featured_categories
+        set_current_user(create_user(super_admin: true))
+        product_one = create_product(id: 'PROD1', name: 'Foo')
+        product_two = create_product(id: 'PROD2', name: 'Bar')
+        pricing = Pricing::Sku.find('SKU').prices.first.tap { |p| p.update!(regular: 5) }
+        category = create_category(product_ids: [product_one.id, product_two.id])
+
+        get storefront.category_path(category)
+        assert_match(/Foo.*Bar/m, response.body)
+        assert_includes(response.body, '5.00')
+
+        release = create_release
+        release.as_current do
+          category.update!(product_ids: [product_two.id, product_one.id])
+          product_one.update!(name: 'Baz')
+          pricing.update!(regular: 7.99)
+        end
+
+        post admin.release_session_path, params: { release_id: release.id }
+
+        get storefront.category_path(category)
+        assert_match(/Bar.*Baz/m, response.body)
+        assert_includes(response.body, '7.99')
+      end
+
+      def test_category_rules_in_releases
+        product_one = create_product(id: 'PROD1', name: 'Foo')
+        product_two = create_product(id: 'PROD2', name: 'Bar')
+        category = create_category(
+          product_rules: [{ name: 'search', operator: 'equals', value: 'foo' }]
+        )
+
+        get storefront.category_path(category)
+        assert_includes(response.body, 'Foo')
+        refute_includes(response.body, 'Bar')
+
+        release = create_release
+        release.as_current do
+          category.update!(
+            product_rules: [{ name: 'search', operator: 'equals', value: 'bar' }]
+          )
+        end
+
+        post admin.release_session_path, params: { release_id: release.id }
+
+        get storefront.category_path(category)
+        refute_includes(response.body, 'Foo')
+        assert_includes(response.body, 'Bar')
+      end
+
+      def test_searches_with_release_customizations
+        set_current_user(create_user(super_admin: true))
+        product_one = create_product(id: 'PROD1', name: 'Test Foo')
+        product_two = create_product(id: 'PROD2', name: 'Test Bar')
+        search_customization = create_search_customization(
+          id: 'test',
+          query: 'test',
+          product_ids: [product_one.id, product_two.id]
+        )
+
+        get storefront.search_path(q: 'test')
+        assert_match(/Test Foo.*Test Bar/m, response.body)
+
+        release = create_release
+        release.as_current do
+          search_customization.update!(product_ids: [product_two.id, product_one.id])
+          product_one.update!(name: 'Test Baz')
+        end
+
+        post admin.release_session_path, params: { release_id: release.id }
+
+        get storefront.search_path(q: 'test')
+        assert_match(/Test Bar.*Test Baz/m, response.body)
+      end
+
+      def test_rescheduling_releases
+        set_current_user(create_user(super_admin: true))
+        product_one = create_product(id: 'PROD1', name: 'Foo')
+        product_two = create_product(id: 'PROD2', name: 'Bar')
+        category = create_category(product_ids: [product_one.id, product_two.id])
+
+        get storefront.category_path(category)
+        assert_match(/Foo.*Bar/m, response.body)
+
+        release_one = create_release(publish_at: 1.day.from_now)
+        release_one.as_current { category.update!(product_ids: [product_two.id, product_one.id]) }
+
+        release_two = create_release(publish_at: 2.days.from_now)
+        release_two.as_current { product_one.update!(name: 'Baz') }
+
+        post admin.release_session_path, params: { release_id: release_one.id }
+        get storefront.category_path(category)
+        assert_match(/Bar.*Foo/m, response.body)
+
+        post admin.release_session_path, params: { release_id: release_two.id }
+        get storefront.category_path(category)
+        assert_match(/Bar.*Baz/m, response.body)
+
+        release_one.update!(publish_at: 1.week.from_now)
+        post admin.release_session_path, params: { release_id: release_one.id }
+        get storefront.category_path(category)
+        assert_match(/Bar.*Baz/m, response.body)
+      end
+    end
+  end
+end

data/test/integration/workarea/storefront/search_integration_test.rb

@@ -13,42 +13,6 @@ module Workarea
         assert_redirected_to(storefront.cart_path)
       end
 
-      def test_renders_search_suggestions_in_json
-        create_product(name: 'Foo')
-        create_category(name: 'Foo Category')
-        create_page(name: 'Foo Page')
-
-        Metrics::SearchByDay.save_search('foo', 3)
-        travel_to 1.week.from_now
-        GenerateInsights.generate_all!
-        BulkIndexSearches.perform
-
-        get storefront.searches_path(q: 'foo', format: 'json')
-        results = JSON.parse(response.body)['results']
-        assert_equal(4, results.length)
-
-        search = results.detect { |r| r['type'] == 'Searches' }
-        assert(search.present?)
-        assert_equal('foo', search['value'])
-        assert_equal(storefront.search_path(q: 'foo'), search['url'])
-
-        product = results.detect { |r| r['type'] == 'Products' }
-        assert(product.present?)
-        assert_equal('Foo', product['value'])
-        assert_match(/product_images/, product['image'])
-        assert_equal(storefront.product_path('foo'), product['url'])
-
-        category = results.detect { |r| r['type'] == 'Categories' }
-        assert(category.present?)
-        assert_equal('Foo Category', category['value'])
-        assert_equal(storefront.category_path('foo-category'), category['url'])
-
-        page = results.detect { |r| r['type'] == 'Pages' }
-        assert(page.present?)
-        assert_equal('Foo Page', page['value'])
-        assert_equal(storefront.page_path('foo-page'), page['url'])
-      end
-
       def test_handles_invalid_queries
         get storefront.search_path(q: '{()!}'),
           headers: { 'HTTP_REFERER' => '/foo' }
@@ -123,16 +87,6 @@ module Workarea
         assert_includes(response.body, 'Foo A')
         assert_includes(response.body, 'Foo B')
       end
-
-      def test_not_accepting_per_page_param
-        one = create_product(name: 'Foo A')
-        two = create_product(name: 'Foo B')
-
-        get storefront.search_path(q: 'foo', page: 1, per_page: 1)
-        assert(response.ok?)
-        assert_includes(response.body, storefront.product_path(one))
-        assert_includes(response.body, storefront.product_path(two))
-      end
     end
   end
 end

data/test/integration/workarea/storefront/segment_overrides_integration_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class SegmentOverridesIntegrationTest < Workarea::IntegrationTest
+      include Storefront::IntegrationTest
+
+      def test_admins_ignore_segments
+        create_life_cycle_segments
+        first_time_visitor = Segment::FirstTimeVisitor.instance
+        returning_visitor = Segment::ReturningVisitor.instance
+        product = create_product(active: true, active_segment_ids: [returning_visitor.id])
+        content = Content.for('home_page')
+        content.blocks.create!(
+          type: 'html',
+          data: { 'html' => '<p>Foo</p>' },
+          active_segment_ids: [returning_visitor.id]
+        )
+
+        set_current_user(create_user(admin: true))
+
+        get storefront.search_path(q: '*')
+        refute_includes(response.body, product.id)
+
+        get storefront.root_path
+        refute_includes(response.body, '<p>Foo</p>')
+      end
+
+      def test_impersonation_segments
+        create_life_cycle_segments
+        first_time_visitor = Segment::FirstTimeVisitor.instance
+        customer = create_user
+        super_admin = create_user(password: 'W3bl1nc!', super_admin: true)
+        post storefront.login_path, params: { email: super_admin.email, password: 'W3bl1nc!' }
+        post admin.impersonations_path, params: { user_id: customer.id }
+
+        get storefront.current_user_path(format: 'json')
+        assert(response.headers['X-Workarea-Segments'].blank?)
+
+        post admin.segment_override_path,
+          params: { segment_ids: { first_time_visitor.id => 'true' } }
+
+        get storefront.current_user_path(format: 'json')
+        assert_equal(first_time_visitor.id, response.headers['X-Workarea-Segments'])
+      end
+    end
+  end
+end

data/test/integration/workarea/storefront/segments_integration_test.rb

@@ -0,0 +1,250 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class SegmentsIntegrationTest < Workarea::IntegrationTest
+      include Storefront::IntegrationTest
+
+      def test_life_cycle_segments_functionality
+        Workarea.config.loyal_customers_min_orders = 3
+        create_life_cycle_segments
+
+        get storefront.current_user_path(format: 'json')
+        assert_equal(
+          Segment::FirstTimeVisitor.instance.id.to_s,
+          response.headers['X-Workarea-Segments']
+        )
+
+        cookies[:sessions] = 2
+        get storefront.current_user_path(format: 'json')
+        assert_equal(
+          Segment::ReturningVisitor.instance.id.to_s,
+          response.headers['X-Workarea-Segments']
+        )
+
+        complete_checkout
+
+        get storefront.current_user_path(format: 'json')
+        assert_equal(
+          Segment::FirstTimeCustomer.instance.id.to_s,
+          response.headers['X-Workarea-Segments']
+        )
+
+        complete_checkout
+
+        get storefront.current_user_path(format: 'json')
+        assert_equal(
+          Segment::ReturningCustomer.instance.id.to_s,
+          response.headers['X-Workarea-Segments']
+        )
+
+        complete_checkout
+
+        get storefront.current_user_path(format: 'json')
+        assert_equal(
+          Segment::LoyalCustomer.instance.id.to_s,
+          response.headers['X-Workarea-Segments']
+        )
+      end
+
+      def test_products_active_by_segment
+        segment_one = create_segment(rules: [Segment::Rules::Sessions.new(minimum: 1, maximum: 1)])
+        segment_two = create_segment(rules: [Segment::Rules::Sessions.new(minimum: 2, maximum: 2)])
+        product_one = create_product(active: true, active_segment_ids: [segment_two.id])
+        product_two = create_product(active: true, active_segment_ids: [segment_one.id])
+
+        assert_raise InvalidDisplay do
+          cookies[:sessions] = 0
+          get storefront.product_path(product_one)
+          assert(response.not_found?)
+        end
+
+        assert_raise InvalidDisplay do
+          cookies[:sessions] = 0
+          get storefront.product_path(product_two)
+          assert(response.not_found?)
+        end
+
+        cookies[:sessions] = 0
+        get storefront.search_path(q: '*')
+        refute_includes(response.body, product_one.id)
+        refute_includes(response.body, product_two.id)
+
+        assert_raise InvalidDisplay do
+          cookies[:sessions] = 1
+          get storefront.product_path(product_one)
+          assert(response.not_found?)
+        end
+
+        cookies[:sessions] = 1
+        get storefront.product_path(product_two)
+        assert(response.ok?)
+
+        cookies[:sessions] = 1
+        get storefront.search_path(q: '*')
+        refute_includes(response.body, product_one.id)
+        assert_includes(response.body, product_two.id)
+
+        cookies[:sessions] = 2
+        get storefront.product_path(product_one)
+        assert(response.ok?)
+
+        assert_raise InvalidDisplay do
+          cookies[:sessions] = 2
+          get storefront.product_path(product_two)
+          assert(response.not_found?)
+        end
+
+        cookies[:sessions] = 2
+        get storefront.search_path(q: '*')
+        assert_includes(response.body, product_one.id)
+        refute_includes(response.body, product_two.id)
+
+        segment_one.rules.first.update!(minimum: 1, maximum: nil)
+        segment_two.rules.first.update!(minimum: 1, maximum: nil)
+
+        cookies[:sessions] = 1
+        get storefront.product_path(product_one)
+        assert(response.ok?)
+
+        cookies[:sessions] = 1
+        get storefront.product_path(product_two)
+        assert(response.ok?)
+
+        cookies[:sessions] = 1
+        get storefront.search_path(q: '*')
+        assert_includes(response.body, product_one.id)
+        assert_includes(response.body, product_two.id)
+      end
+
+      def test_content_active_by_segment
+        segment_one = create_segment(rules: [Segment::Rules::Sessions.new(minimum: 1, maximum: 1)])
+        segment_two = create_segment(rules: [Segment::Rules::Sessions.new(minimum: 2, maximum: 2)])
+
+        content = Content.for('home_page')
+        content.blocks.create!(
+          type: 'html',
+          data: { 'html' => '<p>Foo</p>' },
+          active_segment_ids: [segment_one.id]
+        )
+        content.blocks.create!(
+          type: 'html',
+          data: { 'html' => '<p>Bar</p>' },
+          active_segment_ids: [segment_two.id]
+        )
+
+        cookies[:sessions] = 1
+        get storefront.root_path
+        assert_includes(response.body, '<p>Foo</p>')
+        refute_includes(response.body, '<p>Bar</p>')
+
+        cookies[:sessions] = 2
+        get storefront.root_path
+        refute_includes(response.body, '<p>Foo</p>')
+        assert_includes(response.body, '<p>Bar</p>')
+
+        segment_one.rules.first.update!(minimum: 1, maximum: nil)
+        segment_two.rules.first.update!(minimum: 1, maximum: nil)
+        cookies[:sessions] = 1
+        get storefront.root_path
+        assert_includes(response.body, '<p>Foo</p>')
+        assert_includes(response.body, '<p>Bar</p>')
+      end
+
+      def test_logged_in_based_segments
+        logged_in = create_segment(rules: [Segment::Rules::LoggedIn.new(logged_in: true)])
+        logged_out = create_segment(rules: [Segment::Rules::LoggedIn.new(logged_in: false)])
+
+        get storefront.current_user_path(format: 'json')
+        assert_equal(logged_out.id.to_s, response.headers['X-Workarea-Segments'])
+
+        user = create_user(password: 'w0rkArea!')
+        post storefront.login_path,
+          params: { email: user.email, password: 'w0rkArea!' }
+
+        get storefront.current_user_path(format: 'json')
+        assert_equal(logged_in.id.to_s, response.headers['X-Workarea-Segments'])
+      end
+
+      def test_endpoints_without_a_visit
+        assert_nothing_raised do
+          get storefront.internal_error_path(format: 'png')
+          refute(response.headers.key?('X-Workarea-Segments'))
+        end
+      end
+
+      def test_segmented_discounts
+        new_visitors = create_segment(rules: [Segment::Rules::Sessions.new(minimum: 0)])
+        returning_visitors = create_segment(rules: [Segment::Rules::Sessions.new(minimum: 2)])
+        product = create_product(variants: [{ sku: 'SKU', regular: 5.to_m }])
+        discount = create_product_discount(
+          amount_type: 'flat',
+          amount: 1.to_m,
+          product_ids: [product.id],
+          active: true,
+          active_segment_ids: [returning_visitors.id]
+        )
+
+        post storefront.cart_items_path,
+           params: { product_id: product.id, sku: product.skus.first, quantity: 1 }
+
+        order = Order.first
+        assert_equal(5.to_m, order.total_price)
+
+        cookies[:sessions] = 2
+        get storefront.cart_path # reprice the order
+        assert_equal(4.to_m, order.reload.total_price)
+      end
+
+      def test_http_caching_headers_for_segmented_content
+        Workarea.config.strip_http_caching_in_tests = false
+        segment = create_segment(rules: [Segment::Rules::Sessions.new(maximum: 999)])
+
+        get storefront.root_path
+        refute_match(/private/, response.headers['Cache-Control'])
+        assert_match(/public/, response.headers['Cache-Control'])
+        assert(response.headers['X-Workarea-Segmented-Content'].blank?)
+
+        content = Content.for('home_page')
+        content.blocks.create!(
+          type: 'html',
+          data: { 'html' => '<p>Foo</p>' },
+          active_segment_ids: [segment.id]
+        )
+
+        get storefront.root_path
+        assert_match(/private/, response.headers['Cache-Control'])
+        refute_match(/public/, response.headers['Cache-Control'])
+        assert_equal('true', response.headers['X-Workarea-Segmented-Content'])
+
+        product = create_product(active: true, active_segment_ids: [])
+        get storefront.product_path(product)
+        assert(response.ok?)
+        refute_match(/private/, response.headers['Cache-Control'])
+        assert_match(/public/, response.headers['Cache-Control'])
+        assert(response.headers['X-Workarea-Segmented-Content'].blank?)
+
+        product.update!(active_segment_ids: [segment.id])
+        get storefront.product_path(product)
+        assert(response.ok?)
+        assert_match(/private/, response.headers['Cache-Control'])
+        refute_match(/public/, response.headers['Cache-Control'])
+        assert_equal('true', response.headers['X-Workarea-Segmented-Content'])
+
+        category = create_category(active: true, active_segment_ids: [])
+        get storefront.category_path(category)
+        assert(response.ok?)
+        refute_match(/private/, response.headers['Cache-Control'])
+        assert_match(/public/, response.headers['Cache-Control'])
+        assert(response.headers['X-Workarea-Segmented-Content'].blank?)
+
+        category.update!(product_ids: [product.id])
+        get storefront.category_path(category)
+        assert(response.ok?)
+        assert_match(/private/, response.headers['Cache-Control'])
+        refute_match(/public/, response.headers['Cache-Control'])
+        assert_equal('true', response.headers['X-Workarea-Segmented-Content'])
+      end
+    end
+  end
+end