bigbluebutton_rails 0.1.1 → 1.0.0

data/spec/controllers/bigbluebutton/rooms_controller_spec.rb

@@ -10,48 +10,55 @@ describe Bigbluebutton::RoomsController do
   let(:room) { Factory.create(:bigbluebutton_room, :server => server) }
 
   describe "#index" do
-    before(:each) { get :index }
+    before(:each) { get :index, :server_id => server.to_param }
     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, :id => room.to_param }
+    before(:each) { get :show, :server_id => server.to_param, :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 }
+    before(:each) { get :new, :server_id => server.to_param }
     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, :id => room.to_param }
+    before(:each) { get :edit, :server_id => server.to_param, :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(:room) { Factory.create(:bigbluebutton_room) }
+    let(:server) { Factory.create(:bigbluebutton_server) }
+    let(:room) { Factory.create(:bigbluebutton_room, :server => server) }
     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_room_url).with(room, :mobile => '1').
+      controller.should_receive(:join_bigbluebutton_server_room_url).
+        with(mocked_server, 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, :id => room.to_param }
+    before(:each) { get :join_mobile, :server_id => mocked_server.to_param, :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") }
@@ -64,14 +71,15 @@ describe Bigbluebutton::RoomsController do
     context "on success" do
       before :each do
         expect {
-          post :create, :bigbluebutton_room => new_room.attributes
+          post :create, :server_id => server.to_param, :bigbluebutton_room => new_room.attributes
         }.to change{ BigbluebuttonRoom.count }.by(1)
       end
       it {
         should respond_with(:redirect)
-        should redirect_to bigbluebutton_room_path(BigbluebuttonRoom.last)
+        should redirect_to bigbluebutton_server_room_path(server, 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)
@@ -82,16 +90,18 @@ describe Bigbluebutton::RoomsController do
       before :each do
         new_room.name = nil # invalid
         expect {
-          post :create, :bigbluebutton_room => new_room.attributes
+          post :create, :server_id => server.to_param, :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, :bigbluebutton_room => new_room.attributes, :redir_url => bigbluebutton_servers_path
+          post :create, :server_id => server.to_param, :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
@@ -99,7 +109,8 @@ describe Bigbluebutton::RoomsController do
       it "on failure" do
         new_room.name = nil # invalid
         expect {
-          post :create, :bigbluebutton_room => new_room.attributes, :redir_url => bigbluebutton_servers_path
+          post :create, :server_id => server.to_param, :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
@@ -110,7 +121,7 @@ describe Bigbluebutton::RoomsController do
       before :each do
         attr = new_room.attributes
         attr.delete("meetingid")
-        post :create, :bigbluebutton_room => attr
+        post :create, :server_id => server.to_param, :bigbluebutton_room => attr
       end
       it {
         saved = BigbluebuttonRoom.last
@@ -127,40 +138,42 @@ describe Bigbluebutton::RoomsController do
     context "on success" do
       before :each do
         expect {
-          put :update, :id => @room.to_param, :bigbluebutton_room => new_room.attributes
+          put :update, :server_id => server.to_param, :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_room_path(saved)
+        should redirect_to bigbluebutton_server_room_path(server, 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, :id => @room.to_param, :bigbluebutton_room => new_room.attributes
+        put :update, :server_id => server.to_param, :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, :id => @room.to_param, :bigbluebutton_room => new_room.attributes,
+        put :update, :server_id => server.to_param, :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, :id => @room.to_param, :bigbluebutton_room => new_room.attributes,
+        put :update, :server_id => server.to_param, :id => @room.to_param, :bigbluebutton_room => new_room.attributes,
                      :redir_url => bigbluebutton_servers_path
         should respond_with(:redirect)
         should redirect_to bigbluebutton_servers_path
@@ -171,7 +184,7 @@ describe Bigbluebutton::RoomsController do
       before :each do
         attr = new_room.attributes
         attr.delete("meetingid")
-        put :update, :id => @room.to_param, :bigbluebutton_room => attr
+        put :update, :server_id => server.to_param, :id => @room.to_param, :bigbluebutton_room => attr
       end
       it {
         saved = BigbluebuttonRoom.find(@room)
@@ -193,18 +206,20 @@ describe Bigbluebutton::RoomsController do
     context do
       before :each do
         expect {
-          delete :destroy, :id => room.to_param
+          delete :destroy, :server_id => mocked_server.to_param, :id => room.to_param
         }.to change{ BigbluebuttonRoom.count }.by(-1)
       end
       it {
         should respond_with(:redirect)
-        should redirect_to bigbluebutton_rooms_url
+        should redirect_to bigbluebutton_server_rooms_url
       }
+      it { should assign_to(:server).with(mocked_server) }
     end
 
     it "with :redir_url" do
       expect {
-        delete :destroy, :id => room.to_param, :redir_url => bigbluebutton_servers_path
+        delete :destroy, :server_id => mocked_server.to_param, :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
@@ -218,16 +233,17 @@ describe Bigbluebutton::RoomsController do
 
     context "room is running" do
       before { mocked_api.should_receive(:is_meeting_running?).and_return(true) }
-      before(:each) { get :running, :id => room.to_param }
+      before(:each) { get :running, :server_id => mocked_server.to_param, :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, :id => room.to_param }
+      before(:each) { get :running, :server_id => mocked_server.to_param, :id => room.to_param }
       it { response.body.should == build_running_json(false) }
     end
   end
@@ -239,10 +255,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, :id => room.to_param }
+      before(:each) { get :join, :server_id => mocked_server.to_param, :id => room.to_param }
       it {
         should respond_with(:redirect)
-        should redirect_to(invite_bigbluebutton_room_path(room))
+        should redirect_to(invite_bigbluebutton_server_room_path(mocked_server, room))
       }
     end
 
@@ -251,16 +267,16 @@ describe Bigbluebutton::RoomsController do
 
       context "should be defined with a password" do
         before { controller.stub(:bigbluebutton_role) { :password } }
-        before(:each) { get :join, :id => room.to_param }
+        before(:each) { get :join, :server_id => mocked_server.to_param, :id => room.to_param }
         it { should respond_with(:redirect) }
-        it { should redirect_to(invite_bigbluebutton_room_path(room)) }
+        it { should redirect_to(invite_bigbluebutton_server_room_path(mocked_server, room)) }
       end
 
       context "is undefined, the access should be blocked" do
         before { controller.stub(:bigbluebutton_role) { nil } }
         it {
           lambda {
-            get :join, :id => room.to_param
+            get :join, :server_id => mocked_server.to_param, :id => room.to_param
           }.should raise_error(BigbluebuttonRails::RoomAccessDenied)
         }
       end
@@ -270,7 +286,7 @@ describe Bigbluebutton::RoomsController do
     # see support/shared_examples/rooms_controller.rb
     context "calling .join_internal" do
       let(:template) { :join }
-      let(:request) { get :join, :id => room.to_param }
+      let(:request) { get :join, :server_id => mocked_server.to_param, :id => room.to_param }
       before { controller.stub(:bigbluebutton_user).and_return(user) }
       it_should_behave_like "internal join caller"
     end
@@ -283,7 +299,7 @@ describe Bigbluebutton::RoomsController do
         room.should_receive(:perform_join).and_return("http://test.com/join/url")
       }
       before(:each) {
-        get :join, :id => room.to_param, :mobile => "1"
+        get :join, :server_id => mocked_server.to_param, :id => room.to_param, :mobile => "1"
       }
       it { should redirect_to("bigbluebutton://test.com/join/url") }
     end
@@ -298,16 +314,17 @@ 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, :id => room.to_param }
+      before(:each) { get :end, :server_id => mocked_server.to_param, :id => room.to_param }
       it { should respond_with(:redirect) }
-      it { should redirect_to(bigbluebutton_room_path(room)) }
+      it { should redirect_to(bigbluebutton_server_room_path(mocked_server, room)) }
+      it { should assign_to(:server).with(mocked_server) }
       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, :id => room.to_param }
+      before(:each) { get :end, :server_id => mocked_server.to_param, :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
@@ -322,7 +339,7 @@ describe Bigbluebutton::RoomsController do
 
       context "with a role defined" do
         before { controller.stub(:bigbluebutton_role).and_return(:attendee) }
-        before(:each) { get :invite, :id => room.to_param }
+        before(:each) { get :invite, :server_id => mocked_server.to_param, :id => room.to_param }
         it { should respond_with(:success) }
         it { should render_template(:invite) }
         it { should assign_to(:room).with(room) }
@@ -331,7 +348,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, :id => room.to_param }
+          before(:each) { get :invite, :server_id => mocked_server.to_param, :id => room.to_param }
           it { should respond_with(:success) }
           it { should render_template(:invite) }
           it { should assign_to(:room).with(room) }
@@ -341,7 +358,7 @@ describe Bigbluebutton::RoomsController do
           before { controller.stub(:bigbluebutton_role) { nil } }
           it {
             lambda {
-              get :invite, :id => room.to_param
+              get :invite, :server_id => mocked_server.to_param, :id => room.to_param
             }.should raise_error(BigbluebuttonRails::RoomAccessDenied)
           }
         end
@@ -353,15 +370,15 @@ describe Bigbluebutton::RoomsController do
 
       context "with a role defined" do
         before { controller.stub(:bigbluebutton_role).and_return(:attendee) }
-        before(:each) { get :invite, :id => room.to_param }
+        before(:each) { get :invite, :server_id => mocked_server.to_param, :id => room.to_param }
         it { should respond_with(:redirect) }
-        it { should redirect_to(join_bigbluebutton_room_path(room)) }
+        it { should redirect_to(join_bigbluebutton_server_room_path(mocked_server, 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, :id => room.to_param }
+          before(:each) { get :invite, :server_id => mocked_server.to_param, :id => room.to_param }
           it { should respond_with(:success) }
           it { should render_template(:invite) }
           it { should assign_to(:room).with(room) }
@@ -371,7 +388,7 @@ describe Bigbluebutton::RoomsController do
           before { controller.stub(:bigbluebutton_role) { nil } }
           it {
             lambda {
-              get :invite, :id => room.to_param
+              get :invite, :server_id => mocked_server.to_param, :id => room.to_param
             }.should raise_error(BigbluebuttonRails::RoomAccessDenied)
           }
         end
@@ -397,13 +414,13 @@ describe Bigbluebutton::RoomsController do
       }
 
       context "if params[:id]" do
-        before(:each) { post :auth, :id => room.to_param, :user => user_hash }
+        before(:each) { post :auth, :server_id => mocked_server.to_param, :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, :id => "inexistent-room-id", :user => user_hash }
+        before(:each) { post :auth, :server_id => mocked_server.to_param, :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) }
@@ -416,7 +433,7 @@ describe Bigbluebutton::RoomsController do
       before { controller.stub(:bigbluebutton_role) { nil } }
       it {
         lambda {
-          post :auth, :id => room.to_param, :user => hash
+          post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash
         }.should raise_error(BigbluebuttonRails::RoomAccessDenied)
       }
     end
@@ -429,14 +446,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, :id => room.to_param, :user => hash
+      post :auth, :server_id => mocked_server.to_param, :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, :id => room.to_param, :user => hash
+      post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash
       should respond_with(:redirect)
       should redirect_to("http://test.com/attendee/join")
     end
@@ -448,14 +465,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, :id => room.to_param, :user => hash
+      post :auth, :server_id => mocked_server.to_param, :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, :id => room.to_param, :user => user_hash }
+      before(:each) { post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => user_hash }
 
       context "when name is not set" do
         let(:user_hash) { { :password => room.moderator_password } }
@@ -487,57 +504,41 @@ 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, :id => room.to_param, :user => hash }
+      let(:request) { post :auth, :server_id => mocked_server.to_param, :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
-    let(:server) { Factory.create(:bigbluebutton_server) }
-    let(:meetingid) { 'my-meeting-id' }
+    before { mock_server_and_api }
+    let(:new_room) { BigbluebuttonRoom.new(:meetingid => 'my-meeting-id') }
 
     context "on success" do
-      before {
-        controller.stub(:bigbluebutton_user).and_return(nil)
-        BigbluebuttonServer.stub(:find).and_return(server)
-      }
-      before(:each) { get :external, :meeting => meetingid, :server_id => server.id }
+      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) }
       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(meetingid) }
-      it { assigns(:room).server_id.should be(server.id) }
+      it { assigns(:room).meetingid.should be(new_room.meetingid) }
     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 => server.id }
