pacer 0.9.1.1-java

data/spec/pacer/graph/vertex_mixin_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+
+shared_examples_for Pacer::VertexMixin do
+  use_simple_graph_data
+
+  describe '#v' do
+    subject { v0.v }
+    it { should be_a_vertices_route }
+    it { should_not be_a(graph.element_type(:vertex)) }
+    it { should_not be_an_instance_of(graph.element_type(:vertex)) }
+  end
+
+  describe '#add_extensions' do
+    context 'no extensions' do
+      subject { v0.add_extensions([]) }
+      its('extensions.to_a') { should == [] }
+      it { should_not be_a(Pacer::Wrappers::ElementWrapper) }
+    end
+
+    context 'with extensions' do
+      subject { v0.add_extensions([Tackle::SimpleMixin]) }
+      its('extensions.to_a') { should == [Tackle::SimpleMixin] }
+      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
+        subject { v0.add_extensions([Tackle::SimpleMixin]).v }
+        its('extensions.to_a') { should == [Tackle::SimpleMixin] }
+        it { should be_a_vertices_route }
+        it { should be_a(Tackle::SimpleMixin::Route) }
+      end
+    end
+  end
+
+  describe '#delete!' do
+    before do
+      @vertex_id = v0.element_id
+      v0.delete!
+      graph.checkpoint # deleted edges in neo may otherwise still be looked up during the transaction
+    end
+    it 'should be removed' do
+      graph.vertex(@vertex_id).should be_nil
+    end
+  end
+
+  contexts(
+  'into new tg' => proc {
+    let(:dest) { Pacer.tg }
+  },
+  'into graph2' => proc {
+    before { pending 'support temporary hash indices for clone/copy' unless graph.supports_manual_indices? }
+    let(:dest) { graph2 }
+  }) do
+    describe '#clone_into', :transactions => false do
+      subject { v0.clone_into(dest) }
+      its(:properties) { should == { 'name' => 'eliza' } }
+      its(:graph) { should equal(dest) }
+      its('element_id.to_s') { should == v0.element_id.to_s if graph.supports_custom_element_ids? }
+    end
+
+    describe '#copy_into', :transaction => false do
+      subject { v1.copy_into(dest) }
+      its(:properties) { should == { 'name' => 'darrick' } }
+      its(:graph) { should equal(dest) }
+    end
+  end
+
+  subject { v0 }
+  its(:graph) { should equal(graph) }
+  its(:display_name) { should be_nil }
+  its(:inspect) { should =~ /#<[VM]\[#{v0.element_id}\]>/ }
+  context 'with label proc' do
+    before do
+      graph.vertex_name = proc { |e| "some name" }
+    end
+    its(:display_name) { should == "some name" }
+    its(:inspect) { should =~ /#<[VM]\[#{ v0.element_id }\] some name>/ }
+  end
+  it { should_not == v1 }
+  it { should == v0 }
+  context 'edge with same element id', :transactions => false do
+    it { should_not == e0 }
+  end
+
+  context 'with more data' do
+    let(:from_v) { graph.create_vertex }
+    let(:to_v) { graph.create_vertex }
+
+    before do
+      %w[ a a a b b c ].each do |label|
+        v = graph.create_vertex
+        graph.create_edge nil, from_v, v, label
+        graph.create_edge nil, v, to_v, label
+      end
+    end
+    
+    describe '#in_edges' do
+      specify 'to_v should have 6 in edges' do
+        to_v.in_edges.count.should == 6
+      end
+
+      specify 'to_v should have 3 in edges with label a' do
+        to_v.in_edges('a').count.should == 3
+      end
+
+      specify 'to_v should have 4 in edges with label a or c' do
+        to_v.in_edges('a', 'c').count.should == 4
+      end
+
+      it 'should add an extension' do
+        edge = to_v.in_edges(Tackle::SimpleMixin).first
+        edge.should be_a(Pacer::EdgeMixin)
+        edge.extensions.should include(Tackle::SimpleMixin)
+      end
+
+      it 'should be able to mix labels and mixins as arguments' do
+        edge = to_v.in_edges('a', Tackle::SimpleMixin, 'b').first
+        edge.should be_a(Pacer::EdgeMixin)
+        edge.extensions.should include(Tackle::SimpleMixin)
+      end
+
+      it 'should filter correctly with a mix of labels and mixins as arguments' do
+        to_v.in_edges('a', Tackle::SimpleMixin, 'b').count.should == 5
+      end
+    end
+    
+    describe '#out_edges' do
+      specify 'from_v should have 6 out edges' do
+        from_v.out_edges.count.should == 6
+      end
+
+      specify 'from_v should have 3 out edges with label a' do
+        from_v.out_edges('a').count.should == 3
+      end
+
+      specify 'from_v should have 4 out edges with label a or c' do
+        from_v.out_edges('a', 'c').count.should == 4
+      end
+
+      it 'should add an extension' do
+        edge = from_v.out_edges(Tackle::SimpleMixin).first
+        edge.should be_a(Pacer::EdgeMixin)
+        edge.extensions.should include(Tackle::SimpleMixin)
+      end
+
+      it 'should be able to mix labels and mixins as arguments' do
+        edge = from_v.out_edges('a', Tackle::SimpleMixin, 'b').first
+        edge.should be_a(Pacer::EdgeMixin)
+        edge.extensions.should include(Tackle::SimpleMixin)
+      end
+
+      it 'should filter correctly with a mix of labels and mixins as arguments' do
+        from_v.out_edges('a', Tackle::SimpleMixin, 'b').count.should == 5
+      end
+    end
+    
+    describe '#both_edges' do
+      specify 'from_v should have 6 edges' do
+        from_v.both_edges.count.should == 6
+      end
+
+      specify 'from_v should have 3 edges with label a' do
+        from_v.both_edges('a').count.should == 3
+      end
+
+      specify 'from_v should have 4 edges with label a or c' do
+        from_v.both_edges('a', 'c').count.should == 4
+      end
+
+      it 'should add an extension' do
+        edge = from_v.both_edges(Tackle::SimpleMixin).first
+        edge.should be_a(Pacer::EdgeMixin)
+        edge.extensions.should include(Tackle::SimpleMixin)
+      end
+
+      it 'should be able to mix labels and mixins as arguments' do
+        edge = from_v.both_edges('a', Tackle::SimpleMixin, 'b').first
+        edge.should be_a(Pacer::EdgeMixin)
+        edge.extensions.should include(Tackle::SimpleMixin)
+      end
+
+      it 'should filter correctly with a mix of labels and mixins as arguments' do
+        from_v.both_edges('a', Tackle::SimpleMixin, 'b').count.should == 5
+      end
+    end
+  end
+end
+
+Run.all do
+  it_uses Pacer::VertexMixin
+end

data/spec/pacer/route/mixin/base_spec.rb

@@ -0,0 +1,419 @@
+require 'spec_helper'
+
+Run.all do
+  describe Pacer::Core::Route, 'pipe creation internals' do
+    context "graph.v" do
+      describe '#build_pipeline' do
+        subject { graph.v.send(:build_pipeline) }
+        it { should be_a(Array) }
+        its(:count) { should == 2 }
+        its(:first) { should be_a(com.tinkerpop.pipes.transform.VerticesPipe) }
+        specify { subject.first.should equal(subject.last) }
+      end
+
+      describe '#pipe_source' do
+        subject { graph.v.send(:pipe_source) }
+        it { should be_nil }
+      end
+
+      describe '#iterator' do
+        use_simple_graph_data
+        before { setup_data }
+        subject { graph.v.send(:iterator) }
+        its(:next) { should_not be_nil }
+      end
+    end
+
+    context "graph.v(:name => 'gremlin').as(:grem).in_e(:wrote)" do
+      let(:route) { graph.v(:name => 'gremlin').as(:grem).in_e(:wrote) }
+      subject { route }
+
+      its(:inspect) do
+        should be_one_of "#<V-Index(name: \"gremlin\") -> :grem -> inE(:wrote)>",
+                         "#<GraphV -> V-Property(name==\"gremlin\") -> :grem -> inE(:wrote)>"
+      end
+      its(:out_v) { should_not be_nil }
+    end
+
+    context "graph.v(:name => 'gremlin').as(:grem).in_e(:wrote)" do
+      let(:route) { graph.v.in_e.out_v(Tackle::SimpleMixin) }
+      subject { route }
+
+      its(:in_e) { should_not be_nil }
+      its(:to_a) { should == [] }
+      its(:extensions) { should == Set[Tackle::SimpleMixin] }
+    end
+
+    context "graph.v(:name => 'darrick')" do
+      use_simple_graph_data
+      before { setup_data }
+      subject { graph.v(:name => 'darrick') }
+
+      its('iterator.next') { should == v1 }
+      its(:to_a) { should == [v1] }
+    end
+
+    context 'graph.v.element_ids' do
+      describe '#build_pipeline' do
+        subject { graph.v.element_ids.send(:build_pipeline) }
+        it { should be_a(Array) }
+        its(:count) { should == 2 }
+        its(:first) { should be_a(com.tinkerpop.pipes.transform.VerticesPipe) }
+        its(:last) { should be_a(Pacer::Pipes::IdPipe) }
+      end
+
+      describe '#iterator' do
+        use_simple_graph_data
+        before { setup_data }
+        subject { graph.v.element_ids.send(:iterator) }
+        its(:next) { should_not be_nil }
+        it 'should iterate twice then raise an exception' do
+          2.times {
+            [v0.element_id, v1.element_id].should include(subject.next)
+          }
+          begin
+            subject.next
+            fail 'expected exception to be raised'
+          rescue NativeException => e
+            e.cause.inspect.should == 'java.util.NoSuchElementException'
+          end
+        end
+      end
+
+      describe '#to_a' do
+        use_simple_graph_data
+        before { setup_data }
+        subject { graph.v.element_ids.to_a }
+        its(:sort) { should == [v0.element_id, v1.element_id].sort }
+      end
+    end
+  end
+end
+
+Run.all(:read_only) do
+  describe Pacer::Core::Route do
+    use_pacer_graphml_data(:read_only)
+    before { setup_data }
+    describe '#inspect' do
+      it 'should show the path in the resulting string' do
+        r = graph.v(:name => 'gremlin')
+        r = r.as(:grem)
+        r = r.in_e(:wrote)
+        r = r.out_v
+        r = r.out_e(:wrote) { |e| true }
+        r = r.in_v
+        r = r.is_not(:grem)
+        r.inspect.should be_one_of "#<V-Index(name: \"gremlin\") -> :grem -> inE(:wrote) -> outV -> outE(:wrote) -> E-Property(&block) -> inV -> V-Property(&block)>",
+                                   "#<GraphV -> V-Property(name==\"gremlin\") -> :grem -> inE(:wrote) -> outV -> outE(:wrote) -> E-Property(&block) -> inV -> V-Property(&block)>"
+      end
+    end
+
+    describe '#to_a' do
+      it { Set[*graph.v].should == Set[*graph.getVertices] }
+      it { Set[*(graph.v.to_a)].should == Set[*graph.getVertices] }
+      it { Set[*graph.e].should == Set[*graph.getEdges] }
+      it { Set[*(graph.e.to_a)].should == Set[*graph.getEdges] }
+    end
+
+    describe '#root?' do
+      it { graph.should be_root }
+      it { graph.v.should be_root }
+      it { graph.v[3].should_not be_root }
+      it { graph.v.out_e.should_not be_root }
+      it { graph.v.out_e.in_v.should_not be_root }
+    end
+
+    describe 'property filter' do
+      it { graph.v(:name => 'pacer').to_a.should == [pacer] }
+      it { graph.v(:name => 'pacer').count.should == 1 }
+    end
+
+    describe 'block filter' do
+      it { graph.v { false }.count.should == 0 }
+      it { graph.v { true }.count.should == graph.v.count }
+      it { graph.v { |v| v.out_e.none? }[:name].to_a.should == ['blueprints'] }
+
+      it 'should work with paths' do
+        paths = graph.v.out_e(:wrote).in_v.paths.collect(&:to_a)
+        filtered_paths = graph.v { true }.out_e(:wrote).e { true }.in_v.paths.collect(&:to_a)
+        filtered_paths.should == paths
+      end
+    end
+
+    describe '#==' do
+      specify { graph.v.should == graph.v }
+      specify { graph.v.should_not == graph.v { true } }
+      specify { graph.v.should_not == graph.v(:x => 1) }
+      specify { graph.e.should == graph.e }
+      specify { graph.v.should_not == graph.e }
+    end
+
+    describe '#result' do
+      context 'no matching vertices' do
+        subject { graph.v(:name => 'missing').result }
+        it { should be_a(Pacer::Core::Graph::VerticesRoute) }
+        its(:count) { should == 0 }
+        its(:empty?) { should be_true }
+      end
+
+      it 'should not be nil when no matching vertices' do
+        empty = graph.v(:name => 'missing').result
+        empty.should be_a(Pacer::Core::Graph::VerticesRoute)
+        empty.count.should == 0
+      end
+
+      it 'should not be nil when no matching edges' do
+        empty = graph.e(:missing).result
+        empty.should be_a(Pacer::Core::Graph::EdgesRoute)
+        empty.count.should == 0
+      end
+
+      it 'should not be nil when no matching mixed results' do
+        empty = [].to_route(:graph => graph, :element_type => :mixed)
+        empty.should be_a(Pacer::Core::Graph::MixedRoute)
+        empty.count.should == 0
+      end
+    end
+  end
+end
+
+# These specs are :read_only
+shared_examples_for Pacer::Core::Route do
+  # defaults -- you
+  let(:route) { raise 'define a route' }
+  let(:number_of_results) { raise 'how many results are expected' }
+  let(:result_type) { raise 'specify :vertex, :edge, :mixed or :object' }
+  let(:back) { nil }
+  let(:info) { nil }
+  let(:route_extensions) { Set[] }
+
+  context 'without data' do
+    subject { route }
+    it { should be_a(Pacer::Core::Route) }
+    its(:graph) { should equal(graph) }
+    its(:back) { should equal(back) }
+    its(:info) { should == info }
+    context 'with info' do
+      before { route.info = 'some info' }
+      its(:info) { should == 'some info' }
+      after { route.info = nil }
+    end
+    its(:vars) { should be_a(Hash) }
+
+    describe '#from_graph?' do
+      subject { route }
+      it { should be_from_graph graph }
+      it { should_not be_from_graph graph2 }
+    end
+
+    describe '#each' do
+      it { route.each.should be_a(java.util.Iterator) }
+    end
+
+    describe '#result' do
+      before { graph.checkpoint }
+      subject { route.result }
+      its(:element_type) { should == route.element_type }
+    end
+
+  end
+
+  context 'with data' do
+    around do |spec|
+      if number_of_results > 0
+        setup_data
+        spec.run
+      end
+    end
+
+    let(:first_element) { route.first }
+    let(:all_elements) { route.to_a }
+
+    subject { route }
+
+    its(:extensions) { should == route_extensions }
+
+    describe '#[Fixnum]' do
+      subject { route[number_of_results - 1] }
+      it { should be_a(Pacer::Core::Route) }
+      its(:count) { should == 1 }
+      its(:result) { should be_a(Pacer::Core::Route) }
+      its(:extensions) { should == route.extensions }
+    end
+
+    describe '#result' do
+      subject { route.result }
+      it { should be_a(Pacer::Core::Route) }
+      its(:count) { should == number_of_results }
+    end
+
+    describe '#route' do
+      subject { route.route }
+      its(:hide_elements) { should be_true }
+      it { should equal(route) }
+    end
+
+    describe '#first' do
+      subject { route.first }
+      it { should_not be_nil }
+      its(:graph) { should equal(graph) }
+      its('extensions.to_a') { should == route.extensions.to_a }
+    end
+
+    describe '#to_a' do
+      subject { route.to_a }
+      its(:count) { should == number_of_results }
+      it { should be_a(Array) }
+      its('first.extensions.to_a') { should == route.extensions.to_a }
+    end
+
+    describe '#except' do
+      context '(first_element)' do
+        subject { route.except(first_element) }
+        its(:to_a) { should_not include(first_element) }
+        its('first.class') { should == first_element.class }
+        its(:extensions) { should == route.extensions }
+      end
+      context '(all_elements)' do
+        subject { route.except(all_elements) }
+        its(:count) { should == 0 }
+      end
+    end
+
+    describe '#only' do
+      subject { route.only(first_element).uniq }
+      its(:to_a) { should == [first_element] }
+      its('first.class') { should == first_element.class }
+      its(:extensions) { should == route.extensions }
+
+      context 'for non-elements' do
+        subject { route.element_ids.only(first_element.element_id).uniq }
+        its(:to_a) { should == [first_element.element_id] }
+      end
+    end
+  end
+
+  context 'without data' do
+    around do |spec|
+      if number_of_results == 0
+        setup_data
+        spec.run
+      end
+    end
+
+    subject { route }
+
+    describe '#[Fixnum]' do
+      subject { route[0] }
+      it { should be_a(Pacer::Core::Route) }
+      its(:count) { should == 0 }
+      its(:result) { should be_a(Pacer::Core::Route) }
+    end
+
+    describe '#result' do
+      subject { route.result }
+      it { should be_a(Pacer::Core::Route) }
+      its(:count) { should == number_of_results }
+    end
+
+    describe '#route' do
+      subject { route.route }
+      its(:hide_elements) { should be_true }
+      it { should equal(route) }
+    end
+
+    describe '#first' do
+      subject { route.first }
+      it { should be_nil }
+    end
+
+    describe '#to_a' do
+      subject { route.to_a }
+      its(:count) { should == number_of_results }
+      it { should be_a(Array) }
+    end
+
+    describe '#element_type' do
+      its(:element_type) { should == graph.element_type(result_type) }
+    end
+
+    describe '#add_extension' do
+      # Note that this mixin doesn't need to include
+      # versions of each test with extensions applied because
+      context '(SimpleMixin)' do
+        before do
+          @orig_ancestors = route.class.ancestors
+          r = route.add_extension Tackle::SimpleMixin
+          r.should equal(route)
+        end
+        its(:extensions) { should include(Tackle::SimpleMixin) }
+        it { should respond_to(:route_mixin_method) }
+      end
+
+      context '(Object)' do
+        before do
+          @orig_ancestors = route.class.ancestors
+          route.add_extension Object
+        end
+        its(:extensions) { should_not include(Object) }
+      end
+
+      context '(invalid)' do
+        before do
+          @orig_ancestors = route.class.ancestors
+          route.add_extension :invalid
+        end
+        its(:extensions) { should_not include(:invalid) }
+      end
+    end
+
+    describe '#add_extensions' do
+      subject { route.add_extensions([Tackle::SimpleMixin, Object, :invalid]) }
+      its(:extensions) { should include(Tackle::SimpleMixin) }
+    end
+  end
+end
+
+Run.all(:read_only) do
+  use_pacer_graphml_data(:read_only)
+  context 'vertices' do
+    it_uses Pacer::Core::Route do
+      let(:route) { graph.v }
+      let(:number_of_results) { 7 }
+      let(:result_type) { :vertex }
+    end
+  end
+end
+Run.all(:read_only) do
+  use_pacer_graphml_data(:read_only)
+  context 'vertices with extension' do
+    it_uses Pacer::Core::Route do
+      let(:back) { nil }
+      let(:route) { graph.v.filter(Tackle::SimpleMixin) }
+      let(:number_of_results) { 7 }
+      let(:result_type) { :vertex }
+      let(:route_extensions) { Set[Tackle::SimpleMixin] }
+    end
+  end
+end
+Run.all(:read_only) do
+  use_pacer_graphml_data(:read_only)
+  context 'no vertices' do
+    it_uses Pacer::Core::Route do
+      let(:back) { graph.v }
+      let(:route) { back.filter(:something => 'missing') }
+      let(:number_of_results) { 0 }
+      let(:result_type) { :vertex }
+    end
+  end
+end
+Run.all(:read_only) do
+  use_pacer_graphml_data(:read_only)
+  context 'edges' do
+    it_uses Pacer::Core::Route do
+      let(:route) { graph.e }
+      let(:number_of_results) { 14 }
+      let(:result_type) { :edge }
+    end
+  end
+end

data/spec/pacer/route/mixin/bulk_operations_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+Run.all do
+  use_pacer_graphml_data
+
+  describe RouteOperations, :transactions => false do
+    before { setup_data }
+
+    describe '#bulk_job', :transactions => false do
+      context 'commit every 2nd record, updating all vertices' do
+        context 'with wrapped elements' do
+          it 'should update all records' do
+            graph.v(Tackle::SimpleMixin).bulk_job(2) do |v|
+              v[:updated] = 'yes'
+            end
+            graph.v(:updated => 'yes').count.should == 7
+          end
+        end
+
+        it 'should update all records' do
+          graph.v.bulk_job(2) do |v|
+            v[:updated] = 'yup'
+          end
+          graph.v(:updated => 'yup').count.should == 7
+        end
+      end
+    end
+  end
+end
+