bigbluebutton_rails 0.0.4 → 0.0.5

data/spec/controllers/bigbluebutton/rooms_controller_spec.rb

@@ -21,6 +21,7 @@ describe Bigbluebutton::RoomsController do
     it { should respond_with(:success) }
     it { should assign_to(:server).with(server) }
     it { should assign_to(:rooms).with(BigbluebuttonRoom.all) }
+    it { should render_template(:index) }
   end
 
   describe "#show" do
@@ -28,6 +29,7 @@ describe Bigbluebutton::RoomsController do
     it { should respond_with(:success) }
     it { should assign_to(:server).with(server) }
     it { should assign_to(:room).with(room) }
+    it { should render_template(:show) }
   end
 
   describe "#new" do
@@ -35,6 +37,7 @@ describe Bigbluebutton::RoomsController do
     it { should respond_with(:success) }
     it { should assign_to(:server).with(server) }
     it { should assign_to(:room).with_kind_of(BigbluebuttonRoom) }
+    it { should render_template(:new) }
   end
 
   describe "#edit" do
@@ -42,6 +45,25 @@ describe Bigbluebutton::RoomsController do
     it { should respond_with(:success) }
     it { should assign_to(:server).with(server) }
     it { should assign_to(:room).with(room) }
+    it { should render_template(:edit) }
+  end
+
+  describe "#join_mobile" do
+    let(:user) { Factory.build(:user) }
+    before {
+      mock_server_and_api
+      controller.stub(:bigbluebutton_user) { user }
+      controller.should_receive(:bigbluebutton_role).and_return(:moderator)
+      mocked_api.should_receive(:join_meeting_url).
+        with(room.meetingid, user.name, room.moderator_password).
+        and_return("http://join_url")
+    }
+    before(:each) { get :join_mobile, :server_id => mocked_server.to_param, :id => room.to_param }
+    it { should respond_with(:success) }
+    it { should assign_to(:server).with(mocked_server) }
+    it { should assign_to(:room).with(room) }
+    it { should assign_to(:join_url).with("bigbluebutton://join_url") }
+    it { should render_template(:join_mobile) }
   end
 
   describe "#create" do
@@ -112,7 +134,7 @@ describe Bigbluebutton::RoomsController do
 
   describe "#update" do
     let(:new_room) { Factory.build(:bigbluebutton_room) }
-    before { @room = room }
+    before { @room = room } # need this to trigger let(:room) and actually create the room
 
     context "on success" do
       before :each do
@@ -121,8 +143,9 @@ describe Bigbluebutton::RoomsController do
         }.not_to change{ BigbluebuttonRoom.count }
       end
       it {
+        saved = BigbluebuttonRoom.find(@room)
         should respond_with(:redirect)
-        should redirect_to bigbluebutton_server_room_path(server, @room)
+        should redirect_to bigbluebutton_server_room_path(server, saved)
       }
       it {
         saved = BigbluebuttonRoom.find(@room)
@@ -240,14 +263,24 @@ describe Bigbluebutton::RoomsController do
       }
     end
 
-    context "for a user without a role" do
+    context "when the user's role" do
       before { controller.stub(:bigbluebutton_user) { user } }
-      before { controller.stub(:bigbluebutton_role) { nil } }
-      before(:each) { get :join, :server_id => mocked_server.to_param, :id => room.to_param }
-      it {
-        should respond_with(:redirect)
-        should redirect_to(invite_bigbluebutton_server_room_path(mocked_server, room))
-      }
+
+      context "should be defined with a password" do
+        before { controller.stub(:bigbluebutton_role) { :password } }
+        before(:each) { get :join, :server_id => mocked_server.to_param, :id => room.to_param }
+        it { should respond_with(:redirect) }
+        it { should redirect_to(invite_bigbluebutton_server_room_path(mocked_server, room)) }
+      end
+
+      context "is undefined, the access should be blocked" do
+        before { controller.stub(:bigbluebutton_role) { nil } }
+        it {
+          lambda {
+            get :join, :server_id => mocked_server.to_param, :id => room.to_param
+          }.should raise_error(BigbluebuttonRails::RoomAccessDenied)
+        }
+      end
     end
 
     context do
@@ -289,6 +322,38 @@ describe Bigbluebutton::RoomsController do
                    room.logout_url, room.max_participants, room.voice_bridge)
             get :join, :server_id => mocked_server.to_param, :id => room.to_param
           end
