workarea-core 3.4.44 → 3.5.0.beta.1

data/test/models/workarea/shipping/sku_test.rb

@@ -6,25 +6,21 @@ module Workarea
       def test_length_units
         sku = create_shipping_sku
 
-        Workarea.with_config do |config|
-          config.shipping_options = { units: :imperial }
-          assert_equal(:inches, sku.length_units)
+        Workarea.config.shipping_options = { units: :imperial }
+        assert_equal(:inches, sku.length_units)
 
-          config.shipping_options = { units: :metric }
-          assert_equal(:centimeters, sku.length_units)
-        end
+        Workarea.config.shipping_options = { units: :metric }
+        assert_equal(:centimeters, sku.length_units)
       end
 
       def test_weight_units
         sku = create_shipping_sku
 
-        Workarea.with_config do |config|
-          config.shipping_options = { units: :imperial }
-          assert_equal(:ounces, sku.weight_units)
+        Workarea.config.shipping_options = { units: :imperial }
+        assert_equal(:ounces, sku.weight_units)
 
-          config.shipping_options = { units: :metric }
-          assert_equal(:grams, sku.weight_units)
-        end
+        Workarea.config.shipping_options = { units: :metric }
+        assert_equal(:grams, sku.weight_units)
       end
     end
   end

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

@@ -4,22 +4,14 @@ module Workarea
   class User
     class PasswordResetTest < TestCase
       def user
-        @user ||= create_user(email: 'one@workarea.com')
+        @user ||= create_user
       end
 
       def test_setup!
-        2.times do
-          PasswordReset.setup!(user.email)
+        PasswordReset.setup!(user.email)
 
-          assert_equal(1, PasswordReset.count)
-          assert_equal(user.id, PasswordReset.first.user_id)
-        end
-
-        two = create_user(email: 'two@workarea.com')
-        PasswordReset.setup!('two@workarea.com')
-
-        assert_equal(2, PasswordReset.count)
-        assert_equal(two.id, PasswordReset.last.user_id)
+        assert_equal(1, PasswordReset.count)
+        assert_equal(user.id, PasswordReset.first.user_id)
       end
 
       def test_complete

data/test/models/workarea/user_test.rb

@@ -280,24 +280,27 @@ module Workarea
     end
 
     def test_admins_have_more_advanced_password_requirements
-      Workarea.with_config do |config|
-        config.password_strength = :weak
+      Workarea.config.password_strength = :weak
 
-        user = User.new(admin: false, password: 'password').tap(&:valid?)
-        assert(user.errors[:password].blank?)
+      user = User.new(admin: false, password: 'password').tap(&:valid?)
+      assert(user.errors[:password].blank?)
 
-        user = User.new(admin: true, password: 'password').tap(&:valid?)
-        assert(user.errors[:password].present?)
+      user = User.new(admin: true, password: 'password').tap(&:valid?)
+      assert(user.errors[:password].present?)
 
-        user = User.new(admin: true, password: 'xykrDQXT]9Ai7XEXfe').tap(&:valid?)
-        assert(user.errors[:password].blank?)
-      end
+      user = User.new(admin: true, password: 'xykrDQXT]9Ai7XEXfe').tap(&:valid?)
+      assert(user.errors[:password].blank?)
     end
 
     def test_admin_permissions_revoked_when_no_longer_admin
       user = create_user(admin: true, releases_access: true)
       user.update_attributes!(admin: false)
       refute(user.releases_access?)
+
+      user = create_user(super_admin: true, releases_access: true)
+      user.update!(super_admin: false)
+      refute(user.admin?)
+      refute(user.releases_access?)
     end
 
     def test_status_email_recipients_only_admins
@@ -306,7 +309,7 @@ module Workarea
 
       status_email_recipients = User.status_email_recipients
       assert_equal(1, status_email_recipients.size)
-      assert_equal(admin.email, status_email_recipients.first)
+      assert_equal(admin, status_email_recipients.first)
     end
   end
 end

data/test/queries/workarea/admin_search_query_wrapper_test.rb

@@ -60,31 +60,27 @@ module Workarea
     def test_scroll
       50.times { |i| create_redirect(path: "/#{i}", destination: '/bar') }
 
