bigbluebutton_rails 2.2.0 → 2.3.0

data/spec/controllers/bigbluebutton/recordings_controller_spec.rb

@@ -273,6 +273,90 @@ describe Bigbluebutton::RecordingsController do
       before(:each) { get :play, :id => recording.to_param, :type => format.format_type }
       it { should assign_to(:recording).with(other_recording) }
     end
+
+    context "authenticates" do
+      let!(:format) { FactoryGirl.create(:bigbluebutton_playback_format, :recording => recording) }
+
+      before { @previous = BigbluebuttonRails.configuration.playback_url_authentication }
+      after { BigbluebuttonRails.configuration.playback_url_authentication = @previous }
+
+      context "if authentication is enabled" do
+        before {
+          BigbluebuttonRails.configuration.playback_url_authentication = true
+          controller.should_receive(:bigbluebutton_user).and_return('fake-user')
+          BigbluebuttonRecording.any_instance.should_receive(:token_url)
+            .with('fake-user', request.remote_ip, format)
+            .and_return('tokenized-url')
+        }
+        before(:each) { get :play, :id => recording.to_param, :type => format.format_type }
+        it { should respond_with(:redirect) }
+        it { should redirect_to 'tokenized-url' }
+        it { should assign_to(:playback_url).with('tokenized-url') }
+      end
+
+      context "if authentication is not enabled" do
+        before {
+          BigbluebuttonRails.configuration.playback_url_authentication = false
+          BigbluebuttonRecording.any_instance.should_not_receive(:token_url)
+        }
+        before(:each) { get :play, :id => recording.to_param, :type => format.format_type }
+        it { should respond_with(:redirect) }
+        it { should redirect_to format.url }
+        it { should assign_to(:playback_url).with(format.url) }
+      end
+    end
+
+    context "uses an iframe" do
+      let!(:format) { FactoryGirl.create(:bigbluebutton_playback_format, :recording => recording) }
+
+      before { @previous = BigbluebuttonRails.configuration.playback_iframe }
+      after { BigbluebuttonRails.configuration.playback_iframe = @previous }
+
+      context "if the iframe option is on" do
+        before { BigbluebuttonRails.configuration.playback_iframe = true }
+
+        context "and it is downloadable" do
+          before {
+            format.playback_type.update_attributes(downloadable: true)
+            get :play, :id => recording.to_param, :type => format.format_type
+          }
+          it { should respond_with(:redirect) }
+          it { should redirect_to format.url }
+        end
+
+        context "and it is not downloadable" do
+          before {
+            format.playback_type.update_attributes(downloadable: false)
+            get :play, :id => recording.to_param, :type => format.format_type
+          }
+          it { should respond_with(:success) }
+          it { should render_template(:play) }
+          it { should_not render_with_layout }
+        end
+      end
+
+      context "if the iframe option is off" do
+        before { BigbluebuttonRails.configuration.playback_iframe = false }
+
+        context "and it is downloadable" do
+          before {
+            format.playback_type.update_attributes(downloadable: true)
+            get :play, :id => recording.to_param, :type => format.format_type
+          }
+          it { should respond_with(:redirect) }
+          it { should redirect_to format.url }
+        end
+
+        context "and it is not downloadable" do
+          before {
+            format.playback_type.update_attributes(downloadable: false)
+            get :play, :id => recording.to_param, :type => format.format_type
+          }
+          it { should respond_with(:redirect) }
+          it { should redirect_to format.url }
+        end
+      end
+    end
   end
 
   # these actions are essentially the same

data/spec/controllers/bigbluebutton/rooms_controller_exception_handling_spec.rb

