sbf-dm-types 1.3.0.beta

data/spec/integration/comma_separated_list_spec.rb

@@ -0,0 +1,87 @@
+require_relative '../spec_helper'
+
+try_spec do
+
+  require_relative '../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
+            expect(@resource.save).to be(true)
+            @resource.reload
+          end
+
+          it 'has no interests' do
+            expect(@resource.interests).to eq 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
+            expect(@resource.save).to be(true)
+            @resource.reload
+          end
+
+          it 'has empty interests list' do
+            expect(@resource.interests).to eq []
+          end
+        end
+      end
+
+      describe 'with interests information given as a Hash' do
+        it 'raises ArgumentError' do
+          expect do
+            @resource.interests = { :hash => 'value' }
+            @resource.save
+          end.to 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
+            expect(@resource.save).to be(true)
+            @resource.reload
+          end
+
+          it 'includes "fire" in interests' do
+            expect(@resource.interests).to include('fire')
+          end
+
+          it 'includes "water" in interests' do
+            expect(@resource.interests).to include('water')
+          end
+
+          it 'includes "a whole lot of other interesting things" in interests' do
+            expect(@resource.interests).to include('a whole lot of other interesting things')
+          end
+
+          it 'has blank entries removed' do
+            expect(@resource.interests.any? { |i| DataMapper::Ext.blank?(i) }).to be(false)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/integration/dirty_minder_spec.rb

@@ -0,0 +1,197 @@
+require_relative '../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_relative '../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
+          expect(@resource.positions['title']).to eq 'Layperson'
+        end
+
+        describe 'when I change positions' do
+          before :all do
+            expect(@resource.clean?).to eq true
+            @resource.positions['title'] = 'Chief Layer of People'
+            @resource.save
+            @resource.reload
+          end
+
+          it 'remembers the new position' do
+            expect(@resource.positions['title']).to eq 'Chief Layer of People'
+          end
+        end
+
+        describe 'when I add a new attribute of the position' do
+          before :all do
+            expect(@resource.clean?).to eq true
+            @resource.positions['pays_buttloads_of_money'] = true
+            @resource.save
+            @resource.reload
+          end
+
+          it 'remembers the new attribute' do
+            expect(@resource.positions['pays_buttloads_of_money']).to be(true)
+          end
+        end
+
+        describe 'when I change the details of the position' do
+          before :all do
+            expect(@resource.clean?).to eq true
+            @resource.positions['details'].merge!('awesome' => "VERY TRUE")
+            @resource.save
+            @resource.reload
+          end
+
+          it 'remembers the changed detail' do
+            pending 'not supported (YET)'
+
+            # 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).
+            expect(@resource.positions['details']['awesome']).to eq 'VERY TRUE'
+          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 'reflects the previously set/persisted value' do
+            expect(@resource.positions).not_to be_nil
+            expect(@resource.positions['title']).to eq '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
+          expect(@resource.positions.first['title']).to eq 'Layperson'
+        end
+
+        describe 'when I remove the position' do
+          before :all do
+            expect(@resource.clean?).to eq true
+            @resource.positions.pop
+            @resource.save
+            @resource.reload
+          end
+
+          it "knows there aren't any positions" do
+            expect(@resource.positions).to eq []
+          end
+        end
+
+        describe "when I add a new position" do
+          before :all do
+            expect(@resource.clean?).to eq true
+            @resource.positions << {
+              'company' => "Down and Dirty, LP",
+              'title'   => "Porn Star",
+              'details' => { 'awesome' => "also true" },
+            }
+            @resource.save
+            @resource.reload
+          end
+
+          it "knows there's two positions" do
+            expect(@resource.positions.length).to eq 2
+          end
+
+          it 'knows which position is which' do
+            expect(@resource.positions.first['title']).to eq 'Layperson'
+            expect(@resource.positions.last['title']).to eq '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 'remembers the changed detail' do
+              pending 'not supported (YET)'
+
+              # 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).
+              expect(@resource.positions.last['details']['high_risk']).to eq true
+            end
+          end
+        end # when I add a new position
+
+        describe 'when I remove the position with a block-based mutator' do
+          before :all do
+            expect(@resource.clean?).to eq true
+            @resource.positions.reject! { |_| true }
+            @resource.save
+            @resource.reload
+          end
+
+          it "knows there aren't any positions" do
+            expect(@resource.positions).to eq []
+          end
+        end
+
+        describe 'when I mutate positions through a reference' do
+          before :all do
+            expect(@resource.clean?).to eq true
+            @positions = @resource.positions
+            @positions << {
+              'company' => "Ooga Booga, Inc",
+              'title'   => "Rocker",
+            }
+          end
+
+          it 'reflects the change in both the property and the reference' do
+            expect(@resource.positions.length).to eq 2
+            expect(@resource.positions.last['title']).to eq 'Rocker'
+            expect(@positions.last['title']).to eq 'Rocker'
+          end
+        end
+
+      end # positions indirectly mutated as an array
+
+    end
+  end
+end

data/spec/integration/enum_spec.rb

