bigbluebutton_rails 1.4.0 → 2.0.0

data/spec/models/bigbluebutton_room_db_spec.rb

@@ -9,8 +9,10 @@ describe BigbluebuttonRoom do
     it { should have_db_column(:owner_type).of_type(:string) }
     it { should have_db_column(:meetingid).of_type(:string) }
     it { should have_db_column(:name).of_type(:string) }
-    it { should have_db_column(:attendee_password).of_type(:string) }
-    it { should have_db_column(:moderator_password).of_type(:string) }
+    it { should have_db_column(:attendee_key).of_type(:string) }
+    it { should have_db_column(:moderator_key).of_type(:string) }
+    it { should have_db_column(:attendee_api_password).of_type(:string) }
+    it { should have_db_column(:moderator_api_password).of_type(:string) }
     it { should have_db_column(:welcome_msg).of_type(:string) }
     it { should have_db_column(:dial_number).of_type(:string) }
     it { should have_db_column(:logout_url).of_type(:string) }
@@ -19,17 +21,17 @@ describe BigbluebuttonRoom do
     it { should have_db_column(:private).of_type(:boolean) }
     it { should have_db_column(:external).of_type(:boolean) }
     it { should have_db_column(:param).of_type(:string) }
-    it { should have_db_column(:record).of_type(:boolean) }
+    it { should have_db_column(:record_meeting).of_type(:boolean) }
     it { should have_db_column(:duration).of_type(:integer) }
     it { should have_db_column(:created_at).of_type(:datetime) }
     it { should have_db_column(:updated_at).of_type(:datetime) }
+    it { should have_db_column(:create_time).of_type(:integer) }
     it { should have_db_index(:server_id) }
     it { should have_db_index(:meetingid).unique(true) }
-    it { should have_db_index(:voice_bridge).unique(true) }
     it "default values" do
       room = BigbluebuttonRoom.new
-      room.private.should be_false
-      room.external.should be_false
+      room.private.should be_falsey
+      room.external.should be_falsey
       room.meetingid.should_not be_nil
     end
   end

data/spec/models/bigbluebutton_room_options_db_spec.rb

@@ -11,6 +11,7 @@ describe BigbluebuttonRoomOptions do
     it { should have_db_column(:presenter_share_only).of_type(:boolean)}
     it { should have_db_column(:auto_start_video).of_type(:boolean) }
     it { should have_db_column(:auto_start_audio).of_type(:boolean) }
+    it { should have_db_column(:background).of_type(:string) }
   end
 
 end

data/spec/models/bigbluebutton_room_options_spec.rb

@@ -15,13 +15,6 @@ describe BigbluebuttonRoomOptions do
       .room.should be_a_kind_of(BigbluebuttonRoom) }
   it { should validate_presence_of(:room_id) }
 
-  describe "#get_available_layouts" do
-    it "returns the layouts available" do
-      expected = ["Default", "Video Chat", "Meeting", "Webinar", "Lecture assistant", "Lecture"]
-      room_options.get_available_layouts.should eql(expected)
-    end
-  end
-
   describe "#set_on_config_xml" do
     let(:config_xml) { '<config></config>' }
 
@@ -31,7 +24,8 @@ describe BigbluebuttonRoomOptions do
         room_options.update_attributes(:default_layout => "AnyLayout",
                                        :presenter_share_only => true,
                                        :auto_start_video => false,
-                                       :auto_start_audio => false)
+                                       :auto_start_audio => false,
+                                       :background => "http://mconf.org/anything")
         BigBlueButton::BigBlueButtonConfigXml.any_instance
           .should_receive(:set_attribute)
           .with('layout', 'defaultLayout', "AnyLayout", false)
@@ -47,6 +41,9 @@ describe BigbluebuttonRoomOptions do
         BigBlueButton::BigBlueButtonConfigXml.any_instance
           .should_receive(:set_attribute)
           .with('PhoneModule', 'autoJoin', false, true)
+        BigBlueButton::BigBlueButtonConfigXml.any_instance
+          .should_receive(:set_attribute)
+          .with('branding', 'background', "http://mconf.org/anything", false)
         BigBlueButton::BigBlueButtonConfigXml.any_instance
           .should_receive(:is_modified?).and_return(true)
         BigBlueButton::BigBlueButtonConfigXml.any_instance
@@ -58,33 +55,26 @@ describe BigbluebuttonRoomOptions do
 
     context "if the xml did not change" do
       before {
-        room_options.update_attributes(:default_layout => "AnyLayout",
-                                       :presenter_share_only => false,
-                                       :auto_start_video => false,
-                                       :auto_start_audio => false)
-        BigBlueButton::BigBlueButtonConfigXml.any_instance
-          .should_receive(:set_attribute)
-          .with('layout', 'defaultLayout', "AnyLayout", false)
-        BigBlueButton::BigBlueButtonConfigXml.any_instance
-          .should_receive(:set_attribute)
-          .with('VideoconfModule', 'presenterShareOnly', false, true)
-        BigBlueButton::BigBlueButtonConfigXml.any_instance
-          .should_receive(:set_attribute)
-          .with('PhoneModule', 'presenterShareOnly', false, true)
-        BigBlueButton::BigBlueButtonConfigXml.any_instance
-          .should_receive(:set_attribute)
-          .with('VideoconfModule', 'autoStart', false, true)
-        BigBlueButton::BigBlueButtonConfigXml.any_instance
-          .should_receive(:set_attribute)
-          .with('PhoneModule', 'autoJoin', false, true)
-        BigBlueButton::BigBlueButtonConfigXml.any_instance
+        BigBlueButton::BigBlueButtonConfigXml.stub(:set_attribute)
+
+       BigBlueButton::BigBlueButtonConfigXml.any_instance
           .should_receive(:is_modified?).and_return(false)
       }
       subject { room_options.set_on_config_xml(config_xml) }
-      it("returns false") { should be_false }
+      it("returns false") { should be(false) }
     end
 
     context "if #default_layout is" do
+      context "a valid string" do
+        before {
+          room_options.update_attributes(:default_layout => "my layout")
+          BigBlueButton::BigBlueButtonConfigXml.any_instance
+            .should_receive(:set_attribute)
+            .with('layout', 'defaultLayout', "my layout", anything)
+        }
+        it("sets the property in the xml") { room_options.set_on_config_xml(config_xml) }
+      end
+
       context "nil" do
         before {
           room_options.update_attributes(:default_layout => nil)
@@ -119,6 +109,32 @@ describe BigbluebuttonRoomOptions do
         }
         it("doesn't set the property in the xml") { room_options.set_on_config_xml(config_xml) }
       end
