ardm-types 1.2.2

data/spec/integration/api_key_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+try_spec do
+  require './spec/fixtures/api_user'
+
+  describe DataMapper::TypesFixtures::APIUser do
+    supported_by :all do
+      subject { described_class.new(:name => 'alice') }
+
+      let(:original_api_key) { subject.api_key }
+
+      it "should have a default value" do
+        original_api_key.should_not be_nil
+      end
+
+      it "should preserve the default value" do
+        subject.api_key.should == original_api_key
+      end
+
+      it "should generate unique API Keys for each resource" do
+        other_resource = described_class.new(:name => 'eve')
+
+        other_resource.api_key.should_not == original_api_key
+      end
+    end
+  end
+end

data/spec/integration/bcrypt_hash_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+try_spec do
+
+  require './spec/fixtures/person'
+
+  describe DataMapper::TypesFixtures::Person do
+    supported_by :all do
+      before :all  do
+        @resource  = DataMapper::TypesFixtures::Person.create(:password => 'DataMapper R0cks!')
+        DataMapper::TypesFixtures::Person.create(:password => 'password1')
+
+        @people = DataMapper::TypesFixtures::Person.all
+        @resource.reload
+      end
+
+      it 'persists the password on initial save' do
+        @resource.password.should       == 'DataMapper R0cks!'
+        @people.last.password.should == 'password1'
+      end
+
+      it 'recalculates password hash on attribute update' do
+        @resource.attribute_set(:password, 'bcryptic obscure')
+        @resource.save
+
+        @resource.reload
+        @resource.password.should     == 'bcryptic obscure'
+        @resource.password.should_not == 'DataMapper R0cks!'
+      end
+
+      it 'does not change password value on reload' do
+        resource = @people.last
+        original = resource.password.to_s
+        resource.reload
+        resource.password.to_s.should == original
+      end
+
+      it 'uses cost of BCrypt::Engine::DEFAULT_COST' do
+        @resource.password.cost.should == BCrypt::Engine::DEFAULT_COST
+      end
+
+      it 'allows Bcrypt::Password#hash to be an Integer' do
+        @resource.password.hash.should be_kind_of(Integer)
+      end
+    end
+  end
+end

