dbagile 0.0.1

data/test/restful.spec

@@ -0,0 +1,32 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'dbagile/restful/server'
+require 'dbagile/restful/client'
+dbagile_load_all_subspecs(__FILE__)
+
+describe "DbAgile::Restful feature" do
+  
+  let(:environment){ DbAgile::Fixtures::environment                        }
+  let(:database_name){ :sqlite                                             }
+  let(:database)   { environment.repository.database(database_name)      }
+  let(:server)     { DbAgile::Restful::Server.new(environment)             }
+  let(:client)     { DbAgile::Restful::Client.new(server.uri)              }
+  before(:all)     { server.start                                          }
+  after(:all)      { server.stop                                           }
+  
+  def basic_values_uri(extension = "")
+    "#{database_name}/basic_values#{extension}"
+  end
+      
+  describe "the GET interface" do
+    it_should_behave_like "The Restful GET interface" 
+  end
+
+  describe "the POST interface" do
+    it_should_behave_like "The Restful POST interface" 
+  end
+
+  describe "the DELETE interface" do
+    it_should_behave_like "The Restful DELETE interface" 
+  end
+
+end

data/test/run_all_suite.rb

@@ -0,0 +1,51 @@
+$silent = (ARGV[0] == "--silent")
+begin
+  require 'rubygems'
+  require 'highline'
+  $highline = HighLine.new
+rescue LoadError
+  puts "Better test suite summary with highline. Try 'gem install highline'"
+end
+
+# Say something
+def color(message, color)
+  if $highline
+    $highline.color(message, color)
+  else
+    message
+  end
+end
+
+# Test suite in order
+tests = [ :assumptions, :unit, :contract, :commands, :restful ]
+
+# Will contain interesting lines 
+summary = []
+
+# Let's go
+tests.each do |kind| 
+  file = File.expand_path("../#{kind}.spec", __FILE__)
+  
+  puts "Running #{kind} (#{kind}.spec)"
+  summary << "\nSummary for #{kind}_test (#{kind}.spec)\n"
+  
+  # Executes it in a subprocess
+  IO.popen("ruby #{file} 2>&1"){|io|
+    while l = io.gets
+      puts l unless $silent
+      unless l =~ /^\s*\.*\s*$|\(in /
+        if l =~ /0 failures/
+          summary << "  " << color(l, :green) 
+        elsif l =~ /failures/
+          summary << "  " << color(l, :red)
+        elsif l =~ /Finished/
+          summary << "  " << color(l, :blue)
+        else
+          summary << "  " << l
+        end
+      end
+    end
+  }
+end
+
+puts summary.join("")

data/test/spec_helper.rb

@@ -0,0 +1,26 @@
+$LOAD_PATH.unshift(File.expand_path('../', __FILE__))
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'dbagile'
+require 'rubygems'
+require 'fixtures'
+require 'spec'
+require 'spec/autorun'
+require 'fileutils'
+
+def dbagile_load_all_subfiles(requester_file, match)
+  Dir[File.expand_path("../#{match}", requester_file)].each{|f| load(f)}
+end
+
+def dbagile_load_all_subspecs(requester_file, name = File.basename(requester_file, ".spec"))
+  dbagile_load_all_subfiles(requester_file, "#{name}/**/*.spec")
+end
+
+def dbagile_install_examples(requester_file, requester)
+  match = "../#{File.basename(requester_file, '.spec')}/**/*.ex"
+  Dir[File.expand_path(match, requester_file)].each do |file|
+    requester.instance_eval File.read(file)
+  end
+end
+
+dbagile_load_all_subfiles(__FILE__, "support/*.rb")

data/test/support/be_a_valid_json_string.rb

@@ -0,0 +1,19 @@
+Spec::Matchers.define :be_a_valid_json_string do
+  match do |actual|
+    begin
+      JSON::parse(actual)
+      true
+    rescue JSON::JSONError
+      false
+    end
+  end
+  failure_message_for_should do |actual|
+    "expected that #{actual.inspect} would be a valid JSON string"
+  end
+  failure_message_for_should_not do |actual|
+    "expected that #{actual.inspect} would not be a valid JSON string"
+  end
+  description do
+    "a valid JSON string"
+  end
+end

data/test/support/be_a_valid_yaml_string.rb

@@ -0,0 +1,18 @@
+Spec::Matchers.define :be_a_valid_yaml_string do
+  match do |actual|
+    begin
+      !YAML::load(actual).nil?
+    rescue StandardError
+      false
+    end
+  end
+  failure_message_for_should do |actual|
+    "expected that #{actual.inspect} would be a valid YAML string"
+  end
+  failure_message_for_should_not do |actual|
+    "expected that #{actual.inspect} would not be a valid YAML string"
+  end
+  description do
+    "a valid YAML string"
+  end
+end

data/test/unit/adapter/factor.spec

@@ -0,0 +1,13 @@
+require File.expand_path('../../fixtures', __FILE__)
+describe "::DbAgile::Adapter.factor" do
+  
+  let(:options){ Hash.new }
+  subject{ ::DbAgile::Adapter.factor(uri, options) }
+  
+  describe "when called with sqlite scheme" do
+    let(:uri){ "sqlite://test.db" }
+    it{ should be_kind_of(::DbAgile::SequelAdapter) }
+  end
+  
+  
+end

data/test/unit/adapter/sequel/new.spec

@@ -0,0 +1,19 @@
+require File.expand_path('../../../fixtures', __FILE__)
+describe "::DbAgile::SequelAdapter.new" do
+  
+  context "when called without options at all" do
+    subject{ DbAgile::SequelAdapter.new("sqlite://test.db") }
+    it{ should be_kind_of(DbAgile::SequelAdapter) }
+  end 
+  
+  context "when called without options but no tracing" do
+    subject{ DbAgile::SequelAdapter.new("sqlite://test.db", :trace_sql => false) }
+    it{ should be_kind_of(DbAgile::SequelAdapter) }
+  end 
+  
+  context "when called without options but no tracing" do
+    subject{ DbAgile::SequelAdapter.new("sqlite://test.db", :trace_sql => true) }
+    it{ should be_kind_of(DbAgile::SequelAdapter::SequelTracer) }
+  end 
+  
+end

data/test/unit/command/api.spec

@@ -0,0 +1,12 @@
+describe "::DbAgile::Command::API" do
+  
+  let(:api){ ::DbAgile::Command::API.new(DbAgile::default_environment) }
+  
+  it "should have instance methods for each command" do
+    ::DbAgile::Command::each_subclass do |subclass|
+      command_name = DbAgile::Command::ruby_method_for(subclass)
+      api.should respond_to(command_name)
+    end
+  end
+  
+end

data/test/unit/command/command_for.spec

@@ -0,0 +1,36 @@
+require File.expand_path('../../fixtures', __FILE__)
+describe "::DbAgile::Command::command_for /" do
+  
+  subject{ ::DbAgile::Command::command_for(arg, nil) }
+  
+  describe "when called with a class" do
+    let(:arg){ ::DbAgile::Command::Db::List }
+    it{ should be_kind_of(::DbAgile::Command::Db::List) }
+  end
+  
+  describe "when called with a string on a root command" do
+    let(:arg){ "help" }
+    it{ should be_kind_of(::DbAgile::Command::Help) }
+  end
+  
+  describe "when called with a string on a non root command" do
+    let(:arg){ "sql:heading" }
+    it{ should be_kind_of(::DbAgile::Command::SQL::Heading) }
+  end
+  
+  describe "when called with a symbol on a root command" do
+    let(:arg){ :help }
+    it{ should be_kind_of(::DbAgile::Command::Help) }
+  end
+  
+  describe "when called with a symbol on a non root command" do
+    let(:arg){ :sql_heading }
+    it{ should be_kind_of(::DbAgile::Command::SQL::Heading) }
+  end
+
+  describe "when called with a symbol on a non root command" do
+    let(:arg){ :schema_sql_script }
+    it{ should be_kind_of(::DbAgile::Command::Schema::SqlScript) }
+  end
+
+end

data/test/unit/command/command_name_of.spec

@@ -0,0 +1,21 @@
+require File.expand_path('../../fixtures', __FILE__)
+describe "::DbAgile::Command::command_name_of /" do
+  
+  subject{ ::DbAgile::Command::command_name_of(command) }
+  
+  describe "when called on a root command" do
+    let(:command){ DbAgile::Command::Help }
+    it{ should == "help" }
+  end
+  
+  describe "when called on a non root command" do
+    let(:command){ DbAgile::Command::SQL::Heading }
+    it{ should == "sql:heading" }
+  end
+  
+  describe "when called on a complex name command" do
+    let(:command){ DbAgile::Command::Schema::SqlScript }
+    it{ should == "schema:sql-script" }
+  end
+  
+end

data/test/unit/command/ruby_method_for.spec

@@ -0,0 +1,21 @@
+require File.expand_path('../../fixtures', __FILE__)
+describe "::DbAgile::Command::ruby_method_for /" do
+  
+  subject{ ::DbAgile::Command::ruby_method_for(command) }
+  
+  describe "when called on a root command" do
+    let(:command){ DbAgile::Command::Help }
+    it{ should == :help }
+  end
+  
+  describe "when called on a non root command" do
+    let(:command){ DbAgile::Command::SQL::Heading }
+    it{ should == :sql_heading }
+  end
+  
+  describe "when called on a complex name command" do
+    let(:command){ DbAgile::Command::Schema::SqlScript }
+    it{ should == :schema_sql_script }
+  end
+  
+end

data/test/unit/command/sanity.spec

@@ -0,0 +1,34 @@
+require File.expand_path('../../fixtures', __FILE__)
+describe "command sanity /" do
+  
+  DbAgile::Command::each_subclass{|cmd|
+    describe "#{cmd.command_name}" do
+      
+      it "should have a summary" do
+        cmd.summary.should_not be_nil
+        cmd.summary.strip.should_not be_empty
+      end
+      
+      it "should have a category" do
+        cmd.category.should_not be_nil
+        cmd.category.should be_kind_of(Symbol)
+      end
+      
+      unless cmd.command_name == "dba"
+
+        it "should have a usage" do
+          cmd.usage.should =~ /^Usage: dba #{cmd.command_name}/
+        end
+      
+      else
+        
+        it "should have the description" do
+          cmd.description.should =~ /blambeau.github.com/
+        end
+        
+      end
+      
+    end
+  }
+  
+end

data/test/unit/contract/utils/delegate/delegate.spec

@@ -0,0 +1,23 @@
+describe "::DbAgile::Contract::Utils::Delegate" do
+  
+  describe "methods should correctly be installed" do
+    subject{ Object.new.extend(::DbAgile::Contract::Utils::Delegate) }
+    it{ should respond_to(:dataset) }
+  end
+  
+  describe "method should pass parameters correctly" do
+    subject{ 
+      subject = Object.new.extend(::DbAgile::Contract::Utils::Delegate) 
+      def subject.delegate
+        o = Object.new
+        def o.dataset(name)
+          "Hello #{name}"
+        end
+        o
+      end
+      subject
+    }
+    specify { subject.dataset(:world).should == "Hello world" }
+  end
+  
+end

data/test/unit/core/chain/chain.spec

@@ -0,0 +1,57 @@
+require File.expand_path('../../../fixtures', __FILE__)
+describe "DbAgile::Core::Chain" do
+
+  context "When created with only one instance member" do
+    let(:chain){ DbAgile::Core::Chain.new(DbAgile::Fixtures::SayHello.new) }
+    specify{ chain.say_hello("dbagile").should == "dbagile" }
+  end
+  
+  context "When created with only one class member" do
+    let(:chain){ DbAgile::Core::Chain.new(DbAgile::Fixtures::SayHello) }
+    specify{ chain.say_hello("dbagile").should == "dbagile" }
+  end
+  
+  context "When created with only two members" do
+    let(:chain){ DbAgile::Core::Chain.new(DbAgile::Fixtures::Capitalize.new, DbAgile::Fixtures::SayHello.new) }
+    specify{ chain.say_hello("dbagile").should == "Dbagile" }
+  end
+  
+  context "When creaed with two members as classes" do
+    let(:chain){ DbAgile::Core::Chain.new(DbAgile::Fixtures::Capitalize, DbAgile::Fixtures::SayHello) }
+    specify{ chain.say_hello("dbagile").should == "Dbagile" }
+  end
+  
+  context "When created with two members with options as classes" do
+    let(:chain){ DbAgile::Core::Chain.new(DbAgile::Fixtures::Capitalize, :upcase, DbAgile::Fixtures::SayHello) }
+    specify{ chain.say_hello("dbagile").should == "DBAGILE" }
+  end
+  
+  context "When created with two members through shortcut" do
+    let(:chain){ DbAgile::Core::Chain[DbAgile::Fixtures::Capitalize, :upcase, DbAgile::Fixtures::SayHello] }
+    specify{ chain.say_hello("dbagile").should == "DBAGILE" }
+  end
+  
+  context "When plugged with only one instance member" do
+    let(:chain){ DbAgile::Core::Chain.new }
+    specify{ 
+      chain.plug(DbAgile::Fixtures::SayHello.new)
+      chain.say_hello("dbagile").should == "dbagile" 
+    }
+  end
+  
+  context "When plugged different way" do
+    let(:chain){ DbAgile::Core::Chain.new(DbAgile::Fixtures::SayHello) }
+    specify{ 
+      chain.plug(DbAgile::Fixtures::Capitalize, :upcase)
+      chain.say_hello("dbagile").should == "DBAGILE" 
+    }
+  end
+
+  context "When blocks are used" do
+    let(:chain){ DbAgile::Core::Chain.new(DbAgile::Fixtures::SayHello.new) }
+    specify{ 
+      chain.del_to_block{ "hello" }.should == "hello" 
+    }
+  end
+
+end

data/test/unit/core/chain/connect.spec

@@ -0,0 +1,22 @@
+require File.expand_path('../../../fixtures', __FILE__)
+describe "DbAgile::Core::Chain#connect" do
+  
+  subject{ chain.connect(DbAgile::Fixtures::SayHello) }
+
+  context("when reverse then capitalize") do
+    let(:chain){ DbAgile::Core::Chain[DbAgile::Fixtures::Reverse, DbAgile::Fixtures::Capitalize] }
+    specify{
+      subject.should be_kind_of(DbAgile::Core::Chain)
+      subject.say_hello("dbagile").should == "Eligabd"
+    }
+  end
+  
+  context("when capitalize then reverse") do
+    let(:chain){ DbAgile::Core::Chain[DbAgile::Fixtures::Capitalize, DbAgile::Fixtures::Reverse] }
+    specify{
+      subject.should be_kind_of(DbAgile::Core::Chain)
+      subject.say_hello("dbagile").should == "eligabD"
+    }
+  end
+  
+end

data/test/unit/core/chain/delegate_chain.spec

@@ -0,0 +1,16 @@
+require File.expand_path('../../../fixtures', __FILE__)
+describe "DbAgile::Core::Chain#delegate_chain" do
+  
+  subject{ chain.delegate_chain }
+  
+  context "when called on an emtpy chain" do
+    let(:chain){ DbAgile::Core::Chain.new }
+    it{ should == [] }
+  end
+  
+  context "when called on a non emtpy chain" do
+    let(:chain){ DbAgile::Core::Chain.new("hello") }
+    it{ should == ["hello"] }
+  end
+  
+end

data/test/unit/core/chain/initialize.spec

@@ -0,0 +1,19 @@
+require File.expand_path('../../../fixtures', __FILE__)
+describe "DbAgile::Core::Chain#initialize" do
+  
+  context "when called with no args" do
+    let(:chain){ DbAgile::Core::Chain.new }
+    specify{ chain.delegate_chain.should == [] }
+  end
+  
+  context "when called one argument" do
+    let(:chain){ DbAgile::Core::Chain.new("hello") }
+    specify{ chain.delegate_chain.should == ["hello"] }
+  end
+  
+  context "when called many arguments" do
+    let(:chain){ DbAgile::Core::Chain.new("hello 1", "hello 2") }
+    specify{ chain.delegate_chain.should == ["hello 1", "hello 2"] }
+  end
+  
+end

data/test/unit/core/chain/plug.spec

@@ -0,0 +1,31 @@
+require File.expand_path('../../../fixtures', __FILE__)
+describe "DbAgile::Core::Chain#plug" do
+  
+  context "when called on an empty chain" do
+    let(:chain){ DbAgile::Core::Chain.new }
+    subject{ chain.plug("hello") }
+    specify{
+      subject.should == chain
+      chain.delegate_chain.should == ["hello"]
+    }
+  end
+  
+  context "when called on a non empty chain" do
+    let(:chain){ DbAgile::Core::Chain.new("hello 1") }
+    subject{ chain.plug("hello 2") }
+    specify{
+      subject.should == chain
+      chain.delegate_chain.should == ["hello 2", "hello 1"]
+    }
+  end
+
+  context "when called with multiple arguments" do
+    let(:chain){ DbAgile::Core::Chain.new() }
+    subject{ chain.plug("hello 1", "hello 2") }
+    specify{
+      subject.should == chain
+      chain.delegate_chain.should == ["hello 1", "hello 2"]
+    }
+  end
+  
+end

data/test/unit/core/io/dsl/scope.spec

@@ -0,0 +1,9 @@
+require File.expand_path('../../../../fixtures', __FILE__)
+describe "DbAgile::Core::IO::DSL's scope" do
+  
+  it "should resolve File correctly" do
+    DbAgile::Core::IO::DSL.instance_eval{ File }.should == ::File
+    DbAgile::Core::IO::DSL.new.instance_eval{ File }.should == ::File
+  end
+  
+end

data/test/unit/core/repository/create_bang.spec

@@ -0,0 +1,31 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::Core::Repository::create! /" do
+  
+  describe "on an unexisting folder" do
+    before{ FileUtils.rm_rf(path) }
+    after { FileUtils.rm_rf(path) }
+    let(:path){ DbAgile::Fixtures::Core::Repository::repository_path(:unexisting) }
+    
+    it "should not raise any error" do
+      lambda{ DbAgile::Core::Repository::create!(path) }.should_not raise_error
+    end
+    
+    it "should return a repository instance with correct version number" do
+      repo = DbAgile::Core::Repository::create!(path)
+      repo.should be_kind_of(DbAgile::Core::Repository)
+      repo.version.should == DbAgile::VERSION
+    end
+    
+    it "should create a reloadable repository with correct version number" do
+      created = DbAgile::Core::Repository::create!(path)
+      created.send(:version=, "0.99.0")
+      created.save!
+      reloaded = DbAgile::Core::Repository::load(path)
+      reloaded.version.should == "0.99.0"
+    end
+    
+  end
+  
+  
+
+end

data/test/unit/core/repository/current.spec

@@ -0,0 +1,31 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::Core::Repository#current?" do
+
+  let(:database){ DbAgile::Fixtures::Core::Repository::repository(:test_and_prod) }
+
+  describe("When called with an existing but not current database (name)") do
+    subject{ database.current?(:test) }
+    it{ should == false }
+  end
+
+  describe("When called with an existing and current database (name)") do
+    subject{ database.current?(:production) }
+    it{ should == true }
+  end
+
+  describe("When called with an existing but not current database (instance)") do
+    subject{ database.current?(database.database(:test)) }
+    it{ should == false }
+  end
+
+  describe("When called with an existing and current database (instance)") do
+    subject{ database.current?(database.database(:production)) }
+    it{ should == true }
+  end
+
+  describe("When called with an missing database (name)") do
+    subject{ database.current?(:nosuchone) }
+    it{ should be_nil }
+  end
+  
+end

data/test/unit/core/repository/database.spec

@@ -0,0 +1,47 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::Core::Repository#database" do
+
+  let(:repository){ DbAgile::Fixtures::Core::Repository::repository(:test_and_prod) }
+
+  describe("When called with an unexisting database name") do
+    subject{ repository.database(:test) }
+    specify{
+      subject.should be_kind_of(::DbAgile::Core::Database)
+      subject.name.should == :test
+      subject.uri.should == "test.db"
+    }
+  end
+
+  describe("When called with an unexisting database instance") do
+    subject{ repository.database(repository.database(:test)) }
+    specify{
+      subject.should be_kind_of(::DbAgile::Core::Database)
+      subject.name.should == :test
+      subject.uri.should == "test.db"
+    }
+  end
+  
+  describe("When called with a String for uri") do
+    subject{ repository.database("test.db") }
+    specify{
+      subject.should be_kind_of(::DbAgile::Core::Database)
+      subject.name.should == :test
+      subject.uri.should == "test.db"
+    }
+  end
+
+  describe("When called with a Regexp for uri") do
+    subject{ repository.database(/postgres/) }
+    specify{
+      subject.should be_kind_of(::DbAgile::Core::Database)
+      subject.name.should == :production
+      subject.uri.should == "postgres://postgres@localhost/test"
+    }
+  end
+
+  describe("When called with an missing database") do
+    subject{ repository.database(:nosuchone) }
+    it{ should be_nil }
+  end
+  
+end

data/test/unit/core/repository/fixtures/corrupted/dbagile.idx

@@ -0,0 +1 @@
+sdkjqhkj

data/test/unit/core/repository/fixtures/test_and_prod/dbagile.idx

@@ -0,0 +1,21 @@
+--- 
+version: 0.0.1
+databases: 
+  production: 
+    uri: postgres://postgres@localhost/test
+    announced_schema:
+    - schema.yaml
+    effective_schema:
+    - production.yaml
+  test: 
+    uri: test.db
+    announced_schema: 
+    - schema.yaml
+    effective_schema: 
+    - effective.yaml
+    - unsupported.yaml
+  robust:
+    uri: robust.db
+    plugins:
+    - DbAgile::Contract::Robust::Optimistic
+current: production

data/test/unit/core/repository/fixtures.rb

@@ -0,0 +1,25 @@
+require File.expand_path('../../../fixtures', __FILE__)
+module DbAgile
+  module Fixtures
+    module Core
+      module Repository
+        include Fixtures::Utils
+    
+        def repository_path(name_or_file)
+          find_file(name_or_file, __FILE__)
+        end
+      
+        def each_repository_path(&block)
+          each_dir(__FILE__, &block)
+        end
+      
+        # Returns a Schema instance for a given name
+        def repository(name_or_file)
+          DbAgile::Core::Repository::load(repository_path(name_or_file))
+        end
+      
+        extend(Repository)
+      end
+    end # module Core
+  end # module Fixtures
+end # module DbAgile