pupa 0.1.11 → 0.2.0

data/spec/models/vote_spec.rb

@@ -7,7 +7,7 @@ describe Pupa::Vote do
 
   describe '#to_s' do
     it 'should return a human-readable string' do
-      object.to_s.should == 'yes by john-q-public in vote-42'
+      expect(object.to_s).to eq('yes by john-q-public in vote-42')
     end
   end
 end

data/spec/processor/client_spec.rb

@@ -3,13 +3,13 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 describe Pupa::Processor::Client do
   describe '.new' do
     it 'should use the filesystem' do
-      ActiveSupport::Cache::FileStore.should_receive(:new).and_call_original
-      Pupa::Processor::Client.new(cache_dir: '/tmp', level: 'UNKNOWN').get('http://example.com/')
+      expect(ActiveSupport::Cache::FileStore).to receive(:new).and_call_original
+      Pupa::Processor::Client.new(cache_dir: '/tmp', level: 'UNKNOWN').get('http://httpbin.org/')
     end
 
     it 'should use Memcached' do
-      ActiveSupport::Cache::MemCacheStore.should_receive(:new).and_call_original
-      Pupa::Processor::Client.new(cache_dir: 'memcached://localhost', level: 'UNKNOWN').get('http://example.com/')
+      expect(ActiveSupport::Cache::MemCacheStore).to receive(:new).and_call_original
+      Pupa::Processor::Client.new(cache_dir: 'memcached://localhost', level: 'UNKNOWN').get('http://httpbin.org/')
     end
   end
 end

data/spec/processor/connection_adapters/mongodb_adapter_spec.rb

@@ -13,8 +13,8 @@ describe Pupa::Processor::Connection::MongoDBAdapter do
     connection.raw_connection[:people].drop
 
     connection.save(Pupa::Person.new(_id: 'existing', name: 'existing', email: 'existing@example.com'))
-    connection.raw_connection[:people].insert(_type: 'pupa/person', name: 'non-unique')
-    connection.raw_connection[:people].insert(_type: 'pupa/person', name: 'non-unique')
+    connection.raw_connection[:people].insert_one(_type: 'pupa/person', name: 'non-unique')
+    connection.raw_connection[:people].insert_one(_type: 'pupa/person', name: 'non-unique')
   end
 
   describe '.find' do
@@ -23,11 +23,11 @@ describe Pupa::Processor::Connection::MongoDBAdapter do
     end
 
     it 'should return nil if no matches' do
-      connection.find(_type: _type, name: 'nonexistent').should == nil
+      expect(connection.find(_type: _type, name: 'nonexistent')).to eq(nil)
     end
 
     it 'should return a document if one match' do
-      connection.find(_type: _type, name: 'existing').should be_a(Hash)
+      expect(connection.find(_type: _type, name: 'existing')).to be_a(Hash)
     end
 
     it 'should raise an error if many matches' do
@@ -41,13 +41,13 @@ describe Pupa::Processor::Connection::MongoDBAdapter do
     end
 
     it 'should insert a document if no matches' do
-      connection.save(Pupa::Person.new(_id: 'new', name: 'new', email: 'new@example.com')).should == [true, 'new']
-      connection.find(_type: _type, name: 'new')['email'].should == 'new@example.com'
+      expect(connection.save(Pupa::Person.new(_id: 'new', name: 'new', email: 'new@example.com'))).to eq([true, 'new'])
+      expect(connection.find(_type: _type, name: 'new')['email']).to eq('new@example.com')
     end
 
     it 'should update a document if one match' do
-      connection.save(Pupa::Person.new(_id: 'changed', name: 'existing', email: 'changed@example.com')).should == [false, 'existing']
-      connection.find(_type: _type, name: 'existing')['email'].should == 'changed@example.com'
+      expect(connection.save(Pupa::Person.new(_id: 'changed', name: 'existing', email: 'changed@example.com'))).to eq([false, 'existing'])
+      expect(connection.find(_type: _type, name: 'existing')['email']).to eq('changed@example.com')
     end
 
     it 'should raise an error if many matches' do

