active-triples 0.7.6 → 0.8.0

data/spec/active_triples/persistence_strategies/persistence_strategy_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe ActiveTriples::PersistenceStrategy do
+  let(:klass) { Class.new { include ActiveTriples::PersistenceStrategy } }
+  subject { klass.new }
+
+  describe '#persist!' do
+    it 'raises as not implemented' do
+      expect { subject.persist! }.to raise_error NotImplementedError 
+    end
+  end
+
+  describe '#erase_old_resource' do
+    it 'raises as not implemented' do
+      expect { subject.erase_old_resource }.to raise_error NotImplementedError 
+    end
+  end
+
+  describe '#reload' do
+    it 'raises as not implemented' do
+      expect { subject.reload }.to raise_error NotImplementedError 
+    end
+  end
+end

data/spec/active_triples/persistence_strategies/repository_strategy_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe ActiveTriples::RepositoryStrategy do
+  subject { described_class.new(rdf_source) }
+  let(:rdf_source) { ActiveTriples::Resource.new }
+
+  let(:statement) do
+    RDF::Statement.new(rdf_source.to_term, RDF::DC.title, 'moomin')
+  end
+
+  it_behaves_like 'a persistence strategy'
+
+  shared_context 'with repository' do
+    before do
+      allow(subject.obj.singleton_class).to receive(:repository)
+                                             .and_return(:my_repo)
+    end
+  end
+
+  describe '#destroy' do
+    shared_examples 'destroy resource' do
+      it 'removes the resource from the repository' do
+        subject.persist!
+        expect { subject.destroy }
+          .to change { subject.repository.count }.from(1).to(0)
+      end
+    end
+
+    it 'marks resource as destroyed' do
+      subject.destroy
+      expect(subject).to be_destroyed
+    end
+
+    it 'leaves other resources unchanged' do
+      subject.repository <<
+        RDF::Statement(RDF::Node.new, RDF::DC.title, 'snorkmaiden')
+      expect { subject.destroy }
+        .not_to change { subject.repository.count }
+    end
+
+    context 'with statements' do
+      before { rdf_source << statement }
+
+      include_examples 'destroy resource'
+
+      context 'with subjects' do
+        before do
+          subject.obj.set_subject! RDF::URI('http://example.org/moomin')
+        end
+
+        include_examples 'destroy resource'
+      end
+    end
+  end
+
+  describe '#destroyed?' do
+    it 'is false' do
+      expect(subject).not_to be_destroyed
+    end
+  end
+
+  describe '#persist!' do
+    it 'writes to #repository' do
+      rdf_source << statement
+      subject.persist!
+      expect(subject.repository.statements)
+          .to contain_exactly *rdf_source.statements
+    end
+  end
+
+  describe '#erase_old_resource' do
+    it 'removes statements with subject from the repository'
+    it 'removes statements about node from the repository'
+  end
+
+  describe '#reload' do
+    it 'when both repository and object are empty returns true' do
+      expect(subject.reload).to be true
+    end
+
+    context 'with unknown content in repo' do
+      include_context 'with repository' do
+        before do
+          allow(ActiveTriples::Repositories.repositories)
+            .to receive(:[]).with(:my_repo).and_return(repo)
+          repo << statement
+        end
+
+        let(:repo) { RDF::Repository.new }
+      end
+    end
+  end
+
+  describe '#repository' do
+    it 'gives a repository when none is configured' do
+      expect(subject.repository).to be_a RDF::Repository
+    end
+
+    it 'defaults to an ad-hoc in memory RDF::Repository' do
+      expect(subject.repository).to be_ephemeral
+    end
+
+    context 'with repository configured' do
+      include_context 'with repository'
+
+      let(:repo) { double('repo') }
+
+      it 'when repository is not registered raises an error' do
+        expect { subject.repository }
+          .to raise_error ActiveTriples::RepositoryNotFoundError
+      end
+
+      it 'gets repository' do
+        allow(ActiveTriples::Repositories.repositories)
+          .to receive(:[]).with(:my_repo).and_return(repo)
+        expect(subject.repository).to eq repo
+      end
+    end
+  end
+end

