bigbluebutton_rails 2.2.0 → 2.3.0

data/spec/models/bigbluebutton_room_spec.rb

@@ -38,7 +38,7 @@ describe BigbluebuttonRoom do
   it { should ensure_length_of(:meetingid).is_at_least(1).is_at_most(100) }
 
   it { should validate_presence_of(:name) }
-  it { should ensure_length_of(:name).is_at_least(1).is_at_most(150) }
+  it { should ensure_length_of(:name).is_at_least(1).is_at_most(250) }
 
   it { should validate_presence_of(:param) }
   it { should validate_uniqueness_of(:param) }
@@ -63,8 +63,8 @@ describe BigbluebuttonRoom do
   it { should accept_nested_attributes_for(:metadata).allow_destroy(true) }
 
   # attr_accessors
-  [:running, :participant_count, :moderator_count, :attendees,
-   :has_been_forcibly_ended, :start_time, :end_time, :external,
+  [:running, :participant_count, :moderator_count, :current_attendees,
+   :has_been_forcibly_ended, :create_time, :end_time, :external,
    :request_headers, :record_meeting, :duration].each do |attr|
     it { should respond_to(attr) }
     it { should respond_to("#{attr}=") }
@@ -80,6 +80,105 @@ describe BigbluebuttonRoom do
 
   it { should respond_to(:is_running?) }
 
+  describe ".order_by_activity" do
+    let!(:room1) { FactoryGirl.create(:bigbluebutton_room) }
+    let!(:room2) { FactoryGirl.create(:bigbluebutton_room) }
+    let!(:room3) { FactoryGirl.create(:bigbluebutton_room) }
+    let!(:room4) { FactoryGirl.create(:bigbluebutton_room) }
+    let!(:meeting1) { FactoryGirl.create(:bigbluebutton_meeting, create_time: Time.now - 2.hours, room: room1) }
+    let!(:meeting2) { FactoryGirl.create(:bigbluebutton_meeting, create_time: Time.now, room: room2) }
+    let!(:meeting3) { FactoryGirl.create(:bigbluebutton_meeting, create_time: Time.now - 1.hour, room: room3) }
+    let!(:meeting4) { FactoryGirl.create(:bigbluebutton_meeting, create_time: Time.now - 3.hour, room: room4) }
+
+    context "ASC" do
+      subject { BigbluebuttonRoom.order_by_activity }
+      it { subject[0].should eql(room4) }
+      it { subject[1].should eql(room1) }
+      it { subject[2].should eql(room3) }
+      it { subject[3].should eql(room2) }
+    end
+
+    context "DESC" do
+      subject { BigbluebuttonRoom.order_by_activity('DESC') }
+      it { subject[0].should eql(room2) }
+      it { subject[1].should eql(room3) }
+      it { subject[2].should eql(room1) }
+      it { subject[3].should eql(room4) }
+    end
+  end
+
+  describe ".search_by_terms" do
+    let!(:rooms) {
+      [
+        FactoryGirl.create(:bigbluebutton_room, name: "La Lo", param: "lalo-1"),
+        FactoryGirl.create(:bigbluebutton_room, name: "La Le", param: "lale-2"),
+        FactoryGirl.create(:bigbluebutton_room, name: "Li Lo", param: "lilo")
+      ]
+    }
+    let(:subject) { BigbluebuttonRoom.search_by_terms(terms) }
+
+    context '1 term finds something' do
+      let(:terms) { ['la'] }
+      it { subject.count.should be(2) }
+      it { subject.should include(rooms[0], rooms[1]) }
+    end
+
+    context 'composite term finds something' do
+      let(:terms) { ['la lo'] }
+      it { subject.count.should be(1) }
+      it { subject.should include(rooms[0]) }
+    end
+
+    context '2 terms find something' do
+      let(:terms) { ['la', 'lo'] }
+      it { subject.count.should be(3) }
+      it { subject.should include(rooms[0], rooms[1], rooms[2]) }
+    end
+
+    context '1 term finds nothing 1 term finds something' do
+      let(:terms) { ['la', 'notfound'] }
+      it { subject.count.should be(2) }
+      it { subject.should include(rooms[0], rooms[1]) }
+    end
+
+    context '1 term finds nothing' do
+      let(:terms) { ['notfound'] }
+      it { subject.count.should eq(0) }
+    end
+
+    context 'multiple terms find nothing' do
+      let(:terms) { ['nope', 'not', 'found'] }
+      it { subject.count.should eq(0) }
+    end
+
+    context "searches by both name and params" do
+      let(:terms) { ['abcdef'] }
+      before {
+        rooms[1].update_attributes(name: 'abcdef')
+        rooms[2].update_attributes(param: 'abcdef')
+      }
+      it { subject.count.should be(2) }
+      it { subject.should include(rooms[1], rooms[2]) }
+    end
+
+    context "returns a Relation object" do
+      let(:terms) { [''] }
+      it { subject.should be_kind_of(ActiveRecord::Relation) }
+    end
+
+    context "accepts a string as parameter" do
+      let(:terms) { 'la' }
+      it { subject.count.should be(2) }
+      it { subject.should include(rooms[0], rooms[1]) }
+    end
+
+    context "is chainable" do
+      subject { BigbluebuttonRoom.search_by_terms('l').where(id: rooms[0].id) }
+      it { subject.count.should be(1) }
+      it { subject.should include(rooms[0]) }
+    end
+  end
+
   describe "#user_role" do
     let(:room) { FactoryGirl.build(:bigbluebutton_room, :moderator_key => "mod", :attendee_key => "att") }
     it { should respond_to(:user_role) }
@@ -136,9 +235,9 @@ describe BigbluebuttonRoom do
       room.moderator_count.should be(0)
       room.running.should be(false)
       room.has_been_forcibly_ended.should be(false)
-      room.start_time.should be_nil
+      room.create_time.should be_nil
       room.end_time.should be_nil
-      room.attendees.should eql([])
+      room.current_attendees.should eql([])
       room.request_headers.should == {}
     end
 
@@ -308,10 +407,10 @@ describe BigbluebuttonRoom do
         it { room.has_been_forcibly_ended.should == false }
         it { room.participant_count.should == 0 }
         it { room.moderator_count.should == 0 }
-        it { room.start_time.should == nil }
+        it { room.create_time.should == nil }
         it { room.reload.create_time.should == nil }
         it { room.end_time.should == nil }
-        it { room.attendees.should == [] }
+        it { room.current_attendees.should == [] }
       end
 
       context "fetches meeting info when the meeting is running" do
@@ -325,14 +424,15 @@ describe BigbluebuttonRoom do
         it { room.has_been_forcibly_ended.should == false }
         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|
             attendee = BigbluebuttonAttendee.new
             attendee.from_hash(att)
-            room.attendees.should include(attendee)
+            found = room.current_attendees.select{ |a| a.user_name == attendee.user_name }[0]
+            found.user_id.should eql(attendee.user_id)
+            found.role.should eql(attendee.role)
           end
         }
       end
