bigbluebutton_rails 0.0.6 → 0.1.0

data/spec/models/bigbluebutton_server_db_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe BigbluebuttonServer do
+
+  # to ensure that the migration is correct
+  context "db" do
+    it { should have_db_column(:name).of_type(:string) }
+    it { should have_db_column(:url).of_type(:string) }
+    it { should have_db_column(:salt).of_type(:string) }
+    it { should have_db_column(:version).of_type(:string) }
+    it { should have_db_column(:param).of_type(:string) }
+  end
+
+end

data/spec/models/bigbluebutton_server_spec.rb

@@ -6,202 +6,188 @@ describe BigbluebuttonServer do
     BigbluebuttonServer.new.should be_a_kind_of(ActiveRecord::Base)
   end
 
-  # to ensure that the migration is correct
-  context "db" do
-    it { should have_db_column(:name).of_type(:string) }
-    it { should have_db_column(:url).of_type(:string) }
-    it { should have_db_column(:salt).of_type(:string) }
-    it { should have_db_column(:version).of_type(:string) }
-    it { should have_db_column(:param).of_type(:string) }
+  it { should have_many(:rooms) }
+
+  it { should validate_presence_of(:name) }
+  it { should validate_presence_of(:url) }
+  it { should validate_presence_of(:salt) }
+  it { should validate_presence_of(:version) }
+  it { should validate_presence_of(:param) }
+
+  it { should allow_mass_assignment_of(:name) }
+  it { should allow_mass_assignment_of(:url) }
+  it { should allow_mass_assignment_of(:salt) }
+  it { should allow_mass_assignment_of(:version) }
+  it { should allow_mass_assignment_of(:param) }
+
+  context "uniqueness of" do
+    before(:each) { Factory.create(:bigbluebutton_server) }
+    it { should validate_uniqueness_of(:url) }
+    it { should validate_uniqueness_of(:name) }
+    it { should validate_uniqueness_of(:param) }
   end
 
-  context do
+  it "has associated rooms" do
+    server = Factory.create(:bigbluebutton_server)
+    server.rooms.should be_empty
 
-    it { should have_many(:rooms) }
-
-    it { should validate_presence_of(:name) }
-    it { should validate_presence_of(:url) }
-    it { should validate_presence_of(:salt) }
-    it { should validate_presence_of(:version) }
-    it { should validate_presence_of(:param) }
-
-    it { should allow_mass_assignment_of(:name) }
-    it { should allow_mass_assignment_of(:url) }
-    it { should allow_mass_assignment_of(:salt) }
-    it { should allow_mass_assignment_of(:version) }
-    it { should allow_mass_assignment_of(:param) }
-
-    context "uniqueness of" do
-      before(:each) { Factory.create(:bigbluebutton_server) }
-      it { should validate_uniqueness_of(:url) }
-      it { should validate_uniqueness_of(:name) }
-      it { should validate_uniqueness_of(:param) }
-    end
-
-    it "has associated rooms" do
-      server = Factory.create(:bigbluebutton_server)
-      server.rooms.should be_empty
-
-      Factory.create(:bigbluebutton_room, :server => server)
-      server = BigbluebuttonServer.find(server.id)
-      server.rooms.should_not be_empty
-    end
+    Factory.create(:bigbluebutton_room, :server => server)
+    server = BigbluebuttonServer.find(server.id)
+    server.rooms.should_not be_empty
+  end
 
-    it "destroys associated rooms" do
-      server = Factory.create(:bigbluebutton_server)
-      Factory.create(:bigbluebutton_room, :server => server)
-      Factory.create(:bigbluebutton_room, :server => server)
+  it "destroys associated rooms" do
+    server = Factory.create(:bigbluebutton_server)
+    Factory.create(:bigbluebutton_room, :server => server)
+    Factory.create(:bigbluebutton_room, :server => server)
+    expect {
       expect {
-        expect {
-          server.destroy
-        }.to change{ BigbluebuttonServer.count }.by(-1)
-      }.to change{ BigbluebuttonRoom.count }.by(-2)
-    end
+        server.destroy
+      }.to change{ BigbluebuttonServer.count }.by(-1)
+    }.to change{ BigbluebuttonRoom.count }.by(-2)
+  end
 
