bigbluebutton_rails 2.1.0 → 2.2.0

data/spec/controllers/bigbluebutton/servers_controller_spec.rb

@@ -142,7 +142,6 @@ describe Bigbluebutton::ServersController do
 
   describe "#update" do
     let(:new_server) { FactoryGirl.build(:bigbluebutton_server) }
-    before { @server = server } # need this to trigger let(:server) and actually create the object
 
     context "on success" do
       let(:new_server) { FactoryGirl.build(:bigbluebutton_server, version: "") }
@@ -150,16 +149,16 @@ describe Bigbluebutton::ServersController do
       before {
         BigBlueButton::BigBlueButtonApi.any_instance.should_receive(:get_api_version).and_return("0.9")
         expect {
-          put :update, id: @server.to_param, bigbluebutton_server: new_server.attributes
+          put :update, id: server.to_param, bigbluebutton_server: new_server.attributes
         }.not_to change { BigbluebuttonServer.count }
       }
       it {
-        saved = BigbluebuttonServer.find(@server)
+        saved = BigbluebuttonServer.find(server)
         should respond_with(:redirect)
         should redirect_to(bigbluebutton_server_path(saved))
       }
       it {
-        saved = BigbluebuttonServer.find(@server)
+        saved = BigbluebuttonServer.find(server)
         saved.should_not have_same_attributes_as(new_server)
         saved.version.should == "0.9"
       }
@@ -169,10 +168,10 @@ describe Bigbluebutton::ServersController do
     context "on failure" do
       before :each do
         new_server.url = nil # invalid
-        put :update, :id => @server.to_param, :bigbluebutton_server => new_server.attributes
+        put :update, :id => server.to_param, :bigbluebutton_server => new_server.attributes
       end
       it { should render_template(:edit) }
-      it { should assign_to(:server).with(@server) }
+      it { should assign_to(:server).with(server) }
     end
 
     describe "params handling" do
@@ -185,12 +184,12 @@ describe Bigbluebutton::ServersController do
       it {
         # we just check that the rails method 'permit' is being called on the hash with the
         # correct parameters
-        BigbluebuttonServer.stub(:find_by_param).and_return(@server)
-        @server.stub(:update_attributes).and_return(true)
+        BigbluebuttonServer.stub(:find_by_param).and_return(server)
+        server.stub(:update_attributes).and_return(true)
         attrs.stub(:permit).and_return(attrs)
         controller.stub(:params).and_return(params)
 
-        put :update, :id => @server.to_param, :bigbluebutton_server => attrs
+        put :update, :id => server.to_param, :bigbluebutton_server => attrs
         attrs.should have_received(:permit).with(*allowed_params)
       }
     end
@@ -198,8 +197,8 @@ describe Bigbluebutton::ServersController do
     # to make sure it doesn't break if the hash informed doesn't have the key :bigbluebutton_server
     describe "if parameters are not informed" do
       it {
-        put :update, :id => @server.to_param
-        should redirect_to(bigbluebutton_server_path(@server))
+        put :update, :id => server.to_param
+        should redirect_to(bigbluebutton_server_path(server))
       }
     end
 
@@ -207,7 +206,7 @@ describe Bigbluebutton::ServersController do
       context "on success" do
         before(:each) {
           BigbluebuttonServer.any_instance.should_receive(:set_api_version_from_server).and_return(anything)
-          put :update, :id => @server.to_param, :bigbluebutton_server => new_server.attributes, :redir_url => '/any'
+          put :update, :id => server.to_param, :bigbluebutton_server => new_server.attributes, :redir_url => '/any'
         }
         it { should respond_with(:redirect) }
         it { should redirect_to "/any" }
@@ -216,7 +215,7 @@ describe Bigbluebutton::ServersController do
       context "on failure" do
         before(:each) {
           new_server.url = nil # invalid
-          put :update, :id => @server.to_param, :bigbluebutton_server => new_server.attributes, :redir_url => '/any'
+          put :update, :id => server.to_param, :bigbluebutton_server => new_server.attributes, :redir_url => '/any'
         }
         it { should respond_with(:redirect) }
         it { should redirect_to "/any" }
@@ -228,7 +227,7 @@ describe Bigbluebutton::ServersController do
       before { controller.instance_variable_set(:@server, other_server) }
       before(:each) {
         BigbluebuttonServer.any_instance.should_receive(:set_api_version_from_server).and_return(anything)
-        put :update, :id => @server.to_param, :bigbluebutton_server => new_server.attributes
+        put :update, :id => server.to_param, :bigbluebutton_server => new_server.attributes
       }
       it { should assign_to(:server).with(other_server) }
     end
@@ -266,8 +265,8 @@ describe Bigbluebutton::ServersController do
   end
 
   describe "#activity" do
