neography-batch 1.0.0 → 1.0.1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    neography-batch (1.0.0)
+    neography-batch (1.0.1)
 
 GEM
   remote: http://rubygems.org/

data/lib/neography-batch/batch.rb

@@ -1,95 +1,99 @@
-class Batch
-  private
-  def initialize(graph_db = Neography::Rest.new, commands = [])
-    @commands = commands
-    @db = graph_db
-    yield(self) if block_given?
+module Neography
+  module Batch
+    class Batch
+      private
+      def initialize(graph_db = Neography::Rest.new, commands = [])
+        @commands = commands
+        @db = graph_db
+        yield(self) if block_given?
 
-  end
+      end
 
-  def self.get_resolved_commands(commands)
-    result = []
-    reference_and_index = {}
+      def self.get_resolved_commands(commands)
+        result = []
+        reference_and_index = {}
 
-    # write each command_or_batch and remember index of command_or_batch
-    commands.each do |command|
-      index = result.length
-      reference_and_index[command[:reference]] = index
-      result << command[:cmd]
-    end
+        # write each command_or_batch and remember index of command_or_batch
+        commands.each do |command|
+          index = result.length
+          reference_and_index[command[:reference]] = index
+          result << command[:cmd]
+        end
 
-    # replace references contained in the commands with the effective index in the batch
-    result.each do |command|
-      command.each_with_index do |element, index|
-        if reference_and_index.has_key?(element)
-          command[index] = "{#{reference_and_index[element]}}"
+        # replace references contained in the commands with the effective index in the batch
+        result.each do |command|
+          command.each_with_index do |element, index|
+            if reference_and_index.has_key?(element)
+              command[index] = "{#{reference_and_index[element]}}"
+            end
+          end
         end
+        result
       end
-    end
-    result
-  end
-
-  protected
-  def commands
-    @commands
-  end
 
-  public
-  def self.unit
-    Batch.new
-  end
+      protected
+      def commands
+        @commands
+      end
 
-  def add(command_or_batch)
-    if command_or_batch.class == Batch
-      bind(command_or_batch)
-    else
-      unless command_or_batch.respond_to?(:each)
-        raise StandardError, "command_or_batch must respond to :each"
+      public
+      def self.unit
+        Batch.new
       end
 
-      reference = BatchReference.new(command_or_batch)
-      @commands << {:cmd => command_or_batch, :reference => reference}
-      reference
-    end
-  end
+      def add(command_or_batch)
+        if command_or_batch.class == Batch
+          bind(command_or_batch)
+        else
+          unless command_or_batch.respond_to?(:each)
+            raise StandardError, "command_or_batch must respond to :each"
+          end
 
-  def find_reference
-    @commands.select { |c| !block_given? || yield(c[:cmd]) }.map { |c| c[:reference] }
-  end
+          reference = BatchReference.new(command_or_batch)
+          @commands << {:cmd => command_or_batch, :reference => reference}
+          reference
+        end
+      end
 
-  alias :<< :add
+      def find_reference
+        @commands.select { |c| !block_given? || yield(c[:cmd]) }.map { |c| c[:reference] }
+      end
 
-  def submit
-    return [] if @commands.empty?
-    command_list = Batch.get_resolved_commands(@commands)
-    result = @db.batch(*command_list)
-    if result.nil?
-      raise StandardError, "batch returned no result (nil)"
-    end
-    batch_errors = result.select { |r| r["status"] >= 400 }
-    if batch_errors.count > 0
-      raise StandardError, "batch returned one or more errors: #{batch_errors.map { |e| e["message"] }.join("|")}"
-    end
-    results = result.map { |r| r["body"] }
-    @commands.each_with_index { |c, i| c[:reference].notify_after_submit(results[i]) }
-    @commands.clear()
-    results
-  end
+      alias :<< :add
 
