bigbluebutton_rails 2.0.0 → 2.1.0

data/spec/models/bigbluebutton_meeting_db_spec.rb

@@ -13,11 +13,16 @@ describe BigbluebuttonMeeting do
     it { should have_db_column(:recorded).of_type(:boolean) }
     it { should have_db_column(:creator_id).of_type(:integer) }
     it { should have_db_column(:creator_name).of_type(:string) }
-    it { should have_db_index([:meetingid, :start_time]).unique(true) }
+    it { should have_db_column(:create_time).of_type(:integer) }
+    it { should have_db_index([:meetingid, :create_time]).unique(true) }
+    it { should have_db_column(:ended).of_type(:boolean) }
+    it { should have_db_column(:server_url).of_type(:string) }
+    it { should have_db_column(:server_secret).of_type(:string) }
     it "default values" do
-      room = BigbluebuttonRoom.new
-      room.running.should be_falsey
-      room.record_meeting.should be_falsey
+      room = BigbluebuttonMeeting.new
+      room.running.should be(false)
+      room.ended.should be(false)
+      room.recorded.should be(false)
     end
   end
 

data/spec/models/bigbluebutton_meeting_spec.rb

@@ -19,8 +19,8 @@ describe BigbluebuttonMeeting do
   it { should validate_presence_of(:meetingid) }
   it { should ensure_length_of(:meetingid).is_at_least(1).is_at_most(100) }
 
-  it { should validate_presence_of(:start_time) }
-  it { should validate_uniqueness_of(:start_time).scoped_to(:room_id) }
+  it { should validate_presence_of(:create_time) }
+  it { should validate_uniqueness_of(:create_time).scoped_to(:room_id) }
 
   describe "#created_by?" do
     let(:target) { FactoryGirl.create(:bigbluebutton_meeting) }

data/spec/models/bigbluebutton_recording_spec.rb

@@ -173,7 +173,7 @@ describe BigbluebuttonRecording do
       it { BigbluebuttonRecording.count.should == 2 }
     end
 
-    context "sets recording that are not in the parameters as unavailable" do
+    context "sets recording that are not in the parameters as unavailable in a full sync" do
 
       context "for recordings in multiple servers" do
         before {
@@ -182,7 +182,7 @@ describe BigbluebuttonRecording do
           @r2 = FactoryGirl.create(:bigbluebutton_recording, :available => true, :server => new_server)
           @r3 = FactoryGirl.create(:bigbluebutton_recording, :available => true, :server => FactoryGirl.create(:bigbluebutton_server))
           @r4 = FactoryGirl.create(:bigbluebutton_recording, :available => true, :server => FactoryGirl.create(:bigbluebutton_server))
-          BigbluebuttonRecording.sync(new_server, data)
+          BigbluebuttonRecording.sync(new_server, data, true)
         }
         it { BigbluebuttonRecording.count.should == 5 }
         it ("recording from the target server") { @r1.reload.available.should == false }
@@ -196,7 +196,7 @@ describe BigbluebuttonRecording do
           new_server.recordings.delete_all
           @r1 = FactoryGirl.create(:bigbluebutton_recording, :available => true, :server => FactoryGirl.create(:bigbluebutton_server))
           @r2 = FactoryGirl.create(:bigbluebutton_recording, :available => true, :server => FactoryGirl.create(:bigbluebutton_server))
-          BigbluebuttonRecording.sync(new_server, data)
+          BigbluebuttonRecording.sync(new_server, data, true)
         }
         it { new_server.recordings.should be_empty }
         it ("recording from another server") { @r1.reload.available.should == true }
@@ -208,7 +208,7 @@ describe BigbluebuttonRecording do
           BigbluebuttonRecording.delete_all
           @r1 = FactoryGirl.create(:bigbluebutton_recording, :available => true, :server => new_server)
           @r2 = FactoryGirl.create(:bigbluebutton_recording, :available => true, :server => new_server)
