ninja-model 0.4.2 → 0.5.1

data/spec/ninja_model/adapters_spec.rb

@@ -1,8 +1,85 @@
 require 'spec_helper'
 
 describe NinjaModel::Adapters do
+  class DummyAdapter < NinjaModel::Adapters::AbstractAdapter; end
+  class SmarterAdapter < NinjaModel::Adapters::AbstractAdapter; end
+  before {
+    NinjaModel::Base.register_adapter(:dummy, DummyAdapter)
+    NinjaModel::Base.register_adapter(:smarter, SmarterAdapter)
+  }
+  subject { Class.new(NinjaModel::Base) }
+  it { should respond_to(:register_adapter) }
+  it { should respond_to(:set_adapter) }
+
+  describe 'adapter' do
+    before { @klass = Class.new(NinjaModel::Base) }
+    subject { @klass.new }
+    it 'should call retrieve_adapter' do
+      @klass.expects(:retrieve_adapter)
+      subject.adapter
+    end
+  end
+
+  describe 'register_adapter' do
+    it 'should register with the adapter manager' do
+      subject.adapter_manager.class.expects(:register_adapter_class).with(:dummy, DummyAdapter)
+      subject.register_adapter(:dummy, DummyAdapter)
+    end
+  end
+
   describe 'set_adapter' do
+    before {
+      @configuration = mock('Configuration') do
+        stubs(:specs).returns({'development' => {:adapter => :dummy}})
+      end
+      NinjaModel.stubs(:configuration).returns(@configuration)
+      @klass = Class.new(NinjaModel::Base)
+    }
+    subject { @klass }
+    context 'when nil is passed' do
+      it 'should return a DummyAdapter if Rails is available' do
+        @rails = Object.const_set('Rails', Class.new(Object))
+        @rails.stubs(:env).returns('development')
+        subject.set_adapter.spec.name.should eql(:dummy)
+        Object.send(:remove_const, :Rails)
+      end
+      it 'should raise AdapterNotSpecified is Rails is not available' do
+        lambda { subject.set_adapter }.should raise_error(NinjaModel::Adapters::AdapterNotSpecified)
+      end
+    end
+    it 'should return a DummyAdapter pool when "development" is passed' do
+      subject.set_adapter('development').spec.name.should eql(:dummy)
+    end
+    it 'should return a DummyAdapter pool when a dummy specification is passed' do
+      subject.set_adapter(:adapter => :dummy).spec.name.should eql(:dummy)
+    end
+    it 'should return a SmarterAdapter pool when a smarter specification is passed' do
+      subject.set_adapter(:adapter => :smarter).spec.name.should eql(:smarter)
+    end
+    it 'should raise AdapterNotSpecified if the configuration doesn\'t specify an adapter' do
+      lambda { subject.set_adapter({}) }.should raise_error(NinjaModel::Adapters::AdapterNotSpecified)
+    end
+    it 'should raise InvalidAdapter for an invalid adapter name' do
+      lambda { subject.set_adapter(:adapter => :bogus) }.should raise_error(NinjaModel::Adapters::InvalidAdapter)
+    end
+    it 'should raise InvalidSpecification for an invalid Rails.env' do
+      lambda { subject.set_adapter('foobar') }.should raise_error(NinjaModel::Adapters::InvalidSpecification)
+    end
+  end
 
+  describe 'retrieve_adapter' do
+    before { @klass = Class.new(NinjaModel::Base) }
+    it 'should call retrieve_adapter on the manager' do
+      @klass.adapter_manager.expects(:retrieve_adapter).with(@klass)
+      @klass.retrieve_adapter
+    end
   end
 
+  describe 'shutdown_adapter' do
+    before { @klass = Class.new(NinjaModel::Base) }
+    it 'should call remove_adapter on the manager' do
+      @klass.adapter_manager.expects(:remove_adapter).with(@klass)
+      @klass.shutdown_adapter
+    end
+  end
 end

