dbagile 0.0.1

data/test/commands/schema/dump.spec

@@ -0,0 +1,23 @@
+shared_examples_for("The schema:dump command") do
+  
+  let(:invalid){ File.expand_path('../fixtures/invalid.yaml', __FILE__) }
+  
+  it "should return a Schema instance" do
+    dba.schema_dump.should be_kind_of(DbAgile::Core::Schema::DatabaseSchema)
+  end
+
+  it "should display the Schema as a valid YAML string" do
+    dba.output_buffer = StringIO.new
+    dba.schema_dump
+    dba.output_buffer.string.should be_a_valid_yaml_string
+  end
+  
+  it "should raise an error on invalid schema" do
+    lambda{ dba.schema_dump [ invalid ] }.should raise_error(DbAgile::SchemaSemanticsError)
+  end
+
+  it "should not raise an error on invalid schema with --no-check" do
+    lambda{ dba.schema_dump ['--no-check', invalid] }.should_not raise_error(DbAgile::SchemaSemanticsError)
+  end
+
+end

data/test/commands/schema/fixtures/add_constraint.yaml

@@ -0,0 +1,30 @@
+--- 
+logical: 
+  SUPPLIERS: 
+    heading: 
+      S#:    { domain: Integer, mandatory: true }
+      NAME:  { domain: String,  mandatory: true }
+      CITY:  { domain: String,  mandatory: true }
+    constraints: 
+      pk_suppliers: { type: :primary_key, attributes: [ 'S#' ] }
+  PARTS: 
+    heading: 
+      P#:    { domain: Integer, mandatory: true }
+      NAME:  { domain: String,  mandatory: true }
+      COLOR: { domain: String,  mandatory: true }
+    constraints: 
+      pk_parts: { type: :primary_key, attributes: [ 'P#' ] }
+  SUPPLIES: 
+    heading: 
+      S#:    { domain: Integer, mandatory: true }
+      P#:    { domain: Integer, mandatory: true }
+      QTY:   { domain: Integer, mandatory: true }
+    constraints: 
+      pk_supplies: { type: :primary_key, attributes: [ 'S#', 'P#' ] }
+      is_a_known_supplier: { type: :foreign_key, attributes: [ 'S#' ], references: :SUPPLIERS }
+      is_a_known_part: { type: :foreign_key, attributes: [ 'P#' ], references: :PARTS }
+---
+physical:
+  indexes:
+    SUPPLIER_NAMES: { relvar: SUPPLIERS, attributes: [ 'NAME' ] }
+      

data/test/commands/schema/fixtures/announced.yaml

@@ -0,0 +1,28 @@
+--- 
+logical: 
+  SUPPLIERS: 
+    heading: 
+      S#:    { domain: Integer, mandatory: true }
+      NAME:  { domain: String,  mandatory: true }
+      CITY:  { domain: String,  mandatory: true }
+    constraints: 
+      pk_suppliers: { type: :primary_key, attributes: [ 'S#' ] }
+  PARTS: 
+    heading: 
+      P#:    { domain: Integer, mandatory: true }
+      NAME:  { domain: String,  mandatory: true }
+      COLOR: { domain: String,  mandatory: true }
+    constraints: 
+      pk_parts: { type: :primary_key, attributes: [ 'P#' ] }
+  SUPPLIES: 
+    heading: 
+      S#:    { domain: Integer, mandatory: true }
+      P#:    { domain: Integer, mandatory: true }
+      QTY:   { domain: Integer, mandatory: true }
+    constraints: 
+      pk_supplies: { type: :primary_key, attributes: [ 'S#', 'P#' ] }
+---
+physical:
+  indexes:
+    SUPPLIER_NAMES: { relvar: SUPPLIERS, attributes: [ 'NAME' ] }
+  

data/test/commands/schema/fixtures/effective.yaml