data/spec/integration/comma_separated_list_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+try_spec do
+
+  require './spec/fixtures/person'
+
+  describe DataMapper::TypesFixtures::Person do
+    supported_by :all do
+      before :all do
+        @resource = DataMapper::TypesFixtures::Person.new(:name => '')
+      end
+
+      describe 'with no interests information' do
+        before :all do
+          @resource.interests = nil
+        end
+
+        describe 'when dumped and loaded again' do
+          before :all do
+            @resource.save.should be(true)
+            @resource.reload
+          end
+
+          it 'has no interests' do
+            @resource.interests.should == nil
+          end
+        end
+      end
+
+      describe 'with no interests information' do
+        before :all do
+          @resource.interests = []
+        end
+
+        describe 'when dumped and loaded again' do
+          before :all do
+            @resource.save.should be(true)
+            @resource.reload
+          end
+
+          it 'has empty interests list' do
+            @resource.interests.should == []
+          end
+        end
+      end
+
+      describe 'with interests information given as a Hash' do
+        it 'raises ArgumentError' do
+          lambda do
+            @resource.interests = { :hash => 'value' }
+            @resource.save
+          end.should raise_error(ArgumentError, /must be a string, an array or nil/)
+        end
+      end
+
+      describe 'with a few items on the interests list' do
+        before :all do
+          @input = 'fire, water, fire, a whole lot of other interesting things, ,,,'
+          @resource.interests = @input
+        end
+
+        describe 'when dumped and loaded again' do
+          before :all do
+            @resource.save.should be(true)
+            @resource.reload
+          end
+
+          it 'includes "fire" in interests' do
+            @resource.interests.should include('fire')
+          end
+
+          it 'includes "water" in interests' do
+            @resource.interests.should include('water')
+          end
+
+          it 'includes "a whole lot of other interesting things" in interests' do
+            @resource.interests.should include('a whole lot of other interesting things')
+          end
+
+          it 'has blank entries removed' do
+            @resource.interests.any? { |i| DataMapper::Ext.blank?(i) }.should be(false)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/integration/dirty_minder_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+
+try_spec do
+
+  # FIXME: DirtyMinder is currently unsupported on RBX, because unlike the other
+  # supported Rubies, RBX core class (e.g. Array, Hash) methods use #send().  In
+  # other words, the other Rubies don't use #send() (they map directly to their
+  # C functions).
+  #
+  # The current methodology takes advantage of this by using #send() to forward
+  # method invocations we've hooked.  Supporting RBX will require finding
+  # another way, possibly for all Rubies.  In the meantime, something is better
+  # than nothing.
+  next if defined?(RUBY_ENGINE) and RUBY_ENGINE == 'rbx'
+
+  require './spec/fixtures/person'
+
+  describe DataMapper::TypesFixtures::Person do
+    supported_by :all do
+      before :all do
+        @resource = DataMapper::TypesFixtures::Person.new(:name => 'Thomas Edison')
+      end
+
+      describe 'with positions indirectly mutated as a hash' do
+        before :all do
+          @resource.positions = {
+            'company' => "Soon To Be Dirty, LLC",
+            'title'   => "Layperson",
+            'details' => { 'awesome' => true },
+          }
+          @resource.save
+          @resource.reload
+          @resource.positions['title'].should == 'Layperson'
+        end
+
+        describe "when I change positions" do
+          before :all do
+            @resource.clean?.should == true
+            @resource.positions['title'] = 'Chief Layer of People'
+            @resource.save
+            @resource.reload
+          end
+
+          it "should remember the new position" do
+            @resource.positions['title'].should == 'Chief Layer of People'
+          end
+        end
+
+        describe "when I add a new attribute of the position" do
+          before :all do
+            @resource.clean?.should == true
+            @resource.positions['pays_buttloads_of_money'] = true
+            @resource.save
+            @resource.reload
+          end
+
+          it "should remember the new attribute" do
+            @resource.positions['pays_buttloads_of_money'].should be(true)
+          end
+        end
+
+        describe "when I change the details of the position" do
+          before :all do
+            @resource.clean?.should == true
+            @resource.positions['details'].merge!('awesome' => "VERY TRUE")
+            @resource.save
+            @resource.reload
+          end
+
+          it "should remember the changed detail" do
+            pending "not supported (YET)" do
+              # TODO: Not supported (yet?) -- this is a much harder problem to
+              # solve: using mutating accessors of nested objects.  We could
+              # detect it from #dirty? (using the #hash method), but #dirty?
+              # only returns the status of known-mutated properties (not full,
+              # on-demand scan of object dirty-ness).
+              @resource.positions['details']['awesome'].should == 'VERY TRUE'
+            end
+          end
+        end
+
+        describe "when I reload the resource while the property is dirty" do
+          before :all do
+            @resource.positions['title'] = 'Chief Layer of People'
+            @resource.reload
+          end
+
+          it "should reflect the previously set/persisted value" do
+            @resource.positions.should_not be_nil
+            @resource.positions['title'].should == 'Layperson'
+          end
+        end
+
+      end # positions indirectly mutated as a hash
+
+      describe 'with positions indirectly mutated as an array' do
+        before :all do
+          @resource.positions = [
+            { 'company' => "Soon To Be Dirty, LLC",
+              'title'   => "Layperson",
+              'details' => { 'awesome' => true },
+            },
+          ]
+          @resource.save
+          @resource.reload
+          @resource.positions.first['title'].should == 'Layperson'
+        end
+
+        describe "when I remove the position" do
+          before :all do
+            @resource.clean?.should == true
+            @resource.positions.pop
+            @resource.save
+            @resource.reload
+          end
+
+          it "should know there aren't any positions" do
+            @resource.positions.should == []
+          end
+        end
+
+        describe "when I add a new position" do
+          before :all do
+            @resource.clean?.should == true
+            @resource.positions << {
+              'company' => "Down and Dirty, LP",
+              'title'   => "Porn Star",
+              'details' => { 'awesome' => "also true" },
+            }
+            @resource.save
+            @resource.reload
+          end
+
+          it "should know there's two positions" do
+            @resource.positions.length.should == 2
+          end
+
+          it "should know which position is which" do
+            @resource.positions.first['title'].should == "Layperson"
+            @resource.positions.last['title'].should == "Porn Star"
+          end
+
+          describe "when I change the details of one of the positions" do
+            before :all do
+              @resource.positions.last['details'].merge!('high_risk' => true)
+              @resource.save
+              @resource.reload
+            end
+
+            it "should remember the changed detail" do
+              pending "not supported (YET)" do
+                # TODO: Not supported (yet?) -- this is a much harder problem to
+                # solve: using mutating accessors of nested objects.  We could
+                # detect it from #dirty? (using the #hash method), but #dirty?
+                # only returns the status of known-mutated properties (not full,
+                # on-demand scan of object dirty-ness).
+                @resource.positions.last['details']['high_risk'].should == true
+              end
+            end
+          end
+        end # when I add a new position
+
+        describe "when I remove the position with a block-based mutator" do
+          before :all do
+            @resource.clean?.should == true
+            @resource.positions.reject! { |_| true }
+            @resource.save
+            @resource.reload
+          end
+
+          it "should know there aren't any positions" do
+            @resource.positions.should == []
+          end
+        end
+
+        describe "when I mutate positions through a reference" do
+          before :all do
+            @resource.clean?.should == true
+            @positions = @resource.positions
+            @positions << {
+              'company' => "Ooga Booga, Inc",
+              'title'   => "Rocker",
+            }
+          end
+
+          it "should reflect the change in both the property and the reference" do
+            @resource.positions.length.should == 2
+            @resource.positions.last['title'].should == 'Rocker'
+            @positions.last['title'].should == 'Rocker'
+          end
+        end
+
+      end # positions indirectly mutated as an array
+
+    end
+  end
+end

