pacer 0.9.1.1-java

data/spec/pacer/blueprints/neo4j_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+Run.neo4j do
+  describe Pacer::Neo4jGraph do
+    let(:v0) { graph.create_vertex }
+    let(:v1) { graph.create_vertex }
+    let(:e0) { graph.create_edge '0', v0, v1, :default }
+
+    describe '#element_type' do
+      context 'invalid' do
+        it { expect { graph.element_type(:nothing) }.to raise_error(ArgumentError) }
+      end
+
+      context ':vertex' do
+        subject { graph.element_type(:vertex) }
+        it { should == com.tinkerpop.blueprints.pgm.impls.neo4j.Neo4jVertex }
+      end
+
+      context 'a vertex' do
+        subject { graph.element_type(v0) }
+        it { should == com.tinkerpop.blueprints.pgm.impls.neo4j.Neo4jVertex }
+      end
+
+      context ':edge' do
+        subject { graph.element_type(:edge) }
+        it { should == com.tinkerpop.blueprints.pgm.impls.neo4j.Neo4jEdge }
+      end
+
+      context 'an edge' do
+        subject { graph.element_type(e0) }
+        it { should == com.tinkerpop.blueprints.pgm.impls.neo4j.Neo4jEdge }
+      end
+
+      context ':mixed' do
+        subject { graph.element_type(:mixed) }
+        it { should == com.tinkerpop.blueprints.pgm.impls.neo4j.Neo4jElement }
+      end
+
+      context ':object' do
+        subject { graph.element_type(:object) }
+        it { should == Object }
+      end
+
+      context 'from element_type' do
+        context ':vertex' do
+          subject { graph.element_type(graph.element_type :vertex) }
+          it { should == com.tinkerpop.blueprints.pgm.impls.neo4j.Neo4jVertex }
+        end
+
+        context ':edge' do
+          subject { graph.element_type(graph.element_type :edge) }
+          it { should == com.tinkerpop.blueprints.pgm.impls.neo4j.Neo4jEdge }
+        end
+
+        context ':mixed' do
+          subject { graph.element_type(graph.element_type :mixed) }
+          it { should == com.tinkerpop.blueprints.pgm.impls.neo4j.Neo4jElement }
+        end
+
+        context ':object' do
+          subject { graph.element_type(graph.element_type :object) }
+          it { should == Object }
+        end
+      end
+
+      context 'from index_class' do
+        context ':vertex' do
+          subject { graph.element_type(graph.index_class :vertex) }
+          it { should == com.tinkerpop.blueprints.pgm.impls.neo4j.Neo4jVertex }
+        end
+
+        context ':edge' do
+          subject { graph.element_type(graph.index_class :edge) }
+          it { should == com.tinkerpop.blueprints.pgm.impls.neo4j.Neo4jEdge }
+        end
+      end
+    end
+
+    describe '#indices' do
+      subject { graph.indices.to_a }
+      its(:count) { should == 2 }
+    end
+
+    describe '#sanitize_properties' do
+      let(:original) do
+        { :string => ' bob ',
+          :symbol => :abba,
+          :empty => '',
+          :integer => 121,
+          :float => 100.001,
+          :time => Time.utc(1999, 11, 9, 9, 9, 1),
+          :object => { :a => 1, 1 => :a },
+          99 => 'numeric key',
+          'string key' => 'string value'
+        }
+      end
+
+      subject { graph.sanitize_properties original }
+
+      it { should_not equal(original) }
+      specify 'original should be unchanged' do
+        original.should == {
+          :string => ' bob ',
+          :symbol => :abba,
+          :empty => '',
+          :integer => 121,
+          :float => 100.001,
+          :time => Time.utc(1999, 11, 9, 9, 9, 1),
+          :object => { :a => 1, 1 => :a },
+          99 => 'numeric key',
+          'string key' => 'string value'
+        }
+      end
+
+      specify 'string should be stripped' do
+        subject[:string].should == 'bob'
+      end
+
+      specify 'empty string becomes nil' do
+        subject[:empty].should be_nil
+      end
+
+      specify 'numbers should be unmodified' do
+        subject[:integer].should == 121
+        subject[:float].should == 100.001
+      end
+
+      specify 'everything else should be yaml' do
+        subject[:time].should == YAML.dump(Time.utc(1999, 11, 9, 9, 9, 1))
+      end
+
+      its(:keys) { should == original.keys }
+    end
+
+    describe '#in_vertex' do
+      it 'should wrap the vertex' do
+        v = e0.in_vertex(Tackle::SimpleMixin)
+        v.should == v1
+        v.extensions.should include(Tackle::SimpleMixin)
+      end
+
+      it 'should wrap the vertex 2' do
+        v = e0.in_vertex([Tackle::SimpleMixin])
+        v.should == v1
+        v.extensions.should include(Tackle::SimpleMixin)
+      end
+    end
+
+    describe '#out_vertex' do
+      it 'should wrap the vertex' do
+        v = e0.out_vertex(Tackle::SimpleMixin)
+        v.should == v0
+        v.extensions.should include(Tackle::SimpleMixin)
+      end
+
+      it 'should wrap the vertex 2' do
+        v = e0.out_vertex([Tackle::SimpleMixin])
+        v.should == v0
+        v.extensions.should include(Tackle::SimpleMixin)
+      end
+    end
+
+    describe '#get_vertices' do
+      before { e0 }
+      subject { graph.get_vertices }
+      it { should be_a(Pacer::Core::Route) }
+      its(:count) { should == 2 }
+    end
+
+    describe '#get_edges' do
+      before { e0 }
+      subject { graph.get_edges }
+      it { should be_a(Pacer::Core::Route) }
+      its(:count) { should == 1 }
+    end
+  end
+end