data/spec/processor/connection_adapters/postgresql_adapter_spec.rb

@@ -1,66 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Pupa::Processor::Connection::PostgreSQLAdapter do
-  def _type
-    'pupa/person'
-  end
-
-  def connection
-    Pupa::Processor::Connection::PostgreSQLAdapter.new('postgres://localhost:5432/pupa_test')
-  end
-
-  before :all do
-    connection.raw_connection.drop_table?(:people)
-    connection.raw_connection.create_table(:people) do
-      primary_key :id
-      String :_id
-      String :_type
-      String :name
-      String :email
-      Time :created_at
-      Time :updated_at
-    end
-
-    connection.save(Pupa::Person.new(_id: 'existing', name: 'existing', email: 'existing@example.com'))
-    connection.raw_connection[:people].insert(_type: 'pupa/person', name: 'non-unique')
-    connection.raw_connection[:people].insert(_type: 'pupa/person', name: 'non-unique')
-  end
-
-  describe '.find' do
-    it 'should raise an error if selector is empty' do
-      expect{connection.find(_type: _type)}.to raise_error(Pupa::Errors::EmptySelectorError)
-    end
-
-    it 'should return nil if no matches' do
-      connection.find(_type: _type, name: 'nonexistent').should == nil
-    end
-
-    it 'should return a document if one match' do
-      connection.find(_type: _type, name: 'existing').should be_a(Hash)
-    end
-
-    it 'should raise an error if many matches' do
-      expect{connection.find(_type: 'pupa/person', name: 'non-unique')}.to raise_error(Pupa::Errors::TooManyMatches)
-    end
-  end
-
-  describe '.save' do
-    it 'should raise an error if selector is empty' do
-      expect{connection.save(Pupa::Person.new)}.to raise_error(Pupa::Errors::EmptySelectorError)
-    end
-
-    it 'should insert a document if no matches' do
-      connection.save(Pupa::Person.new(_id: 'new', name: 'new', email: 'new@example.com')).should == [true, 'new']
-      connection.find(_type: _type, name: 'new')['email'].should == 'new@example.com'
-    end
-
-    it 'should update a document if one match' do
-      connection.save(Pupa::Person.new(_id: 'changed', name: 'existing', email: 'changed@example.com')).should == [false, 'existing']
-      connection.find(_type: _type, name: 'existing')['email'].should == 'changed@example.com'
-    end
-
-    it 'should raise an error if many matches' do
-      expect{connection.save(Pupa::Person.new(name: 'non-unique'))}.to raise_error(Pupa::Errors::TooManyMatches)
-    end
-  end
+  include_examples 'SQL adapter', 'postgres://localhost:5432/pupa_test'
 end

data/spec/processor/connection_adapters/sqlite_adapter_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Pupa::Processor::Connection::PostgreSQLAdapter do
+  include_examples 'SQL adapter', 'sqlite://test.db'
+end

data/spec/processor/connection_spec.rb

@@ -3,12 +3,12 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 describe Pupa::Processor::Connection do
   describe '.new' do
     it 'should use MongoDB' do
-      Pupa::Processor::Connection::MongoDBAdapter.should_receive(:new).with('mongodb://localhost:27017/pupa').and_call_original
+      expect(Pupa::Processor::Connection::MongoDBAdapter).to receive(:new).with('mongodb://localhost:27017/pupa').and_call_original
       Pupa::Processor::Connection.new('mongodb://localhost:27017/pupa')
     end
 
     it 'should use PostgreSQL' do
-      Pupa::Processor::Connection::PostgreSQLAdapter.should_receive(:new).with('postgres://localhost:5432/pupa').and_call_original
+      expect(Pupa::Processor::Connection::PostgreSQLAdapter).to receive(:new).with('postgres://localhost:5432/pupa').and_call_original
       Pupa::Processor::Connection.new('postgres://localhost:5432/pupa')
     end
   end

data/spec/processor/document_store/file_store_spec.rb

@@ -7,52 +7,52 @@ describe Pupa::Processor::DocumentStore::FileStore do
 
   describe '#exist?' do
     it 'should return true if the store contains an entry for the given key' do
