workarea-core 3.4.45 → 3.5.0.beta.1

data/test/models/workarea/segment/rules/tags_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+module Workarea
+  class Segment
+    module Rules
+      class TagsTest < TestCase
+        def test_qualifies?
+          metrics = Metrics::User.create!(id: 'bcrouse@workarea.com')
+
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          refute(Tags.new.qualifies?(visit))
+
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          refute(Tags.new(tags: %w(foo)).qualifies?(visit))
+
+          metrics.update!(tags: %w(bar))
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          refute(Tags.new(tags: %w(foo)).qualifies?(visit))
+
+          metrics.update!(tags: %w(foo))
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          assert(Tags.new(tags: %w(foo)).qualifies?(visit))
+        end
+      end
+    end
+  end
+end

data/test/models/workarea/segment/rules/traffic_referrer_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+module Workarea
+  class Segment
+    module Rules
+      class TrafficReferrerTest < TestCase
+        def test_qualifies?
+          visit = create_visit
+          refute(TrafficReferrer.new.qualifies?(visit))
+
+          visit = create_visit('HTTP_REFERER' => 'http://workarea.com/')
+          refute(TrafficReferrer.new.qualifies?(visit))
+
+          visit = create_visit('HTTP_REFERER' => 'https://www.google.com/')
+          assert(TrafficReferrer.new(source: 'google').qualifies?(visit))
+          assert(TrafficReferrer.new(source: ' Google').qualifies?(visit))
+          assert(TrafficReferrer.new(medium: 'Search').qualifies?(visit))
+          refute(TrafficReferrer.new(source: 'Facebook ').qualifies?(visit))
+          refute(TrafficReferrer.new(source: 'social').qualifies?(visit))
+
+          visit = create_visit('HTTP_REFERER' => 'https://www.facebook.com/')
+          refute(TrafficReferrer.new(source: ' Google').qualifies?(visit))
+          refute(TrafficReferrer.new(medium: 'search').qualifies?(visit))
+          assert(TrafficReferrer.new(source: 'facebook ').qualifies?(visit))
+          assert(TrafficReferrer.new(medium: 'Social').qualifies?(visit))
+          assert(TrafficReferrer.new(medium: 'Social', source: 'facebook|twitter').qualifies?(visit))
+        end
+      end
+    end
+  end
+end

data/test/models/workarea/segment_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+
+module Workarea
+  class SegmentTest < TestCase
+    def test_find_qualifying
+      one = create_segment(rules: [Segment::Rules::Orders.new(minimum: 1)])
+      two = create_segment(rules: [Segment::Rules::Orders.new(minimum: 2)])
+      three = create_segment(rules: [Segment::Rules::Orders.new(minimum: 3)])
+
+      metrics = Metrics::User.create!(id: 'bcrouse@workarea.com')
+
+      visit = create_visit(email: 'bcrouse@workarea.com')
+      assert(Segment.find_qualifying(visit).empty?)
+
+      metrics.update_attributes!(orders: 1)
+      visit = create_visit(email: 'bcrouse@workarea.com')
+      assert_equal([one], Segment.find_qualifying(visit))
+
+      metrics.update_attributes!(orders: 2)
+      visit = create_visit(email: 'bcrouse@workarea.com')
+      assert_equal([one, two], Segment.find_qualifying(visit))
+
+      metrics.update_attributes!(orders: 3)
+      visit = create_visit(email: 'bcrouse@workarea.com')
+      assert_equal([one, two, three], Segment.find_qualifying(visit))
+    end
+
+    def test_current
+      assert_equal([], Segment.current)
+
+      segment = create_segment
+      Segment.with_current(segment) { assert_equal([segment], Segment.current) }
+      assert_equal([], Segment.current)
+
+      Segment.with_current([segment]) { assert_equal([segment], Segment.current) }
+      assert_equal([], Segment.current)
+
+      assert_raises { Segment.with_current(segment) { raise 'foo' } }
+      assert_equal([], Segment.current)
+    end
+
+    def test_with_current_returns_the_value_from_the_block
+      segment = create_segment
+      result = Segment.with_current(segment) { 'foo' }
+      assert_equal('foo', result)
+    end
+
+    def test_qualifies
+      segment = create_segment(
+        rules: [
+          Segment::Rules::Orders.new(minimum: 2),
+          Segment::Rules::Sessions.new(minimum: 5)
+        ]
+      )
+
+      metrics = Metrics::User.create!(id: 'bcrouse@workarea.com')
+
+      visit = create_visit(email: 'bcrouse@workarea.com')
+      refute(segment.qualifies?(visit))
+
+      metrics.update_attributes!(orders: 2)
+      visit = create_visit(email: 'bcrouse@workarea.com')
+      refute(segment.qualifies?(visit))
+
+      visit = create_visit(email: 'bcrouse@workarea.com', sessions: 2)
+      refute(segment.qualifies?(visit))
+
+      visit = create_visit(email: 'bcrouse@workarea.com', sessions: 5)
+      assert(segment.qualifies?(visit))
+    end
+
+    def test_validates_max_segments
+      15.times { create_segment }
+
+      segment = Segment.new
+      refute(segment.valid?)
+      assert_includes(segment.errors[:base], t('workarea.errors.messages.max_allowed_segments'))
+    end
+  end
+end