@@ -0,0 +1,20 @@
+--- 
+logical: 
+  SUPPLIERS: 
+    heading: 
+      S#:    { domain: Integer, mandatory: true }
+      NAME:  { domain: String,  mandatory: true }
+      CITY:  { domain: String,  mandatory: true }
+    constraints: 
+      pk_suppliers: { type: :primary_key, attributes: [ 'S#' ] }
+  PARTS: 
+    heading: 
+      P#:    { domain: Integer, mandatory: true }
+      NAME:  { domain: String,  mandatory: true }
+      COLOR: { domain: String,  mandatory: true }
+    constraints: 
+      pk_parts: { type: :primary_key, attributes: [ 'P#' ] }
+---
+physical:
+  indexes:
+    SUPPLIER_NAMES: { relvar: SUPPLIERS, attributes: [ 'NAME' ] }

data/test/commands/schema/fixtures/invalid.yaml

@@ -0,0 +1,6 @@
+---
+logical:
+  SUPPLIERS:
+    heading:
+      s#: { domain: Integer, mandatory: true }
+    constraints: {}

data/test/commands/schema/sql_script.spec

@@ -0,0 +1,56 @@
+shared_examples_for("The schema:sql-script 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__) }
+  let(:add_constraint){ File.expand_path('../fixtures/add_constraint.yaml', __FILE__) }
+  
+  it "should return the output buffer with CREATE" do
+    dba.output_buffer = StringIO.new
+    dba.schema_sql_script(%{create}).should == dba.output_buffer
+    s = dba.output_buffer.string
+    s.should =~ /CREATE/
+    s.should_not =~ /DROP/
+  end
+
+  it "should return the output buffer with DROP" do
+    dba.output_buffer = StringIO.new
+    dba.schema_sql_script(%{drop}).should == dba.output_buffer
+    s = dba.output_buffer.string
+    s.should =~ /DROP/
+    s.should_not =~ /CREATE/
+  end
+
+  it "should return the output buffer with STAGE (effective vs. announced)" do
+    dba.output_buffer = StringIO.new
+    dba.schema_sql_script(['stage', effective, announced]).should == dba.output_buffer
+    s = dba.output_buffer.string
+    s.should =~ /CREATE TABLE .SUPPLIES./
+    s.should_not =~ /DROP/
+  end
+
+  it "should return the output buffer with STAGE (announced vs. effective)" do
+    dba.output_buffer = StringIO.new
+    dba.schema_sql_script(['stage', announced, effective]).should == dba.output_buffer
+    s = dba.output_buffer.string
+    s.should =~ /DROP TABLE .SUPPLIES./
+    s.should_not =~ /CREATE/
+  end
+
+  it "should support adding foreign keys, even if it implies deffered staging" do
+    dba.output_buffer = StringIO.new
+    s = dba.schema_sql_script(['stage', '--no-check', announced, add_constraint])
+    s.should == dba.output_buffer
+  end
+
+  it "should raise an error on invalid schema" do
+    s = lambda{ dba.schema_sql_script ['create', invalid ] }
+    s.should raise_error(DbAgile::SchemaSemanticsError)
+  end
+
+  it "should not raise an error on invalid schema with --no-check" do
+    s = lambda{ dba.schema_sql_script ['--no-check', 'create', invalid] }
+    s.should_not raise_error(DbAgile::SchemaSemanticsError)
+  end
+
+end

data/test/commands/sql/drop.spec

@@ -0,0 +1,25 @@
+shared_examples_for("The sql:drop command") do
+  
+  before{
+    dba.with_current_connection do |conn|
+      conn.transaction do |t|
+        t.create_table(:unexisting, {:id => String})
+      end
+    end
+  }
+  after{
+    dba.with_current_connection do |conn|
+      conn.transaction do |t|
+        t.drop_table(:unexisting) if t.has_table?(:unexisting)
+      end
+    end
+  }
+  
+  it "should drop the table" do
+    dba.sql_drop %{unexisting}
+    dba.with_current_connection do |conn|
+      conn.has_table?(:unexisting).should be_false
+    end
+  end
+
+end

data/test/commands/sql/heading.spec

@@ -0,0 +1,7 @@
+shared_examples_for("The sql:heading command") do
+  
+  it "should return the heading" do
+    dba.sql_heading(%w{basic_values}).should == DbAgile::Fixtures::basic_values_heading
+  end
+
+end

data/test/commands/sql/scripts/delete.sql

@@ -0,0 +1 @@
+DELETE FROM basic_values WHERE id >= 10;

data/test/commands/sql/scripts/insert.sql

@@ -0,0 +1,2 @@
+INSERT INTO basic_values (id, name) VALUES (10, 'Hello World');
+INSERT INTO basic_values (id, name) VALUES (11, 'Hi dba!');

data/test/commands/sql/send.spec

@@ -0,0 +1,29 @@
+shared_examples_for("The sql:send command") do
+  
+  it "should print the table on the output buffer" do
+    dba.sql_send("SELECT * FROM suppliers")
+    dba.output_buffer.string.should =~ /^\+\-/
+  end
+  
+  it "should accept INSERT/DELETE" do
+    dba.sql_send("INSERT INTO basic_values (id, name) VALUES (12, 'Hello World')")
+    dba.dataset(:basic_values).count.should == 2
+    dba.sql_send("DELETE FROM basic_values WHERE id=12")
+    dba.dataset(:basic_values).count.should == 1
+  end
+  
+  describe "When used with the --file option" do
+    
+    let(:insert){ File.expand_path("../scripts/insert.sql", __FILE__) }
+    let(:delete){ File.expand_path("../scripts/delete.sql", __FILE__) }
+    
+    it "should execute the file" do
+      dba.sql_send("--file", insert)
+      dba.dataset(:basic_values).count.should == 3
+      dba.sql_send("-f", delete)
+      dba.dataset(:basic_values).count.should == 1
+    end
+    
+  end
+  
+end

data/test/commands/sql/show.spec

@@ -0,0 +1,17 @@
+shared_examples_for("The sql:show command") do
+  
+  it "should return the output buffer" do
+    dba.sql_show(%w{suppliers}).should == dba.output_buffer
+  end
+  
+  it "should print the table one the output buffer" do
+    dba.sql_show(%w{suppliers})
+    dba.output_buffer.string.should =~ /^\+\-/
+  end
+  
+  it "should support pretty-printing" do
+    dba.sql_show(%w{--pretty suppliers})
+    dba.output_buffer.string.should =~ /\.\.\.$/
+  end
+  
+end

data/test/commands.spec

@@ -0,0 +1,138 @@
+require File.expand_path('../spec_helper', __FILE__)
+dbagile_load_all_subspecs(__FILE__)
+describe "DbAgile::Command::API /" do
+  
+  # The environment to use
+  let(:dba){ DbAgile::Command::API.new(DbAgile::Fixtures::environment) }
+  
+  # -- repo
+  describe "repo commands /" do 
+  
+    # Remove empty repo between all test
+    before { dba.repository_path = DbAgile::Fixtures::ensure_empty_repository! }
+    after  { DbAgile::Fixtures::ensure_empty_repository!                       }
+  
+    describe "repo:create /" do
+      it_should_behave_like "The repo:create command" 
+    end
+  
+  end # -- repo
+  
+  # -- db
+  describe "db commands (touching) /" do 
+  
+    # Remove empty repo between all test
+    before { dba.repository_path = DbAgile::Fixtures::ensure_empty_repository! }
+    after  { DbAgile::Fixtures::ensure_empty_repository!                       }
+  
+    describe "db:add /" do
+      it_should_behave_like "The db:add command" 
+    end
+  
+    describe "db:rm /" do
+      it_should_behave_like "The db:rm command" 
+    end
+      
+    describe "db:use /" do
+      it_should_behave_like "The db:use command" 
+    end
+  
+  end # -- db
+  
+  # -- db
+  describe "repository commands (non touching) /" do 
+  
+    # Make usage of sqlite for these tests
+    before { dba.db_use %{sqlite} }
+  
+    describe "db:list /" do
+      it_should_behave_like "The db:list command" 
+    end
+  
+    describe "db:ping /" do
+      it_should_behave_like "The db:ping command" 
+    end
+  
+  end # -- db
+  
+  # -- bulk
+  describe "bulk commands /" do 
+  
+    # Make usage of sqlite for these tests
+    before{ 
+      dba.db_use %{sqlite}
+      dba.output_buffer = StringIO.new
+    }
+    
+    describe "bulk:export /" do
+      it_should_behave_like "The bulk:export command" 
+    end
+  
+    describe "bulk:import /" do
+      it_should_behave_like "The bulk:import command" 
+    end
+  
+  end # -- bulk
+  
+  # -- sql 
+  describe "sql commands /" do
+    
+    # Make usage of sqlite for these tests
+    before{ 
+      dba.db_use %{sqlite}
+      dba.output_buffer = StringIO.new
+    }
+    
+    describe "sql:send /" do
+      it_should_behave_like "The sql:send command" 
+    end
+  
+    describe "sql:show /" do
+      it_should_behave_like "The sql:show command" 
+    end
+  
+    describe "sql:heading /" do
+      it_should_behave_like "The sql:heading command" 
+    end
+  
+    describe "sql:drop /" do
+      it_should_behave_like "The sql:drop command" 
+    end
+  
+  end # -- sql
+  
+  # -- schema
+  describe "schema commands /" do
+    
+    # Make usage of sqlite for these tests
+    before{ 
+      dba.db_use %{sqlite}
+      dba.output_buffer = StringIO.new
+    }
+    
+    describe "schema:dump" do
+      it_should_behave_like "The schema:dump command" 
+    end
+  
+    describe "schema:check" do
+      it_should_behave_like "The schema:check command" 
+    end
+  
+    describe "schema:sql-script" do
+      it_should_behave_like "The schema:sql-script command" 
+    end
+  
+    describe "schema:diff" do
+      it_should_behave_like "The schema:diff command" 
+    end
+  
+  end # -- schema
+  
+  # -- dba
+  describe "main dba command /" do
+  
+    it_should_behave_like "The dba command" 
+  
+  end # -- dba
+  
+end

data/test/contract/connection/transaction.ex

@@ -0,0 +1,11 @@
+it "should give a transaction object" do
+  
+  if subject.ping?
+
+    subject.transaction do |t|
+      t.should be_kind_of(::DbAgile::Core::Transaction)
+    end
+
+  end
+  
+end

data/test/contract/connection.spec

@@ -0,0 +1,9 @@
+shared_examples_for("A Contract::Connection") do
+  
+  ::DbAgile::Contract::Connection.instance_methods(false).each do |meth|
+    it { should respond_to(meth) }
+  end
+  
+  dbagile_install_examples(__FILE__, self)
+
+end

data/test/contract/data/dataset/columns.ex

@@ -0,0 +1,5 @@
+it "should returns expected columns" do
+  
+  subject.columns.sort{|a,b| a.to_s <=> b.to_s}.should == basic_values_keys
+  
+end

data/test/contract/data/dataset/count.ex

@@ -0,0 +1,5 @@
+it "should return an integer" do
+  
+  subject.count.should be_kind_of(Integer)
+
+end

data/test/contract/data/dataset.spec

@@ -0,0 +1,9 @@
+shared_examples_for "A Contract::Data::Dataset" do
+
+  ::DbAgile::Contract::Data::Dataset.instance_methods(false).each do |meth|
+    it { should respond_to(meth) }
+  end
+  
+  dbagile_install_examples(__FILE__, self)
+
+end

data/test/contract/data/table_driven/dataset.ex

@@ -0,0 +1,31 @@
+it "should return a Contract::Data::Dataset instance" do
+
+  subject.dataset(:basic_values).should be_kind_of(DbAgile::Contract::Data::Dataset)
+
+end
+
+it "should support SQL queries" do
+  
+  subject.dataset("SELECT * FROM basic_values").should be_kind_of(DbAgile::Contract::Data::Dataset)
+  
+end
+
+it "should support a projection tuple" do
+  
+  subject.dataset(:basic_values, :id => 1).count.should == 1
+
+  subject.dataset(:basic_values, :id => 10).count.should == 0
+  
+end
+
+it "should support an empty projection tuple" do
+  
+  subject.dataset(:basic_values, {}).count.should == 1
+
+end
+
+it "should support a nil projection tuple" do
+  
+  subject.dataset(:basic_values, nil).count.should == 1
+
+end

data/test/contract/data/table_driven/exists_q.ex

@@ -0,0 +1,27 @@
+it "should return true on non empty result" do
+  
+  subject.exists?(:basic_values, :id => 1).should be_true
+  
+end
+
+it "should return false on empty result" do
+  
+  subject.exists?(:basic_values, :id => 10).should be_false
+  
+end
+
+
+it "should support SQL queries" do
+  
+  subject.exists?("SELECT * FROM basic_values").should be_true
+
+  subject.exists?("SELECT * FROM basic_values WHERE id=10").should be_false
+  
+end
+
+it "should support an empty projection" do
+  
+  subject.exists?(:basic_values, {}).should be_true
+  subject.exists?(:empty_table, {}).should be_false
+  
+end

data/test/contract/data/table_driven.spec

@@ -0,0 +1,9 @@
+shared_examples_for "A Contract::Data::TableDriven" do
+
+  ::DbAgile::Contract::Data::TableDriven.instance_methods(false).each do |meth|
+    it { should respond_to(meth) }
+  end
+  
+  dbagile_install_examples(__FILE__, self)
+
+end

data/test/contract/data/transaction_driven/delete.ex

@@ -0,0 +1,29 @@
+it "should support deleting on empty tables" do
+  
+  subject.delete(:empty_table)
+  
+  subject.dataset(:empty_table).count.should == 0
+  
+end
+
+it "should support deleting on non empty tables" do
+  
+  subject.dataset(:non_empty_table).count.should == 2
+  
+  subject.delete(:non_empty_table)
+  
+  subject.dataset(:non_empty_table).count.should == 0
+  
+end
+
+it "should allow specifying a projection tuple" do
+  
+  subject.dataset(:non_empty_table).count.should == 2
+  
+  subject.delete(:non_empty_table, :id => 1)
+  
+  subject.dataset(:non_empty_table).to_a.should == [ {:id => 2, :english => "Two"} ]
+  
+end
+
+

data/test/contract/data/transaction_driven/direct_sql.ex

@@ -0,0 +1,19 @@
+it "should support SELECT queries" do
+  
+  got = subject.direct_sql("SELECT * FROM basic_values")
+
+  got.should be_kind_of(DbAgile::Contract::Data::Dataset)
+  
+  got.to_a.should == basic_values
+  
+end
+
+it "should be smart enough" do
+
+  subject.direct_sql("SELECT * FROM basic_values").should be_kind_of(DbAgile::Contract::Data::Dataset)
+
+  subject.direct_sql("select * from basic_values").should be_kind_of(DbAgile::Contract::Data::Dataset)
+
+  subject.direct_sql("   select * from basic_values where id=1").should be_kind_of(DbAgile::Contract::Data::Dataset)
+
+end

data/test/contract/data/transaction_driven/insert.ex

@@ -0,0 +1,8 @@
+it "should support inserting valid tuples" do
+  
+  subject.insert(:empty_table, :id => 1).should == {:id => 1}
+  
+  subject.dataset(:empty_table).count.should == 1
+  
+end
+

data/test/contract/data/transaction_driven/update.ex

@@ -0,0 +1,19 @@
+it "should support updating all tuples" do
+  
+  subject.update(:non_empty_table, :english => "None")
+  
+  expected = [{:id => 1, :english => "None"}, {:id => 2, :english => "None"}]
+
+  subject.dataset(:non_empty_table).to_a.sort{|t1,t2| t1[:id] <=> t2[:id]}.should == expected
+  
+end
+
+it "should support updating some tuples only" do
+  
+  subject.update(:non_empty_table, {:english => "None"}, {:id => 1})
+  
+  expected = [{:id => 1, :english => "None"}, {:id => 2, :english => "Two"}]
+
+  subject.dataset(:non_empty_table).to_a.sort{|t1,t2| t1[:id] <=> t2[:id]}.should == expected
+  
+end

data/test/contract/data/transaction_driven.spec

@@ -0,0 +1,18 @@
+shared_examples_for "A Contract::Data::TransactionDriven" do
+
+  ::DbAgile::Contract::Data::TransactionDriven.instance_methods(false).each do |meth|
+    it { should respond_to(meth) }
+  end
+  
+  after(:each){ 
+    subject.delete(:empty_table)     
+  }
+  after(:each){ 
+    subject.delete(:non_empty_table) 
+    subject.insert(:non_empty_table, :id => 1, :english => "One")
+    subject.insert(:non_empty_table, :id => 2, :english => "Two")
+  }
+  
+  dbagile_install_examples(__FILE__, self)
+
+end

data/test/contract/robust/data/table_driven.spec

@@ -0,0 +1,15 @@
+shared_examples_for "A robust Contract::Data::TableDriven" do
+
+  it "should raise a NoSuchTableError on dataset when table does not exists" do
+  
+    lambda { subject.dataset(:unexisting) }.should raise_error(DbAgile::NoSuchTableError)
+  
+  end
+
+  it "should raise a NoSuchTableError on exists? when table does not exists" do
+  
+    lambda { subject.exists?(:unexisting) }.should raise_error(DbAgile::NoSuchTableError)
+  
+  end
+
+end

data/test/contract/robust/data/transaction_driven.spec

@@ -0,0 +1,21 @@
+shared_examples_for "A robust Contract::Data::TransactionDriven" do
+
+  it "should raise a NoSuchTableError on delete when table does not exists" do
+  
+    lambda { subject.delete(:unexisting) }.should raise_error(DbAgile::NoSuchTableError)
+  
+  end
+
+  it "should raise a NoSuchTableError on insert when table does not exists" do
+  
+    lambda { subject.insert(:unexisting, :id => 1) }.should raise_error(DbAgile::NoSuchTableError)
+  
+  end
+
+  it "should raise a NoSuchTableError on update when table does not exists" do
+  
+    lambda { subject.update(:unexisting, :id => 1) }.should raise_error(DbAgile::NoSuchTableError)
+  
+  end
+  
+end

data/test/contract/robust/schema/table_driven.spec

@@ -0,0 +1,21 @@
+shared_examples_for "A robust Contract::Schema::TableDriven" do
+
+  it "should raise a NoSuchTableError on column_names when table does not exists" do
+  
+    lambda { subject.column_names(:unexisting) }.should raise_error(DbAgile::NoSuchTableError)
+  
+  end
+
+  it "should raise a NoSuchTableError on has_column? when table does not exists" do
+  
+    lambda { subject.has_column?(:unexisting, :id) }.should raise_error(DbAgile::NoSuchTableError)
+  
+  end
+
+  it "should raise a NoSuchTableError on heading when table does not exists" do
+  
+    lambda { subject.heading(:unexisting) }.should raise_error(DbAgile::NoSuchTableError)
+  
+  end
+
+end