bigbluebutton_rails 1.4.0 → 2.0.0

data/spec/controllers/bigbluebutton/playback_types_controller_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Bigbluebutton::PlaybackTypesController do
+  render_views
+  let!(:playback_type) { FactoryGirl.create(:bigbluebutton_playback_type) }
+
+  describe "#update" do
+    let!(:new_playback_type) { FactoryGirl.build(:bigbluebutton_playback_type, visible: !playback_type.visible) }
+    let(:referer) { "/back" }
+    before { request.env["HTTP_REFERER"] = referer }
+
+    context "on success" do
+      before(:each) {
+        expect {
+          put :update, :id => playback_type.to_param, :bigbluebutton_playback_type => new_playback_type.attributes
+        }.not_to change{ BigbluebuttonPlaybackType.count }
+      }
+      it { should respond_with(:redirect) }
+      it { should redirect_to(referer) }
+      it {
+        saved = BigbluebuttonPlaybackType.find(playback_type)
+        saved.should have_same_attributes_as(new_playback_type, ['identifier'])
+      }
+      it { should set_the_flash.to(I18n.t('bigbluebutton_rails.playback_types.notice.update.success')) }
+    end
+
+    context "on failure" do
+      before(:each) {
+        BigbluebuttonPlaybackType.should_receive(:find).and_return(playback_type)
+        playback_type.should_receive(:update_attributes).and_return(false)
+        playback_type.errors.add :identifier, "first"
+        playback_type.errors.add :visible, "second"
+        put :update, :id => playback_type.to_param, :bigbluebutton_playback_type => new_playback_type.attributes
+      }
+      it { should respond_with(:redirect) }
+      it { should redirect_to(referer) }
+      it {
+        expected = "Identifier first, Visible second"
+        should set_the_flash.to(expected)
+      }
+    end
+
+    describe "params handling" do
+      let(:attrs) { FactoryGirl.attributes_for(:bigbluebutton_playback_type) }
+      let(:params) { { :bigbluebutton_playback_type => attrs } }
+      let(:allowed_params) {
+        [ :visible, :default ]
+      }
+      it {
+        # we just check that the rails method 'permit' is being called on the hash with the
+        # correct parameters
+        BigbluebuttonPlaybackType.stub(:find).and_return(playback_type)
+        playback_type.stub(:update_attributes).and_return(true)
+        attrs.stub(:permit).and_return(attrs)
+        controller.stub(:params).and_return(params)
+
+        put :update, :id => playback_type.to_param, :bigbluebutton_playback_type => new_playback_type.attributes
+        attrs.should have_received(:permit).with(*allowed_params)
+      }
+    end
+
+    context "doesn't override @playback_type" do
+      let!(:other_playback_type) { FactoryGirl.create(:bigbluebutton_playback_type) }
+      let(:format) { FactoryGirl.create(:bigbluebutton_playback_format, :playback_type => playback_type) }
+      before { controller.instance_variable_set(:@playback_type, other_playback_type) }
+      before(:each) {
+        put :update, :id => playback_type.to_param, :bigbluebutton_playback_type => new_playback_type.attributes
+      }
+      it { should assign_to(:playback_type).with(other_playback_type) }
+    end
+  end
+
+  # important because it might break custom actions on controllers that inherit from this
+  skip "doesn't call #find_playback_type for custom actions"
+
+end

data/spec/controllers/bigbluebutton/recordings_controller_spec.rb

@@ -2,60 +2,89 @@ require 'spec_helper'
 
 describe Bigbluebutton::RecordingsController do
   render_views
-  let(:recording) { FactoryGirl.create(:bigbluebutton_recording) }
+  let!(:recording) { FactoryGirl.create(:bigbluebutton_recording) }
 
   describe "#index" do
-    before { 3.times { FactoryGirl.create(:bigbluebutton_recording) } }
-    before(:each) { get :index }
-    it { should respond_with(:success) }
-    it { should assign_to(:recordings).with(BigbluebuttonRecording.all) }
-    it { should render_template(:index) }
+    context "basic" do
+      before { 3.times { FactoryGirl.create(:bigbluebutton_recording) } }
+      before(:each) { get :index }
+      it { should respond_with(:success) }
+      it { should assign_to(:recordings).with(BigbluebuttonRecording.all) }
+      it { should render_template(:index) }
+    end
+
+    context "doesn't override @recordings" do
+      let!(:my_recordings) { [ FactoryGirl.create(:bigbluebutton_recording), FactoryGirl.create(:bigbluebutton_recording) ] }
+      before {
+        3.times { FactoryGirl.create(:bigbluebutton_recording) }
+        controller.instance_variable_set(:@recordings, my_recordings)
+      }
+      before(:each) { get :index }
+      it { should assign_to(:recordings).with(my_recordings) }
+    end
   end
 
   describe "#show" do
-    before(:each) { get :show, :id => recording.to_param }
-    it { should respond_with(:success) }
-    it { should assign_to(:recording).with(recording) }
-    it { should render_template(:show) }
+    context "basic" do
+      before(:each) { get :show, :id => recording.to_param }
+      it { should respond_with(:success) }
+      it { should assign_to(:recording).with(recording) }
+      it { should render_template(:show) }
+    end
+
+    context "doesn't override @recording" do
+      let!(:other_recording) { FactoryGirl.create(:bigbluebutton_recording) }
+      before { controller.instance_variable_set(:@recording, other_recording) }
+      before(:each) { get :show, :id => recording.to_param }
+      it { should assign_to(:recording).with(other_recording) }
+    end
   end
 
   describe "#edit" do
