perpetuity-postgres 0.0.7 → 0.0.8

data/spec/perpetuity/postgres/query_expression_spec.rb

@@ -8,82 +8,82 @@ module Perpetuity
 
       describe 'translation to SQL expressions' do
         it 'translates equality to symbol by comparing with a string' do
-          expression.to_db.should == "attribute = 'value'"
+          expect(expression.to_db).to be == "attribute = 'value'"
         end
 
         it 'translates equality to strings' do
           expression.value = expression.value.to_s
-          expression.to_db.should == "attribute = 'value'"
+          expect(expression.to_db).to be == "attribute = 'value'"
         end
 
         it 'removes SQL injection from strings' do
           expression.value = "' OR 1; --"
-          expression.to_db.should == "attribute = ''' OR 1; --'"
+          expect(expression.to_db).to be == "attribute = ''' OR 1; --'"
         end
 
         it 'translates equality to numbers' do
           expression.value = 1
-          expression.to_db.should == 'attribute = 1'
+          expect(expression.to_db).to be == 'attribute = 1'
         end
 
         it 'less-than expression' do
           expression.comparator = :<
-          expression.to_db.should == "attribute < 'value'"
+          expect(expression.to_db).to be == "attribute < 'value'"
         end
 
         it 'less-than-or-equal-to expression' do
           expression.comparator = :<=
-          expression.to_db.should == "attribute <= 'value'"
+          expect(expression.to_db).to be == "attribute <= 'value'"
         end
 
         it 'greater-than expression' do
           expression.comparator = :>
-          expression.to_db.should == "attribute > 'value'"
+          expect(expression.to_db).to be == "attribute > 'value'"
         end
 
         it 'greater-than-or-equal-to expression' do
           expression.comparator = :>=
-          expression.to_db.should == "attribute >= 'value'"
+          expect(expression.to_db).to be == "attribute >= 'value'"
         end
 
         it 'not-equal' do
           expression.comparator = :!=
-          expression.to_db.should == "attribute != 'value'"
+          expect(expression.to_db).to be == "attribute != 'value'"
         end
 
         it 'checks for inclusion' do
           expression.comparator = :in
           expression.value = [1, 2, 3]
-          expression.to_db.should == "attribute IN (1,2,3)"
+          expect(expression.to_db).to be == "attribute IN (1,2,3)"
         end
 
         it 'checks for inclusion in a range' do
           expression.comparator = :in
           expression.value = (1..3)
-          expression.to_db.should == "attribute BETWEEN 1 AND 3"
+          expect(expression.to_db).to be == "attribute BETWEEN 1 AND 3"
         end
 
         it 'checks for inclusion of strings' do
           expression.comparator = :in
           expression.value = ['abc', '123']
-          expression.to_db.should == "attribute IN ('abc','123')"
+          expect(expression.to_db).to be == "attribute IN ('abc','123')"
         end
 
         it 'checks for regexp matching' do
           expression.comparator = :=~
           expression.value = /value/
-          expression.to_db.should == "attribute ~ 'value'"
+          expect(expression.to_db).to be == "attribute ~ 'value'"
 
           expression.value = /value/i
-          expression.to_db.should == "attribute ~* 'value'"
+          expect(expression.to_db).to be == "attribute ~* 'value'"
         end
 
         it 'checks for nil' do
           expression.value = nil
-          expression.to_db.should == "attribute IS NULL"
+          expect(expression.to_db).to be == "attribute IS NULL"
 
           expression.comparator = :!=
-          expression.to_db.should == "attribute IS NOT NULL"
+          expect(expression.to_db).to be == "attribute IS NOT NULL"
         end
       end
 
@@ -92,7 +92,7 @@ module Perpetuity
         let(:rhs) { QueryExpression.new :second, :==, :two }
 
         it 'converts | to an $or query' do
-          (lhs | rhs).to_db.should == "(first = 'one' OR second = 'two')"
+          expect((lhs | rhs).to_db).to be == "(first = 'one' OR second = 'two')"
         end
       end
 
@@ -101,14 +101,14 @@ module Perpetuity
         let(:rhs) { QueryExpression.new :second, :==, :two }
 
         it 'converts & to an $and query' do
