workarea-core 3.4.45 → 3.5.0.beta.1

data/test/models/workarea/search/admin/content_asset_test.rb

@@ -19,34 +19,32 @@ module Workarea
         end
 
         def test_placeholders
-          Workarea.with_config do |config|
-            config.image_placeholder_image_name = 'foo.jpg'
-            config.open_graph_placeholder_image_name = 'bar.jpg'
-            config.favicon_placeholder_image_name = 'baz.jpg'
-
-            image_placeholder = create_asset(
-              name: 'Image',
-              file_name: config.image_placeholder_image_name,
-            )
-
-            open_graph_placeholder = create_asset(
-              name: 'Open Graph',
-              file_name: config.open_graph_placeholder_image_name,
-            )
-
-            favicon_placeholder = create_asset(
-              name: 'Favicon',
-              file_name: config.favicon_placeholder_image_name
-            )
-
-            image_result = ContentAsset.new(image_placeholder)
-            open_graph_result = ContentAsset.new(open_graph_placeholder)
-            favicon_result = ContentAsset.new(favicon_placeholder)
-
-            refute(image_result.should_be_indexed?)
-            refute(open_graph_result.should_be_indexed?)
-            refute(favicon_result.should_be_indexed?)
-          end
+          Workarea.config.image_placeholder_image_name = 'foo.jpg'
+          Workarea.config.open_graph_placeholder_image_name = 'bar.jpg'
+          Workarea.config.favicon_placeholder_image_name = 'baz.jpg'
+
+          image_placeholder = create_asset(
+            name: 'Image',
+            file_name: Workarea.config.image_placeholder_image_name,
+          )
+
+          open_graph_placeholder = create_asset(
+            name: 'Open Graph',
+            file_name: Workarea.config.open_graph_placeholder_image_name,
+          )
+
+          favicon_placeholder = create_asset(
+            name: 'Favicon',
+            file_name: Workarea.config.favicon_placeholder_image_name
+          )
+
+          image_result = ContentAsset.new(image_placeholder)
+          open_graph_result = ContentAsset.new(open_graph_placeholder)
+          favicon_result = ContentAsset.new(favicon_placeholder)
+
+          refute(image_result.should_be_indexed?)
+          refute(open_graph_result.should_be_indexed?)
+          refute(favicon_result.should_be_indexed?)
         end
       end
     end

data/test/models/workarea/search/order_text_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+module Workarea
+  module Search
+    class OrderTextTest < TestCase
+      def test_discount_text
+        shipping_discount = create_shipping_discount
+        order_discount = create_order_total_discount
+        product = create_product
+        order = create_order
+        order.add_item(
+          product_id: product.id,
+          sku: product.skus.first,
+          quantity: 1
+        )
+        order.items.first.adjust_pricing(
+          data: { 'discount_id' => order_discount.id.to_s }
+        )
+        order.save!
+
+        shipping = create_shipping(order_id: order.id.to_s)
+        shipping.adjust_pricing(
+          data: { 'discount_id' => shipping_discount.id.to_s }
+        )
+        shipping.save!
+
+        text = Search::OrderText.new(order)
+
+        assert_includes(text.shippings, shipping)
+        assert_includes(text.discount_text, order_discount.id.to_s)
+        assert_includes(text.discount_text, shipping_discount.id.to_s)
+      end
+    end
+  end
+end

data/test/models/workarea/search/storefront/category_query_test.rb