-  def bind(batch)
-    Batch.new(@db, @commands.concat(batch.commands))
-  end
+      def submit
+        return [] if @commands.empty?
+        command_list = Batch.get_resolved_commands(@commands)
+        result = @db.batch(*command_list)
+        if result.nil?
+          raise StandardError, "batch returned no result (nil)"
+        end
+        batch_errors = result.select { |r| r["status"] >= 400 }
+        if batch_errors.count > 0
+          raise StandardError, "batch returned one or more errors: #{batch_errors.map { |e| e["message"] }.join("|")}"
+        end
+        results = result.map { |r| r["body"] }
+        @commands.each_with_index { |c, i| c[:reference].notify_after_submit(results[i]) }
+        @commands.clear()
+        results
+      end
 
-  def ==(other)
-    eql?(other)
-  end
+      def bind(batch)
+        Batch.new(@db, @commands.concat(batch.commands))
+      end
 
-  def eql?(other)
-    if other.class != self.class
-      false
-    else
-      commands.length == other.commands.length &&
-          commands.zip(other.commands).all? { |z| z[0] == z[1] }
+      def ==(other)
+        eql?(other)
+      end
+
+      def eql?(other)
+        if other.class != self.class
+          false
+        else
+          commands.length == other.commands.length &&
+              commands.zip(other.commands).all? { |z| z[0] == z[1] }
+        end
+      end
     end
   end
 end

data/lib/neography-batch/batch_reference.rb

@@ -1,31 +1,35 @@
-class BatchReference
-  def initialize(command)
-    @command = command
-  end
+module Neography
+  module Batch
+    class BatchReference
+      def initialize(command)
+        @command = command
+      end
 
-  protected
-  def after_submit_action
-    @after_submit_action
-  end
+      protected
+      def after_submit_action
+        @after_submit_action
+      end
 
-  def command
-    @command
-  end
+      def command
+        @command
+      end
 
-  public
-  def after_submit(&after_commit_action)
-    @after_submit_action = after_commit_action
-  end
+      public
+      def after_submit(&after_commit_action)
+        @after_submit_action = after_commit_action
+      end
 
-  def notify_after_submit(result)
-    unless @after_submit_action.nil?
-      @after_submit_action.call(result)
-    end
-  end
+      def notify_after_submit(result)
+        unless @after_submit_action.nil?
+          @after_submit_action.call(result)
+        end
+      end
 
-  def ==(other)
-    return false if other.nil?
-    @after_submit_action.equal?(other.after_submit_action) &&
-        @command.equal?(other.command)
+      def ==(other)
+        return false if other.nil?
+        @after_submit_action.equal?(other.after_submit_action) &&
+            @command.equal?(other.command)
+      end
+    end
   end
-end
+end

data/neography-batch.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "neography-batch"
-  s.version     = "1.0.0"
+  s.version     = "1.0.1"
   s.platform    = Gem::Platform::RUBY
   s.authors     = "Jorg Jenni"
   s.email       = "jorg.jenni@jennius.co.uk"

data/spec/batch_reference_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+module Neography
+  module Batch
+    describe BatchReference do
+      describe "==" do
+        specify do
+          ref1 = BatchReference.new([:create, {"id" => 1}])
+          ref2 = BatchReference.new([:create, {"id" => 1}])
+          (ref1==ref2).should be_false
+        end
+        specify do
+          command = [:create, {"id" => 1}]
+          ref1 = BatchReference.new(command)
+          ref2 = BatchReference.new(command)
+          (ref1==ref2).should be_true
+        end
+        specify do
+          command = [:create, {"id" => 1}]
+          ref1 = BatchReference.new(command)
+          ref1.after_submit do
+            puts "Do this"
+          end
+          ref2 = BatchReference.new(command)
+          ref2.after_submit do
+            puts "Do something else"
+          end
+          (ref1==ref2).should be_false
+        end
+      end
+    end
+  end
+end

data/spec/batch_spec.rb

