ardm 0.0.1 → 0.1.0

data/spec/public/model_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+
+module ::ModelBlog
+  # FIXME: load order in tests is being problematic
+  class ArticlePublication < Ardm::Record
+  end
+
+  class Article < Ardm::Record
+    self.table_name = "articles"
+
+    property :id,       Serial
+    property :title,    String, :required => true, :default => 'Default Title'
+    property :body,     Text
+    timestamps :at
+
+    belongs_to :original, self, :required => false
+    has n, :revisions, self, :child_key => [ :original_id ]
+    has 1, :previous,  self, :child_key => [ :original_id ], :order => [ :id.desc ]
+    has n, :article_publications, model: ::ModelBlog::ArticlePublication
+    has n, :publications, :through => :article_publications
+  end
+
+  class Publication < Ardm::Record
+    self.table_name = "api_users" # same set of fields, so even though it's a little weird, I'm going to reuse for now.
+
+    property :id,   Serial
+    property :name, String
+
+    has n, :article_publications, model: ::ModelBlog::ArticlePublication
+    has n, :acticles, :through => :article_publications
+  end
+
+  class ArticlePublication < Ardm::Record
+    self.table_name = "article_publications"
+
+    belongs_to :acticle,     model: '::ModelBlog::Article'
+    belongs_to :publication, model: '::ModelBlog::Publication'
+  end
+end
+
+describe 'Ardm::Record' do
+  before do
+    @article_model     = ModelBlog::Article
+    @publication_model = ModelBlog::Publication
+  end
+
+  def model?; true end
+
+  before do
+    @articles = @article_model
+
+    @original = @articles.create(:title => 'Original Article')
+    @article  = @articles.create(:title => 'Sample Article', :body => 'Sample', :original => @original)
+    @other    = @articles.create(:title => 'Other Article',  :body => 'Other')
+  end
+
+  describe '#new' do
+    subject { model.new(*args) }
+
+    let(:model) { @article_model }
+
+    context 'with no arguments' do
+      let(:args) { [] }
+
+      it { is_expected.to be_instance_of(model) }
+
+      it { expect(subject.title).to eq('Default Title') }
+    end
+
+    context 'with an empty Hash' do
+      let(:args) { [ {} ] }
+
+      it { is_expected.to be_instance_of(model) }
+
+      it { expect(subject.title).to eq('Default Title') }
+    end
+
+    context 'with a non-empty Hash' do
+      let(:attributes) { { :title => 'A Title' } }
+      let(:args)       { [ attributes ]          }
+
+      it { is_expected.to be_instance_of(model) }
+
+      it { expect(subject.title).to eq('A Title') }
+    end
+
+    context 'with nil' do
+      let(:args) { [ nil ] }
+
+      it { is_expected.to be_instance_of(model) }
+
+      it { expect(subject.title).to eq('Default Title') }
+    end
+  end
+
+  [ :create, :create! ].each do |method|
+    describe "##{method}" do
+      subject { model.send(method, *args) }
+
+      let(:model) { @article_model }
+
+      context 'with no arguments' do
+        let(:args) { [] }
+
+        it { is_expected.to be_instance_of(model) }
+
+        it { is_expected.to be_saved }
+      end
+
+      context 'with an empty Hash' do
+        let(:args) { [ {} ] }
+
+        it { is_expected.to be_instance_of(model) }
+
+        it { is_expected.to be_saved }
+      end
+
+      context 'with a non-empty Hash' do
+        let(:attributes) { { :title => 'A Title' } }
+        let(:args)       { [ attributes ]          }
+
+        it { is_expected.to be_instance_of(model) }
+
+        it { is_expected.to be_saved }
+
+        it { expect(subject.title).to eq attributes[:title] }
+      end
+
+      context 'with nil' do
+        let(:args) { [ nil ] }
+
+        it { is_expected.to be_instance_of(model) }
+
+        it { is_expected.to be_saved }
+      end
+    end
+  end
+
+  [ :destroy, :destroy! ].each do |method|
+    describe "##{method}" do
+      it 'should remove all resources', pending: true do
+        expect { @article_model.send(method) }.to change { @article_model.any? }.from(true).to(false)
+      end
+    end
+  end
+
+  [ :update, :update! ].each do |method|
+    describe "##{method}" do
+      subject { model.send(method, *args) }
+
+      let(:model) { @article_model }
+
+      context 'with attributes' do
+        let(:attributes) { { :title => 'Updated Title' } }
+        let(:args)       { [ attributes ]                }
+
+        it { is_expected.to be(true) }
+
+        it 'should persist the changes' do
+          subject
+          expect(model.all(:fields => [ :title ]).map { |resource| resource.title }.uniq).to eq([ attributes[:title] ])
+        end
+      end
+
+      context 'with attributes where one is a parent association' do
+        let(:attributes) { { :original => @other } }
+        let(:args)       { [ attributes ]          }
+
+        it { is_expected.to be(true) }
+
+        it 'should persist the changes' do
+          subject
+          expect(model.all(:fields => [ :original_id ]).map { |resource| resource.original }.uniq).to eq([ attributes[:original] ])
+        end
+      end
+
+      context 'with attributes where a required property is nil' do
+        let(:attributes) { { :title => nil } }
+        let(:args)       { [ attributes ]    }
+
+        it 'should raise InvalidValueError' do
+          expect { subject }.to(raise_error(Ardm::Property::InvalidValueError) do |error|
+            expect(error.property).to eq(model.properties[:title])
+          end)
+        end
+      end
+    end
+  end
+
+  # FIXME: these are very broken right now
+  #it_should_behave_like 'Finder Interface'
+
+end

