dumpdb 1.0.0.rc1

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.log
+*.rbc
+.bundle
+.config
+.yardoc
+.rvmrc
+.rbenv-version
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem 'bundler', '~>1.1'
+gem 'rake',    '~>0.9.2'

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012-Present Kelly Redding
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,263 @@
+# Dumpdb
+
+Dump and restore your databases.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'dumpdb'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dumpdb
+
+## Usage
+
+```ruby
+require 'dumpdb'
+
+class MysqlFullRestore
+  include Dumpdb
+
+  databases { '/path/to/database.yml'}
+  dump_file { "dump.bz2" }
+  source { db('production',  :output_root => '/some/source/dir') }
+  target { db('development', :output_root => '/some/target/dir') }
+
+  dump    { "mysqldump -u :user -p\":pw\" :db | bzip2 > :dump_file" }
+  restore { "mysqladmin -u :user -p\":pw\" -f -b DROP :db; true" }
+  restore { "mysqladmin -u :user -p\":pw\" -f CREATE :db" }
+  restore { "bunzip2 -c :dump_file | mysql -u :user -p\":pw\" :db" }
+
+end
+```
+
+Dumpdb provides a framework for scripting database backups and restores.  You configure your source and target db settings.  You define the set of commands needed for your script to dump the (local or remote) source database and optionally restore the dump to the (local) target database.
+
+### Running
+
+Once you have created an instance of your script with its database settings you can run it.
+
+```ruby
+MysqlFullRestore.new.run
+```
+
+Dumpdb runs the dump commands using source settings and runs the restore commands using target settings.  By default, Dumpdb assumes both the dump and restore commands are to be run on the local system.
+
+### Runner Callbacks
+
+Dumpdb supports defining callbacks for your script.  These get fired as the script is being run.
+
+```ruby
+class MysqlFullRestore
+  include Dumpdb
+
+  # ...
+
+  def after_dump
+    # this will be called after the dump commands have been run
+  end
+
+end
+```
+
+Available callbacks:
+
+* `{before|after}_run` - called before/after any commands have been executed
+* `{before|after}_setup` - called before/after the runner sets up the script run
+* `{before|after}_dump` - called before/after the dump cmds are executed
+* `{before|after}_copy_dump` - called before/after the dump file is copied from source to target
+* `{before|after}_restore` - called before/after the restore cmds are executed
+* `{before|after}_teardown` - called before/after the runner tears down the script run
+* `{before|after}_cmd_run` - called before/after each cmd is run, passes the cmd obj being run
+
+Phases occur in this order: setup, dump, copy_dump, restore, teardown
+
+### Remote dumps
+
+To run your dump commands on a remote server, specify the optional `ssh` setting.
+
+```ruby
+class MysqlFullRestore
+  include Dumpdb
+
+  ssh { 'user@host' }
+
+  # ...
+end
+```
+
+This tells Dumpdb to run the dump commands using ssh on a remote host and to download the dump file using sftp.
+
+## Define your script
+
+Every Dumpdb script assumes there are two types of commands involved: dump commands that run using source settings and restore commands that run using target settings.  The dump commands should produce a single "dump file" (typically a compressed file or tar).  The restore commands restore the local db from the dump file.
+
+### The Dump File
+
+You specify the name of the dump file using the `dump_file` setting
+
+```ruby
+# ...
+dump_file { "dump.bz2" }
+#...
+```
+
+This tells Dumpdb what file is being generated by the dump and will be used in the restore.  The dump commands should produce it.  The restore commands should use it.
+
+### Dump commands
+
+Dump commands are system commands that should produce the dump file.
+
+```ruby
+# ...
+dump { "mysqldump -u :user -p :pw :db | bzip2 > :dump_file" }
+#...
+```
+
+### Restore commands
+
+Restore commands are system commands that should restore the local db from the dump file.
+
+```ruby
+# ...
+restore { "mysqladmin -u :user :pw -f -b DROP :db; true" }   # drop the local db, whether it exists or not
+restore { "mysqladmin -u :user :pw -f CREATE :db" }          # recreate the local db
+restore { "bunzip2 -c :dump_file | mysql -u :user :pw :db" } # unzip the dump file and apply it to the db
+#...
+```
+
+### Command Placeholders
+
+Dump and restore commands are templated.  You define the command with placeholders and appropriate setting values are substituted in when the script is run.
+
+Command placeholders should correspond with keys in the source or target settings.  Dump commands use the source settings and restore commands use the target settings.
+
+### Special Placeholders
+
+There are two special placeholders that are added to the source and target settings automatically:
+
+* `:output_dir`
+dir the dump file is written to or read from (depending on whether dumping or restoring).  This is generated by the script instance.  By default, no specific root value is used - pass in a `:output_root` value to the source and target to specify one.
+
+* `:dump_file`
+path of the dump file - uses the :output_dir setting
+
+You should at least use the `:dump_file` placeholder in your dump and restore commands to ensure proper dump handling and usage.
+
+```ruby
+dump_file { "dump.bz2" }
+
+dump    { "mysqldump :db | bzip2 > :dump_file" }
+restore { "bunzip2 -c :dump_file | mysql :db" }
+```
+
+## Source / Target settings
+
+A Dumpdb script needs to be told about its source and target settings.  You tell it these when you define your script:
+
+```ruby
+class MysqlFullRestore
+  include Dumpdb
+
+  source do
+    { 'user' => 'something',
+      'pw'   => 'secret',
+      'db'   => 'something_production',
+      'something' => 'else'
+    }
+  end
+
+  target do
+    { 'user' => 'root',
+      'pw'   => 'supersecret',
+      'db'   => 'something_development'
+    }
+  end
+
+  # ...
+end
+```
+
+Any settings keys can be used as command placeholders in dump and restore commands.
+
+**Note:** When reading source and target settings, Dumpdb takes common keys like 'hostname', 'username', 'password', and 'database' and exposes them with the more succinct 'host', 'user', 'pw', and 'db'.
+
+### Lookup settings from YAML
+
+Since many ORMs allow you to configure db connections using yaml files, Dumpdb supports specifying your databases from a yaml file.
+
+```ruby
+class MysqlFullRestore
+  include Dumpdb
+
+  databases { '/path/to/database.yml' }
+
+  # ...
+end
+```
+
+Now you can lookup your source and target settings using the `db` method.
+
+```ruby
+databases { '/path/to/database.yml' }
+source { db('production') }
+target { db('development') }
+```
+
+You can merge in additional settings by passing them to the `db` command:
+
+```ruby
+class MysqlFullRestore
+  include Dumpdb
+
+  databases { '/path/to/database.yml' }
+  source { db('produciton', :something => 'else') }
+
+  # ...
+end
+```
+
+### Building Commands
+
+As you may have noticed, the script DSL settings methods all take a proc as their argument.  This is because the procs are lazy-eval'd in the scope of the script instance.  This allows you to use interpolation to help build commands with dynamic data.
+
+Take this example where you want your dump script to honor ignored tables.
+
+```ruby
+require 'dumpdb'
+
+class MysqlIgnoredTablesRestore
+  include Dumpdb
+
+  # ...
+  dump { "mysqldump -u :user -p :pw :db #{ignored_tables} | bzip2 > :dump_file" }
+  # ...
+
+  def initialize(opts={})
+    opts[:ignored_tables] ||= []
+    @opts = opts
+  end
+
+  def ignored_tables
+    @opts[:ignored_tables].collect {|t| "--ignore-table=#{source.db}.#{t}"}.join(' ')
+  end
+end
+```
+
+## Examples
+
+See `examples/` dir. (TODO)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+
+require 'assert/rake_tasks'
+Assert::RakeTasks.install
+
+require 'bundler/gem_tasks'
+
+task :default => :build

