handle-system 0.0.3

data/lib/handle/permissions.rb

@@ -0,0 +1,61 @@
+module Handle
+  class Permissions
+    attr :bitmask
+
+    def initialize(*flags)
+      if flags.last.is_a?(Fixnum)
+        @bitmask = flags.pop
+      else
+        @bitmask = 0
+      end
+      @flags = Hash[flags.reverse.collect.with_index { |f,i| [f,2**i] }.reverse]
+    end
+
+    def bitmask=(value)
+      @bitmask = value.to_i
+    end
+
+    def method_missing(sym, *args)
+      flag = sym.to_s.sub(/([\?\=])$/,'').to_sym
+      if @flags.include?(flag)
+        case $1
+        when '?' then read(flag)
+        when '=' then write(flag,args.first)
+        else super(sym, *args)
+        end
+      else
+        super(sym, *args)
+      end
+    end
+
+    def to_bool
+      @flags.keys.collect { |flag| read(flag) }
+    end
+
+    def to_s
+      "%#{@flags.length}.#{@flags.length}b" % bitmask
+    end
+
+    def max
+      2**@flags.length-1
+    end
+
+    def read(flag)
+      self.bitmask & @flags[flag] > 0
+    end
+
+    def write(flag, value)
+      mask = @flags[flag]
+      if value
+        self.bitmask |= mask
+      else
+        self.bitmask &= (max - mask)
+      end
+    end
+
+    def inspect
+      str = @flags.keys.select { |flag| self.read(flag) }.collect { |flag| flag.inspect }.join(', ')
+      "[#{str}]"
+    end
+  end
+end

data/lib/handle/record.rb