data/spec/active_triples/rdf_source_spec.rb

@@ -1,18 +1,226 @@
 require 'spec_helper'
+require 'rdf/spec/enumerable'
+require 'rdf/spec/queryable'
+require 'rdf/spec/countable'
+require 'rdf/spec/mutable'
 
 describe ActiveTriples::RDFSource do
+  before { @enumerable = subject }
   let(:source_class) { Class.new { include ActiveTriples::RDFSource } }
+  let(:uri) { RDF::URI('http://example.org/moomin') }
 
   subject { source_class.new }
 
-  describe "#fetch" do
-    it "passes extra arguments to RDF::Reader" do
-      expect(RDF::Reader).to receive(:open).with(subject.rdf_subject,
-                                                 { base_uri: subject.rdf_subject,
-                                                   headers: { Accept: 'x-humans/as-they-are' } })
-      subject.fetch(headers: { Accept: 'x-humans/as-they-are' })
+  describe 'RDF interface' do
+    it { is_expected.to be_enumerable }
+    it { is_expected.to be_queryable }
+    it { is_expected.to be_countable }
+    it { is_expected.to be_a_value }
+    # it { is_expected.to be_a_term }
+    # it { is_expected.to be_a_resource }
+
+    let(:enumerable) { source_class.new }
+    it_behaves_like 'an RDF::Enumerable'
+
+    let(:queryable) { enumerable }
+    it_behaves_like 'an RDF::Queryable'
+
+    let(:countable) { enumerable }
+    it_behaves_like 'an RDF::Countable'
+
+    let(:mutable) { enumerable }
+    it_behaves_like 'an RDF::Mutable'
+
+    describe 'Term behavior' do
+      it { is_expected.to be_term }
+
+      it 'is termified when added to an Statement' do
+        expect(RDF::Statement(subject, nil, nil).subject).to eq subject
+      end
+
+      context 'as a node' do
+        describe '#uri?' do
+          it { is_expected.not_to be_uri }
+        end
+
+        describe '#node?' do
+          it { is_expected.to be_node }
+        end
+
+        describe '#to_term' do
+          its(:to_term) { is_expected.to be_node }
+        end
+
+        describe '#to_base' do
+          its(:to_base) { is_expected.to be_a String }
+          its(:to_base) { is_expected.to eq subject.to_term.to_base }
+        end
+      end
+
+      context 'as a uri' do
+        subject { source_class.new(uri) }
+
+        describe '#uri?' do
+          it { is_expected.to be_uri }
+        end
+
+        describe '#node?' do
+          it { is_expected.not_to be_node }
+        end
+
+        describe '#to_term' do
+          its(:to_term) { is_expected.to be_uri }
+        end
+
+        describe '#to_uri' do
+          its(:to_uri) { is_expected.to be_uri }
+        end
+
+        describe '#to_base' do
+          its(:to_base) { is_expected.to be_a String }
+          its(:to_base) { is_expected.to eq subject.to_term.to_base }
+        end
+      end
+    end
+  end
+
+  describe '#==' do
+    shared_examples 'Term equality' do
+      it 'equals itself' do
+        expect(subject).to eq subject
+      end
+
+      it 'equals its own Term' do
+        expect(subject).to eq subject.to_term
+      end
+
+      it 'is symmetric' do
+        expect(subject.to_term).to eq subject
+      end
+
+      it 'does not equal another term' do
+        expect(subject).not_to eq RDF::Node.new
+      end
+    end
+
+    include_examples 'Term equality'
+
+    context 'with a URI' do
+      include_examples 'Term equality' do
+        subject { source_class.new(uri) }
+      end
+    end
+  end
+
+  describe '#id' do
+  end
+
+  describe '#humanize' do
+    it 'gives the "" for a node' do
+      expect(subject.humanize).to eq ''
+    end
+
+    it 'gives a URI string for a URI resource' do
+      allow(subject).to receive(:rdf_subject).and_return(uri)
+      expect(subject.humanize).to eq uri.to_s
+    end
+  end
+
+  describe '#rdf_subject' do
+    its(:rdf_subject) { is_expected.to be_a_node }
+
+    context 'with a URI' do
+      subject { source_class.new(uri) }
+
+      its(:rdf_subject) { is_expected.to be_a_uri }
+      its(:rdf_subject) { is_expected.to eq uri }
+    end
+  end
+
+  describe '#set_value' do
+    it 'raises argument error when given too many arguments' do
+      expect { subject.set_value(double, double, double, double) }
+        .to raise_error ArgumentError
+    end
+
+    it 'sets a value'
+  end
+
+  describe "inheritance" do
+    before do
+      class PrincipalResource
+        include ActiveTriples::RDFSource
+
+        configure type: RDF::FOAF.Agent
+        property :name, predicate: RDF::FOAF.name
+      end
+
+      class UserSource < PrincipalResource
+        configure type: RDF::FOAF.Person
+      end
+
+      class DummySource
+        include ActiveTriples::RDFSource
+
+        property :creator, predicate: RDF::DC.creator
+      end
+    end
+
+    after do
+      Object.send(:remove_const, :PrincipalResource)
+      Object.send(:remove_const, :UserSource)
+      Object.send(:remove_const, :DummySource)
+    end
+
+    let(:dummy) { DummySource.new }
+    let(:bob) { UserSource.new.tap {|u| u.name = "bob"} }
+    let(:sally) { UserSource.new.tap {|u| u.name = "sally"} }
+
+    it "should replace values" do
+      dummy.creator = bob
+      expect(dummy.creator).to eq [bob]
+      dummy.creator = sally
+      expect(dummy.creator).to eq [sally]
+    end
+  end
+
+  describe 'validation' do
+    it { is_expected.to be_valid }
+
+    it 'is valid with valid statements' do
+      subject.insert(*RDF::Spec.quads)
+      expect(subject).to be_valid
+    end
+
+    it 'is valid with valid URI' do
+      source_class.new(uri)
+      expect(subject).to be_valid
+    end
+
+    context 'with invalid URI' do
+      before do
+        allow(subject).to receive(:rdf_subject).and_return(RDF::URI('----'))
+      end
+
+      it { is_expected.not_to be_valid }
+    end
+
+    context 'with invalid statement' do
+      before { subject << RDF::Statement.from([nil, nil, nil]) }
+
+      it 'is invalid' do
+        expect(subject).to be_invalid
+      end
+
+      it 'adds error message' do
+        expect { subject.valid? }
+          .to change { subject.errors.messages }
+               .from({})
+               .to({ base: ["The underlying graph must be valid"] })
+      end
     end
   end
