duple 0.0.1

data/spec/duple/cli/structure_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe Duple::CLI::Structure do
+  include Duple::CLISpecHelpers
+
+  def invoke_structure(options = nil)
+    invoke_cli(:structure, options)
+  end
+
+  context 'from heroku to local' do
+    before {
+      stub_fetch_config
+      stub_dump_structure
+      stub_reset_local
+      stub_restore_structure
+    }
+
+    let(:source) { 'stage' }
+    let(:target) { 'development' }
+
+    it 'fetches the source credentials' do
+      runner.should_receive(:capture).with("heroku config -a duple-stage")
+        .and_return(heroku_config_response)
+
+      invoke_structure
+    end
+
+    it 'dumps the structure from the source' do
+      runner.should_receive(:run)
+        .with(%{PGPASSWORD="pg-pass" pg_dump -Fc --no-acl -O -s -h pg-host -U pg-user -p 6022 pg-db > tmp/duple/stage-structure.dump})
+
+      invoke_structure
+    end
+
+    it 'resets the local database' do
+      runner.should_receive(:run).with(%{bundle exec rake db:drop db:create})
+
+      invoke_structure
+    end
+
+    it 'loads the structure into the local database' do
+      runner.should_receive(:run)
+        .with(%{PGPASSWORD="" pg_restore -v --no-acl -O -s -h localhost -U postgres -p 5432 -d duple_development < tmp/duple/stage-structure.dump})
+
+      invoke_structure
+    end
+  end
+
+  context 'from heroku to heroku' do
+    before {
+      stub_fetch_config
+      stub_dump_structure
+      stub_reset_heroku
+      stub_restore_structure
+    }
+
+    let(:source) { 'production' }
+    let(:target) { 'stage' }
+
+    it 'fetches the source credentials' do
+      runner.should_receive(:capture).with("heroku config -a duple-production")
+        .and_return(heroku_config_response)
+
+      invoke_structure
+    end
+
+    it 'fetches the target credentials' do
+      runner.should_receive(:capture).with("heroku config -a duple-stage")
+        .and_return(heroku_config_response)
+
+      invoke_structure
+    end
+
+    it 'dumps the structure from the source' do
+      runner.should_receive(:run)
+        .with(%{PGPASSWORD="pg-pass" pg_dump -Fc --no-acl -O -s -h pg-host -U pg-user -p 6022 pg-db > tmp/duple/production-structure.dump})
+
+      invoke_structure
+    end
+
+    it 'resets the target database' do
+      runner.should_receive(:run).with(%{heroku pg:reset -a duple-stage})
+
+      invoke_structure
+    end
+
+    it 'loads the structure into the target database' do
+      runner.should_receive(:run)
+        .with(%{PGPASSWORD="pg-pass" pg_restore -v --no-acl -O -s -h pg-host -U pg-user -p 6022 -d pg-db < tmp/duple/production-structure.dump})
+
+      invoke_structure
+    end
+  end
+
+  context 'from local to heroku' do
+    before {
+      stub_fetch_config
+      stub_dump_structure
+      stub_reset_heroku
+      stub_restore_structure
+    }
+
+    let(:source) { 'development' }
+    let(:target) { 'stage' }
+
+    it 'fetches the target credentials' do
+      runner.should_receive(:capture).with("heroku config -a duple-stage")
+        .and_return(heroku_config_response)
+
+      invoke_structure
+    end
+
+    it 'dumps the structure from the local database' do
+      runner.should_receive(:run)
+        .with(%{PGPASSWORD="" pg_dump -Fc --no-acl -O -s -h localhost -U postgres -p 5432 duple_development > tmp/duple/development-structure.dump})
+
+      invoke_structure
+    end
+
+    it 'resets the target database' do
+      runner.should_receive(:run).with(%{heroku pg:reset -a duple-stage})
+
+      invoke_structure
+    end
+
+    it 'loads the structure into the target database' do
+      runner.should_receive(:run)
+        .with(%{PGPASSWORD="pg-pass" pg_restore -v --no-acl -O -s -h pg-host -U pg-user -p 6022 -d pg-db < tmp/duple/development-structure.dump})
+
+      invoke_structure
+    end
+  end
+end