+
+          context "adds the protocol/domain to logout_url" do
+            after :each do
+              get :join, :server_id => mocked_server.to_param, :id => room.to_param
+            end
+
+            it "when it doesn't have protocol neither domain" do
+              room.update_attributes(:logout_url => "/incomplete/url")
+              full_logout_url = "http://test.host" + room.logout_url
+
+              mocked_api.should_receive(:create_meeting).
+                with(anything, anything, anything, anything, anything, anything,
+                     full_logout_url, anything, anything)
+            end
+
+            it "when it doesn't have protocol only" do
+              room.update_attributes(:logout_url => "www.host.com/incomplete/url")
+              full_logout_url = "http://" + room.logout_url
+
+              mocked_api.should_receive(:create_meeting).
+                with(anything, anything, anything, anything, anything, anything,
+                     full_logout_url, anything, anything)
+            end
+
+            it "but not when it has a protocol defined" do
+              room.update_attributes(:logout_url => "http://with/protocol")
+              mocked_api.should_receive(:create_meeting).
+                with(anything, anything, anything, anything, anything, anything,
+                     room.logout_url, anything, anything)
+            end
+          end
+
         end
 
       end
@@ -359,6 +424,7 @@ describe Bigbluebutton::RoomsController do
     context "room is not running" do
       before { mocked_api.should_receive(:is_meeting_running?).and_return(false) }
       before(:each) { get :end, :server_id => mocked_server.to_param, :id => room.to_param }
+      it { should respond_with(:redirect) }
       it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.notice.end.not_running')) }
     end
   end
@@ -369,7 +435,7 @@ describe Bigbluebutton::RoomsController do
 
     context "for an anonymous user" do
       before { controller.stub(:bigbluebutton_user).and_return(nil) }
-      
+
       context "with a role defined" do
         before { controller.stub(:bigbluebutton_role).and_return(:attendee) }
         before(:each) { get :invite, :server_id => mocked_server.to_param, :id => room.to_param }
@@ -378,12 +444,23 @@ describe Bigbluebutton::RoomsController do
         it { should assign_to(:room).with(room) }
       end
 
-      context "without a role" do
-        before { controller.stub(:bigbluebutton_role).and_return(nil) }
-        before(:each) { get :invite, :server_id => mocked_server.to_param, :id => room.to_param }
-        it { should respond_with(:success) }
-        it { should render_template(:invite) }
-        it { should assign_to(:room).with(room) }
+      context "when the user's role" do
+        context "should be defined with a password" do
+          before { controller.stub(:bigbluebutton_role) { :password } }
+          before(:each) { get :invite, :server_id => mocked_server.to_param, :id => room.to_param }
+          it { should respond_with(:success) }
+          it { should render_template(:invite) }
+          it { should assign_to(:room).with(room) }
+        end
+
+        context "is undefined, the access should be blocked" do
+          before { controller.stub(:bigbluebutton_role) { nil } }
+          it {
+            lambda {
+              get :invite, :server_id => mocked_server.to_param, :id => room.to_param
+            }.should raise_error(BigbluebuttonRails::RoomAccessDenied)
+          }
+        end
       end
     end
 
@@ -397,12 +474,23 @@ describe Bigbluebutton::RoomsController do
         it { should redirect_to(join_bigbluebutton_server_room_path(mocked_server, room)) }
       end
 
-      context "without a role" do
-        before { controller.stub(:bigbluebutton_role).and_return(nil) }
-        before(:each) { get :invite, :server_id => mocked_server.to_param, :id => room.to_param }
-        it { should respond_with(:success) }
-        it { should render_template(:invite) }
-        it { should assign_to(:room).with(room) }
+      context "when the user's role" do
+        context "should be defined with a password" do
+          before { controller.stub(:bigbluebutton_role) { :password } }
+          before(:each) { get :invite, :server_id => mocked_server.to_param, :id => room.to_param }
+          it { should respond_with(:success) }
+          it { should render_template(:invite) }
+          it { should assign_to(:room).with(room) }
+        end
+
+        context "is undefined, the access should be blocked" do
+          before { controller.stub(:bigbluebutton_role) { nil } }
+          it {
+            lambda {
+              get :invite, :server_id => mocked_server.to_param, :id => room.to_param
+            }.should raise_error(BigbluebuttonRails::RoomAccessDenied)
+          }
+        end
       end
     end
 
