raggedstaff/openfoodnetwork
1
0
Fork 0
mirror of https://github.com/openfoodfoundation/openfoodnetwork synced 2026-03-03 02:21:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Replace references to 'standing order' with 'subscription' (spec)

Browse Source
This commit is contained in:
Rob Harrington
2018-02-02 16:45:06 +11:00
parent 04e48989c9
commit b7876ebfbf
25 changed files with 524 additions and 524 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
spec/controllers/admin/proxy_orders_controller_spec.rb
View File

@@ -7,8 +7,8 @@ describe Admin::ProxyOrdersController, type: :controller do
let!(:user) { create(:user, enterprise_limit: 10) }
let!(:shop) { create(:distributor_enterprise) }
let!(:order_cycle) { create(:simple_order_cycle, orders_close_at: 1.day.from_now) }
let!(:standing_order) { create(:standing_order, shop: shop, with_items: true) }
let!(:proxy_order) { create(:proxy_order, standing_order: standing_order, order_cycle: order_cycle) }
let!(:subscription) { create(:subscription, shop: shop, with_items: true) }
let!(:proxy_order) { create(:proxy_order, subscription: subscription, order_cycle: order_cycle) }
before do
allow(controller).to receive(:spree_current_user) { user }
@@ -68,8 +68,8 @@ describe Admin::ProxyOrdersController, type: :controller do
let!(:order_cycle) { create(:simple_order_cycle, orders_close_at: 1.day.from_now) }
let!(:payment_method) { create(:payment_method) }
let!(:shipping_method) { create(:shipping_method) }
let!(:standing_order) { create(:standing_order, shop: shop, with_items: true) }
let!(:proxy_order) { create(:proxy_order, standing_order: standing_order, order_cycle: order_cycle) }
let!(:subscription) { create(:subscription, shop: shop, with_items: true) }
let!(:proxy_order) { create(:proxy_order, subscription: subscription, order_cycle: order_cycle) }
let(:order) { proxy_order.initialise_order! }
before do

200
spec/controllers/admin/subscriptions_controller_spec.rb
View File