@@ -1,320 +1,316 @@
 require_relative 'spec_helper'
 
-class Function
-  def self.persist_inserts(elements)
-    batch = Batch.new
-    elements.each do |e|
-      batch << [:create_node, e]
-    end
-    return batch
-  end
-end
 
-def create_batches(command1, command2, command3)
-  batch1 = Batch.new do |b|
-    b<<command1
-  end
+module Neography
+  module Batch
+    describe Batch do
 
-  batch2 = Batch.new do |b|
-    b<<command2
-  end
+      def create_batches(command1, command2, command3)
+        batch1 = Batch.new do |b|
+          b<<command1
+        end
 
-  batch3 = Batch.new do |b|
-    b<<command3
-  end
-  return batch1, batch2, batch3
-end
+        batch2 = Batch.new do |b|
+          b<<command2
+        end
 
-describe "Batch" do
-  let(:db) { Neography::Rest.new }
-  subject { Batch.new(db) }
+        batch3 = Batch.new do |b|
+          b<<command3
+        end
+        return batch1, batch2, batch3
+      end
 
-  describe "new" do
-    it "should create unit when no block provided" do
-      Batch.new.should == Batch.unit()
-    end
-    it "should call block with itself when block is provided" do
-      command = [:command]
-      batch_configured_without_block = Batch.new
-      batch_configured_without_block << command
+      let(:db) { Neography::Rest.new }
+      subject { Batch.new(db) }
 
-      batch_with_block = Batch.new do |b|
-        b << command
-      end
+      describe "new" do
+        it "should create unit when no block provided" do
+          Batch.new.should == Batch.unit()
+        end
+        it "should call block with itself when block is provided" do
+          command = [:command]
+          batch_configured_without_block = Batch.new
+          batch_configured_without_block << command
 
-      batch_with_block.should == batch_configured_without_block
-    end
-  end
+          batch_with_block = Batch.new do |b|
+            b << command
+          end
 
-  describe "==" do
-    specify { (Batch.new==Batch.new).should be_true }
-    specify { (Batch.new==[]).should be_false }
-    specify do
-      command1 = [:command_1]
-      command2 = [:command_2]
-      batch1 = Batch.new do |b|
-        b << command1
-        b << command2
-      end
-      batch2 = Batch.new do |b|
-        b << command1
-        b << command2
-      end
-      (batch1==batch2).should be_true
-    end
-    specify do
-      batch1 = Batch.new do |b|
-        b << [:command_1]
-        b << [:command_2]
-      end
-      batch2 = Batch.new do |b|
-        b << [:command_2]
-        b << [:command_1]
-      end
-      (batch1==batch2).should be_false
-    end
-    specify do
-      batch1 = Batch.new do |b|
-        b << [:command_1, {:id => 7}]
-        b << [:command_2, {:id => 9}]
+          batch_with_block.should == batch_configured_without_block
+        end
       end
-      batch2 = Batch.new do |b|
-        b << [:command_1, {:id => 7}]
-        b << [:command_2, {:id => 8}]
+
+      describe "==" do
+        specify { (Batch.new==Batch.new).should be_true }
+        specify { (Batch.new==[]).should be_false }
+        specify do
+          command1 = [:command_1]
+          command2 = [:command_2]
+          batch1 = Batch.new do |b|
+            b << command1
+            b << command2
+          end
+          batch2 = Batch.new do |b|
+            b << command1
+            b << command2
+          end
+          (batch1==batch2).should be_true
+        end
+        specify do
+          batch1 = Batch.new do |b|
+            b << [:command_1]
+            b << [:command_2]
+          end
+          batch2 = Batch.new do |b|
+            b << [:command_2]
+            b << [:command_1]
+          end
+          (batch1==batch2).should be_false
+        end
+        specify do
+          batch1 = Batch.new do |b|
+            b << [:command_1, {:id => 7}]
+            b << [:command_2, {:id => 9}]
+          end
+          batch2 = Batch.new do |b|
+            b << [:command_1, {:id => 7}]
+            b << [:command_2, {:id => 8}]
+          end
+          (batch1==batch2).should be_false
+        end
+        specify do
+          batch1 = Batch.new { |b| b << [:command_1] }
+          batch2 = Batch.new { |b| b << [:command_2] }
+          (batch1==batch2).should be_false
+        end
+        specify do
+          batch1 = Batch.new { |b| b << [] }
+          batch2 = Batch.new { |b| b << [:command_2] }
+          (batch1==batch2).should be_false
+        end
+        specify do
+          batch1 = Batch.new
+          batch2 = Batch.new { |b| b << [:command_2] }
+          (batch1==batch2).should be_false
+        end
+        specify do
+          batch1 = Batch.new { |b| b << [:command_1] }
+          batch2 = Batch.new { |b| b << [] }
+          (batch1==batch2).should be_false
+        end
       end