data/spec/public/property/binary_spec.rb

@@ -15,9 +15,9 @@ describe Ardm::Property::Binary do
   describe '.options' do
     subject { described_class.options }
 
-    it { should be_kind_of(Hash) }
+    it { is_expected.to be_kind_of(Hash) }
 
-    it { should eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_string, :length => 50) }
+    it { is_expected.to eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_string, :length => 50) }
   end
 
   if RUBY_VERSION >= "1.9"
@@ -30,11 +30,11 @@ describe Ardm::Property::Binary do
       end
 
       it 'should always dump with BINARY' do
-        model.properties[:bin_data].dump("foo".freeze).encoding.names.should include("BINARY")
+        expect(model.properties[:bin_data].dump("foo".freeze).encoding.names).to include("BINARY")
       end
 
       it 'should always load with BINARY' do
-        model.properties[:bin_data].load("foo".freeze).encoding.names.should include("BINARY")
+        expect(model.properties[:bin_data].load("foo".freeze).encoding.names).to include("BINARY")
       end
     end
   end

data/spec/public/property/boolean_spec.rb

@@ -16,15 +16,15 @@ describe Ardm::Property::Boolean do
   describe '.options' do
     subject { described_class.options }
 
-    it { should be_kind_of(Hash) }
+    it { is_expected.to be_kind_of(Hash) }
 
-    it { should eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_boolean) }
+    it { is_expected.to eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_boolean) }
   end
 
   describe "default" do
     it "should set has_picture to the default (booleans are specifically weird in rails because presence validation fails for false)" do
       tshirt = Ardm::Fixtures::TShirt.create!
-      tshirt.should_not have_picture
+      expect(tshirt).not_to have_picture
     end
   end
 end

data/spec/public/property/class_spec.rb

@@ -21,8 +21,8 @@ describe Ardm::Property::Class do
   describe '.options' do
     subject { described_class.options }
 
-    it { should be_kind_of(Hash) }
+    it { is_expected.to be_kind_of(Hash) }
 
-    it { should eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_constant) }
+    it { is_expected.to eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_constant) }
   end
 end

data/spec/public/property/date_spec.rb

@@ -15,8 +15,8 @@ describe Ardm::Property::Date do
   describe '.options' do
     subject { described_class.options }
 
-    it { should be_kind_of(Hash) }
+    it { is_expected.to be_kind_of(Hash) }
 
-    it { should eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_date) }
+    it { is_expected.to eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_date) }
   end
 end

data/spec/public/property/date_time_spec.rb

@@ -15,8 +15,8 @@ describe Ardm::Property::DateTime do
   describe '.options' do
     subject { described_class.options }
 
-    it { should be_kind_of(Hash) }
+    it { is_expected.to be_kind_of(Hash) }
 
-    it { should eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_datetime) }
+    it { is_expected.to eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_datetime) }
   end
 end

data/spec/public/property/decimal_spec.rb

@@ -16,8 +16,8 @@ describe Ardm::Property::Decimal do
   describe '.options' do
     subject { described_class.options }
 
