yadm 0.1

data/spec/yadm/criteria_parser_spec.rb

@@ -0,0 +1,55 @@
+RSpec.describe YADM::CriteriaParser do
+  describe '.parse' do
+    context 'without arguments' do
+      let(:block) do
+        proc do
+          with { age > 12 }.descending_by { age }.ascending_by { id }.first(5)
+        end
+      end
+      
+      let(:expected_criteria) do
+        build_criteria(
+          condition: build_condition(
+            build_expression(build_attribute(:age), :>, 12)
+          ),
+          order: build_order(
+            [
+              build_order_clause(:desc, build_attribute(:age)),
+              build_order_clause(:asc, build_attribute(:id))
+            ]
+          ),
+          limit: build_limit(5)
+        )
+      end
+      
+      it 'returns the parsed YADM::Criteria' do
+        expect(described_class.parse(block, :first)).to eq(expected_criteria)
+      end
+    end
+    
+    context 'with arguments' do
+      let(:block) do
+        proc do |min_age, limit|
+          with { age > min_age }.first(limit)
+        end
+      end
+      
+      let(:expected_criteria) do
+        build_criteria(
+          condition: build_condition(
+            build_expression(
+              build_attribute(:age),
+              :>,
+              build_argument(:first, 0)
+            )
+          ),
+          limit: build_limit(build_argument(:first, 1))
+        )
+      end
+      
+      it 'returns the parsed YADM::Criteria' do
+        expect(described_class.parse(block, :first)).to eq(expected_criteria)
+      end
+    end
+  end
+end

data/spec/yadm/criteria_spec.rb

@@ -0,0 +1,40 @@
+RSpec.describe YADM::Criteria do
+  describe '#merge' do
+    subject do
+      described_class.new(
+        condition: :first_condition,
+        order:     :first_order,
+        limit:     :first_limit
+      )
+    end
+    
+    let(:other_criteria) do
+      described_class.new(
+        condition: :second_condition,
+        order:     :second_order,
+        limit:     :second_limit
+      )
+    end
+    
+    before(:each) do
+      allow(YADM::Criteria::Condition).to receive(:merge).and_return(:third_condition)
+      allow(YADM::Criteria::Order).to receive(:merge).and_return(:third_order)
+      allow(YADM::Criteria::Limit).to receive(:merge).and_return(:third_limit)
+    end
+    
+    it 'merges conditions' do
+      expect(YADM::Criteria::Condition).to receive(:merge).with(:first_condition, :second_condition)
+      expect(subject.merge(other_criteria).condition).to eq(:third_condition)
+    end
+    
+    it 'merges orders' do
+      expect(YADM::Criteria::Order).to receive(:merge).with(:first_order, :second_order)
+      expect(subject.merge(other_criteria).order).to eq(:third_order)
+    end
+    
+    it 'merges limits' do
+      expect(YADM::Criteria::Limit).to receive(:merge).with(:first_limit, :second_limit)
+      expect(subject.merge(other_criteria).limit).to eq(:third_limit)
+    end
+  end
+end

data/spec/yadm/entity_spec.rb

@@ -0,0 +1,76 @@
+RSpec.describe YADM::Entity do
+  let(:entity_class) do
+    Class.new do
+      include YADM::Entity
+    end
+  end
+  
+  describe '.attributes' do
+    before(:each) do
+      entity_class.class_eval do
+        attributes :name
+      end
+    end
+    
+    let(:entity) { entity_class.new(id: 1, name: 'John') }
+    
+    it 'defines a constructor that takes specified attributes' do
+      expect(entity.id).to eq(1)
+      expect(entity.name).to eq('John')
+    end
+    
+    it 'defines accessors' do
+      entity.name = 'Jack'
+      expect(entity.name).to eq('Jack')
+    end
+    
+    context 'with `readonly` option' do
+      before(:each) do
+        entity_class.class_eval do
+          attribute :password, readonly: true
+        end
+      end
+      
+      let(:entity) { entity_class.new(id: 1, name: 'John', password: 'secret') }
+      
+      it 'defines just a reader' do
+        expect(entity.password).to eq('secret')
+        
+        expect {
+          entity.password = 'hello'
+        }.to raise_error(NoMethodError)
+      end
+    end
+    
+    context 'with string parameters' do
+      before(:each) do
+        entity_class.class_eval do
+          attribute 'email'
+        end
+      end
+      
+      let(:entity) do
+        entity_class.new(id: 1, name: 'John', email: 'john@example.com')
+      end
+      
+      it 'behaves the same as with symbol parameters' do
+        expect(entity.email).to eq('john@example.com')
+      end
+    end
+    
+    context 'with string keys in contructor' do
+      let(:entity) { entity_class.new('id' => 1, 'name' => 'John') }
+      
+      it 'behaves the same as with symbol keys' do
+        expect(entity.id).to eq(1)
+        expect(entity.name).to eq('John')
+      end
+    end
+    
+    context 'without arguments' do
+      it 'returns all attribute names' do
+        expect(entity_class.attributes).to eq([:id, :name].to_set)
+      end
+    end
+  end
+end

