gisele-vm 0.6.0

data/spec/unit/prog_list/memory/test_to_relation.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+class Gisele::VM
+  describe ProgList::Memory, 'save' do
+    let(:list){ ProgList::Memory.new }
+
+    before do
+      @puids = (0..1).map{ list.save(Prog.new) }
+      @puids.size.should eq(2)
+    end
+
+    it 'helps getting a relation' do
+      list.to_relation.should be_a(Alf::Relation)
+      list.to_relation.project([:puid]).should eq(Relation(:puid => @puids))
+    end
+
+  end
+end

data/spec/unit/prog_list/sqldb/test_component.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe ProgList::Sqldb, :sqlite => true do
+      subject do
+        ProgList::Sqldb.new sqlite_memory
+      end
+      it_should_behave_like "a component"
+    end
+  end
+end

data/spec/unit/prog_list/sqldb/test_connect.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe ProgList::Sqldb, 'connect', :sqlite => true do
+
+      let(:db){ @db ||= ProgList::Sqldb.new(options) }
+
+      before do
+        db.registered(vm)
+      end
+
+      subject do
+        db.connect
+      end
+
+      after do
+        db.disconnect
+        db.unregistered
+      end
+
+      context 'when the database is unreachable' do
+        let(:options){ {:uri => "postgres://localhost:145/database"} }
+        it 'raises an error' do
+          lambda{
+            subject
+          }.should raise_error(Sequel::Error)
+        end
+      end
+
+      context 'when the database is creatable' do
+        let(:options){ sqlite_memory }
+        it 'returns itself' do
+          subject.should be_a(ProgList::Sqldb)
+        end
+        it 'sets the database under sequel_db' do
+          subject.sequel_db.should be_a(Sequel::Database)
+        end
+        it 'installs the schema' do
+          table_name = subject.send(:table_name)
+          subject.sequel_db.table_exists?(table_name).should be_true
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/prog_list/test_memory.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe ProgList::Memory do
+      subject{ @proglist ||= ProgList::Memory.new }
+      it_should_behave_like "a Storage"
+    end
+  end
+end

data/spec/unit/prog_list/test_sqldb.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe ProgList::Sqldb, :sqlite => true do
+      subject do
+        @proglist ||= begin
+          ProgList::Sqldb.new(sqlite_memory)
+        end
+      end
+      it_should_behave_like "a Storage"
+    end
+  end
+end

data/spec/unit/prog_list/test_storage.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe ProgList, 'storage' do
+      subject{ ProgList.storage(arg) }
+
+      before do
+        subject.should be_a(ProgList::Sqldb)
+      end
+
+      context 'without arg' do
+        let(:arg){ nil }
+        it 'uses an in-memory storage' do
+          subject.options[:uri].should match(/memory/)
+        end
+      end
+
+      context "with 'memory'" do
+        let(:arg){ "memory" }
+        it 'uses an in-memory storage' do
+          subject.options[:uri].should match(/sqlite:memory/)
+        end
+      end
+
+      context "with a specified uri" do
+        let(:arg){ "sqlite://ping.db" }
+        it 'uses an in-memory storage' do
+          subject.options[:uri].should eq("sqlite://ping.db")
+        end
+      end
+
+      context "when options include an uri" do
+        let(:arg){ {:uri => "sqlite://ping.db"} }
+        it 'uses an in-memory storage' do
+          subject.options[:uri].should eq("sqlite://ping.db")
+        end
+      end
+
+      context "with options but no uri" do
+        let(:arg){ {:ping => "pong"} }
+        it 'uses an in-memory storage' do
+          subject.options[:uri].should match(/sqlite:memory/)
+        end
+        it 'installs options' do
+          subject.options[:ping].should eq("pong")
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/registry/test_component.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Registry do
+      subject{ Registry.new(vm) }
+      it_should_behave_like "a component"
+    end
+  end
+end