-          BigbluebuttonRecording.sync(new_server, data)
+          BigbluebuttonRecording.sync(new_server, data, true)
         }
         it { BigbluebuttonRecording.count.should == 3 }
         it ("recording from another server") { @r1.reload.available.should == false }
@@ -216,6 +216,21 @@ describe BigbluebuttonRecording do
       end
     end
 
+    context "doesn't set recordings that are not in the parameters as unavailable if not in a full sync" do
+      before {
+        BigbluebuttonRecording.delete_all
+        @r1 = FactoryGirl.create(:bigbluebutton_recording, :available => true, :server => new_server)
+        @r2 = FactoryGirl.create(:bigbluebutton_recording, :available => true, :server => new_server)
+        @r3 = FactoryGirl.create(:bigbluebutton_recording, :available => true, :server => FactoryGirl.create(:bigbluebutton_server))
+        @r4 = FactoryGirl.create(:bigbluebutton_recording, :available => true, :server => FactoryGirl.create(:bigbluebutton_server))
+        BigbluebuttonRecording.sync(new_server, data)
+      }
+      it { @r1.reload.available.should == true }
+      it { @r2.reload.available.should == true }
+      it { @r3.reload.available.should == true }
+      it { @r4.reload.available.should == true }
+    end
+
     context "works for multiple recordings" do
       before {
         # adds 2 more recordings to the input data

data/spec/models/bigbluebutton_room_options_spec.rb

@@ -47,7 +47,7 @@ describe BigbluebuttonRoomOptions do
         BigBlueButton::BigBlueButtonConfigXml.any_instance
           .should_receive(:is_modified?).and_return(true)
         BigBlueButton::BigBlueButtonConfigXml.any_instance
-          .should_receive(:as_string).and_return('new xml as string')
+          .stub(:as_string).and_return('new xml as string')
       }
       subject { room_options.set_on_config_xml(config_xml) }
       it("returns the new xml") { should eql('new xml as string') }

data/spec/models/bigbluebutton_room_spec.rb

@@ -274,7 +274,7 @@ describe BigbluebuttonRoom do
       # these hashes should be exactly as returned by bigbluebutton-api-ruby to be sure we are testing it right
       let(:hash_info) {
         { :returncode=>true, :meetingID=>"test_id", :attendeePW=>"1234", :moderatorPW=>"4321",
-          :running=>false, :hasBeenForciblyEnded=>false, :startTime=>nil, :endTime=>nil,
+          :running=>false, :hasBeenForciblyEnded=>false, :startTime=>nil, :createTime=>nil, :endTime=>nil,
           :participantCount=>0, :moderatorCount=>0, :attendees=>[], :messageKey=>"", :message=>""
         }
       }
@@ -296,7 +296,7 @@ describe BigbluebuttonRoom do
         { :returncode=>true, :meetingID=>"test_id", :attendeePW=>"1234", :moderatorPW=>"4321",
           :running=>true, :hasBeenForciblyEnded=>false, :startTime=>DateTime.parse("Wed Apr 06 17:09:57 UTC 2011"),
           :endTime=>nil, :participantCount=>4, :moderatorCount=>2, :metadata=>metadata,
-          :attendees=>users, :messageKey=>{ }, :message=>{ }
+          :createTime=>1466876909, :attendees=>users, :messageKey=>{ }, :message=>{ }
         }
       }
 
@@ -315,6 +315,7 @@ describe BigbluebuttonRoom do
         it { room.participant_count.should == 0 }
         it { room.moderator_count.should == 0 }
         it { room.start_time.should == nil }
+        it { room.reload.create_time.should == nil }
         it { room.end_time.should == nil }
         it { room.attendees.should == [] }
       end
@@ -332,6 +333,7 @@ describe BigbluebuttonRoom do
         it { room.participant_count.should == 4 }
         it { room.moderator_count.should == 2 }
         it { room.start_time.should == DateTime.parse("Wed Apr 06 17:09:57 UTC 2011") }