-          (lhs & rhs).to_db.should == "(first = 'one' AND second = 'two')"
+          expect((lhs & rhs).to_db).to be == "(first = 'one' AND second = 'two')"
         end
       end
 
       describe 'values' do
         it 'compares against times' do
           expression.value = Time.new(2013, 1, 2, 3, 4, 5.1234567, '-05:00')
-          expression.to_db.should == "attribute = '2013-01-02 03:04:05.123456-0500'::timestamptz"
+          expect(expression.to_db).to be == "attribute = '2013-01-02 03:04:05.123456-0500'::timestamptz"
         end
       end
     end

data/spec/perpetuity/postgres/query_intersection_spec.rb

@@ -8,15 +8,15 @@ module Perpetuity
       let(:intersection) { QueryIntersection.new(lhs, rhs) }
 
       it 'converts to a SQL "AND" expression' do
-        intersection.to_db.should == '(left = 1 AND right = 2)'
+        expect(intersection.to_db).to be == '(left = 1 AND right = 2)'
       end
 
       it 'allows intersections to have other intersections' do
-        (intersection&intersection).to_db.should == '((left = 1 AND right = 2) AND (left = 1 AND right = 2))'
+        expect((intersection&intersection).to_db).to be == '((left = 1 AND right = 2) AND (left = 1 AND right = 2))'
       end
 
       it 'allows intersections to have unions' do
-        (intersection|intersection).to_db.should == '((left = 1 AND right = 2) OR (left = 1 AND right = 2))'
+        expect((intersection|intersection).to_db).to be == '((left = 1 AND right = 2) OR (left = 1 AND right = 2))'
       end
     end
   end

data/spec/perpetuity/postgres/query_spec.rb

@@ -6,17 +6,17 @@ module Perpetuity
       let(:query) { Query.new { |o| o.name == 'foo' } }
 
       it 'generates an equality statement' do
-        query.to_db.should == "name = 'foo'"
+        expect(query.to_db).to be == "name = 'foo'"
       end
 
       it 'automatically converts to a string' do
         q = ''
         q << query
-        q.should == "name = 'foo'"
+        expect(q).to be == "name = 'foo'"
       end
 
       it 'returns TRUE with no block passed' do
-        Query.new.to_db.should == 'TRUE'
+        expect(Query.new.to_db).to be == 'TRUE'
       end
     end
   end

data/spec/perpetuity/postgres/query_union_spec.rb

@@ -8,15 +8,15 @@ module Perpetuity
       let(:union) { QueryUnion.new(lhs, rhs) }
 
       it 'converts to a SQL "OR" expression' do
-        union.to_db.should == '(left = 1 OR right = 2)'
+        expect(union.to_db).to be == '(left = 1 OR right = 2)'
       end
 
       it 'allows unions to have other unions' do
-        (union|union).to_db.should == '((left = 1 OR right = 2) OR (left = 1 OR right = 2))'
+        expect((union|union).to_db).to be == '((left = 1 OR right = 2) OR (left = 1 OR right = 2))'
       end
 
       it 'allows unions to have intersections' do
-        (union&union).to_db.should == '((left = 1 OR right = 2) AND (left = 1 OR right = 2))'
+        expect((union&union).to_db).to be == '((left = 1 OR right = 2) AND (left = 1 OR right = 2))'
       end
     end
   end

data/spec/perpetuity/postgres/serialized_data_spec.rb

@@ -8,19 +8,19 @@ module Perpetuity
       let(:serialized) { SerializedData.new(columns, data) }
 
       it 'matches a SQL string' do
-        serialized.to_s.should == "(name,age) VALUES ('Jamie',31)"
+        expect(serialized.to_s).to be == "(name,age) VALUES ('Jamie',31)"
       end
 
       describe 'adding values' do
         it 'adds a value' do
           serialized['id'] = 'abc'
-          serialized.to_s.should == "(name,age,id) VALUES ('Jamie',31,'abc')"
+          expect(serialized.to_s).to be == "(name,age,id) VALUES ('Jamie',31,'abc')"
         end
 
         it 'replaces an existing value' do
           serialized['id'] = 'abc'
           serialized['id'] = 'xyz'