-    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(:salt).is_at_least(1).is_at_most(500) }
-    it { should ensure_length_of(:param).is_at_least(3) }
+  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(:salt).is_at_least(1).is_at_most(500) }
+  it { should ensure_length_of(:param).is_at_least(3) }
+
+  context ".to_param" do
+    it { should respond_to(:to_param) }
+    it {
+      s = Factory.create(:bigbluebutton_server)
+      s.to_param.should be(s.param)
+    }
+  end
 
-    context ".to_param" do
-      it { should respond_to(:to_param) }
-      it {
-        s = Factory.create(:bigbluebutton_server)
-        s.to_param.should be(s.param)
-      }
-    end
+  context "url format" do
+    it { should allow_value('http://demo.bigbluebutton.org/bigbluebutton/api').for(:url) }
+    it { should_not allow_value('').for(:url) }
+    it { should_not allow_value('http://demo.bigbluebutton.org').for(:url) }
+    it { should_not allow_value('demo.bigbluebutton.org/bigbluebutton/api').for(:url) }
+  end
 
-    context "url format" do
-      it { should allow_value('http://demo.bigbluebutton.org/bigbluebutton/api').for(:url) }
-      it { should_not allow_value('').for(:url) }
-      it { should_not allow_value('http://demo.bigbluebutton.org').for(:url) }
-      it { should_not allow_value('demo.bigbluebutton.org/bigbluebutton/api').for(:url) }
-    end
+  context "supported versions" do
+    it { should allow_value('0.7').for(:version) }
+    it { should allow_value('0.8').for(:version) }
+    it { should_not allow_value('').for(:version) }
+    it { should_not allow_value('0.64').for(:version) }
+    it { should_not allow_value('0.6').for(:version) }
+  end
 
-    context "supported versions" do
-      it { should allow_value('0.64').for(:version) }
-      it { should allow_value('0.7').for(:version) }
-      it { should_not allow_value('').for(:version) }
-      it { should_not allow_value('0.8').for(:version) }
-      it { should_not allow_value('0.6').for(:version) }
-    end
+  context "param format" do
+    let(:msg) { I18n.t('bigbluebutton_rails.servers.errors.param_format') }
+    it { should validate_format_of(:param).not_with("123 321").with_message(msg) }
+    it { should validate_format_of(:param).not_with("").with_message(msg) }
+    it { should validate_format_of(:param).not_with("ab@c").with_message(msg) }
+    it { should validate_format_of(:param).not_with("ab#c").with_message(msg) }
+    it { should validate_format_of(:param).not_with("ab$c").with_message(msg) }
+    it { should validate_format_of(:param).not_with("ab%c").with_message(msg) }
+    it { should validate_format_of(:param).not_with("ábcd").with_message(msg) }
+    it { should validate_format_of(:param).not_with("-abc").with_message(msg) }
+    it { should validate_format_of(:param).not_with("abc-").with_message(msg) }
+    it { should validate_format_of(:param).with("_abc").with_message(msg) }
+    it { should validate_format_of(:param).with("abc_").with_message(msg) }
+    it { should validate_format_of(:param).with("abc") }
+    it { should validate_format_of(:param).with("123") }
+    it { should validate_format_of(:param).with("abc-123_d5") }
+  end
 
