bigbluebutton_rails 2.3.0 → 3.0.0

data/spec/factories/bigbluebutton_meeting.rb

@@ -7,6 +7,7 @@ FactoryGirl.define do
     m.running false
     m.ended false
     m.create_time { Time.now.to_i + rand(999999) }
+    m.title { Forgery(:lorem_ipsum).words(1) }
     # m.creator_id
     # m.creator_name
   end

data/spec/factories/bigbluebutton_recording.rb

@@ -12,7 +12,6 @@ FactoryGirl.define do
     r.sequence(:recordid) { |n| "rec#{n}-#{SecureRandom.uuid}-#{DateTime.now.to_i}" }
     r.size { rand((20*1024**2)..(500*1024**2)) } # size ranging from 20Mb to 500Mb
     r.available true
-    r.description { Forgery(:lorem_ipsum).words(10) }
 
     after(:create) do |r|
       r.updated_at = r.updated_at.change(:usec => 0)

data/spec/factories/bigbluebutton_room.rb

@@ -10,7 +10,7 @@ FactoryGirl.define do
     r.moderator_api_password { SecureRandom.uuid }
     r.welcome_msg { Forgery(:lorem_ipsum).sentences(2) }
     r.private false
-    r.sequence(:param) { |n| "meeting-#{n}" }
+    r.sequence(:slug) { |n| "meeting-#{n}" }
     r.external false
     r.record_meeting false
     r.duration 0

data/spec/factories/bigbluebutton_server.rb

@@ -4,7 +4,7 @@ FactoryGirl.define do
     s.sequence(:url) { |n| "http://bigbluebutton#{n}.test.com/bigbluebutton/api" }
     s.secret { Forgery(:basic).password :at_least => 30, :at_most => 40 }
     s.version '0.9'
-    s.sequence(:param) { |n| "server-#{n}" }
+    s.sequence(:slug) { |n| "server-#{n}" }
   end
 
   after(:create) do |s|

data/spec/models/bigbluebutton_meeting_db_spec.rb

@@ -16,6 +16,8 @@ describe BigbluebuttonMeeting do
     it { should have_db_column(:ended).of_type(:boolean) }
     it { should have_db_column(:server_url).of_type(:string) }
     it { should have_db_column(:server_secret).of_type(:string) }
+    it { should have_db_column(:title).of_type(:string) }
+
     it "default values" do
       room = BigbluebuttonMeeting.new
       room.running.should be(false)

data/spec/models/bigbluebutton_meeting_spec.rb

@@ -11,7 +11,7 @@ describe BigbluebuttonMeeting do
   it { should belong_to(:room) }
   it { should validate_presence_of(:room) }
 
-  it { should have_one(:recording).dependent(:nullify) }
+  it { should have_one(:recording).dependent(:destroy) }
 
   it { should validate_presence_of(:meetingid) }
   it { should ensure_length_of(:meetingid).is_at_least(1).is_at_most(100) }

data/spec/models/bigbluebutton_recording_db_spec.rb

@@ -13,7 +13,6 @@ describe BigbluebuttonRecording do
     it { should have_db_column(:start_time).of_type(:integer) }
     it { should have_db_column(:end_time).of_type(:integer) }
     it { should have_db_column(:available).of_type(:boolean) }
-    it { should have_db_column(:description).of_type(:string) }
     it { should have_db_column(:created_at).of_type(:datetime) }
     it { should have_db_column(:updated_at).of_type(:datetime) }
     it { should have_db_column(:size).of_type(:integer) }

data/spec/models/bigbluebutton_recording_spec.rb

@@ -665,10 +665,6 @@ describe BigbluebuttonRecording do
     it("sets server") { @recording.server.should == new_server }
     it("sets room") { @recording.room.should == @room }
     it("sets meeting") { @recording.meeting.should == @meeting }
-    it("sets description") {
-      time = Time.at(data[:start_time]).utc.to_formatted_s(:long)
-      @recording.description.should == I18n.t('bigbluebutton_rails.recordings.default.description', :time => time)
-    }
     it("sets recording_users") { @recording.recording_users.should eql([3, 4]) }
   end
 

data/spec/models/bigbluebutton_room_db_spec.rb