-      (batch1==batch2).should be_false
-    end
-    specify do
-      batch1 = Batch.new { |b| b << [:command_1] }
-      batch2 = Batch.new { |b| b << [:command_2] }
-      (batch1==batch2).should be_false
-    end
-    specify do
-      batch1 = Batch.new { |b| b << [] }
-      batch2 = Batch.new { |b| b << [:command_2] }
-      (batch1==batch2).should be_false
-    end
-    specify do
-      batch1 = Batch.new
-      batch2 = Batch.new { |b| b << [:command_2] }
-      (batch1==batch2).should be_false
-    end
-    specify do
-      batch1 = Batch.new { |b| b << [:command_1] }
-      batch2 = Batch.new { |b| b << [] }
-      (batch1==batch2).should be_false
-    end
-  end
 
-  describe "bind" do
-    let(:command1) { [:create_node, {"id" => 7}] }
-    let(:command2) { [:create_unique_node, {"id" => 8}] }
-    let(:command3) { [:create_node, {"id" => 9}] }
-    it "on unit with f should be equal f" do
-      batch1, _, _ = create_batches(command1, command2, command3)
+      describe "bind" do
+        let(:command1) { [:create_node, {"id" => 7}] }
+        let(:command2) { [:create_unique_node, {"id" => 8}] }
+        let(:command3) { [:create_node, {"id" => 9}] }
+        it "on unit with f should be equal f" do
+          batch1, _, _ = create_batches(command1, command2, command3)
 
-      Batch.unit().bind(batch1).should == batch1
-    end
+          Batch.unit().bind(batch1).should == batch1
+        end
 
-    it "with unit should be equal Batch" do
-      batch1, _, _ = create_batches(command1, command2, command3)
+        it "with unit should be equal Batch" do
+          batch1, _, _ = create_batches(command1, command2, command3)
 
-      batch1.bind(Batch.unit()).should == batch1
-    end
+          batch1.bind(Batch.unit()).should == batch1
+        end
 
-    it "chained should be equal to bind with inner binds" do
-      batch1, batch2, batch3 = create_batches(command1, command2, command3)
-      result1 = batch3.bind(batch1).bind(batch2)
+        it "chained should be equal to bind with inner binds" do
+          batch1, batch2, batch3 = create_batches(command1, command2, command3)
+          result1 = batch3.bind(batch1).bind(batch2)
 
-      batch1, batch2, batch3 = create_batches(command1, command2, command3)
-      f = ->() { batch1 }
-      g = ->() { batch2 }
-      result2 = batch3.bind(batch1.bind(batch2))
+          batch1, batch2, batch3 = create_batches(command1, command2, command3)
+          f = ->() { batch1 }
+          g = ->() { batch2 }
+          result2 = batch3.bind(batch1.bind(batch2))
 
-      result1.should == result2
-    end
+          result1.should == result2
+        end
 
