active-fedora 13.1.2 → 13.1.3

data/spec/unit/default_model_mapper_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::DefaultModelMapper do
-  subject(:mapper) { described_class.new classifier_class: classifier, solr_field: solr_field, predicate: predicate }
-  let(:classifier) { class_double(ActiveFedora::ModelClassifier) }
-  let(:classifier_instance) { instance_double(ActiveFedora::ModelClassifier) }
-  let(:solr_field) { 'solr_field' }
-  let(:predicate) { 'info:predicate' }
-
-  describe '#classifier' do
-    context 'with a solr document' do
-      let(:solr_document) { { 'solr_field' => ['xyz'] } }
-
-      before do
-        expect(classifier).to receive(:new).with(['xyz']).and_return(classifier_instance)
-      end
-
-      it 'creates a classifier from the solr field data' do
-        expect(mapper.classifier(solr_document)).to eq classifier_instance
-      end
-    end
-
-    context 'with a resource' do
-      let(:graph) do
-        RDF::Graph.new << [:hello, predicate, 'xyz']
-      end
-
-      let(:resource) { instance_double(ActiveFedora::LdpResource, graph: graph) }
-
-      before do
-        expect(classifier).to receive(:new).with(['xyz']).and_return(classifier_instance)
-      end
-
-      it 'creates a classifier from the resource model predicate' do
-        expect(mapper.classifier(resource)).to eq classifier_instance
-      end
-    end
-  end
-end

data/spec/unit/fedora_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Fedora do
-  subject(:fedora) { described_class.new(config) }
-  describe "#authorized_connection" do
-    describe "with SSL options" do
-      let(:config) {
-        { url: "https://example.com",
-          user: "fedoraAdmin",
-          password: "fedoraAdmin",
-          ssl: { ca_path: '/path/to/certs' } }
-      }
-      specify {
-        expect(Faraday).to receive(:new).with("https://example.com", ssl: { ca_path: '/path/to/certs' }).and_call_original
-        fedora.authorized_connection
-      }
-    end
-    describe "with request options" do
-      let(:config) {
-        { url: "https://example.com",
-          user: "fedoraAdmin",
-          password: "fedoraAdmin",
-          request: { timeout: 600, open_timeout: 60 } }
-      }
-      specify {
-        expect(Faraday).to receive(:new).with("https://example.com", request: { timeout: 600, open_timeout: 60 }).and_call_original
-        fedora.authorized_connection
-      }
-    end
-  end
-end

data/spec/unit/file/streaming_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::File::Streaming do
-  let(:test_class) do
-    tc = Class.new
-    tc.send(:include, described_class)
-    tc
-  end
-  let(:streamer) do
-    streamer = test_class.new
-    allow(streamer).to receive(:uri).and_return(uri)
-    allow(streamer).to receive(:authorization_key).and_return("authorization_key")
-    streamer
-  end
-
-  context "without ssl" do
-    let(:uri) { "http://localhost/file/1" }
-
-    it do
-      expect(Net::HTTP).to receive(:start).with('localhost', 80, use_ssl: false).and_return(nil)
-      streamer.stream.each
-    end
-  end
-
-  context "with ssl" do
-    let(:uri) { "https://localhost/file/1" }
-
-    it do
-      expect(Net::HTTP).to receive(:start).with('localhost', 443, use_ssl: true).and_return(nil)
-      streamer.stream.each
-    end
-  end
-end

data/spec/unit/file_configurator_spec.rb

