workarea-api 4.4.6

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

@@ -0,0 +1,149 @@
+require 'test_helper'
+
+module Workarea
+  module Api
+    module Storefront
+      class CartItemsIntegrationTest < IntegrationTest
+        include OrdersTest
+        include Workarea::Storefront::CatalogCustomizationTestClass
+
+        setup :set_product, :set_order
+
+        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
+        end
+
+        def test_create
+          post storefront_api.cart_items_path(@order),
+            params: {
+              product_id: @product.id,
+              sku: @product.skus.first,
+              quantity: 1
+            }
+
+          results = JSON.parse(response.body)
+          item = results['item']
+          order = results['order']
+
+          assert_equal(1, order['items'].count)
+          assert_equal(1, item['quantity'])
+          assert_equal(@product.id, item['product_id'])
+          assert_equal(@product.skus.first, item['sku'])
+        end
+
+        def test_create_with_limited_inventory
+          post storefront_api.cart_items_path(@order),
+            params: {
+              product_id: @product.id,
+              sku: @product.skus.first,
+              quantity: 3
+            }
+
+          results = JSON.parse(response.body)
+          item = results['item']
+          order = results['order']
+
+          assert_equal(1, order['items'].count)
+          assert_equal(2, item['quantity'])
+
+          messages = JSON.parse(response.headers['X-Flash-Messages'])
+          assert(messages['error'].present?)
+        end
+
+        def test_create_with_inactive_sku
+          @product.variants.first.update_attributes!(active: false)
+
+          post storefront_api.cart_items_path(@order),
+            params: {
+              product_id: @product.id,
+              sku: @product.skus.first,
+              quantity: 1
+            }
+
+          results = JSON.parse(response.body)
+          assert_equal(0, results['order']['items'].count)
+
+          messages = JSON.parse(response.headers['X-Flash-Messages'])
+          assert(messages['info'].present?)
+        end
+
+        def test_create_with_customizations
+          @product.update_attributes(customizations: 'foo_cust')
+
+          post storefront_api.cart_items_path(@order),
+            params: {
+              product_id: @product.id,
+              sku: @product.skus.first,
+              quantity: 1,
+              foo: 'Test',
+              bar: 'This'
+            }
+          result = JSON.parse(response.body)
+
+          assert_equal(1, result['order']['items'].count)
+          assert_equal(
+            { 'foo' => 'Test', 'bar' => 'This' },
+            result['item']['customizations']
+          )
+        end
+
+        def test_create_with_invalid_customizations
+          @product.update_attributes(customizations: 'foo_cust')
+
+          post storefront_api.cart_items_path(@order),
+            params: {
+              product_id: @product.id,
+              sku: @product.skus.first,
+              quantity: 1,
+              foo: 'Test'
+            }
+
+          result = JSON.parse(response.body)
+
+          assert_equal(0, result['order']['items'].count)
+
+          messages = JSON.parse(response.headers['X-Flash-Messages'])
+          assert(messages['error'].present?)
+        end
+
+        def test_update
+          add_item(@order, product_id: @product.id, sku: 'SKU1', quantity: 1)
+
+          patch storefront_api.cart_item_path(@order, @order.items.first),
+            params: { sku: 'SKU2', quantity: 3 }
+
+          results = JSON.parse(response.body)
+          item = results['item']
+          order = results['order']
+
+          assert_equal(1, order['items'].count)
+          assert_equal(3, item['quantity'])
+          assert_equal(@product.id, item['product_id'])
+          assert_equal(@product.skus.last, item['sku'])
+          assert_equal(1800, order['pricing']['total_price']['cents'])
+        end
+
+        def test_destroy
+          add_item(@order, product_id: @product.id, sku: 'SKU1', quantity: 1)
+
+          delete storefront_api.cart_item_path(@order, @order.items.first)
+          result = JSON.parse(response.body)
+
+          assert_equal(0, result['order']['items'].count)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+require 'test_helper'
+
+module Workarea
+  module Api
+    module Storefront
+      class CartsIntegrationTest < IntegrationTest
+        include AuthenticationTest
+        include OrdersTest
+
+        setup :set_product, :set_order
+
+        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 test_new_cart
+          post storefront_api.carts_path
+          result = JSON.parse(response.body)
+
+          assert(result['id'].present?)
+          refute(result['user_id'].present?)
+        end
+
+        def test_show
+          get storefront_api.cart_path(@order)
+          result = JSON.parse(response.body)
+
+          assert_equal(@order.id, result['id'])
+          assert_equal(1, result['items'].count)
+          assert_equal(2, result['items'].first['quantity'])
+        end
+
+        def test_invalid_user
+          user = create_user
+          auth = user.authentication_tokens.create!
+
+          # don't allow authenticated users to grab guest checkouts
+          get storefront_api.cart_path(@order),
+            headers: { 'HTTP_AUTHORIZATION' => encode_credentials(auth.token) }
+
+          refute(response.ok?)
+          assert_equal(404, response.status)
+
+          # don't allow users to grab other users's checkouts
+          other_user = create_user
+          @order.update_attributes!(user_id: other_user.id)
+
+          get storefront_api.cart_path(@order),
+            headers: { 'HTTP_AUTHORIZATION' => encode_credentials(auth.token) }
+
+          refute(response.ok?)
+          assert_equal(404, response.status)
+
+          # don't allow anonymous users to grab other users's checkouts
+          get storefront_api.cart_path(@order)
+          refute(response.ok?)
+          assert_equal(401, response.status)
+        end
+
+        def test_check_inventory
+          add_item(@order, product_id: @product.id, sku: 'SKU1', quantity: 2)
+
+          get storefront_api.cart_path(@order)
+          result = JSON.parse(response.body)
+
+          messages = JSON.parse(response.headers['X-Flash-Messages'])
+          assert(messages['error'].present?)
+
+          assert_equal(2, result['items'].first['quantity'])
+        end
+
+        def test_purchasable_items
+          @product.variants.first.update_attributes!(active: false)
+
+          get storefront_api.cart_path(@order)
+          result = JSON.parse(response.body)
+
+          messages = JSON.parse(response.headers['X-Flash-Messages'])
+          assert(messages['info'].present?)
+
+          assert(result['items'].blank?)
+        end
+
+        def test_add_promo_code
+          create_order_total_discount(promo_codes: %w(TESTCODE))
+
+          post storefront_api.add_promo_code_to_cart_path(@order),
+            params: { promo_code: 'TESTCODE' }
+          result = JSON.parse(response.body)
+
+          assert_equal(@order.id, result['id'])
+          assert_equal(%w(TESTCODE), result['promo_codes'])
+          assert_equal(
+            'Order Total Discount',
+            result['pricing']['price_adjustments'].first['description']
+          )
+        end
+      end
+    end
+  end
+end

data/storefront/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/storefront/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/storefront/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/storefront/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/storefront/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