+        it { room.reload.create_time.should == 1466876909 }
         it { room.end_time.should == nil }
         it {
           users.each do |att|
@@ -342,7 +344,7 @@ describe BigbluebuttonRoom do
         }
       end
 
-      context "calls #update_current_meeting after the information is fetched" do
+      context "calls #update_current_meeting_record after the information is fetched" do
         before {
           mocked_api.should_receive(:get_meeting_info).
             with(room.meetingid, room.moderator_api_password).and_return(hash_info2)
@@ -350,10 +352,77 @@ describe BigbluebuttonRoom do
           room.server = mocked_server
 
           # here's the validation
-          room.should_receive(:update_current_meeting).with(metadata)
+          room.should_receive(:update_current_meeting_record).with(metadata, true)
         }
         it { room.fetch_meeting_info }
       end
+
+      context "if an exception 'notFound' is raised" do
+        let!(:exception) {
+          e = BigBlueButton::BigBlueButtonException.new('Test error')
+          e.key = 'notFound'
+          e
+        }
+        before {
+          expect(mocked_api).to receive(:get_meeting_info) { raise exception }
+          expect(room).not_to receive(:update_current_meeting_record)
+          expect(room).to receive(:finish_meetings)
+        }
+        it { expect { room.fetch_meeting_info }.not_to raise_exception }
+        it {
+          room.fetch_meeting_info
+          room.reload.create_time.should be_nil
+        }
+      end
+
+      context "if an exception other than 'notFound' is raised" do
+        let!(:exception) {
+          e = BigBlueButton::BigBlueButtonException.new('Test error')
+          e.key = 'anythingElse'
+          e
+        }
+        before {
+          expect(mocked_api).to receive(:get_meeting_info) { raise exception }
+          expect(room).not_to receive(:update_current_meeting_record)
+          expect(room).to receive(:finish_meetings)
+        }
+        it { expect { room.fetch_meeting_info }.not_to raise_exception }
+        it {
+          room.fetch_meeting_info
+          room.reload.create_time.should be_nil
+        }
+      end
+
+      context "if an exception with a blank key is raised" do
+        let!(:exception) {
+          e = BigBlueButton::BigBlueButtonException.new('Test error')
+          e.key = ''
+          e
+        }
+        before {
+          expect(mocked_api).to receive(:get_meeting_info) { raise exception }
+          expect(room).not_to receive(:update_current_meeting_record)
+          expect(room).to receive(:finish_meetings)
+        }
+        it { expect { room.fetch_meeting_info }.not_to raise_exception }
+        it {
+          room.fetch_meeting_info
+          room.reload.create_time.should be_nil
+        }
+      end
+
+      context "raises any exception other than a BigBlueButtonException" do
+        let!(:exception) { NoMethodError.new('Test error') }
+        before {
+          expect(mocked_api).to receive(:get_meeting_info) { raise exception }
+          expect(room).not_to receive(:update_current_meeting_record)
+          expect(room).not_to receive(:finish_meetings)
+        }
+        it {
+          expect { room.fetch_meeting_info }.to raise_exception
+          room.reload.create_time.should_not be_nil
+        }
+      end
     end
 
     describe "#send_end" do
@@ -378,7 +447,7 @@ describe BigbluebuttonRoom do
         subject { Resque.peek(:bigbluebutton_rails) }
         it("should have a job schedule") { subject.should_not be_nil }
         it("the job should be the right one") { subject['class'].should eq('BigbluebuttonMeetingUpdater') }
-        it("the job should have the correct parameters") { subject['args'].should eq([room.id, 15]) }
+        it("the job should have the correct parameters") { subject['args'].should eq([room.id]) }
       end
     end
 
@@ -469,7 +538,11 @@ describe BigbluebuttonRoom do
           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 }
