active-fedora 6.8.0 → 7.0.0.pre1

data/spec/unit/attributes_spec.rb

@@ -0,0 +1,314 @@
+require 'spec_helper'
+
+describe ActiveFedora::Base do
+  before :all do
+      class BarStream2 < ActiveFedora::OmDatastream 
+        set_terminology do |t|
+          t.root(:path=>"animals", :xmlns=>"urn:zoobar")
+          t.waterfowl do
+            t.ducks do 
+              t.duck
+            end
+          end
+          t.donkey()
+          t.cow()
+          t.pig()
+          t.horse()
+        end
+
+        def self.xml_template
+              Nokogiri::XML::Document.parse '<animals xmlns="urn:zoobar"> 
+                <waterfowl>
+                  <ducks>
+                    <duck/>
+                  </ducks>
+                </waterfowl>
+                <cow></cow>
+              </animals>'
+        end
+      end
+  end
+  after :all do
+    Object.send(:remove_const, :BarStream2)
+  end
+
+  describe "first level delegation" do 
+    before :all do
+      class BarHistory2 < ActiveFedora::Base
+        has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"someData" do |m|
+          m.field "fubar", :string
+          m.field "bandana", :string
+          m.field "swank", :text
+        end
+        has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"withText" do |m|
+          m.field "fubar", :text
+        end
+        has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"withText2", :label=>"withLabel" do |m|
+          m.field "fubar", :text
+        end 
+
+        has_metadata :type=>BarStream2, :name=>"xmlish"
+        has_attributes :cow, datastream: 'xmlish'                      # for testing the default value of multiple
+        has_attributes :fubar, datastream: 'withText', multiple: true  # test alternate datastream
+        has_attributes :pig, datastream: 'xmlish', multiple: false
+        has_attributes :horse, datastream: 'xmlish', multiple: true
+        has_attributes :duck, datastream: 'xmlish', :at=>[:waterfowl, :ducks, :duck], multiple: true
+      end
+    end
+
+    after :all do
+      Object.send(:remove_const, :BarHistory2)
+    end
+
+    subject { BarHistory2.new }
+
+    describe "inspect" do
+      it "should show the attributes" do
+        expect(subject.inspect).to eq "#<BarHistory2 pid: nil, cow: \"\", fubar: [], pig: nil, horse: [], duck: [\"\"]>"
+      end
+      describe "with a pid" do
+        before { subject.stub(pid: 'test:123') }
+        it "should show a pid" do
+          expect(subject.inspect).to eq "#<BarHistory2 pid: \"test:123\", cow: \"\", fubar: [], pig: nil, horse: [], duck: [\"\"]>"
+        end
+      end
+      describe "with no attributes" do
+        subject { ActiveFedora::Base.new }
+        it "should show a pid" do
+          expect(subject.inspect).to eq "#<ActiveFedora::Base pid: nil>"
+        end
+      end
+
+      describe "with relationships" do
+        before do
+          class BarHistory3 < BarHistory2
+            belongs_to :library, property: :has_constituent, class_name: 'BarHistory2'
+          end
+          subject.library = library
+        end
+        let (:library) { BarHistory2.create }
+        subject {BarHistory3.new}
+        after do 
+          Object.send(:remove_const, :BarHistory3)
+        end
+        it "should show the library_id" do
+          expect(subject.inspect).to eq "#<BarHistory3 pid: nil, cow: \"\", fubar: [], pig: nil, horse: [], duck: [\"\"], library_id: \"#{library.pid}\">"
+        end
+      end
+    end
+
+
+
+    it "should reveal the unique properties" do
+      BarHistory2.unique?(:horse).should be_false
+      BarHistory2.unique?(:pig).should be_true
+      BarHistory2.unique?(:cow).should be_true
+    end
+
+    it "should save a delegated property uniquely" do
+      subject.fubar="Quack"
+      subject.fubar.should == ["Quack"]
+      subject.withText.get_values(:fubar).first.should == 'Quack'
+      subject.cow="Low"
+      subject.cow.should == "Low"
+      subject.xmlish.term_values(:cow).first.should == 'Low'
+
+      subject.pig="Oink"
+      subject.pig.should == "Oink"
+    end
+
+    it "should allow passing parameters to the delegate accessor" do
+      subject.cow=["one", "two"]
+      subject.cow(1).should == 'two'
+    end
+
+    it "should return a single value if not marked as multiple" do
+      subject.cow=["one", "two"]
+      subject.cow.should == "one"
+    end
+
+    it "should return an array if marked as multiple" do
+      subject.horse=["neigh", "whinny"]
+      subject.horse.should == ["neigh", "whinny"]
+    end
+
+    it "should be able to delegate deeply into the terminology" do
+      subject.duck=["Quack", "Peep"]
+      subject.duck.should == ["Quack", "Peep"]
+    end
+
+    it "should be able to track change status" do
+      subject.fubar_changed?.should be_false
+      subject.fubar = "Meow"
+      subject.fubar_changed?.should be_true
+    end
+
+    describe "array getters and setters" do
+      it "should accept symbol keys" do
+        subject[:duck]= ["Cluck", "Gobble"]
+        subject[:duck].should == ["Cluck", "Gobble"]
+      end
+
+      it "should accept string keys" do
+        subject['duck']= ["Cluck", "Gobble"]
+        subject['duck'].should == ["Cluck", "Gobble"]
+      end
+
+      it "should raise an error on the reader when the field isn't delegated" do
+        expect {subject['goose'] }.to raise_error ActiveFedora::UnknownAttributeError, "BarHistory2 does not have an attribute `goose'"
+      end
+
+      it "should raise an error on the setter when the field isn't delegated" do
+        expect {subject['goose']="honk" }.to raise_error ActiveFedora::UnknownAttributeError, "BarHistory2 does not have an attribute `goose'"
+      end
+    end
+
+    describe "attributes=" do
+      it "should raise an error on an invalid attribute" do
+        expect {subject.attributes = {'goose'=>"honk" }}.to raise_error ActiveFedora::UnknownAttributeError, "BarHistory2 does not have an attribute `goose'"
+      end
+    end
+
+    describe "attributes" do
+      let(:vals) { {'cow'=>["moo"], 'pig' => ['oink'], 'horse' =>['neigh'], "fubar"=>[], 'duck'=>['quack'] } }
+      before { subject.attributes = vals }
+      it "should return a hash" do
+        expect(subject.attributes).to eq(vals.merge('id' => nil))
+      end
+    end
+
+  end
+
+  describe "with a superclass" do
+    before :all do
+      class BarHistory2 < ActiveFedora::Base
+        has_metadata 'xmlish', :type=>BarStream2
+        has_attributes :donkey, :cow, datastream: 'xmlish', multiple: true
+      end
+      class BarHistory3 < BarHistory2
+      end
+    end
+
+    after :all do
+      Object.send(:remove_const, :BarHistory3)
+      Object.send(:remove_const, :BarHistory2)
+    end
+
+    subject { BarHistory3.new }
+
+    it "should be able to delegate deeply into the terminology" do
+      subject.donkey=["Bray", "Hee-haw"]
+      subject.donkey.should == ["Bray", "Hee-haw"]
+    end
+
+    it "should be able to track change status" do
+      subject.cow_changed?.should be_false
+      subject.cow = ["Moo"]
+      subject.cow_changed?.should be_true
+    end 
+  end
+
+  describe "with a RDF datastream" do
+    before :all do
+      class BarRdfDatastream < ActiveFedora::NtriplesRDFDatastream
+        map_predicates do |map|
+          map.title(in: RDF::DC)
+          map.description(in: RDF::DC, multivalue: false)
+        end
+      end
+      class BarHistory4 < ActiveFedora::Base
+        has_metadata 'rdfish', :type=>BarRdfDatastream
+        has_attributes :title, :description, datastream: 'rdfish', multiple: true
+      end
+    end
+
+    after :all do
+      Object.send(:remove_const, :BarHistory4)
+      Object.send(:remove_const, :BarRdfDatastream)
+    end
+
+    subject { BarHistory4.new }
+
+    describe "with a multivalued field" do
+      it "should be able to track change status" do
+        subject.title_changed?.should be_false
+        subject.title = ["Title1", "Title2"]
+        subject.title_changed?.should be_true
+      end
+    end
+    describe "with a single-valued field" do
+      it "should be able to track change status" do
+        subject.description_changed?.should be_false
+        subject.description = "A brief description"
+        subject.description_changed?.should be_true
+      end
+    end
+  end 
+
+  describe "without a datastream" do
+    before :all do
+      class BarHistory4 < ActiveFedora::Base
+      end
+    end
+
+    after :all do
+      Object.send(:remove_const, :BarHistory4)
+    end
+
+    subject { BarHistory4}
+
+    it "should raise an error" do
+      expect {subject.has_attributes :title, :description, multiple: true}.to raise_error
+    end
+  end
+
+  describe "when an unknown datastream is specified" do
+    before :all do
+      class BarHistory4 < ActiveFedora::Base
+        has_attributes :description, datastream: 'rdfish', multiple: true
+      end
+    end
+
+    after :all do
+      Object.send(:remove_const, :BarHistory4)
+    end
+
+    subject { BarHistory4.new }
+
+    it "should raise an error on get" do
+      expect {subject.description}.to raise_error(ArgumentError, "Undefined datastream id: `rdfish' in has_attributes")
+    end
+
+    it "should raise an error on set" do
+      expect {subject.description = 'Neat'}.to raise_error(ArgumentError, "Undefined datastream id: `rdfish' in has_attributes")
+    end
+  end
+
+  describe "when a datastream is specified as a symbol" do
+    before :all do
+      class BarRdfDatastream < ActiveFedora::NtriplesRDFDatastream
+        map_predicates do |map|
+          map.title(in: RDF::DC)
+          map.description(in: RDF::DC)
+        end
+      end
+      class BarHistory4 < ActiveFedora::Base
+        has_metadata 'rdfish', :type=>BarRdfDatastream
+        has_attributes :description, datastream: :rdfish
+      end
+    end
+
+    after :all do
+      Object.send(:remove_const, :BarHistory4)
+      Object.send(:remove_const, :BarRdfDatastream)
+    end
+
+    subject { BarHistory4.new(description: 'test1') }
+
+    it "should be able to access the attributes" do
+      expect(subject.description).to eq 'test1'
+    end
+  end
+end
+
+

