workarea-core 3.4.45 → 3.5.0.beta.1

data/test/queries/workarea/reports/sales_by_sku_test.rb

@@ -13,7 +13,8 @@ module Workarea
           units_sold: 2,
           merchandise: 10.to_m,
           discounts: 0.to_m,
-          revenue: 10.to_m
+          tax: 1.to_m,
+          revenue: 11.to_m
         )
 
         Metrics::SkuByDay.inc(
@@ -23,7 +24,10 @@ module Workarea
           units_sold: 4,
           merchandise: 20.to_m,
           discounts: -5.to_m,
-          revenue: 15.to_m
+          tax: 1.to_m,
+          revenue: 16.to_m,
+          units_canceled: 2,
+          refund: -10.to_m
         )
 
         Metrics::SkuByDay.inc(
@@ -33,7 +37,10 @@ module Workarea
           units_sold: 6,
           merchandise: 30.to_m,
           discounts: -3.to_m,
-          revenue: 27.to_m
+          tax: 2.to_m,
+          revenue: 29.to_m,
+          units_canceled: 1,
+          refund: -3.to_m
         )
 
         Metrics::SkuByDay.inc(
@@ -43,7 +50,10 @@ module Workarea
           units_sold: 3,
           merchandise: 11.to_m,
           discounts: 0.to_m,
-          revenue: 11.to_m
+          tax: 1.to_m,
+          revenue: 12.to_m,
+          units_canceled: 1,
+          refund: -5.to_m
         )
 
         Metrics::SkuByDay.inc(
@@ -53,7 +63,8 @@ module Workarea
           units_sold: 5,
           merchandise: 21.to_m,
           discounts: -6.to_m,
-          revenue: 15.to_m
+          tax: 1.to_m,
+          revenue: 16.to_m
         )
 
         Metrics::SkuByDay.inc(
@@ -63,7 +74,8 @@ module Workarea
           units_sold: 7,
           merchandise: 31.to_m,
           discounts: -4.to_m,
-          revenue: 27.to_m
+          tax: 2.to_m,
+          revenue: 29.to_m
         )
       end
 
@@ -80,14 +92,22 @@ module Workarea
         assert_equal(12, foo['units_sold'])
         assert_equal(60, foo['merchandise'])
         assert_equal(-8, foo['discounts'])
-        assert_equal(52, foo['revenue'])
+        assert_equal(4, foo['tax'])
+        assert_equal(56, foo['revenue'])
+        assert_equal(4.33, foo['average_price'])
+        assert_equal(3, foo['units_canceled'])
+        assert_equal(-13, foo['refund'])
 
         bar = report.results.detect { |r| r['_id'] == 'bar' }
         assert_equal(9, bar['orders'])
         assert_equal(15, bar['units_sold'])
         assert_equal(63, bar['merchandise'])
         assert_equal(-10, bar['discounts'])
-        assert_equal(53, bar['revenue'])
+        assert_equal(4, bar['tax'])
+        assert_equal(57, bar['revenue'])
+        assert_equal(3.53, bar['average_price'])
+        assert_equal(1, bar['units_canceled'])
+        assert_equal(-5, bar['refund'])
       end
 
       def test_date_ranges