@@ -432,7 +532,7 @@ describe BigbluebuttonRoom do
         it { room.send_end }
       end
 
-      context "schedules a BigbluebuttonMeetingUpdater" do
+      context "schedules a BigbluebuttonMeetingUpdaterWorker" do
         before {
           room.should_receive(:select_server).and_return(mocked_server)
           mocked_api.should_receive(:end_meeting)
@@ -442,8 +542,8 @@ 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("should have a job scheduled") { subject.should_not be_nil }
+        it("the job should be the right one") { subject['class'].should eq('BigbluebuttonMeetingUpdaterWorker') }
         it("the job should have the correct parameters") { subject['args'].should eq([room.id]) }
       end
     end
@@ -491,8 +591,9 @@ describe BigbluebuttonRoom do
 
       context "sets the room's create_time" do
         before do
+          # BigbluebuttonRails.configuration.should_receive(:get_create_options).and_return(Proc.new{ expected_params })
           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.send_create
@@ -502,9 +603,9 @@ describe BigbluebuttonRoom do
       end
 
       context "sends create_meeting" do
-
         context "for a stored room" do
           before do
+            #BigbluebuttonRails.configuration.should_receive(:get_create_options).and_return(Proc.new{ expected_params })
             mocked_api.should_receive(:create_meeting)
               .with(room.name, room.meetingid, expected_params)
               .and_return(hash_create)
@@ -520,7 +621,8 @@ describe BigbluebuttonRoom do
         context "for a new record" do
           let(:new_room) { FactoryGirl.build(:bigbluebutton_room) }
           before do
-            params  = get_create_params(new_room)
+            params = get_create_params(new_room)
+            # BigbluebuttonRails.configuration.should_receive(:get_create_options).and_return(Proc.new{ params })
             mocked_api.should_receive(:create_meeting)
               .with(new_room.name, new_room.meetingid, params)
               .and_return(hash_create)
@@ -552,16 +654,31 @@ describe BigbluebuttonRoom do
           it { room.changed?.should be(false) }
         end
 
-        context "passing additional options" do
+        context "passing metadata from the db" do
+          let(:user) { FactoryGirl.build(:user) }
+          before do
+            mocked_api.should_receive(:create_meeting)
+              .with(room.name, room.meetingid, get_create_params(room, user))
+              .and_return(hash_create)
+            room.stub(:select_server).and_return(mocked_server)
+            room.send_create(user)
+          end
+          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 user options" do
           let(:user) { FactoryGirl.build(:user) }
           let(:user_opts) { { :record_meeting => false, :other => true } }
           before do
             params = get_create_params(room, user).merge(user_opts)
+            BigbluebuttonRails.configuration.should_receive(:get_create_options).and_return(Proc.new{ user_opts })
             mocked_api.should_receive(:create_meeting)
               .with(room.name, room.meetingid, params)
               .and_return(hash_create)
             room.stub(:select_server).and_return(mocked_server)
-            room.send_create(user, user_opts)
+            room.send_create(user)
           end
           it { room.attendee_api_password.should be(new_attendee_api_password) }
           it { room.moderator_api_password.should be(new_moderator_api_password) }
@@ -572,9 +689,8 @@ describe BigbluebuttonRoom 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))
+              .with(room.name, room.meetingid, expected_params)
               .and_return(hash_create)
             room.stub(:select_server).and_return(mocked_server)
             room.send_create
