exlibris-aleph 1.1.0 → 2.0.0

data/spec/exlibris/aleph/item/circulation_policy_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+module Exlibris
+  module Aleph
+    class Item
+      describe CirculationPolicy do
+        let(:status_code) { '##' }
+        let(:status) { Status.new(status_code) }
+        let(:processing_status_code) { 'DP' }
+        let(:processing_status) { ProcessingStatus.new(processing_status_code) }
+        let(:admin_library) { AdminLibrary.new('ADM50') }
+        let(:sub_library) { SubLibrary.new('SUB', 'Sub Library', admin_library) }
+        let(:identifier) { CirculationPolicy::Identifier.new(status, processing_status, sub_library) }
+        let(:display) { CirculationPolicy::Display.new('Display') }
+        let(:row) { double }
+        let(:loanable) { 'Y' }
+        let(:renewable) { 'Y' }
+        let(:requestable) { 'Y' }
+        let(:photocopyable) { 'Y' }
+        let(:displayable) { 'Y' }
+        let(:specific_item) { 'Y' }
+        let(:limit_hold) { 'Y' }
+        let(:recallable) { 'Y' }
+        let(:rush_recallable) { 'Y' }
+        let(:reloaning_limit) { '00' }
+        let(:bookable) { 'Y' }
+        let(:booking_hours) { 'A' }
+        let(:privileges) { CirculationPolicy::Privileges.new(row) }
+        before do
+          allow(row).to receive(:loanable).and_return(loanable)
+          allow(row).to receive(:renewable).and_return(renewable)
+          allow(row).to receive(:requestable).and_return(requestable)
+          allow(row).to receive(:photocopyable).and_return(photocopyable)
+          allow(row).to receive(:displayable).and_return(displayable)
+          allow(row).to receive(:specific_item).and_return(specific_item)
+          allow(row).to receive(:limit_hold).and_return(limit_hold)
+          allow(row).to receive(:recallable).and_return(recallable)
+          allow(row).to receive(:rush_recallable).and_return(photocopyable)
+          allow(row).to receive(:reloaning_limit).and_return(rush_recallable)
+          allow(row).to receive(:bookable).and_return(bookable)
+          allow(row).to receive(:booking_hours).and_return(booking_hours)
+        end
+        subject(:circulation_policy) { CirculationPolicy.new(identifier, display, privileges) }
+        it { should be_a CirculationPolicy }
+        describe '#identifier' do
+          subject { circulation_policy.identifier }
+          it { should eq identifier }
+        end
+        describe '#display' do
+          subject { circulation_policy.display }
+          it { should eq display }
+        end
+        describe '#privileges' do
+          subject { circulation_policy.privileges }
+          it { should eq privileges }
+        end
+        describe '#==' do
+          subject { circulation_policy == other_object }
+          context 'when the other object is an Item::CirculationPolicy' do
+            let(:other_identifier) { identifier }
+            let(:other_display) { display }
+            let(:other_privileges) { privileges }
+            let(:other_object) { CirculationPolicy.new(other_identifier, other_display, other_privileges) }
+            context 'but the identifier of the other object is different' do
+              let(:other_status) { Status.new('01') }
+              let(:other_identifier) { CirculationPolicy::Identifier.new(other_status, processing_status, sub_library) }
+              it { should be_false }
+            end
+            context 'and the identifier of the other object is the same' do
+              it { should be_true }
+            end
+          end
+          context 'when the other object is not an Item::CirculationPolicy' do
+            let(:other_object) { "invalid" }
+            it { should be_false }
+          end
+        end
+        describe '#===' do
+          subject { circulation_policy === other_object }
+          context 'when the other object is an Item::CirculationPolicy' do
+            let(:other_identifier) { identifier }
+            let(:other_display) { display }
+            let(:other_privileges) { privileges }
+            let(:other_object) { CirculationPolicy.new(other_identifier, other_display, other_privileges) }
+            context 'but the identifier of the other object is different' do
+              let(:other_status) { Status.new('01') }
+              let(:other_identifier) { CirculationPolicy::Identifier.new(other_status, processing_status, sub_library) }
+              it { should be_false }
+            end
+            context 'and the identifier of the other object is the same' do
+              it { should be_true }
+            end
+          end
+          context 'when the other object is not an Item::CirculationPolicy' do
+            let(:other_object) { "invalid" }
+            it { should be_false }
+          end
+        end
+        describe '#eql?' do
+          subject { circulation_policy.eql?(other_object) }
+          context 'when the other object is an Item::CirculationPolicy' do
+            let(:other_identifier) { identifier }
+            let(:other_display) { display }
+            let(:other_privileges) { privileges }
+            let(:other_object) { CirculationPolicy.new(other_identifier, other_display, other_privileges) }
+            context 'but the identifier of the other object is different' do
+              let(:other_status) { Status.new('01') }
+              let(:other_identifier) { CirculationPolicy::Identifier.new(other_status, processing_status, sub_library) }
+              it { should be_false }
+            end
+            context 'and the identifier of the other object is the same' do
+              it { should be_true }
+            end
+          end
+          context 'when the other object is not an Item::CirculationPolicy' do
+            let(:other_object) { "invalid" }
+            it { should be_false }
+          end
+        end
+        context 'when initialized with arguments' do
+          context 'but the "identifier" argument is not an Item::CirculationPolicy::Identifier' do
+            let(:identifier) { "invalid" }
+            it 'should raise an ArgumentError' do
+              expect { subject }.to raise_error ArgumentError
+            end
+          end
+          context 'and the "identifier" argument is an Item::CirculationPolicy::Identifier' do
+            context 'but the "display" argument is not an Item::CirculationPolicy::Display' do
+              let(:display) { "invalid" }
+              it 'should raise an ArgumentError' do
+                expect { subject }.to raise_error ArgumentError
+              end
+            end
+            context 'and the "display" argument is an Item::CirculationPolicy::Display' do
+              context 'but the "privileges" argument is not a Item::CirculationPolicy::Privileges' do
+                let(:privileges) { "invalid" }
+                it 'should raise an ArgumentError' do
+                  expect { subject }.to raise_error ArgumentError
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/exlibris/aleph/item/circulation_status_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+module Exlibris
+  module Aleph
+    class Item
+      describe CirculationStatus do
+        let(:value) { 'On Shelf' }
+        subject(:circulation_status) { CirculationStatus.new(value) }
+        it { should be_a CirculationStatus }
+        describe '#value' do
+          subject { circulation_status.value }
+          it { should eq value }
+        end
+        describe '#due_date' do
+          subject { circulation_status.due_date }
+          it { should be_nil }
+          context 'when the value is "05/31/14"' do
+            let(:value) { '05/31/14' }
+            it { should eq '05/31/14' }
+          end
+          context 'when the value is "Recalled due date: 05/31/14"' do
+            let(:value) { 'Recalled due date: 05/31/14' }
+            it { should eq '05/31/14' }
+          end
+        end
+        describe '#to_s' do
+          subject { circulation_status.to_s }
+          it { should eq value }
+        end
+        describe '#==' do
+          subject { circulation_status == other_object }
+          context 'when the other object is an Exlibris::Aleph::Item::DisplayMask' do
+            context 'and the value is the same' do
+              let(:other_object) { CirculationStatus.new(value) }
+              it { should be_true }
+            end
+            context 'but the value is different' do
+              let(:other_object) { CirculationStatus.new('Reshelving') }
+              it { should be_false }
+            end
+          end
+          context 'when the other object is not an Exlibris::Aleph::Item::DisplayMask' do
+            let(:other_object) { "string" }
+            it { should be_false }
+          end
+        end
+        describe '#===' do
+          subject { circulation_status === other_object }
+          context 'when the other object is an Exlibris::Aleph::Item::DisplayMask' do
+            context 'and the value is the same' do
+              let(:other_object) { CirculationStatus.new(value) }
+              it { should be_true }
+            end
+            context 'but the value is different' do
+              let(:other_object) { CirculationStatus.new('Reshelving') }
+              it { should be_false }
+            end
+          end
+          context 'when the other object is not an Exlibris::Aleph::Item::DisplayMask' do
+            let(:other_object) { "string" }
+            it { should be_false }
+          end
+        end
+        describe '#eql?' do
+          subject { circulation_status.eql?(other_object) }
+          context 'when the other object is an Exlibris::Aleph::Item::DisplayMask' do
+            context 'and the value is the same' do
+              let(:other_object) { CirculationStatus.new(value) }
+              it { should be_true }
+            end
+            context 'but the value is different' do
+              let(:other_object) { CirculationStatus.new('Reshelving') }
+              it { should be_false }
+            end
+          end
+          context 'when the other object is not an Exlibris::Aleph::Item::DisplayMask' do
+            let(:other_object) { "string" }
+            it { should be_false }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/exlibris/aleph/item/display_mask_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+module Exlibris
+  module Aleph
+    class Item
+      describe DisplayMask do
+        let(:value) { 'Display' }
+        let(:mask) { 'Display Mask' }
+        subject(:display_mask  ) { DisplayMask.new(value, mask) }
+        it { should be_a DisplayMask }
+        describe '#value' do
+          subject { display_mask.value }
+          it { should eq value }
+        end
+        describe '#mask' do
+          subject { display_mask.mask }
+          it { should eq mask }
+        end
+        describe '#==' do
+          subject { display_mask == other_object }
+          context 'when the other object is an Exlibris::Aleph::Item::DisplayMask' do
+            context 'and the value is the same' do
+              let(:other_object) { DisplayMask.new(value, mask) }
+              it { should be_true }
+            end
+            context 'but the value is different' do
+              let(:other_object) { DisplayMask.new('Display 1', 'Display 1 Mask') }
+              it { should be_false }
+            end
+          end
+          context 'when the other object is not an Exlibris::Aleph::Item::DisplayMask' do
+            let(:other_object) { "string" }
+            it { should be_false }
+          end
+        end
+        describe '#===' do
+          subject { display_mask === other_object }
+          context 'when the other object is an Exlibris::Aleph::Item::DisplayMask' do
+            context 'and the value is the same' do
+              let(:other_object) { DisplayMask.new(value, mask) }
+              it { should be_true }
+            end
+            context 'but the value is different' do
+              let(:other_object) { DisplayMask.new('Display 1', 'Display 1 Mask') }
+              it { should be_false }
+            end
+          end
+          context 'when the other object is not an Exlibris::Aleph::Item::DisplayMask' do
+            let(:other_object) { "string" }
+            it { should be_false }
+          end
+        end
+        describe '#eql?' do
+          subject { display_mask.eql?(other_object) }
+          context 'when the other object is an Exlibris::Aleph::Item::DisplayMask' do
+            context 'and the value is the same' do
+              let(:other_object) { DisplayMask.new(value, mask) }
+              it { should be_true }
+            end
+            context 'but the value is different' do
+              let(:other_object) { DisplayMask.new('Display 1', 'Display 1 Mask') }
+              it { should be_false }
+            end
+          end
+          context 'when the other object is not an Exlibris::Aleph::Item::DisplayMask' do
+            let(:other_object) { "string" }
+            it { should be_false }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/exlibris/aleph/item/opac_note_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+module Exlibris
+  module Aleph
+    class Item
+      describe OpacNote do
+        let(:value) { "Library's copy is predominantly out of order Advertising and Covers from 1936." }
+        subject(:opac_note) { OpacNote.new(value) }
+        describe '#value' do
+          subject { opac_note.value }
+          it { should eq value }
+        end
+        describe '#to_s' do
+          subject { opac_note.to_s }
+          it { should eq value }
+        end
+      end
+    end
+  end
+end

