axiom-do-adapter 0.1.0 → 0.2.0

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

@@ -6,24 +6,22 @@ require 'axiom/relation/gateway'
 describe Relation::Gateway, '#extend' do
   subject { object.extend(args, &block) }
 
-  let(:adapter)  { mock('Adapter')                         }
-  let(:relation) { mock('Relation', :extend => response)   }
-  let(:response) { mock('New Relation', :kind_of? => true) }
-  let!(:object)  { described_class.new(adapter, relation)  }
-  let(:args)     { stub                                    }
-  let(:block)    { lambda { |context| }                    }
+  let(:adapter)  { double('Adapter')                         }
+  let(:relation) { double('Relation', extend: response)      }
+  let(:response) { double('New Relation', :kind_of? => true) }
+  let!(:object)  { described_class.new(adapter, relation)    }
+  let(:args)     { double                                    }
+  let(:block)    { ->(context) {}                            }
 
   it_should_behave_like 'a unary relation method'
 
   it 'forwards the arguments to relation#extend' do
-    relation.should_receive(:extend).with(args)
+    expect(relation).to receive(:extend).with(args)
     subject
   end
 
-  unless testing_block_passing_broken?
-    it 'forwards the block to relation#extend' do
-      relation.should_receive(:extend) { |&proc| proc.should equal(block) }
-      subject
-    end
+  it 'forwards the block to relation#extend' do
+    expect(relation).to receive(:extend) { |&proc| expect(proc).to equal(block) }
+    subject
   end
 end

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

