pacer 0.9.1.1-java

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

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+# New tests:
+Run.tg(:read_only) do
+  use_pacer_graphml_data(:read_only)
+
+  describe RouteOperations do
+    describe '#most_frequent' do
+      context '()' do
+        subject { graph.v[:type].most_frequent }
+        it { should == 'project' }
+      end
+
+      context '(0)' do
+        subject { graph.v[:type].most_frequent(0) }
+        it { should == 'project' }
+      end
+
+      context '(1)' do
+        subject { graph.v[:type].most_frequent(1) }
+        it { should == 'person' }
+      end
+
+      context '(0..1)' do
+        subject { graph.v[:type].most_frequent(0..1) }
+        it { should be_a Pacer::Core::Route }
+        its(:element_type) { should == Object }
+        its(:to_a) { should == ['project', 'person'] }
+      end
+
+      context '(0, true)' do
+        subject { graph.v[:type].most_frequent(0, true) }
+        it { should == ['project', 4] }
+      end
+
+      context '(1, true)' do
+        subject { graph.v[:type].most_frequent(1, true) }
+        it { should == ['person', 2] }
+      end
+
+      context '(0..1, true)' do
+        subject { graph.v[:type].most_frequent(0..1, true) }
+        it { should == [['project', 4], ['person', 2]] }
+      end
+    end
+  end
+end
+
+Run.tg do
+  use_pacer_graphml_data
+
+  describe RouteOperations do
+    before do
+      setup_data
+    end
+
+    describe '#build_index' do
+      context "('new_index', 'k') { count += 1 }", :transactions => true do
+        it 'should build the index with raw elements' do
+          count = 0
+          index = graph.v.build_index('new_index', 'k', 'name')
+          index.should_not be_nil
+          index.get('k', 'pangloss').count.should == 1
+        end
+
+        it 'should build the index with wrapped elements' do
+          count = 0
+          index = graph.v(TP::Person).build_index('new_index', 'k', 'name')
+          index.should_not be_nil
+          index.get('k', 'pangloss').count.should == 1
+        end
+
+        it 'should do nothing if there are no elements' do
+          count = 0
+          index = graph.v.limit(0).build_index('new_index', 'k', 'name')
+          index.should be_nil
+        end
+
+        after do
+          graph.dropIndex 'new_index'
+        end
+      end
+    end
+  end
+end
+
+
+# Modernize these old tests:
+describe RouteOperations do
+  before :all do
+    @g = Pacer.tg 'spec/data/pacer.graphml'
+  end
+
+  describe '#as' do
+    it 'should set the variable to the correct node' do
+      vars = Set[]
+      @g.v.as(:a_vertex).in_e(:wrote) { |edge| vars << edge.vars[:a_vertex] }.count
+      vars.should == Set[*@g.e.e(:wrote).in_v]
+    end
+
+    it 'should not break path generation (simple)' do
+      who = nil
+      r = @g.v.as(:who).in_e(:wrote).out_v.v { |v|
+        who = v.vars[:who]
+      }.paths
+      r.each do |path|
+        path.to_a[0].should == @g
+        path.to_a[1].should == who
+        path.length.should == 4
+      end
+    end
+
+    it 'should not break path generation' do
+      who_wrote_what = nil
+      r = @g.v.as(:who).in_e(:wrote).as(:wrote).out_v.as(:what).v { |v|
+        who_wrote_what = [@g, v.vars[:who], v.vars[:wrote], v.vars[:what]]
+      }.paths
+      r.each do |path|
+        path.to_a.should == who_wrote_what
+      end
+    end
+  end
+
+  describe :delete! do
+    it 'should not try to delete an element twice'
+  end
+end