@@ -19,7 +19,7 @@ describe BigbluebuttonRoom do
     it { should have_db_column(:max_participants).of_type(:integer) }
     it { should have_db_column(:private).of_type(:boolean) }
     it { should have_db_column(:external).of_type(:boolean) }
-    it { should have_db_column(:param).of_type(:string) }
+    it { should have_db_column(:slug).of_type(:string) }
     it { should have_db_column(:record_meeting).of_type(:boolean) }
     it { should have_db_column(:duration).of_type(:integer) }
     it { should have_db_column(:created_at).of_type(:datetime) }

data/spec/models/bigbluebutton_room_spec.rb

@@ -40,9 +40,9 @@ describe BigbluebuttonRoom do
   it { should validate_presence_of(:name) }
   it { should ensure_length_of(:name).is_at_least(1).is_at_most(250) }
 
-  it { should validate_presence_of(:param) }
-  it { should validate_uniqueness_of(:param) }
-  it { should ensure_length_of(:param).is_at_least(1) }
+  it { should validate_presence_of(:slug) }
+  it { should validate_uniqueness_of(:slug) }
+  it { should ensure_length_of(:slug).is_at_least(1) }
 
   it { should be_boolean(:private) }
 
@@ -74,7 +74,7 @@ describe BigbluebuttonRoom do
     it { should respond_to(:to_param) }
     it {
       r = FactoryGirl.create(:bigbluebutton_room)
-      r.to_param.should be(r.param)
+      r.to_param.should be(r.slug)
     }
   end
 
@@ -110,9 +110,9 @@ describe BigbluebuttonRoom do
   describe ".search_by_terms" do
     let!(:rooms) {
       [
-        FactoryGirl.create(:bigbluebutton_room, name: "La Lo", param: "lalo-1"),
-        FactoryGirl.create(:bigbluebutton_room, name: "La Le", param: "lale-2"),
-        FactoryGirl.create(:bigbluebutton_room, name: "Li Lo", param: "lilo")
+        FactoryGirl.create(:bigbluebutton_room, name: "La Lo", slug: "lalo-1"),
+        FactoryGirl.create(:bigbluebutton_room, name: "La Le", slug: "lale-2"),
+        FactoryGirl.create(:bigbluebutton_room, name: "Li Lo", slug: "lilo")
       ]
     }
     let(:subject) { BigbluebuttonRoom.search_by_terms(terms) }
@@ -155,7 +155,7 @@ describe BigbluebuttonRoom do
       let(:terms) { ['abcdef'] }
       before {
         rooms[1].update_attributes(name: 'abcdef')
-        rooms[2].update_attributes(param: 'abcdef')
+        rooms[2].update_attributes(slug: 'abcdef')
       }
       it { subject.count.should be(2) }
       it { subject.should include(rooms[1], rooms[2]) }
@@ -277,40 +277,38 @@ describe BigbluebuttonRoom do
     end
   end
 