@@ -598,7 +714,6 @@ describe BigbluebuttonRoom 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)
@@ -612,9 +727,8 @@ describe BigbluebuttonRoom 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))
+                .with(room.name, room.meetingid, expected_params)
                 .and_return(hash_create)
               room.stub(:select_server).and_return(mocked_server)
               room.send_create
@@ -624,30 +738,43 @@ describe BigbluebuttonRoom do
         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)
+          context "set the correct attributes in the 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)
 
-            expect {
-              room.send_create
-            }.to change{ BigbluebuttonMeeting.count }.by(1)
+              expect {
+                room.send_create
+              }.to change{ BigbluebuttonMeeting.count }.by(1)
+            end
+            subject { BigbluebuttonMeeting.last }
+            it { subject.room.should eql(room) }
+            it { subject.server_url.should eql(mocked_server.url) }
+            it { subject.server_secret.should eql(mocked_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.ended.should eql(false) }
+          end
+
+          context "calls create_meeting_record with the correct arguments" do
+            let(:user_opts) { { opt1: 1, opt2: 'two' } }
+            let(:response) { { response: 1 } }
+            before do
+              BigbluebuttonRails.configuration.should_receive(:get_create_options).and_return(Proc.new{ user_opts })
+              room.should_receive(:internal_create_meeting) do
+                ['my-server', response]
+              end
+              room.should_receive(:create_meeting_record).with(response, 'my-server', 'my-user', user_opts)
+            end
+            it { room.send_create('my-user') }
           end
-          subject { BigbluebuttonMeeting.last }
-          it { subject.room.should eql(room) }
-          it { subject.server_url.should eql(mocked_server.url) }
-          it { subject.server_secret.should eql(mocked_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
+        context "enqueues a BigbluebuttonMeetingUpdaterWorker" do
           before do
             mocked_api.should_receive(:create_meeting)
               .with(room.name, room.meetingid, expected_params)
@@ -660,7 +787,7 @@ describe BigbluebuttonRoom do
           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 be the right one") { subject['class'].should eq('BigbluebuttonMeetingUpdaterWorker') }
           it("the job should have the correct parameters") { subject['args'].should eq([room.id, 10]) }
         end
       end
@@ -744,6 +871,7 @@ describe BigbluebuttonRoom do
         before do
           room.full_logout_url = "full-version-of-logout-url"
           hash = get_create_params(room).merge({ :logoutURL => "full-version-of-logout-url" })
+          # BigbluebuttonRails.configuration.should_receive(:get_create_options).and_return(Proc.new{ hash })
           mocked_api.should_receive(:create_meeting).
             with(room.name, room.meetingid, hash).and_return(hash_create)
           room.stub(:select_server).and_return(mocked_server)
@@ -890,6 +1018,164 @@ describe BigbluebuttonRoom do
       end
     end
 
+    describe "#parameterized_join_url" do
+      let(:username) { Forgery(:name).full_name }
+      let(:role) { :attendee }
+      let(:id) { 'fake-user-id' }
+
+      context "sets a config token" do
+        context "when it exists" do
+          before {
+            room.create_time = nil
+            room.should_receive(:fetch_new_token).and_return('fake-token')
+            room.should_receive(:join_url).with(username, role, nil, { configToken: 'fake-token' })
+          }
+          it { room.parameterized_join_url(username, role, nil) }
+        end
+
+        context "not when it doesn't exist" do
+          before {
+            room.create_time = nil
+            room.should_receive(:fetch_new_token).and_return(nil)
+            room.should_receive(:join_url).with(username, role, nil, { })
+          }
+          it { room.parameterized_join_url(username, role, nil) }
+        end
+
+        context "not when a token is passed in the options" do
+          before {
+            room.create_time = nil
+            room.should_not_receive(:fetch_new_token)
+            room.should_receive(:join_url).with(username, role, nil, { configToken: "any" })
+          }
+          it { room.parameterized_join_url(username, role, nil, { configToken: "any" }) }
+        end
+      end
+
+      context "sets a create time" do
+        context "when it exists" do
+          before {
+            room.stub(:fetch_new_token).and_return(nil)
+            room.should_receive(:join_url).with(username, role, nil, { createTime: room.create_time })
+          }
+          it { room.parameterized_join_url(username, role, nil) }
+        end
+
+        context "when it doesn't exist" do
+          before {
+            room.create_time = nil
+            room.stub(:fetch_new_token).and_return(nil)
+            room.should_receive(:join_url).with(username, role, nil, { })
+          }
+          it { room.parameterized_join_url(username, role, nil) }
+        end
+      end
+
+      context "sets a user id" do
+        context "when it exists" do
+          before {
+            room.create_time = nil
+            room.stub(:fetch_new_token).and_return(nil)
+            room.should_receive(:join_url).with(username, role, nil, { userID: 'fake-user-id' })
+          }
+          it { room.parameterized_join_url(username, role, 'fake-user-id') }
+        end
+
+        context "when it doesn't exist" do
+          before {
+            room.create_time = nil
+            room.stub(:fetch_new_token).and_return(nil)
+            room.should_receive(:join_url).with(username, role, nil, { })
+          }
+          it { room.parameterized_join_url(username, role, nil) }
+        end
+      end
+
+      context "uses the options in the parameters" do
+        context "when the are set" do
+          let(:options) { { option1: 'value1' } }
+          before {
+            room.create_time = nil
+            room.stub(:fetch_new_token).and_return(nil)
+            room.should_receive(:join_url).with(username, role, nil, options)
+          }
+          it { room.parameterized_join_url(username, role, nil, options) }
+        end
+
+        context "overrides the options set internally by the method" do
+          let(:options) { { option1: 'value1', configToken: 'opts-token', createTime: 123, userID: 'opts-userid' } }
+          before {
+            room.stub(:fetch_new_token).and_return('valid')
+            room.should_receive(:join_url).with(username, role, nil, options)
+          }
+          it { room.parameterized_join_url(username, role, 'opts-userid', options) }
+        end
+      end
+
+      context "uses the options passed by the application" do
+        context "when the are set" do
+          let(:options) { { option1: 'value1' } }
+          before {
+            BigbluebuttonRails.configuration.stub(:get_join_options).and_return(Proc.new{ options })
+            room.create_time = nil
+            room.stub(:fetch_new_token).and_return(nil)
+            room.should_receive(:join_url).with(username, role, nil, options)
+          }
+          it { room.parameterized_join_url(username, role, nil, {}) }
+        end
+
+        context "overrides the options set internally by the method" do
+          let(:options) { { option1: 'value1', configToken: 'valid', createTime: 'valid', userID: 'valid' } }
+          let(:expected_options) { { option1: 'value1', configToken: 'valid', createTime: 'valid', userID: 'valid' } }
+          before {
+            BigbluebuttonRails.configuration.stub(:get_join_options).and_return(Proc.new{ options })
+            room.stub(:fetch_new_token).and_return('invalid')
+            room.should_receive(:join_url).with(username, role, nil, expected_options)
+          }
+          it { room.parameterized_join_url(username, role, 'invalid', {}) }
+        end
+
+        context "calls get_join_options with the correct parameters" do
+          context "if the user is passed in the arguments" do
+            let(:user) { 'any user' }
+            before {
+              proc = double(Proc)
+              proc.should_receive(:call).with(room, user)
+              BigbluebuttonRails.configuration.should_receive(:get_join_options).and_return(proc)
+              room.stub(:fetch_new_token).and_return(nil)
+              room.stub(:join_url)
+            }
+            it { room.parameterized_join_url(username, role, nil, {}, user) }
+          end
+
+          context "if the user is not passed in the arguments" do
+            before {
+              proc = double(Proc)
+              proc.should_receive(:call).with(room, nil)
+              BigbluebuttonRails.configuration.should_receive(:get_join_options).and_return(proc)
+              room.stub(:fetch_new_token).and_return(nil)
+              room.stub(:join_url)
+            }
+            it { room.parameterized_join_url(username, role, nil, {}, nil) }
+          end
+        end
+      end
+
+      context "returns #join_url" do
+        let(:expected_url) { 'https://fake-return-url.no/join?here=1' }
+        before {
+          room.stub(:fetch_new_token).and_return('fake-token')
+          room.should_receive(:join_url)
+            .with(username, role, nil, {
+                    userID: 'fake-user-id', configToken: 'fake-token', createTime: room.create_time
+                  }).and_return(expected_url)
+        }
+        it {
+          room.parameterized_join_url(username, role, 'fake-user-id').should eql(expected_url)
+        }
+      end
+    end
+
     describe "#fetch_new_token" do
       let(:config_xml) {
         '<config>
@@ -942,8 +1228,25 @@ describe BigbluebuttonRoom do
         }
         it("returns nil") { room.fetch_new_token.should be_nil }
       end
-    end
 
+      context "when used with a block" do
+        before {
+          room.room_options.should_receive(:is_modified?)
+            .and_return(true)
+          mocked_api.should_receive(:get_default_config_xml).and_return(config_xml)
+          room.room_options.should_not_receive(:set_on_config_xml)
+          mocked_server.should_receive(:update_config).with('fake-xml-from-block')
+          mocked_api.should_receive(:set_config_xml)
+            .with(room.meetingid, 'fake-xml-from-block')
+        }
+        it("uses the xml returned by the block") {
+          room.fetch_new_token do |xml|
+            xml.should eql(config_xml)
+            'fake-xml-from-block'
+          end
+        }
+      end
+    end
   end
 
   context "#available_layouts" do
@@ -1129,7 +1432,7 @@ describe BigbluebuttonRoom do
     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_create).with(user)
         room.should_receive(:send_end)
       }
       subject { room.create_meeting(user) }
@@ -1153,7 +1456,7 @@ describe BigbluebuttonRoom do
     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_create).with(user)
         room.should_receive(:send_end) { raise BigBlueButton::BigBlueButtonException.new('test') }
       }
       it {
@@ -1170,9 +1473,14 @@ describe BigbluebuttonRoom do
     it { should respond_to(:"full_logout_url=") }
   end
 
+  describe "#short_path" do
+    subject { FactoryGirl.create(:bigbluebutton_room) }
+    it { subject.short_path.should eql("/bigbluebutton/rooms/#{subject.to_param}/join") }
+  end
+
   describe "#select_server" do
-    let(:server) { FactoryGirl.create(:bigbluebutton_server) }
-    let(:room) { FactoryGirl.create(:bigbluebutton_room) }
+    let!(:server) { FactoryGirl.create(:bigbluebutton_server) }
+    let!(:room) { FactoryGirl.create(:bigbluebutton_room) }
 
     it { room.respond_to?(:select_server, true).should be(true) }
 
@@ -1205,46 +1513,13 @@ describe BigbluebuttonRoom do
         room.send(:get_metadata_for_create).should == result
       }
     end