-    context "param format" do
-      let(:msg) { I18n.t('bigbluebutton_rails.servers.errors.param_format') }
-      it { should validate_format_of(:param).not_with("123 321").with_message(msg) }
-      it { should validate_format_of(:param).not_with("").with_message(msg) }
-      it { should validate_format_of(:param).not_with("ab@c").with_message(msg) }
-      it { should validate_format_of(:param).not_with("ab#c").with_message(msg) }
-      it { should validate_format_of(:param).not_with("ab$c").with_message(msg) }
-      it { should validate_format_of(:param).not_with("ab%c").with_message(msg) }
-      it { should validate_format_of(:param).not_with("ábcd").with_message(msg) }
-      it { should validate_format_of(:param).not_with("-abc").with_message(msg) }
-      it { should validate_format_of(:param).not_with("abc-").with_message(msg) }
-      it { should validate_format_of(:param).with("_abc").with_message(msg) }
-      it { should validate_format_of(:param).with("abc_").with_message(msg) }
-      it { should validate_format_of(:param).with("abc") }
-      it { should validate_format_of(:param).with("123") }
-      it { should validate_format_of(:param).with("abc-123_d5") }
+  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
     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
-      end
-      it "nil" do
-        @server = Factory.build(:bigbluebutton_server, :param => nil,
-                                :name => "-My Name@ _Is Odd_-")
-      end
-      it "empty" do
-        @server = Factory.build(:bigbluebutton_server, :param => "",
-                                :name => "-My Name@ _Is Odd_-")
-      end
+    it "nil" do
+      @server = Factory.build(:bigbluebutton_server, :param => nil,
+                              :name => "-My Name@ _Is Odd_-")
     end
-
-    context "has an api object" do
-      let(:server) { server = Factory.build(:bigbluebutton_server) }
-      it { should respond_to(:api) }
-      it { server.api.should_not be_nil }
-      it {
-        server.save
-        server.api.should_not be_nil
-      }
-      context "with the correct attributes" do
-        let(:api) { api = BigBlueButton::BigBlueButtonApi.new(server.url, server.salt,
-                                                              server.version, false) }
-        it { server.api.should == api }
-
-        # updating any of these attributes should update the api
-        # FIXME: can't test the version updated bc only 0.7 is supported right now
-        { :url => 'http://anotherurl.com/bigbluebutton/api',
-          :salt => '12345-abcde-67890-fghijk', :version => '0.7' }.each do |k,v|
-          it {
-            server.send("#{k}=", v)
-            server.api.send(k).should == v
-          }
-        end
-      end
+    it "empty" do
+      @server = Factory.build(:bigbluebutton_server, :param => "",
+                              :name => "-My Name@ _Is Odd_-")
     end
+  end
 
-    context "initializes" do
-      let(:server) { BigbluebuttonServer.new }
-
-      it "fetched attributes before they are fetched" do
-        server.meetings.should == []
+  context "has an api object" do
+    let(:server) { server = Factory.build(:bigbluebutton_server) }
+    it { should respond_to(:api) }
+    it { server.api.should_not be_nil }
+    it {
+      server.save
+      server.api.should_not be_nil
+    }
+    context "with the correct attributes" do
+      let(:api) { api = BigBlueButton::BigBlueButtonApi.new(server.url, server.salt,
+                                                            server.version, false) }
+      it { server.api.should == api }
+
+      # updating any of these attributes should update the api
+      { :url => 'http://anotherurl.com/bigbluebutton/api',
+        :salt => '12345-abcde-67890-fghijk', :version => '0.8' }.each do |k,v|
+        it {
+          server.send("#{k}=", v)
+          server.api.send(k).should == v
+        }
       end
     end
+  end
 
