bigbluebutton_rails 2.2.0 → 2.3.0

data/lib/classes/bigbluebutton_attendee.rb

@@ -1,21 +0,0 @@
-# Used to store the attendees of a meeting as returned by BigBlueButton in
-# <tt>get_meeting_info</tt>.
-class BigbluebuttonAttendee
-
-  attr_accessor :user_id, :full_name, :role
-
-  def from_hash(hash)
-    self.user_id = hash[:userID].to_s
-    self.full_name = hash[:fullName].to_s
-    self.role = hash[:role].to_s.downcase == "moderator" ? :moderator : :attendee
-  end
-
-  def ==(other)
-    r = true
-    [:user_id, :full_name, :role].each do |param|
-      r = r && self.send(param) == other.send(param)
-    end
-    r
-  end
-
-end

data/spec/classes/bigbluebutton_attendee_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-
-describe BigbluebuttonAttendee do
-
-  it "should be recognized" do
-    lambda { BigbluebuttonAttendee.new }.should_not raise_error
-  end
-
-  [:user_id, :full_name, :role].each do |attr|
-    it { should respond_to(attr) }
-    it { should respond_to(:"#{attr}=") }
-  end
-
-  context "equality" do
-    let(:attendee1) {
-      attendee = BigbluebuttonAttendee.new
-      attendee.user_id = Forgery(:basic).password
-      attendee.full_name = Forgery(:name).full_name
-      attendee.role = :attendee
-      attendee
-    }
-    let(:attendee2) {
-      attendee = BigbluebuttonAttendee.new
-      attendee.user_id = Forgery(:basic).password
-      attendee.full_name = Forgery(:name).full_name
-      attendee.role = :moderator
-      attendee
-    }
-    let(:attendee3) {
-      attendee = BigbluebuttonAttendee.new
-      attendee.user_id = attendee1.user_id
-      attendee.full_name = attendee1.full_name
-      attendee.role = attendee1.role
-      attendee
-    }
-
-    it { attendee1.should == attendee3 }
-    it { attendee1.should_not == attendee2 }
-    it { attendee2.should_not == attendee3 }
-  end
-
-  context "gets params from hash" do
-    let(:hash) { {:userID=>"user_id", :fullName=>"House M.D.", :role=>"MODERATOR"} }
-    let(:attendee) { BigbluebuttonAttendee.new }
-
-    it "standard case" do
-      attendee.from_hash(hash)
-      attendee.user_id.should == "user_id"
-      attendee.full_name.should == "House M.D."
-      attendee.role.should == :moderator
-    end
-
-    it "converts user_id to string" do
-      hash[:userID] = 123
-      attendee.from_hash(hash)
-      attendee.user_id.should == "123"
-    end
-
-    it "role is not case sensitive" do
-      hash[:role] = "mODErAtOR"
-      attendee.from_hash(hash)
-      attendee.role.should == :moderator
-    end
-
-    it "any role other than 'moderator' is attendee" do
-      hash[:role] = "VIEWER"
-      attendee.from_hash(hash)
-      attendee.role.should == :attendee
-
-      hash[:role] = "whatever"
-      attendee.from_hash(hash)
-      attendee.role.should == :attendee
-    end
-  end
-
-end

data/spec/controllers/bigbluebutton/recordings_controller_json_responses_spec.rb