-
-    context "returns the dynamic metadata, if any" do
-      before {
-        BigbluebuttonRails.configure do |config|
-          config.get_dynamic_metadata = Proc.new do |room|
-            { "test1" => "value1", "test2" => "value2" }
-          end
-        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 {
-        BigbluebuttonRails.configure do |config|
-          config.get_dynamic_metadata = Proc.new do |room|
-            { "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")
-      }
-
-      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
     let(:room) { FactoryGirl.create(:bigbluebutton_room) }
 
-    context "if there's no start_time set in the room" do
-      before { room.start_time = nil }
+    context "if there's no create_time set in the room" do
+      before { room.create_time = nil }
       it { room.get_current_meeting.should be_nil }
     end
 
@@ -1280,7 +1555,7 @@ describe BigbluebuttonRoom do
       before {
         room.create_time = Time.now.utc
         room.running = !room.running # to change its default value
-        room.start_time = Time.at(Time.now.to_i - 123)  # to change its default value
+        room.create_time = Time.at(Time.now.to_i - 123)  # to change its default value
       }
 
       context "and no metadata was passed" do
@@ -1294,7 +1569,7 @@ describe BigbluebuttonRoom do
         }
         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 create_time") { subject.create_time.should eq(room.create_time.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
@@ -1310,7 +1585,7 @@ describe BigbluebuttonRoom do
         }
         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 create_time") { subject.create_time.should eq(room.create_time.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