-    it { should respond_to(:fetch_meetings) }
-    it { should respond_to(:meetings) }
-
-    context "fetching info from bbb" do
-      let(:server) { Factory.create(:bigbluebutton_server) }
-      let(:room1) { Factory.create(:bigbluebutton_room, :server => server, :meetingid => "room1", :randomize_meetingid => true) }
-      let(:room2) { Factory.create(:bigbluebutton_room, :server => server, :meetingid => "room2", :randomize_meetingid => true) }
-
-      # the hashes should be exactly as returned by bigbluebutton-api-ruby to be sure we are testing it right
-      let(:meetings) {
-        [
-         { :meetingID => room1.meetingid, :attendeePW => "ap", :moderatorPW => "mp", :hasBeenForciblyEnded => false, :running => true},
-         { :meetingID => room2.meetingid, :attendeePW => "pass", :moderatorPW => "pass", :hasBeenForciblyEnded => true, :running => false},
-         { :meetingID => "im not in the db", :attendeePW => "pass", :moderatorPW => "pass", :hasBeenForciblyEnded => true, :running => true}
-        ]
-      }
-      let(:hash) {
-        { :returncode => true,
-          :meetings => meetings
-        }
-      }
-
-      before {
-        @api_mock = mock(BigBlueButton::BigBlueButtonApi)
-        server.stub(:api).and_return(@api_mock)
-        @api_mock.should_receive(:get_meetings).and_return(hash)
-        server.fetch_meetings
-
-        # the passwords are updated during fetch_meetings
-        room1.moderator_password = "mp"
-        room1.attendee_password = "ap"
-        room2.moderator_password = "pass"
-        room2.attendee_password = "pass"
-      }
+  context "initializes" do
+    let(:server) { BigbluebuttonServer.new }
 
-      it { server.meetings.count.should be(3) }
-      it { server.meetings[0].should have_same_attributes_as(room1) }
-      it { server.meetings[1].should have_same_attributes_as(room2) }
-      it { server.meetings[2].meetingid.should == "im not in the db" }
-      it { server.meetings[2].name.should == "im not in the db" }
-      it { server.meetings[2].server.should == server }
-      it { server.meetings[2].attendee_password.should == "pass" }
-      it { server.meetings[2].moderator_password.should == "pass" }
-      it { server.meetings[2].running.should == true }
-      it { server.meetings[2].new_record?.should be_true }
-      it { server.meetings[2].external.should be_true }
-      it { server.meetings[2].randomize_meetingid.should be_false }
-      it { server.meetings[2].private.should be_true  }
+    it "fetched attributes before they are fetched" do
+      server.meetings.should == []
     end
+  end
 
+  it { should respond_to(:fetch_meetings) }
+  it { should respond_to(:meetings) }
+
+  context "fetching info from bbb" do
+    let(:server) { Factory.create(:bigbluebutton_server) }
+    let(:room1) { Factory.create(:bigbluebutton_room, :server => server, :meetingid => "room1", :randomize_meetingid => true) }
+    let(:room2) { Factory.create(:bigbluebutton_room, :server => server, :meetingid => "room2", :randomize_meetingid => true) }
+
+    # the hashes should be exactly as returned by bigbluebutton-api-ruby to be sure we are testing it right
+    let(:meetings) {
+      [
+       { :meetingID => room1.meetingid, :attendeePW => "ap", :moderatorPW => "mp", :hasBeenForciblyEnded => false, :running => true},
+       { :meetingID => room2.meetingid, :attendeePW => "pass", :moderatorPW => "pass", :hasBeenForciblyEnded => true, :running => false},
+       { :meetingID => "im not in the db", :attendeePW => "pass", :moderatorPW => "pass", :hasBeenForciblyEnded => true, :running => true}
+      ]
+    }
+    let(:hash) {
+      { :returncode => true,
+        :meetings => meetings
+      }
+    }
+
+    before {
+      @api_mock = mock(BigBlueButton::BigBlueButtonApi)
+      server.stub(:api).and_return(@api_mock)
+      @api_mock.should_receive(:get_meetings).and_return(hash)
+      server.fetch_meetings
+
+      # the passwords are updated during fetch_meetings
+      room1.moderator_password = "mp"
+      room1.attendee_password = "ap"
+      room2.moderator_password = "pass"
+      room2.attendee_password = "pass"
+    }
+
+    it { server.meetings.count.should be(3) }
+    it { server.meetings[0].should have_same_attributes_as(room1) }
+    it { server.meetings[1].should have_same_attributes_as(room2) }
+    it { server.meetings[2].meetingid.should == "im not in the db" }
+    it { server.meetings[2].name.should == "im not in the db" }
+    it { server.meetings[2].server.should == server }
+    it { server.meetings[2].attendee_password.should == "pass" }
+    it { server.meetings[2].moderator_password.should == "pass" }
+    it { server.meetings[2].running.should == true }
+    it { server.meetings[2].new_record?.should be_true }
+    it { server.meetings[2].external.should be_true }
+    it { server.meetings[2].randomize_meetingid.should be_false }
+    it { server.meetings[2].private.should be_true  }
   end
 
 end