data/spec/pacer/support/enumerable_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe Enumerable do
+  describe '#one?' do
+    it 'should be true if there is one element' do
+      [:x].one?.should be_true
+    end
+
+    it 'should be false if there are no elements' do
+      [].one?.should be_false
+    end
+
+    it 'should be false if there are 2 elements' do
+      [:a, :b].one?.should be_false
+    end
+
+    it 'should be false if there are lots of elements' do
+      ([:a, :b] * 100).one?.should be_false
+    end
+  end
+
+  describe '#many?' do
+    it 'should be false if there is one element' do
+      [:x].many?.should be_false
+    end
+
+    it 'should be false if there are no elements' do
+      [].many?.should be_false
+    end
+
+    it 'should be true if there are 2 elements' do
+      [:a, :b].many?.should be_true
+    end
+
+    it 'should be true if there are lots of elements' do
+      ([:a, :b] * 100).many?.should be_true
+    end
+  end
+
+  describe '#to_hashset' do
+    it 'should return an empty hashset' do
+      [].to_hashset.should == java.util.HashSet.new
+    end
+
+    it 'should not clone an existing hashset' do
+      hs = java.util.HashSet.new
+      hs.to_hashset.should equal(hs)
+    end
+
+    it 'should create a hashset from an array' do
+      hs = java.util.HashSet.new
+      hs.add 'a'
+      hs.add 'b'
+      ['a', 'b', 'a'].to_hashset.should == hs
+    end
+
+    it 'should create a hashset from an arraylist' do
+      hs = java.util.HashSet.new
+      hs.add 'a'
+      hs.add 'b'
+      al = java.util.ArrayList.new
+      al.add 'a'
+      al.add 'b'
+      al.add 'a'
+      al.to_hashset.should == hs
+    end
+  end
+
+  Run.tg do
+    use_simple_graph_data
+
+    describe '#to_route' do
+      context "from [1, 'a']" do
+        context 'with no arguments' do
+          subject { [1, 'a'].to_route }
+          it { should be_a Pacer::Core::Route }
+          its(:element_type) { should == Object }
+          its(:to_a) { should == [1, 'a'] }
+        end
+
+        context 'based on an object route' do
+          subject { [1, 'a'].to_route(:based_on => graph.v[:name]) }
+          it { should be_a Pacer::Core::Route }
+          its(:element_type) { should == Object }
+          its(:to_a) { should == [1, 'a'] }
+        end
+
+        context 'based on an object route with an extension' do
+          subject { [1, 'a'].to_route(:based_on => graph.v[:name].add_extension(Tackle::SimpleMixin)) }
+          it { should be_a Pacer::Core::Route }
+          its(:extensions) { should == Set[Tackle::SimpleMixin] }
+          its(:element_type) { should == Object }
+          its(:to_a) { should == [1, 'a'] }
+        end
+      end
+
+      context 'from [elements]' do
+        let(:elements) { [v0, v1] }
+
+        context 'based on an element route' do
+          subject { elements.to_route(:based_on => graph.v) }
+          its(:element_type) { should == graph.element_type(:vertex) }
+          its(:to_a) { should == elements }
+        end
+
+        context 'based on an extended element route' do
+          subject { elements.to_route(:based_on => graph.v(Tackle::SimpleMixin)) }
+          its(:extensions) { should == Set[Tackle::SimpleMixin] }
+          its(:element_type) { should == graph.element_type(:vertex) }
+          its(:to_a) { should == elements }
+        end
+      end
+    end
+  end
+end

