bigbluebutton_rails 1.4.0 → 2.0.0

data/spec/models/bigbluebutton_server_config_spec.rb

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe BigbluebuttonServerConfig do
+
+  before { mock_server_and_api }
+
+  it { should belong_to(:server) }
+  it { should validate_presence_of(:server_id) }
+  it { should serialize(:available_layouts).as(Array) }
+
+  describe "serializes #available_layouts as an Array" do
+    let(:config) { FactoryGirl.create(:bigbluebutton_server_config) }
+    let(:layouts) { ["layout1", "layout2"] }
+
+    it {
+      config.update_attributes(available_layouts: layouts)
+      config.available_layouts.should eq(layouts)
+    }
+  end
+
+  describe "#update_config" do
+    let(:config) { FactoryGirl.create(:bigbluebutton_server_config, server: mocked_server) }
+    let(:layouts) { ["layout1", "layout2"] }
+    let(:new_layouts) { ["layout3", "layout4"] }
+
+    before {
+      mocked_api.should_receive(:get_default_config_xml).and_return("<config></config>")
+      config.update_attributes(available_layouts: layouts)
+    }
+
+    context "when there are new layouts in the server" do
+      before {
+        mocked_api.should_receive(:get_available_layouts).and_return(new_layouts)
+        config.update_config
+      }
+      it { config.available_layouts.should eql new_layouts }
+    end
+
+    context "when there are no new layouts" do
+      before {
+        mocked_api.should_receive(:get_available_layouts).once.and_return(nil)
+        expect(config).not_to receive(:update_attributes)
+        config.update_config
+      }
+      it { config.available_layouts.should eql layouts }
+    end
+
+    context "rescues from BigBlueButton::BigBlueButtonException" do
+      before {
+        mocked_api.stub(:get_available_layouts) { raise BigBlueButton::BigBlueButtonException.new }
+        expect(config).not_to receive(:update_attributes)
+      }
+      it {
+        expect { config.update_config }.not_to raise_error
+      }
+    end
+  end
+
+  describe "#available_layouts_names" do
+    let(:layouts) { ["layout1", "bbb.test.layout2", "Wëird Chárs"] }
+    let(:expected) { ["layout1", "layout2", "Wëird Chárs"] }
+    let(:config) { FactoryGirl.create(:bigbluebutton_server_config, available_layouts: layouts) }
+
+    before {
+      I18n.stub(:t) { |value|
+        case value
+        when "bigbluebutton_rails.server_configs.layouts.layout1"
+          "Layout1 Localized"
+        when "bigbluebutton_rails.server_configs.layouts.layout2"
+          "Layout2 Localized"
+        when "bigbluebutton_rails.server_configs.layouts.weird_chars"
+          "Weird Localized"
+        else
+          nil
+        end
+      }
+    }
+
+    it {
+      config.available_layouts_names.should eql(['Layout1 Localized', 'Layout2 Localized', 'Weird Localized'])
+    }
+  end
+
+  describe "#available_layouts_for_select" do
+    let(:layouts) { ["layout1", "bbb.test.layout2", "Wëird Chárs"] }
+    let(:expected) { ["layout1", "layout2", "Wëird Chárs"] }
+    let(:config) { FactoryGirl.create(:bigbluebutton_server_config, available_layouts: layouts) }
+
+    before {
+      I18n.stub(:t) { |value|
+        case value
+        when "bigbluebutton_rails.server_configs.layouts.layout1"
+          "Layout1 Localized"
+        when "bigbluebutton_rails.server_configs.layouts.layout2"
+          "Layout2 Localized"
+        when "bigbluebutton_rails.server_configs.layouts.weird_chars"
+          "Weird Localized"
+        else
+          nil
+        end
+      }
+    }
+
+    it {
+      config.available_layouts_for_select.should eql(
+        [
+          ['Layout1 Localized', 'layout1'],
+          ['Layout2 Localized', 'bbb.test.layout2'],
+          ['Weird Localized', 'Wëird Chárs']
+        ]
+      )
+    }
+  end
+end

data/spec/models/bigbluebutton_server_spec.rb

@@ -10,10 +10,16 @@ describe BigbluebuttonServer do
 
   it { should have_many(:recordings).dependent(:nullify) }
 
+  it { should have_one(:config).dependent(:destroy) }
+  it { should delegate(:update_config).to(:config) }
+
+  it { should delegate(:available_layouts).to(:config) }
+  it { should delegate(:available_layouts_names).to(:config) }
+  it { should delegate(:available_layouts_for_select).to(:config) }
+
   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) }
 
   context "uniqueness of" do
@@ -62,11 +68,14 @@ describe BigbluebuttonServer do
   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 allow_value('0.81').for(:version) }
+    it { should allow_value('0.9').for(:version) }
+    it { should allow_value('').for(:version) }
+    it { should allow_value(nil).for(:version) }
     it { should_not allow_value('0.64').for(:version) }
     it { should_not allow_value('0.6').for(:version) }
