active-fedora 8.7.0 → 9.0.0.beta1

data/spec/unit/rubydora_connection_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-require 'active_fedora/rubydora_connection'
-
-describe ActiveFedora::RubydoraConnection do
-  describe 'initialize' do
-    it "should pass through options" do
-      @instance = ActiveFedora::RubydoraConnection.new :timeout => 3600, :force => true, :validateChecksum=>true
-      expect(@instance.connection.client.options[:timeout]).to eq(3600)
-      expect(@instance.connection.config[:validateChecksum]).to eq(true)
-    end
-  end
-end

data/spec/unit/semantic_node_spec.rb

@@ -1,112 +0,0 @@
-require 'spec_helper'
-
-@@last_pid = 0
-describe ActiveFedora::SemanticNode do
-
-  describe "with a bunch of objects" do
-    def increment_pid
-      @@last_pid += 1    
-    end
-    
-    before(:each) do
-      class SpecNode
-        include ActiveFedora::SemanticNode
-        
-        attr_accessor :pid
-        def initialize (params={}) 
-          self.pid = params[:pid]
-        end
-        def internal_uri
-          'info:fedora/' + pid.to_s
-        end
-      end
-
-      @node = SpecNode.new
-      allow(@node).to receive(:rels_ext).and_return(double("rels_ext", :content_will_change! => true, :content=>''))
-      @node.pid = increment_pid
-    end
-    
-    after(:each) do
-      Object.send(:remove_const, :SpecNode)
-    end
-
-    describe "pid_from_uri" do
-      it "should strip the info:fedora/ out of a given string" do 
-        expect(SpecNode.pid_from_uri("info:fedora/FOO:BAR")).to eq("FOO:BAR")
-      end
-    end
-    
-    describe ".add_relationship" do
-      it "should add relationship to the relationships graph" do
-        @node.add_relationship("isMemberOf", 'demo:9')
-        expect(@node.ids_for_outbound("isMemberOf")).to eq(['demo:9'])
-      end
-      it "should not be written into the graph until it is saved" do
-        @n1 = ActiveFedora::Base.new
-        @node.add_relationship(:has_part, @n1)
-        expect(@node.relationships.statements.to_a.first.object.to_s).to eq('info:fedora/') 
-        @n1.save
-        expect(@node.relationships.statements.to_a.first.object.to_s).to eq(@n1.internal_uri)
-      end
-
-      it "should add a literal relationship to the relationships graph" do
-        @node.add_relationship("isMemberOf", 'demo:9', true)
-        expect(@node.relationships("isMemberOf")).to eq(['demo:9'])
-      end
-      
-      it "adding relationship to an instance should not affect class-level relationships hash" do 
-        local_test_node1 = SpecNode.new
-        local_test_node2 = SpecNode.new
-        allow(local_test_node1).to receive(:rels_ext).and_return(double("rels_ext", :content_will_change! => true, :content=>''))
-        local_test_node1.add_relationship(:is_member_of, 'demo:10')
-        allow(local_test_node2).to receive(:rels_ext).and_return(double('rels-ext', :content=>''))
-        
-        expect(local_test_node1.relationships(:is_member_of)).to eq(["demo:10"])
-        expect(local_test_node2.relationships(:is_member_of)).to eq([])
-      end
-      
-    end
-
-    describe ".clear_relationship" do
-      before do
-        @node.add_relationship(:is_member_of, 'demo:9')
-        @node.add_relationship(:is_member_of, 'demo:7')
-        @node.add_relationship(:has_description, 'demo:9')
-      end
-      it "should clear the specified relationship" do
-        @node.clear_relationship(:is_member_of)
-        expect(@node.relationships(:is_member_of)).to eq([])
-        expect(@node.relationships(:has_description)).to eq(['demo:9'])
-      end
-    end
-    
-    describe '#remove_relationship' do
-      it 'should remove a relationship from the relationships hash' do
-        allow(@node).to receive(:rels_ext).and_return(double("rels_ext", :content_will_change! => true, :content=>''))
-        @node.add_relationship(:has_part, "info:fedora/3")
-        @node.add_relationship(:has_part, "info:fedora/4")
-        #check both are there
-        expect(@node.ids_for_outbound(:has_part)).to include "3", "4"
-        @node.remove_relationship(:has_part, "info:fedora/3")
-        #check returns false if relationship does not exist and does nothing with different predicate
-        @node.remove_relationship(:has_member,"info:fedora/4")
-        #check only one item removed
-        expect(@node.ids_for_outbound(:has_part)).to eq(['4'])
-        @node.remove_relationship(:has_part,"info:fedora/4")
-        #check last item removed and predicate removed since now emtpy
-        expect(@node.ids_for_outbound(:has_part)).to eq([])
-
-        expect(@node.relationships_are_dirty).to eq(true)
-        
-      end
-    end
-
-    describe '#assert_kind_of' do
-      it 'should raise an exception if object supplied is not the correct type' do
-        expect {@node.assert_kind_of 'SpecNode', @node, ActiveFedora::Base}.to raise_error
-        #now should not throw any exception
-        @node.assert_kind_of 'SpecNode', @node, SpecNode
-      end
-    end
-  end
-end