+
+      context "true" do
+        before {
+          room_options.update_attributes(:presenter_share_only => true)
+          BigBlueButton::BigBlueButtonConfigXml.any_instance
+            .should_receive(:set_attribute)
+            .with('VideoconfModule', 'presenterShareOnly', true, anything)
+          BigBlueButton::BigBlueButtonConfigXml.any_instance
+            .should_receive(:set_attribute)
+            .with('PhoneModule', 'presenterShareOnly', true, anything)
+        }
+        it("sets the property in the xml") { room_options.set_on_config_xml(config_xml) }
+      end
+
+      context "false" do
+        before {
+          room_options.update_attributes(:presenter_share_only => false)
+          BigBlueButton::BigBlueButtonConfigXml.any_instance
+            .should_receive(:set_attribute)
+            .with('VideoconfModule', 'presenterShareOnly', false, anything)
+          BigBlueButton::BigBlueButtonConfigXml.any_instance
+            .should_receive(:set_attribute)
+            .with('PhoneModule', 'presenterShareOnly', false, anything)
+        }
+        it("sets the property in the xml") { room_options.set_on_config_xml(config_xml) }
+      end
     end
 
     context "if #auto_start_video is" do
@@ -131,6 +147,26 @@ describe BigbluebuttonRoomOptions do
         }
         it("doesn't set the property in the xml") { room_options.set_on_config_xml(config_xml) }
       end
+
+      context "true" do
+        before {
+          room_options.update_attributes(:auto_start_video => true)
+          BigBlueButton::BigBlueButtonConfigXml.any_instance
+            .should_receive(:set_attribute)
+            .with('VideoconfModule', 'autoStart', true, anything)
+        }
+        it("sets the property in the xml") { room_options.set_on_config_xml(config_xml) }
+      end
+
+      context "false" do
+        before {
+          room_options.update_attributes(:auto_start_video => false)
+          BigBlueButton::BigBlueButtonConfigXml.any_instance
+            .should_receive(:set_attribute)
+            .with('VideoconfModule', 'autoStart', false, anything)
+        }
+        it("sets the property in the xml") { room_options.set_on_config_xml(config_xml) }
+      end
     end
 
     context "if #auto_start_audio is" do
@@ -143,63 +179,126 @@ describe BigbluebuttonRoomOptions do
         }
         it("doesn't set the property in the xml") {room_options.set_on_config_xml(config_xml) }
       end
+
+      context "true" do
+        before {
+          room_options.update_attributes(:auto_start_audio => true)
+          BigBlueButton::BigBlueButtonConfigXml.any_instance
+            .should_receive(:set_attribute)
+            .with('PhoneModule', 'autoJoin', true, anything)
+        }
+        it("sets the property in the xml") {room_options.set_on_config_xml(config_xml) }
+      end
+
+      context "false" do
+        before {
+          room_options.update_attributes(:auto_start_audio => false)
+          BigBlueButton::BigBlueButtonConfigXml.any_instance
+            .should_receive(:set_attribute)
+            .with('PhoneModule', 'autoJoin', false, anything)
+        }
+        it("sets the property in the xml") {room_options.set_on_config_xml(config_xml) }
+      end
     end
 
+    context "if #background is" do
+      context "a valid string" do
+        before {
+          room_options.update_attributes(:background => "my background")
+          BigBlueButton::BigBlueButtonConfigXml.any_instance
+            .should_receive(:set_attribute)
+            .with('branding', 'background', 'my background', anything)
+        }
+        it("sets the property in the xml") { room_options.set_on_config_xml(config_xml) }
+      end
+
+      context "nil" do
+        before {
+          room_options.update_attributes(:background => nil)
+          BigBlueButton::BigBlueButtonConfigXml.any_instance
+            .should_not_receive(:set_attribute)
+            .with('branding', 'background', anything, anything)
+        }
+        it("doesn't set the property in the xml") {room_options.set_on_config_xml(config_xml) }
+      end
+
+      context "empty string" do
+        before {
+          room_options.update_attributes(:background => "")
+          BigBlueButton::BigBlueButtonConfigXml.any_instance
+            .should_not_receive(:set_attribute)
+            .with('branding', 'background', anything, anything)
+        }
+        it("doesn't set the property in the xml") { room_options.set_on_config_xml(config_xml) }
+      end
+    end
   end
 
   describe "#is_modified?" do
     context "if default_layout is set" do
       before { room_options.update_attributes(:default_layout => 'Any') }
       subject { room_options.is_modified? }
-      it("returns true") { should be_true }
+      it { should be(true) }
     end
 
     context "if default_layout is not set" do
       before { room_options.update_attributes(:default_layout => nil) }
       subject { room_options.is_modified? }
-      it("returns false") { should be_false }
+      it { should be(false) }
     end
 
     context "if default_layout is empty" do
       before { room_options.update_attributes(:default_layout => "") }
       subject { room_options.is_modified? }
-      it("returns true") { should be_true }
+      it { should be(false) }
     end
 
     context "if presenter_share_only is set" do
       before { room_options.update_attributes(:presenter_share_only => true) }
       subject { room_options.is_modified? }
-      it("returns true") { should be_true}
+      it { should be(true) }
     end
 
     context "if presenter_share_only is not set" do
       before { room_options.update_attributes(:presenter_share_only => nil) }
       subject { room_options.is_modified? }
-      it("returns false") { should be_false }
+      it { should be(false) }
     end
 
     context "if auto_start_video is set" do
       before { room_options.update_attributes(:auto_start_video => true) }
       subject { room_options.is_modified? }
-      it("returns true") { should be_true}
+      it { should be(true) }
     end
 
     context "if auto_start_video is not set" do
       before { room_options.update_attributes(:auto_start_video => nil) }
       subject { room_options.is_modified? }
-      it("returns false" ) { should be_false }
+      it { should be(false) }
     end
 
     context "if auto_start_audio is set" do
       before { room_options.update_attributes(:auto_start_audio => true) }
       subject { room_options.is_modified? }
-      it("returns true") { should be_true}
+      it { should be(true) }
     end
 
     context "if auto_start_audio is not set" do
       before { room_options.update_attributes(:auto_start_audio => nil) }
       subject { room_options.is_modified? }
-      it("returns false" ) { should be_false }
+      it { should be(false) }
+    end
+
+    context "if background is set" do
+      before { room_options.update_attributes(:background => true) }
+      subject { room_options.is_modified? }
+      it { should be(true) }
+    end
+
+    context "if background is not set" do
+      before { room_options.update_attributes(:background => nil) }
+      subject { room_options.is_modified? }
+      it { should be(false) }
     end
   end
 

data/spec/models/bigbluebutton_room_spec.rb

@@ -33,17 +33,14 @@ describe BigbluebuttonRoom do
   it { should delegate(:auto_start_audio).to(:room_options) }
   it { should delegate(:"auto_start_audio=").to(:room_options) }
 
-  it { should delegate(:get_available_layouts).to(:room_options) }
+  it { should delegate(:background).to(:room_options) }
+  it { should delegate(:"background=").to(:room_options) }
 
   it { should validate_presence_of(:meetingid) }
   it { should validate_uniqueness_of(:meetingid) }
   it { should ensure_length_of(:meetingid).is_at_least(1).is_at_most(100) }
 
