bigbluebutton_rails 0.0.5 → 0.0.6

data/spec/controllers/bigbluebutton/servers_controller_json_responses_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe Bigbluebutton::ServersController do
+  render_views
+  let(:server) { Factory.create(:bigbluebutton_server) }
+
+  context "json responses for " do
+
+    describe "#index" do
+      before do
+        @server1 = Factory.create(:bigbluebutton_server)
+        @server2 = Factory.create(:bigbluebutton_server)
+      end
+      before(:each) { get :index, :format => 'json' }
+      it { should respond_with(:success) }
+      it { should respond_with_content_type(:json) }
+      it { should respond_with_json([@server1, @server2].to_json) }
+    end
+
+    describe "#new" do
+      before(:each) { get :new, :format => 'json' }
+      it { should respond_with(:success) }
+      it { should respond_with_content_type(:json) }
+      it { should respond_with_json(BigbluebuttonServer.new.to_json).ignoring_values }
+    end
+
+    describe "#show" do
+      before(:each) { get :show, :id => server.to_param, :format => 'json' }
+      it { should respond_with(:success) }
+      it { should respond_with_content_type(:json) }
+      it { should respond_with_json(server.to_json) }
+    end
+
+    describe "#create" do
+      let(:new_server) { Factory.build(:bigbluebutton_server) }
+
+      context "on success" do
+        before(:each) {
+          post :create, :bigbluebutton_server => new_server.attributes, :format => 'json'
+        }
+        it { should respond_with(:created) }
+        it { should respond_with_content_type(:json) }
+        it { should respond_with_json(new_server.to_json).ignoring_attributes }
+      end
+
+      context "on failure" do
+        before(:each) {
+          new_server.url = nil # invalid
+          post :create, :bigbluebutton_server => new_server.attributes, :format => 'json'
+        }
+        it { should respond_with(:unprocessable_entity) }
+        it { should respond_with_content_type(:json) }
+        it {
+          new_server.save # should fail
+          should respond_with_json(new_server.errors.full_messages.to_json)
+        }
+      end
+    end
+
+    describe "#update" do
+      let(:new_server) { Factory.build(:bigbluebutton_server) }
+      before { @server = server }
+
+      context "on success" do
+        before(:each) {
+          put :update, :id => @server.to_param, :bigbluebutton_server => new_server.attributes, :format => 'json'
+        }
+        it { should respond_with(:success) }
+        it { should respond_with_content_type(:json) }
+      end
+
+      context "on failure" do
+        before(:each) {
+          new_server.url = nil # invalid
+          put :update, :id => @server.to_param, :bigbluebutton_server => new_server.attributes, :format => 'json'
+        }
+        it { should respond_with(:unprocessable_entity) }
+        it { should respond_with_content_type(:json) }
+        it {
+          new_server.save # should fail
+          should respond_with_json(new_server.errors.full_messages.to_json)
+        }
+      end
+    end
+
+    describe "#destroy" do
+      before :each do
+        @server = server
+        delete :destroy, :id => @server.to_param, :format => 'json'
+      end
+      it { should respond_with(:success) }
+      it { should respond_with_content_type(:json) }
+    end
+
+    describe "#activity" do
+      let(:room1) { Factory.create(:bigbluebutton_room, :server => server) }
+      let(:room2) { Factory.create(:bigbluebutton_room, :server => server) }
+      before do
+        # so we return our mocked server
+        BigbluebuttonServer.stub!(:find_by_param).with(server.to_param).
+          and_return(server)
+      end
+
+      context "on success" do
+        before do
+          server.should_receive(:fetch_meetings).and_return({ })
+          server.should_receive(:meetings).twice.and_return([room1, room2])
+          room1.should_receive(:fetch_meeting_info)
+          room2.should_receive(:fetch_meeting_info)
+        end
+        before(:each) { get :activity, :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
+
+      context "on failure" do
+        let(:bbb_error_msg) { "err msg" }
+        let(:bbb_error) { BigBlueButton::BigBlueButtonException.new(bbb_error_msg) }
+        before do
+          server.should_receive(:fetch_meetings).and_return({ })
+          server.should_receive(:meetings).at_least(:once).and_return([room1, room2])
+          room1.should_receive(:fetch_meeting_info) { raise bbb_error }
+        end
+        before(:each) { get :activity, :id => server.to_param, :format => 'json' }
+        it { should respond_with(:error) }
+        it { should respond_with_content_type(:json) }
+        it { should respond_with_json([{ :message => bbb_error_msg }, room1, room2].to_json) }
+        it { should set_the_flash.to(bbb_error_msg) }
+      end
+
+      context "ignores params[:update_list]" do
+        before do
+          server.should_receive(:fetch_meetings).and_return({ })
+          server.should_receive(:meetings).twice.and_return([room1, room2])
+          room1.should_receive(:fetch_meeting_info)
+          room2.should_receive(:fetch_meeting_info)
+        end
+        before(:each) { get :activity, :id => server.to_param, :update_list => true, :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
+end

data/spec/controllers/bigbluebutton/servers_controller_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Bigbluebutton::ServersController do
-
   render_views
   let(:server) { Factory.create(:bigbluebutton_server) }
 
@@ -9,24 +8,28 @@ describe Bigbluebutton::ServersController do
     before(:each) { get :index }
     it { should respond_with(:success) }
     it { should assign_to(:servers).with(BigbluebuttonServer.all) }
+    it { should render_template(:index) }
   end
 
   describe "#show" do
     before(:each) { get :show, :id => server.to_param }
     it { should respond_with(:success) }
     it { should assign_to(:server).with(server) }
+    it { should render_template(:show) }
   end
 
   describe "#new" do
     before(:each) { get :new }
     it { should respond_with(:success) }
     it { should assign_to(:server).with_kind_of(BigbluebuttonServer) }
+    it { should render_template(:new) }
   end
 
   describe "#edit" do
     before(:each) { get :edit, :id => server.to_param }
     it { should respond_with(:success) }
     it { should assign_to(:server).with(server) }
+    it { should render_template(:edit) }
   end
 
   describe "#create" do
@@ -75,96 +78,67 @@ describe Bigbluebutton::ServersController do
     }
   end
 
-  # verify all JSON responses
-  context "json responses for " do
-
-    describe "#index" do
-      before do
-        @server1 = Factory.create(:bigbluebutton_server)
-        @server2 = Factory.create(:bigbluebutton_server)
-      end
-      before(:each) { get :index, :format => 'json' }
-      it { should respond_with(:success) }
-      it { should respond_with_content_type(:json) }
-      it { should respond_with_json([@server1, @server2].to_json) }
-    end
-
-    describe "#new" do
-      before(:each) { get :new, :format => 'json' }
-      it { should respond_with(:success) }
-      it { should respond_with_content_type(:json) }
-      it { should respond_with_json(BigbluebuttonServer.new.to_json).ignoring_values }
+  describe "#activity" do
+    let(:room1) { Factory.create(:bigbluebutton_room, :server => server) }
+    let(:room2) { Factory.create(:bigbluebutton_room, :server => server) }
+    before do
+      # so we return our mocked server
+      BigbluebuttonServer.stub!(:find_by_param).with(server.to_param).
+        and_return(server)
     end
 
-    describe "#show" do
-      before(:each) { get :show, :id => server.to_param, :format => 'json' }
-      it { should respond_with(:success) }
-      it { should respond_with_content_type(:json) }
-      it { should respond_with_json(server.to_json) }
-    end
+    context "standard behaviour" do
 
-    describe "#create" do
-      let(:new_server) { Factory.build(:bigbluebutton_server) }
+      before do
+        # mock some methods that trigger BBB API calls
+        server.should_receive(:fetch_meetings).and_return({ })
+        server.should_receive(:meetings).at_least(:once).and_return([room1, room2])
+        room1.should_receive(:fetch_meeting_info)
+        room2.should_receive(:fetch_meeting_info)
+      end
 
-      context "on success" do
-        before(:each) {
-          post :create, :bigbluebutton_server => new_server.attributes, :format => 'json'
-        }
-        it { should respond_with(:created) }
-        it { should respond_with_content_type(:json) }
-        it { should respond_with_json(new_server.to_json).ignoring_attributes }
+      context do
+        before(:each) { get :activity, :id => server.to_param }
+        it { should respond_with(:success) }
+        it { should assign_to(:server).with(server) }
+        it { should render_template(:activity) }
       end
 
-      context "on failure" do
-        before(:each) {
-          new_server.url = nil # invalid
-          post :create, :bigbluebutton_server => new_server.attributes, :format => 'json'
-        }
-        it { should respond_with(:unprocessable_entity) }
-        it { should respond_with_content_type(:json) }
-        it {
-          new_server.save # should fail
-          should respond_with_json(new_server.errors.full_messages.to_json)
-        }
+      context "with params[:update_list]" do
+        context "and :format nil" do
+          before(:each) { get :activity, :id => server.to_param, :update_list => true }
+          it { should render_template(:activity_list) }
+        end
+        context "and :format = 'html'" do
+          before(:each) { get :activity, :id => server.to_param, :update_list => true, :format => "html" }
+          it { should render_template(:activity_list) }
+        end
       end
+
     end
 
-    describe "#update" do
-      let(:new_server) { Factory.build(:bigbluebutton_server) }
-      before { @server = server }
+    context "exception handling" do
+      let(:bbb_error_msg) { "err msg" }
+      let(:bbb_error) { BigBlueButton::BigBlueButtonException.new(bbb_error_msg) }
 
-      context "on success" do
-        before(:each) {
-          put :update, :id => @server.to_param, :bigbluebutton_server => new_server.attributes, :format => 'json'
-        }
-        it { should respond_with(:success) }
-        it { should respond_with_content_type(:json) }
+      context "at fetch_meetings" do
+        before { server.should_receive(:fetch_meetings) { raise bbb_error } }
+        before(:each) { get :activity, :id => server.to_param }
+        it { should set_the_flash.to(bbb_error_msg) }
       end
 
-      context "on failure" do
-        before(:each) {
-          new_server.url = nil # invalid
-          put :update, :id => @server.to_param, :bigbluebutton_server => new_server.attributes, :format => 'json'
-        }
-        it { should respond_with(:unprocessable_entity) }
-        it { should respond_with_content_type(:json) }
-        it {
-          new_server.save # should fail
-          should respond_with_json(new_server.errors.full_messages.to_json)
-        }
-      end
-    end
-
-    describe "#destroy" do
-      before :each do
-        @server = server
-        delete :destroy, :id => @server.to_param, :format => 'json'
+      context "at fetch_meeting_info" do
+        before do
+          server.should_receive(:fetch_meetings).and_return({ })
+          server.should_receive(:meetings).at_least(:once).and_return([room1, room2])
+          room1.should_receive(:fetch_meeting_info) { raise bbb_error }
+        end
+        before(:each) { get :activity, :id => server.to_param }
+        it { should set_the_flash.to(bbb_error_msg) }
       end
-      it { should respond_with(:success) }
-      it { should respond_with_content_type(:json) }
     end
 
-  end # json responses
+  end # #activity
 
 end
 

data/spec/factories/bigbluebutton_room.rb

@@ -8,4 +8,5 @@ Factory.define :bigbluebutton_room do |r|
   r.private false
   r.randomize_meetingid false
   r.sequence(:param) { |n| "meeting-#{n}" }
+  r.external false
 end

data/spec/models/bigbluebutton_room_spec.rb

@@ -163,13 +163,21 @@ describe BigbluebuttonRoom do
       end
 
       context "voice_bridge" do
-        it { room.voice_bridge.should_not be_nil }
-        it { room.voice_bridge.length.should == 5 }
-        it { room.voice_bridge[0].should == '7' }
         it {
           b = BigbluebuttonRoom.new(:voice_bridge => "user defined")
           b.voice_bridge.should == "user defined"
         }
+        context "with a random value" do
+          it { room.voice_bridge.should_not be_nil }
+          it { room.voice_bridge.should =~ /7[0-9]{4}/ }
+          it "tries to randomize 10 times if voice_bridge already exists" do
+            room = Factory.create(:bigbluebutton_room, :voice_bridge => "70000")
+            BigbluebuttonRoom.stub!(:find_by_voice_bridge).and_return(room)
+            ActiveSupport::SecureRandom.should_receive(:random_number).exactly(10).and_return(0000)
+            room2 = BigbluebuttonRoom.new # triggers the random_number calls
+            room2.voice_bridge.should == "70000"
+          end
+        end
       end
     end
 
@@ -321,22 +329,39 @@ describe BigbluebuttonRoom do
 
         it { should respond_to(:send_create) }
 
-        it "send create_meeting" do
-          mocked_api.should_receive(:create_meeting).
-            with(room.name, room.meetingid, room.moderator_password,
-                 room.attendee_password, room.welcome_msg, room.dial_number,
-                 room.logout_url, room.max_participants, room.voice_bridge).
-            and_return(hash_create)
-          room.server = mocked_server
-          room.send_create
+        context "send create_meeting" do
+
+          context "for a stored room" do
+            before do
+              mocked_api.should_receive(:create_meeting).
+                with(room.name, room.meetingid, room.moderator_password,
+                     room.attendee_password, room.welcome_msg, room.dial_number,
+                     room.logout_url, room.max_participants, room.voice_bridge).
+                and_return(hash_create)
+              room.server = mocked_server
+              room.send_create
+            end
+            it { room.attendee_password.should be(attendee_password) }
+            it { room.moderator_password.should be(moderator_password) }
+            it { room.changed?.should be_false }
+          end
 
-          room.attendee_password.should == attendee_password
-          room.moderator_password.should == moderator_password
+          context "for a new_record" do
+            let(:new_room) { Factory.build(:bigbluebutton_room) }
+            before do
+              mocked_api.should_receive(:create_meeting).
+                with(new_room.name, new_room.meetingid, new_room.moderator_password,
+                     new_room.attendee_password, new_room.welcome_msg, new_room.dial_number,
+                     new_room.logout_url, new_room.max_participants, new_room.voice_bridge).
+                and_return(hash_create)
+              new_room.server = mocked_server
+              new_room.send_create
+            end
+            it { new_room.attendee_password.should be(attendee_password) }
+            it { new_room.moderator_password.should be(moderator_password) }
+            it("do not save the record") { new_room.new_record?.should be_true }
+          end
 
-          # to be sure that the model was saved
-          saved = BigbluebuttonRoom.find(room.id)
-          saved.attendee_password.should == attendee_password
-          saved.moderator_password.should == moderator_password
         end
 
         context "randomizes meetingid" do
@@ -409,6 +434,13 @@ describe BigbluebuttonRoom do
           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
@@ -427,6 +459,98 @@ describe BigbluebuttonRoom do
       end
     end
 
+    describe "#add_domain_to_logout_url" do
+      context "when logout_url has a path only" do
+        let(:room) { Factory.create(:bigbluebutton_room, :logout_url => '/only/path') }
+        before(:each) { room.add_domain_to_logout_url("HTTP://", "test.com") }
+        it { room.logout_url.should == "http://test.com/only/path" }
+      end
+
+      context "when logout_url has a path and domain" do
+        let(:room) { Factory.create(:bigbluebutton_room, :logout_url => 'other.com/only/path') }
+        before(:each) { room.add_domain_to_logout_url("HTTP://", "test.com") }
+        it { room.logout_url.should == "http://other.com/only/path" }
+      end
+
+      context "when logout_url has a path, domain and protocol" do
+        let(:room) { Factory.create(:bigbluebutton_room, :logout_url => 'HTTPS://other.com/only/path') }
+        before(:each) { room.add_domain_to_logout_url("HTTP://", "test.com") }
+        it { room.logout_url.should == "https://other.com/only/path" }
+      end
+
+      context "does nothing if logout_url is nil" do
+        let(:room) { Factory.create(:bigbluebutton_room, :logout_url => nil) }
+        before(:each) { room.add_domain_to_logout_url("HTTP://", "test.com") }
+        it { room.logout_url.should == nil }
+      end
+    end
+
+    describe "#perform_join" do
+      let(:room) { Factory.create(:bigbluebutton_room) }
+      let(:user) { Factory.build(:user) }
+
+      context "for an attendee" do
+        before { room.should_receive(:fetch_is_running?) }
+
+        context "when the conference is running" do
+          before {
+            room.should_receive(:is_running?).and_return(true)
+            room.should_receive(:join_url).with(user.name, :attendee).
+              and_return("http://test.com/attendee/join")
+          }
+          subject { room.perform_join(user.name, :attendee) }
+          it { should == "http://test.com/attendee/join" }
+        end
+
+        context "when the conference is not running" do
+          before { room.should_receive(:is_running?).and_return(false) }
+          subject { room.perform_join(user.name, :attendee) }
+          it { should be_nil }
+        end
+      end
+
+      context "for a moderator" do
+        before { room.should_receive(:fetch_is_running?) }
+
+        context "when the conference is running" do
+          before {
+            room.should_receive(:is_running?).and_return(true)
+            room.should_receive(:join_url).with(user.name, :moderator).
+              and_return("http://test.com/moderator/join")
+          }
+          subject { room.perform_join(user.name, :moderator) }
+          it { should == "http://test.com/moderator/join" }
+        end
+
+        context "when the conference is not running" do
+          before {
+            room.should_receive(:is_running?).and_return(false)
+            room.should_receive(:send_create)
+            room.should_receive(:join_url).with(user.name, :moderator).
+              and_return("http://test.com/moderator/join")
+          }
+          subject { room.perform_join(user.name, :moderator) }
+          it { should == "http://test.com/moderator/join" }
+        end
+
+        context "when the arg 'request' is informed" do
+          let(:request) { stub(ActionController::Request) }
+          before {
+            request.stub!(:protocol).and_return("HTTP://")
+            request.stub!(:host).and_return("test.com")
+            room.should_receive(:add_domain_to_logout_url).with("HTTP://", "test.com")
+            room.should_receive(:is_running?).and_return(true)
+            room.should_receive(:join_url).with(user.name, :moderator).
+              and_return("http://test.com/moderator/join")
+          }
+          subject { room.perform_join(user.name, :moderator, request) }
+          it { should == "http://test.com/moderator/join" }
+        end
+
+      end
+
+    end
+
   end
 
 end

data/spec/models/bigbluebutton_server_spec.rb

@@ -133,8 +133,9 @@ describe BigbluebuttonServer do
         it { server.api.should == api }
 
         # updating any of these attributes should update the api
+        # FIXME: can't test the version updated bc only 0.7 is supported right now
         { :url => 'http://anotherurl.com/bigbluebutton/api',
-          :salt => '12345-abcde-67890-fghijk', :version => '0.64' }.each do |k,v|
+          :salt => '12345-abcde-67890-fghijk', :version => '0.7' }.each do |k,v|
           it {
             server.send("#{k}=", v)
             server.api.send(k).should == v
@@ -151,14 +152,13 @@ describe BigbluebuttonServer do
       end
     end
 
+    it { should respond_to(:fetch_meetings) }
+    it { should respond_to(:meetings) }
+
     context "fetching info from bbb" do
       let(:server) { Factory.create(:bigbluebutton_server) }
       let(:room1) { Factory.create(:bigbluebutton_room, :server => server, :meetingid => "room1", :randomize_meetingid => true) }
       let(:room2) { Factory.create(:bigbluebutton_room, :server => server, :meetingid => "room2", :randomize_meetingid => true) }
-      before {
-        @api_mock = mock(BigBlueButton::BigBlueButtonApi)
-        server.stub(:api).and_return(@api_mock)
-      }
 
       # the hashes should be exactly as returned by bigbluebutton-api-ruby to be sure we are testing it right
       let(:meetings) {
@@ -174,41 +174,32 @@ describe BigbluebuttonServer do
         }
       }
 
