bigbluebutton_rails 0.0.2 → 0.0.3

data/spec/controllers/bigbluebutton/rooms_controller_spec.rb

@@ -1,27 +1,15 @@
 require 'spec_helper'
 require 'bigbluebutton-api'
 
+# Some tests mock the server and its API object
+# We don't want to trigger real API calls here (this is done in the integration tests)
+
 def build_running_json(value, error=nil)
   hash = { :running => "#{value}" }
   hash[:error] = error unless error.nil?
   hash.to_json
 end
 
-def mock_server_and_api
-  @api_mock = mock(BigBlueButton::BigBlueButtonApi)
-  @server_mock = mock_model(BigbluebuttonServer)
-  @server_mock.stub(:api).and_return(@api_mock)
-  BigbluebuttonServer.stub(:find).and_return(@server_mock)
-end
-
-def mocked_server
-  @server_mock
-end
-
-def mocked_api
-  @api_mock
-end
-
 describe Bigbluebutton::RoomsController do
 
   render_views
@@ -59,7 +47,7 @@ describe Bigbluebutton::RoomsController do
   describe "#create" do
     let(:new_room) { Factory.build(:bigbluebutton_room, :server => server) }
 
-    context do
+    context "on success" do
       before :each do
         expect {
           post :create, :server_id => server.to_param, :bigbluebutton_room => new_room.attributes
@@ -67,7 +55,7 @@ describe Bigbluebutton::RoomsController do
       end
       it {
         should respond_with(:redirect)
-        should redirect_to(bigbluebutton_server_room_path(server, BigbluebuttonRoom.last))
+        should redirect_to bigbluebutton_server_room_path(server, BigbluebuttonRoom.last)
       }
       it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.notice.create.success')) }
       it { should assign_to(:server).with(server) }
@@ -77,15 +65,46 @@ describe Bigbluebutton::RoomsController do
       }
     end
 
-    context "when meeting_id is not specified should copied from name" do
+    context "on failure" do
+      before :each do
+        new_room.name = nil # invalid
+        expect {
+          post :create, :server_id => server.to_param, :bigbluebutton_room => new_room.attributes
+        }.not_to change{ BigbluebuttonRoom.count }
+      end
+      it { should render_template(:new) }
+      it { should assign_to(:server).with(server) }
+    end
+
+    context "with :redir_url" do
+      it "on success" do
+        expect {
+          post :create, :server_id => server.to_param, :bigbluebutton_room => new_room.attributes,
+                        :redir_url => bigbluebutton_servers_path
+        }.to change{ BigbluebuttonRoom.count }.by(1)
+        should respond_with(:redirect)
+        should redirect_to bigbluebutton_servers_path
+      end
+      it "on failure" do
+        new_room.name = nil # invalid
+        expect {
+          post :create, :server_id => server.to_param, :bigbluebutton_room => new_room.attributes,
+                        :redir_url => bigbluebutton_servers_path
+        }.not_to change{ BigbluebuttonRoom.count }
+        should respond_with(:redirect)
+        should redirect_to bigbluebutton_servers_path
+      end
+    end
+
+    context "when meetingid is not specified it should be copied from name" do
       before :each do
         attr = new_room.attributes
-        attr.delete("meeting_id")
+        attr.delete("meetingid")
         post :create, :server_id => server.to_param, :bigbluebutton_room => attr
       end
       it {
         saved = BigbluebuttonRoom.last
-        new_room.meeting_id = new_room.name
+        new_room.meetingid = new_room.name
         saved.should have_same_attributes_as(new_room)
       }
     end
@@ -95,7 +114,7 @@ describe Bigbluebutton::RoomsController do
     let(:new_room) { Factory.build(:bigbluebutton_room) }
     before { @room = room }
 
