dbagile 0.0.1

data/test/unit/core/schema/stage_script.spec

@@ -0,0 +1,26 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::Core::Schema#stage_script" do
+  
+  let(:announced) { DbAgile::Fixtures::Core::Schema::schema(:left)  }
+  let(:effective) { DbAgile::Fixtures::Core::Schema::schema(:right) }
+  
+  it "should compute the operation list correctly" do
+    merged = DbAgile::Core::Schema::merge(effective, announced){|l,r| nil}
+    ops = DbAgile::Core::Schema::stage_script(merged, {:expand => true, :collapse => true})
+    ops.should be_kind_of(DbAgile::Core::Schema::Migrate::AbstractScript)
+    ops.each{|op|
+      case op.kind
+        when :create_table
+          op.operations.size.should >= 1
+        when :drop_table
+        when :expand_table
+          op.operations.size.should == 1
+        when :collapse_table
+          op.operations.size.should == 1
+        else
+          raise "Unexpected operation kind #{op.kind}"
+      end
+    }
+  end
+
+end

data/test/unit/core/schema/to_yaml.spec

@@ -0,0 +1,13 @@
+require File.expand_path('../fixtures', __FILE__)
+require 'yaml'
+describe "DbAgile::Core::Schema#to_yaml /" do
+  
+  it "should work on all fixture files" do
+    DbAgile::Fixtures::Core::Schema::each_schema_file{|yaml_file|
+      schema = DbAgile::Core::Schema::yaml_file_load(yaml_file)
+      schema.to_yaml.should be_a_valid_yaml_string  
+      DbAgile::Core::Schema::yaml_load(schema.to_yaml).should be_kind_of(DbAgile::Core::Schema::DatabaseSchema)
+    }
+  end
+  
+end

data/test/unit/core/schema/yaml_display.spec

@@ -0,0 +1,14 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::Core::Schema / to_yaml_str" do
+  
+  let(:left) { DbAgile::Fixtures::Core::Schema::schema(:left)  }
+  let(:right){ DbAgile::Fixtures::Core::Schema::schema(:right) }
+  
+  it "should not print the ---" do
+    env = DbAgile::default_environment
+    env.message_buffer = StringIO.new
+    merged = DbAgile::Core::Schema::merge(left, right){|l,r| nil}
+    lambda{ merged.yaml_display(env) }.should_not raise_error
+  end
+  
+end

data/test/unit/core/schema/yaml_load.spec

@@ -0,0 +1,20 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::Core::Schema::yaml_load /" do
+  
+  let(:yaml_file){ DbAgile::Fixtures::Core::Schema::schema_file(:suppliers_and_parts) }
+  
+  it "should be YAML loadable from a file" do
+    DbAgile::Core::Schema::yaml_file_load(yaml_file).should be_kind_of(DbAgile::Core::Schema::DatabaseSchema)
+  end
+
+  it "should be YAML loadable from an IO" do
+    File.open(yaml_file, "r") do |io|
+      DbAgile::Core::Schema::yaml_file_load(io).should be_kind_of(DbAgile::Core::Schema::DatabaseSchema)
+    end
+  end
+
+  it "should be YAML loadable from an String" do
+    DbAgile::Core::Schema::yaml_load(File.read(yaml_file)).should be_kind_of(DbAgile::Core::Schema::DatabaseSchema)
+  end
+  
+end

data/test/unit/core/transaction/transaction.spec

@@ -0,0 +1,10 @@
+require File.expand_path('../../../fixtures', __FILE__)
+describe "DbAgile::Core::Transaction" do
+  
+  subject{ ::DbAgile::Core::Transaction.new(nil) }
+  it{ should respond_to(:ping) }
+  it{ should respond_to(:dataset) }
+  it{ should respond_to(:create_table) }
+  
+end
+  

data/test/unit/fixtures.rb