@@ -415,6 +503,16 @@ describe Bigbluebutton::RoomsController do
       controller.stub(:bigbluebutton_user).and_return(nil)
     }
 
+    context "block access if bigbluebutton_role returns nil" do
+      let(:hash) { { :name => "Elftor", :password => room.attendee_password } }
+      before { controller.stub(:bigbluebutton_role) { nil } }
+      it {
+        lambda {
+          post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash
+        }.should raise_error(BigbluebuttonRails::RoomAccessDenied)
+      }
+    end
+
     context "if there's a user logged, should use it's name" do
       let(:hash) { { :name => "Elftor", :password => room.attendee_password } }
       it do
@@ -437,7 +535,7 @@ describe Bigbluebutton::RoomsController do
         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.error.auth.failure')) }
+        it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.errors.auth.failure')) }
       end
 
       context "the password is wrong" do
@@ -446,7 +544,7 @@ describe Bigbluebutton::RoomsController do
         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.error.auth.failure')) }
+        it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.errors.auth.failure')) }
       end
 
     end
@@ -487,7 +585,7 @@ describe Bigbluebutton::RoomsController do
           post :auth, :server_id => mocked_server.to_param, :id => room.to_param, :user => hash
           should respond_with(:success)
           should render_template(:invite)
-          should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.error.not_running'))
+          should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.errors.auth.not_running'))
         end
       end
 
@@ -545,6 +643,7 @@ describe Bigbluebutton::RoomsController do
     it { should assign_to(:server).with(server) }
   end
 
+  # make sure that the exceptions thrown by bigbluebutton-api-ruby are treated by the controller
   context "exception handling" do
     let(:bbb_error_msg) { "err msg" }
     let(:bbb_error) { BigBlueButton::BigBlueButtonException.new(bbb_error_msg) }
@@ -651,5 +750,165 @@ describe Bigbluebutton::RoomsController do
 
   end # exception handling
 
