perpetuity-postgres 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 131881bc7b24a361b04326b0fac2699ca1ca2c22
-  data.tar.gz: 57dc7bd53e485500524439604ceaa517f5990215
+  metadata.gz: dbfd7bfbff611c846132965cc13c105ac722f469
+  data.tar.gz: 70179a20ab781629f0f1c56e6639104476e5fbe1
 SHA512:
-  metadata.gz: e1c978801cc9d1a5c4bc888c899ce27ff15166bb396ad4eb5b95212664b408e76f13afb57175220072b532b6beaeb598794c67c0f1de809cb893bad71de49e8a
-  data.tar.gz: 5645ce0e3ebca3602b789515db6762ca0713c958dd915502dea87d8137df67f1c55b8b53bd9a632e081c55ce8ee767a12984a294a74db2992150ef48c8b32a68
+  metadata.gz: fbe960158dfbab549a471033e7e8219f477aa2e3f2c573c685b9eee7ac8bdbbb5d1877f7df9722fb98310f6e67186b4b6103658027f518e4173f1683b4f65d7a
+  data.tar.gz: c380f8f7b8cc6ccbf731dc92e58dd7995c95ac91d4629c856553fd4d672afb3133a2cbffd88220b499c675afe56d5c767d7f64cc9b5141505bbf4ca6d9f493bc

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## Version 0.0.8
+
+- Reconnect automatically if connection is interrupted. Reconnection is tried 3x at 1-second intervals.
+
 ## Version 0.0.7
 
 - Allow for querying within a range: `mapper.select { |o| o.value.in (1..3) }`

data/lib/perpetuity/postgres/connection.rb

@@ -43,6 +43,18 @@ module Perpetuity
 
       def execute sql
         pg_connection.exec sql
+      rescue PG::AdminShutdown, PG::UnableToSend => e
+        # server closed the connection unexpectedly
+        # Try to reconnect 3 times in case it's just a server restart.
+        unable_to_send_retries ||= 0
+        if unable_to_send_retries < 3
+          connect
+          unable_to_send_retries += 1
+          sleep 1
+          retry
+        else
+          raise
+        end
       rescue PG::UndefinedFunction => e
         if e.message =~ /uuid_generate/
           use_uuid_extension

data/lib/perpetuity/postgres/version.rb

@@ -1,5 +1,5 @@
 module Perpetuity
   class Postgres
-    VERSION = "0.0.7"
+    VERSION = "0.0.8"
   end
 end

data/perpetuity-postgres.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rspec", "~> 2.0"
+  spec.add_development_dependency "rspec"
   spec.add_development_dependency "rake"
   spec.add_runtime_dependency "perpetuity", "~> 1.0.0"
   spec.add_runtime_dependency "pg"

data/spec/perpetuity/postgres/boolean_value_spec.rb

@@ -4,11 +4,11 @@ module Perpetuity
   class Postgres
     describe BooleanValue do
       it 'serializes true into a Postgres true value' do
-        BooleanValue.new(true).to_s.should == 'TRUE'
+        expect(BooleanValue.new(true).to_s).to be == 'TRUE'
       end
 
       it 'serializes false into a Postgres false value' do
-        BooleanValue.new(false).to_s.should == 'FALSE'
+        expect(BooleanValue.new(false).to_s).to be == 'FALSE'
       end
     end
   end

data/spec/perpetuity/postgres/connection_pool_spec.rb

@@ -26,19 +26,18 @@ module Perpetuity
         end
 
         it 'returns the value of the block' do
-          pool.lend_connection { 1 }.should == 1
+          expect(pool.lend_connection { 1 }).to be == 1
         end
       end
 
       it 'executes a given SQL statement' do
         sql = "SELECT TRUE"
-        Connection.any_instance.should_receive(:execute)
-                               .with(sql)
+        expect_any_instance_of(Connection).to receive(:execute).with(sql)
         pool.execute sql
       end
 
       it 'passes the tables message to a connection' do
-        Connection.any_instance.should_receive(:tables)
+        expect_any_instance_of(Connection).to receive(:tables)
         pool.tables
       end
 

data/spec/perpetuity/postgres/connection_spec.rb

@@ -7,24 +7,24 @@ module Perpetuity
 
       it 'sanitizes the options for the pg gem' do
         options = { db: 'db', username: 'user' }
