bigbluebutton_rails 0.1.0 → 0.1.1

data/spec/controllers/bigbluebutton/servers_controller_json_responses_spec.rb

@@ -4,7 +4,7 @@ describe Bigbluebutton::ServersController do
   render_views
   let(:server) { Factory.create(:bigbluebutton_server) }
 
-  context "json responses for " do
+  context "json responses for" do
 
     describe "#index" do
       before do
@@ -144,5 +144,16 @@ describe Bigbluebutton::ServersController do
 
     end
 
+    describe "#rooms" do
+      before do
+        @room1 = Factory.create(:bigbluebutton_room, :server => server)
+        @room2 = Factory.create(:bigbluebutton_room, :server => server)
+      end
+      before(:each) { get :rooms, :id => server.to_param, :format => 'json' }
+      it { should respond_with(:success) }
+      it { should respond_with_content_type(:json) }
+      it { should respond_with_json([@room1, @room2].to_json) }
+    end
+
   end
 end

data/spec/controllers/bigbluebutton/servers_controller_spec.rb

@@ -140,5 +140,16 @@ describe Bigbluebutton::ServersController do
 
   end # #activity
 
+  describe "#rooms" do
+    before do
+      @room1 = Factory.create(:bigbluebutton_room, :server => server)
+      @room2 = Factory.create(:bigbluebutton_room, :server => server)
+    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
+
 end
 

data/spec/generators/install_generator_spec.rb

@@ -21,8 +21,8 @@ describe BigbluebuttonRails::Generators::InstallGenerator do
 
     it "all files are properly destroyed" do
       run_generator %w(), :behavior => :revoke
-      assert_no_file "config/locales/bigbluebutton_rails.en.yml"
       assert_no_migration "db/migrate/create_bigbluebutton_rails.rb"
+      assert_no_file "config/locales/bigbluebutton_rails.en.yml"
       assert_no_file "public/stylesheets/bigbluebutton_rails.css"
       assert_no_file "public/javascripts/jquery.min.js"
       assert_no_file "public/images/loading.gif"

data/spec/models/bigbluebutton_room_spec.rb

@@ -13,7 +13,7 @@ describe BigbluebuttonRoom do
   it { should_not validate_presence_of(:owner_id) }
   it { should_not validate_presence_of(:owner_type) }
 
-  it { should validate_presence_of(:server_id) }
+  it { should_not validate_presence_of(:server_id) }
   it { should validate_presence_of(:meetingid) }
   it { should validate_presence_of(:voice_bridge) }
   it { should validate_presence_of(:name) }
@@ -22,10 +22,10 @@ describe BigbluebuttonRoom do
   it { should be_boolean(:private) }
   it { should be_boolean(:randomize_meetingid) }
 
-  [:name, :server_id, :meetingid, :attendee_password, :moderator_password,
-   :welcome_msg, :owner, :server, :private, :logout_url, :dial_number,
-   :voice_bridge, :max_participants, :owner_id, :owner_type,
-   :randomize_meetingid, :param].
+  [:name, :server_id, :meetingid, :attendee_password,
+   :moderator_password, :welcome_msg, :owner, :private, :logout_url,
+   :dial_number, :voice_bridge, :max_participants, :owner_id,
+   :owner_type, :randomize_meetingid, :param].
     each do |attribute|
     it { should allow_mass_assignment_of(attribute) }
   end
@@ -36,11 +36,6 @@ describe BigbluebuttonRoom do
   it { should validate_uniqueness_of(:voice_bridge) }
   it { should validate_uniqueness_of(:param) }
 
-  it {
-    room = Factory.create(:bigbluebutton_room)
-    room.server.should_not be_nil
-  }
-
   it { should ensure_length_of(:meetingid).is_at_least(1).is_at_most(100) }
   it { should ensure_length_of(:name).is_at_least(1).is_at_most(150) }
   it { should ensure_length_of(:attendee_password).is_at_most(16) }
