perpetuity 0.7.3 → 1.0.0.beta

data/spec/perpetuity/mongodb/query_intersection_spec.rb

@@ -1,16 +0,0 @@
-require 'perpetuity/mongodb/query_intersection'
-require 'perpetuity/mongodb/query_expression'
-
-module Perpetuity
-  class MongoDB
-    describe QueryIntersection do
-      let(:lhs) { QueryExpression.new :first, :equals, 'one' }
-      let(:rhs) { QueryExpression.new :second, :equals, 'two' }
-      let(:intersection) { QueryIntersection.new lhs, rhs }
-
-      it 'returns a Mongo representation of the union of 2 expressions' do
-        intersection.to_db.should be == { '$and' => [{first: 'one'}, {second: 'two'}] }
-      end
-    end
-  end
-end

data/spec/perpetuity/mongodb/query_spec.rb

@@ -1,79 +0,0 @@
-require 'perpetuity/mongodb/query'
-
-module Perpetuity
-  describe MongoDB::Query do
-    let(:query) { MongoDB::Query }
-
-    it 'generates Mongo equality expressions' do
-      query.new{ |user| user.name == 'Jamie' }.to_db.should == {name: 'Jamie'}
-    end
-
-    it 'generates Mongo less-than expressions' do
-      query.new{ |v| v.quantity < 10 }.to_db.should == {quantity: { '$lt' => 10}}
-    end
-
-    it 'generates Mongo less-than-or-equal expressions' do
-      query.new{ |v| v.quantity <= 10 }.to_db.should == {quantity: { '$lte' => 10}}
-    end
-
-    it 'generates Mongo greater-than expressions' do
-      query.new{ |v| v.quantity > 10 }.to_db.should == {quantity: { '$gt' => 10}}
-    end
-
-    it 'generates Mongo greater-than-or-equal expressions' do
-      query.new{ |v| v.quantity >= 10 }.to_db.should == {quantity: { '$gte' => 10}}
-    end
-
-    it 'generates Mongo inequality expressions' do
-      query.new{ |user| user.name.not_equal? 'Jamie' }.to_db.should == {
-        name: {'$ne' => 'Jamie'}
-      }
-    end
-
-    it 'generates Mongo regexp expressions' do
-      query.new{ |user| user.name =~ /Jamie/ }.to_db.should == {name: /Jamie/}
-    end
-
-    describe 'negated queries' do
-      it 'negates an equality query' do
-        q = query.new { |user| user.name == 'Jamie' }
-        q.negate.to_db.should == { name: { '$ne' => 'Jamie' } }
-      end
-
-      it 'negates a not-equal query' do
-        q = query.new { |account| account.balance != 10 }
-        q.negate.to_db.should == { balance: { '$not' => { '$ne' => 10 } } }
-      end
-
-      it 'negates a less-than query' do
-        q = query.new { |account| account.balance < 10 }
-        q.negate.to_db.should == { balance: { '$not' => { '$lt' => 10 } } }
-      end
-
-      it 'negates a less-than-or-equal query' do
-        q = query.new { |account| account.balance <= 10 }
-        q.negate.to_db.should == { balance: { '$not' => { '$lte' => 10 } } }
-      end
-
-      it 'negates a greater-than query' do
-        q = query.new { |account| account.balance > 10 }
-        q.negate.to_db.should == { balance: { '$not' => { '$gt' => 10 } } }
-      end
-
-      it 'negates a greater-than-or-equal query' do
-        q = query.new { |account| account.balance >= 10 }
-        q.negate.to_db.should == { balance: { '$not' => { '$gte' => 10 } } }
-      end
-
-      it 'negates a regex query' do
-        q = query.new { |account| account.name =~ /Jamie/ }
-        q.negate.to_db.should == { name: { '$not' => /Jamie/ } }
-      end
-
-      it 'negates a inclusion query' do
-        q = query.new { |article| article.tags.in ['tag1', 'tag2'] }
-        q.negate.to_db.should == { tags: { '$not' => { '$in' => ['tag1', 'tag2'] } } }
-      end
-    end
-  end
-end