-      store.exist?('foo.json').should == true
+      expect(store.exist?('foo.json')).to eq(true)
     end
 
     it 'should return false if the store does not contain an entry for the given key' do
-      store.exist?('nonexistent').should == false
+      expect(store.exist?('nonexistent')).to eq(false)
     end
   end
 
   describe '#entries' do
     it 'should return all keys in the store' do
-      store.entries.sort.should == %w(bar.json baz.json foo.json)
+      expect(store.entries.sort).to eq(%w(bar.json baz.json foo.json))
     end
   end
 
   describe '#read' do
     it 'should return the value of the given key' do
-      store.read('foo.json').should == {'name' => 'foo'}
+      expect(store.read('foo.json')).to eq({'name' => 'foo'})
     end
   end
 
   describe '#read_multi' do
     it 'should return the values of the given keys' do
-      store.read_multi(%w(foo.json bar.json)).should == [{'name' => 'foo'}, {'name' => 'bar'}]
+      expect(store.read_multi(%w(foo.json bar.json))).to eq([{'name' => 'foo'}, {'name' => 'bar'}])
     end
   end
 
   describe '#write' do
     it 'should write an entry with the given value for the given key' do
-      store.exist?('new.json').should == false
+      expect(store.exist?('new.json')).to eq(false)
       store.write('new.json', {name: 'new'})
-      store.read('new.json').should == {'name' => 'new'}
+      expect(store.read('new.json')).to eq({'name' => 'new'})
       store.delete('new.json') # cleanup
     end
   end
 
   describe '#write_unless_exists' do
     it 'should write an entry with the given value for the given key' do
-      store.exist?('new.json').should == false
-      store.write_unless_exists('new.json', {name: 'new'}).should == true
-      store.read('new.json').should == {'name' => 'new'}
+      expect(store.exist?('new.json')).to eq(false)
+      expect(store.write_unless_exists('new.json', {name: 'new'})).to eq(true)
+      expect(store.read('new.json')).to eq({'name' => 'new'})
       store.delete('new.json') # cleanup
     end
 
     it 'should not write an entry with the given value for the given key if the key exists' do
-      store.write_unless_exists('foo.json', {name: 'new'}).should == false
-      store.read('foo.json').should == {'name' => 'foo'}
+      expect(store.write_unless_exists('foo.json', {name: 'new'})).to eq(false)
+      expect(store.read('foo.json')).to eq({'name' => 'foo'})
     end
   end
 
@@ -64,10 +64,10 @@ describe Pupa::Processor::DocumentStore::FileStore do
       end
 
       pairs.keys.each do |name|
-        store.exist?(name).should == false
+        expect(store.exist?(name)).to eq(false)
       end
       store.write_multi(pairs)
-      store.read_multi(pairs.keys).should == [{'name' => 'new1'}, {'name' => 'new2'}]
+      expect(store.read_multi(pairs.keys)).to eq([{'name' => 'new1'}, {'name' => 'new2'}])
       pairs.keys.each do |name| # cleanup
         store.delete(name)
       end
@@ -77,17 +77,17 @@ describe Pupa::Processor::DocumentStore::FileStore do
   describe '#delete' do
     it 'should delete an entry with the given key from the store' do
       store.write('new.json', {name: 'new'})
-      store.exist?('new.json').should == true
+      expect(store.exist?('new.json')).to eq(true)
       store.delete('new.json')
-      store.exist?('new.json').should == false
+      expect(store.exist?('new.json')).to eq(false)
     end
   end
 
   describe '#clear' do
     it 'should delete all entries from the store' do
-      store.entries.sort.should == %w(bar.json baz.json foo.json)
+      expect(store.entries.sort).to eq(%w(bar.json baz.json foo.json))
       store.clear
-      store.entries.should == []
+      expect(store.entries).to eq([])
 
       %w(bar baz foo).each do |name| # cleanup
         store.write("#{name}.json", {name: name})
@@ -97,7 +97,7 @@ describe Pupa::Processor::DocumentStore::FileStore do
 
   describe '#path' do
     it 'should return the file path to the entry' do
