bigbluebutton_rails 0.1.0 → 0.1.1

data/spec/controllers/bigbluebutton/rooms_controller_spec.rb

@@ -10,55 +10,48 @@ describe Bigbluebutton::RoomsController do
   let(:room) { Factory.create(:bigbluebutton_room, :server => server) }
 
   describe "#index" do
-    before(:each) { get :index, :server_id => server.to_param }
+    before(:each) { get :index }
     it { should respond_with(:success) }
-    it { should assign_to(:server).with(server) }
     it { should assign_to(:rooms).with(BigbluebuttonRoom.all) }
     it { should render_template(:index) }
   end
 
   describe "#show" do
-    before(:each) { get :show, :server_id => server.to_param, :id => room.to_param }
+    before(:each) { get :show, :id => room.to_param }
     it { should respond_with(:success) }
-    it { should assign_to(:server).with(server) }
     it { should assign_to(:room).with(room) }
     it { should render_template(:show) }
   end
 
   describe "#new" do
-    before(:each) { get :new, :server_id => server.to_param }
+    before(:each) { get :new }
     it { should respond_with(:success) }
-    it { should assign_to(:server).with(server) }
     it { should assign_to(:room).with_kind_of(BigbluebuttonRoom) }
     it { should render_template(:new) }
   end
 
   describe "#edit" do
-    before(:each) { get :edit, :server_id => server.to_param, :id => room.to_param }
+    before(:each) { get :edit, :id => room.to_param }
     it { should respond_with(:success) }
-    it { should assign_to(:server).with(server) }
     it { should assign_to(:room).with(room) }
     it { should render_template(:edit) }
   end
 
   describe "#join_mobile" do
     let(:user) { Factory.build(:user) }
-    let(:server) { Factory.create(:bigbluebutton_server) }
-    let(:room) { Factory.create(:bigbluebutton_room, :server => server) }
+    let(:room) { Factory.create(:bigbluebutton_room) }
     before {
       mock_server_and_api
+      room.server = mocked_server
       controller.stub(:bigbluebutton_user) { user }
       controller.should_receive(:bigbluebutton_role).and_return(:moderator)
-      controller.should_receive(:join_bigbluebutton_server_room_url).
-        with(mocked_server, room, :mobile => '1').
+      controller.should_receive(:join_bigbluebutton_room_url).with(room, :mobile => '1').
         and_return("http://test.com/join/url?mobile=1")
-      mocked_api.should_receive(:join_meeting_url).
-        with(room.meetingid, user.name, room.moderator_password).
+      mocked_api.should_receive(:join_meeting_url).with(room.meetingid, user.name, room.moderator_password).
         and_return("bigbluebutton://test.com/open/url/for/qrcode")
     }
-    before(:each) { get :join_mobile, :server_id => mocked_server.to_param, :id => room.to_param }
+    before(:each) { get :join_mobile, :id => room.to_param }
     it { should respond_with(:success) }
-    it { should assign_to(:server).with(mocked_server) }
     it { should assign_to(:room).with(room) }
     it { should assign_to(:join_url).with("bigbluebutton://test.com/join/url?mobile=1") }
     it { should assign_to(:qrcode_url).with("bigbluebutton://test.com/open/url/for/qrcode") }
@@ -71,15 +64,14 @@ describe Bigbluebutton::RoomsController do
     context "on success" do
       before :each do
         expect {
-          post :create, :server_id => server.to_param, :bigbluebutton_room => new_room.attributes
+          post :create, :bigbluebutton_room => new_room.attributes
         }.to change{ BigbluebuttonRoom.count }.by(1)
       end
       it {
         should respond_with(:redirect)
-        should redirect_to bigbluebutton_server_room_path(server, BigbluebuttonRoom.last)
+        should redirect_to bigbluebutton_room_path(BigbluebuttonRoom.last)
       }
       it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.notice.create.success')) }
