bigbluebutton_rails 1.4.0 → 2.0.0

data/spec/models/bigbluebutton_playback_type_spec.rb

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe BigbluebuttonPlaybackType do
+  it "loaded correctly" do
+    BigbluebuttonPlaybackType.new.should be_a_kind_of(ActiveRecord::Base)
+  end
+
+  before { FactoryGirl.create(:bigbluebutton_playback_type) }
+
+  it { should validate_presence_of(:identifier) }
+
+  it { should_not validate_presence_of(:visible) }
+
+  it { should have_many(:playback_formats).dependent(:nullify) }
+
+  context "ensures only 0 or 1 records with default=true" do
+    context "automatically sets new records as default=false if setting the current as default=true" do
+      let!(:first) { FactoryGirl.create(:bigbluebutton_playback_type, default: true) }
+      let!(:target) { FactoryGirl.create(:bigbluebutton_playback_type, default: false) }
+      before(:each) {
+        target.update_attributes(default: true)
+      }
+      it { target.reload.default.should be(true) }
+      it { first.reload.default.should be(false) }
+    end
+
+    context "doesn't change other records to default=false if not setting the current as default=true" do
+      let!(:first) { FactoryGirl.create(:bigbluebutton_playback_type, default: true) }
+      let!(:target) { FactoryGirl.create(:bigbluebutton_playback_type, default: false) }
+      before(:each) {
+        target.update_attributes(identifier: "any")
+      }
+      it { target.reload.default.should be(false) }
+      it { first.reload.default.should be(true) }
+    end
+
+    context "allows all records to have default=false" do
+      let!(:first) { FactoryGirl.create(:bigbluebutton_playback_type, default: false) }
+      let!(:target) { FactoryGirl.create(:bigbluebutton_playback_type, default: true) }
+      before(:each) {
+        target.update_attributes(default: false)
+      }
+      it { target.reload.default.should be(false) }
+      it { first.reload.default.should be(false) }
+    end
+  end
+
+  describe "#name" do
+    let(:subject) { FactoryGirl.create(:bigbluebutton_playback_type) }
+
+    it {
+      subject.identifier = "presentation"
+      subject.name.should eql(I18n.t("bigbluebutton_rails.playback_types.presentation.name"))
+    }
+
+    it {
+      subject.identifier = "any_other"
+      subject.name.should eql("Any Other")
+    }
+  end
+
+  describe "#description" do
+    let(:subject) { FactoryGirl.create(:bigbluebutton_playback_type) }
+
+    it {
+      subject.identifier = "presentation"
+      subject.description.should eql(I18n.t("bigbluebutton_rails.playback_types.presentation.tip"))
+    }
+
+    it {
+      subject.identifier = "any_other"
+      subject.description.should eql("Any Other")
+    }
+  end
+end

data/spec/models/bigbluebutton_recording_db_spec.rb

@@ -16,11 +16,13 @@ describe BigbluebuttonRecording do
     it { should have_db_column(:description).of_type(:string) }
     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(:size).of_type(:integer) }
     it { should have_db_index(:room_id) }
     it { should have_db_index(:recordid).unique(true) }
     it "default values" do
       room = BigbluebuttonRecording.new
-      room.published.should be_false
+      room.published.should be(false)
+      room.size.should be(0)
     end
   end
 

data/spec/models/bigbluebutton_recording_spec.rb

@@ -16,15 +16,17 @@ describe BigbluebuttonRecording do
   it { should validate_presence_of(:recordid) }
   it { should validate_uniqueness_of(:recordid) }
 
-  [:recordid, :meetingid, :name, :published, :start_time,
-   :end_time, :available].each do |attribute|
-    it { should allow_mass_assignment_of(attribute) }
-  end
-
   it { should have_many(:metadata).dependent(:destroy) }
 
   it { should have_many(:playback_formats).dependent(:destroy) }
 