+  # verify all JSON responses
+  context "json responses for " do
+    describe "#index" do
+      before do
+        @room1 = Factory.create(:bigbluebutton_room, :server => server)
+        @room2 = Factory.create(:bigbluebutton_room, :server => server)
+      end
+      before(:each) { get :index, :server_id => server.to_param, :format => 'json' }
+      it { should respond_with(:success) }
+      it { should respond_with_content_type(:json) }
+      it { should respond_with_json([@room1, @room2].to_json) }
+    end
+
+    describe "#new" do
+      before(:each) { get :new, :server_id => server.to_param, :format => 'json' }
+      it { should respond_with(:success) }
+      it { should respond_with_content_type(:json) }
+      it {
+        # we ignore all values bc a BigbluebuttonRoom is generated with some
+        # random values (meetingid, voice_bridge)
+        should respond_with_json(BigbluebuttonRoom.new.to_json).ignoring_values
+      }
+    end
+
+    describe "#show" do
+      before(:each) { get :show, :server_id => server.to_param, :id => room.to_param, :format => 'json' }
+      it { should respond_with(:success) }
+      it { should respond_with_content_type(:json) }
+      it { should respond_with_json(room.to_json) }
+    end
+
+    describe "#create" do
+      let(:new_room) { Factory.build(:bigbluebutton_room, :server => server) }
+
+      context "on success" do
+        before(:each) {
+          post :create, :server_id => server.to_param, :bigbluebutton_room => new_room.attributes, :format => 'json'
+        }
+        it { should respond_with(:created) }
+        it { should respond_with_content_type(:json) }
+        it {
+          json = { :message => I18n.t('bigbluebutton_rails.rooms.notice.create.success') }.to_json
+          should respond_with_json(json)
+        }
+      end
+
+      context "on failure" do
+        before(:each) {
+          new_room.name = nil # invalid
+          post :create, :server_id => server.to_param, :bigbluebutton_room => new_room.attributes, :format => 'json'
+        }
+        it { should respond_with(:unprocessable_entity) }
+        it { should respond_with_content_type(:json) }
+        it {
+          new_room.save # should fail
+          should respond_with_json(new_room.errors.full_messages.to_json)
+        }
+      end
+    end
+
+    describe "#update" do
+      let(:new_room) { Factory.build(:bigbluebutton_room) }
+      before { @room = room }
+
+      context "on success" do
+        before(:each) {
+          put :update, :server_id => server.to_param, :id => @room.to_param, :bigbluebutton_room => new_room.attributes, :format => 'json'
+        }
+        it { should respond_with(:success) }
+        it { should respond_with_content_type(:json) }
+        it {
+          json = { :message => I18n.t('bigbluebutton_rails.rooms.notice.update.success') }.to_json
+          should respond_with_json(json)
+        }
+      end
+
+      context "on failure" do
+        before(:each) {
+          new_room.name = nil # invalid
+          put :update, :server_id => server.to_param, :id => @room.to_param, :bigbluebutton_room => new_room.attributes, :format => 'json'
+        }
+        it { should respond_with(:unprocessable_entity) }
+        it { should respond_with_content_type(:json) }
+        it {
+          new_room.save # should fail
+          should respond_with_json(new_room.errors.full_messages.to_json)
+        }
+      end
+    end
+
+    describe "#end" do
+      before { mock_server_and_api }
+
+      context "room is running" do
+        before {
+          mocked_api.should_receive(:is_meeting_running?).and_return(true)
+          mocked_api.should_receive(:end_meeting).with(room.meetingid, room.moderator_password)
+        }
+        before(:each) { get :end, :server_id => mocked_server.to_param, :id => room.to_param, :format => 'json' }
+        it { should respond_with(:success) }
+        it { should respond_with_content_type(:json) }
+        it { should respond_with_json(I18n.t('bigbluebutton_rails.rooms.notice.end.success')) }
+      end
+
+      context "room is not running" do
+        before { mocked_api.should_receive(:is_meeting_running?).and_return(false) }
+        before(:each) { get :end, :server_id => mocked_server.to_param, :id => room.to_param, :format => 'json' }
+        it { should respond_with(:error) }
+        it { should respond_with_content_type(:json) }
+        it { should respond_with_json(I18n.t('bigbluebutton_rails.rooms.notice.end.not_running')) }
+      end
+
+      context "throwing an exception" do
+        let(:msg) { "any error message" }
+        before {
+          mocked_api.should_receive(:is_meeting_running?).and_return{ raise BigBlueButton::BigBlueButtonException.new(msg) }
+        }
+        before(:each) { get :end, :server_id => mocked_server.to_param, :id => room.to_param, :format => 'json' }
+        it { should respond_with(:error) }
+        it { should respond_with_content_type(:json) }
+        it { should respond_with_json(msg) }
+      end
+
+    end
+
+    describe "#destroy" do
+      before { mock_server_and_api }
+
+      context "on success" do
+        before {
+          mocked_api.should_receive(:is_meeting_running?).and_return(true)
+          mocked_api.should_receive(:end_meeting)
+        }
+        before(:each) {
+          delete :destroy, :server_id => mocked_server.to_param, :id => room.to_param, :format => 'json'
+        }
+        it { should respond_with(:success) }
+        it { should respond_with_content_type(:json) }
+        it {
+          json = { :message => I18n.t('bigbluebutton_rails.rooms.notice.destroy.success') }.to_json
+          should respond_with_json(json)
+        }
+      end
+
+      context "throwing error" do
+        let(:msg) { "any error message" }
+        before {
+          mocked_api.should_receive(:is_meeting_running?).and_return{ raise BigBlueButton::BigBlueButtonException.new(msg) }
+        }
+        before(:each) {
+          delete :destroy, :server_id => mocked_server.to_param, :id => room.to_param, :format => 'json'
+        }
+        it { should respond_with(:error) }
+        it { should respond_with_content_type(:json) }
+        it { should respond_with_json({ :message => msg }.to_json) }
+      end
+    end
+
+  end # json responses
+
 end
 

data/spec/controllers/bigbluebutton/servers_controller_spec.rb

@@ -51,8 +51,9 @@ describe Bigbluebutton::ServersController do
       }.not_to change{ BigbluebuttonServer.count }
     end
     it {
+      saved = BigbluebuttonServer.find(@server)
       should respond_with(:redirect)
-      should redirect_to(bigbluebutton_server_path(@server))
+      should redirect_to(bigbluebutton_server_path(saved))
     }
     it {
       saved = BigbluebuttonServer.find(@server)
@@ -74,5 +75,96 @@ describe Bigbluebutton::ServersController do
     }
   end
 
