workarea-api-storefront 4.4.6 → 4.5.4

data/lib/workarea/api/storefront.rb

@@ -13,3 +13,4 @@ end
 
 require 'workarea/api/version'
 require 'workarea/api/storefront/engine'
+require 'workarea/api/storefront/visit.decorator'

data/lib/workarea/api/storefront/visit.decorator

@@ -0,0 +1,52 @@
+module Workarea
+  decorate Visit, with: 'storefront_api' do
+    def api?
+      return @api if defined?(@api)
+      @api = Workarea.config.is_api_visit.call(request)
+    end
+
+    def cookies
+      api? ? {} : super
+    end
+
+    def session
+      api? ? {} : super
+    end
+
+    def logged_in?
+      return super unless api?
+
+      regex = ActionController::HttpAuthentication::Token::TOKEN_REGEX
+      request.authorization.to_s[regex].present?
+    end
+
+    def current_email
+      return super unless api?
+      return request.params['email'] unless logged_in?
+      return @current_email if defined? @current_email
+
+      @current_email = current_user&.email
+    end
+
+    def current_user
+      token, options = ActionController::HttpAuthentication::Token.token_and_options(request)
+      @current_user ||= Api::Storefront::Authentication.find_user(token, options)
+    end
+
+    def sessions
+      api? ? request.params['sessions'].to_i : super
+    end
+
+    def current_metrics_id
+      return super unless api?
+
+      return @current_metrics_id if defined?(@current_metrics_id)
+      @current_metrics_id = current_email.presence || request.params['session_id']
+    end
+
+    def current_metrics_id=(value)
+      return super unless api?
+      # Unsupported in the API
+    end
+  end
+end

data/test/documentation/workarea/api/storefront/checkouts_documentation_test.rb

@@ -85,6 +85,27 @@ module Workarea
           end
         end
 
+        def test_and_document_update_failure
+          description 'Failure to update a checkout'
+          route storefront_api.checkout_path(':id')
+          explanation <<-EOS
+            This is an example of what occurs when you fail to send in the correct parameters for your checkout.
+          EOS
+
+          record_request do
+            patch storefront_api.checkout_path(@order),
+              as: :json,
+              params: {
+                email: 'susanb@workarea.com',
+                shipping_address: address.except(:first_name),
+                billing_address: address.except(:last_name),
+                shipping_service: 'Express'
+              }
+
+            assert_equal(422, response.status)
+          end
+        end
+
         def test_and_document_complete
           description 'Completing a checkout'
           route storefront_api.complete_checkout_path(':id')

data/test/documentation/workarea/api/storefront/segmentation_documentation_test.rb