data/spec/rails_app/.gitignore

@@ -1,4 +1,5 @@
 config/locales/bigbluebutton_rails.en.yml
 db/migrate/*bigbluebutton_rails.rb
 db/schema.rb
-tmp/
+tmp/
+logs/

data/spec/rails_app/db/seeds.rb

@@ -1,8 +1,20 @@
 # This file should contain all the record creation needed to seed the database with its default values.
 # The data can then be loaded with the rake db:seed (or created alongside the db with db:setup).
 
-file = File.join(Rails.root, "..", "integration_conf.yml")
-if File.exists? file
-  config = YAML.load_file(file)["server"]
-  BigbluebuttonServer.create!(config)
+file = File.join(Rails.root, "features", "config.yml")
+if File.exists?(file)
+  config = YAML.load_file(file)
+
+  if ENV['SERVER']
+    unless config['servers'].has_key?(ENV['SERVER'])
+      throw Exception.new("Server #{ENV['SERVER']} does not exists in your configuration file.")
+    end
+    server = config['servers'][ENV['SERVER']]
+  else
+    server = config['servers'][config['servers'].keys.first]
+  end
+  server['version'] = '0.7' unless server.has_key?('version')
+  server['name'] = URI.parse(server['url']).host
+
+  BigbluebuttonServer.create!(server)
 end

data/spec/rails_app/features/activity_monitor_servers.feature

@@ -0,0 +1,53 @@
+Feature: Monitor the active in the webconference servers
+  To check the current status of a server
+  One needs a real-time activity monitor
+
+  @need-bot
+  Scenario: View the list of meetings running in a server
+    Given an anonymous user
+      And a real server
+      And 2 meetings running in this server
+    When he goes to the server activity monitor page
+    Then he should see the 2 meetings that are running
+
+  @need-bot
+  Scenario: View the list of meetings in progress and meetings recently finished
+    Given an anonymous user
+      And a real server
+      And 2 meetings running in this server
+      And 2 meetings recently ended in this server
+    When he goes to the server activity monitor page
+    Then he should see the 2 meetings that are running
+      And he should see the 2 recently ended meetings
+
+  @need-bot
+  Scenario: View externally created meetings (in rooms that are not in the database)
+    Given an anonymous user
+      And a real server
+      And an external room in this server
+    When he goes to the server activity monitor page
+    Then he should see the external room in the list
+
+  # Note: This will only work for bbb servers with removeMeetingWhenEnded=false
+  # See: http://code.google.com/p/bigbluebutton/issues/detail?id=980
+  @need-bot
+  Scenario: Contains a link to partially refresh the meeting list
+    Given an anonymous user
+      And a real server
+      And 2 meetings running in this server
+    When he goes to the server activity monitor page
+      And the first meeting is ended
+      And he clicks in the link to update the meeting list
+    Then he should see one meeting running and the other meeting not running
+
+  # Note: This will only work for bbb servers with removeMeetingWhenEnded=false
+  #       Also defaultMeetingExpireDuration should be >= 2
+  @need-bot @webkit
+  Scenario: Partially refresh the meeting list periodically
+    Given an anonymous user
+      And a real server
+      And 2 meetings running in this server
+    When he goes to the server activity monitor page
+      And the first meeting is ended
+    Then after 31 seconds
+      And he should see one meeting running and the other meeting not running