dbagile 0.0.1

data/lib/dbagile.rb

@@ -0,0 +1,66 @@
+require 'dbagile/loader'
+module DbAgile
+  
+  # Version of the DbAgile interface
+  VERSION = "0.0.1".freeze
+  
+  # Domains recognized as valid domains inside a SQL database
+  RECOGNIZED_DOMAINS = [
+    ::SByC::TypeSystem::Ruby::Boolean,
+    TrueClass, FalseClass, 
+    String, 
+    Fixnum, Bignum, Integer,
+    Float,
+    Time, 
+    Date
+  ]
+  
+  # 
+  # Builds a DbAgile::Command::API instance and yields the block with the
+  # api instance.
+  #
+  # A fresh new default environement is created if no one is given.
+  #
+  # Example
+  #   DbAgile::dba do |dba|
+  #     # Override environment default values (~/.dbagile, ...)
+  #     dba.repository_path  = ...     # your application own repository
+  #     dba.output_buffer     = ...    # keep messages in any object supporting :<< (STDOUT by default)
+  # 
+  #     # Start using dbagile commands
+  #     dba.bulk_export %w{--csv --type-safe contacts}  # each line pushed in buffer
+  #     dba.bulk_export %w{--ruby contacts}             # each record pushed as a Hash in buffer
+  # end
+  #
+  def dba(environment = nil)
+    environment ||= default_environment
+    dba = DbAgile::Command::API.new(environment)
+    if block_given?
+      yield(dba)
+    else
+      dba
+    end
+  end
+  module_function :dba
+  
+  #
+  # Builds a default environment instance.
+  #
+  # @see DbAgile::Core::Repository.default
+  #
+  def default_environment
+    DbAgile::Environment.default
+  end
+  module_function :default_environment
+
+end # module DbAgile
+require 'dbagile/robustness'
+require 'dbagile/errors'
+require 'dbagile/environment'
+require 'dbagile/contract'
+require 'dbagile/tools'
+require 'dbagile/io'
+require 'dbagile/core'
+require 'dbagile/adapter'
+require 'dbagile/plugin'
+require 'dbagile/command'

data/test/assumptions/equality.spec

@@ -0,0 +1,11 @@
+require File.expand_path('../fixtures.rb', __FILE__)
+describe "The way comparison work" do
+  
+  it "should not override ==" do
+    foo1 = DbAgile::Fixtures::Assumptions::FooComparable.new(1)
+    foo2 = DbAgile::Fixtures::Assumptions::FooComparable.new(1)
+    (foo1 <=> foo2).should == 0
+    (foo1 == foo2).should == false
+  end
+  
+end

data/test/assumptions/fixtures.rb

@@ -0,0 +1,39 @@
+require File.expand_path('../../spec_helper.rb', __FILE__)
+module DbAgile
+  module Fixtures
+    module Assumptions
+
+      module SafeModule
+        
+        def safe_method
+          SafeModule
+        end
+        
+      end
+      
+      class UnsafeClass
+        
+        def safe_method
+          UnsafeClass
+        end
+        
+        include SafeModule
+      end
+      
+      class FooComparable
+        
+        attr_reader :int
+        
+        def initialize(int)
+          @int = int
+        end
+        
+        def <=>(other)
+          @int <=> other.int
+        end
+        
+      end
+      
+    end # module Assumptions
+  end # module Fixtures
+end # module DbAgile

data/test/assumptions/inheritance.spec

@@ -0,0 +1,17 @@
+require File.expand_path('../fixtures.rb', __FILE__)
+describe "The way inheritance works with modules" do
+  
+  let(:namespace){ DbAgile::Fixtures::Assumptions }
+  let(:safe_class){ namespace::UnsafeClass.new.extend(namespace::SafeModule) }
+  
+  describe "The way modules are included" do
+    subject{ safe_class }
+    it{ should be_kind_of(namespace::SafeModule) }
+  end
+  
+  describe "The way methods are overriden" do
+    subject{ safe_class.safe_method }
+    it { should == namespace::UnsafeClass }
+  end
+  
+end

data/test/assumptions/sequel/autonumber.spec

@@ -0,0 +1,19 @@
+require File.expand_path('../../fixtures', __FILE__)
+describe "auto number on sequel /" do
+
+  let(:db_file){ File.expand_path('../test.db', __FILE__) } 
+  let(:db){ Sequel::connect("sqlite://#{db_file}") }
+  before{
+    if db.table_exists?(:test)
+      db.drop_table(:test)
+    end
+  }
+
+  it "should be supported at primary key time" do
+    db.create_table(:test){
+      column :id, :integer
+      primary_key :id, :auto_increment => true
+    }
+  end
+
+end