data/spec/yadm/identity_map_spec.rb

@@ -0,0 +1,128 @@
+require 'yadm/adapters/memory'
+
+RSpec.describe YADM::IdentityMap do
+  let(:data_source) { YADM::Adapters::Memory.new }
+  
+  before(:each) do
+    data_source.add(:people, name: 'John')
+  end
+  
+  subject { YADM::IdentityMap.new(data_source) }
+  
+  describe '#get' do
+    context 'without a record in map' do
+      it 'gets the record from the data source' do
+        expect(subject.get(:people, 1)).to eq(id: 1, name: 'John')
+      end
+    end
+    
+    context 'with a record in map' do
+      before(:each) do
+        subject.get(:people, 1)
+        data_source.change(:people, 1, name: 'Jack')
+      end
+      
+      it 'gets the record from the map' do
+        expect(subject.get(:people, 1)).to eq(id: 1, name: 'John')
+      end
+    end
+  end
+  
+  describe '#add' do
+    it 'saves the record in the data source' do
+      subject.add(:people, name: 'Jack')
+      
+      expect(data_source.get(:people, 2)[:name]).to eq('Jack')
+    end
+    
+    it 'saves the record in the map' do
+      subject.add(:people, name: 'Jack')
+      
+      expect(data_source).not_to receive(:get)
+      expect(subject.get(:people, 2)[:id]).to eq(2)
+    end
+    
+    it 'returns the id of the added record' do
+      expect(subject.add(:people, name: 'Jack')).to eq(2)
+    end
+  end
+  
+  describe '#change' do
+    context 'without a record in map' do
+      before(:each) do
+        subject.change(:people, 1, name: 'David')
+      end
+      
+      it 'changes the record in the data source' do
+        expect(data_source.get(:people, 1)[:name]).to eq('David')
+      end
+      
+      it 'adds the record to the map' do
+        expect(data_source).not_to receive(:get)
+        expect(subject.get(:people, 1)[:id]).to eq(1)
+      end
+    end
+    
+    context 'with a record in map' do
+      before(:each) do
+        subject.get(:people, 1)
+        subject.change(:people, 1, name: 'David')
+      end
+      
+      it 'updates the record in the map' do
+        expect(data_source).not_to receive(:get)
+        expect(subject.get(:people, 1)[:name]).to eq('David')
+      end
+    end
+  end
+  
+  describe '#remove' do
+    it 'removes the record from the data source' do
+      subject.remove(:people, 1)
+      expect(data_source.count(:people)).to be_zero
+    end
+    
+    context 'with a record in map' do
+      before(:each) do
+        subject.get(:people, 1)
+        subject.remove(:people, 1)
+      end
+      
+      it 'removes the record from the map' do
+        expect(data_source).to receive(:get).with(:people, 1).and_call_original
+        
+        expect {
+          subject.get(:people, 1)
+        }.to raise_error(KeyError)
+      end
+    end
+  end
+  
+  describe '#count' do
+    it 'passes the method call to the data source' do
+      expect(subject.count(:people)).to eq(1)
+    end
+  end
+  
+  describe '#send_query' do
+    let(:query) { double('Query') }
+    let(:data)  { double('Data') }
+    
+    before(:each) do
+      allow(data_source).to receive(:send_query).with(:people, query).and_return(data)
+    end
+    
+    it 'passes the method call to the data source' do
+      expect(subject.send_query(:people, query)).to eq(data)
+    end
+  end
+  
+  describe '#migrate' do
+    let(:block) { double('Block') }
+    
+    it 'passes the method call to the data source' do
+      expect(data_source).to receive(:migrate).with(block)
+      subject.migrate(block)
+    end
+  end
+end

data/spec/yadm/mapper_spec.rb

@@ -0,0 +1,23 @@
+RSpec.describe YADM::Mapper do
+  let(:identity_map) { YADM::IdentityMap.new(nil) }
+  
+  before(:each) do
+    YADM.data_sources[:source] = identity_map
+  end
+  
+  describe '.repository' do
+    let(:repository) do
+      Class.new do
+        include YADM::Repository
+      end
+    end
+    
+    it 'adds a new mapping for the given repository' do
+      subject.repository(repository) do
+        data_source :source
+      end
+      
+      expect(subject.mapping_for(repository).data_source).to eq(identity_map)
+    end
+  end
+end