@@ -6,12 +6,12 @@ require 'axiom/relation/gateway'
 describe Relation::Gateway, '#intersect' do
   subject { object.intersect(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)       { :intersect                             }
   let(:factory)         { Algebra::Intersection                  }
-  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/join_spec.rb

@@ -6,39 +6,39 @@ require 'axiom/relation/gateway'
 describe Relation::Gateway, '#join' do
   subject { object.join(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)       { :join                                  }
   let(:factory)         { Algebra::Join                          }
-  let(:binary_relation) { mock(factory)                          }
+  let(:binary_relation) { double(factory)                        }
 
   it_should_behave_like 'a binary relation method'
 
   context 'when passed a block' do
     subject { object.join(other) { |context| yields << context } }
 
-    let(:other_relation) { mock('Other Relation')                       }
+    let(:other_relation) { double('Other Relation')                     }
     let(:other)          { described_class.new(adapter, other_relation) }
-    let(:gateway)        { mock('Other Gateway')                        }
-    let(:join)           { mock('Join', :restrict => gateway)           }
+    let(:gateway)        { double('Other Gateway')                      }
+    let(:join)           { double('Join', restrict: gateway)            }
     let(:yields)         { []                                           }
 
     before do
-      Algebra::Join.stub!(:new).with(relation, other_relation).and_return(join)
+      allow(Algebra::Join).to receive(:new).with(relation, other_relation).and_return(join)
     end
 
     it { should equal(gateway) }
 
     it 'passes the relations to the join constructor' do
-      Algebra::Join.should_receive(:new).with(relation, other_relation)
+      expect(Algebra::Join).to receive(:new).with(relation, other_relation)
       subject
     end
 
     it 'passes the block to the join relation' do
-      context = mock('Context')
-      join.should_receive(:restrict).and_yield(context)
-      expect { subject }.to change { yields.dup }.from([]).to([ context ])
+      context = double('Context')
+      expect(join).to receive(:restrict).and_yield(context)
+      expect { subject }.to change { yields.dup }.from([]).to([context])
     end
   end
 end

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

@@ -6,22 +6,22 @@ require 'axiom/relation/gateway'
 describe Relation::Gateway, '#materialize' do
   subject { object.materialize }
 
-  let(:header)       { mock('Header')                                                                          }
-  let(:directions)   { mock('Directions')                                                                      }
-  let(:adapter)      { stub.as_null_object                                                                     }
-  let(:relation)     { mock('Relation', :header => header, :directions => directions, :materialized? => false) }
-  let!(:object)      { described_class.new(adapter, relation)                                                  }
-  let(:materialized) { mock('Materialized')                                                                    }
+  let(:header)       { double('Header')                                                                          }
+  let(:directions)   { double('Directions')                                                                      }
+  let(:adapter)      { double.as_null_object                                                                     }
+  let(:relation)     { double('Relation', :header => header, :directions => directions, :materialized? => false) }
+  let!(:object)      { described_class.new(adapter, relation)                                                    }
+  let(:materialized) { double('Materialized')                                                                    }
 
   before do
-    Relation::Materialized.stub!(:new).and_return(materialized)
-    Relation.stub!(:new).and_return(stub.as_null_object)
+    allow(Relation::Materialized).to receive(:new).and_return(materialized)
+    allow(Relation).to receive(:new).and_return(double.as_null_object)
   end
 
   it { should equal(materialized) }
 
   it 'initializes the materialized relation with the header, tuples and directions' do
-    Relation::Materialized.should_receive(:new).with(header, [], directions)
+    expect(Relation::Materialized).to receive(:new).with(header, [], directions)
     subject
   end
 end

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

@@ -6,18 +6,18 @@ require 'axiom/relation/gateway'
 describe Relation::Gateway, '#optimize' do
   subject { object.optimize }
 
-  let(:adapter)  { stub                                   }
-  let(:relation) { mock('Relation')                       }
+  let(:adapter)  { double                                 }
+  let(:relation) { double('Relation')                     }
   let(:object)   { described_class.new(adapter, relation) }
 
   before do
-    relation.stub!(:optimize).and_return(relation)
+    allow(relation).to receive(:optimize).and_return(relation)
   end
 
   it_should_behave_like 'a command method'
 
   it 'forwards the message to relation#optimize' do
-    relation.should_receive(:optimize).with(no_args)
+    expect(relation).to receive(:optimize).with(no_args)
     subject
   end
 end

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

@@ -6,12 +6,12 @@ require 'axiom/relation/gateway'
 describe Relation::Gateway, '#product' do
   subject { object.product(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)       { :product                               }
   let(:factory)         { Algebra::Product                       }
-  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/project_spec.rb

@@ -6,16 +6,16 @@ require 'axiom/relation/gateway'
 describe Relation::Gateway, '#project' do
   subject { object.project(args) }
 
-  let(:adapter)  { mock('Adapter')                         }
-  let(:relation) { mock('Relation', :project => 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', project: 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#project' do
-    relation.should_receive(:project).with(args)
+    expect(relation).to receive(:project).with(args)
     subject
   end
 end

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

@@ -6,16 +6,16 @@ require 'axiom/relation/gateway'
 describe Relation::Gateway, '#remove' do
   subject { object.remove(args) }
 
-  let(:adapter)  { mock('Adapter')                         }
-  let(:relation) { mock('Relation', :remove => 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', remove: 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#remove' do
-    relation.should_receive(:remove).with(args)
+    expect(relation).to receive(:remove).with(args)
     subject
   end
 end

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

@@ -6,16 +6,16 @@ require 'axiom/relation/gateway'
 describe Relation::Gateway, '#rename' do
   subject { object.rename(args) }
 
-  let(:adapter)  { mock('Adapter')                         }
-  let(:relation) { mock('Relation', :rename => 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', rename: 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#rename' do
-    relation.should_receive(:rename).with(args)
+    expect(relation).to receive(:rename).with(args)
     subject
   end
 end

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

@@ -6,8 +6,8 @@ require 'axiom/relation/gateway'
 describe Relation::Gateway, '#respond_to?' do
   subject { object.respond_to?(method) }
 
-  let(:relation) { mock('Relation', :header => stub)   }
-  let(:object)   { described_class.new(stub, relation) }
+  let(:relation) { double('Relation', header: double)    }
+  let(:object)   { described_class.new(double, relation) }
 
   context 'with an unknown method' do
     let(:method) { :unknown }

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

@@ -6,24 +6,22 @@ require 'axiom/relation/gateway'
 describe Relation::Gateway, '#restrict' do
   subject { object.restrict(args, &block) }
 
-  let(:adapter)  { mock('Adapter')                         }
-  let(:relation) { mock('Relation', :restrict => response) }
-  let(:response) { mock('New Relation', :kind_of? => true) }
-  let!(:object)  { described_class.new(adapter, relation)  }
-  let(:args)     { stub                                    }
-  let(:block)    { lambda { |context| }                    }
+  let(:adapter)  { double('Adapter')                         }
+  let(:relation) { double('Relation', restrict: response)    }
+  let(:response) { double('New Relation', :kind_of? => true) }
+  let!(:object)  { described_class.new(adapter, relation)    }
+  let(:args)     { double                                    }
+  let(:block)    { ->(context) {}                            }
 
   it_should_behave_like 'a unary relation method'
 
   it 'forwards the arguments to relation#restrict' do
-    relation.should_receive(:restrict).with(args)
+    expect(relation).to receive(:restrict).with(args)
     subject
   end
 
-  unless testing_block_passing_broken?
-    it 'forwards the block to relation#restrict' do
-      relation.should_receive(:restrict) { |_args, &proc| proc.should equal(block) }
-      subject
-    end
+  it 'forwards the block to relation#restrict' do
+    expect(relation).to receive(:restrict) { |_args, &proc| expect(proc).to equal(block) }
+    subject
   end
 end

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

@@ -6,16 +6,16 @@ require 'axiom/relation/gateway'
 describe Relation::Gateway, '#reverse' do
   subject { object.reverse(args) }
 
-  let(:adapter)  { mock('Adapter')                         }
-  let(:relation) { mock('Relation', :reverse => 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', reverse: 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#reverse' do
-    relation.should_receive(:reverse).with(args)
+    expect(relation).to receive(:reverse).with(args)
     subject
   end
 end

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

@@ -6,24 +6,22 @@ require 'axiom/relation/gateway'
 describe Relation::Gateway, '#sort_by' do
   subject { object.sort_by(args, &block) }
 
-  let(:adapter)  { mock('Adapter')                         }
-  let(:relation) { mock('Relation', :sort_by => response)  }
-  let(:response) { mock('New Relation', :kind_of? => true) }
-  let!(:object)  { described_class.new(adapter, relation)  }
-  let(:args)     { stub                                    }
-  let(:block)    { lambda { |context| }                    }
+  let(:adapter)  { double('Adapter')                         }
+  let(:relation) { double('Relation', sort_by: response)     }
+  let(:response) { double('New Relation', :kind_of? => true) }
+  let!(:object)  { described_class.new(adapter, relation)    }
+  let(:args)     { double                                    }
+  let(:block)    { ->(context) {}                            }
 
   it_should_behave_like 'a unary relation method'
 
   it 'forwards the arguments to relation#sort_by' do
-    relation.should_receive(:sort_by).with(args)
+    expect(relation).to receive(:sort_by).with(args)
     subject
   end
 
-  unless testing_block_passing_broken?
-    it 'forwards the block to relation#sort_by' do
-      relation.should_receive(:sort_by) { |&proc| proc.should equal(block) }
-      subject
-    end
+  it 'forwards the block to relation#sort_by' do
+    expect(relation).to receive(:sort_by) { |&proc| expect(proc).to equal(block) }
+    subject
   end
 end

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

@@ -4,41 +4,39 @@ require 'spec_helper'
 require 'axiom/relation/gateway'
 
 describe Relation::Gateway, '#summarize' do
-  let(:summarization) { mock('Summarization', :kind_of? => true)      }
-  let(:adapter)       { mock('Adapter')                               }
-  let(:relation)      { mock('Relation', :summarize => summarization) }
-  let!(:object)       { described_class.new(adapter, relation)        }
-  let(:block)         { lambda { |context| }                          }
+  let(:summarization) { double('Summarization', :kind_of? => true)   }
+  let(:adapter)       { double('Adapter')                            }
+  let(:relation)      { double('Relation', summarize: summarization) }
+  let!(:object)       { described_class.new(adapter, relation)       }
+  let(:block)         { ->(context) {}                               }
 
   context 'with no arguments' do
     subject { object.summarize(&block) }
 
-    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 'forwards the default summarize_with relation to relation#summarize' do
-      relation.should_receive(:summarize) do |other|
-        other.should equal(TABLE_DEE)
+      expect(relation).to receive(:summarize) do |other|
+        expect(other).to equal(TABLE_DEE)
       end
       subject
     end
 
-    unless testing_block_passing_broken?
-      it 'forwards the block to relation#summarize' do
-        relation.should_receive(:summarize) do |_summarize_with, &proc|
-          proc.should equal(block)
-        end
-        subject
+    it 'forwards the block to relation#summarize' do
+      expect(relation).to receive(:summarize) do |_summarize_with, &proc|
+        expect(proc).to equal(block)
       end
+      subject
     end
 
     it 'initializes the gateway with the adapter and summarization' do
-      described_class.should_receive(:new).with(adapter, summarization)
+      expect(described_class).to receive(:new).with(adapter, summarization)
       subject
     end
   end
@@ -46,33 +44,31 @@ describe Relation::Gateway, '#summarize' do
   context 'with a header' do
     subject { object.summarize(header, &block) }
 
-    let(:gateway) { mock('New Gateway') }
-    let(:header)  { mock('Header')      }
+    let(:gateway) { double('New Gateway') }
+    let(:header)  { double('Header')      }
 
     before do
-      described_class.stub!(:new).and_return(gateway)
+      allow(described_class).to receive(:new).and_return(gateway)
     end
 
     it { should equal(gateway) }
 
     it 'forwards the header to relation#summarize' do
-      relation.should_receive(:summarize) do |other|
-        other.should equal(header)
+      expect(relation).to receive(:summarize) do |other|
+        expect(other).to equal(header)
       end
       subject
     end
 
-    unless testing_block_passing_broken?
-      it 'forwards the block to relation#summarize' do
-        relation.should_receive(:summarize) do |_summarize_with, &proc|
-          proc.should equal(block)
-        end
-        subject
+    it 'forwards the block to relation#summarize' do
+      expect(relation).to receive(:summarize) do |_summarize_with, &proc|
+        expect(proc).to equal(block)
       end
+      subject
     end
 
     it 'initializes the gateway with the adapter and summarization' do
-      described_class.should_receive(:new).with(adapter, summarization)
+      expect(described_class).to receive(:new).with(adapter, summarization)
       subject
     end
   end
@@ -80,35 +76,33 @@ describe Relation::Gateway, '#summarize' do
   context 'when summarize_with has the same adapter' do
     subject { object.summarize(other, &block) }
 
-    let(:header)         { mock('Header')                               }
-    let(:other_relation) { mock('Other Relation', :header => header)    }
+    let(:header)         { double('Header')                             }
+    let(:other_relation) { double('Other Relation', header: header)     }
     let!(:other)         { described_class.new(adapter, other_relation) }
-    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 'forwards the other relation to relation#summarize' do
-      relation.should_receive(:summarize) do |other|
-        other.should equal(other_relation)
+      expect(relation).to receive(:summarize) do |other|
+        expect(other).to equal(other_relation)
       end
       subject
     end
 
-    unless testing_block_passing_broken?
-      it 'forwards the block to relation#summarize' do
-        relation.should_receive(:summarize) do |_summarize_with, &proc|
-          proc.should equal(block)
-        end
-        subject
+    it 'forwards the block to relation#summarize' do
+      expect(relation).to receive(:summarize) do |&proc|
+        expect(proc).to equal(block)
       end
+      subject
     end
 
     it 'initializes the gateway with the adapter and summarization' do
-      described_class.should_receive(:new).with(adapter, summarization)
+      expect(described_class).to receive(:new).with(adapter, summarization)
       subject
     end
   end
@@ -116,38 +110,38 @@ describe Relation::Gateway, '#summarize' do
   context 'with a relation' do
     subject { object.summarize(summarize_with, &block) }
 
-    let(:context_header)   { mock('Context Header')                              }
-    let(:header)           { mock('Header', :- => context_header)                }
-    let(:summarize_header) { mock('Summarize With Header')                       }
-    let(:summarize_with)   { mock('Other Relation', :header => summarize_header) }
-    let(:functions)        { mock('Functions')                                   }
-    let(:context)          { mock('Context', :functions => functions)            }
+    let(:context_header)   { double('Context Header')                           }
+    let(:header)           { double('Header', :- => context_header)             }
+    let(:summarize_header) { double('Summarize With Header')                    }
+    let(:summarize_with)   { double('Other Relation', header: summarize_header) }
+    let(:functions)        { double('Functions')                                }
+    let(:context)          { double('Context', functions: functions)            }
 
     before do
-      relation.stub!(:header).and_return(header)
-      Algebra::Summarization.stub!(:new).and_return(summarization)
-      Evaluator::Context.stub!(:new).and_return(context)
+      allow(relation).to receive(:header).and_return(header)
+      allow(Algebra::Summarization).to receive(:new).and_return(summarization)
+      allow(Evaluator::Context).to receive(:new).and_return(context)
     end
 
     it { should equal(summarization) }
 
     it 'gets the context header' do
-      header.should_receive(:-).with(summarize_header)
+      expect(header).to receive(:-).with(summarize_header)
       subject
     end
 
     it 'passes the context header into the context' do
-      Evaluator::Context.should_receive(:new).with(context_header)
+      expect(Evaluator::Context).to receive(:new).with(context_header)
       subject
     end
 
     it 'forwards the block to the context' do
-      Evaluator::Context.stub!(:new) { |_header, proc| proc.should equal(block) }.and_return(context)
+      allow(Evaluator::Context).to receive(:new) { |&proc| expect(proc).to equal(block) }.and_return(context)
       subject
     end
 
     it 'initializes the summarization with the gateway, the relation and the functions' do
-      Algebra::Summarization.should_receive(:new).with(object, summarize_with, functions)
+      expect(Algebra::Summarization).to receive(:new).with(object, summarize_with, functions)
       subject
     end
   end