-    let(:room1) { FactoryGirl.create(:bigbluebutton_room, :server => server) }
-    let(:room2) { FactoryGirl.create(:bigbluebutton_room, :server => server) }
+    let(:room1) { FactoryGirl.create(:bigbluebutton_room) }
+    let(:room2) { FactoryGirl.create(:bigbluebutton_room) }
     before do
       # return our mocked server
       BigbluebuttonServer.stub(:find_by_param).with(server.to_param).
@@ -335,40 +334,6 @@ describe Bigbluebutton::ServersController do
     end
   end # #activity
 
-  describe "#rooms" do
-    context "basic" do
-      before do
-        @room1 = FactoryGirl.create(:bigbluebutton_room, :server => server)
-        @room2 = FactoryGirl.create(:bigbluebutton_room, :server => server)
-        FactoryGirl.create(:bigbluebutton_room)
-      end
-      before(:each) { get :rooms, :id => server.to_param }
-      it { should respond_with(:success) }
-      it { should render_template(:rooms) }
-      it { should assign_to(:rooms).with([@room1, @room2]) }
-    end
-
-    context "doesn't override @server" do
-      let!(:other_server) { FactoryGirl.create(:bigbluebutton_server) }
-      before { controller.instance_variable_set(:@server, other_server) }
-      before(:each) { get :rooms, :id => server.to_param }
-      it { should assign_to(:server).with(other_server) }
-    end
-
-    context "doesn't override @rooms" do
-      let!(:my_rooms) {
-        [ FactoryGirl.create(:bigbluebutton_room, server: server),
-          FactoryGirl.create(:bigbluebutton_room, server: server) ]
-      }
-      before {
-        3.times { FactoryGirl.create(:bigbluebutton_room, server: server) }
-        controller.instance_variable_set(:@rooms, my_rooms)
-      }
-      before(:each) { get :rooms, :id => server.to_param }
-      it { should assign_to(:rooms).with(my_rooms) }
-    end
-  end
-
   describe "#publish_recordings" do
     let(:recording_ids) { "id1,id2,id3" }
     before do
@@ -553,7 +518,7 @@ describe Bigbluebutton::ServersController do
         FactoryGirl.create(:bigbluebutton_recording)
 
         # one that belongs to another server but to a room that's in the target server
-        room = FactoryGirl.create(:bigbluebutton_room, :server => server)
+        room = FactoryGirl.create(:bigbluebutton_room)
         FactoryGirl.create(:bigbluebutton_recording, :room => room)
       end
       before(:each) { get :recordings, :id => server.to_param }
@@ -583,4 +548,20 @@ describe Bigbluebutton::ServersController do
     end
   end
 
+  describe "#check" do
+    before do
+      # return our mocked server
+      BigbluebuttonServer.stub(:find_by_param).with(server.to_param).and_return(server)
+    end
+
+    context "on success" do
+      before(:each) {
+        server.should_receive(:check_url).and_return('http://test-server.com/check')
+        post :check, :id => server.to_param
+      }
+      it { should respond_with(:redirect) }
+      it { should redirect_to 'http://test-server.com/check' }
+    end
+  end
+
 end

data/spec/factories/bigbluebutton_meeting.rb

@@ -1,7 +1,6 @@
 FactoryGirl.define do
   factory :bigbluebutton_meeting do |m|
     m.sequence(:meetingid) { |n| "meeting-#{n}-" + SecureRandom.hex(4) }
-    m.association :server, :factory => :bigbluebutton_server
     m.association :room, :factory => :bigbluebutton_room
     m.sequence(:name) { |n| "Name#{n}" }
     m.recorded false

data/spec/factories/bigbluebutton_recording.rb

@@ -12,6 +12,7 @@ FactoryGirl.define do
     r.sequence(:recordid) { |n| "rec#{n}-#{SecureRandom.uuid}-#{DateTime.now.to_i}" }
     r.size { rand((20*1024**2)..(500*1024**2)) } # size ranging from 20Mb to 500Mb
     r.available true
+    r.description { Forgery(:lorem_ipsum).words(10) }
 
     after(:create) do |r|
       r.updated_at = r.updated_at.change(:usec => 0)

data/spec/factories/bigbluebutton_room.rb

@@ -3,7 +3,6 @@ FactoryGirl.define do
     # meetingid with a random factor to avoid duplicated ids in consecutive test runs
     r.sequence(:meetingid) { |n| "meeting-#{n}-" + SecureRandom.hex(4) }
 
-    r.association :server, :factory => :bigbluebutton_server
     r.sequence(:name) { |n| "Name#{n}" }
     r.attendee_key { Forgery(:basic).password :at_least => 10, :at_most => 16 }
     r.moderator_key { Forgery(:basic).password :at_least => 10, :at_most => 16 }

