dk-dumpdb 0.0.1 → 0.1.0

data/test/unit/db_tests.rb

@@ -0,0 +1,103 @@
+require 'assert'
+require 'dk-dumpdb/db'
+
+class Dk::Dumpdb::Db
+
+  class UnitTests < Assert::Context
+    desc "Dk::Dumpdb::Db"
+    setup do
+      @db_class = Dk::Dumpdb::Db
+    end
+    subject{ @db_class }
+
+    should "know its default value" do
+      assert_equal '', DEFAULT_VALUE
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @dump_file_name = Factory.file_name
+      @host           = Factory.string
+      @port           = Factory.integer
+      @user           = Factory.string
+      @pw             = Factory.string
+      @db_name        = Factory.string
+      @output_root    = Factory.dir_path
+      @custom_value   = Factory.string
+
+      @current_time = Factory.time
+      Assert.stub(Time, :now){ @current_time }
+
+      @db = @db_class.new(@dump_file_name, {
+        :host         => @host,
+        :port         => @port,
+        :user         => @user,
+        :pw           => @pw,
+        :db           => @db_name,
+        :output_root  => @output_root,
+        :custom_value => @custom_value
+      })
+    end
+    subject{ @db }
+
+    should have_imeths :host, :port, :user, :pw, :db
+    should have_imeths :output_root, :output_dir, :dump_file
+    should have_imeths :to_hash
+
+    should "know its attributes" do
+      assert_equal @host,        subject.host
+      assert_equal @port,        subject.port
+      assert_equal @user,        subject.user
+      assert_equal @pw,          subject.pw
+      assert_equal @db_name,     subject.db
+      assert_equal @output_root, subject.output_root
+
+      exp = File.join(@output_root, "#{@host}__#{@db_name}__#{@current_time.to_f}")
+      assert_equal exp, subject.output_dir
+
+      exp = File.join(subject.output_dir, @dump_file_name)
+      assert_equal exp, subject.dump_file
+    end
+
+    should "allow custom attributes" do
+      assert_true subject.respond_to?(:custom_value)
+      assert_equal @custom_value, subject.custom_value
+    end
+
+    should "default its attributes" do
+      db = @db_class.new
+
+      assert_equal DEFAULT_VALUE, db.host
+      assert_equal DEFAULT_VALUE, db.port
+      assert_equal DEFAULT_VALUE, db.user
+      assert_equal DEFAULT_VALUE, db.pw
+      assert_equal DEFAULT_VALUE, db.db
+      assert_equal DEFAULT_VALUE, db.output_root
+      assert_equal @current_time.to_f.to_s, db.output_dir
+
+      exp = File.join(db.output_dir, 'dump.output')
+      assert_equal exp, db.dump_file
+    end
+
+    should "know if it is equal to another db" do
+      equal_db = @db_class.new(@dump_file_name, {
+        :host         => @host,
+        :port         => @port,
+        :user         => @user,
+        :pw           => @pw,
+        :db           => @db_name,
+        :output_root  => @output_root,
+        :custom_value => @custom_value
+      })
+      assert_equal subject, equal_db
+
+      not_equal_db = @db_class.new(@dump_file_name, {})
+      assert_not_equal subject, not_equal_db
+    end
+
+  end
+
+end

data/test/unit/dk-dumpdb_tests.rb

@@ -0,0 +1,16 @@
+require 'assert'
+
+module Dk::Dumpdb
+
+  class UnitTests < Assert::Context
+    desc "Dk::Dumpdb"
+    subject{ Dk::Dumpdb }
+
+    should "know its scp args param name" do
+      exp = "dk-dumpdb_scp_args"
+      assert_equal exp, subject::SCP_ARGS_PARAM_NAME
+    end
+
+  end
+
+end

data/test/unit/script_tests.rb