-          serialized.to_s.should == "(name,age,id) VALUES ('Jamie',31,'xyz')"
+          expect(serialized.to_s).to be == "(name,age,id) VALUES ('Jamie',31,'xyz')"
         end
       end
 
@@ -33,39 +33,39 @@ module Perpetuity
         end
 
         it 'matches a SQL string' do
-          serialized_multiple.reduce(:+).to_s.should ==
+          expect(serialized_multiple.reduce(:+).to_s).to be ==
             "(name,age) VALUES ('Jamie',31),('Jessica',23),('Kevin',22)"
         end
 
         it 'does not modify the first value' do
           jamie_values = serialized_multiple.first.values.dup
           serialized_multiple.reduce(:+)
-          serialized_multiple.first.values.should == jamie_values
+          expect(serialized_multiple.first.values).to be == jamie_values
         end
       end
 
       it 'checks whether there are any objects' do
-        serialized.any?.should be_truthy
+        expect(serialized.any?).to be_truthy
         serialized.values.clear << []
-        serialized.any?.should be_falsey
+        expect(serialized.any?).to be_falsey
       end
 
       it 'iterates like a hash' do
-        serialized.map { |attr, value| [attr, value] }.should ==
+        expect(serialized.map { |attr, value| [attr, value] }).to be ==
           [['name', "'Jamie'"], ['age', 31]]
       end
 
       it 'accesses values like a hash' do
-        serialized['age'].should == 31
-        serialized[:age].should == 31
+        expect(serialized['age']).to be == 31
+        expect(serialized[:age]).to be == 31
       end
 
       it 'equals another with the same data' do
         original = SerializedData.new([:a, :b], [1, 2])
         duplicate = SerializedData.new([:a, :b], [1, 2])
         modified = SerializedData.new([:a, :b], [0, 2])
-        original.should == duplicate
-        original.should_not == modified
+        expect(original).to be == duplicate
+        expect(original).not_to be == modified
       end
 
       it 'returns a new SerializedData with the complement of values' do
@@ -73,8 +73,8 @@ module Perpetuity
         original = SerializedData.new(columns, ["'Jamie'", 31, nil, nil])
         new_name = SerializedData.new(columns, ["'Foo'", 31, nil, nil])
         new_age = SerializedData.new(columns, ["'Jamie'", 32, nil, nil])
-        (new_name - original).should == SerializedData.new([:name], ["'Foo'"])
-        (new_age - original).should == SerializedData.new([:age], [32])
+        expect((new_name - original)).to be == SerializedData.new([:name], ["'Foo'"])
+        expect((new_age - original)).to be == SerializedData.new([:age], [32])
       end
     end
   end

data/spec/perpetuity/postgres/serializer_spec.rb

@@ -27,7 +27,7 @@ module Perpetuity
       let(:serializer) { Serializer.new(book_mapper) }
 
       it 'serializes simple objects' do
-        serializer.serialize(Book.new('Foo')).to_s.should ==
+        expect(serializer.serialize(Book.new('Foo')).to_s).to be ==
           %q{(title,authors,main_character) VALUES ('Foo','[]',NULL)}
       end
 
@@ -42,7 +42,7 @@ module Perpetuity
         context 'with nested objects' do
           let(:book) { Book.new('Foo', jamie, character) }
           it 'converts objects into JSON' do
-            serializer.serialize(book).to_s.should ==
+            expect(serializer.serialize(book).to_s).to be ==
               %Q{(title,authors,main_character) VALUES ('Foo','#{jamie_json}','#{character_json}')}
           end
         end
@@ -51,7 +51,7 @@ module Perpetuity
           let(:book) { Book.new('Foo', [jamie], [character]) }
 
           it 'adds the JSON array' do
-            serializer.serialize(book).to_s.should ==
+            expect(serializer.serialize(book).to_s).to be ==
               %Q{(title,authors,main_character) VALUES ('Foo','[#{jamie_json}]','[#{character_json}]')}
           end
         end
@@ -59,39 +59,39 @@ module Perpetuity
 
       context 'with natively serializable values' do
         it 'serializes strings' do
-          serializer.serialize_attribute('string').should == "'string'"
+          expect(serializer.serialize_attribute('string')).to be == "'string'"
         end
 
         it 'serializes numbers' do
