workarea-api-storefront 4.4.6

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

@@ -0,0 +1,118 @@
+require 'test_helper'
+
+module Workarea
+  module Api
+    module Storefront
+      class RecentViewsIntegrationTest < IntegrationTest
+        include AuthenticationTest
+
+        setup :set_product
+        setup :set_category
+
+        def set_product
+          @product = create_product
+        end
+
+        def set_category
+          @category = create_category
+        end
+
+        def test_showing_recent_views_with_authentication
+          user = create_user(first_name: 'Ben', last_name: 'Crouse')
+          set_current_user(user)
+
+          activity = create_user_activity(
+            id: user.id,
+            product_ids: [@product.id],
+            category_ids: [@category.id],
+            searches: ['foo']
+          )
+
+          get storefront_api.recent_views_path
+
+          assert(response.ok?)
+          result = JSON.parse(response.body)
+
+          assert_equal(activity.id, 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)
+          patch storefront_api.recent_views_path,
+            params: {
+              product_id: @product.id,
+              category_id: @category.id,
+              search: 'foo'
+            }
+
+          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')
+        end
+
+        def test_showing_recent_views_with_session_id
+          activity = create_user_activity(
+            product_ids: [@product.id],
+            category_ids: [@category.id],
+            searches: ['bar']
+          )
+
+          get storefront_api.recent_views_path,
+            params: { session_id: activity.id }
+
+          assert(response.ok?)
+          result = JSON.parse(response.body)
+
+          assert_equal(activity.id, result['id'])
+          assert_equal(@product.id, 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,
+              product_id: @product.id,
+              category_id: @category.id,
+              search: 'bar'
+            }
+
+          assert(response.ok?)
+
+          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')
+        end
+
+        def test_adding_without_id
+          patch storefront_api.recent_views_path,
+            params: {
+              product_id: @product.id,
+              category_id: @category.id,
+              search: 'search'
+            }
+
+          refute(response.ok?)
+          assert_equal(0, Recommendation::UserActivity.count)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+module Workarea
+  module Api
+    module Storefront
+      class RecommendationsIntegrationTest < IntegrationTest
+        include AuthenticationTest
+
+        setup :set_auth
+        setup :set_products
+        setup :set_user_activity
+
+        def set_auth
+          user = create_user
+          @auth = user.authentication_tokens.create!
+        end
+
+        def set_products
+          10.times { create_product }
+
+          top_products = Catalog::Product.sample(10).map { |p| { 'product_id' => p.id } }
+          create_top_products(results: top_products)
+        end
+
+        def set_user_activity
+          @activity = create_user_activity
+        end
+
+        def test_showing_recommendations_with_authentication
+          get storefront_api.recommendations_path,
+            headers: { 'HTTP_AUTHORIZATION' => encode_credentials(@auth.token) }
+          result = JSON.parse(response.body)
+
+          assert(response.ok?)
+          assert_equal(6, result['products'].count)
+          refute_empty(result['products'].first['name'])
+        end
+
+        def test_showing_recommendations_with_session_id
+          get storefront_api.recommendations_path,
+            params: { session_id: @activity.id }
+          result = JSON.parse(response.body)
+
+          assert(response.ok?)
+          assert_equal(6, result['products'].count)
+          refute_empty(result['products'].first['name'])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+module Workarea
+  module Api
+    module Storefront
+      class SavedAddressesIntegrationTest < IntegrationTest
+        include AuthenticationTest
+
+        setup :set_user
+        setup :set_address
+
+        def set_user
+          @user = create_user(first_name: 'Ben', last_name: 'Crouse')
+          set_current_user(@user)
+        end
+
+        def set_address
+          @address = @user.addresses.create!(
+            first_name: 'Ben',
+            last_name: 'Crouse',
+            street: '12 N. 3rd St.',
+            city: 'Philadelphia',
+            region: 'PA',
+            country: 'US',
+            postal_code: '19106',
+            phone_number: '2159251800'
+          )
+        end
+
+        def test_index
+          get storefront_api.saved_addresses_path
+          result = JSON.parse(response.body)
+
+          assert_equal(@user.id.to_s, result['user_id'])
+          assert_equal(1, result['addresses'].count)
+          assert_equal(@address.id.to_s, result['addresses'].last['id'])
+        end
+
+        def test_show
+          get storefront_api.saved_address_path(@address)
+          result = JSON.parse(response.body)
+
+          assert_equal(@user.id.to_s, result['user_id'])
+
+          assert_equal(@address.id.to_s, result['id'])
+          assert_equal(@address.first_name, result['first_name'])
+          assert_equal(@address.last_name, result['last_name'])
+          assert_equal(@address.street, result['street'])
+          assert_equal(@address.city, result['city'])
+          assert_equal(@address.country.alpha2, result['country'])
+          assert_equal(@address.region, result['region'])
+          assert_equal(@address.postal_code, result['postal_code'])
+          assert_equal(@address.phone_number, result['phone_number'])
+        end
+
+        def test_create
+          post storefront_api.saved_addresses_path,
+            params: {
+              first_name: 'Ben',
+              last_name: 'Crouse',
+              street: '22 S. 3rd St.',
+              street_2: 'Second Floor',
+              city: 'Philadelphia',
+              region: 'PA',
+              country: 'US',
+              postal_code: '19106',
+              phone_number: '2159251800'
+            }
+
+          assert(response.ok?)
+          assert(2, @user.reload.addresses.count)
+
+          address = @user.reload.addresses.last
+          assert_equal('22 S. 3rd St.', address.street)
+          assert_equal('Second Floor', address.street_2)
+        end
+
+        def test_update
+          patch storefront_api.saved_address_path(@address),
+            params: {
+              street: '22 S. 3rd St.',
+              street_2: 'Second Floor'
+            }
+
+          assert(response.ok?)
+          assert(1, @user.reload.addresses.count)
+
+          address = @user.reload.addresses.first
+          assert_equal('22 S. 3rd St.', address.street)
+          assert_equal('Second Floor', address.street_2)
+        end
+
+        def test_destroy
+          delete storefront_api.saved_address_path(@address)
+          assert_equal(0, @user.reload.addresses.count)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+require 'test_helper'
+
+module Workarea
+  module Api
+    module Storefront
+      class SavedCreditCardsIntegrationTest < IntegrationTest
+        include AuthenticationTest
+
+        setup :set_user
+        setup :set_payment_profile
+        setup :set_credit_card
+
+        def set_user
+          @user = create_user(first_name: 'Ben', last_name: 'Crouse')
+          set_current_user(@user)
+        end
+
+        def set_payment_profile
+          @payment_profile = Payment::Profile.lookup(
+            PaymentReference.new(@user)
+          )
+        end
+
+        def set_credit_card
+          @credit_card = @payment_profile.credit_cards.create!(
+            number: '1',
+            first_name: 'Ben',
+            last_name: 'Crouse',
+            month: '1',
+            year: (Time.now.year + 1).to_s,
+            cvv: '999'
+          )
+        end
+
+        def test_index
+          get storefront_api.saved_credit_cards_path
+          result = JSON.parse(response.body)
+
+          assert_equal(@user.id.to_s, result['user_id'])
+          assert_equal(1, result['credit_cards'].count)
+          assert_equal(@credit_card.id.to_s, result['credit_cards'].last['id'])
+        end
+
+        def test_show
+          get storefront_api.saved_credit_card_path(@credit_card)
+          result = JSON.parse(response.body)
+
+          assert_equal(@user.id.to_s, result['user_id'])
+
+          assert_equal(@credit_card.id.to_s, result['id'])
+          assert_equal(@credit_card.first_name, result['first_name'])
+          assert_equal(@credit_card.last_name, result['last_name'])
+          assert_equal(@credit_card.display_number, result['display_number'])
+          assert_equal(@credit_card.issuer, result['issuer'])
+          assert_equal(@credit_card.month, result['month'])
+          assert_equal(@credit_card.year, result['year'])
+          assert_equal(@credit_card.default, result['default'])
+        end
+
+        def test_create
+          post storefront_api.saved_credit_cards_path,
+            params: {
+              number: '4111111111111111',
+              first_name: 'Ben',
+              last_name: 'Crouse',
+              month: '5',
+              year: (Time.now.year + 1).to_s,
+              cvv: '123'
+            }
+
+          assert(response.ok?)
+          assert(2, @payment_profile.reload.credit_cards.count)
+
+          credit_card = @payment_profile.reload.credit_cards.last
+          assert_equal(5, credit_card.month)
+          assert_equal(
+            ActiveMerchant::Billing::CreditCard.mask('4111111111111111'),
+            credit_card.display_number
+          )
+        end
+
+        def test_update
+          year = Time.now.year + 2
+
+          patch storefront_api.saved_credit_card_path(@credit_card),
+            params: {
+              month: '5',
+              year: year.to_s,
+              cvv: '123'
+            }
+
+          assert(response.ok?)
+          assert(1, @payment_profile.reload.credit_cards.count)
+
+          credit_card = @payment_profile.reload.credit_cards.first
+          assert_equal(5, credit_card.month)
+          assert_equal(year, credit_card.year)
+        end
+
+        def test_destroy
+          delete storefront_api.saved_credit_card_path(@credit_card)
+          assert_equal(0, @payment_profile.reload.credit_cards.count)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+require 'test_helper'
+
+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(
+            id: 'PRODUCT1',
+            name: 'Pretty Nice Shirt',
+            filters:  { 'Size' => %w[Small Medium Large], 'Color' => 'Blue' },
+            variants: [{ sku: 'SKU', regular: 35.to_m }],
+            images: [{ image: product_image_file, option: 'Blue' }]
+          )
+
+          create_product(
+            id: 'PRODUCT2',
+            name: 'Great Pants',
+            filters:  { 'Size' => %w[Small Medium Large], 'Color' => 'Brown' },
+            variants: [{ sku: 'SKU', regular: 50.to_m }],
+            images: [{ image: product_image_file, option: 'Brown' }]
+          )
+
+          content = Content.for('search')
+          content.blocks.create!(
+            area: :results,
+            type: :text,
+            data: { text: 'global search test content' }
+          )
+
+          get storefront_api.search_path(q: 'large')
+          result = JSON.parse(response.body)
+
+          assert(result['query_string'].present?)
+          assert(result.key?('message'))
+          assert(result.key?('redirect'))
+
+          content_blocks = result['content_blocks']
+          assert_equal(1, content_blocks.count)
+
+          assert_equal(2, result['total_results'])
+          assert_equal(2, result['facets'].count)
+
+          products = result['products']
+          assert_equal(2, products.count)
+          assert_includes(products.map { |r| r['id'] }, 'PRODUCT1')
+          assert_includes(products.map { |r| r['id'] }, 'PRODUCT2')
+        end
+
+        def test_shows_no_search_results
+          Search::Settings.current.update_attributes!(terms_facets: %w(Color Size))
+          create_product(
+            id: 'PRODUCT1',
+            name: 'Pretty Nice Shirt',
+            filters:  { 'Size' => %w[Small Medium Large], 'Color' => 'Blue' },
+            variants: [{ sku: 'SKU', regular: 35.to_m }],
+            images: [{ image: product_image_file, option: 'Blue' }]
+          )
+
+          content = Content.for('search')
+          content.blocks.create!(
+            area: :results,
+            type: :text,
+            data: { text: 'global search test content' }
+          )
+          content.blocks.create!(
+            area: :no_results,
+            type: :text,
+            data: { text: 'no results test content' }
+          )
+
+          get storefront_api.search_path(q: 'grand')
+          result = JSON.parse(response.body)
+
+          assert(result['query_string'].present?)
+          assert(result.key?('message'))
+          assert(result.key?('redirect'))
+
+          content_blocks = result['content_blocks']
+          assert_equal(2, content_blocks.count)
+
+          assert_equal(0, result['total_results'])
+          assert_equal(0, result['facets'].count)
+
+          products = result['products']
+          assert_equal(0, products.count)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+module Workarea
+  module Api
+    module Storefront
+      class SystemContentIntegrationTest < IntegrationTest
+        include Workarea::Storefront::IntegrationTest
+
+        setup :set_content
+
+        def set_content
+          @content = Content.for('Layout')
+          @content.blocks.create!(
+            area: :header_promo,
+            type: :text,
+            data: { text: 'text' }
+          )
+          @content.blocks.create!(
+            area: :footer_navigation,
+            type: :text,
+            data: { text: 'text' }
+          )
+        end
+
+        def test_shows_categories
+          get storefront_api.system_content_path('layout')
+          result = JSON.parse(response.body)
+
+          assert_equal(@content.id.to_s, result['id'])
+          assert_equal(2, result['content_blocks'].count)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+module Workarea
+  module Api
+    module Storefront
+      class TaxonsIntegrationTest < IntegrationTest
+        setup :set_taxons
+
+        def set_taxons
+          @taxon = create_taxon(
+            name: 'Mens',
+            url: 'http://example.com/pages/mens'
+          )
+
+          @taxon.children.create!(name: 'Sale')
+        end
+
+        def test_show
+          get storefront_api.taxon_path(@taxon)
+          result = JSON.parse(response.body)
+
+          assert_equal(@taxon.id.to_s, result['taxon']['id'])
+          assert_equal(
+            'http://example.com/pages/mens',
+            result['taxon']['navigable_url']
+          )
+
+          assert_equal(1, result['children'].size)
+        end
+
+        def test_inactive_taxon
+          @taxon.update_attributes!(
+            url: nil,
+            navigable: create_page(active: false)
+          )
+
+          get storefront_api.taxon_path(@taxon)
+          refute(response.ok?)
+          assert_equal(404, response.status)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+module Workarea
+  module Api
+    module Storefront
+      class UserCartsIntegrationTest < IntegrationTest
+        include AuthenticationTest
+        include OrdersTest
+
+        setup :set_user, :set_product, :set_order
+
+        def set_user
+          @user = create_user(first_name: 'Ben', last_name: 'Crouse')
+          set_current_user(@user)
+        end
+
+        def set_product
+          @product = create_product(
+            name: 'Test Product',
+            variants: [
+              { sku: 'SKU1', regular: 5.to_m },
+              { sku: 'SKU2', regular: 6.to_m }
+            ]
+          )
+
+          create_inventory(id: 'SKU1', policy: 'standard', available: 2)
+        end
+
+        def set_order
+          @order = create_order(user_id: @user.id.to_s, email: @user.email)
+          add_item(@order, product_id: @product.id, sku: 'SKU1', quantity: 2)
+        end
+
+        def test_index_user_carts
+          get storefront_api.carts_path
+          result = JSON.parse(response.body)
+
+          assert_equal(@user.id.to_s, result['user_id'])
+          assert_equal(1, result['orders'].count)
+
+          order = result['orders'].first
+          assert_equal(@order.id, order['id'])
+        end
+
+        def test_new_cart_for_user
+          post storefront_api.carts_path
+          result = JSON.parse(response.body)
+
+          assert(result['id'].present?)
+          assert(result['user_id'].present?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+module Workarea
+  class User
+    class AuthenticationTokenTestCase < TestCase
+      setup :set_user
+
+      def set_user
+        @user = create_user
+      end
+
+      def test_authenticate
+        assert(AuthenticationToken.authenticate('asflkjasdflkjas').blank?)
+
+        auth = AuthenticationToken.create!(user: @user)
+        assert_equal(auth, AuthenticationToken.authenticate(auth.token))
+      end
+
+      def test_expired
+        auth = AuthenticationToken.create!(user: @user)
+        refute(auth.expired?)
+
+        expired = (Workarea.config.authentication_token_expiration + 1.day).from_now
+        travel_to expired
+
+        assert(auth.expired?)
+      end
+    end
+  end
+end

data/test/support/authentication_test.rb

@@ -0,0 +1,25 @@
+module Workarea
+  module Api
+    module Storefront
+      module AuthenticationTest
+        extend ActiveSupport::Concern
+
+        included do
+          delegate :encode_credentials, to: ActionController::HttpAuthentication::Token
+        end
+
+        def set_current_user(user)
+          Workarea::Api::Storefront::ApplicationController.subclasses.each do |klass|
+            if klass.method_defined?(:current_user)
+              klass.any_instance.stubs(:current_user).returns(user)
+            end
+
+            if klass.method_defined?(:authentication?)
+              klass.any_instance.stubs(:authentication?).returns(true)
+            end
+          end
+        end
+      end
+    end
+  end
+end