@@ -1326,7 +1601,7 @@ describe BigbluebuttonRoom do
         }
         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 create_time") { subject.create_time.should eq(room.create_time.to_i) }
         it("sets ended") { subject.ended.should be(false) }
       end
     end
@@ -1340,7 +1615,7 @@ describe BigbluebuttonRoom do
       let!(:meeting) { FactoryGirl.create(:bigbluebutton_meeting, room: room, ended: false, running: true, create_time: room.create_time) }
       subject {
         expect {
-          room.create_meeting_record
+          room.create_meeting_record({}, server, nil, {})
         }.not_to change{ BigbluebuttonMeeting.count }
       }
       it { BigbluebuttonMeeting.where(room: room).count.should be(1) }
@@ -1368,15 +1643,14 @@ describe BigbluebuttonRoom do
         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
+        room.create_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
+        context "and there's no metadata in the response" do
           before(:each) {
             expect {
-              room.should_receive(:select_server).and_return(server)
-              room.create_meeting_record
+              room.create_meeting_record({}, server, nil, {})
             }.to change{ BigbluebuttonMeeting.count }.by(1)
           }
           subject { BigbluebuttonMeeting.last }
@@ -1387,21 +1661,45 @@ describe BigbluebuttonRoom do
           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("sets create_time") { subject.create_time.should eq(room.create_time.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
+        context "and there's metadata in the response" do
           before(:each) {
             expect {
-              room.create_meeting_record(metadata)
+              room.create_meeting_record({ metadata: metadata }, server, nil, {})
             }.to change{ BigbluebuttonMeeting.count }.by(1)
           }
           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
+
+        context "and there are user attributes" do
+          let(:user_attrs) {
+            {
+              meetingID: room.meetingid + "-2",
+              name: room.name + "-2",
+              record: false, # important to be false here
+              creator_name: "can override the creator name",
+              creator_id: -10
+            }
+          }
+          before {
+            room.record_meeting = true
+            expect {
+              room.create_meeting_record({}, server, nil, user_attrs)
+            }.to change{ BigbluebuttonMeeting.count }.by(1)
+          }
+          subject { BigbluebuttonMeeting.last }
+          it("sets meetingid") { subject.meetingid.should eql(room.meetingid + '-2') }
+          it("sets name") { subject.name.should eql(room.name + '-2') }
+          it("sets recorded") { subject.recorded.should be(false) }
+          it("sets creator name") { subject.creator_name.should eql("can override the creator name") }
+          it("sets creator id") { subject.creator_id.should eql(-10) }
+        end
       end
 
       context "if there were already old meetings associated with the room, finishes them" do
@@ -1411,7 +1709,7 @@ describe BigbluebuttonRoom do
         before(:each) {
           BigbluebuttonMeeting.where(room: room, ended: false).count.should be(2)
           expect {
-            room.create_meeting_record(metadata)
+            room.create_meeting_record({ metadata: metadata }, server, nil, {})
           }.to change{ BigbluebuttonMeeting.count }.by(1)
         }
         it { BigbluebuttonMeeting.where(room: room).count.should be(3) }
@@ -1444,16 +1742,45 @@ describe BigbluebuttonRoom do
 
     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 }
+      let!(:now) { DateTime.now }
+      before(:each) {
+        DateTime.stub(:now).and_return(now)
+        room.finish_meetings
+      }
       it { meeting.reload.running.should be(false) }
       it { meeting.reload.ended.should be(true) }
+      it { meeting.reload.finish_time.should be(now.strftime("%Q").to_i) }
     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 }
