bigbluebutton_rails 0.0.6 → 0.1.0

data/Rakefile

@@ -56,8 +56,9 @@ end
 task :cucumber do
   if File.exists? "features/"
     puts "* Gem features"
-    sh %{ cucumber features/ }
+    sh "cucumber features/"
   end
+
   puts "* Dummy app features"
   cd File.join(File.dirname(__FILE__), "spec", "rails_app")
   sh "cucumber features/"

data/TODO_08

@@ -0,0 +1,13 @@
+TODO for BigBlueButton 0.8:
+
+See:
+* http://code.google.com/p/bigbluebutton/wiki/API#Version_0.8
+* http://groups.google.com/group/bigbluebutton-dev/browse_thread/thread/c214cbe9bdb2268a?pli=1
+
+TODO:
+* Support for recordings
+  * Keep track of older meetings?
+* Pre-upload of slides
+* New arguments in some methods (e.g. userID, record, duration, meta_*)
+* New return values (e.g createTime).
+* We don't need to randomize the meeting_id anymore (to confirm)

data/app/controllers/bigbluebutton/rooms_controller.rb

@@ -165,7 +165,7 @@ class Bigbluebutton::RoomsController < ApplicationController
       role = @room.user_role(params[:user])
     end
 
-    unless role.nil? or name.nil?
+    unless role.nil? or name.nil? or name.empty?
       join_internal(name, role, :invite)
     else
       flash[:error] = t('bigbluebutton_rails.rooms.errors.auth.failure')
@@ -185,11 +185,11 @@ class Bigbluebutton::RoomsController < ApplicationController
   # Authenticates an user using name and password passed in the params from #external
   # Uses params[:meeting] to get the meetingID of the target room
   def external_auth
-    @room = nil
     if !params[:meeting].blank? && !params[:user].blank?
       @server.fetch_meetings
       @room = @server.meetings.select{ |r| r.meetingid == params[:meeting] }.first
     else
+      @room = nil
       message = t('bigbluebutton_rails.rooms.errors.auth.wrong_params')
       redirect_to request.referer, :notice => message
       return
@@ -202,11 +202,11 @@ class Bigbluebutton::RoomsController < ApplicationController
     name = bigbluebutton_user.nil? ? params[:user][:name] : bigbluebutton_user.name
     role = @room.user_role(params[:user])
 
-    unless role.nil? or name.nil?
-      @room.fetch_meeting_info
-      if @room.is_running?
-        join_url = @room.join_url(name, role)
-        redirect_to(join_url)
+    # FIXME: use internal_join ?
+    unless role.nil? or name.nil? or name.empty?
+      url = @room.perform_join(name, role, request)
+      unless url.nil?
+        redirect_to(url)
       else
         flash[:error] = t('bigbluebutton_rails.rooms.errors.auth.not_running')
         render :external
@@ -264,13 +264,13 @@ class Bigbluebutton::RoomsController < ApplicationController
   end
 
   def join_mobile