-    before(:each) { get :edit, :id => recording.to_param }
-    it { should respond_with(:success) }
-    it { should assign_to(:recording).with(recording) }
-    it { should render_template(:edit) }
+    context "basic" do
+      before(:each) { get :edit, :id => recording.to_param }
+      it { should respond_with(:success) }
+      it { should assign_to(:recording).with(recording) }
+      it { should render_template(:edit) }
+    end
+
+    context "doesn't override @recording" do
+      let!(:other_recording) { FactoryGirl.create(:bigbluebutton_recording) }
+      before { controller.instance_variable_set(:@recording, other_recording) }
+      before(:each) { get :edit, :id => recording.to_param }
+      it { should assign_to(:recording).with(other_recording) }
+    end
   end
 
   describe "#update" do
-    let(:new_recording) { FactoryGirl.build(:bigbluebutton_recording) }
-    before { @recording = recording } # need this to trigger let(:recording) and actually create the object
+    let!(:new_recording) { FactoryGirl.build(:bigbluebutton_recording) }
 
     context "on success" do
       before(:each) {
         expect {
-          put :update, :id => @recording.to_param, :bigbluebutton_recording => new_recording.attributes
+          put :update, :id => recording.to_param, :bigbluebutton_recording => new_recording.attributes
         }.not_to change{ BigbluebuttonRecording.count }
       }
       it { should respond_with(:redirect) }
       it {
-        saved = BigbluebuttonRecording.find(@recording)
+        saved = BigbluebuttonRecording.find(recording)
         should redirect_to(bigbluebutton_recording_path(saved))
       }
       it {
-        saved = BigbluebuttonRecording.find(@recording)
-        saved.should have_same_attributes_as(new_recording, ['room_id', 'server_id', 'meeting_id'])
+        saved = BigbluebuttonRecording.find(recording)
+        saved.should have_same_attributes_as(new_recording, ['room_id', 'server_id', 'meeting_id', 'size'])
       }
       it { should set_the_flash.to(I18n.t('bigbluebutton_rails.recordings.notice.update.success')) }
     end
 
     context "on failure" do
       before(:each) {
-        BigbluebuttonRecording.should_receive(:find_by_recordid).and_return(@recording)
-        @recording.should_receive(:update_attributes).and_return(false)
-        put :update, :id => @recording.to_param, :bigbluebutton_recording => new_recording.attributes
+        BigbluebuttonRecording.should_receive(:find_by_recordid).and_return(recording)
+        recording.should_receive(:update_attributes).and_return(false)
+        put :update, :id => recording.to_param, :bigbluebutton_recording => new_recording.attributes
       }
       it { should render_template(:edit) }
-      it { should assign_to(:recording).with(@recording) }
+      it { should assign_to(:recording).with(recording) }
     end
 
     describe "params handling" do
@@ -67,12 +96,12 @@ describe Bigbluebutton::RecordingsController do
       it {
         # we just check that the rails method 'permit' is being called on the hash with the
         # correct parameters
-        BigbluebuttonRecording.stub(:find_by_recordid).and_return(@recording)
-        @recording.stub(:update_attributes).and_return(true)
+        BigbluebuttonRecording.stub(:find_by_recordid).and_return(recording)
+        recording.stub(:update_attributes).and_return(true)
         attrs.stub(:permit).and_return(attrs)
         controller.stub(:params).and_return(params)
 
-        put :update, :id => @recording.to_param, :bigbluebutton_recording => attrs
+        put :update, :id => recording.to_param, :bigbluebutton_recording => attrs
         attrs.should have_received(:permit).with(*allowed_params)
       }
     end
@@ -80,15 +109,15 @@ describe Bigbluebutton::RecordingsController do
     # to make sure it doesn't break if the hash informed doesn't have the key :bigbluebutton_recording
     describe "if parameters are not informed" do
       it {
-        put :update, :id => @recording.to_param
-        should redirect_to(bigbluebutton_recording_path(@recording))
+        put :update, :id => recording.to_param
+        should redirect_to(bigbluebutton_recording_path(recording))
       }
     end
 
     context "with :redir_url" do
       context "on success" do
         before(:each) {
-          put :update, :id => @recording.to_param, :bigbluebutton_recording => new_recording.attributes, :redir_url => '/any'
+          put :update, :id => recording.to_param, :bigbluebutton_recording => new_recording.attributes, :redir_url => '/any'
         }
         it { should respond_with(:redirect) }
         it { should redirect_to "/any" }
@@ -96,15 +125,21 @@ describe Bigbluebutton::RecordingsController do
 
       context "on failure" do
         before(:each) {
-          BigbluebuttonRecording.should_receive(:find_by_recordid).and_return(@recording)
-          @recording.should_receive(:update_attributes).and_return(false)
-          put :update, :id => @recording.to_param, :bigbluebutton_recording => new_recording.attributes, :redir_url => '/any'
+          BigbluebuttonRecording.should_receive(:find_by_recordid).and_return(recording)
+          recording.should_receive(:update_attributes).and_return(false)
+          put :update, :id => recording.to_param, :bigbluebutton_recording => new_recording.attributes, :redir_url => '/any'
         }
         it { should respond_with(:redirect) }
         it { should redirect_to "/any" }
       end
     end
 
+    context "doesn't override @recording" do
+      let!(:other_recording) { FactoryGirl.create(:bigbluebutton_recording) }
+      before { controller.instance_variable_set(:@recording, other_recording) }
+      before(:each) { put :update, :id => recording.to_param, :bigbluebutton_recording => new_recording.attributes }
+      it { should assign_to(:recording).with(other_recording) }
+    end
   end
 
   describe "#destroy" do
@@ -172,6 +207,16 @@ describe Bigbluebutton::RecordingsController do
       it { should redirect_to bigbluebutton_recordings_url }
       it { should set_the_flash.to(I18n.t('bigbluebutton_rails.recordings.notice.destroy.success')) }
     end
+
+    context "doesn't override @recording" do
+      let!(:other_recording) { FactoryGirl.create(:bigbluebutton_recording) }
+      before {
+        controller.instance_variable_set(:@recording, other_recording)
+        other_recording.server.stub(:send_delete_recordings)
+      }
+      before(:each) { delete :destroy, :id => recording.to_param }
+      it { should assign_to(:recording).with(other_recording) }
+    end
   end
 
   describe "#play" do
