mirror of
https://github.com/openfoodfoundation/openfoodnetwork
synced 2026-01-26 20:56:48 +00:00
1170 lines
57 KiB
Ruby
1170 lines
57 KiB
Ruby
require 'spec_helper'
|
|
|
|
feature '
|
|
As an administrator
|
|
I want to manage order cycles
|
|
', js: true do
|
|
include AdminHelper
|
|
include AuthenticationWorkflow
|
|
include WebHelper
|
|
|
|
scenario "listing and filtering order cycles" do
|
|
# Given some order cycles (created in an arbitrary order)
|
|
oc4 = create(:simple_order_cycle, name: 'oc4',
|
|
orders_open_at: 2.days.from_now, orders_close_at: 1.month.from_now)
|
|
oc2 = create(:simple_order_cycle, name: 'oc2', orders_close_at: 1.month.from_now)
|
|
oc6 = create(:simple_order_cycle, name: 'oc6',
|
|
orders_open_at: 1.month.ago, orders_close_at: 3.weeks.ago)
|
|
oc3 = create(:simple_order_cycle, name: 'oc3',
|
|
orders_open_at: 1.day.from_now, orders_close_at: 1.month.from_now)
|
|
oc5 = create(:simple_order_cycle, name: 'oc5',
|
|
orders_open_at: 1.month.ago, orders_close_at: 2.weeks.ago)
|
|
oc1 = create(:order_cycle, name: 'oc1')
|
|
oc0 = create(:simple_order_cycle, name: 'oc0',
|
|
orders_open_at: nil, orders_close_at: nil)
|
|
oc7 = create(:simple_order_cycle, name: 'oc7',
|
|
orders_open_at: 2.months.ago, orders_close_at: 5.weeks.ago)
|
|
schedule1 = create(:schedule, name: 'Schedule1', order_cycles: [oc1, oc3])
|
|
create(:proxy_order, subscription: create(:subscription, schedule: schedule1), order_cycle: oc1)
|
|
|
|
# When I go to the admin order cycles page
|
|
login_to_admin_section
|
|
click_link 'Order Cycles'
|
|
|
|
# Then the order cycles should be ordered correctly
|
|
expect(page).to have_selector "#listing_order_cycles tr td:first-child", count: 7
|
|
|
|
order_cycle_names = ["oc0", "oc1", "oc2", "oc3", "oc4", "oc5", "oc6"]
|
|
expect(all("#listing_order_cycles tr td:first-child input").map(&:value)).to eq order_cycle_names
|
|
|
|
# And the rows should have the correct classes
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc0.id}.undated"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc1.id}.open"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc2.id}.open"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc3.id}.upcoming"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc4.id}.upcoming"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc5.id}.closed"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc6.id}.closed"
|
|
|
|
toggle_columns "Producers", "Shops"
|
|
|
|
# And I should see all the details for an order cycle
|
|
within('table#listing_order_cycles tbody tr:nth-child(2)') do
|
|
# Then I should see the basic fields
|
|
expect(page).to have_input "oc#{oc1.id}[name]", value: oc1.name
|
|
expect(page).to have_input "oc#{oc1.id}[orders_open_at]", value: oc1.orders_open_at
|
|
expect(page).to have_input "oc#{oc1.id}[orders_close_at]", value: oc1.orders_close_at
|
|
expect(page).to have_content oc1.coordinator.name
|
|
|
|
# And I should see the suppliers and distributors
|
|
oc1.suppliers.each { |s| expect(page).to have_content s.name }
|
|
oc1.distributors.each { |d| expect(page).to have_content d.name }
|
|
|
|
# And I should see the number of variants
|
|
expect(page).to have_selector 'td.products', text: '2 variants'
|
|
end
|
|
|
|
# I can load more order_cycles
|
|
expect(page).to have_no_selector "#listing_order_cycles tr.order-cycle-#{oc7.id}"
|
|
click_button "Show 30 more days"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc7.id}"
|
|
|
|
# I can filter order cycle by involved enterprises
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc0.id}"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc1.id}"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc2.id}"
|
|
select2_select oc1.suppliers.first.name, from: "involving_filter"
|
|
expect(page).to have_no_selector "#listing_order_cycles tr.order-cycle-#{oc0.id}"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc1.id}"
|
|
expect(page).to have_no_selector "#listing_order_cycles tr.order-cycle-#{oc2.id}"
|
|
select2_select "Any Enterprise", from: "involving_filter"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc0.id}"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc1.id}"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc2.id}"
|
|
|
|
# I can filter order cycles by name
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc0.id}"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc1.id}"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc2.id}"
|
|
fill_in "query", with: oc0.name
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc0.id}"
|
|
expect(page).to have_no_selector "#listing_order_cycles tr.order-cycle-#{oc1.id}"
|
|
expect(page).to have_no_selector "#listing_order_cycles tr.order-cycle-#{oc2.id}"
|
|
fill_in "query", with: ''
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc0.id}"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc1.id}"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc2.id}"
|
|
|
|
# I can filter order cycle by schedule
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc0.id}"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc1.id}"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc2.id}"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc3.id}"
|
|
select2_select schedule1.name, from: "schedule_filter"
|
|
expect(page).to have_no_selector "#listing_order_cycles tr.order-cycle-#{oc0.id}"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc1.id}"
|
|
expect(page).to have_no_selector "#listing_order_cycles tr.order-cycle-#{oc2.id}"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc3.id}"
|
|
select2_select 'Any Schedule', from: "schedule_filter"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc0.id}"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc1.id}"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc2.id}"
|
|
expect(page).to have_selector "#listing_order_cycles tr.order-cycle-#{oc3.id}"
|
|
|
|
# Attempting to edit dates of an open order cycle with active subscriptions
|
|
find("#oc#{oc1.id}_orders_open_at").click
|
|
expect(page).to have_selector "#confirm-dialog .message", text: I18n.t('admin.order_cycles.date_warning.msg', n: 1)
|
|
end
|
|
|
|
describe 'listing order cycles with other locales' do
|
|
let!(:oc_de) { create(:simple_order_cycle, name: 'oc', orders_open_at: '2012-01-01 00:00') }
|
|
|
|
around(:each) do |spec|
|
|
I18n.locale = :de
|
|
spec.run
|
|
I18n.locale = :en
|
|
end
|
|
|
|
context 'using datepickers' do
|
|
it "correctly opens the datepicker and changes the date field" do
|
|
quick_login_as_admin
|
|
visit admin_order_cycles_path
|
|
|
|
within("tr.order-cycle-#{oc_de.id}") do
|
|
expect(find('input.datetimepicker', match: :first).value).to start_with '2012-01-01 00:00'
|
|
find('img.ui-datepicker-trigger', match: :first).click
|
|
end
|
|
|
|
within("#ui-datepicker-div") do
|
|
expect(page).to have_selector 'a.ui-state-active', text: '1'
|
|
|
|
click_link '30'
|
|
find('button.ui-datepicker-close', match: :first).click
|
|
end
|
|
|
|
within("tr.order-cycle-#{oc_de.id}") do
|
|
expect(find('input.datetimepicker', match: :first).value).to eq '2012-01-30 00:00'
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
context "with specific time" do
|
|
let(:order_cycle_opening_time) { Time.zone.local(2040, 11, 0o6, 0o6, 0o0, 0o0).strftime("%F %T %z") }
|
|
let(:order_cycle_closing_time) { Time.zone.local(2040, 11, 13, 17, 0o0, 0o0).strftime("%F %T %z") }
|
|
|
|
scenario "creating an order cycle with full interface", js: true do
|
|
# Given coordinating, supplying and distributing enterprises with some products with variants
|
|
coordinator = create(:distributor_enterprise, name: 'My coordinator')
|
|
supplier = create(:supplier_enterprise, name: 'My supplier')
|
|
product = create(:product, supplier: supplier)
|
|
v1 = create(:variant, product: product)
|
|
v2 = create(:variant, product: product)
|
|
distributor = create(:distributor_enterprise, name: 'My distributor', with_payment_and_shipping: true)
|
|
|
|
# Relationships required for interface to work
|
|
create(:enterprise_relationship, parent: supplier, child: coordinator, permissions_list: [:add_to_order_cycle])
|
|
create(:enterprise_relationship, parent: distributor, child: coordinator, permissions_list: [:add_to_order_cycle])
|
|
create(:enterprise_relationship, parent: supplier, child: distributor, permissions_list: [:add_to_order_cycle])
|
|
|
|
# And some enterprise fees
|
|
supplier_fee = create(:enterprise_fee, enterprise: supplier, name: 'Supplier fee')
|
|
coordinator_fee = create(:enterprise_fee, enterprise: coordinator, name: 'Coord fee')
|
|
distributor_fee = create(:enterprise_fee, enterprise: distributor, name: 'Distributor fee')
|
|
|
|
# When I go to the new order cycle page
|
|
quick_login_as_admin
|
|
visit admin_order_cycles_path
|
|
click_link 'New Order Cycle'
|
|
|
|
# Select a coordinator since there are two available
|
|
select2_select 'My coordinator', from: 'coordinator_id'
|
|
click_button "Continue >"
|
|
|
|
# I cannot save before filling in the required fields
|
|
expect(page).to have_button("Create", disabled: true)
|
|
|
|
# The Create button is enabled once Name is entered
|
|
fill_in 'order_cycle_name', with: 'Plums & Avos'
|
|
expect(page).to have_button("Create", disabled: false)
|
|
|
|
# If I fill in the basic fields
|
|
fill_in 'order_cycle_orders_open_at', with: order_cycle_opening_time
|
|
fill_in 'order_cycle_orders_close_at', with: order_cycle_closing_time
|
|
|
|
# And I add a coordinator fee
|
|
click_button 'Add coordinator fee'
|
|
select 'Coord fee', from: 'order_cycle_coordinator_fee_0_id'
|
|
|
|
click_button 'Create'
|
|
expect(page).to have_content 'Your order cycle has been created.'
|
|
|
|
# I should not be able to add a blank supplier
|
|
expect(page).to have_select 'new_supplier_id', selected: ''
|
|
expect(page).to have_button 'Add supplier', disabled: true
|
|
|
|
# And I add a supplier and some products
|
|
select 'My supplier', from: 'new_supplier_id'
|
|
click_button 'Add supplier'
|
|
fill_in 'order_cycle_incoming_exchange_0_receival_instructions', with: 'receival instructions'
|
|
page.find('table.exchanges tr.supplier td.products').click
|
|
check "order_cycle_incoming_exchange_0_variants_#{v1.id}"
|
|
check "order_cycle_incoming_exchange_0_variants_#{v2.id}"
|
|
|
|
# I should not be able to re-add the supplier
|
|
expect(page).not_to have_select 'new_supplier_id', with_options: ['My supplier']
|
|
expect(page).to have_button 'Add supplier', disabled: true
|
|
expect(page.all("td.supplier_name").map(&:text)).to eq(['My supplier'])
|
|
|
|
# And I add a supplier fee
|
|
within("tr.supplier-#{supplier.id}") { click_button 'Add fee' }
|
|
select 'My supplier', from: 'order_cycle_incoming_exchange_0_enterprise_fees_0_enterprise_id'
|
|
select 'Supplier fee', from: 'order_cycle_incoming_exchange_0_enterprise_fees_0_enterprise_fee_id'
|
|
|
|
click_button 'Save and Next'
|
|
|
|
# And I add a distributor with the same products
|
|
select 'My distributor', from: 'new_distributor_id'
|
|
click_button 'Add distributor'
|
|
|
|
fill_in 'order_cycle_outgoing_exchange_0_pickup_time', with: 'pickup time'
|
|
fill_in 'order_cycle_outgoing_exchange_0_pickup_instructions', with: 'pickup instructions'
|
|
|
|
page.find('table.exchanges tr.distributor td.products').click
|
|
check "order_cycle_outgoing_exchange_0_variants_#{v1.id}"
|
|
check "order_cycle_outgoing_exchange_0_variants_#{v2.id}"
|
|
|
|
page.find('table.exchanges tr.distributor td.tags').click
|
|
within ".exchange-tags" do
|
|
find(:css, "tags-input .tags input").set "wholesale\n"
|
|
end
|
|
|
|
# And I add a distributor fee
|
|
within("tr.distributor-#{distributor.id}") { click_button 'Add fee' }
|
|
select 'My distributor', from: 'order_cycle_outgoing_exchange_0_enterprise_fees_0_enterprise_id'
|
|
select 'Distributor fee', from: 'order_cycle_outgoing_exchange_0_enterprise_fees_0_enterprise_fee_id'
|
|
|
|
click_button 'Save and Back to List'
|
|
|
|
oc = OrderCycle.last
|
|
toggle_columns "Producers", "Shops"
|
|
|
|
expect(page).to have_input "oc#{oc.id}[name]", value: "Plums & Avos"
|
|
expect(page).to have_input "oc#{oc.id}[orders_open_at]", value: order_cycle_opening_time
|
|
expect(page).to have_input "oc#{oc.id}[orders_close_at]", value: order_cycle_closing_time
|
|
expect(page).to have_content "My coordinator"
|
|
|
|
expect(page).to have_selector 'td.producers', text: 'My supplier'
|
|
expect(page).to have_selector 'td.shops', text: 'My distributor'
|
|
|
|
# And it should have some fees
|
|
expect(oc.exchanges.incoming.first.enterprise_fees).to eq([supplier_fee])
|
|
expect(oc.coordinator_fees).to eq([coordinator_fee])
|
|
expect(oc.exchanges.outgoing.first.enterprise_fees).to eq([distributor_fee])
|
|
|
|
# And it should have some variants selected
|
|
expect(oc.exchanges.first.variants.count).to eq(2)
|
|
expect(oc.exchanges.last.variants.count).to eq(2)
|
|
|
|
# And my receival and pickup time and instructions should have been saved
|
|
exchange = oc.exchanges.incoming.first
|
|
expect(exchange.receival_instructions).to eq('receival instructions')
|
|
|
|
exchange = oc.exchanges.outgoing.first
|
|
expect(exchange.pickup_time).to eq('pickup time')
|
|
expect(exchange.pickup_instructions).to eq('pickup instructions')
|
|
expect(exchange.tag_list).to eq(['wholesale'])
|
|
end
|
|
|
|
scenario "updating an order cycle", js: true do
|
|
# Given an order cycle with all the settings
|
|
oc = create(:order_cycle)
|
|
initial_variants = oc.variants.sort_by(&:id)
|
|
|
|
# And a coordinating, supplying and distributing enterprise with some products with variants
|
|
coordinator = oc.coordinator
|
|
supplier = create(:supplier_enterprise, name: 'My supplier')
|
|
distributor = create(:distributor_enterprise, name: 'My distributor', with_payment_and_shipping: true)
|
|
product = create(:product, supplier: supplier)
|
|
v1 = create(:variant, product: product)
|
|
v2 = create(:variant, product: product)
|
|
|
|
# Relationships required for interface to work
|
|
create(:enterprise_relationship, parent: supplier, child: coordinator, permissions_list: [:add_to_order_cycle])
|
|
create(:enterprise_relationship, parent: distributor, child: coordinator, permissions_list: [:add_to_order_cycle])
|
|
create(:enterprise_relationship, parent: supplier, child: distributor, permissions_list: [:add_to_order_cycle])
|
|
|
|
# And some enterprise fees
|
|
supplier_fee1 = create(:enterprise_fee, enterprise: supplier, name: 'Supplier fee 1')
|
|
supplier_fee2 = create(:enterprise_fee, enterprise: supplier, name: 'Supplier fee 2')
|
|
coordinator_fee1 = create(:enterprise_fee, enterprise: coordinator, name: 'Coord fee 1')
|
|
coordinator_fee2 = create(:enterprise_fee, enterprise: coordinator, name: 'Coord fee 2')
|
|
distributor_fee1 = create(:enterprise_fee, enterprise: distributor, name: 'Distributor fee 1')
|
|
distributor_fee2 = create(:enterprise_fee, enterprise: distributor, name: 'Distributor fee 2')
|
|
|
|
# When I go to its edit page
|
|
quick_login_as_admin
|
|
visit admin_order_cycles_path
|
|
within "tr.order-cycle-#{oc.id}" do
|
|
find("a.edit-order-cycle").click
|
|
end
|
|
|
|
wait_for_edit_form_to_load_order_cycle(oc)
|
|
|
|
# And I update it
|
|
fill_in 'order_cycle_name', with: 'Plums & Avos'
|
|
fill_in 'order_cycle_orders_open_at', with: order_cycle_opening_time
|
|
fill_in 'order_cycle_orders_close_at', with: order_cycle_closing_time
|
|
|
|
# And I configure some coordinator fees
|
|
click_button 'Add coordinator fee'
|
|
select 'Coord fee 1', from: 'order_cycle_coordinator_fee_0_id'
|
|
click_button 'Add coordinator fee'
|
|
click_button 'Add coordinator fee'
|
|
click_link 'order_cycle_coordinator_fee_2_remove'
|
|
select 'Coord fee 2', from: 'order_cycle_coordinator_fee_1_id'
|
|
|
|
click_button 'Save and Next'
|
|
expect(page).to have_content 'Your order cycle has been updated.'
|
|
|
|
# And I add a supplier and some products
|
|
expect(page).to have_selector("table.exchanges tr.supplier")
|
|
select 'My supplier', from: 'new_supplier_id'
|
|
click_button 'Add supplier'
|
|
expect(page).to have_selector("table.exchanges tr.supplier", text: "My supplier")
|
|
page.all("table.exchanges tr.supplier td.products").each(&:click)
|
|
|
|
|
|
expect(page).to have_selector "#order_cycle_incoming_exchange_1_variants_#{initial_variants.last.id}", visible: true
|
|
page.find("#order_cycle_incoming_exchange_1_variants_#{initial_variants.last.id}", visible: true).click # uncheck (with visible:true filter)
|
|
check "order_cycle_incoming_exchange_2_variants_#{v1.id}"
|
|
check "order_cycle_incoming_exchange_2_variants_#{v2.id}"
|
|
|
|
# And I configure some supplier fees
|
|
within("tr.supplier-#{supplier.id}") { click_button 'Add fee' }
|
|
select 'My supplier', from: 'order_cycle_incoming_exchange_2_enterprise_fees_0_enterprise_id'
|
|
select 'Supplier fee 1', from: 'order_cycle_incoming_exchange_2_enterprise_fees_0_enterprise_fee_id'
|
|
within("tr.supplier-#{supplier.id}") { click_button 'Add fee' }
|
|
within("tr.supplier-#{supplier.id}") { click_button 'Add fee' }
|
|
click_link 'order_cycle_incoming_exchange_2_enterprise_fees_0_remove'
|
|
select 'My supplier', from: 'order_cycle_incoming_exchange_2_enterprise_fees_0_enterprise_id'
|
|
select 'Supplier fee 2', from: 'order_cycle_incoming_exchange_2_enterprise_fees_0_enterprise_fee_id'
|
|
|
|
click_button 'Save and Next'
|
|
|
|
# And I add a distributor and some products
|
|
select 'My distributor', from: 'new_distributor_id'
|
|
click_button 'Add distributor'
|
|
expect(page).to have_field("order_cycle_outgoing_exchange_2_pickup_time")
|
|
|
|
fill_in 'order_cycle_outgoing_exchange_0_pickup_time', with: 'New time 0'
|
|
fill_in 'order_cycle_outgoing_exchange_0_pickup_instructions', with: 'New instructions 0'
|
|
fill_in 'order_cycle_outgoing_exchange_1_pickup_time', with: 'New time 1'
|
|
fill_in 'order_cycle_outgoing_exchange_1_pickup_instructions', with: 'New instructions 1'
|
|
fill_in 'order_cycle_outgoing_exchange_2_pickup_time', with: 'New time 2'
|
|
fill_in 'order_cycle_outgoing_exchange_2_pickup_instructions', with: 'New instructions 2'
|
|
|
|
page.find("table.exchanges tr.distributor-#{distributor.id} td.tags").click
|
|
within ".exchange-tags" do
|
|
find(:css, "tags-input .tags input").set "wholesale\n"
|
|
end
|
|
|
|
page.all("table.exchanges tr.distributor td.products").each(&:click)
|
|
|
|
uncheck "order_cycle_outgoing_exchange_2_variants_#{v1.id}"
|
|
check "order_cycle_outgoing_exchange_2_variants_#{v2.id}"
|
|
|
|
# And I configure some distributor fees
|
|
within("tr.distributor-#{distributor.id}") { click_button 'Add fee' }
|
|
select 'My distributor', from: 'order_cycle_outgoing_exchange_2_enterprise_fees_0_enterprise_id'
|
|
select 'Distributor fee 1', from: 'order_cycle_outgoing_exchange_2_enterprise_fees_0_enterprise_fee_id'
|
|
within("tr.distributor-#{distributor.id}") { click_button 'Add fee' }
|
|
within("tr.distributor-#{distributor.id}") { click_button 'Add fee' }
|
|
click_link 'order_cycle_outgoing_exchange_2_enterprise_fees_0_remove'
|
|
select 'My distributor', from: 'order_cycle_outgoing_exchange_2_enterprise_fees_0_enterprise_id'
|
|
select 'Distributor fee 2', from: 'order_cycle_outgoing_exchange_2_enterprise_fees_0_enterprise_fee_id'
|
|
|
|
expect(page).to have_selector "#save-bar"
|
|
click_button 'Save and Back to List'
|
|
|
|
oc = OrderCycle.last
|
|
toggle_columns "Producers", "Shops"
|
|
|
|
expect(page).to have_input "oc#{oc.id}[name]", value: "Plums & Avos"
|
|
expect(page).to have_input "oc#{oc.id}[orders_open_at]", value: order_cycle_opening_time
|
|
expect(page).to have_input "oc#{oc.id}[orders_close_at]", value: order_cycle_closing_time
|
|
expect(page).to have_content coordinator.name
|
|
|
|
expect(page).to have_selector 'td.producers', text: 'My supplier'
|
|
expect(page).to have_selector 'td.shops', text: 'My distributor'
|
|
|
|
# And my coordinator fees should have been configured
|
|
expect(oc.coordinator_fee_ids).to match_array [coordinator_fee1.id, coordinator_fee2.id]
|
|
|
|
# And my supplier fees should have been configured
|
|
expect(oc.exchanges.incoming.last.enterprise_fee_ids).to eq([supplier_fee2.id])
|
|
|
|
# And my distributor fees should have been configured
|
|
expect(oc.exchanges.outgoing.last.enterprise_fee_ids).to eq([distributor_fee2.id])
|
|
|
|
# And my tags should have been save
|
|
expect(oc.exchanges.outgoing.last.tag_list).to eq(['wholesale'])
|
|
|
|
# And it should have some variants selected
|
|
selected_initial_variants = initial_variants.take initial_variants.size - 1
|
|
expect(oc.variants.map(&:id)).to match_array((selected_initial_variants.map(&:id) + [v1.id, v2.id]))
|
|
|
|
# And the collection details should have been updated
|
|
expect(oc.exchanges.where(pickup_time: 'New time 0', pickup_instructions: 'New instructions 0')).to be_present
|
|
expect(oc.exchanges.where(pickup_time: 'New time 1', pickup_instructions: 'New instructions 1')).to be_present
|
|
end
|
|
end
|
|
|
|
scenario "editing an order cycle" do
|
|
# Given an order cycle with all the settings
|
|
oc = create(:order_cycle)
|
|
oc.suppliers.first.update_attribute :name, 'AAA'
|
|
oc.suppliers.last.update_attribute :name, 'ZZZ'
|
|
oc.distributors.first.update_attribute :name, 'AAAA'
|
|
oc.distributors.last.update_attribute :name, 'ZZZZ'
|
|
|
|
# When I edit it
|
|
quick_login_as_admin
|
|
visit edit_admin_order_cycle_path(oc)
|
|
|
|
wait_for_edit_form_to_load_order_cycle(oc)
|
|
|
|
# Then I should see the basic settings
|
|
expect(page.find('#order_cycle_name').value).to eq(oc.name)
|
|
expect(page.find('#order_cycle_orders_open_at').value).to eq(oc.orders_open_at.to_s)
|
|
expect(page.find('#order_cycle_orders_close_at').value).to eq(oc.orders_close_at.to_s)
|
|
expect(page).to have_content "COORDINATOR #{oc.coordinator.name}"
|
|
|
|
click_button 'Next'
|
|
|
|
# And I should see the suppliers
|
|
expect(page).to have_selector 'td.supplier_name', text: oc.suppliers.first.name
|
|
expect(page).to have_selector 'td.supplier_name', text: oc.suppliers.last.name
|
|
|
|
expect(page).to have_field 'order_cycle_incoming_exchange_0_receival_instructions', with: 'instructions 0'
|
|
expect(page).to have_field 'order_cycle_incoming_exchange_1_receival_instructions', with: 'instructions 1'
|
|
|
|
# And the suppliers should have products
|
|
page.all('table.exchanges tbody tr.supplier').each_with_index do |row, i|
|
|
row.find('td.products').click
|
|
|
|
products_panel = page.all('table.exchanges tr.panel-row .exchange-supplied-products').select(&:visible?).first
|
|
expect(products_panel).to have_selector "input[name='order_cycle_incoming_exchange_#{i}_select_all_variants']"
|
|
|
|
row.find('td.products').click
|
|
end
|
|
|
|
# And the suppliers should have fees
|
|
supplier = oc.suppliers.min_by(&:name)
|
|
expect(page).to have_select 'order_cycle_incoming_exchange_0_enterprise_fees_0_enterprise_id', selected: supplier.name
|
|
expect(page).to have_select 'order_cycle_incoming_exchange_0_enterprise_fees_0_enterprise_fee_id', selected: supplier.enterprise_fees.first.name
|
|
|
|
supplier = oc.suppliers.max_by(&:name)
|
|
expect(page).to have_select 'order_cycle_incoming_exchange_1_enterprise_fees_0_enterprise_id', selected: supplier.name
|
|
expect(page).to have_select 'order_cycle_incoming_exchange_1_enterprise_fees_0_enterprise_fee_id', selected: supplier.enterprise_fees.first.name
|
|
|
|
click_button 'Next'
|
|
|
|
# And I should see the distributors
|
|
expect(page).to have_selector 'td.distributor_name', text: oc.distributors.first.name
|
|
expect(page).to have_selector 'td.distributor_name', text: oc.distributors.last.name
|
|
|
|
expect(page).to have_field 'order_cycle_outgoing_exchange_0_pickup_time', with: 'time 0'
|
|
expect(page).to have_field 'order_cycle_outgoing_exchange_0_pickup_instructions', with: 'instructions 0'
|
|
expect(page).to have_field 'order_cycle_outgoing_exchange_1_pickup_time', with: 'time 1'
|
|
expect(page).to have_field 'order_cycle_outgoing_exchange_1_pickup_instructions', with: 'instructions 1'
|
|
|
|
# And the distributors should have products
|
|
page.all('table.exchanges tbody tr.distributor').each_with_index do |row, i|
|
|
row.find('td.products').click
|
|
|
|
products_panel = page.all('table.exchanges tr.panel-row .exchange-distributed-products').select(&:visible?).first
|
|
expect(products_panel).to have_selector "input[name='order_cycle_outgoing_exchange_#{i}_select_all_variants']"
|
|
|
|
row.find('td.products').click
|
|
end
|
|
|
|
# And the distributors should have fees
|
|
distributor = oc.distributors.min_by(&:id)
|
|
expect(page).to have_select 'order_cycle_outgoing_exchange_0_enterprise_fees_0_enterprise_id', selected: distributor.name
|
|
expect(page).to have_select 'order_cycle_outgoing_exchange_0_enterprise_fees_0_enterprise_fee_id', selected: distributor.enterprise_fees.first.name
|
|
|
|
distributor = oc.distributors.max_by(&:id)
|
|
expect(page).to have_select 'order_cycle_outgoing_exchange_1_enterprise_fees_0_enterprise_id', selected: distributor.name
|
|
expect(page).to have_select 'order_cycle_outgoing_exchange_1_enterprise_fees_0_enterprise_fee_id', selected: distributor.enterprise_fees.first.name
|
|
end
|
|
|
|
scenario "editing an order cycle with an exchange between the same enterprise" do
|
|
c = create(:distributor_enterprise, is_primary_producer: true)
|
|
|
|
# Given two order cycles, one with a mono-enterprise incoming exchange...
|
|
oc_incoming = create(:simple_order_cycle, suppliers: [c], coordinator: c)
|
|
|
|
# And the other with a mono-enterprise outgoing exchange
|
|
oc_outgoing = create(:simple_order_cycle, coordinator: c, distributors: [c])
|
|
|
|
# When I edit the first order cycle, the exchange should appear as incoming
|
|
quick_login_as_admin
|
|
visit admin_order_cycle_incoming_path(oc_incoming)
|
|
expect(page).to have_selector 'table.exchanges tr.supplier'
|
|
visit admin_order_cycle_outgoing_path(oc_incoming)
|
|
expect(page).not_to have_selector 'table.exchanges tr.distributor'
|
|
|
|
# And when I edit the second order cycle, the exchange should appear as outgoing
|
|
visit admin_order_cycle_outgoing_path(oc_outgoing)
|
|
expect(page).to have_selector 'table.exchanges tr.distributor'
|
|
visit admin_order_cycle_incoming_path(oc_outgoing)
|
|
expect(page).not_to have_selector 'table.exchanges tr.supplier'
|
|
end
|
|
|
|
describe "editing an order cycle with multiple pages of products", js: true do
|
|
let(:order_cycle) { create(:order_cycle) }
|
|
let(:supplier_enterprise) { order_cycle.exchanges.incoming.first.sender }
|
|
let!(:new_product) { create(:product, supplier: supplier_enterprise) }
|
|
|
|
before do
|
|
stub_const("Api::ExchangeProductsController::DEFAULT_PER_PAGE", 1)
|
|
|
|
quick_login_as_admin
|
|
visit admin_order_cycle_incoming_path(order_cycle)
|
|
expect(page).to have_content "1 / 2 selected"
|
|
|
|
page.find("tr.supplier-#{supplier_enterprise.id} td.products").click
|
|
expect(page).to have_selector ".exchange-product-details"
|
|
|
|
expect(page).to have_content "1 of 2 Products Loaded"
|
|
expect(page).to_not have_content new_product.name
|
|
end
|
|
|
|
scenario "load all products" do
|
|
page.find(".exchange-load-all-variants a").click
|
|
|
|
expect_all_products_loaded
|
|
end
|
|
|
|
scenario "select all products" do
|
|
check "order_cycle_incoming_exchange_0_select_all_variants"
|
|
|
|
expect_all_products_loaded
|
|
|
|
expect(page).to have_checked_field "order_cycle_incoming_exchange_0_variants_#{new_product.variants.first.id}", disabled: false
|
|
end
|
|
|
|
def expect_all_products_loaded
|
|
expect(page).to have_content new_product.name.upcase
|
|
expect(page).to have_content "2 of 2 Products Loaded"
|
|
end
|
|
end
|
|
|
|
scenario "updating many order cycle opening/closing times at once", js: true do
|
|
# Given three order cycles
|
|
oc1 = create(:simple_order_cycle)
|
|
oc2 = create(:simple_order_cycle)
|
|
oc3 = create(:simple_order_cycle,
|
|
orders_open_at: Time.zone.local(2040, 12, 12, 12, 12, 12),
|
|
orders_close_at: Time.zone.local(2041, 12, 12, 12, 12, 12))
|
|
|
|
# When I go to the order cycles page
|
|
quick_login_as_admin
|
|
visit admin_order_cycles_path
|
|
|
|
# And I fill in some new opening/closing times and save them
|
|
within("tr.order-cycle-#{oc1.id}") do
|
|
find("input#oc#{oc1.id}_name").set "Updated Order Cycle 1"
|
|
find("input#oc#{oc1.id}_orders_open_at").set "2040-12-01 12:00:00"
|
|
find("input#oc#{oc1.id}_orders_close_at").set "2040-12-01 12:00:01"
|
|
end
|
|
|
|
within("tr.order-cycle-#{oc2.id}") do
|
|
find("input#oc#{oc2.id}_name").set "Updated Order Cycle 2"
|
|
find("input#oc#{oc2.id}_orders_open_at").set "2040-12-01 12:00:02"
|
|
find("input#oc#{oc2.id}_orders_close_at").set "2040-12-01 12:00:03"
|
|
end
|
|
|
|
# And I fill in a time using the datepicker
|
|
within("tr.order-cycle-#{oc3.id}") do
|
|
# When I trigger the datepicker
|
|
find('img.ui-datepicker-trigger', match: :first).click
|
|
end
|
|
|
|
within("#ui-datepicker-div") do
|
|
# Then it should display the correct date/time
|
|
expect(page).to have_selector 'span.ui-datepicker-month', text: 'DECEMBER'
|
|
expect(page).to have_selector 'span.ui-datepicker-year', text: '2040'
|
|
expect(page).to have_selector 'a.ui-state-active', text: '12'
|
|
|
|
# When I fill in a new date/time
|
|
click_link '1'
|
|
click_button 'Done'
|
|
end
|
|
|
|
within("tr.order-cycle-#{oc3.id}") do
|
|
# Then that date/time should appear on the form
|
|
expect(find("input#oc#{oc3.id}_orders_open_at").value).to eq "2040-12-01 00:00"
|
|
|
|
# Manually fill out time
|
|
find("input#oc#{oc3.id}_name").set "Updated Order Cycle 3"
|
|
find("input#oc#{oc3.id}_orders_open_at").set "2040-12-01 12:00:04"
|
|
find("input#oc#{oc3.id}_orders_close_at").set "2040-12-01 12:00:05"
|
|
end
|
|
|
|
click_button 'Save Changes'
|
|
|
|
# Then my details should have been saved
|
|
expect(page).to have_selector "#save-bar", text: "Order cycles have been updated."
|
|
order_cycles = OrderCycle.order("id ASC")
|
|
expect(order_cycles.map(&:name)).to eq ["Updated Order Cycle 1", "Updated Order Cycle 2", "Updated Order Cycle 3"]
|
|
expect(order_cycles.map { |oc| oc.orders_open_at.sec }).to eq [0, 2, 4]
|
|
expect(order_cycles.map { |oc| oc.orders_close_at.sec }).to eq [1, 3, 5]
|
|
end
|
|
|
|
scenario "cloning an order cycle" do
|
|
# Given an order cycle
|
|
oc = create(:simple_order_cycle)
|
|
|
|
# When I clone it
|
|
quick_login_as_admin
|
|
visit admin_order_cycles_path
|
|
within "tr.order-cycle-#{oc.id}" do
|
|
find('a.clone-order-cycle').click
|
|
end
|
|
expect(flash_message).to eq "Your order cycle #{oc.name} has been cloned."
|
|
|
|
# Then I should have clone of the order cycle
|
|
occ = OrderCycle.last
|
|
expect(occ.name).to eq "COPY OF #{oc.name}"
|
|
end
|
|
|
|
describe "ensuring that hubs in order cycles have valid shipping and payment methods" do
|
|
context "when they don't" do
|
|
let(:hub) { create(:distributor_enterprise) }
|
|
let!(:oc) { create(:simple_order_cycle, distributors: [hub]) }
|
|
|
|
it "displays a warning on the dashboard" do
|
|
login_to_admin_section
|
|
expect(page).to have_content "The hub #{hub.name} is listed in an active order cycle, but does not have valid shipping and payment methods. Until you set these up, customers will not be able to shop at this hub."
|
|
end
|
|
|
|
it "displays a warning on the order cycles screen" do
|
|
quick_login_as_admin
|
|
visit admin_order_cycles_path
|
|
expect(page).to have_content "The hub #{hub.name} is listed in an active order cycle, but does not have valid shipping and payment methods. Until you set these up, customers will not be able to shop at this hub."
|
|
end
|
|
end
|
|
|
|
context "when they do" do
|
|
let(:hub) { create(:distributor_enterprise, with_payment_and_shipping: true) }
|
|
let!(:oc) { create(:simple_order_cycle, distributors: [hub]) }
|
|
|
|
it "does not display the warning on the dashboard" do
|
|
login_to_admin_section
|
|
expect(page).not_to have_content "does not have valid shipping and payment methods"
|
|
end
|
|
end
|
|
end
|
|
|
|
context "as an enterprise user" do
|
|
let!(:supplier_managed) { create(:supplier_enterprise, name: 'Managed supplier') }
|
|
let!(:supplier_unmanaged) { create(:supplier_enterprise, name: 'Unmanaged supplier') }
|
|
let!(:supplier_permitted) { create(:supplier_enterprise, name: 'Permitted supplier') }
|
|
let!(:distributor_managed) { create(:distributor_enterprise, name: 'Managed distributor') }
|
|
let!(:other_distributor_managed) { create(:distributor_enterprise, name: 'Other Managed distributor') }
|
|
let!(:distributor_unmanaged) { create(:distributor_enterprise, name: 'Unmanaged Distributor') }
|
|
let!(:distributor_permitted) { create(:distributor_enterprise, name: 'Permitted distributor') }
|
|
let!(:distributor_managed_fee) { create(:enterprise_fee, enterprise: distributor_managed, name: 'Managed distributor fee') }
|
|
let!(:shipping_method) { create(:shipping_method, distributors: [distributor_managed, distributor_unmanaged, distributor_permitted]) }
|
|
let!(:payment_method) { create(:payment_method, distributors: [distributor_managed, distributor_unmanaged, distributor_permitted]) }
|
|
let!(:product_managed) { create(:product, supplier: supplier_managed) }
|
|
let!(:variant_managed) { product_managed.variants.first }
|
|
let!(:product_permitted) { create(:product, supplier: supplier_permitted) }
|
|
let!(:variant_permitted) { product_permitted.variants.first }
|
|
let!(:schedule) { create(:schedule, name: 'Schedule1', order_cycles: [create(:simple_order_cycle, coordinator: distributor_managed)]) }
|
|
let!(:schedule_of_other_managed_distributor) { create(:schedule, name: 'Other Schedule', order_cycles: [create(:simple_order_cycle, coordinator: other_distributor_managed)]) }
|
|
|
|
before do
|
|
# Relationships required for interface to work
|
|
# Both suppliers allow both managed distributor to distribute their products (and add them to the order cycle)
|
|
create(:enterprise_relationship, parent: supplier_managed, child: distributor_managed, permissions_list: [:add_to_order_cycle])
|
|
create(:enterprise_relationship, parent: supplier_permitted, child: distributor_managed, permissions_list: [:add_to_order_cycle])
|
|
|
|
# Both suppliers allow permitted distributor to distribute their products
|
|
create(:enterprise_relationship, parent: supplier_managed, child: distributor_permitted, permissions_list: [:add_to_order_cycle])
|
|
create(:enterprise_relationship, parent: supplier_permitted, child: distributor_permitted, permissions_list: [:add_to_order_cycle])
|
|
|
|
# Permitted distributor can be added to the order cycle
|
|
create(:enterprise_relationship, parent: distributor_permitted, child: distributor_managed, permissions_list: [:add_to_order_cycle])
|
|
end
|
|
|
|
context "that is a manager of the coordinator" do
|
|
before do
|
|
@new_user = create_enterprise_user
|
|
@new_user.enterprise_roles.build(enterprise: supplier_managed).save
|
|
@new_user.enterprise_roles.build(enterprise: distributor_managed).save
|
|
@new_user.enterprise_roles.build(enterprise: other_distributor_managed).save
|
|
|
|
quick_login_as @new_user
|
|
end
|
|
|
|
scenario "viewing a list of order cycles I am coordinating" do
|
|
oc_user_coordinating = create(:simple_order_cycle, suppliers: [supplier_managed, supplier_unmanaged], coordinator: distributor_managed, distributors: [distributor_managed, distributor_unmanaged], name: 'Order Cycle 1' )
|
|
oc_for_other_user = create(:simple_order_cycle, coordinator: supplier_unmanaged, name: 'Order Cycle 2' )
|
|
|
|
visit spree.admin_dashboard_path
|
|
click_link "Order Cycles"
|
|
|
|
# I should see only the order cycle I am coordinating
|
|
expect(page).to have_selector "tr.order-cycle-#{oc_user_coordinating.id}"
|
|
expect(page).to_not have_selector "tr.order-cycle-#{oc_for_other_user.id}"
|
|
|
|
toggle_columns "Producers", "Shops"
|
|
|
|
# The order cycle should show all enterprises in the order cycle
|
|
expect(page).to have_selector 'td.producers', text: supplier_managed.name
|
|
expect(page).to have_selector 'td.shops', text: distributor_managed.name
|
|
expect(page).to have_selector 'td.producers', text: supplier_unmanaged.name
|
|
expect(page).to have_selector 'td.shops', text: distributor_unmanaged.name
|
|
end
|
|
|
|
scenario "creating a new order cycle" do
|
|
distributor_managed.update_attribute(:enable_subscriptions, true)
|
|
visit admin_order_cycles_path
|
|
click_link 'New Order Cycle'
|
|
|
|
[distributor_unmanaged.name, supplier_managed.name, supplier_unmanaged.name].each do |enterprise_name|
|
|
expect(page).not_to have_select 'coordinator_id', with_options: [enterprise_name]
|
|
end
|
|
select2_select 'Managed distributor', from: 'coordinator_id'
|
|
click_button "Continue >"
|
|
|
|
fill_in 'order_cycle_name', with: 'My order cycle'
|
|
fill_in 'order_cycle_orders_open_at', with: '2040-11-06 06:00:00'
|
|
fill_in 'order_cycle_orders_close_at', with: '2040-11-13 17:00:00'
|
|
expect(page).not_to have_select2 'schedule_ids', with_options: [schedule_of_other_managed_distributor.name]
|
|
multi_select2_select schedule.name, from: 'schedule_ids'
|
|
|
|
click_button 'Add coordinator fee'
|
|
select 'Managed distributor fee', from: 'order_cycle_coordinator_fee_0_id'
|
|
|
|
click_button 'Create'
|
|
|
|
expect(page).to have_select 'new_supplier_id'
|
|
expect(page).not_to have_select 'new_supplier_id', with_options: [supplier_unmanaged.name]
|
|
select 'Managed supplier', from: 'new_supplier_id'
|
|
click_button 'Add supplier'
|
|
select 'Permitted supplier', from: 'new_supplier_id'
|
|
click_button 'Add supplier'
|
|
|
|
select_incoming_variant supplier_managed, 0, variant_managed
|
|
select_incoming_variant supplier_permitted, 1, variant_permitted
|
|
|
|
click_button 'Save and Next'
|
|
|
|
expect(page).to have_select 'new_distributor_id'
|
|
expect(page).not_to have_select 'new_distributor_id', with_options: [distributor_unmanaged.name]
|
|
select 'Managed distributor', from: 'new_distributor_id'
|
|
click_button 'Add distributor'
|
|
select 'Permitted distributor', from: 'new_distributor_id'
|
|
click_button 'Add distributor'
|
|
|
|
fill_in 'order_cycle_outgoing_exchange_0_pickup_time', with: 'pickup time'
|
|
fill_in 'order_cycle_outgoing_exchange_0_pickup_instructions', with: 'pickup instructions'
|
|
fill_in 'order_cycle_outgoing_exchange_1_pickup_time', with: 'pickup time 2'
|
|
fill_in 'order_cycle_outgoing_exchange_1_pickup_instructions', with: 'pickup instructions'
|
|
|
|
page.find("table.exchanges tr.distributor-#{distributor_managed.id} td.tags").click
|
|
within ".exchange-tags" do
|
|
find(:css, "tags-input .tags input").set "wholesale\n"
|
|
end
|
|
|
|
click_button 'Save and Back to List'
|
|
order_cycle = OrderCycle.find_by_name('My order cycle')
|
|
expect(page).to have_input "oc#{order_cycle.id}[name]", value: order_cycle.name
|
|
|
|
expect(order_cycle.suppliers).to match_array [supplier_managed, supplier_permitted]
|
|
expect(order_cycle.coordinator).to eq(distributor_managed)
|
|
expect(order_cycle.distributors).to match_array [distributor_managed, distributor_permitted]
|
|
expect(order_cycle.schedules).to eq([schedule])
|
|
exchange = order_cycle.exchanges.outgoing.to_enterprise(distributor_managed).first
|
|
expect(exchange.tag_list).to eq(["wholesale"])
|
|
end
|
|
|
|
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_subscriptions, true)
|
|
|
|
visit edit_admin_order_cycle_path(oc)
|
|
|
|
expect(page).to have_field 'order_cycle_name', with: oc.name
|
|
multi_select2_select schedule.name, from: 'schedule_ids'
|
|
expect(page).not_to have_select2 'schedule_ids', with_options: [schedule_of_other_managed_distributor.name]
|
|
|
|
click_button 'Save and Next'
|
|
|
|
# When I remove all incoming exchanges
|
|
page.find("tr.supplier-#{supplier_managed.id} a.remove-exchange").click
|
|
page.find("tr.supplier-#{supplier_permitted.id} a.remove-exchange").click
|
|
click_button 'Save and Next'
|
|
|
|
# And I remove all outgoing exchanges
|
|
page.find("tr.distributor-#{distributor_managed.id} a.remove-exchange").click
|
|
page.find("tr.distributor-#{distributor_permitted.id} a.remove-exchange").click
|
|
click_button 'Save and Back to List'
|
|
expect(page).to have_input "oc#{oc.id}[name]", value: oc.name
|
|
|
|
oc.reload
|
|
expect(oc.suppliers).to eq([supplier_unmanaged])
|
|
expect(oc.coordinator).to eq(distributor_managed)
|
|
expect(oc.distributors).to eq([distributor_unmanaged])
|
|
expect(oc.schedules).to eq([schedule])
|
|
end
|
|
|
|
scenario "cloning an order cycle" do
|
|
oc = create(:simple_order_cycle, coordinator: distributor_managed)
|
|
|
|
visit admin_order_cycles_path
|
|
within "tr.order-cycle-#{oc.id}" do
|
|
find('a.clone-order-cycle').click
|
|
end
|
|
expect(flash_message).to eq "Your order cycle #{oc.name} has been cloned."
|
|
|
|
# Then I should have clone of the order cycle
|
|
occ = OrderCycle.last
|
|
expect(occ.name).to eq("COPY OF #{oc.name}")
|
|
end
|
|
end
|
|
|
|
context "that is a manager of a participating producer" do
|
|
let(:new_user) { create_enterprise_user }
|
|
|
|
before do
|
|
new_user.enterprise_roles.build(enterprise: supplier_managed).save
|
|
login_to_admin_as new_user
|
|
end
|
|
|
|
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' )
|
|
v1 = create(:variant, product: create(:product, supplier: supplier_managed) )
|
|
v2 = create(:variant, product: create(:product, supplier: supplier_managed) )
|
|
|
|
# Incoming exchange
|
|
ex_in = oc.exchanges.where(sender_id: supplier_managed, receiver_id: distributor_managed, incoming: true).first
|
|
ex_in.update_attributes(variant_ids: [v1.id, v2.id])
|
|
|
|
# Outgoing exchange
|
|
ex_out = oc.exchanges.where(sender_id: distributor_managed, receiver_id: distributor_managed, incoming: false).first
|
|
ex_out.update_attributes(variant_ids: [v1.id, v2.id])
|
|
|
|
# Stub editable_variants_for_outgoing_exchanges method so we can test permissions
|
|
serializer = Api::Admin::OrderCycleSerializer.new(oc, current_user: new_user)
|
|
allow(Api::Admin::OrderCycleSerializer).to receive(:new) { serializer }
|
|
allow(serializer).to receive(:editable_variants_for_outgoing_exchanges) do
|
|
{ distributor_managed.id.to_s => [v1.id] }
|
|
end
|
|
|
|
# I should only see exchanges for supplier_managed AND
|
|
# distributor_managed and distributor_permitted (who I have given permission to) AND
|
|
# and distributor_unmanaged (who distributes my products)
|
|
visit admin_order_cycle_incoming_path(oc)
|
|
expect(page).to have_selector "tr.supplier-#{supplier_managed.id}"
|
|
expect(page).to have_selector 'tr.supplier', count: 1
|
|
|
|
visit admin_order_cycle_outgoing_path(oc)
|
|
expect(page).to have_selector "tr.distributor-#{distributor_managed.id}"
|
|
expect(page).to have_selector "tr.distributor-#{distributor_permitted.id}"
|
|
expect(page).to have_selector 'tr.distributor', count: 2
|
|
|
|
# Open the products list for managed_supplier's incoming exchange
|
|
within "tr.distributor-#{distributor_managed.id}" do
|
|
page.find("td.products").click
|
|
end
|
|
|
|
# I should be able to see and toggle v1
|
|
expect(page).to have_checked_field "order_cycle_outgoing_exchange_0_variants_#{v1.id}", disabled: false
|
|
uncheck "order_cycle_outgoing_exchange_0_variants_#{v1.id}"
|
|
|
|
# I should be able to see but not toggle v2, because I don't have permission
|
|
expect(page).to have_checked_field "order_cycle_outgoing_exchange_0_variants_#{v2.id}", disabled: true
|
|
|
|
expect(page).not_to have_selector "table.exchanges tr.distributor-#{distributor_managed.id} td.tags"
|
|
|
|
# When I save, any exchanges that I can't manage remain
|
|
click_button 'Save'
|
|
expect(page).to have_content "Your order cycle has been updated."
|
|
|
|
oc.reload
|
|
expect(oc.suppliers).to match_array [supplier_managed, supplier_permitted, supplier_unmanaged]
|
|
expect(oc.coordinator).to eq(distributor_managed)
|
|
expect(oc.distributors).to match_array [distributor_managed, distributor_permitted, distributor_unmanaged]
|
|
end
|
|
end
|
|
|
|
context "that is the manager of a participating hub" do
|
|
let(:my_distributor) { create(:distributor_enterprise) }
|
|
let(:new_user) { create_enterprise_user }
|
|
|
|
before do
|
|
create(:enterprise_relationship, parent: supplier_managed, child: my_distributor, permissions_list: [:add_to_order_cycle])
|
|
|
|
new_user.enterprise_roles.build(enterprise: my_distributor).save
|
|
login_to_admin_as new_user
|
|
end
|
|
|
|
scenario "editing an order cycle" do
|
|
oc = create(:simple_order_cycle, suppliers: [supplier_managed, supplier_permitted, supplier_unmanaged], coordinator: distributor_managed, distributors: [my_distributor, distributor_managed, distributor_permitted, distributor_unmanaged], name: 'Order Cycle 1' )
|
|
v1 = create(:variant, product: create(:product, supplier: supplier_managed) )
|
|
v2 = create(:variant, product: create(:product, supplier: supplier_managed) )
|
|
|
|
# Incoming exchange
|
|
ex_in = oc.exchanges.where(sender_id: supplier_managed, receiver_id: distributor_managed, incoming: true).first
|
|
ex_in.update_attributes(variant_ids: [v1.id, v2.id])
|
|
|
|
# Outgoing exchange
|
|
ex_out = oc.exchanges.where(sender_id: distributor_managed, receiver_id: my_distributor, incoming: false).first
|
|
ex_out.update_attributes(variant_ids: [v1.id, v2.id])
|
|
|
|
# Stub editable_variants_for_incoming_exchanges method so we can test permissions
|
|
serializer = Api::Admin::OrderCycleSerializer.new(oc, current_user: new_user)
|
|
allow(Api::Admin::OrderCycleSerializer).to receive(:new) { serializer }
|
|
allow(serializer).to receive(:editable_variants_for_incoming_exchanges) do
|
|
{ supplier_managed.id.to_s => [v1.id] }
|
|
end
|
|
|
|
# I should see exchanges for my_distributor, and the incoming exchanges supplying the variants in it
|
|
visit admin_order_cycle_outgoing_path(oc)
|
|
expect(page).to have_selector "tr.distributor-#{my_distributor.id}"
|
|
expect(page).to have_selector 'tr.distributor', count: 1
|
|
|
|
visit admin_order_cycle_incoming_path(oc)
|
|
expect(page).to have_selector "tr.supplier-#{supplier_managed.id}"
|
|
expect(page).to have_selector 'tr.supplier', count: 1
|
|
|
|
# Open the products list for managed_supplier's incoming exchange
|
|
within "tr.supplier-#{supplier_managed.id}" do
|
|
page.find("td.products").click
|
|
end
|
|
|
|
# I should be able to see and toggle v1
|
|
expect(page).to have_checked_field "order_cycle_incoming_exchange_0_variants_#{v1.id}", disabled: false
|
|
uncheck "order_cycle_incoming_exchange_0_variants_#{v1.id}"
|
|
|
|
# I should be able to see but not toggle v2, because I don't have permission
|
|
expect(page).to have_checked_field "order_cycle_incoming_exchange_0_variants_#{v2.id}", disabled: true
|
|
|
|
# When I save, any exchange that I can't manage remains
|
|
click_button 'Save and Next'
|
|
expect(page).to have_content "Your order cycle has been updated."
|
|
|
|
expect(page).to have_selector "table.exchanges tr.distributor-#{my_distributor.id} td.tags"
|
|
|
|
oc.reload
|
|
expect(oc.suppliers).to match_array [supplier_managed, supplier_permitted, supplier_unmanaged]
|
|
expect(oc.coordinator).to eq(distributor_managed)
|
|
expect(oc.distributors).to match_array [my_distributor, distributor_managed, distributor_permitted, distributor_unmanaged]
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "simplified interface for enterprise users selling only their own produce" do
|
|
let(:user) { create_enterprise_user }
|
|
let(:enterprise) { create(:enterprise, is_primary_producer: true, sells: 'own') }
|
|
let!(:p1) { create(:simple_product, supplier: enterprise) }
|
|
let!(:p2) { create(:simple_product, supplier: enterprise) }
|
|
let!(:p3) { create(:simple_product, supplier: enterprise) }
|
|
let!(:v1) { p1.variants.first }
|
|
let!(:v2) { p2.variants.first }
|
|
let!(:v3) { p3.variants.first }
|
|
let!(:fee) { create(:enterprise_fee, enterprise: enterprise, name: 'Coord fee') }
|
|
|
|
before do
|
|
user.enterprise_roles.create! enterprise: enterprise
|
|
login_to_admin_as user
|
|
end
|
|
|
|
it "shows me an index of order cycles without enterprise columns" do
|
|
create(:simple_order_cycle, coordinator: enterprise)
|
|
visit admin_order_cycles_path
|
|
expect(page).not_to have_selector 'th', text: 'SUPPLIERS'
|
|
expect(page).not_to have_selector 'th', text: 'COORDINATOR'
|
|
expect(page).not_to have_selector 'th', text: 'DISTRIBUTORS'
|
|
end
|
|
|
|
it "creates order cycles", js: true do
|
|
# When I go to the new order cycle page
|
|
visit admin_order_cycles_path
|
|
click_link 'New Order Cycle'
|
|
|
|
# I cannot save without the required fields
|
|
expect(page).to have_button('Create', disabled: true)
|
|
|
|
# The Create button is enabled once the mandatory fields are entered
|
|
fill_in 'order_cycle_name', with: 'Plums & Avos'
|
|
fill_in 'order_cycle_outgoing_exchange_0_pickup_time', with: 'pickup time'
|
|
expect(page).to have_button('Create', disabled: false)
|
|
|
|
# If I fill in the basic fields
|
|
fill_in 'order_cycle_orders_open_at', with: '2040-10-17 06:00:00'
|
|
fill_in 'order_cycle_orders_close_at', with: '2040-10-24 17:00:00'
|
|
fill_in 'order_cycle_outgoing_exchange_0_pickup_instructions', with: 'pickup instructions'
|
|
|
|
# Then my products / variants should already be selected
|
|
expect(page).to have_checked_field "order_cycle_incoming_exchange_0_variants_#{v1.id}"
|
|
expect(page).to have_checked_field "order_cycle_incoming_exchange_0_variants_#{v2.id}"
|
|
expect(page).to have_checked_field "order_cycle_incoming_exchange_0_variants_#{v3.id}"
|
|
|
|
# When I unselect a product
|
|
uncheck "order_cycle_incoming_exchange_0_variants_#{v2.id}"
|
|
|
|
# And I add a fee and save
|
|
click_button 'Add coordinator fee'
|
|
click_button 'Add coordinator fee'
|
|
click_link 'order_cycle_coordinator_fee_1_remove'
|
|
expect(page).to have_select 'order_cycle_coordinator_fee_0_id'
|
|
expect(page).not_to have_select 'order_cycle_coordinator_fee_1_id'
|
|
|
|
select 'Coord fee', from: 'order_cycle_coordinator_fee_0_id'
|
|
click_button 'Create'
|
|
|
|
# Then my order cycle should have been created
|
|
expect(page).to have_content 'Your order cycle has been created.'
|
|
|
|
oc = OrderCycle.last
|
|
|
|
expect(page).to have_input "oc#{oc.id}[name]", value: "Plums & Avos"
|
|
expect(page).to have_input "oc#{oc.id}[orders_open_at]", value: Time.zone.local(2040, 10, 17, 0o6, 0o0, 0o0).strftime("%F %T %z")
|
|
expect(page).to have_input "oc#{oc.id}[orders_close_at]", value: Time.zone.local(2040, 10, 24, 17, 0o0, 0o0).strftime("%F %T %z")
|
|
|
|
# And it should have some variants selected
|
|
expect(oc.exchanges.incoming.first.variants.count).to eq(2)
|
|
expect(oc.exchanges.outgoing.first.variants.count).to eq(2)
|
|
|
|
# And it should have the fee
|
|
expect(oc.coordinator_fees).to eq([fee])
|
|
|
|
# And my pickup time and instructions should have been saved
|
|
ex = oc.exchanges.outgoing.first
|
|
expect(ex.pickup_time).to eq('pickup time')
|
|
expect(ex.pickup_instructions).to eq('pickup instructions')
|
|
end
|
|
|
|
scenario "editing an order cycle" do
|
|
# Given an order cycle with pickup time and instructions
|
|
fee = create(:enterprise_fee, name: 'my fee', enterprise: enterprise)
|
|
oc = create(:simple_order_cycle, suppliers: [enterprise], coordinator: enterprise, distributors: [enterprise], variants: [v1], coordinator_fees: [fee])
|
|
ex = oc.exchanges.outgoing.first
|
|
ex.update_attributes! pickup_time: 'pickup time', pickup_instructions: 'pickup instructions'
|
|
|
|
# When I edit it
|
|
quick_login_as_admin
|
|
visit admin_order_cycles_path
|
|
within "tr.order-cycle-#{oc.id}" do
|
|
find("a.edit-order-cycle").click
|
|
end
|
|
|
|
wait_for_edit_form_to_load_order_cycle(oc)
|
|
|
|
# Then I should see the basic settings
|
|
expect(page).to have_field 'order_cycle_name', with: oc.name
|
|
expect(page).to have_field 'order_cycle_orders_open_at', with: oc.orders_open_at.to_s
|
|
expect(page).to have_field 'order_cycle_orders_close_at', with: oc.orders_close_at.to_s
|
|
expect(page).to have_field 'order_cycle_outgoing_exchange_0_pickup_time', with: 'pickup time'
|
|
expect(page).to have_field 'order_cycle_outgoing_exchange_0_pickup_instructions', with: 'pickup instructions'
|
|
|
|
# And I should see the products
|
|
expect(page).to have_checked_field "order_cycle_incoming_exchange_0_variants_#{v1.id}"
|
|
expect(page).to have_unchecked_field "order_cycle_incoming_exchange_0_variants_#{v2.id}"
|
|
expect(page).to have_unchecked_field "order_cycle_incoming_exchange_0_variants_#{v3.id}"
|
|
|
|
# And I should see the coordinator fees
|
|
expect(page).to have_select 'order_cycle_coordinator_fee_0_id', selected: 'my fee'
|
|
end
|
|
|
|
scenario "updating an order cycle" do
|
|
# Given an order cycle with pickup time and instructions
|
|
fee1 = create(:enterprise_fee, name: 'my fee', enterprise: enterprise)
|
|
fee2 = create(:enterprise_fee, name: 'that fee', enterprise: enterprise)
|
|
oc = create(:simple_order_cycle, suppliers: [enterprise], coordinator: enterprise, distributors: [enterprise], variants: [v1], coordinator_fees: [fee1])
|
|
ex = oc.exchanges.outgoing.first
|
|
ex.update_attributes! pickup_time: 'pickup time', pickup_instructions: 'pickup instructions'
|
|
|
|
# When I edit it
|
|
quick_login_as_admin
|
|
visit edit_admin_order_cycle_path oc
|
|
|
|
wait_for_edit_form_to_load_order_cycle(oc)
|
|
|
|
# And I fill in the basic fields
|
|
fill_in 'order_cycle_name', with: 'Plums & Avos'
|
|
fill_in 'order_cycle_orders_open_at', with: '2040-10-17 06:00:00'
|
|
fill_in 'order_cycle_orders_close_at', with: '2040-10-24 17:00:00'
|
|
fill_in 'order_cycle_outgoing_exchange_0_pickup_time', with: 'xy'
|
|
fill_in 'order_cycle_outgoing_exchange_0_pickup_instructions', with: 'zzy'
|
|
|
|
# And I make some product selections
|
|
uncheck "order_cycle_incoming_exchange_0_variants_#{v1.id}"
|
|
check "order_cycle_incoming_exchange_0_variants_#{v2.id}"
|
|
check "order_cycle_incoming_exchange_0_variants_#{v3.id}"
|
|
uncheck "order_cycle_incoming_exchange_0_variants_#{v3.id}"
|
|
|
|
# And I select some fees and update
|
|
click_link 'order_cycle_coordinator_fee_0_remove'
|
|
expect(page).not_to have_select 'order_cycle_coordinator_fee_0_id'
|
|
click_button 'Add coordinator fee'
|
|
select 'that fee', from: 'order_cycle_coordinator_fee_0_id'
|
|
|
|
# When I update, or update and close, both work
|
|
click_button 'Save'
|
|
expect(page).to have_content 'Your order cycle has been updated.'
|
|
|
|
fill_in 'order_cycle_outgoing_exchange_0_pickup_instructions', with: 'yyz'
|
|
click_button 'Save and Back to List'
|
|
|
|
# Then my order cycle should have been updated
|
|
expect(page).to have_content 'Your order cycle has been updated.'
|
|
oc = OrderCycle.last
|
|
|
|
expect(page).to have_input "oc#{oc.id}[name]", value: "Plums & Avos"
|
|
expect(page).to have_input "oc#{oc.id}[orders_open_at]", value: Time.zone.local(2040, 10, 17, 0o6, 0o0, 0o0).strftime("%F %T %z")
|
|
expect(page).to have_input "oc#{oc.id}[orders_close_at]", value: Time.zone.local(2040, 10, 24, 17, 0o0, 0o0).strftime("%F %T %z")
|
|
|
|
# And it should have a variant selected
|
|
expect(oc.exchanges.incoming.first.variants).to eq([v2])
|
|
expect(oc.exchanges.outgoing.first.variants).to eq([v2])
|
|
|
|
# And it should have the fee
|
|
expect(oc.coordinator_fees).to eq([fee2])
|
|
|
|
# And my pickup time and instructions should have been saved
|
|
ex = oc.exchanges.outgoing.first
|
|
expect(ex.pickup_time).to eq('xy')
|
|
expect(ex.pickup_instructions).to eq('yyz')
|
|
end
|
|
end
|
|
|
|
scenario "deleting an order cycle" do
|
|
order_cycle = create(:simple_order_cycle, name: "Translusent Berries")
|
|
quick_login_as_admin
|
|
visit admin_order_cycles_path
|
|
expect(page).to have_selector "tr.order-cycle-#{order_cycle.id}"
|
|
accept_alert do
|
|
first('a.delete-order-cycle').click
|
|
end
|
|
expect(page).to_not have_selector "tr.order-cycle-#{order_cycle.id}"
|
|
end
|
|
|
|
private
|
|
|
|
def wait_for_edit_form_to_load_order_cycle(order_cycle)
|
|
expect(page).to have_field "order_cycle_name", with: order_cycle.name
|
|
end
|
|
|
|
def select_incoming_variant(supplier, exchange_no, variant)
|
|
page.find("table.exchanges tr.supplier-#{supplier.id} td.products").click
|
|
check "order_cycle_incoming_exchange_#{exchange_no}_variants_#{variant.id}"
|
|
end
|
|
end
|