+      let!(:now) { DateTime.now }
+      before(:each) {
+        DateTime.stub(:now).and_return(now)
+        room.finish_meetings
+      }
       it { meeting.reload.running.should be(false) }
       it { meeting.reload.ended.should be(true) }
+      it { meeting.reload.finish_time.should be(now.strftime("%Q").to_i) }
+    end
+
+    context "enqueues workers to fetch recordings" do
+      context "if at least one meeting was 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) }
+        before {
+          expect(Resque).to receive(:enqueue_in).with(4.minutes, ::BigbluebuttonRecordingsForRoomWorker, room.id, 3)
+        }
+        it { room.finish_meetings }
+      end
+
+      context "not if no meeting was ended" do
+        let!(:meeting1) { FactoryGirl.create(:bigbluebutton_meeting, room: room, ended: true, running: true) }
+        before {
+          expect(Resque).not_to receive(:enqueue_in)
+        }
+        it { room.finish_meetings }
+      end
     end
   end
 
@@ -1464,6 +1791,7 @@ describe BigbluebuttonRoom do
     it "sets the request headers"
     it "calls api.create_meeting"
     it "accepts additional user options to override the options in the database"
+    it "returns the server selected and the response"
 
     context "adds the invitation URL, if any" do
       before { mock_server_and_api }