-  it { should validate_presence_of(:voice_bridge) }
-  it { should validate_uniqueness_of(:voice_bridge) }
-
   it { should validate_presence_of(:name) }
-  it { should validate_uniqueness_of(:name) }
   it { should ensure_length_of(:name).is_at_least(1).is_at_most(150) }
 
   it { should validate_presence_of(:param) }
@@ -52,7 +49,7 @@ describe BigbluebuttonRoom do
 
   it { should be_boolean(:private) }
 
-  it { should be_boolean(:record) }
+  it { should be_boolean(:record_meeting) }
 
   it { should validate_presence_of(:duration) }
   it { should validate_numericality_of(:duration).only_integer }
@@ -60,9 +57,9 @@ describe BigbluebuttonRoom do
   it { should allow_value(0).for(:duration) }
   it { should allow_value(1).for(:duration) }
 
-  it { should ensure_length_of(:attendee_password).is_at_most(16) }
+  it { should ensure_length_of(:attendee_key).is_at_most(16) }
 
-  it { should ensure_length_of(:moderator_password).is_at_most(16) }
+  it { should ensure_length_of(:moderator_key).is_at_most(16) }
 
   it { should ensure_length_of(:welcome_msg).is_at_most(250) }
 
@@ -71,7 +68,7 @@ describe BigbluebuttonRoom do
   # attr_accessors
   [:running, :participant_count, :moderator_count, :attendees,
    :has_been_forcibly_ended, :start_time, :end_time, :external,
-   :server, :request_headers, :record, :duration].each do |attr|
+   :server, :request_headers, :record_meeting, :duration].each do |attr|
     it { should respond_to(attr) }
     it { should respond_to("#{attr}=") }
   end
@@ -87,13 +84,13 @@ describe BigbluebuttonRoom do
   it { should respond_to(:is_running?) }
 
   describe "#user_role" do
-    let(:room) { FactoryGirl.build(:bigbluebutton_room, :moderator_password => "mod", :attendee_password => "att") }
+    let(:room) { FactoryGirl.build(:bigbluebutton_room, :moderator_key => "mod", :attendee_key => "att") }
     it { should respond_to(:user_role) }
-    it { room.user_role({ :password => room.moderator_password }).should == :moderator }
-    it { room.user_role({ :password => room.attendee_password }).should == :attendee }
-    it { room.user_role({ :password => "wrong" }).should == nil }
-    it { room.user_role({ :password => nil }).should == nil }
-    it { room.user_role({ :not_password => "any" }).should == nil }
+    it { room.user_role({ :key => room.moderator_key }).should == :moderator }
+    it { room.user_role({ :key => room.attendee_key }).should == :attendee }
+    it { room.user_role({ :key => "wrong" }).should == nil }
+    it { room.user_role({ :key => nil }).should == nil }
+    it { room.user_role({ :not_key => "any" }).should == nil }
     it { room.user_role({ }).should == nil }
     it { room.user_role(nil).should == nil }
   end
@@ -119,18 +116,18 @@ describe BigbluebuttonRoom do
     let(:room) { BigbluebuttonRoom.last }
     let(:room2) { BigbluebuttonRoom.last }
     it { should respond_to(:attr_equal?) }
-    it { room.attr_equal?(room2).should be_true }
+    it { room.attr_equal?(room2).should be_truthy }
     it "differentiates instance variables" do
       room2.running = !room.running
-      room.attr_equal?(room2).should be_false
+      room.attr_equal?(room2).should be(false)
     end
     it "differentiates attributes" do
       room2.private = !room.private
-      room.attr_equal?(room2).should be_false
+      room.attr_equal?(room2).should be(false)
     end
     it "differentiates objects" do
       room2 = room.dup
-      room.attr_equal?(room2).should be_false
+      room.attr_equal?(room2).should be(false)
     end
   end
 
@@ -140,8 +137,8 @@ describe BigbluebuttonRoom do
     it "fetched attributes before they are fetched" do
       room.participant_count.should be(0)
       room.moderator_count.should be(0)
-      room.running.should be_false
-      room.has_been_forcibly_ended.should be_false
+      room.running.should be(false)
+      room.has_been_forcibly_ended.should be(false)
       room.start_time.should be_nil
       room.end_time.should be_nil
       room.attendees.should eql([])
@@ -155,25 +152,7 @@ describe BigbluebuttonRoom do
         b.meetingid.should == "user defined"
       }
     end
-
-    context "voice_bridge" do
-      it {
-        b = BigbluebuttonRoom.new(:voice_bridge => "user defined")
-        b.voice_bridge.should == "user defined"
-      }
-      context "with a random value" do
-        it { room.voice_bridge.should_not be_nil }
-        it { room.voice_bridge.should =~ /7[0-9]{4}/ }
-        it "tries to randomize 10 times if voice_bridge already exists" do
-          room = FactoryGirl.create(:bigbluebutton_room, :voice_bridge => "70000")
-          BigbluebuttonRoom.stub(:find_by_voice_bridge).and_return(room)
-          SecureRandom.should_receive(:random_number).exactly(10).and_return(0000)
-          room2 = BigbluebuttonRoom.new # triggers the random_number calls
-          room2.voice_bridge.should == "70000"
-        end
-      end
-    end
-  end
+   end
 
   describe "#room_options" do
     it "is created when the room is created" do
@@ -192,12 +171,12 @@ describe BigbluebuttonRoom do
       }
       it { @room.room_options.should_not be_nil }
       it("is not promptly saved") {
-        @room.room_options.new_record?.should be_true
+        @room.room_options.new_record?.should be(true)
       }
       it("is saved when the room is saved") {
         @room.save!
         @room.reload
-        @room.room_options.new_record?.should be_false
+        @room.room_options.new_record?.should be(false)
       }
     end
   end
@@ -226,7 +205,7 @@ describe BigbluebuttonRoom do
 
   context "sets param as the downcased parameterized name if param is" do
     after :each do
-      @room.save.should be_true
+      @room.save.should be_truthy
       @room.param.should == @room.name.downcase.parameterize
     end
     it "nil" do
@@ -240,18 +219,18 @@ describe BigbluebuttonRoom do
   end
 
   context "when room set to private" do
-    context "sets passwords that are not yet defined" do
-      let(:room) { FactoryGirl.create(:bigbluebutton_room, :private => false, :moderator_password => nil, :attendee_password => nil) }
+    context "sets keys that are not yet defined" do
+      let(:room) { FactoryGirl.create(:bigbluebutton_room, :private => false, :moderator_key => nil, :attendee_key => nil) }
       before(:each) { room.update_attributes(:private => true) }
-      it { room.moderator_password.should_not be_nil }
-      it { room.attendee_password.should_not be_nil }
+      it { room.moderator_key.should_not be_nil }
+      it { room.attendee_key.should_not be_nil }
     end
 