data/spec/ninja_model/attribute_methods_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe NinjaModel::AttributeMethods do
+  class AttributeModel < NinjaModel::Base
+    attribute :test, :string
+  end
+  subject { AttributeModel.new }
+  specify { subject.attribute_method?(:test).should be_true }
+  specify { subject.attribute_method?(:invalid).should be_false }
+
+  it 'should return a list of valid attribute names' do
+    AttributeModel.attribute_names.should eql(['test'])
+  end
+
+  it 'should return a valid column list' do
+    AttributeModel.columns.length.should eql(1)
+  end
+
+  it 'should allow updating by hash' do
+    subject.attributes = {:test => 'hashvalue'}
+    subject.test.should eql('hashvalue')
+  end
+end
+
+describe NinjaModel::AttributeMethods, 'reading an attribute' do
+  class ReaderModel < NinjaModel::Base
+    attribute :test, :string
+  end
+  subject { ReaderModel.new }
+  it { should respond_to(:test) }
+  it 'should call "read_attribute"' do
+    subject.expects(:read_attribute).with('test')
+    subject.test
+  end
+
+  context 'by hash key' do
+    it 'should call "read_attribute"' do
+      subject.expects(:read_attribute).with(:test)
+      subject[:test]
+    end
+    it 'should return the correct value' do
+      subject.test = 'hashcorrect'
+      subject[:test].should eql('hashcorrect')
+    end
+    it 'should accept a string hash key' do
+      subject.test = 'stringkey'
+      subject['test'].should eql('stringkey')
+    end
+  end
+
+  context 'before_type_cast' do
+    it 'should not convert the value' do
+      subject.test = Date.new(2001,1,1)
+      subject.test_before_type_cast.should eql(Date.new(2001,1,1))
+    end
+  end
+end
+
+describe NinjaModel::AttributeMethods, 'writing an attribute' do
+  class WriterModel < NinjaModel::Base
+    attribute :test, :string
+  end
+  subject { WriterModel.new }
+  it 'should call "write_attribute"' do
+    subject.expects(:write_attribute).with('test', 'newvalue')
+    subject.test = 'newvalue'
+  end
+  it 'should update the value' do
+    subject.test = 'newvalue'
+    subject.test.should eql('newvalue')
+  end
+  it 'should be dirty' do
+    subject.test = 'newvalue'
+    subject.changed?.should be_true
+    subject.test_changed?.should be_true
+  end
+  it 'should raise an exception for an invalid attribute name' do
+    lambda { subject.write_attribute(:invalid, 'foo') }.should raise_error(NoMethodError)
+  end
+
+  context 'by hash key' do
+    it 'should call "write_attribute"' do
+      subject.expects(:write_attribute).with(:test, 'newvalue')
+      subject[:test] = 'newvalue'
+    end
+    it 'should update the value' do
+      subject[:test] = 'newvalue'
+      subject.test.should eql('newvalue')
+    end
+    it 'should accept a string hash key' do
+      subject['test'] = 'stringkey'
+      subject.test.should eql('stringkey')
+    end
+  end
+end

