exlibris-aleph 1.1.0 → 2.0.0

data/spec/exlibris/aleph/config_spec.rb

@@ -0,0 +1,17 @@
+module Exlibris
+  module Aleph
+    describe Config do
+      subject(:config) { Config }
+      describe '.admin_libraries' do
+        subject { Config.admin_libraries }
+        it { should be_an Array }
+        it { should_not be_empty }
+        it 'should contain AdminLibraries' do
+          subject.each do |admin_library|
+            expect(admin_library).to be_an AdminLibrary
+          end
+        end
+      end
+    end
+  end
+end

data/spec/exlibris/aleph/holding/metadata_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+module Exlibris
+  module Aleph
+    class Holding
+      describe Metadata do
+        let(:marc_xml) { %Q{
+          <holding>
+            <leader>cxH a22001092 4500</leader>
+            <controlfield tag="001">002367980</controlfield>
+            <controlfield tag="004">NYUb12672786</controlfield>
+            <controlfield tag="005">20080531131729.0</controlfield>
+            <controlfield tag="008">0510170|||||8 |001|||||0051017</controlfield>
+            <datafield tag="010" ind1=" " ind2=" ">
+              <subfield code="a">2002030296</subfield>
+            </datafield>
+            <datafield tag="020" ind1=" " ind2=" ">
+              <subfield code="a">0810844915 (alk. paper)</subfield>
+            </datafield>
+            <datafield tag="035" ind1="9" ind2=" ">
+              <subfield code="a">NYUH12672786/13890243</subfield>
+            </datafield>
+            <datafield tag="852" ind1="0" ind2=" ">
+              <subfield code="a">NNCoo</subfield>
+              <subfield code="b">CU</subfield>
+              <subfield code="c">MAIN</subfield>
+              <subfield code="h">HN90.I56</subfield>
+              <subfield code="i">K888 2003</subfield>
+              <subfield code="p">31206028778120</subfield>
+              <subfield code="7">13890243</subfield>
+            </datafield>
+          </holding>
+        }}
+        subject(:metadata) { Metadata.new(marc_xml) }
+        describe '#marc_xml' do
+          subject { metadata.marc_xml }
+          it { should eq marc_xml.strip.gsub('holding>', 'record>') }
+        end
+        describe '#marc_record' do
+          subject { metadata.marc_record }
+          it { should be_a MARC::Record }
+        end
+        describe '#location' do
+          subject { metadata.location }
+          it { should be_a MARC::DataField }
+        end
+        describe '#sub_location' do
+          subject { metadata.sub_location }
+          it { should eq 'CU' }
+        end
+        describe '#shelving_location' do
+          subject { metadata.shelving_location }
+          it { should eq 'MAIN' }
+        end
+      end
+    end
+  end
+end

data/spec/exlibris/aleph/holding_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+module Exlibris
+  module Aleph
+    describe Holding, vcr: {cassette_name: 'record', record: :new_episodes} do
+      let(:record_id) { 'NYU01000864162' }
+      let(:id) { 'NYU60002367980' }
+      let(:tables_manager) { TablesManager.instance }
+      subject(:holding) { Holding.new(record_id, id) }
+      it { should be_a Holding }
+      describe '#record_id' do
+        subject { holding.record_id }
+        it { should eq record_id }
+      end
+      describe '#id' do
+        subject { holding.id }
+        it { should eq id }
+      end
+      describe '#metadata' do
+        subject { holding.metadata }
+        it { should be_a Holding::Metadata }
+      end
+      describe '#collection' do
+        let(:sub_libraries) { tables_manager.sub_libraries }
+        let(:sub_library) do
+          sub_libraries.find do |sub_library|
+            sub_library.code == 'CU'
+          end
+        end
+        let(:collections) { tables_manager.collections }
+        let(:admin_library) { sub_library.admin_library }
+        let(:collection) do
+          collections[admin_library].find do |collection|
+            collection.code == 'MAIN' && collection.sub_library == sub_library
+          end
+        end
+        subject { holding.collection }
+        it { should be_a Collection }
+        it { should eq collection }
+      end
+      context 'when the holding does not exist' do
+        let(:id) { 'ADM60' }
+        describe '#metadata' do
+          subject { holding.metadata }
+          it { should be_nil }
+        end
+        describe '#collection' do
+          subject { holding.collection }
+          it { should be_nil }
+        end
+      end
+    end
+  end
+end