@@ -1,11 +1,11 @@
require 'spec_helper'
describe Admin::StandingOrdersController, type: :controller do
describe Admin::SubscriptionsController, type: :controller do
include AuthenticationWorkflow
describe 'index' do
let!(:user) { create(:user, enterprise_limit: 10) }
let!(:shop) { create(:distributor_enterprise, enable_standing_orders: true) }
let!(:shop) { create(:distributor_enterprise, enable_subscriptions: true) }
before do
allow(controller).to receive(:spree_current_user) { user }
@@ -25,8 +25,8 @@ describe Admin::StandingOrdersController, type: :controller do
before { shop.update_attributes(owner: user) }
let!(:not_enabled_shop) { create(:distributor_enterprise, owner: user) }
context "where I manage a shop that is set up for standing orders" do
let!(:standing_order) { create(:standing_order, shop: shop) }
context "where I manage a shop that is set up for subscriptions" do
let!(:subscription) { create(:subscription, shop: shop) }
it 'renders the index page with appropriate data' do
spree_get :index, params
@@ -36,7 +36,7 @@ describe Admin::StandingOrdersController, type: :controller do
end
end
context "where I don't manage a shop that is set up for standing orders" do
context "where I don't manage a shop that is set up for subscriptions" do
it 'renders the setup_explanation page' do
spree_get :index, params
expect(response).to render_template 'setup_explanation'
@@ -49,7 +49,7 @@ describe Admin::StandingOrdersController, type: :controller do
context 'json' do
let(:params) { { format: :json } }
let!(:standing_order) { create(:standing_order, shop: shop) }
let!(:subscription) { create(:subscription, shop: shop) }
context 'as a regular user' do
it 'redirects to unauthorized' do
@@ -61,25 +61,25 @@ describe Admin::StandingOrdersController, type: :controller do
context 'as an enterprise user' do
before { shop.update_attributes(owner: user) }
let!(:shop2) { create(:distributor_enterprise, owner: user) }
let!(:standing_order2) { create(:standing_order, shop: shop2) }
let!(:subscription2) { create(:subscription, shop: shop2) }
it 'renders the collection as json' do
spree_get :index, params
json_response = JSON.parse(response.body)
expect(json_response.count).to be 2
expect(json_response.map{ |so| so['id'] }).to include standing_order.id, standing_order2.id
expect(json_response.map{ |so| so['id'] }).to include subscription.id, subscription2.id
end
context "when ransack predicates are submitted" do
before { params.merge!(q: { shop_id_eq: shop2.id }) }
it "restricts the list of standing orders" do
it "restricts the list of subscriptions" do
spree_get :index, params
json_response = JSON.parse(response.body)
expect(json_response.count).to be 1
ids = json_response.map{ |so| so['id'] }
expect(ids).to include standing_order2.id
expect(ids).to_not include standing_order.id
expect(ids).to include subscription2.id
expect(ids).to_not include subscription.id
end
end
end
@@ -96,9 +96,9 @@ describe Admin::StandingOrdersController, type: :controller do
it 'loads the preloads the necessary data' do
expect(controller).to receive(:load_form_data)
spree_get :new, standing_order: { shop_id: shop.id }
expect(assigns(:standing_order)).to be_a_new StandingOrder
expect(assigns(:standing_order).shop).to eq shop
spree_get :new, subscription: { shop_id: shop.id }
expect(assigns(:subscription)).to be_a_new Subscription
expect(assigns(:subscription).shop).to eq shop
end
end
@@ -110,7 +110,7 @@ describe Admin::StandingOrdersController, type: :controller do
let!(:schedule) { create(:schedule, order_cycles: [order_cycle]) }
let!(:payment_method) { create(:payment_method, distributors: [shop]) }
let!(:shipping_method) { create(:shipping_method, distributors: [shop]) }
let(:params) { { format: :json, standing_order: { shop_id: shop.id } } }
let(:params) { { format: :json, subscription: { shop_id: shop.id } } }
context 'as an non-manager of the specified shop' do
before do
@@ -130,14 +130,14 @@ describe Admin::StandingOrdersController, type: :controller do
context 'when I submit insufficient params' do
it 'returns errors' do
expect{ spree_post :create, params }.to_not change{ StandingOrder.count }
expect{ spree_post :create, params }.to_not change{ Subscription.count }
json_response = JSON.parse(response.body)
expect(json_response['errors'].keys).to include 'schedule', 'customer', 'payment_method', 'shipping_method', 'begins_at'
end
end
context 'when I submit params containing ids of inaccessible objects' do
# As 'user' I shouldnt be able to associate a standing_order with any of these.
# As 'user' I shouldnt be able to associate a subscription with any of these.
let(:unmanaged_enterprise) { create(:enterprise) }
let(:unmanaged_schedule) { create(:schedule, order_cycles: [create(:simple_order_cycle, coordinator: unmanaged_enterprise)]) }
let(:unmanaged_customer) { create(:customer, enterprise: unmanaged_enterprise) }
@@ -145,7 +145,7 @@ describe Admin::StandingOrdersController, type: :controller do
let(:unmanaged_shipping_method) { create(:shipping_method, distributors: [unmanaged_enterprise]) }
before do
params[:standing_order].merge!(
params[:subscription].merge!(
schedule_id: unmanaged_schedule.id,
customer_id: unmanaged_customer.id,
payment_method_id: unmanaged_payment_method.id,
@@ -156,7 +156,7 @@ describe Admin::StandingOrdersController, type: :controller do
end
it 'returns errors' do
expect{ spree_post :create, params }.to_not change{ StandingOrder.count }
expect{ spree_post :create, params }.to_not change{ Subscription.count }
json_response = JSON.parse(response.body)
expect(json_response['errors'].keys).to include 'schedule', 'customer', 'payment_method', 'shipping_method', 'ends_at'
end
@@ -167,7 +167,7 @@ describe Admin::StandingOrdersController, type: :controller do
let(:variant) { create(:variant) }
before do
params[:standing_order].merge!(
params[:subscription].merge!(
schedule_id: schedule.id,
customer_id: customer.id,
payment_method_id: payment_method.id,
@@ -184,7 +184,7 @@ describe Admin::StandingOrdersController, type: :controller do
context 'where the specified variants are not available from the shop' do
it 'returns an error' do
expect{ spree_post :create, params }.to_not change{ StandingOrder.count }
expect{ spree_post :create, params }.to_not change{ Subscription.count }
json_response = JSON.parse(response.body)
expect(json_response['errors']['standing_line_items']).to eq ["#{variant.product.name} - #{variant.full_name} is not available from the selected schedule"]
end
@@ -193,17 +193,17 @@ describe Admin::StandingOrdersController, type: :controller do
context 'where the specified variants are available from the shop' do
let!(:exchange) { create(:exchange, order_cycle: order_cycle, incoming: false, receiver: shop, variants: [variant]) }
it 'creates standing line items for the standing order' do
expect{ spree_post :create, params }.to change{ StandingOrder.count }.by(1)
standing_order = StandingOrder.last
expect(standing_order.schedule).to eq schedule
expect(standing_order.customer).to eq customer
expect(standing_order.payment_method).to eq payment_method
expect(standing_order.shipping_method).to eq shipping_method
expect(standing_order.bill_address.firstname).to eq address.firstname
expect(standing_order.ship_address.firstname).to eq address.firstname
expect(standing_order.standing_line_items.count).to be 1
standing_line_item = standing_order.standing_line_items.first
it 'creates standing line items for the subscription' do
expect{ spree_post :create, params }.to change{ Subscription.count }.by(1)
subscription = Subscription.last
expect(subscription.schedule).to eq schedule
expect(subscription.customer).to eq customer
expect(subscription.payment_method).to eq payment_method
expect(subscription.shipping_method).to eq shipping_method
expect(subscription.bill_address.firstname).to eq address.firstname
expect(subscription.ship_address.firstname).to eq address.firstname
expect(subscription.standing_line_items.count).to be 1
standing_line_item = subscription.standing_line_items.first
expect(standing_line_item.quantity).to be 2
expect(standing_line_item.variant).to eq variant
end
@@ -220,8 +220,8 @@ describe Admin::StandingOrdersController, type: :controller do
let!(:schedule) { create(:schedule, order_cycles: [order_cycle]) }
let!(:payment_method) { create(:payment_method, distributors: [shop]) }
let!(:shipping_method) { create(:shipping_method, distributors: [shop]) }
let!(:standing_order) {
create(:standing_order,
let!(:subscription) {
create(:subscription,
shop: shop,
customer: customer1,
schedule: schedule,
@@ -235,8 +235,8 @@ describe Admin::StandingOrdersController, type: :controller do
it 'loads the preloads the necessary data' do
expect(controller).to receive(:load_form_data)
spree_get :edit, id: standing_order.id
expect(assigns(:standing_order)).to eq standing_order
spree_get :edit, id: subscription.id
expect(assigns(:subscription)).to eq subscription
end
end
@@ -252,8 +252,8 @@ describe Admin::StandingOrdersController, type: :controller do
let!(:schedule) { create(:schedule, order_cycles: [order_cycle]) }
let!(:payment_method) { create(:payment_method, distributors: [shop]) }
let!(:shipping_method) { create(:shipping_method, distributors: [shop]) }
let!(:standing_order) {
create(:standing_order,
let!(:subscription) {
create(:subscription,
shop: shop,
customer: customer,
schedule: schedule,
@@ -261,10 +261,10 @@ describe Admin::StandingOrdersController, type: :controller do
shipping_method: shipping_method,
standing_line_items: [create(:standing_line_item, variant: variant1, quantity: 2)])
}
let(:standing_line_item1) { standing_order.standing_line_items.first }
let(:params) { { format: :json, id: standing_order.id, standing_order: {} } }
let(:standing_line_item1) { subscription.standing_line_items.first }
let(:params) { { format: :json, id: subscription.id, subscription: {} } }
context 'as an non-manager of the standing order shop' do
context 'as an non-manager of the subscription shop' do
before do
allow(controller).to receive(:spree_current_user) { create(:user, enterprises: [create(:enterprise)]) }
end
@@ -275,7 +275,7 @@ describe Admin::StandingOrdersController, type: :controller do
end
end
context 'as a manager of the standing_order shop' do
context 'as a manager of the subscription shop' do
before do
allow(controller).to receive(:spree_current_user) { user }
end
@@ -285,37 +285,37 @@ describe Admin::StandingOrdersController, type: :controller do
let!(:new_schedule) { create(:schedule, order_cycles: [order_cycle]) }
before do
params[:standing_order].merge!(schedule_id: new_schedule.id, customer_id: new_customer.id)
params[:subscription].merge!(schedule_id: new_schedule.id, customer_id: new_customer.id)
end
it 'does not alter customer_id or schedule_id' do
spree_post :update, params
standing_order.reload
expect(standing_order.customer).to eq customer
expect(standing_order.schedule).to eq schedule
subscription.reload
expect(subscription.customer).to eq customer
expect(subscription.schedule).to eq schedule
end
end
context 'when I submit params containing ids of inaccessible objects' do
# As 'user' I shouldnt be able to associate a standing_order with any of these.
# As 'user' I shouldnt be able to associate a subscription with any of these.
let(:unmanaged_enterprise) { create(:enterprise) }
let(:unmanaged_payment_method) { create(:payment_method, distributors: [unmanaged_enterprise]) }
let(:unmanaged_shipping_method) { create(:shipping_method, distributors: [unmanaged_enterprise]) }
before do
params[:standing_order].merge!(
params[:subscription].merge!(
payment_method_id: unmanaged_payment_method.id,
shipping_method_id: unmanaged_shipping_method.id
)
end
it 'returns errors' do
expect{ spree_post :update, params }.to_not change{ StandingOrder.count }
expect{ spree_post :update, params }.to_not change{ Subscription.count }
json_response = JSON.parse(response.body)
expect(json_response['errors'].keys).to include 'payment_method', 'shipping_method'
standing_order.reload
expect(standing_order.payment_method).to eq payment_method
expect(standing_order.shipping_method).to eq shipping_method
subscription.reload
expect(subscription.payment_method).to eq payment_method
expect(subscription.shipping_method).to eq shipping_method
end
end
@@ -324,19 +324,19 @@ describe Admin::StandingOrdersController, type: :controller do
let!(:new_shipping_method) { create(:shipping_method, distributors: [shop]) }
before do
params[:standing_order].merge!(
params[:subscription].merge!(
payment_method_id: new_payment_method.id,
shipping_method_id: new_shipping_method.id
)
end
it 'updates the standing order' do
it 'updates the subscription' do
spree_post :update, params
standing_order.reload
expect(standing_order.schedule).to eq schedule
expect(standing_order.customer).to eq customer
expect(standing_order.payment_method).to eq new_payment_method
expect(standing_order.shipping_method).to eq new_shipping_method
subscription.reload
expect(subscription.schedule).to eq schedule
expect(subscription.customer).to eq customer
expect(subscription.payment_method).to eq new_payment_method
expect(subscription.shipping_method).to eq new_shipping_method
end
context 'with standing_line_items params' do
@@ -349,7 +349,7 @@ describe Admin::StandingOrdersController, type: :controller do
context 'where the specified variants are not available from the shop' do
it 'returns an error' do
expect{ spree_post :update, params }.to_not change{ standing_order.standing_line_items.count }
expect{ spree_post :update, params }.to_not change{ subscription.standing_line_items.count }
json_response = JSON.parse(response.body)
expect(json_response['errors']['standing_line_items']).to eq ["#{product2.name} - #{variant2.full_name} is not available from the selected schedule"]
end
@@ -358,11 +358,11 @@ describe Admin::StandingOrdersController, type: :controller do
context 'where the specified variants are available from the shop' do
before { outgoing_exchange.update_attributes(variants: [variant1, variant2]) }
it 'creates standing line items for the standing order' do
expect{ spree_post :update, params }.to change{ standing_order.standing_line_items.count }.by(1)
standing_order.reload
expect(standing_order.standing_line_items.count).to be 2
standing_line_item = standing_order.standing_line_items.last
it 'creates standing line items for the subscription' do
expect{ spree_post :update, params }.to change{ subscription.standing_line_items.count }.by(1)
subscription.reload
expect(subscription.standing_line_items.count).to be 2
standing_line_item = subscription.standing_line_items.last
expect(standing_line_item.quantity).to be 2
expect(standing_line_item.variant).to eq variant2
end
@@ -376,15 +376,15 @@ describe Admin::StandingOrdersController, type: :controller do
let!(:user) { create(:user, enterprise_limit: 10) }
let!(:shop) { create(:distributor_enterprise) }
let!(:order_cycle) { create(:simple_order_cycle, orders_close_at: 1.day.from_now) }
let!(:standing_order) { create(:standing_order, shop: shop, with_items: true) }
let!(:proxy_order) { create(:proxy_order, standing_order: standing_order, order_cycle: order_cycle) }
let!(:subscription) { create(:subscription, shop: shop, with_items: true) }
let!(:proxy_order) { create(:proxy_order, subscription: subscription, order_cycle: order_cycle) }
before do
allow(controller).to receive(:spree_current_user) { user }
end
context 'json' do
let(:params) { { format: :json, id: standing_order.id } }
let(:params) { { format: :json, id: subscription.id } }
context 'as a regular user' do
it 'redirects to unauthorized' do
@@ -408,8 +408,8 @@ describe Admin::StandingOrdersController, type: :controller do
before { shop.update_attributes(owner: user) }
context "when at least one associated order is still 'open'" do
let(:order_cycle) { standing_order.order_cycles.first }
let(:proxy_order) { create(:proxy_order, standing_order: standing_order, order_cycle: order_cycle) }
let(:order_cycle) { subscription.order_cycles.first }
let(:proxy_order) { create(:proxy_order, subscription: subscription, order_cycle: order_cycle) }
let!(:order) { proxy_order.initialise_order! }
before { while !order.completed? do break unless order.next! end }
@@ -419,19 +419,19 @@ describe Admin::StandingOrdersController, type: :controller do
spree_put :cancel, params
expect(response.status).to be 409
json_response = JSON.parse(response.body)
expect(json_response['errors']['open_orders']).to eq I18n.t('admin.standing_orders.confirm_cancel_open_orders_msg')
expect(json_response['errors']['open_orders']).to eq I18n.t('admin.subscriptions.confirm_cancel_open_orders_msg')
end
end
context "when 'keep' has been provided as the 'open_orders' directive" do
before { params.merge!(open_orders: 'keep') }
it 'renders the cancelled standing_order as json, and does not cancel the open order' do
it 'renders the cancelled subscription as json, and does not cancel the open order' do
spree_put :cancel, params
json_response = JSON.parse(response.body)
expect(json_response['canceled_at']).to_not be nil
expect(json_response['id']).to eq standing_order.id
expect(standing_order.reload.canceled_at).to be_within(5.seconds).of Time.zone.now
expect(json_response['id']).to eq subscription.id
expect(subscription.reload.canceled_at).to be_within(5.seconds).of Time.zone.now
expect(order.reload.state).to eq 'complete'
expect(proxy_order.reload.canceled_at).to be nil
end
@@ -446,12 +446,12 @@ describe Admin::StandingOrdersController, type: :controller do
allow(mail_mock).to receive(:deliver)
end
it 'renders the cancelled standing_order as json, and cancels the open order' do
it 'renders the cancelled subscription as json, and cancels the open order' do
spree_put :cancel, params
json_response = JSON.parse(response.body)
expect(json_response['canceled_at']).to_not be nil
expect(json_response['id']).to eq standing_order.id
expect(standing_order.reload.canceled_at).to be_within(5.seconds).of Time.zone.now
expect(json_response['id']).to eq subscription.id
expect(subscription.reload.canceled_at).to be_within(5.seconds).of Time.zone.now
expect(order.reload.state).to eq 'canceled'
expect(proxy_order.reload.canceled_at).to be_within(5.seconds).of Time.zone.now
expect(mail_mock).to have_received(:deliver)
@@ -460,12 +460,12 @@ describe Admin::StandingOrdersController, type: :controller do
end
context "when no associated orders are still 'open'" do
it 'renders the cancelled standing_order as json' do
it 'renders the cancelled subscription as json' do
spree_put :cancel, params
json_response = JSON.parse(response.body)
expect(json_response['canceled_at']).to_not be nil
expect(json_response['id']).to eq standing_order.id
expect(standing_order.reload.canceled_at).to be_within(5.seconds).of Time.zone.now
expect(json_response['id']).to eq subscription.id
expect(subscription.reload.canceled_at).to be_within(5.seconds).of Time.zone.now
end
end
end
@@ -476,14 +476,14 @@ describe Admin::StandingOrdersController, type: :controller do
describe 'pause' do
let!(:user) { create(:user, enterprise_limit: 10) }
let!(:shop) { create(:distributor_enterprise) }
let!(:standing_order) { create(:standing_order, shop: shop, with_items: true) }
let!(:subscription) { create(:subscription, shop: shop, with_items: true) }
before do
allow(controller).to receive(:spree_current_user) { user }
end
context 'json' do
let(:params) { { format: :json, id: standing_order.id } }
let(:params) { { format: :json, id: subscription.id } }
context 'as a regular user' do
it 'redirects to unauthorized' do
@@ -507,8 +507,8 @@ describe Admin::StandingOrdersController, type: :controller do
before { shop.update_attributes(owner: user) }
context "when at least one associated order is still 'open'" do
let(:order_cycle) { standing_order.order_cycles.first }
let(:proxy_order) { create(:proxy_order, standing_order: standing_order, order_cycle: order_cycle) }
let(:order_cycle) { subscription.order_cycles.first }
let(:proxy_order) { create(:proxy_order, subscription: subscription, order_cycle: order_cycle) }
let!(:order) { proxy_order.initialise_order! }
before { while !order.completed? do break unless order.next! end }
@@ -518,19 +518,19 @@ describe Admin::StandingOrdersController, type: :controller do
spree_put :pause, params
expect(response.status).to be 409
json_response = JSON.parse(response.body)
expect(json_response['errors']['open_orders']).to eq I18n.t('admin.standing_orders.confirm_cancel_open_orders_msg')
expect(json_response['errors']['open_orders']).to eq I18n.t('admin.subscriptions.confirm_cancel_open_orders_msg')
end
end
context "when 'keep' has been provided as the 'open_orders' directive" do
before { params.merge!(open_orders: 'keep') }
it 'renders the paused standing_order as json, and does not cancel the open order' do
it 'renders the paused subscription as json, and does not cancel the open order' do
spree_put :pause, params
json_response = JSON.parse(response.body)
expect(json_response['paused_at']).to_not be nil
expect(json_response['id']).to eq standing_order.id
expect(standing_order.reload.paused_at).to be_within(5.seconds).of Time.zone.now
expect(json_response['id']).to eq subscription.id
expect(subscription.reload.paused_at).to be_within(5.seconds).of Time.zone.now
expect(order.reload.state).to eq 'complete'
expect(proxy_order.reload.canceled_at).to be nil
end
@@ -545,12 +545,12 @@ describe Admin::StandingOrdersController, type: :controller do
allow(mail_mock).to receive(:deliver)
end
it 'renders the paused standing_order as json, and cancels the open order' do
it 'renders the paused subscription as json, and cancels the open order' do
spree_put :pause, params
json_response = JSON.parse(response.body)
expect(json_response['paused_at']).to_not be nil
expect(json_response['id']).to eq standing_order.id
expect(standing_order.reload.paused_at).to be_within(5.seconds).of Time.zone.now
expect(json_response['id']).to eq subscription.id
expect(subscription.reload.paused_at).to be_within(5.seconds).of Time.zone.now
expect(order.reload.state).to eq 'canceled'
expect(proxy_order.reload.canceled_at).to be_within(5.seconds).of Time.zone.now
expect(mail_mock).to have_received(:deliver)
@@ -559,12 +559,12 @@ describe Admin::StandingOrdersController, type: :controller do
end
context "when no associated orders are still 'open'" do
it 'renders the paused standing_order as json' do
it 'renders the paused subscription as json' do
spree_put :pause, params
json_response = JSON.parse(response.body)
expect(json_response['paused_at']).to_not be nil
expect(json_response['id']).to eq standing_order.id
expect(standing_order.reload.paused_at).to be_within(5.seconds).of Time.zone.now
expect(json_response['id']).to eq subscription.id
expect(subscription.reload.paused_at).to be_within(5.seconds).of Time.zone.now
end
end
end
@@ -575,14 +575,14 @@ describe Admin::StandingOrdersController, type: :controller do
describe 'unpause' do
let!(:user) { create(:user, enterprise_limit: 10) }
let!(:shop) { create(:distributor_enterprise) }
let!(:standing_order) { create(:standing_order, shop: shop, paused_at: Time.zone.now, with_items: true) }
let!(:subscription) { create(:subscription, shop: shop, paused_at: Time.zone.now, with_items: true) }
before do
allow(controller).to receive(:spree_current_user) { user }
end
context 'json' do
let(:params) { { format: :json, id: standing_order.id } }
let(:params) { { format: :json, id: subscription.id } }
context 'as a regular user' do
it 'redirects to unauthorized' do
@@ -605,12 +605,12 @@ describe Admin::StandingOrdersController, type: :controller do
context "with authorisation" do
before { shop.update_attributes(owner: user) }
it 'renders the paused standing_order as json' do
it 'renders the paused subscription as json' do
spree_put :unpause, params
json_response = JSON.parse(response.body)
expect(json_response['paused_at']).to be nil
expect(json_response['id']).to eq standing_order.id
expect(standing_order.reload.paused_at).to be nil
expect(json_response['id']).to eq subscription.id
expect(subscription.reload.paused_at).to be nil
end
end
end
@@ -629,7 +629,7 @@ describe Admin::StandingOrdersController, type: :controller do
before do
allow(controller).to receive(:spree_current_user) { user }
controller.instance_variable_set(:@standing_order, StandingOrder.new(shop: shop))
controller.instance_variable_set(:@subscription, Subscription.new(shop: shop))
end
it "assigns data to instance variables" do

24
spec/factories.rb
View File

@@ -138,7 +138,7 @@ FactoryGirl.define do
order_cycles { [OrderCycle.first || FactoryGirl.create(:simple_order_cycle)] }
end
factory :standing_order, :class => StandingOrder do
factory :subscription, :class => Subscription do
shop { create :enterprise }
schedule { create(:schedule, order_cycles: [create(:simple_order_cycle, coordinator: shop)]) }
customer { create(:customer, enterprise: shop) }
@@ -153,33 +153,33 @@ FactoryGirl.define do
with_proxy_orders false
end
after(:create) do |standing_order, proxy|
after(:create) do |subscription, proxy|
if proxy.with_items
standing_order.standing_line_items = build_list(:standing_line_item, 3, standing_order: standing_order)
standing_order.order_cycles.each do |oc|
ex = oc.exchanges.outgoing.find_by_sender_id_and_receiver_id(standing_order.shop_id, standing_order.shop_id) ||
create(:exchange, :order_cycle => oc, :sender => standing_order.shop, :receiver => standing_order.shop, :incoming => false, :pickup_time => 'time', :pickup_instructions => 'instructions')
standing_order.standing_line_items.each { |sli| ex.variants << sli.variant }
subscription.standing_line_items = build_list(:standing_line_item, 3, subscription: subscription)
subscription.order_cycles.each do |oc|
ex = oc.exchanges.outgoing.find_by_sender_id_and_receiver_id(subscription.shop_id, subscription.shop_id) ||
create(:exchange, :order_cycle => oc, :sender => subscription.shop, :receiver => subscription.shop, :incoming => false, :pickup_time => 'time', :pickup_instructions => 'instructions')
subscription.standing_line_items.each { |sli| ex.variants << sli.variant }
end
end
if proxy.with_proxy_orders
standing_order.order_cycles.each do |oc|
standing_order.proxy_orders << create(:proxy_order, standing_order: standing_order, order_cycle: oc)
subscription.order_cycles.each do |oc|
subscription.proxy_orders << create(:proxy_order, subscription: subscription, order_cycle: oc)
end
end
end
end
factory :standing_line_item, :class => StandingLineItem do
standing_order
subscription
variant
quantity 1
end
factory :proxy_order, :class => ProxyOrder do
standing_order
order_cycle { standing_order.order_cycles.first }
subscription
order_cycle { subscription.order_cycles.first }
before(:create) do |proxy_order, proxy|
if proxy_order.order
proxy_order.order.update_attribute(:order_cycle_id, proxy_order.order_cycle_id)

2
spec/features/admin/enterprises_spec.rb
View File

@@ -91,7 +91,7 @@ feature %q{
expect(page).to have_checked_field "enterprise_allow_guest_orders_true"
choose "Visible to registered customers only"
expect(page).to have_no_checked_field "enterprise_require_login_false"
# expect(page).to have_checked_field "enterprise_enable_standing_orders_false"
# expect(page).to have_checked_field "enterprise_enable_subscriptions_false"
within(".side_menu") { click_link "Users" }
select2_search user.email, from: 'Owner'

4
spec/features/admin/order_cycles_spec.rb
View File

@@ -702,7 +702,7 @@ feature %q{
end
scenario "creating a new order cycle" do
distributor_managed.update_attribute(:enable_standing_orders, true)
distributor_managed.update_attribute(:enable_subscriptions, true)
# Make the page long enough to avoid the save bar overlaying the form
page.driver.resize(1280, 2000)
@@ -796,7 +796,7 @@ feature %q{
scenario "editing an order cycle" do
oc = create(:simple_order_cycle, { suppliers: [supplier_managed, supplier_permitted, supplier_unmanaged], coordinator: distributor_managed, distributors: [distributor_managed, distributor_permitted, distributor_unmanaged], name: 'Order Cycle 1' } )
distributor_managed.update_attribute(:enable_standing_orders, true)
distributor_managed.update_attribute(:enable_subscriptions, true)
visit edit_admin_order_cycle_path(oc)

6
spec/features/admin/schedules_spec.rb
View File

@@ -6,9 +6,9 @@ feature 'Schedules', js: true do
context "as an enterprise user" do
let(:user) { create(:user, enterprise_limit: 10) }
let(:managed_enterprise) { create(:distributor_enterprise, owner: user, enable_standing_orders: true) }
let(:unmanaged_enterprise) { create(:distributor_enterprise, enable_standing_orders: true) }
let(:managed_enterprise2) { create(:distributor_enterprise, owner: user, enable_standing_orders: true) }
let(:managed_enterprise) { create(:distributor_enterprise, owner: user, enable_subscriptions: true) }
let(:unmanaged_enterprise) { create(:distributor_enterprise, enable_subscriptions: true) }
let(:managed_enterprise2) { create(:distributor_enterprise, owner: user, enable_subscriptions: true) }
let!(:oc1) { create(:simple_order_cycle, coordinator: managed_enterprise, name: 'oc1') }
let!(:oc2) { create(:simple_order_cycle, coordinator: managed_enterprise, name: 'oc2') }
let!(:oc3) { create(:simple_order_cycle, coordinator: managed_enterprise, name: 'oc3') }

134
spec/features/admin/subscriptions_spec.rb
View File

@@ -6,16 +6,16 @@ feature 'Standing Orders' do
context "as an enterprise user", js: true do
let!(:user) { create_enterprise_user(enterprise_limit: 10) }
let!(:shop) { create(:distributor_enterprise, owner: user, enable_standing_orders: true) }
let!(:shop2) { create(:distributor_enterprise, owner: user, enable_standing_orders: true) }
let!(:shop_unmanaged) { create(:distributor_enterprise, enable_standing_orders: true) }
let!(:shop) { create(:distributor_enterprise, owner: user, enable_subscriptions: true) }
let!(:shop2) { create(:distributor_enterprise, owner: user, enable_subscriptions: true) }
let!(:shop_unmanaged) { create(:distributor_enterprise, enable_subscriptions: true) }
before { quick_login_as user }
context 'listing standing orders' do
let!(:standing_order) { create(:standing_order, shop: shop, with_items: true, with_proxy_orders: true) }
let!(:standing_order2) { create(:standing_order, shop: shop2, with_items: true, with_proxy_orders: true) }
let!(:standing_order_unmanaged) { create(:standing_order, shop: shop_unmanaged, with_items: true, with_proxy_orders: true) }
context 'listing subscriptions' do
let!(:subscription) { create(:subscription, shop: shop, with_items: true, with_proxy_orders: true) }
let!(:subscription2) { create(:subscription, shop: shop2, with_items: true, with_proxy_orders: true) }
let!(:subscription_unmanaged) { create(:subscription, shop: shop_unmanaged, with_items: true, with_proxy_orders: true) }
it "passes the smoke test" do
visit spree.admin_path
@@ -26,42 +26,42 @@ feature 'Standing Orders' do
select2_select shop2.name, from: "shop_id"
# Loads the right standing orders
expect(page).to have_selector "tr#so_#{standing_order2.id}"
expect(page).to have_no_selector "tr#so_#{standing_order.id}"
expect(page).to have_no_selector "tr#so_#{standing_order_unmanaged.id}"
within "tr#so_#{standing_order2.id}" do
expect(page).to have_selector "td.customer", text: standing_order2.customer.email
# Loads the right subscriptions
expect(page).to have_selector "tr#so_#{subscription2.id}"
expect(page).to have_no_selector "tr#so_#{subscription.id}"
expect(page).to have_no_selector "tr#so_#{subscription_unmanaged.id}"
within "tr#so_#{subscription2.id}" do
expect(page).to have_selector "td.customer", text: subscription2.customer.email
end
# Changing Shops
select2_select shop.name, from: "shop_id"
# Loads the right standing orders
expect(page).to have_selector "tr#so_#{standing_order.id}"
expect(page).to have_no_selector "tr#so_#{standing_order2.id}"
expect(page).to have_no_selector "tr#so_#{standing_order_unmanaged.id}"
within "tr#so_#{standing_order.id}" do
expect(page).to have_selector "td.customer", text: standing_order.customer.email
# Loads the right subscriptions
expect(page).to have_selector "tr#so_#{subscription.id}"
expect(page).to have_no_selector "tr#so_#{subscription2.id}"
expect(page).to have_no_selector "tr#so_#{subscription_unmanaged.id}"
within "tr#so_#{subscription.id}" do
expect(page).to have_selector "td.customer", text: subscription.customer.email
end
# Using the Quick Search
expect(page).to have_selector "tr#so_#{standing_order.id}"
expect(page).to have_selector "tr#so_#{subscription.id}"
fill_in 'query', with: 'blah blah blah'
expect(page).to have_no_selector "tr#so_#{standing_order.id}"
expect(page).to have_no_selector "tr#so_#{subscription.id}"
fill_in 'query', with: ''
expect(page).to have_selector "tr#so_#{standing_order.id}"
expect(page).to have_selector "tr#so_#{subscription.id}"
# Toggling columns
expect(page).to have_selector "th.customer"
expect(page).to have_content standing_order.customer.email
expect(page).to have_content subscription.customer.email
first("div#columns-dropdown", :text => "COLUMNS").click
first("div#columns-dropdown div.menu div.menu_item", text: "Customer").click
expect(page).to_not have_selector "th.customer"
expect(page).to_not have_content standing_order.customer.email
expect(page).to_not have_content subscription.customer.email
# Viewing Orders
within "tr#so_#{standing_order.id}" do
within "tr#so_#{subscription.id}" do
expect(page).to have_selector "td.orders.panel-toggle", text: 1
page.find("td.orders.panel-toggle").trigger('click')
end
@@ -69,7 +69,7 @@ feature 'Standing Orders' do
within ".standing-order-orders" do
expect(page).to have_selector "tr.proxy_order", count: 1
proxy_order = standing_order.proxy_orders.first
proxy_order = subscription.proxy_orders.first
within "tr#po_#{proxy_order.id}" do
expect(page).to_not have_content 'CANCELLED'
accept_alert 'Are you sure?' do
@@ -88,39 +88,39 @@ feature 'Standing Orders' do
end
end
# Pausing a standing order
within "tr#so_#{standing_order.id}" do
# Pausing a subscription
within "tr#so_#{subscription.id}" do
find("a.pause-standing-order").click
end
click_button "Yes, I'm sure"
within "tr#so_#{standing_order.id}" do
within "tr#so_#{subscription.id}" do
expect(page).to have_selector ".state.paused", text: "PAUSED"
expect(standing_order.reload.paused_at).to be_within(5.seconds).of Time.zone.now
expect(subscription.reload.paused_at).to be_within(5.seconds).of Time.zone.now
end
# Unpausing a standing order
within "tr#so_#{standing_order.id}" do
# Unpausing a subscription
within "tr#so_#{subscription.id}" do
find("a.unpause-standing-order").click
end
click_button "Yes, I'm sure"
within "tr#so_#{standing_order.id}" do
within "tr#so_#{subscription.id}" do
expect(page).to have_selector ".state.active", text: "ACTIVE"
expect(standing_order.reload.paused_at).to be nil
expect(subscription.reload.paused_at).to be nil
end
# Cancelling a standing order
within "tr#so_#{standing_order.id}" do
# Cancelling a subscription
within "tr#so_#{subscription.id}" do
find("a.cancel-standing-order").click
end
click_button "Yes, I'm sure"
within "tr#so_#{standing_order.id}" do
within "tr#so_#{subscription.id}" do
expect(page).to have_selector ".state.canceled", text: "CANCELLED"
expect(standing_order.reload.canceled_at).to be_within(5.seconds).of Time.zone.now
expect(subscription.reload.canceled_at).to be_within(5.seconds).of Time.zone.now
end
end
end
context 'creating a new standing order' do
context 'creating a new subscription' do
let(:address) { create(:address) }
let!(:customer_user) { create(:user) }
let!(:credit_card1) { create(:credit_card, user: customer_user, cc_type: 'visa', last_digits: 1111, month: 10, year: 2030) }
@@ -139,9 +139,9 @@ feature 'Standing Orders' do
let!(:shipping_method) { create(:shipping_method, distributors: [shop]) }
it "passes the smoke test" do
visit admin_standing_orders_path
visit admin_subscriptions_path
click_link 'New Standing Order'
select2_select shop.name, from: 'new_standing_order_shop_id'
select2_select shop.name, from: 'new_subscription_shop_id'
click_button 'Continue'
select2_select customer.email, from: 'customer_id'
@@ -222,7 +222,7 @@ feature 'Standing Orders' do
expect{
click_button('Create Standing Order')
expect(page).to have_content 'Please add at least one product'
}.to_not change(StandingOrder, :count)
}.to_not change(Subscription, :count)
# Adding a new product
targetted_select2_search product2.name, from: '#add_variant_id', dropdown_css: '.select2-drop'
@@ -238,7 +238,7 @@ feature 'Standing Orders' do
expect{
click_button('Create Standing Order')
expect(page).to have_content 'Saved'
}.to change(StandingOrder, :count).by(1)
}.to change(Subscription, :count).by(1)
# Prices are shown
within 'table#standing-line-items tr.item', match: :first do
@@ -248,24 +248,24 @@ feature 'Standing Orders' do
expect(page).to have_selector 'td.total', text: "$23.25"
end
# Basic properties of standing order are set
standing_order = StandingOrder.last
expect(standing_order.customer).to eq customer
expect(standing_order.schedule).to eq schedule
expect(standing_order.payment_method).to eq payment_method
expect(standing_order.shipping_method).to eq shipping_method
expect(standing_order.bill_address.firstname).to eq 'Freda'
expect(standing_order.ship_address.firstname).to eq 'Freda'
expect(standing_order.credit_card_id).to eq credit_card2.id
# Basic properties of subscription are set
subscription = Subscription.last
expect(subscription.customer).to eq customer
expect(subscription.schedule).to eq schedule
expect(subscription.payment_method).to eq payment_method
expect(subscription.shipping_method).to eq shipping_method
expect(subscription.bill_address.firstname).to eq 'Freda'
expect(subscription.ship_address.firstname).to eq 'Freda'
expect(subscription.credit_card_id).to eq credit_card2.id
# Standing Line Items are created
expect(standing_order.standing_line_items.count).to eq 1
standing_line_item = standing_order.standing_line_items.first
expect(subscription.standing_line_items.count).to eq 1
standing_line_item = subscription.standing_line_items.first
expect(standing_line_item.variant).to eq variant2
expect(standing_line_item.quantity).to eq 3
end
context 'editing an existing standing order' do
context 'editing an existing subscription' do
let!(:customer) { create(:customer, enterprise: shop) }
let!(:product1) { create(:product, supplier: shop) }
let!(:product2) { create(:product, supplier: shop) }
@@ -281,8 +281,8 @@ feature 'Standing Orders' do
let!(:variant3_ex) { variant3_oc.exchanges.create(sender: shop, receiver: shop, variants: [variant3]) }
let!(:payment_method) { create(:payment_method, distributors: [shop]) }
let!(:shipping_method) { create(:shipping_method, distributors: [shop]) }
let!(:standing_order) {
create(:standing_order,
let!(:subscription) {
create(:subscription,
shop: shop,
customer: customer,
schedule: schedule,
@@ -293,7 +293,7 @@ feature 'Standing Orders' do
}
it "passes the smoke test" do
visit edit_admin_standing_order_path(standing_order)
visit edit_admin_subscription_path(subscription)
# Customer and Schedule cannot be edited
expect(page).to have_selector '#s2id_customer_id.select2-container-disabled'
@@ -306,7 +306,7 @@ feature 'Standing Orders' do
expect(page).to have_input 'quantity', with: "2"
expect(page).to have_selector 'td.total', text: "$27.50"
# Remove variant1 from the standing order
# Remove variant1 from the subscription
find("a.delete-item").click
end
@@ -314,7 +314,7 @@ feature 'Standing Orders' do
click_button 'Save Changes'
expect(page).to have_content 'Please add at least one product'
# Add variant2 to the standing order
# Add variant2 to the subscription
targetted_select2_search product2.name, from: '#add_variant_id', dropdown_css: '.select2-drop'
fill_in 'add_quantity', with: 1
click_link 'Add'
@@ -328,7 +328,7 @@ feature 'Standing Orders' do
# Total should be $7.75
expect(page).to have_selector '#order_form_total', text: "$7.75"
# Add variant3 to the standing order (even though it is not available)
# Add variant3 to the subscription (even though it is not available)
targetted_select2_search product3.name, from: '#add_variant_id', dropdown_css: '.select2-drop'
fill_in 'add_quantity', with: 1
click_link 'Add'
@@ -345,7 +345,7 @@ feature 'Standing Orders' do
click_button 'Save Changes'
expect(page).to have_content "#{product3.name} - #{variant3.full_name} is not available from the selected schedule"
# Remove variant3 from the standing order
# Remove variant3 from the subscription
within '#sli_1' do
find("a.delete-item").click
end
@@ -356,19 +356,19 @@ feature 'Standing Orders' do
# Total should be $7.75
expect(page).to have_selector '#order_form_total', text: "$7.75"
expect(page).to have_selector 'tr.item', count: 1
expect(standing_order.reload.standing_line_items.length).to eq 1
expect(standing_order.standing_line_items.first.variant).to eq variant2
expect(subscription.reload.standing_line_items.length).to eq 1
expect(subscription.standing_line_items.first.variant).to eq variant2
end
context "with initialised order that has been changed" do
let(:proxy_order) { standing_order.proxy_orders.first }
let(:proxy_order) { subscription.proxy_orders.first }
let(:order) { proxy_order.initialise_order! }
let(:line_item) { order.line_items.first }
before { line_item.update_attributes(quantity: 3) }
it "reports issues encountered during the update" do
visit edit_admin_standing_order_path(standing_order)
visit edit_admin_subscription_path(subscription)
within "#sli_0" do
fill_in 'quantity', with: "1"
@@ -377,7 +377,7 @@ feature 'Standing Orders' do
click_button 'Save Changes'
expect(page).to have_content 'Saved'
expect(page).to have_selector "#order_update_issues_dialog .message", text: I18n.t("admin.standing_orders.order_update_issues_msg")
expect(page).to have_selector "#order_update_issues_dialog .message", text: I18n.t("admin.subscriptions.order_update_issues_msg")
end
end
end

16
spec/helpers/admin/subscriptions_helper_spec.rb
View File

@@ -1,6 +1,6 @@
require 'spec_helper'
describe Admin::StandingOrdersHelper, type: :helper do
describe Admin::SubscriptionsHelper, type: :helper do
describe "checking if setup is complete for any [shop]" do
let(:shop) { create(:distributor_enterprise) }
let(:customer) { create(:customer, enterprise: shop) }
@@ -10,23 +10,23 @@ describe Admin::StandingOrdersHelper, type: :helper do
context "when a shop has no shipping methods present" do
before { customer; payment_method; schedule }
it { expect(helper.standing_orders_setup_complete?([shop])).to be false }
it { expect(helper.subscriptions_setup_complete?([shop])).to be false }
end
context "when a shop has no Cash or Stripe payment methods present" do
let!(:paypal) { Spree::Gateway::PayPalExpress.create!(name: "PayPalExpress", distributor_ids: [shop.id]) }
before { customer; shipping_method; schedule }
it { expect(helper.standing_orders_setup_complete?([shop])).to be false }
it { expect(helper.subscriptions_setup_complete?([shop])).to be false }
end
context "when a shop has no customers present" do
before { shipping_method; payment_method; schedule }
it { expect(helper.standing_orders_setup_complete?([shop])).to be false }
it { expect(helper.subscriptions_setup_complete?([shop])).to be false }
end
context "when a shop does not coordinate any schedules" do
before { customer; shipping_method; payment_method; }
it { expect(helper.standing_orders_setup_complete?([shop])).to be false }
it { expect(helper.subscriptions_setup_complete?([shop])).to be false }
end
context "when a shop meets all requirements" do
@@ -34,15 +34,15 @@ describe Admin::StandingOrdersHelper, type: :helper do
let(:some_other_shop) { create(:distributor_enterprise) }
context "but it is not passed in" do
it { expect(helper.standing_orders_setup_complete?([some_other_shop])).to be false }
it { expect(helper.subscriptions_setup_complete?([some_other_shop])).to be false }
end
context "and it is passed in" do
it { expect(helper.standing_orders_setup_complete?([shop])).to be true }
it { expect(helper.subscriptions_setup_complete?([shop])).to be true }
end
context "and it is passed in with other shops that do not meet the requirements" do
it { expect(helper.standing_orders_setup_complete?([shop, some_other_shop])).to be true }
it { expect(helper.subscriptions_setup_complete?([shop, some_other_shop])).to be true }
end
end
end

30
spec/jobs/subscription_confirm_job_spec.rb
View File

@@ -1,15 +1,15 @@
require 'spec_helper'
describe StandingOrderConfirmJob do
let(:job) { StandingOrderConfirmJob.new }
describe SubscriptionConfirmJob do
let(:job) { SubscriptionConfirmJob.new }
describe "finding proxy_orders that are ready to be confirmed" do
let(:shop) { create(:distributor_enterprise) }
let(:order_cycle1) { create(:simple_order_cycle, coordinator: shop, orders_close_at: 59.minutes.ago, updated_at: 1.day.ago) }
let(:order_cycle2) { create(:simple_order_cycle, coordinator: shop, orders_close_at: 61.minutes.ago, updated_at: 1.day.ago) }
let(:schedule) { create(:schedule, order_cycles: [order_cycle1, order_cycle2]) }
let(:standing_order) { create(:standing_order, shop: shop, schedule: schedule) }
let!(:proxy_order) { create(:proxy_order, standing_order: standing_order, order_cycle: order_cycle1, placed_at: 5.minutes.ago, order: create(:order, completed_at: 1.minute.ago)) }
let(:subscription) { create(:subscription, shop: shop, schedule: schedule) }
let!(:proxy_order) { create(:proxy_order, subscription: subscription, order_cycle: order_cycle1, placed_at: 5.minutes.ago, order: create(:order, completed_at: 1.minute.ago)) }
let(:proxy_orders) { job.send(:proxy_orders) }
it "returns proxy orders that meet all of the criteria" do
@@ -21,13 +21,13 @@ describe StandingOrderConfirmJob do
expect(proxy_orders).to_not include proxy_order
end
it "ignores proxy orders for paused standing orders" do
standing_order.update_attributes!(paused_at: 1.minute.ago)
it "ignores proxy orders for paused subscriptions" do
subscription.update_attributes!(paused_at: 1.minute.ago)
expect(proxy_orders).to_not include proxy_order
end
it "ignores proxy orders for cancelled standing orders" do
standing_order.update_attributes!(canceled_at: 1.minute.ago)
it "ignores proxy orders for cancelled subscriptions" do
subscription.update_attributes!(canceled_at: 1.minute.ago)
expect(proxy_orders).to_not include proxy_order
end
@@ -106,8 +106,8 @@ describe StandingOrderConfirmJob do
let(:order_cycle1) { create(:simple_order_cycle, coordinator: shop) }
let(:order_cycle2) { create(:simple_order_cycle, coordinator: shop) }
let(:schedule1) { create(:schedule, order_cycles: [order_cycle1, order_cycle2]) }
let(:standing_order1) { create(:standing_order, shop: shop, schedule: schedule1, with_items: true) }
let(:proxy_order) { create(:proxy_order, standing_order: standing_order1) }
let(:subscription1) { create(:subscription, shop: shop, schedule: schedule1, with_items: true) }
let(:proxy_order) { create(:proxy_order, subscription: subscription1) }
let(:order) { proxy_order.initialise_order! }
before do
@@ -162,7 +162,7 @@ describe StandingOrderConfirmJob do
expect(payment).to receive(:completed?) { true }
end
it "sends only a standing order confirm email, no regular confirmation emails" do
it "sends only a subscription confirm email, no regular confirmation emails" do
ActionMailer::Base.deliveries.clear
expect{ job.send(:process!) }.to_not enqueue_job ConfirmOrderJob
expect(job).to have_received(:send_confirm_email).once
@@ -179,13 +179,13 @@ describe StandingOrderConfirmJob do
before do
job.instance_variable_set(:@order, order)
allow(StandingOrderMailer).to receive(:confirmation_email) { mail_mock }
allow(SubscriptionMailer).to receive(:confirmation_email) { mail_mock }
end
it "records a success and sends the email" do
expect(job).to receive(:record_success).with(order).once
job.send(:send_confirm_email)
expect(StandingOrderMailer).to have_received(:confirmation_email).with(order)
expect(SubscriptionMailer).to have_received(:confirmation_email).with(order)
expect(mail_mock).to have_received(:deliver)
end
end
@@ -196,13 +196,13 @@ describe StandingOrderConfirmJob do
before do
job.instance_variable_set(:@order, order)
allow(StandingOrderMailer).to receive(:failed_payment_email) { mail_mock }
allow(SubscriptionMailer).to receive(:failed_payment_email) { mail_mock }
end
it "records and logs an error and sends the email" do
expect(job).to receive(:record_and_log_error).with(:failed_payment, order).once
job.send(:send_failed_payment_email)
expect(StandingOrderMailer).to have_received(:failed_payment_email).with(order)
expect(SubscriptionMailer).to have_received(:failed_payment_email).with(order)
expect(mail_mock).to have_received(:deliver)
end
end

32
spec/jobs/subscription_placement_job_spec.rb
View File

@@ -1,15 +1,15 @@
require 'spec_helper'
describe StandingOrderPlacementJob do
let(:job) { StandingOrderPlacementJob.new }
describe SubscriptionPlacementJob do
let(:job) { SubscriptionPlacementJob.new }
describe "finding proxy_orders that are ready to be placed" do
let(:shop) { create(:distributor_enterprise) }
let(:order_cycle1) { create(:simple_order_cycle, coordinator: shop, orders_open_at: 1.minute.ago, orders_close_at: 10.minutes.from_now) }
let(:order_cycle2) { create(:simple_order_cycle, coordinator: shop, orders_open_at: 10.minutes.ago, orders_close_at: 1.minute.ago) }
let(:schedule) { create(:schedule, order_cycles: [order_cycle1, order_cycle2]) }
let(:standing_order) { create(:standing_order, shop: shop, schedule: schedule) }
let!(:proxy_order) { create(:proxy_order, standing_order: standing_order, order_cycle: order_cycle1) } # OK
let(:subscription) { create(:subscription, shop: shop, schedule: schedule) }
let!(:proxy_order) { create(:proxy_order, subscription: subscription, order_cycle: order_cycle1) } # OK
it "ignores proxy orders where the OC has closed" do
expect(job.send(:proxy_orders)).to include proxy_order
@@ -17,13 +17,13 @@ describe StandingOrderPlacementJob do
expect(job.send(:proxy_orders)).to_not include proxy_order
end
it "ignores proxy orders for paused or cancelled standing orders" do
it "ignores proxy orders for paused or cancelled subscriptions" do
expect(job.send(:proxy_orders)).to include proxy_order
standing_order.update_attributes!(paused_at: 1.minute.ago)
subscription.update_attributes!(paused_at: 1.minute.ago)
expect(job.send(:proxy_orders)).to_not include proxy_order
standing_order.update_attributes!(paused_at: nil)
subscription.update_attributes!(paused_at: nil)
expect(job.send(:proxy_orders)).to include proxy_order
standing_order.update_attributes!(canceled_at: 1.minute.ago)
subscription.update_attributes!(canceled_at: 1.minute.ago)
expect(job.send(:proxy_orders)).to_not include proxy_order
end
@@ -118,9 +118,9 @@ describe StandingOrderPlacementJob do
end
end
describe "processing a standing order order" do
let(:standing_order) { create(:standing_order, with_items: true) }
let(:proxy_order) { create(:proxy_order, standing_order: standing_order) }
describe "processing a subscription order" do
let(:subscription) { create(:subscription, with_items: true) }
let(:proxy_order) { create(:proxy_order, subscription: subscription) }
let!(:order) { proxy_order.initialise_order! }
before do
@@ -186,7 +186,7 @@ describe StandingOrderPlacementJob do
let(:mail_mock) { double(:mailer_mock, deliver: true) }
before do
allow(StandingOrderMailer).to receive(:placement_email) { mail_mock }
allow(SubscriptionMailer).to receive(:placement_email) { mail_mock }
end
context "when changes are present" do
@@ -195,7 +195,7 @@ describe StandingOrderPlacementJob do
it "logs an issue and sends the email" do
expect(job).to receive(:record_issue).with(:changes, order).once
job.send(:send_placement_email, order, changes)
expect(StandingOrderMailer).to have_received(:placement_email).with(order, changes)
expect(SubscriptionMailer).to have_received(:placement_email).with(order, changes)
expect(mail_mock).to have_received(:deliver)
end
end
@@ -206,7 +206,7 @@ describe StandingOrderPlacementJob do
it "logs a success and sends the email" do
expect(job).to receive(:record_success).with(order).once
job.send(:send_placement_email, order, changes)
expect(StandingOrderMailer).to have_received(:placement_email)
expect(SubscriptionMailer).to have_received(:placement_email)
expect(mail_mock).to have_received(:deliver)
end
end
@@ -218,13 +218,13 @@ describe StandingOrderPlacementJob do
let(:mail_mock) { double(:mailer_mock, deliver: true) }
before do
allow(StandingOrderMailer).to receive(:empty_email) { mail_mock }
allow(SubscriptionMailer).to receive(:empty_email) { mail_mock }
end
it "logs an issue and sends the email" do
expect(job).to receive(:record_issue).with(:empty, order).once
job.send(:send_empty_email, order, changes)
expect(StandingOrderMailer).to have_received(:empty_email).with(order, changes)
expect(SubscriptionMailer).to have_received(:empty_email).with(order, changes)
expect(mail_mock).to have_received(:deliver)
end
end

10
spec/lib/open_food_network/permissions_spec.rb
View File

@@ -395,14 +395,14 @@ module OpenFoodNetwork
end
end
describe "finding visible standing orders" do
let!(:so1) { create(:standing_order) }
let!(:so2) { create(:standing_order) }
describe "finding visible subscriptions" do
let!(:so1) { create(:subscription) }
let!(:so2) { create(:subscription) }
it "returns standing orders placed with managed shops" do
it "returns subscriptions placed with managed shops" do
expect(permissions).to receive(:managed_enterprises) { [so1.shop] }
expect(permissions.visible_standing_orders).to eq [so1]
expect(permissions.visible_subscriptions).to eq [so1]
end
end
end

56
spec/lib/open_food_network/proxy_order_syncer_spec.rb
View File

@@ -3,75 +3,75 @@ require 'open_food_network/proxy_order_syncer'
module OpenFoodNetwork
describe ProxyOrderSyncer do
describe "initialization" do
let!(:standing_order) { create(:standing_order) }
let!(:subscription) { create(:subscription) }
it "raises an error when initialized with an object that is not a StandingOrder or an ActiveRecord::Relation" do
expect{ ProxyOrderSyncer.new(standing_order) }.to_not raise_error
expect{ ProxyOrderSyncer.new(StandingOrder.where(id: standing_order.id)) }.to_not raise_error
it "raises an error when initialized with an object that is not a Subscription or an ActiveRecord::Relation" do
expect{ ProxyOrderSyncer.new(subscription) }.to_not raise_error
expect{ ProxyOrderSyncer.new(Subscription.where(id: subscription.id)) }.to_not raise_error
expect{ ProxyOrderSyncer.new("something") }.to raise_error RuntimeError
end
end
describe "updating proxy_orders on a standing orders" do
describe "updating proxy_orders on a subscriptions" do
let(:now) { Time.zone.now }
let!(:schedule) { create(:schedule) }
let!(:standing_order) { create(:standing_order, schedule: schedule, begins_at: now + 1.minute, ends_at: now + 2.minutes) }
let!(:subscription) { create(:subscription, schedule: schedule, begins_at: now + 1.minute, ends_at: now + 2.minutes) }
let!(:oc1) { create(:simple_order_cycle, schedules: [schedule], orders_open_at: now - 1.minute, orders_close_at: now) } # Closed
let!(:oc2) { create(:simple_order_cycle, schedules: [schedule], orders_open_at: now - 1.minute, orders_close_at: now + 59.seconds) } # Open, but closes before begins at
let!(:oc3) { create(:simple_order_cycle, schedules: [schedule], orders_open_at: now - 1.minute, orders_close_at: now + 1.minute) } # Open + closes on begins at
let!(:oc4) { create(:simple_order_cycle, schedules: [schedule], orders_open_at: now - 1.minute, orders_close_at: now + 2.minutes) } # Open + closes on ends at
let!(:oc5) { create(:simple_order_cycle, schedules: [schedule], orders_open_at: now - 1.minute, orders_close_at: now + 121.seconds) } # Open + closes after ends at
let(:syncer) { ProxyOrderSyncer.new(standing_order) }
let(:syncer) { ProxyOrderSyncer.new(subscription) }
describe "#sync!" do
let!(:oc6) { create(:simple_order_cycle, schedules: [schedule], orders_open_at: now - 1.minute, orders_close_at: now + 59.seconds) } # Open, but closes before begins at
let!(:oc7) { create(:simple_order_cycle, schedules: [schedule], orders_open_at: now - 1.minute, orders_close_at: now + 61.seconds) } # Open + closes on begins at
let!(:oc8) { create(:simple_order_cycle, schedules: [schedule], orders_open_at: now - 1.minute, orders_close_at: now + 121.seconds) } # Open + closes after ends at
let!(:po1) { create(:proxy_order, standing_order: standing_order, order_cycle: oc6) }
let!(:po2) { create(:proxy_order, standing_order: standing_order, order_cycle: oc7) }
let!(:po3) { create(:proxy_order, standing_order: standing_order, order_cycle: oc8) }
let!(:po1) { create(:proxy_order, subscription: subscription, order_cycle: oc6) }
let!(:po2) { create(:proxy_order, subscription: subscription, order_cycle: oc7) }
let!(:po3) { create(:proxy_order, subscription: subscription, order_cycle: oc8) }
it "performs both create and remove actions to rectify proxy orders" do
expect(syncer).to receive(:create_proxy_orders!).and_call_original
expect(syncer).to receive(:remove_obsolete_proxy_orders!).and_call_original
syncer.sync!
standing_order.reload
expect(standing_order.proxy_orders).to include po2
expect(standing_order.proxy_orders).to_not include po1, po3
expect(standing_order.proxy_orders.map(&:order_cycle)).to include oc3, oc4, oc7
expect(standing_order.proxy_orders.map(&:order_cycle)).to_not include oc1, oc2, oc5, oc6, oc8
subscription.reload
expect(subscription.proxy_orders).to include po2
expect(subscription.proxy_orders).to_not include po1, po3
expect(subscription.proxy_orders.map(&:order_cycle)).to include oc3, oc4, oc7
expect(subscription.proxy_orders.map(&:order_cycle)).to_not include oc1, oc2, oc5, oc6, oc8
end
end
describe "#initialise_proxy_orders!" do
let(:new_standing_order) { build(:standing_order, schedule: schedule, begins_at: now + 1.minute, ends_at: now + 2.minutes) }
let(:new_subscription) { build(:subscription, schedule: schedule, begins_at: now + 1.minute, ends_at: now + 2.minutes) }
it "builds proxy orders for in-range order cycles that are not already closed" do
allow(syncer).to receive(:standing_order) { new_standing_order }
allow(syncer).to receive(:subscription) { new_subscription }
expect{ syncer.send(:initialise_proxy_orders!) }.to_not change(ProxyOrder, :count).from(0)
expect{ new_standing_order.save! }.to change(ProxyOrder, :count).from(0).to(2)
expect(new_standing_order.proxy_orders.map(&:order_cycle_id)).to include oc3.id, oc4.id
expect{ new_subscription.save! }.to change(ProxyOrder, :count).from(0).to(2)
expect(new_subscription.proxy_orders.map(&:order_cycle_id)).to include oc3.id, oc4.id
end
end
describe "#create_proxy_orders!" do
it "creates proxy orders for in-range order cycles that are not already closed" do
allow(syncer).to receive(:standing_order) { standing_order }
allow(syncer).to receive(:subscription) { subscription }
expect{ syncer.send(:create_proxy_orders!) }.to change(ProxyOrder, :count).from(0).to(2)
expect(standing_order.proxy_orders.map(&:order_cycle)).to include oc3, oc4
expect(subscription.proxy_orders.map(&:order_cycle)).to include oc3, oc4
end
end
describe "#remove_obsolete_proxy_orders!" do
let!(:po1) { create(:proxy_order, standing_order: standing_order, order_cycle: oc1) }
let!(:po2) { create(:proxy_order, standing_order: standing_order, order_cycle: oc2) }
let!(:po3) { create(:proxy_order, standing_order: standing_order, order_cycle: oc3) }
let!(:po4) { create(:proxy_order, standing_order: standing_order, order_cycle: oc4) }
let!(:po5) { create(:proxy_order, standing_order: standing_order, order_cycle: oc5) }
let!(:po1) { create(:proxy_order, subscription: subscription, order_cycle: oc1) }
let!(:po2) { create(:proxy_order, subscription: subscription, order_cycle: oc2) }
let!(:po3) { create(:proxy_order, subscription: subscription, order_cycle: oc3) }
let!(:po4) { create(:proxy_order, subscription: subscription, order_cycle: oc4) }
let!(:po5) { create(:proxy_order, subscription: subscription, order_cycle: oc5) }
it "destroys proxy orders that are closed or out of range" do
allow(syncer).to receive(:standing_order) { standing_order }
allow(syncer).to receive(:subscription) { subscription }
expect{ syncer.send(:remove_obsolete_proxy_orders!) }.to change(ProxyOrder, :count).from(5).to(2)
expect(standing_order.proxy_orders.map(&:order_cycle)).to include oc3, oc4
expect(subscription.proxy_orders.map(&:order_cycle)).to include oc3, oc4
end
end
end

18
spec/lib/open_food_network/subscription_payment_updater_spec.rb
View File

@@ -1,9 +1,9 @@
require 'open_food_network/standing_order_payment_updater'
require 'open_food_network/subscription_payment_updater'
module OpenFoodNetwork
describe StandingOrderPaymentUpdater do
describe SubscriptionPaymentUpdater do
let(:order) { create(:order) }
let(:updater) { OpenFoodNetwork::StandingOrderPaymentUpdater.new(order) }
let(:updater) { OpenFoodNetwork::SubscriptionPaymentUpdater.new(order) }
describe "#payment" do
context "when only one payment exists on the order" do
@@ -48,12 +48,12 @@ module OpenFoodNetwork
context "when no pending payments are present" do
let(:payment_method) { create(:payment_method) }
let(:standing_order) { double(:standing_order, payment_method_id: payment_method.id) }
let(:subscription) { double(:subscription, payment_method_id: payment_method.id) }
before do
allow(order).to receive(:pending_payments).once { [] }
allow(order).to receive(:outstanding_balance) { 5 }
allow(order).to receive(:standing_order) { standing_order }
allow(order).to receive(:subscription) { subscription }
end
it "creates a new payment on the order" do
@@ -96,7 +96,7 @@ module OpenFoodNetwork
context "and the payment source is not a credit card" do
before { expect(updater).to receive(:card_set?) { false } }
context "and no credit card is available on the standing order" do
context "and no credit card is available on the subscription" do
before { expect(updater).to receive(:ensure_credit_card) { false } }
it "adds an error to the order and does not update the payment" do
@@ -105,7 +105,7 @@ module OpenFoodNetwork
end
end
context "but a credit card is available on the standing order" do
context "but a credit card is available on the subscription" do
before { expect(updater).to receive(:ensure_credit_card) { true } }
context "when the payment total doesn't match the outstanding balance on the order" do
@@ -151,7 +151,7 @@ module OpenFoodNetwork
let!(:payment) { create(:payment, source: nil) }
before { allow(updater).to receive(:payment) { payment } }
context "when no credit card is specified by the standing order" do
context "when no credit card is specified by the subscription" do
before { allow(updater).to receive(:saved_credit_card) { nil } }
it "returns false and down not update the payment source" do
@@ -161,7 +161,7 @@ module OpenFoodNetwork
end
end
context "when a credit card is specified by the standing order" do
context "when a credit card is specified by the subscription" do
let(:credit_card) { create(:credit_card) }
before { allow(updater).to receive(:saved_credit_card) { credit_card } }

10
spec/lib/open_food_network/subscription_summarizer_spec.rb
View File

@@ -1,9 +1,9 @@
require 'open_food_network/standing_order_summarizer'
require 'open_food_network/subscription_summarizer'
module OpenFoodNetwork
describe StandingOrderSummarizer do
describe SubscriptionSummarizer do
let(:order) { create(:order) }
let(:summarizer) { OpenFoodNetwork::StandingOrderSummarizer.new }
let(:summarizer) { OpenFoodNetwork::SubscriptionSummarizer.new }
describe "#summary_for" do
let(:order) { double(:order, distributor_id: 123) }
@@ -100,7 +100,7 @@ module OpenFoodNetwork
end
it "sends a placement summary email for each summary" do
expect(StandingOrderMailer).to receive(:placement_summary_email).twice { mail_mock }
expect(SubscriptionMailer).to receive(:placement_summary_email).twice { mail_mock }
summarizer.send_placement_summary_emails
end
end
@@ -116,7 +116,7 @@ module OpenFoodNetwork
end
it "sends a placement summary email for each summary" do
expect(StandingOrderMailer).to receive(:confirmation_summary_email).twice { mail_mock }
expect(SubscriptionMailer).to receive(:confirmation_summary_email).twice { mail_mock }
summarizer.send_confirmation_summary_emails
end
end

6
spec/lib/open_food_network/subscription_summary_spec.rb
View File

@@ -1,8 +1,8 @@
require 'open_food_network/standing_order_summary'
require 'open_food_network/subscription_summary'
module OpenFoodNetwork
describe StandingOrderSummary do
let(:summary) { OpenFoodNetwork::StandingOrderSummary.new(123) }
describe SubscriptionSummary do
let(:summary) { OpenFoodNetwork::SubscriptionSummary.new(123) }
describe "#initialize" do
it "initializes instance variables: shop_id, order_count, success_count and issues" do

88
spec/mailers/subscription_mailer_spec.rb
View File

@@ -1,13 +1,13 @@
require 'spec_helper'
describe StandingOrderMailer do
describe SubscriptionMailer do
include ActionView::Helpers::SanitizeHelper
let!(:mail_method) { create(:mail_method, preferred_mails_from: 'spree@example.com') }
describe "order placement" do
let(:standing_order) { create(:standing_order, with_items: true) }
let(:proxy_order) { create(:proxy_order, standing_order: standing_order) }
let(:subscription) { create(:subscription, with_items: true) }
let(:proxy_order) { create(:proxy_order, subscription: subscription) }
let!(:order) { proxy_order.initialise_order! }
context "when changes have been made to the order" do
@@ -16,12 +16,12 @@ describe StandingOrderMailer do
before do
changes[order.line_items.first.id] = 2
expect do
StandingOrderMailer.placement_email(order, changes).deliver
end.to change{ StandingOrderMailer.deliveries.count }.by(1)
SubscriptionMailer.placement_email(order, changes).deliver
end.to change{ SubscriptionMailer.deliveries.count }.by(1)
end
it "sends the email, which notifies the customer of changes made" do
body = StandingOrderMailer.deliveries.last.body.encoded
body = SubscriptionMailer.deliveries.last.body.encoded
expect(body).to include "This order was automatically created for you."
expect(body).to include "Unfortunately, not all products that you requested were available."
expect(body).to include "href=\"#{spree.order_url(order)}\""
@@ -31,12 +31,12 @@ describe StandingOrderMailer do
context "and changes have not been made to the order" do
before do
expect do
StandingOrderMailer.placement_email(order, {}).deliver
end.to change{ StandingOrderMailer.deliveries.count }.by(1)
SubscriptionMailer.placement_email(order, {}).deliver
end.to change{ SubscriptionMailer.deliveries.count }.by(1)
end
it "sends the email" do
body = StandingOrderMailer.deliveries.last.body.encoded
body = SubscriptionMailer.deliveries.last.body.encoded
expect(body).to include "This order was automatically created for you."
expect(body).to_not include "Unfortunately, not all products that you requested were available."
expect(body).to include "href=\"#{spree.order_url(order)}\""
@@ -45,60 +45,60 @@ describe StandingOrderMailer do
end
describe "order confirmation" do
let(:standing_order) { create(:standing_order, with_items: true) }
let(:proxy_order) { create(:proxy_order, standing_order: standing_order) }
let(:subscription) { create(:subscription, with_items: true) }
let(:proxy_order) { create(:proxy_order, subscription: subscription) }
let!(:order) { proxy_order.initialise_order! }
before do
expect do
StandingOrderMailer.confirmation_email(order).deliver
end.to change{ StandingOrderMailer.deliveries.count }.by(1)
SubscriptionMailer.confirmation_email(order).deliver
end.to change{ SubscriptionMailer.deliveries.count }.by(1)
end
it "sends the email" do
body = StandingOrderMailer.deliveries.last.body.encoded
body = SubscriptionMailer.deliveries.last.body.encoded
expect(body).to include "This order was automatically placed for you"
expect(body).to include "href=\"#{spree.order_url(order)}\""
end
end
describe "empty order notification" do
let(:standing_order) { create(:standing_order, with_items: true) }
let(:proxy_order) { create(:proxy_order, standing_order: standing_order) }
let(:subscription) { create(:subscription, with_items: true) }
let(:proxy_order) { create(:proxy_order, subscription: subscription) }
let!(:order) { proxy_order.initialise_order! }
before do
expect do
StandingOrderMailer.empty_email(order, {}).deliver
end.to change{ StandingOrderMailer.deliveries.count }.by(1)
SubscriptionMailer.empty_email(order, {}).deliver
end.to change{ SubscriptionMailer.deliveries.count }.by(1)
end
it "sends the email" do
body = StandingOrderMailer.deliveries.last.body.encoded
body = SubscriptionMailer.deliveries.last.body.encoded
expect(body).to include "We tried to place a new order with"
expect(body).to include "Unfortunately, none of products that you ordered were available"
end
end
describe "failed payment notification" do
let(:standing_order) { create(:standing_order, with_items: true) }
let(:proxy_order) { create(:proxy_order, standing_order: standing_order) }
let(:subscription) { create(:subscription, with_items: true) }
let(:proxy_order) { create(:proxy_order, subscription: subscription) }
let!(:order) { proxy_order.initialise_order! }
before do
order.errors.add(:base, "This is a payment failure error")
expect do
StandingOrderMailer.failed_payment_email(order).deliver
end.to change{ StandingOrderMailer.deliveries.count }.by(1)
SubscriptionMailer.failed_payment_email(order).deliver
end.to change{ SubscriptionMailer.deliveries.count }.by(1)
end
it "sends the email" do
body = strip_tags(StandingOrderMailer.deliveries.last.body.encoded)
body = strip_tags(SubscriptionMailer.deliveries.last.body.encoded)
expect(body).to include I18n.t("email_so_failed_payment_intro_html")
explainer = I18n.t("email_so_failed_payment_explainer_html", distributor: standing_order.shop.name)
explainer = I18n.t("email_so_failed_payment_explainer_html", distributor: subscription.shop.name)
expect(body).to include strip_tags(explainer)
details = I18n.t("email_so_failed_payment_details_html", distributor: standing_order.shop.name)
details = I18n.t("email_so_failed_payment_details_html", distributor: subscription.shop.name)
expect(body).to include strip_tags(details)
expect(body).to include "This is a payment failure error"
end
@@ -107,17 +107,17 @@ describe StandingOrderMailer do
describe "order placement summary" do
let!(:shop) { create(:enterprise) }
let!(:summary) { double(:summary, shop_id: shop.id) }
let(:body) { strip_tags(StandingOrderMailer.deliveries.last.body.encoded) }
let(:scope) { "standing_order_mailer" }
let(:body) { strip_tags(SubscriptionMailer.deliveries.last.body.encoded) }
let(:scope) { "subscription_mailer" }
before { allow(summary).to receive(:unrecorded_ids) { [] } }
context "when no issues were encountered while processing standing orders" do
context "when no issues were encountered while processing subscriptions" do
before do
allow(summary).to receive(:order_count) { 37 }
allow(summary).to receive(:issue_count) { 0 }
allow(summary).to receive(:issues) { {} }
StandingOrderMailer.placement_summary_email(summary).deliver
SubscriptionMailer.placement_summary_email(summary).deliver
end
it "sends the email, which notifies the enterprise that all orders were successfully processed" do
@@ -128,7 +128,7 @@ describe StandingOrderMailer do
end
end
context "when some issues were encountered while processing standing orders" do
context "when some issues were encountered while processing subscriptions" do
let(:order1) { double(:order, id: 1, number: "R123456", to_s: "R123456") }
let(:order2) { double(:order, id: 2, number: "R654321", to_s: "R654321") }
@@ -142,7 +142,7 @@ describe StandingOrderMailer do
context "when no unrecorded issues are present" do
it "sends the email, which notifies the enterprise that some issues were encountered" do
StandingOrderMailer.placement_summary_email(summary).deliver
SubscriptionMailer.placement_summary_email(summary).deliver
expect(body).to include I18n.t("#{scope}.placement_summary_email.intro", shop: shop.name)
expect(body).to include I18n.t("#{scope}.summary_overview.total", count: 37)
expect(body).to include I18n.t("#{scope}.summary_overview.success_some", count: 35)
@@ -170,7 +170,7 @@ describe StandingOrderMailer do
it "sends the email, which notifies the enterprise that some issues were encountered" do
expect(summary).to receive(:orders_affected_by).with(:other) { [order3, order4] }
StandingOrderMailer.placement_summary_email(summary).deliver
SubscriptionMailer.placement_summary_email(summary).deliver
expect(body).to include I18n.t("#{scope}.summary_detail.processing.title", count: 2)
expect(body).to include I18n.t("#{scope}.summary_detail.processing.explainer")
expect(body).to include I18n.t("#{scope}.summary_detail.other.title", count: 2)
@@ -183,7 +183,7 @@ describe StandingOrderMailer do
end
end
context "when no standing orders were processed successfully" do
context "when no subscriptions were processed successfully" do
let(:order1) { double(:order, id: 1, number: "R123456", to_s: "R123456") }
let(:order2) { double(:order, id: 2, number: "R654321", to_s: "R654321") }
@@ -193,7 +193,7 @@ describe StandingOrderMailer do
allow(summary).to receive(:issue_count) { 2 }
allow(summary).to receive(:issues) { { changes: { 1 => nil, 2 => nil } } }
allow(summary).to receive(:orders_affected_by) { [order1, order2] }
StandingOrderMailer.placement_summary_email(summary).deliver
SubscriptionMailer.placement_summary_email(summary).deliver
end
it "sends the email, which notifies the enterprise that some issues were encountered" do
@@ -217,17 +217,17 @@ describe StandingOrderMailer do
describe "order confirmation summary" do
let!(:shop) { create(:enterprise) }
let!(:summary) { double(:summary, shop_id: shop.id) }
let(:body) { strip_tags(StandingOrderMailer.deliveries.last.body.encoded) }
let(:scope) { "standing_order_mailer" }
let(:body) { strip_tags(SubscriptionMailer.deliveries.last.body.encoded) }
let(:scope) { "subscription_mailer" }
before { allow(summary).to receive(:unrecorded_ids) { [] } }
context "when no issues were encountered while processing standing orders" do
context "when no issues were encountered while processing subscriptions" do
before do
allow(summary).to receive(:order_count) { 37 }
allow(summary).to receive(:issue_count) { 0 }
allow(summary).to receive(:issues) { {} }
StandingOrderMailer.confirmation_summary_email(summary).deliver
SubscriptionMailer.confirmation_summary_email(summary).deliver
end
it "sends the email, which notifies the enterprise that all orders were successfully processed" do
@@ -238,7 +238,7 @@ describe StandingOrderMailer do
end
end
context "when some issues were encountered while processing standing orders" do
context "when some issues were encountered while processing subscriptions" do
let(:order1) { double(:order, id: 1, number: "R123456", to_s: "R123456") }
let(:order2) { double(:order, id: 2, number: "R654321", to_s: "R654321") }
@@ -252,7 +252,7 @@ describe StandingOrderMailer do
context "when no unrecorded issues are present" do
it "sends the email, which notifies the enterprise that some issues were encountered" do
StandingOrderMailer.confirmation_summary_email(summary).deliver
SubscriptionMailer.confirmation_summary_email(summary).deliver
expect(body).to include I18n.t("#{scope}.confirmation_summary_email.intro", shop: shop.name)
expect(body).to include I18n.t("#{scope}.summary_overview.total", count: 37)
expect(body).to include I18n.t("#{scope}.summary_overview.success_some", count: 35)
@@ -280,7 +280,7 @@ describe StandingOrderMailer do
it "sends the email, which notifies the enterprise that some issues were encountered" do
expect(summary).to receive(:orders_affected_by).with(:other) { [order3, order4] }
StandingOrderMailer.confirmation_summary_email(summary).deliver
SubscriptionMailer.confirmation_summary_email(summary).deliver
expect(body).to include I18n.t("#{scope}.summary_detail.failed_payment.title", count: 2)
expect(body).to include I18n.t("#{scope}.summary_detail.failed_payment.explainer")
expect(body).to include I18n.t("#{scope}.summary_detail.other.title", count: 2)
@@ -293,7 +293,7 @@ describe StandingOrderMailer do
end
end
context "when no standing orders were processed successfully" do
context "when no subscriptions were processed successfully" do
let(:order1) { double(:order, id: 1, number: "R123456", to_s: "R123456") }
let(:order2) { double(:order, id: 2, number: "R654321", to_s: "R654321") }
@@ -303,7 +303,7 @@ describe StandingOrderMailer do
allow(summary).to receive(:issue_count) { 2 }
allow(summary).to receive(:issues) { { changes: { 1 => nil, 2 => nil } } }
allow(summary).to receive(:orders_affected_by) { [order1, order2] }
StandingOrderMailer.confirmation_summary_email(summary).deliver
SubscriptionMailer.confirmation_summary_email(summary).deliver
end
it "sends the email, which notifies the enterprise that some issues were encountered" do

4
spec/models/column_preference_spec.rb
View File

@@ -65,7 +65,7 @@ describe ColumnPreference, type: :model do
let(:action_name) { "order_cycles_index" }
context "and the user owns a standing-orders-enabled enterprise" do
let!(:enterprise) { create(:distributor_enterprise, enable_standing_orders: true) }
let!(:enterprise) { create(:distributor_enterprise, enable_subscriptions: true) }
it "removes the schedules column from the defaults" do
ColumnPreference.filter(default_preferences, enterprise.owner, action_name)
@@ -74,7 +74,7 @@ describe ColumnPreference, type: :model do
end
context "and the user does not own a standing-orders-enabled enterprise" do
let!(:enterprise) { create(:distributor_enterprise, enable_standing_orders: false) }
let!(:enterprise) { create(:distributor_enterprise, enable_subscriptions: false) }
it "removes the schedules column from the defaults" do
ColumnPreference.filter(default_preferences, enterprise.owner, action_name)

34
spec/models/proxy_order_spec.rb
View File

@@ -3,10 +3,10 @@ require 'spec_helper'
describe ProxyOrder, type: :model do
describe "cancel" do
let(:order_cycle) { create(:simple_order_cycle) }
let(:standing_order) { create(:standing_order) }
let(:subscription) { create(:subscription) }
context "when the order cycle is not yet closed" do
let(:proxy_order) { create(:proxy_order, standing_order: standing_order, order: order, order_cycle: order_cycle) }
let(:proxy_order) { create(:proxy_order, subscription: subscription, order: order, order_cycle: order_cycle) }
before { order_cycle.update_attributes(orders_open_at: 1.day.ago, orders_close_at: 3.days.from_now) }
context "and an order has not been initialised" do
@@ -44,7 +44,7 @@ describe ProxyOrder, type: :model do
end
context "when the order cycle is already closed" do
let(:proxy_order) { create(:proxy_order, standing_order: standing_order, order: order, order_cycle: order_cycle) }
let(:proxy_order) { create(:proxy_order, subscription: subscription, order: order, order_cycle: order_cycle) }
before { order_cycle.update_attributes(orders_open_at: 3.days.ago, orders_close_at: 1.minute.ago) }
context "and an order has not been initialised" do
@@ -159,28 +159,28 @@ describe ProxyOrder, type: :model do
describe "initialise_order!" do
context "when the order has not already been initialised" do
let(:standing_order) { create(:standing_order, with_items: true) }
let!(:proxy_order) { create(:proxy_order, standing_order: standing_order) }
let(:subscription) { create(:subscription, with_items: true) }
let!(:proxy_order) { create(:proxy_order, subscription: subscription) }
it "builds a new order based the standing order" do
it "builds a new order based the subscription" do
expect{ proxy_order.initialise_order! }.to change{ Spree::Order.count }.by(1)
expect(proxy_order.reload.order).to be_a Spree::Order
order = proxy_order.order
expect(order.line_items.count).to eq standing_order.standing_line_items.count
expect(order.customer).to eq standing_order.customer
expect(order.user).to eq standing_order.customer.user
expect(order.distributor).to eq standing_order.shop
expect(order.line_items.count).to eq subscription.standing_line_items.count
expect(order.customer).to eq subscription.customer
expect(order.user).to eq subscription.customer.user
expect(order.distributor).to eq subscription.shop
expect(order.order_cycle).to eq proxy_order.order_cycle
expect(order.shipping_method).to eq standing_order.shipping_method
expect(order.shipments.first.shipping_method).to eq standing_order.shipping_method
expect(order.payments.first.payment_method).to eq standing_order.payment_method
expect(order.bill_address).to eq standing_order.bill_address
expect(order.ship_address).to eq standing_order.ship_address
expect(order.shipping_method).to eq subscription.shipping_method
expect(order.shipments.first.shipping_method).to eq subscription.shipping_method
expect(order.payments.first.payment_method).to eq subscription.payment_method
expect(order.bill_address).to eq subscription.bill_address
expect(order.ship_address).to eq subscription.ship_address
expect(order.complete?).to be false
end
context "when a requested quantity is greater than available stock" do
let(:sli) { standing_order.standing_line_items.first }
let(:sli) { subscription.standing_line_items.first }
let(:variant) { sli.variant }
before do
@@ -198,7 +198,7 @@ describe ProxyOrder, type: :model do
context "when the customer does not have a user associated with it" do
before do
standing_order.customer.update_attribute(:user_id, nil)
subscription.customer.update_attribute(:user_id, nil)
end
it "initialises the order without a user_id" do

6
spec/models/spree/order_spec.rb
View File

@@ -573,7 +573,7 @@ describe Spree::Order do
end.to_not enqueue_job ConfirmOrderJob
end
it "does not send confirmation emails when the order belongs to a standing order" do
it "does not send confirmation emails when the order belongs to a subscription" do
create(:proxy_order, order: order)
expect do
@@ -794,13 +794,13 @@ describe Spree::Order do
let!(:order) { create(:order ) }
let!(:payment) { create(:payment, order: order, state: 'checkout') }
context "when the order is not a standing order" do
context "when the order is not a subscription" do
it "returns the payments on the order" do
expect(order.reload.pending_payments).to eq [payment]
end
end
context "when the order is a standing order" do
context "when the order is a subscription" do
let!(:proxy_order) { create(:proxy_order, order: order) }
let!(:order_cycle) { proxy_order.order_cycle }

4
spec/models/standing_line_item_spec.rb
View File

@@ -2,8 +2,8 @@ require 'spec_helper'
describe StandingLineItem, model: true do
describe "validations" do
it "requires a standing_order" do
expect(subject).to validate_presence_of :standing_order
it "requires a subscription" do
expect(subject).to validate_presence_of :subscription
end
it "requires a variant" do

78
spec/models/subscription_spec.rb
View File

@@ -1,6 +1,6 @@
require 'spec_helper'
describe StandingOrder, type: :model do
describe Subscription, type: :model do
describe "associations" do
it { expect(subject).to belong_to(:shop) }
it { expect(subject).to belong_to(:customer) }
@@ -17,34 +17,34 @@ describe StandingOrder, type: :model do
end
describe "cancel" do
let!(:standing_order) { create(:standing_order) }
let!(:subscription) { create(:subscription) }
let!(:proxy_order1) { create(:proxy_order, order_cycle: create(:simple_order_cycle)) }
let!(:proxy_order2) { create(:proxy_order, order_cycle: create(:simple_order_cycle)) }
before do
allow(standing_order).to receive(:proxy_orders) { [proxy_order1, proxy_order2] }
allow(subscription).to receive(:proxy_orders) { [proxy_order1, proxy_order2] }
end
context "when all standing order orders can be cancelled" do
context "when all subscription orders can be cancelled" do
before { allow(proxy_order1).to receive(:cancel) { true } }
before { allow(proxy_order2).to receive(:cancel) { true } }
it "marks the standing order as cancelled and calls #cancel on all proxy_orders" do
standing_order.cancel
expect(standing_order.reload.canceled_at).to be_within(5.seconds).of Time.zone.now
it "marks the subscription as cancelled and calls #cancel on all proxy_orders" do
subscription.cancel
expect(subscription.reload.canceled_at).to be_within(5.seconds).of Time.zone.now
expect(proxy_order1).to have_received(:cancel)
expect(proxy_order2).to have_received(:cancel)
end
end
context "when a standing order order cannot be cancelled" do
context "when a subscription order cannot be cancelled" do
before { allow(proxy_order1).to receive(:cancel).and_raise("Some error") }
before { allow(proxy_order2).to receive(:cancel) { true } }
it "aborts the transaction" do
# ie. canceled_at remains as nil, #cancel not called on second standing order order
expect{ standing_order.cancel }.to raise_error "Some error"
expect(standing_order.reload.canceled_at).to be nil
# ie. canceled_at remains as nil, #cancel not called on second subscription order
expect{ subscription.cancel }.to raise_error "Some error"
expect(subscription.reload.canceled_at).to be nil
expect(proxy_order1).to have_received(:cancel)
expect(proxy_order2).to_not have_received(:cancel)
end
@@ -52,70 +52,70 @@ describe StandingOrder, type: :model do
end
describe "state" do
let(:standing_order) { StandingOrder.new }
let(:subscription) { Subscription.new }
context "when the standing order has been cancelled" do
before { allow(standing_order).to receive(:canceled_at) { Time.zone.now } }
context "when the subscription has been cancelled" do
before { allow(subscription).to receive(:canceled_at) { Time.zone.now } }
it "returns 'canceled'" do
expect(standing_order.state).to eq 'canceled'
expect(subscription.state).to eq 'canceled'
end
end
context "when the standing order has not been cancelled" do
before { allow(standing_order).to receive(:canceled_at) { nil } }
context "when the subscription has not been cancelled" do
before { allow(subscription).to receive(:canceled_at) { nil } }
context "and the standing order has been paused" do
before { allow(standing_order).to receive(:paused_at) { Time.zone.now } }
context "and the subscription has been paused" do
before { allow(subscription).to receive(:paused_at) { Time.zone.now } }
it "returns 'paused'" do
expect(standing_order.state).to eq 'paused'
expect(subscription.state).to eq 'paused'
end
end
context "and the standing order has not been paused" do
before { allow(standing_order).to receive(:paused_at) { nil } }
context "and the subscription has not been paused" do
before { allow(subscription).to receive(:paused_at) { nil } }
context "and the standing order has no begins_at date" do
before { allow(standing_order).to receive(:begins_at) { nil } }
context "and the subscription has no begins_at date" do
before { allow(subscription).to receive(:begins_at) { nil } }
it "returns 'pending'" do
expect(standing_order.state).to eq 'pending'
expect(subscription.state).to eq 'pending'
end
end
context "and the standing order has a begins_at date in the future" do
before { allow(standing_order).to receive(:begins_at) { 1.minute.from_now } }
context "and the subscription has a begins_at date in the future" do
before { allow(subscription).to receive(:begins_at) { 1.minute.from_now } }
it "returns 'pending'" do
expect(standing_order.state).to eq 'pending'
expect(subscription.state).to eq 'pending'
end
end
context "and the standing order has a begins_at date in the past" do
before { allow(standing_order).to receive(:begins_at) { 1.minute.ago } }
context "and the subscription has a begins_at date in the past" do
before { allow(subscription).to receive(:begins_at) { 1.minute.ago } }
context "and the standing order has no ends_at date set" do
before { allow(standing_order).to receive(:ends_at) { nil } }
context "and the subscription has no ends_at date set" do
before { allow(subscription).to receive(:ends_at) { nil } }
it "returns 'active'" do
expect(standing_order.state).to eq 'active'
expect(subscription.state).to eq 'active'
end
end
context "and the standing order has an ends_at date in the future" do
before { allow(standing_order).to receive(:ends_at) { 1.minute.from_now } }
context "and the subscription has an ends_at date in the future" do
before { allow(subscription).to receive(:ends_at) { 1.minute.from_now } }
it "returns 'active'" do
expect(standing_order.state).to eq 'active'
expect(subscription.state).to eq 'active'
end
end
context "and the standing order has an ends_at date in the past" do
before { allow(standing_order).to receive(:ends_at) { 1.minute.ago } }
context "and the subscription has an ends_at date in the past" do
before { allow(subscription).to receive(:ends_at) { 1.minute.ago } }
it "returns 'ended'" do
expect(standing_order.state).to eq 'ended'
expect(subscription.state).to eq 'ended'
end
end
end

20
spec/performance/proxy_order_syncer_spec.rb
View File

@@ -11,19 +11,19 @@ module OpenFoodNetwork
end
end
let!(:standing_orders) do
let!(:subscriptions) do
Array.new(150) do |_i|
create(:standing_order, schedule: schedule, begins_at: start, ends_at: start + 10.days)
create(:subscription, schedule: schedule, begins_at: start, ends_at: start + 10.days)
end
StandingOrder.where(schedule_id: schedule)
Subscription.where(schedule_id: schedule)
end
context "measuring performance for initialisation" do
it "reports the average run time for adding 10 OCs to 150 standing orders" do
it "reports the average run time for adding 10 OCs to 150 subscriptions" do
expect(ProxyOrder.count).to be 0
times = []
10.times do
syncer = ProxyOrderSyncer.new(standing_orders.reload)
syncer = ProxyOrderSyncer.new(subscriptions.reload)
t1 = Time.zone.now
syncer.sync!
@@ -40,14 +40,14 @@ module OpenFoodNetwork
end
context "measuring performance for removal" do
it "reports the average run time for removing 8 OCs from 150 standing orders" do
it "reports the average run time for removing 8 OCs from 150 subscriptions" do
times = []
10.times do
syncer = ProxyOrderSyncer.new(standing_orders.reload)
syncer = ProxyOrderSyncer.new(subscriptions.reload)
syncer.sync!
expect(ProxyOrder.count).to be 1500
standing_orders.update_all(begins_at: start + 8.days + 1.minute)
syncer = ProxyOrderSyncer.new(standing_orders.reload)
subscriptions.update_all(begins_at: start + 8.days + 1.minute)
syncer = ProxyOrderSyncer.new(subscriptions.reload)
t1 = Time.zone.now
syncer.sync!
@@ -57,7 +57,7 @@ module OpenFoodNetwork
puts diff.round(2)
expect(ProxyOrder.count).to be 300
standing_orders.update_all(begins_at: start)
subscriptions.update_all(begins_at: start)
end
puts "AVG: #{(times.sum / times.count).round(2)}"
end

152
spec/services/order_syncer_spec.rb
View File

@@ -1,45 +1,45 @@
describe OrderSyncer do
describe "updating the shipping method" do
let(:standing_order) { create(:standing_order, with_items: true, with_proxy_orders: true) }
let(:order) { standing_order.proxy_orders.first.initialise_order! }
let(:shipping_method) { standing_order.shipping_method }
let(:new_shipping_method) { create(:shipping_method, distributors: [standing_order.shop]) }
let(:syncer) { OrderSyncer.new(standing_order) }
let(:subscription) { create(:subscription, with_items: true, with_proxy_orders: true) }
let(:order) { subscription.proxy_orders.first.initialise_order! }
let(:shipping_method) { subscription.shipping_method }
let(:new_shipping_method) { create(:shipping_method, distributors: [subscription.shop]) }
let(:syncer) { OrderSyncer.new(subscription) }
context "when the shipping method on an order is the same as the standing order" do
context "when the shipping method on an order is the same as the subscription" do
let(:params) { { shipping_method_id: new_shipping_method.id } }
it "updates the shipping_method on the order and on shipments" do
expect(order.shipments.first.shipping_method_id_was).to eq shipping_method.id
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
expect(order.reload.shipping_method).to eq new_shipping_method
expect(order.shipments.first.shipping_method).to eq new_shipping_method
end
end
context "when the shipping method on a shipment is not the same as the original shipping method on the standing order" do
context "when the shipping method on a shipment is not the same as the original shipping method on the subscription" do
let(:params) { { shipping_method_id: new_shipping_method.id } }
context "when the shipping method on a shipment is the same as the new shipping method on the standing order" do
context "when the shipping method on a shipment is the same as the new shipping method on the subscription" do
before do
# Updating the shipping method on a shipment updates the shipping method on the order,
# and vice-versa via logic in Spree's shipments controller. So updating both here mimics that
# behaviour.
order.shipments.first.update_attributes(shipping_method_id: new_shipping_method.id)
order.update_attributes(shipping_method_id: new_shipping_method.id)
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
end
it "does not update the shipping_method on the standing order or on the pre-altered shipment" do
it "does not update the shipping_method on the subscription or on the pre-altered shipment" do
expect(order.reload.shipping_method).to eq new_shipping_method
expect(order.reload.shipments.first.shipping_method).to eq new_shipping_method
expect(syncer.order_update_issues[order.id]).to be nil
end
end
context "when the shipping method on a shipment is not the same as the new shipping method on the standing order" do
context "when the shipping method on a shipment is not the same as the new shipping method on the subscription" do
let(:changed_shipping_method) { create(:shipping_method) }
before do
@@ -48,11 +48,11 @@ describe OrderSyncer do
# behaviour.
order.shipments.first.update_attributes(shipping_method_id: changed_shipping_method.id)
order.update_attributes(shipping_method_id: changed_shipping_method.id)
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
end
it "does not update the shipping_method on the standing order or on the pre-altered shipment" do
it "does not update the shipping_method on the subscription or on the pre-altered shipment" do
expect(order.reload.shipping_method).to eq changed_shipping_method
expect(order.reload.shipments.first.shipping_method).to eq changed_shipping_method
expect(syncer.order_update_issues[order.id]).to include "Shipping Method"
@@ -62,20 +62,20 @@ describe OrderSyncer do
end
describe "changing the payment method" do
let(:standing_order) { create(:standing_order, with_items: true, with_proxy_orders: true) }
let(:order) { standing_order.proxy_orders.first.initialise_order! }
let(:payment_method) { standing_order.payment_method }
let(:new_payment_method) { create(:payment_method, distributors: [standing_order.shop]) }
let(:subscription) { create(:subscription, with_items: true, with_proxy_orders: true) }
let(:order) { subscription.proxy_orders.first.initialise_order! }
let(:payment_method) { subscription.payment_method }
let(:new_payment_method) { create(:payment_method, distributors: [subscription.shop]) }
let(:invalid_payment_method) { create(:payment_method, distributors: [create(:enterprise)]) }
let(:bogus_payment_method) { create(:bogus_payment_method, distributors: [standing_order.shop]) }
let(:syncer) { OrderSyncer.new(standing_order) }
let(:bogus_payment_method) { create(:bogus_payment_method, distributors: [subscription.shop]) }
let(:syncer) { OrderSyncer.new(subscription) }
context "when the payment method on an order is the same as the standing order" do
context "when the payment method on an order is the same as the subscription" do
let(:params) { { payment_method_id: new_payment_method.id } }
it "voids existing payments and creates a new payment with the relevant payment method" do
expect(order.payments.reload.first.payment_method).to eq payment_method
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
payments = order.reload.payments
expect(payments.count).to be 2
@@ -86,13 +86,13 @@ describe OrderSyncer do
end
end
context "when the payment method on a payment is not the same as the standing order" do
context "when the payment method on a payment is not the same as the subscription" do
let(:params) { { payment_method_id: new_payment_method.id } }
context "when the payment method on a payment is the same as the original payment method on the standing order" do
context "when the payment method on a payment is the same as the original payment method on the subscription" do
before do
order.payments.first.update_attribute(:payment_method_id, new_payment_method.id)
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
end
@@ -104,12 +104,12 @@ describe OrderSyncer do
end
end
context "when the payment method on a shipment is not the same as the original payment method on the standing order" do
context "when the payment method on a shipment is not the same as the original payment method on the subscription" do
let(:changed_payment_method) { create(:payment_method) }
before do
order.payments.first.update_attribute(:payment_method_id, changed_payment_method.id)
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
end
@@ -124,20 +124,20 @@ describe OrderSyncer do
end
describe "changing the billing address" do
let(:standing_order) { create(:standing_order, with_items: true, with_proxy_orders: true) }
let(:shipping_method) { standing_order.shipping_method }
let!(:order) { standing_order.proxy_orders.first.initialise_order! }
let!(:bill_address_attrs) { standing_order.bill_address.attributes }
let!(:ship_address_attrs) { standing_order.ship_address.attributes }
let(:subscription) { create(:subscription, with_items: true, with_proxy_orders: true) }
let(:shipping_method) { subscription.shipping_method }
let!(:order) { subscription.proxy_orders.first.initialise_order! }
let!(:bill_address_attrs) { subscription.bill_address.attributes }
let!(:ship_address_attrs) { subscription.ship_address.attributes }
let(:params) { { bill_address_attributes: { id: bill_address_attrs["id"], firstname: "Bill", address1: "123 abc st", phone: "1123581321" } } }
let(:syncer) { OrderSyncer.new(standing_order) }
let(:syncer) { OrderSyncer.new(subscription) }
context "when a ship address is not required" do
before { shipping_method.update_attributes(require_ship_address: false) }
context "when the bill_address on the order matches that on the standing order" do
context "when the bill_address on the order matches that on the subscription" do
it "updates all bill_address attrs and ship_address names + phone" do
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
expect(syncer.order_update_issues.keys).to_not include order.id
order.reload;
@@ -152,10 +152,10 @@ describe OrderSyncer do
end
end
context "when the bill_address on the order doesn't match that on the standing order" do
context "when the bill_address on the order doesn't match that on the subscription" do
before { order.bill_address.update_attributes(firstname: "Jane") }
it "does not update bill_address or ship_address on the order" do
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
expect(syncer.order_update_issues.keys).to include order.id
order.reload;
@@ -174,9 +174,9 @@ describe OrderSyncer do
context "when a ship address is required" do
before { shipping_method.update_attributes(require_ship_address: true) }
context "when the bill_address on the order matches that on the standing order" do
context "when the bill_address on the order matches that on the subscription" do
it "only updates bill_address attrs" do
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
expect(syncer.order_update_issues.keys).to_not include order.id
order.reload;
@@ -191,11 +191,11 @@ describe OrderSyncer do
end
end
context "when the bill_address on the order doesn't match that on the standing order" do
context "when the bill_address on the order doesn't match that on the subscription" do
before { order.bill_address.update_attributes(firstname: "Jane") }
it "does not update bill_address or ship_address on the order" do
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
expect(syncer.order_update_issues.keys).to include order.id
order.reload;
@@ -213,19 +213,19 @@ describe OrderSyncer do
end
describe "changing the ship address" do
let(:standing_order) { create(:standing_order, with_items: true, with_proxy_orders: true) }
let(:shipping_method) { standing_order.shipping_method }
let!(:order) { standing_order.proxy_orders.first.initialise_order! }
let!(:bill_address_attrs) { standing_order.bill_address.attributes }
let!(:ship_address_attrs) { standing_order.ship_address.attributes }
let(:subscription) { create(:subscription, with_items: true, with_proxy_orders: true) }
let(:shipping_method) { subscription.shipping_method }
let!(:order) { subscription.proxy_orders.first.initialise_order! }
let!(:bill_address_attrs) { subscription.bill_address.attributes }
let!(:ship_address_attrs) { subscription.ship_address.attributes }
let(:params) { { ship_address_attributes: { id: ship_address_attrs["id"], firstname: "Ship", address1: "123 abc st", phone: "1123581321" } } }
let(:syncer) { OrderSyncer.new(standing_order) }
let(:syncer) { OrderSyncer.new(subscription) }
context "when a ship address is not required" do
before { shipping_method.update_attributes(require_ship_address: false) }
it "does not change the ship address" do
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
expect(syncer.order_update_issues.keys).to_not include order.id
order.reload;
@@ -240,7 +240,7 @@ describe OrderSyncer do
before { params.merge!(shipping_method_id: new_shipping_method.id) }
it "updates ship_address attrs" do
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
expect(syncer.order_update_issues.keys).to_not include order.id
order.reload;
@@ -255,9 +255,9 @@ describe OrderSyncer do
context "when a ship address is required" do
before { shipping_method.update_attributes(require_ship_address: true) }
context "when the ship address on the order matches that on the standing order" do
context "when the ship address on the order matches that on the subscription" do
it "updates ship_address attrs" do
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
expect(syncer.order_update_issues.keys).to_not include order.id
order.reload;
@@ -268,10 +268,10 @@ describe OrderSyncer do
end
end
context "when the ship address on the order doesn't match that on the standing order" do
context "when the ship address on the order doesn't match that on the subscription" do
before { order.ship_address.update_attributes(firstname: "Jane") }
it "does not update ship_address on the order" do
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
expect(syncer.order_update_issues.keys).to include order.id
order.reload;
@@ -285,22 +285,22 @@ describe OrderSyncer do
end
describe "changing the quantity of a line item" do
let(:standing_order) { create(:standing_order, with_items: true, with_proxy_orders: true) }
let(:order) { standing_order.proxy_orders.first.initialise_order! }
let(:sli) { standing_order.standing_line_items.first }
let(:subscription) { create(:subscription, with_items: true, with_proxy_orders: true) }
let(:order) { subscription.proxy_orders.first.initialise_order! }
let(:sli) { subscription.standing_line_items.first }
let(:variant) { sli.variant }
before { variant.update_attribute(:count_on_hand, 2) }
context "when quantity is within available stock" do
let(:params) { { standing_line_items_attributes: [{ id: sli.id, quantity: 2}] } }
let(:syncer) { OrderSyncer.new(standing_order) }
let(:syncer) { OrderSyncer.new(subscription) }
it "updates the line_item quantities and totals on all orders" do
expect(order.reload.total.to_f).to eq 59.97
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
line_items = Spree::LineItem.where(order_id: standing_order.orders, variant_id: sli.variant_id)
line_items = Spree::LineItem.where(order_id: subscription.orders, variant_id: sli.variant_id)
expect(line_items.map(&:quantity)).to eq [2]
expect(order.reload.total.to_f).to eq 79.96
end
@@ -308,13 +308,13 @@ describe OrderSyncer do
context "when quantity is greater than available stock" do
let(:params) { { standing_line_items_attributes: [{ id: sli.id, quantity: 3}] } }
let(:syncer) { OrderSyncer.new(standing_order) }
let(:syncer) { OrderSyncer.new(subscription) }
it "updates the line_item quantities and totals on all orders" do
expect(order.reload.total.to_f).to eq 59.97
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
line_items = Spree::LineItem.where(order_id: standing_order.orders, variant_id: sli.variant_id)
line_items = Spree::LineItem.where(order_id: subscription.orders, variant_id: sli.variant_id)
expect(line_items.map(&:quantity)).to eq [3]
expect(order.reload.total.to_f).to eq 99.95
end
@@ -322,7 +322,7 @@ describe OrderSyncer do
context "where the quantity of the item on an initialised order has already been changed" do
let(:params) { { standing_line_items_attributes: [{ id: sli.id, quantity: 3}] } }
let(:syncer) { OrderSyncer.new(standing_order) }
let(:syncer) { OrderSyncer.new(subscription) }
let(:changed_line_item) { order.line_items.find_by_variant_id(sli.variant_id) }
before { variant.update_attribute(:count_on_hand, 3) }
@@ -332,7 +332,7 @@ describe OrderSyncer do
it "does not change the quantity, and doesn't add the order to order_update_issues" do
expect(order.reload.total.to_f).to eq 99.95
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
expect(changed_line_item.reload.quantity).to eq 3
expect(order.reload.total.to_f).to eq 99.95
@@ -345,7 +345,7 @@ describe OrderSyncer do
it "does not change the quantity, and adds the order to order_update_issues" do
expect(order.reload.total.to_f).to eq 79.96
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
expect(changed_line_item.reload.quantity).to eq 2
expect(order.reload.total.to_f).to eq 79.96
@@ -356,35 +356,35 @@ describe OrderSyncer do
end
describe "adding a new line item" do
let(:standing_order) { create(:standing_order, with_items: true, with_proxy_orders: true) }
let(:order) { standing_order.proxy_orders.first.initialise_order! }
let(:subscription) { create(:subscription, with_items: true, with_proxy_orders: true) }
let(:order) { subscription.proxy_orders.first.initialise_order! }
let(:variant) { create(:variant) }
let(:params) { { standing_line_items_attributes: [{ id: nil, variant_id: variant.id, quantity: 1}] } }
let(:syncer) { OrderSyncer.new(standing_order) }
let(:syncer) { OrderSyncer.new(subscription) }
it "adds the line item and updates the total on all orders" do
expect(order.reload.total.to_f).to eq 59.97
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
line_items = Spree::LineItem.where(order_id: standing_order.orders, variant_id: variant.id)
line_items = Spree::LineItem.where(order_id: subscription.orders, variant_id: variant.id)
expect(line_items.map(&:quantity)).to eq [1]
expect(order.reload.total.to_f).to eq 79.96
end
end
describe "removing an existing line item" do
let(:standing_order) { create(:standing_order, with_items: true, with_proxy_orders: true) }
let(:order) { standing_order.proxy_orders.first.initialise_order! }
let(:sli) { standing_order.standing_line_items.first }
let(:subscription) { create(:subscription, with_items: true, with_proxy_orders: true) }
let(:order) { subscription.proxy_orders.first.initialise_order! }
let(:sli) { subscription.standing_line_items.first }
let(:variant) { sli.variant }
let(:params) { { standing_line_items_attributes: [{ id: sli.id, _destroy: true }] } }
let(:syncer) { OrderSyncer.new(standing_order) }
let(:syncer) { OrderSyncer.new(subscription) }
it "removes the line item and updates totals on all orders" do
expect(order.reload.total.to_f).to eq 59.97
standing_order.assign_attributes(params)
subscription.assign_attributes(params)
expect(syncer.sync!).to be true
line_items = Spree::LineItem.where(order_id: standing_order.orders, variant_id: variant.id)
line_items = Spree::LineItem.where(order_id: subscription.orders, variant_id: variant.id)
expect(line_items.count).to be 0
expect(order.reload.total.to_f).to eq 39.98
end

20
spec/services/subscription_form_spec.rb
View File

@@ -1,5 +1,5 @@
describe StandingOrderForm do
describe "creating a new standing order" do
describe SubscriptionForm do
describe "creating a new subscription" do
let!(:shop) { create(:distributor_enterprise) }
let!(:customer) { create(:customer, enterprise: shop) }
let!(:product1) { create(:product, supplier: shop) }
@@ -21,7 +21,7 @@ describe StandingOrderForm do
let!(:payment_method) { create(:payment_method, distributors: [shop]) }
let!(:shipping_method) { create(:shipping_method, distributors: [shop]) }
let!(:address) { create(:address) }
let(:standing_order) { StandingOrder.new }
let(:subscription) { Subscription.new }
let!(:params) {
{
@@ -41,20 +41,20 @@ describe StandingOrderForm do
]
} }
let(:form) { StandingOrderForm.new(standing_order, params) }
let(:form) { SubscriptionForm.new(subscription, params) }
it "creates orders for each order cycle in the schedule" do
Spree::Config.set allow_backorders: false
expect(form.save).to be true
expect(standing_order.proxy_orders.count).to be 2
expect(subscription.proxy_orders.count).to be 2
# This order cycle has already closed, so no order is initialized
proxy_order1 = standing_order.proxy_orders.find_by_order_cycle_id(order_cycle1.id)
proxy_order1 = subscription.proxy_orders.find_by_order_cycle_id(order_cycle1.id)
expect(proxy_order1).to be nil
# Currently open order cycle, closing after begins_at and before ends_at
proxy_order2 = standing_order.proxy_orders.find_by_order_cycle_id(order_cycle2.id)
proxy_order2 = subscription.proxy_orders.find_by_order_cycle_id(order_cycle2.id)
expect(proxy_order2).to be_a ProxyOrder
order2 = proxy_order2.initialise_order!
expect(order2.line_items.count).to be 3
@@ -69,7 +69,7 @@ describe StandingOrderForm do
# Future order cycle, closing after begins_at and before ends_at
# Adds line items for variants that aren't yet available from the order cycle
proxy_order3 = standing_order.proxy_orders.find_by_order_cycle_id(order_cycle3.id)
proxy_order3 = subscription.proxy_orders.find_by_order_cycle_id(order_cycle3.id)
expect(proxy_order3).to be_a ProxyOrder
order3 = proxy_order3.initialise_order!
expect(order3).to be_a Spree::Order
@@ -84,14 +84,14 @@ describe StandingOrderForm do
expect(order3.completed?).to be false
# Future order cycle closing after ends_at
proxy_order4 = standing_order.proxy_orders.find_by_order_cycle_id(order_cycle4.id)
proxy_order4 = subscription.proxy_orders.find_by_order_cycle_id(order_cycle4.id)
expect(proxy_order4).to be nil
end
end
describe "validating price_estimates on standing line items" do
let(:params) { { } }
let(:form) { StandingOrderForm.new(nil, params) }
let(:form) { SubscriptionForm.new(nil, params) }
context "when line_item params are present" do
before { allow(form).to receive(:price_estimate_for) }

86
spec/services/subscription_validator_spec.rb
View File

@@ -1,25 +1,25 @@
describe StandingOrderValidator do
describe SubscriptionValidator do
let(:shop) { instance_double(Enterprise, name: "Shop") }
describe "delegation" do
let(:standing_order) { create(:standing_order) }
let(:validator) { StandingOrderValidator.new(standing_order) }
let(:subscription) { create(:subscription) }
let(:validator) { SubscriptionValidator.new(subscription) }
it "delegates to standing_order" do
expect(validator.shop).to eq standing_order.shop
expect(validator.customer).to eq standing_order.customer
expect(validator.schedule).to eq standing_order.schedule
expect(validator.shipping_method).to eq standing_order.shipping_method
expect(validator.payment_method).to eq standing_order.payment_method
expect(validator.bill_address).to eq standing_order.bill_address
expect(validator.ship_address).to eq standing_order.ship_address
expect(validator.begins_at).to eq standing_order.begins_at
expect(validator.ends_at).to eq standing_order.ends_at
it "delegates to subscription" do
expect(validator.shop).to eq subscription.shop
expect(validator.customer).to eq subscription.customer
expect(validator.schedule).to eq subscription.schedule
expect(validator.shipping_method).to eq subscription.shipping_method
expect(validator.payment_method).to eq subscription.payment_method
expect(validator.bill_address).to eq subscription.bill_address
expect(validator.ship_address).to eq subscription.ship_address
expect(validator.begins_at).to eq subscription.begins_at
expect(validator.ends_at).to eq subscription.ends_at
end
end
describe "validations" do
let(:standing_order_stubs) do
let(:subscription_stubs) do
{
shop: shop,
customer: true,
@@ -48,8 +48,8 @@ describe StandingOrderValidator do
}
end
let(:standing_order) { instance_double(StandingOrder, standing_order_stubs) }
let(:validator) { StandingOrderValidator.new(standing_order) }
let(:subscription) { instance_double(Subscription, subscription_stubs) }
let(:validator) { SubscriptionValidator.new(subscription) }
def stub_validations(validator, methods)
methods.each do |name, value|
@@ -58,11 +58,11 @@ describe StandingOrderValidator do
end
describe "shipping method validation" do
let(:standing_order) { instance_double(StandingOrder, standing_order_stubs.except(:shipping_method)) }
let(:subscription) { instance_double(Subscription, subscription_stubs.except(:shipping_method)) }
before { stub_validations(validator, validation_stubs.except(:shipping_method_allowed?)) }
context "when no shipping method is present" do
before { expect(standing_order).to receive(:shipping_method).at_least(:once) { nil } }
before { expect(subscription).to receive(:shipping_method).at_least(:once) { nil } }
it "adds an error and returns false" do
expect(validator.valid?).to be false
@@ -72,7 +72,7 @@ describe StandingOrderValidator do
context "when a shipping method is present" do
let(:shipping_method) { instance_double(Spree::ShippingMethod, distributors: [shop]) }
before { expect(standing_order).to receive(:shipping_method).at_least(:once) { shipping_method } }
before { expect(subscription).to receive(:shipping_method).at_least(:once) { shipping_method } }
context "and the shipping method is not associated with the shop" do
before { allow(shipping_method).to receive(:distributors) { [double(:enterprise)] } }
@@ -95,11 +95,11 @@ describe StandingOrderValidator do
end
describe "payment method validation" do
let(:standing_order) { instance_double(StandingOrder, standing_order_stubs.except(:payment_method)) }
let(:subscription) { instance_double(Subscription, subscription_stubs.except(:payment_method)) }
before { stub_validations(validator, validation_stubs.except(:payment_method_allowed?)) }
context "when no payment method is present" do
before { expect(standing_order).to receive(:payment_method).at_least(:once) { nil } }
before { expect(subscription).to receive(:payment_method).at_least(:once) { nil } }
it "adds an error and returns false" do
expect(validator.valid?).to be false
@@ -109,7 +109,7 @@ describe StandingOrderValidator do
context "when a payment method is present" do
let(:payment_method) { instance_double(Spree::PaymentMethod, distributors: [shop]) }
before { expect(standing_order).to receive(:payment_method).at_least(:once) { payment_method } }
before { expect(subscription).to receive(:payment_method).at_least(:once) { payment_method } }
context "and the payment method is not associated with the shop" do
before { allow(payment_method).to receive(:distributors) { [double(:enterprise)] } }
@@ -132,12 +132,12 @@ describe StandingOrderValidator do
end
describe "payment method type validation" do
let(:standing_order) { instance_double(StandingOrder, standing_order_stubs.except(:payment_method)) }
let(:subscription) { instance_double(Subscription, subscription_stubs.except(:payment_method)) }
before { stub_validations(validator, validation_stubs.except(:payment_method_type_allowed?)) }
context "when a payment method is present" do
let(:payment_method) { instance_double(Spree::PaymentMethod, distributors: [shop]) }
before { expect(standing_order).to receive(:payment_method).at_least(:once) { payment_method } }
before { expect(subscription).to receive(:payment_method).at_least(:once) { payment_method } }
context "and the payment method type is not in the approved list" do
before { allow(payment_method).to receive(:type) { "Blah" } }
@@ -149,7 +149,7 @@ describe StandingOrderValidator do
end
context "and the payment method is in the approved list" do
let(:approved_type) { StandingOrder::ALLOWED_PAYMENT_METHOD_TYPES.first }
let(:approved_type) { Subscription::ALLOWED_PAYMENT_METHOD_TYPES.first }
before { allow(payment_method).to receive(:type) { approved_type } }
it "returns true" do
@@ -161,9 +161,9 @@ describe StandingOrderValidator do
end
describe "dates" do
let(:standing_order) { instance_double(StandingOrder, standing_order_stubs.except(:begins_at, :ends_at)) }
let(:subscription) { instance_double(Subscription, subscription_stubs.except(:begins_at, :ends_at)) }
before { stub_validations(validator, validation_stubs.except(:ends_at_after_begins_at?)) }
before { expect(standing_order).to receive(:begins_at).at_least(:once) { begins_at } }
before { expect(subscription).to receive(:begins_at).at_least(:once) { begins_at } }
context "when no begins_at is present" do
let(:begins_at) { nil }
@@ -176,7 +176,7 @@ describe StandingOrderValidator do
context "when a start date is present" do
let(:begins_at) { Time.zone.today }
before { expect(standing_order).to receive(:ends_at).at_least(:once) { ends_at } }
before { expect(subscription).to receive(:ends_at).at_least(:once) { ends_at } }
context "when no ends_at is present" do
let(:ends_at) { nil }
@@ -215,9 +215,9 @@ describe StandingOrderValidator do
describe "addresses" do
before { stub_validations(validator, validation_stubs) }
let(:standing_order) { instance_double(StandingOrder, standing_order_stubs.except(:bill_address, :ship_address)) }
before { expect(standing_order).to receive(:bill_address).at_least(:once) { bill_address } }
before { expect(standing_order).to receive(:ship_address).at_least(:once) { ship_address } }
let(:subscription) { instance_double(Subscription, subscription_stubs.except(:bill_address, :ship_address)) }
before { expect(subscription).to receive(:bill_address).at_least(:once) { bill_address } }
before { expect(subscription).to receive(:ship_address).at_least(:once) { ship_address } }
context "when bill_address and ship_address are not present" do
let(:bill_address) { nil }
@@ -243,9 +243,9 @@ describe StandingOrderValidator do
end
describe "customer" do
let(:standing_order) { instance_double(StandingOrder, standing_order_stubs.except(:customer)) }
let(:subscription) { instance_double(Subscription, subscription_stubs.except(:customer)) }
before { stub_validations(validator, validation_stubs.except(:customer_allowed?)) }
before { expect(standing_order).to receive(:customer).at_least(:once) { customer } }
before { expect(subscription).to receive(:customer).at_least(:once) { customer } }
context "when no customer is present" do
let(:customer) { nil }
@@ -280,9 +280,9 @@ describe StandingOrderValidator do
end
describe "schedule" do
let(:standing_order) { instance_double(StandingOrder, standing_order_stubs.except(:schedule)) }
let(:subscription) { instance_double(Subscription, subscription_stubs.except(:schedule)) }
before { stub_validations(validator, validation_stubs.except(:schedule_allowed?)) }
before { expect(standing_order).to receive(:schedule).at_least(:once) { schedule } }
before { expect(subscription).to receive(:schedule).at_least(:once) { schedule } }
context "when no schedule is present" do
let(:schedule) { nil }
@@ -317,9 +317,9 @@ describe StandingOrderValidator do
end
describe "credit card" do
let(:standing_order) { instance_double(StandingOrder, standing_order_stubs.except(:payment_method)) }
let(:subscription) { instance_double(Subscription, subscription_stubs.except(:payment_method)) }
before { stub_validations(validator, validation_stubs.except(:credit_card_ok?)) }
before { expect(standing_order).to receive(:payment_method).at_least(:once) { payment_method } }
before { expect(subscription).to receive(:payment_method).at_least(:once) { payment_method } }
context "when using a Check payment method" do
let(:payment_method) { instance_double(Spree::PaymentMethod, type: "Spree::PaymentMethod::Check") }
@@ -332,7 +332,7 @@ describe StandingOrderValidator do
context "when using the StripeConnect payment gateway" do
let(:payment_method) { instance_double(Spree::PaymentMethod, type: "Spree::Gateway::StripeConnect") }
before { expect(standing_order).to receive(:credit_card_id).at_least(:once) { credit_card_id } }
before { expect(subscription).to receive(:credit_card_id).at_least(:once) { credit_card_id } }
context "when a credit card is not present" do
let(:credit_card_id) { nil }
@@ -345,7 +345,7 @@ describe StandingOrderValidator do
context "when a credit card is present" do
let(:credit_card_id) { 12 }
before { expect(standing_order).to receive(:customer).at_least(:once) { customer } }
before { expect(subscription).to receive(:customer).at_least(:once) { customer } }
context "and the customer is not associated with a user" do
let(:customer) { instance_double(Customer, user: nil) }
@@ -382,9 +382,9 @@ describe StandingOrderValidator do
end
describe "standing line items" do
let(:standing_order) { instance_double(StandingOrder, standing_order_stubs) }
let(:subscription) { instance_double(Subscription, subscription_stubs) }
before { stub_validations(validator, validation_stubs.except(:standing_line_items_present?)) }
before { expect(standing_order).to receive(:standing_line_items).at_least(:once) { standing_line_items } }
before { expect(subscription).to receive(:standing_line_items).at_least(:once) { standing_line_items } }
context "when no standing line items are present" do
let(:standing_line_items) { [] }
@@ -418,9 +418,9 @@ describe StandingOrderValidator do
end
describe "variant availability" do
let(:standing_order) { instance_double(StandingOrder, standing_order_stubs) }
let(:subscription) { instance_double(Subscription, subscription_stubs) }
before { stub_validations(validator, validation_stubs.except(:requested_variants_available?)) }
before { expect(standing_order).to receive(:standing_line_items).at_least(:once) { standing_line_items } }
before { expect(subscription).to receive(:standing_line_items).at_least(:once) { standing_line_items } }
context "when no standing line items are present" do
let(:standing_line_items) { [] }