@@ -188,9 +233,20 @@ describe Bigbluebutton::RecordingsController do
       end
 
       context "when params[:type] is not specified plays the first format" do
-        before(:each) { get :play, :id => recording.to_param }
-        it { should respond_with(:redirect) }
-        it { should redirect_to @format1.url }
+        context "plays the default format" do
+          before {
+            @format2.playback_type.update_attributes(default: true)
+          }
+          before(:each) { get :play, :id => recording.to_param }
+          it { should respond_with(:redirect) }
+          it { should redirect_to @format2.url }
+        end
+
+        context "plays the first format if there's no default" do
+          before(:each) { get :play, :id => recording.to_param }
+          it { should respond_with(:redirect) }
+          it { should redirect_to @format1.url }
+        end
       end
     end
 
@@ -209,6 +265,13 @@ describe Bigbluebutton::RecordingsController do
       end
     end
 
+    context "doesn't override @recording" do
+      let!(:other_recording) { FactoryGirl.create(:bigbluebutton_recording) }
+      let(:format) { FactoryGirl.create(:bigbluebutton_playback_format, :recording => recording) }
+      before { controller.instance_variable_set(:@recording, other_recording) }
+      before(:each) { get :play, :id => recording.to_param, :type => format.format_type }
+      it { should assign_to(:recording).with(other_recording) }
+    end
   end
 
   # these actions are essentially the same
@@ -269,7 +332,16 @@ describe Bigbluebutton::RecordingsController do
         end
       end
 
+      context "doesn't override @recording" do
+        let!(:other_recording) { FactoryGirl.create(:bigbluebutton_recording) }
+        before {
+          controller.instance_variable_set(:@recording, other_recording)
+          other_recording.server.stub(:send_publish_recordings)
+        }
+        before(:each) { post action, :id => recording.to_param }
+        it { should assign_to(:recording).with(other_recording) }
+      end
+
     end
   end
-
 end

data/spec/controllers/bigbluebutton/rooms_controller_exception_handling_spec.rb

@@ -84,6 +84,7 @@ describe Bigbluebutton::RoomsController do
         it "catches exception on create_meeting" do
           mocked_api.should_receive(:"request_headers=").once
           mocked_api.should_receive(:is_meeting_running?).exactly(3).times.and_return(false)
+          mocked_api.should_receive(:end_meeting)
           mocked_api.should_receive(:create_meeting) { raise bbb_error }
         end
 

data/spec/controllers/bigbluebutton/rooms_controller_json_responses_spec.rb

@@ -105,7 +105,7 @@ describe Bigbluebutton::RoomsController do
       context "room is running" do
         before {
           mocked_api.should_receive(:is_meeting_running?).and_return(true)
-          mocked_api.should_receive(:end_meeting).with(room.meetingid, room.moderator_password)
+          mocked_api.should_receive(:end_meeting).with(room.meetingid, room.moderator_api_password)
         }
         before(:each) { get :end, :id => room.to_param, :format => 'json' }
         it { should respond_with(:success) }
@@ -124,7 +124,7 @@ describe Bigbluebutton::RoomsController do
       context "throwing an exception" do
         let(:msg) { "any error message" }
         before {
-          mocked_api.should_receive(:is_meeting_running?).and_return{ raise BigBlueButton::BigBlueButtonException.new(msg) }
+          mocked_api.should_receive(:is_meeting_running?) { raise BigBlueButton::BigBlueButtonException.new(msg) }
         }
         before(:each) { get :end, :id => room.to_param, :format => 'json' }
         it { should respond_with(:error) }