data/test/models/workarea/segmentable_test.rb

@@ -0,0 +1,74 @@
+require 'test_helper'
+
+module Workarea
+  class SegmentableTest < TestCase
+    class Foo
+      include Mongoid::Document
+      include Releasable
+      include Segmentable
+    end
+
+    def test_active_by_segment
+      segment_one = create_segment(name: 'One')
+      segment_two = create_segment(name: 'Two')
+
+      model = Foo.create!(active: false, active_segment_ids: [])
+      refute(model.active?)
+
+      model.update!(active: true, active_segment_ids: [])
+      assert(model.active?)
+
+      model.update!(active_segment_ids: [segment_one.id])
+      assert(model.active?)
+      Segment.with_current { refute(model.active?) }
+      Segment.with_current(segment_one) { assert(model.active?) }
+      Segment.with_current(segment_two) { refute(model.active?) }
+      Segment.with_current(segment_one, segment_two) { assert(model.active?) }
+
+      model.update!(active_segment_ids: [segment_two.id])
+      assert(model.active?)
+      Segment.with_current { refute(model.active?) }
+      Segment.with_current(segment_one) { refute(model.active?) }
+      Segment.with_current(segment_two) { assert(model.active?) }
+      Segment.with_current(segment_one, segment_two) { assert(model.active?) }
+
+      model.update!(active_segment_ids: [segment_one.id, segment_two.id])
+      assert(model.active?)
+      Segment.with_current { refute(model.active?) }
+      Segment.with_current(segment_one) { assert(model.active?) }
+      Segment.with_current(segment_two) { assert(model.active?) }
+      Segment.with_current(segment_one, segment_two) { assert(model.active?) }
+    end
+
+    def test_segments_and_activate_with
+      segment_one = create_segment
+      segment_two = create_segment
+      release = create_release
+
+      model = Foo.create!(activate_with: release.id, active_segment_ids: [segment_one.id])
+      refute(model.reload.active?)
+
+      Segment.with_current do
+        refute(model.reload.active?)
+        release.as_current { refute(model.reload.active?) }
+      end
+
+      Segment.with_current(segment_one) do
+        refute(model.reload.active?)
+        release.as_current { assert(model.reload.active?) }
+      end
+
+      Segment.with_current(segment_two) do
+        refute(model.reload.active?)
+        release.as_current { refute(model.reload.active?) }
+      end
+
+      release.publish!
+      assert(model.reload.active?)
+
+      Segment.with_current { refute(model.reload.active?) }
+      Segment.with_current(segment_one) { assert(model.reload.active?) }
+      Segment.with_current(segment_two) { refute(model.reload.active?) }
+    end
+  end
+end

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

@@ -4,117 +4,115 @@ module Workarea
   class Shipping
     class AddressTest < TestCase
       def test_po_box_addresses