+  # verify all JSON responses
+  context "json responses for " do
+
+    describe "#index" do
+      before do
+        @server1 = Factory.create(:bigbluebutton_server)
+        @server2 = Factory.create(:bigbluebutton_server)
+      end
+      before(:each) { get :index, :format => 'json' }
+      it { should respond_with(:success) }
+      it { should respond_with_content_type(:json) }
+      it { should respond_with_json([@server1, @server2].to_json) }
+    end
+
+    describe "#new" do
+      before(:each) { get :new, :format => 'json' }
+      it { should respond_with(:success) }
+      it { should respond_with_content_type(:json) }
+      it { should respond_with_json(BigbluebuttonServer.new.to_json).ignoring_values }
+    end
+
+    describe "#show" do
+      before(:each) { get :show, :id => server.to_param, :format => 'json' }
+      it { should respond_with(:success) }
+      it { should respond_with_content_type(:json) }
+      it { should respond_with_json(server.to_json) }
+    end
+
+    describe "#create" do
+      let(:new_server) { Factory.build(:bigbluebutton_server) }
+
+      context "on success" do
+        before(:each) {
+          post :create, :bigbluebutton_server => new_server.attributes, :format => 'json'
+        }
+        it { should respond_with(:created) }
+        it { should respond_with_content_type(:json) }
+        it { should respond_with_json(new_server.to_json).ignoring_attributes }
+      end
+
+      context "on failure" do
+        before(:each) {
+          new_server.url = nil # invalid
+          post :create, :bigbluebutton_server => new_server.attributes, :format => 'json'
+        }
+        it { should respond_with(:unprocessable_entity) }
+        it { should respond_with_content_type(:json) }
+        it {
+          new_server.save # should fail
+          should respond_with_json(new_server.errors.full_messages.to_json)
+        }
+      end
+    end
+
+    describe "#update" do
+      let(:new_server) { Factory.build(:bigbluebutton_server) }
+      before { @server = server }
+
+      context "on success" do
+        before(:each) {
+          put :update, :id => @server.to_param, :bigbluebutton_server => new_server.attributes, :format => 'json'
+        }
+        it { should respond_with(:success) }
+        it { should respond_with_content_type(:json) }
+      end
+
+      context "on failure" do
+        before(:each) {
+          new_server.url = nil # invalid
+          put :update, :id => @server.to_param, :bigbluebutton_server => new_server.attributes, :format => 'json'
+        }
+        it { should respond_with(:unprocessable_entity) }
+        it { should respond_with_content_type(:json) }
+        it {
+          new_server.save # should fail
+          should respond_with_json(new_server.errors.full_messages.to_json)
+        }
+      end
+    end
+
+    describe "#destroy" do
+      before :each do
+        @server = server
+        delete :destroy, :id => @server.to_param, :format => 'json'
+      end
+      it { should respond_with(:success) }
+      it { should respond_with_content_type(:json) }
+    end
+
+  end # json responses
+
 end
 

data/spec/factories/bigbluebutton_room.rb

@@ -7,4 +7,5 @@ Factory.define :bigbluebutton_room do |r|
   r.welcome_msg { Forgery(:lorem_ipsum).sentences(2) }
   r.private false
   r.randomize_meetingid false
+  r.sequence(:param) { |n| "meeting-#{n}" }
 end

data/spec/factories/bigbluebutton_server.rb

@@ -3,4 +3,5 @@ Factory.define :bigbluebutton_server do |s|
   s.sequence(:url) { |n| "http://bigbluebutton#{n}.test.com/bigbluebutton/api" }
   s.salt { Forgery(:basic).password :at_least => 30, :at_most => 40 }
   s.version '0.7'
+  s.sequence(:param) { |n| "server-#{n}" }
 end

data/spec/factories/integration/bigbluebutton_server_integration.rb

@@ -0,0 +1,8 @@
+IntegrationConf.load
+config = IntegrationConf.config["server"]
+
+Factory.define :bigbluebutton_server_integration, :parent => :bigbluebutton_server do |s|
+  s.url { config["url"] }
+  s.salt { config["salt"] }
+  s.version { config["version"] }
+end

data/spec/generators/install_generator_spec.rb

@@ -5,19 +5,62 @@ describe BigbluebuttonRails::Generators::InstallGenerator do
   destination File.expand_path("../../../tmp", __FILE__)
   tests BigbluebuttonRails::Generators::InstallGenerator
 
