axiom-do-adapter 0.1.0 → 0.2.0

data/spec/shared/unary_relation_method_behaviour.rb

@@ -1,21 +1,21 @@
 # encoding: utf-8
 
 shared_examples_for 'a unary relation method' do
-  let(:gateway) { mock('New Gateway') }
+  let(:gateway) { double('New Gateway') }
 
   before do
-    described_class.stub!(:new).and_return(gateway)
+    allow(described_class).to receive(:new).and_return(gateway)
   end
 
   it { should equal(gateway) }
 
   it 'tests the response is a relation' do
-    response.should_receive(:kind_of?).with(Relation)
+    expect(response).to receive(:kind_of?).with(Relation)
     subject
   end
 
   it 'initializes the new gateway with the adapter and response' do
-    described_class.should_receive(:new).with(adapter, response)
+    expect(described_class).to receive(:new).with(adapter, response)
     subject
   end
 end

data/spec/spec_helper.rb

@@ -1,38 +1,33 @@
 # encoding: utf-8
 
-require 'backports'
-require 'backports/basic_object' unless defined?(::BasicObject)
-require 'devtools/spec_helper'
-require 'ice_nine'
-
 if ENV['COVERAGE'] == 'true'
   require 'simplecov'
   require 'coveralls'
 
-  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-  ]
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[    SimpleCov::Formatter::HTMLFormatter,
+                                                                 Coveralls::SimpleCov::Formatter
+]
 
   SimpleCov.start do
-    command_name     'spec:unit'
-    add_filter       'config'
-    add_filter       'spec'
+    command_name 'spec:unit'
+
+    add_filter 'config'
+    add_filter 'spec'
+    add_filter 'vendor'
+
     minimum_coverage 100
   end
 end
 
+require 'devtools/spec_helper'
 require 'axiom-do-adapter'
 
 include Axiom
 
-# require spec support files and shared behavior
-Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each do |file|
-  require file
-end
-
 RSpec.configure do |config|
-  config.extend Spec::ExampleGroupMethods
+  config.expect_with :rspec do |expect_with|
+    expect_with.syntax = :expect
+  end
 
   # Record the original Attribute descendants
   config.before do

data/spec/support/config_alias.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'rbconfig'
 
 ::Config = RbConfig unless defined?(::Config)

data/spec/unit/axiom/adapter/data_objects/class_methods/new_spec.rb

@@ -6,7 +6,7 @@ require 'axiom/adapter/data_objects'
 describe Adapter::DataObjects, '.new' do
   subject { object.new(uri) }
 
-  let(:uri)    { stub            }
+  let(:uri)    { double          }
   let(:object) { described_class }
 
   it { should be_instance_of(described_class) }

data/spec/unit/axiom/adapter/data_objects/read_spec.rb

@@ -4,56 +4,52 @@ require 'spec_helper'
 require 'axiom/adapter/data_objects'
 
 describe Adapter::DataObjects, '#read' do
-  let(:uri)       { stub                     }
+  let(:uri)       { double                   }
   let(:object)    { described_class.new(uri) }
-  let(:relation)  { mock('Relation')         }
-  let(:statement) { mock('Statement')        }
-  let(:rows)      { [ [ 1 ], [ 2 ], [ 3 ] ]  }
+  let(:relation)  { double('Relation')       }
+  let(:statement) { double('Statement')      }
+  let(:rows)      { [[1], [2], [3]]          }
   let(:yields)    { []                       }
 
   before do
-    expectation = statement.stub(:each)
-    rows.each { |row| expectation.and_yield(row) }
-
-    described_class::Statement.stub!(:new).and_return(statement)
+    allow(statement).to receive(:each, &rows.method(:each))
+    allow(described_class::Statement).to receive(:new).and_return(statement)
   end
 
   context 'with a block' do
     subject { object.read(relation) { |row| yields << row } }
 
-    let(:connection) { mock('Connection', :close => nil) }
+    let(:connection) { double('Connection', close: nil) }
 
     before do
-      DataObjects::Connection.stub!(:new).and_return(connection)
+      allow(DataObjects::Connection).to receive(:new).and_return(connection)
     end
 
     it_should_behave_like 'a command method'
 
     it 'opens a connection' do
-      DataObjects::Connection.should_receive(:new).with(uri).and_return(connection)
+      expect(DataObjects::Connection).to receive(:new).with(uri).and_return(connection)
       subject
     end
 
     it 'closes a connection' do