@@ -50,7 +45,8 @@ describe BigbluebuttonRoom do
 
   # attr_accessors
   [:running, :participant_count, :moderator_count, :attendees,
-   :has_been_forcibly_ended, :start_time, :end_time, :external].each do |attr|
+   :has_been_forcibly_ended, :start_time, :end_time,
+   :external, :server].each do |attr|
     it { should respond_to(attr) }
     it { should respond_to("#{attr}=") }
   end
@@ -192,20 +188,26 @@ describe BigbluebuttonRoom do
 
       it { should respond_to(:fetch_is_running?) }
 
-      it "fetches is_running? when not running" do
-        mocked_api.should_receive(:is_meeting_running?).with(room.meetingid).and_return(false)
-        room.server = mocked_server
-        room.fetch_is_running?
-        room.running.should == false
-        room.is_running?.should == false
+      context "fetches is_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
+        }
+        before(:each) { room.fetch_is_running? }
+        it { room.running.should == false }
+        it { room.is_running?.should == false }
       end
 
-      it "fetches is_running? when running" do
-        mocked_api.should_receive(:is_meeting_running?).with(room.meetingid).and_return(true)
-        room.server = mocked_server
-        room.fetch_is_running?
-        room.running.should == true
-        room.is_running?.should == true
+      context "fetches is_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
+        }
+        before(:each) { room.fetch_is_running? }
+        it { room.running.should == true }
+        it { room.is_running?.should == true }
       end
 
     end
@@ -237,53 +239,57 @@ describe BigbluebuttonRoom do
 
       it { should respond_to(:fetch_meeting_info) }
 
-      it "fetches meeting info when the meeting is not running" do
-        mocked_api.should_receive(:get_meeting_info).
-          with(room.meetingid, room.moderator_password).and_return(hash_info)
-        room.server = mocked_server
-
-        room.fetch_meeting_info
-        room.running.should == false
-        room.has_been_forcibly_ended.should == false
-        room.participant_count.should == 0
-        room.moderator_count.should == 0
-        room.start_time.should == nil
-        room.end_time.should == nil
-        room.attendees.should == []
+      context "fetches meeting info when the meeting is not running" do
+        before {
+          mocked_api.should_receive(:get_meeting_info).
+            with(room.meetingid, room.moderator_password).and_return(hash_info)
+          room.should_receive(:require_server)
+          room.server = mocked_server
+        }
+        before(:each) { room.fetch_meeting_info }
+        it { room.running.should == false }
+        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.end_time.should == nil }
+        it { room.attendees.should == [] }
       end
 
-      it "fetches meeting info when the meeting is running" do
-        mocked_api.should_receive(:get_meeting_info).
-          with(room.meetingid, room.moderator_password).and_return(hash_info2)
-        room.server = mocked_server
-
-        room.fetch_meeting_info
-        room.running.should == true
-        room.has_been_forcibly_ended.should == false
-        room.participant_count.should == 4
-        room.moderator_count.should == 2
-        room.start_time.should == DateTime.parse("Wed Apr 06 17:09:57 UTC 2011")
-        room.end_time.should == nil
-
-        users.each do |att|
-          attendee = BigbluebuttonAttendee.new
-          attendee.from_hash(att)
-          room.attendees.should include(attendee)
-        end
+      context "fetches meeting info when the meeting is running" do
+        before {
+          mocked_api.should_receive(:get_meeting_info).
+            with(room.meetingid, room.moderator_password).and_return(hash_info2)
+          room.should_receive(:require_server)
+          room.server = mocked_server
+        }
+        before(:each) { room.fetch_meeting_info }
+        it { room.running.should == true }
+        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.end_time.should == nil }
+        it {
+          users.each do |att|
+            attendee = BigbluebuttonAttendee.new
+            attendee.from_hash(att)
+            room.attendees.should include(attendee)
+          end
+        }
       end
 
     end
 
     describe "#send_end" do
-
       it { should respond_to(:send_end) }
 
       it "send end_meeting" do
         mocked_api.should_receive(:end_meeting).with(room.meetingid, room.moderator_password)