-          serializer.serialize_attribute(1).should == '1'
-          serializer.serialize_attribute(1.5).should == '1.5'
+          expect(serializer.serialize_attribute(1)).to be == '1'
+          expect(serializer.serialize_attribute(1.5)).to be == '1.5'
         end
 
         it 'serializes nil' do
-          serializer.serialize_attribute(nil).should == 'NULL'
+          expect(serializer.serialize_attribute(nil)).to be == 'NULL'
         end
 
         it 'serializes booleans' do
-          serializer.serialize_attribute(true).should == 'TRUE'
-          serializer.serialize_attribute(false).should == 'FALSE'
+          expect(serializer.serialize_attribute(true)).to be == 'TRUE'
+          expect(serializer.serialize_attribute(false)).to be == 'FALSE'
         end
 
         it 'serializes Time objects' do
           time = Time.new(2000, 1, 2, 3, 4, 5.123456, '-04:00')
-          serializer.serialize_attribute(time).should == "'2000-01-02 03:04:05.123456-0400'::timestamptz"
+          expect(serializer.serialize_attribute(time)).to be == "'2000-01-02 03:04:05.123456-0400'::timestamptz"
         end
 
         it 'serializes Date objects' do
           date = Date.new(2014, 8, 25)
-          serializer.serialize_attribute(date).should == "'2014-08-25'::date"
+          expect(serializer.serialize_attribute(date)).to be == "'2014-08-25'::date"
         end
 
         it 'serializes an array as JSON' do
-          serializer.serialize_attribute([1, 'foo']).should == %q{'[1,"foo"]'}
+          expect(serializer.serialize_attribute([1, 'foo'])).to be == %q{'[1,"foo"]'}
         end
 
         it 'serializes a hash as JSON' do
-          serializer.serialize_attribute(a: 1, foo: ['bar']).should == %q{'{"a":1,"foo":["bar"]}'}
+          expect(serializer.serialize_attribute(a: 1, foo: ['bar'])).to be == %q{'{"a":1,"foo":["bar"]}'}
         end
       end
 
@@ -114,7 +114,7 @@ module Perpetuity
           }].to_json
           serialized_book['authors'] = serialized_authors
           book = Book.new('My Book', [author])
-          serializer.unserialize(serialized_book).should == book
+          expect(serializer.unserialize(serialized_book)).to be == book
         end
 
         it 'deserializes an object which references another object' do
@@ -125,7 +125,7 @@ module Perpetuity
             }
           }.to_json
           deserialized_book = Book.new('My Book', [], Reference.new(Person, 'id-id-id'))
-          serializer.unserialize(serialized_book).should == deserialized_book
+          expect(serializer.unserialize(serialized_book)).to be == deserialized_book
         end
 
         let(:article_class) do
@@ -180,31 +180,31 @@ module Perpetuity
             published_at: Time.new(2013, 1, 2, 3, 4, 5.123456, '-05:00'),
             published: true
           )
-          serializer.unserialize(serialized_article).should == article
+          expect(serializer.unserialize(serialized_article)).to be == article
         end
       end
 
       describe 'identifying embedded/referenced objects as foreign' do
         it 'sees hashes with metadata keys as foreign objects' do
-          serializer.foreign_object?({'__metadata__' => 'lol'}).should be_truthy
+          expect(serializer.foreign_object?({'__metadata__' => 'lol'})).to be_truthy
         end
 
         it 'sees hashes without metadata keys as simple hashes' do
-          serializer.foreign_object?({ 'name' => 'foo' }).should be_falsey
+          expect(serializer.foreign_object?({ 'name' => 'foo' })).to be_falsey
         end
       end
 
       describe 'identifying possible JSON strings' do
         it 'identifies JSON objects' do
-          serializer.possible_json_value?('{"name":"foo"}').should be_truthy
+          expect(serializer.possible_json_value?('{"name":"foo"}')).to be_truthy
         end
 
         it 'identifies JSON arrays' do
-          serializer.possible_json_value?('[{"name":"foo"}]').should be_truthy
+          expect(serializer.possible_json_value?('[{"name":"foo"}]')).to be_truthy
         end
 
         it 'rejects things it does not detect as either of the above' do
-          serializer.possible_json_value?('foo is my name').should be_falsey
+          expect(serializer.possible_json_value?('foo is my name')).to be_falsey
         end
       end
 