data/test/assumptions/sequel/connect.spec

@@ -0,0 +1,29 @@
+require File.expand_path('../../fixtures', __FILE__)
+describe "Sequel::connect /" do
+
+  let(:uris){[
+    'postgres://nosuchuser@localhost/nosuch_database',
+    'sqlite://tmp/test.db',
+    'mysql://nosuchuser@localhost/nosuch_database',
+    'dbi-frontbase://nosuchuser@localhost/nosuch_database',
+    'dbi-mysql://nosuchuser@localhost/nosuch_database',
+    'dbi-oracle://nosuchuser@localhost/nosuch_database',
+    'dbi-msql://nosuchuser@localhost/nosuch_database',
+  ]}
+
+  it "allows connecting and using SQL tools on unexisting databases" do
+    uris.each{|uri|
+      lambda{ 
+        db = Sequel::connect(uri)
+        gen = Sequel::Schema::Generator.new(db){
+          column :id, Integer
+          column :name, String
+          primary_key [:id]
+        }
+        res = db.send(:create_table_sql, :mytable, gen, {})
+        res.should =~ /CREATE TABLE/
+      }.should_not raise_error
+    }
+  end
+
+end

data/test/assumptions/stdlib/pathname.spec

@@ -0,0 +1,13 @@
+require File.expand_path('../../fixtures.rb', __FILE__)
+require 'pathname'
+describe "Pathname utility" do
+  
+  it "should be able to relativize files" do
+    child = Pathname.new(__FILE__)
+    parent = Pathname.new(File.dirname(File.dirname(__FILE__)))
+    rel = child.relative_path_from(parent)
+    rel.should be_relative
+    rel.to_s.should == "stdlib/pathname.spec"
+  end
+  
+end

data/test/assumptions/yaml/fixtures.rb

@@ -0,0 +1,25 @@
+require 'yaml'
+require File.expand_path('../../fixtures', __FILE__)
+module DbAgile
+  module Fixtures
+    class YAMLDumpable
+      
+      attr_reader :name
+      
+      def initialize(name)
+        @name = name
+      end
+      
+      def to_yaml(opts = {})
+        YAML::quick_emit(self, opts) do |out|
+          out.map("tag:yaml.org,2002:map", :inline ) do |map|
+            map.add('class', self.class.to_s)
+            map.add('name', self.name)
+          end
+        end
+        { 'test' => true }.to_yaml(opts)
+      end
+      
+    end # class YAMLDumpable
+  end # module Fixtures
+end # module DbAgile

data/test/assumptions/yaml/to_yaml.spec

@@ -0,0 +1,10 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "to_yaml understanding /" do
+
+  describe "about user-defined to_yaml method" do
+    let(:dumpable){ DbAgile::Fixtures::YAMLDumpable.new("hello") }
+    subject{ lambda{ dumpable.to_yaml } }
+    it{ should_not raise_error }
+  end
+
+end

data/test/assumptions.spec

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

data/test/commands/bulk/export.spec