data/spec/perpetuity/mongodb/query_union_spec.rb

@@ -1,16 +0,0 @@
-require 'perpetuity/mongodb/query_union'
-require 'perpetuity/mongodb/query_expression'
-
-module Perpetuity
-  class MongoDB
-    describe QueryUnion do
-      let(:lhs) { QueryExpression.new :first, :equals, 'one' }
-      let(:rhs) { QueryExpression.new :second, :equals, 'two' }
-      let(:union) { QueryUnion.new lhs, rhs }
-
-      it 'returns the proper union of two expressions' do
-        union.to_db.should be == { '$or' => [{first: 'one'}, {second: 'two'}] }
-      end
-    end
-  end
-end

data/spec/perpetuity/mongodb/serializer_spec.rb

@@ -1,212 +0,0 @@
-require 'perpetuity/mongodb/serializer'
-require 'perpetuity/mapper'
-require 'perpetuity/mapper_registry'
-require 'support/test_classes/book'
-require 'support/test_classes/user'
-require 'support/test_classes/car'
-
-module Perpetuity
-  class MongoDB
-    describe Serializer do
-      let(:dave) { User.new('Dave') }
-      let(:andy) { User.new('Andy') }
-      let(:authors) { [dave, andy] }
-      let(:book) { Book.new('The Pragmatic Programmer', authors) }
-      let(:mapper_registry) { MapperRegistry.new }
-      let(:book_mapper) do
-        registry = mapper_registry
-        Class.new(Perpetuity::Mapper) do
-          map Book, registry
-          attribute :title
-          attribute :authors
-        end.new(registry)
-      end
-      let(:user_mapper) do
-        registry = mapper_registry
-        Class.new(Perpetuity::Mapper) do
-          map User, registry
-          attribute :name
-        end.new(registry)
-      end
-      let(:data_source) { double('Data Source') }
-      let(:serializer) { Serializer.new(book_mapper) }
-
-      before do
-        serializer.give_id_to dave, 1
-        serializer.give_id_to andy, 2
-      end
-
-      it 'serializes an array of non-embedded attributes as references' do
-        user_mapper.stub(data_source: data_source)
-        book_mapper.stub(data_source: data_source)
-        data_source.should_receive(:can_serialize?).with(book.title).and_return true
-        data_source.should_receive(:can_serialize?).with(dave).and_return false
-        data_source.should_receive(:can_serialize?).with(andy).and_return false
-        serializer.serialize(book).should be == {
-          'title' => book.title,
-          'authors' => [
-            {
-              '__metadata__' => {
-                'class' => 'User',
-                'id' => user_mapper.id_for(dave)
-              }
-            },
-            {
-              '__metadata__' => {
-                'class' => 'User',
-                'id' => user_mapper.id_for(andy)
-              }
-            }
-          ]
-        }
-      end
-
-      it 'can serialize only changed attributes' do
-        book = Book.new('Original Title')
-        updated_book = book.dup
-        updated_book.title = 'New Title'
-        book_mapper.stub(data_source: data_source)
-        data_source.stub(:can_serialize?).with('New Title') { true }
-        data_source.stub(:can_serialize?).with('Original Title') { true }
-        serializer.serialize_changes(updated_book, book).should == {
-          'title' => 'New Title'
-        }
-      end
-
-      context 'with objects that have hashes as attributes' do
-        let(:name_data) { {first_name: 'Jamie', last_name: 'Gaskins'} }
-        let(:serialized_data) { { 'name' => name_data } }
-        let(:user) { User.new(name_data) }
-        let(:user_serializer) { Serializer.new(user_mapper) }
-
-        before do
-          user_mapper.stub(data_source: data_source)
-          book_mapper.stub(data_source: data_source)
-          data_source.stub(:can_serialize?).with(name_data) { true }
-        end
-
-        it 'serializes' do
-          user_serializer.serialize(user).should be == serialized_data
-        end
-
-        it 'unserializes' do
-          user_serializer.unserialize(serialized_data).name.should be == user.name
-        end
-      end
-
-      describe 'with an array of references' do
-        let(:author) { Reference.new(User, 1) }
-        let(:title) { 'title' }
-        let(:book) { Book.new(title, [author]) }
-
-        before do
-          user_mapper.stub(data_source: data_source)
-          book_mapper.stub(data_source: data_source)
-        end
-
-        it 'passes the reference unserialized' do
-          data_source.should_receive(:can_serialize?).with('title') { true }
-          serializer.serialize(book).should == {
-            'title' => title,
-            'authors' => [{
-              '__metadata__' => {
-                'class' => author.klass.to_s,
-                'id' => author.id
-              }
-            }]
-          }
-        end
-      end
-
-      context 'with uninitialized attributes' do
-        let(:car_model) { 'Corvette' }
-        let(:car) { Car.new(model: car_model) }
-        let(:mapper) do
-          registry = mapper_registry
-          Class.new(Mapper) do
-            map Car, registry
-
-            attribute :make
-            attribute :model
-          end.new(registry)
-        end
-        let(:serializer) { Serializer.new(mapper) }
-
-
-        it 'does not persist uninitialized attributes' do
-          mapper.stub data_source: data_source
-          data_source.should_receive(:can_serialize?).with(car_model) { true }
-
-          serializer.serialize(car).should == { 'model' => car_model }
-        end
-      end
-
-      context 'with marshaled data' do
-        let(:unserializable_value) { 1..10 }
-
-        it 'stores metadata with marshal information' do
-          book = Book.new(unserializable_value)
-
-          book_mapper.stub(data_source: data_source)
-          data_source.stub(:can_serialize?).with(book.title) { false }
-
-          serializer.serialize(book).should == {
-            'title' => {
-              '__marshaled__' => true,
-              'value' => Marshal.dump(unserializable_value)
-            },
-            'authors' => []
-          }
-        end
-
-        it 'stores marshaled attributes within arrays' do
-          book = Book.new([unserializable_value])
-          book_mapper.stub(data_source: data_source)
-          data_source.stub(:can_serialize?).with(book.title.first) { false }
-
-          serializer.serialize(book).should == {
-            'title' => [{
-              '__marshaled__' => true,
-              'value' => Marshal.dump(unserializable_value)
-            }],
-            'authors' => []
-          }
-        end
-
-        it 'unmarshals data that has been marshaled by the serializer' do
-          data = {
-            'title' => {
-              '__marshaled__' => true,
-              'value' => Marshal.dump(unserializable_value),
-            }
-          }
-          serializer.unserialize(data).title.should be_a unserializable_value.class
-        end
-
-        it 'does not unmarshal data not marshaled by the serializer' do
-          data = { 'title' => Marshal.dump(unserializable_value) }
-
-          serializer.unserialize(data).title.should be_a String
-        end
-      end
-
-      it 'unserializes a hash of primitives' do
-        time = Time.now
-        serialized_data = {
-          'number' => 1,
-          'string' => 'hello',
-          'boolean' => true,
-          'float' => 7.5,
-          'time' => time
-        }
-
-        object = serializer.unserialize(serialized_data)
-        object.instance_variable_get(:@number).should == 1
-        object.instance_variable_get(:@string).should == 'hello'
-        object.instance_variable_get(:@boolean).should == true
-        object.instance_variable_get(:@float).should == 7.5
-        object.instance_variable_get(:@time).should == time
-      end
-    end
-  end
-end

