pacer 1.0.2-java → 1.0.3-java

data/spec/pacer/blueprints/neo4j_spec.rb

@@ -1,163 +1,17 @@
 require 'spec_helper'
 
 Run.neo4j do
-  describe 'neo4j graph' do
-    let(:v0) { graph.create_vertex }
-    let(:v1) { graph.create_vertex }
-    let(:e0) { graph.create_edge '0', v0, v1, :default }
+  use_simple_graph_data
 
-    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 == :vertex }
-      end
-
-      context 'a vertex' do
-        subject { graph.element_type(v0) }
-        it { should == :vertex }
-      end
-
-      context ':edge' do
-        subject { graph.element_type(:edge) }
-        it { should == :edge }
-      end
-
-      context 'an edge' do
-        subject { graph.element_type(e0) }
-        it { should == :edge }
-      end
-
-      context ':mixed' do
-        subject { graph.element_type(:mixed) }
-        it { should == :mixed }
-      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 == :vertex }
-        end
-
-        context ':edge' do
-          subject { graph.element_type(graph.element_type :edge) }
-          it { should == :edge }
-        end
-
-        context ':mixed' do
-          subject { graph.element_type(graph.element_type :mixed) }
-          it { should == :mixed }
-        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 == :vertex }
-        end
-
-        context ':edge' do
-          subject { graph.element_type(graph.index_class :edge) }
-          it { should == :edge }
-        end
-      end
-    end
-
-    describe '#indices' do
-      subject { graph.indices.to_a }
-      its(:count) { should == 0 }
+  describe '#vertex' do
+    it 'should not raise an exception for invalid key type' do
+      graph.vertex('bad id').should be_nil
     end
+  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
+  describe '#edge' do
+    it 'should not raise an exception for invalid key type' do
+      graph.edge('bad id').should be_nil
     end
   end
 end

data/spec/pacer/blueprints/orient_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+Run.orient do
+  # no special cases for Orient?
+end

data/spec/pacer/blueprints/tg_spec.rb

@@ -1,80 +1,5 @@
 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 == :vertex }
-      end
-
-      context 'a vertex' do
-        subject { graph.element_type(v0) }
-        it { should == :vertex }
-      end
-
-      context ':edge' do
-        subject { graph.element_type(:edge) }
-        it { should == :edge }
-      end
-
-      context 'an edge' do
-        subject { graph.element_type(e0) }
-        it { should == :edge }
-      end
-
-      context ':mixed' do
-        subject { graph.element_type(:mixed) }
-        it { should == :mixed }
-      end
-
-      context ':object' do
-        subject { graph.element_type(:object) }
-        it { should == :object }
-      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
-  end
+  # no special cases for TinkerGraph?
 end

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

@@ -1,5 +1,32 @@
 require 'spec_helper'
 
+Run.all(:read_write) do
+  use_pacer_graphml_data(:read_write)
+
+  describe '#property?' do
+    before do
+      setup_data
+      graph.create_vertex other: 'hi'
+      graph.create_vertex falsy: false
+      graph.create_vertex zero: 0
+    end
+
+    it 'should filter vertices that do not have the given property' do
+      graph.v.count.should == 10
+      graph.v.property?(:name).count.should == 7
+      graph.v.property?(:other).count.should == 1
+    end
+
+    it 'should work even if the value is falsy' do
+      graph.v.count.should == 10
+      graph.v.property?(:name).count.should == 7
+      graph.v.property?(:zero).count.should == 1
+
+      graph.v.property?(:falsy).count.should == 1
+    end
+  end
+end
+
 Run.all(:read_only) do
   use_pacer_graphml_data(:read_only)
 
@@ -30,12 +57,12 @@ Run.all(:read_only) 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 }
+      its(:to_set) { should == graph.v.out_e.in_v.to_set }
 
       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 }
+        it { subject.to_set.should == graph.v.out_e(:uses, :wrote).in_v.to_set }
       end
 
       it 'should not apply extensions to new route' do
@@ -47,11 +74,11 @@ Run.all(:read_only) 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 }
+      its(:to_set) { should == graph.v.in_e.out_v.to_set }
       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 }
+        it { subject.to_set.should == graph.v.in_e(:uses, :wrote).out_v.to_set }
       end
 
       it 'should not apply extensions to new route' do
@@ -97,7 +124,7 @@ Run.tg(:read_only) 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)
+        graph.v.out_e.in_v.in_e(:wrote).out_v.paths.to_a.should == paths.to_a
       end
     end
   end