+        before(:each) { get :external, :server_id => mocked_server.to_param }
         it { should respond_with(:redirect) }
-        it { should redirect_to bigbluebutton_rooms_path }
+        it { should redirect_to bigbluebutton_server_rooms_path(mocked_server) }
         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 => server.id, :redir_url => '/'}
+        before(:each) { get :external, :server_id => mocked_server.to_param, :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
@@ -548,36 +549,27 @@ describe Bigbluebutton::RoomsController do
                                            :moderator_password => Forgery(:basic).password,
                                            :server => mocked_server) }
     let(:meetings) { [ new_room ] }
-    before { controller.stub(:bigbluebutton_user).and_return(nil) }
-
-    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
+    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
+    }
 
-    context "shows error" do
-      let(:http_referer) { bigbluebutton_server_path(mocked_server) }
-      before {
-        mock_server_and_api
-        request.env["HTTP_REFERER"] = http_referer
-      }
+    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 "if not params[:meeting]" do
-        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 }
+        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 }
         it { should assign_to(:room).with(nil) }
         it { should respond_with(:redirect) }
         it { should redirect_to(http_referer) }
@@ -585,8 +577,8 @@ describe Bigbluebutton::RoomsController do
       end
 
       context "if not params[:user]" do
-        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 }
+        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 }
         it { should assign_to(:room).with(nil) }
         it { should respond_with(:redirect) }
         it { should redirect_to(http_referer) }
