bigbluebutton_rails 0.0.5 → 0.0.6

data/spec/controllers/bigbluebutton/rooms_controller_spec.rb

@@ -1,17 +1,10 @@
 require 'spec_helper'
-require 'bigbluebutton-api'
+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
-
 describe Bigbluebutton::RoomsController do
-
   render_views
   let(:server) { Factory.create(:bigbluebutton_server) }
   let(:room) { Factory.create(:bigbluebutton_room, :server => server) }
@@ -50,19 +43,25 @@ describe Bigbluebutton::RoomsController do
 
   describe "#join_mobile" do
     let(:user) { Factory.build(:user) }
+    let(:server) { Factory.create(:bigbluebutton_server) }
+    let(:room) { Factory.create(:bigbluebutton_room, :server => server) }
     before {
       mock_server_and_api
       controller.stub(:bigbluebutton_user) { user }
       controller.should_receive(:bigbluebutton_role).and_return(:moderator)
+      controller.should_receive(:join_bigbluebutton_server_room_path).
+        with(mocked_server, room, :mobile => '1').
+        and_return("http://test.com/join/url?mobile=1")
       mocked_api.should_receive(:join_meeting_url).
         with(room.meetingid, user.name, room.moderator_password).
-        and_return("http://join_url")
+        and_return("bigbluebutton://test.com/open/url/for/qrcode")
     }
     before(:each) { get :join_mobile, :server_id => mocked_server.to_param, :id => room.to_param }
     it { should respond_with(:success) }
     it { should assign_to(:server).with(mocked_server) }
     it { should assign_to(:room).with(room) }
-    it { should assign_to(:join_url).with("bigbluebutton://join_url") }
+    it { should assign_to(:join_url).with("bigbluebutton://test.com/join/url?mobile=1") }
+    it { should assign_to(:qrcode_url).with("bigbluebutton://test.com/open/url/for/qrcode") }
     it { should render_template(:join_mobile) }
   end
 
@@ -283,124 +282,26 @@ describe Bigbluebutton::RoomsController do
       end
     end
 
-    context do
-      before { controller.stub(:bigbluebutton_user) { user } }
-
-      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).with(room.meetingid, user.name, room.moderator_password).
-            and_return("http://test.com/mod/join")
-        }
-
-        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
-
-        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
-
-          context "adds the protocol/domain to logout_url" do
-            after :each do
-              get :join, :server_id => mocked_server.to_param, :id => room.to_param
-            end
-
-            it "when it doesn't have protocol neither domain" do
-              room.update_attributes(:logout_url => "/incomplete/url")
-              full_logout_url = "http://test.host" + room.logout_url
-
-              mocked_api.should_receive(:create_meeting).
-                with(anything, anything, anything, anything, anything, anything,
-                     full_logout_url, anything, anything)
-            end
-
-            it "when it doesn't have protocol only" do
-              room.update_attributes(:logout_url => "www.host.com/incomplete/url")
-              full_logout_url = "http://" + room.logout_url
-
-              mocked_api.should_receive(:create_meeting).
-                with(anything, anything, anything, anything, anything, anything,
-                     full_logout_url, anything, anything)
-            end
-
-            it "but not when it has a protocol defined" do
-              room.update_attributes(:logout_url => "http://with/protocol")
-              mocked_api.should_receive(:create_meeting).
-                with(anything, anything, anything, anything, anything, anything,
-                     room.logout_url, anything, anything)
-            end
-          end
-
-        end
-
-      end
-
-      context "if the user is an attendee" do
-        before {
-          controller.should_receive(:bigbluebutton_role).with(room).and_return(:attendee)
-        }
-
-        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
+    # verify the behaviour of .join_internal
+    # see support/shared_examples/rooms_controller.rb
+    context "calling .join_internal" do
+      let(:template) { :join }
+      let(:request) { get :join, :server_id => mocked_server.to_param, :id => room.to_param }
+      before { controller.stub(:bigbluebutton_user).and_return(user) }
+      it_should_behave_like "internal join caller"
+    end
 