+  describe "#size" do
+    # make sure it's a bigint
+    it { should allow_value(-9223372036854775808).for(:size) }
+    it { should allow_value(0).for(:size) }
+    it { should allow_value(9223372036854775807).for(:size) }
+  end
+
   context "scopes" do
 
     describe "#published" do
@@ -46,6 +48,24 @@ describe BigbluebuttonRecording do
     }
   end
 
+  describe "#default_playback_format" do
+    let!(:recording) { FactoryGirl.create(:bigbluebutton_recording) }
+    let!(:type_default) { FactoryGirl.create(:bigbluebutton_playback_type, default: true) }
+    let!(:type_other) { FactoryGirl.create(:bigbluebutton_playback_type, default: false) }
+    let!(:format1) { FactoryGirl.create(:bigbluebutton_playback_format, recording: recording, playback_type: type_other) }
+    let!(:format2) { FactoryGirl.create(:bigbluebutton_playback_format, recording: recording, playback_type: type_default) }
+    let!(:format3) { FactoryGirl.create(:bigbluebutton_playback_format, recording: recording, playback_type: type_other) }
+
+    context "in a normal situation" do
+      it { recording.default_playback_format.should eql(format2) }
+    end
+
+    context "when there's more than one format of the default type" do
+      let!(:format4) { FactoryGirl.create(:bigbluebutton_playback_format, recording: recording, playback_type: type_default) }
+      it { recording.default_playback_format.should eql(format2) }
+    end
+  end
+
   describe ".sync" do
     let(:data) {
       [
@@ -56,6 +76,7 @@ describe BigbluebuttonRecording do
          :published => true,
          :startTime => DateTime.now,
          :endTime => DateTime.now + 2.hours,
+         :size => 100,
          :metadata => {
            :course => "Fundamentals of JAVA",
            :description => "List of recordings",
@@ -96,6 +117,7 @@ describe BigbluebuttonRecording do
       it { @recording.server.should == new_server }
       it { @recording.room.should == @room }
       it { @recording.available.should == true }
+      it { @recording.size.should == 100 }
       it { @recording.metadata.count.should == 3 }
       3.times do |i|
         it { @recording.metadata[i].name.should == data[0][:metadata].keys[i].to_s }
@@ -103,6 +125,7 @@ describe BigbluebuttonRecording do
       end
       it { @recording.playback_formats.count.should == 2 }
       2.times do |i|
+        it { @recording.playback_formats[i].playback_type.identifier.should == data[0][:playback][:format][i][:type] }
         it { @recording.playback_formats[i].format_type.should == data[0][:playback][:format][i][:type] }
         it { @recording.playback_formats[i].url.should == data[0][:playback][:format][i][:url] }
         it { @recording.playback_formats[i].length.should == data[0][:playback][:format][i][:length] }
@@ -126,6 +149,7 @@ describe BigbluebuttonRecording do
       it { @recording.server.should == new_server }
       it { @recording.room.should == @room }
       it { @recording.available.should == true }
+      it { @recording.size.should == 100 }
       it { @recording.metadata.count.should == 3 }
       3.times do |i|
         it { @recording.metadata[i].name.should == data[0][:metadata].keys[i].to_s }
@@ -133,6 +157,7 @@ describe BigbluebuttonRecording do
       end
       it { @recording.playback_formats.count.should == 2 }
       2.times do |i|
+        it { @recording.playback_formats[i].playback_type.identifier.should == data[0][:playback][:format][i][:type] }
         it { @recording.playback_formats[i].format_type.should == data[0][:playback][:format][i][:type] }
         it { @recording.playback_formats[i].url.should == data[0][:playback][:format][i][:url] }
         it { @recording.playback_formats[i].length.should == data[0][:playback][:format][i][:length] }
@@ -149,17 +174,46 @@ describe BigbluebuttonRecording do
     end
 
     context "sets recording that are not in the parameters as unavailable" do
-      before {
-        # pre-existing recordings that should be marked as unavailable
-        @r1 = FactoryGirl.create(:bigbluebutton_recording, :available => true)
-        @r2 = FactoryGirl.create(:bigbluebutton_recording, :available => true)
-        BigbluebuttonRecording.sync(new_server, data)
-        @r1.reload
-        @r2.reload
-      }
-      it { BigbluebuttonRecording.count.should == 3 }
-      it { @r1.available.should == false }
-      it { @r2.available.should == false }
+
+      context "for recordings in multiple servers" do
+        before {
+          BigbluebuttonRecording.delete_all
+          @r1 = FactoryGirl.create(:bigbluebutton_recording, :available => true, :server => new_server)
+          @r2 = FactoryGirl.create(:bigbluebutton_recording, :available => true, :server => new_server)
+          @r3 = FactoryGirl.create(:bigbluebutton_recording, :available => true, :server => FactoryGirl.create(:bigbluebutton_server))
+          @r4 = FactoryGirl.create(:bigbluebutton_recording, :available => true, :server => FactoryGirl.create(:bigbluebutton_server))
+          BigbluebuttonRecording.sync(new_server, data)
+        }
+        it { BigbluebuttonRecording.count.should == 5 }
+        it ("recording from the target server") { @r1.reload.available.should == false }
+        it ("recording from the target server") { @r2.reload.available.should == false }
+        it ("recording from another server") { @r3.reload.available.should == true }
+        it ("recording from another server") { @r4.reload.available.should == true }
+      end
+
+      context "when there are no recordings in the target server" do
+        before {
+          new_server.recordings.delete_all
+          @r1 = FactoryGirl.create(:bigbluebutton_recording, :available => true, :server => FactoryGirl.create(:bigbluebutton_server))
+          @r2 = FactoryGirl.create(:bigbluebutton_recording, :available => true, :server => FactoryGirl.create(:bigbluebutton_server))
+          BigbluebuttonRecording.sync(new_server, data)
+        }
+        it { new_server.recordings.should be_empty }
+        it ("recording from another server") { @r1.reload.available.should == true }
+        it ("recording from another server") { @r2.reload.available.should == true }
+      end
+
+      context "when there are no recordings in other servers" do
+        before {
+          BigbluebuttonRecording.delete_all
+          @r1 = FactoryGirl.create(:bigbluebutton_recording, :available => true, :server => new_server)
+          @r2 = FactoryGirl.create(:bigbluebutton_recording, :available => true, :server => new_server)
+          BigbluebuttonRecording.sync(new_server, data)
+        }
+        it { BigbluebuttonRecording.count.should == 3 }
+        it ("recording from another server") { @r1.reload.available.should == false }
+        it ("recording from another server") { @r2.reload.available.should == false }
+      end
     end
 
     context "works for multiple recordings" do
@@ -206,26 +260,39 @@ describe BigbluebuttonRecording do
         :published => !old_attrs[:published],
         :start_time => attrs[:start_time],
         :end_time => attrs[:end_time],
+        :size => attrs[:size],
         :metadata => { :any => "any" },
         :playback => { :format => [ { :type => "any1" }, { :type => "any2" } ] }
       }
     }
     let(:new_server) { FactoryGirl.create(:bigbluebutton_server) }
 
-    before {
-      @room = FactoryGirl.create(:bigbluebutton_room, :meetingid => attrs[:meetingid])
-      BigbluebuttonRecording.should_receive(:sync_additional_data)
-        .with(recording, data)
-      BigbluebuttonRecording.send(:update_recording, new_server, recording, data)
-    }
-    it { recording.recordid.should == old_attrs[:recordid] } # not updated
-    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.server.should == new_server }
-    it { recording.room.should == @room }
+    context "default behavior" do
+      before {
+        @room = FactoryGirl.create(:bigbluebutton_room, :meetingid => attrs[:meetingid])
+        BigbluebuttonRecording.should_receive(:sync_additional_data)
+          .with(recording, data)
+        BigbluebuttonRecording.send(:update_recording, new_server, recording, data)
+      }
+      it { recording.recordid.should == old_attrs[:recordid] } # not updated
+      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.size.should == attrs[:size] }
+      it { recording.server.should == new_server }
+      it { recording.room.should == @room }
+    end
+
+    context "works if the recording returned has no :size attribute" do
+      before {
+        data.delete(:size)
+        recording.update_attributes(size: 0)
+        BigbluebuttonRecording.send(:update_recording, new_server, recording, data)
+      }
+      it { recording.size.should == 0 }
+    end
   end
 
   describe ".create_recording" do