-    describe "and submit" do
-      it "should combine separate batches into one batch" do
-        batch1 = Batch.new(db)
-        ref11 = batch1 << [:create_node, {"id" => 1}]
-        ref12 = batch1 << [:create_node, {"id" => 2}]
-        batch1 << [:create_relationship, ref11, ref12, {}]
-
-        batch2 = Batch.new(db)
-        ref21 = batch2 << [:create_node, {"id" => 3}]
-        ref22 = batch2 << [:create_node, {"id" => 4}]
-        batch2 << [:create_relationship, ref21, ref22, {}]
-
-        batch = batch2.bind(batch1)
-
-        db.should_receive(:batch).with do |*commands|
-          commands[0].should == [:create_node, {"id" => 3}]
-          commands[1].should == [:create_node, {"id" => 4}]
-          commands[2].should == [:create_relationship, "{0}", "{1}", {}]
-          commands[3].should == [:create_node, {"id" => 1}]
-          commands[4].should == [:create_node, {"id" => 2}]
-          commands[5].should == [:create_relationship, "{3}", "{4}", {}]
-        end.and_return([])
-
-        batch.submit()
+        describe "and submit" do
+          it "should combine separate batches into one batch" do
+            batch1 = Batch.new(db)
+            ref11 = batch1 << [:create_node, {"id" => 1}]
+            ref12 = batch1 << [:create_node, {"id" => 2}]
+            batch1 << [:create_relationship, ref11, ref12, {}]
+
+            batch2 = Batch.new(db)
+            ref21 = batch2 << [:create_node, {"id" => 3}]
+            ref22 = batch2 << [:create_node, {"id" => 4}]
+            batch2 << [:create_relationship, ref21, ref22, {}]
+
+            batch = batch2.bind(batch1)
+
+            db.should_receive(:batch).with do |*commands|
+              commands[0].should == [:create_node, {"id" => 3}]
+              commands[1].should == [:create_node, {"id" => 4}]
+              commands[2].should == [:create_relationship, "{0}", "{1}", {}]
+              commands[3].should == [:create_node, {"id" => 1}]
+              commands[4].should == [:create_node, {"id" => 2}]
+              commands[5].should == [:create_relationship, "{3}", "{4}", {}]
+            end.and_return([])
+
+            batch.submit()
+          end
+        end
       end
-    end
-  end
-  describe "find_reference" do
-    it "should return reference when command is found" do
-      ref1 = subject << [:create_node, {"id" => 7}]
-      ref2 = subject << [:create_node, {"id" => 8}]
-      subject << [:create_relationship, ref2, ref1, {}]
-
-      result = subject.find_reference { |c| c[0] == :create_node && c[1]["id"] == 8 }
-      result.should have(1).item
-      result.should include(ref2)
-    end
-
-    it "should return empty when command is not found" do
-      result = subject.find_reference { |c| c[0] == :create_node && c[1]["id"] == 8 }
-      result.should be_empty
-    end
-
-    it "should return all reference when no predicate specified" do
-      ref1 = subject << [:create_node, {"id" => 7}]
-      ref2 = subject << [:create_node, {"id" => 8}]
+      describe "find_reference" do
+        it "should return reference when command is found" do
+          ref1 = subject << [:create_node, {"id" => 7}]
+          ref2 = subject << [:create_node, {"id" => 8}]
+          subject << [:create_relationship, ref2, ref1, {}]
+
+          result = subject.find_reference { |c| c[0] == :create_node && c[1]["id"] == 8 }
+          result.should have(1).item
+          result.should include(ref2)
+        end
 
-      result = subject.find_reference()
-      result.should have(2).item
-    end
-  end
-  describe "<<" do
-    it "should be the same as add when command is argument" do
-      command = [:create_node]
-      batch_used_with_add = Batch.new
-      batch_used_with_add.add command
+        it "should return empty when command is not found" do
+          result = subject.find_reference { |c| c[0] == :create_node && c[1]["id"] == 8 }
+          result.should be_empty
+        end
 