data/spec/exlibris/aleph/holdings_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+module Exlibris
+  module Aleph
+    describe Holdings, vcr: {cassette_name: 'record', record: :new_episodes} do
+      let(:record_id) { 'NYU01000864162' }
+      subject(:holdings) { Holdings.new(record_id) }
+      it { should be_an Holdings }
+      describe '#record_id' do
+        subject { holdings.record_id }
+        it { should eq record_id }
+      end
+      describe '#each' do
+        subject { holdings.each }
+        it { should be_an Enumerable }
+      end
+      describe '#size' do
+        subject { holdings.size }
+        it { should eq 2 }
+      end
+      describe '#to_a' do
+        subject { holdings.to_a }
+        it { should be_an Array }
+        it 'should contain Holdings' do
+          subject.each do |holding|
+            expect(holding).to be_a Holding
+          end
+        end
+      end
+      context 'when there is only one holding' do
+        let(:record_id) { 'NYU01003415726' }
+        describe '#size' do
+          subject { holdings.size }
+          it { should eq 1 }
+        end
+        describe '#to_a' do
+          subject { holdings.to_a }
+          it { should be_an Array }
+          it 'should contain Holdings' do
+            subject.each do |holding|
+              expect(holding).to be_a Holding
+            end
+          end
+        end
+      end
+      context 'when there are no holdings' do
+        let(:record_id) { 'NYU01000000000' }
+        describe '#size' do
+          subject { holdings.size }
+          it { should eq 0 }
+        end
+        describe '#to_a' do
+          subject { holdings.to_a }
+          it { should be_an Array }
+          it { should be_empty }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Exlibris
+  module Aleph
+    class Item
+      describe CallNumber do
+        let(:classification) { }
+        let(:description) { }
+        subject(:call_number) { CallNumber.new(classification, description) }
+        describe '#classification' do
+          subject { call_number.classification }
+          it { should eq classification }
+        end
+        describe '#description' do
+          subject { call_number.description }
+          it { should eq description }
+        end
+      end
+    end
+  end
+end