-    context do
+    context "on success" do
       before :each do
         expect {
           put :update, :server_id => server.to_param, :id => @room.to_param, :bigbluebutton_room => new_room.attributes
@@ -103,7 +122,7 @@ describe Bigbluebutton::RoomsController do
       end
       it {
         should respond_with(:redirect)
-        should redirect_to(bigbluebutton_server_room_path(server, @room))
+        should redirect_to bigbluebutton_server_room_path(server, @room)
       }
       it {
         saved = BigbluebuttonRoom.find(@room)
@@ -113,15 +132,41 @@ describe Bigbluebutton::RoomsController do
       it { should assign_to(:server).with(server) }
     end
 
-    context "when meeting_id is not specified should copied from name" do
+    context "on failure" do
+      before :each do
+        new_room.name = nil # invalid
+        put :update, :server_id => server.to_param, :id => @room.to_param, :bigbluebutton_room => new_room.attributes
+      end
+      it { should render_template(:edit) }
+      it { should assign_to(:server).with(server) }
+      it { should assign_to(:room).with(@room) }
+    end
+
+    context "with :redir_url" do
+      it "on success" do
+        put :update, :server_id => server.to_param, :id => @room.to_param, :bigbluebutton_room => new_room.attributes,
+                     :redir_url => bigbluebutton_servers_path
+        should respond_with(:redirect)
+        should redirect_to bigbluebutton_servers_path
+      end
+      it "on failure" do
+        new_room.name = nil # invalid
+        put :update, :server_id => server.to_param, :id => @room.to_param, :bigbluebutton_room => new_room.attributes,
+                     :redir_url => bigbluebutton_servers_path
+        should respond_with(:redirect)
+        should redirect_to bigbluebutton_servers_path
+      end
+    end
+
+    context "when meetingid is not specified should copied from name" do
       before :each do
         attr = new_room.attributes
-        attr.delete("meeting_id")
+        attr.delete("meetingid")
         put :update, :server_id => server.to_param, :id => @room.to_param, :bigbluebutton_room => attr
       end
       it {
         saved = BigbluebuttonRoom.find(@room)
-        new_room.meeting_id = new_room.name
+        new_room.meetingid = new_room.name
         saved.should have_same_attributes_as(new_room)
       }
     end
@@ -133,19 +178,31 @@ describe Bigbluebutton::RoomsController do
       mock_server_and_api
       # to make sure it calls end_meeting if the meeting is running
       mocked_api.should_receive(:is_meeting_running?).and_return(true)
-      mocked_api.should_receive(:end_meeting).with(room.meeting_id, room.moderator_password)
+      mocked_api.should_receive(:end_meeting).with(room.meetingid, room.moderator_password)
     }
 
-    before :each do
+    context do
+      before :each do
+        expect {
+          delete :destroy, :server_id => mocked_server.to_param, :id => room.to_param
+        }.to change{ BigbluebuttonRoom.count }.by(-1)
+      end
+      it {
+        should respond_with(:redirect)
+        should redirect_to bigbluebutton_server_rooms_url
+      }
+      it { should assign_to(:server).with(mocked_server) }
+    end
+
+    it "with :redir_url" do
       expect {
-        delete :destroy, :server_id => mocked_server.to_param, :id => room.to_param
+        delete :destroy, :server_id => mocked_server.to_param, :id => room.to_param,
+                         :redir_url => bigbluebutton_servers_path
       }.to change{ BigbluebuttonRoom.count }.by(-1)
-    end
-    it {
       should respond_with(:redirect)
-      should redirect_to(bigbluebutton_server_rooms_path)
-    }
-    it { should assign_to(:server).with(mocked_server) }
+      should redirect_to bigbluebutton_servers_path
+    end
+
   end
 
   describe "#running" do
@@ -170,58 +227,234 @@ describe Bigbluebutton::RoomsController do
   end
 
   describe "#join" do
-
-    before { controller.stub_chain(:bigbluebutton_user, :name).and_return("Test name") }
-
-    # mock the server so we can mock the BBB API
-    # we don't want to trigger real API calls here (this is done in the integration tests)
-
-    # setup basic server and API mocks
+    let(:user) { Factory.build(:user) }
     before { mock_server_and_api }
 
-    context "if the user is a moderator" do
-      before {
-        controller.should_receive(:bigbluebutton_role).with(room).and_return(:moderator)
-        mocked_api.should_receive(:join_meeting_url).and_return("http://test.com/mod/join")
+    context "for an anonymous user" do
+      before { controller.stub(:bigbluebutton_user) { nil } }
+      before { controller.stub(:bigbluebutton_role) { :moderator } }
+      before(:each) { get :join, :server_id => mocked_server.to_param, :id => room.to_param }
+      it {
+        should respond_with(:redirect)
+        should redirect_to(invite_bigbluebutton_server_room_path(mocked_server, room))
       }
+    end
 
-      context "and the conference is running" do
+    context "for a user without a role" do
+      before { controller.stub(:bigbluebutton_user) { user } }
+      before { controller.stub(:bigbluebutton_role) { nil } }
+      before(:each) { get :join, :server_id => mocked_server.to_param, :id => room.to_param }
+      it {
+        should respond_with(:redirect)
+        should redirect_to(invite_bigbluebutton_server_room_path(mocked_server, room))
+      }
+    end
+
+    context do
+      before { controller.stub(:bigbluebutton_user) { user } }
+
+      context "if the user is a moderator" do
         before {
-          mocked_api.should_receive(:is_meeting_running?).and_return(true)
+          controller.should_receive(:bigbluebutton_role).with(room).and_return(:moderator)
+          mocked_api.should_receive(:join_meeting_url).with(room.meetingid, user.name, room.moderator_password).
+            and_return("http://test.com/mod/join")
         }
 
-        it "assigns server" do
-          get :join, :server_id => mocked_server.to_param, :id => room.to_param
-          should assign_to(:server).with(mocked_server)
+        context "and the conference is running" do
+          before {
+            mocked_api.should_receive(:is_meeting_running?).and_return(true)
+          }
+
+          it "assigns server" do
+            get :join, :server_id => mocked_server.to_param, :id => room.to_param
+            should assign_to(:server).with(mocked_server)
+          end
+
+          it "redirects to the moderator join url" do
+            get :join, :server_id => mocked_server.to_param, :id => room.to_param
+            should respond_with(:redirect)
+            should redirect_to("http://test.com/mod/join")
+          end
         end
 
-        it "redirects to the moderator join url" do
-          get :join, :server_id => mocked_server.to_param, :id => room.to_param
-          should respond_with(:redirect)
-          should redirect_to("http://test.com/mod/join")
+        context "and the conference is NOT running" do
+          before {
+            mocked_api.should_receive(:is_meeting_running?).and_return(false)
+          }
+
+          it "creates the conference" 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)
+            get :join, :server_id => mocked_server.to_param, :id => room.to_param
+          end
         end
+
       end
 
-      context "and the conference is NOT running" do
+      context "if the user is an attendee" do
         before {
-          mocked_api.should_receive(:is_meeting_running?).and_return(false)
+          controller.should_receive(:bigbluebutton_role).with(room).and_return(:attendee)
         }
 
-        it "creates the conference" do
-          mocked_api.should_receive(:create_meeting).
-            with(room.name, room.meeting_id, room.moderator_password,
-                 room.attendee_password, room.welcome_msg)
-          get :join, :server_id => mocked_server.to_param, :id => room.to_param
+        context "and the conference is running" do
+          before {
+            mocked_api.should_receive(:is_meeting_running?).and_return(true)
+            mocked_api.should_receive(:join_meeting_url).with(room.meetingid, user.name, room.attendee_password).
+              and_return("http://test.com/attendee/join")
+          }
+
+          it "assigns server" do
+            get :join, :server_id => mocked_server.to_param, :id => room.to_param
+            should assign_to(:server).with(mocked_server)
+          end
+
+          it "redirects to the attendee join url" do
+            get :join, :server_id => mocked_server.to_param, :id => room.to_param
+            should respond_with(:redirect)
+            should redirect_to("http://test.com/attendee/join")
+          end
+        end
+
+        context "and the conference is NOT running" do
+          before {
+            mocked_api.should_receive(:is_meeting_running?).and_return(false)
+          }
+
+          it "do not try to create the conference" do
+            mocked_api.should_not_receive(:create_meeting)
+            get :join, :server_id => mocked_server.to_param, :id => room.to_param
+          end
+
+          it "renders #join to wait for a moderator" do
+            get :join, :server_id => mocked_server.to_param, :id => room.to_param
+            should respond_with(:success)
+            should render_template(:join)
+          end
         end
+
       end
 
     end
 
-    context "if the user is an attendee" do
+  end
+
+  describe "#end" do
+    before { mock_server_and_api }
+
+    context "room is running" do
       before {
-        controller.should_receive(:bigbluebutton_role).with(room).and_return(:attendee)
+        mocked_api.should_receive(:is_meeting_running?).and_return(true)
+        mocked_api.should_receive(:end_meeting).with(room.meetingid, room.moderator_password)
       }
+      before(:each) { get :end, :server_id => mocked_server.to_param, :id => room.to_param }
+      it { should respond_with(:redirect) }
+      it { should redirect_to(bigbluebutton_server_room_path(mocked_server, room)) }
+      it { should assign_to(:server).with(mocked_server) }
+      it { should assign_to(:room).with(room) }
+      it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.notice.end.success')) }
+    end
+
+    context "room is not running" do
+      before { mocked_api.should_receive(:is_meeting_running?).and_return(false) }
+      before(:each) { get :end, :server_id => mocked_server.to_param, :id => room.to_param }
+      it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.notice.end.not_running')) }
+    end
+  end
+
+  describe "#invite" do
+    before { mock_server_and_api }
+    let(:user) { Factory.build(:user) }
+
+    context "for an anonymous user" do
+      before { controller.stub(:bigbluebutton_user).and_return(nil) }
+      
+      context "with a role defined" do
+        before { controller.stub(:bigbluebutton_role).and_return(:attendee) }
+        before(:each) { get :invite, :server_id => mocked_server.to_param, :id => room.to_param }
+        it { should respond_with(:success) }
+        it { should render_template(:invite) }
+        it { should assign_to(:room).with(room) }
+      end
+
+      context "without a role" do
+        before { controller.stub(:bigbluebutton_role).and_return(nil) }
+        before(:each) { get :invite, :server_id => mocked_server.to_param, :id => room.to_param }
+        it { should respond_with(:success) }
+        it { should render_template(:invite) }
+        it { should assign_to(:room).with(room) }
+      end
+    end
+
+    context "for a logged user" do
+      before { controller.stub(:bigbluebutton_user).and_return(user) }
+
+      context "with a role defined" do
+        before { controller.stub(:bigbluebutton_role).and_return(:attendee) }
+        before(:each) { get :invite, :server_id => mocked_server.to_param, :id => room.to_param }
+        it { should respond_with(:redirect) }
+        it { should redirect_to(join_bigbluebutton_server_room_path(mocked_server, room)) }
+      end
 
+      context "without a role" do
+        before { controller.stub(:bigbluebutton_role).and_return(nil) }
+        before(:each) { get :invite, :server_id => mocked_server.to_param, :id => room.to_param }
+        it { should respond_with(:success) }
+        it { should render_template(:invite) }
+        it { should assign_to(:room).with(room) }
+      end
+    end
+
+  end
+
+  describe "#auth" do
+    let(:user) { Factory.build(:user) }
+    before {
+      mock_server_and_api
+      controller.stub(:bigbluebutton_user).and_return(nil)
+    }
+
+    context "if there's a user logged, should use it's name" do
+      let(:hash) { { :name => "Elftor", :password => room.attendee_password } }
+      it do
+        controller.stub(:bigbluebutton_user).and_return(user)
+        mocked_api.should_receive(:is_meeting_running?).and_return(true)
+        mocked_api.should_receive(:join_meeting_url).
+          with(room.meetingid, user.name, room.attendee_password).
+          and_return("http://test.com/attendee/join")
+        post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash
+        should respond_with(:redirect)
+        should redirect_to("http://test.com/attendee/join")
+      end
+    end
+
+    context "shows error when" do
+
+      context "name is not set" do
+        let(:hash) { { :password => room.moderator_password } }
+        before(:each) { post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash }
+        it { should respond_with(:unauthorized) }
+        it { should assign_to(:room).with(room) }
+        it { should render_template(:invite) }
+        it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.error.auth.failure')) }
+      end
+
+      context "the password is wrong" do
+        let(:hash) { { :name => "Elftor", :password => nil } }
+        before(:each) { post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash }
+        it { should respond_with(:unauthorized) }
+        it { should assign_to(:room).with(room) }
+        it { should render_template(:invite) }
+        it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.error.auth.failure')) }
+      end
+
+    end
+
+    context "entering the attendee password" do
+      let(:hash) { { :name => "Elftor", :password => room.attendee_password } }
+
+      # OPTMIZE Almost the same tests as in #join. Can they be integrated somehow?
       context "and the conference is running" do
         before {
           mocked_api.should_receive(:is_meeting_running?).and_return(true)
@@ -229,12 +462,12 @@ describe Bigbluebutton::RoomsController do
         }
 
         it "assigns server" do
-          get :join, :server_id => mocked_server.to_param, :id => room.to_param
+          post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash
           should assign_to(:server).with(mocked_server)
         end
 
         it "redirects to the attendee join url" do
-          get :join, :server_id => mocked_server.to_param, :id => room.to_param
+          post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash
           should respond_with(:redirect)
           should redirect_to("http://test.com/attendee/join")
         end
@@ -247,40 +480,58 @@ describe Bigbluebutton::RoomsController do
 
         it "do not try to create the conference" do
           mocked_api.should_not_receive(:create_meeting)
-          get :join, :server_id => mocked_server.to_param, :id => room.to_param
+          post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash
         end
 
-        it "render the join_wait view to wait for a moderator" do
-          get :join, :server_id => mocked_server.to_param, :id => room.to_param
+        it "renders #invite" do
+          post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash
           should respond_with(:success)
-          should render_template(:join_wait)
+          should render_template(:invite)
+          should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.error.not_running'))
         end
       end
 
     end
 
-  end
-
-  describe "#end" do
-    before { mock_server_and_api }
+    context "entering the moderator password" do
+      let(:hash) { { :name => "Elftor", :password => room.moderator_password } }
 
-    context "room is running" do
+      # OPTMIZE Almost the same tests as in #join. Can they be integrated somehow?
       before {
-        mocked_api.should_receive(:is_meeting_running?).and_return(true)
-        mocked_api.should_receive(:end_meeting).with(room.meeting_id, room.moderator_password)
+        mocked_api.should_receive(:join_meeting_url).and_return("http://test.com/mod/join")
       }
-      before(:each) { get :end, :server_id => mocked_server.to_param, :id => room.to_param }
-      it { should respond_with(:redirect) }
-      it { should redirect_to(bigbluebutton_server_room_path(mocked_server, room)) }
-      it { should assign_to(:server).with(mocked_server) }
-      it { should assign_to(:room).with(room) }
-      it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.notice.end.success')) }
-    end
 
-    context "room is not running" do
-      before { mocked_api.should_receive(:is_meeting_running?).and_return(false) }
-      before(:each) { get :end, :server_id => mocked_server.to_param, :id => room.to_param }
-      it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.notice.end.not_running')) }
+      context "and the conference is running" do
+        before {
+          mocked_api.should_receive(:is_meeting_running?).and_return(true)
+        }
+
+        it "assigns server" do
+          post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash
+          should assign_to(:server).with(mocked_server)
+        end
+
+        it "redirects to the moderator join url" do
+          post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash
+          should respond_with(:redirect)
+          should redirect_to("http://test.com/mod/join")
+        end
+      end
+
+      context "and the conference is NOT running" do
+        before {
+          mocked_api.should_receive(:is_meeting_running?).and_return(false)
+        }
+
+        it "creates the conference" 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)
+          post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash
+        end
+      end
+
     end
   end
 