data/test/queries/workarea/reports/sales_by_tender_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+module Workarea
+  module Reports
+    class SalesByTenderTest < TestCase
+      setup :add_data, :time_travel
+
+      def add_data
+        Metrics::TenderByDay.inc(
+          key: { tender: 'credit_card' },
+          at: Time.zone.local(2018, 10, 27),
+          orders: 1,
+          revenue: 10.to_m
+        )
+
+        Metrics::TenderByDay.inc(
+          key: { tender: 'credit_card' },
+          at: Time.zone.local(2018, 10, 28),
+          orders: 2,
+          revenue: 15.to_m
+        )
+
+        Metrics::TenderByDay.inc(
+          key: { tender: 'credit_card' },
+          at: Time.zone.local(2018, 10, 29),
+          orders: 3,
+          revenue: 27.to_m
+        )
+
+        Metrics::TenderByDay.inc(
+          key: { tender: 'store_credit' },
+          at: Time.zone.local(2018, 10, 27),
+          orders: 2,
+          revenue: 11.to_m
+        )
+
+        Metrics::TenderByDay.inc(
+          key: { tender: 'store_credit' },
+          at: Time.zone.local(2018, 10, 28),
+          orders: 3,
+          revenue: 15.to_m
+        )
+
+        Metrics::TenderByDay.inc(
+          key: { tender: 'store_credit' },
+          at: Time.zone.local(2018, 10, 29),
+          orders: 4,
+          revenue: 27.to_m
+        )
+      end
+
+      def time_travel
+        travel_to Time.zone.local(2018, 10, 30)
+      end
+
+      def test_grouping_and_summing
+        report = SalesByTender.new
+        assert_equal(2, report.results.length)
+
+        credit_card = report.results.detect { |r| r['_id'] == 'credit_card' }
+        assert_equal(6, credit_card['orders'])
+        assert_equal(52, credit_card['revenue'])
+
+        store_credit = report.results.detect { |r| r['_id'] == 'store_credit' }
+        assert_equal(9, store_credit['orders'])
+        assert_equal(53, store_credit['revenue'])
+      end
+
+      def test_date_ranges
+        report = SalesByTender.new
+        credit_card = report.results.detect { |r| r['_id'] == 'credit_card' }
+        assert_equal(6, credit_card['orders'])
+
+        report = SalesByTender.new(starts_at: '2018-10-28', ends_at: '2018-10-28')
+        credit_card = report.results.detect { |r| r['_id'] == 'credit_card' }
+        assert_equal(2, credit_card['orders'])
+
+        report = SalesByTender.new(starts_at: '2018-10-28', ends_at: '2018-10-29')
+        credit_card = report.results.detect { |r| r['_id'] == 'credit_card' }
+        assert_equal(5, credit_card['orders'])
+
+        report = SalesByTender.new(starts_at: '2018-10-28')
+        credit_card = report.results.detect { |r| r['_id'] == 'credit_card' }
+        assert_equal(5, credit_card['orders'])
+
+        report = SalesByTender.new(ends_at: '2018-10-28')
+        credit_card = report.results.detect { |r| r['_id'] == 'credit_card' }
+        assert_equal(3, credit_card['orders'])
+      end
+
+      def test_sorting
+        report = SalesByTender.new(sort_by: 'orders', sort_direction: 'asc')
+        assert_equal('credit_card', report.results.first['_id'])
+
+        report = SalesByTender.new(sort_by: 'orders', sort_direction: 'desc')
+        assert_equal('store_credit', report.results.first['_id'])
+      end
+    end
+  end
+end

data/test/queries/workarea/reports/sales_by_traffic_referrer_test.rb

@@ -99,12 +99,12 @@ module Workarea
         assert_equal(-10, facebook['discounts'])
         assert_equal(53, facebook['revenue'])
 
-        tumblr = report.results.detect { |r| r['_id']['source'] == 'Twitter' }
-        assert_equal(3, tumblr['orders'])
-        assert_equal(3, tumblr['units_sold'])
-        assert_equal(30, tumblr['merchandise'])
-        assert_equal(0, tumblr['discounts'])
-        assert_equal(30, tumblr['revenue'])
+        twitter = report.results.detect { |r| r['_id']['source'] == 'Twitter' }
+        assert_equal(3, twitter['orders'])
+        assert_equal(3, twitter['units_sold'])
+        assert_equal(30, twitter['merchandise'])
+        assert_equal(0, twitter['discounts'])
+        assert_equal(30, twitter['revenue'])
       end
 
       def test_date_ranges

data/test/queries/workarea/search/admin_releases_test.rb

@@ -9,10 +9,6 @@ module Workarea
         @scheduled = create_release(name: 'Scheduled Release', publish_at: 1.week.from_now)
         @unscheduled = create_release(name: 'Unscheduled Release', created_at: Time.zone.local(2016, 6, 6))
         @published = create_release(name: 'Published Release', published_at: 1.week.ago)
-        @undone = create_release(name: 'Undone Release', published_at: 2.week.ago, undone_at: 1.day.ago)
-        @scheduled_undo_1 = create_release(name: 'Scheduled Undo Release 1', published_at: 5.week.ago, undo_at: 1.day.from_now)
-        @scheduled_undo_2 = create_release(name: 'Scheduled Undo Release 2', published_at: 4.week.ago, undo_at: 3.day.from_now)
-        @scheduled_undo_3 = create_release(name: 'Scheduled Undo Release 3', published_at: 3.week.ago, undo_at: 2.day.from_now)
       end
 
       def test_filter
@@ -25,34 +21,13 @@ module Workarea
         assert_includes(search.results, @unscheduled)
 
         search = AdminReleases.new(publishing: 'published')