data/spec/pacer/blueprints/tg_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+Run.tg do
+  describe Pacer::TinkerGraph do
+    let(:v0) { graph.create_vertex }
+    let(:v1) { graph.create_vertex }
+    let(:e0) { graph.create_edge '0', v0, v1, :default }
+
+    describe '#element_type' do
+      context 'invalid' do
+        it { expect { graph.element_type(:nothing) }.to raise_error(ArgumentError) }
+      end
+
+      context ':vertex' do
+        subject { Pacer.tg.element_type(:vertex) }
+        it { should == com.tinkerpop.blueprints.pgm.impls.tg.TinkerVertex }
+      end
+
+      context 'a vertex' do
+        subject { graph.element_type(v0) }
+        it { should == com.tinkerpop.blueprints.pgm.impls.tg.TinkerVertex }
+      end
+
+      context ':edge' do
+        subject { graph.element_type(:edge) }
+        it { should == com.tinkerpop.blueprints.pgm.impls.tg.TinkerEdge }
+      end
+
+      context 'an edge' do
+        subject { graph.element_type(e0) }
+        it { should == com.tinkerpop.blueprints.pgm.impls.tg.TinkerEdge }
+      end
+
+      context ':mixed' do
+        subject { graph.element_type(:mixed) }
+        it { should == com.tinkerpop.blueprints.pgm.impls.tg.TinkerElement }
+      end
+
+      context ':object' do
+        subject { graph.element_type(:object) }
+        it { should == Object }
+      end
+
+      context 'from result' do
+        context ':vertex' do
+          subject { Pacer.tg.element_type(Pacer.tg.element_type :vertex) }
+          it { should == com.tinkerpop.blueprints.pgm.impls.tg.TinkerVertex }
+        end
+
+        context ':edge' do
+          subject { graph.element_type(Pacer.tg.element_type :edge) }
+          it { should == com.tinkerpop.blueprints.pgm.impls.tg.TinkerEdge }
+        end
+
+        context ':mixed' do
+          subject { graph.element_type(Pacer.tg.element_type :mixed) }
+          it { should == com.tinkerpop.blueprints.pgm.impls.tg.TinkerElement }
+        end
+
+        context ':object' do
+          subject { graph.element_type(Pacer.tg.element_type :object) }
+          it { should == Object }
+        end
+      end
+
+      context 'from index_class' do
+        context ':vertex' do
+          subject { graph.element_type(graph.index_class :vertex) }
+          it { should == com.tinkerpop.blueprints.pgm.impls.tg.TinkerVertex }
+        end
+
+        context ':edge' do
+          subject { graph.element_type(graph.index_class :edge) }
+          it { should == com.tinkerpop.blueprints.pgm.impls.tg.TinkerEdge }
+        end
+      end
+    end
+
+    describe '#sanitize_properties' do
+      specify 'returns its argument' do
+        arg = { :a => 1 }
+        graph.sanitize_properties(arg).should equal(arg)
+      end
+    end
+
+    describe '#in_vertex' do
+      it 'should wrap the vertex' do
+        v = e0.in_vertex(Tackle::SimpleMixin)
+        v.should == v1
+        v.extensions.should include(Tackle::SimpleMixin)
+      end
+
+      it 'should wrap the vertex 2' do
+        v = e0.in_vertex([Tackle::SimpleMixin])
+        v.should == v1
+        v.extensions.should include(Tackle::SimpleMixin)
+      end
+    end
+
+    describe '#out_vertex' do
+      it 'should wrap the vertex' do
+        v = e0.out_vertex(Tackle::SimpleMixin)
+        v.should == v0
+        v.extensions.should include(Tackle::SimpleMixin)
+      end
+
+      it 'should wrap the vertex 2' do
+        v = e0.out_vertex([Tackle::SimpleMixin])
+        v.should == v0
+        v.extensions.should include(Tackle::SimpleMixin)
+      end
+    end
+
+    describe '#get_vertices' do
+      before { e0 }
+      subject { graph.get_vertices }
+      it { should be_a(Pacer::Core::Route) }
+      its(:count) { should == 2 }
+    end
+
+    describe '#get_edges' do
+      before { e0 }
+      subject { graph.get_edges }
+      it { should be_a(Pacer::Core::Route) }
+      its(:count) { should == 1 }
+    end
+  end
+end