@@ -10,7 +10,7 @@ describe Bigbluebutton::RoomsController do
     let(:http_referer) { bigbluebutton_server_path(mocked_server) }
     let(:room) { FactoryGirl.create(:bigbluebutton_room) }
     before {
-      BigbluebuttonRoom.stub(:find_by_param) { room }
+      BigbluebuttonRoom.stub(:find_by) { room }
       BigbluebuttonRoom.stub(:find) { room }
       mock_server_and_api
       request.env["HTTP_REFERER"] = http_referer
@@ -69,7 +69,7 @@ describe Bigbluebutton::RoomsController do
         before {
           controller.should_receive(:bigbluebutton_role).with(room).and_return(:moderator)
           room.stub(:select_server).and_return(mocked_server)
-          BigbluebuttonRoom.stub(:find_by_param).and_return(room)
+          BigbluebuttonRoom.stub(:find_by).and_return(room)
         }
 
         it "catches exception on the first is_meeting_running" do

data/spec/controllers/bigbluebutton/rooms_controller_spec.rb

@@ -307,7 +307,7 @@ describe Bigbluebutton::RoomsController do
       it {
         # we just check that the rails method 'permit' is being called on the hash with the
         # correct parameters
-        BigbluebuttonRoom.stub(:find_by_param).and_return(room)
+        BigbluebuttonRoom.stub(:find_by).and_return(room)
         room.stub(:update_attributes).and_return(true)
         attrs.stub(:permit).and_return(attrs)
         controller.stub(:params).and_return(params)
@@ -476,7 +476,7 @@ describe Bigbluebutton::RoomsController do
           context "if params[:id] doesn't exists" do
             let(:message) { I18n.t('bigbluebutton_rails.rooms.errors.join.wrong_params') }
             before(:each) {
-              BigbluebuttonRoom.stub(:find_by_param).and_return(nil)
+              BigbluebuttonRoom.stub(:find_by).and_return(nil)
               send(method, :join, :id => "inexistent-room-id", :user => user_hash)
             }
             it { should assign_to(:room).with(nil) }
@@ -801,6 +801,15 @@ describe Bigbluebutton::RoomsController do
       it { should set_the_flash.to(I18n.t('bigbluebutton_rails.rooms.notice.fetch_recordings.success')) }
     end
 
+    context "responds to :json" do
+      before(:each) {
+        mocked_server.should_receive(:fetch_recordings).with(filter)
+        post :fetch_recordings, :id => room.to_param, :format => :json
+      }
+      it { should respond_with(:success) }
+      it { should respond_with_content_type('application/json') }
+    end
+
     context "on BigBlueButtonException" do
       let(:bbb_error_msg) { SecureRandom.hex(250) }
       let(:bbb_error) { BigBlueButton::BigBlueButtonException.new(bbb_error_msg) }
@@ -930,7 +939,7 @@ describe Bigbluebutton::RoomsController do
     # uses any action that triggers this before filter
     context "when @room is valid" do
       before {
-        BigbluebuttonRoom.stub(:find_by_param).and_return(room)
+        BigbluebuttonRoom.stub(:find_by).and_return(room)
         room.should_receive(:fetch_is_running?).and_return(false)
       }
       it {
@@ -969,28 +978,22 @@ describe Bigbluebutton::RoomsController do
       request.env["HTTP_REFERER"] = http_referer
       controller.stub(:bigbluebutton_user).and_return(user)
       controller.stub(:bigbluebutton_role).and_return(:attendee)
-      BigbluebuttonRoom.stub(:find_by_param).and_return(room)
+      BigbluebuttonRoom.stub(:find_by).and_return(room)
       controller.send(:find_room)
     }
 
     context "when the user has permission to create the meeting" do
-
-      context "in the standard case" do
-        before {
-          room.should_receive(:fetch_is_running?).at_least(:once).and_return(false)
-          controller.stub(:bigbluebutton_can_create?).with(room, :attendee)
-            .and_return(true)
-          controller.stub(:bigbluebutton_create_options).with(room)
-            .and_return({ custom: true })
-          room.should_receive(:create_meeting)
-            .with(user, controller.request, { custom: true }).and_return(true)
-          room.should_receive(:fetch_new_token).and_return(nil)
-          room.should_receive(:join_url).and_return("http://test.com/join/url/")
-        }
-        before(:each) { get :join, :id => room.to_param }
-        it { should respond_with(:redirect) }
-        it { should redirect_to("http://test.com/join/url/") }
-      end
+      before {
+        room.should_receive(:fetch_is_running?).at_least(:once).and_return(false)
+        controller.stub(:bigbluebutton_can_create?).with(room, :attendee).and_return(true)
+        room.should_receive(:create_meeting)
+          .with(user, controller.request).and_return(true)
+        room.should_receive(:fetch_new_token).and_return(nil)
+        room.should_receive(:join_url).and_return("http://test.com/join/url/")
+      }
+      before(:each) { get :join, :id => room.to_param }
+      it { should respond_with(:redirect) }
+      it { should redirect_to("http://test.com/join/url/") }
     end
 
     context "when the user doesn't have permission to create the meeting" do
@@ -1194,7 +1197,6 @@ describe Bigbluebutton::RoomsController do
     context "doesn't break if a guest user has permission to create a meeting" do
       before {
         room.stub(:fetch_is_running?).and_return(false)
-        controller.stub(:bigbluebutton_create_options).and_return({ custom: true })
         controller.stub(:bigbluebutton_can_create?).and_return(true)
         room.stub(:create_meeting).and_return(true)
         controller.stub(:bigbluebutton_user).and_return(nil)

data/spec/controllers/bigbluebutton/servers_controller_spec.rb

@@ -469,6 +469,15 @@ describe Bigbluebutton::ServersController do
       it { should set_the_flash.to(I18n.t('bigbluebutton_rails.servers.notice.fetch_recordings.success')) }
     end
 
+    context "responds to :json" do
+      before(:each) {
+        server.should_receive(:fetch_recordings).with({})
+        post :fetch_recordings, :id => server.to_param, :format => :json
+      }
+      it { should respond_with(:success) }
+      it { should respond_with_content_type('application/json') }
+    end
+
     context "on failure" do
       let(:bbb_error_msg) { SecureRandom.hex(250) }
       let(:bbb_error) { BigBlueButton::BigBlueButtonException.new(bbb_error_msg) }

data/spec/factories/bigbluebutton_attendee.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :bigbluebutton_attendee do |a|
+    a.sequence(:user_id) { |n| "userid-#{n}" }
+    a.sequence(:user_name) { |n| "User Full Name #{n}" }
+    a.association :meeting, :factory => :bigbluebutton_meeting
+  end
+end

data/spec/factories/bigbluebutton_meeting.rb

@@ -6,7 +6,6 @@ FactoryGirl.define do
     m.recorded false
     m.running false
     m.ended false
-    m.start_time { Time.at(Time.now.to_i + rand(999999)) }
     m.create_time { Time.now.to_i + rand(999999) }
     # m.creator_id
     # m.creator_name

data/spec/factories/bigbluebutton_playback_type.rb

@@ -3,5 +3,6 @@ FactoryGirl.define do
     pbt.sequence(:identifier) { |n| "#{Forgery(:name).first_name.downcase}-#{n}" }
     pbt.visible true
     pbt.default false
+    pbt.downloadable false
   end
 end

data/spec/factories/bigbluebutton_recording.rb

@@ -6,8 +6,8 @@ FactoryGirl.define do
     r.meetingid { "meeting" + SecureRandom.hex(8) }
     r.sequence(:name) { |n| "Rec #{n}" }
     r.published true
-    r.start_time { Time.now - rand(5).hours }
-    r.end_time { Time.now + rand(5).hours }
+    r.start_time { Time.now.to_i - rand(5).hours }
+    r.end_time { Time.now.to_i + rand(5).hours }
     # TODO: should contain the meeting's start_time at the end
     r.sequence(:recordid) { |n| "rec#{n}-#{SecureRandom.uuid}-#{DateTime.now.to_i}" }
     r.size { rand((20*1024**2)..(500*1024**2)) } # size ranging from 20Mb to 500Mb
@@ -17,8 +17,6 @@ FactoryGirl.define do
     after(:create) do |r|
       r.updated_at = r.updated_at.change(:usec => 0)
       r.created_at = r.created_at.change(:usec => 0)
-      r.start_time = r.start_time.change(:usec => 0)
-      r.end_time = r.end_time.change(:usec => 0)
     end
   end
 end

data/spec/helpers/bigbluebutton_rails_helper_spec.rb

@@ -14,6 +14,14 @@ describe BigbluebuttonRailsHelper do
     it("uses UTF-8") { should match /choe=UTF-8/ }
   end
 
-end
-
+  describe "#api_typeof" do
+    it { api_type_of(FactoryGirl.create(:bigbluebutton_room)).should eql('room') }
+    it { api_type_of(FactoryGirl.create(:bigbluebutton_server)).should eql('server') }
+    it { api_type_of(FactoryGirl.create(:bigbluebutton_recording)).should eql('recording') }
 
+    context "for a new class" do
+      class MyUserClass; end
+      it { api_type_of(MyUserClass.new).should eql('my-user-class') }
+    end
+  end
+end

data/spec/lib/bigbluebutton_rails/background_tasks_spec.rb

@@ -4,6 +4,7 @@ describe BigbluebuttonRails::BackgroundTasks do
 
   describe ".finish_meetings" do
     let!(:api) { double(BigBlueButton::BigBlueButtonApi) }
+    let!(:server) { FactoryGirl.create(:bigbluebutton_server) }
 
     context "set meetings that ended as not running and ended" do
       let(:room) { FactoryGirl.create(:bigbluebutton_room) }

data/spec/lib/tasks/meetings_rake_spec.rb

@@ -15,4 +15,4 @@ describe "bigbluebutton_rails:meetings:finish" do
     subject.invoke
     BigbluebuttonRails::BackgroundTasks.should have_received(:finish_meetings)
   end
-end
+end

data/spec/models/bigbluebutton_attendee_spec.rb

@@ -0,0 +1,44 @@
+# coding: utf-8
+require 'spec_helper'
+
+describe BigbluebuttonAttendee do
+  it "loaded correctly" do
+    BigbluebuttonAttendee.new.should be_a_kind_of(ActiveRecord::Base)
+  end
+
+  before { FactoryGirl.create(:bigbluebutton_attendee) }
+
+  context "gets params from hash" do
+    let(:hash) { {:userID=>"user_id", :fullName=>"House M.D.", :role=>"MODERATOR"} }
+    let(:attendee) { BigbluebuttonAttendee.new }
+
+    it "standard case" do
+      attendee.from_hash(hash)
+      attendee.user_id.should == "user_id"
+      attendee.user_name.should == "House M.D."
+      attendee.role.should == :moderator
+    end
+
+    it "converts user_id to string" do
+      hash[:userID] = 123
+      attendee.from_hash(hash)
+      attendee.user_id.should == "123"
+    end
+
+    it "role is not case sensitive" do
+      hash[:role] = "mODErAtOR"
+      attendee.from_hash(hash)
+      attendee.role.should == :moderator
+    end
+
+    it "any role other than 'moderator' is attendee" do
+      hash[:role] = "VIEWER"
+      attendee.from_hash(hash)
+      attendee.role.should == :attendee
+
+      hash[:role] = "whatever"
+      attendee.from_hash(hash)
+      attendee.role.should == :attendee
+    end
+  end
+end

data/spec/models/bigbluebutton_meeting_db_spec.rb

@@ -7,7 +7,6 @@ describe BigbluebuttonMeeting do
     it { should have_db_column(:room_id).of_type(:integer) }
     it { should have_db_column(:meetingid).of_type(:string) }
     it { should have_db_column(:name).of_type(:string) }
-    it { should have_db_column(:start_time).of_type(:datetime) }
     it { should have_db_column(:running).of_type(:boolean) }
     it { should have_db_column(:recorded).of_type(:boolean) }
     it { should have_db_column(:creator_id).of_type(:integer) }

data/spec/models/bigbluebutton_meeting_spec.rb

@@ -19,6 +19,7 @@ describe BigbluebuttonMeeting do
   it { should validate_presence_of(:create_time) }
   it { should validate_uniqueness_of(:create_time).scoped_to(:room_id) }
 
+
   describe "#created_by?" do
     let(:target) { FactoryGirl.create(:bigbluebutton_meeting) }
 

data/spec/models/bigbluebutton_playback_format_spec.rb

@@ -22,6 +22,8 @@ describe BigbluebuttonPlaybackFormat do
   it { should delegate_method(:default).to(:playback_type) }
   it { should delegate_method(:default?).to(:playback_type) }
   it { should delegate_method(:description).to(:playback_type) }
+  it { should delegate_method(:downloadable).to(:playback_type) }
+  it { should delegate_method(:downloadable?).to(:playback_type) }
 
   context "allows nil for delegates to playback_type" do
     let(:target) { FactoryGirl.create(:bigbluebutton_playback_format, playback_type: nil) }

data/spec/models/bigbluebutton_playback_type_db_spec.rb

@@ -9,6 +9,7 @@ describe BigbluebuttonPlaybackType do
     it { should have_db_column(:default).of_type(:boolean) }
     it { should have_db_column(:created_at).of_type(:datetime) }
     it { should have_db_column(:updated_at).of_type(:datetime) }
+    it { should have_db_column(:downloadable).of_type(:boolean) }
   end
 
 end

data/spec/models/bigbluebutton_recording_db_spec.rb

@@ -10,8 +10,8 @@ describe BigbluebuttonRecording do
     it { should have_db_column(:meetingid).of_type(:string) }
     it { should have_db_column(:name).of_type(:string) }
     it { should have_db_column(:published).of_type(:boolean) }
-    it { should have_db_column(:start_time).of_type(:datetime) }
-    it { should have_db_column(:end_time).of_type(:datetime) }
+    it { should have_db_column(:start_time).of_type(:integer) }
+    it { should have_db_column(:end_time).of_type(:integer) }
     it { should have_db_column(:available).of_type(:boolean) }
     it { should have_db_column(:description).of_type(:string) }
     it { should have_db_column(:created_at).of_type(:datetime) }

data/spec/models/bigbluebutton_recording_spec.rb

@@ -48,6 +48,43 @@ describe BigbluebuttonRecording do
     }
   end
 
+  describe "#get_token" do
+    it { should respond_to(:get_token) }
+
+    let!(:recording) { FactoryGirl.create(:bigbluebutton_recording) }
+    let!(:type_default) { FactoryGirl.create(:bigbluebutton_playback_type, default: true) }
+    let!(:server) { FactoryGirl.create(:bigbluebutton_server) }
+    let(:user) { FactoryGirl.build(:user) }
+    let(:user_ip) { "10.0.0.1" }
+    let(:api) { double(BigBlueButton::BigBlueButtonApi) }
+
+    before do
+      BigbluebuttonServer.any_instance.stub(:api).and_return(api)
+      api.stub(:send_api_request).and_return({:returncode=>true, :token=>"RECORDING_TOKEN", :messageKey=>"", :message=>""})
+    end
+
+    it  { recording.get_token(user, user_ip).should include("RECORDING_TOKEN") }
+  end
+
+  describe "#token_url" do
+    it { should respond_to(:token_url) }
+
+    let!(:recording) { FactoryGirl.create(:bigbluebutton_recording) }
+    let!(:type_default) { FactoryGirl.create(:bigbluebutton_playback_type, default: true) }
+    let!(:server) { FactoryGirl.create(:bigbluebutton_server) }
+    let(:user) { FactoryGirl.build(:user) }
+    let(:user_ip) { "10.0.0.1" }
+    let!(:format) { FactoryGirl.create(:bigbluebutton_playback_format, recording: recording, playback_type: type_default) }
+    let(:api) { double(BigBlueButton::BigBlueButtonApi) }
+
+    before do
+      BigbluebuttonServer.any_instance.stub(:api).and_return(api)
+      api.stub(:send_api_request).and_return({:returncode=>true, :token=>"RECORDING_TOKEN", :messageKey=>"", :message=>""})
+    end
+
+    it  { recording.token_url(user, user_ip, format).should include("?token=RECORDING_TOKEN") }
+  end
+
   describe "#default_playback_format" do
     let!(:recording) { FactoryGirl.create(:bigbluebutton_recording) }
     let!(:type_default) { FactoryGirl.create(:bigbluebutton_playback_type, default: true) }
@@ -66,6 +103,26 @@ describe BigbluebuttonRecording do
     end
   end
 
+  describe "#delete_from_server" do
+    let!(:recording) { FactoryGirl.create(:bigbluebutton_recording) }
+
+    context "when there's a server associated" do
+      let!(:server) { FactoryGirl.create(:bigbluebutton_server) }
+      before {
+        recording.update_attributes(server: server)
+        server.should_receive(:send_delete_recordings).with(recording.recordid).and_return('response')
+      }
+      it { recording.delete_from_server!.should eql('response') }
+    end
+
+    context "when there's no server associated" do
+      before {
+        recording.update_attributes(server: nil)
+      }
+      it { recording.delete_from_server!.should be(false) }
+    end
+  end
+
   describe ".overall_average_length" do
     context "when there's no recording" do
       it { BigbluebuttonRecording.overall_average_length.should eql(0) }
@@ -98,36 +155,221 @@ describe BigbluebuttonRecording do
     end
   end
 
+  describe ".recording_changed?" do
+    let!(:data) {
+      {
+        recordid: "recording-1",
+        meetingid: "meetingid-1",
+        name: "Evening Class1",
+        published: true,
+        start_time: DateTime.now,
+        end_time: DateTime.now + 2.hours,
+        size: "100",
+        metadata: {
+          course: "Fundamentals of JAVA",
+          description: "List of recordings",
+          activity: "Evening Class1"
+        },
+        playback: { format:
+          [
+           { type: "slides",
+             url: "http://test-install.blindsidenetworks.com/playback/slides/playback.html?meetingId=125468758b24fa27551e7a065849dda3ce65dd32-1329872486268",
+             length: 64
+           },
+           { type: "presentation",
+             url: "http://test-install.blindsidenetworks.com/presentation/slides/playback.html?meetingId=125468758b24fa27551e7a065849dda3ce65dd32-1329872486268",
+             length: 64
+           }
+          ]
+        }
+      }
+    }
+    let!(:recording) {
+      attrs = {
+        recordid: data[:recordid],
+        meetingid: data[:meetingid],
+        name: data[:name],
+        published: data[:published],
+        start_time: data[:start_time],
+        end_time: data[:end_time],
+        size: data[:size]
+      }
+      r = FactoryGirl.create(:bigbluebutton_recording, attrs)
+      data[:metadata].each do |k, v|
+        BigbluebuttonMetadata.create(owner: r, name: k, content: v)
+      end
+      data[:playback][:format].each do |format|
+        type = BigbluebuttonPlaybackType.create(visible: true, identifier: format[:type])
+        BigbluebuttonPlaybackFormat.create(recording: r, url: format[:url], length: format[:length], playback_type: type)
+      end
+      r
+    }
+
+    it "returns false when they didn't changed" do
+      BigbluebuttonRecording.recording_changed?(recording, data).should be(false)
+    end
+
+    context "returns true when an attribute changed" do
+      it "in the data" do
+        data[:published] = !data[:published]
+        BigbluebuttonRecording.recording_changed?(recording, data).should be(true)
+      end
+
+      it "in the database" do
+        recording.update(published: !recording.published)
+        BigbluebuttonRecording.recording_changed?(recording, data).should be(true)
+      end
+    end
+
+    context "returns true when a metadata" do
+      context "changed" do
+        it "in the data" do
+          data[:metadata][:course] = data[:metadata][:course] + "-changed"
+          BigbluebuttonRecording.recording_changed?(recording, data).should be(true)
+        end
+
+        it "in the database" do
+          recording.metadata.first.update(content: recording.metadata.first.content + "-changed")
+          BigbluebuttonRecording.recording_changed?(recording, data).should be(true)
+        end
+      end
+
+      context "was added" do
+        it "in the data" do
+          data[:metadata][:new_one] = "anything"
+          BigbluebuttonRecording.recording_changed?(recording, data).should be(true)
+        end
+
+        it "in the database" do
+          BigbluebuttonMetadata.create(owner: recording, name: "new", content: "anything")
+          BigbluebuttonRecording.recording_changed?(recording, data).should be(true)
+        end
+      end
+
+      context "was removed" do
+        it "in the data" do
+          data[:metadata].delete(:course)
+          BigbluebuttonRecording.recording_changed?(recording, data).should be(true)
+        end
+
+        it "in the database" do
+          recording.metadata.first.destroy
+          BigbluebuttonRecording.recording_changed?(recording, data).should be(true)
+        end
+      end
+    end
+
+    context "returns true when a playback format" do
+      context "changed" do
+        it "in the data" do
+          data[:playback][:format][0][:url] = data[:playback][:format][0][:url] + "/changed"
+          BigbluebuttonRecording.recording_changed?(recording, data).should be(true)
+        end
+
+        it "in the database" do
+          recording.playback_formats.first.update(url: recording.playback_formats.first.url + "/changed")
+          BigbluebuttonRecording.recording_changed?(recording, data).should be(true)
+        end
+      end
+
+      context "was added" do
+        it "in the data" do
+          data[:playback][:format] << {
+            type: "new-format",
+            url: "http://anything.here",
+            length: 64
+          }
+          BigbluebuttonRecording.recording_changed?(recording, data).should be(true)
+        end
+
+        it "in the database" do
+          type = BigbluebuttonPlaybackType.create(visible: true, identifier: "new-format-db")
+          BigbluebuttonPlaybackFormat.create(recording: recording, url: "anything", length: 12, playback_type: type)
+          BigbluebuttonRecording.recording_changed?(recording, data).should be(true)
+        end
+      end
+
+      context "was removed" do
+        it "in the data" do
+          data[:playback][:format] = data[:playback][:format].drop(1)
+          BigbluebuttonRecording.recording_changed?(recording, data).should be(true)
+        end
+
+        it "in the database" do
+          recording.playback_formats.first.destroy
+          BigbluebuttonRecording.recording_changed?(recording, data).should be(true)
+        end
+      end
+    end
+
+    context "ignores ignored keys" do
+      it "in the data" do
+        data[:random] = "anything"
+        BigbluebuttonRecording.recording_changed?(recording, data).should be(false)
+      end
+
+      it "in the database" do
+        recording.available = !recording.available
+        BigbluebuttonRecording.recording_changed?(recording, data).should be(false)
+      end
+    end
+
+    it "ignores the ordering of the elements in the inputs" do
+      data[:playback][:format] = data[:playback][:format].reverse
+      BigbluebuttonRecording.recording_changed?(recording, data).should be(false)
+    end
+
+    context "works when there are no formats" do
+      it "in the data" do
+        data[:playback].delete(:format)
+        BigbluebuttonRecording.recording_changed?(recording, data).should be(true)
+      end
+
+      it "in the database" do
+        BigbluebuttonPlaybackFormat.delete_all
+        BigbluebuttonRecording.recording_changed?(recording, data).should be(true)
+      end
+    end
+
+    context "works when there is no metadata" do
+      it "in the data" do
+        data.delete(:metadata)
+        BigbluebuttonRecording.recording_changed?(recording, data).should be(true)
+      end
+
+      it "in the database" do
+        BigbluebuttonMetadata.delete_all
+        BigbluebuttonRecording.recording_changed?(recording, data).should be(true)
+      end
+    end
+  end
+
   describe ".sync" do
     let(:data) {
-      [
-       {
-         :recordID => "recording-1",
-         :meetingID => "meetingid-1",
-         :name => "Evening Class1",
-         :published => true,
-         :startTime => DateTime.now,
-         :endTime => DateTime.now + 2.hours,
-         :size => 100,
-         :metadata => {
-           :course => "Fundamentals of JAVA",
-           :description => "List of recordings",
-           :activity => "Evening Class1"
-         },
-         :playback => { :format =>
-           [
-            { :type => "slides",
-              :url => "http://test-install.blindsidenetworks.com/playback/slides/playback.html?meetingId=125468758b24fa27551e7a065849dda3ce65dd32-1329872486268",
-              :length => 64
-            },
-            { :type => "presentation",
-              :url => "http://test-install.blindsidenetworks.com/presentation/slides/playback.html?meetingId=125468758b24fa27551e7a065849dda3ce65dd32-1329872486268",
-              :length => 64
-            }
-           ]
-         }
-       }
-      ]
+      [{
+        recordID: "recording-1",
+        meetingID: "meetingid-1",
+        name: "Evening Class1",
+        published: true,
+        startTime: DateTime.now,
+        endTime: DateTime.now + 2.hours,
+        size: 100,
+        metadata: {
+          course: "Fundamentals of JAVA",
+          description: "List of recordings",
+          activity: "Evening Class1"
+        },
+        playback: { format:
+         [{ type: "slides",
+            url: "http://test-install.blindsidenetworks.com/playback/slides/playback.html?meetingId=125468758b24fa27551e7a065849dda3ce65dd32-1329872486268",
+            length: 64
+          },
+          { type: "presentation",
+            url: "http://test-install.blindsidenetworks.com/presentation/slides/playback.html?meetingId=125468758b24fa27551e7a065849dda3ce65dd32-1329872486268",
+            length: 64
+          }]
+        }
+      }]
     }
     let(:new_server) { FactoryGirl.create(:bigbluebutton_server) }
     before {
@@ -144,8 +386,8 @@ describe BigbluebuttonRecording do
       it { @recording.meetingid.should == data[0][:meetingID] }
       it { @recording.name.should == data[0][:name] }
       it { @recording.published.should == data[0][:published] }
-      it { @recording.end_time.utc.to_i.should == data[0][:endTime].utc.to_i }
-      it { @recording.start_time.utc.to_i.should == data[0][:startTime].utc.to_i }
+      it { @recording.end_time.to_i.should == data[0][:endTime].to_i }
+      it { @recording.start_time.to_i.should == data[0][:startTime].to_i }
       it { @recording.server.should == new_server }
       it { @recording.room.should == @room }
       it { @recording.available.should == true }
@@ -176,8 +418,8 @@ describe BigbluebuttonRecording do
       it { @recording.meetingid.should == data[0][:meetingID] }
       it { @recording.name.should == data[0][:name] }
       it { @recording.published.should == data[0][:published] }
-      it { @recording.end_time.utc.to_i.should == data[0][:endTime].utc.to_i }
-      it { @recording.start_time.utc.to_i.should == data[0][:startTime].utc.to_i }
+      it { @recording.end_time.to_i.should == data[0][:endTime].to_i }
+      it { @recording.start_time.to_i.should == data[0][:startTime].to_i }
       it { @recording.server.should == new_server }
       it { @recording.room.should == @room }
       it { @recording.available.should == true }
@@ -293,6 +535,40 @@ describe BigbluebuttonRecording do
       it { BigbluebuttonMetadata.count.should == 3 }
       it { BigbluebuttonPlaybackFormat.count.should == 2 }
     end
+
+    context "when there are unused playback types on the database" do
+      before {
+        FactoryGirl.create(:bigbluebutton_playback_type, :identifier => "to-be-removed")
+        FactoryGirl.create(:bigbluebutton_playback_type, :identifier => "another")
+        BigbluebuttonRecording.sync(new_server, data)
+      }
+      it { BigbluebuttonPlaybackType.count.should == 2 }
+      it { BigbluebuttonPlaybackType.find_by(identifier: "slides").should_not be_nil }
+      it { BigbluebuttonPlaybackType.find_by(identifier: "presentation").should_not be_nil }
+    end
+
+    it "doesn't update if the recording didn't change" do
+      # once to create the recording
+      now = DateTime.now
+      expected = now - 1.month
+      Timecop.freeze(expected)
+      rec_data = data.clone
+
+      BigbluebuttonRecording.sync(new_server, rec_data)
+
+      # set an expected updated_at
+      rec = BigbluebuttonRecording.first
+      puts "before #{rec.updated_at} (#{DateTime.now})"
+      # rec.send(:write_attribute, :updated_at, expected)
+
+      # shouldn't change it
+      Timecop.freeze(now)
+      BigbluebuttonRecording.sync(new_server, rec_data)
+      puts "after #{rec.reload.updated_at} (#{DateTime.now})"
+      rec.reload.updated_at.to_i.should eql(expected.to_i)
+
+      Timecop.return
+    end
   end
 
   describe ".update_recording" do
@@ -309,6 +585,7 @@ describe BigbluebuttonRecording do
         :end_time => attrs[:end_time],
         :size => attrs[:size],
         :metadata => { :any => "any" },
+        :recordingUsers => { :user => [{ :externalUserID => 1 }, { :externalUserID => 2 }] },
         :playback => { :format => [ { :type => "any1" }, { :type => "any2" } ] }
       }
     }
@@ -325,11 +602,12 @@ describe BigbluebuttonRecording do
       it { recording.meetingid.should == attrs[:meetingid] }
       it { recording.name.should == attrs[:name] }
       it { recording.published.should == !old_attrs[:published] }
-      it { recording.end_time.utc.to_i.should == attrs[:end_time].utc.to_i }
-      it { recording.start_time.utc.to_i.should == attrs[:start_time].utc.to_i }
+      it { recording.end_time.to_i.should == attrs[:end_time].to_i }
+      it { recording.start_time.to_i.should == attrs[:start_time].to_i }
       it { recording.size.should == attrs[:size] }
       it { recording.server.should == new_server }
       it { recording.room.should == @room }
+      it { recording.recording_users.should eql([1, 2]) }
     end
 
     context "works if the recording returned has no :size attribute" do
@@ -340,11 +618,19 @@ describe BigbluebuttonRecording do
       }
       it { recording.size.should == 0 }
     end