data/spec/duple/configuration_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+describe Duple::Configuration do
+
+  describe '#excluded_tables' do
+    let(:config_hash) { YAML.load(File.read('spec/config/groups.yml'))}
+
+    context 'with neither tables nor group options' do
+      it 'returns an empty array' do
+        config = Duple::Configuration.new(config_hash, {})
+        config.excluded_tables.should == []
+      end
+    end
+
+    context 'with the group option' do
+      it 'returns the tables specified by the group' do
+        config = Duple::Configuration.new(config_hash, {group: 'no_comments'})
+        config.excluded_tables.should == ['comments']
+      end
+
+      context 'with an include_all group' do
+        it 'returns the tables specified by the group' do
+          config = Duple::Configuration.new(config_hash, {group: 'all_but_comments'})
+          config.excluded_tables.should == ['comments']
+        end
+      end
+    end
+
+    context 'with both tables and group options' do
+      it 'does not exclude tables in the tables option' do
+        config = Duple::Configuration.new(config_hash, {
+          group: 'no_comments',
+          tables: ['comments']
+        })
+        config.included_tables.should == ['comments']
+        config.excluded_tables.should == []
+      end
+
+      context 'with an include_all group' do
+        it 'does not exclude tables in the tables option' do
+          config = Duple::Configuration.new(config_hash, {
+            group: 'all_but_comments',
+            tables: ['comments']
+          })
+          config.included_tables.should == []
+          config.excluded_tables.should == []
+        end
+      end
+    end
+  end
+
+  describe '#included_tables' do
+    let(:config_hash) { YAML.load(File.read('spec/config/groups.yml'))}
+
+    context 'with neither tables nor group options' do
+      it 'returns an empty array' do
+        config = Duple::Configuration.new(config_hash, {})
+        config.included_tables.should == []
+      end
+    end
+
+    context 'with the tables option' do
+      it 'returns the tables specified in the option value' do
+        config = Duple::Configuration.new(config_hash, {tables: ['categories']})
+        config.included_tables.should == ['categories']
+      end
+    end
+
+    context 'with the group option' do
+      it 'returns the tables specified by the group' do
+        config = Duple::Configuration.new(config_hash, {group: 'minimal'})
+        config.included_tables.should == ['categories', 'links']
+      end
+
+      context 'with an include_all group' do
+        it 'returns an empty array' do
+          config = Duple::Configuration.new(config_hash, {group: 'all'})
+          config.included_tables.should == []
+        end
+      end
+    end
+
+    context 'with both tables and group options' do
+      it 'returns all tables in the group and the option value' do
+        config = Duple::Configuration.new(config_hash, {
+          group: 'minimal',
+          tables: ['posts', 'comments']
+        })
+        config.included_tables.should == ['categories', 'comments', 'links', 'posts']
+      end
+
+      context 'with an include_all group' do
+        it 'returns an empty array' do
+          config = Duple::Configuration.new(config_hash, {
+            group: 'all',
+            tables: ['posts', 'comments']
+          })
+          config.included_tables.should == []
+        end
+      end
+    end
+  end
+
+  describe '#source_environment' do
+    let(:config_hash) { YAML.load(File.read('spec/config/simple.yml'))}
+
+    it 'gets the default source environment' do
+      config = Duple::Configuration.new(config_hash, {})
+      config.source_environment.should_not be_nil
+      config.source_environment['appname'].should == 'duple-stage'
+    end
+
+    it 'gets the source environment' do
+      config = Duple::Configuration.new(config_hash, { source: 'production' })
+      config.source_environment.should_not be_nil
+      config.source_environment['appname'].should == 'duple-production'
+    end
+
+    it 'does not allow multiple default sources' do
+      config_hash['environments']['backstage'] = {'default_source' => true}
+      config = Duple::Configuration.new(config_hash, {})
+      expect {
+        config.source_environment
+      }.to raise_error(ArgumentError, 'Only a single environment can be default_source.')
+    end
+  end
+
+  describe '#target_environment' do
+    let(:config_hash) { YAML.load(File.read('spec/config/simple.yml'))}
+
+    it 'gets the default target environment' do
+      config = Duple::Configuration.new(config_hash, {})
+      config.target_environment.should_not be_nil
+      config.target_environment['type'].should == 'local'
+    end
+
+    it 'gets the target environment' do
+      config = Duple::Configuration.new(config_hash, { target: 'stage' })
+      config.target_environment.should_not be_nil
+      config.target_environment['appname'].should == 'duple-stage'
+    end
+
+    it 'fails if the target is not allowed' do
+      config = Duple::Configuration.new(config_hash, { target: 'production' })
+      expect {
+        config.target_environment
+      }.to raise_error(ArgumentError, 'Invalid target: production is not allowed to be a target.')
+    end
+
+    it 'does not allow multiple default targets' do
+      config_hash['environments']['backstage'] = {'default_target' => true}
+      config = Duple::Configuration.new(config_hash, {})
+      expect {
+        config.target_environment
+      }.to raise_error(ArgumentError, 'Only a single environment can be default_target.')
+    end
+
+    it 'allows multiple disallowed targets' do
+      config_hash['environments']['reporting'] = {'allow_target' => false}
+      config = Duple::Configuration.new(config_hash, {})
+      expect {
+        config.target_environment
+      }.to_not raise_error(ArgumentError, 'Only a single environment can be allow_target.')
+    end
+  end
+end