+    context "when :mobile => true" do
+      before {
+        controller.stub(:bigbluebutton_user) { user }
+        controller.stub(:bigbluebutton_role) { :moderator }
+        BigbluebuttonRoom.stub(:find_by_param).and_return(room)
+        room.should_receive(:perform_join).and_return("http://test.com/join/url")
+      }
+      before(:each) {
+        get :join, :server_id => mocked_server.to_param, :id => room.to_param, :mobile => "1"
+      }
+      it { should redirect_to("bigbluebutton://test.com/join/url") }
     end
 
   end
@@ -503,6 +404,30 @@ describe Bigbluebutton::RoomsController do
       controller.stub(:bigbluebutton_user).and_return(nil)
     }
 
+    context "assigns @room" do
+      let(:user_hash) { { :name => "Elftor", :password => room.attendee_password } }
+      let(:meetingid) { "my-meeting-id" }
+      let(:http_referer) { bigbluebutton_server_path(mocked_server) }
+      before {
+        mocked_api.stub!(:is_meeting_running?)
+        request.env["HTTP_REFERER"] = http_referer
+      }
+
+      context "if params[:id]" do
+        before(:each) { post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => user_hash }
+        it { should assign_to(:room).with(room) }
+      end
+
+      context "if params[:id] doesn't exists" do
+        let(:message) { I18n.t('bigbluebutton_rails.rooms.errors.auth.wrong_params') }
+        before(:each) { post :auth, :server_id => mocked_server.to_param, :id => "inexistent-room-id", :user => user_hash }
+        it { should assign_to(:room).with(nil) }
+        it { should respond_with(:redirect) }
+        it { should redirect_to(http_referer) }
+        it { should set_the_flash.to(message) }
+      end
+    end
+
     context "block access if bigbluebutton_role returns nil" do
       let(:hash) { { :name => "Elftor", :password => room.attendee_password } }
       before { controller.stub(:bigbluebutton_role) { nil } }
@@ -513,402 +438,233 @@ describe Bigbluebutton::RoomsController do
       }
     end
 
-    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
+    it "if there's a user logged, should use his name" do
+      controller.stub(:bigbluebutton_role) { :password }
+      hash = { :name => "Elftor", :password => room.attendee_password }
+      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). # here's the validation
+        and_return("http://test.com/attendee/join")
+      post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash
     end
 
-    context "shows error when" do
+    it "redirects to the correct join_url" do
+      hash = { :name => "Elftor", :password => room.attendee_password }
+      mocked_api.should_receive(:is_meeting_running?).and_return(true)
+      mocked_api.should_receive(:join_meeting_url).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
 
-      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 "use bigbluebutton_role when the return is diferent of password" do
+      controller.stub(:bigbluebutton_role) { :attendee }
+      hash = { :name => "Elftor", :password => nil }
+      mocked_api.should_receive(:is_meeting_running?).and_return(true)
+      mocked_api.should_receive(:join_meeting_url).
+        with(anything, anything, 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
+
+    context "validates user input and shows error" do
+      before { controller.should_receive(:bigbluebutton_role).once { :password } }
+      before(:each) { post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => user_hash }
+
+      context "when name is not set" do
+        let(:user_hash) { { :password => room.moderator_password } }
         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.errors.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 }
+      context "when the password is wrong" do
+        let(:user_hash) { { :name => "Elftor", :password => nil } }
         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.errors.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)
-          mocked_api.should_receive(:join_meeting_url).and_return("http://test.com/attendee/join")
-        }
-
-        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 attendee 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/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)
-          post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash
-        end
-
-        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(:invite)
-          should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.errors.auth.not_running'))
-        end
-      end
-
+    # verify the behaviour of .join_internal
+    # see support/shared_examples/rooms_controller.rb
+    context "calling .join_internal" do
+      let(:template) { :invite }
+      let(:hash) { { :name => user.name, :password => room.attendee_password } }
+      let(:request) { post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash }
+      before { controller.stub(:bigbluebutton_user).and_return(nil) }
+      it_should_behave_like "internal join caller"
     end
