perpetuity-postgres 0.0.7 → 0.0.8

data/spec/perpetuity/postgres/table/attribute_spec.rb

@@ -8,11 +8,11 @@ module Perpetuity
         let(:title)  { Attribute.new('title', String) }
 
         it 'knows its name' do
-          title.name.should == 'title'
+          expect(title.name).to be == 'title'
         end
 
         it 'knows its type' do
-          title.type.should == String
+          expect(title.type).to be == String
         end
 
         describe 'id' do
@@ -24,19 +24,19 @@ module Perpetuity
           end
 
           it 'is a UUID type' do
-            id.sql_type.should == 'UUID'
+            expect(id.sql_type).to be == 'UUID'
           end
 
           it 'is a primary key' do
-            id.should be_primary_key
+            expect(id).to be_primary_key
           end
 
           it 'can have a specified default' do
-            id.default.should == Expression.new('uuid_generate_v4()')
+            expect(id.default).to be == Expression.new('uuid_generate_v4()')
           end
 
           it 'generates the proper SQL' do
-            id.sql_declaration.should == 'id UUID PRIMARY KEY DEFAULT uuid_generate_v4()'
+            expect(id.sql_declaration).to be == 'id UUID PRIMARY KEY DEFAULT uuid_generate_v4()'
           end
         end
 
@@ -44,11 +44,11 @@ module Perpetuity
           let(:body) { Attribute.new('body', String, default: 'foo') }
 
           it 'converts to the proper SQL type' do
-            body.sql_type.should == 'TEXT'
+            expect(body.sql_type).to be == 'TEXT'
           end
 
           it 'generates the proper SQL' do
-            body.sql_declaration.should == "body TEXT DEFAULT 'foo'"
+            expect(body.sql_declaration).to be == "body TEXT DEFAULT 'foo'"
           end
         end
 
@@ -57,8 +57,8 @@ module Perpetuity
           let(:public_key) { Attribute.new('public_key', Bignum) }
 
           it 'generates the proper SQL' do
-            page_views.sql_declaration.should == 'page_views BIGINT DEFAULT 0'
-            public_key.sql_declaration.should == 'public_key NUMERIC'
+            expect(page_views.sql_declaration).to be == 'page_views BIGINT DEFAULT 0'
+            expect(public_key.sql_declaration).to be == 'public_key NUMERIC'
           end
         end
 
@@ -67,8 +67,8 @@ module Perpetuity
           let(:precise_pi) { Attribute.new('precise_pi', BigDecimal) }
 
           it 'generates the proper SQL' do
-            pi.sql_declaration.should == 'pi FLOAT'
-            precise_pi.sql_declaration.should == 'precise_pi NUMERIC'
+            expect(pi.sql_declaration).to be == 'pi FLOAT'
+            expect(precise_pi.sql_declaration).to be == 'precise_pi NUMERIC'
           end
         end
 
@@ -76,7 +76,7 @@ module Perpetuity
           let(:timestamp) { Attribute.new('timestamp', Time) }
 
           it 'converts to the SQL TIMESTAMPTZ type' do
-            timestamp.sql_type.should == 'TIMESTAMPTZ'
+            expect(timestamp.sql_type).to be == 'TIMESTAMPTZ'
           end
         end
 
@@ -84,14 +84,14 @@ module Perpetuity
           let(:date) { Attribute.new('anniversary_date', Date) }
 
           it 'converts to the SQL DATE type' do
-            date.sql_type.should == 'DATE'
+            expect(date.sql_type).to be == 'DATE'
           end
         end
 
         describe 'booleans' do
           it 'is stored in a BOOLEAN column' do
-            Attribute.new(:true,  TrueClass).sql_type.should == 'BOOLEAN'
-            Attribute.new(:false, FalseClass).sql_type.should == 'BOOLEAN'
+            expect(Attribute.new(:true,  TrueClass).sql_type).to be == 'BOOLEAN'
+            expect(Attribute.new(:false, FalseClass).sql_type).to be == 'BOOLEAN'
           end
         end
 