-  context "#param format" do
-    let(:msg) { I18n.t('bigbluebutton_rails.rooms.errors.param_format') }
-    it { should_not allow_value("123 321").for(:param).with_message(msg) }
-    it { should_not allow_value("").for(:param).with_message(msg) }
-    it { should_not allow_value("ab@c").for(:param).with_message(msg) }
-    it { should_not allow_value("ab#c").for(:param).with_message(msg) }
-    it { should_not allow_value("ab$c").for(:param).with_message(msg) }
-    it { should_not allow_value("ab%c").for(:param).with_message(msg) }
-    it { should_not allow_value("ábcd").for(:param).with_message(msg) }
-    it { should_not allow_value("-abc").for(:param).with_message(msg) }
-    it { should_not allow_value("abc-").for(:param).with_message(msg) }
-    it { should_not allow_value("-").for(:param).with_message(msg) }
-    it { should allow_value("_abc").for(:param).with_message(msg) }
-    it { should allow_value("abc_").for(:param).with_message(msg) }
-    it { should allow_value("abc").for(:param).with_message(msg) }
-    it { should allow_value("123").for(:param).with_message(msg) }
-    it { should allow_value("1").for(:param).with_message(msg) }
-    it { should allow_value("a").for(:param).with_message(msg) }
-    it { should allow_value("_").for(:param).with_message(msg) }
-    it { should allow_value("abc-123_d5").for(:param).with_message(msg) }
+  context "#slug format" do
+    let(:msg) { I18n.t('bigbluebutton_rails.rooms.errors.slug_format') }
+    it { should_not allow_value("123 321").for(:slug).with_message(msg) }
+    it { should_not allow_value("").for(:slug).with_message(msg) }
+    it { should_not allow_value("ab@c").for(:slug).with_message(msg) }
+    it { should_not allow_value("ab#c").for(:slug).with_message(msg) }
+    it { should_not allow_value("ab$c").for(:slug).with_message(msg) }
+    it { should_not allow_value("ab%c").for(:slug).with_message(msg) }
+    it { should_not allow_value("ábcd").for(:slug).with_message(msg) }
+    it { should_not allow_value("-abc").for(:slug).with_message(msg) }
+    it { should_not allow_value("abc-").for(:slug).with_message(msg) }
+    it { should_not allow_value("-").for(:slug).with_message(msg) }
+    it { should allow_value("_abc").for(:slug).with_message(msg) }
+    it { should allow_value("abc_").for(:slug).with_message(msg) }
+    it { should allow_value("abc").for(:slug).with_message(msg) }
+    it { should allow_value("123").for(:slug).with_message(msg) }
+    it { should allow_value("1").for(:slug).with_message(msg) }
+    it { should allow_value("a").for(:slug).with_message(msg) }
+    it { should allow_value("_").for(:slug).with_message(msg) }
+    it { should allow_value("abc-123_d5").for(:slug).with_message(msg) }
   end
 
-  context "sets param as the downcased parameterized name if param is" do
+  context "sets slug as the downcased parameterized name if slug is" do
     after :each do
       @room.save.should be_truthy
-      @room.param.should == @room.name.downcase.parameterize
+      @room.slug.should == @room.name.downcase.parameterize
     end
     it "nil" do
-      @room = FactoryGirl.build(:bigbluebutton_room, :param => nil,
-                            :name => "-My Name@ _Is Odd_-")
+      @room = FactoryGirl.build(:bigbluebutton_room, slug: nil, name: "-My Name@ _Is Odd_-")
     end
     it "empty" do
-      @room = FactoryGirl.build(:bigbluebutton_room, :param => "",
-                            :name => "-My Name@ _Is Odd_-")
+      @room = FactoryGirl.build(:bigbluebutton_room, slug: "", name: "-My Name@ _Is Odd_-")
     end
   end
 
@@ -643,6 +641,7 @@ describe BigbluebuttonRoom do
           let(:user) { FactoryGirl.build(:user) }
           before do
             params = get_create_params(room, user)
+            # BigbluebuttonRails.configuration.should_receive(:get_create_options).and_return(Proc.new{ params })
             mocked_api.should_receive(:create_meeting)
               .with(room.name, room.meetingid, params)
               .and_return(hash_create)