-        connection.sanitize_options(options).should == {
+        expect(connection.sanitize_options(options)).to be == {
           dbname: 'db',
           user: 'user'
         }
       end
 
       it 'is only activated when it is used' do
-        connection.should_not be_active
-        PG.stub(connect: double(exec: true))
+        expect(connection).not_to be_active
+        allow(PG).to receive(:connect) { double(exec: true) }
         connection.connect
-        connection.should be_active
+        expect(connection).to be_active
       end
 
       it 'executes SQL' do
         connection.execute 'CREATE TABLE IF NOT EXISTS abcdefg (name text)'
-        connection.tables.should include 'abcdefg'
+        expect(connection.tables).to include 'abcdefg'
         connection.execute 'DROP TABLE IF EXISTS abcdefg'
-        connection.tables.should_not include 'abcdefg'
+        expect(connection.tables).not_to include 'abcdefg'
       end
     end
   end

data/spec/perpetuity/postgres/date_value_spec.rb

@@ -5,19 +5,19 @@ module Perpetuity
     describe DateValue do
       it 'converts to a SQL string' do
         date = Date.new(2014, 8, 25)
-        DateValue.new(date).to_s.should == "'2014-08-25'::date"
+        expect(DateValue.new(date).to_s).to be == "'2014-08-25'::date"
       end
 
       describe 'conversion from a SQL value string' do
         it 'converts GMT-X times' do
           actual = DateValue.from_sql('2013-12-01')
           expected = Date.new(2013, 12, 1)
-          actual.to_date.should == expected
+          expect(actual.to_date).to be == expected
         end
       end
 
       it 'returns its wrapped value' do
-        DateValue.new(:foo).value.should == :foo
+        expect(DateValue.new(:foo).value).to be == :foo
       end
     end
   end

data/spec/perpetuity/postgres/expression_spec.rb

@@ -6,7 +6,7 @@ module Perpetuity
       let(:expression) { Expression.new('uuid_generate_v4()') }
 
       it 'passes the expression straight into SQL' do
-        expression.to_sql.should == 'uuid_generate_v4()'
+        expect(expression.to_sql).to be == 'uuid_generate_v4()'
       end
     end
   end

data/spec/perpetuity/postgres/index_collection_spec.rb

@@ -7,22 +7,22 @@ module Perpetuity
       let(:indexes) { IndexCollection.new(Object) }
 
       it 'knows which table it is indexing' do
-        indexes.table.should == 'Object'
+        expect(indexes.table).to be == 'Object'
       end
 
       it 'iterates over its indexes' do
         indexes << 1
-        indexes.map { |index| index.to_s }.should include '1'
+        expect(indexes.map { |index| index.to_s }).to include '1'
       end
 
       it 'converts to an array' do
-        indexes.to_ary.should == []
+        expect(indexes.to_ary).to be == []
       end
 
       it 'removes indexes based on a block' do
         indexes << double('Index', name: 'lol')
         indexes.reject! { |index| index.name == 'lol' }
-        indexes.map(&:name).should_not include 'lol'
+        expect(indexes.map(&:name)).not_to include 'lol'
       end
     end
   end

data/spec/perpetuity/postgres/index_spec.rb

@@ -12,11 +12,11 @@ module Perpetuity
         }
 
         index = Index.from_sql(index_hash)
-        index.attribute_names.should == ['id', 'name']
-        index.name.should == 'Object_id_name_index'
-        index.table.should == 'Object'
-        index.should be_unique
-        index.should be_active
+        expect(index.attribute_names).to be == ['id', 'name']
+        expect(index.name).to be == 'Object_id_name_index'
+        expect(index.table).to be == 'Object'
+        expect(index).to be_unique
+        expect(index).to be_active
       end
 
       it 'sets itself as active' do
@@ -24,9 +24,9 @@ module Perpetuity
                           name: 'Table',
                           unique: false)
 
-        index.should_not be_active
+        expect(index).not_to be_active
         index.activate!
-        index.should be_active
+        expect(index).to be_active
       end
 
       describe 'equality' do
@@ -41,7 +41,7 @@ module Perpetuity
 
         it 'is equal to an index with identical state' do
           new_index = index.dup
-          new_index.should == index
+          expect(new_index).to be == index
         end
 
         it 'is not equal to an index with different attributes' do
