workarea-wish_lists 3.0.4

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

@@ -0,0 +1,211 @@
+require 'test_helper'
+
+module Workarea
+  class Catalog::Customizations::Foo < Catalog::Customizations
+    customized_fields :foo, :baz
+    validates_presence_of :foo
+  end
+
+  module Storefront
+    class WishListsIntegrationTest < Workarea::IntegrationTest
+      setup :user, :product
+
+      def user
+        @user ||= create_user(email: 'test@workarea.com', password: 'w3bl1nc')
+      end
+
+      def wish_list
+        @wish_list ||= WishList.for_user(user.id)
+      end
+
+      def product
+        @product ||= create_product(
+          name: 'Integration Product',
+          variants: [{ sku: 'SKU1', regular: 10.to_m }]
+        )
+      end
+
+      def login
+        post storefront.login_path,
+             params: {
+               email: 'test@workarea.com',
+               password: 'w3bl1nc'
+             }
+      end
+
+      def test_update
+        login
+
+        patch storefront.update_users_wish_list_path,
+              params: { privacy: 'shared' }
+
+        wish_list.reload
+        assert(wish_list.shared?)
+
+        patch storefront.update_users_wish_list_path,
+              params: { privacy: 'private' }
+
+        wish_list.reload
+        assert(wish_list.private?)
+      end
+
+      def test_update_item_quantity
+        login
+
+        post storefront.add_to_users_wish_list_path,
+             params: {
+               product_id: product.id,
+               sku:        product.skus.first,
+               quantity:   1
+             }
+
+        assert_equal(1, wish_list.quantity)
+
+        patch storefront.update_item_users_wish_list_path(wish_list.items.first),
+              params: { quantity: 3 }
+
+        wish_list.reload
+        assert_equal(3, wish_list.quantity)
+      end
+
+      def test_add_item_with_customizations
+        login
+
+        product.update!(customizations: 'foo')
+
+        assert_difference -> { wish_list.quantity } do
+          post storefront.add_to_users_wish_list_path,
+               params: {
+                 product_id: product.id,
+                 sku:        product.skus.first,
+                 quantity:   1,
+                 foo:        'bar',
+                 baz:        'bat'
+               }
+          wish_list.reload
+        end
+
+        assert_redirected_to(storefront.users_wish_list_path)
+        assert(wish_list.items.last.customizations.present?)
+      end
+
+      def test_add_item
+        login
+
+        post storefront.add_to_users_wish_list_path,
+             params: {
+               product_id: product.id,
+               sku:        product.skus.first,
+               quantity:   1
+             }
+
+        assert_equal(product.id, wish_list.items.first.product_id)
+        assert_equal(product.skus.first, wish_list.items.first.sku)
+        assert_equal(1, wish_list.items.first.quantity)
+      end
+
+      def test_add_item_after_login
+        post storefront.add_to_users_wish_list_path,
+             params: {
+               product_id: product.id,
+               sku:        product.skus.first,
+               quantity:   1
+             }
+
+        login
+        get storefront.users_wish_list_path
+
+        assert_equal(1, wish_list.quantity)
+        assert_equal(product.id, wish_list.items.first.product_id)
+        assert_equal(product.skus.first, wish_list.items.first.sku)
+        assert_equal(1, wish_list.items.first.quantity)
+      end
+
+      def test_remove_item
+        login
+
+        post storefront.add_to_users_wish_list_path,
+             params: {
+               product_id: product.id,
+               sku:        product.skus.first,
+               quantity:   1
+             }
+
+        delete storefront.remove_from_users_wish_list_path,
+               params: { sku: product.skus.first }
+
+        assert_equal(0, wish_list.quantity)
+      end
+
+      def test_cannot_add_out_of_stock_products_from_wish_list_to_cart
+        inventory = create_inventory(
+          id: 'SKU1',
+          policy: 'standard',
+          available: 1
+        )
+
+        login
+
+        post storefront.add_to_users_wish_list_path,
+          params: {
+            product_id: product.id,
+            sku:        product.skus.first,
+            quantity:   1
+          }
+
+        inventory.update_attributes(available: 0)
+
+        assert_equal(product.id, wish_list.items.first.product_id)
+        assert_equal(product.skus.first, wish_list.items.first.sku)
+        assert_equal(1, wish_list.items.first.quantity)
+
+        get storefront.users_wish_list_path
+        assert_select '.grid__cell' do
+          assert_select('p[class="unavailable"]', true)
+        end
+
+        post storefront.cart_items_path,
+          params: {
+            product_id: wish_list.items.first.product_id,
+            sku: wish_list.items.first.sku,
+            quantity: 1
+          }
+
+        assert(response.ok?)
+
+        order = Order.first
+        order.reload
+        assert_equal(0, order.quantity)
+      end
+
+      def test_back_out_of_moving_to_wish_list_as_guest
+        post storefront.cart_items_path, params: {
+          product_id: product.id,
+          sku: product.skus.first,
+          quantity: 1
+        }
+        order = Order.last
+        item = order.items.first
+
+        assert_response(:success)
+        refute_empty(order.items)
+
+        post storefront.from_cart_users_wish_list_path(item_id: item.id)
+
+        assert_redirected_to(storefront.login_path)
+        refute_empty(order.reload.items)
+        assert_equal(item.id.to_s, session[:wish_list_item_id])
+
+        login
+
+        assert_redirected_to(storefront.users_wish_list_path)
+
+        follow_redirect!
+
+        assert_response(:success)
+        refute(session.key?(:wish_list_item_id))
+        assert_empty(order.reload.items)
+      end
+    end
+  end
+end