@@ -594,9 +586,8 @@ describe Bigbluebutton::RoomsController do
       end
     end
 
-    context "with @server and @room assigned" do
+    context "got the room" do
       before {
-        mock_server_and_api
         mocked_server.should_receive(:fetch_meetings)
         mocked_server.should_receive(:meetings).and_return(meetings)
       }
@@ -604,12 +595,12 @@ describe Bigbluebutton::RoomsController do
       it "block access if bigbluebutton_role returns nil" do
         controller.stub(:bigbluebutton_role) { nil }
         lambda {
-          post :external_auth, :meeting => new_room.meetingid, :server_id => mocked_server.id, :user => user_hash
+          post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :user => user_hash
         }.should raise_error(BigbluebuttonRails::RoomAccessDenied)
       end
 
       context "validates user input and shows error" do
-        before(:each) { post :external_auth, :meeting => new_room.meetingid, :server_id => mocked_server.id, :user => user_hash }
+        before(:each) { post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :user => user_hash }
 
         context "when name is not set" do
           let(:user_hash) { { :password => room.moderator_password } }
@@ -642,7 +633,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, :meeting => new_room.meetingid, :server_id => mocked_server.id, :user => user_hash }
+          before(:each) { post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :user => user_hash }
           it { should respond_with(:redirect) }
           it { should redirect_to("http://test.com/attendee/join") }
         end
