active_mapper 0.0.1

data/spec/active_mapper/mapper_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+describe ActiveMapper::Mapper do
+  let(:adapter) { ActiveMapper::Adapter::Memory.new }
+  let(:mapper) { ActiveMapper::Mapper.new(User, adapter) }
+  let(:user) { User.new(name: 'user', age: 28) }
+  let(:other_user) { User.new(name: 'other', age: 35) }
+
+  before do
+    mapper.save(user)
+    mapper.save(other_user)
+  end
+
+  describe '#all?' do
+    it 'is true when all objects match' do
+      expect(mapper.all? { |user| user.age > 18 }).to be_true
+    end
+
+    it 'is false when all objects do not match' do
+      expect(mapper.all? { |user| user.age > 28 }).to be_false
+    end
+  end
+
+  describe '#any?' do
+    it 'is true when any objects match' do
+      expect(mapper.any? { |user| user.age == 28 }).to be_true
+    end
+
+    it 'is false when no objects match' do
+      expect(mapper.any? { |user| user.age > 35 }).to be_false
+    end
+  end
+
+  describe '#none?' do
+    it 'is true when no objects match' do
+      expect(mapper.none? { |user| user.age == 18 }).to be_true
+    end
+
+    it 'is false when any objects match' do
+      expect(mapper.none? { |user| user.age == 28 }).to be_false
+    end
+  end
+
+  describe '#one?' do
+    it 'is true when one object matches' do
+      expect(mapper.one? { |user| user.age == 28 }).to be_true
+    end
+
+    it 'is false when no objects match' do
+      expect(mapper.one? { |user| user.age > 35 }).to be_false
+    end
+
+    it 'is false when more than one object matches' do
+      expect(mapper.one? { |user| user.age > 18 }).to be_false
+    end
+  end
+
+  describe '#count' do
+    it 'counts the all objects' do
+      expect(mapper.count).to eq(2)
+    end
+
+    it 'counts matching objects' do
+      expect(mapper.count { |user| user.age < 35 }).to eq(1)
+    end
+  end
+
+  describe '#min' do
+    it 'finds the minimum value' do
+      expect(mapper.min(:age)).to eq(28)
+    end
+  end
+
+  describe '#max' do
+    it 'finds the maximum value' do
+      expect(mapper.max(:age)).to eq(35)  
+    end
+  end
+
+  describe '#minmax' do
+    it 'finds the minium and maximum values' do
+      expect(mapper.minmax(:age)).to eq([28, 35])
+    end
+  end
+
+  describe '#average' do
+    it 'finds the average value' do
+      expect(mapper.avg(:age)).to eq(31.5)
+    end
+  end
+
+  describe '#sum' do
+    it 'finds the total value' do
+      expect(mapper.sum(:age)).to eq(63)
+    end
+  end
+
+  describe '#find' do
+    it 'finds the object with the matching id' do
+      expect(mapper.find(user.id)).to eq(user)
+    end
+
+    it 'finds the first matching object' do
+      expect(mapper.find { |user| user.age > 21 }).to eq(user)
+    end
+  end
+
+  describe '#find_all' do
+    it 'finds all objects' do
+      expect(mapper.find_all.to_a).to eq([user, other_user])
+    end
+
+    it 'finds all matching objects' do
+      expect(mapper.find_all { |user| user.age < 30 }.to_a).to eq([user])
+    end
+  end
+
+  describe '#last' do
+    it 'finds the last matching object' do
+      expect(mapper.last { |user| user.age > 18 }).to eq(other_user)
+    end
+  end
+
+  describe '#select' do
+    it 'finds all matching objects' do
+      expect(mapper.select { |user| user.age < 30 }.to_a).to eq([user])
+    end
+  end
+
+  describe '#reject' do
+    it 'finds all non matching objects' do
+      expect(mapper.reject { |user| user.age == 28 }.to_a).to eq([other_user])
+    end
+  end
+
+  describe '#delete' do
+    it 'deletes the object' do
+      mapper.delete(user)
+
+      expect(mapper.find(user.id)).to be_nil
+    end
+  end
+
+  describe '#delete_if' do
+    it 'deletes all matching objects' do
+      mapper.delete_if { |user| user.age == 28 }
+
+      expect(mapper.find(user.id)).to be_nil
+      expect(mapper.find(other_user.id)).to eq(other_user)
+    end
+  end
+
+  describe '#clear' do
+    it 'deletes all objects' do
+      mapper.clear
+
+      expect(mapper.count).to eq(0)
+    end
+  end
+
+  describe '#keep_if' do
+    it 'deletes all non matching objects' do
+      mapper.keep_if { |user| user.age == 28 }
+
+      expect(mapper.find(user.id)).to eq(user)
+      expect(mapper.find(other_user.id)).to be_nil
+    end
+  end
+
+  describe '#save' do
+    before { mapper.clear }
+
+    it 'does not save invalid objects' do
+      user.stub(valid?: false)
+      expect(adapter).to_not receive(:insert)
+
+      expect(mapper.save(user)).to be_false
+    end
+
+    it 'creates unpersisted objects that are valid' do
+      user.stub(valid?: true)
+      user.id = nil
+
+      expect(adapter).to receive(:insert).with(User, user).and_return(1)
+      expect { mapper.save(user) }.to change(user, :id)
+    end
+
+    it 'updates persisted objects that are valid' do
+      user.stub(valid?: true)
+      mapper.save(user)
+
+      expect(adapter).to receive(:update).with(User, user)
+      expect { mapper.save(user) }.to_not change(user, :id)
+    end
+  end
+end