-    context "only sets the passwords if the room was public before" do
-      let(:room) { FactoryGirl.create(:bigbluebutton_room, :private => true, :moderator_password => "123", :attendee_password => "321") }
+    context "only sets the keys if the room was public before" do
+      let(:room) { FactoryGirl.create(:bigbluebutton_room, :private => true, :moderator_key => "123", :attendee_key => "321") }
       before(:each) { room.update_attributes(:private => true) }
-      it { room.moderator_password.should == "123" }
-      it { room.attendee_password.should == "321" }
+      it { room.moderator_key.should == "123" }
+      it { room.attendee_key.should == "321" }
     end
   end
 
@@ -270,9 +249,9 @@ describe BigbluebuttonRoom do
           room.server = mocked_server
         }
         before(:each) { @response = room.fetch_is_running? }
-        it { room.running.should be_false }
-        it { room.is_running?.should be_false }
-        it { @response.should be_false }
+        it { room.running.should be(false) }
+        it { room.is_running?.should be(false) }
+        it { @response.should be(false) }
       end
 
       context "fetches 'running' when running" do
@@ -282,9 +261,9 @@ describe BigbluebuttonRoom do
           room.server = mocked_server
         }
         before(:each) { @response = room.fetch_is_running? }
-        it { room.running.should be_true }
-        it { room.is_running?.should be_true }
-        it { @response.should be_true }
+        it { room.running.should be_truthy }
+        it { room.is_running?.should be_truthy }
+        it { @response.should be_truthy }
       end
 
     end
@@ -326,7 +305,7 @@ describe BigbluebuttonRoom do
       context "fetches meeting info when the meeting is not running" do
         before {
           mocked_api.should_receive(:get_meeting_info).
-            with(room.meetingid, room.moderator_password).and_return(hash_info)
+            with(room.meetingid, room.moderator_api_password).and_return(hash_info)
           room.should_receive(:require_server)
           room.server = mocked_server
         }
@@ -343,7 +322,7 @@ describe BigbluebuttonRoom do
       context "fetches meeting info when the meeting is running" do
         before {
           mocked_api.should_receive(:get_meeting_info).
-            with(room.meetingid, room.moderator_password).and_return(hash_info2)
+            with(room.meetingid, room.moderator_api_password).and_return(hash_info2)
           room.should_receive(:require_server)
           room.server = mocked_server
         }
@@ -366,7 +345,7 @@ describe BigbluebuttonRoom do
       context "calls #update_current_meeting after the information is fetched" do
         before {
           mocked_api.should_receive(:get_meeting_info).
-            with(room.meetingid, room.moderator_password).and_return(hash_info2)
+            with(room.meetingid, room.moderator_api_password).and_return(hash_info2)
           room.should_receive(:require_server)
           room.server = mocked_server
 
@@ -382,7 +361,7 @@ describe BigbluebuttonRoom do
 
       context "calls end_meeting" do
         before {
-          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)
           room.should_receive(:require_server)
           room.server = mocked_server
         }
@@ -404,15 +383,19 @@ describe BigbluebuttonRoom do
     end
 
     describe "#send_create" do
-      let(:attendee_password) { Forgery(:basic).password }
-      let(:moderator_password) { Forgery(:basic).password }
+      let(:time) { 1409531761442 }
+      let(:new_moderator_api_password) { Forgery(:basic).password }
+      let(:new_attendee_api_password) { Forgery(:basic).password }
+      let(:voice_bridge) { SecureRandom.random_number(99999) }
       let(:hash_create) {
         {
           :returncode => "SUCCESS", :meetingID => "test_id",
-          :attendeePW => attendee_password, :moderatorPW => moderator_password,
+          :attendeePW => new_attendee_api_password, :moderatorPW => new_moderator_api_password,
+          :voiceBridge => voice_bridge, :createTime => time,
           :hasBeenForciblyEnded => "false", :messageKey => {}, :message => {}
         }
       }