-      store.path('foo').should == File.expand_path(File.join('..', '..', 'fixtures', 'foo'), __dir__)
+      expect(store.path('foo')).to eq(File.expand_path(File.join('..', '..', 'fixtures', 'foo'), __dir__))
     end
   end
 end

data/spec/processor/document_store/redis_store_spec.rb

@@ -14,52 +14,52 @@ describe Pupa::Processor::DocumentStore::RedisStore do
 
   describe '#exist?' do
     it 'should return true if the store contains an entry for the given key' do
-      store.exist?('foo.json').should == true
+      expect(store.exist?('foo.json')).to eq(true)
     end
 
     it 'should return false if the store does not contain an entry for the given key' do
-      store.exist?('nonexistent').should == false
+      expect(store.exist?('nonexistent')).to eq(false)
     end
   end
 
   describe '#entries' do
     it 'should return all keys in the store' do
-      store.entries.sort.should == %w(bar.json baz.json foo.json)
+      expect(store.entries.sort).to eq(%w(bar.json baz.json foo.json))
     end
   end
 
   describe '#read' do
     it 'should return the value of the given key' do
-      store.read('foo.json').should == {'name' => 'foo'}
+      expect(store.read('foo.json')).to eq({'name' => 'foo'})
     end
   end
 
   describe '#read_multi' do
     it 'should return the values of the given keys' do
-      store.read_multi(%w(foo.json bar.json)).should == [{'name' => 'foo'}, {'name' => 'bar'}]
+      expect(store.read_multi(%w(foo.json bar.json))).to eq([{'name' => 'foo'}, {'name' => 'bar'}])
     end
   end
 
   describe '#write' do
     it 'should write an entry with the given value for the given key' do
-      store.exist?('new.json').should == false
+      expect(store.exist?('new.json')).to eq(false)
       store.write('new.json', {name: 'new'})
-      store.read('new.json').should == {'name' => 'new'}
+      expect(store.read('new.json')).to eq({'name' => 'new'})
       store.delete('new.json') # cleanup
     end
   end
 
   describe '#write_unless_exists' do
     it 'should write an entry with the given value for the given key' do
-      store.exist?('new.json').should == false
-      store.write_unless_exists('new.json', {name: 'new'}).should == true
-      store.read('new.json').should == {'name' => 'new'}
+      expect(store.exist?('new.json')).to eq(false)
+      expect(store.write_unless_exists('new.json', {name: 'new'})).to eq(true)
+      expect(store.read('new.json')).to eq({'name' => 'new'})
       store.delete('new.json') # cleanup
     end
 
     it 'should not write an entry with the given value for the given key if the key exists' do
-      store.write_unless_exists('foo.json', {name: 'new'}).should == false
-      store.read('foo.json').should == {'name' => 'foo'}
+      expect(store.write_unless_exists('foo.json', {name: 'new'})).to eq(false)
+      expect(store.read('foo.json')).to eq({'name' => 'foo'})
     end
   end
 
@@ -71,10 +71,10 @@ describe Pupa::Processor::DocumentStore::RedisStore do
       end
 
       pairs.keys.each do |name|
-        store.exist?(name).should == false
+        expect(store.exist?(name)).to eq(false)
       end
       store.write_multi(pairs)
-      store.read_multi(pairs.keys).should == [{'name' => 'new1'}, {'name' => 'new2'}]
+      expect(store.read_multi(pairs.keys)).to eq([{'name' => 'new1'}, {'name' => 'new2'}])
       pairs.keys.each do |name| # cleanup
         store.delete(name)
       end
@@ -84,17 +84,17 @@ describe Pupa::Processor::DocumentStore::RedisStore do
   describe '#delete' do
     it 'should delete an entry with the given key from the store' do
       store.write('new.json', {name: 'new'})
-      store.exist?('new.json').should == true
+      expect(store.exist?('new.json')).to eq(true)
       store.delete('new.json')
-      store.exist?('new.json').should == false
+      expect(store.exist?('new.json')).to eq(false)
     end
   end
 
   describe '#clear' do
     it 'should delete all entries from the store' do