-      Workarea.with_config do |config|
-        config.per_page = 5
-
-        query = AdminSearchQueryWrapper.new(
-          model_type: 'Workarea::Navigation::Redirect'
-        )
-
-        count = 0
-        passes = 0
-        query.scroll { |results| count += results.size; passes += 1 }
-        assert_equal(50, count)
-        assert_equal(10, passes)
-
-        config.per_page = 500
-
-        query = AdminSearchQueryWrapper.new(
-          model_type: 'Workarea::Navigation::Redirect'
-        )
-
-        count = 0
-        passes = 0
-        query.scroll { |results| count += results.size; passes += 1 }
-        assert_equal(50, count)
-        assert_equal(1, passes)
-      end
+      query = AdminSearchQueryWrapper.new(
+        model_type: 'Workarea::Navigation::Redirect',
+        per_page: 5
+      )
+
+      count = 0
+      passes = 0
+      query.scroll { |results| count += results.size; passes += 1 }
+      assert_equal(50, count)
+      assert_equal(10, passes)
+
+      query = AdminSearchQueryWrapper.new(
+        model_type: 'Workarea::Navigation::Redirect',
+        per_page: 500
+      )
+
+      count = 0
+      passes = 0
+      query.scroll { |results| count += results.size; passes += 1 }
+      assert_equal(50, count)
+      assert_equal(1, passes)
     end
   end
 end

data/test/queries/workarea/categorization_test.rb

@@ -84,5 +84,54 @@ module Workarea
       assert_equal(0, categorization.size)
       assert_equal([], categorization.to_models)
     end
+
+    def test_finding_categories_based_on_current_release
+      release = create_release(publish_at: 1.day.from_now)
+      category_one = create_category
+      category_two = create_category(product_ids: [@product.id])
+
+      release.as_current do
+        category_one.update!(product_ids: [@product.id])
+        assert_equal(
+          [category_two.id.to_s, category_one.id.to_s],
+          Categorization.new(@product).to_a
+        )
+      end
+
+      release.changesets.destroy_all
+      category_one.reload.update!(product_ids: [@product.id])
+
+      release.as_current do
+        category_one.update!(product_ids: [])
+        assert_equal([category_two.id.to_s], Categorization.new(@product).to_a)
+      end
+
+      create_release(publish_at: 2.days.from_now).as_current do
+        assert_equal([category_two.id.to_s], Categorization.new(@product).to_a)
+      end
+    end
+
+    def test_finding_rule_categories_based_on_current_release
+      bar = create_product(name: 'Bar')
+      category_one = create_category(product_rules: [{ name: 'search', operator: 'equals', value: 'foo' }])
+      category_two = create_category(product_rules: [{ name: 'search', operator: 'equals', value: 'bar' }])
+
+      assert_equal([category_one.id.to_s], Categorization.new(@product).queries)
+      assert_equal([category_two.id.to_s], Categorization.new(bar).queries)
+
+      release = create_release
+      release.as_current do
+        category_one.product_rules.first.update!(name: 'search', operator: 'equals', value: 'bar')
+
+        assert_equal([], Categorization.new(@product).queries)
+        assert_equal(
+          [category_two.id.to_s, category_one.id.to_s],
+          Categorization.new(bar).queries
+        )
+      end
+
+      assert_equal([category_one.id.to_s], Categorization.new(@product).queries)
+      assert_equal([category_two.id.to_s], Categorization.new(bar).queries)
+    end
   end
 end

data/test/queries/workarea/featured_categorization_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+module Workarea
+  class FeaturedCategorizationTest < TestCase
+    include TestCase::Workers
+    include TestCase::SearchIndexing
+
+    setup :set_product
+
+    def set_product
+      @product = create_product
+    end
+
+    def test_all
+      release = create_release(publish_at: 1.day.from_now)
+      category_one = create_category
+      category_two = create_category(product_ids: [@product.id])
+
+      release.as_current do
+        category_one.update!(product_ids: [@product.id])
+        assert_equal(
+          [category_two, category_one],
+          FeaturedCategorization.new(@product.id).to_a
+        )
+      end
+
+      release.changesets.destroy_all
+      category_one.reload.update!(product_ids: [@product.id])
+
+      release.as_current do
+        category_one.update!(product_ids: [])
+        assert_equal([category_two], FeaturedCategorization.new(@product.id).to_a)
+      end
+
+      create_release(publish_at: 2.days.from_now).as_current do
+        assert_equal([category_two], FeaturedCategorization.new(@product.id).to_a)
+      end
+    end
+
+    def test_categories_affected_by_current_release
+      create_category
+      assert_empty(FeaturedCategorization.new(@product.id).categories_affected_by_current_release)
+
+      category_one = create_category
+      release_one = create_release(publish_at: 1.day.from_now)
+      release_one.as_current do
+        category_one.update!(product_ids: [@product.id])
+
+        categorization = FeaturedCategorization.new(@product.id)
+        assert_equal([category_one], categorization.categories_affected_by_current_release)
+        assert(categorization.categories_affected_by_current_release.first.featured_product?(@product.id))
+      end
+
+      release_two = create_release(publish_at: 2.days.from_now)
+      release_two.as_current do
+        category_one.update!(product_ids: ['foo'])
+
+        categorization = FeaturedCategorization.new(@product.id)
+        assert_equal([category_one], categorization.categories_affected_by_current_release)
+        refute(categorization.categories_affected_by_current_release.first.featured_product?(@product.id))
+      end
+
+      assert_empty(FeaturedCategorization.new(@product.id).categories_affected_by_current_release)
+    end
+  end
+end