@@ -0,0 +1,67 @@
+require File.expand_path('../../spec_helper', __FILE__)
+module DbAgile
+  module Fixtures
+    
+    module Utils
+      
+      # Finds a file
+      def find_file(name_or_file, resolver, extension = nil)
+        if name_or_file.kind_of?(Symbol)
+          name_or_file = find_file("#{name_or_file}#{extension}", resolver) 
+        end
+        unless name_or_file[0, 1] == '/'
+          name_or_file = File.expand_path("../fixtures/#{name_or_file}#{extension}", resolver) 
+        end
+        name_or_file
+      end
+      
+      # Yields block for each file with a given extension
+      def each_file(resolver, extension, &block)
+        Dir[File.expand_path("../fixtures/*.#{extension}", resolver)].each(&block)
+      end
+      
+      # Yields block for each file with a given extension
+      def each_dir(resolver, &block)
+        Dir[File.expand_path("../fixtures/*", resolver)].each(&block)
+      end
+      
+    end
+    
+    class SayHello
+      def del_to_block
+        yield
+      end
+      def say_hello(who)
+        who
+      end
+    end
+    
+    class Reverse
+      def say_hello(who)
+        delegate.say_hello(who.reverse)
+      end
+    end
+    
+    class Upcase
+      def say_hello(who)
+        delegate.say_hello(who.upcase)
+      end
+    end
+    
+    class Downcase
+      def say_hello(who)
+        delegate.say_hello(who.downcase)
+      end
+    end
+    
+    class Capitalize
+      def initialize(method = :capitalize)
+        @method = method
+      end
+      def say_hello(who)
+        delegate.say_hello(who.send(@method))
+      end
+    end
+
+  end
+end

data/test/unit/io/to_xxx.spec

@@ -0,0 +1,52 @@
+require File.expand_path('../../fixtures', __FILE__)
+
+describe "DbAgile::IO /" do
+
+  # Class sanity
+  describe "Class interface" do
+
+    DbAgile::IO::KNOWN_TO_FORMATS.each do |format|
+      specify{ DbAgile::IO.should respond_to("to_#{format}".to_sym) }
+    end
+
+    DbAgile::IO::KNOWN_FROM_FORMATS.each do |format|
+      specify{ DbAgile::IO.should respond_to("from_#{format}".to_sym) }
+    end
+    
+  end
+
+  # Some tools
+  let(:relation_like){[
+    {:id => 1, :name => "DbAgile", :version => DbAgile::VERSION},
+    {:id => 2, :name => "SByC", :version => SByC::VERSION}
+  ]}
+  let(:columns){ [ :id, :name, :version ] }
+
+  ::DbAgile::IO::KNOWN_FORMATS.each do |format|
+    
+    describe "#{format} format /" do 
+      let(:options){ DbAgile::IO::roundtrip_options(format) }
+      let(:encoder){ lambda { 
+        DbAgile::IO.send("to_#{format}".to_sym, relation_like, columns, StringIO.new, options) 
+      }}
+      let(:decoder){ lambda { 
+        DbAgile::IO.send("from_#{format}".to_sym, StringIO.new(encoder.call.string), options) 
+      }}
+      
+      specify "it should support a to_#{format} that returns the buffer" do
+        encoder.should_not raise_error 
+        encoder.call.should be_kind_of(StringIO)
+      end
+    
+      next unless  DbAgile::IO.respond_to?("from_#{format}") 
+
+      specify "it should support roundtrip" do
+        decoder.should_not raise_error
+        decoder.call.should == relation_like
+      end
+        
+    end
+    
+  end # ::DbAgile::IO::KNOWN_FORMATS
+  
+end # describe DbAgile::IO

data/test/unit/plugin/options.spec

@@ -0,0 +1,21 @@
+require File.expand_path('../../fixtures', __FILE__)
+describe "::DbAgile::Plugin#options" do
+  
+  let(:defplugin){ 
+    class DefPlugin < ::DbAgile::Plugin
+      def default_options() {:default => 12} end
+    end
+    DefPlugin
+  }
+  
+  describe "When initialize with default options without overriding" do
+    subject{ defplugin.new(:name => "dbagile").options }
+    it { should == {:default => 12, :name => "dbagile"} }
+  end
+
+  describe "When initialize with default options with overriding" do
+    subject{ defplugin.new(:default => 1, :name => "dbagile").options }
+    it { should == {:default => 1, :name => "dbagile"} }
+  end
+
+end

data/test/unit/plugin/tuple_heading.spec