data/spec/perpetuity/validations/length_spec.rb

@@ -1,53 +0,0 @@
-require 'perpetuity/validations/length'
-
-module Perpetuity
-  module Validations
-    describe Length do
-      let(:length) { Length.new :to_s, {}}
-
-      describe 'minimum length' do
-        before { length.at_least 4 }
-
-        it 'invalidates' do
-          length.pass?('abc').should be false
-        end
-
-        it 'validates' do
-          length.pass?('abcd').should be true
-        end
-      end
-
-      describe 'maximum length' do
-        before { length.at_most 4 }
-
-        it 'validates' do
-          length.pass?('abcd').should be true
-        end
-
-        it 'invalidates' do
-          length.pass?('abcde').should be false
-        end
-      end
-
-      describe 'ranges' do
-        before { length.between 4..5 }
-
-        it 'invalidates values too short' do
-          length.pass?('abc').should be false
-        end
-
-        it 'validates lengths at the low end' do
-          length.pass?('abcd').should be true
-        end
-
-        it 'validates lengths at the high end' do
-          length.pass?('abcde').should be true
-        end
-
-        it 'invalidates values too long' do
-          length.pass?('abcdef').should be false
-        end
-      end
-    end
-  end
-end

data/spec/perpetuity/validations/presence_spec.rb

