pacer 0.9.1.1-java → 1.0.0-java

data/spec/pacer/wrapper/vertex_wrapper_spec.rb

@@ -15,7 +15,11 @@ Run.all :read_only do
     its(:extensions) { should == v_exts }
 
     describe 'instance' do
-      subject { v_wrapper_class.new pacer }
+      subject do
+        v = v_wrapper_class.new pacer.element
+        v.graph = graph
+        v
+      end
       it               { should_not be_nil }
       its(:element)    { should_not be_nil }
       it               { should == pacer }
@@ -24,10 +28,293 @@ Run.all :read_only do
       its(:extensions) { should == v_exts }
 
       describe 'with more extensions added' do
-        subject { v_wrapper_class.new(pacer).add_extensions([Pacer::Utils::TSort]) }
+        subject { v_wrapper_class.new(pacer.element).add_extensions([Pacer::Utils::TSort]) }
         its(:class) { should_not == v_wrapper_class }
         its(:extensions) { should == v_exts + [Pacer::Utils::TSort] }
       end
     end
   end
 end
+
+module VertexWrapperSpec
+  module Project
+    def self.route_conditions
+      { :type => 'project' }
+    end
+
+    module Vertex
+    end
+  end
+
+  module IsRuby
+    def self.route_conditions
+      { :language => 'ruby' }
+    end
+
+    module Vertex
+    end
+  end
+end
+
+shared_examples_for Pacer::Wrappers::VertexWrapper do
+  use_simple_graph_data
+
+  describe '#v' do
+    subject { v0.v }
+    it { should be_a_vertices_route }
+    its(:element_type) { should == :vertex }
+  end
+
+  describe '#add_extensions' do
+    context 'no extensions' do
+      subject { v0.add_extensions([]) }
+      its('extensions.to_a') { should == [] }
+      its(:class) { should == Pacer::Wrappers::VertexWrapper }
+    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 '#as?' do
+    let(:v) { graph.create_vertex type: 'project' }
+    context 'Project' do
+      subject { v.as?(VertexWrapperSpec::Project) }
+      it { should be_true }
+    end
+    context 'IsRuby' do
+      subject { v.as?(VertexWrapperSpec::IsRuby) }
+      it { should_not be_true }
+    end
+    context 'Project, IsRuby' do
+      subject { v.as?(VertexWrapperSpec::Project, VertexWrapperSpec::IsRuby) }
+      it { should_not be_true }
+    end
+  end
+
+  describe '#as' do
+    context 'vertex is a Project' do
+      let(:v) { graph.create_vertex type: 'project' }
+
+      it 'should yield a Project' do
+        yielded = false
+        v.as(VertexWrapperSpec::Project) do |v2|
+          yielded = true
+          v2.should == v
+          v2.extensions.should include VertexWrapperSpec::Project
+          v2.should be_a VertexWrapperSpec::Project::Vertex
+        end
+        yielded.should be_true
+      end
+
+      it 'should not yield a IsRuby' do
+        yielded = false
+        v.as(VertexWrapperSpec::IsRuby) do |v2|
+          yielded = true
+        end
+        yielded.should be_false
+      end
+    end
+  end
+
+  describe '#only_as' do
+    context 'able' do
+      subject { graph.create_vertex VertexWrapperSpec::IsRuby, type: 'project', language: 'ruby' }
+
+      its(:extensions) { should include VertexWrapperSpec::IsRuby }
+
+      it 'should yield a Project' do
+        yielded = false
+        subject.only_as(VertexWrapperSpec::Project) do |v2|
+          yielded = true
+          v2.should == subject
+          v2.extensions.should == [VertexWrapperSpec::Project]
+          v2.should be_a VertexWrapperSpec::Project::Vertex
+        end
+        yielded.should be_true
+      end
+    end
+
+    context 'unable' do
+      subject { graph.create_vertex VertexWrapperSpec::IsRuby, language: 'ruby' }
+
+      it 'should not yield a Project' do
+        yielded = false
+        subject.only_as(VertexWrapperSpec::Project) do |v2|
+          yielded = true
+        end
+        yielded.should be_false
+      end
+    end
+  end
+
+  describe '#delete!' do
+    before do
+      @vertex_id = v0.element_id
+      v0.delete!
+      c = example.metadata[:graph_commit]
+      c.call if c
+    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.features.supportsIndices }
+    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 unless graph.features.ignoresSuppliedIds }
+    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::Wrappers::EdgeWrapper)
+        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::Wrappers::EdgeWrapper)
+        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::Wrappers::EdgeWrapper)
+        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::Wrappers::EdgeWrapper)
+        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::Wrappers::EdgeWrapper)
+        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::Wrappers::EdgeWrapper)
+        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::Wrappers::VertexWrapper
+end