+        room.should_receive(:require_server)
         room.server = mocked_server
         room.send_end
       end
-
     end
 
     describe "#send_create" do
@@ -299,7 +305,7 @@ describe BigbluebuttonRoom do
 
       it { should respond_to(:send_create) }
 
-      context "send create_meeting" do
+      context "sends create_meeting" do
 
         context "for a stored room" do
           before do
@@ -309,6 +315,7 @@ describe BigbluebuttonRoom do
                                   :voiceBridge => room.voice_bridge)
             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
             room.send_create
           end
@@ -326,6 +333,7 @@ describe BigbluebuttonRoom do
                                   :voiceBridge => new_room.voice_bridge)
             mocked_api.should_receive(:create_meeting).
               with(new_room.name, new_room.meetingid, hash).and_return(hash_create)
+            new_room.stub(:select_server).and_return(mocked_server)
             new_room.server = mocked_server
             new_room.send_create
           end
@@ -337,13 +345,12 @@ describe BigbluebuttonRoom do
       end
 
       context "randomizes meetingid" do
-        let(:fail_hash) { { :returncode => true, :meetingID => "new id",
-            :messageKey => "duplicateWarning" } }
-        let(:success_hash) { { :returncode => true, :meetingID => "new id",
-            :messageKey => "" } }
+        let(:fail_hash) { { :returncode => true, :meetingID => "new id", :messageKey => "duplicateWarning" } }
+        let(:success_hash) { { :returncode => true, :meetingID => "new id", :messageKey => "" } }
         let(:new_id) { "new id" }
         before {
           room.randomize_meetingid = true
+          room.stub(:select_server).and_return(mocked_server)
           room.server = mocked_server
         }
 
@@ -358,7 +365,7 @@ describe BigbluebuttonRoom do
         end
 
         it "and tries again on error" do
-          # fails twice and them succeds
+          # fails twice and then succeds
           room.should_receive(:random_meetingid).exactly(3).times.and_return(new_id)
           hash = hash_including(:moderatorPW => room.moderator_password, :attendeePW => room.attendee_password,
                                 :welcome  => room.welcome_msg, :dialNumber => room.dial_number,
@@ -392,37 +399,72 @@ describe BigbluebuttonRoom do
                                 :voiceBridge => room.voice_bridge)
           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
 
-    end
+      context "selects and requires a server" do
+        let(:another_server) { Factory.create(:bigbluebutton_server) }
+
+        context "and saves the result" do
+          before do
+            room.randomize_meetingid = false # take the shortest path inside #send_create
+            room.should_receive(:select_server).and_return(another_server)
+            room.should_receive(:require_server)
+            room.should_receive(:do_create_meeting)
+            room.server = mocked_server
+            room.send_create
+          end
+          it { BigbluebuttonRoom.find(room.id).server_id.should == another_server.id }
+        end
+
+        context "and does not save when is a new record" do
+          let(:new_room) { Factory.build(:bigbluebutton_room) }
+          before do
+            new_room.randomize_meetingid = false # take the shortest path inside #send_create
+            new_room.should_receive(:select_server).and_return(another_server)
+            new_room.should_receive(:require_server)
+            new_room.should_receive(:do_create_meeting).and_return(nil)
+            new_room.should_not_receive(:save)
+            new_room.server = mocked_server
+            new_room.send_create
+          end
+          it { new_room.new_record?.should be_true }
+        end
+      end
+
+    end # #send_create
 
     describe "#join_url" do
       let(:username) { Forgery(:name).full_name }
 
       it { should respond_to(:join_url) }
 
-      it "with moderator role" do
-        mocked_api.should_receive(:join_meeting_url).
-          with(room.meetingid, username, room.moderator_password)
-        room.server = mocked_server
-        room.join_url(username, :moderator)
-      end
+      context do
+        before { room.should_receive(:require_server) }
 