data/dumpdb.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/dumpdb/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = "dumpdb"
+  gem.version     = Dumpdb::VERSION
+  gem.description = %q{Dump and restore your databases.}
+  gem.summary     = %q{Dump and restore your databases.}
+
+  gem.authors     = ["Kelly Redding", "Collin Redding"]
+  gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
+  gem.homepage    = "http://github.com/redding/dumpdb"
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency("assert")
+  gem.add_dependency("scmd", ["~>2.0"])
+  gem.add_dependency("ns-options", ["1.0.0.rc1"])
+end

data/lib/dumpdb/db.rb

@@ -0,0 +1,47 @@
+require 'ostruct'
+
+module Dumpdb
+
+  class Db
+
+    def initialize(dump_file_name, values=nil)
+      @dump_file_name = dump_file_name || 'dump.output'
+      @values = (values || {}).inject({}) do |vals, (k, v)|
+        # stringify keys
+        vals.merge(k.to_s => v)
+      end
+
+      @values['host']        ||= (@values['hostname'] || '')
+      @values['user']        ||= (@values['username'] || '')
+      @values['pw']          ||= (@values['password'] || '')
+      @values['db']          ||= (@values['database'] || '')
+      @values['output_root'] ||= ''
+
+      @values['output_dir'] = output_dir(self.output_root, "#{self.host}__#{self.db}")
+      @values['dump_file']  = File.join(self.output_dir, @dump_file_name)
+    end
+
+    def to_hash; @values; end
+
+    def method_missing(meth, *args, &block)
+      if @values.has_key?(meth.to_s)
+        @values[meth.to_s]
+      else
+        super
+      end
+    end
+
+    def respond_to?(meth)
+      @values.has_key?(meth.to_s) || super
+    end
+
+    private
+
+    def output_dir(root, name)
+      name_time = "#{name}__#{Time.now.to_f}"
+      root && !root.empty? ? File.join(root, name_time) : name_time
+    end
+
+  end
+
+end