-        assert_equal(5, search.total)
-        assert_includes(search.results, @published)
-        assert_includes(search.results, @undone)
-        assert_includes(search.results, @scheduled_undo_1)
-        assert_includes(search.results, @scheduled_undo_2)
-        assert_includes(search.results, @scheduled_undo_3)
-
-        search = AdminReleases.new(publishing: 'undone')
         assert_equal(1, search.total)
-        assert_includes(search.results, @undone)
-
-        search = AdminReleases.new(publishing: 'scheduled_undo')
-        assert_equal(3, search.total)
-        assert_includes(search.results, @scheduled_undo_1)
-        assert_includes(search.results, @scheduled_undo_2)
-        assert_includes(search.results, @scheduled_undo_3)
+        assert_includes(search.results, @published)
       end
 
       def test_sort
         search = AdminReleases.new(sort: 'published_date')
         assert_equal(@published, search.results.first)
-        assert_equal(@undone, search.results.second)
-        assert_equal(@scheduled_undo_3, search.results.third)
-
-        search = AdminReleases.new(sort: 'undo_date')
-        assert_equal(@scheduled_undo_1, search.results.first)
-        assert_equal(@scheduled_undo_3, search.results.second)
-        assert_equal(@scheduled_undo_2, search.results.third)
       end
 
       def test_filter_by_date

data/test/queries/workarea/search/admin_search_test.rb

@@ -81,16 +81,6 @@ module Workarea
         assert_equal(results.reverse, search.results)
       end
 