@@ -1140,7 +1139,7 @@ describe BigbluebuttonRoom do
             let(:user) { 'any user' }
             before {
               proc = double(Proc)
-              proc.should_receive(:call).with(room, user)
+              proc.should_receive(:call).with(room, user, {username: username, role: role} )
               BigbluebuttonRails.configuration.should_receive(:get_join_options).and_return(proc)
               room.stub(:fetch_new_token).and_return(nil)
               room.stub(:join_url)
@@ -1151,7 +1150,7 @@ describe BigbluebuttonRoom do
           context "if the user is not passed in the arguments" do
             before {
               proc = double(Proc)
-              proc.should_receive(:call).with(room, nil)
+              proc.should_receive(:call).with(room, nil, {username: username, role: role} )
               BigbluebuttonRails.configuration.should_receive(:get_join_options).and_return(proc)
               room.stub(:fetch_new_token).and_return(nil)
               room.stub(:join_url)
@@ -1323,48 +1322,38 @@ describe BigbluebuttonRoom do
 
     context "generates the dial number and saves in the room" do
       before {
-        BigbluebuttonRails::DialNumber.stub(:randomize).and_return("(99) 1234-5678")
-      }
-      it { room.generate_dial_number!.should be(true) }
-      it {
-        room.generate_dial_number!
-        room.reload.dial_number.should eql("(99) 1234-5678")
+        BigbluebuttonRoom.stub(:generate_dial_number).and_return("(99) 1234-5678")
+        room.generate_dial_number!('x')
       }
+      it { room.reload.dial_number.should eql("(99) 1234-5678") }
+      it { room.generate_dial_number!('x').should be(true) }
     end
 
     context "uses the pattern informed" do
       before {
-        BigbluebuttonRails::DialNumber.should_receive(:randomize).with("(99) 12xx-xxxx")
+        BigbluebuttonRoom.should_receive(:generate_dial_number).with("(99) 12xx-xxxx")
       }
       it { room.generate_dial_number!("(99) 12xx-xxxx").should be(true) }
     end
 
-    # tries several times
+    context "returns nil if no pattern is given" do
+      it { BigbluebuttonRoom.last.generate_dial_number!.should be(nil) }
+    end
+  end
 
-    context "tries to generate a unique number multiple times" do
-      let!(:another_room) { FactoryGirl.create(:bigbluebutton_room, dial_number: "(99) 1234-5678") }
-      before {
-        expect(BigbluebuttonRails::DialNumber).to receive(:randomize).exactly(19).times.and_return("(99) 1234-5678")
-        expect(BigbluebuttonRails::DialNumber).to receive(:randomize).and_return("(99) 1234-5679") # unique
-      }
-      it { room.generate_dial_number!.should be(true) }
-      it {
-        room.generate_dial_number!
-        room.reload.dial_number.should eql("(99) 1234-5679")
-      }
+  context "#generate_dial_number" do
+    context "uses the last room creatd to set dial number" do
+      before { BigbluebuttonRoom.last.update_attributes(dial_number: '1234-5678') }
+      it { BigbluebuttonRoom.generate_dial_number('x').should eql('1234-5679') }
     end
 
-    context "returns nil if can't generate a unique number" do
-      before { @previous_dn = room.dial_number }
-      let!(:another_room) { FactoryGirl.create(:bigbluebutton_room, dial_number: "(99) 1234-5678") }
-      before {
-        expect(BigbluebuttonRails::DialNumber).to receive(:randomize).exactly(20).times.and_return("(99) 1234-5678")
-      }
-      it { room.generate_dial_number!.should be_nil }
-      it {
-        room.generate_dial_number!
-        room.reload.dial_number.should eql(@previous_dn)
-      }
+    context "when the firt room is created" do
+      before { BigbluebuttonRoom.first.delete }
+      it { BigbluebuttonRoom.generate_dial_number('1234-xxxx').should eql('1234-0000') }
+    end
+
+    context "returns nil if no pattern is given" do
+      it { BigbluebuttonRoom.generate_dial_number.should be(nil) }
     end
   end
 
@@ -1625,7 +1614,7 @@ describe BigbluebuttonRoom do
 
     context "if #create_time is not set in the room" do
       before { room.update_attributes(create_time: nil) }
-      subject { room.create_meeting_record }
+      subject { room.create_meeting_record({}, server, nil, {}) }
       it("doesn't create a meeting") {
         BigbluebuttonMeeting.find_by(room_id: room.id).should be_nil
       }
@@ -1769,7 +1758,7 @@ describe BigbluebuttonRoom do
         let!(:meeting1) { FactoryGirl.create(:bigbluebutton_meeting, room: room, ended: false, running: true) }
         let!(:meeting2) { FactoryGirl.create(:bigbluebutton_meeting, room: room, ended: false, running: true) }
         before {
-          expect(Resque).to receive(:enqueue_in).with(4.minutes, ::BigbluebuttonRecordingsForRoomWorker, room.id, 3)
+          expect(Resque).to receive(:enqueue_in).with(1.minute, ::BigbluebuttonRecordingsForRoomWorker, room.id, 10)
         }
         it { room.finish_meetings }
       end
@@ -1831,7 +1820,7 @@ describe BigbluebuttonRoom do
         it { room.send(:internal_create_meeting) }
       end
 
-      context "adds the value returned by BigbluebuttonRoom#invitation_url" do
+      context "adds the invitation_url" do
         before {
           BigbluebuttonRails.configure do |config|
             config.get_invitation_url = Proc.new do |room|

data/spec/models/bigbluebutton_server_db_spec.rb

@@ -8,7 +8,7 @@ describe BigbluebuttonServer do
     it { should have_db_column(:url).of_type(:string) }
     it { should have_db_column(:secret).of_type(:string) }
     it { should have_db_column(:version).of_type(:string) }
-    it { should have_db_column(:param).of_type(:string) }
+    it { should have_db_column(:slug).of_type(:string) }
     it { should have_db_column(:created_at).of_type(:datetime) }
     it { should have_db_column(:updated_at).of_type(:datetime) }
   end

data/spec/models/bigbluebutton_server_spec.rb

@@ -18,11 +18,11 @@ describe BigbluebuttonServer do
   it { should validate_presence_of(:name) }
   it { should validate_presence_of(:url) }
   it { should validate_presence_of(:secret) }
-  it { should validate_presence_of(:param) }
+  it { should validate_presence_of(:slug) }
 
   context "uniqueness of" do
     before(:each) { FactoryGirl.create(:bigbluebutton_server) }
-    it { should validate_uniqueness_of(:param) }
+    it { should validate_uniqueness_of(:slug) }
   end
 
   it "has associated recordings" do
@@ -40,6 +40,8 @@ describe BigbluebuttonServer do
     let!(:rec2) { FactoryGirl.create(:bigbluebutton_recording, server: server) }
     let!(:rec3) { FactoryGirl.create(:bigbluebutton_recording) }
 
+    before { BigbluebuttonServer.any_instance.stub(:send_delete_recordings).and_return(true) }
+
     it {
       server.recordings.count.should eql(2)
       server.destroy
@@ -52,13 +54,13 @@ describe BigbluebuttonServer do
   it { should ensure_length_of(:name).is_at_least(1).is_at_most(500) }
   it { should ensure_length_of(:url).is_at_most(500) }
   it { should ensure_length_of(:secret).is_at_least(1).is_at_most(500) }
-  it { should ensure_length_of(:param).is_at_least(3) }
+  it { should ensure_length_of(:slug).is_at_least(3) }
 
   context ".to_param" do
     it { should respond_to(:to_param) }
     it {
       s = FactoryGirl.create(:bigbluebutton_server)
-      s.to_param.should be(s.param)
+      s.to_param.should be(s.slug)
     }
   end
 
@@ -80,37 +82,35 @@ describe BigbluebuttonServer do
     it { should_not allow_value('0.7').for(:version) }
   end
 
-  context "param format" do
-    let(:msg) { I18n.t('bigbluebutton_rails.servers.errors.param_format') }
-    it { should_not allow_value("123 321").for(:param).with_message(msg) }
-    it { should_not allow_value("").for(:param).with_message(msg) }
-    it { should_not allow_value("ab@c").for(:param).with_message(msg) }
-    it { should_not allow_value("ab#c").for(:param).with_message(msg) }
-    it { should_not allow_value("ab$c").for(:param).with_message(msg) }
-    it { should_not allow_value("ab%c").for(:param).with_message(msg) }
-    it { should_not allow_value("ábcd").for(:param).with_message(msg) }
-    it { should_not allow_value("-abc").for(:param).with_message(msg) }
-    it { should_not allow_value("abc-").for(:param).with_message(msg) }
-    it { should_not allow_value("-").for(:param).with_message(msg) }
-    it { should allow_value("_abc").for(:param).with_message(msg) }
-    it { should allow_value("abc_").for(:param).with_message(msg) }
-    it { should allow_value("abc").for(:param).with_message(msg) }
-    it { should allow_value("123").for(:param).with_message(msg) }
-    it { should allow_value("abc-123_d5").for(:param).with_message(msg) }
+  context "slug format" do
+    let(:msg) { I18n.t('bigbluebutton_rails.servers.errors.slug_format') }
+    it { should_not allow_value("123 321").for(:slug).with_message(msg) }
+    it { should_not allow_value("").for(:slug).with_message(msg) }
+    it { should_not allow_value("ab@c").for(:slug).with_message(msg) }
+    it { should_not allow_value("ab#c").for(:slug).with_message(msg) }
+    it { should_not allow_value("ab$c").for(:slug).with_message(msg) }
+    it { should_not allow_value("ab%c").for(:slug).with_message(msg) }
+    it { should_not allow_value("ábcd").for(:slug).with_message(msg) }
+    it { should_not allow_value("-abc").for(:slug).with_message(msg) }
+    it { should_not allow_value("abc-").for(:slug).with_message(msg) }
+    it { should_not allow_value("-").for(:slug).with_message(msg) }
+    it { should allow_value("_abc").for(:slug).with_message(msg) }
+    it { should allow_value("abc_").for(:slug).with_message(msg) }
+    it { should allow_value("abc").for(:slug).with_message(msg) }
+    it { should allow_value("123").for(:slug).with_message(msg) }
+    it { should allow_value("abc-123_d5").for(:slug).with_message(msg) }
   end
 
   context "sets param as the downcased parameterized name if param is" do
     after :each do
       @server.save.should be(true)
-      @server.param.should == @server.name.downcase.parameterize
+      @server.slug.should == @server.name.downcase.parameterize
     end
     it "nil" do
-      @server = FactoryGirl.build(:bigbluebutton_server, :param => nil,
-                              :name => "-My Name@ _Is Odd_-")
+      @server = FactoryGirl.build(:bigbluebutton_server, slug: nil, name: "-My Name@ _Is Odd_-")
     end
     it "empty" do
-      @server = FactoryGirl.build(:bigbluebutton_server, :param => "",
-                              :name => "-My Name@ _Is Odd_-")
+      @server = FactoryGirl.build(:bigbluebutton_server, slug: "", name: "-My Name@ _Is Odd_-")
     end
   end
 

data/spec/rails_app/features/step_definitions/create_rooms_steps.rb

@@ -10,7 +10,7 @@ When /^registers a new room$/i do
   fill_in("bigbluebutton_room[dial_number]", :with => attrs[:dial_number])
   fill_in("bigbluebutton_room[max_participants]", :with => attrs[:max_participants])
   check("bigbluebutton_room[external]") if attrs[:external]
-  fill_in("bigbluebutton_room[param]", :with => attrs[:param])
+  fill_in("bigbluebutton_room[slug]", :with => attrs[:slug])
   # Note: voice_bridge is generated when the BigbluebuttonRoom is created
   click_button("Create")
 end
@@ -27,7 +27,7 @@ When /^registers a new room with wrong parameters$/i do
   fill_in("bigbluebutton_room[dial_number]", :with => attrs[:dial_number])
   fill_in("bigbluebutton_room[max_participants]", :with => attrs[:max_participants])
   check("bigbluebutton_room[external]") if attrs[:external]
-  fill_in("bigbluebutton_room[param]", :with => attrs[:param])
+  fill_in("bigbluebutton_room[slug]", :with => attrs[:slug])
   click_button("Create")
 end
 

data/spec/rails_app/features/step_definitions/create_servers_steps.rb

@@ -4,7 +4,7 @@ When /^registers a new server$/i do
   fill_in("bigbluebutton_server[url]", :with => attrs[:url])
   fill_in("bigbluebutton_server[secret]", :with => attrs[:secret])
   fill_in("bigbluebutton_server[version]", :with => attrs[:version])
-  fill_in("bigbluebutton_server[param]", :with => attrs[:param])
+  fill_in("bigbluebutton_server[slug]", :with => attrs[:slug])
   click_button("Create")
 end
 
@@ -14,7 +14,7 @@ When /^registers a new server with a wrong URL$/i do
   fill_in("bigbluebutton_server[url]", :with => "invalid url")
   fill_in("bigbluebutton_server[secret]", :with => attrs[:secret])
   fill_in("bigbluebutton_server[version]", :with => attrs[:version])
-  fill_in("bigbluebutton_server[param]", :with => attrs[:param])
+  fill_in("bigbluebutton_server[slug]", :with => attrs[:slug])
   click_button("Create")
 end