data/spec/ninja_model/attribute_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe NinjaModel::Attribute do
+  def mock_attribute(*args)
+    NinjaModel::Attribute.new(*args)
+  end
+
+  RSpec::Matchers.define :convert do |input|
+    chain :to do |expected|
+      @expected = expected
+    end
+
+    match do |attr|
+      @actual = attr.convert(input)
+      @actual.eql?(@expected)
+    end
+
+    failure_message_for_should do |attr|
+      "convert(#{input.inspect}) should be #{@expected.inspect}, but got #{@actual.inspect}"
+    end
+
+    description do |attr|
+      "convert #{input.inspect} to #{@expected.inspect}"
+    end
+  end
+
+  context 'an instance' do
+    before {
+      @date_obj = Date.new(2001,1,1)
+      @datetime_obj = DateTime.new(2001,1,1)
+    }
+    subject { mock_attribute(:foo, :string, :default => 'bar') }
+    it { should respond_to(:name) }
+    it { should respond_to(:type) }
+    it { should respond_to(:default) }
+    its(:name) { should eql('foo') }
+    its(:type) { should eql(:string) }
+    its(:default) { should eql('bar') }
+
+    context 'with a :string type' do
+      subject { mock_attribute(:test, :string) }
+      it { should convert('').to('') }
+      it { should convert('foo').to('foo') }
+      it { should convert(123).to('123') }
+      it { should convert(1.23).to('1.23') }
+      it { should convert(@date_obj).to(@date_obj.to_s) }
+      it { should convert(@datetime_obj).to(@datetime_obj.to_s) }
+      it { should convert(true).to('true') }
+      it { should convert(false).to('false') }
+      it { should convert(nil).to(nil) }
+      it 'should raise an error with an unconvertable value' do
+        lambda { subject.convert([]) }.should raise_error(NinjaModel::InvalidConversion)
+      end
+      its(:number?) { should be_false }
+    end
+
+    context 'with an :integer type' do
+      subject { mock_attribute(:test, :integer) }
+      it { should convert('').to(0) }
+      it { should convert('foo').to(0) }
+      it { should convert(123).to(123) }
+      it { should convert(1.23).to(1) }
+      it { should convert(@date_obj).to(1) }
+      it { should convert(@datetime_obj).to(@datetime_obj.to_i) }
+      it { should convert(true).to(1) }
+      it { should convert(false).to(0) }
+      it { should convert(nil).to(0) }
+      its(:number?) { should be_true }
+    end
+
+    context 'with a :float type' do
+      subject { mock_attribute(:test, :float) }
+      it { should convert('').to(0.0) }
+      it { should convert('foo').to(0.0) }
+      it { should convert(123).to(123.0) }
+      it { should convert(1.23).to(1.23) }
+      it { should convert(@date_obj).to(1.0) }
+      it { should convert(@datetime_obj).to(@datetime_obj.to_f) }
+      it { should convert(true).to(1.0) }
+      it { should convert(false).to(0.0) }
+      it { should convert(nil).to(0.0) }
+      its(:number?) { should be_true }
+    end
+
+    context 'with a :date type' do
+      subject { mock_attribute(:test, :date) }
+      it { should convert('').to(nil) }
+      it { should convert('foo').to(nil) }
+      it { should convert(123).to(123) }
+      it { should convert(1.23).to(1.23) }
+      it { should convert(@date_obj).to(@date_obj) }
+      it { should convert(@datetime_obj).to(@datetime_obj) }
+      it { should convert('2001-01-01').to(Date.new(2001,1,1)) }
+      it { should convert(true).to(true) }
+      it { should convert(false).to(false) }
+      it { should convert(nil).to(nil) }
+      its(:number?) { should be_false }
+    end
+
+    context 'with a :datetime type' do
+      subject { mock_attribute(:test, :datetime) }
+      it { should convert('').to(nil) }
+      it { should convert('foo').to(nil) }
+      it { should convert(123).to(123) }
+      it { should convert(1.23).to(1.23) }
+      it { should convert(@date_obj).to(@date_obj) }
+      it { should convert(@datetime_obj).to(@datetime_obj) }
+      it { should convert('2001-01-01 01:01:00').to(DateTime.new(2001,1,1,1,1)) }
+      it { should convert(true).to(true) }
+      it { should convert(false).to(false) }
+      it { should convert(nil).to(nil) }
+      its(:number?) { should be_false }
+    end
+
+    context 'with a :boolean type' do
+      subject { mock_attribute(:test, :boolean) }
+      it { should convert('').to(nil) }
+      it { should convert('foo').to(false) }
+      it { should convert(123).to(false) }
+      it { should convert(1.23).to(false) }
+      it { should convert(@date_obj).to(false) }
+      it { should convert(@datetime_obj).to(false) }
+      it { should convert(true).to(true) }
+      it { should convert(false).to(false) }
+      it { should convert(nil).to(false) }
+      its(:number?) { should be_false }
+    end
+  end
+end

data/spec/ninja_model/base_spec.rb

@@ -2,65 +2,17 @@ require 'spec_helper'
 
 describe NinjaModel::Base do
   it_should_behave_like "ActiveModel"