-      subject << command
+        it "should return all reference when no predicate specified" do
+          ref1 = subject << [:create_node, {"id" => 7}]
+          ref2 = subject << [:create_node, {"id" => 8}]
 
-      subject.should == batch_used_with_add
-    end
-    it "should be the same as bind when command is Batch" do
-      another_batch = Batch.new do |b|
-        b << [:create_node]
+          result = subject.find_reference()
+          result.should have(2).item
+        end
       end
-      subject << [:create_node]
+      describe "<<" do
+        it "should be the same as add when command is argument" do
+          command = [:create_node]
+          batch_used_with_add = Batch.new
+          batch_used_with_add.add command
 
-      subject << another_batch
+          subject << command
 
-      db.should_receive(:batch) do |*commands|
-        commands.should have(2).items
-      end.and_return([])
-      subject.submit()
-    end
-  end
-  describe "add and submit" do
-    it "should raise exception when added element doesn't respond to :each" do
-      -> { subject.add(1) }.should raise_exception(StandardError)
-    end
+          subject.should == batch_used_with_add
+        end
+        it "should be the same as bind when command is Batch" do
+          another_batch = Batch.new do |b|
+            b << [:create_node]
+          end
+          subject << [:create_node]
 
-    it "should add command to be submitted later" do
-      command = [:create_node]
-      subject.add(command)
+          subject << another_batch
 
-      db.should_receive(:batch).with(command).and_return([])
+          db.should_receive(:batch) do |*commands|
+            commands.should have(2).items
+          end.and_return([])
+          subject.submit()
+        end
+      end
+      describe "add and submit" do
+        it "should raise exception when added element doesn't respond to :each" do
+          -> { subject.add(1) }.should raise_exception(StandardError)
+        end
 
-      subject.submit()
-    end
+        it "should add command to be submitted later" do
+          command = [:create_node]
+          subject.add(command)
 
-    it "should resolve references to preceding commands" do
-      jim = subject << [:create_node]
-      john = subject << [:create_node]
-      subject << [:create_relationship, john, jim]
+          db.should_receive(:batch).with(command).and_return([])
 
-      db.should_receive(:batch).with do |*commands|
-        relationship_cmd = commands.last
-        relationship_cmd[1].should == "{1}" # john was resolved to index where john was created
-        relationship_cmd[2].should == "{0}" # jim was resolved to index where john was created
-      end.and_return([])
+          subject.submit()
+        end
 
-      subject.submit()
-    end
+        it "should resolve references to preceding commands" do
+          jim = subject << [:create_node]
+          john = subject << [:create_node]
+          subject << [:create_relationship, john, jim]
 
-    context "when list 2 commands" do
-      before do
-        @john = subject.add [:create_node]
-        @markus = subject.add [:create_node]
-      end
-      context "and another command is added" do
-        let(:another_command) { [:create_relationship] }
-        before do
-          subject.add(another_command)
-        end
-        it "should contain 3 commands" do
           db.should_receive(:batch).with do |*commands|
-            commands.should have(3).items
+            relationship_cmd = commands.last
+            relationship_cmd[1].should == "{1}" # john was resolved to index where john was created
+            relationship_cmd[2].should == "{0}" # jim was resolved to index where john was created
           end.and_return([])
 
           subject.submit()
         end
-        it "should append command" do
-          db.should_receive(:batch).with do |*commands|
-            commands.last.should == another_command
-          end.and_return([])
 
-          subject.submit()
+        context "when list 2 commands" do
+          before do
+            @john = subject.add [:create_node]
+            @markus = subject.add [:create_node]
+          end
+          context "and another command is added" do
+            let(:another_command) { [:create_relationship] }
+            before do
+              subject.add(another_command)
+            end
+            it "should contain 3 commands" do
+              db.should_receive(:batch).with do |*commands|
+                commands.should have(3).items
+              end.and_return([])
+
+              subject.submit()
+            end
+            it "should append command" do
+              db.should_receive(:batch).with do |*commands|
+                commands.last.should == another_command
+              end.and_return([])
+
+              subject.submit()
+            end
+          end
         end
       end