data/spec/exlibris/aleph/item/circulation_policy/display_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+module Exlibris
+  module Aleph
+    class Item
+      class CirculationPolicy
+        describe Display do
+          let(:value) { 'Display' }
+          let(:mask) { 'Display Mask' }
+          subject(:display) { Display.new(value, mask) }
+          it { should be_a Display }
+          describe '#value' do
+            subject { display.value }
+            it { should eq value }
+          end
+          describe '#mask' do
+            subject { display.mask }
+            it { should eq mask }
+            context 'when the mask is not given' do
+              let(:display) { Display.new(value) }
+              it { should eq value }
+            end
+            context 'when the mask is given' do
+              context 'and the mask is nil' do
+                let(:mask) { nil }
+                it { should eq value }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/exlibris/aleph/item/circulation_policy/identifier_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+module Exlibris
+  module Aleph
+    class Item
+      class CirculationPolicy
+        describe Identifier 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) }
+          subject(:identifier) { Identifier.new(status, processing_status, sub_library) }
+          it { should be_a Identifier }
+          describe '#status' do
+            subject { identifier.status }
+            it { should be_a Status }
+            it { should eq status }
+          end
+          describe '#processing_status' do
+            subject { identifier.processing_status }
+            it { should be_a ProcessingStatus }
+            it { should eq processing_status }
+          end
+          describe '#sub_library' do
+            subject { identifier.sub_library }
+            it { should be_a SubLibrary }
+            it { should eq sub_library }
+          end
+          describe '#==' do
+            subject { identifier == other_object }
+            context 'when the other object is an Item::CirculationPolicy::Identifier' do
+              let(:other_status) { status }
+              let(:other_processing_status) { processing_status }
+              let(:other_sub_library) { sub_library }
+              let(:other_object) { Identifier.new(other_status, other_processing_status, other_sub_library) }
+              context 'but the status of the other object is different' do
+                let(:other_status) { Status.new('01') }
+                it { should be_false }
+              end
+              context 'and the status of the other object is the same' do
+                context 'but the processing status of the other object is different' do
+                  let(:other_processing_status) { ProcessingStatus.new('##') }
+                  it { should be_false }
+                end
+                context 'and the processing status of the other object is the same' do
+                  context 'but the sub library of the other object is different' do
+                    let(:other_sub_library) { SubLibrary.new('SUB1', 'Sub Library 1', admin_library) }
+                    it { should be_false }
+                  end
+                  context 'and the sub library of the other object is the same' do
+                    it { should be_true }
+                  end
+                end
+              end
+            end
+            context 'when the other object is not an Item::CirculationPolicy::Identifier' do
+              let(:other_object) { "invalid" }
+              it { should be_false }
+            end
+          end
+          describe '#===' do
+            subject { identifier === other_object }
+            context 'when the other object is an Item::CirculationPolicy::Identifier' do
+              let(:other_status) { status }
+              let(:other_processing_status) { processing_status }
+              let(:other_sub_library) { sub_library }
+              let(:other_object) { Identifier.new(other_status, other_processing_status, other_sub_library) }
+              context 'but the status of the other object is different' do
+                let(:other_status) { Status.new('01') }
+                it { should be_false }
+              end
+              context 'and the status of the other object is the same' do
+                context 'but the processing status of the other object is different' do
+                  let(:other_processing_status) { ProcessingStatus.new('##') }
+                  it { should be_false }
+                end
+                context 'and the processing status of the other object is the same' do
+                  context 'but the sub library of the other object is different' do
+                    let(:other_sub_library) { SubLibrary.new('SUB1', 'Sub Library 1', admin_library) }
+                    it { should be_false }
+                  end
+                  context 'and the sub library of the other object is the same' do
+                    it { should be_true }
+                  end
+                end
+              end
+            end
+            context 'when the other object is not an Item::CirculationPolicy::Identifier' do
+              let(:other_object) { "invalid" }
+              it { should be_false }
+            end
+          end
+          describe '#eql?' do
+            subject { identifier.eql?(other_object) }
+            context 'when the other object is an Item::CirculationPolicy::Identifier' do
+              let(:other_status) { status }
+              let(:other_processing_status) { processing_status }
+              let(:other_sub_library) { sub_library }
+              let(:other_object) { Identifier.new(other_status, other_processing_status, other_sub_library) }
+              context 'but the status of the other object is different' do
+                let(:other_status) { Status.new('01') }
+                it { should be_false }
+              end
+              context 'and the status of the other object is the same' do
+                context 'but the processing status of the other object is different' do
+                  let(:other_processing_status) { ProcessingStatus.new('##') }
+                  it { should be_false }
+                end
+                context 'and the processing status of the other object is the same' do
+                  context 'but the sub library of the other object is different' do
+                    let(:other_sub_library) { SubLibrary.new('SUB1', 'Sub Library 1', admin_library) }
+                    it { should be_false }
+                  end
+                  context 'and the sub library of the other object is the same' do
+                    it { should be_true }
+                  end
+                end
+              end
+            end
+            context 'when the other object is not an Item::CirculationPolicy::Identifier' do
+              let(:other_object) { "invalid" }
+              it { should be_false }
+            end
+          end
+          context 'when initialized with arguments' do
+            context 'but the "status" argument is not an Item::Status' do
+              let(:status) { "invalid" }
+              it 'should raise an ArgumentError' do
+                expect { subject }.to raise_error ArgumentError
+              end
+            end
+            context 'and the "status" argument is an Item::Status' do
+              context 'but the "processing status" argument is not an Item::ProcessingStatus' do
+                let(:processing_status) { "invalid" }
+                it 'should raise an ArgumentError' do
+                  expect { subject }.to raise_error ArgumentError
+                end
+              end
+              context 'and the "processing status" argument is an Item::ProcessingStatus' do
+                context 'but the "sub library" argument is not a SubLibrary' do
+                  let(:sub_library) { "invalid" }
+                  it 'should raise an ArgumentError' do
+                    expect { subject }.to raise_error ArgumentError
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/exlibris/aleph/item/circulation_policy/privileges_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+module Exlibris
+  module Aleph
+    class Item
+      class CirculationPolicy
+        describe Privileges do
+          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' }
+          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(rush_recallable)
+            allow(row).to receive(:reloaning_limit).and_return(reloaning_limit)
+            allow(row).to receive(:bookable).and_return(bookable)
+            allow(row).to receive(:booking_hours).and_return(booking_hours)
+          end
+          subject(:privileges) { Privileges.new(row) }
+          describe '#loanable' do
+            subject { privileges.loanable }
+            it { should eq loanable }
+          end
+          describe '#loanable?' do
+            subject { privileges.loanable? }
+            it { should be_true }
+            context 'when the item is not loanable' do
+              let(:loanable) { 'N' }
+              it { should be_false }
+            end
+          end
+          describe '#renewable' do
+            subject { privileges.renewable }
+            it { should eq renewable }
+          end
+          describe '#renewable?' do
+            subject { privileges.renewable? }
+            it { should be_true }
+            context 'when the item is not renewable' do
+              let(:renewable) { 'N' }
+              it { should be_false }
+            end
+          end
+          describe '#requestable' do
+            subject { privileges.requestable }
+            it { should eq requestable }
+          end
+          describe '#requestable?' do
+            subject { privileges.requestable? }
+            it { should be_true }
+            context 'when the item is not requestable' do
+              let(:requestable) { 'N' }
+              it { should be_false }
+            end
+            context 'when the item is always requestable' do
+              let(:requestable) { 'C' }
+              it { should be_true }
+            end
+          end
+          describe '#always_requestable?' do
+            subject { privileges.always_requestable? }
+            it { should be_false }
+            context 'when the item is not requestable' do
+              let(:requestable) { 'N' }
+              it { should be_false }
+            end
+            context 'when the item is always requestable' do
+              let(:requestable) { 'C' }
+              it { should be_true }
+            end
+          end
+          describe '#photocopyable' do
+            subject { privileges.photocopyable }
+            it { should eq photocopyable }
+          end
+          describe '#photocopyable?' do
+            subject { privileges.photocopyable? }
+            it { should be_true }
+            context 'when the item is not photocopyable' do
+              let(:photocopyable) { 'N' }
+              it { should be_false }
+            end
+          end
+          describe '#displayable' do
+            subject { privileges.displayable }
+            it { should eq displayable }
+          end
+          describe '#displayable?' do
+            subject { privileges.displayable? }
+            it { should be_true }
+            context 'when the item is not displayable' do
+              let(:displayable) { 'N' }
+              it { should be_false }
+            end
+          end
+          describe '#specific_item' do
+            subject { privileges.specific_item }
+            it { should eq specific_item }
+          end
+          describe '#specific_item?' do
+            subject { privileges.specific_item? }
+            it { should be_true }
+            context 'when item requests are not for specific items' do
+              let(:specific_item) { 'N' }
+              it { should be_false }
+            end
+          end
+          describe '#limit_hold' do
+            subject { privileges.limit_hold }
+            it { should eq limit_hold }
+          end
+          describe '#limit_hold?' do
+            subject { privileges.limit_hold? }
+            it { should be_true }
+            context 'when the item is has no hold limit' do
+              let(:limit_hold) { 'N' }
+              it { should be_false }
+            end
+          end
+          describe '#recallable' do
+            subject { privileges.recallable }
+            it { should eq recallable }
+          end
+          describe '#recallable?' do
+            subject { privileges.recallable? }
+            it { should be_true }
+            context 'when the item is not recallable' do
+              let(:recallable) { 'N' }
+              it { should be_false }
+            end
+          end
+          describe '#rush_recallable' do
+            subject { privileges.rush_recallable }
+            it { should eq rush_recallable }
+          end
+          describe '#rush_recallable?' do
+            subject { privileges.rush_recallable? }
+            it { should be_true }
+            context 'when the item is not "rush" recallable' do
+              let(:rush_recallable) { 'N' }
+              it { should be_false }
+            end
+          end
+          describe '#reloaning_limit' do
+            subject { privileges.reloaning_limit }
+            it { should eq reloaning_limit }
+          end
+          describe '#bookable' do
+            subject { privileges.bookable }
+            it { should eq bookable }
+          end
+          describe '#bookable?' do
+            subject { privileges.bookable? }
+            it { should be_true }
+            context 'when the item is not bookable' do
+              let(:bookable) { 'N' }
+              it { should be_false }
+            end
+          end
+          describe '#booking_hours' do
+            subject { privileges.booking_hours }
+            it { should eq booking_hours }
+          end
+        end
+      end
+    end
+  end
+end