+  end
 
-    context "entering the moderator password" do
-      let(:hash) { { :name => "Elftor", :password => room.moderator_password } }
-
-      # OPTMIZE Almost the same tests as in #join. Can they be integrated somehow?
-      before {
-        mocked_api.should_receive(:join_meeting_url).and_return("http://test.com/mod/join")
-      }
+  describe "#external" do
+    before { mock_server_and_api }
+    let(:new_room) { BigbluebuttonRoom.new(:meetingid => 'my-meeting-id') }
 
-      context "and the conference is running" do
-        before {
-          mocked_api.should_receive(:is_meeting_running?).and_return(true)
-        }
+    context "on success" do
+      before { controller.stub(:bigbluebutton_user).and_return(nil) }
+      before(:each) { get :external, :server_id => mocked_server.to_param, :meeting => new_room.meetingid }
+      it { should assign_to(:server).with(mocked_server) }
+      it { should respond_with(:success) }
+      it { should render_template(:external) }
+      it { should assign_to(:room).with_kind_of(BigbluebuttonRoom) }
+      it { assigns(:room).meetingid.should be(new_room.meetingid) }
+    end
 
-        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
+    context "when params[:meeting].blank?" do
+      before { controller.stub(:bigbluebutton_user).and_return(nil) }
 
-        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
+      context "without params[:redir_url]" do
+        before(:each) { get :external, :server_id => mocked_server.to_param }
+        it { should respond_with(:redirect) }
+        it { should redirect_to bigbluebutton_server_rooms_path(mocked_server) }
+        it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.errors.external.blank_meetingid')) }
       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
+      context "with params[:redir_url]" do
+        before(:each) { get :external, :server_id => mocked_server.to_param, :redir_url => '/'}
+        it { should redirect_to '/' }
       end
-
     end
-  end
-
-  # can be used when matching rooms inside some resource other than servers
-  context "selects the first server when the server_id in the url is inexistent" do
-    let(:server2) { Factory.create(:bigbluebutton_server) }
-
-    # get /users/:user_id/room/:id(.:format)
-    before(:each) { get :show, :id => room.to_param, :user_id => "1" }
-    it { should respond_with(:success) }
-    it { should assign_to(:server).with(server) }
-  end
+  end # #external
 
-  # make sure that the exceptions thrown by bigbluebutton-api-ruby are treated by the controller
-  context "exception handling" do
-    let(:bbb_error_msg) { "err msg" }
-    let(:bbb_error) { BigBlueButton::BigBlueButtonException.new(bbb_error_msg) }
+  describe "#external_auth" do
+    let(:user) { Factory.build(:user) }
+    let(:user_hash) { { :name => "Elftor", :password => new_room.attendee_password } }
+    let(:meetingid) { "my-meeting-id" }
+    let(:new_room) { BigbluebuttonRoom.new(:meetingid => meetingid,
+                                           :attendee_password => Forgery(:basic).password,
+                                           :moderator_password => Forgery(:basic).password,
+                                           :server => mocked_server) }
+    let(:meetings) { [ new_room ] }
     let(:http_referer) { bigbluebutton_server_path(mocked_server) }
     before {
       mock_server_and_api
+      controller.stub(:bigbluebutton_user).and_return(nil)
       request.env["HTTP_REFERER"] = http_referer
     }
 
-    describe "#destroy" do
-      it "catches exception on is_meeting_running" do
-        mocked_api.should_receive(:is_meeting_running?) { raise bbb_error }
+    context "assigns @room" do
+      context "if params[:meeting] and params[:user]" do
+        before { # TODO: this block is being repeated several times, put it in a method or something
+          mocked_server.should_receive(:fetch_meetings)
+          mocked_server.should_receive(:meetings).and_return(meetings)
+          new_room.should_receive(:fetch_meeting_info)
+        }
+        before(:each) { post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :user => user_hash }
+        it { should assign_to(:room).with(new_room) }
       end
 