@@ -0,0 +1,81 @@
+require 'test_helper'
+
+module Workarea
+  module Search
+    class Storefront
+      class CategoryQueryTest < TestCase
+        include TestCase::SearchIndexing
+
+        setup :set_models
+
+        def set_models
+          @product = create_product(name: 'Foo')
+          @category = create_category(
+            product_rules: [
+              { name: 'search', operator: 'equals', value: 'foo' }
+            ]
+          )
+
+          IndexProduct.perform(@product)
+        end
+
+        def test_adds_a_category_to_percolator
+          assert(CategoryQuery.new(@category).create)
+          assert_equal([@category.id.to_s], CategoryQuery.find_by_product(@product))
+        end
+
+        def test_does_not_add_a_category_without_rules
+          category = create_category(product_rules: [])
+          CategoryQuery.new(category).create
+          assert_equal([], CategoryQuery.find_by_product(@product))
+        end
+
+        def test_products_that_dont_exist_in_the_index
+          assert(CategoryQuery.new(@category).create)
+          product = create_product(name: 'Foo bar')
+
+          result = CategoryQuery.find_by_product(product)
+          assert_equal(1, result.length)
+          assert_equal(@category.id.to_s, result.first)
+        end
+
+        def test_removes_the_category_from_the_percolator
+          assert(CategoryQuery.new(@category).create)
+          CategoryQuery.new(@category).delete
+          assert_equal([], CategoryQuery.find_by_product(@product))
+        end
+
+        def test_returns_over_ten_categories_in_percolator
+          11.times do
+            category = create_category(
+              product_rules: [
+                { name: 'search', operator: 'equals', value: '*' }
+              ]
+            )
+
+            CategoryQuery.new(category).create
+          end
+
+          assert_equal(11, CategoryQuery.find_by_product(@product).size)
+        end
+
+        def test_product_missing_from_storefront_index
+          Storefront.delete_indexes!
+          assert_empty(CategoryQuery.find_by_product(@product))
+        end
+
+        def test_finding_a_product_with_current_release
+          create_release.as_current do
+            @product.update!(name: 'Bar')
+            IndexProduct.perform(@product)
+            assert_equal([], CategoryQuery.find_by_product(@product))
+
+            @category.product_rules.first.update!(value: 'bar')
+            CategoryQuery.new(@category).update
+            assert_equal([@category.id.to_s], CategoryQuery.find_by_product(@product))
+          end
+        end
+      end
+    end
+  end
+end

data/test/models/workarea/search/storefront/product/categories_test.rb

@@ -5,89 +5,29 @@ module Workarea
     class Storefront
       class Product
         class CategoriesTest < TestCase
-          setup :set_models
-          setup :setup_indexes
+          include TestCase::SearchIndexing
 