-      it { should assign_to(:server).with(server) }
       it {
         saved = BigbluebuttonRoom.last
         saved.should have_same_attributes_as(new_room)
@@ -90,18 +82,16 @@ describe Bigbluebutton::RoomsController do
       before :each do
         new_room.name = nil # invalid
         expect {
-          post :create, :server_id => server.to_param, :bigbluebutton_room => new_room.attributes
+          post :create, :bigbluebutton_room => new_room.attributes
         }.not_to change{ BigbluebuttonRoom.count }
       end
       it { should render_template(:new) }
-      it { should assign_to(:server).with(server) }
     end
 
     context "with :redir_url" do
       it "on success" do
         expect {
-          post :create, :server_id => server.to_param, :bigbluebutton_room => new_room.attributes,
-                        :redir_url => bigbluebutton_servers_path
+          post :create, :bigbluebutton_room => new_room.attributes, :redir_url => bigbluebutton_servers_path
         }.to change{ BigbluebuttonRoom.count }.by(1)
         should respond_with(:redirect)
         should redirect_to bigbluebutton_servers_path
@@ -109,8 +99,7 @@ describe Bigbluebutton::RoomsController do
       it "on failure" do
         new_room.name = nil # invalid
         expect {
-          post :create, :server_id => server.to_param, :bigbluebutton_room => new_room.attributes,
-                        :redir_url => bigbluebutton_servers_path
+          post :create, :bigbluebutton_room => new_room.attributes, :redir_url => bigbluebutton_servers_path
         }.not_to change{ BigbluebuttonRoom.count }
         should respond_with(:redirect)
         should redirect_to bigbluebutton_servers_path
@@ -121,7 +110,7 @@ describe Bigbluebutton::RoomsController do
       before :each do
         attr = new_room.attributes
         attr.delete("meetingid")
-        post :create, :server_id => server.to_param, :bigbluebutton_room => attr
+        post :create, :bigbluebutton_room => attr
       end
       it {
         saved = BigbluebuttonRoom.last
@@ -138,42 +127,40 @@ describe Bigbluebutton::RoomsController do
     context "on success" do
       before :each do
         expect {
-          put :update, :server_id => server.to_param, :id => @room.to_param, :bigbluebutton_room => new_room.attributes
+          put :update, :id => @room.to_param, :bigbluebutton_room => new_room.attributes
         }.not_to change{ BigbluebuttonRoom.count }
       end
       it {
         saved = BigbluebuttonRoom.find(@room)
         should respond_with(:redirect)
-        should redirect_to bigbluebutton_server_room_path(server, saved)
+        should redirect_to bigbluebutton_room_path(saved)
       }
       it {
         saved = BigbluebuttonRoom.find(@room)
         saved.should have_same_attributes_as(new_room)
       }
       it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.notice.update.success')) }
-      it { should assign_to(:server).with(server) }
     end
 
     context "on failure" do
       before :each do
         new_room.name = nil # invalid
-        put :update, :server_id => server.to_param, :id => @room.to_param, :bigbluebutton_room => new_room.attributes
+        put :update, :id => @room.to_param, :bigbluebutton_room => new_room.attributes
       end
       it { should render_template(:edit) }
-      it { should assign_to(:server).with(server) }
       it { should assign_to(:room).with(@room) }
     end
 
     context "with :redir_url" do
       it "on success" do
-        put :update, :server_id => server.to_param, :id => @room.to_param, :bigbluebutton_room => new_room.attributes,
+        put :update, :id => @room.to_param, :bigbluebutton_room => new_room.attributes,
                      :redir_url => bigbluebutton_servers_path
         should respond_with(:redirect)
         should redirect_to bigbluebutton_servers_path
       end
       it "on failure" do
         new_room.name = nil # invalid
-        put :update, :server_id => server.to_param, :id => @room.to_param, :bigbluebutton_room => new_room.attributes,
+        put :update, :id => @room.to_param, :bigbluebutton_room => new_room.attributes,
                      :redir_url => bigbluebutton_servers_path
         should respond_with(:redirect)
         should redirect_to bigbluebutton_servers_path
@@ -184,7 +171,7 @@ describe Bigbluebutton::RoomsController do
       before :each do
         attr = new_room.attributes
         attr.delete("meetingid")
-        put :update, :server_id => server.to_param, :id => @room.to_param, :bigbluebutton_room => attr
+        put :update, :id => @room.to_param, :bigbluebutton_room => attr
       end
       it {
         saved = BigbluebuttonRoom.find(@room)
@@ -206,20 +193,18 @@ describe Bigbluebutton::RoomsController do
     context do
       before :each do
         expect {
-          delete :destroy, :server_id => mocked_server.to_param, :id => room.to_param
+          delete :destroy, :id => room.to_param
         }.to change{ BigbluebuttonRoom.count }.by(-1)
       end
       it {
         should respond_with(:redirect)
-        should redirect_to bigbluebutton_server_rooms_url
+        should redirect_to bigbluebutton_rooms_url
       }
-      it { should assign_to(:server).with(mocked_server) }
     end
 
     it "with :redir_url" do
       expect {
-        delete :destroy, :server_id => mocked_server.to_param, :id => room.to_param,
-                         :redir_url => bigbluebutton_servers_path
+        delete :destroy, :id => room.to_param, :redir_url => bigbluebutton_servers_path
       }.to change{ BigbluebuttonRoom.count }.by(-1)
       should respond_with(:redirect)
       should redirect_to bigbluebutton_servers_path
@@ -233,17 +218,16 @@ describe Bigbluebutton::RoomsController do
 
     context "room is running" do
       before { mocked_api.should_receive(:is_meeting_running?).and_return(true) }
-      before(:each) { get :running, :server_id => mocked_server.to_param, :id => room.to_param }
+      before(:each) { get :running, :id => room.to_param }
       it { should respond_with(:success) }
       it { should respond_with_content_type(:json) }
-      it { should assign_to(:server).with(mocked_server) }
       it { should assign_to(:room).with(room) }
       it { response.body.should == build_running_json(true) }
     end
 
     context "room is not running" do
       before { mocked_api.should_receive(:is_meeting_running?).and_return(false) }
-      before(:each) { get :running, :server_id => mocked_server.to_param, :id => room.to_param }
+      before(:each) { get :running, :id => room.to_param }
       it { response.body.should == build_running_json(false) }
     end
   end
@@ -255,10 +239,10 @@ describe Bigbluebutton::RoomsController do
     context "for an anonymous user" do
       before { controller.stub(:bigbluebutton_user) { nil } }
       before { controller.stub(:bigbluebutton_role) { :moderator } }
-      before(:each) { get :join, :server_id => mocked_server.to_param, :id => room.to_param }
+      before(:each) { get :join, :id => room.to_param }
       it {
         should respond_with(:redirect)
-        should redirect_to(invite_bigbluebutton_server_room_path(mocked_server, room))
+        should redirect_to(invite_bigbluebutton_room_path(room))
       }
     end
 
@@ -267,16 +251,16 @@ describe Bigbluebutton::RoomsController do
 
       context "should be defined with a password" do
         before { controller.stub(:bigbluebutton_role) { :password } }
-        before(:each) { get :join, :server_id => mocked_server.to_param, :id => room.to_param }
+        before(:each) { get :join, :id => room.to_param }
         it { should respond_with(:redirect) }
-        it { should redirect_to(invite_bigbluebutton_server_room_path(mocked_server, room)) }
+        it { should redirect_to(invite_bigbluebutton_room_path(room)) }
       end
 
       context "is undefined, the access should be blocked" do
         before { controller.stub(:bigbluebutton_role) { nil } }
         it {
           lambda {
-            get :join, :server_id => mocked_server.to_param, :id => room.to_param
+            get :join, :id => room.to_param
           }.should raise_error(BigbluebuttonRails::RoomAccessDenied)
         }
       end
@@ -286,7 +270,7 @@ describe Bigbluebutton::RoomsController do
     # see support/shared_examples/rooms_controller.rb
     context "calling .join_internal" do
       let(:template) { :join }
-      let(:request) { get :join, :server_id => mocked_server.to_param, :id => room.to_param }
+      let(:request) { get :join, :id => room.to_param }
       before { controller.stub(:bigbluebutton_user).and_return(user) }
       it_should_behave_like "internal join caller"
     end
@@ -299,7 +283,7 @@ describe Bigbluebutton::RoomsController do
         room.should_receive(:perform_join).and_return("http://test.com/join/url")
       }
       before(:each) {
-        get :join, :server_id => mocked_server.to_param, :id => room.to_param, :mobile => "1"
+        get :join, :id => room.to_param, :mobile => "1"
       }
       it { should redirect_to("bigbluebutton://test.com/join/url") }
     end
@@ -314,17 +298,16 @@ describe Bigbluebutton::RoomsController do
         mocked_api.should_receive(:is_meeting_running?).and_return(true)
         mocked_api.should_receive(:end_meeting).with(room.meetingid, room.moderator_password)
       }
-      before(:each) { get :end, :server_id => mocked_server.to_param, :id => room.to_param }
+      before(:each) { get :end, :id => room.to_param }
       it { should respond_with(:redirect) }
-      it { should redirect_to(bigbluebutton_server_room_path(mocked_server, room)) }
-      it { should assign_to(:server).with(mocked_server) }
+      it { should redirect_to(bigbluebutton_room_path(room)) }
       it { should assign_to(:room).with(room) }
       it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.notice.end.success')) }
     end
 
     context "room is not running" do
       before { mocked_api.should_receive(:is_meeting_running?).and_return(false) }
-      before(:each) { get :end, :server_id => mocked_server.to_param, :id => room.to_param }
+      before(:each) { get :end, :id => room.to_param }
       it { should respond_with(:redirect) }
       it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.notice.end.not_running')) }
     end
@@ -339,7 +322,7 @@ describe Bigbluebutton::RoomsController do
 
       context "with a role defined" do
         before { controller.stub(:bigbluebutton_role).and_return(:attendee) }
-        before(:each) { get :invite, :server_id => mocked_server.to_param, :id => room.to_param }
+        before(:each) { get :invite, :id => room.to_param }
         it { should respond_with(:success) }
         it { should render_template(:invite) }
         it { should assign_to(:room).with(room) }
@@ -348,7 +331,7 @@ describe Bigbluebutton::RoomsController do
       context "when the user's role" do
         context "should be defined with a password" do
           before { controller.stub(:bigbluebutton_role) { :password } }
-          before(:each) { get :invite, :server_id => mocked_server.to_param, :id => room.to_param }
+          before(:each) { get :invite, :id => room.to_param }
           it { should respond_with(:success) }
           it { should render_template(:invite) }
           it { should assign_to(:room).with(room) }
@@ -358,7 +341,7 @@ describe Bigbluebutton::RoomsController do
           before { controller.stub(:bigbluebutton_role) { nil } }
           it {
             lambda {
-              get :invite, :server_id => mocked_server.to_param, :id => room.to_param
+              get :invite, :id => room.to_param
             }.should raise_error(BigbluebuttonRails::RoomAccessDenied)
           }
         end
@@ -370,15 +353,15 @@ describe Bigbluebutton::RoomsController do
 
       context "with a role defined" do
         before { controller.stub(:bigbluebutton_role).and_return(:attendee) }
-        before(:each) { get :invite, :server_id => mocked_server.to_param, :id => room.to_param }
+        before(:each) { get :invite, :id => room.to_param }
         it { should respond_with(:redirect) }
-        it { should redirect_to(join_bigbluebutton_server_room_path(mocked_server, room)) }
+        it { should redirect_to(join_bigbluebutton_room_path(room)) }
       end
 
       context "when the user's role" do
         context "should be defined with a password" do
           before { controller.stub(:bigbluebutton_role) { :password } }
-          before(:each) { get :invite, :server_id => mocked_server.to_param, :id => room.to_param }
+          before(:each) { get :invite, :id => room.to_param }
           it { should respond_with(:success) }
           it { should render_template(:invite) }
           it { should assign_to(:room).with(room) }
@@ -388,7 +371,7 @@ describe Bigbluebutton::RoomsController do
           before { controller.stub(:bigbluebutton_role) { nil } }
           it {
             lambda {
-              get :invite, :server_id => mocked_server.to_param, :id => room.to_param
+              get :invite, :id => room.to_param
             }.should raise_error(BigbluebuttonRails::RoomAccessDenied)
           }
         end
@@ -414,13 +397,13 @@ describe Bigbluebutton::RoomsController do
       }
 
       context "if params[:id]" do