@@ -1,295 +0,0 @@
-require 'spec_helper'
-require 'config_helper'
-
-describe ActiveFedora::FileConfigurator do
-  subject(:configurator) { ActiveFedora.configurator }
-
-  after :all do
-    unstub_rails
-    # Restore to default fedora configs
-    restore_spec_configuration
-  end
-
-  describe "#initialize" do
-    it "triggers configuration reset (to empty defaults)" do
-      expect_any_instance_of(described_class).to receive(:reset!)
-      described_class.new
-    end
-  end
-
-  describe "#config_options" do
-    before do
-      configurator.reset!
-    end
-    it "is an empty hash" do
-      expect(configurator.config_options).to eq({})
-    end
-  end
-
-  describe "#fedora_config" do
-    before do
-      configurator.reset!
-    end
-    it "triggers configuration to load" do
-      expect(configurator).to receive(:load_fedora_config)
-      configurator.fedora_config
-    end
-  end
-  describe "#solr_config" do
-    before do
-      configurator.reset!
-    end
-    it "triggers configuration to load" do
-      expect(configurator).to receive(:load_solr_config)
-      configurator.solr_config
-    end
-  end
-
-  describe "#reset!" do
-    before { configurator.reset! }
-    it "clears @fedora_config" do
-      expect(configurator.instance_variable_get(:@fedora_config)).to eq({})
-    end
-    it "clears @solr_config" do
-      expect(configurator.instance_variable_get(:@solr_config)).to eq({})
-    end
-    it "clears @config_options" do
-      expect(configurator.instance_variable_get(:@config_options)).to eq({})
-    end
-  end
-
-  describe "initialization methods" do
-    describe "config_path(:fedora)" do
-      it "uses the config_options[:config_path] if it exists" do
-        expect(configurator).to receive(:config_options).and_return(fedora_config_path: "/path/to/fedora.yml")
-        expect(File).to receive(:file?).with("/path/to/fedora.yml").and_return(true)
-        expect(configurator.config_path(:fedora)).to eql("/path/to/fedora.yml")
-      end
-
-      it "looks in Rails.root/config/fedora.yml if it exists and no fedora_config_path passed in" do
-        expect(configurator).to receive(:config_options).and_return({})
-        stub_rails(root: "/rails/root")
-        expect(File).to receive(:file?).with("/rails/root/config/fedora.yml").and_return(true)
-        expect(configurator.config_path(:fedora)).to eql("/rails/root/config/fedora.yml")
-        unstub_rails
-      end
-
-      it "looks in ./config/fedora.yml if neither rails.root nor :fedora_config_path are set" do
-        expect(configurator).to receive(:config_options).and_return({})
-        allow(Dir).to receive(:getwd).and_return("/current/working/directory")
-        expect(File).to receive(:file?).with("/current/working/directory/config/fedora.yml").and_return(true)
-        expect(configurator.config_path(:fedora)).to eql("/current/working/directory/config/fedora.yml")
-      end
-
-      it "returns default fedora.yml that ships with active-fedora if none of the above" do
-        expect(configurator).to receive(:config_options).and_return({})
-        expect(Dir).to receive(:getwd).and_return("/current/working/directory")
-        expect(File).to receive(:file?).with("/current/working/directory/config/fedora.yml").and_return(false)
-        expect(File).to receive(:file?).with(File.expand_path(File.join(File.dirname("__FILE__"), 'config', 'fedora.yml'))).and_return(true)
-        expect(ActiveFedora::Base.logger).to receive(:warn).with("Using the default fedora.yml that comes with active-fedora.  If you want to override this, pass the path to fedora.yml to ActiveFedora - ie. ActiveFedora.init(:fedora_config_path => '/path/to/fedora.yml') - or set Rails.root and put fedora.yml into \#{Rails.root}/config.")
-        expect(configurator.config_path(:fedora)).to eql(File.expand_path(File.join(File.dirname("__FILE__"), 'config', 'fedora.yml')))
-      end
-    end
-
-    describe "config_path(:solr)" do
-      it "returns the solr_config_path if set in config_options hash" do
-        allow(configurator).to receive(:config_options).and_return(solr_config_path: "/path/to/solr.yml")
-        expect(File).to receive(:file?).with("/path/to/solr.yml").and_return(true)
-        expect(configurator.config_path(:solr)).to eql("/path/to/solr.yml")
-      end
-
-      it "returns the solr.yml file in the same directory as the fedora.yml if it exists" do
-        expect(configurator).to receive(:path).and_return("/path/to/fedora/config/fedora.yml")
-        expect(File).to receive(:file?).with("/path/to/fedora/config/solr.yml").and_return(true)
-        expect(configurator.config_path(:solr)).to eql("/path/to/fedora/config/solr.yml")
-      end
-
-      context "no solr.yml in same directory as fedora.yml and fedora.yml does not contain solr url" do
-        before do
-          allow(configurator).to receive(:config_options).and_return({})
-          expect(configurator).to receive(:path).and_return("/path/to/fedora/config/fedora.yml")
-          expect(File).to receive(:file?).with("/path/to/fedora/config/solr.yml").and_return(false)
-        end
-        after do
-          unstub_rails
-        end
-
-        it "does not raise an error if there is not a solr.yml in the same directory as the fedora.yml and the fedora.yml has a solr url defined and look in rails.root" do
-          stub_rails(root: "/rails/root")
-          expect(File).to receive(:file?).with("/rails/root/config/solr.yml").and_return(true)
-          expect(configurator.config_path(:solr)).to eql("/rails/root/config/solr.yml")
-        end
-
-        it "looks in ./config/solr.yml if no rails root" do
-          allow(Dir).to receive(:getwd).and_return("/current/working/directory")
-          expect(File).to receive(:file?).with("/current/working/directory/config/solr.yml").and_return(true)
-          expect(configurator.config_path(:solr)).to eql("/current/working/directory/config/solr.yml")
-        end
-
-        it "returns the default solr.yml file that ships with active-fedora if no other option is set" do
-          allow(Dir).to receive(:getwd).and_return("/current/working/directory")
-          expect(File).to receive(:file?).with("/current/working/directory/config/solr.yml").and_return(false)
-          expect(File).to receive(:file?).with(File.expand_path(File.join(File.dirname("__FILE__"), 'config', 'solr.yml'))).and_return(true)
-          expect(ActiveFedora::Base.logger).to receive(:warn).with("Using the default solr.yml that comes with active-fedora.  If you want to override this, pass the path to solr.yml to ActiveFedora - ie. ActiveFedora.init(:solr_config_path => '/path/to/solr.yml') - or set Rails.root and put solr.yml into \#{Rails.root}/config.")
-          expect(configurator.config_path(:solr)).to eql(File.expand_path(File.join(File.dirname("__FILE__"), 'config', 'solr.yml')))
-        end
-      end
-    end
-
-    describe "load_fedora_config" do
-      before do
-        configurator.reset!
-      end
-      it "loads the file specified in fedora_config_path" do
-        expect(configurator).to receive(:config_path).with(:fedora).and_return("/path/to/fedora.yml")
-        expect(configurator).to receive(:load_solr_config)
-        expect(IO).to receive(:read).with("/path/to/fedora.yml").and_return("development:\n url: http://devfedora:8983\ntest:\n  url: http://myfedora:8080")
-        expect(configurator.load_fedora_config).to eq(url: "http://myfedora:8080")
-        expect(configurator.fedora_config).to eq(url: "http://myfedora:8080")
-      end
-
-      it "allows sharding" do
-        expect(configurator).to receive(:config_path).with(:fedora).and_return("/path/to/fedora.yml")
-        expect(configurator).to receive(:load_solr_config)
-        expect(IO).to receive(:read).with("/path/to/fedora.yml").and_return("development:\n  url: http://devfedora:8983\ntest:\n- url: http://myfedora:8080\n- url: http://myfedora:8081")
-        expect(configurator.load_fedora_config).to eq [{ url: "http://myfedora:8080" }, { url: "http://myfedora:8081" }]
-        expect(configurator.fedora_config).to eq [{ url: "http://myfedora:8080" }, { url: "http://myfedora:8081" }]
-      end
-
-      it "parses the file using ERb" do
-        expect(configurator).to receive(:config_path).with(:fedora).and_return("/path/to/fedora.yml")
-        expect(configurator).to receive(:load_solr_config)
-        expect(IO).to receive(:read).with("/path/to/fedora.yml").and_return("development:\n  url: http://devfedora:<%= 8983 %>\ntest:\n  url: http://myfedora:<%= 8081 %>")
-        expect(configurator.load_fedora_config).to eq(url: "http://myfedora:8081")
-        expect(configurator.fedora_config).to eq(url: "http://myfedora:8081")
-      end
-    end
-
-    describe "load_solr_config" do
-      before do
-        configurator.reset!
-      end
-      it "loads the file specified in solr_config_path" do
-        expect(configurator).to receive(:config_path).with(:solr).and_return("/path/to/solr.yml")
-        expect(configurator).to receive(:load_fedora_config)
-        expect(IO).to receive(:read).with("/path/to/solr.yml").and_return("development:\n  default:\n    url: http://devsolr:8983\ntest:\n  default:\n    url: http://mysolr:8080")
-        expect(configurator.load_solr_config).to eq(url: "http://mysolr:8080")
-        expect(configurator.solr_config).to eq(url: "http://mysolr:8080")
-      end
-
-      it "parses the file using ERb" do
-        expect(configurator).to receive(:config_path).with(:solr).and_return("/path/to/solr.yml")
-        expect(configurator).to receive(:load_fedora_config)
-        expect(IO).to receive(:read).with("/path/to/solr.yml").and_return("development:\n  default:\n    url: http://devsolr:<%= 8983 %>\ntest:\n  default:\n    url: http://mysolr:<%= 8081 %>")
-        expect(configurator.load_solr_config).to eq(url: "http://mysolr:8081")
-        expect(configurator.solr_config).to eq(url: "http://mysolr:8081")
-      end
-
-      it "includes update_path and select_path in solr_config" do
-        expect(configurator).to receive(:config_path).with(:solr).and_return("/path/to/solr.yml")
-        expect(configurator).to receive(:load_fedora_config)
-        expect(IO).to receive(:read).with("/path/to/solr.yml").and_return("test:\n  url: http://mysolr:8080\n  update_path: update_test\n  select_path: select_test\n")
-        expect(configurator.solr_config[:update_path]).to eq('update_test')
-        expect(configurator.solr_config[:select_path]).to eq('select_test')
-      end
-    end
-
-    describe "load_configs" do
-      describe "when config is not loaded" do
-        before do
-          configurator.instance_variable_set :@config_loaded, nil
-        end
-        it "loads the fedora and solr configs" do
-          expect(configurator).to_not be_config_loaded
-          configurator.load_configs
-          expect(configurator).to be_config_loaded
-        end
-      end
-      describe "when config is loaded" do
-        before do
-          configurator.instance_variable_set :@config_loaded, true
-        end
-        it "loads the fedora and solr configs" do
-          expect(configurator).to receive(:load_config).never
-          expect(configurator).to be_config_loaded
-          configurator.load_configs
-          expect(configurator).to be_config_loaded
-        end
-      end
-    end
-
-    describe "check_fedora_path_for_solr" do
-      it "finds the solr.yml file and return it if it exists" do
-        expect(configurator).to receive(:path).and_return("/path/to/fedora/fedora.yml")
-        expect(File).to receive(:file?).with("/path/to/fedora/solr.yml").and_return(true)
-        expect(configurator.check_fedora_path_for_solr).to eq "/path/to/fedora/solr.yml"
-      end
-      it "returns nil if the solr.yml file is not there" do
-        expect(configurator).to receive(:path).and_return("/path/to/fedora/fedora.yml")
-        expect(File).to receive(:file?).with("/path/to/fedora/solr.yml").and_return(false)
-        expect(configurator.check_fedora_path_for_solr).to be_nil
-      end
-    end
-  end
-
-  describe "setting the environment and loading configuration" do
-    before(:all) do
-      @fake_rails_root = File.expand_path(File.dirname(__FILE__) + '/../fixtures/rails_root')
-    end
-
-    after(:all) do
-      config_file = File.join(File.dirname(__FILE__), "..", "..", "config", "fedora.yml")
-      environment = "test"
-      ActiveFedora.init(environment: environment, fedora_config_path: config_file)
-    end
-
-    it "can tell its config paths" do
-      configurator.init
-      expect(configurator).to respond_to(:solr_config_path)
-    end
-
-    it "loads a config from the current working directory as a second choice" do
-      allow(Dir).to receive(:getwd).and_return(@fake_rails_root)
-      configurator.init
-      expect(configurator.config_path(:fedora)).to eql("#{@fake_rails_root}/config/fedora.yml")
-      expect(configurator.solr_config_path).to eql("#{@fake_rails_root}/config/solr.yml")
-    end
-
-    it "loads the config that ships with this gem as a last choice" do
-      allow(Dir).to receive(:getwd).and_return("/fake/path")
-      expect(ActiveFedora::Base.logger).to receive(:warn).with("Using the default fedora.yml that comes with active-fedora.  If you want to override this, pass the path to fedora.yml to ActiveFedora - ie. ActiveFedora.init(:fedora_config_path => '/path/to/fedora.yml') - or set Rails.root and put fedora.yml into \#{Rails.root}/config.").exactly(3).times
-      configurator.init
-      expected_config = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "config"))
-      expect(configurator.config_path(:fedora)).to eql(expected_config + '/fedora.yml')
-      expect(configurator.solr_config_path).to eql(expected_config + '/solr.yml')
-    end
-    it "raises an error if you pass in a string" do
-      expect(lambda { configurator.init("#{@fake_rails_root}/config/fake_fedora.yml") }).to raise_exception(ArgumentError)
-    end
-    it "raises an error if you pass in a non-existant config file" do
-      expect(lambda { configurator.init(fedora_config_path: "really_fake_fedora.yml") }).to raise_exception(ActiveFedora::ConfigurationError)
-    end
-
-    describe "within Rails" do
-      before do
-        stub_rails(root: File.dirname(__FILE__) + '/../fixtures/rails_root')
-      end
-
-      after do
-        unstub_rails
-      end
-
-      it "loads a config from Rails.root as a first choice" do
-        configurator.init
-        expect(configurator.config_path(:fedora)).to eql("#{Rails.root}/config/fedora.yml")
-        expect(configurator.solr_config_path).to eql("#{Rails.root}/config/solr.yml")
-      end
-
-      it "can tell what environment it is set to run in" do
-        stub_rails(env: "development")
-        configurator.init
-        expect(ActiveFedora.environment).to eql("development")
-      end
-    end
-  end
-end