@@ -1520,62 +1848,21 @@ describe BigbluebuttonRoom do
       end
     end
 
-    context "adds the dynamic metadata, if any" do
+    context "adds the options from user_opts" do
       before { mock_server_and_api }
       let(:room) { FactoryGirl.create(:bigbluebutton_room) }
-
+      let(:user_opts) { { "meta_test1" => "value1", "meta_test2" => "value2" } }
       before {
         room.stub(:select_server).and_return(mocked_server)
         mocked_api.stub(:"request_headers=")
-      }
-
-      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 {
-          BigbluebuttonRails.configure do |config|
-            config.get_dynamic_metadata = Proc.new do |room|
-              nil
-            end
-          end
-
-          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 "adds the value returned by BigbluebuttonRoom#invitation_url" do
-        before {
-          BigbluebuttonRails.configure do |config|
-            config.get_dynamic_metadata = Proc.new do |room|
-              { "test1" => "value1", "test2" => "value2" }
-            end
-          end
 
-          mocked_api.should_receive(:create_meeting) do |name, meetingid, opts|
-            opts.should include('meta_test1' => 'value1')
-            opts.should include('meta_test2' => 'value2')
-          end
-        }
+        mocked_api.should_receive(:create_meeting) do |name, meetingid, opts|
+          opts.should include('meta_test1' => 'value1')
+          opts.should include('meta_test2' => 'value2')
+        end
+      }
 
-        it { room.send(:internal_create_meeting) }
-      end
+      it { room.send(:internal_create_meeting, nil, user_opts) }
     end
   end
 end
@@ -1594,12 +1881,12 @@ def get_create_params(room, user=nil)
     :autoStartRecording => room.auto_start_recording,
     :allowStartStopRecording => room.allow_start_stop_recording
   }
-  room.metadata.each { |meta| params["meta_#{meta.name}"] = meta.content }
   unless user.nil?
     userid = user.send(:id)
     username = user.send(:name)
     params.merge!({ "meta_bbbrails-user-id" => userid })
     params.merge!({ "meta_bbbrails-user-name" => username })
   end
+  room.metadata.each { |meta| params["meta_#{meta.name}"] = meta.content }
   params
 end