modis 0.0.1

data/spec/attributes_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+module AttributesSpec
+  class MockModel
+    include Modis::Model
+
+    attribute :name, :string, default: 'Janet'
+    attribute :age, :integer, default: 60
+    attribute :percentage, :float
+    attribute :created_at, :timestamp
+    attribute :flag, :boolean
+    attribute :array, :array
+    attribute :hash, :hash
+    attribute :hash_strict, :hash, strict: true
+    attribute :hash_not_strict, :hash, strict: false
+  end
+end
+
+describe Modis::Attributes do
+  let(:model) { AttributesSpec::MockModel.new }
+
+  it 'defines attributes' do
+    model.name = 'bar'
+    model.name.should == 'bar'
+  end
+
+  it 'applies an default value' do
+    model.name.should eq 'Janet'
+    model.age.should eq 60
+  end
+
+  it 'does not mark an attribute with a default as dirty' do
+    model.name_changed?.should be_false
+  end
+
+  it 'raises an error for an unsupported attribute type' do
+    expect do
+      class AttributesSpec::MockModel
+        attribute :unsupported, :symbol
+      end
+    end.to raise_error(Modis::UnsupportedAttributeType)
+  end
+
+  it 'assigns attributes' do
+    model.assign_attributes(name: 'bar')
+    model.name.should eq 'bar'
+  end
+
+  it 'does not attempt to assign attributes that are not defined on the model' do
+    model.assign_attributes(missing_attr: 'derp')
+    model.respond_to?(:missing_attr).should be_false
+  end
+
+  it 'allows an attribute to be nilled' do
+    model.name = nil
+    model.save!
+    model.class.find(model.id).name.should be_nil
+  end
+
+  describe ':string type' do
+    it 'is coerced' do
+      model.name = 'Ian'
+      model.save!
+      found = AttributesSpec::MockModel.find(model.id)
+      found.name.should eq 'Ian'
+    end
+  end
+
+  describe ':integer type' do
+    it 'is coerced' do
+      model.age = 18
+      model.save!
+      found = AttributesSpec::MockModel.find(model.id)
+      found.age.should eq 18
+    end
+  end
+
+  describe ':float type' do
+    it 'is coerced' do
+      model.percentage = 18.6
+      model.save!
+      found = AttributesSpec::MockModel.find(model.id)
+      found.percentage.should eq 18.6
+    end
+
+    it 'coerces a string representation to Float' do
+      model.percentage = '18.6'
+      model.save!
+      found = AttributesSpec::MockModel.find(model.id)
+      found.percentage.should eq 18.6
+    end
+  end
+
+  describe ':timestamp type' do
+    it 'is coerced' do
+      now = Time.now
+      model.created_at = now
+      model.save!
+      found = AttributesSpec::MockModel.find(model.id)
+      found.created_at.should be_kind_of(Time)
+      found.created_at.to_s.should eq now.to_s
+    end
+
+    it 'coerces a string representation to Time' do
+      now = Time.now
+      model.created_at = now.to_s
+      model.save!
+      found = AttributesSpec::MockModel.find(model.id)
+      found.created_at.should be_kind_of(Time)
+      found.created_at.to_s.should eq now.to_s
+    end
+  end
+
+  describe ':boolean type' do
+    it 'is coerced' do
+      model.flag = 'true'
+      model.save!
+      found = AttributesSpec::MockModel.find(model.id)
+      found.flag.should eq true
+    end
+
+    it 'raises an error if assigned a non-boolean value' do
+      expect { model.flag = 'unf!' }.to raise_error(Modis::AttributeCoercionError)
+    end
+  end
+
+  describe ':array type' do
+    it 'is coerced' do
+      model.array = [1, 2, 3]
+      model.save!
+      found = AttributesSpec::MockModel.find(model.id)
+      found.array.should eq [1, 2, 3]
+    end
+
+    it 'raises an error when assigned another type' do
+      expect { model.array = {foo: :bar} }.to raise_error(Modis::AttributeCoercionError)
+    end
+
+    it 'does not raise an error when assigned a JSON array string' do
+      expect { model.array = "[1,2,3]" }.to_not raise_error
+    end
+
+    it 'does not raise an error when a JSON string does not deserialize to an Array' do
+      expect { model.array = "{\"foo\":\"bar\"}" }.to raise_error(Modis::AttributeCoercionError)
+    end
+  end
+
+  describe ':hash type' do
+    it 'is coerced' do
+      model.hash = {foo: :bar}
+      model.save!
+      found = AttributesSpec::MockModel.find(model.id)
+      found.hash.should eq({'foo' => 'bar'})
+    end
+
+    describe 'strict: true' do
+      it 'raises an error if the value cannot be decoded on assignment' do
+        expect { model.hash_strict = "test" }.to raise_error(MultiJson::ParseError)
+      end
+
+      it 'does not raise an error if the value can be decoded on assignment' do
+        expect { model.hash_strict = "{\"foo\":\"bar\"}" }.to_not raise_error
+      end
+    end
+
+    describe 'strict: false' do
+      it 'returns the value if it cannot be decoded' do
+        model.write_attribute(:hash_not_strict, "test")
+        model.save!
+        found = AttributesSpec::MockModel.find(model.id)
+        found.hash_not_strict.should eq "test"
+      end
+
+      it 'does not raise an error when assigned another type' do
+        expect { model.hash_not_strict = "test" }.to_not raise_error
+      end
+    end
+  end
+end