+
+    context "works if the recording returned has no :recordingUsers attribute" do
+      before {
+        data.delete(:recordingUsers)
+        BigbluebuttonRecording.send(:update_recording, new_server, recording, data)
+      }
+      it { recording.recording_users.should == [] }
+    end
   end
 
   describe ".create_recording" do
-    let(:meeting_start_time) { DateTime.now }
-    let(:recordid) { "#{SecureRandom.uuid}-#{meeting_start_time.to_i}" }
+    let(:meeting_create_time) { DateTime.now.utc.to_i }
+    let(:recordid) { "#{SecureRandom.uuid}-#{meeting_create_time.to_i}" }
     let(:attrs) { FactoryGirl.attributes_for(:bigbluebutton_recording) }
     let(:data) {
       {
@@ -352,9 +638,10 @@ describe BigbluebuttonRecording do
         :meetingid => attrs[:meetingid],
         :name => attrs[:name],
         :published => attrs[:published],
-        :start_time => attrs[:start_time],
+        :start_time => meeting_create_time,
         :end_time => attrs[:end_time],
         :metadata => { :any => "any" },
+        :recordingUsers => { :user => [{ :externalUserID => 3 }, { :externalUserID => 4 }] },
         :playback => { :format => [ { :type => "any1" }, { :type => "any2" } ] }
       }
     }