-        before(:each) { post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => user_hash }
+        before(:each) { post :auth, :id => room.to_param, :user => user_hash }
         it { should assign_to(:room).with(room) }
       end
 
       context "if params[:id] doesn't exists" do
         let(:message) { I18n.t('bigbluebutton_rails.rooms.errors.auth.wrong_params') }
-        before(:each) { post :auth, :server_id => mocked_server.to_param, :id => "inexistent-room-id", :user => user_hash }
+        before(:each) { post :auth, :id => "inexistent-room-id", :user => user_hash }
         it { should assign_to(:room).with(nil) }
         it { should respond_with(:redirect) }
         it { should redirect_to(http_referer) }
@@ -433,7 +416,7 @@ describe Bigbluebutton::RoomsController do
       before { controller.stub(:bigbluebutton_role) { nil } }
       it {
         lambda {
-          post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash
+          post :auth, :id => room.to_param, :user => hash
         }.should raise_error(BigbluebuttonRails::RoomAccessDenied)
       }
     end
@@ -446,14 +429,14 @@ describe Bigbluebutton::RoomsController do
       mocked_api.should_receive(:join_meeting_url).
         with(room.meetingid, user.name, room.attendee_password). # here's the validation
         and_return("http://test.com/attendee/join")
-      post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash
+      post :auth, :id => room.to_param, :user => hash
     end
 
     it "redirects to the correct join_url" do
       hash = { :name => "Elftor", :password => room.attendee_password }
       mocked_api.should_receive(:is_meeting_running?).and_return(true)
       mocked_api.should_receive(:join_meeting_url).and_return("http://test.com/attendee/join")
