lims-core 3.2.3

data/spec/persistence/sequel/spec_helper.rb

@@ -0,0 +1,39 @@
+require 'persistence/spec_helper'
+require 'yaml'
+require 'sequel'
+
+module Helper
+def save(object)
+  store.with_session do |session|
+    session << object
+    lambda { session.id_for(object) }
+  end.call
+end
+end
+
+RSpec.configure do |c|
+  c.include Helper
+end
+
+if RUBY_PLATFORM == "java"
+  require 'jdbc/sqlite3'
+  shared_context "sqlite db" do |&block|
+    let(:db) { ::Sequel.connect('jdbc:sqlite::memory:') }
+  end
+else
+  shared_context "sqlite db" do
+    let!(:db) { ::Sequel.sqlite('') }
+  end
+end
+
+config_database = YAML.load_file(File.join("config", "database.yml"))
+ENV["LIMS_SUPPORT_ENV"] = "development" unless ENV["LIMS_SUPPORT_ENV"]
+env = ENV["LIMS_SUPPORT_ENV"]
+connection_params = config_database['test_mysql']
+
+shared_context "mysql db" do |&block|
+  let!(:db) { ::Sequel.connect(connection_params) }
+  let(:store) { Lims::Core::Persistence::Sequel::Store.new(db) }
+end
+
+

data/spec/persistence/sequel/store_shared.rb

@@ -0,0 +1,25 @@
+
+# Spec requirements
+require 'spec_helper'
+
+# Model requirements
+require 'sequel'
+require 'lims-core/persistence/sequel/store'
+Sequel.extension :migration
+
+shared_context "prepare tables" do
+  def prepare_table(db)
+    Sequel::Migrator.run(db, 'db/migrations')
+  end
+end
+
+Loggers = []
+#require 'logger'; Loggers << Logger.new($stdout)
+
+shared_context "sequel store" do
+    include_context "prepare tables"
+    let(:db) {  Sequel.sqlite '' , :loggers => Loggers }
+    let(:store) { Lims::Core::Persistence::Sequel::Store.new(db) }
+    before (:each) { prepare_table(db) }
+
+end

data/spec/persistence/sequel/store_spec.rb

@@ -0,0 +1,22 @@
+# Spec requirements
+require 'persistence/sequel/spec_helper'
+
+# Model requirements
+require 'lims-core/persistence/sequel/store'
+
+module Lims::Core::Persistence
+    describe Sequel::Store, :store => true, :persistence => true, :persistence => true, :sequel => true do
+      context "initialized with a valid database" do
+        include_context "sqlite db"
+        it "must  be valid" do
+          expect { described_class.new(db) }.to_not raise_error
+        end
+      end
+
+      context "initialized with something elese" do
+        it "must  be invalid" do
+          expect { described_class.new("my database") }.to raise_error
+        end
+      end
+    end
+end

data/spec/persistence/session_spec.rb