@@ -362,7 +649,7 @@ describe BigbluebuttonRecording do
 
     before {
       @room = FactoryGirl.create(:bigbluebutton_room, :meetingid => attrs[:meetingid])
-      @meeting = FactoryGirl.create(:bigbluebutton_meeting, :room => @room, :start_time => meeting_start_time.utc)
+      @meeting = FactoryGirl.create(:bigbluebutton_meeting, :room => @room, :create_time => meeting_create_time, :meetingid => attrs[:meetingid])
 
       BigbluebuttonRecording.should_receive(:sync_additional_data)
         .with(anything, data)
@@ -373,15 +660,16 @@ describe BigbluebuttonRecording do
     it("sets meetingid") { @recording.meetingid.should == attrs[:meetingid] }
     it("sets name") { @recording.name.should == attrs[:name] }
     it("sets published") { @recording.published.should == attrs[:published] }
-    it("sets end_time") { @recording.end_time.utc.to_i.should == attrs[:end_time].utc.to_i }
-    it("sets start_time") { @recording.start_time.utc.to_i.should == attrs[:start_time].utc.to_i }
+    it("sets end_time") { @recording.end_time.to_i.should == attrs[:end_time].to_i }
+    it("sets start_time") { @recording.start_time.to_i.should == meeting_create_time }
     it("sets server") { @recording.server.should == new_server }
     it("sets room") { @recording.room.should == @room }
     it("sets meeting") { @recording.meeting.should == @meeting }
     it("sets description") {
-      time = data[:start_time].utc.to_formatted_s(:long)
+      time = Time.at(data[:start_time]).utc.to_formatted_s(:long)
       @recording.description.should == I18n.t('bigbluebutton_rails.recordings.default.description', :time => time)
     }
+    it("sets recording_users") { @recording.recording_users.should eql([3, 4]) }
   end
 
   describe ".adapt_recording_hash" do
@@ -407,6 +695,30 @@ describe BigbluebuttonRecording do
     it { should eq(after) }
   end
 
+  describe ".adapt_recording_users" do
+    context "with one user" do
+      let(:original) {
+        { :user => { :externalUserID => 1 } }
+      }
+      let(:expected) { [1] }
+      it { BigbluebuttonRecording.send(:adapt_recording_users, original).should eql(expected) }
+    end
+
+    context "with several users" do
+      let(:original) {
+        { :user => [{ :externalUserID => 2 }, { :externalUserID => 1 }, { :externalUserID => 15 }] }
+      }
+      let(:expected) { [2, 1, 15] }
+      it { BigbluebuttonRecording.send(:adapt_recording_users, original).should eql(expected) }
+    end
+
+    [nil, []].each do |arg|
+      context "returns nil if the argument is #{arg.inspect}" do
+        it { BigbluebuttonRecording.send(:adapt_recording_users, arg).should be_nil }
+      end
+    end
+  end
+
   describe ".sync_additional_data" do
     let(:attrs) { FactoryGirl.attributes_for(:bigbluebutton_recording) }
     let(:recording) { FactoryGirl.create(:bigbluebutton_recording) }
@@ -520,14 +832,29 @@ describe BigbluebuttonRecording do
       }
 
       context "and it's not in the database yet" do
