dp_stm_map 0.0.2

data/spec/dp_stm_map/Client_spec.rb

@@ -0,0 +1,133 @@
+require 'dp_stm_map'
+
+require 'thread'
+require 'timeout'
+require 'tmpdir'
+require 'fileutils'
+Dir["./spec/**/*_shared.rb"].sort.each {|f| require f}
+
+module DpStmMap
+
+  describe DistributedPersistentStmMap do
+
+    before do
+      @storage_dir=Dir.mktmpdir
+      Dir.mkdir "%s/server" % @storage_dir
+      Dir.mkdir "%s/local" % @storage_dir
+      server.start
+    end
+
+    after do
+      server.stop
+      FileUtils.rm_rf(@storage_dir)
+      subject.stop
+    end
+
+    let(:server) {Manager.new port, "%s/server" % @storage_dir}
+
+    let(:port) {31337}
+
+    subject { DistributedPersistentStmMap.new 'localhost', port, "%s/local" % @storage_dir }
+
+
+    describe :map_behaviour do
+
+      before do
+        queue=Queue.new
+        subject.on_connected do
+          queue << "connected"
+        end
+        subject.start
+        timeout(1) do
+          queue.pop.should == "connected"
+        end
+      end
+
+
+      it_behaves_like "StmMap"
+    end    
+
+
+    it "should reconnect to server that has rebooted" do
+      queue=Queue.new
+      subject.on_connected do
+        queue << true
+      end
+      subject.start
+    end
+
+    describe :on_connected do
+      it "should be executed when client did connect to the manager" do
+
+        queue=Queue.new
+        subject.on_disconnected do
+          queue << "disconnected"
+        end
+        subject.on_connected do
+          queue << "connected"
+        end
+        subject.start
+        timeout(1) do
+          queue.pop.should == "connected"
+        end
+
+        sleep 0.1
+        server.stop        
+
+        timeout(5) do
+          queue.pop.should == "disconnected"
+        end
+
+        server.start
+
+        timeout(5) do
+          queue.pop.should == "connected"
+        end
+
+      end
+    end
+
+    describe :on_disconnected do
+      it "should be executed when client did disconnect from the manager" do
+        queue=Queue.new
+        subject.on_disconnected do
+          queue << "disconnected"
+        end
+        subject.on_connected do
+          queue << "connected"
+        end
+        subject.start
+
+        timeout(1) do
+          queue.pop.should == "connected"
+        end
+
+        subject.stop
+
+        timeout(1) do
+          queue.pop.should == "disconnected"
+        end
+      end
+    end
+
+    describe :stop do
+      it "should stop client" do
+        queue=Queue.new
+        subject.on_disconnected do
+          queue << "disconnected"
+        end
+        subject.on_connected do
+          queue << "connected"
+        end
+        subject.start
+        timeout(1) do
+          queue.pop.should == "connected"
+        end
+        subject.stop
+        timeout(1) do
+          queue.pop.should == "disconnected"
+        end
+      end
+    end
+  end
+end

data/spec/dp_stm_map/InMemoryStmMap_spec.rb

@@ -0,0 +1,10 @@
+require 'dp_stm_map'
+Dir["./spec/**/*_shared.rb"].sort.each {|f| require f}
+
+module DpStmMap
+
+  describe InMemoryStmMap do
+    it_behaves_like "StmMap"
+  end
+
+end

data/spec/dp_stm_map/Manager_spec.rb