-      it "catches exception on end_meeting" do
-        mocked_api.should_receive(:is_meeting_running?).and_return(true)
-        mocked_api.should_receive(:end_meeting) { raise bbb_error }
+      context "if not params[:meeting]" do
+        let(:message) { I18n.t('bigbluebutton_rails.rooms.errors.auth.wrong_params') }
+        before(:each) { post :external_auth, :server_id => mocked_server.to_param, :meeting => nil, :user => user_hash }
+        it { should assign_to(:room).with(nil) }
+        it { should respond_with(:redirect) }
+        it { should redirect_to(http_referer) }
+        it { should set_the_flash.to(message) }
       end
 
-      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_url
-        should set_the_flash.to(bbb_error_msg)
+      context "if not params[:user]" do
+        let(:message) { I18n.t('bigbluebutton_rails.rooms.errors.auth.wrong_params') }
+        before(:each) { post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :user => nil }
+        it { should assign_to(:room).with(nil) }
+        it { should respond_with(:redirect) }
+        it { should redirect_to(http_referer) }
+        it { should set_the_flash.to(message) }
       end
     end
 
-    describe "#running" do
-      before { mocked_api.should_receive(:is_meeting_running?) { raise bbb_error } }
-      before(:each) { get :running, :server_id => mocked_server.to_param, :id => room.to_param }
-      it { should respond_with(:success) }
-      it { response.body.should == build_running_json(false, bbb_error_msg) }
-      it { should set_the_flash.to(bbb_error_msg) }
-    end
-
-    describe "#end" do
-      it "catches exception on is_meeting_running" do
-        mocked_api.should_receive(:is_meeting_running?) { raise bbb_error }
-      end
+    context "got the room" do
+      before {
+        mocked_server.should_receive(:fetch_meetings)
+        mocked_server.should_receive(:meetings).and_return(meetings)
+      }
 
-      it "catches exception on end_meeting" do
-        mocked_api.should_receive(:is_meeting_running?).and_return(true)
-        mocked_api.should_receive(:end_meeting) { raise bbb_error }
+      it "block access if bigbluebutton_role returns nil" do
+        controller.stub(:bigbluebutton_role) { nil }
+        lambda {
+          post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :user => user_hash
+        }.should raise_error(BigbluebuttonRails::RoomAccessDenied)
       end
 
-      after :each do
-        get :end, :server_id => mocked_server.to_param, :id => room.to_param
-        should respond_with(:redirect)
-        should redirect_to(http_referer)
-        should set_the_flash.to(bbb_error_msg)
+      it "fetches meeting info" do
+        new_room.should_receive(:fetch_meeting_info)
+        post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :user => user_hash
       end
-    end
 
-    describe "#join" do
-      before { controller.stub(:bigbluebutton_user) { Factory.build(:user) } }
+      context "validates user input and shows error" do
+        before(:each) { post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :user => user_hash }
 
-      context "as moderator" do
-        before { controller.should_receive(:bigbluebutton_role).with(room).and_return(:moderator) }
-
-        it "catches exception on is_meeting_running" do
-          mocked_api.should_receive(:is_meeting_running?) { raise bbb_error }
+        context "when name is not set" do
+          let(:user_hash) { { :password => room.moderator_password } }
+          it { should respond_with(:unauthorized) }
+          it { should assign_to(:room).with(new_room) }
+          it { should render_template(:external) }
+          it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.errors.auth.failure')) }
         end
 
-        it "catches exception on create_meeting" do
-          mocked_api.should_receive(:is_meeting_running?).and_return(false)
-          mocked_api.should_receive(:create_meeting) { raise bbb_error }
+        context "when the password is wrong" do
+          let(:user_hash) { { :name => "Elftor", :password => nil } }
+          it { should respond_with(:unauthorized) }
+          it { should assign_to(:room).with(new_room) }
+          it { should render_template(:external) }
+          it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.errors.auth.failure')) }
         end