data/lib/dumpdb/runner.rb

@@ -0,0 +1,76 @@
+require 'dumpdb/settings'
+
+module Dumpdb
+  class Runner
+
+    attr_reader :script, :cmd_runner
+
+    def initialize(script, opts={})
+      @script = script
+      @cmd_runner = opts[:cmd_runner] || scmd_cmd_runner
+    end
+
+    def run
+      run_callback 'before_run'
+      run_callback 'before_setup'
+      run_setup
+
+      begin
+        run_callback 'after_setup'
+        [:dump, :copy_dump, :restore].each{|phase_name| run_phase phase_name}
+      ensure
+        run_phase 'teardown'
+        run_callback 'after_run'
+      end
+    end
+
+    protected
+
+    def run_setup
+      run_cmd(@script.dump_cmd    { "mkdir -p #{source.output_dir}"  })
+      run_cmd(@script.restore_cmd { "mkdir -p #{target.output_dir}"  })
+    end
+
+    def run_dump
+      @script.dump_cmds.each{|cmd| run_cmd(cmd)}
+    end
+
+    def run_copy_dump
+      run_cmd @script.copy_dump_cmd
+    end
+
+    def run_restore
+      @script.restore_cmds.each{|cmd| run_cmd(cmd)}
+    end
+
+    def run_teardown
+      run_cmd(@script.dump_cmd    { "rm -rf #{source.output_dir}" })
+      run_cmd(@script.restore_cmd { "rm -rf #{target.output_dir}" })
+    end
+
+    private
+
+    def run_phase(phase_name)
+      run_callback "before_#{phase_name}"
+      self.send("run_#{phase_name}")
+      run_callback "after_#{phase_name}"
+    end
+
+    def run_cmd(cmd_str)
+      cmd_obj = @cmd_runner.new(cmd_str)
+      run_callback('before_cmd_run', cmd_obj)
+      cmd_obj.run!
+      run_callback('after_cmd_run', cmd_obj)
+    end
+
+    def run_callback(meth, *args)
+      @script.send(meth.to_s, *args)
+    end
+
+    def scmd_cmd_runner
+      require 'scmd'
+      Scmd
+    end
+
+  end
+end

data/lib/dumpdb/settings.rb

@@ -0,0 +1,100 @@
+require 'dumpdb/db'
+
+module Dumpdb::Settings
+
+  class Base
+
+    attr_reader :proc
+
+    def initialize(proc=nil)
+      @proc = proc.kind_of?(::Proc) ? proc : Proc.new { proc }
+    end
+
+    def value(script)
+      script.instance_eval &@proc
+    end
+
+  end
+
+  class Ssh < Base; end
+
+  class Databases < Base
+
+    def value(script)
+      val = super
+      val.kind_of?(::String) ? load_yaml(val) : val
+    end
+
+    private
+
+    def load_yaml(file_path)
+      YAML.load(File.read(File.expand_path(file_path)))
+    end
+  end
+
+  class DumpFile < Base; end
+
+  class SourceTarget < Base
+
+    def value(script)
+      val = super
+      val.kind_of?(Dumpdb::Db) ? val : Dumpdb::Db.new(script.dump_file, val)
+    end
+
+  end
+
+  class Cmd < Base
+
+    def value(script, placeholder_vals)
+      hsub(super(script), placeholder_vals)
+    end
+
+    private
+
+    def hsub(string, hash)
+      hash.inject(string) {|new_str, (k, v)| new_str.gsub(":#{k}", v.to_s)}
+    end
+
+  end
+
+  class DumpCmd < Cmd
+
+    def value(script, placeholder_vals={})
+      val = super(script, script.source.to_hash.merge(placeholder_vals))
+      if script.ssh?
+        val = "ssh -A #{script.ssh_opts} #{script.ssh} \"#{val}\""
+      end
+      val
+    end
+
+  end
+
+  class RestoreCmd < Cmd
+
+    def value(script, placeholder_vals={})
+      super(script, script.target.to_hash.merge(placeholder_vals))
+    end
+
+  end
+
+  class CopyDumpCmd < Cmd
+
+    def value(script)
+      if script.ssh?
+        "sftp #{script.ssh_opts} #{script.ssh}:#{script.source.dump_file} #{script.target.dump_file}"
+      else
+        "cp #{script.source.dump_file} #{script.target.dump_file}"
+      end
+    end
+
+  end
+
+  class CmdList < ::Array
+
+    def value(script, placeholder_vals={})
+      self.map{|cmd| cmd.value(script, placeholder_vals)}
+    end
+
+  end
+
+end