data/spec/errors_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+module ErrorsSpec
+  class MockModel
+    include Modis::Model
+
+    attribute :name, :string
+  end
+end
+
+describe Modis::Errors do
+  let(:model) { ErrorsSpec::MockModel.new }
+
+  it 'adds errors' do
+    model.errors.add(:name, 'is not valid')
+    model.errors[:name].should eq ['is not valid']
+  end
+end

data/spec/finders_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+module FindersSpec
+  class User
+    include Modis::Model
+    self.namespace = 'users'
+
+    attribute :name, :string
+    attribute :age, :integer
+  end
+
+  class Consumer < User
+  end
+
+  class Producer < User
+  end
+end
+
+describe Modis::Finders do
+  let!(:model) { FindersSpec::User.create!(name: 'Ian', age: 28) }
+  let(:found) { FindersSpec::User.find(model.id) }
+
+  it 'finds by ID' do
+    found.id.should eq model.id
+    found.name.should eq model.name
+    found.age.should eq model.age
+  end
+
+  it 'raises an error if the record could not be found' do
+    expect do
+      FindersSpec::User.find(model.id + 1)
+    end.to raise_error(Modis::RecordNotFound, "Couldn't find FindersSpec::User with id=#{model.id + 1}")
+  end
+
+  it 'does not flag an attribute as dirty on a found instance' do
+    found.id_changed?.should be_false
+  end
+
+  describe 'all' do
+    it 'returns all records' do
+      m2 = FindersSpec::User.create!(name: 'Tanya', age: 30)
+      m3 = FindersSpec::User.create!(name: 'Kyle', age: 32)
+
+      FindersSpec::User.all.should == [model, m2, m3]
+    end
+
+    it 'does not return a destroyed record' do
+      model.destroy
+      FindersSpec::User.all.should == []
+    end
+  end
+
+  it 'identifies a found record as not being new' do
+    found.new_record?.should be_false
+  end
+
+  describe 'Single Table Inheritance' do
+    it 'returns the correct namespace' do
+      FindersSpec::Consumer.namespace.should eq 'users'
+      FindersSpec::Consumer.absolute_namespace.should eq 'modis:users'
+      FindersSpec::Producer.namespace.should eq 'users'
+      FindersSpec::Producer.absolute_namespace.should eq 'modis:users'
+    end
+
+    it 'returns instances of the correct class' do
+      FindersSpec::Consumer.create!(name: 'Kyle')
+      FindersSpec::Producer.create!(name: 'Tanya')
+
+      models = FindersSpec::User.all
+
+      ian = models.find { |model| model.name == 'Ian' }
+      kyle = models.find { |model| model.name == 'Kyle' }
+      tanya = models.find { |model| model.name == 'Tanya' }
+
+      ian.should be_kind_of(FindersSpec::User)
+      kyle.should be_kind_of(FindersSpec::Consumer)
+      tanya.should be_kind_of(FindersSpec::Producer)
+
+      FindersSpec::User.find(ian.id).should be_kind_of(FindersSpec::User)
+      FindersSpec::User.find(kyle.id).should be_kind_of(FindersSpec::Consumer)
+      FindersSpec::User.find(tanya.id).should be_kind_of(FindersSpec::Producer)
+    end
+  end
+end

data/spec/persistence_spec.rb