data/spec/unit/file_io_spec.rb

@@ -1,137 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::FileIO do
-  # 300,000 byte test string
-  test_file = (0..300_000).reduce('') do |s, c| s << (c % 256).chr end
-
-  let(:file_contents) { test_file }
-  let(:fedora_file) {
-    ActiveFedora::File.new .tap do |file|
-      file.content = file_contents
-      file.save
-    end
-  }
-  let(:io) { described_class.new(fedora_file) }
-
-  describe "#read" do
-    it "reads the entire file when called without parameters" do
-      expect(io.read).to eql(file_contents)
-    end
-
-    it "returns nil at end of file when requested with length" do
-      io.read
-      expect(io.read(10)).to be_nil
-    end
-
-    it "returns only requested amount of bytes" do
-      expect(io.read(5)).to eql(file_contents[0..4])
-      expect(io.read(5)).to eql(file_contents[5..9])
-      expect(io.read(100_000)).to eql(file_contents[10..100_009])
-      expect(io.read(200_000)).to eql(file_contents[100_010..-1])
-    end
-
-    it "returns an empty string if 0 bytes is requested" do
-      expect(io.read(0)).to eql('')
-    end
-
-    it "raises an error with negative length parameter" do
-      expect { io.read(-1) }.to raise_error(ArgumentError)
-    end
-
-    it "returns ASCII-8BIT strings" do
-      expect(io.read(10).encoding.to_s).to eql("ASCII-8BIT")
-      expect(io.read.encoding.to_s).to eql("ASCII-8BIT")
-    end
-
-    it "can take a buffer parameter" do
-      buffer = ''
-      expect(io.read(100, buffer)).to eql(file_contents[0..99])
-      expect(buffer).to eql(file_contents[0..99])
-      # IO.read will clear the buffer if it's not empty
-      expect(io.read(100, buffer)).to eql(file_contents[100..199])
-      expect(buffer).to eql(file_contents[100..199])
-    end
-
-    context "with empty file" do
-      let(:file_contents) { '' }
-      it "returns an empty string when called without parameters" do
-        expect(io.read).to eql('')
-      end
-
-      it "returns nil when called with length parameter" do
-        expect(io.read(10)).to be_nil
-      end
-    end
-
-    context "edge cases" do
-      let(:stream) {
-        instance_double(ActiveFedora::File::Streaming::FileBody).tap do |stream|
-          allow(stream).to receive(:each) do |&block|
-            ['abcd', 'efghijkl', 'mnopqrst', 'uvwxy', 'z'].each(&block)
-          end
-        end
-      }
-      before {
-        allow(fedora_file).to receive(:stream).and_return(stream)
-      }
-      let(:file_contents) { 'abcdefghijklmnopqrstuvwxyz' }
-      it "are handled correctly" do
-        expect(io.read(4)).to eql('abcd')
-        expect(io.read(7)).to eql('efghijk')
-        expect(io.read(9)).to eql('lmnopqrst')
-        expect(io.read(6)).to eql('uvwxyz')
-        expect(io.read(4)).to be_nil
-      end
-    end
-  end
-
-  describe "#pos" do
-    it "returns current position" do
-      expect(io.pos).to be(0)
-      io.read(5)
-      expect(io.pos).to be(5)
-      io.read(100_000)
-      expect(io.pos).to be(100_005)
-      io.read
-      expect(io.pos).to be(file_contents.length)
-      io.rewind
-      expect(io.pos).to be(0)
-    end
-  end
-
-  describe "#rewind" do
-    it "restarts the stream" do
-      io.read(10)
-      io.rewind
-      expect(io.read(10)).to eql(file_contents[0..9])
-    end
-  end
-
-  describe "#close" do
-    it "closes the stream" do
-      io.read(10)
-      io.close
-      expect { io.read(10) } .to raise_error(IOError)
-    end
-  end
-
-  describe "#binmode" do
-    it "responds to binmode" do
-      expect { io.binmode } .not_to raise_error
-    end
-  end
-
-  describe "#binmode?" do
-    it "returns true" do
-      expect(io.binmode?).to be(true)
-    end
-  end
-
-  describe "working with IO.copy_stream" do
-    let(:output_stream) { StringIO.new .tap(&:binmode) }
-    it "copies the stream" do
-      IO.copy_stream(io, output_stream)
-      expect(output_stream.string).to eql(file_contents)
-    end
-  end
-end