-      it { should respond_to(:fetch_meetings) }
-      it { should respond_to(:meetings) }
-
-      it "fetches meetings" do
+      before {
+        @api_mock = mock(BigBlueButton::BigBlueButtonApi)
+        server.stub(:api).and_return(@api_mock)
         @api_mock.should_receive(:get_meetings).and_return(hash)
         server.fetch_meetings
 
-        server.meetings.count.should be(3)
-
-        server.meetings[0].should == room1
-        server.meetings[0].attendee_password.should == "ap"
-        server.meetings[0].moderator_password.should == "mp"
-        server.meetings[0].running.should == true
-        server.meetings[0].new_record?.should be_false
-        server.meetings[0].external.should be_false
-        server.meetings[0].randomize_meetingid.should be_true
-
-        server.meetings[1].should == room2
-        server.meetings[1].attendee_password.should == "pass"
-        server.meetings[1].moderator_password.should == "pass"
-        server.meetings[1].running.should == false
-        server.meetings[1].new_record?.should be_false
-        server.meetings[1].external.should be_false
-        server.meetings[1].randomize_meetingid.should be_true
-
-        server.meetings[2].meetingid.should == "im not in the db"
-        server.meetings[2].server.should == server
-        server.meetings[2].attendee_password.should == "pass"
-        server.meetings[2].moderator_password.should == "pass"
-        server.meetings[2].running.should == true
-        server.meetings[2].new_record?.should be_false
-        server.meetings[2].external.should be_true
-        server.meetings[2].randomize_meetingid.should be_false
-      end
+        # the passwords are updated during fetch_meetings
+        room1.moderator_password = "mp"
+        room1.attendee_password = "ap"
+        room2.moderator_password = "pass"
+        room2.attendee_password = "pass"
+      }
 