data/spec/active_mapper/relation_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+
+describe ActiveMapper::Relation do
+  let(:adapter) { ActiveMapper::Adapter::Memory.new }
+  let(:user) { User.new(name: 'user', age: 28) }
+  let(:other_user) { User.new(name: 'other', age: 35) }
+
+  before do
+    user.id  = adapter.insert(User, user)
+    other_user.id = adapter.insert(User, other_user)
+  end
+
+  def create_relation(&block)
+    ActiveMapper::Relation.new(User, adapter, &block)
+  end
+
+  describe '#any?' do
+    it 'is true when there are matching objects' do
+      relation = create_relation { |user| user.age == 28 }
+      expect(relation.any?).to be_true
+    end
+
+    it 'is false when there are no matching objects' do
+      relation = create_relation { |user| user.age == 18 }
+      expect(relation.any?).to be_false
+    end
+  end
+
+  describe '#none?' do
+    it 'is true when there are no matching objects' do
+      relation = create_relation { |user| user.age < 18 }
+
+      expect(relation.none?).to be_true
+      expect(relation.empty?).to be_true
+    end
+
+    it 'is false when there are matching objects' do
+      relation = create_relation { |user| user.age == 28 }
+
+      expect(relation.none?).to be_false
+      expect(relation.empty?).to be_false
+    end
+  end
+
+  describe '#one?' do
+    it 'is true when there is one matching object' do
+      relation = create_relation { |user| user.age == 28 }
+
+      expect(relation.one?).to be_true
+    end
+
+    it 'is false when there are no matching objects' do
+      relation = create_relation { |user| user.age < 18 }
+
+      expect(relation.one?).to be_false
+    end
+
+    it 'is false when there are is more than one matching object' do
+      relation = create_relation { |user| user.age > 18 }
+
+      expect(relation.one?).to be_false
+    end
+  end
+
+  describe '#count' do
+    it 'counts the number of matching objects' do
+      relation = create_relation { |user| user.age == 28 }
+
+      expect(relation.count).to eq(1)
+      expect(relation.length).to eq(1)
+      expect(relation.size).to eq(1)
+    end
+  end
+
+  describe '#min' do
+    it 'calculates the minimum value' do
+      expect(create_relation.min(:age)).to eql(28)
+    end
+  end
+
+  describe '#max' do
+    it 'calculates the maximum value' do
+      expect(create_relation.max(:age)).to eq(35)
+    end
+  end
+
+  describe '#minmax' do
+    it 'calculates the minimum and maximum values' do
+      expect(create_relation.minmax(:age)).to eq([28, 35])
+    end
+  end
+
+  describe '#avg' do
+    it 'calculates the average value' do
+      expect(create_relation.avg(:age)).to eq(31.5)
+    end
+  end
+
+  describe '#sum' do
+    it 'calculates the total value' do
+      expect(create_relation.sum(:age)).to eq(63)
+    end
+  end
+
+  describe '#drop' do
+    it 'offsets by the number of objects' do
+      expect(create_relation.drop(1).to_a).to eq([other_user])
+    end
+  end
+
+  describe '#select' do
+    it 'returns matching objects' do
+      relation = create_relation { |user| user.name == 'user' }.select { |user| user.age == 28 }.to_a
+
+      expect(relation).to include(user)
+      expect(relation).to_not include(other_user)
+    end
+  end
+
+  describe '#reject' do
+    it 'returns non matching objects' do
+      relation = create_relation { |user| user.age > 18 }.reject { |user| user.name == 'user' }.to_a
+
+      expect(relation).to include(other_user)
+      expect(relation).to_not include(user)
+    end
+  end
+
+  describe '#first' do
+    it 'returns the first matching object' do
+      expect(create_relation.first).to eq(user)
+    end
+
+    it 'returns the first number of matching objects' do
+      expect(create_relation.first(2)).to eq([user, other_user])
+    end
+  end
+
+  describe '#last' do
+    it 'returns the last matching object' do
+      expect(create_relation.last).to eq(other_user)
+    end
+
+    it 'returns the last number of matching objects' do
+      expect(create_relation.last(2)).to eq([other_user, user])
+    end
+  end
+
+  describe '#take' do
+    it 'limits the number of records returned' do
+      expect(create_relation.take(1).to_a).to eq([user])
+    end
+  end
+
+  describe '#to_a' do
+    it 'finds all matching objects' do
+      expect(create_relation { |user| user.age == 28 }.to_a).to eq([user])
+    end
+  end
+
+  describe '#map' do
+    it 'maps the objects' do
+      expect(create_relation.map(&:name)).to eq(['user', 'other'])
+    end
+  end
+
+  describe '#each' do
+    it 'iterates through the objects' do
+      create_relation { |user| user.age == 18 }.each { |u| expect(u).to eq(user) }
+    end
+  end
+
+  describe '#sort_by' do
+    it 'sorts the objects by attribute' do
+      relation = create_relation.sort_by(&:name).to_a
+
+      expect(relation.first).to eq(other_user)
+      expect(relation.last).to eq(user)
+    end
+  end
+
+  describe '#reverse' do
+    it 'sets the opposite direction to order by' do
+      relation = create_relation.sort_by(&:age).reverse.to_a
+
+      expect(relation.first).to eq(other_user)
+      expect(relation.last).to eq(user)
+    end
+  end
+end