@@ -0,0 +1,199 @@
+# Spec requirements
+require 'persistence/spec_helper'
+
+# Model requirements
+require 'lims-core/persistence/store'
+require 'lims-core/persistence/session'
+
+
+module SessionSpec
+  class Model
+    include Lims::Core::Resource
+    attribute :value, String
+
+    def initialize(args)
+      case args
+      when String then @value = args
+      else
+        super(args)
+      end
+    end
+    def attributesX
+      {:nesting => {:value => @value} }
+    end
+
+    class ModelPersistor < Lims::Core::Persistence::Persistor
+      Model = SessionSpec::Model
+      @@objects ={}
+      def self.register(key, value)
+        key ||= @@objects.size + 1
+        @@objects[key] =  value
+        key
+      end
+
+      def bulk_load(states, *params, &block)
+        states.map { |state| block.call(@@objects[state.id].attributes.merge(id:state.id)) }
+      end
+
+      def self.clear()
+        @@objects ={}
+      end
+
+    end
+  end
+
+
+  shared_examples "doesn't save 'clean' objects" do
+    it "doesn't save read objects" do
+      store.with_session do |session|
+        loaded = session.model[1]
+        loaded.should == a # test the test works !
+        Model::ModelPersistor.any_instance.should_not_receive(:insert) do |state|
+          state.resource.should == a
+        end
+        Model::ModelPersistor.any_instance.should_receive(:insert) do |state|
+          state.resource.should == b
+        end
+        session << loaded << b
+      end
+    end
+    it "updates 'dirty' objects" do
+      store.with_session do |session|
+        loaded = session.model[1]
+        loaded.value = "new value"
+        Model::ModelPersistor.any_instance.should_not_receive(:insert) do |state|
+          state.resource.should == a
+        end
+        Model::ModelPersistor.any_instance.should_receive(:bulk_update) do |states|
+          states.size == 1
+          states.first.resource.should == loaded
+          1
+        end
+        Model::ModelPersistor.any_instance.should_receive(:insert) do |state|
+          state.resource.should == b
+          2
+        end
+        session << loaded << b
+      end
+    end
+  end
+
+  module Lims::Core::Persistence
+    describe Session, :session => true, :persistence => true, :persistence => true do
+      let(:store) { Store.new() }
+
+      context "#transaction" do
+        let(:a) { Model.new("A") }
+        let(:b) { Model.new("B") }
+        let(:c) { Model.new("C") }
+
+        it "save the 2 if no problem" do
+          Model::ModelPersistor.any_instance.should_receive(:insert) do |state|
+            state.resource.should == a
+          end
+          Model::ModelPersistor.any_instance.should_receive(:insert) do |state|
+            state.resource.should == b
+          end
+          store.with_session do |session|
+            session << a << b
+          end
+        end
+
+        context "#dirty attribute strategy" do
+          # Mock session and persistor to load object
+          let!(:persistor_class) {
+            Session.stub(:model_for) { Model }
+            Session.stub(:persistor_class_for).with(Model) do 
+              Model::ModelPersistor::clear()
+              Model::ModelPersistor::register(1, a)
+              Model::ModelPersistor::register(2, b)
+              Model::ModelPersistor
+            end
+          }
+          context "no strategy" do
+            it "save read objects" do
+              store.with_session do |session|
+                session.dirty_attribute_strategy = nil
+                loaded = session.model[1];
+                loaded.should == a # test the test works !
+                Model::ModelPersistor.any_instance.should_not_receive(:bulk_update) do |states|
+                  states.size == 1
+                  states.first.resource.should == a
+                  1
+                end
+                Model::ModelPersistor.any_instance.should_receive(:bulk_insert) do |states|
+                  states.map(&:resource).should include b
+                  states.map(&:resource).should_not include a
+                  2 
+                end
+                session << loaded  << b
+              end
+            end
+          end
+
+          context "deep copy strategy" do
+            before(:each) { store.dirty_attribute_strategy = Store::DIRTY_ATTRIBUTE_STRATEGY_DEEP_COPY }
+            include_context "doesn't save 'clean' objects"
+          end
+          context "sha1 strategy" do
+            before(:each) { store.dirty_attribute_strategy = Store::DIRTY_ATTRIBUTE_STRATEGY_SHA1 }
+            include_context "doesn't save 'clean' objects"
+          end
+          context "md5 strategy", :focus => true do
+            before(:each) { store.dirty_attribute_strategy = Store::DIRTY_ATTRIBUTE_STRATEGY_MD5 }
+            include_context "doesn't save 'clean' objects"
+          end
+        end
+
+        context "#nested" do
+          before(:each) { 
+            Model::ModelPersistor.any_instance.stub(:insert) do |state|
+              # We stub insert to register object so they can be reloaded.
+              # However, the registration is a class method therefore common
+              # to all Persistor. That should work because an new id is given
+              # even if the object has already been registered from another Persistor.
+              state.inserted(Model::ModelPersistor::register(nil, state.resource))
+            end
+          }
+          it "share object states with parent" do
+            store.with_session do |session|
+              session << a
+
+              session.with_subsession do |sub_session|
+                session.state_for(a).should equal(sub_session.state_for(a))
+              end
+            end
+          end
+
+          it "can access object from children session " do
+            store.with_session do |session|
+              id = session.with_subsession do |sub_session|
+                sub_session << a
+                lambda { sub_session.id_for(a) }
+              end.call
+              session.model[id].should equal(a)
+
+              store.with_session do |sub_session|
+              end
+            end
+          end
+
+          it "saves object in corresponding transaction"  do
+            last_session = store.with_session do |session|
+              session << a
+              session.with_subsession do |sub_session|
+                sub_session <<  b
+              end
+
+              session.state_for(a).new?.should == true # not saved yet
+              session.state_for(b).new?.should == false # saved by now
+
+              session
+            end
+            last_session.state_for(a).new?.should == false # saved by now
+          end
+        end
+      end
+    end
+  end
+end