@@ -0,0 +1,323 @@
+require 'dp_stm_map'
+require 'tmpdir'
+require 'yaml'
+require 'set'
+
+def send_message socket, message
+  yaml=message.serialize
+  socket.write([yaml.bytesize].pack("Q>"))
+  socket.write(yaml)
+  socket.flush
+  socket.rewind
+end
+
+module DpStmMap
+
+
+  describe CurrentValues do
+
+    before do
+      @storage_dir=Dir.mktmpdir
+    end
+
+    after do
+      FileUtils.rm_rf(@storage_dir)
+    end
+
+    subject {CurrentValues.new @storage_dir}
+
+    it "should store a new value" do
+      subject['x']='y'
+      subject['x'].should == 'y'
+    end
+
+
+    it "should change existing value" do
+      subject['x']='y'
+      subject['x']='z'
+      subject['x'].should == 'z'
+    end
+
+    it "should store nil" do
+      subject['x']=nil
+      subject['x'].should be_nil
+    end
+
+  end
+
+
+
+  describe TransactionLog do
+
+    before do
+      @storage_dir=Dir.mktmpdir
+    end
+
+    after do
+      FileUtils.rm_rf(@storage_dir)
+    end
+
+    subject {TransactionLog.new @storage_dir}
+
+    describe :store_transaction do
+      it "should store first transaction with id 1" do
+        subject.store_transaction({'x' => 'abc'},{'abc' => 'some data'},[]).should == 1
+      end
+    end
+
+
+    describe :add_listener do
+      it "should call listener with transaction when new transaction is available" do
+        queue=Queue.new
+        subject.add_listener(0) do |txid, change|
+          queue << [txid, change]
+        end
+        subject.store_transaction({'x' => 'abc'},{'abc' => 'some data'},[])
+        queue.pop.should == [1,[{'x' => 'abc'},{'abc' => 'some data'},[]]]
+      end
+
+
+      it "should call listener for all missed transactions" do
+        queue=Queue.new
+        subject.store_transaction({'x' => 'abc'},{'abc' => 'some data'},[])
+        subject.add_listener(0) do |txid, change|
+          queue << [txid, change]
+        end
+        queue.pop.should == [1,[{'x' => 'abc'},{'abc' => 'some data'},[]]]
+      end
+
+
+      it "should call all registered listeners" do
+        queue1=Queue.new
+        queue2=Queue.new
+        subject.store_transaction({'x' => 'abc'},{'abc' => 'some data'},[])
+        subject.add_listener(0) do |txid, change|
+          queue1 << [txid, change]
+        end
+        subject.add_listener(0) do |txid, change|
+          queue2 << [txid, change]
+        end
+        queue1.pop.should == [1,[{'x' => 'abc'},{'abc' => 'some data'},[]]]
+        queue2.pop.should == [1,[{'x' => 'abc'},{'abc' => 'some data'},[]]]
+      end
+
+
+    end
+  end
+
+
+  describe ReferenceCounts do
+
+    before do
+      @storage_dir=Dir.mktmpdir
+    end
+
+    after do
+      FileUtils.rm_rf(@storage_dir)
+    end
+
+
+    subject {ReferenceCounts.new @storage_dir}
+
+
+    describe :add_reference do
+      it "should record new reference" do
+        subject.add_reference 'abc'
+        subject.should have_references('abc')
+      end
+    end
+
+    describe :remove_reference do
+      it "should remove existing reference" do
+        subject.add_reference 'abc'
+        subject.remove_reference 'abc'
+        subject.should_not have_references('abc')
+      end
+
+      it "should raise exception when reference does not exist" do
+        expect{subject.remove_reference 'abc'}.to raise_error
+      end
+    end
+
+    describe :has_references? do
+      context "when there is one reference" do
+        before {subject.add_reference 'abc'}
+        it "should return true" do
+          subject.should have_references('abc')
+        end
+      end
+      context "when there are no references" do
+        it "should return false" do
+          subject.should_not have_references('abc')
+        end
+      end
+
+    end
+
+  end
+
+  describe ClientTransactionManager do
+
+    let(:current_values) {double("current values")}
+    let(:reference_counts) {double("reference counts")}
+    let(:transaction_log) {double("transaction log")}
+
+    subject {ClientTransactionManager.new current_values, reference_counts, transaction_log}
+
+    it "should apply valid transaction" do
+      current_values.should_receive(:[]).with('x').and_return(nil)
+      current_values.should_receive(:[]=).with('x','abc')
+      reference_counts.should_receive(:has_references?).with('abc').and_return(false)
+      reference_counts.should_receive(:add_reference).with('abc')
+      transaction_log.should_receive(:store_transaction).with({'x' => 'abc'},{'abc' => 'some value'}, []).and_return(1)
+      subject.apply_transaction({'x' => [nil,'abc']},{'abc' => 'some value'}).should == 1
+    end
+
+    it "should increase reference count of the new value" do
+      current_values.should_receive(:[]).with('x').and_return('def')
+      current_values.should_receive(:[]=).with('x','abc')
+      reference_counts.should_receive(:has_references?).with('abc').and_return(false)
+      reference_counts.should_receive(:has_references?).with('def').and_return(false)
+      reference_counts.should_receive(:add_reference).with('abc')
+      reference_counts.should_receive(:remove_reference).with('def')
+      transaction_log.should_receive(:store_transaction).with({'x' => 'abc'},{'abc' => 'some value'}, ['def'])
+      subject.apply_transaction({'x' => ['def','abc']},{'abc' => 'some value'})
+    end
+
+    it "should not increase reference count of nil" do
+      current_values.should_receive(:[]).with('x').and_return('def')
+      current_values.should_receive(:[]=).with('x',nil)
+      reference_counts.should_receive(:remove_reference).with('def')
+      reference_counts.should_receive(:has_references?).with('def').and_return(false)
+      transaction_log.should_receive(:store_transaction).with({'x' => nil},{}, ['def'])
+      subject.apply_transaction({'x' => ['def',nil]},{})
+    end
+
+    it "should refuse transaction referencing not existing data" do
+      current_values.should_receive(:[]).with('x').and_return(nil)
+      reference_counts.should_receive(:has_references?).with('abc').and_return(false)
+      expect {subject.apply_transaction({'x' => [nil,'abc']},{})}.to raise_error StaleTransactionError
+    end
+
+    it "should apply changes if nothing has changed" do
+      current_values.should_receive(:[]).with('x').and_return('abc')
+      transaction_log.should_receive(:store_transaction).with({},{}, [])
+      subject.apply_transaction({'x' => ['abc','abc']},{})
+    end
+
+    it "should refuse stale transaction" do
+      current_values.should_receive(:[]).with('x').and_return('def')
+      expect {subject.apply_transaction({'x' => [nil,'abc']},{'abc' => 'some value'})}.to raise_error StaleTransactionError
+    end
+
+
+  end
+
+
+
+  describe Manager do
+
+
+    let (:port) {0}
+
+
+    before do
+      @storage_dir=Dir.mktmpdir
+      subject.start
+    end
+
+    after do
+      FileUtils.rm_rf(@storage_dir)
+      begin
+        subject.stop
+      rescue => ex
+        STDERR.puts "#{ex.backtrace.join("\n")}: #{ex.message} (#{ex.class})"
+      end
+    end
+
+
+    before do
+      @storage_dir=Dir.mktmpdir
+    end
+
+    subject {Manager.new port, @storage_dir}
+
+    it "should start and stop" do
+      TCPSocket.new 'localhost',subject.port
+    end
+
+  end
+
+
+  describe SocketTransport do
+
+    let (:socket) {StringIO.new}
+
+    subject {SocketTransport.new socket}
+
+    describe :next_message do
+      it "should read sent message" do
+        send_message(socket, ClientHelloMessage.new(0))
+        subject.next_message.should be_a ClientHelloMessage
+      end
+    end
+
+    describe :send_message do
+      it "should serialize message" do
+        subject.send_message ClientHelloMessage.new(1)
+        socket.rewind
+        subject.next_message.should be_a ClientHelloMessage
+      end
+    end
+
+    describe :close do
+      it "should close socket" do
+        subject.close
+        socket.should be_closed
+      end
+    end
+  end
+
+
+  describe ClientHandler do
+
+    let (:client_transport) {double("client transport")}
+    let (:transaction_manager) {double("transaction manager")}
+
+
+    subject {ClientHandler.new client_transport, transaction_manager}
+
+
+    # it "should send server hello message to client" do
+    #   transaction_log.should_receive(:register_listener).with(0)
+    #   client_transport.should_receive(:send_message).with(an_instance_of(ServerHelloMessage))
+    #   subject.handle(ClientHelloMessage.new 0)
+    # end
+
+
+    it "should send transaction messages for all previous state transitions" do
+      client_transport.should_receive(:send_message).with(an_instance_of(TransactionMessage))
+      subject.handle(TransactionMessage.new(1, {},{}, []))
+    end
+
+    it "should invoke transaction manager operations on client transaction messages" do
+      transaction_manager.should_receive(:apply_transaction).with({"x"=>["a", "b"]}, {"b"=>"content"}).and_return(1)
+      client_transport.should_receive(:send_message) do |msg|
+          msg.should be_a ClientTransactionSuccessfulMessage
+          msg.transaction_sequence.should == 1
+      end
+      subject.handle(ClientTransactionMessage.new('tx1',{'x' => ['a','b']},{'b' => 'content'}))
+    end
+
+    it "should send ClientTransactionFailedMessage when transaction fails" do
+      transaction_manager.should_receive(:apply_transaction).with({"x"=>["a", "b"]}, {"b"=>"content"}).and_raise(StaleTransactionError)
+      client_transport.should_receive(:send_message).with(an_instance_of(ClientTransactionFailedMessage))
+      subject.handle(ClientTransactionMessage.new('tx1',{'x' => ['a','b']},{'b' => 'content'}))
+    end
+
+
+
+
+
+  end
+end