data/spec/pacer/transform/join_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+Run.tg :read_only do
+  use_pacer_graphml_data :read_only
+
+  describe Pacer::Transform::Join do
+    context 'with no key or value specified' do
+      subject { graph.v.join }
+      its(:count) { should == 7 }
+      specify 'each element should be a node' do
+        subject.each do |group|
+          group[:key].should be_a graph.element_type(:vertex)
+          group.property_keys.to_a.should == ['key']
+        end
+      end
+    end
+
+    context 'with key_route only' do
+      subject { graph.v.join(:key) { |r| r[:type] } }
+
+      its(:count) { should == 7 }
+      its(:to_a) { should_not be_empty }
+      specify 'each result should have one value' do
+        subject.each do |group|
+          group[:key].should be_a String
+          group.property_keys.to_a.should == ['key']
+        end
+      end
+    end
+
+    context 'with key_route and value route' do
+      let(:route) { graph.v.join(:key) { |r| r[:type] }.join }
+      subject { route }
+
+      specify 'each result should reflect an element' do
+        subject.each.zip(graph.v.to_a) do |group, e|
+          group[:key].should == e[:type]
+          group.property_keys.to_set.should == Set['key', 'values']
+          group[:values].last.element_id.should == e.element_id
+        end
+      end
+
+      context '#multigraph' do
+        subject { route.multigraph }
+        it { should be_a Pacer::MultiGraph }
+
+        its('v.count') { should == 3 }
+
+
+        context 'person' do
+          subject { route.multigraph.vertex 'person' }
+          it 'should hove 2 values' do
+            subject[:values].length.should == 2
+          end
+          it { subject[:values].should == graph.v(:type => 'person').to_a }
+        end
+
+        context 'project' do
+          subject { route.multigraph.vertex 'project' }
+          it 'should hove 2 values' do
+            subject[:values].length.should == 4
+          end
+          it { subject[:values].should == graph.v(:type => 'project').to_a }
+        end
+
+        context 'reduced to a count' do
+          subject do
+            route.multigraph.v.reduce({}) do |h, v|
+              h[v.element_id] = v[:values].count
+              h
+            end
+          end
+          specify 'it should have a count for values' do
+            subject['project'].should == 4
+            subject['person'].should == 2
+            subject['group'].should == 1
+          end
+        end
+
+        context 'reduced to a string' do
+          subject do
+            route.multigraph.v.reduce({}) do |h, v|
+              h[v.element_id] = v[:values].map { |v| v[:name] }.join ', '
+              h
+            end
+          end
+          specify do
+            subject['project'].should == 'blueprints, pipes, pacer, gremlin'
+            subject['person'].should == 'pangloss, okram'
+            subject['group'].should == 'tinkerpop'
+          end
+        end
+      end
+    end
+
+    context 'with a key block that returns a literal value' do
+      subject { graph.v.join { |r| r[:type] }.key { |r| r[:type].length } }
+      its(:count) { should == 7 }
+      specify 'each value should have a numeric key' do
+        subject.each do |v|
+          v[:key].should == v.element_id
+          v[:key].should == v[:values].first.length
+        end
+      end
+    end
+
+    context 'with values_maps' do
+      let(:counted_group) do
+        graph.v.join(:count) { |r| r.out_e.counted.cap }.
+          join(:out_e, &:out_e).
+          key { |r| r[:type] }
+      end
+      subject do
+        counted_group.multigraph
+      end
+      its('v.count') { should == 3 }
+      specify { counted_group.count.should == 7 }
+      specify 'combine(:count) should group the counts in a hash' do
+        hash = Hash[subject.v[[:key, :count]].to_a]
+        hash.should == {"project"=>[0, 1, 3, 2], "person"=>[1, 3], "group"=>[4]}
+      end
+
+      specify 'reduce summarizes edge labels for each type' do
+        result = Hash[subject.v.map { |v| [v.element_id, v[:out_e].group_count { |e| e.label }] }.to_a]
+        result.should == {"project" => {"uses"     => 5, "modelled_on" => 1},
+                          "person"  => {"wrote"    => 4},
+                          "group"   => {"projects" => 3, "member"      => 1}}
+      end
+
+      its(:inspect) { should == "#<MultiGraph>" }
+      
+      specify do
+        counted_group.inspect.should == 
+          "#<GraphV -> V-Join(#<V -> Obj(type)>: {:count=>#<V -> outE -> Obj-Cap(E-Counted)>, :out_e=>#<V -> outE>})>"
+      end
+    end
+  end
+end

data/spec/pacer/transform/path_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Pacer::Transform::Path do
+  before :all do
+    @g = Pacer.tg 'spec/data/pacer.graphml'
+  end
+
+  describe '#paths' do
+    it 'should return the paths between people and projects' do
+      Set[*@g.v(:type => 'person').out_e.in_v(:type => 'project').paths.collect(&:to_a)].should ==
+        Set[[@g.vertex(0), @g.edge(0), @g.vertex(1)],
+            [@g.vertex(5), @g.edge(1), @g.vertex(4)],
+            [@g.vertex(5), @g.edge(13), @g.vertex(2)],
+            [@g.vertex(5), @g.edge(12), @g.vertex(3)]]
+    end
+
+    it 'should include all elements traversed' do
+      @g.v.out_e.in_v.paths.each do |path|
+        path[0].should == @g
+        path[1].should be_a(Pacer::TinkerVertex)
+        path[2].should be_a(Pacer::TinkerEdge)
+        path[3].should be_a(Pacer::TinkerVertex)
+        path.length.should == 4
+      end
+    end
+
+  end
+
+  describe '#transpose' do
+    it 'should return the paths between people and projects' do
+      transposed = @g.v(:type => 'person').out_e.in_v(:type => 'project').paths.transpose
+      Set[*transposed].should ==
+        Set[[@g.vertex(0), @g.vertex(5), @g.vertex(5), @g.vertex(5)],
+            [@g.edge(0), @g.edge(1), @g.edge(13), @g.edge(12)],
+            [@g.vertex(1), @g.vertex(4), @g.vertex(2), @g.vertex(3)]]
+    end
+  end
+
+  describe '#subgraph' do
+    before do
+      @sg = @g.v(:type => 'person').out_e.in_v(:type => 'project').subgraph
+
+      @vertices = @g.v(:type => 'person').to_a + @g.v(:type => 'project').to_a
+      @edges = @g.v(:type => 'person').out_e(:wrote)
+    end
+
+    it { Set[*@sg.v.element_ids].should == Set[*@vertices.collect { |v| v.element_id }] }
+    it { Set[*@sg.e.element_ids].should == Set[*@edges.collect { |e| e.element_id }] }
+
+    it { @sg.e.labels.uniq.to_a.should == ['wrote'] }
+    it { Set[*@sg.v.collect { |v| v.properties }].should == Set[*@vertices.collect { |v| v.properties }] }
+  end
+end
+