@@ -0,0 +1,78 @@
+require_relative '../spec_helper'
+
+try_spec do
+
+  require_relative '../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'
+          )
+
+          expect(@resource.save).to be(true)
+          @resource.reload
+        end
+
+        it 'preserves property value' do
+          expect(@resource.status).to eq :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
+          expect(@resource.status).to eq :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'
+          )
+          expect(@resource.save).to be(true)
+        end
+
+        it 'supports queries with equality operator on enumeration property' do
+          expect(DataMapper::TypesFixtures::Ticket.all(:status => :confirmed)).to include(@resource)
+        end
+
+        it 'supports queries with inequality operator on enumeration property' do
+          expect(DataMapper::TypesFixtures::Ticket.all(:status.not => :confirmed)).not_to 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
+          expect(@resource).not_to be_valid
+        end
+
+        it 'has errors' do
+          expect(@resource.errors).not_to be_empty
+        end
+
+        it 'has a meaningful error message on invalid property' do
+          expect(@resource.errors.on(:status)).to 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_relative '../spec_helper'
+
+try_spec do
+
+  require_relative '../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
+            expect(@resource.birthday).to eq ::Time.parse('1983-05-03')
+          end
+        end
+
+        describe 'when dumped and loaded again' do
+          before :all do
+            expect(@resource.save).to be(true)
+            @resource.reload
+          end
+
+          it 'has a valid birthday' do
+            expect(@resource.birthday).to eq ::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
+            expect(@resource.birthday).to be_nil
+          end
+        end
+
+        describe 'when dumped and loaded again' do
+          before :all do
+            expect(@resource.save).to be(true)
+            @resource.reload
+          end
+
+          it 'has a nil value for birthday' do
+            expect(@resource.birthday).to be_nil
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/integration/file_path_spec.rb

@@ -0,0 +1,160 @@
+require_relative '../spec_helper'
+
+try_spec do
+
+  require_relative '../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
+            expect(@resource.source_path.to_s).to eq @source_path
+          end
+
+          it 'responds to :directory?' do
+            expect(@resource.source_path).to respond_to(:directory?)
+          end
+
+          it 'responds to :file?' do
+            expect(@resource.source_path).to respond_to(:file?)
+          end
+
+          it 'responds to :dirname' do
+            expect(@resource.source_path).to respond_to(:dirname)
+          end
+
+          it 'responds to :absolute?' do
+            expect(@resource.source_path).to respond_to(:absolute?)
+          end
+
+          it 'responds to :readable?' do
+            expect(@resource.source_path).to respond_to(:readable?)
+          end
+
+          it 'responds to :size' do
+            expect(@resource.source_path).to 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
+            expect(@resource.save).to be(true)
+            @resource.reload
+          end
+
+          it 'points to original path' do
+            expect(@resource.destination_path.to_s).to eq @destination_path
+          end
+
+          it 'responds to :directory?' do
+            expect(@resource.destination_path).to respond_to(:directory?)
+          end
+
+          it 'responds to :file?' do
+            expect(@resource.destination_path).to respond_to(:file?)
+          end
+
+          it 'responds to :dirname' do
+            expect(@resource.destination_path).to respond_to(:dirname)
+          end
+
+          it 'responds to :absolute?' do
+            expect(@resource.destination_path).to respond_to(:absolute?)
+          end
+
+          it 'responds to :readable?' do
+            expect(@resource.destination_path).to respond_to(:readable?)
+          end
+
+          it 'responds to :size' do
+            expect(@resource.destination_path).to 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
+            expect(@resource.save).to be(true)
+            @resource.reload
+          end
+
+          it 'has nil source path' do
+            expect(@resource.source_path).to 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
+            expect(@resource.save).to be(true)
+            @resource.reload
+          end
+
+          it 'has nil source path' do
+            expect(@resource.source_path).to 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
+            expect(@resource.save).to be(true)
+            @resource.reload
+          end
+
+          it 'has nil source path' do
+            expect(@resource.source_path).to 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
+            expect do
+              DataMapper::TypesFixtures::SoftwarePackage.new(:source_path => @source_path)
+            end.to raise_error(TypeError)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/integration/flag_spec.rb

@@ -0,0 +1,72 @@
+require_relative '../spec_helper'
+
+try_spec do
+
+  require_relative '../fixtures/tshirt'
+
+  describe DataMapper::TypesFixtures::TShirt do
+    supported_by :all do
+      before do
+        @resource = DataMapper::TypesFixtures::TShirt.new(
+          :writing     => 'Fork you',
+          :has_picture => true,
+          :picture     => :octocat,
+          :color       => :white
+        )
+      end
+
+      describe 'with the default value' do
+        it 'returns it as an array' do
+          expect(@resource.size).to eql(DataMapper::TypesFixtures::TShirt.properties[:size].default)
+        end
+      end
+
+      describe 'with multiple sizes' do
+        describe 'dumped and loaded' do
+          before do
+            @resource.size = [ :xs, :medium ]
+            expect(@resource.save).to be(true)
+            @resource.reload
+          end
+
+          it 'returns size as array' do
+            expect(@resource.size).to eq [ :xs, :medium ]
+          end
+        end
+      end
+
+      describe 'with a single size' do
+        before do
+          @resource.size = :large
+        end
+
+        describe 'dumped and loaded' do
+          before do
+            expect(@resource.save).to be(true)
+            @resource.reload
+          end
+
+          it 'returns size as array with a single value' do
+            expect(@resource.size).to eq [:large]
+          end
+        end
+      end
+
+      # Flag does not add any auto validations
+      describe 'without size' do
+        before do
+          expect(@resource).to be_valid
+          @resource.size = nil
+        end
+
+        it 'is valid' do
+          expect(@resource).to be_valid
+        end
+
+        it 'has no errors' do
+          expect(@resource.errors).to be_empty
+        end
+      end
+    end
+  end
+end