-      def test_default_sort_by_score
-        # Unlike other admin searches (primarily indexes), we want searching to
-        # default sort by score. Testing scores directly is unreliable so just
-        # do a simple check here.
-        assert_equal(
-          [{ _score: :desc }, { updated_at: :desc }],
-          AdminSearch.new.default_admin_sort
-        )
-      end
-
       def test_selected_sorting
         results = [
           create_product(name: 'A', variants: []),

data/test/queries/workarea/search/admin_users_test.rb

@@ -7,8 +7,8 @@ module Workarea
         one = create_user(email: 'foo@workarea.com')
         two = create_user(email: 'bar@workarea.com')
 
-        Metrics::User.create!(id: one.email, revenue: 50)
-        Metrics::User.create!(id: two.email, revenue: 5)
+        Metrics::User.save_order(email: one.email, revenue: 50)
+        Metrics::User.save_order(email: two.email, revenue: 5)
         Search::Admin::User.new(one).save
         Search::Admin::User.new(two).save
 

data/test/queries/workarea/search/category_browse_test.rb

@@ -329,6 +329,59 @@ module Workarea
         search = CategoryBrowse.new(sort: %w(featured), category_ids: [category.id])
         assert_equal(%w(1 2 3), search.results.map { |r| r[:model].id })
       end
+
+      def test_different_products_by_segment
+        segment_one = create_segment(name: 'One')
+        segment_two = create_segment(name: 'Two')
+        product_one = create_product(id: '1', active: true, active_segment_ids: [segment_one.id])
+        product_two = create_product(id: '2', active: true, active_segment_ids: [segment_two.id])
+        product_three = create_product(id: '3', active: false, active_segment_ids: [segment_one.id])
+        product_four = create_product(id: '4', active: true)
+        product_five = create_product(id: '5', active: false)
+        rules = [ProductRule.new(name: 'search', operator: 'equals', value: '*')]
+
+        search = CategoryBrowse.new(rules: rules)
+        result_ids = search.results.map { |r| r[:model].id }
+
+        refute_includes(result_ids, product_one.id)
+        refute_includes(result_ids, product_two.id)
+        refute_includes(result_ids, product_three.id)
+        assert_includes(result_ids, product_four.id)
+        refute_includes(result_ids, product_five.id)
+
+        Segment.with_current(segment_one) do
+          search = CategoryBrowse.new(rules: rules)
+          result_ids = search.results.map { |r| r[:model].id }
+
+          assert_includes(result_ids, product_one.id)
+          refute_includes(result_ids, product_two.id)
+          refute_includes(result_ids, product_three.id)
+          assert_includes(result_ids, product_four.id)
+          refute_includes(result_ids, product_five.id)
+        end
+
+        Segment.with_current(segment_two) do
+          search = CategoryBrowse.new(rules: rules)
+          result_ids = search.results.map { |r| r[:model].id }
+
+          refute_includes(result_ids, product_one.id)
+          assert_includes(result_ids, product_two.id)
+          refute_includes(result_ids, product_three.id)
+          assert_includes(result_ids, product_four.id)
+          refute_includes(result_ids, product_five.id)
+        end
+
+        Segment.with_current(segment_one, segment_two) do
+          search = CategoryBrowse.new(rules: rules)
+          result_ids = search.results.map { |r| r[:model].id }
+
+          assert_includes(result_ids, product_one.id)
+          assert_includes(result_ids, product_two.id)
+          refute_includes(result_ids, product_three.id)
+          assert_includes(result_ids, product_four.id)
+          refute_includes(result_ids, product_five.id)
+        end
+      end
     end
   end
 end

data/test/queries/workarea/search/facet_sorting/size_test.rb

@@ -5,21 +5,19 @@ module Workarea
     class FacetSorting
       class SizeTest < TestCase
         def test_call
-          Workarea.with_config do |config|
-            config.search_facet_size_sort = %(XS S M L XL)
+          Workarea.config.search_facet_size_sort = %(XS S M L XL)
 
-            results = { 'M' => 50, 'L' => 40, 'S' => 30, 'XL' => 20, 'XS' => 10 }
-            assert_equal(
-              { 'XS' => 10, 'S' => 30, 'M' => 50, 'L' => 40, 'XL' => 20 },
-              Size.call(:size, results)
-            )
+          results = { 'M' => 50, 'L' => 40, 'S' => 30, 'XL' => 20, 'XS' => 10 }
+          assert_equal(
+            { 'XS' => 10, 'S' => 30, 'M' => 50, 'L' => 40, 'XL' => 20 },
+            Size.call(:size, results)
+          )
 
-            results = { 'M' => 50, 'Small' => 40, 'XXL' => 30, 'XL' => 20 }
-            assert_equal(
-              { 'M' => 50, 'XL' => 20, 'Small' => 40, 'XXL' => 30 },
-              Size.call(:size, results)
-            )
-          end
+          results = { 'M' => 50, 'Small' => 40, 'XXL' => 30, 'XL' => 20 }
+          assert_equal(
+            { 'M' => 50, 'XL' => 20, 'Small' => 40, 'XXL' => 30 },
+            Size.call(:size, results)
+          )
         end
       end
     end

data/test/queries/workarea/search/pagination_test.rb

@@ -19,39 +19,22 @@ module Workarea
         assert_equal(1, Paginate.new(page: 'asdf').page)
       end
 
-      def test_per_page
-        assert_equal(Workarea.config.per_page, Paginate.new.per_page)
-        assert_equal(2, Paginate.new(per_page: 2).per_page)
-        assert_equal(Workarea.config.per_page, Paginate.new(per_page: -1).per_page)
-        assert_equal(Workarea.config.per_page, Paginate.new(per_page: 0).per_page)
-        assert_equal(3, Paginate.new(per_page: '3').per_page)
-        assert_equal(Workarea.config.per_page, Paginate.new(per_page: 'asdf').per_page)
-      end
-
       def test_from
-        Workarea.with_config do |config|
-          config.per_page = 30
-          assert_equal(0, Paginate.new(page: 1).from)
-        end
+        Workarea.config.per_page = 30
+        assert_equal(0, Paginate.new(page: 1).from)
 
-        Workarea.with_config do |config|
-          config.per_page = 15
-          assert_equal(15, Paginate.new(page: 2).from)
-        end
+        Workarea.config.per_page = 15
+        assert_equal(15, Paginate.new(page: 2).from)
 
-        Workarea.with_config do |config|
-          config.per_page = 45
-          assert_equal(90, Paginate.new(page: 3).from)
-        end
+        Workarea.config.per_page = 45
+        assert_equal(90, Paginate.new(page: 3).from)
       end
 
       def test_size
-        Workarea.with_config do |config|
-          config.per_page = 30
+        Workarea.config.per_page = 30
 
-          search = Paginate.new(page: 2)
-          assert_equal(30, search.size)
-        end
+        search = Paginate.new(page: 2)
+        assert_equal(30, search.size)
       end
 
       def test_each_by

data/test/queries/workarea/search/product_entries_test.rb

@@ -9,6 +9,33 @@ module Workarea
         assert_equal(1, ProductEntries.new(products.first).entries.size)
         assert_equal(3, ProductEntries.new(products).entries.size)
       end
+
+      def test_live_entries
+        product = create_product(name: 'Foo')
+        create_release.as_current do
+          product.update!(name: 'Bar')
+          product.reload
+        end
+        assert_equal('Bar', product.name)
+
+        results = ProductEntries.new(product).live_entries
+        assert_equal(1, results.size)
+        assert_equal('Foo', results.first.model.name)
+        refute_equal(product.object_id, results.first.model.object_id)
+      end
+
+      def test_release_entries
+        product = create_product(name: 'Foo')
+        release = create_release
+        release.as_current { product.update!(name: 'Bar') }
+        assert_equal('Foo', product.name)
+
+        results = ProductEntries.new(product).release_entries
+        assert_equal(1, results.size)
+        assert_equal('Bar', results.first.model.name)
+        assert_equal(release.id, results.first.release_id)
+        refute_equal(product.object_id, results.first.model.object_id)
+      end
     end
   end
 end

data/test/queries/workarea/search/product_search_test.rb

@@ -408,22 +408,6 @@ module Workarea
         assert(result[:raw].present?)
         assert_kind_of(Float, result[:raw]['_score'])
       end
-
-      def test_locale
-        # No simple way to run this test without fallbacks or localized fields
-        return unless Workarea.config.localized_active_fields
-
-        set_locales(available: [:en, :es], default: :en, current: :en)
-        Search::Storefront.reset_indexes!
-
-        product = create_product(active_translations: { 'en' => true, 'es' => false })
-
-        I18n.locale = :es
-        assert_equal([], ProductSearch.new(q: '*').results.pluck(:model))
-
-        I18n.locale = :en
-        assert_equal([product], ProductSearch.new(q: '*').results.pluck(:model))
-      end
     end
   end
 end

data/test/queries/workarea/search/storefront_search/response_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+module Workarea
+  module Search
+    class StorefrontSearch
+      class ResponseTest < TestCase
+        def test_only_uses_active_product_rules
+          customization = create_search_customization(
+            id: 'foo',
+            product_rules: [
+              { name: 'excluded_products', operator: 'equals', value: '1' },
+              { name: 'excluded_products', operator: 'equals', value: '2', active: false }
+            ]
+          )
+
+          response = Response.new(q: 'foo', customization: customization)
+          assert_equal(customization.product_rules.take(1), response.query.params[:rules])
+
+          customization.product_rules.first.update!(active: false)
+          response.reset!(q: 'foo')
+          assert_empty(response.query.params[:rules])
+        end
+      end
+    end
+  end
+end

data/test/queries/workarea/search/storefront_search_test.rb

@@ -55,56 +55,54 @@ module Workarea
       end
 
       def test_only_finds_active_customizations
-        Search::Customization.find_by_query('*').tap do |c|
-          c.active = false
-          c.save
-        end
-        search = StorefrontSearch.new(q: '*')
+        customization = Search::Customization.find_by_query('foo')
+        search = StorefrontSearch.new(q: 'foo')
+        assert_equal(customization, search.customization)
+
+        customization.update!(active: false)
+        search = StorefrontSearch.new(q: 'foo')
+        refute_equal(customization, search.customization)
         refute(search.customization.persisted?)
       end
 
       def test_keeps_track_of_middleware
-        Workarea.with_config do |config|
-          config.storefront_search_middleware = SwappableList.new(
-            %w(
-              Workarea::Search::StorefrontSearch::Redirect
-              Workarea::Search::StorefrontSearch::ExactMatches
-              Workarea::Search::StorefrontSearch::ProductMultipass
-              Workarea::Search::StorefrontSearch::SpellingCorrection
-              Workarea::Search::StorefrontSearch::Template
-            )
+        Workarea.config.storefront_search_middleware = SwappableList.new(
+          %w(
+            Workarea::Search::StorefrontSearch::Redirect
+            Workarea::Search::StorefrontSearch::ExactMatches
+            Workarea::Search::StorefrontSearch::ProductMultipass
+            Workarea::Search::StorefrontSearch::SpellingCorrection
+            Workarea::Search::StorefrontSearch::Template
           )
+        )
 
-          assert_equal(5, StorefrontSearch.new(q: '*').used_middleware.size)
+        assert_equal(5, StorefrontSearch.new(q: '*').used_middleware.size)
 
-          product = create_product(name: 'Foo Product')
-          IndexProduct.perform(product)
+        product = create_product(name: 'Foo Product')
+        IndexProduct.perform(product)
 
-          exact_match = StorefrontSearch.new(q: product.id)
-          assert_equal(2, exact_match.used_middleware.size)
-          assert_kind_of(StorefrontSearch::ExactMatches, exact_match.used_middleware.last)
-        end
+        exact_match = StorefrontSearch.new(q: product.id)
+        assert_equal(2, exact_match.used_middleware.size)
+        assert_kind_of(StorefrontSearch::ExactMatches, exact_match.used_middleware.last)
       end
 
       def test_tracing
-        Workarea.with_config do |config|
-          config.storefront_search_middleware = SwappableList.new(
-            %w(
-              Workarea::Search::StorefrontSearch::Redirect
-              Workarea::Search::StorefrontSearch::ExactMatches
-              Workarea::Search::StorefrontSearch::ProductMultipass
-              Workarea::Search::StorefrontSearch::SpellingCorrection
-              Workarea::Search::StorefrontSearch::Template
-            )
+        Workarea.config.storefront_search_middleware = SwappableList.new(
+          %w(
+            Workarea::Search::StorefrontSearch::Redirect
+            Workarea::Search::StorefrontSearch::ExactMatches
+            Workarea::Search::StorefrontSearch::ProductMultipass
+            Workarea::Search::StorefrontSearch::SpellingCorrection
+            Workarea::Search::StorefrontSearch::Template
           )
+        )
 
-          trace = StorefrontSearch.new(q: '*').response.trace
+        trace = StorefrontSearch.new(q: '*').response.trace
 
-          assert_equal(3, trace.size)
-          assert_nil(trace.first.reset_by)
-          assert_kind_of(StorefrontSearch::ProductMultipass, trace.second.reset_by)
-          assert_kind_of(StorefrontSearch::ProductMultipass, trace.third.reset_by)
-        end
+        assert_equal(3, trace.size)
+        assert_nil(trace.first.reset_by)
+        assert_kind_of(StorefrontSearch::ProductMultipass, trace.second.reset_by)
+        assert_kind_of(StorefrontSearch::ProductMultipass, trace.third.reset_by)
       end
 
       def test_exact_match_customization

data/test/services/workarea/cancel_order_test.rb

@@ -1,20 +1,15 @@
 require 'test_helper'
 
-# TODO: Factor out remaining calls to this service and then remove
-# Plugins call Order#cancel directly and no longer go through this service
 module Workarea
-  class CancelOrderTest < IntegrationTest
-    setup :stub_mailers
-
-    # We don't care to test mailers here, they're tested as part of other
-    # integration and/or system tests.
-    def stub_mailers
-      Storefront::FulfillmentMailer.stubs(:shipped).returns(stub_everything)
-      Storefront::FulfillmentMailer.stubs(:canceled).returns(stub_everything)
-    end
+  class CancelOrderTest < TestCase
+    setup :build_order
+
+    def build_order
+      create_product(id: 'PROD1', variants: [{ sku: 'SKU1', regular: 5.to_m }])
+      create_product(id: 'PROD2', variants: [{ sku: 'SKU2', regular: 3.to_m }])
 
-    setup do
       @order = Order.new(
+        email: 'test@workarea.com',
         items: [
           { product_id: 'PROD1', sku: 'SKU1', quantity: 2 },
           { product_id: 'PROD2', sku: 'SKU2', quantity: 3 }
@@ -106,13 +101,32 @@ module Workarea
     end
 
     def test_marking_the_order_canceled
-      @order.save!(validate: false)
+      complete_checkout(@order)
+
+      SaveOrderMetrics.perform(@order)
+
+      assert_equal(1, Metrics::User.first.orders)
+
+      product_metric = Metrics::ProductByDay.by_product('PROD1').first
+      assert_equal(2, product_metric.units_sold)
+
+      travel_to 1.week.from_now
 
       cancel = CancelOrder.new(@order)
       cancel.perform
 
       @order.reload
       assert(@order.canceled?)
+
+      assert_equal(1, Metrics::User.first.cancellations)
+
+      product_metric.reload
+      assert_equal(2, product_metric.units_sold)
+      assert_equal(0, product_metric.units_canceled)
+
+      product_metric = Metrics::ProductByDay.by_product('PROD1').last
+      assert_equal(0, product_metric.units_sold)
+      assert_equal(2, product_metric.units_canceled)
     end
   end
 end