data/spec/unit/registry/test_connect.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Registry, "connect" do
+
+      let(:registry){ Registry.new(vm) }
+      let(:c1){ Component.new }
+      let(:c2){ Component.new }
+      let(:c3){ Component.new }
+
+      subject do
+        registry.connect
+      end
+
+      before do
+        registry.register(c1)
+        registry.register(c2)
+        registry.register(c3)
+        registry.components.should eq([c1, c2, c3])
+      end
+
+      context "when everything goes right" do
+        it 'connects all components' do
+          subject
+          registry.components.each do |c|
+            c.should be_connected
+            c.vm.should eq(vm)
+          end
+        end
+      end
+
+      context "when a component fails to load" do
+        before do
+          def c2.connect
+            raise ArgumentError, "blah"
+          end
+        end
+        it 'raise the original error' do
+          lambda{
+            subject
+          }.should raise_error(ArgumentError, "blah")
+        end
+        it 'disconnects connected components' do
+          subject rescue nil
+          registry.components.each do |c|
+            c.should_not be_connected
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/registry/test_disconnect.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Registry, "connect" do
+
+      let(:registry){ Registry.new(vm) }
+      let(:c1){ Component.new }
+      let(:c2){ Component.new }
+      let(:c3){ Component.new }
+
+      subject do
+        registry.disconnect
+      end
+
+      before do
+        registry.register(c1)
+        registry.register(c2)
+        registry.register(c3)
+        registry.components.should eq([c1, c2, c3])
+        registry.connect
+        subject
+      end
+
+      context 'when everything goes fine' do
+        it 'keeps components registered' do
+          registry.components.should eq([c1, c2, c3])
+        end
+        it 'disconnects all components' do
+          registry.components.each do |c|
+            c.should_not be_connected
+          end
+        end
+      end
+
+      context 'when a component encounters an error' do
+        before do
+          def c3.disconnect
+            super
+            raise ArgumentError
+          end
+        end
+        it 'silently disconnects all components' do
+          registry.components.each do |c|
+            c.should_not be_connected
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/registry/test_registration.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Registry, "registration" do
+
+      subject{ Registry.new(vm)  }
+      let(:c){ Component.new }
+      let(:c_prior){ Component.new }
+
+      it 'allows registering and unregistering components' do
+        subject.register(c)
+        subject.components.should be_include(c)
+        c.should be_registered
+        c.vm.should eq(vm)
+        subject.unregister(c)
+        subject.components.should_not be_include(c)
+        c.should_not be_registered
+      end
+
+      it 'allows registring prior components' do
+        subject.register(c)
+        subject.register(c_prior, true)
+        subject.components.should eq([c_prior, c])
+        c.should be_registered
+      end
+
+      it 'raises an error if hot registration' do
+        subject.connect
+        lambda{
+          subject.register(c)
+        }.should raise_error(NotImplementedError)
+      end
+
+      it 'raises an error if hot unregistration' do
+        subject.register(c)
+        subject.connect
+        lambda{
+          subject.unregister(c)
+        }.should raise_error(NotImplementedError)
+      end
+
+    end
+  end
+end

data/spec/unit/shared/a_component.rb

@@ -0,0 +1,49 @@
+module Gisele
+  class VM
+    shared_examples_for "a component" do
+
+      it 'allows vm registration and de-registration' do
+        the_vm = vm
+        subject.registered(the_vm)
+        subject.should be_registered
+        subject.vm.should eq(the_vm)
+        subject.unregistered
+        subject.should_not be_registered
+        subject.vm.should be_a(NullObject)
+      end
+
+      it 'allows vm connection and deconnection' do
+        the_vm = vm
+        subject.registered(the_vm)
+        subject.connect
+        subject.should be_connected
+        subject.disconnect
+        subject.should_not be_connected
+      end
+
+      it 'raises an InvalidStateError when connect used unregistered' do
+        unless subject.registered? # the registry is always connected
+          lambda{
+            subject.connect
+          }.should raise_error(InvalidStateError, "Not registered")
+        end
+      end
+
+      it 'raises an InvalidStateError when connect is badly used' do
+        subject.registered(vm)
+        subject.connect
+        lambda{
+          subject.connect
+        }.should raise_error(InvalidStateError, "Already connected")
+      end
+
+      it 'raises an InvalidStateError when disconnect is badly used' do
+        subject.registered(vm)
+        lambda{
+          subject.disconnect
+        }.should raise_error(InvalidStateError, "Not connected")
+      end
+
+    end
+  end
+end