@@ -156,7 +156,7 @@ describe Bigbluebutton::RoomsController do
       context "throwing error" do
         let(:msg) { "any error message" }
         before {
-          mocked_api.should_receive(:is_meeting_running?).and_return{ raise BigBlueButton::BigBlueButtonException.new(msg) }
+          mocked_api.should_receive(:is_meeting_running?) { raise BigBlueButton::BigBlueButtonException.new(msg) }
         }
         before(:each) {
           delete :destroy, :id => room.to_param, :format => 'json'
@@ -175,5 +175,29 @@ describe Bigbluebutton::RoomsController do
       it "on error"
     end
 
+    describe "#generate_dial_number" do
+      context "on success" do
+        before(:each) {
+          BigbluebuttonRoom.any_instance.stub(:generate_dial_number!).and_return(true)
+          post :generate_dial_number, id: room.to_param, format: 'json'
+        }
+        it { should respond_with(:success) }
+        it { should respond_with_content_type('application/json') }
+      end
+
+      context "on error" do
+        before(:each) {
+          BigbluebuttonRoom.any_instance.stub(:generate_dial_number!).and_return(nil)
+          post :generate_dial_number, id: room.to_param, format: 'json'
+        }
+        it { should respond_with(:error) }
+        it { should respond_with_content_type('application/json') }
+        it {
+          error_msg = I18n.t('bigbluebutton_rails.rooms.errors.generate_dial_number.not_unique')
+          should respond_with_json({ :message => error_msg }.to_json)
+        }
+      end
+    end
+
   end
 end

data/spec/controllers/bigbluebutton/rooms_controller_spec.rb

@@ -8,34 +8,74 @@ describe Bigbluebutton::RoomsController do
   render_views
   let(:server) { FactoryGirl.create(:bigbluebutton_server) }
   let(:room) { FactoryGirl.create(:bigbluebutton_room, :server => server) }
+  let(:params_to_ignore) { ['moderator_api_password', 'attendee_api_password'] }
 
   describe "#index" do
-    before { 3.times { FactoryGirl.create(:bigbluebutton_room) } }
-    before(:each) { get :index }
-    it { should respond_with(:success) }
-    it { should assign_to(:rooms).with(BigbluebuttonRoom.all) }
-    it { should render_template(:index) }
+    context "basic" do
+      before { 3.times { FactoryGirl.create(:bigbluebutton_room) } }
+      before(:each) { get :index }
+      it { should respond_with(:success) }
+      it { should assign_to(:rooms).with(BigbluebuttonRoom.all) }
+      it { should render_template(:index) }
+    end
+
+    context "doesn't override @rooms" do
+      let!(:my_rooms) { [ FactoryGirl.create(:bigbluebutton_room), FactoryGirl.create(:bigbluebutton_room) ] }
+      before {
+        3.times { FactoryGirl.create(:bigbluebutton_room) }
+        controller.instance_variable_set(:@rooms, my_rooms)
+      }
+      before(:each) { get :index }
+      it { should assign_to(:rooms).with(my_rooms) }
+    end
   end
 
   describe "#show" do
-    before(:each) { get :show, :id => room.to_param }
-    it { should respond_with(:success) }
-    it { should assign_to(:room).with(room) }
-    it { should render_template(:show) }
+    context "basic" do
+      before(:each) { get :show, :id => room.to_param }
+      it { should respond_with(:success) }
+      it { should assign_to(:room).with(room) }
+      it { should render_template(:show) }
+    end
+
+    context "doesn't override @room" do
+      let!(:other_room) { FactoryGirl.create(:bigbluebutton_room) }
+      before { controller.instance_variable_set(:@room, other_room) }
+      before(:each) { get :show, :id => room.to_param }
+      it { should assign_to(:room).with(other_room) }
+    end
   end
 
   describe "#new" do
-    before(:each) { get :new }
-    it { should respond_with(:success) }
-    it { should assign_to(:room).with_kind_of(BigbluebuttonRoom) }
-    it { should render_template(:new) }
+    context "basic" do
+      before(:each) { get :new }
+      it { should respond_with(:success) }
+      it { should assign_to(:room).with_kind_of(BigbluebuttonRoom) }
+      it { should render_template(:new) }
+    end
+
+    context "doesn't override @room" do
+      let!(:other_room) { FactoryGirl.create(:bigbluebutton_room) }
+      before { controller.instance_variable_set(:@room, other_room) }
+      before(:each) { get :new }
+      it { should assign_to(:room).with(other_room) }
+    end
   end
 
   describe "#edit" do
-    before(:each) { get :edit, :id => room.to_param }
-    it { should respond_with(:success) }
-    it { should assign_to(:room).with(room) }
-    it { should render_template(:edit) }
+    context "basic" do
+      before(:each) { get :edit, :id => room.to_param }
+      it { should respond_with(:success) }
+      it { should assign_to(:room).with(room) }
+      it { should render_template(:edit) }
+    end
+
+    context "doesn't override @room" do
+      let!(:other_room) { FactoryGirl.create(:bigbluebutton_room) }
+      before { controller.instance_variable_set(:@room, other_room) }
+      before(:each) { get :edit, :id => room.to_param }
+      it { should assign_to(:room).with(other_room) }
+    end
   end
 
   describe "#join_mobile" do
@@ -87,6 +127,13 @@ describe Bigbluebutton::RoomsController do
       it("assigns join_desktop") { should assign_to(:join_desktop).with("http://test.com/join/url?desktop=1") }
       it { should render_template(:join_mobile) }
     end
+
+    context "doesn't override @room" do
+      let!(:other_room) { FactoryGirl.create(:bigbluebutton_room) }
+      before { controller.instance_variable_set(:@room, other_room) }
+      before(:each) { get :join_mobile, :id => room.to_param }
+      it { should assign_to(:room).with(other_room) }
+    end
   end
 
   describe "#create" do
@@ -105,7 +152,7 @@ describe Bigbluebutton::RoomsController do
       it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.notice.create.success')) }
       it {
         saved = BigbluebuttonRoom.last
-        saved.should have_same_attributes_as(new_room)
+        saved.should have_same_attributes_as(new_room, params_to_ignore)
       }
     end
 
@@ -151,7 +198,7 @@ describe Bigbluebutton::RoomsController do
       it {
         saved = BigbluebuttonRoom.last
         new_room.meetingid = new_room.name
-        saved.should have_same_attributes_as(new_room)
+        saved.should have_same_attributes_as(new_room, params_to_ignore)
       }
     end
 
@@ -159,10 +206,12 @@ describe Bigbluebutton::RoomsController do
       let(:attrs) { FactoryGirl.attributes_for(:bigbluebutton_room) }
       let(:params) { { :bigbluebutton_room => attrs } }
       let(:allowed_params) {
-        [ :name, :server_id, :meetingid, :attendee_password, :moderator_password, :welcome_msg,
+        [ :name, :server_id, :meetingid, :attendee_key, :moderator_key, :welcome_msg,
           :private, :logout_url, :dial_number, :voice_bridge, :max_participants, :owner_id,
-          :owner_type, :external, :param, :record, :duration, :default_layout, :presenter_share_only,
-          :auto_start_video, :auto_start_audio, :metadata_attributes => [ :id, :name, :content, :_destroy, :owner_id ] ]
+          :owner_type, :external, :param, :record_meeting, :duration, :default_layout, :presenter_share_only,
+          :auto_start_video, :auto_start_audio, :background,
+          :moderator_only_message, :auto_start_recording, :allow_start_stop_recording,
+          :metadata_attributes => [ :id, :name, :content, :_destroy, :owner_id ] ]
       }
 
       it {
@@ -187,6 +236,13 @@ describe Bigbluebutton::RoomsController do
         should render_template(:new)
       }
     end
+
+    context "doesn't override @room" do
+      let!(:other_room) { FactoryGirl.create(:bigbluebutton_room) }
+      before { controller.instance_variable_set(:@room, other_room) }
+      before(:each) { post :create, :bigbluebutton_room => new_room.attributes }
+      it { should assign_to(:room).with(other_room) }
+    end
   end
 
   describe "#update" do
@@ -206,7 +262,7 @@ describe Bigbluebutton::RoomsController do
       }
       it {
         saved = BigbluebuttonRoom.find(@room)
-        saved.should have_same_attributes_as(new_room)
+        saved.should have_same_attributes_as(new_room, params_to_ignore)
       }
       it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.notice.update.success')) }
     end