data/spec/unit/base_active_model_spec.rb

@@ -1,54 +1,54 @@
 require 'spec_helper'
 
 describe ActiveFedora::Base do
-  describe 'active model methods' do
-    class BarStream < ActiveFedora::OmDatastream
+  describe "active model methods" do 
+    class BarStream < ActiveFedora::OmDatastream 
       set_terminology do |t|
-        t.root(:path => 'first', :xmlns => 'urn:foobar')
+        t.root(:path=>"first", :xmlns=>"urn:foobar")
         t.duck()
       end
 
       def self.xml_template
-            Nokogiri::XML::Document.parse '<first xmlns="urn:foobar">
+            Nokogiri::XML::Document.parse '<first xmlns="urn:foobar"> 
               <duck></duck>
             </first>'
       end
     end
 
     class BarHistory < ActiveFedora::Base
-      has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'someData' do |m|
-        m.field 'fubar', :string
-        m.field 'swank', :text
+      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"someData" do |m|
+        m.field "fubar", :string
+        m.field "swank", :text
       end
-      has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'withText' do |m|
-        m.field 'fubar', :text
-      end
-      has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'withText2', :label => 'withLabel' do |m|
-        m.field 'fubar', :text
+      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"withText" do |m|
+        m.field "fubar", :text
       end