@@ -309,7 +376,7 @@ describe BigbluebuttonRecording do
       }
     }
 
-    it "succeds" do
+    it "succeeds" do
       BigbluebuttonRecording.should_receive(:sync_metadata)
         .with(recording, data[:metadata])
       BigbluebuttonRecording.should_receive(:sync_playback_formats)
@@ -400,45 +467,87 @@ describe BigbluebuttonRecording do
   describe ".sync_playback_formats" do
     let(:recording) { FactoryGirl.create(:bigbluebutton_recording) }
 
-    context "with several formats" do
+    context "with a single format" do
       let(:data) {
-        [ { :type => "any1", :url => "url1", :length => 1 },
-          { :type => "any2", :url => "url2", :length => 2 } ]
+        { :type => "any1", :url => "url1", :length => 1 }
       }
-      before {
-        # one playback format to be updated
-        FactoryGirl.create(:bigbluebutton_playback_format,
-                           :recording => recording, :format_type => "any1")
-        # one to be deleted
-        FactoryGirl.create(:bigbluebutton_playback_format, :recording => recording)
 
-        BigbluebuttonRecording.send(:sync_playback_formats, recording, data)
-      }
-      it { BigbluebuttonPlaybackFormat.count.should == 2 }
-      it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id).count.should == 2 }
-      it { BigbluebuttonPlaybackFormat.find_by_format_type("any1").url.should == "url1" }
-      it { BigbluebuttonPlaybackFormat.find_by_format_type("any1").length.should == 1 }
-      it { BigbluebuttonPlaybackFormat.find_by_format_type("any2").url.should == "url2" }
-      it { BigbluebuttonPlaybackFormat.find_by_format_type("any2").length.should == 2 }
+      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) }
+      end
+
+      context "and it's already in the database" do
+        before {
+          # one playback format to be updated
+          playback_type = FactoryGirl.create(:bigbluebutton_playback_type, identifier: "any1", visible: false)
+          FactoryGirl.create(:bigbluebutton_playback_format,
+                             :recording => recording, :playback_type => playback_type)
+
+          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(false) }
+      end
+
+      context "and there are unused formats in the database" do
+        before {
+          # formats to be deleted
+          FactoryGirl.create(:bigbluebutton_playback_format, :recording => recording)
+          FactoryGirl.create(:bigbluebutton_playback_format, :recording => recording)
+
+          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 }
+      end
     end
 