@@ -1,111 +0,0 @@
-require 'spec_helper'
-
-describe Bigbluebutton::RecordingsController do
-  render_views
-  let(:recording) { FactoryGirl.create(:bigbluebutton_recording) }
-
-  context "json responses for" do
-
-    describe "#index" do
-      before do
-        @recording1 = FactoryGirl.create(:bigbluebutton_recording)
-        @recording2 = FactoryGirl.create(:bigbluebutton_recording)
-      end
-      before(:each) { get :index, :format => 'json' }
-      it { should respond_with(:success) }
-      it { should respond_with_content_type('application/json') }
-      it { should respond_with_json([@recording1, @recording2].to_json) }
-    end
-
-    describe "#show" do
-      before(:each) { get :show, :id => recording.to_param, :format => 'json' }
-      it { should respond_with(:success) }
-      it { should respond_with_content_type('application/json') }
-      it { should respond_with_json(recording.to_json) }
-    end
-
-    describe "#show" do
-      before(:each) { get :show, :id => recording.to_param, :format => 'json' }
-      it { should respond_with(:success) }
-      it { should respond_with_content_type('application/json') }
-      it { should respond_with_json(recording.to_json) }
-    end
-
-    describe "#update" do
-      let(:new_recording) { FactoryGirl.build(:bigbluebutton_recording) }
-      before { @recording = recording }
-
-      context "on success" do
-        before(:each) {
-          put :update, :id => @recording.to_param, :bigbluebutton_recording => new_recording.attributes, :format => 'json'
-        }
-        it { should respond_with(:success) }
-        it { should respond_with_content_type('application/json') }
-        it { response.body.should eq("true") }
-      end
-
-      context "on failure" do
-        before {
-          BigbluebuttonRecording.any_instance.should_receive(:update_attributes).and_return(false)
-        }
-        before(:each) {
-          put :update, :id => @recording.to_param, :bigbluebutton_recording => new_recording.attributes, :format => 'json'
-        }
-        it { should respond_with(:unprocessable_entity) }
-        it { should respond_with_content_type('application/json') }
-        it { should respond_with_json([].to_json) }
-      end
-    end
-
-    describe "#destroy" do
-      before :each do
-        @recording = recording
-        @recording.server = nil
-        BigbluebuttonRecording.stub(:find_by_recordid) { @recording }
-        delete :destroy, :id => @recording.to_param, :format => 'json'
-      end
-      it { should respond_with(:success) }
-      it { should respond_with_content_type('application/json') }
-    end
-
-    # these actions are essentially the same
-    [:publish, :unpublish].each do |action|
-      describe "##{action.to_s}" do
-        before { mock_server_and_api }
-        let(:flag) { action == :publish ? true : false }
-
-        context "on success" do
-          before {
-            mocked_server.should_receive(:send_publish_recordings).with(recording.recordid, flag)
-          }
-          before(:each) { post action, :id => recording.to_param, :format => 'json' }
-          it { should respond_with(:success) }
-          it { should respond_with_content_type('application/json') }
-          it { should respond_with_json(I18n.t("bigbluebutton_rails.recordings.notice.#{action.to_s}.success")) }
-        end
-
-        context "on failure" do
-          let(:bbb_error_msg) { SecureRandom.hex(250) }
-          let(:bbb_error) { BigBlueButton::BigBlueButtonException.new(bbb_error_msg) }
-          before {
-            request.env["HTTP_REFERER"] = "/any"
-            mocked_server.should_receive(:send_publish_recordings) { raise bbb_error }
-          }
-          before(:each) { post action, :id => recording.to_param, :format => 'json' }
-          it { should respond_with(:error) }
-          it { should respond_with_content_type('application/json') }
-          it { should respond_with_json(bbb_error_msg[0..200]) }
-        end
-
-        context "returns error if there's no server associated" do
-          before { recording.stub(:server) { nil } }
-          before(:each) { post action, :id => recording.to_param, :format => 'json' }
-          it { should respond_with(:error) }
-          it { should respond_with_content_type('application/json') }
-          it { should respond_with_json(I18n.t('bigbluebutton_rails.recordings.errors.check_for_server.no_server')) }
-        end
-      end
-    end
-
-  end
-end

data/spec/controllers/bigbluebutton/rooms_controller_json_responses_spec.rb