data/lib/dumpdb/version.rb

@@ -0,0 +1,3 @@
+module Dumpdb
+  VERSION = "1.0.0.rc1"
+end

data/lib/dumpdb.rb

@@ -0,0 +1,102 @@
+require 'ns-options'
+
+require 'dumpdb/settings'
+require 'dumpdb/db'
+require 'dumpdb/runner'
+
+module Dumpdb
+
+  class BadDatabaseName < RuntimeError; end
+
+  def self.included(receiver)
+    receiver.class_eval do
+      include NsOptions
+      options :settings do
+        option 'ssh',          Settings::Ssh,          :default => ''
+        option 'databases',    Settings::Databases,    :default => {}
+        option 'dump_file',    Settings::DumpFile,     :default => ''
+        option 'source',       Settings::SourceTarget, :default => {}
+        option 'target',       Settings::SourceTarget, :default => {}
+        option 'dump_cmds',    Settings::CmdList,      :default => []
+        option 'restore_cmds', Settings::CmdList,      :default => []
+      end
+
+      extend  SettingsDslMethods
+      include SettingsMethods
+
+      def self.inherited(subclass)
+        subclass.settings.apply(self.settings.to_hash)
+      end
+
+    end
+  end
+
+  module SettingsDslMethods
+
+    def ssh(&block);       settings.ssh       = Settings::Ssh.new(block);          end
+    def databases(&block); settings.databases = Settings::Databases.new(block);    end
+    def dump_file(&block); settings.dump_file = Settings::DumpFile.new(block);     end
+    def source(&block);    settings.source    = Settings::SourceTarget.new(block); end
+    def target(&block);    settings.target    = Settings::SourceTarget.new(block); end
+
+    def dump(&block);    settings.dump_cmds    << Settings::DumpCmd.new(block);    end
+    def restore(&block); settings.restore_cmds << Settings::RestoreCmd.new(block); end
+
+  end
+
+  module SettingsMethods
+
+    def settings; self.class.settings; end
+
+    def ssh;       @ssh       ||= settings.ssh.value(self);       end
+    def databases; @databases ||= settings.databases.value(self); end
+    def dump_file; @dump_file ||= settings.dump_file.value(self); end
+    def source;    @source    ||= settings.source.value(self);    end
+    def target;    @target    ||= settings.target.value(self);    end
+
+    def dump_cmds;     @dump_cmds     ||= settings.dump_cmds.value(self);        end
+    def restore_cmds;  @restore_cmds  ||= settings.restore_cmds.value(self);     end
+    def copy_dump_cmd; @copy_dump_cmd ||= Settings::CopyDumpCmd.new.value(self); end
+
+  end
+
+  def db(database_name, other_vals=nil)
+    if (db_vals = self.databases[database_name]).nil?
+      raise BadDatabaseName, "no database named `#{database_name}'."
+    end
+    Db.new(self.dump_file, db_vals.merge(other_vals || {}))
+  end
+
+  def dump_cmd(&block);   Settings::DumpCmd.new(block).value(self);    end
+  def restore_cmd(&block) Settings::RestoreCmd.new(block).value(self); end
+
+  def ssh?
+    self.ssh && !self.ssh.empty?
+  end
+
+  def ssh_opts
+    "-o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -o ConnectTimeout=10"
+  end
+
+  def run(cmd_runner=nil)
+    Runner.new(self, :cmd_runner => cmd_runner).run
+  end
+
+  # Callbacks
+
+  def before_run(*args);       end
+  def after_run(*args);        end
+  def before_setup(*args);     end
+  def after_setup(*args);      end
+  def before_dump(*args);      end
+  def after_dump(*args);       end
+  def before_copy_dump(*args); end
+  def after_copy_dump(*args);  end
+  def before_restore(*args);   end
+  def after_restore(*args);    end
+  def before_teardown(*args);  end
+  def after_teardown(*args);   end
+  def before_cmd_run(*args);   end
+  def after_cmd_run(*args);    end
+
+end