-      store.entries.sort.should == %w(bar.json baz.json foo.json)
+      expect(store.entries.sort).to eq(%w(bar.json baz.json foo.json))
       store.clear
-      store.entries.should == []
+      expect(store.entries).to eq([])
 
       %w(bar baz foo).each do |name| # cleanup
         store.write("#{name}.json", {name: name})

data/spec/processor/document_store_spec.rb

@@ -3,12 +3,12 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 describe Pupa::Processor::DocumentStore do
   describe '.new' do
     it 'should use the filesystem' do
-      Pupa::Processor::DocumentStore::FileStore.should_receive(:new).with('/tmp').and_call_original
+      expect(Pupa::Processor::DocumentStore::FileStore).to receive(:new).with('/tmp').and_call_original
       Pupa::Processor::DocumentStore.new('/tmp')
     end
 
     it 'should use Redis' do
-      Pupa::Processor::DocumentStore::RedisStore.should_receive(:new).with('redis://localhost', {}).and_call_original
+      expect(Pupa::Processor::DocumentStore::RedisStore).to receive(:new).with('redis://localhost', {}).and_call_original
       Pupa::Processor::DocumentStore.new('redis://localhost')
     end
   end

data/spec/processor/middleware/logger_spec.rb

@@ -27,15 +27,15 @@ describe Pupa::Processor::Middleware::Logger do
     end
 
     it 'should still return output' do
-      @response.body.should == 'hello'
+      expect(@response.body).to eq('hello')
     end
 
     it 'should log the method and URL' do
-      io.string.should match('get http:/hello')
+      expect(io.string).to match('get http:/hello')
     end
 
     it 'should log request headers' do
-      io.string.should match('Accept: "text/html')
+      expect(io.string).to match('Accept: "text/html')
     end
   end
 
@@ -62,11 +62,11 @@ describe Pupa::Processor::Middleware::Logger do
       end
 
       it 'should log the method and URL' do
-        io.string.should match('get http:/hello')
+        expect(io.string).to match('get http:/hello')
       end
 
       it 'should not log request headers' do
-        io.string.should_not match('Accept: "text/html')
+        expect(io.string).not_to match('Accept: "text/html')
       end
     end
 
@@ -76,11 +76,11 @@ describe Pupa::Processor::Middleware::Logger do
       end
 
       it 'should log the method and URL' do
-        io.string.should match('post http:/hello foo=bar')
+        expect(io.string).to match('post http:/hello foo=bar')
       end
 
       it 'should not log request headers' do
-        io.string.should_not match('Accept: "text/html')
+        expect(io.string).not_to match('Accept: "text/html')
       end
     end
   end

data/spec/processor/middleware/parse_json_spec.rb

@@ -85,6 +85,6 @@ describe Pupa::Processor::Middleware::ParseJson do
   end
 
   it "chokes on invalid json" do
-    expect{ process('{') }.to raise_error
+    expect{ process('{') }.to raise_error(Faraday::ParsingError)
   end
 end

data/spec/processor/yielder_spec.rb

@@ -21,11 +21,11 @@ describe Pupa::Processor::Yielder do
       yielder.each do |n|
         array << n
       end
-      array.should == (0..9).to_a
+      expect(array).to eq((0..9).to_a)
     end
 
     it 'should be composable with other iterators' do
-      yielder.each.map{|n| n}.should == (0..9).to_a
+      expect(yielder.each.map{|n| n}).to eq((0..9).to_a)
     end
   end
 
@@ -35,7 +35,7 @@ describe Pupa::Processor::Yielder do
       10.times do |n|
         array << yielder.next
       end
-      array.should == (0..9).to_a
+      expect(array).to eq((0..9).to_a)
     end
 
     it 'should raise an error if the enumerator is at the end' do
@@ -45,7 +45,7 @@ describe Pupa::Processor::Yielder do
 
   describe '#to_enum' do
     it 'should return an enumerator' do
-      yielder.to_enum.should be_a(Enumerator)
+      expect(yielder.to_enum).to be_a(Enumerator)
     end
 
     it 'should return a lazy enumerator' do