-          def set_models
-            @product = create_product(name: 'Foo')
-            @category = create_category(
+          def test_includes_featured_category_ids_the_product_has
+            product = create_product(name: 'Foo')
+            category = create_category(
               product_rules: [
                 { name: 'search', operator: 'equals', value: 'foo' }
               ]
             )
-          end
-
-          def setup_indexes
-            Storefront.reset_indexes!
-            IndexProduct.perform(@product)
-          end
 
-          def test_adds_a_category_to_percolator
-            assert(Product.add_category(@category))
-            assert_equal([@category.id.to_s], Product.find_categories(@product))
-          end
+            IndexProduct.perform(product)
+            CategoryQuery.new(category).create
 
-          def test_does_not_add_a_category_without_rules
-            category = create_category(product_rules: [])
-            Product.add_category(category)
-            assert_equal([], Product.find_categories(@product))
-          end
-
-          def test_products_that_dont_exist_in_the_index
-            assert(Product.add_category(@category))
-            product = create_product(name: 'Foo bar')
-
-            result = Product.find_categories(product)
-            assert_equal(1, result.length)
-            assert_equal(@category.id.to_s, result.first)
-          end
-
-          def test_removes_the_category_from_the_percolator
-            assert(Product.add_category(@category))
-            Product.delete_category(@category.id)
-            assert_equal([], Product.find_categories(@product))
-          end
+            category_1 = create_category(product_ids: [product.id])
+            category_2 = create_category(product_ids: [product.id])
+            category_3 = create_category(product_ids: [product.id])
 
-          def test_returns_over_ten_categories_in_percolator
-            11.times do
-              Product.add_category(
-                create_category(
-                  product_rules: [
-                    {
-                      name: 'search',
-                      operator: 'equals',
-                      value: '*'
-                    }
-                  ]
-                )
-              )
-            end
-
-            assert_equal(11, Product.find_categories(@product).size)
-          end
-
-          def test_includes_featured_category_ids_the_product_has
-            Product.add_category(@category)
-
-            category_1 = create_category(product_ids: [@product.id])
-            category_2 = create_category(product_ids: [@product.id])
-            category_3 = create_category(product_ids: [@product.id])
-
-            results = Product.new(@product).category_id
+            results = Product.new(product).category_id
             assert_equal(3, results.length)
             assert_includes(results, category_1.id)
             assert_includes(results, category_2.id)
             assert_includes(results, category_3.id)
           end
-
-          def test_product_missing_from_storefront_index
-            Storefront.delete_indexes!
-
-            search_model = Product.new(@product)
-
-            assert(search_model.destroy)
-            assert_empty(Product.find_categories(@product))
-          end
         end
       end
     end

data/test/models/workarea/search/storefront/product_test.rb

@@ -4,11 +4,6 @@ module Workarea
   module Search
     class Storefront
       class ProductTest < IntegrationTest
-        def test_save
-          Product.any_instance.expects(:save).once
-          create_product(variants: [])
-        end
-
         def test_sku_returns_only_skus_that_have_inventory
           inventory = create_inventory(
             id: 'SKU1',
@@ -94,13 +89,17 @@ module Workarea
 
           travel_to Time.zone.local(2018, 12, 5)
 
-          Workarea.with_config do |config|
-            config.score_decay = 0.5
-            config.sorting_score_ttl = 1.year
+          Workarea.config.score_decay = 0.5
+          Workarea.config.sorting_score_ttl = 1.year
+
+          search_model = Product.new(product)
+          assert_equal(1.75, search_model.orders_score)
+        end
 
-            search_model = Product.new(product)
-            assert_equal(1.75, search_model.orders_score)
-          end
+        def test_product_missing_from_storefront_index
+          product = create_product
+          Storefront.delete_indexes!
+          assert(Product.new(product).destroy)
         end
       end
     end

data/test/models/workarea/search/storefront_test.rb

@@ -7,20 +7,8 @@ module Workarea
         model = create_product(active: false)
         refute(Storefront.new(model).active[:now])
 
-        model.update_attributes!(active: true)
+        model.update!(active: true)
         assert(Storefront.new(model).active[:now])
-
-        model.update_attributes!(active: false)
-        release = create_release
-
-        Release.with_current(release.id) do
-          model.update_attributes!(active: true)
-        end
-
-        model.reload
-        results = Storefront.new(model).active
-        refute(results[:now])
-        assert(results[release.id.to_s])
       end
     end
   end

data/test/models/workarea/segment/life_cycle_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+module Workarea
+  class Segment
+    class LifeCycleTest < TestCase
+      class FooSegment < Segment
+        include LifeCycle
+        self.default_rules = [Rules::Orders.new(maximum: 0)]
+      end
+
+      def test_cannot_destroy
+        life_cycle = FooSegment.instance # create it
+
+        assert_no_difference 'Segment.count' do
+          refute(life_cycle.destroy)
+        end
+
+        assert_nothing_raised do
+          life_cycle.reload
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+module Workarea
+  class Segment
+    module Rules
+      class BrowserInfoTest < TestCase
+        def test_qualifies?
+          refute(BrowserInfo.new.qualifies?(create_visit))
+
+          visit = create_visit('HTTP_USER_AGENT' => 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0.2 Safari/605.1.15')
+          refute(BrowserInfo.new(general: %w(chrome)).qualifies?(visit))
+          assert(BrowserInfo.new(general: %w(safari)).qualifies?(visit))
+          refute(BrowserInfo.new(device: %w(mobile)).qualifies?(visit))
+          assert(BrowserInfo.new(device: %w(unknown)).qualifies?(visit))
+          refute(BrowserInfo.new(platform: %w(android)).qualifies?(visit))
+          assert(BrowserInfo.new(platform: %w(mac)).qualifies?(visit))
+          refute(BrowserInfo.new(general: %w(chrome), device: %w(mobile)).qualifies?(visit))
+          assert(BrowserInfo.new(general: %w(safari), device: %w(mobile)).qualifies?(visit))
+
+          visit = create_visit('HTTP_USER_AGENT' => 'Mozilla/5.0 (iPad; U; CPU OS 3_2 like Mac OS X; en-us) AppleWebKit/531.21.10 (KHTML, like Gecko) Version/4.0.4 Mobile/7B334b Safari/531.21.10')
+          refute(BrowserInfo.new(general: %w(chrome)).qualifies?(visit))
+          assert(BrowserInfo.new(general: %w(safari)).qualifies?(visit))
+          refute(BrowserInfo.new(device: %w(mobile)).qualifies?(visit))
+          assert(BrowserInfo.new(device: %w(ipad)).qualifies?(visit))
+          refute(BrowserInfo.new(platform: %w(android)).qualifies?(visit))
+          assert(BrowserInfo.new(platform: %w(ios)).qualifies?(visit))
+          refute(BrowserInfo.new(general: %w(chrome), platform: %w(mobile)).qualifies?(visit))
+          assert(BrowserInfo.new(general: %w(chrome), platform: %w(ios)).qualifies?(visit))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+module Workarea
+  class Segment
+    module Rules
+      class GeolocationOptionTest < TestCase
+        def test_search
+          assert_equal([GeolocationOption['US-PA']], GeolocationOption.search('penn'))
+          assert_equal([GeolocationOption['US-PA']], GeolocationOption.search('Penn'))
+          assert_equal([GeolocationOption['CA']], GeolocationOption.search('cana'))
+          assert_equal([GeolocationOption['CA']], GeolocationOption.search('CaNa'))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+module Workarea
+  class Segment
+    module Rules
+      class GeolocationTest < TestCase
+        def test_qualifies?
+          refute(Geolocation.new.qualifies?(create_visit))
+
+          visit = create_visit('HTTP_GEOIP_REGION' => 'PA')
+          refute(Geolocation.new(locations: %w(NJ)).qualifies?(visit))
+          assert(Geolocation.new(locations: %w(pa)).qualifies?(visit))
+          assert(Geolocation.new(locations: %w(PA)).qualifies?(visit))
+          assert(Geolocation.new(locations: %w(NJ PA)).qualifies?(visit))
+          refute(Geolocation.new(locations: %w(NJ NY)).qualifies?(visit))
+
+          visit = create_visit(
+            'HTTP_GEOIP_REGION' => 'PA',
+            'HTTP_GEOIP_CITY_COUNTRY_CODE' => 'US'
+          )
+          assert(Geolocation.new(locations: %w(Pennsylvania)).qualifies?(visit))
+          assert(Geolocation.new(locations: %w(US-PA)).qualifies?(visit))
+
+          visit = create_visit('HTTP_GEOIP_CITY' => 'Philadelphia')
+          assert(Geolocation.new(locations: %w(philadelphia)).qualifies?(visit))
+          assert(Geolocation.new(locations: %w(Philadelphia)).qualifies?(visit))
+          assert(Geolocation.new(locations: %w(Philadelphia US)).qualifies?(visit))
+          refute(Geolocation.new(locations: %w(Harrisburg)).qualifies?(visit))
+          refute(Geolocation.new(locations: %w(Harrisburg PA)).qualifies?(visit))
+          assert(Geolocation.new(locations: %w(Philadelphia Harrisburg)).qualifies?(visit))
+          refute(Geolocation.new(locations: %w(Pittsburgh Harrisburg)).qualifies?(visit))
+
+          visit = create_visit('HTTP_GEOIP_CITY_COUNTRY_CODE' => 'US')
+          refute(Geolocation.new(locations: %w(CA)).qualifies?(visit))
+          assert(Geolocation.new(locations: %w(US)).qualifies?(visit))
+          assert(Geolocation.new(locations: %w(USA)).qualifies?(visit))
+          assert(Geolocation.new(locations: ['United States of America']).qualifies?(visit))
+          assert(Geolocation.new(locations: %w(Philadelphia US)).qualifies?(visit))
+          assert(Geolocation.new(locations: %w(US CA)).qualifies?(visit))
+          refute(Geolocation.new(locations: %w(MX CA)).qualifies?(visit))
+
+          visit = create_visit('HTTP_GEOIP_POSTAL_CODE' => '19106')
+          assert(Geolocation.new(locations: %w(19106)).qualifies?(visit))
+          refute(Geolocation.new(locations: %w(19147)).qualifies?(visit))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+module Workarea
+  class Segment
+    module Rules
+      class LastOrderTest < TestCase
+        def test_qualifies?
+          freeze_time
+          metrics = Metrics::User.create!(id: 'bcrouse@workarea.com')
+
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          refute(LastOrder.new.qualifies?(visit))
+
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          refute(LastOrder.new(days: 7).qualifies?(visit))
+
+          metrics.update_attributes!(last_order_at: 8.days.ago)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          refute(LastOrder.new(days: 7).qualifies?(visit))
+
+          metrics.update_attributes!(last_order_at: 7.days.ago)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          assert(LastOrder.new(days: 7).qualifies?(visit))
+
+          metrics.update_attributes!(last_order_at: 6.days.ago)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          assert(LastOrder.new(days: 7).qualifies?(visit))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+module Workarea
+  class Segment
+    module Rules
+      class LoggedInTest < TestCase
+        def test_qualifies?
+          metrics = Metrics::User.create!(id: 'bcrouse@workarea.com')
+
+          visit = create_visit(email: 'bcrouse@workarea.com', logged_in: false)
+          refute(LoggedIn.new(logged_in: true).qualifies?(visit))
+
+          visit = create_visit(email: 'bcrouse@workarea.com', logged_in: false)
+          assert(LoggedIn.new(logged_in: false).qualifies?(visit))
+
+          visit = create_visit(email: 'bcrouse@workarea.com', logged_in: true)
+          assert(LoggedIn.new(logged_in: true).qualifies?(visit))
+
+          visit = create_visit(email: 'bcrouse@workarea.com', logged_in: true)
+          refute(LoggedIn.new(logged_in: false).qualifies?(visit))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+module Workarea
+  class Segment
+    module Rules
+      class OrdersTest < TestCase
+        def test_qualifies?
+          metrics = Metrics::User.create!(id: 'bcrouse@workarea.com')
+
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          refute(Orders.new.qualifies?(visit))
+
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          refute(Orders.new(minimum: 1).qualifies?(visit))
+
+          metrics.update_attributes!(orders: 0)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          refute(Orders.new(minimum: 1).qualifies?(visit))
+
+          metrics.update_attributes!(orders: 1)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          assert(Orders.new(minimum: 1).qualifies?(visit))
+
+          metrics.update_attributes!(orders: 2)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          assert(Orders.new(minimum: 1).qualifies?(visit))
+
+          metrics.update_attributes!(orders: 0)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          assert(Orders.new(maximum: 2).qualifies?(visit))
+
+          metrics.update_attributes!(orders: 1)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          assert(Orders.new(maximum: 2).qualifies?(visit))
+
+          metrics.update_attributes!(orders: 2)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          assert(Orders.new(maximum: 2).qualifies?(visit))
+
+          metrics.update_attributes!(orders: 3)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          refute(Orders.new(maximum: 2).qualifies?(visit))
+
+          metrics.update_attributes!(orders: 3)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          refute(Orders.new(minimum: 1, maximum: 2).qualifies?(visit))
+
+          metrics.update_attributes!(orders: 1)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          assert(Orders.new(minimum: 1, maximum: 2).qualifies?(visit))
+
+          metrics.update_attributes!(orders: 2)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          assert(Orders.new(minimum: 1, maximum: 2).qualifies?(visit))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+module Workarea
+  class Segment
+    module Rules
+      class RevenueTest < TestCase
+        def test_qualifies?
+          metrics = Metrics::User.create!(id: 'bcrouse@workarea.com')
+
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          refute(Revenue.new.qualifies?(visit))
+
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          refute(Revenue.new(minimum: 1).qualifies?(visit))
+
+          metrics.update_attributes!(revenue: 0)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          refute(Revenue.new(minimum: 1).qualifies?(visit))
+
+          metrics.update_attributes!(revenue: 1)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          assert(Revenue.new(minimum: 1).qualifies?(visit))
+
+          metrics.update_attributes!(revenue: 2)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          assert(Revenue.new(minimum: 1).qualifies?(visit))
+
+          metrics.update_attributes!(revenue: 0)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          assert(Revenue.new(maximum: 2).qualifies?(visit))
+
+          metrics.update_attributes!(revenue: 1)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          assert(Revenue.new(maximum: 2).qualifies?(visit))
+
+          metrics.update_attributes!(revenue: 2)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          assert(Revenue.new(maximum: 2).qualifies?(visit))
+
+          metrics.update_attributes!(revenue: 3)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          refute(Revenue.new(maximum: 2).qualifies?(visit))
+
+          metrics.update_attributes!(revenue: 3)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          refute(Revenue.new(minimum: 1, maximum: 2).qualifies?(visit))
+
+          metrics.update_attributes!(revenue: 1)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          assert(Revenue.new(minimum: 1, maximum: 2).qualifies?(visit))
+
+          metrics.update_attributes!(revenue: 2)
+          visit = create_visit(email: 'bcrouse@workarea.com')
+          assert(Revenue.new(minimum: 1, maximum: 2).qualifies?(visit))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+module Workarea
+  class Segment
+    module Rules
+      class SessionsTest < TestCase
+        def test_qualifies?
+          visit = create_visit
+          refute(Sessions.new.qualifies?(visit))
+          refute(Sessions.new(minimum: 1).qualifies?(visit))
+          refute(Sessions.new(minimum: 1).qualifies?(create_visit(sessions: 0)))
+          assert(Sessions.new(minimum: 1).qualifies?(create_visit(sessions: 1)))
+          assert(Sessions.new(minimum: 1).qualifies?(create_visit(sessions: 2)))
+          assert(Sessions.new(maximum: 2).qualifies?(create_visit(sessions: 0)))
+          assert(Sessions.new(maximum: 2).qualifies?(create_visit(sessions: 1)))
+          assert(Sessions.new(maximum: 2).qualifies?(create_visit(sessions: 2)))
+          refute(Sessions.new(maximum: 2).qualifies?(create_visit(sessions: 3)))
+          refute(Sessions.new(minimum: 1, maximum: 2).qualifies?(create_visit(sessions: 3)))
+          refute(Sessions.new(minimum: 1, maximum: 2).qualifies?(create_visit(sessions: 0)))
+          assert(Sessions.new(minimum: 1, maximum: 2).qualifies?(create_visit(sessions: 1)))
+          assert(Sessions.new(minimum: 1, maximum: 2).qualifies?(create_visit(sessions: 2)))
+        end
+      end
+    end
+  end
+end