data/spec/models/bigbluebutton_meeting_db_spec.rb

@@ -4,7 +4,6 @@ describe BigbluebuttonMeeting do
 
   # to ensure that the migration is correct
   context "db" do
-    it { should have_db_column(:server_id).of_type(:integer) }
     it { should have_db_column(:room_id).of_type(:integer) }
     it { should have_db_column(:meetingid).of_type(:string) }
     it { should have_db_column(:name).of_type(:string) }

data/spec/models/bigbluebutton_meeting_spec.rb

@@ -8,9 +8,6 @@ describe BigbluebuttonMeeting do
 
   before { FactoryGirl.create(:bigbluebutton_meeting) }
 
-  it { should belong_to(:server) }
-  it { should_not validate_presence_of(:server_id) }
-
   it { should belong_to(:room) }
   it { should validate_presence_of(:room) }
 

data/spec/models/bigbluebutton_metadata_spec.rb

@@ -42,11 +42,11 @@ describe BigbluebuttonMetadata do
     before(:each) { subject.owner = FactoryGirl.create(:bigbluebutton_room) }
 
     it { should ensure_exclusion_of(:name)
-          .in_array(BigbluebuttonRails.metadata_invalid_keys.map(&:to_s)) }
+          .in_array(BigbluebuttonRails.configuration.metadata_invalid_keys.map(&:to_s)) }
 
     it "allows values to be added to the list of invalid metadata keys" do
-      old = BigbluebuttonRails.metadata_invalid_keys.clone
-      BigbluebuttonRails.metadata_invalid_keys.push("1")
+      old = BigbluebuttonRails.configuration.metadata_invalid_keys.clone
+      BigbluebuttonRails.configuration.metadata_invalid_keys.push("1")
       old.push("1")
       should ensure_exclusion_of(:name).in_array(old.map(&:to_s))
     end
@@ -54,7 +54,7 @@ describe BigbluebuttonMetadata do
     it "only invalidates if the metadata belongs to a room" do
       subject.owner = FactoryGirl.create(:bigbluebutton_recording)
       should_not ensure_exclusion_of(:name)
-        .in_array(BigbluebuttonRails.metadata_invalid_keys.map(&:to_s))
+        .in_array(BigbluebuttonRails.configuration.metadata_invalid_keys.map(&:to_s))
     end
   end
 end

data/spec/models/bigbluebutton_recording_spec.rb

@@ -66,6 +66,38 @@ describe BigbluebuttonRecording do
     end
   end
 
+  describe ".overall_average_length" do
+    context "when there's no recording" do
+      it { BigbluebuttonRecording.overall_average_length.should eql(0) }
+    end
+
+    context "when there are a few recordings" do
+      let!(:recording1) { FactoryGirl.create(:bigbluebutton_recording) }
+      let!(:recording2) { FactoryGirl.create(:bigbluebutton_recording) }
+      let!(:type_default) { FactoryGirl.create(:bigbluebutton_playback_type, default: true) }
+      let!(:type_other) { FactoryGirl.create(:bigbluebutton_playback_type, default: false) }
+      let!(:format_other_rec1) { FactoryGirl.create(:bigbluebutton_playback_format, recording: recording1, playback_type: type_other, length: 50) }
+      let!(:format_default_rec1) { FactoryGirl.create(:bigbluebutton_playback_format, recording: recording1, playback_type: type_default, length: 100) }
+      let!(:format_other_rec2) { FactoryGirl.create(:bigbluebutton_playback_format, recording: recording2, playback_type: type_other, length: 50) }
+      let!(:format_default_rec2) { FactoryGirl.create(:bigbluebutton_playback_format, recording: recording2, playback_type: type_default, length: 100) }
+
+      it { BigbluebuttonRecording.overall_average_length.should eql(6000.0) }
+    end
+  end
+
+  describe ".overall_average_size" do
+    context "when there's no recording" do
+      it { BigbluebuttonRecording.overall_average_size.should eql(0) }
+    end
+
+    context "when there are a few recordings" do
+      let!(:recording1) { FactoryGirl.create(:bigbluebutton_recording, size: 100000000) } # 100 MB
+      let!(:recording2) { FactoryGirl.create(:bigbluebutton_recording, size: 200000000) } # 200 MB
+
+      it { BigbluebuttonRecording.overall_average_size.should eql(150000000) }
+    end
+  end
+
   describe ".sync" do
     let(:data) {
       [

data/spec/models/bigbluebutton_room_db_spec.rb

@@ -4,7 +4,6 @@ describe BigbluebuttonRoom do
 
   # to ensure that the migration is correct
   context "db" do
-    it { should have_db_column(:server_id).of_type(:integer) }
     it { should have_db_column(:owner_id).of_type(:integer) }
     it { should have_db_column(:owner_type).of_type(:string) }
     it { should have_db_column(:meetingid).of_type(:string) }
@@ -26,7 +25,6 @@ describe BigbluebuttonRoom do
     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 "default values" do
       room = BigbluebuttonRoom.new

data/spec/models/bigbluebutton_room_spec.rb

@@ -1,4 +1,4 @@
-# -*- coding: utf-8 -*-
+# coding: utf-8
 require 'spec_helper'
 
 describe BigbluebuttonRoom do
@@ -8,9 +8,6 @@ describe BigbluebuttonRoom do
 
   before { FactoryGirl.create(:bigbluebutton_room) }
 
-  it { should belong_to(:server) }
-  it { should_not validate_presence_of(:server_id) }
-
   it { should belong_to(:owner) }
   it { should_not validate_presence_of(:owner_id) }
   it { should_not validate_presence_of(:owner_type) }
@@ -68,7 +65,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_meeting, :duration].each do |attr|
+   :request_headers, :record_meeting, :duration].each do |attr|
     it { should respond_to(attr) }
     it { should respond_to("#{attr}=") }
   end