+      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"withText2", :label=>"withLabel" do |m|
+        m.field "fubar", :text
+      end 
 
-      has_metadata :type => BarStream, :name => 'xmlish'
-      delegate :fubar, to: 'withText', multiple: false
-      delegate :duck, to: 'xmlish', multiple: false
+      has_metadata :type=>BarStream, :name=>"xmlish"
+      has_attributes :fubar, datastream: 'withText', multiple: false
+      has_attributes :duck, datastream: 'xmlish', multiple: false
     end
     before :each do
       @n = BarHistory.new()
     end
-    describe 'attributes=' do
-      it 'should set attributes' do
-        @n.attributes = {:fubar => 'baz', :duck => 'Quack'}
-        expect(@n.fubar).to eq('baz')
-        expect(@n.withText.get_values(:fubar).first).to eq('baz')
-        expect(@n.duck).to eq('Quack')
-        expect(@n.xmlish.term_values(:duck).first).to eq('Quack')
+    describe "attributes=" do
+      it "should set attributes" do
+        @n.attributes = {:fubar=>"baz", :duck=>"Quack"}
+        @n.fubar.should == "baz"
+        @n.withText.get_values(:fubar).first.should == 'baz'
+        @n.duck.should == "Quack"
+        @n.xmlish.term_values(:duck).first.should == 'Quack'
       end
     end
-    describe 'update_attributes' do
-      it 'should set attributes and save ' do
-        @n.update_attributes(:fubar => 'baz', :duck => 'Quack')
+    describe "update_attributes" do
+      it "should set attributes and save " do
+        @n.update_attributes(:fubar=>"baz", :duck=>"Quack")
         @q = BarHistory.find(@n.pid)
-        expect(@q.fubar).to eq('baz')
-        expect(@q.duck).to eq('Quack')
+        @q.fubar.should == "baz"
+        @q.duck.should == "Quack"
       end
       after do
         @n.delete
@@ -57,3 +57,4 @@ describe ActiveFedora::Base do
 
   end
 end
+

data/spec/unit/base_cma_spec.rb

@@ -1,16 +1,16 @@
 require 'spec_helper'
 
 describe ActiveFedora::Base do
-
+  
   before(:each) do
     @test_object = ActiveFedora::Base.new
   end
-
+  
   describe '.save' do
 
-    it 'should add hasModel relationship that points to the CModel if @new_object' do
-      allow(@test_object).to receive(:update_index)
-      expect(@test_object).to receive(:refresh)
+    it "should add hasModel relationship that points to the CModel if @new_object" do
+      @test_object.stub(:update_index)
+      @test_object.should_receive(:refresh)
       @test_object.save
     end
   end

data/spec/unit/base_datastream_management_spec.rb

@@ -1,57 +1,57 @@
 require 'spec_helper'
 
 describe ActiveFedora::Base do
-
+  
   before(:each) do
     @test_object = ActiveFedora::Base.new
   end
-
+  
   describe '.generate_dsid' do
-    it 'should return a dsid that is not currently in use' do
-      dsids = Hash['DS1' => 1, 'DS2' => 1]
-      expect(@test_object).to receive(:datastreams).and_return(dsids)
+    it "should return a dsid that is not currently in use" do
+      dsids = Hash["DS1"=>1, "DS2"=>1]
+      @test_object.should_receive(:datastreams).and_return(dsids)
       generated_id = @test_object.generate_dsid
-      expect(generated_id).not_to be_nil
-      expect(generated_id).to eq('DS3')
+      generated_id.should_not be_nil
+      generated_id.should == "DS3"
     end
-    it 'should accept a prefix argument, default to using DS as prefix' do
-      expect(@test_object.generate_dsid('FOO')).to eq('FOO1')
+    it "should accept a prefix argument, default to using DS as prefix" do
+      @test_object.generate_dsid("FOO").should == "FOO1"  
     end
 
-    it 'if delete a datastream it should still use next index for a prefix' do
-      dsids = Hash['DS2' => 1]
-      expect(@test_object).to receive(:datastreams).and_return(dsids)
+    it "if delete a datastream it should still use next index for a prefix" do
+      dsids = Hash["DS2"=>1]
+      @test_object.should_receive(:datastreams).and_return(dsids)
       generated_id = @test_object.generate_dsid
-      expect(generated_id).not_to be_nil
-      expect(generated_id).to eq('DS3')
+      generated_id.should_not be_nil
+      generated_id.should == "DS3"
     end
   end
   describe '.add_datastream' do
-    it 'should not call Datastream.save' do
+    it "should not call Datastream.save" do
       ds = ActiveFedora::Datastream.new(@test_object.inner_object, 'ds_to_add')
-      expect(ds).to receive(:save).never
+      ds.should_receive(:save).never
       @test_object.add_datastream(ds)
     end
-    it 'should add the datastream to the datastreams_in_memory array' do
+    it "should add the datastream to the datastreams_in_memory array" do
       ds = ActiveFedora::Datastream.new(@test_object.inner_object, 'ds_to_add')
-      expect(@test_object.datastreams).not_to have_key(ds.dsid)
+      @test_object.datastreams.should_not have_key(ds.dsid)
       @test_object.add_datastream(ds)
-      expect(@test_object.datastreams).to have_key(ds.dsid)
+      @test_object.datastreams.should have_key(ds.dsid)
     end
-    it 'should auto-assign dsids using auto-incremented integers if dsid is nil or an empty string' do
+    it "should auto-assign dsids using auto-incremented integers if dsid is nil or an empty string" do 
       ds = ActiveFedora::Datastream.new(@test_object.inner_object, nil)
-      expect(ds.dsid).to be_nil
+      ds.dsid.should == nil
       ds_emptystringid = ActiveFedora::Datastream.new(@test_object.inner_object, '')
       @test_object.stub(:generate_dsid => 'foo')
      # ds.should_receive(:dsid=).with("foo")
-      expect(@test_object.add_datastream(ds)).to eq('foo')
-      expect(@test_object.add_datastream(ds_emptystringid)).to eq('foo')
+      @test_object.add_datastream(ds).should == 'foo'
+      @test_object.add_datastream(ds_emptystringid).should == 'foo'
     end
-    it 'should accept a prefix option and apply it to automatically assigned dsids' do
+    it "should accept a prefix option and apply it to automatically assigned dsids" do
       ds = ActiveFedora::Datastream.new(@test_object.inner_object, nil)
-      expect(ds.dsid).to be_nil
-      @test_object.stub(:generate_dsid => 'FOO')
-      expect(@test_object.add_datastream(ds, :prefix => 'FOO')).to eq('FOO')
+      ds.dsid.should == nil
+      @test_object.stub(:generate_dsid => "FOO")
+      @test_object.add_datastream(ds, :prefix => "FOO").should == 'FOO'
     end
   end
 end