-      it "with attendee role" do
-        mocked_api.should_receive(:join_meeting_url).
-          with(room.meetingid, username, room.attendee_password)
-        room.server = mocked_server
-        room.join_url(username, :attendee)
-      end
+        it "with moderator role" do
+          mocked_api.should_receive(:join_meeting_url).
+            with(room.meetingid, username, room.moderator_password)
+          room.server = mocked_server
+          room.join_url(username, :moderator)
+        end
 
-      it "without a role" do
-        mocked_api.should_receive(:join_meeting_url).
-          with(room.meetingid, username, 'pass')
-        room.server = mocked_server
-        room.join_url(username, nil, 'pass')
+        it "with attendee role" do
+          mocked_api.should_receive(:join_meeting_url).
+            with(room.meetingid, username, room.attendee_password)
+          room.server = mocked_server
+          room.join_url(username, :attendee)
+        end
+
+        it "without a role" do
+          mocked_api.should_receive(:join_meeting_url).
+            with(room.meetingid, username, 'pass')
+          room.server = mocked_server
+          room.join_url(username, nil, 'pass')
+        end
       end
     end
 
@@ -548,4 +590,48 @@ describe BigbluebuttonRoom do
     it { should respond_to(:"full_logout_url=") }
   end
 
+  describe "#require_server" do
+    let(:room) { Factory.create(:bigbluebutton_room) }
+    it { should respond_to(:require_server) }
+
+    context "throws exception when the room has no server associated" do
+      before { room.server = nil }
+      it {
+        lambda {
+          room.send(:require_server)
+        }.should raise_error(BigbluebuttonRails::ServerRequired)
+      }
+    end
+
+    context "does nothing if the room has a server associated" do
+      before { room.server = Factory.create(:bigbluebutton_server) }
+      it {
+        lambda {
+          room.send(:require_server)
+        }.should_not raise_error(BigbluebuttonRails::ServerRequired)
+      }
+    end
+  end
+
+  describe "#select_server" do
+    let(:room) { Factory.create(:bigbluebutton_room, :server => nil) }
+    it { should respond_to(:select_server) }
+
+    context "selects the server with less rooms" do
+      before {
+        BigbluebuttonServer.destroy_all
+        s1 = Factory.create(:bigbluebutton_server)
+        @s2 = Factory.create(:bigbluebutton_server)
+        3.times{ Factory.create(:bigbluebutton_room, :server => s1) }
+        2.times{ Factory.create(:bigbluebutton_room, :server => @s2) }
+      }
+      it { room.send(:select_server).should == @s2 }
+    end
+
+    context "returns nil of there are no servers" do
+      before(:each) { BigbluebuttonServer.destroy_all }
+      it { room.send(:select_server).should == nil }
+    end
+  end
+
 end

data/spec/models/bigbluebutton_server_spec.rb

@@ -36,15 +36,15 @@ describe BigbluebuttonServer do
     server.rooms.should_not be_empty
   end
 
-  it "destroys associated rooms" do
+  it "nullifies associated rooms" do
     server = Factory.create(:bigbluebutton_server)
-    Factory.create(:bigbluebutton_room, :server => server)
-    Factory.create(:bigbluebutton_room, :server => server)
+    room = Factory.create(:bigbluebutton_room, :server => server)
     expect {
       expect {
         server.destroy
       }.to change{ BigbluebuttonServer.count }.by(-1)
-    }.to change{ BigbluebuttonRoom.count }.by(-2)
+    }.to change{ BigbluebuttonRoom.count }.by(0)
+    BigbluebuttonRoom.find(room.id).server_id.should == nil
   end
 
   it { should ensure_length_of(:name).is_at_least(1).is_at_most(500) }

data/spec/rails_app/features/activity_monitor_servers.feature

@@ -2,6 +2,12 @@ Feature: Monitor the active in the webconference servers
   To check the current status of a server
   One needs a real-time activity monitor
 
+  Scenario: View the activity monitor page
+    Given an anonymous user
+      And a real server
+    When he goes to the server activity monitor page
+    Then he should see the server activity monitor page
+
   @need-bot
   Scenario: View the list of meetings running in a server
     Given an anonymous user