dm-types 0.9.11 → 0.10.0

data/spec/integration/uuid_spec.rb

@@ -1,46 +1,100 @@
-require 'pathname'
-require Pathname(__FILE__).dirname.parent.expand_path + 'spec_helper'
-
-begin
-  gem 'uuidtools', '~>1.0.7'
-  require 'uuidtools'
-rescue LoadError
-  skip_tests = true
-end
+require 'spec_helper'
+
+try_spec do
+
+  require 'spec/fixtures/network_node'
+
+  describe DataMapper::Types::Fixtures::NetworkNode do
+    describe 'with UUID set as UUID object' do
+      before :all do
+        @uuid_string = 'b0fc632e-d744-4821-afe3-4ea0701859ee'
+        @uuid        = UUIDTools::UUID.parse(@uuid_string)
+        @resource       = DataMapper::Types::Fixtures::NetworkNode.new(:uuid => @uuid)
+
+        @resource.save.should be_true
+      end
+
+      describe 'when reloaded' do
+        before :all do
+          @resource.reload
+        end
+
+        it 'has the same UUID string' do
+          @resource.uuid.to_s.should == @uuid_string
+        end
 
-describe 'DataMapper::Types::UUID' do
-  unless skip_tests
-    before(:all) do
-      class UUIDTest
-        include DataMapper::Resource
+        it 'returns UUID as an object' do
+          @resource.uuid.should be_an_instance_of(UUIDTools::UUID)
+        end
+      end
+    end
 
-        property :id, Serial
-        property :uuid, ::DataMapper::Types::UUID
+    describe 'with UUID set as a valid UUID string' do
+      before :all do
+        @uuid  = 'b0fc632e-d744-4821-afe3-4ea0701859ee'
+        @resource = DataMapper::Types::Fixtures::NetworkNode.new(:uuid => @uuid)
       end
 
-      UUIDTest.auto_migrate!
+      describe 'when reloaded' do
+        before :all do
+          @resource.reload
+        end
+
+        it 'has the same UUID string' do
+          @resource.uuid.to_s.should == @uuid
+        end
+
+        it 'returns UUID as an object' do
+          @resource.uuid.should be_an_instance_of(UUIDTools::UUID)
+        end
+      end
     end
 
-    it "should be settable as a uuid" do
-      u = UUIDTest.create(:uuid => UUID.parse('b0fc632e-d744-4821-afe3-4ea0701859ee'))
+    describe 'with UUID set as invalid UUID string' do
+      before :all do
+        @uuid  = 'meh'
+        @operation = lambda do
+          DataMapper::Types::Fixtures::NetworkNode.new(:uuid => @uuid)
+        end
+      end
 
-      u.uuid.should be_kind_of(UUID)
-      u.uuid.to_s.should == 'b0fc632e-d744-4821-afe3-4ea0701859ee'
+      describe 'when assigned UUID' do
+        it 'raises ArgumentError' do
+          @operation.should raise_error(ArgumentError, /Invalid UUID format/)
+        end
+      end
     end
 
-    it "should be settable as a string" do
-      u = UUIDTest.create(:uuid => 'b0fc632e-d744-4821-afe3-4ea0701859ee')
+    describe 'with UUID set as a blank string' do
+      before :all do
+        @uuid  = ''
+        @operation = lambda do
+          DataMapper::Types::Fixtures::NetworkNode.new(:uuid => @uuid)
+        end
+      end
 
-      u.uuid.should be_kind_of(UUID)
-      u.uuid.to_s.should == 'b0fc632e-d744-4821-afe3-4ea0701859ee'
+      describe 'when assigned UUID' do
+        it 'raises ArgumentError' do
+          @operation.should raise_error(ArgumentError, /Invalid UUID format/)
+        end
+      end
     end
 
-    it "should be allowed to be null" do
-      u = UUIDTest.create()
+    describe 'with missing UUID' do
+      before :all do
+        @uuid  = nil
+        @resource = DataMapper::Types::Fixtures::NetworkNode.new(:uuid => @uuid)
+      end
 
-      u.uuid.should be_nil
+      describe 'when reloaded' do
+        before :all do
+          @resource.reload
+        end
+
+        it 'has no UUID' do
+          @resource.uuid.should be_nil
+        end
+      end
     end
-  else
-    it 'requires the uuidtools gem to test'
   end
 end

data/spec/integration/yaml_spec.rb

