pacer 0.9.1.1-java → 1.0.0-java

data/spec/pacer/wrapper/edge_wrapper_spec.rb

@@ -15,7 +15,11 @@ Run.all :read_only do
     its(:extensions) { should == e_exts }
 
     describe 'instance' do
-      subject { e_wrapper_class.new pangloss_wrote_pacer }
+      subject do
+        e = e_wrapper_class.new pangloss_wrote_pacer.element
+        e.graph = graph
+        e
+      end
       it               { should_not be_nil }
       its(:element)    { should_not be_nil }
       it               { should == pangloss_wrote_pacer }
@@ -24,10 +28,126 @@ Run.all :read_only do
       its(:extensions) { should == e_exts }
 
       describe 'with more extensions added' do
-        subject { e_wrapper_class.new(pacer).add_extensions([Pacer::Utils::TSort]) }
+        subject { e_wrapper_class.new(pacer.element).add_extensions([Pacer::Utils::TSort]) }
         its(:class) { should_not == e_wrapper_class }
         its(:extensions) { should == e_exts + [Pacer::Utils::TSort] }
       end
     end
   end
 end
+
+shared_examples_for Pacer::Wrappers::EdgeWrapper do
+  use_simple_graph_data
+
+  describe '#e' do
+    subject { e0.e }
+    it { should be_an_edges_route }
+    its(:element_type) { should == :edge }
+  end
+
+  describe '#add_extensions' do
+    context 'no extensions' do
+      subject { e0.add_extensions([]) }
+      its('extensions.to_a') { should == [] }
+      its(:class) { should == Pacer::Wrappers::EdgeWrapper }
+    end
+
+    context 'with extensions' do
+      subject { e0.add_extensions([Tackle::SimpleMixin]) }
+      its('extensions.to_a') { should == [Tackle::SimpleMixin] }
+      it { should be_a(Pacer::Wrappers::ElementWrapper) }
+      it { should be_a(Pacer::Wrappers::EdgeWrapper) }
+      it { should_not be_a(Pacer::Wrappers::VertexWrapper) }
+
+      describe '#e' do
+        subject { e0.add_extensions([Tackle::SimpleMixin]).e }
+        its('extensions.to_a') { should == [Tackle::SimpleMixin] }
+        it { should be_an_edges_route }
+        it { should be_a(Tackle::SimpleMixin::Route) }
+      end
+    end
+  end
+
+  describe '#delete!' do
+    before do
+      @edge_id = e0.element_id
+      e0.delete!
+      c = example.metadata[:graph_commit]
+      c.call if c
+    end
+    it 'should be removed' do
+      graph.edge(@edge_id).should be_nil
+    end
+  end
+
+  contexts(
+  'into new tg' => proc {
+    let(:dest) { Pacer.tg }
+  },
+  'into graph2' => proc {
+    let(:dest) { graph2 }
+  }) do
+    describe '#clone_into', :transactions => false do
+      before { pending 'support temporary hash indices for clone/copy' unless graph.features.supportsIndices }
+      context 'including vertices' do
+        subject { e0.clone_into(dest, :create_vertices => true) }
+
+        its('element_id.to_s') { should == e0.element_id.to_s unless graph.features.ignoresSuppliedIds }
+        its(:label) { should == 'links' }
+        its(:graph) { should equal(dest) }
+        its('in_vertex.properties') { should == { 'name' => 'eliza' } }
+        its('out_vertex.properties') { should == { 'name' => 'darrick' } }
+      end
+
+      context 'without vertices' do
+        subject { e0.clone_into(dest) rescue nil }
+        it { should be_nil }
+
+        context 'but already existing' do
+          before do
+            v0.clone_into(dest)
+            v1.clone_into(dest)
+          end
+          subject { e0.clone_into(dest) }
+          its('element_id.to_s') { should == e0.element_id.to_s unless graph.features.ignoresSuppliedIds }
+          its(:label) { should == 'links' }
+          its(:graph) { should equal(dest) }
+          its('in_vertex.properties') { should == { 'name' => 'eliza' } }
+          its('out_vertex.properties') { should == { 'name' => 'darrick' } }
+        end
+      end
+    end
+
+    describe '#copy_into', :transactions => false do
+      before { pending unless graph.features.supportsIndices }
+      subject { v0.clone_into(dest); v1.clone_into(dest); e0.copy_into(dest) }
+      its(:label) { should == 'links' }
+      its(:graph) { should equal(dest) }
+      its('in_vertex.properties') { should == { 'name' => 'eliza' } }
+      its('out_vertex.properties') { should == { 'name' => 'darrick' } }
+    end
+
+  end
+
+  subject { e0 }
+  its(:graph) { should equal(graph) }
+  its(:display_name) { should == "#{ v0.element_id }-links-#{ v1.element_id }" }
+  its(:inspect) { should == "#<E[#{ e0.element_id }]:#{ v0.element_id }-links-#{ v1.element_id }>" }
+  context 'with label proc' do
+    before do
+      graph.edge_name = proc { |e| "some name" }
+    end
+    its(:display_name) { should == "some name" }
+    its(:inspect) { should == "#<E[#{ e0.element_id }]:some name>" }
+  end
+
+  context '', :transactions => true do
+    it { should_not == e1 }
+    it { should == e0 }
+    it { should_not == v0 }
+  end
+end
+
+Run.all do
+  it_uses Pacer::Wrappers::EdgeWrapper
+end