data/spec/pacer/utils/tsort_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe Pacer::Utils::TSort do
+  let(:graph) { Pacer.tg }
+
+  context 'single vertex' do
+    before do
+      graph.create_vertex
+    end
+    let(:node) { graph.v(Pacer::Utils::TSort).first }
+
+    describe 'tsort()' do
+      subject { node.tsort.to_a }
+      it { should == [node] }
+    end
+  end
+
+  context 'breakfast example' do
+    let(:breakfast) { graph.create_vertex 'breakfast' }
+    let(:serve) { graph.create_vertex 'serve' }
+    let(:cook) { graph.create_vertex 'cook' }
+    let(:eggs) { graph.create_vertex 'buy eggs' }
+    let(:bacon) { graph.create_vertex 'buy bacon' }
+
+    before do
+      [eggs, bacon].to_route(:graph => graph, :element_type => :vertex).add_edges_to :requires, cook
+      cook.add_edges_to :requires, serve
+      serve.add_edges_to :requires, breakfast
+    end
+
+    context 'whole meal' do
+      subject do
+        graph.v(Pacer::Utils::TSort).tsort.to_a
+      end
+
+      it { should == [ bacon, eggs, cook, serve, breakfast ] }
+
+      it 'should be different from the default order' do
+        should_not == graph.v.to_a
+      end
+    end
+
+    context 'from one vertex' do
+      subject do
+        graph.v(Pacer::Utils::TSort).only(cook).tsort.to_a
+      end
+
+      it { should == [ bacon, eggs, cook ] }
+    end
+  end
+
+  context 'circular' do
+    let(:a) { graph.create_vertex 'a' }
+    let(:b) { graph.create_vertex 'b' }
+    let(:c) { graph.create_vertex 'c' }
+
+    before do
+      a.add_edges_to :needs, b
+      b.add_edges_to :needs, c
+      c.add_edges_to :needs, a
+    end
+
+    it 'should raise a TSort::Cyclic error' do
+      proc {
+        graph.v(Pacer::Utils::TSort).tsort
+      }.should raise_error TSort::Cyclic
+    end
+
+    it 'can not TSort a subset of a cyclical graph' do
+      proc {
+        graph.v(Pacer::Utils::TSort).only([a,b]).tsort.should == [a,b]
+      }.should raise_error TSort::Cyclic
+    end
+
+    it 'can be worked around with subgraph' do
+      vertices = graph.v.only([a,b]).result
+      edges = graph.e.lookahead(:min => 2) { |e| e.both_v.only(vertices) }.result
+      subgraph = (vertices.to_a + edges.to_a).to_route(:graph => graph, :element_type => :mixed).subgraph
+      # The elements aren't the same since they've been copied into a
+      # new graph:
+      subgraph.v(Pacer::Utils::TSort).tsort.element_ids.to_a.should == ['b', 'a']
+    end
+
+    it 'can be sorted with a custom dependencies block' do
+      graph.v(Pacer::Utils::TSort).dependencies { |v| v.in.except(c) }.tsort.to_a.should ==
+        [a, b, c]
+    end
+  end
+end

data/spec/pacer/wrapper/edge_wrapper_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+Run.all :read_only do
+  use_pacer_graphml_data :read_only
+
+  describe Pacer::Wrappers::EdgeWrapper do
+
+    let(:e_exts) { [Tackle::SimpleMixin, TP::Wrote] }
+    let(:e_wrapper_class) { Pacer::Wrappers::EdgeWrapper.wrapper_for e_exts }
+
+    subject { e_wrapper_class }
+
+    it { should_not be_nil }
+    its(:route_conditions) { should == { label: 'wrote' } }
+    its(:extensions) { should == e_exts }
+
+    describe 'instance' do
+      subject { e_wrapper_class.new pangloss_wrote_pacer }
+      it               { should_not be_nil }
+      its(:element)    { should_not be_nil }
+      it               { should == pangloss_wrote_pacer }
+      it               { should_not equal pangloss_wrote_pacer }
+      its(:element_id) { should == pangloss_wrote_pacer.element_id }
+      its(:extensions) { should == e_exts }
+
+      describe 'with more extensions added' do
+        subject { e_wrapper_class.new(pacer).add_extensions([Pacer::Utils::TSort]) }
+        its(:class) { should_not == e_wrapper_class }
+        its(:extensions) { should == e_exts + [Pacer::Utils::TSort] }
+      end
+    end
+  end
+end