-  before(:each) do
-    @klass = Class.new(NinjaModel::Base) do
-    end
+  before {
+    @klass = Class.new(NinjaModel::Base)
     @klass.send :attribute, :width, :integer
     @klass.send :attribute, :height, :integer
     @klass.send :attribute, :color, :string
-  end
-
-  it 'should return a configuration path' do
-    Rails.stubs(:root).returns('/')
-    @klass.configuration_path.should be_kind_of(String)
-  end
-
-  it 'should accept a configuration path' do
-    @klass.configuration_path = 'foo'
-    @klass.configuration_path.should eql('foo')
-  end
-
-  it 'should return NinjaModel\'s logger' do
-    logger = mock('logger')
-    NinjaModel.stubs(:logger).returns(logger)
-    @klass.logger.should eql(logger)
-  end
-
-  it { @klass.should respond_to(:logger) }
-
-  it 'should generate a relation' do
-    @klass.relation.should be_kind_of(NinjaModel::Relation)
-  end
+  }
 
   it 'should instantiate from an existing data structure' do
     attrs = {:width => 100, :height => 200, :color => 'red'}
     @obj = @klass.new
     @obj.instantiate(attrs)
-    @obj.attributes[:width].should eql(100)
-  end
-
-  it 'should return a configuration' do
-    @klass.stubs(:configuration_path)
-    IO.stubs(:read).returns('foo: bar')
-    @klass.configuration.should be_kind_of(Hash)
-    @klass.configuration[:foo].should eql('bar')
-  end
-
-  describe 'scoping' do
-    it 'should return a stock relation for unscoped' do
-      @klass.unscoped.predicates.should be_empty
-      @klass.unscoped.limit_value.should be_nil
-      @klass.unscoped.offset_value.should be_nil
-      @klass.unscoped.ordering.should be_empty
-      @klass.unscoped.predicates.should be_empty
-    end
-
-    it 'should handle default scoping' do
-      @klass.default_scope(@klass.where(:width => 100))
-      rel = @klass.default_scoping.first
-      rel.should be_kind_of(NinjaModel::Relation)
-      rel.predicates.first.should be_kind_of(NinjaModel::Predicate)
-      rel.predicates.first.value.should eql(100)
-    end
+    @obj.width.should eql(100)
   end
 end

data/spec/ninja_model/identity_spec.rb

@@ -1,41 +1,25 @@
 require 'spec_helper'
 
 describe NinjaModel::Identity do
-  before(:each) do
-    @klass = Class.new
-    @klass.send :include, NinjaModel::Identity
+  class IdentityModel < NinjaModel::Base
+    attribute :primary, :integer, :primary_key => true
   end
+  before {
+    @obj = IdentityModel.new
+    @obj.primary = 123
+    @obj
+  }
+  subject { @obj }
 
-  def persisted
-    obj = @klass.new
-    obj.stubs(:id).returns(123)
-    obj.stubs(:persisted?).returns(true)
-    obj
+  context 'when persisted' do
+    before { @obj.stubs(:persisted?).returns(true) }
+    its(:to_param) { should eql('123') }
+    its(:to_key) { should eql([123]) }
   end
 
-  def unpersisted
-    obj = @klass.new
-    obj.stubs(:persisted?).returns(false)
-    obj
-  end
-
-  describe 'to_key' do
-    it 'should generate a key when persisted' do
-      persisted.to_key.should eql([123])
-    end
-
-    it 'should return nil when not persisted' do
-      unpersisted.to_key.should be_nil
-    end
-  end
-
-  describe 'to_param' do
-    it 'should generate a param when persisted' do
-      persisted.to_param.should eql('123')
-    end
-
-    it 'should return nil when not persisted' do
-      unpersisted.to_param.should be_nil
-    end
+  context 'when not persisted' do
+    before { @obj.stubs(:persisted?).returns(false) }
+    its(:to_param) { should be_nil }
+    its(:to_key) { should be_nil }
   end
 end

data/spec/ninja_model/persistence_spec.rb

@@ -1,9 +1,135 @@
 require 'spec_helper'
 
 describe NinjaModel::Persistence do