data/spec/exlibris/aleph/item/processing_status_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+module Exlibris
+  module Aleph
+    class Item
+      describe ProcessingStatus do
+        let(:code) { 'DP' }
+        subject(:processing_status) { ProcessingStatus.new(code) }
+        it { should be_a ProcessingStatus }
+        describe '#code' do
+          subject { processing_status.code }
+          it { should eq code }
+        end
+        describe '#display' do
+          subject { processing_status.display }
+          it { should be_nil }
+        end
+        describe '#to_s' do
+          subject { processing_status.to_s }
+          it { should eq code }
+        end
+        describe '#==' do
+          subject { processing_status == other_object }
+          context 'when the other object is an Item::ProcessingStatus' do
+            context 'and the code is the same' do
+              let(:other_object) { ProcessingStatus.new(code) }
+              it { should be_true }
+            end
+            context 'but the code is different' do
+              let(:other_object) { ProcessingStatus.new('##') }
+              it { should be_false }
+            end
+          end
+          context 'when the other object is not an Item::ProcessingStatus' do
+            let(:other_object) { "string" }
+            it { should be_false }
+          end
+        end
+        describe '#===' do
+          subject { processing_status === other_object }
+          context 'when the other object is an Item::ProcessingStatus' do
+            context 'and the code is the same' do
+              let(:other_object) { ProcessingStatus.new(code) }
+              it { should be_true }
+            end
+            context 'but the code is different' do
+              let(:other_object) { ProcessingStatus.new('##') }
+              it { should be_false }
+            end
+          end
+          context 'when the other object is not an Item::ProcessingStatus' do
+            let(:other_object) { "string" }
+            it { should be_false }
+          end
+        end
+        describe '#eql?' do
+          subject { processing_status.eql?(other_object) }
+          context 'when the other object is an Item::ProcessingStatus' do
+            context 'and the code is the same' do
+              let(:other_object) { ProcessingStatus.new(code) }
+              it { should be_true }
+            end
+            context 'but the code is different' do
+              let(:other_object) { ProcessingStatus.new('##') }
+              it { should be_false }
+            end
+          end
+          context 'when the other object is not an Item::ProcessingStatus' do
+            let(:other_object) { "string" }
+            it { should be_false }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/exlibris/aleph/item/queue_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+module Exlibris
+  module Aleph
+    class Item
+      describe Queue do
+        let(:value) { "1 request(s) of 1 items." }
+        subject(:queue) { Queue.new(value) }
+        describe '#value' do
+          subject { queue.value }
+          it { should eq value }
+        end
+        describe '#to_s' do
+          subject { queue.to_s }
+          it { should eq value }
+        end
+        describe '#number_of_requests' do
+          subject { queue.number_of_requests }
+          it { should eq 1 }
+          context 'when the input value is nil' do
+            let(:value) { nil }
+            it { should eq 0 }
+          end
+          context 'when the input value is blank' do
+            let(:value) { '' }
+            it { should eq 0 }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/exlibris/aleph/item/status_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+module Exlibris
+  module Aleph
+    class Item
+      describe Status do
+        let(:code) { '01' }
+        let(:display) { 'Regular loan' }
+        subject(:status) { Status.new(code, display) }
+        it { should be_a Status }
+        describe '#code' do
+          subject { status.code }
+          it { should eq code }
+        end
+        describe '#display' do
+          subject { status.display }
+          it { should eq display }
+          context 'when initialized without a display' do
+            let(:status) { Status.new(code) }
+            it { should be_nil }
+          end
+        end
+        describe '#to_s' do
+          subject { status.to_s }
+          it { should eq display }
+        end
+        describe '#==' do
+          subject { status == other_object }
+          context 'when the other object is an Item::Status' do
+            context 'and the code is the same' do
+              let(:other_object) { Status.new(code) }
+              it { should be_true }
+            end
+            context 'but the code is different' do
+              let(:other_object) { Status.new('02') }
+              it { should be_false }
+            end
+          end
+          context 'when the other object is not an Item::Status' do
+            let(:other_object) { "string" }
+            it { should be_false }
+          end
+        end
+        describe '#===' do
+          subject { status === other_object }
+          context 'when the other object is an Item::Status' do
+            context 'and the code is the same' do
+              let(:other_object) { Status.new(code) }
+              it { should be_true }
+            end
+            context 'but the code is different' do
+              let(:other_object) { Status.new('02') }
+              it { should be_false }
+            end
+          end
+          context 'when the other object is not an Item::Status' do
+            let(:other_object) { "string" }
+            it { should be_false }
+          end
+        end
+        describe '#eql?' do
+          subject { status.eql?(other_object) }
+          context 'when the other object is an Item::Status' do
+            context 'and the code is the same' do
+              let(:other_object) { Status.new(code) }
+              it { should be_true }
+            end
+            context 'but the code is different' do
+              let(:other_object) { Status.new('02') }
+              it { should be_false }
+            end
+          end
+          context 'when the other object is not an Item::Status' do
+            let(:other_object) { "string" }
+            it { should be_false }
+          end
+        end
+      end
+    end
+  end
+end