data/spec/active_mapper_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe ActiveMapper do
+  describe '.[]' do
+    it 'returns the stored mapper' do
+      expect(ActiveMapper[User].mapped_class).to eql(User)
+    end
+  end
+
+  describe '.adapter' do
+    let(:adapter) { double('Adapter') }
+
+    it 'returns the adapter that has been set' do
+      ActiveMapper.adapter = adapter
+
+      expect(ActiveMapper.adapter).to eq(adapter)
+    end
+
+    it 'defaults to the memory store' do
+      ActiveMapper.adapter = nil
+
+      expect(ActiveMapper.adapter).to be_a(ActiveMapper::Adapter::Memory)
+    end
+  end
+end

data/spec/features/active_record_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe 'ActiveMapper with ActiveRecord adapter' do
+  setup_active_record('active_record_integration')
+
+  it_should_behave_like 'ActiveMapper Integration', ActiveMapper::Adapter::ActiveRecord.new
+end

data/spec/features/memory_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe 'ActiveMapper with Memory adapter' do
+  it_should_behave_like 'ActiveMapper Integration', ActiveMapper::Adapter::Memory.new
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require 'active_record'
+require 'active_mapper'
+
+Dir['./spec/support/**/*.rb'].each { |f| require f }
+
+# stop deprecation message
+I18n.enforce_available_locales = false
+
+class CreateUsers < ActiveRecord::Migration
+  def up
+    create_table :users do |t|
+      t.string :name
+      t.integer :age
+      t.timestamps
+    end
+  end
+end
+
+def setup_active_record(name)
+  db = "./spec/support/db/#{name}.sqlite3"
+
+  before(:all) do
+    ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: db)
+    CreateUsers.new.migrate(:up)
+  end
+
+  after(:all) do
+    File.delete(db)
+  end
+end

data/spec/support/models/user.rb

@@ -0,0 +1,20 @@
+class User
+  include ActiveModel::Model
+
+  attr_accessor :id, :name, :age, :created_at, :updated_at
+
+  validates :name, presence: true
+  validates :age, presence: true, numericality: { only_integer: true }
+
+  def persisted?
+    id
+  end
+
+  def ==(other)
+    if id
+      id == other.id
+    else
+      object_id == other.object_id
+    end
+  end
+end

data/spec/support/shared/active_mapper_integration.rb