@@ -243,10 +299,12 @@ describe Bigbluebutton::RoomsController do
       let(:attrs) { FactoryGirl.attributes_for(:bigbluebutton_room) }
       let(:params) { { :bigbluebutton_room => attrs } }
       let(:allowed_params) {
-        [ :name, :server_id, :meetingid, :attendee_password, :moderator_password, :welcome_msg,
+        [ :name, :server_id, :meetingid, :attendee_key, :moderator_key, :welcome_msg,
           :private, :logout_url, :dial_number, :voice_bridge, :max_participants, :owner_id,
-          :owner_type, :external, :param, :record, :duration, :default_layout, :presenter_share_only,
-          :auto_start_video, :auto_start_audio, :metadata_attributes => [ :id, :name, :content, :_destroy, :owner_id ] ]
+          :owner_type, :external, :param, :record_meeting, :duration, :default_layout, :presenter_share_only,
+          :auto_start_video, :auto_start_audio, :background,
+          :moderator_only_message, :auto_start_recording, :allow_start_stop_recording,
+          :metadata_attributes => [ :id, :name, :content, :_destroy, :owner_id ] ]
       }
       it {
         # we just check that the rails method 'permit' is being called on the hash with the
@@ -269,19 +327,25 @@ describe Bigbluebutton::RoomsController do
         should redirect_to(bigbluebutton_room_path(@room))
       }
     end
+
+    context "doesn't override @room" do
+      let!(:other_room) { FactoryGirl.create(:bigbluebutton_room) }
+      before { controller.instance_variable_set(:@room, other_room) }
+      before(:each) { put :update, :id => @room.to_param, :bigbluebutton_room => new_room.attributes }
+      it { should assign_to(:room).with(other_room) }
+    end
   end
 
   describe "#destroy" do
-    before {
-      controller.should_receive(:set_request_headers)
-      mock_server_and_api
-      # to make sure it calls end_meeting if the meeting is running
-      mocked_api.should_receive(:is_meeting_running?).and_return(true)
-    }
-
     context "on success" do