data/spec/dp_stm_map/Message_spec.rb

@@ -0,0 +1,21 @@
+require 'dp_stm_map/Message'
+
+module DpStmMap
+
+  describe JsonMessage do
+
+    subject {ServerHelloMessage.new}
+
+    # it "should be serializable to json" do
+    #   subject.serialize.should == "{\"type\":\"DpStmMap::ServerHelloMessage\"}"
+    # end
+
+    # it "should be deserializable from json" do
+    #   JsonMessage.deserialize("{\"type\":\"DpStmMap::ServerHelloMessage\"}").should be_a ServerHelloMessage
+    # end
+
+    
+  end
+
+  
+end

data/spec/dp_stm_map/ObjectStore_spec.rb

@@ -0,0 +1,87 @@
+require 'dp_stm_map'
+
+module DpStmMap
+
+  class SomeObject
+    attr_accessor :value
+
+    def == other
+      case other
+      when SomeObject
+        other.value == self.value
+      else
+        false
+      end
+    end
+  end
+
+  describe ObjectStore do
+
+
+    let(:some_object) {v=SomeObject.new; v.value='v1'; v}
+
+    subject {ObjectStore.new InMemoryStmMap.new}
+
+
+    describe :on_atomic do
+      it "should be executed after atomic change" do
+        changes=nil
+        subject.on_atomic do |c|
+          changes=c
+        end
+        subject.atomic do |tx|
+          tx[:user,'abc']=some_object
+        end
+        changes.should == {[:user, 'abc'] => [nil, some_object]}
+      end
+    end
+
+
+
+    describe :validate_atomic do
+      it "should stop transaction when exception is raised" do
+
+        changes=nil
+        subject.validate_atomic do |c|
+          changes=c
+          raise "something went wrong"
+        end
+
+        expect do
+          subject.atomic do |tx|
+            tx[:user,'abc']=some_object
+          end
+        end.to raise_error "something went wrong"
+
+        changes.should == {[:user, 'abc'] => [nil, some_object]}
+
+        subject.atomic_read do |tx|
+          tx[:user,'abc'].should == nil
+        end
+
+      end
+    end
+
+    describe :atomic do
+      it "should store Ruby objects" do
+        subject.atomic do |tx|
+          tx[:user,'abc']=some_object
+        end
+
+        subject.atomic_read do |tx|
+          tx.should have_key(:user, 'abc')
+          tx[:user,'abc'].should == some_object
+        end
+      end
+      it "should store nil values" do
+        subject.atomic do |tx|
+          tx[:user,'abc']=nil
+        end
+
+        subject.atomic_read do |tx|
+          tx[:user,'abc'].should == nil
+        end
+      end
+    end
+  end
+end