Order Cycles can be assigned to schedules via new/edit form

spec/controllers/admin/order_cycles_controller_spec.rb

@@ -98,59 +98,58 @@ module Admin
 
     describe "update" do
       let(:order_cycle) { create(:simple_order_cycle) }
+      let(:producer) { create(:supplier_enterprise) }
+      let(:coordinator) { order_cycle.coordinator }
+      let(:hub) { create(:distributor_enterprise) }
+      let(:v) { create(:variant) }
+      let!(:incoming_exchange) { create(:exchange, order_cycle: order_cycle, sender: producer, receiver: coordinator, incoming: true, variants: [v]) }
+      let!(:outgoing_exchange) { create(:exchange, order_cycle: order_cycle, sender: coordinator, receiver: hub, incoming: false, variants: [v]) }
 
-      before { login_as_admin }
+      context "as a manager of the coordinator" do
+        before { login_as_enterprise_user([coordinator]) }
 
-      it "sets flash message when page is reloading" do
-        spree_put :update, id: order_cycle.id, reloading: '1', order_cycle: {}
-        flash[:notice].should == 'Your order cycle has been updated.'
-      end
-
-      it "does not set flash message otherwise" do
-        flash[:notice].should be_nil
-      end
-
-      context "when updating without explicitly submitting exchanges" do
-        let(:form_applicator_mock) { double(:form_applicator) }
-        let(:incoming_exchange) { create(:exchange, order_cycle: order_cycle, incoming: true) }
-        let(:outgoing_exchange) { create(:exchange, order_cycle: order_cycle, incoming: false) }
-
-
-        before do
-          allow(OpenFoodNetwork::OrderCycleFormApplicator).to receive(:new) { form_applicator_mock }
-          allow(form_applicator_mock).to receive(:go!) { nil }
+        it "sets flash message when page is reloading" do
+          spree_put :update, id: order_cycle.id, reloading: '1', order_cycle: {}
+          flash[:notice].should == 'Your order cycle has been updated.'
         end
 
-         it "does not run the OrderCycleFormApplicator" do
-           expect(order_cycle.exchanges.incoming).to eq [incoming_exchange]
-           expect(order_cycle.exchanges.outgoing).to eq [outgoing_exchange]
-           expect(order_cycle.prefers_product_selection_from_coordinator_inventory_only?).to be false
-           spree_put :update, id: order_cycle.id, order_cycle: { name: 'Some new name', preferred_product_selection_from_coordinator_inventory_only: true }
-           expect(form_applicator_mock).to_not have_received(:go!)
-           order_cycle.reload
-           expect(order_cycle.exchanges.incoming).to eq [incoming_exchange]
-           expect(order_cycle.exchanges.outgoing).to eq [outgoing_exchange]
-           expect(order_cycle.name).to eq 'Some new name'
-           expect(order_cycle.prefers_product_selection_from_coordinator_inventory_only?).to be true
-         end
+        it "does not set flash message otherwise" do
+          flash[:notice].should be_nil
+        end
+
+        context "when updating without explicitly submitting exchanges" do
+          let(:form_applicator_mock) { double(:form_applicator) }
+
+          before do
+            allow(OpenFoodNetwork::OrderCycleFormApplicator).to receive(:new) { form_applicator_mock }
+            allow(form_applicator_mock).to receive(:go!) { nil }
+          end
+
+           it "does not run the OrderCycleFormApplicator" do
+             expect(order_cycle.exchanges.incoming).to eq [incoming_exchange]
+             expect(order_cycle.exchanges.outgoing).to eq [outgoing_exchange]
+             expect(order_cycle.prefers_product_selection_from_coordinator_inventory_only?).to be false
+             spree_put :update, id: order_cycle.id, order_cycle: { name: 'Some new name', preferred_product_selection_from_coordinator_inventory_only: true }
+             expect(form_applicator_mock).to_not have_received(:go!)
+             order_cycle.reload
+             expect(order_cycle.exchanges.incoming).to eq [incoming_exchange]
+             expect(order_cycle.exchanges.outgoing).to eq [outgoing_exchange]
+             expect(order_cycle.name).to eq 'Some new name'
+             expect(order_cycle.prefers_product_selection_from_coordinator_inventory_only?).to be true
+           end
+        end
       end
 
       context "as a producer supplying to an order cycle" do