@@ -1,37 +1,67 @@
-require 'pathname'
-require Pathname(__FILE__).dirname.parent.expand_path + 'spec_helper'
+require 'spec_helper'
 
-describe DataMapper::Types::Enum do
-  before(:all) do
-    class ::YamlTest
-      include DataMapper::Resource
+try_spec do
 
-      property :id, Serial
-      property :yaml, Yaml
+  require 'spec/fixtures/person'
+  require 'spec/fixtures/invention'
+
+  describe DataMapper::Types::Fixtures::Person do
+    before :all do
+      @resource = DataMapper::Types::Fixtures::Person.new(:name => '')
     end
-    YamlTest.auto_migrate!
 
-    class ::SerializeMe
-      attr_accessor :name
+    describe 'with no inventions information' do
+      before :all do
+        @resource.inventions = nil
+      end
+
+      describe 'when dumped and loaded again' do
+        before :all do
+          @resource.save.should be_true
+          @resource.reload
+        end
+
+        it 'has nil inventions list' do
+          @resource.inventions.should be_nil
+        end
+      end
     end
-  end
 
-  it "should work" do
-    obj = SerializeMe.new
-    obj.name = 'Hello!'
+    describe 'with a few items on the inventions list' do
+      before :all do
+        @input = [ 'carbon telephone transmitter', 'light bulb', 'electric grid' ].map do |name|
+          DataMapper::Types::Fixtures::Invention.new(name)
+        end
+        @resource.inventions = @input
+      end
 
-    repository(:default) do
-      YamlTest.create(:yaml => [1, 2, 3])
-      YamlTest.create(:yaml => obj)
+      describe 'when dumped and loaded again' do
+        before :all do
+          @resource.save.should be_true
+          @resource.reload
+        end
+
+        it 'loads inventions list to the state when it was dumped/persisted with keys being strings' do
+          @resource.inventions.should == @input
+        end
+      end
     end
 
-    tests = YamlTest.all
-    tests.first.yaml.should == [1, 2, 3]
-    tests.last.yaml.should be_kind_of(SerializeMe)
-    tests.last.yaml.name.should == 'Hello!'
-  end
+    describe 'with inventions information given as empty list' do
+      before :all do
+        @resource.inventions = []
+      end
 
-  it 'should immediately typecast supplied values' do
-    YamlTest.new(:yaml => [1, 2, 3]).yaml.should == [1, 2, 3]
+      describe 'when dumped and loaded again' do
+        before :all do
+          @resource.save.should be_true
+          @resource.reload
+        end
+
+        it 'has empty inventions list' do
+          @resource.inventions.should == []
+        end
+      end
+    end
   end
 end

data/spec/shared/identity_function_group.rb

@@ -0,0 +1,5 @@
+describe "identity function", :shared => true do
+  it "returns value unchanged" do
+    @result.should == @input
+  end
+end

data/spec/spec.opts

@@ -1 +1,2 @@
 --colour
+--loadby random

data/spec/spec_helper.rb

@@ -1,31 +1,63 @@
-require 'pathname'
 require 'rubygems'
 
-gem 'rspec', '~>1.2'
-require 'spec'
+# TODO: autovalidation hooks are needed badly,
+#       otherwise plugin devs will have to abuse
+#       alising and load order even further and it kinda makes
+#       me sad -- MK
 