+          it("doesn't save the record") { new_room.new_record?.should be(true) }
+          it("doesn't create a meeting") { BigbluebuttonMeeting.where(room: new_room).should be_empty }
+          it("doesn't schedule a meeting updater") {
+            Resque.peek(:bigbluebutton_rails).should be_nil
+          }
         end
 
         context "passing the user" do
@@ -562,6 +635,50 @@ describe BigbluebuttonRoom do
             it { room.changed?.should be(false) }
           end
         end
+
+        context "creates a meeting record" do
+          before do
+            mocked_api.should_receive(:create_meeting)
+              .with(room.name, room.meetingid, expected_params)
+              .and_return(hash_create)
+            room.stub(:select_server).and_return(mocked_server)
+
+            room.server = mocked_server
+            expect {
+              room.send_create
+            }.to change{ BigbluebuttonMeeting.count }.by(1)
+          end
+          subject { BigbluebuttonMeeting.last }
+          it { subject.room.should eql(room) }
+          it { subject.server_id.should eql(room.server.id) }
+          it { subject.server_url.should eql(room.server.url) }
+          it { subject.server_secret.should eql(room.server.secret) }
+          it { subject.meetingid.should eql(room.meetingid) }
+          it { subject.name.should eql(room.name) }
+          it { subject.recorded.should eql(room.record_meeting) }
+          it { subject.create_time.should eql(room.create_time) }
+          it { subject.create_time.should eql(room.create_time) }
+          it { subject.start_time.should eql(room.start_time) }
+          it { subject.ended.should eql(false) }
+        end
+
+        context "enqueues a BigbluebuttonMeetingUpdater" do
+          before do
+            mocked_api.should_receive(:create_meeting)
+              .with(room.name, room.meetingid, expected_params)
+              .and_return(hash_create)
+            room.stub(:select_server).and_return(mocked_server)
+
+            room.server = mocked_server
+            expect {
+              room.send_create
+            }.to change{ Resque.info[:pending] }.by(1)
+          end
+          subject { Resque.peek(:bigbluebutton_rails) }
+          it("should have a job schedule") { subject.should_not be_nil }
+          it("the job should be the right one") { subject['class'].should eq('BigbluebuttonMeetingUpdater') }
+          it("the job should have the correct parameters") { subject['args'].should eq([room.id, 10]) }
+        end
       end
 
       context "generating a meeting id" do
@@ -693,7 +810,6 @@ describe BigbluebuttonRoom do
         end
         it { room.send_create }
       end
-
     end # #send_create
 
     describe "#join_url" do
@@ -1142,14 +1258,66 @@ describe BigbluebuttonRoom do
 
   describe "#get_metadata_for_create" do
     let(:room) { FactoryGirl.create(:bigbluebutton_room, :server => nil) }
-    before {
-      @m1 = FactoryGirl.create(:bigbluebutton_room_metadata, :owner => room)
-      @m2 = FactoryGirl.create(:bigbluebutton_room_metadata, :owner => room)
-    }
-    it {
-      result = { "meta_#{@m1.name}" => @m1.content, "meta_#{@m2.name}" => @m2.content }
-      room.send(:get_metadata_for_create).should == result
-    }
+
+    context "returns the metadata from the database" do
+      before {
+        @m1 = FactoryGirl.create(:bigbluebutton_room_metadata, :owner => room)
+        @m2 = FactoryGirl.create(:bigbluebutton_room_metadata, :owner => room)
+      }
+      it {
+        result = { "meta_#{@m1.name}" => @m1.content, "meta_#{@m2.name}" => @m2.content }
+        room.send(:get_metadata_for_create).should == result
+      }
+    end
+
+    context "returns the dynamic metadata, if any" do
+      before {
+        BigbluebuttonRoom.class_eval do
+          def dynamic_metadata
+            {
+              "test1" => "value1",
+              "test2" => "value2"
+            }
+          end
+        end
+      }
+      after {
+        BigbluebuttonRoom.class_eval do
+          undef_method :dynamic_metadata
+        end
+      }
+
+      it {
+        result = { "meta_test1" => "value1", "meta_test2" => "value2" }
+        room.send(:get_metadata_for_create).should eql(result)
+      }
+    end
+
+    context "gives priority to the dynamic metadata" do
+      before {
+        BigbluebuttonRoom.class_eval do
+          def dynamic_metadata
+            {
+              "test1" => "value1",
+              "test2" => "value2"
+            }
+          end
+        end
+
+        @m1 = FactoryGirl.create(:bigbluebutton_room_metadata, owner: room, name: "test1", content: "content overwritten")
+        @m2 = FactoryGirl.create(:bigbluebutton_room_metadata, owner: room, name: "other", content: "other content")
+      }
+      after {
+        BigbluebuttonRoom.class_eval do
+          undef_method :dynamic_metadata
+        end
+      }
+
+      it {
+        result = { "meta_test1" => "value1", "meta_test2" => "value2", "meta_other" => "other content" }
+        room.send(:get_metadata_for_create).should eql(result)
+      }
+    end
   end
 
   describe "#get_current_meeting" do