-  before(:all) do
-    prepare_destination
-    run_generator
+  context "standard install" do
+    before(:all) do
+      prepare_destination
+      run_generator
+    end
+
+    it "all files are properly created" do
+      assert_migration "db/migrate/create_bigbluebutton_rails.rb"
+      assert_file "config/locales/bigbluebutton_rails.en.yml"
+      assert_file "public/stylesheets/bigbluebutton_rails.css"
+      assert_file "public/javascripts/jquery.min.js"
+      assert_file "public/images/loading.gif"
+    end
+
+    it "all files are properly destroyed" do
+      run_generator %w(), :behavior => :revoke
+      assert_no_file "config/locales/bigbluebutton_rails.en.yml"
+      assert_no_migration "db/migrate/create_bigbluebutton_rails.rb"
+      assert_no_file "public/stylesheets/bigbluebutton_rails.css"
+      assert_no_file "public/javascripts/jquery.min.js"
+      assert_no_file "public/images/loading.gif"
+    end
   end
 
-  it "all files are properly created" do
-    assert_migration "db/migrate/create_bigbluebutton_rails.rb"
-    assert_file "config/locales/bigbluebutton_rails.en.yml"
+  context "setting migration-only" do
+    before(:all) do
+      prepare_destination
+      run_generator %w{ --migration-only }
+    end
+
+    it "only the migration is created" do
+      assert_migration "db/migrate/create_bigbluebutton_rails.rb"
+      assert_no_file "config/locales/bigbluebutton_rails.en.yml"
+      assert_no_file "public/stylesheets/bigbluebutton_rails.css"
+      assert_no_file "public/javascripts/jquery.min.js"
+      assert_no_file "public/images/loading.gif"
+    end
   end
 
-  it "all files are properly destroyed" do
-    run_generator %w(), :behavior => :revoke
-    assert_no_file "config/locales/bigbluebutton_rails.en.yml"
-    assert_no_migration "db/migrate/create_bigbluebutton_rails.rb"
+  context "migrating to version" do
+    before { prepare_destination }
+
+    ["0.0.4", "0.0.5"].each do |version|
+      context "#{version}" do
+        before { run_generator [ version ] }
+
+        it "all files are properly created" do
+          assert_migration "db/migrate/bigbluebutton_rails_to_#{version.gsub(".", "_")}.rb"
+        end
+
+        it "all files are properly destroyed" do
+          run_generator [ version ], :behavior => :revoke
+          assert_no_migration "db/migrate/bigbluebutton_rails_to_#{version.gsub(".", "_")}.rb"
+        end
+      end
+    end
   end
+
 end

data/spec/generators/views_generator_spec.rb

@@ -30,14 +30,18 @@ describe BigbluebuttonRails::Generators::ViewsGenerator do
 
   def assert_files(assert_exists=true, scope="bigbluebutton")
     files = [
-      "app/views/#{scope}/rooms/edit.html.erb",
       "app/views/#{scope}/rooms/_form.html.erb",
+      "app/views/#{scope}/rooms/edit.html.erb",
       "app/views/#{scope}/rooms/index.html.erb",
+      "app/views/#{scope}/rooms/invite.html.erb",
       "app/views/#{scope}/rooms/join.html.erb",
+      "app/views/#{scope}/rooms/join_mobile.html.erb",
       "app/views/#{scope}/rooms/new.html.erb",
       "app/views/#{scope}/rooms/show.html.erb",
-      "app/views/#{scope}/servers/edit.html.erb",
+      "app/views/#{scope}/servers/_activity_list.html.erb",
       "app/views/#{scope}/servers/_form.html.erb",
+      "app/views/#{scope}/servers/activity.html.erb",
+      "app/views/#{scope}/servers/edit.html.erb",
       "app/views/#{scope}/servers/index.html.erb",
       "app/views/#{scope}/servers/new.html.erb",
       "app/views/#{scope}/servers/show.html.erb"

data/spec/helpers/bigbluebutton_rails_helper_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe BigbluebuttonRailsHelper do
+
+  describe "#qrcode_url" do
+    let(:url) { "http://www.google.com" }
+    let(:size) { "55x55" }
+
+    subject { qrcode_url(url, size) }
+
+    it("uses google charts api") { should match /https:\/\/chart.googleapis.com\/chart\?cht=qr/ }
+    it("uses encoded content") { should match /chl=#{CGI::escape(url)}/ }
+    it("uses size") { should match /chs=#{size}/ }
+    it("uses UTF-8") { should match /choe=UTF-8/ }
+  end
+
+end
+
+