data/spec/pacer/core/graph/edges_route_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+Run.all(:read_only) do
+  use_pacer_graphml_data(:read_only)
+
+  context Pacer::Core::Graph::EdgesRoute do
+    subject { graph.e }
+    it { should be_a Pacer::Core::Graph::EdgesRoute }
+    its(:count) { should == 14 }
+
+    describe '#out_v' do
+      subject { graph.e.out_v }
+      it { should be_a Pacer::Core::Graph::VerticesRoute }
+      its(:count) { should == 14 }
+    end
+
+    describe '#in_v' do
+      subject { graph.e.in_v }
+      it { should be_a Pacer::Core::Graph::VerticesRoute }
+      its(:count) { should == 14 }
+    end
+
+    describe '#both_v' do
+      subject { graph.e.both_v }
+      it { should be_a Pacer::Core::Graph::VerticesRoute }
+      its(:count) { should == 28 }
+    end
+
+    describe '#e' do
+      subject { graph.e.e }
+      it { should be_a Pacer::Core::Graph::EdgesRoute }
+      its(:count) { should == 14 }
+    end
+
+    describe '#labels' do
+      subject { graph.e.labels }
+      it { should be_a Pacer::Core::Route }
+      its(:element_type) { should == Object }
+      its(:count) { should == 14 }
+    end
+
+    describe '#to_h' do
+      subject { graph.e.to_h }
+      let(:okram) { graph.v(:name => 'okram').first }
+
+      it { should be_a Hash }
+      specify 'okram key has all outward related vertices in an array as the value' do
+        subject[okram].sort_by { |v| v.element_id }.should == okram.out_e.in_v.to_a.sort_by { |v| v.element_id }
+      end
+    end
+  end
+end

data/spec/pacer/core/graph/element_route_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+shared_examples_for Pacer::Core::Graph::ElementRoute do
+  describe '#properties' do
+    subject { r.properties }
+    its(:count) { should == r.count }
+    its(:element_type) { should == Object }
+    specify 'should all be hashes' do
+      props = subject.each
+      elements = r.each
+      elements.zip(props.to_a).each do |e, p|
+        e.properties.should == p
+      end
+    end
+  end
+
+  context 'with extensions' do
+    let(:route) { r.add_extension(Tackle::SimpleMixin) }
+    describe '#each without a block' do
+      subject { route.each }
+      specify 'elements should be wrapped' do
+        subject.first.extensions.should include(Tackle::SimpleMixin)
+      end
+    end
+  end
+end
+
+Run.all(:read_only) do
+  use_pacer_graphml_data(:read_only)
+
+  context Pacer::Core::Graph::EdgesRoute, '2' do
+    it_uses Pacer::Core::Graph::ElementRoute do
+      def r
+        graph.e
+      end
+    end
+  end
+
+  context Pacer::Core::Graph::VerticesRoute, '2' do
+    it_uses Pacer::Core::Graph::ElementRoute do
+      def r
+        graph.v
+      end
+    end
+  end
+end