data/spec/unit/service_definitions_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-class Test < ActiveFedora::Base
-  include ActiveFedora::ServiceDefinitions
-  #has_service_definition "monkey:100"
-end
-
-describe ActiveFedora::ServiceDefinitions do
-  before(:each) do
-    mmap = <<-MMAP
-<fmm:MethodMap xmlns:fmm="http://fedora.comm.nsdlib.org/service/methodmap" name="Fedora MethodMap for listing collection members">
-<fmm:Method operationName="getDocumentStyle1"/>
-<fmm:Method operationName="getDocumentStyle2"/>
-</fmm:MethodMap>
-    MMAP
-    @repository = ActiveFedora::Base.connection_for_pid(0)
-    allow(@repository).to receive(:datastream_dissemination).with({:pid=>'test:12',:dsid=>'METHODMAP'}).and_return mmap
-    Test.has_service_definition "test:12"
-  end
-
-  subject { 
-      obj = Test.new()
-      allow(obj).to receive(:pid).and_return('monkey:99')
-      obj
-    }
-  describe "method lookup" do
-    it "should find method keys in the YAML config" do
-      expect(ActiveFedora::ServiceDefinitions.lookup_method("fedora-system:3", "viewObjectProfile")).to eq(:object_profile)
-    end
-  end
-  describe "method creation" do
-    it "should create the system sdef methods" do
-      expect(subject).to respond_to(:object_profile)
-    end
-    it "should create the declared sdef methods" do
-      expect(subject).to respond_to(:document_style_1)
-    end
-  end
-  describe "generated method" do
-    it "should call the appropriate rubydora rest api method" do
-      expect(@repository).to receive(:dissemination).with({:pid=>'monkey:99',:sdef=>'test:12', :method=>'getDocumentStyle1'})
-      #@mock_client.stub(:[]).with('objects/monkey%3A99/methods/test%3A12/getDocumentStyle1')
-
-      subject.document_style_1
-    end
-    it "should call the appropriate rubydora rest api method with parameters" do
-      expect(@repository).to receive(:dissemination).with({:pid=>'monkey:99',:sdef=>'test:12', :method=>'getDocumentStyle1', :format=>'xml'})
-      obj = Test.new()
-      allow(obj).to receive(:pid).and_return('monkey:99')
-      obj.document_style_1({:format=>'xml'})
-    end
-    it "should call the appropriate rubydora rest api method with a block" do
-      allow(@repository).to receive(:dissemination).with({:pid=>'monkey:99',:sdef=>'test:12', :method=>'getDocumentStyle1'}).and_yield "ping!","pang!"
-      obj = Test.new()
-      allow(obj).to receive(:pid).and_return('monkey:99')
-      block_response = ""
-      obj.document_style_1 {|res,req|
-        block_response += 'pong!' if res == "ping!" and req == "pang!"
-      }
-      expect(block_response).to eq("pong!")
-    end
-  end
-end

data/spec/unit/solr_digital_object_spec.rb