+    it { should_not allow_value('0.7').for(:version) }
   end
 
   context "param format" do
@@ -90,7 +99,7 @@ describe BigbluebuttonServer do
 
   context "sets param as the downcased parameterized name if param is" do
     after :each do
-      @server.save.should be_true
+      @server.save.should be(true)
       @server.param.should == @server.name.downcase.parameterize
     end
     it "nil" do
@@ -103,28 +112,45 @@ describe BigbluebuttonServer do
     end
   end
 
-  context "has an api object" do
-    let(:server) { server = FactoryGirl.build(:bigbluebutton_server) }
+  context "#api" do
+    let(:server) { FactoryGirl.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) }
+      let(: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|
+        :salt => '12345-abcde-67890-fghijk', :version => '0.9' }.each do |k,v|
         it {
           server.send("#{k}=", v)
           server.api.send(k).should == v
         }
       end
     end
+
+    context "returns the cached API object, if any" do
+      it {
+        BigBlueButton::BigBlueButtonApi.should_receive(:new).once.and_return("fake api")
+        server.api
+        server.api
+      }
+    end
+
+    context "automatically fetches the API version if the version if not set" do
+      before(:each) {
+        server.update_attributes(version: nil)
+        BigBlueButton::BigBlueButtonApi.any_instance.stub(:get_api_version).and_return("0.9")
+      }
+      it { server.api.version.should eql("0.9") }
+      it {
+        server.api
+        server.version.should eql("0.9")
+        server.reload.version.should be_nil # doesn't save it
+      }
+    end
   end
 
   context "initializes" do
@@ -163,11 +189,11 @@ describe BigbluebuttonServer do
       @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"
+      # the keys are updated during fetch_meetings
+      room1.moderator_api_password = "mp"
+      room1.attendee_api_password = "ap"
+      room2.moderator_api_password = "pass"
+      room2.attendee_api_password = "pass"
     }
 
     it { server.meetings.count.should be(3) }
@@ -176,12 +202,12 @@ describe BigbluebuttonServer do
     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].attendee_api_password.should == "pass" }
+    it { server.meetings[2].moderator_api_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].private.should be_true  }
+    it { server.meetings[2].new_record?.should be_truthy }
+    it { server.meetings[2].external.should be_truthy }
+    it { server.meetings[2].private.should be_truthy  }
 
     it "updates the meeting associated with this room"
   end
@@ -268,4 +294,135 @@ describe BigbluebuttonServer do
     end
   end
 
+  describe "#config" do
+    it "is created when the server is created" do
+      server = FactoryGirl.create(:bigbluebutton_server)
+      server.config.should_not be_nil
+      server.config.should be_an_instance_of(BigbluebuttonServerConfig)
+      server.config.server.should eql(server)
+    end
+
+    context "if it was not created, is built when accessed" do
+      before(:each) {
+        @server = FactoryGirl.create(:bigbluebutton_server)
+        @server.config.destroy
+        @server.reload
+        @server.config # access it so the new obj is created
+      }
+      it { @server.config.should_not be_nil }
+      it("is not promptly saved") {
+        @server.config.new_record?.should be(true)
+      }
+      it("is saved when the server is saved") {
+        @server.save!
+        @server.reload
+        @server.config.new_record?.should be(false)
+      }
+    end
+  end
+
+  describe "triggers #update_config" do
+
+    context "on after create" do
+      it {
+        BigbluebuttonServerConfig.any_instance.should_receive(:update_config).once
+        FactoryGirl.create(:bigbluebutton_server)
+      }
+    end
+
+    context "on after save" do
+      let(:server) { FactoryGirl.create(:bigbluebutton_server, version: "0.8") }
+      before { server.stub(:set_api_version_from_server) }
+
+      context "if #url changed" do
+        before { server.should_receive(:update_config).once }
+        it { server.update_attributes(url: server.url + "-2") }
+      end
+
+      context "if #salt changed" do
+        before { server.should_receive(:update_config).once }
+        it { server.update_attributes(salt: server.salt + "-2") }
+      end
+
+      context "if #version changed" do
+        before { server.should_receive(:update_config).once }
+        it { server.update_attributes(version: "0.9") }
+      end
+
+      context "not if any other attribute changed" do
+        before { server.should_not_receive(:update_config) }
+        it { server.update_attributes(name: server.name + "-2") }
+      end
+    end
+  end
+
+  describe "triggers #set_api_version_from_server" do
+
+    context "on after save" do
+      let(:server) { FactoryGirl.create(:bigbluebutton_server, version: "0.8") }
+
+      context "when the model is created" do
+        it {
+          s = FactoryGirl.build(:bigbluebutton_server, version: nil)
+          s.should_receive(:set_api_version_from_server).once
+          s.save
+        }
+      end
+
+      context "if #url changed" do
+        before { server.should_receive(:set_api_version_from_server).once }
+        it { server.update_attributes(url: server.url + "-2") }
+      end
+
+      context "if #salt changed" do
+        before { server.should_receive(:set_api_version_from_server).once }
+        it { server.update_attributes(salt: server.salt + "-2") }
+      end
+
+      context "if #version changed" do
+        before { server.should_receive(:set_api_version_from_server).once }
+        it { server.update_attributes(version: "0.9") }
+      end
+
+      context "not if #name changed" do
+        before { server.should_not_receive(:set_api_version_from_server) }
+        it { server.update_attributes(name: server.name + "-2") }
+      end
+
+      # Specific test for when we have a version set in the server, set it to a blank value,
+      # and it ends up getting the same old version from the server.
+      # Depending on how the hooks to update the version are set up, this won't work.
+      context "checking the real value of #version" do
+        let(:version_from_api) { "0.9" }
+        let(:old_version) { "0.9" }
+        let(:server) { FactoryGirl.create(:bigbluebutton_server, version: version_from_api) }
+
+        context "if #version was set to empty" do
+          before {
+            api_mock = double(BigBlueButton::BigBlueButtonApi)
+            api_mock.stub(:version).and_return(version_from_api)
+            api_mock.stub(:get_default_config_xml)
+            api_mock.stub(:get_available_layouts)
+            BigBlueButton::BigBlueButtonApi.stub(:new).and_return(api_mock)
+          }
+          it {
+            server.update_attributes(version: "")
+            server.reload.version.should eql(version_from_api)
+          }
+        end
+
+        context "doesn't raise an exception if the server is offline" do
+          before {
+            BigBlueButton::BigBlueButtonApi.stub(:new) { raise BigBlueButton::BigBlueButtonException.new('test exception') }
+          }
+          it {
+            server.update_attributes(url: "http://insert-any-invalid-url.mconf.org/bigbluebutton/api")
+            server.reload.version.should be_nil
+          }
+        end
+
+      end
+    end
+  end
+
 end