data/spec/yadm/mapping/attribute_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe YADM::Mapping::Attribute do
+  context 'with an Integer type' do
+    subject { described_class.new(Integer) }
+    
+    describe '#coerce' do
+      it 'coerces the value to integer' do
+        expect(subject.coerce('123')).to eq(123)
+        expect(subject.coerce(123)).to eq(123)
+        expect(subject.coerce('123abc')).to eq(123)
+        expect(subject.coerce('abc')).to eq(0)
+      end
+      
+      it 'leaves nil as is' do
+        expect(subject.coerce(nil)).to be_nil
+      end
+    end
+  end
+  
+  context 'with a String type' do
+    subject { described_class.new(String) }
+    
+    describe '#coerce' do
+      it 'coerces the value to String' do
+        expect(subject.coerce(123)).to eq('123')
+        expect(subject.coerce('123')).to eq('123')
+        expect(subject.coerce('123abc')).to eq('123abc')
+        expect(subject.coerce(:abc)).to eq('abc')
+      end
+      
+      it 'leaves nil as is' do
+        expect(subject.coerce(nil)).to be_nil
+      end
+    end
+  end
+end

data/spec/yadm/mapping_spec.rb

@@ -0,0 +1,122 @@
+require 'yadm/adapters/memory'
+
+RSpec.describe YADM::Mapping do
+  let(:data_source)  { YADM::Adapters::Memory.new }
+  let(:identity_map) { YADM::IdentityMap.new(data_source) }
+  
+  before(:each) do
+    data_source.add(:people, name: 'John', age: '35')
+    YADM.data_sources[:source] = identity_map
+  end
+  
+  let(:people_mapping) do
+    YADM::Mapping.new do
+      data_source :source
+      collection  :people
+      
+      attribute :id, Integer
+      attribute :name, String
+      attribute :age, Integer
+    end
+  end
+  
+  describe '#get' do
+    it 'returns a hash with converted attributes' do
+      hash = people_mapping.get(1)
+      
+      expect(hash[:id]).to eq(1)
+      expect(hash[:name]).to eq('John')
+      expect(hash[:age]).to eq(35)
+    end
+  end
+  
+  describe '#add' do
+    it 'passes the method call to the data source' do
+      people_mapping.add(name: 'Jack', age: 27)
+      expect(people_mapping.get(2)[:name]).to eq('Jack')
+    end
+  end
+  
+  describe '#change' do
+    it 'passes the method call to the data source' do
+      people_mapping.change(1, name: 'Johnny')
+      expect(people_mapping.get(1)[:name]).to eq('Johnny')
+    end
+  end
+  
+  describe '#remove' do
+    it 'passes the method call to the data source' do
+      people_mapping.remove(1)
+      expect { people_mapping.get(1) }.to raise_error(KeyError)
+    end
+  end
+  
+  describe '#count' do
+    it 'passes the method call to the data source' do
+      expect(people_mapping.count).to eq(1)
+    end
+  end
+  
+  describe '#send_query' do
+    let(:query) { double('Query') }
+    
+    let(:data) do
+      [
+        { id: 1, name: 'John', age: '31' },
+        { id: 2, name: 'Jack', age: '42' }
+      ]
+    end
+    
+    before(:each) do
+      allow(identity_map).to receive(:send_query).with(:people, query).and_return(data)
+    end
+    
+    it 'gets the data from the data source and coerces it' do
+      result = people_mapping.send_query(query)
+      
+      expect(result.first[:name]).to eq('John')
+      expect(result.first[:age]).to eq(31)
+      expect(result.last[:name]).to eq('Jack')
+      expect(result.last[:age]).to eq(42)
+    end
+  end
+  
+  describe YADM::Mapping::DSL do
+    describe '#data_source' do
+      let(:mapping) do
+        YADM::Mapping.new do
+          data_source :source
+        end
+      end
+      
+      it 'specifies the data source identifier' do
+        expect(mapping.data_source).to eq(identity_map)
+      end
+    end
+    
+    describe '#collection' do
+      let(:mapping) do
+        YADM::Mapping.new do
+          collection :people
+        end
+      end
+      
+      it 'specifies the collection' do
+        expect(mapping.collection).to eq(:people)
+      end
+    end
+    
+    describe '#attribute' do
+      let(:mapping) do
+        YADM::Mapping.new do
+          attribute :id, Integer
+        end
+      end
+      
+      it 'adds a new attribute' do
+        expect(mapping.attributes).to have_key(:id)
+        expect(mapping.attributes[:id]).to eq(YADM::Mapping::Attribute.new(Integer))
+      end
+    end
+  end
+end