+  let(:dummy_source) { Class.new { include ActiveTriples::RDFSource } }
 
   describe ".apply_schema" do
     before do
@@ -23,10 +231,10 @@ describe ActiveTriples::RDFSource do
     after do
       Object.send(:remove_const, "MyDataModel")
     end
-    it "applies the schema" do
-      source_class.apply_schema MyDataModel
+    it "should apply the schema" do
+      dummy_source.apply_schema MyDataModel
 
-      expect { source_class.new.test_title }.not_to raise_error
+      expect{dummy_source.new.test_title}.not_to raise_error
     end
   end
 end

data/spec/active_triples/relation_spec.rb

@@ -3,6 +3,10 @@ require 'rdf/isomorphic'
 
 describe ActiveTriples::Relation do
 
+  subject do
+    described_class.new(double("parent", reflections: []), double("value args"))
+  end
+
   describe "#rdf_subject" do
     let(:parent_resource) { double("parent resource", reflections: {}) }
 
@@ -11,7 +15,7 @@ describe ActiveTriples::Relation do
     context "when relation has 0 value arguments" do
       before { subject.value_arguments = double(length: 0) }
       it "should raise an error" do
-        expect { subject.send(:rdf_subject) }.to raise_error ArgumentError
+        expect { subject.send(:rdf_subject) }.to raise_error
       end
     end
     context "when term has 1 value argument" do