@@ -152,7 +149,7 @@ describe BigbluebuttonRoom do
         b.meetingid.should == "user defined"
       }
     end
-   end
+  end
 
   describe "#room_options" do
     it "is created when the room is created" do
@@ -245,8 +242,7 @@ describe BigbluebuttonRoom do
       context "fetches 'running' when not running" do
         before {
           mocked_api.should_receive(:is_meeting_running?).with(room.meetingid).and_return(false)
-          room.should_receive(:require_server)
-          room.server = mocked_server
+          room.should_receive(:select_server).and_return(mocked_server)
         }
         before(:each) { @response = room.fetch_is_running? }
         it { room.running.should be(false) }
@@ -257,8 +253,7 @@ describe BigbluebuttonRoom do
       context "fetches 'running' when running" do
         before {
           mocked_api.should_receive(:is_meeting_running?).with(room.meetingid).and_return(true)
-          room.should_receive(:require_server)
-          room.server = mocked_server
+          room.should_receive(:select_server).and_return(mocked_server)
         }
         before(:each) { @response = room.fetch_is_running? }
         it { room.running.should be_truthy }
@@ -288,8 +283,8 @@ describe BigbluebuttonRoom do
       }
       let(:metadata) {
         m = {}
-        m[BigbluebuttonRails.metadata_user_id] = user.id
-        m[BigbluebuttonRails.metadata_user_name] = user.name
+        m[BigbluebuttonRails.configuration.metadata_user_id] = user.id
+        m[BigbluebuttonRails.configuration.metadata_user_name] = user.name
         m
       }
       let(:hash_info2) {
@@ -306,8 +301,7 @@ describe BigbluebuttonRoom do
         before {
           mocked_api.should_receive(:get_meeting_info).
             with(room.meetingid, room.moderator_api_password).and_return(hash_info)
-          room.should_receive(:require_server)
-          room.server = mocked_server
+          room.should_receive(:select_server).and_return(mocked_server)
         }
         before(:each) { room.fetch_meeting_info }
         it { room.running.should == false }
@@ -324,8 +318,7 @@ describe BigbluebuttonRoom do
         before {
           mocked_api.should_receive(:get_meeting_info).
             with(room.meetingid, room.moderator_api_password).and_return(hash_info2)
-          room.should_receive(:require_server)
-          room.server = mocked_server
+          room.should_receive(:select_server).and_return(mocked_server)
         }
         before(:each) { room.fetch_meeting_info }
         it { room.running.should == true }
@@ -348,8 +341,7 @@ describe BigbluebuttonRoom do
         before {
           mocked_api.should_receive(:get_meeting_info).
             with(room.meetingid, room.moderator_api_password).and_return(hash_info2)
-          room.should_receive(:require_server)
-          room.server = mocked_server
+          room.should_receive(:select_server).and_return(mocked_server)
 
           # here's the validation
           room.should_receive(:update_current_meeting_record).with(metadata, true)
@@ -364,6 +356,7 @@ describe BigbluebuttonRoom do
           e
         }
         before {
+          room.should_receive(:select_server).and_return(mocked_server)
           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)
@@ -382,6 +375,7 @@ describe BigbluebuttonRoom do
           e
         }
         before {
+          room.should_receive(:select_server).and_return(mocked_server)
           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)
@@ -400,6 +394,7 @@ describe BigbluebuttonRoom do
           e
         }
         before {
+          room.should_receive(:select_server).and_return(mocked_server)
           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)