+      let(:expected_params) { get_create_params(room) }
       before {
         room.update_attributes(:welcome_msg => "Anything")
         FactoryGirl.create(:bigbluebutton_room_metadata, :owner => room)
@@ -441,80 +424,223 @@ describe BigbluebuttonRoom do
         end
       end
 
+      context "sets the room's create_time" do
+        before do
+          mocked_api.should_receive(:create_meeting)
+            .with(room.name, room.meetingid, get_create_params(room))
+            .and_return(hash_create)
+          room.stub(:select_server).and_return(mocked_server)
+          room.server = mocked_server
+          room.send_create
+        end
+
+        it { expect(room.create_time).to eq(time) }
+      end
+
       context "sends create_meeting" do
 
         context "for a stored room" do
           before do
             mocked_api.should_receive(:create_meeting)
-              .with(room.name, room.meetingid, get_create_params(room))
+              .with(room.name, room.meetingid, expected_params)
               .and_return(hash_create)
             room.stub(:select_server).and_return(mocked_server)
+
             room.server = mocked_server
             room.send_create
           end
-          it { room.attendee_password.should be(attendee_password) }
-          it { room.moderator_password.should be(moderator_password) }
-          it { room.changed?.should be_false }
+          it { room.attendee_api_password.should be(new_attendee_api_password) }
+          it { room.moderator_api_password.should be(new_moderator_api_password) }
+          it { room.voice_bridge.should be(voice_bridge) }
+          it { room.changed?.should be(false) }
         end
 
         context "for a new record" do
           let(:new_room) { FactoryGirl.build(:bigbluebutton_room) }
           before do
+            params  = get_create_params(new_room)
             mocked_api.should_receive(:create_meeting)
-              .with(new_room.name, new_room.meetingid, get_create_params(new_room))
+              .with(new_room.name, new_room.meetingid, params)
               .and_return(hash_create)
             new_room.stub(:select_server).and_return(mocked_server)
             new_room.server = mocked_server
             new_room.send_create
           end
-          it { new_room.attendee_password.should be(attendee_password) }
-          it { new_room.moderator_password.should be(moderator_password) }
-          it("and do not save the record") { new_room.new_record?.should be_true }
+          it { new_room.attendee_api_password.should be(new_attendee_api_password) }
+          it { new_room.moderator_api_password.should be(new_moderator_api_password) }
+          it { new_room.voice_bridge.should be(voice_bridge) }
+          it("and do not save the record") { new_room.new_record?.should be_truthy }
         end
 
         context "passing the user" do
           let(:user) { FactoryGirl.build(:user) }
           before do
+            params = get_create_params(room, user)
             mocked_api.should_receive(:create_meeting)
-              .with(room.name, room.meetingid, get_create_params(room, user))
+              .with(room.name, room.meetingid, params)
               .and_return(hash_create)
             room.stub(:select_server).and_return(mocked_server)
             room.server = mocked_server
             room.send_create(user)
           end
-          it { room.attendee_password.should be(attendee_password) }
-          it { room.moderator_password.should be(moderator_password) }
-          it { room.changed?.should be_false }
+          it { room.attendee_api_password.should be(new_attendee_api_password) }
+          it { room.moderator_api_password.should be(new_moderator_api_password) }
+          it { room.changed?.should be(false) }
         end
 
         context "passing additional options" do
           let(:user) { FactoryGirl.build(:user) }
-          let(:user_opts) { { :record => false, :other => true } }
+          let(:user_opts) { { :record_meeting => false, :other => true } }
           before do
+            params = get_create_params(room, user).merge(user_opts)
             mocked_api.should_receive(:create_meeting)
-              .with(room.name, room.meetingid, get_create_params(room, user).merge(user_opts))
+              .with(room.name, room.meetingid, params)
               .and_return(hash_create)
             room.stub(:select_server).and_return(mocked_server)
             room.server = mocked_server
             room.send_create(user, user_opts)
           end
-          it { room.attendee_password.should be(attendee_password) }
-          it { room.moderator_password.should be(moderator_password) }
-          it { room.changed?.should be_false }
+          it { room.attendee_api_password.should be(new_attendee_api_password) }
+          it { room.moderator_api_password.should be(new_moderator_api_password) }
+          it { room.changed?.should be(false) }
+        end
+
+        context "when the call to create doesn't return a voice bridge" do
+          before do
+            room.update_attributes(:voice_bridge => nil)
+            hash_create.delete(:voiceBridge)
+
+            mocked_api.should_receive(:create_meeting)
+              .with(room.name, room.meetingid, get_create_params(room))
+              .and_return(hash_create)
+            room.stub(:select_server).and_return(mocked_server)
+            room.server = mocked_server
+            room.send_create
+          end
+          it { room.voice_bridge.should be_nil }
+          it { room.changed?.should be(false) }
+        end
+
+        context "when it's set to use local voice bridges" do
+          before {
+            @use_local_voice_bridges = BigbluebuttonRails.use_local_voice_bridges
+            BigbluebuttonRails.use_local_voice_bridges = true
+          }
+          after {
+            BigbluebuttonRails.use_local_voice_bridges = @use_local_voice_bridges
+          }
+
+          context "sets the voice bridge in the params if there's a voice bridge" do
+            let(:voice_bridge) { SecureRandom.random_number(99999) }
+            before do
+              room.update_attributes(:voice_bridge => voice_bridge)
+              create_params = get_create_params(room)
+              create_params.merge!({ :voiceBridge => voice_bridge })
+
+              mocked_api.should_receive(:create_meeting)
+                .with(room.name, room.meetingid, create_params)
+                .and_return(hash_create)
+              room.stub(:select_server).and_return(mocked_server)
+              room.server = mocked_server
+              room.send_create
+            end
+            it { room.changed?.should be(false) }
+          end
+
+          context "doesn't set the voice bridge if it's blank" do
+            let(:voice_bridge) { SecureRandom.random_number(99999) }
+            before do
+              room.update_attributes(:voice_bridge => "")
+
+              mocked_api.should_receive(:create_meeting)
+                .with(room.name, room.meetingid, get_create_params(room))
+                .and_return(hash_create)
+              room.stub(:select_server).and_return(mocked_server)
+              room.server = mocked_server
+              room.send_create
+            end
+            it { room.changed?.should be(false) }
+          end
         end
       end
 
-      context "generates a meetingid if nil" do
+      context "generating a meeting id" do
         let(:new_id) { "new id" }
-        before {
-          room.meetingid = nil
+
+        ['', nil].each do |value|
+          it "generates a new one if it's empty or nil" do
+            room.meetingid = value
+            room.stub(:select_server).and_return(mocked_server)
+            room.server = mocked_server
+            room.should_receive(:unique_meetingid).and_return(new_id)
+            mocked_api.should_receive(:create_meeting)
+              .with(room.name, new_id, anything)
+            room.send_create
+          end
+        end
+
+        it "doesn't generate a new meetingid if already set" do
+          old_id = "old id"
+          room.meetingid = old_id
           room.stub(:select_server).and_return(mocked_server)
           room.server = mocked_server
-        }
-        it "before calling create" do
-          room.should_receive(:unique_meetingid).and_return(new_id)
+          room.should_not_receive(:unique_meetingid)
+          mocked_api.should_receive(:create_meeting)
+            .with(room.name, old_id, anything)
+          room.send_create
+        end
+      end
+
+      context "generating a moderator password" do
+        let(:new_pass) { "new pass" }
+
+        ['', nil].each do |value|
+          it "generates a new one if it's empty or nil" do
+            room.moderator_api_password = value
+            room.stub(:select_server).and_return(mocked_server)
+            room.server = mocked_server
+            room.should_receive(:internal_password).and_return(new_pass)
+            mocked_api.should_receive(:create_meeting)
+              .with(room.name, anything, hash_including(moderatorPW: new_pass))
+            room.send_create
+          end
+        end
+
+        it "doesn't generate a new moderator password if already set" do
+          old_pass = "old pass"
+          room.moderator_api_password = old_pass
+          room.stub(:select_server).and_return(mocked_server)
+          room.server = mocked_server
+          room.should_not_receive(:internal_password)
+          mocked_api.should_receive(:create_meeting)
+            .with(room.name, anything, hash_including(moderatorPW: old_pass))
+          room.send_create
+        end
+      end
+
+      context "generating a attendee password" do
+        let(:new_pass) { "new pass" }
+
+        ['', nil].each do |value|
+          it "generates a new one if it's empty or nil" do
+            room.attendee_api_password = value
+            room.stub(:select_server).and_return(mocked_server)
+            room.server = mocked_server
+            room.should_receive(:internal_password).and_return(new_pass)
+            mocked_api.should_receive(:create_meeting)
+              .with(room.name, anything, hash_including(attendeePW: new_pass))
+            room.send_create
+          end
+        end
+
+        it "doesn't generate a new attendee password if already set" do
+          old_pass = "old pass"
+          room.attendee_api_password = old_pass
+          room.stub(:select_server).and_return(mocked_server)
+          room.server = mocked_server
+          room.should_not_receive(:internal_password)
           mocked_api.should_receive(:create_meeting)
-            .with(room.name, new_id, get_create_params(room))
+            .with(room.name, anything, hash_including(attendeePW: old_pass))
           room.send_create
         end
       end
@@ -533,29 +659,27 @@ describe BigbluebuttonRoom do
 
       context "selects and requires a server" do
         let(:another_server) { FactoryGirl.create(:bigbluebutton_server) }
-
+        let(:room2) { FactoryGirl.create(:bigbluebutton_room, :server => nil) }
         context "and saves the result" do
           before do
-            room.should_receive(:select_server).and_return(another_server)
-            room.should_receive(:require_server)
-            room.should_receive(:internal_create_meeting)
-            room.server = mocked_server
-            room.send_create
+            room2.should_receive(:internal_create_meeting)
+            room2.send_create
           end
-          it { BigbluebuttonRoom.find(room.id).server_id.should == another_server.id }
+          # send_create will call require_server, so a server will be assigned
+          # to this room
+          it { BigbluebuttonRoom.find(room2.id).server_id.should_not be_nil }
         end
 
         context "and does not save when is a new record" do
           let(:new_room) { FactoryGirl.build(:bigbluebutton_room) }
           before do
-            new_room.should_receive(:select_server).and_return(another_server)
             new_room.should_receive(:require_server)
             new_room.should_receive(:internal_create_meeting).and_return(nil)
             new_room.should_not_receive(:save)
             new_room.server = mocked_server
             new_room.send_create
           end
-          it { new_room.new_record?.should be_true }
+          it { new_room.new_record?.should be_truthy }
         end
       end
 
@@ -583,7 +707,7 @@ describe BigbluebuttonRoom do
         before {
           room.should_receive(:require_server)
           mocked_api.should_receive(:join_meeting_url)
-            .with(room.meetingid, username, room.moderator_password, join_options)
+            .with(room.meetingid, username, room.moderator_api_password, join_options)
             .and_return(expected)
           room.server = mocked_server
         }
@@ -596,7 +720,7 @@ describe BigbluebuttonRoom do
         before {
           room.should_receive(:require_server)
           mocked_api.should_receive(:join_meeting_url)
-            .with(room.meetingid, username, room.attendee_password, join_options)
+            .with(room.meetingid, username, room.attendee_api_password, join_options)
             .and_return(expected)
           room.server = mocked_server
         }
@@ -605,16 +729,44 @@ describe BigbluebuttonRoom do
       end
 
       context "without a role" do
-        let(:expected) { 'expected-url' }
-        before {
-          room.should_receive(:require_server)
-          mocked_api.should_receive(:join_meeting_url)
-            .with(room.meetingid, username, 'pass', join_options)
-            .and_return(expected)
-          room.server = mocked_server
-        }
-        subject { room.join_url(username, nil, 'pass', join_options) }
-        it("returns the correct url") { subject.should eq(expected) }
+        context "passing the moderator key" do
+          let(:expected) { 'expected-url' }
+          before {
+            room.should_receive(:require_server)
+            mocked_api.should_receive(:join_meeting_url)
+              .with(room.meetingid, username, room.moderator_api_password, join_options)
+              .and_return(expected)
+            room.server = mocked_server
+          }
+          subject { room.join_url(username, nil, room.moderator_key, join_options) }
+          it("returns the correct url") { subject.should eq(expected) }
+        end
+
+        context "passing the attendee key" do
+          let(:expected) { 'expected-url' }
+          before {
+            room.should_receive(:require_server)
+            mocked_api.should_receive(:join_meeting_url)
+              .with(room.meetingid, username, room.attendee_api_password, join_options)
+              .and_return(expected)
+            room.server = mocked_server
+          }
+          subject { room.join_url(username, nil, room.attendee_key, join_options) }
+          it("returns the correct url") { subject.should eq(expected) }
+        end
+
+        context "passing an unmatching key" do
+          let(:expected) { 'expected-url' }
+          before {
+            room.should_receive(:require_server)
+            mocked_api.should_receive(:join_meeting_url)
+              .with(room.meetingid, username, nil, join_options)
+              .and_return(expected)
+            room.server = mocked_server
+          }
+          subject { room.join_url(username, nil, "wrong key", join_options) }
+          it("returns the correct url") { subject.should eq(expected) }
+        end
       end
 
       context "strips the url before returning it" do
@@ -632,8 +784,8 @@ describe BigbluebuttonRoom do
     describe "#fetch_new_token" do
       let(:config_xml) {
         '<config>
-           <localeversion suppressWarning="false">0.8</localeversion>
-           <version>0.8</version>
+           <localeversion suppressWarning="false">0.9.0</localeversion>
+           <version>264</version>
            <layout showLogButton="false" showVideoLayout="false" showResetLayout="false" defaultLayout="Webinar" showToolbar="true" showFooter="true" showMeetingName="true" showHelpButton="true" showLogoutWindow="true" showLayoutTools="true" showNetworkMonitor="true" confirmLogout="true"/>
            <modules>
              <module name="LayoutModule" url="http://server.test/client/LayoutModule.swf?v=15" uri="rtmp://server.test/bigbluebutton" layoutConfig="http://server.test/client/conf/layout.xml" enableEdit="true"/>
@@ -655,6 +807,7 @@ describe BigbluebuttonRoom do
             mocked_api.should_receive(:set_config_xml)
               .with(room.meetingid, 'fake-config-xml')
               .and_return('fake-token')
+            mocked_server.should_receive(:update_config).with('fake-config-xml')
           }
           it("returns the token generated") { room.fetch_new_token.should eql('fake-token') }
         end
@@ -682,17 +835,118 @@ describe BigbluebuttonRoom do
 
   end
 
-  context "validates passwords" do
+  context "#available_layouts" do
+    context "delegates to server" do
+      let(:room) { FactoryGirl.build(:bigbluebutton_room) }
+      let(:layouts) { [ 'layout-1', 'another layout' ] }
+      before {
+        room.server.should_receive(:available_layouts)
+          .and_return(layouts)
+      }
+      it { room.available_layouts.should eql(layouts) }
+    end
+
+    context "returns and empty array if the server is nil" do
+      let(:room) { FactoryGirl.build(:bigbluebutton_room, server: nil) }
+      it { room.available_layouts.should eql([]) }
+    end
+  end
+
+  context "#available_layouts_names" do
+    context "delegates to server" do
+      let(:room) { FactoryGirl.build(:bigbluebutton_room) }
+      let(:layouts) { [ 'layout-1', 'another layout' ] }
+      before {
+        room.server.should_receive(:available_layouts_names)
+          .and_return(layouts)
+      }
+      it { room.available_layouts_names.should eql(layouts) }
+    end
+
+    context "returns and empty array if the server is nil" do
+      let(:room) { FactoryGirl.build(:bigbluebutton_room, server: nil) }
+      it { room.available_layouts_names.should eql([]) }
+    end
+  end
+
+  context "#available_layouts_for_select" do
+    context "delegates to server" do
+      let(:room) { FactoryGirl.build(:bigbluebutton_room) }
+      let(:layouts) { [ 'layout-1', 'another layout' ] }
+      before {
+        room.server.should_receive(:available_layouts_for_select)
+          .and_return(layouts)
+      }
+      it { room.available_layouts_for_select.should eql(layouts) }
+    end
+
+    context "returns and empty array if the server is nil" do
+      let(:room) { FactoryGirl.build(:bigbluebutton_room, server: nil) }
+      it { room.available_layouts_for_select.should eql([]) }
+    end
+  end
+
+  context "#generate_dial_number!" do
+    let(:room) { FactoryGirl.create(:bigbluebutton_room) }
+
+    context "generates the dial number and saves in the room" do
+      before {
+        BigbluebuttonRails::DialNumber.stub(:randomize).and_return("(99) 1234-5678")
+      }
+      it { room.generate_dial_number!.should be(true) }
+      it {
+        room.generate_dial_number!
+        room.reload.dial_number.should eql("(99) 1234-5678")
+      }
+    end
+
+    context "uses the pattern informed" do
+      before {
+        BigbluebuttonRails::DialNumber.should_receive(:randomize).with("(99) 12xx-xxxx")
+      }
+      it { room.generate_dial_number!("(99) 12xx-xxxx").should be(true) }
+    end
+
+    # tries several times
+
+    context "tries to generate a unique number multiple times" do
+      let!(:another_room) { FactoryGirl.create(:bigbluebutton_room, dial_number: "(99) 1234-5678") }
+      before {
+        expect(BigbluebuttonRails::DialNumber).to receive(:randomize).exactly(19).times.and_return("(99) 1234-5678")
+        expect(BigbluebuttonRails::DialNumber).to receive(:randomize).and_return("(99) 1234-5679") # unique
+      }
+      it { room.generate_dial_number!.should be(true) }
+      it {
+        room.generate_dial_number!
+        room.reload.dial_number.should eql("(99) 1234-5679")
+      }
+    end
+
+    context "returns nil if can't generate a unique number" do
+      before { @previous_dn = room.dial_number }
+      let!(:another_room) { FactoryGirl.create(:bigbluebutton_room, dial_number: "(99) 1234-5678") }
+      before {
+        expect(BigbluebuttonRails::DialNumber).to receive(:randomize).exactly(20).times.and_return("(99) 1234-5678")
+      }
+      it { room.generate_dial_number!.should be_nil }
+      it {
+        room.generate_dial_number!
+        room.reload.dial_number.should eql(@previous_dn)
+      }
+    end
+  end
+
+  context "validates keys" do
     context "for private rooms" do
       let(:room) { FactoryGirl.create(:bigbluebutton_room, :private => true) }
-      it { room.should_not allow_value('').for(:moderator_password) }
-      it { room.should_not allow_value('').for(:attendee_password) }
+      it { room.should_not allow_value('').for(:moderator_key) }
+      it { room.should_not allow_value('').for(:attendee_key) }
     end
 
     context "for public rooms" do
       let(:room) { FactoryGirl.create(:bigbluebutton_room, :private => false) }
-      it { room.should allow_value('').for(:moderator_password) }
-      it { room.should allow_value('').for(:attendee_password) }
+      it { room.should allow_value('').for(:moderator_key) }
+      it { room.should allow_value('').for(:attendee_key) }
     end
   end
 
@@ -740,16 +994,17 @@ describe BigbluebuttonRoom do
         room.should_receive(:is_running?).and_return(true)
       }
       subject { room.create_meeting(user) }