@@ -0,0 +1,104 @@
+require 'test_helper'
+require 'workarea/api/documentation_test'
+
+module Workarea
+  module Api
+    module Storefront
+      class SegmentationDocumentationTest < DocumentationTest
+        resource 'Segmentation'
+
+        def test_and_document_session_count
+          description 'Specifying session count for segmentation'
+          route storefront_api.system_content_path('home_page')
+          explanation <<~EOS
+            Workarea supports segmenting users by number of sessions, e.g.
+            first-time vs returning visitors. To support this in the storefront
+            API, the client will be responsible for managing this since the API
+            is stateless (doesn't have cookies/session).
+
+            To get session-based segments functioning, you need to pass a
+            `sessions` parameter in each request. Workarea will use that as
+            the number of sessions for determing the segments for the response.
+            This works for all requests across the storefront API.
+
+            This example shows getting a home page with segmented content based
+            on the number of sessions.
+          EOS
+
+          first_time = Segment::FirstTimeVisitor.instance
+          returning = Segment::ReturningVisitor.instance
+
+          content = Content.for('Home Page')
+          content.blocks.create!(
+            type: 'text',
+            data: { text: 'Hello visitor!' },
+            active_segment_ids: [first_time.id]
+          )
+          content.blocks.create!(
+            type: 'text',
+            data: { text: 'Welcome back!' },
+            active_segment_ids: [returning.id]
+          )
+
+          record_request do
+            get storefront_api.system_content_path('home_page', sessions: 1)
+            assert_match(/Hello visitor!/, response.body)
+            assert(response.ok?)
+          end
+          record_request do
+            get storefront_api.system_content_path('home_page', sessions: 2)
+            assert_match(/Welcome back!/, response.body)
+            assert(response.ok?)
+          end
+        end
+
+        def test_and_document_session_ids
+          description 'Using session IDs for segmenting non-authenticated users'
+          route storefront_api.system_content_path('home_page')
+          explanation <<~EOS
+            Workarea supports segmenting users by number of orders, revenue, etc.
+            For this functionality to work for users without accounts, you'll
+            need to maintain and pass a `session_id` consistently throughout calls
+            to the API.
+
+            An instance of `Metrics::User` will be found or created for that
+            `session_id`, and data about the user will be tracked there.
+
+            Assuming use of the `session_id` consistently through checkout, this
+            example shows getting home page content for two different anonymous
+            users and getting segmented content back.
+          EOS
+
+          first_time = Segment::FirstTimeCustomer.instance
+          returning = Segment::ReturningCustomer.instance
+
+          Metrics::User.create!(id: 'session_1', orders: 1)
+          Metrics::User.create!(id: 'session_2', orders: 2)
+
+          content = Content.for('Home Page')
+          content.blocks.create!(
+            type: 'text',
+            data: { text: 'Thanks for your order!' },
+            active_segment_ids: [first_time.id]
+          )
+          content.blocks.create!(
+            type: 'text',
+            data: { text: 'Welcome back repeat customer!' },
+            active_segment_ids: [returning.id]
+          )
+
+          record_request do
+            get storefront_api.system_content_path('home_page', session_id: 'session_1')
+            assert_match(/Thanks/, response.body)
+            assert(response.ok?)
+          end
+          record_request do
+            get storefront_api.system_content_path('home_page', session_id: 'session_2')
+            assert_match(/Welcome back/, response.body)
+            assert(response.ok?)
+          end
+        end
+      end
+    end
+  end
+end

data/test/documentation/workarea/api/storefront/validation_documentation_test.rb

@@ -72,7 +72,7 @@ module Workarea
                 }
               }
 
-            assert_equal(200, response.status)
+            assert_equal(422, response.status)
           end
         end
       end

data/test/dummy/config/initializers/session_store.rb

@@ -1,3 +1,5 @@
 # Be sure to restart your server when you modify this file.
 
-Rails.application.config.session_store :cookie_store, key: '_dummy_session'
+Rails.application.config.session_store :cookie_store,
+                                       key: '_dummy_session',
+                                       expire_after: 30.minutes

data/test/integration/workarea/api/storefront/analytics_integration_test.rb

@@ -7,11 +7,19 @@ module Workarea
         def test_saving_category_view
           post storefront_api.analytics_category_view_path(category_id: 'foo')
           assert_equal(1, Metrics::CategoryByDay.first.views)
+
+          post storefront_api.analytics_category_view_path(category_id: 'foo', session_id: '1')
+          assert_equal(2, Metrics::CategoryByDay.first.views)
+          assert_equal(%w(foo), Metrics::User.find('1').viewed.category_ids)
         end
 
         def test_saving_product_view
           post storefront_api.analytics_product_view_path(product_id: 'foo')
           assert_equal(1, Metrics::ProductByDay.first.views)
+
+          post storefront_api.analytics_product_view_path(product_id: 'foo', session_id: '1')
+          assert_equal(2, Metrics::ProductByDay.first.views)
+          assert_equal(%w(foo), Metrics::User.find('1').viewed.product_ids)
         end
 
         def test_saving_search
@@ -21,14 +29,11 @@ module Workarea
           insights = Metrics::SearchByDay.first
           assert_equal(1, insights.searches)
           assert_equal(5, insights.total_results)
-        end
 
-        def test_saving_search_abandonment
-          # Saving abandonment is deprecated, and this will be removed in v3.5
-        end
-
-        def test_saving_filters
-          # Saving filters is deprecated, and this will be removed in v3.5
+          post storefront_api.analytics_search_path,
+            params: { q: 'foo', total_results: 5, session_id: '1' }
+          assert_equal(2, insights.reload.searches)
+          assert_equal(%w(foo), Metrics::User.find('1').viewed.search_ids)
         end
       end
     end

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

