mirror of
https://github.com/openfoodfoundation/openfoodnetwork
synced 2026-01-24 20:36:49 +00:00
748 lines
28 KiB
Ruby
748 lines
28 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require 'spec_helper'
|
|
|
|
describe OrderCycle do
|
|
include OpenFoodNetwork::EmailHelper
|
|
|
|
it "should be valid when built from factory" do
|
|
expect(build(:simple_order_cycle)).to be_valid
|
|
end
|
|
|
|
it "should not be valid without a name" do
|
|
oc = build(:simple_order_cycle)
|
|
oc.name = ''
|
|
expect(oc).not_to be_valid
|
|
end
|
|
|
|
it 'should not be valid when open date is after close date' do
|
|
oc = build(:simple_order_cycle, orders_open_at: Time.zone.now, orders_close_at: 1.minute.ago)
|
|
expect(oc).to_not be_valid
|
|
end
|
|
|
|
describe "#at_least_one_shipping_method_selected_for_each_distributor" do
|
|
context "distributor order cycle i.e. :sells is 'any'" do
|
|
context "when multiple distributors have been added to the order cycle already" do
|
|
it "is valid when adding a shipping method for *all* distributors" do
|
|
distributor_i = create(:distributor_enterprise)
|
|
distributor_ii = create(:distributor_enterprise)
|
|
distributor_i_shipping_method = create(:shipping_method, distributors: [distributor_i])
|
|
distributor_ii_shipping_method = create(:shipping_method, distributors: [distributor_ii])
|
|
order_cycle = create(:distributor_order_cycle, distributors: [distributor_i, distributor_ii])
|
|
|
|
order_cycle.shipping_method_ids = [distributor_i_shipping_method.id, distributor_ii_shipping_method.id]
|
|
|
|
expect(order_cycle).to be_valid
|
|
end
|
|
end
|
|
|
|
it "is not valid when adding a shipping method for *some but not all* distributors" do
|
|
distributor_i = create(:distributor_enterprise)
|
|
distributor_ii = create(:distributor_enterprise)
|
|
distributor_i_shipping_method = create(:shipping_method, distributors: [distributor_i])
|
|
distributor_ii_shipping_method = create(:shipping_method, distributors: [distributor_i])
|
|
order_cycle = create(:distributor_order_cycle, distributors: [distributor_i, distributor_ii])
|
|
|
|
order_cycle.shipping_method_ids = [distributor_i_shipping_method.id]
|
|
|
|
expect(order_cycle).to be_invalid
|
|
expect(order_cycle.errors.to_a).to eq ["You need to select at least one shipping method for each distributor"]
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "#no_invalid_shipping_methods" do
|
|
context "when a shipping method is not valid" do
|
|
it "adds a validation error, and it is more meaningful than the default 'Order cycle shipping methods is invalid'" do
|
|
order_cycle = create(:distributor_order_cycle, with_distributor_and_shipping_method: true)
|
|
shipping_method = order_cycle.shipping_methods.first
|
|
|
|
shipping_method.update_column(:display_on, "back_end")
|
|
|
|
expect(order_cycle).to be_invalid
|
|
expect(order_cycle.errors.to_a).to eq ["Shipping method must be available at checkout"]
|
|
|
|
shipping_method.update_column(:display_on, "")
|
|
|
|
expect(order_cycle.reload).to be_valid
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "#validate_shipping_methods" do
|
|
it "doesn't skip shipping method validations by default" do
|
|
order_cycle = create(:distributor_order_cycle, distributors: [create(:distributor_enterprise)])
|
|
|
|
expect(order_cycle).to be_invalid
|
|
expect(order_cycle.errors.to_a).to eq ["You need to select at least one shipping method for each distributor"]
|
|
end
|
|
|
|
it "allows shipping method validations to be skipped because distributors need to be saved before shipping methods" do
|
|
order_cycle = create(:distributor_order_cycle, distributors: [create(:distributor_enterprise)])
|
|
|
|
order_cycle.validate_shipping_methods = false
|
|
|
|
expect(order_cycle).to be_valid
|
|
end
|
|
end
|
|
|
|
it "has a coordinator and associated fees" do
|
|
oc = create(:simple_order_cycle)
|
|
|
|
oc.coordinator = create(:enterprise)
|
|
oc.coordinator_fees << create(:enterprise_fee, enterprise: oc.coordinator)
|
|
|
|
oc.save!
|
|
end
|
|
|
|
it "has exchanges" do
|
|
oc = create(:simple_order_cycle)
|
|
|
|
create(:exchange, order_cycle: oc)
|
|
create(:exchange, order_cycle: oc)
|
|
create(:exchange, order_cycle: oc)
|
|
|
|
expect(oc.exchanges.count).to eq(3)
|
|
end
|
|
|
|
it "finds order cycles in various stages of their lifecycle" do
|
|
oc_active = create(:simple_order_cycle, orders_open_at: 1.week.ago,
|
|
orders_close_at: 1.week.from_now)
|
|
oc_not_yet_open = create(:simple_order_cycle, orders_open_at: 1.week.from_now,
|
|
orders_close_at: 2.weeks.from_now)
|
|
oc_already_closed = create(:simple_order_cycle, orders_open_at: 2.weeks.ago,
|
|
orders_close_at: 1.week.ago)
|
|
oc_undated = create(:simple_order_cycle, orders_open_at: nil, orders_close_at: nil)
|
|
oc_undated_open = create(:simple_order_cycle, orders_open_at: 1.week.ago, orders_close_at: nil)
|
|
oc_undated_close = create(:simple_order_cycle, orders_open_at: nil,
|
|
orders_close_at: 1.week.from_now)
|
|
|
|
expect(OrderCycle.active).to eq([oc_active])
|
|
expect(OrderCycle.inactive).to match_array [oc_not_yet_open, oc_already_closed]
|
|
expect(OrderCycle.upcoming).to eq([oc_not_yet_open])
|
|
expect(OrderCycle.closed).to eq([oc_already_closed])
|
|
expect(OrderCycle.undated).to eq([oc_undated, oc_undated_open, oc_undated_close])
|
|
expect(OrderCycle.not_closed).to eq([oc_active, oc_not_yet_open, oc_undated, oc_undated_open,
|
|
oc_undated_close])
|
|
expect(OrderCycle.dated).to eq([oc_active, oc_not_yet_open, oc_already_closed])
|
|
end
|
|
|
|
it "finds order cycles accessible by a user" do
|
|
e1 = create(:enterprise, is_primary_producer: true, sells: "any")
|
|
e2 = create(:enterprise, is_primary_producer: true, sells: "any")
|
|
user = create(:user, enterprises: [e2], spree_roles: [])
|
|
user.spree_roles = []
|
|
|
|
oc_coordinated = create(:simple_order_cycle, coordinator: e2)
|
|
oc_sent = create(:simple_order_cycle, suppliers: [e2])
|
|
oc_received = create(:simple_order_cycle, distributors: [e2])
|
|
oc_not_accessible = create(:simple_order_cycle, coordinator: e1)
|
|
|
|
expect(OrderCycle.visible_by(user)).to include(oc_coordinated, oc_sent, oc_received)
|
|
expect(OrderCycle.visible_by(user)).not_to include(oc_not_accessible)
|
|
end
|
|
|
|
it "finds the most recently closed order cycles" do
|
|
oc1 = create(:simple_order_cycle, orders_close_at: 2.hours.ago)
|
|
oc2 = create(:simple_order_cycle, orders_close_at: 1.hour.ago)
|
|
oc3 = create(:simple_order_cycle, orders_close_at: 1.hour.from_now)
|
|
|
|
expect(OrderCycle.most_recently_closed).to eq([oc2, oc1])
|
|
end
|
|
|
|
it "finds the soonest opening order cycles" do
|
|
oc1 = create(:simple_order_cycle, orders_open_at: 1.week.from_now)
|
|
oc2 = create(:simple_order_cycle, orders_open_at: 2.hours.from_now)
|
|
oc3 = create(:simple_order_cycle, orders_open_at: 1.hour.ago)
|
|
|
|
expect(OrderCycle.soonest_opening).to eq([oc2, oc1])
|
|
end
|
|
|
|
it "finds the soonest closing order cycles" do
|
|
oc1 = create(:simple_order_cycle, orders_close_at: 2.hours.ago)
|
|
oc2 = create(:simple_order_cycle, orders_close_at: 2.hours.from_now)
|
|
oc3 = create(:simple_order_cycle, orders_close_at: 1.hour.from_now)
|
|
|
|
expect(OrderCycle.soonest_closing).to eq([oc3, oc2])
|
|
end
|
|
|
|
describe "finding order cycles with a particular distributor" do
|
|
let(:c) { create(:supplier_enterprise) }
|
|
let(:d) { create(:distributor_enterprise) }
|
|
|
|
it "returns order cycles with that distributor" do
|
|
oc = create(:simple_order_cycle, coordinator: c, distributors: [d])
|
|
expect(OrderCycle.with_distributor(d)).to eq([oc])
|
|
end
|
|
|
|
it "does not return order cycles with that enterprise as supplier" do
|
|
oc = create(:simple_order_cycle, coordinator: c, suppliers: [d])
|
|
expect(OrderCycle.with_distributor(d)).to eq([])
|
|
end
|
|
|
|
it "does not return order cycles without that distributor" do
|
|
oc = create(:simple_order_cycle, coordinator: c)
|
|
expect(OrderCycle.with_distributor(d)).to eq([])
|
|
end
|
|
end
|
|
|
|
it "reports its suppliers" do
|
|
oc = create(:simple_order_cycle)
|
|
|
|
e1 = create(:exchange, incoming: true,
|
|
order_cycle: oc, receiver: oc.coordinator, sender: create(:enterprise))
|
|
e2 = create(:exchange, incoming: true,
|
|
order_cycle: oc, receiver: oc.coordinator, sender: create(:enterprise))
|
|
|
|
expect(oc.suppliers).to match_array [e1.sender, e2.sender]
|
|
end
|
|
|
|
it "reports its distributors" do
|
|
oc = create(:simple_order_cycle, validate_shipping_methods: false)
|
|
|
|
e1 = create(:exchange, incoming: false,
|
|
order_cycle: oc, sender: oc.coordinator, receiver: create(:enterprise))
|
|
e2 = create(:exchange, incoming: false,
|
|
order_cycle: oc, sender: oc.coordinator, receiver: create(:enterprise))
|
|
|
|
expect(oc.distributors).to match_array [e1.receiver, e2.receiver]
|
|
end
|
|
|
|
it "checks for existance of distributors" do
|
|
oc = create(:simple_order_cycle, validate_shipping_methods: false)
|
|
d1 = create(:distributor_enterprise)
|
|
d2 = create(:distributor_enterprise)
|
|
create(:exchange, order_cycle: oc, sender: oc.coordinator, receiver: d1, incoming: false)
|
|
|
|
expect(oc).to have_distributor(d1)
|
|
expect(oc).not_to have_distributor(d2)
|
|
end
|
|
|
|
it "checks for variants" do
|
|
p1 = create(:simple_product)
|
|
p2 = create(:simple_product)
|
|
oc = create(:simple_order_cycle, suppliers: [p1.supplier], variants: [p1.master])
|
|
|
|
expect(oc).to have_variant(p1.master)
|
|
expect(oc).not_to have_variant(p2.master)
|
|
end
|
|
|
|
describe "product exchanges" do
|
|
let(:oc) { create(:simple_order_cycle) }
|
|
let(:d1) { create(:enterprise) }
|
|
let(:d2) { create(:enterprise) }
|
|
let!(:e0) {
|
|
create(:exchange, incoming: true,
|
|
order_cycle: oc, sender: create(:enterprise), receiver: oc.coordinator)
|
|
}
|
|
let!(:e1) {
|
|
create(:exchange, incoming: false,
|
|
order_cycle: oc, sender: oc.coordinator, receiver: d1)
|
|
}
|
|
let!(:e2) {
|
|
create(:exchange, incoming: false,
|
|
order_cycle: oc, sender: oc.coordinator, receiver: d2)
|
|
}
|
|
let!(:p0) { create(:simple_product) }
|
|
let!(:p1) { create(:simple_product) }
|
|
let!(:p1_v_deleted) { create(:variant, product: p1) }
|
|
let!(:p1_v_visible) {
|
|
create(:variant, product: p1,
|
|
inventory_items: [create(:inventory_item, enterprise: d2, visible: true)])
|
|
}
|
|
let!(:p1_v_hidden) {
|
|
create(:variant, product: p1,
|
|
inventory_items: [create(:inventory_item, enterprise: d2, visible: false)])
|
|
}
|
|
let!(:p2) { create(:simple_product) }
|
|
let!(:p2_v) { create(:variant, product: p2) }
|
|
|
|
before(:each) do
|
|
p1_v_deleted.deleted_at = Time.zone.now
|
|
p1_v_deleted.save
|
|
|
|
e0.variants << p0.master
|
|
e1.variants << p1.master
|
|
e1.variants << p2.master
|
|
e1.variants << p2_v
|
|
e2.variants << p1.master
|
|
e2.variants << p1_v_deleted
|
|
e2.variants << p1_v_visible
|
|
e2.variants << p1_v_hidden
|
|
end
|
|
|
|
it "reports on the variants exchanged" do
|
|
expect(oc.variants).to match_array [p0.master, p1.master, p2.master, p2_v, p1_v_visible,
|
|
p1_v_hidden]
|
|
end
|
|
|
|
it "returns the correct count of variants" do
|
|
expect(oc.variants.count).to eq(6)
|
|
end
|
|
|
|
it "reports on the variants supplied" do
|
|
expect(oc.supplied_variants).to match_array [p0.master]
|
|
end
|
|
|
|
it "reports on the variants distributed" do
|
|
expect(oc.distributed_variants).to match_array [p1.master, p2.master, p2_v, p1_v_visible,
|
|
p1_v_hidden]
|
|
end
|
|
|
|
it "reports on the products distributed by a particular distributor" do
|
|
expect(oc.products_distributed_by(d2)).to eq([p1])
|
|
end
|
|
|
|
it "reports on the products exchanged" do
|
|
expect(oc.products).to match_array [p0, p1, p2]
|
|
end
|
|
|
|
context "listing variant distributed by a particular distributor" do
|
|
context "when default settings are in play" do
|
|
it "returns an empty list when no distributor is given" do
|
|
expect(oc.variants_distributed_by(nil)).to eq([])
|
|
end
|
|
|
|
it "returns all variants in the outgoing exchange for the distributor provided" do
|
|
expect(oc.variants_distributed_by(d2)).to include p1.master, p1_v_visible
|
|
expect(oc.variants_distributed_by(d2)).not_to include p1_v_hidden, p1_v_deleted
|
|
expect(oc.variants_distributed_by(d1)).to include p2_v
|
|
end
|
|
|
|
context "with soft-deleted variants" do
|
|
it "does not consider soft-deleted variants to be currently distributed in the oc" do
|
|
p2_v.delete
|
|
|
|
expect(oc.variants_distributed_by(d1)).to_not include p2_v
|
|
end
|
|
end
|
|
end
|
|
|
|
context "when hub prefers product selection from inventory only" do
|
|
before do
|
|
allow(d1).to receive(:prefers_product_selection_from_inventory_only?) { true }
|
|
end
|
|
|
|
it "returns an empty list when no distributor is given" do
|
|
expect(oc.variants_distributed_by(nil)).to eq([])
|
|
end
|
|
|
|
it "returns only variants in the exchange that are also in the distributor's inventory" do
|
|
expect(oc.variants_distributed_by(d1)).not_to include p2_v
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "exchanges" do
|
|
before(:each) do
|
|
@oc = create(:simple_order_cycle)
|
|
|
|
@d1 = create(:enterprise)
|
|
@d2 = create(:enterprise, next_collection_at: '2-8pm Friday')
|
|
|
|
@e0 = create(:exchange, order_cycle: @oc, sender: create(:enterprise),
|
|
receiver: @oc.coordinator, incoming: true)
|
|
@e1 = create(:exchange, order_cycle: @oc, sender: @oc.coordinator, receiver: @d1,
|
|
incoming: false, pickup_time: '5pm Tuesday', pickup_instructions: "Come get it!")
|
|
@e2 = create(:exchange, order_cycle: @oc, sender: @oc.coordinator, receiver: @d2,
|
|
incoming: false, pickup_time: nil)
|
|
end
|
|
|
|
it "finds the exchange for a distributor" do
|
|
expect(@oc.exchange_for_distributor(@d1)).to eq(@e1)
|
|
expect(@oc.exchange_for_distributor(@d2)).to eq(@e2)
|
|
end
|
|
|
|
describe "finding pickup time for a distributor" do
|
|
it "looks up the pickup time on the exchange when present" do
|
|
expect(@oc.pickup_time_for(@d1)).to eq('5pm Tuesday')
|
|
end
|
|
|
|
it "returns the distributor's default collection time otherwise" do
|
|
expect(@oc.pickup_time_for(@d2)).to eq('2-8pm Friday')
|
|
end
|
|
end
|
|
|
|
describe "finding pickup instructions for a distributor" do
|
|
it "returns the pickup instructions" do
|
|
expect(@oc.pickup_instructions_for(@d1)).to eq("Come get it!")
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "checking status" do
|
|
let(:oc) { build_stubbed(:simple_order_cycle) }
|
|
|
|
it "reports status when an order cycle is upcoming" do
|
|
Timecop.freeze(oc.orders_open_at - 1.second) do
|
|
expect(oc).not_to be_undated
|
|
expect(oc).to be_dated
|
|
expect(oc).to be_upcoming
|
|
expect(oc).not_to be_open
|
|
expect(oc).not_to be_closed
|
|
end
|
|
end
|
|
|
|
it "reports status when an order cycle is open" do
|
|
expect(oc).not_to be_undated
|
|
expect(oc).to be_dated
|
|
expect(oc).not_to be_upcoming
|
|
expect(oc).to be_open
|
|
expect(oc).not_to be_closed
|
|
end
|
|
|
|
it "reports status when an order cycle has closed" do
|
|
Timecop.freeze(oc.orders_close_at + 1.second) do
|
|
expect(oc).not_to be_undated
|
|
expect(oc).to be_dated
|
|
expect(oc).not_to be_upcoming
|
|
expect(oc).not_to be_open
|
|
expect(oc).to be_closed
|
|
end
|
|
end
|
|
|
|
it "reports status when an order cycle is undated" do
|
|
oc.orders_open_at = nil
|
|
oc.orders_close_at = nil
|
|
|
|
expect(oc).to be_undated
|
|
expect(oc).not_to be_dated
|
|
expect(oc).not_to be_upcoming
|
|
expect(oc).not_to be_open
|
|
expect(oc).not_to be_closed
|
|
end
|
|
|
|
it "reports status when an order cycle is partially dated - opening time only" do
|
|
oc.orders_close_at = nil
|
|
|
|
expect(oc).to be_undated
|
|
expect(oc).not_to be_dated
|
|
expect(oc).not_to be_upcoming
|
|
expect(oc).not_to be_open
|
|
expect(oc).not_to be_closed
|
|
end
|
|
|
|
it "reports status when an order cycle is partially dated - closing time only" do
|
|
oc.orders_open_at = nil
|
|
|
|
expect(oc).to be_undated
|
|
expect(oc).not_to be_dated
|
|
expect(oc).not_to be_upcoming
|
|
expect(oc).not_to be_open
|
|
expect(oc).not_to be_closed
|
|
end
|
|
end
|
|
|
|
describe "clone!" do
|
|
it "clones itself" do
|
|
coordinator = create(:enterprise);
|
|
oc = create(:simple_order_cycle,
|
|
coordinator_fees: [create(:enterprise_fee, enterprise: coordinator)],
|
|
preferred_product_selection_from_coordinator_inventory_only: true,
|
|
automatic_notifications: true, processed_at: Time.zone.now, mails_sent: true)
|
|
schedule = create(:schedule, order_cycles: [oc])
|
|
ex1 = create(:exchange, order_cycle: oc)
|
|
ex2 = create(:exchange, order_cycle: oc)
|
|
oc.clone!
|
|
|
|
occ = OrderCycle.last
|
|
expect(occ.name).to eq("COPY OF #{oc.name}")
|
|
expect(occ.orders_open_at).to be_nil
|
|
expect(occ.orders_close_at).to be_nil
|
|
expect(occ.coordinator).not_to be_nil
|
|
expect(occ.preferred_product_selection_from_coordinator_inventory_only).to be true
|
|
expect(occ.automatic_notifications).to eq(oc.automatic_notifications)
|
|
expect(occ.processed_at).to eq(nil)
|
|
expect(occ.mails_sent).to eq(nil)
|
|
expect(occ.coordinator).to eq(oc.coordinator)
|
|
|
|
expect(occ.coordinator_fee_ids).not_to be_empty
|
|
expect(occ.coordinator_fee_ids).to eq(oc.coordinator_fee_ids)
|
|
expect(occ.preferred_product_selection_from_coordinator_inventory_only).to eq(oc.preferred_product_selection_from_coordinator_inventory_only)
|
|
expect(occ.schedule_ids).not_to be_empty
|
|
expect(occ.schedule_ids).to eq(oc.schedule_ids)
|
|
|
|
# Check that the exchanges have been cloned.
|
|
original_exchange_attributes = oc.exchanges.map { |ex| core_exchange_attributes(ex) }
|
|
cloned_exchange_attributes = occ.exchanges.map { |ex| core_exchange_attributes(ex) }
|
|
|
|
expect(cloned_exchange_attributes).to match_array original_exchange_attributes
|
|
end
|
|
|
|
context "distributor order cycle created before the customisable shipping methods feature was available" do
|
|
it "allows the clone to have customisable shipping methods" do
|
|
order_cycle = create(:distributor_order_cycle, shipping_methods_customisable: false)
|
|
|
|
order_cycle.clone!
|
|
|
|
order_cycle_clone = OrderCycle.last
|
|
expect(order_cycle_clone.shipping_methods_customisable).to eq(true)
|
|
end
|
|
end
|
|
|
|
context "when it has shipping methods which can longer be applied validly e.g. shipping method is backoffice only" do
|
|
it "raises an error (TODO: display a message to user explaining why clone failed)" do
|
|
distributor = create(:distributor_enterprise)
|
|
shipping_method = create(:shipping_method, distributors: [distributor])
|
|
order_cycle = create(:distributor_order_cycle, distributors: [distributor], shipping_methods: [shipping_method])
|
|
shipping_method.update_column(:display_on, "back_end")
|
|
|
|
expect {
|
|
order_cycle.clone!
|
|
}.to raise_error ActiveRecord::RecordInvalid
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "finding recently closed order cycles" do
|
|
it "should give the most recently closed order cycle for a distributor" do
|
|
distributor = create(:distributor_enterprise)
|
|
oc = create(:simple_order_cycle, name: 'oc 1', distributors: [distributor],
|
|
orders_open_at: 10.days.ago, orders_close_at: 9.days.ago)
|
|
expect(OrderCycle.most_recently_closed_for(distributor)).to eq(oc)
|
|
end
|
|
|
|
it "should return nil when there have been none" do
|
|
distributor = create(:distributor_enterprise)
|
|
expect(OrderCycle.most_recently_closed_for(distributor)).to eq(nil)
|
|
end
|
|
end
|
|
|
|
describe "finding order cycles opening in the future" do
|
|
it "should give the soonest opening order cycle for a distributor" do
|
|
distributor = create(:distributor_enterprise)
|
|
oc = create(:simple_order_cycle, name: 'oc 1', distributors: [distributor],
|
|
orders_open_at: 10.days.from_now, orders_close_at: 11.days.from_now)
|
|
expect(OrderCycle.first_opening_for(distributor)).to eq(oc)
|
|
end
|
|
|
|
it "should return no order cycle when none are impending" do
|
|
distributor = create(:distributor_enterprise)
|
|
expect(OrderCycle.first_opening_for(distributor)).to eq(nil)
|
|
end
|
|
end
|
|
|
|
describe "finding open order cycles" do
|
|
it "should give the soonest closing order cycle for a distributor" do
|
|
distributor = create(:distributor_enterprise)
|
|
oc = create(:simple_order_cycle, name: 'oc 1', distributors: [distributor],
|
|
orders_open_at: 1.day.ago, orders_close_at: 11.days.from_now)
|
|
oc2 = create(:simple_order_cycle, name: 'oc 2', distributors: [distributor],
|
|
orders_open_at: 2.days.ago, orders_close_at: 12.days.from_now)
|
|
expect(OrderCycle.first_closing_for(distributor)).to eq(oc)
|
|
end
|
|
end
|
|
|
|
describe "finding the earliest closing times for each distributor" do
|
|
let(:time1) { 1.week.from_now }
|
|
let(:time2) { 2.weeks.from_now }
|
|
let(:time3) { 3.weeks.from_now }
|
|
let(:e1) { create(:distributor_enterprise) }
|
|
let(:e2) { create(:distributor_enterprise) }
|
|
let!(:oc1) { create(:simple_order_cycle, orders_close_at: time1, distributors: [e1]) }
|
|
let!(:oc2) { create(:simple_order_cycle, orders_close_at: time2, distributors: [e2]) }
|
|
let!(:oc3) { create(:simple_order_cycle, orders_close_at: time3, distributors: [e2]) }
|
|
|
|
it "returns the closing time, indexed by enterprise id" do
|
|
expect(OrderCycle.earliest_closing_times[e1.id].round).to eq(time1.round)
|
|
end
|
|
|
|
it "returns the earliest closing time" do
|
|
expect(OrderCycle.earliest_closing_times[e2.id].round).to eq(time2.round)
|
|
end
|
|
end
|
|
|
|
describe "finding all line items sold by to a user by a given shop" do
|
|
let(:shop) { create(:enterprise) }
|
|
let(:user) { create(:user) }
|
|
let(:oc) { create(:order_cycle) }
|
|
let!(:order) {
|
|
create(:completed_order_with_totals, distributor: shop, user: user, order_cycle: oc)
|
|
}
|
|
let!(:order_from_other_hub) {
|
|
create(:completed_order_with_totals, distributor: create(:enterprise), user: user,
|
|
order_cycle: oc)
|
|
}
|
|
let!(:order_from_other_user) {
|
|
create(:completed_order_with_totals, distributor: shop, user: create(:user), order_cycle: oc)
|
|
}
|
|
let!(:order_from_other_oc) {
|
|
create(:completed_order_with_totals, distributor: shop, user: user,
|
|
order_cycle: create(:order_cycle))
|
|
}
|
|
let!(:order_cancelled) {
|
|
create(:completed_order_with_totals, distributor: shop, user: user, order_cycle: oc)
|
|
}
|
|
|
|
before do
|
|
setup_email
|
|
end
|
|
before { order_cancelled.cancel }
|
|
|
|
it "only returns items from non-cancelled orders in the OC, placed by the user at the shop" do
|
|
items = oc.items_bought_by_user(user, shop)
|
|
expect(items).to match_array order.reload.line_items
|
|
end
|
|
|
|
it "returns items with scoped variants" do
|
|
overridden_variant = order.line_items.first.variant
|
|
create(:variant_override, hub: shop, variant: overridden_variant, count_on_hand: 1000)
|
|
|
|
items = oc.items_bought_by_user(user, shop)
|
|
|
|
expect(items).to match_array order.reload.line_items
|
|
item_with_overridden_variant = items.find { |item| item.variant_id == overridden_variant.id }
|
|
expect(item_with_overridden_variant.variant.on_hand).to eq(1000)
|
|
end
|
|
end
|
|
|
|
describe "version tracking", versioning: true do
|
|
let!(:oc) { create(:sells_own_order_cycle, name: "Original") }
|
|
|
|
it "remembers old versions" do
|
|
expect {
|
|
oc.update!(name: "New name")
|
|
}.to change {
|
|
oc.versions.count
|
|
}.by(1)
|
|
|
|
expect(oc.versions.last.reify.name).to eq "Original"
|
|
end
|
|
|
|
# Needs additional gem:
|
|
# https://github.com/westonganger/paper_trail-association_tracking
|
|
xit "records versions when adding schedules" do
|
|
pending "seems broken with current version"
|
|
|
|
expect {
|
|
# Creating a schedule associates it automatically:
|
|
create(:schedule)
|
|
expect(oc.schedules.count).to eq 1
|
|
}.to change {
|
|
oc.versions.count
|
|
}.by(1)
|
|
end
|
|
|
|
it "records associated schedules" do
|
|
schedule = create(:schedule)
|
|
expect(oc.reload.schedules).to eq [schedule]
|
|
oc.update!(name: "New name")
|
|
|
|
expect(oc.versions.last.custom_data).to eq "[#{schedule.id}]"
|
|
end
|
|
|
|
it "remembers schedules of the previous version" do
|
|
schedule = create(:schedule)
|
|
expect(oc.reload.schedules).to eq [schedule]
|
|
oc.update!(name: "New name", schedules: [])
|
|
|
|
pending "gathering schedule ids before save"
|
|
expect(oc.versions.last.custom_data).to eq "[#{schedule.id}]"
|
|
end
|
|
end
|
|
|
|
describe "syncing subscriptions" do
|
|
let!(:subscription) { create(:subscription, with_items: true) }
|
|
let!(:oc) { subscription.order_cycles.first }
|
|
|
|
before do
|
|
oc.update_columns(orders_open_at: 1.week.ago, orders_close_at: 1.day.ago)
|
|
end
|
|
|
|
it "syncs subscriptions when transitioning from closed to open" do
|
|
expect(OrderManagement::Subscriptions::ProxyOrderSyncer).to receive(:new).and_call_original
|
|
|
|
expect{
|
|
oc.update(orders_close_at: 1.week.from_now)
|
|
}.to change{ ProxyOrder.count }
|
|
end
|
|
|
|
it "syncs subscriptions when transitioning from closed to upcoming" do
|
|
expect(OrderManagement::Subscriptions::ProxyOrderSyncer).to receive(:new).and_call_original
|
|
|
|
expect {
|
|
oc.update(orders_open_at: 1.day.from_now, orders_close_at: 1.week.from_now)
|
|
}.to change{ ProxyOrder.count }
|
|
end
|
|
|
|
context "when the current dates are nil" do
|
|
before { oc.update(orders_open_at: nil, orders_close_at: nil) }
|
|
|
|
it "syncs subscriptions when transitioning from closed to open" do
|
|
expect(OrderManagement::Subscriptions::ProxyOrderSyncer).to receive(:new).and_call_original
|
|
|
|
expect{
|
|
oc.update(orders_open_at: 1.day.ago, orders_close_at: 1.week.from_now)
|
|
}.to change{ ProxyOrder.count }
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "processed_at " do
|
|
let!(:oc) {
|
|
create(:simple_order_cycle, orders_open_at: 1.week.ago, orders_close_at: 1.day.ago, processed_at: 1.hour.ago)
|
|
}
|
|
|
|
it "reset processed_at if close date change in future" do
|
|
expect(oc.processed_at).to_not be_nil
|
|
oc.update!(orders_close_at: 1.week.from_now)
|
|
expect(oc.processed_at).to be_nil
|
|
end
|
|
|
|
it "it does not reset processed_at if close date change in the past" do
|
|
expect(oc.processed_at).to_not be_nil
|
|
oc.update!(orders_close_at: 2.days.ago)
|
|
expect(oc.processed_at).to_not be_nil
|
|
end
|
|
|
|
it "it does not reset processed_at if close date do not change" do
|
|
expect(oc.processed_at).to_not be_nil
|
|
oc.update!(orders_open_at: 2.weeks.ago)
|
|
expect(oc.processed_at).to_not be_nil
|
|
end
|
|
end
|
|
|
|
describe "#attachable_shipping_methods" do
|
|
it "includes shipping methods from the distributors on the order cycle" do
|
|
shipping_method = create(:shipping_method)
|
|
enterprise = create(:enterprise, shipping_methods: [shipping_method])
|
|
oc = create(:simple_order_cycle, distributors: [enterprise])
|
|
|
|
expect(oc.attachable_shipping_methods).to eq([shipping_method])
|
|
end
|
|
|
|
it "does not include backoffice only shipping methods" do
|
|
shipping_method = create(:shipping_method, display_on: "back_end")
|
|
enterprise = create(:enterprise, shipping_methods: [shipping_method])
|
|
oc = create(:simple_order_cycle, distributors: [enterprise])
|
|
|
|
expect(oc.attachable_shipping_methods).to be_empty
|
|
end
|
|
end
|
|
|
|
describe "#simple?" do
|
|
it "returns true if the coordinator sells their own products i.e. shops" do
|
|
order_cycle = build(:simple_order_cycle, coordinator: build(:enterprise, sells: "own"))
|
|
|
|
expect(order_cycle).to be_simple
|
|
end
|
|
|
|
it "returns false if the coordinator can sell other people's products i.e. hubs" do
|
|
order_cycle = build(:simple_order_cycle, coordinator: build(:enterprise, sells: "any"))
|
|
|
|
expect(order_cycle).not_to be_simple
|
|
end
|
|
end
|
|
|
|
def core_exchange_attributes(exchange)
|
|
exterior_attribute_keys = %w(id order_cycle_id created_at updated_at)
|
|
exchange.attributes.
|
|
reject { |k| exterior_attribute_keys.include? k }.
|
|
merge(
|
|
'variant_ids' => exchange.variant_ids.sort,
|
|
'enterprise_fee_ids' => exchange.enterprise_fee_ids.sort
|
|
)
|
|
end
|
|
end
|