-      connection.should_receive(:close).with(no_args)
+      expect(connection).to receive(:close).with(no_args)
       subject
     end
 
     it 'does not close a connection if the constructor throws an exception' do
       mock_exception = Class.new(Exception)
-      DataObjects::Connection.should_receive(:new).and_raise(mock_exception)
-      connection.should_not_receive(:close)
+      expect(DataObjects::Connection).to receive(:new).and_raise(mock_exception)
+      expect(connection).not_to receive(:close)
       expect { subject }.to raise_error(mock_exception)
     end
 
     it 'yields each row' do
-      expect { subject }.to change { yields.dup }.
-        from([]).
-        to(rows)
+      expect { subject }.to change { yields.dup }.from([]).to(rows)
     end
 
     it 'initializes a statement' do
-      described_class::Statement.should_receive(:new).with(connection, relation).and_return(statement)
+      expect(described_class::Statement).to receive(:new).with(connection, relation).and_return(statement)
       subject
     end
   end

data/spec/unit/axiom/adapter/data_objects/statement/class_methods/new_spec.rb

@@ -4,8 +4,8 @@ require 'spec_helper'
 require 'axiom/adapter/data_objects/statement'
 
 describe Adapter::DataObjects::Statement, '.new' do
-  let(:connection) { stub            }
-  let(:relation)   { stub            }
+  let(:connection) { double          }
+  let(:relation)   { double          }
   let(:object)     { described_class }
 
   context 'without a visitor' do
@@ -19,7 +19,7 @@ describe Adapter::DataObjects::Statement, '.new' do
   context 'with a visitor' do
     subject { object.new(connection, relation, visitor) }
 
-    let(:visitor) { stub }
+    let(:visitor) { double }
 
     it { should be_instance_of(described_class) }
 

data/spec/unit/axiom/adapter/data_objects/statement/each_spec.rb

@@ -4,20 +4,21 @@ require 'spec_helper'
 require 'axiom/adapter/data_objects/statement'
 
 describe Adapter::DataObjects::Statement, '#each' do
-  let(:reader)     { mock('Reader', :next! => false).as_null_object            }
-  let(:command)    { mock('Command', :execute_reader => reader).as_null_object }
-  let(:connection) { mock('Connection', :create_command => command)            }
-  let(:attribute)  { stub                                                      }
-  let(:primitive)  { stub                                                      }
-  let(:relation)   { mock('Relation', :header => [ attribute ])                }
-  let(:generator)  { mock('Generator').as_null_object                          }
-  let(:rows)       { [ stub, stub ]                                            }
-  let(:object)     { described_class.new(connection, relation, generator)      }
-  let(:yields)     { []                                                        }
+  let(:reader)     { double('Reader', :next! => false).as_null_object         }
+  let(:command)    { double('Command', execute_reader: reader).as_null_object }
+  let(:connection) { double('Connection', create_command: command)            }
+  let(:attribute)  { double                                                   }
+  let(:primitive)  { double                                                   }
+  let(:relation)   { double('Relation', header: [attribute])                  }
+  let(:generator)  { double('Generator').as_null_object                       }
+  let(:rows)       { [double, double]                                         }
+  let(:object)     { described_class.new(connection, relation, generator)     }
+  let(:yields)     { []                                                       }
 
   before do
-    command.stub!(:dup => command, :freeze => command)
-    attribute.stub_chain(:class, :primitive).and_return(primitive)
+    allow(command).to receive(:dup).and_return(command)
+    allow(command).to receive(:freeze).and_return(command)
+    attribute.stub_chain(:type, :primitive).and_return(primitive)
   end
 
   context 'with no block' do
@@ -26,7 +27,7 @@ describe Adapter::DataObjects::Statement, '#each' do
     it { should be_instance_of(to_enum.class) }
 
     it 'yields the expected attributes' do
-      subject.to_a.should eql(object.to_a)
+      expect(subject.to_a).to eql(object.to_a)
     end
   end
 
@@ -34,30 +35,28 @@ describe Adapter::DataObjects::Statement, '#each' do
     subject { object.each { |row| yields << row } }
 
     before do
-      connection.should_receive(:create_command).with(object.to_s)
+      expect(connection).to receive(:create_command).with(object.to_s)
 