-        Workarea.with_config do |config|
-          address = Shipping::Address.new(
-            first_name: 'Ben',
-            last_name: 'Crouse',
-            street: '22 S. 3rd St.',
-            street_2: 'Second Floor',
-            city: 'Philadelphia',
-            region: 'PA',
-            postal_code: '19106',
-            country: 'US'
-          )
-
-          config.allow_shipping_address_po_box = false
-
-          po_boxes = [
-            'PO Box 123',
-            'P O box 123',
-            'P. O. Box 123',
-            'P.O.Box 123',
-            'post box 123',
-            'post office box 123',
-            'post office 123',
-            'P.O.B 123',
-            'P.O.B. 123',
-            'Post Office Bin 123',
-            'Postal Code 123',
-            'Post Box #123',
-            'Postal Box 123',
-            'P.O. Box 123',
-            'PO. Box 123',
-            'P.o box 123',
-            'Pobox 123',
-            'pob 123',
-            'pob123',
-            'pobox123',
-            'p.o. Box123',
-            'po-box123',
-            'p.o.-box 123',
-            'PO-Box 123',
-            'p-o-box 123',
-            'p-o box 123',
-            'box 123',
-            'Box123',
-            'Box-123'
-          ]
-
-          non_po_boxes = [
-            '123 Box Turtle Circle',
-            '123 Boxing Pass',
-            '123 Poblano Lane',
-            '123 P O Davis Drive',
-            '123 Postal Circle'
-          ]
-
-          po_boxes.each do |po_box|
-            address.street = po_box
-            refute(address.valid?)
-            refute(address.errors[:street].empty?)
-          end
-
-          address.street = '22 S. 3rd St'
-          po_boxes.each do |po_box|
-            address.street_2 = po_box
-            refute(address.valid?)
-            refute(address.errors[:street_2].empty?)
-          end
-
-          config.allow_shipping_address_po_box = true
-          address.street_2 = 'Second Floor'
-
-          po_boxes.each do |po_box|
-            address.street = po_box
-            assert(address.valid?)
-            refute(address.errors[:street].present?)
-          end
-
-          address.street = '22 S. 3rd St'
-          po_boxes.each do |po_box|
-            address.street_2 = po_box
-            assert(address.valid?)
-            refute(address.errors[:street_2].present?)
-          end
-
-          non_po_boxes.each do |non_po_box|
-            address.street = non_po_box
-            assert(address.valid?)
-            assert(address.errors[:street].empty?)
-          end
-
-          address.street = '22 S. 3rd St'
-          non_po_boxes.each do |non_po_box|
-            address.street_2 = non_po_box
-            assert(address.valid?)
-            assert(address.errors[:street_2].empty?)
-          end
-
-          config.allow_shipping_address_po_box = true
-          address.street_2 = 'Second Floor'
-
-          non_po_boxes.each do |non_po_box|
-            address.street = non_po_box
-            assert(address.valid?)
-            refute(address.errors[:street].present?)
-          end
-
-          address.street = '22 S. 3rd St'
-          non_po_boxes.each do |non_po_box|
-            address.street_2 = non_po_box
-            assert(address.valid?)
-            refute(address.errors[:street_2].present?)
-          end
+        address = Shipping::Address.new(
+          first_name: 'Ben',
+          last_name: 'Crouse',
+          street: '22 S. 3rd St.',
+          street_2: 'Second Floor',
+          city: 'Philadelphia',
+          region: 'PA',
+          postal_code: '19106',
+          country: 'US'
+        )
+
+        Workarea.config.allow_shipping_address_po_box = false
+
+        po_boxes = [
+          'PO Box 123',
+          'P O box 123',
+          'P. O. Box 123',
+          'P.O.Box 123',
+          'post box 123',
+          'post office box 123',
+          'post office 123',
+          'P.O.B 123',
+          'P.O.B. 123',
+          'Post Office Bin 123',
+          'Postal Code 123',
+          'Post Box #123',
+          'Postal Box 123',
+          'P.O. Box 123',
+          'PO. Box 123',
+          'P.o box 123',
+          'Pobox 123',
+          'pob 123',
+          'pob123',
+          'pobox123',
+          'p.o. Box123',
+          'po-box123',
+          'p.o.-box 123',
+          'PO-Box 123',
+          'p-o-box 123',
+          'p-o box 123',
+          'box 123',
+          'Box123',
+          'Box-123'
+        ]
+
+        non_po_boxes = [
+          '123 Box Turtle Circle',
+          '123 Boxing Pass',
+          '123 Poblano Lane',
+          '123 P O Davis Drive',
+          '123 Postal Circle'
+        ]
+
+        po_boxes.each do |po_box|
+          address.street = po_box
+          refute(address.valid?)
+          refute(address.errors[:street].empty?)
+        end
+
+        address.street = '22 S. 3rd St'
+        po_boxes.each do |po_box|
+          address.street_2 = po_box
+          refute(address.valid?)
+          refute(address.errors[:street_2].empty?)
+        end
+
+        Workarea.config.allow_shipping_address_po_box = true
+        address.street_2 = 'Second Floor'
+
+        po_boxes.each do |po_box|
+          address.street = po_box
+          assert(address.valid?)
+          refute(address.errors[:street].present?)
+        end
+
+        address.street = '22 S. 3rd St'
+        po_boxes.each do |po_box|
+          address.street_2 = po_box
+          assert(address.valid?)
+          refute(address.errors[:street_2].present?)
+        end
+
+        non_po_boxes.each do |non_po_box|
+          address.street = non_po_box
+          assert(address.valid?)
+          assert(address.errors[:street].empty?)
+        end
+
+        address.street = '22 S. 3rd St'
+        non_po_boxes.each do |non_po_box|
+          address.street_2 = non_po_box
+          assert(address.valid?)
+          assert(address.errors[:street_2].empty?)
+        end
+
+        Workarea.config.allow_shipping_address_po_box = true
+        address.street_2 = 'Second Floor'
+
+        non_po_boxes.each do |non_po_box|
+          address.street = non_po_box
+          assert(address.valid?)
+          refute(address.errors[:street].present?)
+        end
+
+        address.street = '22 S. 3rd St'
+        non_po_boxes.each do |non_po_box|
+          address.street_2 = non_po_box
+          assert(address.valid?)
+          refute(address.errors[:street_2].present?)
         end
       end
 

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