-require Pathname(__FILE__).dirname.parent.expand_path + 'lib/dm-types'
+# use local dm-core if running from a typical dev checkout.
+lib = File.join('..', '..', 'dm-core', 'lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib)
+require 'dm-core'
 
-ENV["SQLITE3_SPEC_URI"]   ||= 'sqlite3::memory:'
-ENV["MYSQL_SPEC_URI"]     ||= 'mysql://localhost/dm_core_test'
-ENV["POSTGRES_SPEC_URI"]  ||= 'postgres://postgres@localhost/dm_more_test'
+# use local dm-validations if running from a typical dev checkout.
+lib = File.join('..', 'dm-validations', 'lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib)
+require 'dm-validations'
 
-# DataMapper::Logger.new(STDOUT, :debug)
+# Support running specs with 'rake spec' and 'spec'
+$LOAD_PATH.unshift('lib') unless $LOAD_PATH.include?('lib')
+
+require 'dm-types'
+
+def load_driver(name, default_uri)
+  return false if ENV['ADAPTER'] != name.to_s
 
-def setup_adapter(name, default_uri = nil)
   begin
-    DataMapper.setup(name, ENV["#{ENV['ADAPTER'].to_s.upcase}_SPEC_URI"] || default_uri)
-    Object.const_set('ADAPTER', ENV['ADAPTER'].to_sym) if name.to_s == ENV['ADAPTER']
+    DataMapper.setup(name, ENV["#{name.to_s.upcase}_SPEC_URI"] || default_uri)
+    DataMapper::Repository.adapters[:default] =  DataMapper::Repository.adapters[name]
     true
-  rescue Exception => e
-    if name.to_s == ENV['ADAPTER']
-      Object.const_set('ADAPTER', nil)
-      warn "Could not load do_#{name}: #{e}"
-    end
+  rescue LoadError => e
+    warn "Could not load do_#{name}: #{e}"
     false
   end
 end
 
 ENV['ADAPTER'] ||= 'sqlite3'
 
-setup_adapter(:default)
+HAS_SQLITE3  = load_driver(:sqlite3,  'sqlite3::memory:')
+HAS_MYSQL    = load_driver(:mysql,    'mysql://localhost/dm_core_test')
+HAS_POSTGRES = load_driver(:postgres, 'postgres://postgres@localhost/dm_core_test')
+
+
+DEPENDENCIES = {
+  'bcrypt'    => 'bcrypt-ruby',
+  'fastercsv' => 'fastercsv',
+  'json'      => 'json',
+  'stringex'  => 'stringex',
+  'uuidtools' => 'uuidtools',
+}
+
+def try_spec
+  begin
+    yield
+  rescue NameError
+    # do nothing
+  rescue LoadError => error
+    raise error unless lib = error.message.match(/\Ano such file to load -- (.+)\z/)[1]
+
+    gem_location = DEPENDENCIES[lib] || raise("Unknown lib #{lib}")
+
+    warn "[WARNING] Skipping specs using #{lib}, please do: gem install #{gem_location}"
+  end
+end

data/spec/unit/bcrypt_hash_spec.rb

@@ -1,104 +1,147 @@
-require 'pathname'
-require Pathname(__FILE__).dirname.parent.expand_path + 'spec_helper'
+require 'spec_helper'
 
-include DataMapper::Types
-
-begin
-  gem 'bcrypt-ruby', '~>2.0.5'
-  require 'bcrypt'
-rescue LoadError
-  skip_tests = true
-end
-
-describe "DataMapper::Types::BCryptHash" do
-  unless skip_tests
-
-    before(:each) do
-      @clear_password = "DataMapper R0cks!"
+try_spec do
+  describe DataMapper::Types::BCryptHash do
+    before :all do
+      @clear_password   = 'DataMapper R0cks!'
       @crypted_password = BCrypt::Password.create(@clear_password)
+
       @nonstandard_type = 1
 
       class TestType
         @a = 1
-        @b = "Hi There"
+        @b = 'Hi There'
       end
       @nonstandard_type2 = TestType.new
     end
 
-    describe ".dump" do
-      it "should return a crypted hash as a BCrypt::Password" do
-        BCryptHash.dump(@clear_password, :property).should be_an_instance_of(BCrypt::Password)
-      end
+    describe '.dump' do
+      describe 'when argument is a string' do
+        before :all do
+          @input  = 'DataMapper'
+          @result = DataMapper::Types::BCryptHash.dump(@input, :property)
+        end
+
+        it 'returns instance of BCrypt::Password' do
+          @result.should be_an_instance_of(BCrypt::Password)
+        end
 
-      it "should return a string that is 60 characters long" do
-        BCryptHash.dump(@clear_password, :property).to_s.should have(60).characters
+        it 'returns a string that is 60 characters long' do
+          @result.should have(60).characters
+        end
       end
 
-      it "should return nil if nil is passed" do
-        BCryptHash.dump(nil, :property).should be_nil
+      describe 'when argument is nil' do
+        before :all do
+          @input  = nil
+          @result = DataMapper::Types::BCryptHash.dump(@input, :property)
+        end
+
+        it 'returns nil' do
+          @result.should be_nil
+        end
       end
     end
 
-    describe ".load" do
-      it "should return the password as a BCrypt::Password" do
-        BCryptHash.load(@crypted_password, :property).should be_an_instance_of(BCrypt::Password)
-      end
+    describe '.load' do
+      describe 'when argument is a string' do
+        before :all do
+          @input  = 'DataMapper'
+          @result = DataMapper::Types::BCryptHash.load(@crypted_password, :property)
+        end
+
+        it 'returns instance of BCrypt::Password' do
+          @result.should be_an_instance_of(BCrypt::Password)
+        end
 
-      it "should return the password as a password which matches" do
-        BCryptHash.load(@crypted_password, :property).should == @clear_password
+        it 'returns a string that matches original' do
+          @result.should == @clear_password
+        end
       end
 
-      it "should return nil if given nil" do
-        BCryptHash.load(nil, :property).should be_nil
+      describe 'when argument is nil' do
+        before :all do
+          @input  = nil
+          @result = DataMapper::Types::BCryptHash.load(@input, :property)
+        end
+
+        it 'returns nil' do
+          @result.should be_nil
+        end
       end
     end
 
-    describe ".typecast" do
-      it "should return the crypted_password as a BCrypt::Password" do
-        BCryptHash.typecast(@crypted_password, :property).should be_an_instance_of(BCrypt::Password)
-      end
+    describe '.typecast' do
+      describe 'when argument is a string' do
+        before :all do
+          @input  = 'bcrypt hash'
+          @result = DataMapper::Types::BCryptHash.typecast(@input, :property)
+        end
 
-      it "should match the password as a BCrypt::Password" do
-        BCryptHash.typecast(@crypted_password, :property).should == @clear_password
-      end
+        it 'casts argument to BCrypt::Password' do
+          @result.should be_an_instance_of(BCrypt::Password)
+        end
 
-      it "should return the string value of crypted_password as a BCrypt::Password" do
-        BCryptHash.typecast(@crypted_password.to_s, :property).should be_an_instance_of(BCrypt::Password)
+        it 'casts argument to value that matches input' do
+          @result.should == @input
+        end
       end
 
-      it "should match the password as a string of the crypted_password" do
-        BCryptHash.typecast(@crypted_password.to_s, :property).should == @clear_password
-      end
+      describe 'when argument is a blank string' do
+        before :all do
+          @input  = ''
+          @result = DataMapper::Types::BCryptHash.typecast(@input, :property)
+        end
 
-      it "should return the password as a BCrypt::Password" do
-        BCryptHash.typecast(@clear_password, :property).should be_an_instance_of(BCrypt::Password)
-      end
+        it 'casts argument to BCrypt::Password' do
+          @result.should be_an_instance_of(BCrypt::Password)
+        end
 
-      it "should match the password as clear_password" do
-        BCryptHash.typecast(@clear_password, :property).should == @clear_password
+        it 'casts argument to value that matches input' do
+          @result.should == @input
+        end
       end
 
-      it "should encrypt any type that has to_s" do
-        BCryptHash.typecast(@nonstandard_type, :property).should be_an_instance_of(BCrypt::Password)
-      end
+      describe 'when argument is integer' do
+        before :all do
+          @input  = 2249
+          @result = DataMapper::Types::BCryptHash.typecast(@input, :property)
+        end
 
-      it "should match the non-standard type" do
-        BCryptHash.typecast(@nonstandard_type, :property).should == @nonstandard_type
-      end
+        it 'casts argument to BCrypt::Password' do
+          @result.should be_an_instance_of(BCrypt::Password)
+        end
 
-      it "should encrypt anything passed to it" do
-        BCryptHash.typecast(@nonstandard_type2, :property).should be_an_instance_of(BCrypt::Password)
+        it 'casts argument to value that matches input' do
+          @result.should == @input
+        end
       end
 
-      it "should match user-defined types" do
-        BCryptHash.typecast(@nonstandard_type2, :property).should == @nonstandard_type2
+      describe 'when argument is hash' do
+        before :all do
+          @input  = { :cryptic => 'obscure' }
+          @result = DataMapper::Types::BCryptHash.typecast(@input, :property)
+        end
+
+        it 'casts argument to BCrypt::Password' do
+          @result.should be_an_instance_of(BCrypt::Password)
+        end
+
+        it 'casts argument to value that matches input' do
+          @result.should == @input
+        end
       end
 
-      it "should return nil if given nil" do
-        BCryptHash.typecast(nil, :property).should be_nil
+      describe 'when argument is nil' do
+        before :all do
+          @input  = nil
+          @result = DataMapper::Types::BCryptHash.typecast(@input, :property)
+        end
+
+        it 'returns nil' do
+          @result.should be_nil
+        end
       end
     end
-  else
-    it "requires the bcrypt-ruby gem to test"
   end
 end