+      before {
+        controller.should_receive(:set_request_headers)
+        mock_server_and_api
+        # to make sure it calls end_meeting if the meeting is running
+        mocked_api.should_receive(:is_meeting_running?).and_return(true)
+        mocked_api.should_receive(:end_meeting).with(room.meetingid, room.moderator_api_password)
+      }
       before(:each) {
-        mocked_api.should_receive(:end_meeting).with(room.meetingid, room.moderator_password)
         expect {
           delete :destroy, :id => room.to_param
         }.to change{ BigbluebuttonRoom.count }.by(-1)
@@ -294,6 +358,10 @@ describe Bigbluebutton::RoomsController do
       let(:bbb_error_msg) { SecureRandom.hex(250) }
       let(:bbb_error) { BigBlueButton::BigBlueButtonException.new(bbb_error_msg) }
       before {
+        controller.should_receive(:set_request_headers)
+        mock_server_and_api
+        # to make sure it calls end_meeting if the meeting is running
+        mocked_api.should_receive(:is_meeting_running?).and_return(true)
         mocked_api.should_receive(:end_meeting) { raise bbb_error }
       }
       before(:each) {
@@ -310,9 +378,15 @@ describe Bigbluebutton::RoomsController do
     end
 
     context "with :redir_url" do
+      before {
+        controller.should_receive(:set_request_headers)
+        mock_server_and_api
+        # to make sure it calls end_meeting if the meeting is running
+        mocked_api.should_receive(:is_meeting_running?).and_return(true)
+        mocked_api.should_receive(:end_meeting)
+      }
       before(:each) {
         expect {
-          mocked_api.should_receive(:end_meeting)
           delete :destroy, :id => room.to_param, :redir_url => "/any"
         }.to change{ BigbluebuttonRoom.count }.by(-1)
       }
@@ -320,6 +394,12 @@ describe Bigbluebutton::RoomsController do
       it { should redirect_to "/any" }
     end
 
+    context "doesn't override @room" do
+      let!(:other_room) { FactoryGirl.create(:bigbluebutton_room) }
+      before { controller.instance_variable_set(:@room, other_room) }
+      before(:each) { delete :destroy, :id => room.to_param }
+      it { should assign_to(:room).with(other_room) }
+    end
   end
 
   describe "#running" do
@@ -352,8 +432,22 @@ describe Bigbluebutton::RoomsController do
       it { should respond_with(:success) }
       it { should set_the_flash.to(bbb_error_msg[0..200]) }
     end
-  end
 
+    context "doesn't override @room" do
+      let!(:other_room) { FactoryGirl.create(:bigbluebutton_room) }
+      before {
+        controller.stub(:running)
+        controller.instance_variable_set(:@room, other_room)
+      }
+      before(:each) {
+        begin
+          get :running, :id => room.to_param
+        rescue ActionView::MissingTemplate
+        end
+        }
+      it { should assign_to(:room).with(other_room) }
+    end
+  end
 
   describe "#join" do
     let(:user) { FactoryGirl.build(:user) }
@@ -368,7 +462,7 @@ describe Bigbluebutton::RoomsController do
       context "via #{method}" do
 
         context "before filter #join_check_room" do
-          let(:user_hash) { { :name => "Elftor", :password => room.attendee_password } }
+          let(:user_hash) { { :name => "Elftor", :key => room.attendee_key } }
           let(:meetingid) { "my-meeting-id" }
 
           context "if params[:id]" do
@@ -392,12 +486,24 @@ describe Bigbluebutton::RoomsController do
             it { should redirect_to(http_referer) }
             it { should set_the_flash.to(message) }
           end
+
+          context "doesn't override @room" do
+            let!(:other_room) { FactoryGirl.create(:bigbluebutton_room) }
+            before {
+              controller.instance_variable_set(:@room, other_room)
+              other_room.stub(:fetch_is_running?).and_return(true)
+            }
+            before(:each) {
+              send(method, :join, :id => room.to_param, :user => user_hash)
+            }
+            it { should assign_to(:room).with(other_room) }
+          end
         end
 
         context "before filter #join_user_params" do
 
           context "block access if bigbluebutton_role returns nil" do
-            let(:hash) { { :name => "Elftor", :password => room.attendee_password } }
+            let(:hash) { { :name => "Elftor", :key => room.attendee_key } }
             before { controller.stub(:bigbluebutton_role) { nil } }
             it {
               lambda {
@@ -407,24 +513,24 @@ describe Bigbluebutton::RoomsController do
           end
 
           it "if there's a user logged, should use his name" do
-            controller.stub(:bigbluebutton_role) { :password }
-            hash = { :name => "Elftor", :password => room.attendee_password }
+            controller.stub(:bigbluebutton_role) { :key }
+            hash = { :name => "Elftor", :key => room.attendee_key }
             controller.stub(:bigbluebutton_user).and_return(user)
             mocked_api.should_receive(:is_meeting_running?).at_least(:once).and_return(true)
             mocked_api.should_receive(:join_meeting_url)
-              .with(room.meetingid, user.name, room.attendee_password, anything) # here's the validation
+              .with(room.meetingid, user.name, room.attendee_api_password, anything) # here's the validation
               .and_return("http://test.com/attendee/join")
             send(method, :join, :id => room.to_param, :user => hash)
           end
 
-          context "uses bigbluebutton_role when the return is not :password" do
-            let(:hash) { { :name => "Elftor", :password => nil } }
+          context "uses bigbluebutton_role when the return is not :key" do
+            let(:hash) { { :name => "Elftor", :key => nil } }
             before {
               controller.stub(:bigbluebutton_user).and_return(nil)
               controller.stub(:bigbluebutton_role) { :attendee }
               mocked_api.should_receive(:is_meeting_running?).at_least(:once).and_return(true)
               mocked_api.should_receive(:join_meeting_url)
-                .with(anything, anything, room.attendee_password, anything)
+                .with(anything, anything, room.attendee_api_password, anything)
                 .and_return("http://test.com/attendee/join")
             }
             before(:each) { send(method, :join, :id => room.to_param, :user => hash) }
@@ -438,12 +544,12 @@ describe Bigbluebutton::RoomsController do
           context "validates user input and shows error" do
             before {
               controller.stub(:bigbluebutton_user).and_return(nil)
-              controller.should_receive(:bigbluebutton_role).once { :password }
+              controller.should_receive(:bigbluebutton_role).once { :key }
             }
             before(:each) { send(method, :join, :id => room.to_param, :user => user_hash) }
 
             context "when name is not set" do
-              let(:user_hash) { { :password => room.moderator_password } }
+              let(:user_hash) { { :key => room.moderator_key } }
               it { should respond_with(:redirect) }
               it { should redirect_to(http_referer) }
               it { should assign_to(:room).with(room) }
@@ -454,7 +560,7 @@ describe Bigbluebutton::RoomsController do
             end
 
             context "when name is set but empty" do
-              let(:user_hash) { { :password => room.moderator_password, :name => "" } }
+              let(:user_hash) { { :key => room.moderator_key, :name => "" } }
               it { should respond_with(:redirect) }
               it { should redirect_to(http_referer) }
               it { should assign_to(:room).with(room) }
@@ -464,8 +570,8 @@ describe Bigbluebutton::RoomsController do
               it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.errors.join.failure')) }
             end
 
-            context "when the password is wrong" do
-              let(:user_hash) { { :name => "Elftor", :password => nil } }
+            context "when the key is wrong" do
+              let(:user_hash) { { :name => "Elftor", :key => nil } }
               it { should respond_with(:redirect) }
               it { should redirect_to(http_referer) }
               it { should assign_to(:user_role).with(nil) }
@@ -479,7 +585,7 @@ describe Bigbluebutton::RoomsController do
         end
 
         context "before filter #join_check_can_create" do
-          let(:user_hash) { { :password => room.moderator_password, :name => "Elftor" } }
+          let(:user_hash) { { :key => room.moderator_key, :name => "Elftor" } }
           before {
             controller.stub(:bigbluebutton_user).and_return(nil)
             controller.should_receive(:bigbluebutton_role).once { :moderator }
@@ -507,9 +613,8 @@ describe Bigbluebutton::RoomsController do
           context "in a mobile device with no flags set" do
             before {
               controller.stub(:bigbluebutton_role) { :moderator }
-              browser = double()
-              browser.should_receive(:mobile?).and_return(true)
-              controller.stub(:browser).and_return(browser)
+              controller.stub(:browser).and_return('my-browser')
+              BigbluebuttonRails.should_receive(:use_mobile_client?).with('my-browser').and_return(true)
             }
 
             context "with no parameters in the url" do
@@ -536,11 +641,8 @@ describe Bigbluebutton::RoomsController do
             before {
               controller.stub(:bigbluebutton_user) { user }
               controller.stub(:bigbluebutton_role) { :moderator }
-
-              # make sure it's in a mobile device
-              browser = double()
-              browser.should_receive(:mobile?).and_return(true)
-              controller.stub(:browser).and_return(browser)
+              controller.stub(:browser).and_return('my-browser')
+              BigbluebuttonRails.should_receive(:use_mobile_client?).with('my-browser').and_return(true)
 
               # here's the real verification
               controller.should_receive(:join_internal).with(user.name, :moderator, user.id)
@@ -552,11 +654,8 @@ describe Bigbluebutton::RoomsController do
             before {
               controller.stub(:bigbluebutton_user) { user }
               controller.stub(:bigbluebutton_role) { :moderator }
-
-              # make sure it's in a mobile device
-              browser = double()
-              browser.should_receive(:mobile?).and_return(true)
-              controller.stub(:browser).and_return(browser)
+              controller.stub(:browser).and_return('my-browser')
+              BigbluebuttonRails.should_receive(:use_mobile_client?).with('my-browser').and_return(true)
 
               # here's the real verification
               controller.should_receive(:join_internal).with(user.name, :moderator, user.id)
@@ -593,7 +692,7 @@ describe Bigbluebutton::RoomsController do
     context "room is running" do
       before {
         mocked_api.should_receive(:is_meeting_running?).and_return(true)
-        mocked_api.should_receive(:end_meeting).with(room.meetingid, room.moderator_password)
+        mocked_api.should_receive(:end_meeting).with(room.meetingid, room.moderator_api_password)
       }
       before(:each) { get :end, :id => room.to_param }
       it { should respond_with(:redirect) }
@@ -606,7 +705,7 @@ describe Bigbluebutton::RoomsController do
     context "with :redir_url" do
       before {
         mocked_api.should_receive(:is_meeting_running?).and_return(true)
-        mocked_api.should_receive(:end_meeting).with(room.meetingid, room.moderator_password)
+        mocked_api.should_receive(:end_meeting).with(room.meetingid, room.moderator_api_password)
       }
       before(:each) { get :end, :id => room.to_param, :redir_url => '/any' }
       it { should respond_with(:redirect) }
@@ -631,6 +730,16 @@ describe Bigbluebutton::RoomsController do
       it { should respond_with(:redirect) }
       it { should set_the_flash.to(bbb_error_msg[0..200]) }
     end
+
+    context "doesn't override @room" do
+      let!(:other_room) { FactoryGirl.create(:bigbluebutton_room) }
+      before {
+        controller.instance_variable_set(:@room, other_room)
+        other_room.stub(:fetch_is_running?).and_return(true)
+      }
+      before(:each) { get :end, :id => room.to_param }
+      it { should assign_to(:room).with(other_room) }
+    end
   end
 
   describe "#invite" do
@@ -648,13 +757,13 @@ describe Bigbluebutton::RoomsController do
     end
 
     context "when the user's role" do
-      context "should be defined with a password" do
-        before { controller.stub(:bigbluebutton_role) { :password } }
+      context "should be defined with a key" do
+        before { controller.stub(:bigbluebutton_role) { :key } }
         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) }
-        it { should assign_to(:user_role).with(:password) }
+        it { should assign_to(:user_role).with(:key) }
       end
 
       context "is undefined, the access should be blocked" do
@@ -666,12 +775,18 @@ describe Bigbluebutton::RoomsController do
         }
       end
     end
+
+    context "doesn't override @room" do
+      let!(:other_room) { FactoryGirl.create(:bigbluebutton_room) }
+      before { controller.instance_variable_set(:@room, other_room) }
+      before(:each) { get :invite, :id => room.to_param }
+      it { should assign_to(:room).with(other_room) }
+    end
   end
 
   describe "#fetch_recordings" do
     # setup basic server and API mocks
     before do
-      #controller.should_receive(:set_request_headers)
       mock_server_and_api
     end
     let(:filter) {
@@ -729,6 +844,15 @@ describe Bigbluebutton::RoomsController do
       end
     end
 
+    context "doesn't override @room" do
+      let!(:other_room) { FactoryGirl.create(:bigbluebutton_room) }
+      before {
+        controller.instance_variable_set(:@room, other_room)
+        other_room.server = nil
+      }
+      before(:each) { post :fetch_recordings, :id => room.to_param }
+      it { should assign_to(:room).with(other_room) }
+    end
   end
 
   describe "#recordings" do
@@ -747,6 +871,51 @@ describe Bigbluebutton::RoomsController do
     it { should assign_to(:recordings).with([@recording1, @recording2]) }
   end
 
+  describe "#generate_dial_number" do
+    let(:http_referer) { bigbluebutton_room_path(room) }
+    before {
+      request.env["HTTP_REFERER"] = http_referer
+    }
+
+    context "on success" do
+      before(:each) {
+        BigbluebuttonRoom.any_instance.stub(:generate_dial_number!).and_return(true)
+        post :generate_dial_number, id: room.to_param
+      }
+      it { should respond_with(:redirect) }
+      it { should redirect_to(http_referer) }
+      it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.notice.generate_dial_number.success')) }
+    end
+
+    context "on error" do
+      before(:each) {
+        BigbluebuttonRoom.any_instance.stub(:generate_dial_number!).and_return(nil)
+        post :generate_dial_number, id: room.to_param
+      }
+      it { should respond_with(:redirect) }
+      it { should redirect_to(http_referer) }
+      it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.errors.generate_dial_number.not_unique')) }
+    end
+
+    context "uses params[:pattern]" do
+      before(:each) {
+        BigbluebuttonRoom.any_instance.stub(:generate_dial_number!).with("xxx-xxx").and_return(true)
+        post :generate_dial_number, id: room.to_param, pattern: "xxx-xxx"
+      }
+      it { should respond_with(:redirect) }
+      it { should redirect_to(http_referer) }
+    end
+
+    context "doesn't use params[:pattern] if it's blank" do
+      before(:each) {
+        BigbluebuttonRoom.any_instance.stub(:generate_dial_number!).with(nil).and_return(true)
+        post :generate_dial_number, id: room.to_param, pattern: ""
+      }
+      it { should respond_with(:redirect) }
+      it { should redirect_to(http_referer) }
+    end
+  end
+
   describe "before filter :set_request_headers" do
     let(:headers) { {"x-forwarded-for" => "0.0.0.0"} }
     let(:make_request) {  }
@@ -771,6 +940,26 @@ describe Bigbluebutton::RoomsController do
         room.request_headers.should == headers
       }
     end
+
+    context "doesn't override @room" do
+      let!(:other_room) { FactoryGirl.create(:bigbluebutton_room) }
+      before { controller.instance_variable_set(:@room, other_room) }
+      before(:each) { get :recordings, :id => room.to_param }
+      it { should assign_to(:room).with(other_room) }
+    end
+
+    context "doesn't override @recordings" do
+      let!(:my_recordings) {
+        [ FactoryGirl.create(:bigbluebutton_recording, room: room),
+          FactoryGirl.create(:bigbluebutton_recording, room: room) ]
+      }
+      before {
+        3.times { FactoryGirl.create(:bigbluebutton_recording, room: room) }
+        controller.instance_variable_set(:@recordings, my_recordings)
+      }
+      before(:each) { get :recordings, :id => room.to_param }
+      it { should assign_to(:recordings).with(my_recordings) }
+    end
   end
 
   # Test #join_internal using #join because it's easier and cleaner than the other
@@ -796,11 +985,11 @@ describe Bigbluebutton::RoomsController do
         room.should_receive(:create_meeting)
           .with(user, controller.request, { custom: true })
         room.should_receive(:fetch_new_token).and_return(nil)
-        room.should_receive(:join_url).and_return("http://test.com/join/url")
+        room.should_receive(:join_url).and_return("http://test.com/join/url/")
       }
       before(:each) { get :join, :id => room.to_param }
       it { should respond_with(:redirect) }
-      it { should redirect_to("http://test.com/join/url") }
+      it { should redirect_to("http://test.com/join/url/") }
     end
 
     context "when the user doesn't have permission to create the meeting" do
@@ -856,7 +1045,7 @@ describe Bigbluebutton::RoomsController do
           room.should_receive(:fetch_new_token).and_return('fake-token')
           room.should_receive(:join_url)
             .with(user.name, :attendee, nil, hash_including(:configToken  => 'fake-token'))
-            .and_return("http://test.com/join/url")
+            .and_return("http://test.com/join/url/")
         }
         it("uses the token") { get :join, :id => room.to_param }
       end
@@ -865,13 +1054,87 @@ describe Bigbluebutton::RoomsController do
         before(:each) {
           room.should_receive(:fetch_new_token).and_return(nil)
           room.should_receive(:join_url)
-            .with(user.name, :attendee, nil, {})
-            .and_return("http://test.com/join/url")
+            .with(user.name, :attendee, nil, hash_not_including(:configToken))
+            .and_return("http://test.com/join/url/")
         }
         it("does not use the token") { get :join, :id => room.to_param }
       end
     end
 
+    context "pass createTime parameter to join_url" do
+      let(:time) { DateTime.now }
+      before {
+        room.should_receive(:fetch_is_running?).at_least(:once).and_return(true)
+        room.should_not_receive(:create_meeting)
+      }
+
+      context "if the createTime is not blank" do
+        before(:each) {
+          room.stub(:create_time).and_return(time)
+          room.should_receive(:fetch_new_token).and_return(anything)
+          room.should_receive(:join_url)
+            .with(user.name, :attendee, nil, hash_including(:createTime => time))
+        }
+        it ("uses the createTime") { get :join, :id => room.to_param }
+      end
+
+      context "if the createTime is blank" do
+        before(:each) {
+          room.stub(:create_time).and_return("")
+          room.should_receive(:fetch_new_token).and_return(anything)
+          room.should_receive(:join_url)
+            .with(user.name, :attendee, nil, hash_not_including(:createTime))
+        }
+        it ("does not use the createTime") { get :join, :id => room.to_param }
+      end
+
+      context "if the createTime is nil" do
+        before(:each) {
+          room.stub(:create_time).and_return(nil)
+          room.should_receive(:fetch_new_token).and_return(anything)
+          room.should_receive(:join_url)
+            .with(user.name, :attendee, nil, hash_not_including(:createTime))
+        }
+        it ("does not use the createTime") { get :join, :id => room.to_param }
+      end
+    end
+
+    context "pass userID to join url" do
+      before {
+        room.should_receive(:fetch_is_running?).at_least(:once).and_return(true)
+        room.should_not_receive(:create_meeting)
+      }
+
+      context "userID is nil" do
+        before(:each) {
+          user.id = nil
+          room.should_receive(:fetch_new_token).and_return(anything)
+          room.should_receive(:join_url)
+            .with(user.name, :attendee, nil, hash_not_including(:userID))
+        }
+        it("does not use the userID") { get :join, :id => room.to_param }
+      end
+
+      context "userID is blank" do
+        before(:each) {
+          user.id = ""
+          room.should_receive(:fetch_new_token).and_return(anything)
+          room.should_receive(:join_url)
+            .with(user.name, :attendee, nil, hash_not_including(:userID))
+        }
+        it("does not use the userID") { get :join, :id => room.to_param }
+      end
+
+      context "userID is not blank" do
+        before(:each) {
+          room.should_receive(:fetch_new_token).and_return(anything)
+          room.should_receive(:join_url)
+            .with(user.name, :attendee, nil, hash_including(:userID => user.id))
+        }
+        it("uses the userID") { get :join, :id => room.to_param }
+      end
+    end
+
     context "when the user doesn't have permission to join the meeting" do
       before {
         room.should_receive(:fetch_is_running?).at_least(:once).and_return(true)
@@ -892,9 +1155,7 @@ describe Bigbluebutton::RoomsController do
         room.should_receive(:fetch_is_running?).at_least(:once).and_return(true)
         room.should_not_receive(:create_meeting)
         room.should_receive(:fetch_new_token).and_return(nil)
-        browser = double()
-        browser.should_receive(:mobile?).twice.and_return(true)
-        controller.stub(:browser).and_return(browser)
+        BigbluebuttonRails.stub(:use_mobile_client?).and_return(true)
       }
 
       context "and the url uses 'http'" do