Fix UnitPrice spec

spec/services/unit_prices_spec.rb

@@ -3,53 +3,46 @@
 require 'spec_helper'
 
 RSpec.describe UnitPrice do
-  subject { UnitPrice.new(variant) }
-  let(:variant) { Spree::Variant.new }
-  let(:product) { instance_double(Spree::Product) }
-
   before do
-    allow(variant).to receive(:product) { product }
     allow(Spree::Config).to receive(:available_units).and_return("g,lb,oz,kg,T,mL,L,kL")
   end
 
   describe "#unit" do
     context "metric" do
-      before do
-        allow(product).to receive(:variant_unit_scale) { 1.0 }
-      end
-
       it "returns kg for weight" do
-        allow(product).to receive(:variant_unit) { "weight" }
-        expect(subject.unit).to eq("kg")
+        variant = Spree::Variant.new(variant_unit_scale: 1.0, variant_unit: "weight")
+
+        expect(UnitPrice.new(variant).unit).to eq("kg")
       end
 
       it "returns L for volume" do
-        allow(product).to receive(:variant_unit) { "volume" }
-        expect(subject.unit).to eq("L")
+        variant = Spree::Variant.new(variant_unit_scale: 1.0, variant_unit: "volume")
+
+        expect(UnitPrice.new(variant).unit).to eq("L")
       end
     end
 
     context "imperial" do
       it "returns lbs" do
-        allow(product).to receive(:variant_unit_scale) { 453.6 }
-        allow(product).to receive(:variant_unit) { "weight" }
-        expect(subject.unit).to eq("lb")
+        variant = Spree::Variant.new(variant_unit_scale: 453.6, variant_unit: "weight")
+
+        expect(UnitPrice.new(variant).unit).to eq("lb")
       end
     end
 
     context "items" do
       it "returns items if no unit is specified" do
-        allow(product).to receive(:variant_unit_name) { nil }
-        allow(product).to receive(:variant_unit_scale) { nil }
-        allow(product).to receive(:variant_unit) { "items" }
-        expect(subject.unit).to eq("Item")
+        variant = Spree::Variant.new(variant_unit_name: nil, variant_unit_scale: nil,
+                                     variant_unit: "items")
+
+        expect(UnitPrice.new(variant).unit).to eq("Item")
       end
 
       it "returns the unit if a unit is specified" do
-        allow(product).to receive(:variant_unit_name) { "bunch" }
-        allow(product).to receive(:variant_unit_scale) { nil }
-        allow(product).to receive(:variant_unit) { "items" }
-        expect(subject.unit).to eq("bunch")
+        variant = Spree::Variant.new(variant_unit_name: "bunch", variant_unit_scale: nil,
+                                     variant_unit: "items")
+
+        expect(UnitPrice.new(variant).unit).to eq("bunch")
       end
     end
   end
@@ -57,49 +50,47 @@ RSpec.describe UnitPrice do
   describe "#denominator" do
     context "metric" do
       it "returns 0.5 for a 500g variant" do
-        allow(product).to receive(:variant_unit_scale) { 1.0 }
-        allow(product).to receive(:variant_unit) { "weight" }
-        variant.unit_value = 500
-        expect(subject.denominator).to eq(0.5)
+        variant = Spree::Variant.new(variant_unit_scale: 1.0, unit_value: 500,
+                                     variant_unit: "weight")
+
+        expect(UnitPrice.new(variant).denominator).to eq(0.5)
       end
 
       it "returns 2 for a 2kg variant" do
-        allow(product).to receive(:variant_unit_scale) { 1000 }
-        allow(product).to receive(:variant_unit) { "weight" }
-        variant.unit_value = 2000
-        expect(subject.denominator).to eq(2)
+        variant = Spree::Variant.new(variant_unit_scale: 1000, unit_value: 2000,
+                                     variant_unit: "weight")
+
+        expect(UnitPrice.new(variant).denominator).to eq(2)
       end
 
       it "returns 0.5 for a 500mL variant" do
-        allow(product).to receive(:variant_unit_scale) { 0.001 }
-        allow(product).to receive(:variant_unit) { "volume" }
-        variant.unit_value = 0.5
-        expect(subject.denominator).to eq(0.5)
+        variant = Spree::Variant.new(variant_unit_scale: 0.001, unit_value: 0.5,
+                                     variant_unit: "volume")
+
+        expect(UnitPrice.new(variant).denominator).to eq(0.5)
       end
     end
 
     context "imperial" do
       it "returns 2 for a 2 pound variant" do
-        allow(product).to receive(:variant_unit_scale) { 453.6 }
-        allow(product).to receive(:variant_unit) { "weight" }
-        variant.unit_value = 2 * 453.6
-        expect(subject.denominator).to eq(2)
+        variant = Spree::Variant.new(variant_unit_scale: 453.6, unit_value: 2 * 453.6,
+                                     variant_unit: "weight")
+
+        expect(UnitPrice.new(variant).denominator).to eq(2)
       end
     end
 
     context "items" do
       it "returns 1 if no unit is specified" do
-        allow(product).to receive(:variant_unit_scale) { nil }
-        allow(product).to receive(:variant_unit) { "items" }
-        variant.unit_value = 1
-        expect(subject.denominator).to eq(1)
+        variant = Spree::Variant.new(variant_unit_scale: nil, unit_value: 1, variant_unit: "items")
+
+        expect(UnitPrice.new(variant).denominator).to eq(1)
       end
 
       it "returns 2 for multi-item units" do
-        allow(product).to receive(:variant_unit_scale) { nil }
-        allow(product).to receive(:variant_unit) { "items" }
-        variant.unit_value = 2
-        expect(subject.denominator).to eq(2)
+        variant = Spree::Variant.new(variant_unit_scale: nil, unit_value: 2, variant_unit: "items")
+
+        expect(UnitPrice.new(variant).denominator).to eq(2)
       end
     end
   end