data/test/db_tests.rb

@@ -0,0 +1,33 @@
+require 'assert'
+require 'ostruct'
+
+module Dumpdb
+
+  class DbTests < Assert::Context
+    desc "the Db helper class"
+    setup do
+      @db = Db.new(nil)#(:host => 'h', :user => 'u', :pw => 'p', :db => 'd')
+    end
+    subject { @db }
+
+    should have_imeths :host, :user, :pw, :db, :output_root, :output_dir, :dump_file
+
+    should "default its values" do
+      [:host, :user, :pw, :db, :output_root].each do |val|
+        assert_equal '', subject.send(val)
+      end
+      assert_match '____',        subject.output_dir
+      assert_match 'dump.output', subject.dump_file
+    end
+
+    should "set values" do
+      db = Db.new('dump.file', :host => 'h', :db => 'd', :something => 'else')
+
+      assert_equal 'h',         db.host
+      assert_equal 'd',         db.db
+      assert_match 'h__d__',    db.output_dir
+      assert_match 'dump.file', db.dump_file
+    end
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,7 @@
+# this file is automatically required in when you require 'assert' in your tests
+# put test helpers here
+
+# add root dir to the load path
+$LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
+
+require 'test/support/test_scripts'

data/test/irb.rb

@@ -0,0 +1,9 @@
+require 'assert/setup'
+
+# this file is required in when the 'irb' rake test is run.
+# b/c 'assert/setup' is required above, the test helper will be
+# required in as well.
+
+# put any IRB setup code here
+
+require 'dumpdb'

data/test/runner_tests.rb

@@ -0,0 +1,41 @@
+require 'assert'
+require 'test/support/fake_cmd_runner'
+
+require 'dumpdb/runner'
+
+module Dumpdb
+
+  class RunnerTests < Assert::Context
+    desc "the runner"
+    setup do
+      FakeCmdRunner.reset
+      @script = RunnerScript.new
+      @runner = Runner.new(@script, :cmd_runner => FakeCmdRunner)
+    end
+    teardown do
+      FakeCmdRunner.reset
+    end
+    subject { @runner }
+
+
+    should have_reader :script, :cmd_runner
+
+    should "run the script" do
+      assert_empty FakeCmdRunner.cmds
+      subject.run
+
+      assert_not_empty FakeCmdRunner.cmds
+      assert_equal 7, FakeCmdRunner.cmds.size
+      assert_equal "a restore cmd", FakeCmdRunner.cmds[-3]
+    end
+
+    should "call the callbacks" do
+      assert_not @script.all_callbacks_called?
+      subject.run
+
+      assert @script.all_callbacks_called?
+    end
+
+  end
+
+end

data/test/script_tests.rb