@@ -1160,28 +1328,28 @@ describe BigbluebuttonRoom do
       it { room.get_current_meeting.should be_nil }
     end
 
-    context "if the room has a start_time set" do
+    context "if the room has a create_time set" do
       before {
-        @m1 = FactoryGirl.create(:bigbluebutton_meeting, :room => room, :start_time => Time.now.utc - 2.minutes)
-        @m2 = FactoryGirl.create(:bigbluebutton_meeting, :room => room, :start_time => Time.now.utc)
-        room.start_time = @m1.start_time
+        @m1 = FactoryGirl.create(:bigbluebutton_meeting, :room => room, :create_time => Time.now.utc - 2.minutes)
+        @m2 = FactoryGirl.create(:bigbluebutton_meeting, :room => room, :create_time => Time.now.utc)
+        room.update_attributes(create_time: @m1.create_time)
       }
       it("returns the correct BigbluebuttonMeeting") { room.get_current_meeting.should eql(@m1) }
     end
   end
 
-  describe "#update_current_meeting" do
+  describe "#update_current_meeting_record" do
     let(:room) { FactoryGirl.create(:bigbluebutton_room) }
 
-    context "if @start_time is not set in the room" do
-      before { room.start_time = nil }
-      subject { room.update_current_meeting }
-      it("doesn't create a meeting") {
+    context "if #create_time is not set in the room" do
+      before { room.update_attributes(create_time: nil) }
+      subject { room.update_current_meeting_record }
+      it("doesn't do anything") {
         BigbluebuttonMeeting.find_by_room_id(room.id).should be_nil
       }
     end
 
-    context "if @start_time is set" do
+    context "if #create_time is set" do
       let(:user) { FactoryGirl.build(:user) }
       let(:metadata) {
         m = {}
@@ -1190,67 +1358,109 @@ describe BigbluebuttonRoom do
         m
       }
       before {
-        room.start_time = Time.now.utc
+        room.create_time = Time.now.utc
         room.running = !room.running # to change its default value
-        room.record_meeting = !room.record_meeting   # to change its default value
+        room.start_time = Time.at(Time.now.to_i - 123)  # to change its default value
       }
 
-      context "if there's no meeting associated yet creates one" do
-        context "and no metadata was passed" do
-          before { room.running = true }
-          before(:each) {
-            expect {
-              room.update_current_meeting
-            }.to change{ BigbluebuttonMeeting.count }.by(1)
-          }
-          subject { BigbluebuttonMeeting.find_by_room_id(room.id) }
-          it("sets server") { subject.server.should eq(room.server) }
-          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 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 }
-          it("doesn't set creator_name") { subject.creator_name.should be_nil }
-        end
+      context "and no metadata was passed" do
+        before {
+          FactoryGirl.create(:bigbluebutton_meeting, :room => room, :create_time => room.create_time)
+        }
+        before(:each) {
+          expect {
+            room.update_current_meeting_record
+          }.not_to change{ BigbluebuttonMeeting.count }
+        }
+        subject { BigbluebuttonMeeting.find_by_room_id(room.id) }
+        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 }
+        it("doesn't set creator_name") { subject.creator_name.should be_nil }
+      end
 
