pacer 0.9.1.1-java → 1.0.0-java

data/spec/pacer/graph/element_mixin_spec.rb

@@ -1,297 +0,0 @@
-require 'spec_helper'
-
-unless defined? ElementMixinSpec
-ElementMixinSpec = true
-
-shared_examples_for Pacer::ElementMixin do
-  context 'vertex' do
-    subject { v0 }
-    it { should be_a(Pacer::Core::Graph::VerticesRoute) }
-    it { should be_a(Pacer::ElementMixin) }
-    it { should be_a(Pacer::VertexMixin) }
-    it { should_not be_a(Pacer::EdgeMixin) }
-
-    describe '#v' do
-      context '()' do
-        subject { v0.v }
-        its(:to_a) { should == [v0] }
-        it { should be_a_vertices_route }
-      end
-
-      context '(:name => "eliza")' do
-        subject { v0.v(:name => 'eliza') }
-        its(:to_a) { should == [v0] }
-        it { should be_a_vertices_route }
-      end
-
-      context '(:name => "other")' do
-        subject { v0.v(:name => 'other') }
-        its(:to_a) { should == [] }
-        it { should be_a_vertices_route }
-      end
-
-      context '(SimpleMixin)' do
-        subject { v0.v(Tackle::SimpleMixin) }
-        its(:to_a) { should == [v0] }
-        it { should be_a_vertices_route }
-        its(:extensions) { should == Set[Tackle::SimpleMixin] }
-      end
-    end
-
-    describe '#e' do
-      it 'is unsupported' do
-        expect { v0.e }.to raise_error(Pacer::UnsupportedOperation)
-      end
-    end
-
-    describe '#eql?' do
-      subject { Hash.new(0) }
-      before do
-        subject[v0] += 1
-        subject[graph.v.first] += 1
-      end
-
-      its(:keys) { should == [v0] }
-      its(:values) { should == [2] }
-
-      it 'should put wrapped vertices in the same key' do
-        subject[v0.v(Tackle::SimpleMixin).first] += 1
-        subject.values.should == [3]
-      end
-
-      it 'should put other vertices in a different key' do
-        subject[v1].should == 0
-        subject[v0].should == 2
-      end
-    end
-  end
-
-  context 'edge' do
-    subject { e0 }
-    it { should be_a(Pacer::Core::Graph::EdgesRoute) }
-    it { should be_a(Pacer::ElementMixin) }
-    it { should be_a(Pacer::EdgeMixin) }
-    it { should_not be_a(Pacer::VertexMixin) }
-
-    describe '#e', :transactions => false do
-      context '()' do
-        subject { e0.e }
-        its(:to_a) { should == [e0] }
-        it(:a => :b) { should be_an_edges_route }
-      end
-
-      context '(:links)' do
-        subject { e0.e(:links) }
-        its(:to_a) { should == [e0] }
-        it { should be_an_edges_route }
-      end
-
-      context '(:other)' do
-        subject { e0.e(:other) }
-        its(:to_a) { should == [] }
-        it { should be_an_edges_route }
-      end
-
-      context '(SimpleMixin)' do
-        subject { e0.e(Tackle::SimpleMixin) }
-        its(:to_a) { should == [e0] }
-        it { should be_an_edges_route }
-        its(:extensions) { should == Set[Tackle::SimpleMixin] }
-      end
-    end
-
-    describe '#v' do
-      it 'is unsupported' do
-        expect { e0.v }.to raise_error(Pacer::UnsupportedOperation)
-      end
-    end
-
-    describe '#eql?', :transactions => false do
-      subject { Hash.new(0) }
-      before do
-        subject[e0] += 1
-        subject[graph.e.first] += 1
-      end
-
-      its(:keys) { should == [e0] }
-      its(:values) { should == [2] }
-
-      it 'should put wrapped edges in the same key' do
-        subject[e0.e(Tackle::SimpleMixin).first] += 1
-        subject.values.should == [3]
-      end
-
-      it 'should put other edges in a different key' do
-        subject[e1].should == 0
-        subject[e0].should == 2
-      end
-    end
-  end
-
-  describe '#graph' do
-    it { v0.graph.should == graph }
-    it { e0.graph.should == graph }
-  end
-
-  contexts(
-  'vertex' => proc{
-    let(:element) { v0 }
-  },
-  'edge' => proc{
-    let(:element) { e0 }
-  }) do
-    describe '#[]' do
-      context 'value types' do
-        it '(String)' do
-          element[:string] = 'words'
-          element[:string].should == 'words'
-        end
-
-        it '(Array)' do
-          a = [10, 'elements']
-          element[:array] = a
-          element[:array].should == a
-        end
-
-        it '(Hash)' do
-          h = { :elements => 10 }
-          element[:hash] = h
-          element[:hash].should == h
-        end
-
-        it '(Time)' do
-          time = Time.utc 2011, 1, 2, 3, 4, 5
-          element[:time] = time
-          element[:time].should == time
-        end
-
-        it '(Fixnum)' do
-          element[:number] = 123
-          element[:number].should == 123
-        end
-
-        it '(Float)' do
-          element[:float] = 12.345
-          element[:float].should == 12.345
-        end
-
-        it '(Bignum)' do
-          element[:big] = 123321123321123321123321123321123321
-          element[:big].should == 123321123321123321123321123321123321
-        end
-
-        it "('')" do
-          element[:name] = ''
-          element[:name].should be_nil
-          element.property_keys.should_not include('name')
-        end
-
-        it '(nil)' do
-          element[:name] = nil
-          element[:name].should be_nil
-          element.property_keys.should_not include('name')
-        end
-      end
-
-      context 'key types' do
-        it 'String' do
-          element['name'].should == element[:name]
-        end
-
-        it 'Fixnum' do
-          element[123] = 'value'
-          element[123].should == 'value'
-        end
-      end
-    end
-
-    describe '#result', :transactions => false do
-      subject { element.result }
-      it { should equal(element) }
-    end
-
-    describe '#from_graph?' do
-      context 'same graph' do
-        subject { element.from_graph? graph }
-        it { should be_true }
-      end
-      context 'different graph' do
-        subject { element.from_graph? graph2 }
-        it { should be_false }
-      end
-    end
-
-    describe '#properties' do
-      before do
-        element.properties = { :a => 'valuea', :b => 'valueb' }
-      end
-      subject { element.properties }
-      it { should be_a(Hash) }
-      its(:count) { should == 2 }
-      it 'should have the correct vales' do
-        element.properties['a'].should == 'valuea'
-        element.properties['b'].should == 'valueb'
-        element[:a].should == 'valuea'
-        element[:b].should == 'valueb'
-      end
-      it 'should not affect the element if returned values are changed' do
-        element.properties['a'].gsub!(/value/, 'oops')
-        element.properties['a'].should == 'valuea'
-        element[:a].should == 'valuea'
-      end
-      it 'should not affect the element if returned keys are changed' do
-        element.properties.delete('a')
-        element.properties['a'].should == 'valuea'
-        element[:a].should == 'valuea'
-      end
-      it 'should not affect the element if something is added' do
-        element.properties['c'] = 'something'
-        element[:c].should be_nil
-      end
-      context 'existing properties' do
-        before do
-          element.properties = { :a => 'new value', :c => 'value c' }
-        end
-        its(:count) { should == 2 }
-        it 'should have the correct values' do
-          element[:a].should == 'new value'
-          element[:b].should be_nil
-          element[:c].should == 'value c'
-        end
-      end
-    end
-
-    subject { element }
-    its(:element_id) { should_not be_nil }
-    context '', :transactions => false do
-      # FIXME: Neo4j edges are flaky sometimes when inside a
-      # transaction. If you look them up by id, they are not found.
-      its(:to_a) { should == [element] }
-      its(:element) { should == element }
-    end
-  end
-end
-end
-
-Run.all do
-  it_uses Pacer::ElementMixin do
-    let(:v0) { graph.create_vertex :name => 'eliza' }
-    let(:v1) { graph.create_vertex :name => 'darrick' }
-    let(:e0) { graph.create_edge nil, v0, v1, :links }
-    let(:e1) { graph.create_edge nil, v0, v1, :relinks }
-  end
-
-  context 'vertex' do
-    let(:v0) { graph.create_vertex :name => 'eliza' }
-    subject { v0 }
-    it { should_not be_a(Pacer::Wrappers::ElementWrapper) }
-  end
-
-  context 'edge' do
-    let(:v0) { graph.create_vertex :name => 'eliza' }
-    let(:v1) { graph.create_vertex :name => 'darrick' }
-    let(:e0) { graph.create_edge nil, v0, v1, :links }
-    subject { e0 }
-    it { should_not be_a(Pacer::Wrappers::ElementWrapper) }
-  end
-end

data/spec/pacer/graph/vertex_mixin_spec.rb

@@ -1,192 +0,0 @@
-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