@@ -0,0 +1,130 @@
+require 'assert'
+
+module Dumpdb
+
+  class ScriptTests < Assert::Context
+    desc "the main script mixin"
+    setup do
+      @script = LocalScript.new
+    end
+    subject { @script }
+
+    should have_cmeths :settings
+    should have_imeths :settings, :db, :dump_cmd, :restore_cmd, :ssh?, :ssh_opts, :run
+
+    should have_cmeths :ssh, :databases, :dump_file, :source, :target
+    should have_imeths :ssh, :databases, :dump_file, :source, :target
+
+    should have_cmeths :dump, :restore
+    should have_imeths :dump_cmds, :restore_cmds, :copy_dump_cmd
+
+    should have_imeths :before_run, :before_setup, :before_teardown
+    should have_imeths :after_run,  :after_setup,  :after_teardown
+    should have_imeths :before_dump, :before_copy_dump, :before_restore
+    should have_imeths :after_dump,  :after_copy_dump,  :after_restore
+
+    should "store its settings using ns-options" do
+      assert_kind_of NsOptions::Namespace, subject.class.settings
+      assert_same subject.class.settings, subject.settings
+    end
+
+    should "store off the settings for the script" do
+      assert_kind_of Settings::Ssh,          subject.settings.ssh
+      assert_kind_of Settings::Databases,    subject.settings.databases
+      assert_kind_of Settings::DumpFile,     subject.settings.dump_file
+      assert_kind_of Settings::SourceTarget, subject.settings.source
+      assert_kind_of Settings::SourceTarget, subject.settings.target
+      assert_kind_of Settings::CmdList,      subject.settings.dump_cmds
+      assert_kind_of Settings::CmdList,      subject.settings.restore_cmds
+    end
+
+  end
+
+  class DbMethTests < ScriptTests
+    desc "`db' method"
+    setup do
+      @script = LocalScript.new
+    end
+
+    should "build a Db based on the named database values" do
+      assert_kind_of Db, subject.target
+      assert_equal 'testhost', subject.target.host
+    end
+
+    should "build a Db based on the named database values plus additional values" do
+      assert_kind_of Db, subject.source
+      assert_equal 'devhost', subject.source.host
+      assert_equal 'value', subject.source.another
+    end
+
+    should "complain if looking up a db not in the `databases` collection" do
+      assert_raises BadDatabaseName do
+        subject.db('does_not_exist')
+      end
+    end
+
+  end
+
+  class CmdMethsTests < ScriptTests
+
+    should "build dump command strings" do
+      assert_equal 'echo local', subject.dump_cmd { "echo #{type}" }
+    end
+
+    should "build restore command strings" do
+      assert_equal 'echo local', subject.restore_cmd { "echo #{type}" }
+    end
+
+  end
+
+  class SshTests < ScriptTests
+
+    should "know if its in ssh mode or not" do
+      assert     RemoteScript.new.ssh?
+      assert_not LocalScript.new.ssh?
+    end
+
+    should "know what ssh options to use" do
+      exp_opts = "-o UserKnownHostsFile=/dev/null"\
+                 " -o StrictHostKeyChecking=no"\
+                 " -o ConnectTimeout=10"\
+
+      assert_equal exp_opts, subject.ssh_opts
+    end
+
+  end
+
+  class RunTests < ScriptTests
+    setup do
+      FakeCmdRunner.reset
+      @script = RunnerScript.new
+    end
+    teardown do
+      FakeCmdRunner.reset
+    end
+
+    should "run the script when `run` is called" do
+      assert_empty FakeCmdRunner.cmds
+      @script.run(FakeCmdRunner)
+
+      assert_not_empty FakeCmdRunner.cmds
+      assert_equal 7, FakeCmdRunner.cmds.size
+      assert_equal "a restore cmd", FakeCmdRunner.cmds[-3]
+    end
+
+  end
+
+  class InheritedTests < ScriptTests
+    desc "when inherited"
+    setup do
+      @a_remote_script     = RemoteScript.new
+      @a_sub_remote_script = Class.new(RemoteScript).new
+    end
+
+    should "pass its definition values to any subclass" do
+      assert_equal @a_remote_script.ssh, @a_sub_remote_script.ssh
+    end
+
+  end
+
+end

data/test/settings_tests.rb