-        context "and metadata was passed" do
-          before { room.running = true }
-          before(:each) {
-            expect {
-              room.update_current_meeting(metadata)
-            }.to change{ BigbluebuttonMeeting.count }.by(1)
-          }
-          subject { BigbluebuttonMeeting.find_by_room_id(room.id) }
-          it("sets creator_id") { subject.creator_id.should eq(user.id) }
-          it("sets creator_name") { subject.creator_name.should eq(user.name) }
-        end
+      context "and metadata was passed" do
+        before {
+          FactoryGirl.create(:bigbluebutton_meeting, :room => room, :create_time => room.create_time)
+        }
+        before(:each) {
+          expect {
+            room.update_current_meeting_record(metadata)
+          }.not_to change{ BigbluebuttonMeeting.count }
+        }
+        subject { BigbluebuttonMeeting.find_by_room_id(room.id) }
+        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("sets creator_id") { subject.creator_id.should eq(user.id) }
+        it("sets creator_name") { subject.creator_name.should eq(user.name) }
       end
 
-      context "if there's no meeting associated yet but the meeting is not running" do
-        before { room.running = false }
+      context "if force_not_ended is set" do
+        before {
+          FactoryGirl.create(:bigbluebutton_meeting, :room => room, :create_time => room.create_time, :ended => true)
+        }
         before(:each) {
           expect {
-            room.update_current_meeting
+            room.update_current_meeting_record(nil, true)
           }.not_to change{ BigbluebuttonMeeting.count }
         }
         subject { BigbluebuttonMeeting.find_by_room_id(room.id) }
-        it("shouldn't create a meeting") { subject.should be_nil }
+        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("sets ended") { subject.ended.should be(false) }
       end
+    end
+  end
+
+  describe "#create_meeting_record" do
+    let(:room) { FactoryGirl.create(:bigbluebutton_room) }
+
+    context "if there is already a current meeting" do
+      let!(:meeting) { FactoryGirl.create(:bigbluebutton_meeting, room: room, ended: false, running: true, create_time: room.create_time) }
+      subject {
+        expect {
+          room.create_meeting_record
+        }.not_to change{ BigbluebuttonMeeting.count }
+      }
+      it { BigbluebuttonMeeting.where(room: room).count.should be(1) }
+      it { meeting.reload.running.should be(true) }
+      it { meeting.reload.ended.should be(false) }
+    end
+
+    context "if #create_time is not set in the room" do
+      before { room.update_attributes(create_time: nil) }
+      subject { room.create_meeting_record }
+      it("doesn't create a meeting") {
+        BigbluebuttonMeeting.find_by(room_id: room.id).should be_nil
+      }
+    end
+
+    context "if #create_time is set" do
+      let(:user) { FactoryGirl.build(:user) }
+      let(:metadata) {
+        m = {}
+        m[BigbluebuttonRails.metadata_user_id] = user.id
+        m[BigbluebuttonRails.metadata_user_name] = user.name
+        m
+      }
+      before {
+        room.create_time = Time.now.utc
+        room.running = !room.running # to change its default value
+        room.record_meeting = !room.record_meeting # to change its default value
+        room.start_time = Time.at(Time.now.to_i - 123)  # to change its default value
+      }
 
-      context "if there's already a meeting associated updates it" do
+      context "if there's no meeting associated yet creates one" do
         context "and no metadata was passed" do