@@ -0,0 +1,165 @@
+require 'assert'
+require 'dk-dumpdb/script'
+
+require 'much-plugin'
+require 'dk-dumpdb/config'
+require 'dk-dumpdb/task'
+
+module Dk::Dumpdb::Script
+
+  class UnitTests < Assert::Context
+    desc "Dk::Dumpdb::Script"
+    subject{ Dk::Dumpdb::Script }
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, subject
+    end
+
+  end
+
+  class MixinTests < UnitTests
+    desc "mixin"
+    setup do
+      @config_proc = Proc.new do
+        ssh{ "user@host" }
+
+        dump_file{ "dump.bz2" }
+
+        source do
+          { :user        => 'admin',
+            :pw          => 'secret',
+            :db          => 'myapp_db',
+            :output_root => '/some/source/dir'
+          }
+        end
+        target do
+          { :host        => 'localhost',
+            :user        => 'admin',
+            :db          => 'myapp_db',
+            :output_root => '/some/target/dir'
+          }
+        end
+
+        dump{ "mysqldump -u :user -p\":pw\" :db | bzip2 > :dump_file" }
+        restore{ "bunzip2 -c :dump_file | mysql -u :user -p\":pw\" :db" }
+      end
+      @script_class = Class.new do
+        include Dk::Dumpdb::Script
+      end
+    end
+    subject{ @script_class }
+
+    should have_imeths :config_blocks, :config, :task_description, :task_desc
+
+    should "know its config blocks" do
+      assert_empty subject.config_blocks
+
+      subject.config(&@config_proc)
+      assert_equal [@config_proc], subject.config_blocks
+    end
+
+    should "define a Task for the script class" do
+      task_class = @script_class::Task
+
+      assert_includes Dk::Dumpdb::Task, task_class
+      assert_equal @script_class, task_class.script_class
+    end
+
+    should "set a description on its Task" do
+      assert_nil subject.task_description
+      assert_nil subject.task_desc
+
+      exp = Factory.string
+      subject.task_description exp
+      assert_equal exp, subject.task_description
+      assert_equal exp, subject.task_desc
+
+      exp = Factory.string
+      subject.task_desc exp
+      assert_equal exp, subject.task_description
+      assert_equal exp, subject.task_desc
+    end
+
+  end
+
+  class InitTests < MixinTests
+    desc "when init"
+    setup do
+      now = Factory.time
+      Assert.stub(Time, :now){ now }
+
+      @script_class.config(&@config_proc)
+      @script = @script_class.new
+    end
+    subject{ @script }
+
+    should have_readers :params
+    should have_imeths :config
+    should have_imeths :ssh, :dump_file, :source, :target, :copy_dump_cmd_args
+    should have_imeths :dump_cmds, :restore_cmds
+    should have_imeths :source_dump_file, :target_dump_file
+    should have_imeths :source_hash, :target_hash
+    should have_imeths :ssh?
+    should have_imeths :dump_cmd, :restore_cmd
+
+    should "know its params" do
+      exp = {}
+      assert_equal exp, subject.params
+
+      params = { Factory.string => Factory.string }
+      script = @script_class.new(params)
+      assert_equal params, script.params
+    end
+
+    should "know its config" do
+      assert_instance_of Dk::Dumpdb::Config, subject.config
+    end
+
+    should "know its config values" do
+      c = subject.config
+      assert_equal c.ssh.value(subject),       subject.ssh
+      assert_equal c.dump_file.value(subject), subject.dump_file
+      assert_equal c.source.value(subject),    subject.source
+      assert_equal c.target.value(subject),    subject.target
+
+      assert_equal c.copy_dump_cmd_args.value(subject), subject.copy_dump_cmd_args
+
+      assert_equal c.dump_cmds.value(subject),    subject.dump_cmds
+      assert_equal c.restore_cmds.value(subject), subject.restore_cmds
+    end
+
+    should "demeter its source/target" do
+      assert_equal subject.source.dump_file, subject.source_dump_file
+      assert_equal subject.target.dump_file, subject.target_dump_file
+      assert_equal subject.source.to_hash,   subject.source_hash
+      assert_equal subject.target.to_hash,   subject.target_hash
+    end
+
+    should "know if it should use ssh or not" do
+      assert_true subject.ssh?
+
+      none = Class.new{ include Dk::Dumpdb::Script }
+      assert_false none.new.ssh?
+
+      empty = Class.new do
+        include Dk::Dumpdb::Script
+        config do
+          ssh{ '' }
+        end
+      end
+      assert_false empty.new.ssh?
+    end
+
+    should "build dump/restore cmd strs" do
+      cmd_str = Factory.string
+
+      exp = subject.config.dump_cmd(subject, &proc{ cmd_str })
+      assert_equal exp, subject.dump_cmd(&proc{ cmd_str })
+
+      exp = subject.config.restore_cmd(subject, &proc{ cmd_str })
+      assert_equal exp, subject.restore_cmd(&proc{ cmd_str })
+    end
+
+  end
+
+end

data/test/unit/task/copy_dump_tests.rb

@@ -0,0 +1,57 @@
+require 'assert'
+require 'dk-dumpdb/task/copy_dump'
+
+require 'test/support/task/internal_task'
+
+class Dk::Dumpdb::Task::CopyDump
+
+  class UnitTests < Assert::Context
+    desc "Dk::Dumpdb::Task::CopyDump"
+    setup do
+      @task_class = Dk::Dumpdb::Task::CopyDump
+    end
+    subject{ @task_class}
+
+    should "be an internal task" do
+      assert_includes Dk::Dumpdb::Task::InternalTask, subject
+    end
+
+    should "know its description" do
+      exp = "(dk-dumpdb) copy the given script's dump file from source to target"
+      assert_equal exp, subject.description
+    end
+
+  end
+
+  class InitTests < UnitTests
+    include Dk::Dumpdb::Task::InternalTask::TestHelpers
+
+    desc "when init"
+    setup do
+      now = Factory.time
+      Assert.stub(Time, :now){ now }
+
+      set_dk_dumpdb_script_param
+      @runner = test_runner(@task_class, :params => @params)
+    end
+
+  end
+
+  class RunTests < InitTests
+    desc "and run"
+    setup do
+      @runner.run
+    end
+    subject{ @runner }
+
+    should "run a cmd to copy the dump" do
+      assert_equal 1, subject.runs.size
+      cp_dump = subject.runs.first
+
+      exp = @params['script'].copy_dump_cmd_args
+      assert_match /#{exp}\Z/, cp_dump.cmd_str
+    end
+
+  end
+
+end