data/spec/pacer/core/graph/graph_route_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+Run.all(:read_only, false) do
+  around { |spec| spec.run if graph }
+  use_pacer_graphml_data(:read_only)
+
+  context Pacer::Core::Graph::GraphRoute do
+    describe '#v' do
+      subject { graph.v }
+      it { should be_a_vertices_route }
+      its(:to_a) { should_not be_empty }
+    end
+
+    describe '#e' do
+      subject { graph.e }
+      it { should be_an_edges_route }
+      its(:to_a) { should_not be_empty }
+    end
+
+    subject { graph }
+    it { should_not be_a(Pacer::Routes::RouteOperations) }
+
+    describe '#filter' do
+      it 'is not implemented' do
+        expect { graph.filter(:a => 'b') }.to raise_error
+      end
+    end
+
+    its(:result) { should == graph }
+    its(:hide_elements) { should == true }
+
+    context 'with vertex name indexed' do
+      before :all do
+        graph.v.build_index :name if graph
+        graph.search_manual_indices = true if graph
+      end
+
+      after :all do
+        graph.drop_index :name if graph
+      end
+
+      context 'basic search' do
+        subject { graph.v(:name => 'pangloss') }
+        it { should be_a(Pacer::Filter::IndexFilter) }
+        its(:to_a) { should_not be_empty }
+        its(:count) { should == 1 }
+      end
+
+      context 'basic search 2' do
+        subject { graph.v([{ :name => 'pangloss' }]) }
+        it { should be_a(Pacer::Filter::IndexFilter) }
+        its(:to_a) { should_not be_empty }
+        its(:count) { should == 1 }
+      end
+
+      context 'basic search 3' do
+        subject { graph.v({ :name => 'pangloss' }, { :type => 'person' } ) }
+        its(:inspect) { should == '#<V-Index(name: "pangloss") -> V-Property(type=="person")>' }
+        its(:to_a) { should_not be_empty }
+        its(:count) { should == 1 }
+      end
+
+      context 'extension search' do
+        subject { graph.v(TP::Person, :name => { :name => 'pangloss' }) }
+        its(:inspect) { should == '#<V-Index(name: "pangloss") -> V-Property(TP::Person)>' }
+        its(:extensions) { should include(TP::Person) }
+        its(:to_a) { should_not be_empty }
+        its(:count) { should == 1 }
+      end
+
+      context 'extension search 2' do
+        subject { graph.v(TP::Pangloss) }
+        it { should be_a(Pacer::Filter::IndexFilter) }
+        its(:to_a) { should_not be_empty }
+        its(:count) { should == 1 }
+      end
+    end
+
+    context 'with vertex auto index' do
+      before :all do
+        graph.build_automatic_index :v_auto, :vertex, [:type] if graph
+      end
+
+      after :all do
+        graph.drop_index :v_auto if graph
+      end
+
+      subject { graph.v(:type => 'person') }
+      it { should be_a(Pacer::Filter::IndexFilter) }
+      its(:to_a) { should_not be_empty }
+      its(:count) { should == 2 }
+    end
+  end
+end