@@ -0,0 +1,11 @@
+require File.expand_path('../../fixtures', __FILE__)
+describe "::DbAgile::Plugin#tuple_heading" do
+  
+  let(:plugin){ DbAgile::Plugin.new }
+  
+  describe "When called on on a typical tuple" do
+    subject{ plugin.send(:tuple_heading, :id => 1, :name => "dbagile") }
+    it{ should == {:id => Fixnum, :name => String} }
+  end
+
+end

data/test/unit/plugin/with_options.spec

@@ -0,0 +1,12 @@
+require File.expand_path('../../fixtures', __FILE__)
+describe "::DbAgile::Plugin.with_options" do
+  
+  let(:subClass){ Class.new(::DbAgile::Plugin) }
+  
+  context "when called on a subclass" do
+    subject{ subClass[:hello => "world"] }
+    it{ should be_kind_of(subClass) }
+    specify{ subject.options.should == {:hello => "world"}}
+  end
+  
+end

data/test/unit/tools/ruby/class_unqualified_name.spec

@@ -0,0 +1,26 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::RubyTools#class_unqualified_name /" do
+  
+  subject{ DbAgile::RubyTools::class_unqualified_name(clazz) }
+  
+  describe "when called on unqualified class" do
+    let(:clazz){ ::String }
+    it{ should == "String" }
+  end
+  
+  describe "when called on qualified class" do
+    let(:clazz){ DbAgile::RubyTools }
+    it{ should == "RubyTools" }
+  end
+  
+  describe "when called on long qualified class" do
+    let(:clazz){ DbAgile::Fixtures::Utils }
+    it{ should == "Utils" }
+  end
+  
+  describe "when piped with parent_module" do
+    let(:clazz){ DbAgile::RubyTools::parent_module(DbAgile::Fixtures::Utils) }
+    it{ should == "Fixtures" }
+  end
+
+end

data/test/unit/tools/ruby/extract_file_rdoc.spec

@@ -0,0 +1,10 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::RubyTools#extract_file_rdoc /" do
+  
+  subject{ DbAgile::RubyTools::extract_file_rdoc(File.expand_path('../fixtures.rb', __FILE__)) }
+  
+  it "should be as expected" do
+    subject.should == File.read(File.expand_path('../fixtures/rdoc.txt', __FILE__))
+  end
+  
+end

data/test/unit/tools/ruby/fixtures/rdoc.txt

@@ -0,0 +1,12 @@
+
+This is a fixtures helper that matches documentation conventions.
+
+This is a second paragraph
+That append on two lines
+
+
+WARNING:
+  This kind of indentation should not be interpreted as code
+
+  But this one yes
+

data/test/unit/tools/ruby/fixtures.rb

@@ -0,0 +1,19 @@
+require File.expand_path('../../../fixtures', __FILE__)
+module DbAgile
+  module Fixtures
+    #
+    # This is a fixtures helper that matches documentation conventions.
+    #
+    # This is a second paragraph
+    # That append on two lines
+    #
+    #
+    # WARNING:
+    #   This kind of indentation should not be interpreted as code
+    #
+    #   But this one yes
+    #
+    module RubyTools
+    end # module RubyTools
+  end # module Fixtures
+end # module DbAgile

data/test/unit/tools/ruby/optional_args_block_call.spec

@@ -0,0 +1,35 @@
+require File.expand_path('../../../fixtures', __FILE__)
+describe "DbAgile::RubyTools#optional_args_block_call /" do
+  
+  subject{ DbAgile::RubyTools::optional_args_block_call(block, args) }
+  
+  describe "when block has no arguments /" do
+    let(:block){ lambda {
+      "ok"
+    } }
+
+    describe "when no args are given" do
+      let(:args){ [ ] } 
+      it { should == "ok" }
+    end
+
+    describe "when no args are given" do
+      let(:args){ [ "hello" ] } 
+      it { should == "ok" }
+    end
+
+  end
+  
+  describe "when block has one arguments /" do
+    let(:block){ lambda {|name|
+      name
+    } }
+
+    describe "when args are given" do
+      let(:args){ [ "hello" ] } 
+      it { should == "hello" }
+    end
+
+  end
+  
+end

