workarea-storefront 3.4.12

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

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class ContactFormIntegrationTest < Workarea::IntegrationTest
+      def test_inquiry_creation
+        Workarea.with_config do |config|
+          config.email_to = 'test@workarea.com'
+
+          post storefront.contact_path,
+            params: {
+              name: 'Ben Crouse',
+              email: 'bcrouse@workarea.com',
+              subject: 'orders',
+              order_id: 'ORDER123',
+              message: 'test message'
+            }
+
+          result = Inquiry.first
+          assert_equal('Ben Crouse', result.name)
+          assert_equal('bcrouse@workarea.com', result.email)
+          assert(result.subject.present?)
+          assert_equal('ORDER123', result.order_id)
+          assert_equal('test message', result.message)
+
+          last_email = ActionMailer::Base.deliveries.last
+          assert_includes(last_email.subject, 'Orders')
+          assert_includes(last_email.to, Workarea.config.email_to)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class ContentBlocksIntegrationTest < Workarea::IntegrationTest
+      def test_content_blocks_render_with_defaults
+        # For sample data
+        create_asset
+        create_taxon
+        create_product
+        create_category
+        create_page
+
+        content = Content.for('home_page')
+
+        Workarea.config.content_block_types.each do |block_type|
+          content.blocks.build(
+            type: block_type.slug,
+            data: block_type.defaults
+          )
+        end
+
+        content.save!
+
+        get storefront.root_path
+        assert(response.ok?)
+      end
+
+      def test_previewing_new_content_block
+        set_current_user(create_user(super_admin: true))
+
+        get storefront.new_content_block_path(
+          type_id: 'html',
+          content_id: create_content.id
+        )
+
+        assert(response.ok?)
+      end
+
+      def test_showing_a_content_block
+        set_current_user(create_user(super_admin: true))
+        content = create_content
+        block = content.blocks.build(
+          type: :html,
+          data: { 'html' => 'foo' }
+        )
+        content.save!
+
+        get storefront.content_block_path(block)
+        assert(response.ok?)
+      end
+
+      def test_showing_a_content_draft
+        set_current_user(create_user(super_admin: true))
+        content = create_content
+        block = content.blocks.build(
+          type: :html,
+          data: { 'html' => 'foo' }
+        )
+        content.save!
+
+        draft = Content::BlockDraft.create!(
+          block.attributes.merge('content_id' => content.id)
+        )
+
+        get storefront.draft_content_block_path(draft)
+        assert(response.ok?)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class CurrentCheckoutIntegrationTest < Workarea::IntegrationTest
+      class CurrentCheckoutController < Storefront::ApplicationController
+        def test
+          current_order.save if params[:save]
+          head :ok
+        end
+      end
+
+      setup do
+        Rails.application.routes.prepend do
+          get 'current_checkout_test', to: "#{CurrentCheckoutController.controller_path}#test"
+        end
+
+        Rails.application.reload_routes!
+      end
+
+      def test_current_order
+        get '/current_checkout_test'
+        assert(session[:order_id].blank?)
+
+        get '/current_checkout_test', params: { save: true }
+        assert(session[:order_id].present?)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class CurrentUserIntegrationTest < Workarea::IntegrationTest
+      def test_returns_admin_true_when_impersonating
+        admin_user = create_user(password: 'W3bl1nc!', super_admin: true)
+        non_admin = create_user
+
+        post storefront.login_path,
+          params: { email: admin_user.email, password: 'W3bl1nc!' }
+
+        get storefront.current_user_path(format: 'json')
+        results = JSON.parse(response.body)
+        assert(results['admin'])
+
+        post admin.impersonations_path, params: { user_id: non_admin.id }
+
+        get storefront.current_user_path(format: 'json')
+        results = JSON.parse(response.body)
+
+        assert(results['admin'], 'user is not admin')
+        assert_equal(ApplicationController.request_forgery_protection_token.to_s, results['csrf_param'])
+        assert(results['csrf_token'].present?, 'csrf token not found')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class EmailSignupsIntegrationTest < Workarea::IntegrationTest
+      def test_saves_a_sign_up
+        post storefront.email_signup_path,
+          params: { email: 'bcrouse@workarea.com' }
+
+        assert_redirected_to(storefront.root_path)
+        assert(flash[:success].present?)
+        assert_equal(1, Email::Signup.where(email: 'bcrouse@workarea.com').count)
+      end
+
+      def test_handles_a_sign_up_failure
+        post storefront.email_signup_path,
+          params: { email: 'bcrouse@workarea' }
+
+        assert_redirected_to(storefront.root_path)
+        assert(flash[:error].present?)
+        assert_equal(0, Email::Signup.count)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class ErrorsIntegrationTest < Workarea::IntegrationTest
+      setup :remove_error_static_files
+      teardown :move_error_static_files_back
+
+      def remove_error_static_files
+        %w(404 500).each do |type|
+          begin
+            FileUtils.mv(
+              Rails.root.join('public', "#{type}.html"),
+              Rails.root.join('public', "#{type}_tmp.html")
+            )
+
+          rescue Errno::ENOENT
+            # noop
+          end
+        end
+      end
+
+      def move_error_static_files_back
+        %w(404 500).each do |type|
+          begin
+            FileUtils.mv(
+              Rails.root.join('public', "#{type}_tmp.html"),
+              Rails.root.join('public', "#{type}.html")
+            )
+
+          rescue Errno::ENOENT
+            # noop
+          end
+        end
+      end
+
+      def test_custom_not_found
+        not_found = Content.for('Not Found')
+        not_found.blocks.build(
+          type: :html,
+          data: { html: 'Foo bar' }
+        )
+        not_found.save!
+
+        get storefront.not_found_path,
+          env: { 'action_dispatch.original_path' => 'foo' }
+
+        assert_equal(404, response.status)
+        assert_includes(response.body, 'Foo bar')
+      end
+
+      def test_custom_internal_error
+        internal_error = Content.for('Internal Server Error')
+        internal_error.blocks.build(
+          type: :html,
+          data: { html: 'Foo bar' }
+        )
+        internal_error.save!
+
+        error = RuntimeError.new('test')
+
+        get storefront.internal_error_path,
+          env: { 'action_dispatch.exception' => error }
+
+        assert_equal(500, response.status)
+        assert_equal(error, request.env['rack.exception'])
+        assert_includes(response.body, 'Foo bar')
+
+        get storefront.internal_error_path(format: :json),
+          env: { 'action_dispatch.exception' => error }
+
+        assert_equal(500, response.status)
+        assert_equal(error, request.env['rack.exception'])
+        assert_empty(response.body)
+      end
+
+      def test_on_demand_content_creation
+        get storefront.not_found_path,
+          env: { 'action_dispatch.original_path' => 'foo' }
+
+        assert_equal(404, response.status)
+        assert_includes(response.body, 'Not Found')
+
+        error = RuntimeError.new('test')
+        get storefront.internal_error_path,
+          env: { 'action_dispatch.exception' => error }
+
+        assert_equal(500, response.status)
+        assert_equal(error, request.env['rack.exception'])
+        assert_includes(response.body, 'Internal Server Error')
+      end
+
+      def test_redirects
+        page = create_page(slug: 'faq')
+        create_redirect(
+          path: storefront.product_path('foo-bar'),
+          destination: storefront.page_path(page)
+        )
+
+        get storefront.not_found_path,
+          env: {
+            'action_dispatch.original_path' => storefront.product_path('foo-bar')
+          }
+
+        assert_redirected_to(storefront.page_path(page))
+        assert_equal(301, response.status)
+
+        create_redirect(
+          path: storefront.product_path('foo-bar', foo: 'bar'),
+          destination: storefront.page_path(page, foo: 'bar')
+        )
+
+        get storefront.not_found_path,
+          env: {
+            'action_dispatch.original_path' => storefront.product_path('foo-bar', foo: 'bar')
+          }
+
+        assert_redirected_to(storefront.page_path(page, foo: 'bar'))
+        assert_equal(301, response.status)
+      end
+
+      def test_pwa_network_offline_error
+        offline = Content.for('Offline')
+        offline.blocks.build(
+          type: :html,
+          data: { html: 'Foo bar' }
+        )
+        offline.save!
+
+        get storefront.offline_path
+
+        assert_equal(200, response.status)
+        assert_includes(response.body, 'Foo bar')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class FaviconsIntegrationTest < Workarea::IntegrationTest
+      def test_rendering_favicon_tags
+        get storefront.root_path
+
+        assert_select('link[rel="icon"]')
+        assert_select('link[rel="manifest"]')
+        assert_select('meta[name="msapplication-config"]')
+        assert_select('meta[name="theme-color"]')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class GuestBrowsingIntegrationTest < Workarea::IntegrationTest
+      include Storefront::IntegrationTest
+
+      def test_checkout_with_guest_browsing
+        admin_user = create_user(password: 'W3bl1nc!', super_admin: true)
+
+        post storefront.login_path,
+          params: { email: admin_user.email, password: 'W3bl1nc!' }
+
+        post admin.guest_browsing_path
+
+        complete_checkout
+        order = Order.placed.first
+        assert_nil(order.user_id)
+        assert('admin', order.source)
+        assert(order.checkout_by_id, admin_user.id.to_s)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class HeadTagsIntegrationTest < Workarea::IntegrationTest
+      setup :set_config
+      teardown :reset_config
+
+      def set_config
+        @current = Workarea.config.per_page
+        Workarea.config.per_page = 1
+      end
+
+      def reset_config
+        Workarea.config.per_page = @current
+      end
+
+      def test_category_tags
+        filters = { color: ['Red'] }
+        products = Array.new(3) { create_product(filters: filters) }
+        category = create_category(
+          product_ids: products.map(&:id),
+          terms_facets: %w(color)
+        )
+        page = create_page
+
+        get storefront.page_path(page)
+        assert_select('link[rel=canonical]') do |elements|
+          assert_equal(1, elements.length)
+          assert_equal(storefront.page_url(page), elements.first['href'])
+        end
+
+        get storefront.root_path
+        assert_select('link[rel=canonical]') do |elements|
+          assert_equal(1, elements.length)
+          assert_equal(storefront.root_url, elements.first['href'])
+        end
+
+        get storefront.category_path(category)
+        assert_select('link[rel=canonical]') do |elements|
+          assert_equal(1, elements.length)
+          assert_equal(storefront.category_url(category), elements[0]['href'])
+        end
+        assert_select('link[rel=next]') do |elements|
+          assert_equal(1, elements.length)
+          assert_equal(storefront.category_url(category, page: 2), elements[0]['href'])
+        end
+        assert_select('link[rel=prev]', false)
+        assert_select('meta[name=robots]') do |elements|
+          assert_equal(2, elements.length)
+          assert_equal('noodp', elements[0]['content'])
+          assert_equal('index, follow', elements[1]['content'])
+        end
+
+        get storefront.category_path(category, page: 2)
+        assert_select('link[rel=canonical]') do |elements|
+          assert_equal(1, elements.length)
+          assert_equal(storefront.category_url(category, page: 2), elements[0]['href'])
+        end
+        assert_select('link[rel=next]') do |elements|
+          assert_equal(1, elements.length)
+          assert_equal(storefront.category_url(category, page: 3), elements[0]['href'])
+        end
+        assert_select('link[rel=prev]') do |elements|
+          assert_equal(1, elements.length)
+          assert_equal(storefront.category_url(category), elements[0]['href'])
+        end
+        assert_select('meta[name=robots]') do |elements|
+          assert_equal(2, elements.length)
+          assert_equal('noodp', elements[0]['content'])
+          assert_equal('noindex, follow', elements[1]['content'])
+        end
+
+        get storefront.category_path(category, page: 3)
+        assert_select('link[rel=canonical]') do |elements|
+          assert_equal(1, elements.length)
+          assert_equal(storefront.category_url(category, page: 3), elements[0]['href'])
+        end
+        assert_select('link[rel=next]', false)
+        assert_select('link[rel=prev]') do |elements|
+          assert_equal(1, elements.length)
+          assert_equal(storefront.category_url(category, page: 2), elements[0]['href'])
+        end
+        assert_select('meta[name=robots]') do |elements|
+          assert_equal(2, elements.length)
+          assert_equal('noodp', elements[0]['content'])
+          assert_equal('noindex, follow', elements[1]['content'])
+        end
+
+        get storefront.category_path(category, filters)
+        assert_select('link[rel=canonical]') do |elements|
+          assert_equal(1, elements.length)
+          assert_equal(storefront.category_url(category), elements[0]['href'])
+        end
+        assert_select('link[rel=next]') do |elements|
+          assert_equal(1, elements.length)
+          assert_equal(storefront.category_url(category, page: 2), elements[0]['href'])
+        end
+        assert_select('link[rel=prev]', false)
+        assert_select('meta[name=robots]') do |elements|
+          assert_equal(2, elements.length)
+          assert_equal('noodp', elements[0]['content'])
+          assert_equal('noindex, follow', elements[1]['content'])
+        end
+
+        get storefront.category_path(category, filters.merge(page: 2))
+        assert_select('link[rel=canonical]') do |elements|
+          assert_equal(1, elements.length)
+          assert_equal(storefront.category_url(category, page: 2), elements[0]['href'])
+        end
+        assert_select('link[rel=next]') do |elements|
+          assert_equal(1, elements.length)
+          assert_equal(storefront.category_url(category, page: 3), elements[0]['href'])
+        end
+        assert_select('link[rel=prev]') do |elements|
+          assert_equal(1, elements.length)
+          assert_equal(storefront.category_url(category), elements[0]['href'])
+        end
+        assert_select('meta[name=robots]') do |elements|
+          assert_equal(2, elements.length)
+          assert_equal('noodp', elements[0]['content'])
+          assert_equal('noindex, follow', elements[1]['content'])
+        end
+      end
+    end
+  end
+end