data/test/models/workarea/wish_list/public_search_test.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+
+module Workarea
+  class WishList
+    class PublicSearchTest < TestCase
+      setup :wish_list, :nameless_wish_list
+
+      def email
+        'test@workarea.com'
+      end
+
+      def first
+        'Ben'
+      end
+
+      def last
+        'Crouse'
+      end
+
+      def full_name
+        [first, last].join(' ')
+      end
+
+      def other_email
+        'test-again@workarea.com'
+      end
+
+      def another_email
+        'test-other@workarea.com'
+      end
+
+      def wish_list
+        @wish_list ||= create_wish_list(
+          email:      email,
+          name:       full_name,
+          first_name: first,
+          last_name:  last,
+          location:   'Philadelphia PA 19106'
+        )
+      end
+
+      def nameless_wish_list
+        @nameless_wish_list ||= create_wish_list(
+          email:      another_email,
+          name: another_email,
+          first_name: '',
+          last_name: '',
+          location:   'Philadelphia PA 19106'
+        )
+      end
+
+      def test_results
+        search = Workarea::WishList::PublicSearch.new(full_name)
+        assert_equal([wish_list], search.results.to_a)
+
+        search = Workarea::WishList::PublicSearch.new(another_email)
+        refute_empty(search.results)
+
+        search = Workarea::WishList::PublicSearch.new('bogus@example.com')
+        assert_empty(search.results)
+
+        search = Workarea::WishList::PublicSearch.new(email)
+        assert_equal([wish_list], search.results.to_a)
+
+        search = Workarea::WishList::PublicSearch.new(email)
+        assert_equal([wish_list], search.results.to_a)
+
+        search = Workarea::WishList::PublicSearch.new(full_name, 'Philadelphia')
+        assert_equal([wish_list], search.results.to_a)
+
+        search = Workarea::WishList::PublicSearch.new('bogus')
+        assert(search.results.to_a.empty?)
+
+        wish_list.update_attributes(privacy: 'private')
+        assert(Workarea::WishList::PublicSearch.new(full_name).results.empty?)
+
+        wish_list.update_attributes(privacy: 'shared')
+        assert(Workarea::WishList::PublicSearch.new(full_name).results.empty?)
+      end
+    end
+  end
+end

data/test/models/workarea/wish_list_test.rb