@@ -212,13 +212,13 @@ module Perpetuity
         original = Book.new('Old title')
         modified = original.dup
         modified.title = 'New title'
-        serializer.serialize_changes(modified, original).should ==
+        expect(serializer.serialize_changes(modified, original)).to be ==
           SerializedData.new([:title], ["'New title'"])
       end
 
       it 'serializes a reference as its referenced class' do
         reference = Reference.new(Object, 123)
-        serializer.serialize_reference(reference).should == JSONHash.new(
+        expect(serializer.serialize_reference(reference)).to be == JSONHash.new(
           __metadata__: {
             class: Object,
             id: 123

data/spec/perpetuity/postgres/sql_function_spec.rb

@@ -5,12 +5,12 @@ module Perpetuity
     describe SQLFunction do
       it 'converts to a SQL function call' do
         function = SQLFunction.new('json_array_length', :comments)
-        function.to_s.should == 'json_array_length(comments)'
+        expect(function.to_s).to be == 'json_array_length(comments)'
       end
 
       it 'takes multiple arguments' do
         function = SQLFunction.new('compare', :a, :b)
-        function.to_s.should == 'compare(a,b)'
+        expect(function.to_s).to be == 'compare(a,b)'
       end
     end
   end

data/spec/perpetuity/postgres/sql_select_spec.rb

@@ -9,50 +9,50 @@ module Perpetuity
       subject { query }
 
       it 'returns its table name' do
-        query.table.should == 'foo'
+        expect(query.table).to be == 'foo'
       end
 
       it 'returns its WHERE clause' do
-        query.where.should == "name = 'foo'"
+        expect(query.where).to be == "name = 'foo'"
       end
 
       it 'returns its limit' do
-        query.limit.should == 4
+        expect(query.limit).to be == 4
       end
 
       it 'generates a SQL query' do
-        query.to_s.should == %Q{SELECT * FROM "foo" WHERE name = 'foo' LIMIT 4}
+        expect(query.to_s).to be == %Q{SELECT * FROM "foo" WHERE name = 'foo' LIMIT 4}
       end
 
       it 'generates a query with no clauses' do
         sql = SQLSelect.new(from: 'foo').to_s
-        sql.should == %Q{SELECT * FROM "foo"}
+        expect(sql).to be == %Q{SELECT * FROM "foo"}
       end
 
       it 'generates a count query' do
         sql = SQLSelect.new('COUNT(*)', from: 'foo').to_s
-        sql.should == %Q{SELECT COUNT(*) FROM "foo"}
+        expect(sql).to be == %Q{SELECT COUNT(*) FROM "foo"}
       end
 
       it 'generates a query with an ORDER BY clause' do
         sql = SQLSelect.new(from: 'foo', order: 'name').to_s
-        sql.should == %Q{SELECT * FROM "foo" ORDER BY name}
+        expect(sql).to be == %Q{SELECT * FROM "foo" ORDER BY name}
 
         sql = SQLSelect.new(from: 'foo', order: { name: :asc }).to_s
-        sql.should == %Q{SELECT * FROM "foo" ORDER BY name ASC}
+        expect(sql).to be == %Q{SELECT * FROM "foo" ORDER BY name ASC}
 
         sql = SQLSelect.new(from: 'foo', order: { name: :asc, age: :desc }).to_s
-        sql.should == %Q{SELECT * FROM "foo" ORDER BY name ASC,age DESC}
+        expect(sql).to be == %Q{SELECT * FROM "foo" ORDER BY name ASC,age DESC}
       end
 
       it 'generates a query with an OFFSET clause' do
         sql = SQLSelect.new(from: 'foo', offset: 12).to_s
-        sql.should == %Q{SELECT * FROM "foo" OFFSET 12}
+        expect(sql).to be == %Q{SELECT * FROM "foo" OFFSET 12}
       end
 
       it 'generates a query with a GROUP BY clause' do
         sql = SQLSelect.new(from: 'foo', group: :id).to_s
-        sql.should == %Q{SELECT * FROM "foo" GROUP BY id}
+        expect(sql).to be == %Q{SELECT * FROM "foo" GROUP BY id}
       end
     end
   end

data/spec/perpetuity/postgres/sql_update_spec.rb

@@ -7,14 +7,14 @@ module Perpetuity
       context 'when given a SerializedData' do
         it 'generates the SQL to update an object' do
           update = SQLUpdate.new('User', 'abc123', SerializedData.new([:foo, :baz], ["'bar'", "'quux'"]))
-          update.to_s.should == %Q{UPDATE "User" SET foo = 'bar',baz = 'quux' WHERE id = 'abc123'}
+          expect(update.to_s).to be == %Q{UPDATE "User" SET foo = 'bar',baz = 'quux' WHERE id = 'abc123'}
         end
       end
 
       context 'when given a hash' do
         it 'sanitizes the data into SQLValues' do
           update = SQLUpdate.new('User', 'abc123', foo: 'bar', baz: 'quux')
-          update.to_s.should == %Q{UPDATE "User" SET foo = 'bar',baz = 'quux' WHERE id = 'abc123'}
+          expect(update.to_s).to be == %Q{UPDATE "User" SET foo = 'bar',baz = 'quux' WHERE id = 'abc123'}
         end
       end
     end

data/spec/perpetuity/postgres/sql_value_spec.rb

@@ -4,56 +4,56 @@ module Perpetuity
   class Postgres
     describe SQLValue do
       it 'converts strings' do
-        SQLValue.new('Foo').should == "'Foo'"
-        SQLValue.new("Jamie's House").should == "'Jamie''s House'"
+        expect(SQLValue.new('Foo')).to be == "'Foo'"
+        expect(SQLValue.new("Jamie's House")).to be == "'Jamie''s House'"
       end
 
       it 'converts symbols' do
-        SQLValue.new(:foo).should == "'foo'"
+        expect(SQLValue.new(:foo)).to be == "'foo'"
       end
 
       it 'converts integers' do
-        SQLValue.new(1).should == "1"
+        expect(SQLValue.new(1)).to be == "1"
       end
 
       it 'converts floats' do
-        SQLValue.new(1.5).should == "1.5"
+        expect(SQLValue.new(1.5)).to be == "1.5"
       end
 
       it 'converts nil' do
-        SQLValue.new(nil).should == "NULL"
+        expect(SQLValue.new(nil)).to be == "NULL"
       end
 
       it 'converts booleans' do
-        SQLValue.new(true).should == "TRUE"
-        SQLValue.new(false).should == "FALSE"
+        expect(SQLValue.new(true)).to be == "TRUE"
+        expect(SQLValue.new(false)).to be == "FALSE"
       end
 
       it 'converts hashes' do
-        SQLValue.new({ a: 1, b: 'foo'}).should == %q({"a":1,"b":"foo"})
+        expect(SQLValue.new({ a: 1, b: 'foo'})).to be == %q({"a":1,"b":"foo"})
       end
 
       it 'converts arrays' do
-        SQLValue.new([1, 'foo', { a: 1 }]).should == %q([1,"foo",{"a":1}])
+        expect(SQLValue.new([1, 'foo', { a: 1 }])).to be == %q([1,"foo",{"a":1}])
       end
 
       it 'converts JSONHashes' do
-        SQLValue.new(JSONHash.new(a: 1)).should == %q({"a":1})
+        expect(SQLValue.new(JSONHash.new(a: 1))).to be == %q({"a":1})
       end
 
       it 'converts JSONArrays' do
-        SQLValue.new(JSONArray.new([1, 'foo', [1, 'foo']])).should ==
+        expect(SQLValue.new(JSONArray.new([1, 'foo', [1, 'foo']]))).to be ==
           %q([1,"foo",[1,"foo"]])
       end
 
       it 'converts Time objects' do
         time = Time.new(2013, 1, 2, 3, 4, 5.1234567, '+05:30')
-        SQLValue.new(time).should == "'2013-01-02 03:04:05.123456+0530'::timestamptz"
+        expect(SQLValue.new(time)).to be == "'2013-01-02 03:04:05.123456+0530'::timestamptz"
       end
 
       it 'converts Date objects' do
         date = Date.new(2014, 8, 25)
-        SQLValue.new(date).should == "'2014-08-25'::date"
+        expect(SQLValue.new(date)).to be == "'2014-08-25'::date"
       end
     end
   end