-      post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash
+      post :auth, :id => room.to_param, :user => hash
       should respond_with(:redirect)
       should redirect_to("http://test.com/attendee/join")
     end
@@ -465,14 +448,14 @@ describe Bigbluebutton::RoomsController do
       mocked_api.should_receive(:join_meeting_url).
         with(anything, anything, room.attendee_password).
         and_return("http://test.com/attendee/join")
-      post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash
+      post :auth, :id => room.to_param, :user => hash
       should respond_with(:redirect)
       should redirect_to("http://test.com/attendee/join")
     end
 
     context "validates user input and shows error" do
       before { controller.should_receive(:bigbluebutton_role).once { :password } }
-      before(:each) { post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => user_hash }
+      before(:each) { post :auth, :id => room.to_param, :user => user_hash }
 
       context "when name is not set" do
         let(:user_hash) { { :password => room.moderator_password } }
@@ -504,41 +487,57 @@ describe Bigbluebutton::RoomsController do
     context "calling .join_internal" do
       let(:template) { :invite }
       let(:hash) { { :name => user.name, :password => room.attendee_password } }
-      let(:request) { post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash }
+      let(:request) { post :auth, :id => room.to_param, :user => hash }
       before { controller.stub(:bigbluebutton_user).and_return(nil) }
       it_should_behave_like "internal join caller"
     end
   end
 
   describe "#external" do