@@ -99,7 +99,7 @@ module Perpetuity
           let(:author) { Attribute.new('author', Object) }
 
           it 'has an SQL type of JSON' do
-            author.sql_type.should == 'JSON'
+            expect(author.sql_type).to be == 'JSON'
           end
         end
       end

data/spec/perpetuity/postgres/table_name_spec.rb

@@ -4,7 +4,7 @@ module Perpetuity
   class Postgres
     describe TableName do
       it 'converts to a SQL-string table name' do
-        TableName.new('Person').to_s.should == '"Person"'
+        expect(TableName.new('Person').to_s).to be == '"Person"'
       end
 
       it 'cannot contain double quotes' do
@@ -12,7 +12,7 @@ module Perpetuity
       end
 
       it 'compares equally to its string representation' do
-        TableName.new('Person').should == 'Person'
+        expect(TableName.new('Person')).to be == 'Person'
       end
     end
   end

data/spec/perpetuity/postgres/table_spec.rb

@@ -13,19 +13,19 @@ module Perpetuity
       let(:table) { Table.new('Article', attributes) }
 
       it 'knows its name' do
-        table.name.should == 'Article'
+        expect(table.name).to be == 'Article'
       end
 
       it 'knows its attributes' do
-        table.attributes.should == attributes
+        expect(table.attributes).to be == attributes
       end
 
       it 'converts to a string for SQL' do
-        table.to_s.should == '"Article"'
+        expect(table.to_s).to be == '"Article"'
       end
 
       it 'generates proper SQL to create itself' do
-        table.create_table_sql.should ==
+        expect(table.create_table_sql).to be ==
           'CREATE TABLE IF NOT EXISTS "Article" (id UUID PRIMARY KEY DEFAULT uuid_generate_v4(), title TEXT, body TEXT, author JSON, published_at TIMESTAMPTZ, views BIGINT)'
       end
 
@@ -33,7 +33,7 @@ module Perpetuity
         attributes = self.attributes.dup
         attributes.unshift Table::Attribute.new(:id, String)
         table = Table.new('Article', attributes)
-        table.create_table_sql.should ==
+        expect(table.create_table_sql).to be ==
           'CREATE TABLE IF NOT EXISTS "Article" (id TEXT PRIMARY KEY, title TEXT, body TEXT, author JSON, published_at TIMESTAMPTZ, views BIGINT)'
       end
 
@@ -42,7 +42,7 @@ module Perpetuity
           it 'uses the attribute type for the column type' do
             attributes = [Table::Attribute.new(:id, String, primary_key: true), Table::Attribute.new(:name, String)]
             table = Table.new('User', attributes)
-            table.create_table_sql.should == 'CREATE TABLE IF NOT EXISTS "User" (id TEXT PRIMARY KEY, name TEXT)'
+            expect(table.create_table_sql).to be == 'CREATE TABLE IF NOT EXISTS "User" (id TEXT PRIMARY KEY, name TEXT)'
           end
         end
       end

data/spec/perpetuity/postgres/text_value_spec.rb

@@ -4,11 +4,11 @@ module Perpetuity
   class Postgres
     describe TextValue do
       it 'serializes into a Postgres-compatible string' do
-        TextValue.new('Jamie').to_s.should == "'Jamie'"
+        expect(TextValue.new('Jamie').to_s).to be == "'Jamie'"
       end
 
       it 'escapes single quotes' do
-        TextValue.new("Jamie's house").to_s.should == "'Jamie''s house'"
+        expect(TextValue.new("Jamie's house").to_s).to be == "'Jamie''s house'"
       end
     end
   end

data/spec/perpetuity/postgres/timestamp_value_spec.rb

@@ -5,25 +5,25 @@ module Perpetuity
     describe TimestampValue do
       it 'converts to a SQL string' do
         time = Time.new(2000, 1, 2, 3, 4, 5.0123456, '-04:00')