-    it { should be_kind_of(Hash) }
+    it { is_expected.to be_kind_of(Hash) }
 
-    it { should eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_decimal, :precision => 10, :scale => 0) }
+    it { is_expected.to eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_decimal, :precision => 10, :scale => 0) }
   end
 end

data/spec/public/property/discriminator_spec.rb

@@ -7,6 +7,7 @@ module ::DiscBlog
     property :id,    Serial
     property :title, String, :required => true
     property :type,  Discriminator, :field => "slug"
+    timestamps :at
   end
 
   class Article < Content; end
@@ -26,13 +27,13 @@ describe Ardm::Property::Discriminator do
   describe '.options' do
     subject { described_class.options }
 
-    it { should be_kind_of(Hash) }
+    it { is_expected.to be_kind_of(Hash) }
 
-    it { should include(:load_as => Class, :required => true) }
+    it { is_expected.to include(:load_as => Class, :required => true) }
   end
 
   it 'should typecast to a Model' do
-    @article_model.properties[:type].typecast('DiscBlog::Release').should equal(@release_model)
+    expect(@article_model.properties[:type].typecast('DiscBlog::Release')).to equal(@release_model)
   end
 
   describe 'Model#new' do
@@ -42,11 +43,11 @@ describe Ardm::Property::Discriminator do
       end
 
       it 'should return a Resource' do
-        @resource.should be_kind_of(Ardm::Record)
+        expect(@resource).to be_kind_of(Ardm::Record)
       end
 
       it 'should be an descendant instance' do
-        @resource.should be_instance_of(DiscBlog::Release)
+        expect(@resource).to be_instance_of(DiscBlog::Release)
       end
     end
 
@@ -56,11 +57,11 @@ describe Ardm::Property::Discriminator do
       end
 
       it 'should return a Resource' do
-        @resource.should be_kind_of(Ardm::Record)
+        expect(@resource).to be_kind_of(Ardm::Record)
       end
 
       it 'should be an descendant instance' do
-        @resource.should be_instance_of(DiscBlog::Release)
+        expect(@resource).to be_instance_of(DiscBlog::Release)
       end
     end
 
@@ -70,44 +71,44 @@ describe Ardm::Property::Discriminator do
       end
 
       it 'should return a Resource' do
-        @resource.should be_kind_of(Ardm::Record)
+        expect(@resource).to be_kind_of(Ardm::Record)
       end
 
       it 'should be a base model instance' do
-        @resource.should be_instance_of(@article_model)
+        expect(@resource).to be_instance_of(@article_model)
       end
     end
   end
 
   describe 'Model#descendants' do
     it 'should set the descendants for the grandparent model' do
-      @article_model.descendants.to_a.should =~ [ @announcement_model, @release_model ]
+      expect(@article_model.descendants.to_a).to match_array([ @announcement_model, @release_model ])
     end
 
     it 'should set the descendants for the parent model' do
-      @announcement_model.descendants.to_a.should == [ @release_model ]
+      expect(@announcement_model.descendants.to_a).to eq([ @release_model ])
     end
 
     it 'should set the descendants for the child model' do
-      @release_model.descendants.to_a.should == []
+      expect(@release_model.descendants.to_a).to eq([])
     end
   end
 
   describe 'Model#default_scope', :pending => "I don't understand the intention of these" do
     it 'should have no default scope for the top level model' do
-      @content_model.default_scope[:type].should be_nil
+      expect(@content_model.default_scope[:type]).to be_nil
     end
 
     it 'should set the default scope for the grandparent model' do
-      @article_model.default_scope[:type].to_a.should =~ [ @article_model, @announcement_model, @release_model ]
+      expect(@article_model.default_scope[:type].to_a).to match_array([ @article_model, @announcement_model, @release_model ])
     end
 
     it 'should set the default scope for the parent model' do
-      @announcement_model.default_scope[:type].to_a.should =~ [ @announcement_model, @release_model ]
+      expect(@announcement_model.default_scope[:type].to_a).to match_array([ @announcement_model, @release_model ])
     end
 
     it 'should set the default scope for the child model' do
-      @release_model.default_scope[:type].to_a.should == [ @release_model ]
+      expect(@release_model.default_scope[:type].to_a).to eq([ @release_model ])
     end
   end
 
@@ -116,18 +117,18 @@ describe Ardm::Property::Discriminator do
   end
 
   it 'should persist the type' do