-      command.should_receive(:set_types).with([ primitive ]).ordered
-      command.should_receive(:execute_reader).with(no_args).ordered
+      expect(command).to receive(:set_types).with([primitive]).ordered
+      expect(command).to receive(:execute_reader).with(no_args).ordered
 
       rows.each do |values|
-        reader.should_receive(:next!).with(no_args).ordered.and_return(true)
-        reader.should_receive(:values).with(no_args).ordered.and_return(values)
+        expect(reader).to receive(:next!).with(no_args).ordered.and_return(true)
+        expect(reader).to receive(:values).with(no_args).ordered.and_return(values)
       end
 
-      reader.should_receive(:next!).with(no_args).ordered.and_return(false)
-      reader.should_receive(:close).with(no_args).ordered
+      expect(reader).to receive(:next!).with(no_args).ordered.and_return(false)
+      expect(reader).to receive(:close).with(no_args).ordered
     end
 
     before do
-      relation.should_receive(:header)
+      expect(relation).to receive(:header)
     end
 
     it_should_behave_like 'a command method'
 
     it 'yields each row' do
-      expect { subject }.to change { yields.dup }.
-        from([]).
-        to(rows)
+      expect { subject }.to change { yields.dup }.from([]).to(rows)
     end
   end
 end

data/spec/unit/axiom/adapter/data_objects/statement/to_s_spec.rb

@@ -6,17 +6,17 @@ require 'axiom/adapter/data_objects/statement'
 describe Adapter::DataObjects::Statement, '#to_s' do
   subject { object.to_s }
 
-  let(:sql)        { mock('SQL')                       }
-  let(:connection) { stub                              }
-  let(:relation)   { mock('Relation')                  }
-  let(:generator)  { mock('Generator', :to_sql => sql) }
+  let(:sql)        { double('SQL')                    }
+  let(:connection) { double                           }
+  let(:relation)   { double('Relation')               }
+  let(:generator)  { double('Generator', to_sql: sql) }
 
   context 'without a visitor' do
     let(:visitor) { SQL::Generator::Relation                  }  # default visitor
     let(:object)  { described_class.new(connection, relation) }
 
     before do
-      visitor.stub!(:visit).and_return(generator)
+      allow(visitor).to receive(:visit).and_return(generator)
     end
 
     it_should_behave_like 'an idempotent method'
@@ -26,17 +26,17 @@ describe Adapter::DataObjects::Statement, '#to_s' do
     it { should equal(sql) }
 
     it 'visits the relation' do
-      visitor.should_receive(:visit).with(relation)
+      expect(visitor).to receive(:visit).with(relation)
       subject
     end
   end
 
   context 'with a visitor' do
-    let(:visitor) { mock('Visitor', :visit => generator)               }
+    let(:visitor) { double('Visitor', visit: generator)                }
     let(:object)  { described_class.new(connection, relation, visitor) }
 
     before do
-      visitor.stub!(:visit).and_return(generator)
+      allow(visitor).to receive(:visit).and_return(generator)
     end
 
     it_should_behave_like 'an idempotent method'
@@ -46,7 +46,7 @@ describe Adapter::DataObjects::Statement, '#to_s' do
     it { should equal(sql) }
 
     it 'visits the relation' do
-      visitor.should_receive(:visit).with(relation)
+      expect(visitor).to receive(:visit).with(relation)
       subject
     end
   end

data/spec/unit/axiom/relation/gateway/class_methods/new_spec.rb

@@ -6,8 +6,8 @@ require 'axiom/relation/gateway'
 describe Relation::Gateway, '.new' do
   subject { object.new(adapter, relation) }
 
-  let(:adapter)  { stub            }
-  let(:relation) { stub            }
+  let(:adapter)  { double          }
+  let(:relation) { double          }
   let(:object)   { described_class }
 
   it { should be_instance_of(described_class) }

data/spec/unit/axiom/relation/gateway/difference_spec.rb

@@ -6,12 +6,12 @@ require 'axiom/relation/gateway'
 describe Relation::Gateway, '#difference' do
   subject { object.difference(other) }
 
-  let(:adapter)         { mock('Adapter')                        }
-  let(:relation)        { mock('Relation')                       }
+  let(:adapter)         { double('Adapter')                      }
+  let(:relation)        { double('Relation')                     }
   let(:object)          { described_class.new(adapter, relation) }
   let(:operation)       { :difference                            }
   let(:factory)         { Algebra::Difference                    }