@@ -0,0 +1,100 @@
+shared_examples_for("The bulk:export command") do
+  
+  it "should return the output buffer" do
+    dba.bulk_export(%w{suppliers}).should == dba.output_buffer
+  end
+
+  it "should support a --select option" do
+    dba.bulk_export(%w{--csv --select id,name basic_values})
+    dba.output_buffer.string.should =~ /^1,Standard values/
+  end
+  
+  it "should support a --allbut option" do
+    dba.bulk_export(%w{--csv --allbut name basic_values})
+    dba.output_buffer.string.should_not =~ /Standard values/
+  end
+  
+  ### --csv
+  
+  describe "When used with --csv option" do
+    
+    it "should support a --headers option" do
+      dba.bulk_export(%w{--csv --headers --select id,name basic_values})
+      dba.output_buffer.string.should =~ /^id,name/
+    end
+  
+    it "should support a --seperator option" do
+      dba.bulk_export(%w{--csv --separator=; --select id,name basic_values})
+      dba.output_buffer.string.should =~ /^1;Standard values/
+    end
+  
+    it "should support --force-quotes --quote options" do
+      dba.bulk_export(%w{--csv --quote=' --force-quotes --select id,name basic_values})
+      dba.output_buffer.string.strip.should == "'1','Standard values'"
+    end
+    
+  end
+  
+  ### --json
+  
+  describe "When used with --json option" do
+    
+    it "should return a valid JSON string" do
+      result = dba.bulk_export(%w{--json basic_values}).string
+      result.should be_a_valid_json_string
+      back_tuple = JSON::parse(result)[0]
+      DbAgile::Fixtures::basic_values[0].each_pair{|k,v| 
+        next if v.kind_of?(Time) or v.kind_of?(Date) # not supported by json
+        back_tuple[k.to_s].should == v
+      }
+    end
+    
+    it "should support a --no-pretty option" do
+      result = dba.bulk_export(%w{--json --no-pretty --select id,name basic_values}).string
+      result.strip.should_not =~ /\n/
+      result.should be_a_valid_json_string
+    end
+
+    it "should support a --pretty option" do
+      result = dba.bulk_export(%w{--json --pretty --select id,name basic_values}).string
+      result.strip.should =~ /\n/
+      result.should be_a_valid_json_string
+    end
+
+    it "should support a --type-sage option" do
+      result = dba.bulk_export(%w{--json --type-safe basic_values}).string
+      result.should be_a_valid_json_string
+    end
+    
+  end
+  
+  ### --yaml
+
+  describe "When used with --yaml option" do
+
+    it "should return yaml valid string" do
+      result = dba.bulk_export(%w{--yaml basic_values}).string
+      result.should be_a_valid_yaml_string
+      YAML::load(result).should == DbAgile::Fixtures::basic_values
+    end
+    
+    it "should return yaml valid string with --type-safe" do
+      result = dba.bulk_export(%w{--yaml --type-safe basic_values}).string
+      result.should be_a_valid_yaml_string
+    end
+    
+  end
+
+  ### --ruby
+  
+  describe "When used with --ruby option" do
+    
+    it "should support a valid ruby string" do
+      dba.bulk_export %w{--ruby basic_values}
+      back = Kernel.eval(dba.output_buffer.string)
+      back.should == DbAgile::Fixtures::basic_values
+    end
+    
+  end
+  
+end

data/test/commands/bulk/import.spec

@@ -0,0 +1,49 @@
+shared_examples_for("The bulk:import command") do
+  
+  # --ruby
+  
+  describe "When used with a --ruby option" do
+
+    it "should work on input buffer by default" do
+      File.open(DbAgile::Fixtures::basic_values_path, "r"){|io|
+        dba.input_buffer = io
+        dba.bulk_import %w{--ruby --drop-table basic_values_copy}
+        dba.sql_send "UPDATE basic_values_copy SET ruby_nil = null"
+      }
+      dba.dataset(:basic_values_copy).to_a.should == DbAgile::Fixtures::basic_values
+    end
+
+    it "should accept a --input option" do
+      dba.bulk_import ['--input', DbAgile::Fixtures::basic_values_path] + %w{--ruby --drop-table basic_values_copy}
+      dba.sql_send "UPDATE basic_values_copy SET ruby_nil = null"
+      dba.dataset(:basic_values_copy).to_a.should == DbAgile::Fixtures::basic_values
+    end
+    
+    it "should support an export/import piping through StringIO" do
+      dba.bulk_export %w{--ruby basic_values}
+      dba.input_buffer  = StringIO.new(dba.output_buffer.string)
+      dba.output_buffer = StringIO.new 
+      dba.bulk_import %w{--ruby --create-table basic_values_copy}
+      dba.dataset(:basic_values_copy).to_a.should == DbAgile::Fixtures::basic_values
+    end
+
+  end # --ruby
+  
+  # --format=x --type-safe
+  [:csv, :json, :yaml, :ruby].each do |format|
+  
+    describe "When piping import/export with --type-safe in #{format}" do
+  
+      it "should be type safe" do
+        dba.bulk_export "--format", format, "--type-safe", "basic_values"
+        dba.input_buffer  = StringIO.new(dba.output_buffer.string)
+        dba.output_buffer = StringIO.new 
+        dba.bulk_import "--drop-table", "--format", format, "--type-safe", "basic_values_copy"
+        dba.dataset(:basic_values_copy).to_a.should == DbAgile::Fixtures::basic_values
+      end
+  
+    end
+    
+  end # --format=x --type-safe
+  
+end

data/test/commands/db/add.spec

@@ -0,0 +1,31 @@
+shared_examples_for("The db:add command") do
+  
+  it "should return the new database" do
+    dba.db_add(%w{test test.db}).should be_kind_of(DbAgile::Core::Database)
+  end
+  
+  it "should accept an absolute database" do
+    dba.db_add(%w{test postgres://dbagile@localhost/unexisting}).should be_kind_of(DbAgile::Core::Database)
+  end
+  
+  it "should raise an error when the name is already in use" do
+    dba.db_add(%w{test test.db})
+    lambda{ dba.db_add(%w{test test.db}) }.should raise_error(DbAgile::DatabaseNameConflictError)
+  end
+  
+  it "should save the repository" do
+    dba.db_add(%w{test test.db})
+    dba.dup.repository.has_database?(:test).should be_true
+  end
+  
+  it "should set the database as the current one by default" do
+    dba.db_add(%w{test test.db})
+    dba.dup.repository.current?(:test).should be_true
+  end 
+  
+  it "should not set the database as the current one with --no-current" do
+    dba.db_add(%w{--no-current test test.db})
+    dba.dup.repository.current?(:test).should be_false
+  end 
+  
+end

data/test/commands/db/list.spec

@@ -0,0 +1,29 @@
+shared_examples_for("The db:list command") do
+  
+  describe "/ on a non empty repository /" do
+    
+    it "should return the repository instance" do
+      dba.db_list.should be_kind_of(DbAgile::Core::Repository)
+    end
+  
+    it "should print the databases" do
+      dba.output_buffer = StringIO.new
+      dba.db_list
+      dba.output_buffer.string.should =~ /Available databases/
+    end
+    
+  end
+  
+  describe "/ on an empty repository /" do
+
+    before{ dba.repository_path = DbAgile::Fixtures::ensure_empty_repository! }
+    
+    it "should print a friendly error message when no database" do
+      dba.message_buffer = StringIO.new
+      dba.db_list
+      dba.message_buffer.string.should =~ /No database found/
+    end
+    
+  end
+  
+end

data/test/commands/db/ping.spec

@@ -0,0 +1,21 @@
+shared_examples_for("The db:ping command") do
+  
+  it "should return the pinged database" do
+    dba.db_ping(%w{sqlite}).should be_kind_of(::DbAgile::Core::Database)
+  end
+
+  it "should return the error if ping failed" do
+    dba.db_ping(%w{unexisting}).should be_kind_of(StandardError)
+  end
+
+  it "should print a friendly message on success" do
+    dba.db_ping(%w{sqlite})
+    dba.output_buffer.string.should =~ /ok/
+  end
+
+  it "should print a friendly message on failure" do
+    dba.db_ping(%w{unexisting})
+    dba.output_buffer.string.should =~ /KO/
+  end
+
+end

data/test/commands/db/rm.spec

@@ -0,0 +1,18 @@
+shared_examples_for("The db:rm command") do
+  
+  it "should return the repository" do
+    dba.db_add(%w{test test.db})
+    dba.db_rm(%w{test}).should be_kind_of(::DbAgile::Core::Repository)
+  end
+  
+  it "should raise an error when the name is unknown" do
+    lambda{ dba.db_rm(%w{test}) }.should raise_error(DbAgile::NoSuchDatabaseError)
+  end
+  
+  it "should save the repository" do
+    dba.db_add(%w{test test.db})
+    dba.db_rm(%w{test})
+    dba.dup.repository.has_database?(:test).should be_false
+  end
+
+end

data/test/commands/db/use.spec

@@ -0,0 +1,18 @@
+shared_examples_for("The db:use command") do
+  
+  it "should return the current database" do
+    dba.db_add(%w{test test.db})
+    dba.db_use(%w{test}).should be_kind_of(::DbAgile::Core::Database)
+  end
+
+  it "should raise an error if the database is unknown" do
+    lambda{ dba.db_use(%w{test}) }.should raise_error(DbAgile::NoSuchDatabaseError)
+  end
+
+  it "should save the repository" do
+    dba.db_add(%w{--no-current test test.db})
+    dba.db_use(%w{test})
+    dba.dup.repository.current?(:test).should be_true
+  end
+  
+end

data/test/commands/dba.spec

@@ -0,0 +1,54 @@
+shared_examples_for("The dba command") do
+  
+  let(:env){ DbAgile::default_environment.with_testing_methods! }
+  let(:dba){ DbAgile::Command::Dba.new(env) }
+  subject{ dba.run(__FILE__, args); env }
+  
+  describe "when called on an existing repository /" do
+    
+    before{ env.repository_path = DbAgile::Fixtures::repository_path(:basics) }
+    
+    describe "with no args" do
+      let(:args){ [] }
+      it{ should have_flushed(/Usage:/) }
+    end
+    
+    describe "with --help" do
+      let(:args){ ['--help'] }
+      it{ should have_flushed(/Usage:/) }
+    end
+    
+    describe "with --version" do
+      let(:args){ ['--version'] }
+      it{ should have_flushed(/(c)/) }
+    end
+    
+    describe "with --interactive" do
+      let(:args){ ['--interactive'] }
+      it{ should be_interactive }
+    end
+    
+    describe "with --no-interactive" do
+      let(:args){ ['--no-interactive'] }
+      it{ should_not be_interactive }
+    end
+    
+    describe "with --backtrace" do
+      let(:args){ ['--backtrace'] }
+      it{ should be_show_backtrace }
+    end
+    
+    describe "with --no-backtrace" do
+      let(:args){ ['--no-backtrace'] }
+      it{ should_not be_show_backtrace }
+    end
+    
+    describe "with help" do
+      let(:args){ ['help', 'help'] }
+      it{ should have_flushed(/Usage:/) }
+      it{ should have_flushed(/Description:/) }
+    end
+    
+  end # on an existing repository
+  
+end

data/test/commands/repo/create.spec

@@ -0,0 +1,30 @@
+shared_examples_for("The repo:create command") do
+  
+  let(:empty_path){ DbAgile::Fixtures::repository_path(:empty) }
+    
+  describe "when the repository already exists" do
+    
+    before { dba.repository_path = DbAgile::Fixtures::ensure_empty_repository! }
+
+    it "should raise an error without --force" do
+      lambda{ dba.repo_create [ dba.repository_path ] }.should raise_error(IOError)
+    end
+
+    it "should not raise an error with --force" do
+      lambda{ dba.repo_create [ "--force", dba.repository_path ] }.should_not raise_error(IOError)
+    end
+
+  end
+
+  describe "when the repository does not exist" do
+    
+    before { FileUtils.rm_rf(empty_path) }
+    
+    it "should create the repo without --force" do
+      dba.repo_create [ dba.repository_path ]
+      dba.repository.should be_kind_of(DbAgile::Core::Repository)
+    end
+
+  end
+  
+end

data/test/commands/schema/check.spec

@@ -0,0 +1,25 @@
+shared_examples_for("The schema:check command") do
+  
+  describe "when the shema is valid" do
+    
+    it "should return a Schema and Errors" do
+      schema, errors = dba.schema_check
+      schema.should be_kind_of(DbAgile::Core::Schema::DatabaseSchema)
+      errors.should be_kind_of(DbAgile::SchemaSemanticsError)
+      errors.should be_empty
+    end
+
+  end
+
+  describe "when the shema is invalid" do
+
+    it "should return a Schema and Errors" do
+      schema, errors = dba.schema_check [ File.expand_path('../fixtures/invalid.yaml', __FILE__) ]
+      schema.should be_kind_of(DbAgile::Core::Schema::DatabaseSchema)
+      errors.should be_kind_of(DbAgile::SchemaSemanticsError)
+      errors.should_not be_empty
+    end
+
+  end
+
+end

data/test/commands/schema/diff.spec

@@ -0,0 +1,30 @@
+shared_examples_for("The schema:diff command") do
+  
+  let(:invalid){ File.expand_path('../fixtures/invalid.yaml', __FILE__) }
+  let(:announced){ File.expand_path('../fixtures/announced.yaml', __FILE__) }
+  let(:effective){ File.expand_path('../fixtures/effective.yaml', __FILE__) }
+  
+  it "should return merged schema" do
+    dba.message_buffer = StringIO.new
+    dba.schema_diff([announced, effective]).should be_kind_of(DbAgile::Core::Schema::DatabaseSchema)
+  end
+  
+  it "should show all differences without -u" do
+    dba.message_buffer = StringIO.new
+    dba.schema_diff([effective, announced]).should be_kind_of(DbAgile::Core::Schema::DatabaseSchema)
+    s = dba.message_buffer.string
+    s.should =~ /PARTS/
+    s.should =~ /SUPPLIERS/
+    s.should =~ /SUPPLIES/
+  end
+  
+  it "should not show all differences with -u" do
+    dba.message_buffer = StringIO.new
+    dba.schema_diff(['-u', effective, announced]).should be_kind_of(DbAgile::Core::Schema::DatabaseSchema)
+    s = dba.message_buffer.string
+    s.should =~ /SUPPLIES/
+    s.should_not =~ /SUPPLIERS/
+    s.should_not =~ /PARTS/
+  end
+
+end