@@ -1,97 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::SolrDigitalObject do
-  describe "repository" do
-    subject { ActiveFedora::SolrDigitalObject.new({},{'datastreams'=>{}}) }
-    describe "when not finished" do
-      it "should not respond_to? :repository" do
-        expect(subject).not_to respond_to :repository
-      end
-    end
-    describe "when finished" do
-      before do
-        subject.freeze
-      end
-      it "should respond_to? :repository" do
-        expect(subject).to respond_to :repository
-      end
-    end
-  end
-
-  describe "fetch" do
-    before do
-      class MyDatastream
-        def initialize(_, _)
-        end
-
-        def primary_solr_name(field)
-          return if field == :publisher
-          "#{field}_tesim"
-        end
-        def self.type(field)
-          :string
-        end
-      end
-      class MyModel < ActiveFedora::Base
-        has_metadata 'descMetadata', type: MyDatastream
-        has_attributes :title, :author, :publisher, datastream: 'descMetadata'
-      end
-
-    end
-    after do
-      Object.send(:remove_const, :MyModel)
-      Object.send(:remove_const, :MyDatastream)
-    end
-    subject { ActiveFedora::SolrDigitalObject.new({'title_tesim' => 'foo'},{'datastreams'=>{}}, MyModel) }
-    it "the default should be nil" do
-      expect(subject.fetch('author')).to be_empty
-    end
-    it "should grab values" do
-      expect(subject.fetch('title')).to eq ['foo']
-    end
-    it "should grab values" do
-      expect(subject.fetch('title')).to eq ['foo']
-    end
-
-    it "should raise an error if the field isn't indexed" do
-      expect{subject.fetch('publisher')}.to raise_error KeyError, "Tried to fetch `publisher' from solr, but it isn't indexed."
-    end
-
-  end
-
-  describe "initializing" do
-    describe "without a datastream in the ds spec and an xml mime type in the solr doc" do
-      before do
-        class WithoutMetadataDs < ActiveFedora::Base
-          ## No datastreams are defined in this class
-        end
-      end
-      after do
-        Object.send(:remove_const, :WithoutMetadataDs)
-      end
-      subject { ActiveFedora::SolrDigitalObject.new({}, {'datastreams'=>{'properties'=>{'dsMIME'=>'text/xml'}}},WithoutMetadataDs) }
-      it "should create an xml datastream" do
-        expect(subject.datastreams['properties']).to be_kind_of ActiveFedora::OmDatastream
-      end
-
-      its(:new_record?) { should be_falsey }
-    end
-    
-    describe "with a ds spec that's not part of the solrized object" do
-      before do
-        class MissingMetadataDs < ActiveFedora::Base
-          has_metadata :name => "foo", :type => ActiveFedora::OmDatastream, :label => 'Foo Data'
-        end
-        after do
-          Object.send(:remove_const, MissingMetadataDs)
-        end
-        subject { ActiveFedora::SolrDigitalObject.new({}, {'datastreams'=>{'properties'=>{'dsMIME'=>'text/xml'}}},MissingMetadataDs) }
-        it "should have a foo datastream" do
-          subject.datastreams['foo'].label.should == 'Foo Data'
-        end
-      end
-    end
-  end
-
-
-end

data/spec/unit/unsaved_digital_object_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::UnsavedDigitalObject do
-  
-  describe "an unsaved instance" do
-    subject { ActiveFedora::UnsavedDigitalObject.new(ActiveFedora::Base, 'bar') }
-
-    it { is_expected.to be_new_record}
-
-    it "should have ownerId property" do
-      subject.ownerId = 'fooo'
-      expect(subject.ownerId).to eq('fooo')
-    end
-
-    it "should have state" do
-      subject.ownerId = 'D'
-      expect(subject.ownerId).to eq('D')
-    end
-
-    it "should not have a default pid" do
-      expect(subject.pid).to be_nil
-    end
-    it "should be able to set the pid" do
-      subject.pid = "my:new_object"
-      expect(subject.pid).to eq("my:new_object")
-    end
-  end
-
-
-  describe "#save" do
-    before :all do
-      obj = ActiveFedora::UnsavedDigitalObject.new(ActiveFedora::Base, 'bar') 
-      obj.label = 'my label'
-      obj.ownerId = 'fooo'
-      @saved_obj = obj.save
-    end
-    it "should be a digital object" do
-      expect(@saved_obj).to be_kind_of ActiveFedora::DigitalObject
-    end
-    it "should set the ownerId property" do
-      expect(@saved_obj.ownerId).to eq('fooo')
-    end
-    it "should set the label property" do
-      expect(@saved_obj.label).to eq('my label')
-    end
-  end
-
-end