-  let(:binary_relation) { mock(factory)                          }
+  let(:binary_relation) { double(factory)                        }
 
   it_should_behave_like 'a binary relation method'
 end

data/spec/unit/axiom/relation/gateway/drop_spec.rb

@@ -6,16 +6,16 @@ require 'axiom/relation/gateway'
 describe Relation::Gateway, '#drop' do
   subject { object.drop(args) }
 
-  let(:adapter)  { mock('Adapter')                         }
-  let(:relation) { mock('Relation', :drop => response)     }
-  let(:response) { mock('New Relation', :kind_of? => true) }
-  let!(:object)  { described_class.new(adapter, relation)  }
-  let(:args)     { stub                                    }
+  let(:adapter)  { double('Adapter')                         }
+  let(:relation) { double('Relation', drop: response)        }
+  let(:response) { double('New Relation', :kind_of? => true) }
+  let!(:object)  { described_class.new(adapter, relation)    }
+  let(:args)     { double                                    }
 
   it_should_behave_like 'a unary relation method'
 
   it 'forwards the arguments to relation#drop' do
-    relation.should_receive(:drop).with(args)
+    expect(relation).to receive(:drop).with(args)
     subject
   end
 end

data/spec/unit/axiom/relation/gateway/each_spec.rb

@@ -6,50 +6,48 @@ require 'axiom/relation/gateway'
 describe Relation::Gateway, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
-  let(:header)   { mock('Header')                         }
-  let(:reader)   { mock('Reader')                         }
-  let(:tuple)    { mock('Tuple')                          }
-  let(:adapter)  { mock('Adapter')                        }
-  let(:relation) { mock('Relation')                       }
+  let(:header)   { double('Header')                       }
+  let(:reader)   { double('Reader')                       }
+  let(:tuple)    { double('Tuple')                        }
+  let(:adapter)  { double('Adapter')                      }
+  let(:relation) { double('Relation')                     }
   let!(:object)  { described_class.new(adapter, relation) }
   let(:yields)   { []                                     }
 
   context 'with an unmaterialized relation' do
-    let(:wrapper) { stub }
+    let(:wrapper) { double }
 
     before do
-      adapter.stub!(:read).and_return(reader)
+      allow(adapter).to receive(:read).and_return(reader)
 
-      relation.stub!(:header).and_return(header)
-      relation.stub!(:materialized?).and_return(false)
-      relation.stub!(:each).and_return(relation)
+      allow(relation).to receive(:header).and_return(header)
+      allow(relation).to receive(:materialized?).and_return(false)
+      allow(relation).to receive(:each).and_return(relation)
 
-      wrapper.stub!(:each).and_yield(tuple)
-      Relation.stub!(:new).and_return(wrapper)
+      allow(wrapper).to receive(:each).and_yield(tuple)
+      allow(Relation).to receive(:new).and_return(wrapper)
     end
 
     it_should_behave_like 'an #each method'
 
     it 'yields each tuple' do
-      expect { subject }.to change { yields.dup }.
-        from([]).
-        to([ tuple ])
+      expect { subject }.to change { yields.dup }.from([]).to([tuple])
     end
 
     it 'passes in the relation to the adapter reader' do
-      adapter.should_receive(:read).with(relation)
+      expect(adapter).to receive(:read).with(relation)
       subject
     end
 
     it 'passes in the relation header and reader to the wrapper constructor' do
-      Relation.should_receive(:new).with(header, reader)
+      expect(Relation).to receive(:new).with(header, reader)
       subject
     end
   end
 
   context 'with a materialized relation' do
     before do
-      relation.stub!(:materialized?).and_return(true)
+      allow(relation).to receive(:materialized?).and_return(true)
 
       tuple = self.tuple
 
@@ -68,18 +66,16 @@ describe Relation::Gateway, '#each' do
     it_should_behave_like 'an #each method'
 
     it 'yields each tuple' do
-      expect { subject }.to change { yields.dup }.
-        from([]).
-        to([ tuple ])
+      expect { subject }.to change { yields.dup }.from([]).to([tuple])
     end
 
     it 'does not create a reader' do
-      adapter.should_not_receive(:read)
+      expect(adapter).not_to receive(:read)
       subject
     end
 
     it 'does not create a wrapper' do
-      Relation.should_not_receive(:new)
+      expect(Relation).not_to receive(:new)
       subject
     end
   end