@@ -1,30 +0,0 @@
-require 'perpetuity/validations/presence'
-
-module Perpetuity
-  module Validations
-    describe Presence do
-      let(:presence) { Presence.new :to_s }
-      let(:valid) { double('valid object') }
-      let(:invalid) { double('invalid object') }
-
-      it 'validates values that are present' do
-        presence.pass?(valid).should be_true
-      end
-
-      it 'invalidates nil values' do
-        invalid.stub(to_s: nil)
-        presence.pass?(invalid).should be_false
-      end
-
-      it 'invalidates empty strings' do
-        invalid.stub(to_s: '')
-        presence.pass?(invalid).should be_false
-      end
-
-      it 'invalidates strings with only whitespace' do
-        invalid.stub(to_s: ' ')
-        presence.pass?(invalid).should be_false
-      end
-    end
-  end
-end

data/spec/perpetuity/validations_spec.rb

@@ -1,87 +0,0 @@
-require 'perpetuity/validations'
-
-module Perpetuity
-  describe ValidationSet do
-    let(:validation_set) { ValidationSet.new }
-    it 'is empty when created' do
-      validation_set.should be_empty
-    end
-
-    it 'can add validations' do
-      v = double('validation')
-      validation_set << v
-
-      validation_set.first.should == v
-    end
-
-    it 'validates an object' do
-      v = double('validation')
-      v.stub(pass?: true)
-      validation_set << v
-
-      validation_set.should be_valid(double('object'))
-    end
-
-    it 'invalidates an object' do
-      v = double('validation')
-      v.stub(pass?: false)
-      validation_set << v
-
-      validation_set.should_not be_valid(double('object'))
-    end
-
-    describe 'validation types' do
-      let(:valid_object) { double('valid object') }
-      let(:invalid_object) { double('invalid object') }
-
-      it 'validates presence of an attribute' do
-        valid_object.stub(email: 'me@example.com')
-        validation_set.present :email
-
-        validation_set.count.should eq 1
-        validation_set.should be_valid(valid_object)
-      end
-
-      it 'validates length of an attribute' do
-        valid_object.stub(email: 'me@example.com')
-        validation_set.length :email, at_most: 14
-        validation_set.length :email, at_least: 14
-
-        validation_set.count.should eq 2
-        validation_set.should be_valid(valid_object)
-      end
-
-      it 'validates length within a range' do
-        valid_object.stub(email: 'me@example.com')
-        validation_set.length :email, between: (14..14)
-
-        validation_set.should have(1).items
-        validation_set.should be_valid(valid_object)
-      end
-
-      it 'invalidates length within a range' do
-        invalid_object.stub(email: 'me@example.com')
-        validation_set.length :email, between: (0..13)
-
-        validation_set.should have(1).items
-        validation_set.should be_invalid(invalid_object)
-      end
-
-      it 'invalidates when attribute is too short' do
-        invalid_object.stub(email: 'foo')
-        validation_set.length :email, at_least: 4
-
-        validation_set.count.should eq 1
-        validation_set.should be_invalid(invalid_object)
-      end
-
-      it 'invalidates when attribute is too long' do
-        invalid_object.stub(email: 'me@example.com')
-        subject.length :email, at_most: 4
-
-        subject.count.should eq 1
-        subject.should be_invalid(invalid_object)
-      end
-    end
-  end
-end