-    @announcement.class.find(*@announcement.key).type.should equal(@announcement_model)
+    expect(@announcement.class.find(*@announcement.key).type).to equal(@announcement_model)
   end
 
   it 'should be retrieved as an instance of the correct class' do
-    @announcement.class.find(*@announcement.key).should be_instance_of(@announcement_model)
+    expect(@announcement.class.find(*@announcement.key)).to be_instance_of(@announcement_model)
   end
 
   it 'should include descendants in finders' do
-    @article_model.first.should eql(@announcement)
+    expect(@article_model.first).to eql(@announcement)
   end
 
   it 'should not include ancestors' do
-    @release_model.first.should be_nil
+    expect(@release_model.first).to be_nil
   end
 end

data/spec/public/property/float_spec.rb

@@ -15,8 +15,8 @@ describe Ardm::Property::Float do
   describe '.options' do
     subject { described_class.options }
 
-    it { should be_kind_of(Hash) }
+    it { is_expected.to be_kind_of(Hash) }
 
-    it { should eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_float, :precision => 10, :scale => nil) }
+    it { is_expected.to eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_float, :precision => 10, :scale => nil) }
   end
 end

data/spec/public/property/integer_spec.rb

@@ -15,8 +15,8 @@ describe Ardm::Property::Integer do
   describe '.options' do
     subject { described_class.options }
 
-    it { should be_kind_of(Hash) }
+    it { is_expected.to be_kind_of(Hash) }
 
-    it { should eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_integer) }
+    it { is_expected.to eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_integer) }
   end
 end

data/spec/public/property/object_spec.rb

@@ -8,6 +8,7 @@ describe Ardm::Property, 'Object type' do
         property :id,    Serial
         property :title, String
         property :meta,  Object, :required => true, :field => 'body'
+        timestamps :at
       end
     end
 
@@ -20,12 +21,12 @@ describe Ardm::Property, 'Object type' do
   describe '.options' do
     subject { described_class.options }
 
-    it { should be_kind_of(Hash) }
+    it { is_expected.to be_kind_of(Hash) }
 
-    it { should be_empty }
+    it { is_expected.to be_empty }
   end
 
-  it { should respond_to(:typecast) }
+  it { is_expected.to respond_to(:typecast) }
 
   describe '#typecast' do
     before do
@@ -34,10 +35,10 @@ describe Ardm::Property, 'Object type' do
 
     subject { @property.typecast(@value) }
 
-    it { should equal(@value) }
+    it { is_expected.to equal(@value) }
   end
 
-  it { should respond_to(:dump) }
+  it { is_expected.to respond_to(:dump) }
 
   describe '#dump' do
     describe 'with a value' do
@@ -47,23 +48,23 @@ describe Ardm::Property, 'Object type' do
 
       subject { @property.dump(@value) }
 
-      it { @property.load(subject).should == @value }
+      it { expect(@property.load(subject)).to eq(@value) }
     end
 
     describe 'with nil' do
       subject { @property.dump(nil) }
 
-      it { should be_nil }
+      it { is_expected.to be_nil }
     end
   end
 
-  it { should respond_to(:valid?) }
+  it { is_expected.to respond_to(:valid?) }
 
   describe '#valid?' do
     describe 'with a valid load_as' do
       subject { @property.valid?('lang' => 'en_CA') }
 
-      it { should be(true) }
+      it { is_expected.to be(true) }
     end
 
     describe 'with nil and property is not required' do
@@ -73,19 +74,19 @@ describe Ardm::Property, 'Object type' do
 
       subject { @property.valid?(nil) }
 
-      it { should be(true) }
+      it { is_expected.to be(true) }
     end
 
     describe 'with nil and property is required' do
       subject { @property.valid?(nil) }
 
-      it { should be(false) }
+      it { is_expected.to be(false) }
     end
 
     describe 'with nil and property is required, but validity is negated' do
       subject { @property.valid?(nil, true) }
 
-      it { should be(true) }
+      it { is_expected.to be(true) }
     end
   end
 
@@ -97,7 +98,7 @@ describe Ardm::Property, 'Object type' do
     subject { @resource.reload.meta }
 
     it 'should load the correct value' do
-      should == { 'lang' => 'en_CA' }
+      is_expected.to eq({ 'lang' => 'en_CA' })
     end
   end
 end