workarea-api-storefront 4.4.6

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

@@ -0,0 +1,84 @@
+require 'test_helper'
+
+module Workarea
+  module Api
+    module Storefront
+      class CategoriesIntegrationTest < IntegrationTest
+        setup :set_product
+        setup :set_category
+        setup :set_taxonomy
+        setup :set_content
+
+        def set_product
+          @product = create_product(
+            filters:  { size: %w[Small Medium Large], color: 'Blue' },
+            variants: [{ sku: 'SKU', details: { color: 'Blue' }, regular: 2.to_m }],
+            details: { size: 'Small', color: 'Red' },
+            images: [{ image: product_image_file, option: 'Blue' }]
+          )
+        end
+
+        def set_category
+          @category = create_category(
+            product_ids: [@product.id],
+            terms_facets: %w(Size Color)
+          )
+        end
+
+        def set_taxonomy
+          first_level = create_taxon(name: 'First Level')
+          @taxon = first_level.children.create!(navigable: @category)
+        end
+
+        def set_content
+          content = Content.for(@category)
+          content.blocks.build(
+            area: :above_results,
+            type: :text,
+            data: { text: 'text' }
+          )
+          content.blocks.build(
+            area: :below_results,
+            type: :text,
+            data: { text: 'text' }
+          )
+          content.save!
+        end
+
+        def test_shows_categories_index
+          create_category
+
+          get storefront_api.categories_path
+          result = JSON.parse(response.body)
+
+          assert_equal(2, result['categories'].size)
+        end
+
+        def test_shows_categories
+          get storefront_api.category_path(@category.slug)
+          result = JSON.parse(response.body)
+
+          assert_equal(@category.id.to_s, result['id'])
+
+          assert_equal(3, result['breadcrumbs'].count)
+          assert_equal(@taxon.id.to_s, result['breadcrumbs'].last['id'])
+
+          assert_equal(2, result['content_blocks'].count)
+
+          assert_equal(1, result['total_results'])
+
+          assert_equal(1, result['facets'].count)
+
+          product_result = result['products'].first
+          assert_equal(1, result['products'].count)
+          assert_equal(@product.id, product_result['id'])
+
+          processors = product_result['images'].first['urls'].map { |p| p['type'].to_sym }
+          processors.each do |processor|
+            refute_includes(Workarea.config.api_product_image_jobs_blacklist, processor)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,203 @@
+require 'test_helper'
+
+module Workarea
+  module Api
+    module Storefront
+      class CheckoutsIntegrationTest < IntegrationTest
+        include OrdersTest
+
+        setup :set_product, :set_order, :set_checkout_data
+
+        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
+          add_item(@order, product_id: @product.id, sku: 'SKU1', quantity: 2)
+        end
+
+        def set_checkout_data
+          create_shipping_service(name: 'Standard', rates: [{ price: 5.to_m }])
+          create_shipping_service(name: 'Express', rates: [{ price: 10.to_m }])
+          create_shipping_service(name: 'Overnight', rates: [{ price: 20.to_m }])
+        end
+
+        def address
+          {
+            first_name: 'Ben',
+            last_name: 'Crouse',
+            street: '22 S. 3rd St.',
+            street_2: 'Second Floor',
+            city: 'Philadelphia',
+            region: 'PA',
+            postal_code: '19106',
+            country: 'US'
+          }
+        end
+
+        def test_preventing_checkout_with_a_placed_order
+          order = create_placed_order
+
+          get storefront_api.cart_path(order)
+          refute(response.ok?)
+          assert_equal(404, response.status)
+
+          get storefront_api.checkout_path(order)
+          refute(response.ok?)
+          assert_equal(404, response.status)
+
+          patch storefront_api.checkout_path(order)
+          refute(response.ok?)
+          assert_equal(404, response.status)
+
+          post storefront_api.complete_checkout_path(order)
+          refute(response.ok?)
+          assert_equal(404, response.status)
+
+          get storefront_api.reset_checkout_path(order)
+          refute(response.ok?)
+          assert_equal(404, response.status)
+        end
+
+        def test_show
+          get storefront_api.checkout_path(@order)
+          results = JSON.parse(response.body)
+          order = results['order']
+
+          assert(order['id'].present?)
+          refute(order['user_id'].present?)
+
+          checkout = results['checkout']
+          assert(checkout['started_at'].present?)
+
+          assert(checkout['addresses'].present?)
+          refute(checkout['addresses']['complete'])
+
+          assert(checkout['shipping'].present?)
+          refute(checkout['shipping']['complete'])
+
+          assert(checkout['payment'].present?)
+          refute(checkout['payment']['complete'])
+        end
+
+        def test_update
+          patch storefront_api.checkout_path(@order),
+            params: {
+              email: 'test@workarea.com',
+              shipping_address: address,
+              billing_address: address,
+            }
+
+          results = JSON.parse(response.body)
+          order = results['order']
+          checkout = results['checkout']
+
+          assert(checkout['addresses']['complete'])
+          assert_equal('test@workarea.com', order['email'])
+
+          shipping_address = order['shipping_address']
+          assert(shipping_address.present?)
+          assert_equal('Ben', shipping_address['first_name'])
+          assert_equal('Crouse', shipping_address['last_name'])
+          assert_equal('22 S. 3rd St.', shipping_address['street'])
+          assert_equal('Second Floor', shipping_address['street_2'])
+          assert_equal('PA', shipping_address['region'])
+          assert_equal('US', shipping_address['country'])
+          assert_equal('19106', shipping_address['postal_code'])
+
+          billing_address = order['billing_address']
+          assert(billing_address.present?)
+          assert_equal('Ben', billing_address['first_name'])
+          assert_equal('Crouse', billing_address['last_name'])
+          assert_equal('22 S. 3rd St.', billing_address['street'])
+          assert_equal('Second Floor', billing_address['street_2'])
+          assert_equal('PA', billing_address['region'])
+          assert_equal('US', billing_address['country'])
+          assert_equal('19106', billing_address['postal_code'])
+
+          shipping_options = checkout['shipping']['shipping_options']
+          assert(shipping_options.present?)
+          assert_equal('Standard', shipping_options.first['name'])
+          assert_equal('Express', shipping_options.second['name'])
+          assert_equal('Overnight', shipping_options.third['name'])
+
+          patch storefront_api.checkout_path(order['id']),
+            params: { shipping_service: 'Express' }
+
+          checkout = JSON.parse(response.body)['checkout']
+          assert(checkout['shipping']['complete'])
+
+          assert_equal('Express', checkout['shipping']['shipping_service'])
+          assert_equal(1000, checkout['shipping']['shipping_total']['cents'])
+        end
+
+        def test_complete
+          patch storefront_api.checkout_path(@order),
+            params: {
+              email: 'test@workarea.com',
+              shipping_address: address,
+              billing_address: address,
+              shipping_service: 'Express',
+            }
+          result = JSON.parse(response.body)
+
+          assert(result['checkout']['shipping']['complete'])
+
+          post storefront_api.complete_checkout_path(result['order']['id']),
+            params: {
+              payment: 'new_card',
+              credit_card: {
+                number: '1',
+                month: '1',
+                year: Time.now.year + 1,
+                cvv: '999'
+              }
+            }
+          result = JSON.parse(response.body)
+
+          assert(result['order']['placed_at'])
+          assert_equal(2000, result['order']['pricing']['total_price']['cents'])
+
+          tender = result['order']['tenders'].first
+          assert_equal('credit_card', tender['type'])
+          assert_equal(2000, tender['amount']['cents'])
+
+          order = Order.first
+          assert_equal('storefront_api', order.source)
+        end
+
+        def test_reset
+          patch storefront_api.checkout_path(@order),
+            params: {
+              email: 'test@workarea.com',
+              shipping_address: address,
+              billing_address: address,
+            }
+
+          results = JSON.parse(response.body)
+          order = results['order']
+          checkout = results['checkout']
+
+          assert(checkout['addresses']['complete'])
+          started_at = checkout['started_at']
+          assert(started_at.present?)
+
+          get storefront_api.reset_checkout_path(order['id'])
+          checkout = JSON.parse(response.body)['checkout']
+
+          refute(checkout['addresses']['complete'])
+          refute_equal(started_at, checkout['started_at'])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+module Workarea
+  module Api
+    module Storefront
+      class ContactsIntegrationTest < IntegrationTest
+        setup :set_contact_params
+
+        def set_contact_params
+          @contact_params = {
+            name: 'Name',
+            email: 'email@example.com',
+            order_id: 'OrderID',
+            subject: :orders,
+            message: 'Message'
+          }
+        end
+
+        def test_create_inquiries
+          data = @contact_params
+          assert_difference 'Inquiry.count', 1 do
+            post storefront_api.contacts_path, params: data
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+module Workarea
+  module Api
+    module Storefront
+      class EmailSignupsIntegrationTest < IntegrationTest
+        setup :set_content
+
+        def set_content
+          page = Workarea::Storefront::EmailSignupsViewModel.new
+          page.content.blocks.create!(
+            type: :text,
+            data: { text: 'foo bar' }
+          )
+        end
+
+        def test_show_email_signups
+          get storefront_api.email_signups_path
+          result = JSON.parse(response.body)
+
+          result_block = result['content_blocks'].first
+          assert_equal('text', result_block['type'])
+          assert_equal('foo bar', result_block['data']['text'])
+        end
+
+        def test_create_email_signups
+          assert_difference 'Email::Signup.count', 2 do
+            post storefront_api.email_signups_path, params: { email: 'email@example.com' }
+            post storefront_api.email_signups_path, params: { email: 'email2@example.com' }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+module Workarea
+  module Api
+    module Storefront
+      class MenusIntegrationTest < IntegrationTest
+        include Workarea::Storefront::IntegrationTest
+
+        setup :set_navigation_menu
+
+        def set_navigation_menu
+          @menus = ['Men', 'Women', 'Children'].map do |name|
+            first_level = create_taxon(
+              name: name,
+              url: "http://example.com/#{name.downcase}"
+            )
+
+            second_level = first_level.children.create!(name: 'Sale')
+
+            menu = create_menu(taxon: first_level)
+
+            content = Content.for(menu)
+            content.blocks.create!(
+              type: 'taxonomy',
+              data: { 'start' => second_level.id }
+            )
+
+            menu
+          end
+
+          @menu = @menus.first
+        end
+
+        def test_lists_menus
+          get storefront_api.menus_path
+          result = JSON.parse(response.body)
+
+          assert_equal(@menus.count, result['menus'].count)
+        end
+
+        def test_shows_menus
+          get storefront_api.menu_path(@menu)
+          result = JSON.parse(response.body)
+
+          result_block = result['content_blocks'].first
+          assert_equal(@menu.id.to_s, result['id'])
+          assert_equal(1, result['content_blocks'].count)
+          assert_equal('taxonomy', result_block['type'])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+require 'test_helper'
+
+module Workarea
+  module Api
+    module Storefront
+      class OrdersIntegrationTest < IntegrationTest
+        include AuthenticationTest
+
+        setup :set_user
+        setup :set_order
+
+        def set_user
+          @user = create_user(first_name: 'Ben', last_name: 'Crouse')
+          set_current_user(@user)
+        end
+
+        def set_order
+          @order = begin
+            order = Order.new(user_id: @user.id, email: @user.email)
+
+            product = create_product(
+              name: 'Product One',
+              variants: [{ sku: 'PROD1', regular: 5.to_m }]
+            )
+            order.add_item(product_id: product.id, sku: 'PROD1', quantity: 2)
+
+            product = create_product(
+              name: 'Product Two',
+              variants: [{ sku: 'PROD2', regular: 10.to_m }]
+            )
+            order.add_item(product_id: product.id, sku: 'PROD2', quantity: 1)
+
+            product = create_product(
+              name: 'Product Three',
+              variants: [{ sku: 'PROD3', regular: 20.to_m }]
+            )
+            order.add_item(
+              product_id: product.id,
+              sku: 'PROD3',
+              quantity: 1,
+              customizations: { 'foo' => 'bar' }
+            )
+
+            complete_checkout(
+              order,
+              shipping_service: create_shipping_service(name: 'Express').name,
+              credit_card: {
+                number: '4111111111111111',
+                month: '3',
+                year: Time.now.year + 2,
+                cvv: '123'
+              }
+
+            )
+
+            fulfillment = Fulfillment.find(order.id)
+            fulfillment.ship_items(
+              '1Z',
+              [{ 'id' => order.items.first.id, 'quantity' => 2 }]
+            )
+
+            fulfillment.cancel_items(
+              [{ 'id' => order.items.second.id, 'quantity' => 1 }]
+            )
+
+            order
+          end
+        end
+
+        def test_index
+          get storefront_api.orders_path
+          result = JSON.parse(response.body)
+
+          assert_equal(@user.id.to_s, result['user_id'])
+          assert_equal(1, result['orders'].count)
+          assert_equal(@order.id.to_s, result['orders'].last['id'])
+        end
+
+        def test_show
+          get storefront_api.order_path(@order)
+          results = JSON.parse(response.body)
+          order = results['order']
+
+          assert_equal(@user.id.to_s, order['user_id'])
+          assert_equal(@order.id, order['id'])
+          assert(order['placed_at'].present?)
+
+          assert(order['shipping_address'].present?)
+          assert(order['shipping_service'].present?)
+
+          assert(order['billing_address'].present?)
+          assert_equal(1, order['tenders'].count)
+
+          pricing = order['pricing']
+          assert(pricing['shipping_total'].present?)
+          assert(pricing['tax_total'].present?)
+          assert(pricing['subtotal_price'].present?)
+          assert(pricing['total_price'].present?)
+          assert(pricing['paid_amount'].present?)
+
+          assert_equal(3, order['items'].count)
+          assert(order['items'].one? { |i| i['customizations'].present? })
+
+          fulfillment = results['fulfillment']
+          assert(fulfillment['status'].present?)
+          assert_equal(1, fulfillment['packages'].count)
+          assert(fulfillment['packages'].first['tracking_number'].present?)
+          assert_equal(1, fulfillment['packages'].first['items'].count)
+          assert_equal(1, fulfillment['pending_items'].count)
+          assert_equal(1, fulfillment['canceled_items'].count)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+module Workarea
+  module Api
+    module Storefront
+      class PagesIntegrationTest < IntegrationTest
+        setup :set_page
+        setup :set_taxonomy
+        setup :set_content
+
+        def set_page
+          @page = create_page
+        end
+
+        def set_taxonomy
+          first_level = create_taxon(
+            name: 'First Level'
+          )
+
+          @taxon = first_level.children.create!(navigable: @page)
+        end
+
+        def set_content
+          content = Content.for(@page)
+          content.blocks.create!(
+            area: :default,
+            type: :text,
+            data: { text: 'text' }
+          )
+          content.blocks.create!(
+            area: :default,
+            type: :image,
+            data: { image: asset.id.to_s, alt: 'Foo' }
+          )
+        end
+
+        def asset
+          @asset ||= create_asset
+        end
+
+        def test_shows_pages
+          get storefront_api.page_path(@page)
+          result = JSON.parse(response.body)
+
+          assert_equal(@page.id.to_s, result['id'])
+          assert_equal(3, result['breadcrumbs'].count)
+          assert_equal(@taxon.id.to_s, result['breadcrumbs'].last['id'])
+          assert_equal(2, result['content_blocks'].count)
+
+          block = result['content_blocks'].last
+          assert(block['data']['image_url'])
+          assert(block['html'])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+module Workarea
+  module Api
+    module Storefront
+      class PasswordResetsIntegrationTest < Workarea::IntegrationTest
+        def test_forgotten_passwords_emails
+          user = create_user(password: 'p@assword!')
+
+          assert_difference 'User::PasswordReset.count', 1 do
+            post storefront_api.password_resets_path,
+              params: { email: user.email }
+          end
+
+          assert_equal(user, User::PasswordReset.first.user)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+module Workarea
+  module Api
+    module Storefront
+      class ProductsIntegrationTest < Workarea::IntegrationTest
+        setup :set_product
+
+        def set_product
+          @product = create_product(
+            filters:  { size: %w[Small Medium Large], color: 'Blue' },
+            variants: [{ sku: 'SKU1', details: { color: 'Blue' }, regular: 2.to_m },
+                       { sku: 'SKU2', details: { color: 'Red' }, regular: 3.to_m }],
+            details: { size: 'Small', color: 'Red' },
+            images: [{ image: product_image_file, option: 'Blue' }]
+          )
+
+          # for recommendations
+          create_top_products(results: [{ 'product_id' => create_product.id }])
+        end
+
+        def test_shows_products
+          get storefront_api.product_path(@product)
+          results = JSON.parse(response.body)
+          product = results['product']
+          recommendations = results['recommendations']
+
+          assert_equal(1, recommendations.size)
+
+          assert_equal(@product.id, product['id'])
+          assert_equal(2, product['variants'].count)
+          assert_equal(200.0, product['original_min_price']['cents'])
+
+          processors = product['images'].first['urls'].map { |p| p['type'].to_sym }
+          processors.each do |processor|
+            refute_includes(Workarea.config.api_product_image_jobs_blacklist, processor)
+          end
+        end
+
+        def test_shows_products_with_sku_selected
+          get storefront_api.product_path(@product, sku: 'SKU2')
+          result = JSON.parse(response.body)['product']
+
+          assert_equal(@product.id, result['id'])
+          assert_equal(300.0, result['original_min_price']['cents'])
+        end
+      end
+    end
+  end
+end