data/spec/pacer/wrapper/element_wrapper_spec.rb

@@ -1,11 +1,297 @@
 require 'spec_helper'
-require 'pacer/graph/element_mixin_spec'
 
+shared_examples_for Pacer::Wrappers::ElementWrapper do
+  context 'vertex' do
+    subject { v0 }
+    it { should be_a(Pacer::Core::Graph::VerticesRoute) }
+    it { should be_a(Pacer::Wrappers::ElementWrapper) }
+    it { should be_a(Pacer::Wrappers::VertexWrapper) }
+    it { should_not be_a(Pacer::Wrappers::EdgeWrapper) }
+
+    describe '#v' do
+      context '()' do
+        subject { v0.v }
+        its(:to_a) { should == [v0] }
+        it { should be_a_vertices_route }
+      end
+
+      context '(:name => "eliza")' do
+        subject { v0.v(:name => 'eliza') }
+        its(:to_a) { should == [v0] }
+        it { should be_a_vertices_route }
+      end
+
+      context '(:name => "other")' do
+        subject { v0.v(:name => 'other') }
+        its(:to_a) { should == [] }
+        it { should be_a_vertices_route }
+      end
+
+      context '(SimpleMixin)' do
+        subject { v0.v(Tackle::SimpleMixin) }
+        its(:to_a) { should == [v0] }
+        it { should be_a_vertices_route }
+        its(:extensions) { should == [Tackle::SimpleMixin] }
+        its(:element_type) { should == :vertex }
+      end
+    end
+
+    describe '#e' do
+      it 'is unsupported' do
+        expect { v0.e }.to raise_error(Pacer::UnsupportedOperation)
+      end
+    end
+
+    describe '#eql?' do
+      subject { Hash.new(0) }
+      before do
+        subject[v0] += 1
+        subject[graph.v.first] += 1
+      end
+
+      its(:keys) { should == [v0] }
+      its(:values) { should == [2] }
+
+      it 'should put wrapped vertices in the same key' do
+        subject[v0.v(Tackle::SimpleMixin).first] += 1
+        subject.values.should == [3]
+      end
+
+      it 'should put other vertices in a different key' do
+        subject[v1].should == 0
+        subject[v0].should == 2
+      end
+    end
+  end
+
+  context 'edge' do
+    subject { e0 }
+    it { should be_a(Pacer::Core::Graph::EdgesRoute) }
+    it { should be_a(Pacer::Wrappers::ElementWrapper) }
+    it { should be_a(Pacer::Wrappers::EdgeWrapper) }
+    it { should_not be_a(Pacer::Wrappers::VertexWrapper) }
+
+    describe '#e', :transactions => false do
+      context '()' do
+        subject { e0.e }
+        its(:to_a) { should == [e0] }
+        it(:a => :b) { should be_an_edges_route }
+      end
+
+      context '(:links)' do
+        subject { e0.e(:links) }
+        its(:to_a) { should == [e0] }
+        it { should be_an_edges_route }
+      end
+
+      context '(:other)' do
+        subject { e0.e(:other) }
+        its(:to_a) { should == [] }
+        it { should be_an_edges_route }
+      end
+
+      context '(SimpleMixin)' do
+        subject { e0.e(Tackle::SimpleMixin) }
+        its(:to_a) { should == [e0] }
+        it { should be_an_edges_route }
+        its(:extensions) { should == [Tackle::SimpleMixin] }
+      end
+    end
+
+    describe '#v' do
+      it 'is unsupported' do
+        expect { e0.v }.to raise_error(Pacer::UnsupportedOperation)
+      end
+    end
+
+    describe '#eql?', :transactions => false do
+      subject { Hash.new(0) }
+      before do
+        subject[e0] += 1
+        subject[graph.e.first] += 1
+      end
+
+      its(:keys) { should == [e0] }
+      its(:values) { should == [2] }
+
+      it 'should put wrapped edges in the same key' do
+        subject[e0.e(Tackle::SimpleMixin).first] += 1
+        subject.values.should == [3]
+      end
+
+      it 'should put other edges in a different key' do
+        subject[e1].should == 0
+        subject[e0].should == 2
+      end
+    end
+  end
+
+  describe '#graph' do
+    it { v0.graph.should == graph }
+    it { e0.graph.should == graph }
+  end
+
+  contexts(
+  'vertex' => proc{
+    let(:element) { v0 }
+  },
+  'edge' => proc{
+    let(:element) { e0 }
+  }) do
+    describe '#[]' do
+      context 'value types' do
+        it '(String)' do
+          element[:string] = 'words'
+          element[:string].should == 'words'
+        end
+
+        it '(Array)' do
+          a = [10, 'elements']
+          element[:array] = a
+          element[:array].should == a
+        end
+
+        it '(Hash)' do
+          h = { :elements => 10 }
+          element[:hash] = h
+          element[:hash].should == h
+        end
+
+        it '(Time)' do
+          time = Time.utc 2011, 1, 2, 3, 4, 5
+          element[:time] = time
+          element[:time].should == time
+        end
+
+        it '(Fixnum)' do
+          element[:number] = 123
+          element[:number].should == 123
+        end
+
+        it '(Float)' do
+          element[:float] = 12.345
+          element[:float].should == 12.345
+        end
+
+        it '(Bignum)' do
+          element[:big] = 123321123321123321123321123321123321
+          element[:big].should == 123321123321123321123321123321123321
+        end
+
+        it "('')" do
+          element[:name] = ''
+          element[:name].should be_nil
+          element.property_keys.should_not include('name')
+        end
+
+        it '(nil)' do
+          element[:name] = nil
+          element[:name].should be_nil
+          element.property_keys.should_not include('name')
+        end
+      end
+
+      context 'key types' do
+        it 'String' do
+          element['name'].should == element[:name]
+        end
+
+        it 'Fixnum' do
+          element[123] = 'value'
+          element[123].should == 'value'
+        end
+      end
+    end
+
+    describe '#result', :transactions => false do
+      subject { element.result }
+      it { should equal(element) }
+    end
+
+    describe '#from_graph?' do
+      context 'same graph' do
+        subject { element.from_graph? graph }
+        it { should be_true }
+      end
+      context 'different graph' do
+        subject { element.from_graph? graph2 }
+        it { should be_false }
+      end
+    end
+
+    describe '#properties' do
+      before do
+        element.properties = { :a => 'valuea', :b => 'valueb' }
+      end
+      subject { element.properties }
+      it { should be_a(Hash) }
+      its(:count) { should == 2 }
+      it 'should have the correct vales' do
+        element.properties['a'].should == 'valuea'
+        element.properties['b'].should == 'valueb'
+        element[:a].should == 'valuea'
+        element[:b].should == 'valueb'
+      end
+      it 'should not affect the element if returned values are changed' do
+        element.properties['a'].gsub!(/value/, 'oops')
+        element.properties['a'].should == 'valuea'
+        element[:a].should == 'valuea'
+      end
+      it 'should not affect the element if returned keys are changed' do
+        element.properties.delete('a')
+        element.properties['a'].should == 'valuea'
+        element[:a].should == 'valuea'
+      end
+      it 'should not affect the element if something is added' do
+        element.properties['c'] = 'something'
+        element[:c].should be_nil
+      end
+      context 'existing properties' do
+        before do
+          element.properties = { :a => 'new value', :c => 'value c' }
+        end
+        its(:count) { should == 2 }
+        it 'should have the correct values' do
+          element[:a].should == 'new value'
+          element[:b].should be_nil
+          element[:c].should == 'value c'
+        end
+      end
+    end
+
+    subject { element }
+    its(:element_id) { should_not be_nil }
+    #its(:to_a) { should == [element] }
+  end
+end
+
+Run.all do
+  it_uses Pacer::Wrappers::ElementWrapper do
+    let(:v0) { graph.create_vertex :name => 'eliza' }
+    let(:v1) { graph.create_vertex :name => 'darrick' }
+    let(:e0) { graph.create_edge nil, v0, v1, :links }
+    let(:e1) { graph.create_edge nil, v0, v1, :relinks }
+  end
+
+  context 'vertex' do
+    let(:v0) { graph.create_vertex :name => 'eliza' }
+    subject { v0 }
+    its(:class) { should == Pacer::Wrappers::VertexWrapper  }
+  end
+
+  context 'edge' do
+    let(:v0) { graph.create_vertex :name => 'eliza' }
+    let(:v1) { graph.create_vertex :name => 'darrick' }
+    let(:e0) { graph.create_edge nil, v0, v1, :links }
+    subject { e0 }
+    its(:class) { should == Pacer::Wrappers::EdgeWrapper }
+  end
+end
 Run.all do
   # This runs about 500 specs, basically it should test all the ways
   # that wrappers act the same as native elements
-  describe Pacer::Wrappers::ElementWrapper do
-    it_uses Pacer::ElementMixin do
+  describe 'wrapped elements' do
+    it_uses Pacer::Wrappers::ElementWrapper do
       let(:v0) { graph.create_vertex(Tackle::SimpleMixin, :name => 'eliza') }
       let(:v1) { graph.create_vertex(Tackle::SimpleMixin, :name => 'darrick') }
       let(:e0) { graph.create_edge nil, v0, v1, :links, Tackle::SimpleMixin }