@@ -414,6 +409,7 @@ describe BigbluebuttonRoom do
       context "raises any exception other than a BigBlueButtonException" do
         let!(:exception) { NoMethodError.new('Test error') }
         before {
+          room.should_receive(:select_server).and_return(mocked_server)
           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)
@@ -431,19 +427,20 @@ describe BigbluebuttonRoom do
       context "calls end_meeting" do
         before {
           mocked_api.should_receive(:end_meeting).with(room.meetingid, room.moderator_api_password)
-          room.should_receive(:require_server)
-          room.server = mocked_server
+          room.should_receive(:select_server).and_return(mocked_server)
         }
         it { room.send_end }
       end
 
       context "schedules a BigbluebuttonMeetingUpdater" do
-        before { mocked_api.should_receive(:end_meeting) }
-        before(:each) {
+        before {
+          room.should_receive(:select_server).and_return(mocked_server)
+          mocked_api.should_receive(:end_meeting)
           expect {
             room.send_end
           }.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') }
@@ -480,7 +477,6 @@ describe BigbluebuttonRoom do
           mocked_api.should_receive(:create_meeting)
             .with(anything, anything, hash_including(:welcome  => "Hi!"))
           room.stub(:select_server).and_return(mocked_server)
-          room.server = mocked_server
         end
 
         context "nil" do
@@ -499,7 +495,6 @@ describe BigbluebuttonRoom do
             .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
 
@@ -514,8 +509,6 @@ describe BigbluebuttonRoom do
               .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_api_password.should be(new_attendee_api_password) }
@@ -532,7 +525,6 @@ describe BigbluebuttonRoom do
               .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_api_password.should be(new_attendee_api_password) }
@@ -553,7 +545,6 @@ describe BigbluebuttonRoom do
               .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_api_password.should be(new_attendee_api_password) }
@@ -570,7 +561,6 @@ describe BigbluebuttonRoom do
               .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_api_password.should be(new_attendee_api_password) }
@@ -587,7 +577,6 @@ describe BigbluebuttonRoom do
               .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 }
@@ -596,11 +585,11 @@ describe BigbluebuttonRoom do
 
         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
+            @use_local_voice_bridges = BigbluebuttonRails.configuration.use_local_voice_bridges
+            BigbluebuttonRails.configuration.use_local_voice_bridges = true
           }
           after {
-            BigbluebuttonRails.use_local_voice_bridges = @use_local_voice_bridges
+            BigbluebuttonRails.configuration.use_local_voice_bridges = @use_local_voice_bridges
           }
 
           context "sets the voice bridge in the params if there's a voice bridge" do
@@ -614,7 +603,6 @@ describe BigbluebuttonRoom do
                 .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) }
@@ -629,7 +617,6 @@ describe BigbluebuttonRoom do
                 .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) }
@@ -643,16 +630,14 @@ describe BigbluebuttonRoom do
               .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.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) }
@@ -669,7 +654,6 @@ describe BigbluebuttonRoom do
               .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)
@@ -688,7 +672,6 @@ describe BigbluebuttonRoom do
           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)
@@ -700,7 +683,6 @@ describe BigbluebuttonRoom do
           old_id = "old id"
           room.meetingid = old_id
           room.stub(:select_server).and_return(mocked_server)
-          room.server = mocked_server
           room.should_not_receive(:unique_meetingid)
           mocked_api.should_receive(:create_meeting)
             .with(room.name, old_id, anything)
@@ -715,7 +697,6 @@ describe BigbluebuttonRoom do
           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))
@@ -727,7 +708,6 @@ describe BigbluebuttonRoom 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))
@@ -742,7 +722,6 @@ describe BigbluebuttonRoom do
           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))
@@ -754,7 +733,6 @@ describe BigbluebuttonRoom 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, anything, hash_including(attendeePW: old_pass))
@@ -769,34 +747,23 @@ describe BigbluebuttonRoom do
           mocked_api.should_receive(:create_meeting).
             with(room.name, room.meetingid, hash).and_return(hash_create)
           room.stub(:select_server).and_return(mocked_server)
-          room.server = mocked_server
         end
         it { room.send_create }
       end
 
-      context "selects and requires a server" do
+      context "selects 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
-            room2.should_receive(:internal_create_meeting)
-            room2.send_create
-          end
-          # 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
+        let(:room2) { FactoryGirl.create(:bigbluebutton_room) }
+        let(:api) { double(BigBlueButton::BigBlueButtonApi) }
 
-        context "and does not save when is a new record" do
-          let(:new_room) { FactoryGirl.build(:bigbluebutton_room) }
+        context "and saves the result" do
           before do
-            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
+            room2.should_receive(:select_server).with(:create).and_return(another_server)
+            another_server.stub(:api).and_return(api)
+            api.should_receive(:request_headers=)
+            api.should_receive(:create_meeting)
           end