-    @join_url = join_bigbluebutton_server_room_path(@server, @room, :mobile => '1')
+    @join_url = join_bigbluebutton_server_room_url(@server, @room, :mobile => '1')
     @join_url.gsub!(/http:\/\//i, "bigbluebutton://")
 
     # TODO: we can't use the mconf url because the mobile client scanning the qrcode is not
     # logged. so we are using the full BBB url for now.
     @qrcode_url = @room.join_url(bigbluebutton_user.name, bigbluebutton_role(@room))
-    @qrcode_url.gsub!("http://", "bigbluebutton://")
+    @qrcode_url.gsub!(/http:\/\//i, "bigbluebutton://")
   end
 
   protected

data/app/controllers/bigbluebutton/servers_controller.rb

@@ -34,7 +34,7 @@ class Bigbluebutton::ServersController < ApplicationController
 
     # update_list works only for html
     if params[:update_list] && (params[:format].nil? || params[:format].to_s == "html")
-      render :html => 'activity_list', :server => @server
+      render :partial => 'activity_list', :locals => { :server => @server }
       return
     end
 

data/app/models/bigbluebutton_room.rb

@@ -1,5 +1,3 @@
-require 'active_support/secure_random'
-
 class BigbluebuttonRoom < ActiveRecord::Base
   belongs_to :server, :class_name => 'BigbluebuttonServer'
   belongs_to :owner, :polymorphic => true
@@ -41,6 +39,9 @@ class BigbluebuttonRoom < ActiveRecord::Base
   after_initialize :init
   before_validation :set_param
 
+  # the full logout_url used when logout_url is a relative path
+  attr_accessor :full_logout_url
+
   # Convenience method to access the attribute <tt>running</tt>
   def is_running?
     @running
@@ -201,10 +202,9 @@ class BigbluebuttonRoom < ActiveRecord::Base
   def perform_join(username, role, request=nil)
     fetch_is_running?
 
-    # if the current user is a moderator, create the room (if needed)
-    # and join it
+    # if the user is a moderator, create the room (if needed) and join it
     if role == :moderator
-      add_domain_to_logout_url(request.protocol, request.host) unless request.nil?
+      add_domain_to_logout_url(request.protocol, request.host_with_port) unless request.nil?
       send_create unless is_running?
       ret = join_url(username, role)
 
@@ -218,6 +218,7 @@ class BigbluebuttonRoom < ActiveRecord::Base
   end
 
   # add a domain name and/or protocol to the logout_url if needed
+  # it doesn't save in the db, just updates the instance
   def add_domain_to_logout_url(protocol, host)
     unless logout_url.nil?
       url = logout_url.downcase
@@ -227,7 +228,7 @@ class BigbluebuttonRoom < ActiveRecord::Base
         end
         url = protocol + url
       end
-      update_attributes(:logout_url => url.downcase)
+      self.full_logout_url = url.downcase
     end
   end
 
@@ -248,29 +249,30 @@ class BigbluebuttonRoom < ActiveRecord::Base
   end
 
   def random_meetingid
-    #ActiveSupport::SecureRandom.hex(16)
     # TODO temporarily using the name to get a friendlier meetingid
     if self[:name].blank?
-      ActiveSupport::SecureRandom.hex(8)
+      SecureRandom.hex(8)
     else
-      self[:name] + '-' + ActiveSupport::SecureRandom.random_number(9999).to_s
+      self[:name] + '-' + SecureRandom.random_number(9999).to_s
     end
   end
 
   def random_voice_bridge
-    value = (70000 + ActiveSupport::SecureRandom.random_number(9999)).to_s
+    value = (70000 + SecureRandom.random_number(9999)).to_s
     count = 1
     while not BigbluebuttonRoom.find_by_voice_bridge(value).nil? and count < 10
       count += 1
-      value = (70000 + ActiveSupport::SecureRandom.random_number(9999)).to_s
+      value = (70000 + SecureRandom.random_number(9999)).to_s
     end
     value
   end
 
   def do_create_meeting
-    self.server.api.create_meeting(self.name, self.meetingid, self.moderator_password,
-                                   self.attendee_password, self.welcome_msg, self.dial_number,
-                                   self.logout_url, self.max_participants, self.voice_bridge)
+    opts = { :moderatorPW => self.moderator_password, :attendeePW => self.attendee_password,
+      :welcome => self.welcome_msg, :dialNumber => self.dial_number,
+      :logoutURL => self.full_logout_url || self.logout_url,
+      :maxParticipants => self.max_participants, :voiceBridge => self.voice_bridge }
+    self.server.api.create_meeting(self.name, self.meetingid, opts)
   end
 
   # if :param wasn't set, sets it as :name downcase and parameterized

data/app/models/bigbluebutton_server.rb

@@ -31,7 +31,7 @@ class BigbluebuttonServer < ActiveRecord::Base
 
   validates :version,
             :presence => true,
-            :inclusion => { :in => ['0.64', '0.7'] }
+            :inclusion => { :in => ['0.7', '0.8'] }
 
   attr_accessible :name, :url, :version, :salt, :param
 

data/app/views/bigbluebutton/rooms/_form.html.erb

@@ -7,7 +7,7 @@
 <%= form_for [@server, @room], :url => url do |f| %>
   <% if @room.errors.any? %>
     <div id="error_explanation">
-      <h2><%= pluralize(@room.errors.count, "error") %> prohibited this bigbluebutton_room from being saved:</h2>
+      <h2><%= pluralize(@room.errors.count, "error") %>:</h2>
       <ul>
       <% @room.errors.full_messages.each do |msg| %>
         <li><%= msg %></li>

data/app/views/bigbluebutton/rooms/external.html.erb

@@ -1,6 +1,6 @@
 <h1>Join the meeting <%= @room.name %></h1>
 
-<p id="error"><%= flash[:error] %></p>
+<div id="error_explanation"><%= flash[:error] %></div>
 
 <p>This meeting was created from another application.<br/>You must provide a name and a password to join:</p>
 
@@ -8,7 +8,7 @@
   <%= hidden_field_tag "meeting", params[:meeting] %>
 
   <div class="field">
-    Name:<br />
+    <label for="user_name">Name:</label><br />
     <% if bigbluebutton_user.nil? %>
       <%= text_field_tag "user[name]", "" %>
     <% else %>
@@ -16,7 +16,7 @@
     <% end %>
   </div>
   <div class="field">
-    Password:<br />
+    <label for="user_password">Password:</label><br />
     <%= password_field_tag "user[password]", "" %>
   </div>
 

data/app/views/bigbluebutton/rooms/invite.html.erb

@@ -28,7 +28,7 @@ $(document).ready(function(){
 
 <h1>Invite to the meeting <%= @room.name %></h1>
 
-<p id="error"><%= flash[:error] %></p>
+<div id="error_explanation"><%= flash[:error] %></div>
 
 <p>Meeting status: <span id="meeting_status">-</span> (<a href="javascript:ajax_request();">refresh</a>)</p>
 <p><%= @room.name %> requires a name and/or password to join:</p>
@@ -36,7 +36,7 @@ $(document).ready(function(){
 <%= form_tag join_bigbluebutton_server_room_path(@server, @room) do %>
 
   <div class="field">
-    Name:<br />
+    <label for="user_name">Name:</label><br />
     <% if bigbluebutton_user.nil? %>
       <%= text_field_tag "user[name]", "" %>
     <% else %>
@@ -44,7 +44,7 @@ $(document).ready(function(){
     <% end %>
   </div>
   <div class="field">
-    Password:<br />
+    <label for="user_password">Password:</label><br />
     <% if @room.private %>
       <%= password_field_tag "user[password]", "" %>
     <% else %>

data/app/views/bigbluebutton/servers/_form.html.erb

@@ -1,7 +1,7 @@
 <%= form_for(@server) do |f| %>
   <% if @server.errors.any? %>
     <div id="error_explanation">
-      <h2><%= pluralize(@server.errors.count, "error") %> prohibited this bigbluebutton_server from being saved:</h2>
+      <h2><%= pluralize(@server.errors.count, "error") %>:</h2>
       <ul>
       <% @server.errors.full_messages.each do |msg| %>
         <li><%= msg %></li>

data/bigbluebutton_rails.gemspec

@@ -15,6 +15,6 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.require_paths = ["lib"]
 
-  s.add_dependency("rails", ">= 3.0.3")
-  s.add_dependency("bigbluebutton-api-ruby", "~> 0.0.11")
+  s.add_dependency("rails", ">= 3.0.0")
+  s.add_dependency("bigbluebutton-api-ruby", "~> 0.1.0")
 end

data/lib/bigbluebutton_rails/version.rb

@@ -1,3 +1,3 @@
 module BigbluebuttonRails
-  VERSION = "0.0.6".freeze
+  VERSION = "0.1.0".freeze
 end

data/spec/controllers/bigbluebutton/rooms_controller_spec.rb

@@ -49,7 +49,7 @@ describe Bigbluebutton::RoomsController do
       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).
+      controller.should_receive(:join_bigbluebutton_server_room_url).
         with(mocked_server, room, :mobile => '1').
         and_return("http://test.com/join/url?mobile=1")
       mocked_api.should_receive(:join_meeting_url).
@@ -482,6 +482,14 @@ describe Bigbluebutton::RoomsController do
         it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.errors.auth.failure')) }
       end
 
+      context "when name is set but empty" do
+        let(:user_hash) { { :password => room.moderator_password, :name => "" } }
+        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 "when the password is wrong" do
         let(:user_hash) { { :name => "Elftor", :password => nil } }
         it { should respond_with(:unauthorized) }
@@ -534,8 +542,7 @@ describe Bigbluebutton::RoomsController do
   end # #external
 
   describe "#external_auth" do
-    let(:user) { Factory.build(:user) }
-    let(:user_hash) { { :name => "Elftor", :password => new_room.attendee_password } }
+    let(:user_hash) { { :name => "Any Name", :password => new_room.attendee_password } }
     let(:meetingid) { "my-meeting-id" }
     let(:new_room) { BigbluebuttonRoom.new(:meetingid => meetingid,
                                            :attendee_password => Forgery(:basic).password,
@@ -554,7 +561,7 @@ describe Bigbluebutton::RoomsController 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)
+          new_room.should_receive(:perform_join)
         }
         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) }
@@ -592,11 +599,6 @@ describe Bigbluebutton::RoomsController do
         }.should raise_error(BigbluebuttonRails::RoomAccessDenied)
       end
 
-      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
-
       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 }
 
@@ -608,6 +610,14 @@ describe Bigbluebutton::RoomsController do
           it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.errors.auth.failure')) }
         end
 
+        context "when name is empty not set" do
+          let(:user_hash) { { :password => room.moderator_password, :name => "" } }
+          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
+
         context "when the password is wrong" do
           let(:user_hash) { { :name => "Elftor", :password => nil } }
           it { should respond_with(:unauthorized) }
@@ -617,39 +627,34 @@ describe Bigbluebutton::RoomsController do
         end
       end
 
-      context "and the meeting is running" do
-        before {
-          new_room.should_receive(:fetch_meeting_info)
-          new_room.running = true
-        }
-
-        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
+      context "calls room#perform_join" do
+        context "and redirects to the url received" do
+          before {
+            new_room.should_receive(:perform_join).with(anything, :attendee, request).
+              and_return("http://test.com/attendee/join")
+          }
+          before(:each) { post :external_auth, :server_id => mocked_server.to_param, :meeting => new_room.meetingid, :user => user_hash }
+          it { should respond_with(:redirect) }
+          it { should redirect_to("http://test.com/attendee/join") }
         end
 
-        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://test.com/attendee/join")
+        context "and shows error if it returns nil" do
+          before {
+            new_room.should_receive(:perform_join).with(user_hash[:name], :attendee, request).and_return(nil)
+          }
+          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 render_template(:external) }
+          it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.errors.auth.not_running')) }
         end
       end
 
-      context "and the meeting is not running" do
-        before {
-          new_room.should_receive(:fetch_meeting_info)
-          new_room.running = false
-        }
-        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 render_template(:external) }
-        it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.errors.auth.not_running')) }
+      it "if there's a user logged, should use his name" do
+        user = Factory.build(:user)
+        controller.stub(:bigbluebutton_user).and_return(user)
+        new_room.should_receive(:perform_join).with(user.name, anything, anything). # 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
 
     end

data/spec/factories/bigbluebutton_room.rb

@@ -1,6 +1,8 @@
 Factory.define :bigbluebutton_room do |r|
+  # meetingid with a random factor to avoid duplicated ids in consecutive test runs
+  r.sequence(:meetingid) { |n| "meeting-#{n}-" + SecureRandom.hex(4) }
+
   r.association :server, :factory => :bigbluebutton_server
-  r.sequence(:meetingid) { |n| "MeetingID#{n}" }
   r.sequence(:name) { |n| "Name#{n}" }
   r.attendee_password { Forgery(:basic).password :at_least => 10, :at_most => 16 }
   r.moderator_password { Forgery(:basic).password :at_least => 10, :at_most => 16 }

data/spec/models/bigbluebutton_room_db_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe BigbluebuttonRoom do
+
+  # to ensure that the migration is correct
+  context "db" do
+    it { should have_db_column(:server_id).of_type(:integer) }
+    it { should have_db_column(:owner_id).of_type(:integer) }
+    it { should have_db_column(:owner_type).of_type(:string) }
+    it { should have_db_column(:meetingid).of_type(:string) }
+    it { should have_db_column(:name).of_type(:string) }
+    it { should have_db_column(:attendee_password).of_type(:string) }
+    it { should have_db_column(:moderator_password).of_type(:string) }
+    it { should have_db_column(:welcome_msg).of_type(:string) }
+    it { should have_db_column(:dial_number).of_type(:string) }
+    it { should have_db_column(:logout_url).of_type(:string) }
+    it { should have_db_column(:voice_bridge).of_type(:string) }
+    it { should have_db_column(:max_participants).of_type(:integer) }
+    it { should have_db_column(:private).of_type(:boolean) }
+    it { should have_db_column(:randomize_meetingid).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_index(:server_id) }
+    it { should have_db_index(:meetingid).unique(true) }
+    it { should have_db_index(:voice_bridge).unique(true) }
+    it "default values" do
+      room = BigbluebuttonRoom.new
+      room.private.should be_false
+      room.randomize_meetingid.should be_true
+      room.external.should be_false
+    end
+  end
+
+end

data/spec/models/bigbluebutton_room_spec.rb

@@ -6,551 +6,546 @@ describe BigbluebuttonRoom do
     BigbluebuttonRoom.new.should be_a_kind_of(ActiveRecord::Base)
   end
 
-  # to ensure that the migration is correct
-  context "db" do
-    it { should have_db_column(:server_id).of_type(:integer) }
-    it { should have_db_column(:owner_id).of_type(:integer) }
-    it { should have_db_column(:owner_type).of_type(:string) }
-    it { should have_db_column(:meetingid).of_type(:string) }
-    it { should have_db_column(:name).of_type(:string) }
-    it { should have_db_column(:attendee_password).of_type(:string) }
-    it { should have_db_column(:moderator_password).of_type(:string) }
-    it { should have_db_column(:welcome_msg).of_type(:string) }
-    it { should have_db_column(:dial_number).of_type(:string) }
-    it { should have_db_column(:logout_url).of_type(:string) }
-    it { should have_db_column(:voice_bridge).of_type(:string) }
-    it { should have_db_column(:max_participants).of_type(:integer) }
-    it { should have_db_column(:private).of_type(:boolean) }
-    it { should have_db_column(:randomize_meetingid).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_index(:server_id) }
-    it { should have_db_index(:meetingid).unique(true) }
-    it { should have_db_index(:voice_bridge).unique(true) }
-    it "default values" do
-      room = BigbluebuttonRoom.new
-      room.private.should be_false
-      room.randomize_meetingid.should be_true
-      room.external.should be_false
-    end
+  before { Factory.create(:bigbluebutton_room) }
+
+  it { should belong_to(:server) }
+  it { should belong_to(:owner) }
+  it { should_not validate_presence_of(:owner_id) }
+  it { should_not validate_presence_of(:owner_type) }
+
+  it { should validate_presence_of(:server_id) }
+  it { should validate_presence_of(:meetingid) }
+  it { should validate_presence_of(:voice_bridge) }
+  it { should validate_presence_of(:name) }
+  it { should validate_presence_of(:param) }
+
+  it { should be_boolean(:private) }
+  it { should be_boolean(:randomize_meetingid) }
+
+  [:name, :server_id, :meetingid, :attendee_password, :moderator_password,
+   :welcome_msg, :owner, :server, :private, :logout_url, :dial_number,
+   :voice_bridge, :max_participants, :owner_id, :owner_type,
+   :randomize_meetingid, :param].
+    each do |attribute|
+    it { should allow_mass_assignment_of(attribute) }
+  end
+  it { should_not allow_mass_assignment_of(:id) }
+
+  it { should validate_uniqueness_of(:meetingid) }
+  it { should validate_uniqueness_of(:name) }
+  it { should validate_uniqueness_of(:voice_bridge) }
+  it { should validate_uniqueness_of(:param) }
+
+  it {
+    room = Factory.create(:bigbluebutton_room)
+    room.server.should_not be_nil
+  }
+
+  it { should ensure_length_of(:meetingid).is_at_least(1).is_at_most(100) }
+  it { should ensure_length_of(:name).is_at_least(1).is_at_most(150) }
+  it { should ensure_length_of(:attendee_password).is_at_most(16) }
+  it { should ensure_length_of(:moderator_password).is_at_most(16) }
+  it { should ensure_length_of(:welcome_msg).is_at_most(250) }
+  it { should ensure_length_of(:param).is_at_least(3) }
+
+  # attr_accessors
+  [:running, :participant_count, :moderator_count, :attendees,
+   :has_been_forcibly_ended, :start_time, :end_time, :external].each do |attr|
+    it { should respond_to(attr) }
+    it { should respond_to("#{attr}=") }
   end
 
-  context do
-    before { Factory.create(:bigbluebutton_room) }
-
-    it { should belong_to(:server) }
-    it { should belong_to(:owner) }
-    it { should_not validate_presence_of(:owner_id) }
-    it { should_not validate_presence_of(:owner_type) }
-
-    it { should validate_presence_of(:server_id) }
-    it { should validate_presence_of(:meetingid) }
-    it { should validate_presence_of(:voice_bridge) }
-    it { should validate_presence_of(:name) }
-    it { should validate_presence_of(:param) }
-
-    it { should be_boolean(:private) }
-    it { should be_boolean(:randomize_meetingid) }
-
-    [:name, :server_id, :meetingid, :attendee_password, :moderator_password,
-     :welcome_msg, :owner, :server, :private, :logout_url, :dial_number,
-     :voice_bridge, :max_participants, :owner_id, :owner_type,
-     :randomize_meetingid, :param].
-      each do |attribute|
-      it { should allow_mass_assignment_of(attribute) }
-    end
-    it { should_not allow_mass_assignment_of(:id) }
-
-    it { should validate_uniqueness_of(:meetingid) }
-    it { should validate_uniqueness_of(:name) }
-    it { should validate_uniqueness_of(:voice_bridge) }
-    it { should validate_uniqueness_of(:param) }
-
+  context ".to_param" do
+    it { should respond_to(:to_param) }
     it {
-      room = Factory.create(:bigbluebutton_room)
-      room.server.should_not be_nil
+      r = Factory.create(:bigbluebutton_room)
+      r.to_param.should be(r.param)
     }
+  end
 
-    it { should ensure_length_of(:meetingid).is_at_least(1).is_at_most(100) }
-    it { should ensure_length_of(:name).is_at_least(1).is_at_most(150) }
-    it { should ensure_length_of(:attendee_password).is_at_most(16) }
-    it { should ensure_length_of(:moderator_password).is_at_most(16) }
-    it { should ensure_length_of(:welcome_msg).is_at_most(250) }
-    it { should ensure_length_of(:param).is_at_least(3) }
-
-    # attr_accessors
-    [:running, :participant_count, :moderator_count, :attendees,
-     :has_been_forcibly_ended, :start_time, :end_time, :external].each do |attr|
-      it { should respond_to(attr) }
-      it { should respond_to("#{attr}=") }
-    end
-
-    context ".to_param" do
-      it { should respond_to(:to_param) }
-      it {
-        r = Factory.create(:bigbluebutton_room)
-        r.to_param.should be(r.param)
-      }
-    end
+  it { should respond_to(:is_running?) }
 
-    it { should respond_to(:is_running?) }
+  describe "#user_role" do
+    let(:room) { Factory.build(:bigbluebutton_room, :moderator_password => "mod", :attendee_password => "att") }
+    it { should respond_to(:user_role) }
+    it { room.user_role({ :password => room.moderator_password }).should == :moderator }
+    it { room.user_role({ :password => room.attendee_password }).should == :attendee }
+    it { room.user_role({ :password => "wrong" }).should == nil }
+    it { room.user_role({ :password => nil }).should == nil }
+    it { room.user_role({ :not_password => "any" }).should == nil }
+  end
 
-    describe "#user_role" do
-      let(:room) { Factory.build(:bigbluebutton_room, :moderator_password => "mod", :attendee_password => "att") }
-      it { should respond_to(:user_role) }
-      it { room.user_role({ :password => room.moderator_password }).should == :moderator }
-      it { room.user_role({ :password => room.attendee_password }).should == :attendee }
-      it { room.user_role({ :password => "wrong" }).should == nil }
-      it { room.user_role({ :password => nil }).should == nil }
-      it { room.user_role({ :not_password => "any" }).should == nil }
+  describe "#instance_variables_compare" do
+    let(:room) { Factory.create(:bigbluebutton_room) }
+    let(:room2) { BigbluebuttonRoom.last }
+    it { should respond_to(:instance_variables_compare) }
+    it { room.instance_variables_compare(room2).should be_empty }
+    it "compares instance variables" do
+      room2.running = !room.running
+      room.instance_variables_compare(room2).should_not be_empty
+      room.instance_variables_compare(room2).should include(:@running)
     end
-
-    describe "#instance_variables_compare" do
-      let(:room) { Factory.create(:bigbluebutton_room) }
-      let(:room2) { BigbluebuttonRoom.last }
-      it { should respond_to(:instance_variables_compare) }
-      it { room.instance_variables_compare(room2).should be_empty }
-      it "compares instance variables" do
-        room2.running = !room.running
-        room.instance_variables_compare(room2).should_not be_empty
-        room.instance_variables_compare(room2).should include(:@running)
-      end
-      it "ignores attributes" do
-        room2.private = !room.private
-        room.instance_variables_compare(room2).should be_empty
-      end
+    it "ignores attributes" do
+      room2.private = !room.private
+      room.instance_variables_compare(room2).should be_empty
     end
+  end
 
-    describe "#attr_equal?" do
-      before { Factory.create(:bigbluebutton_room) }
-      let(:room) { BigbluebuttonRoom.last }
-      let(:room2) { BigbluebuttonRoom.last }
-      it { should respond_to(:attr_equal?) }
-      it { room.attr_equal?(room2).should be_true }
-      it "compares instance variables" do
-        room2.running = !room.running
-        room.attr_equal?(room2).should be_false
-      end
-      it "compares attributes" do
-        room2.private = !room.private
-        room.attr_equal?(room2).should be_false
-      end
-      it "compares objects" do
-        room2 = room.clone
-        room.attr_equal?(room2).should be_false
-      end
+  describe "#attr_equal?" do
+    before { Factory.create(:bigbluebutton_room) }
+    let(:room) { BigbluebuttonRoom.last }
+    let(:room2) { BigbluebuttonRoom.last }
+    it { should respond_to(:attr_equal?) }
+    it { room.attr_equal?(room2).should be_true }
+    it "compares instance variables" do
+      room2.running = !room.running
+      room.attr_equal?(room2).should be_false
     end
+    it "compares attributes" do
+      room2.private = !room.private
+      room.attr_equal?(room2).should be_false
+    end
+    it "compares objects" do
+      room2 = room.clone
+      room.attr_equal?(room2).should be_false
+    end
+  end
 
-    context "initializes" do
-      let(:room) { BigbluebuttonRoom.new }
-
-      it "fetched attributes before they are fetched" do
-        room.participant_count.should == 0
-        room.moderator_count.should == 0
-        room.running.should be_false
-        room.has_been_forcibly_ended.should be_false
-        room.start_time.should be_nil
-        room.end_time.should be_nil
-        room.attendees.should == []
-      end
+  context "initializes" do
+    let(:room) { BigbluebuttonRoom.new }
+
+    it "fetched attributes before they are fetched" do
+      room.participant_count.should == 0
+      room.moderator_count.should == 0
+      room.running.should be_false
+      room.has_been_forcibly_ended.should be_false
+      room.start_time.should be_nil
+      room.end_time.should be_nil
+      room.attendees.should == []
+    end
 
-      context "meetingid" do
-        it { room.meetingid.should_not be_nil }
-        it {
-          b = BigbluebuttonRoom.new(:meetingid => "user defined")
-          b.meetingid.should == "user defined"
-        }
-      end
+    context "meetingid" do
+      it { room.meetingid.should_not be_nil }
+      it {
+        b = BigbluebuttonRoom.new(:meetingid => "user defined")
+        b.meetingid.should == "user defined"
+      }
+    end
 
-      context "voice_bridge" do
-        it {
-          b = BigbluebuttonRoom.new(:voice_bridge => "user defined")
-          b.voice_bridge.should == "user defined"
-        }
-        context "with a random value" do
-          it { room.voice_bridge.should_not be_nil }
-          it { room.voice_bridge.should =~ /7[0-9]{4}/ }
-          it "tries to randomize 10 times if voice_bridge already exists" do
-            room = Factory.create(:bigbluebutton_room, :voice_bridge => "70000")
-            BigbluebuttonRoom.stub!(:find_by_voice_bridge).and_return(room)
-            ActiveSupport::SecureRandom.should_receive(:random_number).exactly(10).and_return(0000)
-            room2 = BigbluebuttonRoom.new # triggers the random_number calls
-            room2.voice_bridge.should == "70000"
-          end
+    context "voice_bridge" do
+      it {
+        b = BigbluebuttonRoom.new(:voice_bridge => "user defined")
+        b.voice_bridge.should == "user defined"
+      }
+      context "with a random value" do
+        it { room.voice_bridge.should_not be_nil }
+        it { room.voice_bridge.should =~ /7[0-9]{4}/ }
+        it "tries to randomize 10 times if voice_bridge already exists" do
+          room = Factory.create(:bigbluebutton_room, :voice_bridge => "70000")
+          BigbluebuttonRoom.stub!(:find_by_voice_bridge).and_return(room)
+          SecureRandom.should_receive(:random_number).exactly(10).and_return(0000)
+          room2 = BigbluebuttonRoom.new # triggers the random_number calls
+          room2.voice_bridge.should == "70000"
         end
       end
     end
+  end
 
-    context "param format" do
-      let(:msg) { I18n.t('bigbluebutton_rails.rooms.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.rooms.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 "sets param as the downcased parameterized name if param is" do
-      after :each do
-        @room.save.should be_true
-        @room.param.should == @room.name.downcase.parameterize
-      end
-      it "nil" do
-        @room = Factory.build(:bigbluebutton_room, :param => nil,
-                              :name => "-My Name@ _Is Odd_-")
-      end
-      it "empty" do
-        @room = Factory.build(:bigbluebutton_room, :param => "",
-                              :name => "-My Name@ _Is Odd_-")
-      end
+  context "sets param as the downcased parameterized name if param is" do
+    after :each do
+      @room.save.should be_true
+      @room.param.should == @room.name.downcase.parameterize
+    end
+    it "nil" do
+      @room = Factory.build(:bigbluebutton_room, :param => nil,
+                            :name => "-My Name@ _Is Odd_-")
     end
+    it "empty" do
+      @room = Factory.build(:bigbluebutton_room, :param => "",
+                            :name => "-My Name@ _Is Odd_-")
+    end
+  end
 
-    context "using the api" do
-      before { mock_server_and_api }
-      let(:room) { Factory.create(:bigbluebutton_room) }
+  context "using the api" do
+    before { mock_server_and_api }
+    let(:room) { Factory.create(:bigbluebutton_room) }
 
-      describe "#fetch_is_running?" do
+    describe "#fetch_is_running?" do
 
-        it { should respond_to(:fetch_is_running?) }
+      it { should respond_to(:fetch_is_running?) }
 
-        it "fetches is_running? when not running" do
-          mocked_api.should_receive(:is_meeting_running?).with(room.meetingid).and_return(false)
-          room.server = mocked_server
-          room.fetch_is_running?
-          room.running.should == false
-          room.is_running?.should == false
-        end
-
-        it "fetches is_running? when running" do
-          mocked_api.should_receive(:is_meeting_running?).with(room.meetingid).and_return(true)
-          room.server = mocked_server
-          room.fetch_is_running?
-          room.running.should == true
-          room.is_running?.should == true
-        end
+      it "fetches is_running? when not running" do
+        mocked_api.should_receive(:is_meeting_running?).with(room.meetingid).and_return(false)
+        room.server = mocked_server
+        room.fetch_is_running?
+        room.running.should == false
+        room.is_running?.should == false
+      end
 
+      it "fetches is_running? when running" do
+        mocked_api.should_receive(:is_meeting_running?).with(room.meetingid).and_return(true)
+        room.server = mocked_server
+        room.fetch_is_running?
+        room.running.should == true
+        room.is_running?.should == true
       end
 
-      describe "#fetch_meeting_info" do
+    end
 
-        # these hashes should be exactly as returned by bigbluebutton-api-ruby to be sure we are testing it right
-        let(:hash_info) {
-          { :returncode=>true, :meetingID=>"test_id", :attendeePW=>"1234", :moderatorPW=>"4321",
-            :running=>false, :hasBeenForciblyEnded=>false, :startTime=>nil, :endTime=>nil,
-            :participantCount=>0, :moderatorCount=>0, :attendees=>[], :messageKey=>"", :message=>""
-          }
-        }
-        let(:users) {
-          [
-           {:userID=>"ndw1fnaev0rj", :fullName=>"House M.D.", :role=>:moderator},
-           {:userID=>"gn9e22b7ynna", :fullName=>"Dexter Morgan", :role=>:moderator},
-           {:userID=>"llzihbndryc3", :fullName=>"Cameron Palmer", :role=>:viewer},
-           {:userID=>"rbepbovolsxt", :fullName=>"Trinity", :role=>:viewer}
-          ]
+    describe "#fetch_meeting_info" do
+
+      # these hashes should be exactly as returned by bigbluebutton-api-ruby to be sure we are testing it right
+      let(:hash_info) {
+        { :returncode=>true, :meetingID=>"test_id", :attendeePW=>"1234", :moderatorPW=>"4321",
+          :running=>false, :hasBeenForciblyEnded=>false, :startTime=>nil, :endTime=>nil,
+          :participantCount=>0, :moderatorCount=>0, :attendees=>[], :messageKey=>"", :message=>""
         }
-        let(:hash_info2) {
-          { :returncode=>true, :meetingID=>"test_id", :attendeePW=>"1234", :moderatorPW=>"4321",
-            :running=>true, :hasBeenForciblyEnded=>false, :startTime=>DateTime.parse("Wed Apr 06 17:09:57 UTC 2011"),
-            :endTime=>nil, :participantCount=>4, :moderatorCount=>2,
-            :attendees=>users, :messageKey=>{ }, :message=>{ }
-          }
+      }
+      let(:users) {
+        [
+         {:userID=>"ndw1fnaev0rj", :fullName=>"House M.D.", :role=>:moderator},
+         {:userID=>"gn9e22b7ynna", :fullName=>"Dexter Morgan", :role=>:moderator},
+         {:userID=>"llzihbndryc3", :fullName=>"Cameron Palmer", :role=>:viewer},
+         {:userID=>"rbepbovolsxt", :fullName=>"Trinity", :role=>:viewer}
+        ]
+      }
+      let(:hash_info2) {
+        { :returncode=>true, :meetingID=>"test_id", :attendeePW=>"1234", :moderatorPW=>"4321",
+          :running=>true, :hasBeenForciblyEnded=>false, :startTime=>DateTime.parse("Wed Apr 06 17:09:57 UTC 2011"),
+          :endTime=>nil, :participantCount=>4, :moderatorCount=>2,
+          :attendees=>users, :messageKey=>{ }, :message=>{ }
         }
+      }
 
-        it { should respond_to(:fetch_meeting_info) }
-
-        it "fetches meeting info when the meeting is not running" do
-          mocked_api.should_receive(:get_meeting_info).
-            with(room.meetingid, room.moderator_password).and_return(hash_info)
-          room.server = mocked_server
+      it { should respond_to(:fetch_meeting_info) }
 
-          room.fetch_meeting_info
-          room.running.should == false
-          room.has_been_forcibly_ended.should == false
-          room.participant_count.should == 0
-          room.moderator_count.should == 0
-          room.start_time.should == nil
-          room.end_time.should == nil
-          room.attendees.should == []
-        end
+      it "fetches meeting info when the meeting is not running" do
+        mocked_api.should_receive(:get_meeting_info).
+          with(room.meetingid, room.moderator_password).and_return(hash_info)
+        room.server = mocked_server
 
-        it "fetches meeting info when the meeting is running" do
-          mocked_api.should_receive(:get_meeting_info).
-            with(room.meetingid, room.moderator_password).and_return(hash_info2)
-          room.server = mocked_server
+        room.fetch_meeting_info
+        room.running.should == false
+        room.has_been_forcibly_ended.should == false
+        room.participant_count.should == 0
+        room.moderator_count.should == 0
+        room.start_time.should == nil
+        room.end_time.should == nil
+        room.attendees.should == []
+      end
 
-          room.fetch_meeting_info
-          room.running.should == true
-          room.has_been_forcibly_ended.should == false
-          room.participant_count.should == 4
-          room.moderator_count.should == 2
-          room.start_time.should == DateTime.parse("Wed Apr 06 17:09:57 UTC 2011")
-          room.end_time.should == nil
-
-          users.each do |att|
-            attendee = BigbluebuttonAttendee.new
-            attendee.from_hash(att)
-            room.attendees.should include(attendee)
-          end
+      it "fetches meeting info when the meeting is running" do
+        mocked_api.should_receive(:get_meeting_info).
+          with(room.meetingid, room.moderator_password).and_return(hash_info2)
+        room.server = mocked_server
+
+        room.fetch_meeting_info
+        room.running.should == true
+        room.has_been_forcibly_ended.should == false
+        room.participant_count.should == 4
+        room.moderator_count.should == 2
+        room.start_time.should == DateTime.parse("Wed Apr 06 17:09:57 UTC 2011")
+        room.end_time.should == nil
+
+        users.each do |att|
+          attendee = BigbluebuttonAttendee.new
+          attendee.from_hash(att)
+          room.attendees.should include(attendee)
         end
-
       end
 
-      describe "#send_end" do
+    end
 
-        it { should respond_to(:send_end) }
+    describe "#send_end" do
 
-        it "send end_meeting" do
-          mocked_api.should_receive(:end_meeting).with(room.meetingid, room.moderator_password)
-          room.server = mocked_server
-          room.send_end
-        end
+      it { should respond_to(:send_end) }
 
+      it "send end_meeting" do
+        mocked_api.should_receive(:end_meeting).with(room.meetingid, room.moderator_password)
+        room.server = mocked_server
+        room.send_end
       end
 
-      describe "#send_create" do
-        let(:attendee_password) { Forgery(:basic).password }
-        let(:moderator_password) { Forgery(:basic).password }
-        let(:hash_create) {
-          {
-            :returncode => "SUCCESS", :meetingID => "test_id",
-            :attendeePW => attendee_password, :moderatorPW => moderator_password,
-            :hasBeenForciblyEnded => "false", :messageKey => {}, :message => {}
-          }
-        }
-
-        it { should respond_to(:send_create) }
-
-        context "send create_meeting" do
-
-          context "for a stored room" do
-            before 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).
-                and_return(hash_create)
-              room.server = mocked_server
-              room.send_create
-            end
-            it { room.attendee_password.should be(attendee_password) }
-            it { room.moderator_password.should be(moderator_password) }
-            it { room.changed?.should be_false }
-          end
+    end
 
-          context "for a new_record" do
-            let(:new_room) { Factory.build(:bigbluebutton_room) }
-            before do
-              mocked_api.should_receive(:create_meeting).
-                with(new_room.name, new_room.meetingid, new_room.moderator_password,
-                     new_room.attendee_password, new_room.welcome_msg, new_room.dial_number,
-                     new_room.logout_url, new_room.max_participants, new_room.voice_bridge).
-                and_return(hash_create)
-              new_room.server = mocked_server
-              new_room.send_create
-            end
-            it { new_room.attendee_password.should be(attendee_password) }
-            it { new_room.moderator_password.should be(moderator_password) }
-            it("do not save the record") { new_room.new_record?.should be_true }
-          end
+    describe "#send_create" do
+      let(:attendee_password) { Forgery(:basic).password }
+      let(:moderator_password) { Forgery(:basic).password }
+      let(:hash_create) {
+        {
+          :returncode => "SUCCESS", :meetingID => "test_id",
+          :attendeePW => attendee_password, :moderatorPW => moderator_password,
+          :hasBeenForciblyEnded => "false", :messageKey => {}, :message => {}
+        }
+      }
 
-        end
+      it { should respond_to(:send_create) }
 
-        context "randomizes meetingid" do
-          let(:fail_hash) { { :returncode => true, :meetingID => "new id",
-                              :messageKey => "duplicateWarning" } }
-          let(:success_hash) { { :returncode => true, :meetingID => "new id",
-                                 :messageKey => "" } }
-          let(:new_id) { "new id" }
-          before {
-            room.randomize_meetingid = true
-            room.server = mocked_server
-          }
+      context "send create_meeting" do
 
-          it "before calling create" do
-            room.should_receive(:random_meetingid).and_return(new_id)
+        context "for a stored room" do
+          before do
+            hash = hash_including(:moderatorPW => room.moderator_password, :attendeePW => room.attendee_password,
+                                  :welcome  => room.welcome_msg, :dialNumber => room.dial_number,
+                                  :logoutURL => room.logout_url, :maxParticipants => room.max_participants,
+                                  :voiceBridge => room.voice_bridge)
             mocked_api.should_receive(:create_meeting).
-              with(room.name, new_id, room.moderator_password,
-                   room.attendee_password, room.welcome_msg, room.dial_number,
-                   room.logout_url, room.max_participants, room.voice_bridge)
-            room.send_create
-          end
-
-          it "and tries again on error" do
-            # fails twice and them succeds
-            room.should_receive(:random_meetingid).exactly(3).times.and_return(new_id)
-            mocked_api.should_receive(:create_meeting).
-              with(room.name, new_id, room.moderator_password,
-                   room.attendee_password, room.welcome_msg, room.dial_number,
-                   room.logout_url, room.max_participants, room.voice_bridge).
-              twice.
-              and_return(fail_hash)
-            mocked_api.should_receive(:create_meeting).
-              with(room.name, new_id, room.moderator_password,
-                   room.attendee_password, room.welcome_msg, room.dial_number,
-                   room.logout_url, room.max_participants, room.voice_bridge).
-              once.
-              and_return(success_hash)
+              with(room.name, room.meetingid, hash).and_return(hash_create)
+            room.server = mocked_server
             room.send_create
           end
+          it { room.attendee_password.should be(attendee_password) }
+          it { room.moderator_password.should be(moderator_password) }
+          it { room.changed?.should be_false }
+        end
 
-          it "and limits to 10 tries" do
-            room.should_receive(:random_meetingid).exactly(11).times.and_return(new_id)
+        context "for a new record" do
+          let(:new_room) { Factory.build(:bigbluebutton_room) }
+          before do
+            hash = hash_including(:moderatorPW => new_room.moderator_password, :attendeePW => new_room.attendee_password,
+                                  :welcome  => new_room.welcome_msg, :dialNumber => new_room.dial_number,
+                                  :logoutURL => new_room.logout_url, :maxParticipants => new_room.max_participants,
+                                  :voiceBridge => new_room.voice_bridge)
             mocked_api.should_receive(:create_meeting).
-              with(room.name, new_id, room.moderator_password,
-                   room.attendee_password, room.welcome_msg, room.dial_number,
-                   room.logout_url, room.max_participants, room.voice_bridge).
-              exactly(10).times.
-              and_return(fail_hash)
-            room.send_create
+              with(new_room.name, new_room.meetingid, hash).and_return(hash_create)
+            new_room.server = mocked_server
+            new_room.send_create
           end
+          it { new_room.attendee_password.should be(attendee_password) }
+          it { new_room.moderator_password.should be(moderator_password) }
+          it("and do not save the record") { new_room.new_record?.should be_true }
         end
 
       end
 
-      describe "#join_url" do
-        let(:username) { Forgery(:name).full_name }
+      context "randomizes meetingid" do
+        let(:fail_hash) { { :returncode => true, :meetingID => "new id",
+            :messageKey => "duplicateWarning" } }
+        let(:success_hash) { { :returncode => true, :meetingID => "new id",
+            :messageKey => "" } }
+        let(:new_id) { "new id" }
+        before {
+          room.randomize_meetingid = true
+          room.server = mocked_server
+        }
 
-        it { should respond_to(:join_url) }
+        it "before calling create" do
+          room.should_receive(:random_meetingid).and_return(new_id)
+          hash = hash_including(:moderatorPW => room.moderator_password, :attendeePW => room.attendee_password,
+                                :welcome  => room.welcome_msg, :dialNumber => room.dial_number,
+                                :logoutURL => room.logout_url, :maxParticipants => room.max_participants,
+                                :voiceBridge => room.voice_bridge)
+          mocked_api.should_receive(:create_meeting).with(room.name, new_id, hash)
+          room.send_create
+        end
 
-        it "with moderator role" do
-          mocked_api.should_receive(:join_meeting_url).
-            with(room.meetingid, username, room.moderator_password)
-          room.server = mocked_server
-          room.join_url(username, :moderator)
+        it "and tries again on error" do
+          # fails twice and them succeds
+          room.should_receive(:random_meetingid).exactly(3).times.and_return(new_id)
+          hash = hash_including(:moderatorPW => room.moderator_password, :attendeePW => room.attendee_password,
+                                :welcome  => room.welcome_msg, :dialNumber => room.dial_number,
+                                :logoutURL => room.logout_url, :maxParticipants => room.max_participants,
+                                :voiceBridge => room.voice_bridge)
+          mocked_api.should_receive(:create_meeting).
+            with(room.name, new_id, hash).twice.and_return(fail_hash)
+          mocked_api.should_receive(:create_meeting).
+            with(room.name, new_id, hash).once.and_return(success_hash)
+          room.send_create
         end
 
-        it "with attendee role" do
-          mocked_api.should_receive(:join_meeting_url).
-            with(room.meetingid, username, room.attendee_password)
-          room.server = mocked_server
-          room.join_url(username, :attendee)
+        it "and limits to 10 tries" do
+          room.should_receive(:random_meetingid).exactly(11).times.and_return(new_id)
+          hash = hash_including(:moderatorPW => room.moderator_password, :attendeePW => room.attendee_password,
+                                :welcome  => room.welcome_msg, :dialNumber => room.dial_number,
+                                :logoutURL => room.logout_url, :maxParticipants => room.max_participants,
+                                :voiceBridge => room.voice_bridge)
+          mocked_api.should_receive(:create_meeting).
+            with(room.name, new_id, hash).exactly(10).times.and_return(fail_hash)
+          room.send_create
         end
+      end
 
-        it "without a role" do
-          mocked_api.should_receive(:join_meeting_url).
-            with(room.meetingid, username, 'pass')
+      context "uses #full_logout_url when set" do
+        before do
+          room.full_logout_url = "full-version-of-logout-url"
+          hash = hash_including(:moderatorPW => room.moderator_password, :attendeePW => room.attendee_password,
+                                :welcome  => room.welcome_msg, :dialNumber => room.dial_number,
+                                :logoutURL => "full-version-of-logout-url", :maxParticipants => room.max_participants,
+                                :voiceBridge => room.voice_bridge)
+          mocked_api.should_receive(:create_meeting).
+            with(room.name, room.meetingid, hash).and_return(hash_create)
           room.server = mocked_server
-          room.join_url(username, nil, 'pass')
         end
+        it { room.send_create }
       end
 
     end
 
-    context "validates passwords" do
-      context "for private rooms" do
-        let (:room) { Factory.build(:bigbluebutton_room, :private => true) }
-        it { room.should_not allow_value('').for(:moderator_password) }
-        it { room.should_not allow_value('').for(:attendee_password) }
-      end
+    describe "#join_url" do
+      let(:username) { Forgery(:name).full_name }
 
-      context "for public rooms" do
-        let (:room) { Factory.build(:bigbluebutton_room, :private => false) }
-        it { room.should allow_value('').for(:moderator_password) }
-        it { room.should allow_value('').for(:attendee_password) }
-      end
-    end
+      it { should respond_to(:join_url) }
 
-    describe "#add_domain_to_logout_url" do
-      context "when logout_url has a path only" do
-        let(:room) { Factory.create(:bigbluebutton_room, :logout_url => '/only/path') }
-        before(:each) { room.add_domain_to_logout_url("HTTP://", "test.com") }
-        it { room.logout_url.should == "http://test.com/only/path" }
+      it "with moderator role" do
+        mocked_api.should_receive(:join_meeting_url).
+          with(room.meetingid, username, room.moderator_password)
+        room.server = mocked_server
+        room.join_url(username, :moderator)
       end
 
-      context "when logout_url has a path and domain" do
-        let(:room) { Factory.create(:bigbluebutton_room, :logout_url => 'other.com/only/path') }
-        before(:each) { room.add_domain_to_logout_url("HTTP://", "test.com") }
-        it { room.logout_url.should == "http://other.com/only/path" }
+      it "with attendee role" do
+        mocked_api.should_receive(:join_meeting_url).
+          with(room.meetingid, username, room.attendee_password)
+        room.server = mocked_server
+        room.join_url(username, :attendee)
       end
 
-      context "when logout_url has a path, domain and protocol" do
-        let(:room) { Factory.create(:bigbluebutton_room, :logout_url => 'HTTPS://other.com/only/path') }
-        before(:each) { room.add_domain_to_logout_url("HTTP://", "test.com") }
-        it { room.logout_url.should == "https://other.com/only/path" }
+      it "without a role" do
+        mocked_api.should_receive(:join_meeting_url).
+          with(room.meetingid, username, 'pass')
+        room.server = mocked_server
+        room.join_url(username, nil, 'pass')
       end
+    end
 
-      context "does nothing if logout_url is nil" do
-        let(:room) { Factory.create(:bigbluebutton_room, :logout_url => nil) }
-        before(:each) { room.add_domain_to_logout_url("HTTP://", "test.com") }
-        it { room.logout_url.should == nil }
-      end
+  end
+
+  context "validates passwords" do
+    context "for private rooms" do
+      let (:room) { Factory.build(:bigbluebutton_room, :private => true) }
+      it { room.should_not allow_value('').for(:moderator_password) }
+      it { room.should_not allow_value('').for(:attendee_password) }
     end
 
-    describe "#perform_join" do
-      let(:room) { Factory.create(:bigbluebutton_room) }
-      let(:user) { Factory.build(:user) }
-
-      context "for an attendee" do
-        before { room.should_receive(:fetch_is_running?) }
-
-        context "when the conference is running" do
-          before {
-            room.should_receive(:is_running?).and_return(true)
-            room.should_receive(:join_url).with(user.name, :attendee).
-              and_return("http://test.com/attendee/join")
-          }
-          subject { room.perform_join(user.name, :attendee) }
-          it { should == "http://test.com/attendee/join" }
-        end
+    context "for public rooms" do
+      let (:room) { Factory.build(:bigbluebutton_room, :private => false) }
+      it { room.should allow_value('').for(:moderator_password) }
+      it { room.should allow_value('').for(:attendee_password) }
+    end
+  end
 
-        context "when the conference is not running" do
-          before { room.should_receive(:is_running?).and_return(false) }
-          subject { room.perform_join(user.name, :attendee) }
-          it { should be_nil }
-        end
+  describe "#add_domain_to_logout_url" do
+    context "when logout_url has a path only" do
+      let(:room) { Factory.create(:bigbluebutton_room, :logout_url => '/only/path') }
+      before(:each) { room.add_domain_to_logout_url("HTTP://", "test.com:80") }
+      it { room.full_logout_url.should == "http://test.com:80/only/path" }
+      it { room.logout_url.should == "/only/path" }
+      it { BigbluebuttonRoom.find(room.id).logout_url.should == "/only/path" }
+    end
+
+    context "when logout_url has a path and domain" do
+      let(:room) { Factory.create(:bigbluebutton_room, :logout_url => 'other.com/only/path') }
+      before(:each) { room.add_domain_to_logout_url("HTTP://", "test.com:80") }
+      it { room.full_logout_url.should == "http://other.com/only/path" }
+      it { room.logout_url.should == "other.com/only/path" }
+      it { BigbluebuttonRoom.find(room.id).logout_url.should == "other.com/only/path" }
+    end
+
+    context "when logout_url has a path, domain and protocol" do
+      let(:room) { Factory.create(:bigbluebutton_room, :logout_url => 'HTTPS://other.com/only/path') }
+      before(:each) { room.add_domain_to_logout_url("HTTP://", "test.com:80") }
+      it { room.full_logout_url.should == "https://other.com/only/path" }
+      it { room.logout_url.should == "HTTPS://other.com/only/path" }
+      it { BigbluebuttonRoom.find(room.id).logout_url.should == "HTTPS://other.com/only/path" }
+    end
+
+    context "does nothing if logout_url is nil" do
+      let(:room) { Factory.create(:bigbluebutton_room, :logout_url => nil) }
+      before(:each) { room.add_domain_to_logout_url("HTTP://", "test.com:80") }
+      it { room.full_logout_url.should be_nil }
+      it { room.logout_url.should be_nil }
+      it { BigbluebuttonRoom.find(room.id).logout_url.should be_nil }
+    end
+  end
+
+  describe "#perform_join" do
+    let(:room) { Factory.create(:bigbluebutton_room) }
+    let(:user) { Factory.build(:user) }
+
+    context "for an attendee" do
+      before { room.should_receive(:fetch_is_running?) }
+
+      context "when the conference is running" do
+        before {
+          room.should_receive(:is_running?).and_return(true)
+          room.should_receive(:join_url).with(user.name, :attendee).
+          and_return("http://test.com/attendee/join")
+        }
+        subject { room.perform_join(user.name, :attendee) }
+        it { should == "http://test.com/attendee/join" }
       end
 
-      context "for a moderator" do
-        before { room.should_receive(:fetch_is_running?) }
-
-        context "when the conference is running" do
-          before {
-            room.should_receive(:is_running?).and_return(true)
-            room.should_receive(:join_url).with(user.name, :moderator).
-              and_return("http://test.com/moderator/join")
-          }
-          subject { room.perform_join(user.name, :moderator) }
-          it { should == "http://test.com/moderator/join" }
-        end
+      context "when the conference is not running" do
+        before { room.should_receive(:is_running?).and_return(false) }
+        subject { room.perform_join(user.name, :attendee) }
+        it { should be_nil }
+      end
+    end
 
-        context "when the conference is not running" do
-          before {
-            room.should_receive(:is_running?).and_return(false)
-            room.should_receive(:send_create)
-            room.should_receive(:join_url).with(user.name, :moderator).
-              and_return("http://test.com/moderator/join")
-          }
-          subject { room.perform_join(user.name, :moderator) }
-          it { should == "http://test.com/moderator/join" }
-        end
+    context "for a moderator" do
+      before { room.should_receive(:fetch_is_running?) }
 
-        context "when the arg 'request' is informed" do
-          let(:request) { stub(ActionController::Request) }
-          before {
-            request.stub!(:protocol).and_return("HTTP://")
-            request.stub!(:host).and_return("test.com")
-            room.should_receive(:add_domain_to_logout_url).with("HTTP://", "test.com")
-            room.should_receive(:is_running?).and_return(true)
-            room.should_receive(:join_url).with(user.name, :moderator).
-              and_return("http://test.com/moderator/join")
-          }
-          subject { room.perform_join(user.name, :moderator, request) }
-          it { should == "http://test.com/moderator/join" }
-        end
+      context "when the conference is running" do
+        before {
+          room.should_receive(:is_running?).and_return(true)
+          room.should_receive(:join_url).with(user.name, :moderator).
+          and_return("http://test.com/moderator/join")
+        }
+        subject { room.perform_join(user.name, :moderator) }
+        it { should == "http://test.com/moderator/join" }
+      end
+
+      context "when the conference is not running" do
+        before {
+          room.should_receive(:is_running?).and_return(false)
+          room.should_receive(:send_create)
+          room.should_receive(:join_url).with(user.name, :moderator).
+          and_return("http://test.com/moderator/join")
+        }
+        subject { room.perform_join(user.name, :moderator) }
+        it { should == "http://test.com/moderator/join" }
+      end
 
+      context "when the arg 'request' is informed" do
+        let(:request) { stub(ActionController::Request) }
+        before {
+          request.stub!(:protocol).and_return("HTTP://")
+          request.stub!(:host_with_port).and_return("test.com:80")
+          room.should_receive(:add_domain_to_logout_url).with("HTTP://", "test.com:80")
+          room.should_receive(:is_running?).and_return(true)
+          room.should_receive(:join_url).with(user.name, :moderator).
+          and_return("http://test.com/moderator/join")
+        }
+        subject { room.perform_join(user.name, :moderator, request) }
+        it { should == "http://test.com/moderator/join" }
       end
 
     end
 
   end
 
+  describe "#full_logout_url" do
+    subject { BigbluebuttonRoom.new }
+    it { should respond_to(:full_logout_url) }
+    it { should respond_to(:"full_logout_url=") }
+  end
+
 end