-        TimestampValue.new(time).to_s.should == "'2000-01-02 03:04:05.012345-0400'::timestamptz"
+        expect(TimestampValue.new(time).to_s).to be == "'2000-01-02 03:04:05.012345-0400'::timestamptz"
       end
 
       describe 'conversion from a SQL value string' do
         it 'converts GMT-X times' do
           actual = TimestampValue.from_sql('2013-12-01 15:31:23.838367-05')
           expected = Time.new(2013, 12, 1, 15, 31, 23.838367, '-05:00')
-          actual.to_time.should be_within(0.0000001).of expected
+          expect(actual.to_time).to be_within(0.0000001).of expected
         end
 
         it 'converts GMT+X times' do
           actual = TimestampValue.from_sql('1982-08-25 22:19:10.123456+08')
           expected = Time.new(1982, 8, 25, 10, 19, 10.123456, '-04:00')
-          actual.to_time.should be_within(0.0000001).of expected
+          expect(actual.to_time).to be_within(0.0000001).of expected
         end
       end
 
       it 'returns its wrapped value' do
-        TimestampValue.new(:foo).value.should == :foo
+        expect(TimestampValue.new(:foo).value).to be == :foo
       end
     end
   end

data/spec/perpetuity/postgres/value_with_attribute_spec.rb

@@ -8,18 +8,18 @@ module Perpetuity
       let(:serialized) { ValueWithAttribute.new('foo', attribute) }
 
       it 'contains a value and an attribute' do
-        serialized.value.should == 'foo'
-        serialized.attribute.should == attribute
+        expect(serialized.value).to be == 'foo'
+        expect(serialized.attribute).to be == attribute
       end
 
       it 'knows its type' do
-        serialized.type.should be String
+        expect(serialized.type).to be String
       end
 
       context 'when attribute is embedded' do
         let(:attribute) { OpenStruct.new(embedded?: true) }
         it 'is embedded' do
-          serialized.should be_embedded
+          expect(serialized).to be_embedded
         end
       end
 
@@ -27,12 +27,12 @@ module Perpetuity
         let(:attribute) { OpenStruct.new(embedded?: false) }
 
         it 'is not embedded' do
-          serialized.should_not be_embedded
+          expect(serialized).not_to be_embedded
         end
       end
 
       it 'passes messages to the value' do
-        serialized.upcase.should == 'FOO'
+        expect(serialized.upcase).to be == 'FOO'
       end
     end
   end

data/spec/perpetuity/postgres_spec.rb

@@ -28,7 +28,7 @@ module Perpetuity
 
         [:host, :port, :db, :pool_size, :username, :password].each do |attribute|
           it "returns its #{attribute}" do
-            postgres.public_send(attribute).should == send(attribute)
+            expect(postgres.public_send(attribute)).to be == send(attribute)
           end
         end
       end
@@ -37,23 +37,23 @@ module Perpetuity
         let(:postgres) { Postgres.new(db: 'my_db') }
 
         it 'defaults to host = localhost' do
-          postgres.host.should == 'localhost'
+          expect(postgres.host).to be == 'localhost'
         end
 
         it 'defaults to port = 5432 (Postgres default)' do
-          postgres.port.should == 5432
+          expect(postgres.port).to be == 5432
         end
 
         it "defaults to username = #{ENV['USER']}" do
-          postgres.username.should == ENV['USER']
+          expect(postgres.username).to be == ENV['USER']
         end
 
         it 'defaults to a blank password' do
-          postgres.password.should be nil
+          expect(postgres.password).to be nil
         end
 
         it 'defaults to pool_size = 5' do
-          postgres.pool_size.should == 5
+          expect(postgres.pool_size).to be == 5
         end
       end
     end
@@ -64,10 +64,10 @@ module Perpetuity
         Postgres::Table::Attribute.new('body', String),
         Postgres::Table::Attribute.new('author', Object)
       ]