-    end
-  end
-  describe "submit" do
-    it "should raise exception when server returns error" do
-      # this provokes a server error, because the second create_unique_node cannot be reference in create_relationship
-      subject << [:create_unique_node, "test", "id", "1", {}]
-      subject << [:create_unique_node, "test", "id", "2", {}]
-      subject << [:create_relationship, "test", "{0}", "{1}", {}]
-
-      ->() { subject.submit() }.should raise_error(StandardError)
-    end
-    it "should notify reference handler" do
-      node_1_result = nil
-      node_2_result = nil
-      ref1 = subject << [:create_node, {"id" => 1}]
-      ref2 = subject << [:create_node, {"id" => 2}]
-      ref1.after_submit do |node|
-        node_1_result = node
-      end
-      ref2.after_submit do |node|
-        node_2_result = node
-      end
-
-      subject.submit()
+      describe "submit" do
+        it "should raise exception when server returns error" do
+          # this provokes a server error, because the second create_unique_node cannot be reference in create_relationship
+          subject << [:create_unique_node, "test", "id", "1", {}]
+          subject << [:create_unique_node, "test", "id", "2", {}]
+          subject << [:create_relationship, "test", "{0}", "{1}", {}]
+
+          ->() { subject.submit() }.should raise_error(StandardError)
+        end
+        it "should notify reference handler" do
+          node_1_result = nil
+          node_2_result = nil
+          ref1 = subject << [:create_node, {"id" => 1}]
+          ref2 = subject << [:create_node, {"id" => 2}]
+          ref1.after_submit do |node|
+            node_1_result = node
+          end
+          ref2.after_submit do |node|
+            node_2_result = node
+          end
 
-      node_1_result.should_not be_nil
-      node_2_result.should_not be_nil
-      node_1_result["data"]["id"].should == 1
-      node_2_result["data"]["id"].should == 2
-    end
+          subject.submit()
 
-    it "should reset state of batch" do
-      subject << [:create_node, {"id" => 1}]
-      subject.submit()
+          node_1_result.should_not be_nil
+          node_2_result.should_not be_nil
+          node_1_result["data"]["id"].should == 1
+          node_2_result["data"]["id"].should == 2
+        end
 
-      db.should_not_receive(:batch)
-      result = subject.submit()
-      result.should be_empty
-    end
+        it "should reset state of batch" do
+          subject << [:create_node, {"id" => 1}]
+          subject.submit()
 
-    context "one create_node added" do
-      before { subject << [:create_node, {}] }
-      it "should return created node" do
-        result = subject.submit()
-        result.should have(1).items
-      end
-      it "should create-node on Db" do
-        result = subject.submit()
+          db.should_not_receive(:batch)
+          result = subject.submit()
+          result.should be_empty
+        end
 
-        node = result.first
-        node_id = db.get_id(node)
-        count = db.execute_query("start s=node(#{node_id}) return count(*)")
-        count["data"][0][0].should == 1
+        context "one create_node added" do
+          before { subject << [:create_node, {}] }
+          it "should return created node" do
+            result = subject.submit()
+            result.should have(1).items
+          end
+          it "should create-node on Db" do
+            result = subject.submit()
+
+            node = result.first
+            node_id = db.get_id(node)
+            count = db.execute_query("start s=node(#{node_id}) return count(*)")
+            count["data"][0][0].should == 1
+          end
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: neography-batch
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -75,6 +75,7 @@ files:
 - lib/neography-batch/batch.rb
 - lib/neography-batch/batch_reference.rb
 - neography-batch.gemspec
+- spec/batch_reference_spec.rb
 - spec/batch_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/Enceradeira/neography-batch