data/spec/duple/runner_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'fileutils'
+
+describe Duple::Runner do
+
+  let(:test_dir) { 'tmp' }
+  let(:test_file) { "#{test_dir}/spawnbag.txt" }
+  let(:log) { StringIO.new }
+  after { log.close }
+
+  before { FileUtils.mkdir_p(test_dir) }
+  after { FileUtils.rm(test_file) if File.exists?(test_file) }
+
+  context 'in live mode' do
+    let(:runner) { Duple::Runner.new(log: log) }
+
+    it 'executes a command' do
+      runner.run("touch #{test_file}")
+
+      Pathname.new(test_file).should exist
+    end
+
+    it 'captures the output of the command' do
+      result = runner.capture("cat #{__FILE__}")
+      result.should =~ /captures the output of the command/
+    end
+
+    it 'writes the commands to the log' do
+      runner.run("touch #{test_file}")
+      log.string.should == " * Running: touch tmp/spawnbag.txt\n"
+    end
+
+    it 'raises an error if the command fails' do
+      expect {
+        runner.capture("cat NOT_A_REAL_FILE > /dev/null 2>&1")
+      }.to raise_error(RuntimeError, /Command failed: pid \d+ exit 1/)
+    end
+  end
+
+  context 'in dry run mode' do
+    let(:runner) { Duple::Runner.new(dry_run: true, log: log) }
+
+    it 'does not actually run the commands' do
+      runner.run("touch #{test_file}")
+
+      Pathname.new(test_file).should_not exist
+    end
+
+    it 'writes the commands to the log' do
+      runner.run("touch #{test_file}")
+      log.string.should == " * Running: touch tmp/spawnbag.txt\n"
+    end
+  end
+
+  context 'with a recorder' do
+    let(:recorder) { StringIO.new }
+    let(:runner) { Duple::Runner.new(recorder: recorder, log: log) }
+
+    it 'logs commands to a file' do
+      runner.capture('ls tmp')
+      runner.capture('date')
+      recorder.string.split("\n").should == ['ls tmp', 'date']
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+lib_path = File.expand_path('../../lib', __FILE__)
+$:.unshift(lib_path)
+
+require 'simplecov'
+require 'duple'
+Dir['spec/support/**/*.rb'].each { |f| require File.expand_path(f) }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/support/cli_spec_helpers.rb

@@ -0,0 +1,85 @@
+module Duple
+  module CLISpecHelpers
+    def self.included(base)
+      base.send(:let, :runner) { double_runner }
+      base.send(:let, :source) { 'stage' }
+      base.send(:let, :target) { 'development' }
+      base.send(:let, :snapshot_path) { 'tmp/duple/stage-2012-10-19-03-09-30.dump' }
+    end
+
+    def double_runner
+      runner = fire_double('Duple::Runner')
+      Duple::Runner.stub(:new).and_return(runner)
+      runner
+    end
+
+    def heroku_pgbackups_url_response
+      File.read('spec/config/heroku_pgbackups_url.txt')
+    end
+
+    def heroku_pgbackups_response
+      File.read('spec/config/heroku_pgbackups.txt')
+    end
+
+    def heroku_config_response
+      File.read('spec/config/heroku_config.txt')
+    end
+
+    def stub_fetch_url
+      runner.stub(:capture).with(/heroku pgbackups:url/)
+        .and_return(heroku_pgbackups_url_response)
+    end
+
+    def stub_fetch_config
+      runner.stub(:capture).with(/heroku config/)
+        .and_return(heroku_config_response)
+    end
+
+    def stub_fetch_backups
+      runner.stub(:capture).with(/heroku pgbackups /)
+        .and_return(heroku_pgbackups_response)
+    end
+
+    def stub_download_snapshot
+      runner.stub(:run).with(/curl/)
+    end
+
+    def stub_dump_structure
+      runner.stub(:run).with(/pg_dump .* -s /)
+    end
+
+    def stub_restore_structure
+      runner.stub(:run).with(/pg_restore .* -s /)
+    end
+
+    def stub_dump_data
+      runner.stub(:run).with(/pg_dump .* -a /)
+    end
+
+    def stub_restore_url
+      runner.stub(:run).with(/heroku pgbackups:restore .* -a /)
+    end
+
+    def stub_restore_data
+      runner.stub(:run).with(/pg_restore .* -a /)
+    end
+
+    def stub_reset_heroku
+      runner.stub(:run).with(/heroku pg:reset/)
+    end
+
+    def stub_reset_local
+      runner.stub(:run).with(/bundle exec rake db:drop db:create/)
+    end
+
+    def invoke_cli(command, options = nil)
+      options ||= {}
+      script = Duple::CLI::Root.new
+      script.invoke(command, [], {
+        config: 'spec/config/simple.yml',
+        source: source,
+        target: target
+      }.merge(options))
+    end
+  end
+end