-      postgres.should have_table('Article')
+      expect(postgres).to have_table('Article')
 
       postgres.drop_table 'Article'
-      postgres.should_not have_table 'Article'
+      expect(postgres).not_to have_table 'Article'
     end
 
     it 'adds columns automatically if they are not there' do
@@ -86,15 +86,15 @@ module Perpetuity
                                            ["'Jamie'", "'2013-1-1'"])]
       id = postgres.insert('Article', data, attributes).first
 
-      postgres.find('Article', id)['timestamp'].should =~ /2013/
+      expect(postgres.find('Article', id)['timestamp']).to be =~ /2013/
 
       postgres.drop_table 'Article' # Cleanup
     end
 
     it 'converts values into something that works with the DB' do
-      postgres.postgresify("string").should == "'string'"
-      postgres.postgresify(1).should == '1'
-      postgres.postgresify(true).should == 'TRUE'
+      expect(postgres.postgresify("string")).to be == "'string'"
+      expect(postgres.postgresify(1)).to be == '1'
+      expect(postgres.postgresify(true)).to be == 'TRUE'
     end
 
     describe 'working with data' do
@@ -109,8 +109,8 @@ module Perpetuity
         id = postgres.insert('User', data, attributes).first
         result = postgres.find('User', id)
 
-        id.should =~ /[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}/
-        result['name'].should == 'Jamie'
+        expect(id).to be =~ /[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}/
+        expect(result['name']).to be == 'Jamie'
       end
 
       describe 'returning ids' do
@@ -118,7 +118,7 @@ module Perpetuity
           data << Postgres::SerializedData.new([:name], ["'Jessica'"]) <<
           Postgres::SerializedData.new([:name], ["'Kevin'"])
           ids = postgres.insert('User', data, attributes)
-          ids.should be_a Array
+          expect(ids).to be_a Array
           expect(ids.count).to eq 3
         end
 
@@ -127,7 +127,7 @@ module Perpetuity
           attributes << Attribute.new(:id, Integer)
           data.first[:id] = 1234
           ids = postgres.insert 'User', data, attributes
-          ids.first.should == 1234
+          expect(ids.first).to be == 1234
           postgres.drop_table 'User'
         end
       end
@@ -144,12 +144,12 @@ module Perpetuity
 
       it 'returns a count of 0 when the table does not exist' do
         postgres.drop_table 'Article'
-        postgres.count('Article').should == 0
+        expect(postgres.count('Article')).to be == 0
       end
 
       it 'returns no rows when the table does not exist' do
         postgres.drop_table 'Article'
-        postgres.retrieve('Article', 'TRUE').should == []
+        expect(postgres.retrieve('Article', 'TRUE')).to be == []
       end
 
       it 'updates a specific record' do
@@ -157,7 +157,7 @@ module Perpetuity
         postgres.update 'User', id, name: 'foo'
 
         retrieved = postgres.retrieve 'User', "id = '#{id}'"
-        retrieved.first['name'].should == 'foo'
+        expect(retrieved.first['name']).to be == 'foo'
       end
 
       it 'updates a record when a column does not currently exist' do
@@ -165,14 +165,14 @@ module Perpetuity
         postgres.update 'User', id, Postgres::SerializedData.new(['foo'], ["'bar'"])
 
         retrieved = postgres.retrieve('User', "id = '#{id}'")
-        retrieved.first['foo'].should == 'bar'
+        expect(retrieved.first['foo']).to be == 'bar'
       end
 
       describe 'deletion' do
         it 'deletes all records' do
           postgres.insert 'User', data, attributes
           postgres.delete_all 'User'
-          postgres.count('User').should == 0
+          expect(postgres.count('User')).to be == 0
         end
 
         it 'deletes a record with a specific id' do
@@ -197,42 +197,42 @@ module Perpetuity
         it 'increments a value for a record' do
           id = postgres.insert('Increment', data, attributes).first
           postgres.increment 'Increment', id, :n, 10