@@ -35,45 +39,57 @@ describe ActiveTriples::Relation do
     context "when relation has 3 value arguments" do
       before { subject.value_arguments = double(length: 3) }
       it "should raise an error" do
-        expect { subject.send(:rdf_subject)  }.to raise_error ArgumentError
+        expect { subject.send(:rdf_subject)  }.to raise_error
       end
     end
   end
 
   describe "#valid_datatype?" do
-    subject { described_class.new(double("parent", reflections: []), "value" ) }
-    before { allow(subject.parent).to receive(:rdf_subject) { "parent subject" } }
+    before do
+      allow(subject.parent).to receive(:rdf_subject) { "parent subject" } 
+    end
+
     context "the value is not a Resource" do
       it "should be true if value is a String" do
         expect(subject.send(:valid_datatype?, "foo")).to be true
       end
+
       it "should be true if value is a Symbol" do
         expect(subject.send(:valid_datatype?, :foo)).to be true
       end
+
       it "should be true if the value is a Numeric" do
         expect(subject.send(:valid_datatype?, 1)).to be true
         expect(subject.send(:valid_datatype?, 0.1)).to be true
       end
+
       it "should be true if the value is a Date" do
         expect(subject.send(:valid_datatype?, Date.today)).to be true
       end
+
       it "should be true if the value is a Time" do
         expect(subject.send(:valid_datatype?, Time.now)).to be true
       end
+
       it "should be true if the value is a boolean" do
         expect(subject.send(:valid_datatype?, false)).to be true
         expect(subject.send(:valid_datatype?, true)).to be true
       end
     end
+
     context "the value is a Resource" do
       after { Object.send(:remove_const, :DummyResource) }
+
       let(:resource) { DummyResource.new }
+
       context "and the resource class does not include RDF::Isomorphic" do
         before { class DummyResource; include ActiveTriples::RDFSource; end }
+
         it "should be false" do
           expect(subject.send(:valid_datatype?, resource)).to be false
         end
       end
+
       context "and the resource class includes RDF:Isomorphic" do
         before do
           class DummyResource
@@ -81,10 +97,12 @@ describe ActiveTriples::Relation do
             include RDF::Isomorphic
           end
         end
+
         it "should be false" do
           expect(subject.send(:valid_datatype?, resource)).to be false
         end
       end
+
       context "and the resource class includes RDF::Isomorphic and aliases :== to :isomorphic_with?" do
         before do
           class DummyResource
@@ -93,6 +111,7 @@ describe ActiveTriples::Relation do
             alias_method :==, :isomorphic_with?
           end
         end
+
         it "should be false" do
           expect(subject.send(:valid_datatype?, resource)).to be false
         end
@@ -100,4 +119,32 @@ describe ActiveTriples::Relation do
     end
   end
 
+  describe '#empty_property' do
+
+    before { resource << RDF::Statement(resource, property, 'value') }
+
+    subject { described_class.new(resource, value_args) }
+    let(:resource) { ActiveTriples::Resource.new }
+    let(:property) { RDF::URI.new('http://example.com/moomin') }
+
+    let(:value_args) do
+      double('value args', 
+             length: 1,
+             first: 'first',
+             last: property)
+    end
+
+    it 'deletes values from property' do
+      expect { subject.empty_property }.to change { subject.result }
+                                            .from(['value']).to([])
+    end
+
+    it 'deletes multiple values from property' do
+      values = [Date.today, 'value2', RDF::Node.new, true]
+      resource.set_value(property, values)
+
+      expect { subject.empty_property }.to change { subject.result }
+                                            .from(values).to([])
+    end
+  end
 end