@@ -49,14 +49,14 @@ module Perpetuity
                                 name: name,
                                 unique: unique)
 
-          new_index.should_not == index
+          expect(new_index).not_to be == index
         end
 
         it 'is equal to an index with stringified attributes' do
           new_index = Index.new(attributes: attributes.map(&:to_s),
                                 name: name,
                                 unique: unique)
-          new_index.should == index
+          expect(new_index).to be == index
         end
 
         it 'is not equal to an index with another name' do
@@ -64,18 +64,18 @@ module Perpetuity
                                 name: 'NotObject',
                                 unique: unique)
 
-          new_index.should_not == index
+          expect(new_index).not_to be == index
         end
 
         it 'is not equal to an index with opposite uniqueness' do
           new_index = Index.new(attributes: attributes,
                                 name: name,
                                 unique: !unique)
-          new_index.should_not == index
+          expect(new_index).not_to be == index
         end
 
         it 'is not equal to things that are not indexes' do
-          index.should_not == 'lol'
+          expect(index).not_to be == 'lol'
         end
       end
     end

data/spec/perpetuity/postgres/json_array_spec.rb

@@ -4,31 +4,31 @@ module Perpetuity
   class Postgres
     describe JSONArray do
       it 'serializes empty arrays' do
-        JSONArray.new([]).to_s.should == "'[]'"
+        expect(JSONArray.new([]).to_s).to be == "'[]'"
       end
 
       it 'serializes arrays of numeric values' do
-        JSONArray.new([1,2,3]).to_s.should == "'[1,2,3]'"
+        expect(JSONArray.new([1,2,3]).to_s).to be == "'[1,2,3]'"
       end
 
       it 'serializes arrays of strings' do
-        JSONArray.new(%w(foo bar baz)).to_s.should == %q{'["foo","bar","baz"]'}
+        expect(JSONArray.new(%w(foo bar baz)).to_s).to be == %q{'["foo","bar","baz"]'}
       end
 
       it 'serializes arrays of hashes' do
-        JSONArray.new([{a: 1}, {b: 2}]).to_s.should == %q{'[{"a":1},{"b":2}]'}
+        expect(JSONArray.new([{a: 1}, {b: 2}]).to_s).to be == %q{'[{"a":1},{"b":2}]'}
       end
 
       it 'serializes arrays of JSONHashes' do
-        JSONArray.new([JSONHash.new(a: 1)]).to_s.should == %q{'[{"a":1}]'}
+        expect(JSONArray.new([JSONHash.new(a: 1)]).to_s).to be == %q{'[{"a":1}]'}
       end
 
       it 'serializes arrays of arrays' do
-        JSONArray.new([[1], ['foo']]).to_s.should == %q{'[[1],["foo"]]'}
+        expect(JSONArray.new([[1], ['foo']]).to_s).to be == %q{'[[1],["foo"]]'}
       end
 
       it 'serializes elements of arrays' do
-        JSONArray.new([1,'a']).to_s.should == %q{'[1,"a"]'}
+        expect(JSONArray.new([1,'a']).to_s).to be == %q{'[1,"a"]'}
       end
     end
   end

data/spec/perpetuity/postgres/json_hash_spec.rb

@@ -4,44 +4,44 @@ module Perpetuity
   class Postgres
     describe JSONHash do
       it 'serializes empty hashes' do
-        JSONHash.new({}).to_s.should == "'{}'"
+        expect(JSONHash.new({}).to_s).to be == "'{}'"
       end
 
       it 'serializes hashes with string elements' do
-        JSONHash.new({a: 'b'}).to_s.should == %q{'{"a":"b"}'}
+        expect(JSONHash.new({a: 'b'}).to_s).to be == %q{'{"a":"b"}'}
       end
 
       it 'serializes hashes with numeric elements' do
-        JSONHash.new({a: 1}).to_s.should == %q{'{"a":1}'}
+        expect(JSONHash.new({a: 1}).to_s).to be == %q{'{"a":1}'}
       end
 
       it 'serializes hashes with boolean elements' do
-        JSONHash.new({a: true, b: false}).to_s.should == %q('{"a":true,"b":false}')
+        expect(JSONHash.new({a: true, b: false}).to_s).to be == %q('{"a":true,"b":false}')
       end
 
       it 'serializes nil values' do