data/spec/spec_helper.rb

@@ -1,3 +1,9 @@
+def maybe_require(file)
+  require file
+rescue LoadError
+  puts "Not using #{ file }"
+end
+
 require "rubygems"
 require "bundler"
 Bundler.setup(:default, :development)
@@ -5,6 +11,9 @@ require 'rspec'
 require 'pacer'
 require 'set'
 
+require 'simplecov'
+SimpleCov.start if ENV['COVERAGE']
+
 Dir['./spec/support/**/*.rb'].map {|f| require f}
 Dir['./spec/tackle/*.rb'].map {|f| require f}
 
@@ -20,9 +29,9 @@ def in_editor?
   ENV.has_key?('TM_MODE') || ENV.has_key?('EMACS') || ENV.has_key?('VIM')
 end
 
-require 'pacer-neo4j'
-# require 'pacer-dex'
-Pacer::DexGraph = Class.new unless defined? Pacer::DexGraph
+maybe_require 'pacer-neo4j'
+maybe_require 'pacer-orient'
+maybe_require 'pacer-dex'
 
 Run = RSpec::GraphRunner.new ENV['GRAPHS']
 
@@ -38,11 +47,11 @@ def use_pacer_graphml_data(usage_style = :read_write)
   if usage_style == :read_only
     let(:setup_data) { }
     before(:all) do
-      graph.import 'spec/data/pacer.graphml' if graph
+      Pacer::GraphML.import graph, 'spec/data/pacer.graphml' if graph
     end
   else
     let(:setup_data) do
-      graph.import 'spec/data/pacer.graphml' if graph
+      Pacer::GraphML.import graph, 'spec/data/pacer.graphml' if graph
     end
   end
   let(:pangloss) { graph.v(:name => 'pangloss', :type => 'person').first }
@@ -55,11 +64,11 @@ def use_grateful_dead_data(usage_style = :read_write)
   if usage_style == :read_only
     let(:setup_data) { }
     before(:all) do
-      graph.import 'spec/data/grateful-dead.xml' if graph
+      Pacer::GraphML.import graph, 'spec/data/grateful-dead.xml' if graph
     end
   else
     let(:setup_data) do
-      graph.import 'spec/data/grateful-dead.xml' if graph
+      Pacer::GraphML.import graph, 'spec/data/grateful-dead.xml' if graph
     end
   end
 end

data/spec/support/graph_runner.rb

@@ -1,4 +1,31 @@
+maybe_require 'pacer-neo4j/rspec'
+maybe_require 'pacer-orient/rspec'
+maybe_require 'pacer-dex/rspec'
+
 class RSpec::GraphRunner
+  module Stubs
+    def all(*args)
+    end
+
+    def tg(*args)
+    end
+
+    def neo4j(*args)
+    end
+
+    def rg(*args)
+    end
+
+    def multigraph(*args)
+    end
+
+    def dex(*args)
+    end
+
+    def orient(*args)
+    end
+  end
+
   module Tg
     def all(usage_style = :read_write, indices = true, &block)
       tg(usage_style, indices, &block)
@@ -7,21 +34,11 @@ class RSpec::GraphRunner
     def tg(usage_style = :read_write, indices = true, &block)
       return unless use_graph? 'tg'
       describe 'tg' do