@@ -0,0 +1,129 @@
+shared_examples_for 'ActiveMapper Integration' do |adapter|
+  let(:mapper) { ActiveMapper::Mapper.new(User, adapter) }
+  let(:user) { User.new(name: 'user', age: 28) }
+  let(:other_user) { User.new(name: 'other', age: 35) }
+
+  after { mapper.clear }
+
+  it 'can create and modify records' do
+    mapper.save(user)
+    user.name = 'Changed'
+    user.age = 18
+    mapper.save(user)
+
+    record = mapper.find(user.id)
+
+    expect(record.name).to eq('Changed')
+    expect(record.age).to eq(18)
+  end
+
+  it 'can delete records' do
+    mapper.save(user)
+    mapper.delete(user)
+
+    expect(mapper.find(user.id)).to be_nil
+
+    user.id = nil
+
+    mapper.save(user)
+    mapper.save(other_user)
+    mapper.clear
+
+    expect(mapper.count).to eq(0)
+
+    user.id = nil
+    other_user.id = nil
+
+    mapper.save(user)
+    mapper.save(other_user)
+    mapper.delete_if { |user| user.age < 35 }
+
+    expect(mapper.find(other_user.id)).to eq(other_user)
+    expect(mapper.find(user.id)).to be_nil
+
+    user.id = nil
+    other_user.id = nil
+
+    mapper.save(user)
+    mapper.save(other_user)
+    mapper.keep_if { |user| user.age < 35 }
+
+    expect(mapper.find(user.id)).to eq(user)
+    expect(mapper.find(other_user.id)).to be_nil
+  end
+
+  it 'can retrieve the first, last and all records' do
+    mapper.save(user)
+    mapper.save(other_user)
+
+    expect(mapper.first).to eq(user)
+    expect(mapper.last).to eq(other_user)
+
+    records = mapper.find_all.to_a
+
+    expect(records).to include(user)
+    expect(records).to include(other_user)
+  end
+
+  it 'can count records' do
+    mapper.save(user)
+    mapper.save(other_user)
+
+    expect(mapper.count).to eq(2)
+    expect(mapper.count { |user| user.age < 35 }).to eq(1)
+  end
+
+  it 'can query for records' do
+    mapper.save(user)
+    mapper.save(other_user)
+
+    expect(mapper.reject { |user| user.name == 'user' }.to_a).to eq([other_user])
+    expect(mapper.first { |user| user.name.in 'user' }).to eq(user)
+    expect(mapper.first { |user| user.name.not_in 'user' }).to eq(other_user)
+    expect(mapper.first { |user| user.name.starts_with 'us' }).to eq(user)
+    expect(mapper.first { |user| user.name.contains 'th' }).to eq(other_user)
+    expect(mapper.first { |user| user.name.ends_with 'er' }).to eq(user)
+    expect(mapper.first { |user| user.name == 'user' }).to eq(user)
+    expect(mapper.first { |user| user.name != 'user' }).to eq(other_user)
+    expect(mapper.first { |user| user.age > 30 }).to eq(other_user)
+    expect(mapper.first { |user| user.age >= 35 }).to eq(other_user)
+    expect(mapper.first { |user| user.age < 35 }).to eq(user)
+    expect(mapper.first { |user| user.age <= 28 }).to eq(user)
+    expect(mapper.first { |user| !(user.age == 28) }).to eq(other_user)
+    expect(mapper.first { |user| (user.name == 'user') & (user.age > 18) }).to eq(user)
+    expect(mapper.first { |user| (user.name == 'other') | (user.age == 35) }).to eq(other_user)
+  end
+
+  it 'can aggregate data' do
+    mapper.save(user)
+    mapper.save(other_user)
+
+    expect(mapper.max(:age)).to eq(35)
+    expect(mapper.min(:age)).to eq(28)
+    expect(mapper.minmax(:age)).to eq([28, 35])
+    expect(mapper.avg(:age)).to eq(31.5)
+    expect(mapper.sum(:age)).to eq(63)
+  end
+
+  it 'can sort records' do
+    other_user.age = user.age
+
+    mapper.save(user)
+    mapper.save(other_user)
+    
+    records = mapper.find_all.sort_by { |user| [user.name, user.age] }.to_a
+
+    expect(records.first).to eq(other_user)
+    expect(records.last).to eq(user)
+
+    records = mapper.find_all.sort_by { |user| [user.age, -user.name] }.to_a
+
+    expect(records.first).to eq(user)
+    expect(records.last).to eq(other_user)
+
+    records = mapper.find_all.sort_by { |user| [user.age, -user.name] }.reverse.to_a
+
+    expect(records.first).to eq(other_user)
+    expect(records.last).to eq(user)
+  end
+end