-        JSONHash.new({a: nil}).to_s.should == %q('{"a":null}')
+        expect(JSONHash.new({a: nil}).to_s).to be == %q('{"a":null}')
       end
 
       it 'does not surround the an inner serialized value with quotes' do
-        JSONHash.new({a: 1}, :inner).to_s.should == %q[{"a":1}]
+        expect(JSONHash.new({a: 1}, :inner).to_s).to be == %q[{"a":1}]
       end
 
       it 'serializes hashes with multiple entries' do
-        JSONHash.new({a: 1, b: 'c'}).to_s.should == %q{'{"a":1,"b":"c"}'}
+        expect(JSONHash.new({a: 1, b: 'c'}).to_s).to be == %q{'{"a":1,"b":"c"}'}
       end
 
       it 'serializes a hash with array values' do
-        JSONHash.new({foo: ['bar', 'baz', 'quux']}).to_s.should ==
+        expect(JSONHash.new({foo: ['bar', 'baz', 'quux']}).to_s).to be ==
           %q{'{"foo":["bar","baz","quux"]}'}
       end
 
       it 'converts back to a hash' do
-        JSONHash.new({a: 1}).to_hash.should == { a: 1 }
+        expect(JSONHash.new({a: 1}).to_hash).to be == { a: 1 }
       end
 
       it 'is equal to an identical hash' do
-        JSONHash.new(a: 1).should == JSONHash.new(a: 1)
+        expect(JSONHash.new(a: 1)).to be == JSONHash.new(a: 1)
       end
     end
   end

data/spec/perpetuity/postgres/json_string_value_spec.rb

@@ -4,15 +4,15 @@ module Perpetuity
   class Postgres
     describe JSONStringValue do
       it 'serializes into a JSON string value' do
-        JSONStringValue.new('Jamie').to_s.should == '"Jamie"'
+        expect(JSONStringValue.new('Jamie').to_s).to be == '"Jamie"'
       end
 
       it 'converts symbols into strings' do
-        JSONStringValue.new(:foo).to_s.should == '"foo"'
+        expect(JSONStringValue.new(:foo).to_s).to be == '"foo"'
       end
 
       it 'escapes quotes' do
-        JSONStringValue.new('Anakin "Darth Vader" Skywalker').to_s.should ==
+        expect(JSONStringValue.new('Anakin "Darth Vader" Skywalker').to_s).to be ==
           '"Anakin \\"Darth Vader\\" Skywalker"'
       end
     end

data/spec/perpetuity/postgres/negated_query_spec.rb

@@ -4,35 +4,35 @@ module Perpetuity
   class Postgres
     describe NegatedQuery do
       it 'negates equality' do
-        NegatedQuery.new { |o| o.name == 'foo' }.to_db.should == "NOT (name = 'foo')"
+        expect(NegatedQuery.new { |o| o.name == 'foo' }.to_db).to be == "NOT (name = 'foo')"
       end
 
       it 'negates regex matching' do
-        NegatedQuery.new { |o| o.name =~ /foo/ }.to_db.should == "NOT (name ~ 'foo')"
+        expect(NegatedQuery.new { |o| o.name =~ /foo/ }.to_db).to be == "NOT (name ~ 'foo')"
       end
 
       it 'negates case-insensitive regex matching' do
-        NegatedQuery.new { |o| o.name =~ /foo/i }.to_db.should == "NOT (name ~* 'foo')"
+        expect(NegatedQuery.new { |o| o.name =~ /foo/i }.to_db).to be == "NOT (name ~* 'foo')"
       end
 
       it 'negates inequality' do
-        NegatedQuery.new { |o| o.name != /foo/i }.to_db.should == "NOT (name != 'foo')"
+        expect(NegatedQuery.new { |o| o.name != /foo/i }.to_db).to be == "NOT (name != 'foo')"
       end
 
       it 'negates greater-than' do
-        NegatedQuery.new { |o| o.age > 1 }.to_db.should == "NOT (age > 1)"
+        expect(NegatedQuery.new { |o| o.age > 1 }.to_db).to be == "NOT (age > 1)"
       end
 
       it 'negates greater-than-or-equal' do