@@ -651,7 +642,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, :meeting => new_room.meetingid, :server_id => mocked_server.id, :user => user_hash }
+          before(:each) { post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :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')) }
@@ -663,12 +654,22 @@ 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, :meeting => new_room.meetingid, :server_id => mocked_server.id, :user => user_hash
+        post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :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
 

data/spec/controllers/bigbluebutton/servers_controller_json_responses_spec.rb

@@ -4,7 +4,7 @@ describe Bigbluebutton::ServersController do
   render_views
   let(:server) { Factory.create(:bigbluebutton_server) }
 
-  context "json responses for" do
+  context "json responses for " do
 
     describe "#index" do
       before do
@@ -144,16 +144,5 @@ describe Bigbluebutton::ServersController do
 
     end
 
-    describe "#rooms" do
-      before do
-        @room1 = Factory.create(:bigbluebutton_room, :server => server)
-        @room2 = Factory.create(:bigbluebutton_room, :server => server)
-      end
-      before(:each) { get :rooms, :id => server.to_param, :format => 'json' }
-      it { should respond_with(:success) }
-      it { should respond_with_content_type(:json) }
-      it { should respond_with_json([@room1, @room2].to_json) }
-    end
-
   end
 end

data/spec/controllers/bigbluebutton/servers_controller_spec.rb

@@ -140,16 +140,5 @@ describe Bigbluebutton::ServersController do
 
   end # #activity
 
-  describe "#rooms" do
-    before do
-      @room1 = Factory.create(:bigbluebutton_room, :server => server)
-      @room2 = Factory.create(:bigbluebutton_room, :server => server)
-    end
-    before(:each) { get :rooms, :id => server.to_param }
-    it { should respond_with(:success) }
-    it { should render_template(:rooms) }
-    it { should assign_to(:rooms).with([@room1, @room2]) }
-  end
-
 end
 

data/spec/generators/install_generator_spec.rb

@@ -21,8 +21,8 @@ describe BigbluebuttonRails::Generators::InstallGenerator do
 
     it "all files are properly destroyed" do
       run_generator %w(), :behavior => :revoke
-      assert_no_migration "db/migrate/create_bigbluebutton_rails.rb"
       assert_no_file "config/locales/bigbluebutton_rails.en.yml"
+      assert_no_migration "db/migrate/create_bigbluebutton_rails.rb"
       assert_no_file "public/stylesheets/bigbluebutton_rails.css"
       assert_no_file "public/javascripts/jquery.min.js"
       assert_no_file "public/images/loading.gif"