data/spec/pacer/core/graph/vertices_route_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+Run.all(:read_only) do
+  use_pacer_graphml_data(:read_only)
+
+  context Pacer::Core::Graph::VerticesRoute do
+    subject { graph.v }
+    it { should be_a Pacer::Core::Graph::VerticesRoute }
+    its(:count) { should == 7 }
+
+    describe '#out_e' do
+      subject { graph.v.out_e }
+      it { should be_a Pacer::Core::Graph::EdgesRoute }
+      its(:count) { should == 14 }
+
+      describe '(:uses)' do
+        subject { graph.v.out_e(:uses) }
+        its(:count) { should == 5 }
+        it { subject.labels.to_a.should == ['uses'] * 5 }
+      end
+
+      describe '(:uses, :wrote)' do
+        subject { graph.v.out_e(:uses, :wrote) }
+        its(:count) { should == 9 }
+        it { Set[*subject.labels].should == Set['uses', 'wrote'] }
+      end
+    end
+
+    describe '#out' do
+      subject { graph.v.out }
+      it { should be_a Pacer::Core::Graph::VerticesRoute }
+      its(:count) { should == 14 }
+      its(:to_a) { should == graph.v.out_e.in_v.to_a }
+
+      describe '(:uses, :wrote)' do
+        subject { graph.v.out(:uses, :wrote) }
+        its(:count) { should == 9 }
+        it { subject.to_a.should == graph.v.out_e(:uses, :wrote).in_v.to_a }
+      end
+    end
+
+    describe '#in' do
+      subject { graph.v.in }
+      it { should be_a Pacer::Core::Graph::VerticesRoute }
+      its(:count) { should == 14 }
+      its(:to_a) { should == graph.v.in_e.out_v.to_a }
+      describe '(:uses, :wrote)' do
+        subject { graph.v.in(:uses, :wrote) }
+        its(:count) { should == 9 }
+        it { subject.to_a.should == graph.v.in_e(:uses, :wrote).out_v.to_a }
+      end
+    end
+
+    describe '#both' do
+      subject { graph.v.both }
+      it { should be_a Pacer::Core::Graph::VerticesRoute }
+      its(:count) { should == 28 }
+      describe '(:wrote)' do
+        subject { graph.v.both(:wrote) }
+        its(:count) { should == 8 }
+        # These element ids only work under TinkerGraph:
+        #it { subject.element_ids.to_a.should == %w[5 5 0 1 4 2 3 5] }
+      end
+    end
+  end
+end
+
+Run.tg(:read_only) do
+  context Pacer::Core::Graph::VerticesRoute do
+    use_pacer_graphml_data(:read_only)
+
+    describe '#out_e' do
+      it { graph.v.out_e.should be_an_edges_route }
+      it { graph.v.out_e(:label).should be_a(Pacer::Route) }
+      it { graph.v.out_e(:label) { |x| true }.should be_a(Pacer::Route) }
+      it { graph.v.out_e { |x| true }.should be_a(Pacer::Route) }
+
+      it { Set[*graph.v.out_e].should == Set[*graph.edges] }
+
+      it { graph.v.out_e.count.should >= 1 }
+
+      specify 'with label filter should work with path generation' do
+        r = graph.v.out_e.in_v.in_e { |e| e.label == 'wrote' }.out_v
+        paths = r.paths
+        paths.first.should_not be_nil
+        graph.v.out_e.in_v.in_e(:wrote).out_v.paths.collect(&:to_a).should == paths.collect(&:to_a)
+      end
+    end
+  end
+end
+
+Run.tg do
+  use_pacer_graphml_data
+
+  context Pacer::Core::Graph::VerticesRoute do
+    describe :add_edges_to do
+      before do
+        setup_data
+      end
+
+      let(:pangloss) { graph.v(:name => 'pangloss') }
+      let(:pacer) { graph.v(:name => 'pacer') }
+
+      context '1 to 1' do
+        before do
+          @result = pangloss.add_edges_to(:likes, pacer, :pros => "it's fast", :cons => nil)
+        end
+
+        subject { @result.first }
+
+        it { should_not be_nil }
+        its(:out_vertex) { should == pangloss.first }
+        its(:in_vertex) { should == pacer.first }
+        its(:label) { should == 'likes' }
+
+        it 'should store properties' do
+          subject[:pros].should == "it's fast"
+        end
+
+        it 'should not add properties with null values' do
+          subject.getPropertyKeys.should_not include('cons')
+        end
+      end
+
+      context 'many to many' do
+        let(:people) { graph.v(:type => 'person') }
+        let(:projects) { graph.v :type => 'project' }
+
+        subject { people.add_edges_to(:uses, projects) }
+
+        it { should be_a(Pacer::Core::Route) }
+        its(:element_type) { should == graph.element_type(:edge) }
+        its(:count) { should == 8 }
+        its('back.back.element_type') { should == Object }
+        its('back.count') { should == 8 }
+
+        specify 'all edges in rasge should exist' do
+          subject.each do |edge|
+            edge.should_not be_nil
+            edge.label.should == 'uses'
+          end
+        end
+      end
+
+      context 'edge cases' do
+        it 'should do nothing if there are no source vertices' do
+          result = graph.v(:name => 'no match').add_edges_to(:likes, pacer, :pros => "it's fast", :cons => nil)
+          result.should be_nil
+        end
+
+        it 'should do nothing if there are no target vertices' do
+          result = pangloss.add_edges_to(:likes, graph.v(:name => 'I hate everytihng'))
+          result.should be_nil
+        end
+
+        it 'should associate to a single element' do
+          result = pangloss.add_edges_to(:likes, pacer.first)
+          edge = result.first
+          edge.should_not be_nil
+        end
+
+        it 'should do nothing if target is nil' do
+          result = pangloss.add_edges_to(:likes, nil)
+          result.should be_nil
+        end
+      end
+    end
+  end
+end