data/test/unit/tools/ruby/parent_module.spec

@@ -0,0 +1,21 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::RubyTools#parent_module /" do
+  
+  subject{ DbAgile::RubyTools::parent_module(clazz) }
+  
+  describe "when called on unqualified class" do
+    let(:clazz){ ::String }
+    it{ should be_nil }
+  end
+  
+  describe "when called on qualified class" do
+    let(:clazz){ DbAgile::RubyTools }
+    it{ should == DbAgile }
+  end
+  
+  describe "when called on long qualified class" do
+    let(:clazz){ DbAgile::Fixtures::Utils }
+    it{ should == DbAgile::Fixtures }
+  end
+  
+end

data/test/unit/tools/ruby/rdoc_file_paragraphs.spec

@@ -0,0 +1,13 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::RubyTools#extract_file_rdoc /" do
+  
+  subject{ DbAgile::RubyTools::rdoc_file_paragraphs(File.expand_path('../fixtures.rb', __FILE__)) }
+  
+  it "should be as expected" do
+    subject.should == ["This is a fixtures helper that matches documentation conventions.\n", 
+                       "This is a second paragraph\nThat append on two lines\n", 
+                       "WARNING:\n  This kind of indentation should not be interpreted as code\n", 
+                       "  But this one yes\n"]
+  end
+  
+end

data/test/unit/tools/tuple/tuple_heading.spec

@@ -0,0 +1,11 @@
+require File.expand_path('../../../fixtures', __FILE__)
+describe "::DbAgile::Tools::Tuple#tuple_heading" do
+  
+  let(:tools){ Object.new.extend(DbAgile::Tools::Tuple) }
+  
+  describe "When called on on a typical tuple" do
+    subject{ tools.tuple_heading(:id => 1, :name => "dbagile") }
+    it{ should == {:id => Fixnum, :name => String} }
+  end
+
+end

data/test/unit/tools/tuple/tuple_key.spec

@@ -0,0 +1,27 @@
+require File.expand_path('../../../fixtures', __FILE__)
+describe "::DbAgile::Tools::Tuple#tuple_key" do
+  
+  let(:tools){ Object.new.extend(DbAgile::Tools::Tuple) }
+  let(:tuple){ {:id => 1, :name => "dbagile", :version => DbAgile::VERSION} }
+  
+  describe "When called without keys info" do
+    subject{ tools.tuple_key(tuple, nil) }
+    it{ should == tuple }
+  end
+  
+  describe "When called without matching key" do
+    subject{ tools.tuple_key(tuple, [[:hello], [:world, [:again]]]) }
+    it{ should == tuple }
+  end
+  
+  describe "When called with a single matching key" do
+    subject{ tools.tuple_key(tuple, [ [:id] ]) }
+    it{ should == {:id => 1} }
+  end
+  
+  describe "When called with a composite second matching key" do
+    subject{ tools.tuple_key(tuple, [ [:id2], [:name, :version] ]) }
+    it{ should == {:name => "dbagile", :version => DbAgile::VERSION} }
+  end
+  
+end

data/test/unit/tools/tuple/tuple_project.spec

@@ -0,0 +1,23 @@
+require File.expand_path('../../../fixtures', __FILE__)
+describe "::DbAgile::Tools::Tuple#tuple_project" do
+  
+  let(:tools){ Object.new.extend(DbAgile::Tools::Tuple) }
+  let(:tuple){ {:id => 1, :name => "dbagile"} }
+  
+  describe "When called on on a typical tuple" do
+    subject{ tools.tuple_project(tuple, [:id]) }
+    it{ should == {:id => 1} }
+  end
+  
+  describe "When called on on a typical tuple" do
+    subject{ tools.tuple_project(tuple, [:id, :name]) }
+    it{ should == {:id => 1, :name => "dbagile"} }
+  end
+
+  describe "When called on on a typical tuple" do
+    subject{ tools.tuple_project(tuple, [:noone]) }
+    it{ should == {:noone => nil} }
+  end
+
+  
+end

data/test/unit.spec

@@ -0,0 +1,3 @@
+require File.expand_path('../spec_helper', __FILE__)
+dbagile_load_all_subspecs(__FILE__)
+