@@ -0,0 +1,266 @@
+require 'spec_helper'
+
+module PersistenceSpec
+  class MockModel
+    include Modis::Model
+
+    attribute :name, :string, default: 'Ian'
+    attribute :age, :integer
+    validates :name, presence: true
+
+    before_create :test_before_create
+    after_create :test_after_create
+
+    before_update :test_before_update
+    after_update :test_after_update
+
+    before_save :test_before_save
+    after_save :test_after_save
+
+    def called_callbacks
+      @called_callbacks ||= []
+    end
+
+    def test_after_create
+      called_callbacks << :test_after_create
+    end
+
+    def test_before_create
+      called_callbacks << :test_before_create
+    end
+
+    def test_after_update
+      called_callbacks << :test_after_update
+    end
+
+    def test_before_update
+      called_callbacks << :test_before_update
+    end
+
+    def test_after_save
+      called_callbacks << :test_after_save
+    end
+
+    def test_before_save
+      called_callbacks << :test_before_save
+    end
+  end
+end
+
+describe Modis::Persistence do
+  let(:model) { PersistenceSpec::MockModel.new }
+
+  describe 'namespaces' do
+    it 'returns the namespace' do
+      PersistenceSpec::MockModel.namespace.should eq 'persistence_spec:mock_model'
+    end
+
+    it 'returns the absolute namespace' do
+      PersistenceSpec::MockModel.absolute_namespace.should eq 'modis:persistence_spec:mock_model'
+    end
+
+    it 'allows the namespace to be set explicitly' do
+      PersistenceSpec::MockModel.namespace = 'other'
+      PersistenceSpec::MockModel.absolute_namespace.should eq 'modis:other'
+    end
+
+    after { PersistenceSpec::MockModel.namespace = nil }
+  end
+
+  it 'returns a key' do
+    model.save!
+    model.key.should eq 'modis:persistence_spec:mock_model:1'
+  end
+
+  it 'returns a nil key if not saved' do
+    model.key.should be_nil
+  end
+
+  it 'works with ActiveModel dirty tracking' do
+    expect { model.name = 'Kyle' }.to change(model, :changed).to(['name'])
+    model.name_changed?.should be_true
+  end
+
+  it 'resets dirty tracking when saved' do
+    model.name = 'Kyle'
+    model.name_changed?.should be_true
+    model.save!
+    model.name_changed?.should be_false
+  end
+
+  it 'resets dirty tracking when created' do
+    model = PersistenceSpec::MockModel.create!(name: 'Ian')
+    model.name_changed?.should be_false
+  end
+
+  it 'is persisted' do
+    model.persisted?.should be_true
+  end
+
+  it 'does not track the ID if the underlying Redis command failed'
+
+  it 'does not perform validation if validate: false' do
+    model.name = nil
+    model.valid?.should be_false
+    expect { model.save!(validate: false) }.to_not raise_error
+    model.reload
+    model.name.should be_nil
+
+    model.save(validate: false).should be_true
+  end
+
+  describe 'an existing record' do
+    it 'only updates dirty attributes'
+  end
+
+  describe 'reload' do
+    it 'reloads attributes' do
+      model.save!
+      model2 = model.class.find(model.id)
+      model2.name = 'Changed'
+      model2.save!
+      expect { model.reload }.to change(model, :name).to('Changed')
+    end
+
+    it 'resets dirty tracking' do
+      model.save!
+      model.name = 'Foo'
+      model.name_changed?.should be_true
+      model.reload
+      model.name_changed?.should be_false
+    end
+
+    it 'raises an error if the record has not been saved' do
+      expect { model.reload }.to raise_error(Modis::RecordNotFound, "Couldn't find PersistenceSpec::MockModel without an ID")
+    end
+  end
+
+  describe 'callbacks' do
+    it 'preserves dirty state for the duration of the callback life cycle'
+    it 'halts the chain if a callback returns false'
+
+    describe 'a new record' do
+      it 'calls the before_create callback' do
+        model.save!
+        model.called_callbacks.should include(:test_before_create)
+      end
+
+      it 'calls the after create callback' do
+        model.save!
+        model.called_callbacks.should include(:test_after_create)
+      end
+    end
+
+    describe 'an existing record' do
+      before { model.save! }
+
+      it 'calls the before_update callback' do
+        model.save!
+        model.called_callbacks.should include(:test_before_update)
+      end
+
+      it 'calls the after update callback' do
+        model.save!
+        model.called_callbacks.should include(:test_after_update)
+      end
+    end
+
+    it 'calls the before_save callback' do
+      model.save!
+      model.called_callbacks.should include(:test_before_save)
+    end
+
+    it 'calls the after save callback' do
+      model.save!
+      model.called_callbacks.should include(:test_after_save)
+    end
+  end
+
+  describe 'create' do
+    it 'resets dirty tracking' do
+      model = PersistenceSpec::MockModel.create(name: 'Ian')
+      model.name_changed?.should be_false
+    end
+
+    describe 'a valid model' do
+      it 'returns the created model'
+    end
+
+    describe 'an invalid model' do
+      it 'returns the unsaved model'
+    end
+  end
+
+  describe 'update_attribute' do
+    it 'does not perform validation' do
+      model.name = nil
+      model.valid?.should be_false
+      model.name = 'Test'
+      model.update_attribute(:name, nil)
+    end
+
+    it 'invokes callbacks' do
+      model.update_attribute(:name, 'Derp')
+      model.called_callbacks.should_not be_empty
+    end
+
+    it 'updates all dirty attributes' do
+      model.age = 29
+      model.update_attribute(:name, 'Derp')
+      model.reload
+      model.age.should eq 29
+    end
+  end
+
+  describe 'update_attributes!' do
+it 'updates the given attributes' do
+      model.update_attributes!(name: 'Derp', age: 29)
+      model.reload
+      model.name.should eq 'Derp'
+      model.age.should eq 29
+    end
+
+    it 'invokes callbacks' do
+      model.update_attributes!(name: 'Derp')
+      model.called_callbacks.should_not be_empty
+    end
+
+    it 'updates all dirty attributes' do
+      model.age = 29
+      model.update_attributes!(name: 'Derp')
+      model.reload
+      model.age.should eq 29
+    end
+
+    it 'raises an error if the model is invalid' do
+      expect do
+        model.update_attributes!(name: nil).should be_false
+        end.to raise_error(Modis::RecordInvalid)
+    end
+  end
+
+  describe 'update_attributes' do
+    it 'updates the given attributes' do
+      model.update_attributes(name: 'Derp', age: 29)
+      model.reload
+      model.name.should eq 'Derp'
+      model.age.should eq 29
+    end
+
+    it 'invokes callbacks' do
+      model.update_attributes(name: 'Derp')
+      model.called_callbacks.should_not be_empty
+    end
+
+    it 'updates all dirty attributes' do
+      model.age = 29
+      model.update_attributes(name: 'Derp')
+      model.reload
+      model.age.should eq 29
+    end
+
+    it 'returns false if the model is invalid' do
+      model.update_attributes(name: nil).should be_false
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+begin
+  require './spec/support/simplecov_helper'
+  include SimpleCovHelper
+  start_simple_cov('unit')
+rescue LoadError
+  puts "Coverage disabled."
+end
+
+require 'modis'
+
+Modis.configure do |config|
+  config.namespace = 'modis'
+end
+
+RSpec.configure do |config|
+  config.after :each do
+    keys = Modis.redis.keys "#{Modis.config.namespace}:*"
+    Modis.redis.del *keys unless keys.empty?
+  end
+end