-          postgres.find('Increment', id)['n'].should == '11'
+          expect(postgres.find('Increment', id)['n']).to be == '11'
         end
       end
     end
 
     describe 'query generation' do
       it 'creates SQL queries with a block' do
-        postgres.query { |o| o.name == 'foo' }.to_db.should ==
+        expect(postgres.query { |o| o.name == 'foo' }.to_db).to be ==
           "name = 'foo'"
       end
 
       it 'does not allow SQL injection' do
         query = postgres.query { |o| o.name == "' OR 1; --" }.to_db
-        query.should == "name = ''' OR 1; --'"
+        expect(query).to be == "name = ''' OR 1; --'"
       end
 
       it 'limits results' do
         query = postgres.query
         sql = postgres.select(from: 'Article', where: query, limit: 2)
-        sql.should == %Q{SELECT * FROM "Article" WHERE TRUE LIMIT 2}
+        expect(sql).to be == %Q{SELECT * FROM "Article" WHERE TRUE LIMIT 2}
       end
 
       describe 'ordering results' do
         it 'orders results without a qualifier' do
           sql = postgres.select(from: 'Article', order: :title)
-          sql.should == %Q{SELECT * FROM "Article" ORDER BY title}
+          expect(sql).to be == %Q{SELECT * FROM "Article" ORDER BY title}
         end
 
         it 'orders results with asc' do
           sql = postgres.select(from: 'Article', order: { title: :asc })
-          sql.should == %Q{SELECT * FROM "Article" ORDER BY title ASC}
+          expect(sql).to be == %Q{SELECT * FROM "Article" ORDER BY title ASC}
         end
 
         it 'reverse-orders results' do
           sql = postgres.select(from: 'Article', order: { title: :desc })
-          sql.should == %Q{SELECT * FROM "Article" ORDER BY title DESC}
+          expect(sql).to be == %Q{SELECT * FROM "Article" ORDER BY title DESC}
         end
       end
     end
@@ -255,10 +255,10 @@ module Perpetuity
 
         active_indexes = postgres.active_indexes(Object)
         index = active_indexes.find { |i| i.attribute_names == ['title'] }
-        index.attribute_names.should == ['title']
-        index.table.should == 'Object'
-        index.should be_unique
-        index.should be_active
+        expect(index.attribute_names).to be == ['title']
+        expect(index.table).to be == 'Object'
+        expect(index).to be_unique
+        expect(index).to be_active
       end
 
       describe 'adding indexes to the database' do
@@ -266,17 +266,17 @@ module Perpetuity
           title_attribute = Attribute.new(:title, String)
           postgres.index Object, title_attribute
           index = postgres.indexes(Object).find { |i| i.attributes.map(&:name) == [:title] }
-          index.attribute_names.should == ['title']
-          index.table.should == 'Object'
-          index.should_not be_unique
-          index.should_not be_active
+          expect(index.attribute_names).to be == ['title']
+          expect(index.table).to be == 'Object'
+          expect(index).not_to be_unique
+          expect(index).not_to be_active
         end
 
         it 'activates the specified index' do
           title_attribute = Attribute.new(:title, String)
           index = postgres.index Object, title_attribute
           postgres.activate_index! index
-          postgres.active_indexes(Object).map(&:attribute_names).should include ['title']
+          expect(postgres.active_indexes(Object).map(&:attribute_names)).to include ['title']
         end
       end
 
@@ -285,7 +285,7 @@ module Perpetuity
           index = postgres.index(Object, Attribute.new(:title, String))
           postgres.activate_index! index
           postgres.remove_index index
-          postgres.active_indexes(Object).map(&:attribute_names).should_not include ['title']
+          expect(postgres.active_indexes(Object).map(&:attribute_names)).not_to include ['title']
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: perpetuity-postgres
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Jamie Gaskins
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-23 00:00:00.000000000 Z
+date: 2014-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -28,16 +28,16 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement