Promotions: First Order condition must not fail on canceled orders

The store I work in lets customers cancel their orders, and create a new
one in its stead. The feature is described as "Edit your order" to
customers. When they do this, the order they then place is perceived to
be their first order, and I think we should respect that.

Also changes the spec to work with actual records rather than mocking
chains.

Author: mamhoff

promotions/app/models/solidus_promotions/conditions/first_order.rb

@@ -20,11 +20,11 @@ def eligible?(order, options = {})
       private
 
       def completed_orders
-        user ? user.orders.complete : orders_by_email
+        user ? user.orders.complete.not_canceled : orders_by_email
       end
 
       def orders_by_email
-        Spree::Order.where(email: email).complete
+        Spree::Order.where(email: email).complete.not_canceled
       end
     end
   end

promotions/spec/models/solidus_promotions/conditions/first_order_spec.rb

@@ -4,8 +4,9 @@
 
 RSpec.describe SolidusPromotions::Conditions::FirstOrder, type: :model do
   let(:condition) { described_class.new }
-  let(:order) { mock_model(Spree::Order, user: nil, email: nil) }
-  let(:user) { mock_model(Spree::LegacyUser) }
+  let(:order) { create(:order, user:, email:) }
+  let(:user) { nil }
+  let(:email) { nil }
 
   describe "#level" do
     it "is order" do
@@ -31,36 +32,36 @@
 
   context "first order" do
     context "for a signed user" do
-      context "with no completed orders" do
-        before do
-          allow(user).to receive_message_chain(:orders, complete: [])
-        end
-
-        specify do
-          allow(order).to receive_messages(user: user)
-          expect(condition).to be_eligible(order)
-        end
+      let(:user) { create(:user) }
+      let(:email) { user.email }
 
+      context "with no completed, un-canceled orders" do
         it "is eligible when user passed in payload data" do
           expect(condition).to be_eligible(order, user: user)
         end
       end
 
       context "with completed orders" do
-        before do
-          allow(order).to receive_messages(user: user)
-        end
+        let(:order) { create(:completed_order_with_totals, user:, email:) }
 
         it "is eligible when checked against first completed order" do
-          allow(user).to receive_message_chain(:orders, complete: [order])
           expect(condition).to be_eligible(order)
         end
 
         context "with another order" do
-          before { allow(user).to receive_message_chain(:orders, complete: [mock_model(Spree::Order)]) }
+          let!(:previous_order) { create(:completed_order_with_totals, user:) }
 
           it { expect(condition).not_to be_eligible(order) }
 
+          context "if previous order is canceled" do
+            before do
+              previous_order.cancel!
+            end
+
+            it { expect(condition).to be_eligible(order) }
+          end
+
+
           it "sets an error message" do
             condition.eligible?(order)
             expect(condition.eligibility_errors.full_messages.first)
@@ -79,17 +80,23 @@
     context "for a guest user" do
       let(:email) { "user@solidus.io" }
 
-      before { allow(order).to receive_messages email: "user@solidus.io" }
-
       context "with no other orders" do
         it { expect(condition).to be_eligible(order) }
       end
 
       context "with another order" do
-        before { allow(condition).to receive_messages(orders_by_email: [mock_model(Spree::Order)]) }
+        let!(:previous_order) { create(:completed_order_with_totals, user: nil, email:) }
 
         it { expect(condition).not_to be_eligible(order) }
 
+        context "if previous order is canceled" do
+          before do
+            previous_order.cancel!
+          end
+
+          it { expect(condition).to be_eligible(order) }
+        end
+
         it "sets an error message" do
           condition.eligible?(order)
           expect(condition.eligibility_errors.full_messages.first)