@@ -19,30 +19,38 @@ module Workarea
 
         def test_showing_recent_views_with_authentication
           user = create_user(first_name: 'Ben', last_name: 'Crouse')
-          set_current_user(user)
+          post storefront_api.authentication_tokens_path,
+            params: { email: user.email, password: user.password }
+          token = JSON.parse(response.body)['token']
 
-          activity = create_user_activity(
-            id: user.id,
+          Metrics::User.save_affinity(
+            id: user.email,
+            action: 'viewed',
             product_ids: [@product.id],
             category_ids: [@category.id],
-            searches: ['foo']
+            at: Time.current,
+            search_ids: %w(foo)
           )
 
-          get storefront_api.recent_views_path
+          get storefront_api.recent_views_path,
+            headers: { 'HTTP_AUTHORIZATION' => encode_credentials(token) }
 
           assert(response.ok?)
           result = JSON.parse(response.body)
 
-          assert_equal(activity.id, result['id'])
+          assert_equal(user.email, result['id'])
           assert_equal(@product.id, result['products'].first['id'])
           assert_equal(@category.id.to_s, result['categories'].first['id'])
-          assert_includes(result['searches'], 'foo')
         end
 
         def test_adding_recent_views_for_authentication
           user = create_user(first_name: 'Ben', last_name: 'Crouse')
-          set_current_user(user)
+          post storefront_api.authentication_tokens_path,
+            params: { email: user.email, password: user.password }
+          token = JSON.parse(response.body)['token']
+
           patch storefront_api.recent_views_path,
+            headers: { 'HTTP_AUTHORIZATION' => encode_credentials(token) },
             params: {
               product_id: @product.id,
               category_id: @category.id,
@@ -51,54 +59,51 @@ module Workarea
 
           assert(response.ok?)
 
-          user_activity = Recommendation::UserActivity.first
-          assert_equal(user.id.to_s, user_activity.id.to_s)
-          assert_includes(user_activity.product_ids, @product.id)
-          assert_includes(user_activity.category_ids, @category.id.to_s)
-          assert_includes(user_activity.searches, 'foo')
+          user_activity = Workarea::Storefront::UserActivityViewModel.wrap(
+            Metrics::User.first
+          )
+          assert_equal(user.email, user_activity.id)
+          assert_includes(user_activity.products, @product)
+          assert_includes(user_activity.categories, @category)
         end
 
         def test_showing_recent_views_with_session_id
-          activity = create_user_activity(
+          Metrics::User.save_affinity(
+            id: BSON::ObjectId.new.to_s,
+            action: 'viewed',
             product_ids: [@product.id],
             category_ids: [@category.id],
-            searches: ['bar']
+            search_ids: %w(foo)
           )
+          activity = Metrics::User.last
 
           get storefront_api.recent_views_path,
             params: { session_id: activity.id }
 
-          assert(response.ok?)
+          assert_response(:success)
           result = JSON.parse(response.body)
 
-          assert_equal(activity.id, result['id'])
-          assert_equal(@product.id, result['products'].first['id'])
+          assert_equal(activity.id.to_s, result['id'])
+          assert_equal(@product.id.to_s, result['products'].first['id'])
           assert_equal(@category.id.to_s, result['categories'].first['id'])
-          assert_includes(result['searches'], 'bar')
         end
 
         def test_adding_recent_views_for_session_id
-          activity = create_user_activity(
-            product_ids: [@product.id],
-            category_ids: [@category.id],
-            searches: ['bar']
-          )
-
           patch storefront_api.recent_views_path,
             params: {
-              session_id: activity.id,
+              session_id: BSON::ObjectId.new.to_s,
               product_id: @product.id,
               category_id: @category.id,
               search: 'bar'
             }
 
-          assert(response.ok?)
+          assert_response(:success)
 
-          user_activity = Recommendation::UserActivity.first
-          assert_equal(activity.id, user_activity.id)
-          assert_includes(user_activity.product_ids, @product.id)
-          assert_includes(user_activity.category_ids, @category.id.to_s)
-          assert_includes(user_activity.searches, 'bar')
+          user_activity = Workarea::Storefront::UserActivityViewModel.wrap(
+            Metrics::User.first
+          )
+          assert_includes(user_activity.products, @product)
+          assert_includes(user_activity.categories, @category)
         end
 
         def test_adding_without_id
@@ -110,7 +115,7 @@ module Workarea
             }
 
           refute(response.ok?)
-          assert_equal(0, Recommendation::UserActivity.count)
+          assert_equal(0, Metrics::User.count)
         end
       end
     end

data/test/integration/workarea/api/storefront/recommendations_integration_test.rb

@@ -23,7 +23,7 @@ module Workarea
         end
 
         def set_user_activity
-          @activity = create_user_activity
+          @activity = Metrics::User.create!
         end
 
         def test_showing_recommendations_with_authentication

data/test/integration/workarea/api/storefront/searches_integration_test.rb

@@ -4,42 +4,6 @@ module Workarea
   module Api
     module Storefront
       class SearchesIntegrationTest < IntegrationTest
-        def test_showing_search_autocomplete
-          create_product(name: 'Foo')
-          create_category(name: 'Foo Category')
-          create_page(name: 'Foo Page')
-
-          Metrics::SearchByDay.save_search('foo', 3)
-          travel_to 1.weeks.from_now
-          GenerateInsights.generate_all!
-          BulkIndexSearches.perform
-
-          get storefront_api.searches_path(q: 'foo')
-          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_api.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_api.product_path('foo'), product['url'])
-
-          category = results.detect { |r| r['type'] == 'Categories' }
-          assert(category.present?)
-          assert_equal('Foo Category', category['value'])
-          assert_equal(storefront_api.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_api.page_path('foo-page'), page['url'])
-        end
-
         def test_shows_search_results
           Search::Settings.current.update_attributes!(terms_facets: %w(Color Size))
           create_product(

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

@@ -0,0 +1,218 @@
+require 'test_helper'
+
+module Workarea
+  module Api
+    module Storefront
+      class SegmentsIntegrationTest < IntegrationTest
+        include AuthenticationTest
+
+        def test_sessions_functionality
+          first_time = Segment::FirstTimeVisitor.instance
+          returning = Segment::ReturningVisitor.instance
+
+          get storefront_api.system_content_path('home_page')
+          assert_equal(first_time.id.to_s, response.headers['X-Workarea-Segments'])
+
+          get storefront_api.system_content_path('home_page'), params: { sessions: 1 }
+          assert_equal(first_time.id.to_s, response.headers['X-Workarea-Segments'])
+
+          get storefront_api.system_content_path('home_page'), params: { sessions: 2 }
+          assert_equal(returning.id.to_s, response.headers['X-Workarea-Segments'])
+        end
+
+        def test_current_email_functionality
+          first_time = Segment::FirstTimeCustomer.instance
+          returning = Segment::ReturningCustomer.instance
+
+          Metrics::User.save_order(email: 'first-time@workarea.com', revenue: 1.to_m)
+          Metrics::User.save_order(email: 'returning@workarea.com', revenue: 1.to_m)
+          Metrics::User.save_order(email: 'returning@workarea.com', revenue: 1.to_m)
+
+          get storefront_api.system_content_path('home_page')
+          assert(response.headers['X-Workarea-Segments'].blank?)
+
+          get storefront_api.system_content_path('home_page'), params: { email: 'first-time@workarea.com' }
+          assert_equal(first_time.id.to_s, response.headers['X-Workarea-Segments'])
+
+          get storefront_api.system_content_path('home_page'), params: { email: 'returning@workarea.com' }
+          assert_equal(returning.id.to_s, response.headers['X-Workarea-Segments'])
+        end
+
+        def test_session_ids_for_metrics
+          first_time = Segment::FirstTimeCustomer.instance
+          returning = Segment::ReturningCustomer.instance
+
+          Metrics::User.create!(id: '1', orders: 1)
+          Metrics::User.create!(id: '2', orders: 2)
+
+          get storefront_api.system_content_path('home_page')
+          assert(response.headers['X-Workarea-Segments'].blank?)
+
+          get storefront_api.system_content_path('home_page'), params: { session_id: '1' }
+          assert_equal(first_time.id.to_s, response.headers['X-Workarea-Segments'])
+
+          get storefront_api.system_content_path('home_page'), params: { session_id: '2' }
+          assert_equal(returning.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
+            get storefront_api.product_path(product_one), params: { sessions: 0 }
+            assert(response.not_found?)
+          end
+
+          assert_raise InvalidDisplay do
+            get storefront_api.product_path(product_two), params: { sessions: 0 }
+            assert(response.not_found?)
+          end
+
+          get storefront_api.search_path(q: '*'), params: { sessions: 0 }
+          assert(JSON.parse(response.body)['products'].empty?)
+
+          assert_raise InvalidDisplay do
+            get storefront_api.product_path(product_one), params: { sessions: 1 }
+            assert(response.not_found?)
+          end
+
+          get storefront_api.product_path(product_two), params: { sessions: 1 }
+          assert(response.ok?)
+
+          get storefront_api.search_path(q: '*'), params: { sessions: 1 }
+          products = JSON.parse(response.body)['products']
+          assert_equal([product_two.id], products.map { |p| p['id'] })
+
+          get storefront_api.product_path(product_one), params: { sessions: 2 }
+          assert(response.ok?)
+
+          assert_raise InvalidDisplay do
+            get storefront_api.product_path(product_two), params: { sessions: 2 }
+            assert(response.not_found?)
+          end
+
+          get storefront_api.search_path(q: '*'), params: { sessions: 2 }
+          products = JSON.parse(response.body)['products']
+          assert_equal([product_one.id], products.map { |p| p['id'] })
+
+          segment_one.rules.first.update!(minimum: 1, maximum: nil)
+          segment_two.rules.first.update!(minimum: 1, maximum: nil)
+
+          get storefront_api.product_path(product_one), params: { sessions: 1 }
+          assert(response.ok?)
+
+          get storefront_api.product_path(product_two), params: { sessions: 1 }
+          assert(response.ok?)
+
+          get storefront_api.search_path(q: '*'), params: { sessions: 1 }
+          products = JSON.parse(response.body)['products']
+          assert_equal(2, products.count)
+          assert_includes(products.map { |r| r['id'] }, product_one.id)
+          assert_includes(products.map { |r| r['id'] }, 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')
+          foo = content.blocks.create!(
+            type: 'html',
+            data: { 'html' => '<p>Foo</p>' },
+            active_segment_ids: [segment_one.id]
+          )
+          bar = content.blocks.create!(
+            type: 'html',
+            data: { 'html' => '<p>Bar</p>' },
+            active_segment_ids: [segment_two.id]
+          )
+
+          get storefront_api.system_content_path('home_page'), params: { sessions: 1 }
+          content_blocks = JSON.parse(response.body)['content_blocks']
+          assert_equal([foo.id.to_s], content_blocks.map { |cb| cb['id'] })
+
+          get storefront_api.system_content_path('home_page'), params: { sessions: 2 }
+          content_blocks = JSON.parse(response.body)['content_blocks']
+          assert_equal([bar.id.to_s], content_blocks.map { |cb| cb['id'] })
+
+          segment_one.rules.first.update!(minimum: 1, maximum: nil)
+          segment_two.rules.first.update!(minimum: 1, maximum: nil)
+
+          get storefront_api.system_content_path('home_page'), params: { sessions: 1 }
+          content_blocks = JSON.parse(response.body)['content_blocks']
+          assert_equal([foo.id.to_s, bar.id.to_s], content_blocks.map { |cb| cb['id'] })
+        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_api.system_content_path('home_page')
+          assert_equal(logged_out.id.to_s, response.headers['X-Workarea-Segments'])
+
+          user = create_user
+          post storefront_api.authentication_tokens_path,
+            params: { email: user.email, password: user.password }
+
+          token = JSON.parse(response.body)['token']
+          get storefront_api.system_content_path('home_page'),
+            headers: { 'HTTP_AUTHORIZATION' => encode_credentials(token) }
+          assert_equal(logged_in.id.to_s, response.headers['X-Workarea-Segments'])
+        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_api.system_content_path('home_page')
+          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_api.system_content_path('home_page')
+          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_api.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_api.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_api.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_api.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
+end