data/spec/persistence/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'spec_helper'
+

data/spec/persistence/uuid_resource_spec.rb

@@ -0,0 +1,80 @@
+# vi: ts=2:sts=2:et:sw=2 spell:spelllang=en
+require 'persistence/spec_helper'
+
+require 'lims-core/persistence/uuid_resource'
+
+module Lims::Core
+  module Persistence
+    describe UuidResource, :uuid_resource => true, :uuid => true, :persistence => true do
+      context "#class" do
+        subject { UuidResource }
+        it "validates valid uuid" do
+          subject.valid?("12345678-abcd-1234-ABCD-1234567890ab").should be_true
+        end
+
+        it "invalidates unvaild uuid" do
+          subject.valid?("12345678-Zbcd-1234-ABCD-1234567890ab").should be_false
+          subject.valid?("12345678-Zbcd-1234-ABCD-1234567890").should be_false
+          subject.valid?("I am not a uuid").should be_false
+        end
+
+        it "generates a UUID" do
+          subject.valid?(subject.generate_uuid()).should be_true
+        end 
+
+        it "generates different UUID" do
+          u1,u2 = 2.times { subject.generate_uuid()}
+          u1.should_not == u2
+        end
+
+        context "#conversion" do
+          context "to packed string" do
+            let(:to_pack) { "41424344-4546-4748-6162-636465666768" }
+            let(:packed) { "ABCDEFGHabcdefgh" }
+
+            it "pack" do
+              subject.pack(to_pack).should == packed
+            end
+
+            it "unpack" do
+              subject.unpack(packed).should == to_pack
+            end
+            it "converts unpacked to valid string" do
+              subject.valid?(subject.unpack(packed))
+            end
+          end
+          context "to bignum" do
+            let(:bignum) { 0x12345678abcd1234abcd1234567890ab }
+            let(:string) { "12345678-abcd-1234-abcd-1234567890ab" }
+
+            it "converts string to bignum" do
+              subject.string_to_bignum(string).should == bignum
+            end
+
+            it "converts bignum to string" do
+              subject.bignum_to_string(bignum).should == string
+            end
+            it "converts bignum to valid string" do
+              subject.valid?(subject.bignum_to_string(bignum))
+            end
+          end
+        end
+      end
+
+
+      context "created without an uuid" do
+        subject { described_class.new(:modeli => "model", :key => 1) }
+        it "should create an new uuid" do
+          subject.uuid.should_not be_nil
+        end
+      end
+      context "created with an uuid" do
+        let(:uuid) { UuidResource.generate_uuid }
+        subject { described_class.new(:model => "model", :key => 1, :uuid => uuid) }
+        it "keeps the same uuid" do
+          subject.uuid.should == uuid
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+  shared_examples "requires" do |attribute|
+    context "without #{attribute}" do
+      let(:excluded_parameters) { [attribute] }
+      it "'s not valid" do
+        subject.valid?.should == false
+      end
+    end
+
+  end
+

data/spec/subclass_tracker_sperc.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+require 'lims-core/subclass_tracker'
+
+
+module SubclassTrackerTest
+  class A
+    extend  Lims::Core::SubclassTracker
+  end
+
+  class B < A
+  end
+
+  class B2 < A
+  end
+
+  class C < B
+  end
+
+  module M
+    extend Lims::Core::SubclassTracker
+  end
+
+  class N
+    include M
+  end
+
+  class N2
+    include M
+  end
+
+  class O < N
+  end
+
+  class O2 < N2
+  end
+
+  describe Lims::Core::SubclassTracker do
+    context "track classes" do
+      subject { A }
+
+      it "responds to subclasses" do
+        subject.should respond_to(:subclasses)
+      end
+
+      it "list its children" do
+        subject.subclasses.should == [B, B2,  C]
+      end
+    end
+
+    context "track modules" do
+      subject { M }
+      it "responds to subclasses" do
+        subject.should respond_to(:subclasses)
+      end
+
+      it "list its children" do
+        subject.subclasses.should == [N, N2, O, O2]
+      end
+    end
+  end
+end