-    before { mock_server_and_api }
-    let(:new_room) { BigbluebuttonRoom.new(:meetingid => 'my-meeting-id') }
+    let(:server) { Factory.create(:bigbluebutton_server) }
+    let(:meetingid) { 'my-meeting-id' }
 
     context "on success" do
-      before { controller.stub(:bigbluebutton_user).and_return(nil) }
-      before(:each) { get :external, :server_id => mocked_server.to_param, :meeting => new_room.meetingid }
-      it { should assign_to(:server).with(mocked_server) }
+      before {
+        controller.stub(:bigbluebutton_user).and_return(nil)
+        BigbluebuttonServer.stub(:find).and_return(server)
+      }
+      before(:each) { get :external, :meeting => meetingid, :server_id => server.id }
       it { should respond_with(:success) }
       it { should render_template(:external) }
+      it { should assign_to(:server).with(server) }
       it { should assign_to(:room).with_kind_of(BigbluebuttonRoom) }
-      it { assigns(:room).meetingid.should be(new_room.meetingid) }
+      it { assigns(:room).meetingid.should be(meetingid) }
+      it { assigns(:room).server_id.should be(server.id) }
     end
 
     context "when params[:meeting].blank?" do
-      before { controller.stub(:bigbluebutton_user).and_return(nil) }
-
       context "without params[:redir_url]" do