@@ -0,0 +1,200 @@
+require 'assert'
+
+require 'dumpdb/settings'
+
+module Dumpdb
+
+  class SettingsTests < Assert::Context
+    desc "the script settings"
+    setup do
+      @setting = Settings::Base.new
+      @script = LocalScript.new
+    end
+    subject { @setting }
+
+    should have_imeth :value
+    should have_reader :proc
+
+    should "know its value proc" do
+      assert_kind_of ::Proc, subject.proc
+      assert_nil subject.proc.call
+    end
+
+    should "instance eval its proc in the scope of a script to return a value" do
+      setting = Settings::Base.new(Proc.new { "something: #{type}"})
+
+      assert_equal "local", @script.type
+      assert_equal "something: local", setting.value(@script)
+    end
+
+  end
+
+  class SshSettingTests < SettingsTests
+    desc "`ssh` setting"
+
+    should "be available" do
+      assert Settings::Ssh
+    end
+
+  end
+
+  class DatabasesSettingTests < SettingsTests
+    desc "`databases` setting"
+    setup do
+      @from_hash = {
+        'db1' => {'db' => 'one'},
+        'db2' => {'db' => 'two'},
+      }
+    end
+
+    should "be available" do
+      assert Settings::Databases
+    end
+
+    should "come from a hash" do
+      databases = Settings::Databases.new(@from_hash)
+      assert_equal @from_hash, databases.value(@script)
+    end
+
+    should "come from a yaml file" do
+      databases = Settings::Databases.new('test/support/test.yaml')
+      assert_equal({
+        'db-one' => {'db' => 1},
+        'db-two' => {'db' => 2},
+      }, databases.value(@script))
+    end
+
+  end
+
+  class DumpFileSettingTests < SettingsTests
+    desc "`dump_file` setting"
+
+    should "be available" do
+      assert Settings::DumpFile
+    end
+
+  end
+
+  class SourceTargetSettingTests < SettingsTests
+    desc "`source` or `target` setting"
+    setup do
+      @from_hash = {'host' => 'from_hash'}
+    end
+
+    should "be available" do
+      assert Settings::SourceTarget
+    end
+
+    should "come from a hash" do
+      db = Settings::SourceTarget.new(@from_hash).value(@script)
+
+      assert_kind_of Db, db
+      assert_equal 'from_hash', db.host
+    end
+
+    should "come from a Db obj" do
+      db = Settings::Databases.new(Db.new('dump.file', {'host' => 'from_db'})).value(@script)
+
+      assert_kind_of Db, db
+      assert_equal 'from_db', db.host
+    end
+
+  end
+
+  class CmdTests < SettingsTests
+    desc "command helper class"
+    setup do
+      @cmd_str = Proc.new { "this is the #{type} db: :db" }
+    end
+
+    should "be available" do
+      assert Settings::Cmd
+    end
+
+    should "eval and apply any placeholders to the cmd string" do
+      cmd_val = Settings::Cmd.new(@cmd_str).value(@script, @script.source.to_hash)
+      assert_equal "this is the local db: devdb", cmd_val
+    end
+
+  end
+
+  class DumpCmdTests < CmdTests
+    desc "for dump commands"
+
+    should "eval and apply any source placeholders to the cmd string" do
+      cmd_val = Settings::DumpCmd.new(@cmd_str).value(@script)
+      assert_equal "this is the local db: devdb", cmd_val
+    end
+
+  end
+
+  class RemoteDumpCmdTests < DumpCmdTests
+    desc "using ssh"
+    setup do
+      @script = RemoteScript.new
+      @cmd_str = Proc.new { "echo hello" }
+    end
+
+    should "build the cmds to run remtoely using ssh" do
+      exp_cmd_str = "ssh -A #{@script.ssh_opts} #{@script.ssh} \"echo hello\""
+      cmd_val = Settings::DumpCmd.new(@cmd_str).value(@script)
+
+      assert_equal exp_cmd_str, cmd_val
+    end
+
+  end
+
+  class RestoreCmdTests < CmdTests
+    desc "for restore commands"
+
+    should "eval and apply any target placeholders to the cmd string" do
+      cmd_val = Settings::RestoreCmd.new(@cmd_str).value(@script)
+      assert_equal "this is the local db: testdb", cmd_val
+    end
+
+  end
+
+  class CopyDumpCmdTests < CmdTests
+
+    should "be a copy cmd for non-ssh scripts" do
+      script = @script
+      exp_cmd = "cp #{script.source.dump_file} #{script.target.dump_file}"
+
+      assert_equal exp_cmd, script.copy_dump_cmd
+    end
+
+    should "be an sftp cmd for ssh scripts" do
+      script = RemoteScript.new
+      exp_cmd = "sftp #{script.ssh_opts} #{script.ssh}:#{script.source.dump_file} #{script.target.dump_file}"
+
+      assert_equal exp_cmd, script.copy_dump_cmd
+    end
+
+  end
+
+  class CmdListTests < SettingsTests
+    desc "command list helper class"
+    setup do
+      @cmds = [
+        Settings::Cmd.new(Proc.new { "this is the #{type} target db: :db" }),
+        Settings::Cmd.new(Proc.new { "this is the #{type} target host: :host" })
+      ]
+      @exp_val_cmds = [
+        "this is the local target db: testdb",
+        "this is the local target host: testhost"
+      ]
+    end
+
+    should "be an Array" do
+      assert_kind_of ::Array, Settings::CmdList.new
+    end
+
+    should "return the commands, eval'd and placeholders applied" do
+      val_cmds = Settings::CmdList.new(@cmds).value(@script, @script.target.to_hash)
+      assert_equal @exp_val_cmds, val_cmds
+    end
+
+  end
+
+
+end

data/test/support/database.yaml

@@ -0,0 +1,12 @@
+---
+test:
+  hostname: testhost
+  username: testuser
+  password: testpw
+  database: testdb
+
+development:
+  hostname: devhost
+  username: devuser
+  password: devpw
+  database: devdb

data/test/support/fake_cmd_runner.rb