-          it { new_room.new_record?.should be_truthy }
+          it { room2.send_create }
         end
       end
 
@@ -804,7 +771,6 @@ describe BigbluebuttonRoom do
         before do
           mocked_api.should_receive(:create_meeting).with(anything, anything, anything)
           room.stub(:select_server).and_return(mocked_server)
-          room.server = mocked_server
           room.request_headers = { :anything => "anything" }
           mocked_api.should_receive(:"request_headers=").once.with(room.request_headers)
         end
@@ -821,11 +787,10 @@ describe BigbluebuttonRoom do
       context "with moderator role" do
         let(:expected) { 'expected-url' }
         before {
-          room.should_receive(:require_server)
+          room.should_receive(:select_server).and_return(mocked_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, :moderator, nil, join_options) }
         it("returns the correct url") { subject.should eq(expected) }
@@ -834,25 +799,56 @@ describe BigbluebuttonRoom do
       context "with attendee role" do
         let(:expected) { 'expected-url' }
         before {
-          room.should_receive(:require_server)
+          room.should_receive(:select_server).and_return(mocked_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, :attendee, nil, join_options) }
         it("returns the correct url") { subject.should eq(expected) }
       end
 
+      context "with guest role" do
+        let(:expected) { 'expected-url' }
+
+        context "when guest support is disabled" do
+          before {
+            room.should_receive(:select_server).and_return(mocked_server)
+            mocked_api.should_receive(:join_meeting_url)
+              .with(room.meetingid, username, room.attendee_api_password, join_options)
+              .and_return(expected)
+          }
+          subject { room.join_url(username, :guest, nil, join_options) }
+          it("returns the correct url") { subject.should eq(expected) }
+        end
+
+        context "when guest support is enabled" do
+          before {
+            @guest_support_before = BigbluebuttonRails.configuration.guest_support
+            BigbluebuttonRails.configuration.guest_support = true
+
+            room.should_receive(:select_server).and_return(mocked_server)
+            params = { guest: true }.merge(join_options)
+            mocked_api.should_receive(:join_meeting_url)
+              .with(room.meetingid, username, room.attendee_api_password, params)
+              .and_return(expected)
+          }
+          after {
+            BigbluebuttonRails.configuration.guest_support = @guest_support_before
+          }
+          subject { room.join_url(username, :guest, nil, join_options) }
+          it("returns the correct url") { subject.should eq(expected) }
+        end
+      end
+
       context "without a role" do
         context "passing the moderator key" do
           let(:expected) { 'expected-url' }
           before {
-            room.should_receive(:require_server)
+            room.should_receive(:select_server).and_return(mocked_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) }
@@ -861,11 +857,10 @@ describe BigbluebuttonRoom do
         context "passing the attendee key" do
           let(:expected) { 'expected-url' }
           before {
-            room.should_receive(:require_server)
+            room.should_receive(:select_server).and_return(mocked_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) }
@@ -874,11 +869,10 @@ describe BigbluebuttonRoom do
         context "passing an unmatching key" do
           let(:expected) { 'expected-url' }
           before {
-            room.should_receive(:require_server)
+            room.should_receive(:select_server).and_return(mocked_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) }
@@ -887,10 +881,9 @@ describe BigbluebuttonRoom do
 
       context "strips the url before returning it" do
         before {
-          room.should_receive(:require_server)
+          room.should_receive(:select_server).and_return(mocked_server)
           mocked_api.should_receive(:join_meeting_url)
             .and_return(" my.url/with/spaces \t ")
-          room.server = mocked_server
         }
         subject { room.join_url(username, :moderator) }
         it("returns the url stripped") { subject.should eq('my.url/with/spaces') }