-        before(:each) { get :external, :server_id => mocked_server.to_param }
+        before(:each) { get :external, :server_id => server.id }
         it { should respond_with(:redirect) }
-        it { should redirect_to bigbluebutton_server_rooms_path(mocked_server) }
+        it { should redirect_to bigbluebutton_rooms_path }
         it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.errors.external.blank_meetingid')) }
       end
 
       context "with params[:redir_url]" do
-        before(:each) { get :external, :server_id => mocked_server.to_param, :redir_url => '/'}
+        before(:each) { get :external, :server_id => server.id, :redir_url => '/'}
         it { should redirect_to '/' }
       end
     end
+
+    context "when params[:server_id]" do
+      it "is blank" do
+        lambda {
+            get :external, :meeting => meetingid
+        }.should raise_error(ActiveRecord::RecordNotFound)
+      end
+
+      it "is invalid" do
+        lambda {
+            get :external, :meeting => meetingid, :server_id => server.id + 10
+        }.should raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
   end # #external
 
   describe "#external_auth" do
@@ -549,27 +548,36 @@ describe Bigbluebutton::RoomsController do
                                            :moderator_password => Forgery(:basic).password,
                                            :server => mocked_server) }
     let(:meetings) { [ new_room ] }
-    let(:http_referer) { bigbluebutton_server_path(mocked_server) }
-    before {
-      mock_server_and_api
-      controller.stub(:bigbluebutton_user).and_return(nil)
-      request.env["HTTP_REFERER"] = http_referer
-    }
+    before { controller.stub(:bigbluebutton_user).and_return(nil) }
 
-    context "assigns @room" do
-      context "if params[:meeting] and params[:user]" do
-        before { # TODO: this block is being repeated several times, put it in a method or something
-          mocked_server.should_receive(:fetch_meetings)
-          mocked_server.should_receive(:meetings).and_return(meetings)
-          new_room.should_receive(:perform_join)
-        }
-        before(:each) { post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :user => user_hash }
-        it { should assign_to(:room).with(new_room) }
-      end
+    context "assigns @server and @room if params[:meeting] and params[:user] and params[:server_id]" do
+      before {
+        mock_server_and_api
+        mocked_server.should_receive(:fetch_meetings)
+        mocked_server.should_receive(:meetings).and_return(meetings)
+        new_room.should_receive(:perform_join)
+      }
+      before(:each) { post :external_auth, :meeting => new_room.meetingid, :server_id => mocked_server.id, :user => user_hash }
+      it { should assign_to(:room).with(new_room) }
+      it { should assign_to(:server).with(mocked_server) }
+    end
+
+    it "shows error when params[:server_id] is invalid" do
+      lambda {
+        post :external_auth, :meeting => new_room.meetingid, :server_id => nil, :user => user_hash
+      }.should raise_error(ActiveRecord::RecordNotFound)
+    end
+
+    context "shows error" do
+      let(:http_referer) { bigbluebutton_server_path(mocked_server) }
+      before {
+        mock_server_and_api
+        request.env["HTTP_REFERER"] = http_referer
+      }
 
       context "if not params[:meeting]" do