@@ -0,0 +1,28 @@
+module Dumpdb
+
+  class FakeCmdRunner
+
+    def self.cmds
+      @@cmds ||= []
+      @@cmds
+    end
+
+    def self.reset
+      @@cmds = []
+    end
+
+    def initialize(cmd)
+      @cmd = cmd
+    end
+
+    def run!
+      run
+    end
+
+    def run
+      FakeCmdRunner.cmds << @cmd
+    end
+
+  end
+
+end

data/test/support/test.yaml

@@ -0,0 +1,6 @@
+---
+"db-one":
+  db: 1
+
+"db-two":
+  db: 2

data/test/support/test_scripts.rb

@@ -0,0 +1,66 @@
+require 'dumpdb'
+
+class LocalScript
+  include Dumpdb
+
+  databases { 'test/support/database.yaml' }
+  dump_file { "dump.#{type}" }
+  source    { db('development', :another => 'value') }
+  target    { db('test') }
+
+  def type; "local"; end
+end
+
+class RemoteScript
+  include Dumpdb
+
+  ssh       { 'user@example.com' }
+  databases { 'test/support/database.yaml' }
+  dump_file { "dump.#{type}" }
+  source    { db('development') }
+  target    { db('test') }
+
+  def type; "remote"; end
+end
+
+class RunnerScript
+  include Dumpdb
+
+  dump_file { 'dump.output' }
+
+  dump    { 'a dump cmd' }
+  restore { 'a restore cmd' }
+
+  def initialize
+    @before_cmd_run = 0
+    @after_cmd_run  = 0
+  end
+
+  def all_callbacks_called?
+    !!(@before_run && @after_run &&
+       @before_setup && @after_setup &&
+       @before_dump && @after_dump &&
+       @before_copy_dump && @after_copy_dump &&
+       @before_restore && @after_restore &&
+       @before_teardown && @after_teardown &&
+       @before_cmd_run == 7 &&
+       @after_cmd_run  == 7
+      )
+  end
+
+  def before_run(*args);       @before_run       = true; end
+  def after_run(*args);        @after_run        = true; end
+  def before_setup(*args);     @before_setup     = true; end
+  def after_setup(*args);      @after_setup      = true; end
+  def before_dump(*args);      @before_dump      = true; end
+  def after_dump(*args);       @after_dump       = true; end
+  def before_copy_dump(*args); @before_copy_dump = true; end
+  def after_copy_dump(*args);  @after_copy_dump  = true; end
+  def before_restore(*args);   @before_restore   = true; end
+  def after_restore(*args);    @after_restore    = true; end
+  def before_teardown(*args);  @before_teardown  = true; end
+  def after_teardown(*args);   @after_teardown   = true; end
+  def before_cmd_run(*args);   @before_cmd_run   += 1;   end
+  def after_cmd_run(*args);    @after_cmd_run    += 1;   end
+
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification 
+name: dumpdb
+version: !ruby/object:Gem::Version 
+  hash: 3130626483
+  prerelease: 6
+  segments: 
+  - 1
+  - 0
+  - 0
+  - rc
+  - 1
+  version: 1.0.0.rc1
+platform: ruby
+authors: 
+- Kelly Redding
+- Collin Redding
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-11-21 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: assert
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  requirement: *id001
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: scmd
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :runtime
+  requirement: *id002
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: ns-options
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 3130626483
+        segments: 
+        - 1
+        - 0
+        - 0
+        - rc
+        - 1
+        version: 1.0.0.rc1
+  type: :runtime
+  requirement: *id003
+  prerelease: false
+description: Dump and restore your databases.
+email: 
+- kelly@kellyredding.com
+- collin.redding@me.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- dumpdb.gemspec
+- lib/dumpdb.rb
+- lib/dumpdb/db.rb
+- lib/dumpdb/runner.rb
+- lib/dumpdb/settings.rb
+- lib/dumpdb/version.rb
+- test/db_tests.rb
+- test/helper.rb
+- test/irb.rb
+- test/runner_tests.rb
+- test/script_tests.rb
+- test/settings_tests.rb
+- test/support/database.yaml
+- test/support/fake_cmd_runner.rb
+- test/support/test.yaml
+- test/support/test_scripts.rb
+homepage: http://github.com/redding/dumpdb
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      hash: 25
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Dump and restore your databases.
+test_files: 
+- test/db_tests.rb
+- test/helper.rb
+- test/irb.rb
+- test/runner_tests.rb
+- test/script_tests.rb
+- test/settings_tests.rb
+- test/support/database.yaml
+- test/support/fake_cmd_runner.rb
+- test/support/test.yaml
+- test/support/test_scripts.rb