-
-        it "catches exception on join_meeting_url" do
-          mocked_api.should_receive(:is_meeting_running?).and_return(true)
-          mocked_api.should_receive(:join_meeting_url) { raise bbb_error }
-        end
-
-        after :each do
-          get :join, :server_id => mocked_server.to_param, :id => room.to_param
-          should respond_with(:redirect)
-          should redirect_to(http_referer)
-          should set_the_flash.to(bbb_error_msg)
-        end
-
       end
 
-      context "as moderator" do
-        before { controller.should_receive(:bigbluebutton_role).with(room).and_return(:attendee) }
-
-        it "catches exception on is_meeting_running" do
-          mocked_api.should_receive(:is_meeting_running?) { raise bbb_error }
-        end
+      context "and the meeting is running" do
+        before {
+          new_room.should_receive(:fetch_meeting_info)
+          new_room.running = true
+        }
 
-        it "catches exception on join_meeting_url" do
-          mocked_api.should_receive(:is_meeting_running?).and_return(true)
-          mocked_api.should_receive(:join_meeting_url) { raise bbb_error }
+        it "if there's a user logged, should use his name" do
+          controller.stub(:bigbluebutton_user).and_return(user)
+          mocked_api.should_receive(:join_meeting_url).
+            with(new_room.meetingid, user.name, new_room.attendee_password). # here's the validation
+            and_return("http://test.com/attendee/join")
+          post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :user => user_hash
         end
 
-        after :each do
-          get :join, :server_id => mocked_server.to_param, :id => room.to_param
+        it "redirects to the correct join_url" do
+          controller.stub(:bigbluebutton_user).and_return(user)
+          mocked_api.should_receive(:join_meeting_url).
+            and_return("http://test.com/attendee/join")
+          post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :user => user_hash
           should respond_with(:redirect)
-          should redirect_to(http_referer)
-          should set_the_flash.to(bbb_error_msg)
+          should redirect_to("http://test.com/attendee/join")
         end
       end
 