data/spec/support/simplecov_helper.rb

@@ -0,0 +1,19 @@
+require 'simplecov'
+require './spec/support/simplecov_quality_formatter'
+
+module SimpleCovHelper
+  def start_simple_cov(name)
+    SimpleCov.start do
+      add_filter '/spec/'
+      command_name name
+
+      if ENV['TRAVIS']
+        require 'coveralls'
+        formatter SimpleCov::Formatter::MultiFormatter[SimpleCov::Formatter::QualityFormatter,
+                                                       Coveralls::SimpleCov::Formatter]
+      else
+        formatter SimpleCov::Formatter::QualityFormatter
+      end
+    end
+  end
+end

data/spec/support/simplecov_quality_formatter.rb

@@ -0,0 +1,8 @@
+class SimpleCov::Formatter::QualityFormatter
+  def format(result)
+    SimpleCov::Formatter::HTMLFormatter.new.format(result)
+    File.open("coverage/covered_percent", "w") do |f|
+      f.puts result.source_files.covered_percent.to_f
+    end
+  end
+end

data/spec/transaction_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+module TransactionSpec
+  class MockModel
+    include Modis::Model
+  end
+end
+
+describe Modis::Transaction do
+  it 'yields the block in a transaction' do
+    Modis.redis.should_receive(:multi).and_yield
+    TransactionSpec::MockModel.transaction {}
+  end
+end

data/spec/validations_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe 'validations' do
+  class TestModel
+    include Modis::Model
+    attribute :name, :string
+    validates :name, presence: true
+  end
+
+  let(:model) { TestModel.new }
+
+  it 'responds to valid?' do
+    model.name = nil
+    model.valid?.should be_false
+  end
+
+  it 'sets errors on the model' do
+    model.name = nil
+    model.valid?
+    model.errors[:name].should eq ["can't be blank"]
+  end
+
+  describe 'save' do
+    it 'returns true if the model is valid' do
+      model.name = "Ian"
+      model.save.should be_true
+    end
+
+    it 'returns false if the model is invalid' do
+      model.name = nil
+      model.save.should be_false
+    end
+  end
+
+  describe 'save!' do
+    it 'raises an error if the model is invalid' do
+      model.name = nil
+      expect do
+        model.save!.should be_false
+      end.to raise_error(Modis::RecordInvalid)
+    end
+  end
+
+  describe 'create!' do
+    it 'raises an error if the record is not valid' do
+      expect { TestModel.create!(name: nil) }.to raise_error(Modis::RecordInvalid)
+    end
+  end
+end