-        before {
-          BigbluebuttonRecording.send(:sync_playback_formats, recording, data)
-        }
-        it { BigbluebuttonPlaybackFormat.count.should == 1 }
-        it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id).count.should == 1 }
-        it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id).last.url.should == "url1" }
-        it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id).last.length.should == 1 }
-        it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id).last.visible.should be(true) }
+        context "if it is not a downloadable format" do
+          before {
+            BigbluebuttonRecording.send(:sync_playback_formats, recording, data)
+          }
+          it { BigbluebuttonPlaybackFormat.count.should == 1 }
+          it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id).count.should == 1 }
+          it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id).last.url.should == "url1" }
+          it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id).last.length.should == 1 }
+          it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id).last.visible.should be(true) }
+        end
+
+        context "if it is a downloadable format" do
+          after {
+            @previous = BigbluebuttonRails.configuration.downloadable_playback_types
+          }
+          before {
+            BigbluebuttonRails.configuration.downloadable_playback_types = ['any1']
+            BigbluebuttonRecording.send(:sync_playback_formats, recording, data)
+            BigbluebuttonRails.configuration.downloadable_playback_types = @previous
+          }
+          it { BigbluebuttonPlaybackFormat.count.should == 1 }
+          it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id).last.downloadable.should be(true) }
+        end
       end
 
       context "and it's already in the database" do