-          before {
-            FactoryGirl.create(:bigbluebutton_meeting, :room => room, :start_time => room.start_time)
-          }
           before(:each) {
             expect {
-              room.update_current_meeting
-            }.not_to change{ BigbluebuttonMeeting.count }
+              room.create_meeting_record
+            }.to change{ BigbluebuttonMeeting.count }.by(1)
           }
-          subject { BigbluebuttonMeeting.find_by_room_id(room.id) }
+          subject { BigbluebuttonMeeting.last }
           it("sets server") { subject.server.should eq(room.server) }
+          it("sets server_url") { subject.server_url.should eq(room.server.url) }
+          it("sets server_secret") { subject.server_secret.should eq(room.server.secret) }
           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) }
@@ -1262,43 +1472,67 @@ describe BigbluebuttonRoom do
         end
 
         context "and metadata was passed" do
-          before {
-            FactoryGirl.create(:bigbluebutton_meeting, :room => room, :start_time => room.start_time)
-          }
           before(:each) {
             expect {
-              room.update_current_meeting(metadata)
-            }.not_to change{ BigbluebuttonMeeting.count }
+              room.create_meeting_record(metadata)
+            }.to change{ BigbluebuttonMeeting.count }.by(1)
           }
-          subject { BigbluebuttonMeeting.find_by_room_id(room.id) }
+          subject { BigbluebuttonMeeting.last }
           it("sets creator_id") { subject.creator_id.should eq(user.id) }
           it("sets creator_name") { subject.creator_name.should eq(user.name) }
         end
       end
+
+      context "if there were already old meetings associated with the room, finishes them" do
+        let!(:meeting1) { FactoryGirl.create(:bigbluebutton_meeting, room: room, ended: false, running: true) }
+        let!(:meeting2) { FactoryGirl.create(:bigbluebutton_meeting, room: room, ended: false, running: false) }
+
+        before(:each) {
+          BigbluebuttonMeeting.where(room: room, ended: false).count.should be(2)
+          expect {
+            room.create_meeting_record(metadata)
+          }.to change{ BigbluebuttonMeeting.count }.by(1)
+        }
+        it { BigbluebuttonMeeting.where(room: room).count.should be(3) }
+        it { BigbluebuttonMeeting.where(room: room, ended: false).count.should be(1) }
+        it { BigbluebuttonMeeting.where(room: room, ended: true).count.should be(2) }
+        it { BigbluebuttonMeeting.where(room: room, ended: true, running: false).count.should be(2) }
+      end
     end
   end
 
   describe "#finish_meetings" do
     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) }
+    context "finishes all meetings related to this room that are still not ended" do
+      let!(:meeting1) { FactoryGirl.create(:bigbluebutton_meeting, room: room, ended: false, running: true) }
+      let!(:meeting2) { FactoryGirl.create(:bigbluebutton_meeting, room: room, ended: false, running: true) }
+      let!(:meeting3) { FactoryGirl.create(:bigbluebutton_meeting, room: room, ended: false, running: false) }
       before(:each) { room.finish_meetings }
       it { meeting1.reload.running.should be(false) }
+      it { meeting1.reload.ended.should be(true) }
       it { meeting2.reload.running.should be(false) }
+      it { meeting2.reload.ended.should be(true) }
+      it { meeting3.reload.running.should be(false) }
+      it { meeting3.reload.ended.should be(true) }
     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) }
+    context "if there's a current meeting not running, ends it" do
+      let!(:meeting) { FactoryGirl.create(:bigbluebutton_meeting, room: room, ended: false, running: false, create_time: room.create_time) }
+      before(:each) { room.finish_meetings }
+      it { meeting.reload.running.should be(false) }
+      it { meeting.reload.ended.should be(true) }
+    end
+
+    context "ends meetings are already ended but still set as running" do
+      let!(:meeting) { FactoryGirl.create(:bigbluebutton_meeting, room: room, ended: true, running: true) }
+      before(:each) { room.finish_meetings }
+      it { meeting.reload.running.should be(false) }
+      it { meeting.reload.ended.should be(true) }
     end
   end
 
