axiom-do-adapter 0.1.0

data/spec/rcov.opts

@@ -0,0 +1,7 @@
+--exclude-only "spec/,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary
+--failure-threshold 100

data/spec/shared/binary_relation_method_behaviour.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+shared_examples_for 'a binary relation method' do
+  describe 'when other has the same adapter' do
+    let(:other_relation) { mock('Other Relation')                       }
+    let(:other)          { described_class.new(adapter, other_relation) }
+    let(:gateway)        { mock('Other Gateway')                        }
+
+    before do
+      relation.stub!(operation).and_return(gateway)
+    end
+
+    it { should equal(gateway) }
+
+    it 'passes the other relation to the binary operation' do
+      relation.should_receive(operation).with(other_relation)
+      subject
+    end
+  end
+
+  describe 'when other has a different adapter' do
+    let(:other_adapter) { mock('Other Adapter')                    }
+    let(:other)         { described_class.new(other_adapter, stub) }
+
+    before do
+      factory.stub!(:new).and_return(binary_relation)
+    end
+
+    it { should equal(binary_relation) }
+
+    it 'initializes the binary operation with the gateways' do
+      factory.should_receive(:new).with(object, other)
+      subject
+    end
+  end
+
+  describe 'when other has no adapter' do
+    let(:other) { mock('Other Relation') }
+
+    before do
+      factory.stub!(:new).and_return(binary_relation)
+    end
+
+    it { should equal(binary_relation) }
+
+    it 'initializes the binary operation with the gateway and other relation' do
+      factory.should_receive(:new).with(object, other)
+      subject
+    end
+  end
+end

data/spec/shared/unary_relation_method_behaviour.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+shared_examples_for 'a unary relation method' do
+  let(:gateway) { mock('New Gateway') }
+
+  before do
+    described_class.stub!(:new).and_return(gateway)
+  end
+
+  it { should equal(gateway) }
+
+  it 'tests the response is a relation' do
+    response.should_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)
+    subject
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,46 @@
+# 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.start do
+    command_name     'spec:unit'
+    add_filter       'config'
+    add_filter       'spec'
+    minimum_coverage 100
+  end
+end
+
+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
+
+  # Record the original Attribute descendants
+  config.before do
+    @original_descendants = Attribute.descendants.dup
+  end
+
+  # Reset the Attribute descendants
+  config.after do
+    Attribute.descendants.replace(@original_descendants)
+  end
+end

data/spec/support/config_alias.rb

@@ -0,0 +1,3 @@
+require 'rbconfig'
+
+::Config = RbConfig unless defined?(::Config)

data/spec/support/example_group_methods.rb

@@ -0,0 +1,7 @@
+module Spec
+  module ExampleGroupMethods
+    def testing_block_passing_broken?
+      RUBY_PLATFORM.include?('java') && JRUBY_VERSION <= '1.7.0.dev' && RUBY_VERSION >= '1.9.2'
+    end
+  end
+end

data/spec/support/ice_nine_config.rb

@@ -0,0 +1,6 @@
+module IceNine
+  class Freezer
+    class RSpec < NoFreeze
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'axiom/adapter/data_objects'
+
+describe Adapter::DataObjects, '.new' do
+  subject { object.new(uri) }
+
+  let(:uri)    { stub            }
+  let(:object) { described_class }
+
+  it { should be_instance_of(described_class) }
+
+  it { should be_frozen }
+end

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

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'axiom/adapter/data_objects'
+
+describe Adapter::DataObjects, '#read' do
+  let(:uri)       { stub                     }
+  let(:object)    { described_class.new(uri) }
+  let(:relation)  { mock('Relation')         }
+  let(:statement) { mock('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)
+  end
+
+  context 'with a block' do
+    subject { object.read(relation) { |row| yields << row } }
+
+    let(:connection) { mock('Connection', :close => nil) }
+
+    before do
+      DataObjects::Connection.stub!(: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)
+      subject
+    end
+
+    it 'closes a connection' do
+      connection.should_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 { subject }.to raise_error(mock_exception)
+    end
+
+    it 'yields each row' do
+      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)
+      subject
+    end
+  end
+
+  context 'without a block' do
+    subject { object.read(relation) }
+
+    it { should be_instance_of(to_enum.class) }
+  end
+end

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'axiom/adapter/data_objects/statement'
+
+describe Adapter::DataObjects::Statement, '.new' do
+  let(:connection) { stub            }
+  let(:relation)   { stub            }
+  let(:object)     { described_class }
+
+  context 'without a visitor' do
+    subject { object.new(connection, relation) }
+
+    it { should be_instance_of(described_class) }
+
+    it { should be_frozen }
+  end
+
+  context 'with a visitor' do
+    subject { object.new(connection, relation, visitor) }
+
+    let(:visitor) { stub }
+
+    it { should be_instance_of(described_class) }
+
+    it { should be_frozen }
+  end
+end

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

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+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)     { []                                                        }
+
+  before do
+    command.stub!(:dup => command, :freeze => command)
+    attribute.stub_chain(:class, :primitive).and_return(primitive)
+  end
+
+  context 'with no block' do
+    subject { object.each }
+
+    it { should be_instance_of(to_enum.class) }
+
+    it 'yields the expected attributes' do
+      subject.to_a.should eql(object.to_a)
+    end
+  end
+
+  context 'with a block' do
+    subject { object.each { |row| yields << row } }
+
+    before do
+      connection.should_receive(:create_command).with(object.to_s)
+
+      command.should_receive(:set_types).with([ primitive ]).ordered
+      command.should_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)
+      end
+
+      reader.should_receive(:next!).with(no_args).ordered.and_return(false)
+      reader.should_receive(:close).with(no_args).ordered
+    end
+
+    before do
+      relation.should_receive(:header)
+    end
+
+    it_should_behave_like 'a command method'
+
+    it 'yields each row' do
+      expect { subject }.to change { yields.dup }.
+        from([]).
+        to(rows)
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'spec_helper'
+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) }
+
+  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)
+    end
+
+    it_should_behave_like 'an idempotent method'
+
+    it { should be_frozen }
+
+    it { should equal(sql) }
+
+    it 'visits the relation' do
+      visitor.should_receive(:visit).with(relation)
+      subject
+    end
+  end
+
+  context 'with a visitor' do
+    let(:visitor) { mock('Visitor', :visit => generator)               }
+    let(:object)  { described_class.new(connection, relation, visitor) }
+
+    before do
+      visitor.stub!(:visit).and_return(generator)
+    end
+
+    it_should_behave_like 'an idempotent method'
+
+    it { should be_frozen }
+
+    it { should equal(sql) }
+
+    it 'visits the relation' do
+      visitor.should_receive(:visit).with(relation)
+      subject
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'axiom/relation/gateway'
+
+describe Relation::Gateway, '.new' do
+  subject { object.new(adapter, relation) }
+
+  let(:adapter)  { stub            }
+  let(:relation) { stub            }
+  let(:object)   { described_class }
+
+  it { should be_instance_of(described_class) }
+
+  it { should be_frozen }
+end

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

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

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

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+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                                    }
+
+  it_should_behave_like 'a unary relation method'
+
+  it 'forwards the arguments to relation#drop' do
+    relation.should_receive(:drop).with(args)
+    subject
+  end
+end