+      it { server.meetings.count.should be(3) }
+      it { server.meetings[0].should have_same_attributes_as(room1) }
+      it { server.meetings[1].should have_same_attributes_as(room2) }
+      it { server.meetings[2].meetingid.should == "im not in the db" }
+      it { server.meetings[2].name.should == "im not in the db" }
+      it { server.meetings[2].server.should == server }
+      it { server.meetings[2].attendee_password.should == "pass" }
+      it { server.meetings[2].moderator_password.should == "pass" }
+      it { server.meetings[2].running.should == true }
+      it { server.meetings[2].new_record?.should be_true }
+      it { server.meetings[2].external.should be_true }
+      it { server.meetings[2].randomize_meetingid.should be_false }
+      it { server.meetings[2].private.should be_true  }
     end
 
   end

data/spec/rails_app/app/controllers/application_controller.rb

@@ -1,9 +1,10 @@
 class ApplicationController < ActionController::Base
   protect_from_forgery
 
-#  def bigbluebutton_user
-#    User.new
-#  end
+  # TODO: return a real user (use devise?)
+  def bigbluebutton_user
+    @user ||= User.new
+  end
 
 end
 

data/spec/rails_app/config/initializers/rack_hotfix.rb

@@ -0,0 +1,13 @@
+# FIXME: Temporary monkey-patch to solve rack warnings
+# See: http://blog.enricostahn.com/warning-regexp-match-n-against-to-utf-8-strin
+# This is solved in rack 1.3, but rails stills requires rack 1.2
+module Rack
+  module Utils
+    def escape(s)
+      CGI.escape(s.to_s)
+    end
+    def unescape(s)
+      CGI.unescape(s)
+    end
+  end
+end

data/spec/rails_app/features/join_external_bigbluebutton_rooms.feature

@@ -0,0 +1,19 @@
+Feature: Join External BigBlueButton Rooms
+  In order to join webconferences that were created from another application
+  One needs to enter his name and a password
+
+  Scenario: Joining an external BigBlueButton room
+    Given a user named "test user"
+      And a server
+      And an external room
+    When the user goes to the join external room page for this room
+    Then he should see a form to join the external room
+      And be able to join the room
+
+  Scenario: Uses the user name as the default to join a room
+    Given a user named "test user"
+      And a server
+      And an external room
+    When the user goes to the join external room page for this room
+    Then he should see a form to join the external room
+      And his name should be in the appropriate input