data/spec/integration/enum_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+try_spec do
+
+  require './spec/fixtures/ticket'
+
+  describe DataMapper::TypesFixtures::Ticket do
+    supported_by :all do
+      describe 'that is dumped and then loaded' do
+        before :all do
+          @resource = DataMapper::TypesFixtures::Ticket.new(
+            :title  => "Can't order by aggregated fields",
+            :id     => 789,
+            :body   => "I'm trying to use the aggregate method and sort the results by a summed field, but it doesn't work.",
+            :status => 'confirmed'
+          )
+
+          @resource.save.should be(true)
+          @resource.reload
+        end
+
+        it 'preserves property value' do
+          @resource.status.should == :confirmed
+        end
+      end
+
+      describe 'that is supplied a matching enumeration value' do
+        before :all do
+          @resource = DataMapper::TypesFixtures::Ticket.new(:status => :assigned)
+        end
+
+        it 'typecasts it for outside reader' do
+          @resource.status.should == :assigned
+        end
+      end
+
+      describe '#get' do
+        before :all do
+          @resource = DataMapper::TypesFixtures::Ticket.new(
+            :title  => '"sudo make install" of drizzle fails because it tries to chown mysql',
+            :id     => 257497,
+            :body   => "Note that at the very least, there should be a check to see whether or not the user is created before chown'ing a file to the user.",
+            :status => 'confirmed'
+          )
+          @resource.save.should be(true)
+        end
+
+        it 'supports queries with equality operator on enumeration property' do
+          DataMapper::TypesFixtures::Ticket.all(:status => :confirmed).
+            should include(@resource)
+        end
+
+        it 'supports queries with inequality operator on enumeration property' do
+          DataMapper::TypesFixtures::Ticket.all(:status.not => :confirmed).
+            should_not include(@resource)
+        end
+      end
+
+      describe 'with value unknown to enumeration property' do
+        before :all do
+          @resource = DataMapper::TypesFixtures::Ticket.new(:status => :undecided)
+        end
+
+        # TODO: consider sharing shared spec exampels with dm-validations,
+        #       which has 'invalid model' shared group
+        it 'is invalid (auto validation for :within kicks in)' do
+          @resource.should_not be_valid
+        end
+
+        it 'has errors' do
+          @resource.errors.should_not be_empty
+        end
+
+        it 'has a meaningful error message on invalid property' do
+          @resource.errors.on(:status).should include('Status must be one of unconfirmed, confirmed, assigned, resolved, not_applicable')
+        end
+      end
+    end
+  end
+end