-  before(:each) do
-    @klass = Class.new
-    @klass.send :include, NinjaModel::Persistence
+  class PersistenceModel < NinjaModel::Base
+    attribute :testing, :integer
+  end
+
+  before {
+    @obj = PersistenceModel.new
+    @adapter = mock('Adapter')
+    @obj.class.stubs(:adapter).returns(@adapter)
+  }
+  subject { @obj }
+  it { should respond_to(:save) }
+  it { should respond_to(:create) }
+  it { should respond_to(:update) }
+  it { should respond_to(:new_record?) }
+  it { should respond_to(:destroyed?) }
+  it { should respond_to(:persisted?) }
+  it { should respond_to(:destroy) }
+  it { should respond_to(:reload) }
+  it { should respond_to(:update_attributes) }
+  its(:new_record?) { should be_true }
+  its(:persisted?) { should be_false }
+  its(:destroyed?) { should be_false }
+
+  describe 'save' do
+    before { subject.stubs(:run_callbacks).yields(true) }
+    it 'should run the save callbacks' do
+      subject.expects(:run_callbacks).with(:save)
+      subject.save
+    end
+
+    it 'should call create for a new record' do
+      subject.stubs(:new_record?).returns(true)
+      subject.expects(:create)
+      subject.save
+    end
+
+    it 'should call update for a persisted record' do
+      subject.stubs(:new_record?).returns(false)
+      subject.expects(:update)
+      subject.save
+    end
+
+    it 'should clear the changed attributes after successful save' do
+      attributes = {}
+      subject.stubs(:changed_attributes).returns(attributes)
+      subject.stubs(:new_record?).returns(false)
+      subject.stubs(:update).returns(true)
+      attributes.expects(:clear)
+      subject.save
+    end
+
+    it 'should not clear the changed attributes after unsuccessful save' do
+      attributes = {}
+      subject.stubs(:changed_attributes).returns(attributes)
+      subject.stubs(:new_record?).returns(false)
+      subject.stubs(:update).returns(false)
+      attributes.expects(:clear).never
+      subject.save
+    end
+  end
+
+  describe 'create' do
+    before {
+      subject.stubs(:run_callbacks).yields(true)
+      @adapter.stubs(:create).returns(true)
+    }
+    it 'should run the create callbacks' do
+      subject.expects(:run_callbacks).with(:create)
+      subject.create
+    end
+    it 'should call create on the adapter' do
+      @adapter.expects(:create).with(subject)
+      subject.create
+    end
+    it 'should update the persisted status' do
+      subject.create
+      subject.persisted?.should be_true
+    end
+  end
+
+  describe 'update' do
+    before {
+      subject.stubs(:run_callbacks).yields(true)
+      @adapter.stubs(:update).returns(true)
+    }
+    it 'should run the update callbacks' do
+      subject.expects(:run_callbacks).with(:update)
+      subject.update
+    end
+    it 'should call update on the adapter' do
+      @adapter.expects(:update).with(subject)
+      subject.update
+    end
+  end
+
+  describe 'destroy' do
+    before {
+      @adapter.stubs(:destroy).returns(true)
+    }
+    it 'should run the destroy callbacks' do
+      subject.expects(:run_callbacks).with(:destroy)
+      subject.destroy
+    end
+    it 'should call destroy on the adapter' do
+      @adapter.expects(:destroy).with(subject)
+      subject.destroy
+    end
+    it 'should update the destroyed? status' do
+      subject.destroy
+      subject.destroyed?.should be_true
+    end
+    it 'should not be persisted afterwards' do
+      subject.destroy
+      subject.persisted?.should be_false
+    end
+  end
+
+  describe 'reload' do
+    it 'should call reload on the adapter' do
+      @adapter.expects(:reload).with(subject)
+      subject.reload
+    end
+  end
+
+  describe 'update_attributes' do
+    it 'update the attributes hash and save' do
+      subject.expects(:save)
+      subject.update_attributes(:testing => 2)
+      subject.testing.should eql(2)
+    end
   end
-  it { @klass.should respond_to(:get) }
 end