data/spec/rails_app/app/controllers/my_playback_types_controller.rb

@@ -0,0 +1,7 @@
+class MyPlaybackTypesController < ApplicationController
+  respond_to :html
+
+  def index
+    respond_with(@playback_types = BigbluebuttonPlaybackType.all)
+  end
+end

data/spec/rails_app/app/views/frontpage/show.html.erb

@@ -3,3 +3,4 @@
 <%= link_to('View server list', bigbluebutton_servers_path) %> (<%= @servers.count %> servers)<br/>
 <%= link_to('View room list', bigbluebutton_rooms_path) %> (<%= @rooms.count %> rooms)<br/>
 <%= link_to('View recording list', bigbluebutton_recordings_path) %> (<%= @recordings.count %> recordings)<br/>
+<%= link_to('Show or hide playback types', my_playback_types_path) %>

data/spec/rails_app/app/views/my_playback_types/index.html.erb

@@ -0,0 +1,33 @@
+<h1>Listing Playback Types:</h1>
+
+<div id="bbbrails_servers_links">
+  <%= link_to('View server list', bigbluebutton_servers_path) %><br/>
+  <%= link_to('View room list', bigbluebutton_rooms_path) %><br/>
+  <%= link_to('View recording list', bigbluebutton_recordings_path) %>
+</div>
+
+</br></br>
+The list of playback types will be automatically filled with the playback types available in your web conference server.
+You can use this views to make them visible or invisible, a feature useful to dynamically hide playback types you don't
+want the users to have access in your application.
+</br></br>
+
+<ul id="bbbrails_list">
+  <% @playback_types.each do |playback_type| %>
+    <li>
+      <%= form_for(playback_type) do |f| %>
+        <div><label><%= BigbluebuttonPlaybackType.human_attribute_name(:id) %></label> <%= playback_type.id %></div>
+        <div><label><%= BigbluebuttonPlaybackType.human_attribute_name(:identifier) %></label> <%= playback_type.identifier %></div>
+        <div><label><%= BigbluebuttonPlaybackType.human_attribute_name(:visible) %></label>
+          <%= f.check_box :visible %>
+        </div>
+        <div><label><%= BigbluebuttonPlaybackType.human_attribute_name(:default) %></label>
+          <%= f.check_box :default %>
+        </div>
+        <div><label>Access</label>
+          <%= f.submit %>
+        </div>
+      <% end %>
+    </li>
+  <% end %>
+</ul>

data/spec/rails_app/config/application.rb

@@ -54,8 +54,5 @@ module RailsApp
 
     # Version of your assets, change this if you want to expire all your assets
     config.assets.version = '1.0'
-
-    # Disabled rails 3.2 attr_accessible in favor of strong_parameters
-    config.active_record.whitelist_attributes = false
   end
 end

data/spec/rails_app/config/database.yml.travis

@@ -0,0 +1,10 @@
+test:
+  adapter: mysql2
+  database: bigbluebutton_rails_test
+  username: travis
+  encoding: utf8
+development:
+  adapter: mysql2
+  database: bigbluebutton_rails_dev
+  username: travis
+  encoding: utf8