data/test/queries/workarea/order_cancellation_metrics_test.rb

@@ -0,0 +1,203 @@
+require 'test_helper'
+
+module Workarea
+  class OrderCancellationMetricsTest < IntegrationTest
+    setup :set_models
+
+    def set_models
+      create_life_cycle_segments
+      @product_one = create_product(
+        name: 'Foo 1',
+        variants: [{ sku: 'SKU1', regular: 5.to_m, tax_code: '001' }]
+      )
+
+      @product_two = create_product(
+        name: 'Foo 2',
+        variants: [{ sku: 'SKU2', regular: 6.to_m, tax_code: '001' }]
+      )
+
+      shipping_service = create_shipping_service(rates: [{ price: 5.to_m }])
+
+      @category = create_category(product_ids: [@product_one.id])
+      @search = Navigation::SearchResults.new(q: 'foo')
+      @taxon = create_taxon(navigable: @category)
+      @menu = create_menu(taxon: @taxon)
+
+      @order = Order.new(
+        email: 'bcrouse@workarea.com',
+        promo_codes: ['foo'],
+        segment_ids: [Segment::FirstTimeVisitor.instance.id],
+        items: [
+          { product_id: @product_one.id, sku: 'SKU1', quantity: 2, via: @category.to_gid_param },
+          { product_id: @product_two.id, sku: 'SKU2', quantity: 1, via: @search.to_gid_param }
+        ]
+      )
+
+      create_payment_profile(store_credit: 6.to_m, reference: @order.id)
+
+      Metrics::User.save_order(email: 'bcrouse@workarea.com', revenue: 10.to_m)
+
+      create_tax_category(code: '001', rates: [{ percentage: 0.06, country: 'US' }])
+      complete_checkout(@order, shipping_service: shipping_service.name)
+    end
+
+    def test_sales_data
+      metrics = OrderCancellationMetrics.new(@order)
+
+      assert_equal(1, metrics.sales_data[:cancellations])
+      assert_equal(3, metrics.sales_data[:units_canceled])
+      assert_equal(-21.96.to_m, metrics.sales_data[:refund])
+      assert_equal(-21.96.to_m, metrics.sales_data[:revenue])
+
+      metrics = OrderCancellationMetrics.new(
+        @order,
+        item_values: { @order.items.first.id.to_s => { quantity: 1, amount: 4.0 } },
+        shipping_value: 2.0
+      )
+
+      assert_equal(1, metrics.sales_data[:cancellations])
+      assert_equal(1, metrics.sales_data[:units_canceled])
+      assert_equal(-6, metrics.sales_data[:refund])
+      assert_equal(-6, metrics.sales_data[:revenue])
+    end
+
+    def test_products
+      metrics = OrderCancellationMetrics.new(@order)
+
+      assert_equal(2, metrics.products.size)
+
+      assert_equal(2, metrics.products[@product_one.id][:units_canceled])
+      assert_equal(-10.6.to_m, metrics.products[@product_one.id][:refund])
+      assert_equal(-10.6.to_m, metrics.products[@product_one.id][:revenue])
+
+      assert_equal(1, metrics.products[@product_two.id][:units_canceled])
+      assert_equal(-6.36.to_m, metrics.products[@product_two.id][:refund])
+      assert_equal(-6.36.to_m, metrics.products[@product_two.id][:revenue])
+
+      metrics = OrderCancellationMetrics.new(
+        @order,
+        item_values: { @order.items.first.id.to_s => { quantity: 1, amount: 4.0 } },
+      )
+
+      assert_equal(1, metrics.products.size)
+
+      assert_equal(1, metrics.products[@product_one.id][:units_canceled])
+      assert_equal(-4, metrics.products[@product_one.id][:refund])
+      assert_equal(-4, metrics.products[@product_one.id][:revenue])
+    end
+
+    def test_categories
+      metrics = OrderCancellationMetrics.new(@order)
+
+      assert_equal(1, metrics.categories.size)
+      assert_equal(2, metrics.categories[@category.id.to_s][:units_canceled])
+      assert_equal(-10.6.to_m, metrics.categories[@category.id.to_s][:refund])
+      assert_equal(-10.6.to_m, metrics.categories[@category.id.to_s][:revenue])
+
+      metrics = OrderCancellationMetrics.new(
+        @order,
+        item_values: { @order.items.first.id.to_s => { quantity: 1, amount: 4.0 } },
+      )
+
+      assert_equal(1, metrics.categories.size)
+      assert_equal(1, metrics.categories[@category.id.to_s][:units_canceled])
+      assert_equal(-4, metrics.categories[@category.id.to_s][:refund])
+      assert_equal(-4, metrics.categories[@category.id.to_s][:revenue])
+    end
+
+    def test_searches
+      metrics = OrderCancellationMetrics.new(@order)
+
+      assert_equal(1, metrics.searches.size)
+      query_id = @search.query_string.id
+
+      assert_equal(1, metrics.searches[query_id][:units_canceled])
+      assert_equal(-6.36.to_m, metrics.searches[query_id][:refund])
+      assert_equal(-6.36.to_m, metrics.searches[query_id][:revenue])
+
+      metrics = OrderCancellationMetrics.new(
+        @order,
+        item_values: { @order.items.first.id.to_s => { quantity: 1, amount: 4.0 } },
+      )
+      assert_equal(0, metrics.searches.size)
+
+      metrics = OrderCancellationMetrics.new(
+        @order,
+        item_values: { @order.items.second.id.to_s => { quantity: 1, amount: 4.0 } },
+      )
+
+      assert_equal(1, metrics.searches.size)
+      query_id = @search.query_string.id
+
+      assert_equal(1, metrics.searches[query_id][:units_canceled])
+      assert_equal(-4, metrics.searches[query_id][:refund])
+      assert_equal(-4, metrics.searches[query_id][:revenue])
+    end
+
+    def test_skus
+      metrics = OrderCancellationMetrics.new(@order)
+
+      assert_equal(2, metrics.skus.size)
+
+      assert_equal(2, metrics.skus['SKU1'][:units_canceled])
+      assert_equal(-10.6.to_m,  metrics.skus['SKU1'][:refund])
+      assert_equal(-10.6.to_m,  metrics.skus['SKU1'][:revenue])
+
+      assert_equal(1, metrics.skus['SKU2'][:units_canceled])
+      assert_equal(-6.36.to_m, metrics.skus['SKU2'][:refund])
+      assert_equal(-6.36.to_m, metrics.skus['SKU2'][:revenue])
+
+      metrics = OrderCancellationMetrics.new(
+        @order,
+        item_values: { @order.items.first.id.to_s => { quantity: 1, amount: 4.0 } },
+      )
+
+      assert_equal(1, metrics.skus.size)
+
+      assert_equal(1, metrics.skus['SKU1'][:units_canceled])
+      assert_equal(-4,  metrics.skus['SKU1'][:refund])
+      assert_equal(-4,  metrics.skus['SKU1'][:revenue])
+    end
+
+    def test_menus
+      metrics = OrderCancellationMetrics.new(@order)
+      assert_equal(1, metrics.menus.size)
+
+      assert_equal(2, metrics.menus[@menu.id.to_s][:units_canceled])
+      assert_equal(-10.6.to_m, metrics.menus[@menu.id.to_s][:refund])
+      assert_equal(-10.6.to_m, metrics.menus[@menu.id.to_s][:revenue])
+
+      metrics = OrderCancellationMetrics.new(
+        @order,
+        item_values: { @order.items.first.id.to_s => { quantity: 1, amount: 4.0 } },
+      )
+
+      assert_equal(1, metrics.menus.size)
+
+      assert_equal(1, metrics.menus[@menu.id.to_s][:units_canceled])
+      assert_equal(-4, metrics.menus[@menu.id.to_s][:refund])
+      assert_equal(-4, metrics.menus[@menu.id.to_s][:revenue])
+    end
+
+    def test_segments_data
+      metrics = OrderCancellationMetrics.new(@order)
+      segment = Segment::FirstTimeVisitor.instance
+
+      assert_equal(1, metrics.segments[segment.id][:cancellations])
+      assert_equal(3, metrics.segments[segment.id][:units_canceled])
+      assert_equal(-21.96.to_m, metrics.segments[segment.id][:refund])
+      assert_equal(-21.96.to_m, metrics.segments[segment.id][:revenue])
+
+      metrics = OrderCancellationMetrics.new(
+        @order,
+        item_values: { @order.items.first.id.to_s => { quantity: 1, amount: 4.0 } },
+        shipping_value: 2.0
+      )
+
+      assert_equal(1, metrics.segments[segment.id][:cancellations])
+      assert_equal(1, metrics.segments[segment.id][:units_canceled])
+      assert_equal(-6, metrics.segments[segment.id][:refund])
+      assert_equal(-6, metrics.segments[segment.id][:revenue])
+    end
+  end
+end