@@ -584,17 +911,31 @@ describe BigbluebuttonRecording do
 
         BigbluebuttonRecording.send(:sync_playback_formats, recording, data)
       }
-      it { BigbluebuttonPlaybackType.count.should == 3 }
       it { BigbluebuttonPlaybackFormat.count.should == 3 }
-      it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id).count.should == 3 }
-      it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id, :playback_type_id => playback_type.id).first.url.should == "url1" }
-      it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id, :playback_type_id => playback_type.id).first.length.should == 1 }
-      it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id, :playback_type_id => playback_type.id).first.visible.should be(true) }
-      it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id, :playback_type_id => playback_type_hidden.id).first.url.should == "url2" }
-      it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id, :playback_type_id => playback_type_hidden.id).first.length.should == 2 }
-      it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id, :playback_type_id => playback_type_hidden.id).first.visible.should be(false) }
-      it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id, :playback_type_id => BigbluebuttonPlaybackType.last.id).first.url.should == "url3" }
-      it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id, :playback_type_id => BigbluebuttonPlaybackType.last.id).first.length.should == 3 }
+      it { BigbluebuttonPlaybackFormat.where(recording_id: recording.id).count.should == 3 }
+      it {
+        q = BigbluebuttonPlaybackFormat.where(recording_id: recording.id, playback_type_id: playback_type.id, url: "url1")
+        q.size.should == 1
+        f = q.first
+        f.should_not be_nil
+        f.length.should == 1
+        f.visible.should be(true)
+      }
+      it {
+        q = BigbluebuttonPlaybackFormat.where(recording_id: recording.id, playback_type_id: playback_type_hidden.id, url: "url2")
+        q.size.should == 1
+        f = q.first
+        f.should_not be_nil
+        f.length.should == 2
+        f.visible.should be(false)
+      }
+      it {
+        q = BigbluebuttonPlaybackFormat.where(recording_id: recording.id, playback_type_id: BigbluebuttonPlaybackType.last.id, url: "url3")
+        q.size.should == 1
+        f = q.first
+        f.should_not be_nil
+        f.length.should == 3
+      }
     end
 
     context "ignores formats with blank type" do