-      it { should be_false }
+      it { should be(false) }
     end
 
     context "when the conference is not running" do
       before {
         room.should_receive(:is_running?).and_return(false)
         room.should_receive(:send_create).with(user, {})
+        room.should_receive(:send_end)
       }
       subject { room.create_meeting(user) }
-      it { should be_true }
+      it { should be(true) }
     end
 
     context "when the parameter 'request' is informed" do
@@ -760,23 +1015,24 @@ describe BigbluebuttonRoom do
         room.should_receive(:add_domain_to_logout_url).with("HTTP://", "test.com:80")
         room.should_receive(:is_running?).and_return(false)
         room.should_receive(:send_create)
+        room.should_receive(:send_end)
       }
       subject { room.create_meeting(user, request) }
-      it { should be_true }
+      it { should be(true) }
     end
 
-    # context "when the parameter 'request' is informed" do
-    #   let(:request) { double(ActionDispatch::Request) }
-    #   before {
-    #     request.stub(:protocol).and_return("HTTP://")
-    #     request.stub(:host_with_port).and_return("test.com:80")
-    #     room.should_receive(:add_domain_to_logout_url).with("HTTP://", "test.com:80")
-    #     room.should_receive(:is_running?).and_return(false)
-    #     room.should_receive(:send_create)
-    #   }
-    #   subject { room.create_meeting(user.name, user.id, request) }
-    #   it { should be_true }
-    # end
+    context "ignores exceptions raised by send_end (for when there's no meeting created)" do
+      before {
+        room.should_receive(:is_running?).and_return(false)
+        room.should_receive(:send_create).with(user, {})
+        room.should_receive(:send_end) { raise BigBlueButton::BigBlueButtonException.new('test') }
+      }
+      it {
+        expect {
+          room.create_meeting(user)
+        }.not_to raise_error
+      }
+    end
   end
 
   describe "#full_logout_url" do