-    context "with a single format" do
+    context "with several formats" do
       let(:data) {
-        { :type => "any1", :url => "url1", :length => 1 }
+        [ { :type => "any1", :url => "url1", :length => 1 },
+          { :type => "any2", :url => "url2", :length => 2 },
+          { :type => "any3", :url => "url3", :length => 3 } ]
+      }
+      let(:playback_type) {
+        FactoryGirl.create(:bigbluebutton_playback_type, identifier: "any1", visible: true)
+      }
+      let(:playback_type_hidden) {
+        FactoryGirl.create(:bigbluebutton_playback_type, identifier: "any2", visible: false)
       }
       before {
-        # one playback format to be updated
+        # two playback formats to be updated
+        FactoryGirl.create(:bigbluebutton_playback_format,
+                           :recording => recording, :playback_type => playback_type)
         FactoryGirl.create(:bigbluebutton_playback_format,
-                           :recording => recording, :format_type => "any1")
+                           :recording => recording, :playback_type => playback_type_hidden)
         # one to be deleted
         FactoryGirl.create(:bigbluebutton_playback_format, :recording => recording)
 
         BigbluebuttonRecording.send(:sync_playback_formats, recording, data)
       }
-      it { BigbluebuttonPlaybackFormat.count.should == 1 }
-      it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id).count.should == 1 }
-      it { BigbluebuttonPlaybackFormat.find_by_format_type("any1").url.should == "url1" }
-      it { BigbluebuttonPlaybackFormat.find_by_format_type("any1").length.should == 1 }
+      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 }
     end
 
     context "ignores formats with blank type" do