-        let(:graph) do
-          g = Pacer.tg
-          unless indices
-            g.drop_index :vertices
-            g.drop_index :edges
-          end
-          g
-        end
+        let(:graph) { Pacer.tg }
         let(:graph2) { Pacer.tg }
         instance_eval(&block)
       end
     end
-
-    def dex(*args)
-    end
   end
 
   module RubyGraph
@@ -37,11 +54,11 @@ class RSpec::GraphRunner
     protected
 
     def ruby_graph
-      Pacer::RubyGraph.new
+      Pacer::PacerGraph.new Pacer::SimpleEncoder, proc { Pacer::RubyGraph.new }
     end
 
     def ruby_graph2
-      Pacer::RubyGraph.new
+      Pacer::PacerGraph.new Pacer::SimpleEncoder, proc { Pacer::RubyGraph.new }
     end
   end
 
@@ -58,17 +75,22 @@ class RSpec::GraphRunner
     protected
 
     def multi_graph
-      Pacer::MultiGraph.new
+      Pacer::MultiGraph.blank
     end
 
     def multi_graph2
-      Pacer::MultiGraph.new
+      Pacer::MultiGraph.blank
     end
   end
 
+
+  include Stubs
   include Tg
-  include RubyGraph
-  include MultiGraph
+  #include RubyGraph
+  #include MultiGraph
+  include Neo4j if defined? Neo4j
+  include Dex if defined? Dex
+  include Orient if defined? Orient
 
   def initialize(*graphs)
     @graphs = graphs.map { |s| s.to_s.downcase.split(/\s*,\s*/) }.flatten.map { |s| s.strip }.reject { |s| s == '' }
@@ -94,6 +116,7 @@ protected
 
   def for_graph(name, usage_style, indices, transactions, source_graph_1, source_graph_2, unindexed_graph, block)
     return unless use_graph? name
+    clear_graph = proc { |g| clear g }
     describe name do
       let(:graph) do
         if indices
@@ -107,27 +130,32 @@ protected
       end
       if usage_style == :read_only
         before(:all) do
-          source_graph_1.v.delete!
-          source_graph_2.v.delete!
-          unindexed_graph.v.delete! if unindexed_graph
+          if indices
+            clear_graph.call source_graph_1
+          elsif unindexed_graph
+            clear_graph.call unindexed_graph
+          end
+          clear_graph.call source_graph_2
         end
       end
       around do |spec|
         if usage_style == :read_write
-          source_graph_1.v.delete!
-          source_graph_2.v.delete!
-          unindexed_graph.v.delete! if unindexed_graph
+          if indices
+            clear_graph.call source_graph_1
+          elsif unindexed_graph
+            clear_graph.call unindexed_graph
+          end
+          clear_graph.call source_graph_2
         end
         if transactions and spec.use_transactions?
-          graph.manual_transactions do
-            graph2.manual_transactions do
+          graph.transaction do |g1_commit, g1_rollback|
+            graph2.transaction do |_, g2_rollback|
+              spec.metadata[:graph_commit] = g1_commit
               begin
-                graph.begin_transaction
-                graph2.begin_transaction
                 spec.run
               ensure
-                graph.rollback_transaction rescue nil
-                graph2.rollback_transaction rescue nil
+                g1_rollback.call rescue nil
+                g2_rollback.call rescue nil
               end
             end
           end
@@ -138,5 +166,28 @@ protected
       instance_eval(&block)
     end
   end
+
+  def clear(graph)
+    graph.transaction do
+      graph.blueprints_graph.getVertices.each do |v|
+        begin
+          graph.remove_vertex v
+        rescue
+        end
+      end
+      graph.indices.each do |idx|
+        graph.drop_index idx.index_name
+      end
+    end
+    #if graph.v.any?
+    #  fail "Graph still has vertices"
+    #elsif graph.e.any?
+    #  fail "Graph still has edges"
+    #elsif graph.indices.any?
+    #  fail "Graph still has indices"
+    #elsif graph.key_indices.any?
+    #  fail "Graph still has key indices"
+    #end
+  end
 end