@@ -0,0 +1,158 @@
+require 'test_helper'
+
+module Workarea
+  class WishListTest < TestCase
+    def user
+      @user ||= create_user(
+        first_name: 'Foo',
+        last_name: 'Bar',
+        email: 'test@workarea.com',
+        addresses: [{
+          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 wish_list
+      @wish_list ||= WishList.new(user_id: user.id)
+    end
+
+    def order
+      @order ||= Workarea::Order.new(email: 'test@workarea.com')
+    end
+
+    def test_creation
+      WishList.destroy_all
+
+      wish_list = WishList.for_user(user.id)
+
+      assert_equal('Foo', wish_list.first_name)
+      assert_equal('Bar', wish_list.last_name)
+      assert_equal('Foo Bar', wish_list.name)
+      assert_equal('Philadelphia PA US 19106', wish_list.location)
+      assert_equal('test@workarea.com', wish_list.email)
+
+      existing_wish_list = WishList.for_user(user.id)
+      assert_equal(wish_list, existing_wish_list)
+    end
+
+    def test_find_by_token
+      token = 'kjh23r98b'
+      wish_list.update_attributes(token: token)
+      assert_equal(wish_list, WishList.find_by_token(token))
+
+      assert_raise(Workarea::WishList::InvalidToken) { WishList.find_by_token(nil) }
+
+      wish_list.update_attributes(token: 'kjh23r98b')
+      assert_raise(Workarea::WishList::InvalidToken) { WishList.find_by_token('sdkg12gaweb') }
+
+      token = 'kjh23r98b'
+      wish_list.update_attributes(token: token, privacy: 'private')
+      assert_raise(Workarea::WishList::InvalidToken) { WishList.find_by_token(token) }
+    end
+
+    def test_find_products
+      wish_list.add_item('1234', 'SKU1', 1)
+      assert_equal(['1234'], Workarea::WishList.find_products(user.id))
+    end
+
+    def test_named
+      create_wish_list(name: '')
+      create_wish_list(name: 'Zac Owen')
+
+      assert_equal(1, Workarea::WishList.named.size)
+      create_wish_list(name: 'Foo Bar', email: 'test@test.com')
+      assert_equal(2, Workarea::WishList.named.size)
+    end
+
+    def test_public
+      wish_list.update_attributes(privacy: 'public')
+
+      assert(wish_list.public?)
+      refute(wish_list.shared?)
+      refute(wish_list.private?)
+    end
+
+    def test_shared
+      wish_list.update_attributes(privacy: 'shared')
+
+      refute(wish_list.public?)
+      assert(wish_list.shared?)
+      refute(wish_list.private?)
+    end
+
+    def test_private
+      wish_list.update_attributes(privacy: 'private')
+
+      refute(wish_list.public?)
+      refute(wish_list.shared?)
+      assert(wish_list.private?)
+    end
+
+    def test_add_item
+      product_id = '1234'
+      sku = 'SKU'
+
+      wish_list.add_item(product_id, sku, 2)
+      assert_equal(2, wish_list.quantity)
+      assert_equal(product_id, wish_list.items.last.product_id)
+      assert_equal(sku, wish_list.items.last.sku)
+      assert_equal(2, wish_list.items.last.quantity)
+
+      wish_list.add_item(product_id, sku, 2)
+      assert_equal(1, wish_list.items.length)
+      assert_equal(4, wish_list.items.last.quantity)
+    end
+
+    def test_add_item_with_customizations
+      product = create_product(customizations: 'unit')
+      sku = 'SKU'
+
+      assert(wish_list.add_item(product.id, sku, 2, {}, foo: 'bar'))
+      assert_equal(2, wish_list.quantity)
+      assert_equal(product.id, wish_list.items.last.product_id)
+      assert_equal(sku, wish_list.items.last.sku)
+      assert_equal(2, wish_list.items.last.quantity)
+      assert(wish_list.items.last.customizations.present?)
+      assert_equal('bar', wish_list.items.last.customizations[:foo])
+
+      wish_list.add_item(product.id, sku, 2, {}, foo: 'bar')
+      assert_equal(1, wish_list.items.length)
+      assert_equal(4, wish_list.items.last.quantity)
+      assert(wish_list.items.last.customizations.present?)
+      assert_equal('bar', wish_list.items.last.customizations[:foo])
+
+      wish_list.add_item(product.id, sku, 2, {}, foo: 'baz')
+      assert_equal(2, wish_list.items.length)
+      assert(wish_list.items.last.customizations.present?)
+      assert_equal('baz', wish_list.items.last.customizations[:foo])
+    end
+
+    def test_mark_item_purchased
+      order.items.build(product_id: '1234', sku: 'SKU', quantity: 1)
+
+      item = wish_list.items.build(product_id: '1234', sku: 'SKU', quantity: 1)
+
+      wish_list.mark_item_purchased(item.sku, item.quantity)
+      assert(wish_list.unpurchased_items.empty?)
+      assert_includes(wish_list.purchased_items, item)
+      assert_equal(1, wish_list.items.first.received)
+    end
+
+    def test_remove_item
+      sku = 'SKU'
+      item = wish_list.items.build(product_id: '1234', sku: sku, quantity: 2)
+
+      assert_equal(2, wish_list.quantity)
+      wish_list.remove_item(sku)
+      assert_equal(0, wish_list.quantity)
+    end
+  end
+end