@@ -1,203 +0,0 @@
-require 'spec_helper'
-
-describe Bigbluebutton::RoomsController do
-  render_views
-  let(:server) { FactoryGirl.create(:bigbluebutton_server) }
-  let(:room) { FactoryGirl.create(:bigbluebutton_room) }
-  before do
-    BigbluebuttonRoom.stub(:find_by_param) { room }
-    BigbluebuttonRoom.stub(:find) { room }
-  end
-
-  context "json responses for" do
-
-    describe "#index" do
-      before do
-        @room1 = FactoryGirl.create(:bigbluebutton_room)
-        @room2 = FactoryGirl.create(:bigbluebutton_room)
-      end
-      before(:each) { get :index, :format => 'json' }
-      it { should respond_with(:success) }
-      it { should respond_with_content_type('application/json') }
-      it { should respond_with_json([@room1, @room2].to_json) }
-    end
-
-    describe "#new" do
-      before(:each) { get :new, :format => 'json' }
-      it { should respond_with(:success) }
-      it { should respond_with_content_type('application/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, :id => room.to_param, :format => 'json' }
-      it { should respond_with(:success) }
-      it { should respond_with_content_type('application/json') }
-      it { should respond_with_json(room.to_json) }
-    end
-
-    describe "#create" do
-      let(:new_room) { FactoryGirl.build(:bigbluebutton_room) }
-
-      context "on success" do
-        before(:each) {
-          post :create, :bigbluebutton_room => new_room.attributes, :format => 'json'
-        }
-        it { should respond_with(:created) }
-        it { should respond_with_content_type('application/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, :bigbluebutton_room => new_room.attributes, :format => 'json'
-        }
-        it { should respond_with(:unprocessable_entity) }
-        it { should respond_with_content_type('application/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) { FactoryGirl.build(:bigbluebutton_room) }
-      before { @room = room }
-
-      context "on success" do
-        before(:each) {
-          put :update, :id => @room.to_param, :bigbluebutton_room => new_room.attributes, :format => 'json'
-        }
-        it { should respond_with(:success) }
-        it { should respond_with_content_type('application/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, :id => @room.to_param, :bigbluebutton_room => new_room.attributes, :format => 'json'
-        }
-        it { should respond_with(:unprocessable_entity) }
-        it { should respond_with_content_type('application/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
-        before {
-          mocked_api.should_receive(:is_meeting_running?).and_return(true)
-          mocked_api.should_receive(:end_meeting).with(room.meetingid, room.moderator_api_password)
-        }
-        before(:each) { get :end, :id => room.to_param, :format => 'json' }
-        it { should respond_with(:success) }
-        it { should respond_with_content_type('application/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, :id => room.to_param, :format => 'json' }
-        it { should respond_with(:error) }
-        it { should respond_with_content_type('application/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?) { raise BigBlueButton::BigBlueButtonException.new(msg) }
-        }
-        before(:each) { get :end, :id => room.to_param, :format => 'json' }
-        it { should respond_with(:error) }
-        it { should respond_with_content_type('application/json') }
-        it { should respond_with_json(msg) }
-      end
-
-    end
-
-    describe "#destroy" do
-      before { mock_server_and_api }
-
-      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, :id => room.to_param, :format => 'json'
-        }
-        it { should respond_with(:success) }
-        it { should respond_with_content_type('application/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?) { raise BigBlueButton::BigBlueButtonException.new(msg) }
-        }
-        before(:each) {
-          delete :destroy, :id => room.to_param, :format => 'json'
-        }
-        it { should respond_with(:error) }
-        it { should respond_with_content_type('application/json') }
-        it {
-          error_msg = I18n.t('bigbluebutton_rails.rooms.notice.destroy.success_with_bbb_error', :error => msg)
-          should respond_with_json({ :message => error_msg }.to_json)
-        }
-      end
-    end
-
-    describe "#fetch_recordings" do
-      it "on success"
-      it "on error"
-    end
-
-    describe "#generate_dial_number" do
-      context "on success" do
-        before(:each) {
-          BigbluebuttonRoom.any_instance.stub(:generate_dial_number!).and_return(true)
-          post :generate_dial_number, id: room.to_param, format: 'json'
-        }
-        it { should respond_with(:success) }
-        it { should respond_with_content_type('application/json') }
-      end
-
-      context "on error" do
-        before(:each) {
-          BigbluebuttonRoom.any_instance.stub(:generate_dial_number!).and_return(nil)
-          post :generate_dial_number, id: room.to_param, format: 'json'
-        }
-        it { should respond_with(:error) }
-        it { should respond_with_content_type('application/json') }
-        it {
-          error_msg = I18n.t('bigbluebutton_rails.rooms.errors.generate_dial_number.not_unique')
-          should respond_with_json({ :message => error_msg }.to_json)
-        }
-      end
-    end
-
-  end
-end

data/spec/controllers/bigbluebutton/servers_controller_json_responses_spec.rb

@@ -1,162 +0,0 @@
-require 'spec_helper'
-
-describe Bigbluebutton::ServersController do
-  render_views
-  let!(:server) { FactoryGirl.create(:bigbluebutton_server) }
-
-  context "json responses for" do
-
-    describe "#index" do
-      before do
-        BigbluebuttonServer.destroy_all
-        @server1 = FactoryGirl.create(:bigbluebutton_server)
-        @server2 = FactoryGirl.create(:bigbluebutton_server)
-      end
-      before(:each) { get :index, :format => 'json' }
-      it { should respond_with(:success) }
-      it { should respond_with_content_type('application/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('application/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('application/json') }
-      it { should respond_with_json(server.to_json) }
-    end
-
-    describe "#create" do
-      let(:new_server) { FactoryGirl.build(:bigbluebutton_server) }
-
-      context "on success" do
-        before {
-          api_mock = double(BigBlueButton::BigBlueButtonApi)
-          api_mock.stub(:version).and_return("0.9")
-          api_mock.stub(:get_default_config_xml)
-          api_mock.stub(:get_available_layouts)
-          BigBlueButton::BigBlueButtonApi.stub(:new).and_return(api_mock)
-        }
-        before(:each) {
-          post :create, :bigbluebutton_server => new_server.attributes, :format => 'json'
-        }
-        it { should respond_with(:created) }
-        it { should respond_with_content_type('application/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('application/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) { FactoryGirl.build(:bigbluebutton_server) }
-
-      context "on success" do
-        before(:each) {
-          BigbluebuttonServer.any_instance.stub(:set_api_version_from_server)
-          put :update, :id => server.to_param, :bigbluebutton_server => new_server.attributes, :format => 'json'
-        }
-        it { should respond_with(:success) }
-        it { should respond_with_content_type('application/json') }
-        it { response.body.should eq("true") }
-      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('application/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
-        delete :destroy, :id => server.to_param, :format => 'json'
-      end
-      it { should respond_with(:success) }
-      it { should respond_with_content_type('application/json') }
-      it { response.body.should eq("true") }
-    end
-
-    describe "#activity" do
-      let(:room1) { FactoryGirl.create(:bigbluebutton_room) }
-      let(:room2) { FactoryGirl.create(:bigbluebutton_room) }
-      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('application/json') }
-        it { should respond_with_json([room1, room2].to_json) }
-      end
-
-      context "on failure" do
-        let(:bbb_error_msg) { SecureRandom.hex(250) }
-        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('application/json') }
-        it { should respond_with_json([{ :message => bbb_error_msg[0..200] }, room1, room2].to_json) }
-        it { should set_the_flash.to(bbb_error_msg[0..200]) }
-      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('application/json') }
-        it { should respond_with_json([room1, room2].to_json) }
-      end
-
-    end
-
-    describe "#fetch_recordings" do
-      it "on success"
-      it "on error"
-    end
-
-  end
-end