-    end # #join
-
-  end # exception handling
-
-  # verify all JSON responses
-  context "json responses for " do
-    describe "#index" do
-      before do
-        @room1 = Factory.create(:bigbluebutton_room, :server => server)
-        @room2 = Factory.create(:bigbluebutton_room, :server => server)
-      end
-      before(:each) { get :index, :server_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
-
-    describe "#new" do
-      before(:each) { get :new, :server_id => server.to_param, :format => 'json' }
-      it { should respond_with(:success) }
-      it { should respond_with_content_type(:json) }
-      it {
-        # we ignore all values bc a BigbluebuttonRoom is generated with some
-        # random values (meetingid, voice_bridge)
-        should respond_with_json(BigbluebuttonRoom.new.to_json).ignoring_values
-      }
-    end
-
-    describe "#show" do
-      before(:each) { get :show, :server_id => server.to_param, :id => room.to_param, :format => 'json' }
-      it { should respond_with(:success) }
-      it { should respond_with_content_type(:json) }
-      it { should respond_with_json(room.to_json) }
-    end
-
-    describe "#create" do
-      let(:new_room) { Factory.build(:bigbluebutton_room, :server => server) }
-
-      context "on success" do
-        before(:each) {
-          post :create, :server_id => server.to_param, :bigbluebutton_room => new_room.attributes, :format => 'json'
-        }
-        it { should respond_with(:created) }
-        it { should respond_with_content_type(:json) }
-        it {
-          json = { :message => I18n.t('bigbluebutton_rails.rooms.notice.create.success') }.to_json
-          should respond_with_json(json)
-        }
-      end
-
-      context "on failure" do
-        before(:each) {
-          new_room.name = nil # invalid
-          post :create, :server_id => server.to_param, :bigbluebutton_room => new_room.attributes, :format => 'json'
-        }
-        it { should respond_with(:unprocessable_entity) }
-        it { should respond_with_content_type(:json) }
-        it {
-          new_room.save # should fail
-          should respond_with_json(new_room.errors.full_messages.to_json)
-        }
-      end
-    end
-
-    describe "#update" do
-      let(:new_room) { Factory.build(:bigbluebutton_room) }
-      before { @room = room }
-
-      context "on success" do
-        before(:each) {
-          put :update, :server_id => server.to_param, :id => @room.to_param, :bigbluebutton_room => new_room.attributes, :format => 'json'
-        }
-        it { should respond_with(:success) }
-        it { should respond_with_content_type(:json) }
-        it {
-          json = { :message => I18n.t('bigbluebutton_rails.rooms.notice.update.success') }.to_json
-          should respond_with_json(json)
-        }
-      end
-
-      context "on failure" do
-        before(:each) {
-          new_room.name = nil # invalid
-          put :update, :server_id => server.to_param, :id => @room.to_param, :bigbluebutton_room => new_room.attributes, :format => 'json'
-        }
-        it { should respond_with(:unprocessable_entity) }
-        it { should respond_with_content_type(:json) }
-        it {
-          new_room.save # should fail
-          should respond_with_json(new_room.errors.full_messages.to_json)
-        }
-      end
-    end
-
-    describe "#end" do
-      before { mock_server_and_api }
-
-      context "room is running" do
+      context "and the meeting is not running" do
         before {
-          mocked_api.should_receive(:is_meeting_running?).and_return(true)
-          mocked_api.should_receive(:end_meeting).with(room.meetingid, room.moderator_password)
+          new_room.should_receive(:fetch_meeting_info)
+          new_room.running = false
         }
-        before(:each) { get :end, :server_id => mocked_server.to_param, :id => room.to_param, :format => 'json' }
+        before(:each) { post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :user => user_hash }
         it { should respond_with(:success) }
-        it { should respond_with_content_type(:json) }
-        it { should respond_with_json(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, :format => 'json' }
-        it { should respond_with(:error) }
-        it { should respond_with_content_type(:json) }
-        it { should respond_with_json(I18n.t('bigbluebutton_rails.rooms.notice.end.not_running')) }
-      end
-
-      context "throwing an exception" do
-        let(:msg) { "any error message" }
-        before {
-          mocked_api.should_receive(:is_meeting_running?).and_return{ raise BigBlueButton::BigBlueButtonException.new(msg) }
-        }
-        before(:each) { get :end, :server_id => mocked_server.to_param, :id => room.to_param, :format => 'json' }
-        it { should respond_with(:error) }
-        it { should respond_with_content_type(:json) }
-        it { should respond_with_json(msg) }
+        it { should render_template(:external) }
+        it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.errors.auth.not_running')) }
       end
 
     end
 
-    describe "#destroy" do
-      before { mock_server_and_api }
+  end # #external_auth
 
-      context "on success" do
-        before {
-          mocked_api.should_receive(:is_meeting_running?).and_return(true)
-          mocked_api.should_receive(:end_meeting)
-        }
-        before(:each) {
-          delete :destroy, :server_id => mocked_server.to_param, :id => room.to_param, :format => 'json'
-        }
-        it { should respond_with(:success) }
-        it { should respond_with_content_type(:json) }
-        it {
-          json = { :message => I18n.t('bigbluebutton_rails.rooms.notice.destroy.success') }.to_json
-          should respond_with_json(json)
-        }
-      end
-
-      context "throwing error" do
-        let(:msg) { "any error message" }
-        before {
-          mocked_api.should_receive(:is_meeting_running?).and_return{ raise BigBlueButton::BigBlueButtonException.new(msg) }
-        }
-        before(:each) {
-          delete :destroy, :server_id => mocked_server.to_param, :id => room.to_param, :format => 'json'
-        }
-        it { should respond_with(:error) }
-        it { should respond_with_content_type(:json) }
-        it { should respond_with_json({ :message => msg }.to_json) }
-      end
-    end
+  # can be used when matching rooms inside some resource other than servers
+  context "selects the first server when the server_id is not defined in the url" do
+    let(:server2) { Factory.create(:bigbluebutton_server) }
 
-  end # json responses
+    # get /users/:user_id/room/:id(.:format)
+    before(:each) { get :show, :id => room.to_param, :user_id => "1" }
+    it { should respond_with(:success) }
+    it { should assign_to(:server).with(server) }
+  end
 
 end