-        let(:message) { I18n.t('bigbluebutton_rails.rooms.errors.auth.wrong_params') }
-        before(:each) { post :external_auth, :server_id => mocked_server.to_param, :meeting => nil, :user => user_hash }
+        let(:message) { I18n.t('bigbluebutton_rails.rooms.errors.external.wrong_params') }
+        before(:each) { post :external_auth, :meeting => nil, :server_id => mocked_server.id, :user => user_hash }
         it { should assign_to(:room).with(nil) }
         it { should respond_with(:redirect) }
         it { should redirect_to(http_referer) }
@@ -577,8 +585,8 @@ describe Bigbluebutton::RoomsController do
       end
 
       context "if not params[:user]" do
-        let(:message) { I18n.t('bigbluebutton_rails.rooms.errors.auth.wrong_params') }
-        before(:each) { post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :user => nil }
+        let(:message) { I18n.t('bigbluebutton_rails.rooms.errors.external.wrong_params') }
+        before(:each) { post :external_auth, :meeting => new_room.meetingid, :server_id => mocked_server.id, :user => nil }
         it { should assign_to(:room).with(nil) }
         it { should respond_with(:redirect) }
         it { should redirect_to(http_referer) }
@@ -586,8 +594,9 @@ describe Bigbluebutton::RoomsController do
       end
     end
 
-    context "got the room" do
+    context "with @server and @room assigned" do
       before {
+        mock_server_and_api
         mocked_server.should_receive(:fetch_meetings)
         mocked_server.should_receive(:meetings).and_return(meetings)
       }
@@ -595,12 +604,12 @@ describe Bigbluebutton::RoomsController do
       it "block access if bigbluebutton_role returns nil" do
         controller.stub(:bigbluebutton_role) { nil }
         lambda {
-          post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :user => user_hash
+          post :external_auth, :meeting => new_room.meetingid, :server_id => mocked_server.id, :user => user_hash
         }.should raise_error(BigbluebuttonRails::RoomAccessDenied)
       end
 
       context "validates user input and shows error" do
-        before(:each) { post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :user => user_hash }
+        before(:each) { post :external_auth, :meeting => new_room.meetingid, :server_id => mocked_server.id, :user => user_hash }
 
         context "when name is not set" do
           let(:user_hash) { { :password => room.moderator_password } }
@@ -633,7 +642,7 @@ describe Bigbluebutton::RoomsController do
             new_room.should_receive(:perform_join).with(anything, :attendee, request).
               and_return("http://test.com/attendee/join")
           }
-          before(:each) { post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :user => user_hash }
+          before(:each) { post :external_auth, :meeting => new_room.meetingid, :server_id => mocked_server.id, :user => user_hash }
           it { should respond_with(:redirect) }
           it { should redirect_to("http://test.com/attendee/join") }
         end
@@ -642,7 +651,7 @@ describe Bigbluebutton::RoomsController do
           before {
             new_room.should_receive(:perform_join).with(user_hash[:name], :attendee, request).and_return(nil)
           }
-          before(:each) { post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :user => user_hash }
+          before(:each) { post :external_auth, :meeting => new_room.meetingid, :server_id => mocked_server.id, :user => user_hash }
           it { should respond_with(:success) }
           it { should render_template(:external) }
           it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.errors.auth.not_running')) }
@@ -654,22 +663,12 @@ describe Bigbluebutton::RoomsController do
         controller.stub(:bigbluebutton_user).and_return(user)
         new_room.should_receive(:perform_join).with(user.name, anything, anything). # here's the validation
           and_return("http://test.com/attendee/join")
-        post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :user => user_hash
+        post :external_auth, :meeting => new_room.meetingid, :server_id => mocked_server.id, :user => user_hash
       end
 
     end
 
   end # #external_auth
 
-  # can be used when matching rooms inside some resource other than servers
-  context "selects the first server when the server_id is not defined in the url" do
-    let(:server2) { Factory.create(:bigbluebutton_server) }
-
-    # get /users/:user_id/room/:id(.:format)
-    before(:each) { get :show, :id => room.to_param, :user_id => "1" }
-    it { should respond_with(:success) }
-    it { should assign_to(:server).with(server) }
-  end
-
 end