@@ -637,16 +978,6 @@ describe BigbluebuttonRecording do
         it { BigbluebuttonPlaybackType.last.identifier.should == "any1" }
         it { BigbluebuttonPlaybackType.last.playback_formats.should include(BigbluebuttonPlaybackFormat.last) }
       end
-
-      context "when there are unused playback types on the database" do
-        before {
-          FactoryGirl.create(:bigbluebutton_playback_type, :identifier => "any2")
-          FactoryGirl.create(:bigbluebutton_playback_type, :identifier => "any3")
-          BigbluebuttonRecording.send(:sync_playback_formats, recording, data)
-        }
-        it { BigbluebuttonPlaybackType.count.should == 1 }
-        it { BigbluebuttonPlaybackType.last.identifier.should == "any1" }
-      end
     end
   end
 
@@ -702,9 +1033,10 @@ describe BigbluebuttonRecording do
     end
 
     context "if found a start time in recordid" do
-      let(:meeting_start_time) { DateTime.now }
+      let(:meeting_create_time) { DateTime.now.to_i }
+      let(:meetingid_rand) { SecureRandom.uuid }
       let(:recording) {
-        FactoryGirl.create(:bigbluebutton_recording, :recordid => "#{SecureRandom.uuid}-#{meeting_start_time.to_i}")
+        FactoryGirl.create(:bigbluebutton_recording, :recordid => "#{SecureRandom.uuid}-#{meeting_create_time}", :start_time => meeting_create_time, :meetingid => "#{meetingid_rand}-#{meeting_create_time}")
       }
 
       context "when there's no associated meeting" do
@@ -714,7 +1046,7 @@ describe BigbluebuttonRecording do
 
       context "when there's one associated meeting" do
         before {
-          @meeting = FactoryGirl.create(:bigbluebutton_meeting, :room => recording.room, :start_time => meeting_start_time)
+          @meeting = FactoryGirl.create(:bigbluebutton_meeting, :room => recording.room, :create_time => meeting_create_time, :meetingid => "#{meetingid_rand}-#{meeting_create_time}")
         }
         subject { BigbluebuttonRecording.send(:find_matching_meeting, recording) }
         it { subject.should eq(@meeting) }