@@ -1323,7 +1557,7 @@ describe BigbluebuttonRoom do
 
       context "doesn't add the invitation URL by default" do
         before {
-          mocked_api.should_receive(:create_meeting)  do |name, meetingid, opts|
+          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
@@ -1340,11 +1574,17 @@ describe BigbluebuttonRoom do
           end
 
           room.should respond_to(:invitation_url)
-          mocked_api.should_receive(:create_meeting)  do |name, meetingid, opts|
+          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
         }
+        after {
+          BigbluebuttonRoom.class_eval do
+            undef_method :invitation_url
+          end
+        }
+
         it { room.send(:internal_create_meeting) }
       end
 
@@ -1357,32 +1597,91 @@ describe BigbluebuttonRoom do
           end
 
           room.should respond_to(:invitation_url)
-          mocked_api.should_receive(:create_meeting)  do |name, meetingid, opts|
+          mocked_api.should_receive(:create_meeting) do |name, meetingid, opts|
             opts.should include('meta_invitation-url' => 'http://my-invitation.url')
           end
         }
+        after {
+          BigbluebuttonRoom.class_eval do
+            undef_method :invitation_url
+          end
+        }
+
         it { room.send(:internal_create_meeting) }
       end
     end
 
-    context "schedules a BigbluebuttonMeetingUpdater" do
+    context "adds the dynamic metadata, if any" do
       before { mock_server_and_api }
       let(:room) { FactoryGirl.create(:bigbluebutton_room) }
 
       before {
-        mocked_api.stub(:create_meeting)
         mocked_api.stub(:"request_headers=")
         room.server = mocked_server
       }
-      before(:each) {
-        expect {
-          room.send(:internal_create_meeting)
-        }.to change{ Resque.info[:pending] }.by(1)
-      }
-      subject { Resque.peek(:bigbluebutton_rails) }
-      it("should have a job schedule") { subject.should_not be_nil }
-      it("the job should be the right one") { subject['class'].should eq('BigbluebuttonMeetingUpdater') }
-      it("the job should have the correct parameters") { subject['args'].should eq([room.id]) }
+
+      it { room.should_not respond_to(:dynamic_metadata) }
+
+      context "doesn't havedefault dynamic metadata" do
+        before {
+          mocked_api.should_receive(:create_meeting) do |name, meetingid, opts|
+            opts.each do |key, value|
+              key.should_not match(/meta_/)
+            end
+          end
+        }
+        it { room.send(:internal_create_meeting) }
+      end
+
+      context "doesn't add the dynamic metadata if it returns nil" do
+        before {
+          BigbluebuttonRoom.class_eval do
+            def dynamic_metadata
+              nil
+            end
+          end
+
+          room.should respond_to(:dynamic_metadata)
+          mocked_api.should_receive(:create_meeting) do |name, meetingid, opts|
+            opts.each do |key, value|
+              key.should_not match(/meta_/)
+            end
+          end
+        }
+        after {
+          BigbluebuttonRoom.class_eval do
+            undef_method :dynamic_metadata
+          end
+        }
+
+        it { room.send(:internal_create_meeting) }
+      end
+
+      context "adds the value returned by BigbluebuttonRoom#invitation_url" do
+        before {
+          BigbluebuttonRoom.class_eval do
+            def dynamic_metadata
+              {
+                "test1" => "value1",
+                "test2" => "value2"
+              }
+            end
+          end
+
+          room.should respond_to(:dynamic_metadata)
+          mocked_api.should_receive(:create_meeting) do |name, meetingid, opts|
+            opts.should include('meta_test1' => 'value1')
+            opts.should include('meta_test2' => 'value2')
+          end
+        }
+        after {
+          BigbluebuttonRoom.class_eval do
+            undef_method :dynamic_metadata
+          end
+        }
+
+        it { room.send(:internal_create_meeting) }
+      end
     end
   end
 end