-        let(:producer) { create(:supplier_enterprise) }
-        let(:coordinator) { order_cycle.coordinator }
-        let(:hub) { create(:distributor_enterprise) }
-
-        before { login_as_enterprise_user [producer] }
+        before do
+          login_as_enterprise_user [producer]
+        end
 
         describe "removing a variant from incoming" do
-          let(:v) { create(:variant) }
-          let!(:ex_i) { create(:exchange, order_cycle: order_cycle, sender: producer, receiver: coordinator, incoming: true, variants: [v]) }
-          let!(:ex_o) { create(:exchange, order_cycle: order_cycle, sender: coordinator, receiver: hub, incoming: false, variants: [v]) }
-
           let(:params) do
             {order_cycle: {
-               incoming_exchanges: [{id: ex_i.id, enterprise_id: producer.id, sender_id: producer.id, variants: {v.id => false}}],
-               outgoing_exchanges: [{id: ex_o.id, enterprise_id: hub.id,      receiver_id: hub.id,    variants: {v.id => false}}] }
+               incoming_exchanges: [{id: incoming_exchange.id, enterprise_id: producer.id, sender_id: producer.id, variants: {v.id => false}}],
+               outgoing_exchanges: [{id: outgoing_exchange.id, enterprise_id: hub.id,      receiver_id: hub.id,    variants: {v.id => false}}] }
             }
           end
 
@@ -162,6 +161,36 @@ module Admin
       end
     end
 
+    describe "updating schedules" do
+      let(:user) { create(:user, enterprise_limit: 10) }
+      let!(:managed_coordinator) { create(:enterprise, owner: user) }
+      let!(:managed_enterprise) { create(:enterprise, owner: user) }
+      let!(:coordinated_order_cycle) { create(:simple_order_cycle, coordinator: managed_coordinator ) }
+      let!(:coordinated_order_cycle2) { create(:simple_order_cycle, coordinator: managed_enterprise ) }
+      let!(:uncoordinated_order_cycle) { create(:simple_order_cycle, coordinator: create(:enterprise) ) }
+      let!(:coordinated_schedule) { create(:schedule, order_cycles: [coordinated_order_cycle] ) }
+      let!(:coordinated_schedule2) { create(:schedule, order_cycles: [coordinated_order_cycle2] ) }
+      let!(:uncoordinated_schedule) { create(:schedule, order_cycles: [uncoordinated_order_cycle] ) }
+
+      context "where I manage the order_cycle's coordinator" do
+        render_views
+
+        before do
+          controller.stub spree_current_user: user
+        end
+
+        it "allows me to assign only schedules that already I coordinate to the order cycle" do
+          schedule_ids = [coordinated_schedule2.id, uncoordinated_schedule.id ]
+          spree_put :update, format: :json, id: coordinated_order_cycle.id, order_cycle: { schedule_ids: schedule_ids }
+          expect(assigns(:order_cycle)).to eq coordinated_order_cycle
+          # coordinated_order_cycle2 is added
+          expect(coordinated_order_cycle.reload.schedules).to include coordinated_schedule2
+          # coordinated_order_cycle is removed, uncoordinated_order_cycle is NOT added
+          expect(coordinated_order_cycle.reload.schedules).to_not include coordinated_schedule, uncoordinated_schedule
+        end
+      end
+    end
+
     describe "bulk_update" do
       let(:oc) { create(:simple_order_cycle) }
       let!(:coordinator) { oc.coordinator }