data/spec/unit/shared/a_storage.rb

@@ -0,0 +1,114 @@
+module Gisele
+  class VM
+    shared_examples_for "a Storage" do
+
+      def connect_and_clear
+        subject.registered(vm)
+        subject.connect
+        subject.clear
+      end
+
+      def disconnect_and_clear
+        subject.clear
+        subject.disconnect
+        subject.unregistered
+      end
+
+      describe "connect/disconnect" do
+        it 'allows connecting and disconnecting' do
+          subject.registered(vm)
+          subject.connect
+          subject.disconnect
+          subject.unregistered
+        end
+      end
+
+      describe 'fetch/save' do
+        before(:all){ connect_and_clear    }
+        after (:all){ disconnect_and_clear }
+
+        before do
+          @puid = subject.save(Prog.new)
+          @prog = subject.fetch(@puid)
+        end
+
+        it 'allows saving fresh new Prog instances' do
+          default = Prog.new.to_hash
+          default[:puid] = default[:parent] = default[:root] = @puid
+          default.should eq(@prog.to_hash)
+        end
+
+        it 'allows forking Prog instances' do
+          c_puid = subject.save(Prog.new :parent => @puid, :root => @puid)
+          child = subject.fetch(c_puid)
+          child.puid.should eq(c_puid)
+          child.parent.should eq(@puid)
+          child.root.should eq(@puid)
+        end
+
+        it 'allows saving Prog instances' do
+          @prog.pc    = :s18
+          @prog.input = [:ended]
+          s_puid  = subject.save(@prog)
+          fetched = subject.fetch(s_puid)
+          fetched.puid.should eq(@puid)
+          fetched.pc.should eq(:s18)
+          fetched.input.should eq([:ended])
+        end
+
+        it 'allows saving an array of Prog instances' do
+          @prog.pc = :s19
+          p1, p2 = subject.save([@prog, Prog.new])
+          p1.should eq(@puid)
+          subject.fetch(p1).pc.should eq(:s19)
+          subject.fetch(p2).parent.should eq(p2)
+        end
+      end
+
+      describe 'pick' do
+        before(:all) do
+          connect_and_clear
+          @enacted = subject.save(Prog.new :waitfor => :enacter)
+          @worlded = subject.save(Prog.new :waitfor => :world)
+        end
+        after (:all){ disconnect_and_clear }
+
+        it 'allows picking a prog based on a restriction' do
+          subject.pick(:waitfor => :enacter).should eq(subject.fetch(@enacted))
+          subject.pick(:waitfor => :world).should eq(subject.fetch(@worlded))
+        end
+
+        it 'returns nil if picking cannot be served' do
+          subject.pick(:waitfor => :operator).should be_nil
+        end
+      end
+
+      describe 'to_relation' do
+        before(:all) do
+          connect_and_clear
+          @enacted = subject.save(Prog.new :waitfor => :enacter, :pc => :s17)
+          @worlded = subject.save(Prog.new :waitfor => :world,   :pc => :s18)
+        end
+        after (:all){ disconnect_and_clear }
+
+        it 'returns a Relation wil all Progs by default' do
+          rel = subject.to_relation
+          expected = Relation([
+            { :puid => @enacted, :waitlist => {}, :pc => :s17 },
+            { :puid => @worlded, :waitlist => {}, :pc => :s18 }
+          ])
+          rel.project([:puid, :waitlist, :pc]).should eq(expected)
+        end
+
+        it 'supports a restriction Hash argument' do
+          rel = subject.to_relation(:waitfor => :enacter)
+          expected = Relation([
+            { :puid => @enacted, :waitlist => {}, :pc => :s17 },
+          ])
+          rel.project([:puid, :waitlist, :pc]).should eq(expected)
+        end
+      end
+
+    end
+  end
+end