data/test/unit/task/dump_tests.rb

@@ -0,0 +1,58 @@
+require 'assert'
+require 'dk-dumpdb/task/dump'
+
+require 'test/support/task/internal_task'
+
+class Dk::Dumpdb::Task::Dump
+
+  class UnitTests < Assert::Context
+    desc "Dk::Dumpdb::Task::Dump"
+    setup do
+      @task_class = Dk::Dumpdb::Task::Dump
+    end
+    subject{ @task_class}
+
+    should "be an internal task" do
+      assert_includes Dk::Dumpdb::Task::InternalTask, subject
+    end
+
+    should "know its description" do
+      exp = "(dk-dumpdb) run the given script's dump cmds"
+      assert_equal exp, subject.description
+    end
+
+  end
+
+  class InitTests < UnitTests
+    include Dk::Dumpdb::Task::InternalTask::TestHelpers
+
+    desc "when init"
+    setup do
+      now = Factory.time
+      Assert.stub(Time, :now){ now }
+
+      @dump_cmds = dump_cmds = Factory.integer(3).times.map{ Factory.string }
+      set_dk_dumpdb_script_param do
+        dump_cmds.each do |cmd_str|
+          dump{ cmd_str }
+        end
+      end
+      @runner = test_runner(@task_class, :params => @params)
+    end
+
+  end
+
+  class RunTests < InitTests
+    desc "and run"
+    setup do
+      @runner.run
+    end
+    subject{ @runner }
+
+    should "run all dump cmds" do
+      assert_equal @dump_cmds, subject.runs.map(&:cmd_str)
+    end
+
+  end
+
+end

data/test/unit/task/internal_task_tests.rb

@@ -0,0 +1,106 @@
+require 'assert'
+require 'dk-dumpdb/task/internal_task'
+
+require 'dk'
+require 'dk/task'
+require 'much-plugin'
+require 'dk-dumpdb'
+
+module Dk::Dumpdb::Task::InternalTask
+
+  class UnitTests < Assert::Context
+    desc "Dk::Dumpdb::Task::InternalTask"
+    setup do
+      @module = Dk::Dumpdb::Task::InternalTask
+    end
+    subject{ @module }
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, subject
+    end
+
+  end
+
+  class MixinTests < UnitTests
+    desc "mixin"
+    setup do
+      @task_class = Class.new do
+        include Dk::Dumpdb::Task::InternalTask
+        attr_writer :cp_cmd_args
+        def run!
+          source_cmd! "a source cmd"
+          copy_cmd! @cp_cmd_args
+          target_cmd! "a target cmd"
+        end
+      end
+    end
+    subject{ @task_class }
+
+    should "be a Dk task" do
+      assert_includes Dk::Task, subject
+    end
+
+  end
+
+  class InitTests < MixinTests
+    include Dk::Task::TestHelpers
+
+    desc "when init"
+    setup do
+      @cp_args = "#{Factory.file_path} #{Factory.file_path}"
+      @params  = {}
+    end
+
+    should "run source/target/copy cmds as local Dk cmds if not an ssh script" do
+      @params['script'] = Factory.script
+      runner = test_runner(@task_class, :params => @params)
+      task   = runner.task
+
+      task.cp_cmd_args = @cp_args
+      runner.run
+      assert_equal 3, runner.runs.size
+
+      source_cmd, copy_cmd, target_cmd = runner.runs
+      assert_false source_cmd.ssh?
+      assert_false target_cmd.ssh?
+      assert_false copy_cmd.ssh?
+
+      assert_equal "a source cmd", source_cmd.cmd_str
+      assert_equal "a target cmd", target_cmd.cmd_str
+
+      exp = "cp #{@cp_args}"
+      assert_equal exp, copy_cmd.cmd_str
+    end
+
+    should "run source/copy cmds as remote Dk cmds if an ssh script" do
+      @params['script'] = Factory.script{ ssh{ "hostname" } }
+
+      if Factory.boolean
+        @params[Dk::Dumpdb::SCP_ARGS_PARAM_NAME] = Factory.string
+      end
+
+      runner = test_runner(@task_class, :params => @params)
+      task   = runner.task
+
+      task.cp_cmd_args = @cp_args
+      runner.run
+      assert_equal 3, runner.runs.size
+
+      source_ssh, copy_cmd, target_cmd = runner.runs
+      assert_true  source_ssh.ssh?
+      assert_false target_cmd.ssh?
+      assert_false copy_cmd.ssh?
+
+      assert_equal [@params['script'].ssh], source_ssh.cmd_opts[:hosts]
+
+      assert_equal "a source cmd", source_ssh.cmd_str
+      assert_equal "a target cmd", target_cmd.cmd_str
+
+      exp = "scp #{@params[Dk::Dumpdb::SCP_ARGS_PARAM_NAME]} " \
+            "#{@params['script'].ssh}:#{@cp_args}"
+      assert_equal exp, copy_cmd.cmd_str
+    end
+
+  end
+
+end