-        NegatedQuery.new { |o| o.age >= 1 }.to_db.should == "NOT (age >= 1)"
+        expect(NegatedQuery.new { |o| o.age >= 1 }.to_db).to be == "NOT (age >= 1)"
       end
 
       it 'negates less-than' do
-        NegatedQuery.new { |o| o.age < 1 }.to_db.should == "NOT (age < 1)"
+        expect(NegatedQuery.new { |o| o.age < 1 }.to_db).to be == "NOT (age < 1)"
       end
 
       it 'negates less-than-or-equal' do
-        NegatedQuery.new { |o| o.age <= 1 }.to_db.should == "NOT (age <= 1)"
+        expect(NegatedQuery.new { |o| o.age <= 1 }.to_db).to be == "NOT (age <= 1)"
       end
     end
   end

data/spec/perpetuity/postgres/null_value_spec.rb

@@ -4,7 +4,7 @@ module Perpetuity
   class Postgres
     describe NullValue do
       it 'serializes into a Postgres NULL value' do
-        NullValue.new.to_s.should == 'NULL'
+        expect(NullValue.new.to_s).to be == 'NULL'
       end
     end
   end

data/spec/perpetuity/postgres/numeric_value_spec.rb

@@ -4,7 +4,7 @@ module Perpetuity
   class Postgres
     describe NumericValue do
       it 'serializes into a Postgres-compatible number value' do
-        NumericValue.new(1).to_s.should == '1'
+        expect(NumericValue.new(1).to_s).to be == '1'
       end
     end
   end

data/spec/perpetuity/postgres/query_attribute_spec.rb

@@ -6,62 +6,62 @@ module Perpetuity
       let(:attribute) { QueryAttribute.new :attribute_name }
 
       it 'returns its name' do
-        attribute.name.should == :attribute_name
+        expect(attribute.name).to be == :attribute_name
       end
 
       it 'checks for equality' do
-        (attribute == 1).should be_a QueryExpression
+        expect((attribute == 1)).to be_a QueryExpression
       end
 
       it 'checks for less than' do
-        (attribute < 1).should be_a QueryExpression
+        expect((attribute < 1)).to be_a QueryExpression
       end
 
       it 'checks for <=' do
-        (attribute <= 1).should be_a QueryExpression
+        expect((attribute <= 1)).to be_a QueryExpression
       end
 
       it 'checks for greater than' do
-        (attribute > 1).should be_a QueryExpression
+        expect((attribute > 1)).to be_a QueryExpression
       end
 
       it 'checks for >=' do
-        (attribute >= 1).should be_a QueryExpression
+        expect((attribute >= 1)).to be_a QueryExpression
       end
 
       it 'checks for inequality' do
-        (attribute != 1).should be_a QueryExpression
+        expect((attribute != 1)).to be_a QueryExpression
       end
 
       it 'checks for regexp matches' do
-        (attribute =~ /value/).should be_a QueryExpression
+        expect((attribute =~ /value/)).to be_a QueryExpression
       end
 
       it 'checks for inclusion' do
-        (attribute.in [1, 2, 3]).should be_a QueryExpression
+        expect((attribute.in [1, 2, 3])).to be_a QueryExpression
       end
 
       it 'checks for existence' do
-        (attribute.any?).to_db.should == 'json_array_length(attribute_name) > 0'
+        expect((attribute.any?).to_db).to be == 'json_array_length(attribute_name) > 0'
       end
 
       it 'checks for no existence' do
-        (attribute.none?).to_db.should == 'json_array_length(attribute_name) = 0'
+        expect((attribute.none?).to_db).to be == 'json_array_length(attribute_name) = 0'
       end
 
       it 'checks for nil' do
-        attribute.nil?.should be_a QueryExpression
+        expect(attribute.nil?).to be_a QueryExpression
       end
 
       it 'checks for truthiness' do
-        attribute.to_db.should == 'attribute_name IS NOT NULL'
+        expect(attribute.to_db).to be == 'attribute_name IS NOT NULL'
       end
 
       describe 'nested attributes' do
         it 'checks for an id' do
           id = attribute.id
-          id.should be_a QueryAttribute
-          id.name.should == %q{attribute_name->'__metadata__'->>'id'}
+          expect(id).to be_a QueryAttribute
+          expect(id.name).to be == %q{attribute_name->'__metadata__'->>'id'}
         end
       end
     end