@@ -918,6 +911,7 @@ describe BigbluebuttonRoom do
 
         context "and the xml generated is not equal the default one" do
           before {
+            room.should_receive(:select_server).and_return(mocked_server)
             room.room_options.should_receive(:set_on_config_xml)
               .with(config_xml).and_return('fake-config-xml')
             mocked_api.should_receive(:set_config_xml)
@@ -930,6 +924,7 @@ describe BigbluebuttonRoom do
 
         context "and the xml generated is equal the default one" do
           before {
+            room.should_receive(:select_server).and_return(mocked_server)
             room.room_options.should_receive(:set_on_config_xml)
               .with(config_xml).and_return(false)
             mocked_api.should_not_receive(:set_config_xml)
@@ -953,52 +948,70 @@ describe BigbluebuttonRoom do
 
   context "#available_layouts" do
     context "delegates to server" do
+      let(:server) { FactoryGirl.build(:bigbluebutton_server) }
       let(:room) { FactoryGirl.build(:bigbluebutton_room) }
       let(:layouts) { [ 'layout-1', 'another layout' ] }
+
       before {
-        room.server.should_receive(:available_layouts)
+        room.should_receive(:select_server).and_return(server)
+        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([]) }
+      let(:room) { FactoryGirl.build(:bigbluebutton_room) }
+      it {
+        room.should_receive(:select_server).and_return(nil)
+        room.available_layouts.should eql([])
+      }
     end
   end
 
   context "#available_layouts_names" do
     context "delegates to server" do
+      let(:server) { FactoryGirl.build(:bigbluebutton_server) }
       let(:room) { FactoryGirl.build(:bigbluebutton_room) }
       let(:layouts) { [ 'layout-1', 'another layout' ] }
+
       before {
-        room.server.should_receive(:available_layouts_names)
+        room.should_receive(:select_server).and_return(server)
+        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([]) }
+      let(:room) { FactoryGirl.build(:bigbluebutton_room) }
+      it {
+        room.should_receive(:select_server).and_return(nil)
+        room.available_layouts_names.should eql([])
+      }
     end
   end
 
   context "#available_layouts_for_select" do
     context "delegates to server" do
+      let(:server) { FactoryGirl.build(:bigbluebutton_server) }
       let(:room) { FactoryGirl.build(:bigbluebutton_room) }
       let(:layouts) { [ 'layout-1', 'another layout' ] }
+
       before {
-        room.server.should_receive(:available_layouts_for_select)
+        room.should_receive(:select_server).and_return(server)
+        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([]) }
+      let(:room) { FactoryGirl.build(:bigbluebutton_room) }
+      it {
+        room.should_receive(:select_server).and_return(nil)
+        room.available_layouts_for_select.should eql([])
+      }
     end
   end
 
@@ -1157,107 +1170,30 @@ describe BigbluebuttonRoom do
     it { should respond_to(:"full_logout_url=") }
   end
 
-  describe "#require_server" do
+  describe "#select_server" do
+    let(:server) { FactoryGirl.create(:bigbluebutton_server) }
     let(:room) { FactoryGirl.create(:bigbluebutton_room) }
-    it { room.respond_to?(:require_server, true).should be(true) }
-
-    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
+    it { room.respond_to?(:select_server, true).should be(true) }
 
-    context "does nothing if the room has a server associated" do
-      let(:server) { FactoryGirl.create(:bigbluebutton_server) }
-      before {
-        room.server = server
-        expect {
-          room.send(:require_server)
-        }.not_to raise_error
-      }
-      it { room.server.should eql(server) }
+    context "assigns server to room if there is one" do
+      it { room.select_server.should eql(BigbluebuttonServer.first) }
     end
-  end
 
-  describe "#select_server" do
-    let(:room) { FactoryGirl.create(:bigbluebutton_room, :server => nil) }
-    it { room.respond_to?(:select_server, true).should be(true) }
-
-    context "selects the server with less rooms" do
+    context "raises exception if there are no servers to assign" do
       before {
         BigbluebuttonServer.destroy_all
-        s1 = FactoryGirl.create(:bigbluebutton_server)
-        @s2 = FactoryGirl.create(:bigbluebutton_server)
-        3.times{ FactoryGirl.create(:bigbluebutton_room, :server => s1) }
-        2.times{ FactoryGirl.create(:bigbluebutton_room, :server => @s2) }
       }
-      it { room.send(:select_server).should == @s2 }
-    end
-
-    context "returns nil of there are no servers" do
-      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 {
+        expect {
+          room.select_server
+        }.to raise_error(BigbluebuttonRails::ServerRequired)
       }
-      it { room.send(:select_server).should == nil }
     end
   end
 
   describe "#get_metadata_for_create" do
-    let(:room) { FactoryGirl.create(:bigbluebutton_room, :server => nil) }
+    let(:room) { FactoryGirl.create(:bigbluebutton_room) }
 
     context "returns the metadata from the database" do
       before {
@@ -1272,20 +1208,12 @@ describe BigbluebuttonRoom do
 
     context "returns the dynamic metadata, if any" do
       before {
-        BigbluebuttonRoom.class_eval do
-          def dynamic_metadata
-            {
-              "test1" => "value1",
-              "test2" => "value2"
-            }
+        BigbluebuttonRails.configure do |config|
+          config.get_dynamic_metadata = Proc.new do |room|
+            { "test1" => "value1", "test2" => "value2" }
           end
         end
       }
-      after {
-        BigbluebuttonRoom.class_eval do
-          undef_method :dynamic_metadata
-        end
-      }
 
       it {
         result = { "meta_test1" => "value1", "meta_test2" => "value2" }
@@ -1295,23 +1223,15 @@ describe BigbluebuttonRoom do
 
     context "gives priority to the dynamic metadata" do
       before {
-        BigbluebuttonRoom.class_eval do
-          def dynamic_metadata
-            {
-              "test1" => "value1",
-              "test2" => "value2"
-            }
+        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")
       }
-      after {
-        BigbluebuttonRoom.class_eval do
-          undef_method :dynamic_metadata
-        end
-      }
 
       it {
         result = { "meta_test1" => "value1", "meta_test2" => "value2", "meta_other" => "other content" }
@@ -1321,7 +1241,7 @@ describe BigbluebuttonRoom do
   end
 
   describe "#get_current_meeting" do
-    let(:room) { FactoryGirl.create(:bigbluebutton_room, :server => nil) }
+    let(:room) { FactoryGirl.create(:bigbluebutton_room) }
 
     context "if there's no start_time set in the room" do
       before { room.start_time = nil }
@@ -1353,8 +1273,8 @@ describe BigbluebuttonRoom do
       let(:user) { FactoryGirl.build(:user) }
       let(:metadata) {
         m = {}
-        m[BigbluebuttonRails.metadata_user_id] = user.id
-        m[BigbluebuttonRails.metadata_user_name] = user.name
+        m[BigbluebuttonRails.configuration.metadata_user_id] = user.id
+        m[BigbluebuttonRails.configuration.metadata_user_name] = user.name
         m
       }
       before {
@@ -1413,6 +1333,7 @@ describe BigbluebuttonRoom do
   end
 
   describe "#create_meeting_record" do
+    let(:server) { FactoryGirl.create(:bigbluebutton_server) }
     let(:room) { FactoryGirl.create(:bigbluebutton_room) }
 
     context "if there is already a current meeting" do
@@ -1439,8 +1360,8 @@ describe BigbluebuttonRoom do
       let(:user) { FactoryGirl.build(:user) }
       let(:metadata) {
         m = {}
-        m[BigbluebuttonRails.metadata_user_id] = user.id
-        m[BigbluebuttonRails.metadata_user_name] = user.name
+        m[BigbluebuttonRails.configuration.metadata_user_id] = user.id
+        m[BigbluebuttonRails.configuration.metadata_user_name] = user.name
         m
       }
       before {
@@ -1454,13 +1375,13 @@ describe BigbluebuttonRoom do
         context "and no metadata was passed" do
           before(:each) {
             expect {
+              room.should_receive(:select_server).and_return(server)
               room.create_meeting_record
             }.to change{ BigbluebuttonMeeting.count }.by(1)
           }
           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 server_url") { subject.server_url.should eq(server.url) }
+          it("sets server_secret") { subject.server_secret.should eq(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) }
@@ -1549,8 +1470,8 @@ describe BigbluebuttonRoom do
       let(:room) { FactoryGirl.create(:bigbluebutton_room) }
 
       before {
+        room.stub(:select_server).and_return(mocked_server)
         mocked_api.stub(:"request_headers=")
-        room.server = mocked_server
       }
 
       it { room.should_not respond_to(:invitation_url) }
@@ -1567,45 +1488,33 @@ describe BigbluebuttonRoom do
 
       context "doesn't add the invitation URL if BigbluebuttonRoom#invitation_url returns nil" do
         before {
-          BigbluebuttonRoom.class_eval do
-            def invitation_url
+          BigbluebuttonRails.configure do |config|
+            config.get_invitation_url = Proc.new do |room|
               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
         }
-        after {
-          BigbluebuttonRoom.class_eval do
-            undef_method :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
+          BigbluebuttonRails.configure do |config|
+            config.get_invitation_url = Proc.new do |room|
               '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
         }
-        after {
-          BigbluebuttonRoom.class_eval do
-            undef_method :invitation_url
-          end
-        }
 
         it { room.send(:internal_create_meeting) }
       end
@@ -1616,8 +1525,8 @@ describe BigbluebuttonRoom do
       let(:room) { FactoryGirl.create(:bigbluebutton_room) }
 
       before {
+        room.stub(:select_server).and_return(mocked_server)
         mocked_api.stub(:"request_headers=")
-        room.server = mocked_server
       }
 
       it { room.should_not respond_to(:dynamic_metadata) }
@@ -1635,50 +1544,35 @@ describe BigbluebuttonRoom do
 
       context "doesn't add the dynamic metadata if it returns nil" do
         before {
-          BigbluebuttonRoom.class_eval do
-            def dynamic_metadata
+          BigbluebuttonRails.configure do |config|
+            config.get_dynamic_metadata = Proc.new do |room|
               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"
-              }
+          BigbluebuttonRails.configure do |config|
+            config.get_dynamic_metadata = Proc.new do |room|
+              { "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