@@ -0,0 +1,82 @@
+module Handle
+  class Record
+    attr :fields
+
+    def self.from_data(data)
+      result = self.new
+      if data.is_a?(String)
+        data.lines.each { |line| result << Handle::Field::Base.from_data(line) }
+      else
+        data.each { |field| result << Handle::Field::Base.from_data(field) }
+      end
+      result
+    end
+
+    def initialize(fields=[])
+      initialize_with(fields)
+    end
+
+    def initialize_with(fields)
+      @fields = fields
+    end
+
+    def to_a
+      @fields
+    end
+
+    def to_json *args
+      to_a.to_json *args
+    end
+
+    def to_s
+      fields.collect(&:to_s).join("\n")
+    end
+
+    def <<(field)
+      fields << field if field.kind_of?(Handle::Field::Base)
+    end
+
+    def add(field_type, value=nil)
+      field = Handle::Field.const_get(field_type).new
+      indexed_fields = fields.select { |f| f.index < 100 }.sort { |a,b| b.index <=> a.index }
+      if indexed_fields.empty?
+        field.index = 1
+      else
+        field.index = indexed_fields.first.index + 1
+      end
+      field.value = value
+      fields << field
+      field
+    end
+
+    def find_by_index(index)
+      self.find { |field| field.index == index }
+    end
+
+    def |(other)
+      result = { add: Record.new, update: Record.new, delete: Record.new }
+      my_ixs = self.collect(&:index).sort
+      other.each do |field|
+        if my_ixs.delete(field.index)
+          result[:update] << field
+        else
+          result[:add] << field
+        end
+      end
+      my_ixs.each { |ix| result[:delete] << self.find_by_index(ix) }
+      result
+    end
+
+    def ==(other)
+      self.to_a == other.to_a
+    end
+
+    def method_missing(sym, *args, &block)
+      if @fields.respond_to?(sym)
+        @fields.send(sym, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/handle/version.rb

@@ -0,0 +1,3 @@
+module Handle
+  VERSION = "0.0.3"
+end

data/lib/handle.rb

@@ -0,0 +1,19 @@
+require "handle/permissions"
+require "handle/record"
+require "handle/field"
+require "handle/field/admin"
+
+module Handle
+  persistence_module = Module.const_defined?('JRuby') ? 'java' : 'command'
+  require "handle/#{persistence_module}"
+  Record.send(:include, Handle::Persistence)
+  class HandleError < Exception
+    def initialize msg=nil
+      unless msg.nil?
+        msg = msg[0] + msg[1..-1].downcase
+      end
+      super msg
+    end
+  end
+  class NotFound < HandleError; end
+end

data/spec/admin_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path('../spec_helper',__FILE__)
+
+describe Handle::Field::HSAdmin do
+  let(:handle_str)  { Handle::Field::Base.from_data(' index=100 ttl=15200 type=HS_ADMIN rwr- "0FFF0000000D302E4E412F46414B452E41444D494E0000012C"') }
+  let(:handle_hash) { Handle::Field::Base.from_data({ index: 100, ttl: 15200, type: 'HS_ADMIN', perms: 14, value: '0FFF0000000D302E4E412F46414B452E41444D494E0000012C' }) }
+
+  it "#from_hash" do
+    handle = handle_hash
+    expect(handle).to be_a(Handle::Field::HSAdmin)
+    expect(handle.class.value_type).to eq('HS_ADMIN')
+    expect(handle.ttl).to eq(15200)
+    expect(handle.admin_handle).to eq('0.NA/FAKE.ADMIN')
+    expect(handle.admin_index).to eq(300)
+    expect(handle.admin_perms.bitmask).to eq(4095)
+#    expect(handle.value).to eq('http://www.example.edu/fake-handle')
+    expect(handle.value_str).to eq('300:111111111111:0.NA/FAKE.ADMIN')
+  end
+
+  it "#from_string" do
+    handle = handle_str
+    expect(handle).to be_a(Handle::Field::HSAdmin)
+    expect(handle.class.value_type).to eq('HS_ADMIN')
+    expect(handle.ttl).to eq(15200)
+    expect(handle.admin_handle).to eq('0.NA/FAKE.ADMIN')
+    expect(handle.admin_index).to eq(300)
+    expect(handle.admin_perms.bitmask).to eq(4095)
+#    expect(handle.value).to eq('http://www.example.edu/fake-handle')
+    expect(handle.value_str).to eq('300:111111111111:0.NA/FAKE.ADMIN')
+  end
+
+  it "#to_hash" do
+    h = handle_str.to_h
+    expect(h).to be_a(Hash)
+    expect(h).to eq({
+      index: 100,
+      type:  'HS_ADMIN',
+      ttl:   15200,
+      perms: 14,
+      admin_handle: '0.NA/FAKE.ADMIN',
+      admin_index: 300,
+      admin_perms: 4095
+    })
+  end
+
+  it "#to_s" do
+    expect(handle_hash.to_s).to eq(handle_str.to_s)
+  end
+end

data/spec/command/connection_spec.rb

@@ -0,0 +1,145 @@
+require File.expand_path('../../spec_helper',__FILE__)
+
+on_cruby do
+  def parse_batch(command)
+    (cmd, fname, redirect) = command.split(/\s+/,3)
+    File.read(fname).split(/\n\n/).collect { |batch| 
+      (op, data) = batch.split(/\n/,2)
+      { :op => op.strip, :data => data.strip }
+    }
+  end
+
+  describe Handle::Command::Connection do
+    describe "#initialize" do
+      it "file-based private key" do
+        Handle::Command::Connection.new('0.NA/FAKE.ADMIN', 300, 'privkey', 'keypass').batch { |b|
+          b.should_receive(:`) do |command|
+            expect(parse_batch(command)[0]).to eq({ op: "AUTHENTICATE PUBKEY:300:0.NA/FAKE.ADMIN", data: "privkey|keypass" })
+            ""
+          end
+        }.should be_true
+      end
+
+      it "shared secret" do
+        Handle::Command::Connection.new('0.NA/FAKE.ADMIN', 301, 'seckey') { |b|
+          b.should_receive(:`) do |command|
+            expect(parse_batch(command)[0]).to eq({ op: "AUTHENTICATE SECKEY:301:0.NA/FAKE.ADMIN", data: "seckey" })
+            ""
+          end
+        }.should be_true
+      end
+    end
+
+    describe "handle manipulation" do
+      let(:fake_handle) { 'FAKE.PREFIX/FAKE.HANDLE' }
+      let(:new_handle)  { 'FAKE.PREFIX/NEW.HANDLE'  }
+      let(:bad_handle)  { 'FAKE.PREFIX/NEW.HANDLE'  }
+
+      let(:record) {
+        record = Handle::Record.new
+        record.add(:URL, 'http://www.example.edu/fake-handle').index = 2
+        record.add(:Email, 'handle@example.edu').index = 6
+        record << Handle::Field::HSAdmin.new('0.NA/FAKE.ADMIN')
+        record
+      }
+      let(:server) { double(Handle::Java::Native::HSAdapter) }
+      subject { Handle::Command::Connection.new('0.NA/FAKE.ADMIN', 300, 'privkey', 'keypass') }
+
+      it "#resolve_handle" do
+        subject.should_receive(:`) { |command|
+          expect(command).to match(/hdl-qresolver #{fake_handle}/)
+          "Got Response:\n#{record.to_s}"
+        }
+        expect(subject.resolve_handle(fake_handle)).to eq(record)
+      end
+
+      it "#resolve_handle (not found)" do
+        subject.should_receive(:`) { |command|
+          expect(command).to match(/hdl-qresolver #{bad_handle}/)
+          "Got Error:\nError(100): HANDLE NOT FOUND"
+        }
+        expect { subject.resolve_handle(bad_handle) }.to raise_error(Handle::NotFound)
+      end
+
+      it "#resolve_handle (other error)" do
+        subject.should_receive(:`) { |command|
+          expect(command).to match(/hdl-qresolver #{bad_handle}/)
+          "Got Error:\nError(3): SERVER TOO BUSY"
+        }
+        expect { subject.resolve_handle(bad_handle) }.to raise_error(Handle::HandleError)
+      end
+
+      it "#create_record" do
+        new_record = subject.create_record(new_handle)
+        expect(new_record.connection).to eq(subject)
+        expect(new_record.handle).to eq(new_handle)
+      end
+
+      it "#create_handle" do
+        Handle::Command::Batch.any_instance.should_receive(:`) do |command|
+          ops = parse_batch(command)
+          expect(ops.length).to eq(2)
+          expect(ops[1][:op]).to eq("CREATE #{new_handle}")
+          expect(ops[1][:data]).to eq("2 URL 86400 1110 UTF8 http://www.example.edu/fake-handle\n6 EMAIL 86400 1110 UTF8 handle@example.edu\n100 HS_ADMIN 86400 1110 ADMIN 300:111111111111:0.NA/FAKE.ADMIN")
+          "==>SUCCESS[7]: create:#{new_handle}"
+        end
+        expect(subject.create_handle(new_handle, record)).to be_true
+      end
+
+      it "#create_handle (handle already exists)" do
+        Handle::Command::Batch.any_instance.should_receive(:`) do |command|
+          ops = parse_batch(command)
+          expect(ops.length).to eq(2)
+          expect(ops[1][:op]).to eq("CREATE #{new_handle}")
+          expect(ops[1][:data]).to eq("2 URL 86400 1110 UTF8 http://www.example.edu/fake-handle\n6 EMAIL 86400 1110 UTF8 handle@example.edu\n100 HS_ADMIN 86400 1110 ADMIN 300:111111111111:0.NA/FAKE.ADMIN")
+          "==>FAILURE[7]: create:#{new_handle}: Error(101): HANDLE ALREADY EXISTS"
+        end
+        expect { subject.create_handle(new_handle, record) }.to raise_error(Handle::HandleError)
+      end
+
+      it "#add_handle_values" do
+        Handle::Command::Batch.any_instance.should_receive(:`) do |command|
+          ops = parse_batch(command)
+          expect(ops.length).to eq(2)
+          expect(ops[1][:op]).to eq("ADD #{new_handle}")
+          expect(ops[1][:data]).to eq("2 URL 86400 1110 UTF8 http://www.example.edu/fake-handle\n6 EMAIL 86400 1110 UTF8 handle@example.edu\n100 HS_ADMIN 86400 1110 ADMIN 300:111111111111:0.NA/FAKE.ADMIN")
+          "==>SUCCESS[7]: add values:#{new_handle}"
+        end
+        expect(subject.add_handle_values(new_handle, record)).to be_true
+      end
+
+      it "#update_handle_values" do
+        Handle::Command::Batch.any_instance.should_receive(:`) do |command|
+          ops = parse_batch(command)
+          expect(ops.length).to eq(2)
+          expect(ops[1][:op]).to eq("MODIFY #{new_handle}")
+          expect(ops[1][:data]).to eq("2 URL 86400 1110 UTF8 http://www.example.edu/fake-handle\n6 EMAIL 86400 1110 UTF8 handle@example.edu\n100 HS_ADMIN 86400 1110 ADMIN 300:111111111111:0.NA/FAKE.ADMIN")
+          "==>SUCCESS[7]: modify values:#{new_handle}"
+        end
+        expect(subject.update_handle_values(new_handle, record)).to be_true
+      end
+
+      it "#delete_handle_values" do
+        Handle::Command::Batch.any_instance.should_receive(:`) do |command|
+          ops = parse_batch(command)
+          expect(ops.length).to eq(2)
+          expect(ops[1][:op]).to eq("REMOVE 2,6,100:#{new_handle}")
+          expect(ops[1][:data]).to be_empty
+          "==>SUCCESS[4]: delete values:#{new_handle}"
+        end
+        expect(subject.delete_handle_values(new_handle, record)).to be_true
+      end
+
+      it "#delete_handle" do
+        Handle::Command::Batch.any_instance.should_receive(:`) do |command|
+          ops = parse_batch(command)
+          expect(ops.length).to eq(2)
+          expect(ops[1][:op]).to eq("DELETE #{new_handle}")
+          expect(ops[1][:data]).to be_empty
+          "==>SUCCESS[7]: delete:#{new_handle}"
+        end
+        expect(subject.delete_handle(new_handle)).to be_true
+      end
+    end
+  end
+end

data/spec/command/persistence_spec.rb

@@ -0,0 +1,63 @@
+require File.expand_path('../../spec_helper',__FILE__)
+
+on_cruby do
+  describe Handle::Command::Persistence do
+    let(:fake_handle) { 'FAKE.PREFIX/FAKE.HANDLE' }
+    let(:connection)  { double(Handle::Command::Connection) }
+    let(:record) {
+      record = Handle::Record.new
+      record.add(:URL, 'http://www.example.edu/fake-handle').index = 2
+      record.add(:Email, 'handle@example.edu').index = 6
+      record << Handle::Field::HSAdmin.new('0.NA/FAKE.ADMIN')
+      record.connection = connection
+      record
+    }
+    subject { record }
+
+    it "#reload" do
+      current = subject.to_s
+      subject.handle = fake_handle
+      connection.should_receive(:resolve_handle).with(fake_handle) { Handle::Record.from_data(subject.to_s) }
+      subject.reload
+      expect(subject.to_s).to eq(current)
+    end
+
+    it "#destroy" do
+      subject.handle = fake_handle
+      connection.should_receive(:delete_handle).with(fake_handle)
+      subject.destroy
+    end
+
+    describe "#save" do
+      it "nil handle, no param" do
+        expect { subject.save }.to raise_error(Handle::HandleError)
+      end
+
+      it "nil handle, param" do
+        connection.should_receive(:create_handle).with(fake_handle, subject) { true }
+        expect(subject.save(fake_handle)).to be_true
+      end
+
+      it "existing handle, no existing record" do
+        subject.handle = fake_handle
+        current = subject.to_s
+        connection.should_receive(:resolve_handle).with(fake_handle) { raise Handle::NotFound.new('Handle not found') }
+        connection.should_receive(:create_handle) { |handle, record| expect(record).to eq(subject) }
+        subject.save
+      end
+
+      it "change existing record" do
+        subject.handle = fake_handle
+        current = subject.to_s
+        connection.should_receive(:resolve_handle).with(fake_handle) { Handle::Record.from_data(current) }
+        subject.delete(subject.find_by_index(6))
+        subject.add(:URN, 'info:example:fake-handle')
+        connection.should_receive(:delete_handle_values) { |handle, record| expect(record.length).to eq(1) }
+        connection.should_receive(:add_handle_values)    { |handle, record| expect(record.length).to eq(1) }
+        connection.should_receive(:update_handle_values) { |handle, record| expect(record.length).to eq(2) }
+        subject.save
+      end
+    end
+
+  end
+end

data/spec/field_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path('../spec_helper',__FILE__)
+
+describe Handle::Field do
+  let(:handle_str)  { Handle::Field::Base.from_data(' index=2 ttl=15200 type=URL rwr- "http://www.example.edu/fake-handle"') }
+  let(:handle_hash) { Handle::Field::Base.from_data({ index: 2, ttl: 15200, type: 'URL', perms: 14, value: 'http://www.example.edu/fake-handle' }) }
+
+  it "#from_hash" do
+    handle = handle_hash
+    expect(handle).to be_a(Handle::Field::URL)
+    expect(handle.class.value_type).to eq('URL')
+    expect(handle.ttl).to eq(15200)
+    expect(handle.value).to eq('http://www.example.edu/fake-handle')
+    expect(handle.value_str).to eq('http://www.example.edu/fake-handle')
+  end
+
+  it "#from_string" do
+    handle = handle_str
+    expect(handle).to be_a(Handle::Field::URL)
+    expect(handle.class.value_type).to eq('URL')
+    expect(handle.ttl).to eq(15200)
+    expect(handle.value).to eq('http://www.example.edu/fake-handle')
+    expect(handle.value_str).to eq('http://www.example.edu/fake-handle')
+  end
+
+  it "#to_hash" do
+    h = handle_str.to_h
+    expect(h).to be_a(Hash)
+    expect(h).to eq({
+      index: 2,
+      type:  'URL',
+      ttl:   15200,
+      perms: 14,
+      value: 'http://www.example.edu/fake-handle'
+    })
+  end
+
+  it "#to_s" do
+    expect(handle_hash.to_s).to eq(handle_str.to_s)
+  end
+end

data/spec/java/connection_spec.rb

@@ -0,0 +1,118 @@
+require File.expand_path('../../spec_helper',__FILE__)
+
+on_jruby do
+  describe Handle::Java::Connection do
+    describe "#initialize" do
+      it "file-based private key" do
+        File.should_receive(:exists?).with('privkey') { true }
+        File.should_receive(:read).with('privkey') { 'privkey_content' }
+        Handle::Java::Native::HSAdapterFactory.should_receive(:new_instance) do |handle, index, key, secret|
+          expect(handle).to eq('0.NA/FAKE.ADMIN')
+          expect(index).to eq(300)
+          expect(secret.collect(&:chr).join).to eq('keypass')
+          expect(key.collect(&:chr).join).to eq('privkey_content')
+        end
+        Handle::Java::Connection.new('0.NA/FAKE.ADMIN', 300, 'privkey', 'keypass')
+      end
+
+      it "literal private key" do
+        File.should_receive(:exists?).with('privkey') { false }
+        File.should_not_receive(:read)
+        Handle::Java::Native::HSAdapterFactory.should_receive(:new_instance) do |handle, index, key, secret|
+          expect(handle).to eq('0.NA/FAKE.ADMIN')
+          expect(index).to eq(300)
+          expect(secret.collect(&:chr).join).to eq('keypass')
+          expect(key.collect(&:chr).join).to eq('privkey')
+        end
+        Handle::Java::Connection.new('0.NA/FAKE.ADMIN', 300, 'privkey', 'keypass')
+      end
+
+      it "shared secret" do
+        File.should_not_receive(:exists?)
+        File.should_not_receive(:read)
+        Handle::Java::Native::HSAdapterFactory.should_receive(:new_instance) do |handle, index, key|
+          expect(handle).to eq('0.NA/FAKE.ADMIN')
+          expect(index).to eq(301)
+          expect(key.collect(&:chr).join).to eq('seckey')
+        end
+        Handle::Java::Connection.new('0.NA/FAKE.ADMIN', 301, 'seckey')
+      end
+    end
+
+    describe "handle manipulation" do
+      let(:fake_handle) { 'FAKE.PREFIX/FAKE.HANDLE' }
+      let(:new_handle)  { 'FAKE.PREFIX/NEW.HANDLE'  }
+      let(:bad_handle)  { 'FAKE.PREFIX/NEW.HANDLE'  }
+
+      let(:record) {
+        record = Handle::Record.new
+        record.add(:URL, 'http://www.example.edu/fake-handle').index = 2
+        record.add(:Email, 'handle@example.edu').index = 6
+        record << Handle::Field::HSAdmin.new('0.NA/FAKE.ADMIN')
+        record
+      }
+      let(:server) { double(Handle::Java::Native::HSAdapter) }
+      subject { Handle::Java::Connection.new('0.NA/FAKE.ADMIN', 300, 'privkey', 'keypass') }
+
+      before(:each) do
+        Handle::Java::Native::HSAdapterFactory.stub(:new_instance) { server }
+        Handle::Java::Native::HSAdapterFactory.stub(:newInstance)  { server }
+      end
+
+      it "#native" do
+        expect(subject.native).to eq(server)
+      end
+
+      it "#use_udp" do
+        server.should_receive(:setUseUDP).with(false)
+        subject.use_udp = false
+      end
+
+      it "#resolve_handle" do
+        server.should_receive(:resolveHandle).with(fake_handle, anything(), anything(), anything()) { record.to_s }
+        expect(subject.resolve_handle(fake_handle)).to eq(record)
+      end
+
+      it "#resolve_handle (not found)" do
+        server.should_receive(:resolveHandle).with(bad_handle, anything(), anything(), anything())  { raise Handle::Java::Native::HandleException.new(9, "Handle not found") }
+        expect { subject.resolve_handle(bad_handle) }.to raise_error(Handle::NotFound)
+      end
+
+      it "#resolve_handle (other error)" do
+        server.should_receive(:resolveHandle).with(bad_handle, anything(), anything(), anything())  { raise Handle::Java::Native::HandleException.new(2, "Service not found") }
+        expect { subject.resolve_handle(bad_handle) }.to raise_error(Handle::HandleError)
+      end
+
+      it "#create_record" do
+        new_record = subject.create_record(new_handle)
+        expect(new_record.connection).to eq(subject)
+        expect(new_record.handle).to eq(new_handle)
+      end
+
+      it "#create_handle" do
+        server.should_receive(:createHandle).with(new_handle, anything()) { true }
+        expect(subject.create_handle(new_handle, record)).to be_true
+      end
+
+      it "#add_handle_values" do
+        server.should_receive(:addHandleValues).with(new_handle, anything()) { true }
+        expect(subject.add_handle_values(new_handle, record)).to be_true
+      end
+
+      it "#update_handle_values" do
+        server.should_receive(:updateHandleValues).with(new_handle, anything()) { true }
+        expect(subject.update_handle_values(new_handle, record)).to be_true
+      end
+
+      it "#delete_handle_values" do
+        server.should_receive(:deleteHandleValues).with(new_handle, anything()) { true }
+        expect(subject.delete_handle_values(new_handle, record)).to be_true
+      end
+
+      it "#delete_handle" do
+        server.should_receive(:deleteHandle).with(new_handle) { true }
+        expect(subject.delete_handle(new_handle)).to be_true
+      end
+    end
+  end
+end

data/spec/java/persistence_spec.rb

@@ -0,0 +1,67 @@
+require File.expand_path('../../spec_helper',__FILE__)
+
+on_jruby do
+  describe Handle::Java::Persistence do
+    let(:fake_handle) { 'FAKE.PREFIX/FAKE.HANDLE' }
+    let(:connection)  { double(Handle::Java::Connection) }
+    let(:record) {
+      record = Handle::Record.new
+      record.add(:URL, 'http://www.example.edu/fake-handle').index = 2
+      record.add(:Email, 'handle@example.edu').index = 6
+      record << Handle::Field::HSAdmin.new('0.NA/FAKE.ADMIN')
+      record.connection = connection
+      record
+    }
+    subject { record }
+
+    it "#to_java" do
+      expect(Handle::Record.from_data(subject.to_java)).to eq(subject)
+    end
+
+    it "#reload" do
+      current = subject.to_s
+      subject.handle = fake_handle
+      connection.should_receive(:resolve_handle).with(fake_handle) { Handle::Record.from_data(subject.to_s) }
+      subject.reload
+      expect(subject.to_s).to eq(current)
+    end
+
+    it "#destroy" do
+      subject.handle = fake_handle
+      connection.should_receive(:delete_handle).with(fake_handle)
+      subject.destroy
+    end
+
+    describe "#save" do
+      it "nil handle, no param" do
+        expect { subject.save }.to raise_error(Handle::HandleError)
+      end
+
+      it "nil handle, param" do
+        connection.should_receive(:create_handle).with(fake_handle, subject) { true }
+        expect(subject.save(fake_handle)).to be_true
+      end
+
+      it "existing handle, no existing record" do
+        subject.handle = fake_handle
+        current = subject.to_s
+        connection.should_receive(:resolve_handle).with(fake_handle) { raise Handle::NotFound.new('Handle not found') }
+        connection.should_receive(:create_handle) { |handle, record| expect(record).to eq(subject) }
+        subject.save
+      end
+
+      it "change existing record" do
+        subject.handle = fake_handle
+        current = subject.to_s
+        connection.should_receive(:resolve_handle).with(fake_handle) { Handle::Record.from_data(current) }
+        subject.delete(subject.find_by_index(6))
+        subject.add(:URN, 'info:example:fake-handle')
+        connection.should_receive(:delete_handle_values) { |handle, record| expect(record.length).to eq(1) }
+        connection.should_receive(:add_handle_values)    { |handle, record| expect(record.length).to eq(1) }
+        connection.should_receive(:update_handle_values) { |handle, record| expect(record.length).to eq(2) }
+        subject.save
+      end
+    end
+
+  end
+end