@@ -450,12 +559,79 @@ describe BigbluebuttonRecording do
       before {
         BigbluebuttonRecording.send(:sync_playback_formats, recording, data)
       }
+      it { BigbluebuttonPlaybackType.count.should == 1 }
       it { BigbluebuttonPlaybackFormat.count.should == 1 }
       it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id).count.should == 1 }
-      it { BigbluebuttonPlaybackFormat.find_by_format_type("any").url.should == "url2" }
-      it { BigbluebuttonPlaybackFormat.find_by_format_type("any").length.should == 1 }
+      it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id, :playback_type_id => BigbluebuttonPlaybackType.last.id).first.url.should == "url2" }
+      it { BigbluebuttonPlaybackFormat.where(:recording_id => recording.id, :playback_type_id => BigbluebuttonPlaybackType.last.id).first.length.should == 1 }
+    end
+
+    context "manages the playback types" do
+      let(:data) {
+        { :type => "any1", :url => "url1", :length => 1 }
+      }
+
+      context "when the playback type is already on the database" do
+        let!(:playback_type) {
+          FactoryGirl.create(:bigbluebutton_playback_type, :identifier => "any1")
+        }
+        before {
+          BigbluebuttonRecording.send(:sync_playback_formats, recording, data)
+        }
+        it { BigbluebuttonPlaybackType.count.should == 1 }
+        it { BigbluebuttonPlaybackType.last.should ==  playback_type }
+      end
+
+      context "when the playback type is not on the database" do
+        before {
+          BigbluebuttonRecording.send(:sync_playback_formats, recording, data)
+        }
+        it { BigbluebuttonPlaybackType.count.should == 1 }
+        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
+
+  describe ".cleanup_playback_types" do
+    let(:recording) { FactoryGirl.create(:bigbluebutton_recording) }
 
+    context "when all playback types are in use" do
+      before {
+        @kept1 = FactoryGirl.create(:bigbluebutton_playback_format, :recording => recording).playback_type
+        @kept2 = FactoryGirl.create(:bigbluebutton_playback_format, :recording => recording).playback_type
+
+        BigbluebuttonRecording.send(:cleanup_playback_types)
+      }
+      it { BigbluebuttonPlaybackType.count.should == 2 }
+      it { BigbluebuttonPlaybackType.all.should include(@kept1) }
+      it { BigbluebuttonPlaybackType.all.should include(@kept2) }
+    end
+
+    context "when there are unused playback types" do
+      before {
+        @removed1 = FactoryGirl.create(:bigbluebutton_playback_type)
+        @removed2 = FactoryGirl.create(:bigbluebutton_playback_type)
+        @kept1 = FactoryGirl.create(:bigbluebutton_playback_format, :recording => recording).playback_type
+
+        BigbluebuttonRecording.send(:cleanup_playback_types)
+      }
+
+      it { BigbluebuttonPlaybackType.count.should == 1 }
+      it { BigbluebuttonPlaybackType.all.should include(@kept1) }
+      it { BigbluebuttonPlaybackType.all.should_not include(@removed1) }
+      it { BigbluebuttonPlaybackType.all.should_not include(@removed2) }
+    end
   end
 
   describe ".find_matching_meeting" do