data/spec/integration/epoch_time_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+try_spec do
+
+  require './spec/fixtures/person'
+
+  describe DataMapper::TypesFixtures::Person do
+    supported_by :all do
+      before :all do
+        @resource = DataMapper::TypesFixtures::Person.new(:name => '')
+      end
+
+      describe 'with a birthday' do
+        before :all do
+          @resource.birthday = '1983-05-03'
+        end
+
+        describe 'after typecasting string input' do
+          it 'has a valid birthday' do
+            @resource.birthday.should == ::Time.parse('1983-05-03')
+          end
+        end
+
+        describe 'when dumped and loaded again' do
+          before :all do
+            @resource.save.should be(true)
+            @resource.reload
+          end
+
+          it 'has a valid birthday' do
+            @resource.birthday.should == ::Time.parse('1983-05-03')
+          end
+        end
+      end
+
+      describe 'without a birthday' do
+        before :all do
+          @resource.birthday = nil
+        end
+
+        describe 'after typecasting nil' do
+          it 'has a nil value for birthday' do
+            @resource.birthday.should be_nil
+          end
+        end
+
+        describe 'when dumped and loaded again' do
+          before :all do
+            @resource.save.should be(true)
+            @resource.reload
+          end
+
+          it 'has a nil value for birthday' do
+            @resource.birthday.should be_nil
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/integration/file_path_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+try_spec do
+
+  require './spec/fixtures/software_package'
+
+  describe DataMapper::TypesFixtures::SoftwarePackage do
+    supported_by :all do
+      describe 'with source path at /var/cache/apt/archives/linux-libc-dev_2.6.28-11.40_i386.deb' do
+        before :all do
+          @source_path = '/var/cache/apt/archives/linux-libc-dev_2.6.28-11.40_i386.deb'
+          @resource    = DataMapper::TypesFixtures::SoftwarePackage.new(:source_path => @source_path)
+        end
+
+        describe 'when is a new record' do
+          before :all do
+          end
+
+          it 'points to original path' do
+            @resource.source_path.to_s.should == @source_path
+          end
+
+          it 'responds to :directory?' do
+            @resource.source_path.should respond_to(:directory?)
+          end
+
+          it 'responds to :file?' do
+            @resource.source_path.should respond_to(:file?)
+          end
+
+          it 'responds to :dirname' do
+            @resource.source_path.should respond_to(:dirname)
+          end
+
+          it 'responds to :absolute?' do
+            @resource.source_path.should respond_to(:absolute?)
+          end
+
+          it 'responds to :readable?' do
+            @resource.source_path.should respond_to(:readable?)
+          end
+
+          it 'responds to :size' do
+            @resource.source_path.should respond_to(:size)
+          end
+        end
+      end
+
+      describe 'with destination path at /usr/local' do
+        before :all do
+          @destination_path = '/usr/local'
+          @resource         = DataMapper::TypesFixtures::SoftwarePackage.new(:destination_path => @destination_path)
+        end
+
+        describe 'when saved and reloaded' do
+          before :all do
+            @resource.save.should be(true)
+            @resource.reload
+          end
+
+          it 'points to original path' do
+            @resource.destination_path.to_s.should == @destination_path
+          end
+
+          it 'responds to :directory?' do
+            @resource.destination_path.should respond_to(:directory?)
+          end
+
+          it 'responds to :file?' do
+            @resource.destination_path.should respond_to(:file?)
+          end
+
+          it 'responds to :dirname' do
+            @resource.destination_path.should respond_to(:dirname)
+          end
+
+          it 'responds to :absolute?' do
+            @resource.destination_path.should respond_to(:absolute?)
+          end
+
+          it 'responds to :readable?' do
+            @resource.destination_path.should respond_to(:readable?)
+          end
+
+          it 'responds to :size' do
+            @resource.destination_path.should respond_to(:size)
+          end
+        end
+      end
+
+      describe 'with no (nil) source path' do
+        before :all do
+          @source_path = nil
+          @resource    = DataMapper::TypesFixtures::SoftwarePackage.new(:source_path => @source_path)
+        end
+
+        describe 'when saved and reloaded' do
+          before :all do
+            @resource.save.should be(true)
+            @resource.reload
+          end
+
+          it 'has nil source path' do
+            @resource.source_path.should be_nil
+          end
+        end
+      end
+
+      describe 'with a blank source path' do
+        before :all do
+          @source_path = ''
+          @resource    = DataMapper::TypesFixtures::SoftwarePackage.new(:source_path => @source_path)
+        end
+
+        describe 'when saved and reloaded' do
+          before :all do
+            @resource.save.should be(true)
+            @resource.reload
+          end
+
+          it 'has nil source path' do
+            @resource.source_path.should be_nil
+          end
+        end
+      end
+
+      describe 'with a source path assigned to an empty array' do
+        before :all do
+          @source_path = []
+          @resource    = DataMapper::TypesFixtures::SoftwarePackage.new(:source_path => @source_path)
+        end
+
+        describe 'when saved and reloaded' do
+          before :all do
+            @resource.save.should be(true)
+            @resource.reload
+          end
+
+          it 'has nil source path' do
+            @resource.source_path.should be_nil
+          end
+        end
+      end
+
+      describe 'with a source path assigned to a Hash' do
+        before :all do
+          @source_path = { :guitar => 'Joe Satriani' }
+        end
+
+        describe 'when instantiated' do
+          it 'raises an exception' do
+            lambda do
+              DataMapper::TypesFixtures::SoftwarePackage.new(:source_path => @source_path)
+            end.should raise_error(TypeError)
+          end
+        end
+      end
+    end
+  end
+end