@@ -787,30 +1043,77 @@ describe BigbluebuttonRoom do
 
   describe "#require_server" do
     let(:room) { FactoryGirl.create(:bigbluebutton_room) }
-    it { should respond_to(:require_server) }
+    it { room.respond_to?(:require_server, true).should be(true) }
 
-    context "throws exception when the room has no server associated" do
-      before { room.server = nil }
-      it {
-        expect {
-          room.send(:require_server)
-        }.to raise_error(BigbluebuttonRails::ServerRequired)
+    context "if the room has no server associated" do
+      let(:server) { FactoryGirl.create(:bigbluebutton_server) }
+      before {
+        room.server = nil
       }
+
+      context "assigns server to room if there is one" do
+        before {
+          room.send(:require_server)
+        }
+        it { room.reload.server.should_not be_nil }
+      end
+
+      context "raises exception if there are no servers to assign" do
+        before {
+          room.should_receive(:select_server).and_return(nil)
+        }
+        it {
+          expect {
+            room.send(:require_server)
+          }.to raise_error(BigbluebuttonRails::ServerRequired)
+        }
+      end
+
+      context "doesn't save the room if no server is selected" do
+        before {
+          @updated_at = room.updated_at
+          room.should_receive(:select_server).and_return(nil)
+          expect {
+            room.send(:require_server)
+          }.to raise_error(BigbluebuttonRails::ServerRequired)
+        }
+        it { room.updated_at.should eql(@updated_at) }
+      end
+
+      context "doesn't save the room if it's a new record" do
+        let(:room) { FactoryGirl.build(:bigbluebutton_room) }
+        before {
+          room.should_receive(:select_server).and_return(server)
+          room.send(:require_server)
+        }
+        it { room.new_record?.should be(true) }
+        it { room.server.should eql(server) }
+      end
+
+      context "passes the api_method parameter to #select_server" do
+        let(:method) { :my_api_method }
+        before {
+          room.should_receive(:select_server).with(method).and_return(server)
+        }
+        it { room.send(:require_server, method) }
+      end
     end
 
     context "does nothing if the room has a server associated" do
-      before { room.server = FactoryGirl.create(:bigbluebutton_server) }
-      it {
+      let(:server) { FactoryGirl.create(:bigbluebutton_server) }
+      before {
+        room.server = server
         expect {
           room.send(:require_server)
-        }.not_to raise_error()
+        }.not_to raise_error
       }
+      it { room.server.should eql(server) }
     end
   end
 
   describe "#select_server" do
     let(:room) { FactoryGirl.create(:bigbluebutton_room, :server => nil) }
-    it { should respond_to(:select_server) }
+    it { room.respond_to?(:select_server, true).should be(true) }
 
     context "selects the server with less rooms" do
       before {
@@ -824,7 +1127,15 @@ describe BigbluebuttonRoom do
     end
 
     context "returns nil of there are no servers" do
-      before(:each) { BigbluebuttonServer.destroy_all }
+      before { BigbluebuttonServer.destroy_all }
+      it { room.send(:select_server).should == nil }
+    end
+
+    context "returns nil if the room already has a server" do
+      before {
+        2.times{ FactoryGirl.create(:bigbluebutton_server) }
+        room.update_attributes(server: FactoryGirl.create(:bigbluebutton_server))
+      }
       it { room.send(:select_server).should == nil }
     end
   end
@@ -881,7 +1192,7 @@ describe BigbluebuttonRoom do
       before {
         room.start_time = Time.now.utc
         room.running = !room.running # to change its default value
-        room.record = !room.record   # to change its default value
+        room.record_meeting = !room.record_meeting   # to change its default value
       }
 
       context "if there's no meeting associated yet creates one" do
@@ -897,7 +1208,7 @@ describe BigbluebuttonRoom do
           it("sets room") { subject.room.should eq(room) }
           it("sets meetingid") { subject.meetingid.should eq(room.meetingid) }
           it("sets name") { subject.name.should eq(room.name) }
-          it("sets record") { subject.record.should eq(room.record) }
+          it("sets recorded") { subject.recorded.should eq(room.record_meeting) }
           it("sets running") { subject.running.should eq(room.running) }
           it("sets start_time") { subject.start_time.utc.to_i.should eq(room.start_time.utc.to_i) }
           it("doesn't set creator_id") { subject.creator_id.should be_nil }
@@ -943,7 +1254,7 @@ describe BigbluebuttonRoom do
           it("sets room") { subject.room.should eq(room) }
           it("sets meetingid") { subject.meetingid.should eq(room.meetingid) }
           it("sets name") { subject.name.should eq(room.name) }
-          it("sets record") { subject.record.should eq(room.record) }
+          it("sets recorded") { subject.recorded.should eq(room.record_meeting) }
           it("sets running") { subject.running.should eq(room.running) }
           it("sets start_time") { subject.start_time.utc.to_i.should eq(room.start_time.utc.to_i) }
           it("doesn't set creator_id") { subject.creator_id.should be_nil }
@@ -968,7 +1279,27 @@ describe BigbluebuttonRoom do
   end
 
   describe "#finish_meetings" do
-    it "finishes all meetings related to this room that are still running"
+    let!(:room) { FactoryGirl.create(:bigbluebutton_room) }
+
+    context "finishes all meetings related to this room that are still running" do
+      let!(:meeting1) { FactoryGirl.create(:bigbluebutton_meeting, room: room, running: true) }
+      let!(:meeting2) { FactoryGirl.create(:bigbluebutton_meeting, room: room, running: true) }
+      before(:each) { room.finish_meetings }
+      it { meeting1.reload.running.should be(false) }
+      it { meeting2.reload.running.should be(false) }
+    end
+
+    context "works if the room has no meetings" do
+      it { room.finish_meetings }
+    end
+
+    context "works if the room has no meetings running" do
+      let!(:meeting1) { FactoryGirl.create(:bigbluebutton_meeting, room: room, running: false) }
+      let!(:meeting2) { FactoryGirl.create(:bigbluebutton_meeting, room: room, running: false) }
+      it { room.finish_meetings }
+      it { meeting1.reload.running.should be(false) }
+      it { meeting2.reload.running.should be(false) }
+    end
   end
 
   describe "#internal_create_meeting" do
@@ -979,6 +1310,61 @@ describe BigbluebuttonRoom do
     it "calls api.create_meeting"
     it "accepts additional user options to override the options in the database"
 
+    context "adds the invitation URL, if any" do
+      before { mock_server_and_api }
+      let(:room) { FactoryGirl.create(:bigbluebutton_room) }
+
+      before {
+        mocked_api.stub(:"request_headers=")
+        room.server = mocked_server
+      }
+
+      it { room.should_not respond_to(:invitation_url) }
+
+      context "doesn't add the invitation URL by default" do
+        before {
+          mocked_api.should_receive(:create_meeting)  do |name, meetingid, opts|
+            opts.should_not have_key('meta_invitation-url')
+            opts.should_not have_key(:'meta_invitation-url')
+          end
+        }
+        it { room.send(:internal_create_meeting) }
+      end
+
+      context "doesn't add the invitation URL if BigbluebuttonRoom#invitation_url returns nil" do
+        before {
+          BigbluebuttonRoom.class_eval do
+            def invitation_url
+              nil
+            end
+          end
+
+          room.should respond_to(:invitation_url)
+          mocked_api.should_receive(:create_meeting)  do |name, meetingid, opts|
+            opts.should_not have_key('meta_invitation-url')
+            opts.should_not have_key(:'meta_invitation-url')
+          end
+        }
+        it { room.send(:internal_create_meeting) }
+      end
+
+      context "adds the value returned by BigbluebuttonRoom#invitation_url" do
+        before {
+          BigbluebuttonRoom.class_eval do
+            def invitation_url
+              'http://my-invitation.url'
+            end
+          end
+
+          room.should respond_to(:invitation_url)
+          mocked_api.should_receive(:create_meeting)  do |name, meetingid, opts|
+            opts.should include('meta_invitation-url' => 'http://my-invitation.url')
+          end
+        }
+        it { room.send(:internal_create_meeting) }
+      end
+    end
+
     context "schedules a BigbluebuttonMeetingUpdater" do
       before { mock_server_and_api }
       let(:room) { FactoryGirl.create(:bigbluebutton_room) }
@@ -999,20 +1385,21 @@ describe BigbluebuttonRoom do
       it("the job should have the correct parameters") { subject['args'].should eq([room.id]) }
     end
   end
-
 end
 
 def get_create_params(room, user=nil)
   params = {
-    :moderatorPW => room.moderator_password,
-    :attendeePW => room.attendee_password,
+    :record => room.record_meeting,
+    :duration => room.duration,
+    :moderatorPW => room.moderator_api_password,
+    :attendeePW => room.attendee_api_password,
     :welcome  => room.welcome_msg,
     :dialNumber => room.dial_number,
     :logoutURL => room.logout_url,
     :maxParticipants => room.max_participants,
-    :voiceBridge => room.voice_bridge,
-    :record => room.record,
-    :duration => room.duration
+    :moderatorOnlyMessage => room.moderator_only_message,
+    :autoStartRecording => room.auto_start_recording,
+    :allowStartStopRecording => room.allow_start_stop_recording
   }
   room.metadata.each { |meta| params["meta_#{meta.name}"] = meta.content }
   unless user.nil?