@@ -316,7 +567,7 @@ describe Bigbluebutton::RoomsController do
       after :each do
         delete :destroy, :server_id => mocked_server.to_param, :id => room.to_param
         should respond_with(:redirect)
-        should redirect_to(bigbluebutton_server_rooms_path)
+        should redirect_to bigbluebutton_server_rooms_url
         should set_the_flash.to(bbb_error_msg)
       end
     end
@@ -348,7 +599,7 @@ describe Bigbluebutton::RoomsController do
     end
 
     describe "#join" do
-      before { controller.stub_chain(:bigbluebutton_user, :name).and_return("Test name") }
+      before { controller.stub(:bigbluebutton_user) { Factory.build(:user) } }
 
       context "as moderator" do
         before { controller.should_receive(:bigbluebutton_role).with(room).and_return(:moderator) }

data/spec/factories/bigbluebutton_room.rb

@@ -1,8 +1,10 @@
 Factory.define :bigbluebutton_room do |r|
   r.association :server, :factory => :bigbluebutton_server
-  r.sequence(:meeting_id) { |n| "MeetingID#{n}" }
+  r.sequence(:meetingid) { |n| "MeetingID#{n}" }
   r.sequence(:name) { |n| "Name#{n}" }
-  r.attendee_password { Forgery(:basic).password :at_least => 10, :at_most => 20 }
-  r.moderator_password { Forgery(:basic).password :at_least => 10, :at_most => 20 }
+  r.attendee_password { Forgery(:basic).password :at_least => 10, :at_most => 16 }
+  r.moderator_password { Forgery(:basic).password :at_least => 10, :at_most => 16 }
   r.welcome_msg { Forgery(:lorem_ipsum).sentences(2) }
+  r.private false
+  r.randomize_meetingid false
 end

data/spec/factories/user.rb

@@ -0,0 +1,3 @@
+Factory.define :user do |u|
+  u.name { Forgery(:name).full_name }
+end

data/spec/generators/public_generator_spec.rb

@@ -19,7 +19,6 @@ describe BigbluebuttonRails::Generators::PublicGenerator do
   def assert_files(assert_exists=true)
     files = [
       "public/images/loading.gif",
-      "public/javascripts/heartbeat.js",
       "public/javascripts/jquery.min.js"
     ]
     if assert_exists

data/spec/generators/views_generator_spec.rb

@@ -33,7 +33,7 @@ describe BigbluebuttonRails::Generators::ViewsGenerator do
       "app/views/#{scope}/rooms/edit.html.erb",
       "app/views/#{scope}/rooms/_form.html.erb",
       "app/views/#{scope}/rooms/index.html.erb",
-      "app/views/#{scope}/rooms/join_wait.html.erb",
+      "app/views/#{scope}/rooms/join.html.erb",
       "app/views/#{scope}/rooms/new.html.erb",
       "app/views/#{scope}/rooms/show.html.erb",
       "app/views/#{scope}/servers/edit.html.erb",