gta 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2caadf93e8f7ea5300cf04c062f347d16a5d5168
-  data.tar.gz: 704003821efb215a1e3dea713bed103f37c543ac
+  metadata.gz: 6282ea52c54d66479c7bb48a0429f8e4e4113ef7
+  data.tar.gz: c1e27e7e8a29454847b5081109aeb2a6ae4444e0
 SHA512:
-  metadata.gz: b9e92cfb7dcdfd6df8640f5404c51593cff14824152addffa3117266f843d3d22249974e28daede22d6cad42790b18852ce276a30e3eb3070aade62ecca11e3b
-  data.tar.gz: b9c27b5d6b6dc8303420123fc4428cde6758642928adc562278d5d265991d68a25a263b23e7a731b92920a1682200a35387436ae2e58770c78be2a35304762d0
+  metadata.gz: 817bcf144b42c8e96c56f0ec3709d1fcc8c1f217a1bbb15c3f7bce9428645569fe4817fa2279c0f179b75ac65f6a21619769694c82b3a77c62f817fc788e4765
+  data.tar.gz: 16cfc6bc1416af0080822bf1fef98a585421e59fc58c9684789080dc6e47a4567f19c456a18287f685f8e524e85ddee58b975f61d04f83d6b5f937a6f2ca62c1

data/.gitignore

@@ -15,3 +15,6 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.idea
+.DS_Store
+**/.DS_Store

data/gta.gemspec

@@ -6,7 +6,7 @@ require 'gta/version'
 Gem::Specification.new do |spec|
   spec.name          = "gta"
   spec.version       = GTA::VERSION
-  spec.authors       = ["socialchorus", "Kane Baccigalupi"]
+  spec.authors       = ["socialchorus", "Kane Baccigalupi", "Ian Cooper"]
   spec.email         = ["developers@socialchorus.com"]
   spec.description   = %q{GTA: the Git Transit Authority - A git based deploy tool for moving code from stage to stage.}
   spec.summary       = %q{GTA: the Git Transit Authority - A git based deploy tool for moving code from stage to stage.}

data/lib/gta.rb

@@ -4,3 +4,8 @@ require "gta/version"
 require "gta/sh"
 require "gta/manager"
 require "gta/stage"
+require "gta/heroku_db"
+require "gta/local_db"
+require "gta/db"
+require "gta/hotfix"
+require "gta/tag_finder"

data/lib/gta/db.rb

@@ -0,0 +1,57 @@
+module GTA
+  class DB
+    attr_reader :gta_config_path, :database_config_path, :local_env
+
+    def initialize(gta_config_path=nil, database_config_path=nil, local_env=nil)
+      @gta_config_path = gta_config_path
+      @database_config_path = database_config_path
+      @local_env = local_env || 'development'
+    end
+
+    def manager
+      @manager ||= Manager.new(gta_config_path)
+    end
+
+    def local_db
+      @local_db ||= LocalDB.new(local_env, database_config_path)
+    end
+
+    def fetch(stage_name=nil)
+      stage = stage_or_final(stage_name)
+      db(stage.name).fetch
+    end
+
+    def load(stage_name=nil)
+      stage = stage_or_final(stage_name)
+      heroku_db = db(stage.name)
+      local_db.load(heroku_db.file_name)
+    end
+
+    def pull(stage_name=nil)
+      stage = stage_or_final(stage_name)
+      fetch(stage.name)
+      self.load(stage.name)
+    end
+
+    def restore(destination_name, source_name=nil)
+      source = stage_or_final(source_name)
+      destination = manager.stage!(destination_name)
+
+      raise "cannot restore #{destination.name}" unless destination.restorable?
+
+      source_db = db(source.name)
+      source_db.backup
+
+      destination_db = db(destination.name)
+      destination_db.restore_from(source_db.url)
+    end
+
+    def stage_or_final(stage_name)
+      manager.stage(stage_name) || manager.final_stage
+    end
+
+    def db(stage_name)
+      HerokuDB.new(manager.app_name, stage_name)
+    end
+  end
+end

data/lib/gta/heroku_db.rb

@@ -0,0 +1,38 @@
+module GTA
+  class HerokuDB
+    include GTA::Sh
+
+    attr_reader :env, :app, :database_yml_path
+
+    def initialize(app, env)
+      @env = env
+      @app = app
+    end
+
+    def url
+      # using backticks in order to get the bash response
+      `heroku pgbackups:url --app #{app_signature}`
+    end
+
+    def backup
+      sh("heroku pgbackups:capture --expire --app #{app_signature}")
+    end
+
+    def restore_from(url)
+      sh("heroku pgbackups:restore DATABASE_URL \"#{url}\" --app #{app_signature} --confirm #{app_signature}")
+    end
+
+    def fetch
+      sh("curl -o #{file_name} \"#{url}\"")
+    end
+
+    def file_name
+      "~/Downloads/#{app_signature}.sql"
+    end
+
+    def app_signature
+      "#{app}-#{env}"
+    end
+  end
+end
+

data/lib/gta/hotfix.rb

@@ -0,0 +1,41 @@
+module GTA
+  class Hotfix
+    attr_reader :gta_config_path
+
+    def initialize(gta_config_path = nil)
+      @gta_config_path = gta_config_path
+    end
+
+    def checkout(stage_name=nil)
+      stage = stage_for(stage_name)
+      not_hotfixable!(stage_name) unless stage
+      stage.checkout
+    end
+
+    def manager
+      @manager ||= Manager.new(gta_config_path)
+    end
+
+    def deploy
+      stage_name = branch_name
+      stage = stage_for(stage_name)
+      not_hotfixable!(stage_name) if !stage || !stage_name
+      sh "git push #{stage_name} #{stage_name}:master"
+    end
+
+    def not_hotfixable!(stage_name)
+      raise "stage #{stage_name} not hotfixable"
+    end
+
+    def stage_for(stage_name)
+      manager.hotfixer(stage_name)
+    end
+
+    def branch_name
+      # using `` because we need the bash output
+      branches = `git branch`
+      matches = branches.match(/\*\s+(.*)/)
+      matches[1].strip if matches
+    end
+  end
+end

data/lib/gta/local_db.rb

@@ -0,0 +1,40 @@
+module GTA
+  class LocalDB
+    include Sh
+
+    attr_reader :database_config_path, :env
+
+    def initialize(env, database_config_path=nil)
+      @env = env
+      @database_config_path = database_config_path || self.class.default_database_config_path
+    end
+
+    def load(backup_path)
+      sh "pg_restore --verbose --clean --no-acl --no-owner -h localhost#{username}#{database} #{backup_path}"
+    end
+
+    def config
+      @config ||= YAML.load(File.read(database_config_path))[env]
+    end
+
+    def username
+      config['username'] ? " -U #{config['username']}" : ''
+    end
+
+    def database
+      config['database'] ? " -d #{config['database']}" : ''
+    end
+
+    def self.default_database_config_path
+      "#{Dir.pwd}/config/database.yml"
+    end
+
+    def self.env_config
+      ENV['GTA_DATABASE_CONFIG_PATH']
+    end
+
+    def self.local_database_env
+      ENV['RAILS_ENV'] || ENV['GTA_LOCAL_ENV']
+    end
+  end
+end

data/lib/gta/manager.rb

@@ -16,6 +16,10 @@ module GTA
       end
     end
 
+    def app_name
+      @app_name || config && @app_name
+    end
+
     def checkout(name)
       stage!(name).checkout
     end
@@ -31,7 +35,10 @@ module GTA
     end
 
     def config
-      @config ||= YAML.load(File.read(config_path))
+      return @config if @config
+      parsed = YAML.load(File.read(config_path))
+      @app_name = parsed.keys.first
+      @config = parsed.values.first
     end
 
     def stages
@@ -42,6 +49,16 @@ module GTA
       stages.detect{|s| s.name == name.to_s}
     end
 
+    def final_stage
+      stages.detect{|s| s.final? } || stages.last
+    end
+
+    def hotfixer(stage_name=nil)
+      hotfixers = stages.select{|s| s.hotfixable?}
+      default = stage_name == nil ? hotfixers.first : nil
+      hotfixers.detect{|s| s.name == stage_name} || default
+    end
+
     def stage!(name)
       stage(name) || (raise ArgumentError.new("Stage #{name} not found"))
     end

data/lib/gta/railtie.rb

@@ -0,0 +1,7 @@
+module GTA
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      require File.dirname(__FILE__) + "/tasks.rb"
+    end
+  end
+end

data/lib/gta/stage.rb

@@ -2,7 +2,8 @@ module GTA
   class Stage
     include Sh
 
-    attr_reader :name, :repository, :source_name, :branch, :tag, :manager
+    attr_reader :name, :repository, :source_name, :branch, :tag, :manager,
+      :final, :hotfixable, :restorable
 
     def initialize(name, manager, opts)
       @name = name
@@ -11,6 +12,9 @@ module GTA
       @source_name =  opts['source']
       @branch =       opts['branch'] || 'master'
       @tag =          opts['tag']
+      @final =        opts['final']
+      @hotfixable =   opts['hotfixable']
+      @restorable =   opts['restorable']
     end
 
     def stages
@@ -45,11 +49,24 @@ module GTA
     end
 
     def ==(other)
-      name == other.name &&
+       other.is_a?(self.class) &&
+        name == other.name &&
         branch == other.branch &&
         tag == other.tag
     end
 
+    def final?
+      !!final
+    end
+
+    def restorable?
+      !!restorable
+    end
+
+    def hotfixable?
+      !!hotfixable
+    end
+
     # -----------
 
     def source_from(s)
@@ -57,7 +74,7 @@ module GTA
     end
 
     def source_ref
-      tag || "#{name}/#{branch}"
+      TagFinder.new(tag).newest || "#{name}"
     end
 
     def push_command(source_ref, forced=nil)

data/lib/gta/tag_finder.rb

@@ -0,0 +1,22 @@
+module GTA
+  class TagFinder
+    attr_reader :tag
+
+    def initialize(tag)
+      @tag = tag
+    end
+
+    def newest
+      return unless tag
+      tags.last
+    end
+
+    def tag_list
+      `git tag -l #{tag}`
+    end
+
+    def tags
+      tag_list.split(/\s/)
+    end
+  end
+end

data/lib/gta/tasks.rb

@@ -1,2 +1,6 @@
+require 'gta'
+
 load "#{File.dirname(__FILE__)}/tasks/deploy.rake"
 load "#{File.dirname(__FILE__)}/tasks/gta.rake"
+load "#{File.dirname(__FILE__)}/tasks/heroku_db.rake"
+load "#{File.dirname(__FILE__)}/tasks/hotfix.rake"

data/lib/gta/tasks/deploy.rake

@@ -1,44 +1,47 @@
-require 'gta'
-
-namespace :deploy do
-  desc 'task that will be run before a deploy'
-  task :before
-
-  desc 'task that will be run after a deploy'
-  task :after
-
-  # the meat of a deploy, a git push from source to destination
-  task :gta_push, :stage_name do |t, args|
-    raise GTA::Manager.stage_name_error unless stage_name = args[:stage_name]
-    manager = GTA::Manager.new(GTA::Manager.env_config)
-    manager.push_to(stage_name)
-  end
-
-  # a forced version of the meat of the matter
-  task :gta_force_push, :stage_name do |t, args|
-    raise GTA::Manager.stage_name_error unless stage_name = args[:stage_name]
-    manager = GTA::Manager.new(GTA::Manager.env_config)
-    manager.push_to(stage_name, :force)
+namespace :gta do
+  namespace :deploy do
+    desc 'task that will be run before a deploy'
+    task :before, :stage_name
+
+    desc 'task that will be run after a deploy'
+    task :after, :stage_name
+
+    def gta_manager(args={})
+      return @manager if @manager
+      raise GTA::Manager.stage_name_error unless stage_name = args[:stage_name]
+      @manager = GTA::Manager.new(GTA::Manager.env_config)
+    end
+
+    # the meat of a deploy, a git push from source to destination
+    task :gta_push, :stage_name do |t, args|
+      stage_name = args[:stage_name]
+      gta_manager(args).push_to(stage_name)
+    end
+
+    # a forced version of the meat of the matter
+    task :gta_force_push, :stage_name do |t, args|
+      stage_name = args[:stage_name]
+      gta_manager(args).push_to(stage_name, :force)
+    end
+
+    task :deploy, :stage_name do |t, args|
+      stage_name = args[:stage_name]
+      Rake::Task["gta:deploy:before"].invoke(stage_name)
+      Rake::Task["gta:deploy:gta_push"].invoke(stage_name)
+      Rake::Task["gta:deploy:after"].invoke(stage_name)
+    end
+
+    desc 'force push deploy, running before and after tasks'
+    task :force, :stage_name do |t, args|
+      stage_name = args[:stage_name]
+      Rake::Task["gta:deploy:before"].invoke(stage_name)
+      Rake::Task["gta:deploy:gta_force_push"].invoke(stage_name)
+      Rake::Task["gta:deploy:after"].invoke(stage_name)
+    end
   end
 
-  task :wrap, :stage_name do |t, args|
-    stage_name = args[:stage_name]
-    Rake::Task["deploy:before"].invoke(stage_name)
-    Rake::Task["deploy:gta_push"].invoke(stage_name)
-    Rake::Task["deploy:before"].invoke(stage_name)
-  end
-
-  desc 'force push deploy, running before and after tasks'
-  task :force, :stage_name do |t, args|
-    stage_name = args[:stage_name]
-    Rake::Task["deploy:before"].invoke(stage_name)
-    Rake::Task["deploy:gta_force_push"].invoke(stage_name)
-    Rake::Task["deploy:before"].invoke(stage_name)
+  desc "push deploy, running before and after tasks"
+  task :deploy, :stage_name do |t, args|
+    Rake::Task["gta:deploy:deploy"].invoke(args[:stage_name])
   end
 end
-
-desc "push deploy, running before and after tasks"
-task :deploy, :stage_name do |t, args|
-  Rake::Task["deploy:wrap"].invoke(args[:stage_name])
-end
-

data/lib/gta/tasks/gta.rake

@@ -1,5 +1,3 @@
-require 'gta'
-
 namespace :gta do
   desc 'add remote repositories for each of the configured environments'
   task :setup do

data/lib/gta/tasks/heroku_db.rake

@@ -0,0 +1,24 @@
+namespace :gta do
+  namespace :heroku do
+    namespace :db do
+      def gta_db
+        @gta_db ||= GTA::DB.new(GTA::Manager.env_config, GTA::LocalDB.env_config, GTA::LocalDB.local_database_env)
+      end
+
+      desc 'download the database from the specified stage or from the last stage'
+      task :fetch, :stage_name do |t, args|
+        gta_db.fetch(args[:stage_name])
+      end
+
+      desc 'load local database with downloaded backup from stage'
+      task :load, :stage_name do |t, args|
+        gta_db.load(args[:stage_name])
+      end
+
+      desc 'restore remote database from another stage'
+      task :restore, :stage_name do |t, args|
+        gta_db.restore(args[:stage_name], ENV['source'])
+      end
+    end
+  end
+end

data/lib/gta/tasks/hotfix.rake

@@ -0,0 +1,15 @@
+namespace :gta do
+  namespace :hotfix do
+    desc "Checkout a stage for hotfix change and future deploy"
+    task :checkout, :stage_name do |t, args|
+      hotfix = GTA::Hotfix.new(GTA::Manager.env_config)
+      hotfix.checkout(args[:stage_name])
+    end
+
+    desc "deploy checked out branch to that remote"
+    task :deploy do
+      hotfix = GTA::Hotfix.new(GTA::Manager.env_config)
+      hotfix.deploy
+    end
+  end
+end

data/lib/gta/version.rb

@@ -1,3 +1,3 @@
 module GTA
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/spec/db_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe GTA::DB do
+  let(:config_path) { File.dirname(__FILE__) + "/fixtures/config" }
+  let(:gta_config_path) { "#{config_path}/gta.yml" }
+  let(:database_config_path) { "#{config_path}/database.yml" }
+  let(:db) { GTA::DB.new(gta_config_path, database_config_path) }
+  let(:heroku_db) { double(fetch: true) }
+
+  before do
+    GTA::HerokuDB.stub(:new).and_return(heroku_db)
+  end
+
+  it "has a manager" do
+    db.manager.should be_a(GTA::Manager)
+  end
+
+  describe "#fetch" do
+    context "when a stage is provided" do
+      it "will construct a heroku db object with the right stage information" do
+        GTA::HerokuDB.should_receive(:new)
+          .with('activator', 'staging')
+          .and_return(heroku_db)
+        db.fetch('staging')
+      end
+
+      it "will call #fetch on the heroku db object" do
+        heroku_db.should_receive(:fetch)
+        db.fetch('staging')
+      end
+    end
+
+    context "when a stage is not provided" do
+      it "will use the default stage" do
+        GTA::HerokuDB.should_receive(:new)
+          .with('activator', 'qa')
+          .and_return(heroku_db)
+        db.fetch
+      end
+    end
+  end
+
+  describe '#load' do
+    let(:local_db) { double('local_db') }
+
+    before do
+      db.stub(:local_db).and_return(local_db)
+    end
+
+    context "when no source is given" do
+      it "loads the last stage's download into the local database" do
+        GTA::HerokuDB.should_receive(:new)
+          .with('activator', 'qa')
+          .and_return(heroku_db)
+        heroku_db.stub(:file_name).and_return("~/Downloads/activator-qa.sql")
+        local_db.should_receive(:load).with("~/Downloads/activator-qa.sql")
+        db.load
+      end
+    end
+
+    context "when a source is passed" do
+      it "loads the source download into the local database" do
+        GTA::HerokuDB.should_receive(:new)
+          .with('activator', 'production')
+          .and_return(heroku_db)
+        heroku_db.stub(:file_name).and_return("~/Downloads/activator-production.sql")
+        local_db.should_receive(:load).with("~/Downloads/activator-production.sql")
+        db.load('production')
+      end
+    end
+  end
+
+  describe '#pull' do
+    it "calls #fetch with the source (default or other)" do
+      db.should_receive(:fetch).with('qa')
+      db.should_receive(:load).with('qa')
+      db.pull
+    end
+
+    it "calls #load with the source (default or other)" do
+      db.should_receive(:fetch).with('production')
+      db.should_receive(:load).with('production')
+      db.pull('production')
+    end
+  end
+
+  describe '#restore' do
+    let(:manager) { db.manager }
+    let(:source_heroku_db) { double('source db', backup: true, url: 'source-url') }
+    let(:destination_heroku_db) { double('distination db', restore_from: true) }
+
+    context 'when the destination stage is not restorable' do
+      it "raises an error" do
+        expect {
+          db.restore('production')
+        }.to raise_error
+      end
+    end
+
+    context "when the stage is restorable, and no source stage information is given" do
+      before do
+        GTA::HerokuDB.stub(:new) do |app_name, stage_name|
+          if stage_name == 'qa'
+            source_heroku_db
+          elsif stage_name == 'staging'
+            destination_heroku_db
+          end
+        end
+      end
+
+      it "makes a backup of the final stage" do
+        source_heroku_db.should_receive(:backup)
+        db.restore('staging')
+      end
+
+      it "gets the url for the final stage's database" do
+        source_heroku_db.should_receive(:url).and_return('source-url')
+        db.restore('staging')
+      end
+
+      it "calls restore on the destination stage with the database url" do
+        destination_heroku_db.should_receive(:restore_from).with('source-url')
+        db.restore('staging')
+      end
+    end
+
+    context "when a second 'source' stage is specified" do
+      before do
+        GTA::HerokuDB.stub(:new) do |app_name, stage_name|
+          if stage_name == 'production'
+            source_heroku_db
+          elsif stage_name == 'qa'
+            destination_heroku_db
+          end
+        end
+      end
+
+      it "makes a backup of the source stage" do
+        source_heroku_db.should_receive(:backup)
+        db.restore('qa', 'production')
+      end
+
+      it "gets the url for the source's database" do
+        source_heroku_db.should_receive(:url).and_return('source-url')
+        db.restore('qa', 'production')
+      end
+
+      it "calls restore on the destination stage with the database url" do
+        destination_heroku_db.should_receive(:restore_from).with('source-url')
+        db.restore('qa', 'production')
+      end
+    end
+  end
+end

data/spec/fixtures/config/database.yml

@@ -0,0 +1,3 @@
+development:
+  database: activator_dev
+  username: socialchorus

data/spec/fixtures/config/gta.yml

@@ -1,19 +1,25 @@
-origin:
-  repository: git@github.com:socialchorus/activator.git
+activator:
+  origin:
+    repository: git@github.com:socialchorus/activator.git
 
-ci:
-  source: origin
-  repository: git@github.com:socialchorus/activator.git
+  ci:
+    source: origin
+    tag: ci/*
+    repository: git@github.com:socialchorus/activator.git
 
-staging:
-  source: ci
-  tag: staging/*
-  repository: git@heroku.com:activator-staging.git
+  staging:
+    source: ci
+    repository: git@heroku.com:activator-staging.git
+    restorable: true
+    hotfixable: true
 
-qa:
-  source: staging
-  repository: git@heroku.com:activator-qa.git
+  qa:
+    source: staging
+    repository: git@heroku.com:activator-qa.git
+    restorable: true
+    final: true
+    hotfixable: true
 
-production:
-  source: qa
-  repository: git@heroku.com:activator-production.git
+  production:
+    source: qa
+    repository: git@heroku.com:activator-production.git

data/spec/heroku_db_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe GTA::HerokuDB do
+  let(:database_yml_path) { File.dirname(__FILE__) + "/fixtures/config/database.yml" }
+  let(:heroku_db) { GTA::HerokuDB.new('activator', 'staging') }
+
+  describe '#url' do
+    it "gets the temporary database url from heroku" do
+      heroku_db.should_receive(:`)
+        .with("heroku pgbackups:url --app activator-staging")
+        .and_return('backup url')
+      heroku_db.url.should == 'backup url'
+    end
+  end
+
+  describe '#backup' do
+    it "sends a heroku command to backup the databse, with the expire flag" do
+      heroku_db.should_receive(:sh)
+        .with("heroku pgbackups:capture --expire --app activator-staging")
+      heroku_db.backup
+    end
+  end
+
+  describe '#restore_from(url)' do
+    it "sends a heroku command to restore the database from the given url" do
+      heroku_db.should_receive(:sh)
+        .with('heroku pgbackups:restore DATABASE_URL "http://my-database-url.com" --app activator-staging --confirm activator-staging')
+      heroku_db.restore_from("http://my-database-url.com")
+    end
+  end
+
+  describe '#fetch' do
+    it "downloads the latest database backup to an appropriately named file in downloads" do
+      heroku_db.should_receive(:url).and_return('http://heroku-backup-url.com')
+      heroku_db.should_receive(:sh)
+        .with('curl -o ~/Downloads/activator-staging.sql "http://heroku-backup-url.com"')
+      heroku_db.fetch
+    end
+  end
+end

data/spec/hotfix_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe GTA::Hotfix do
+  let(:gta_config_path) { File.dirname(__FILE__) + "/fixtures/config/gta.yml" }
+  let(:hotfix) { GTA::Hotfix.new(gta_config_path) }
+  let(:manager) { hotfix.manager }
+  let(:stage) { double(checkout: true) }
+
+  describe '#checkout' do
+    context "no stage provided" do
+      it "gets the first hotfixable stage" do
+        manager.should_receive(:hotfixer)
+          .and_return(stage)
+        hotfix.checkout
+      end
+
+      it "finds and checks out the first hotfixable stage" do
+        manager.should_receive(:hotfixer).with(nil).and_return(stage)
+        stage.should_receive(:checkout)
+        hotfix.checkout
+      end
+    end
+
+    context "stage is not hotfixable" do
+      it "raises an error" do
+        expect {
+          hotfix.checkout('production')
+        }.to raise_error
+      end
+    end
+
+    context "stage is hotfixable" do
+      it "checks out that stage" do
+        manager.should_receive(:hotfixer)
+          .with('staging')
+          .and_return(stage)
+        stage.should_receive(:checkout)
+        hotfix.checkout('staging')
+      end
+    end
+  end
+
+  describe '#deploy' do
+    context "when on a branch that maps to a stage" do
+      before do
+        hotfix.stub(:`).and_return(branch_output)
+        hotfix.stub(:sh)
+      end
+
+      context "if it is hotfixable" do
+        let(:branch_output) {
+          "  bunny\n  ftc_language\n* qa\n  production"
+        }
+
+        it "should call #sh with the right deploy command" do
+          hotfix.should_receive(:sh)
+            .with("git push qa qa:master")
+            .and_return("deploying")
+          hotfix.deploy.should == "deploying"
+        end
+      end
+
+      context "if it is not hotfixable" do
+        let(:branch_output) {
+          "  bunny\n  ftc_language\n* master\n  production"
+        }
+
+        it "raises an error" do
+          expect {
+            hotfix.deploy
+          }.to raise_error
+        end
+      end
+    end
+  end
+end

data/spec/local_db_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe GTA::LocalDB do
+  let(:env) { 'development' }
+  let(:database_config_path) { File.dirname(__FILE__) + "/fixtures/config/database.yml" }
+  let(:local_db) { GTA::LocalDB.new(env, database_config_path) }
+
+  describe '#load' do
+    it "does a postgres load of the right database based on the config" do
+      local_db.should_receive(:sh).with(
+        "pg_restore --verbose --clean --no-acl --no-owner -h localhost -U socialchorus -d activator_dev ~/Downloads/activator-staging.sql"
+      )
+      local_db.load("~/Downloads/activator-staging.sql")
+    end
+  end
+end

data/spec/manager_spec.rb

@@ -9,6 +9,10 @@ describe GTA::Manager do
     manager.stages.map(&:class).uniq.should == [GTA::Stage]
   end
 
+  it "has an app name" do
+    manager.app_name.should == 'activator'
+  end
+
   describe '#fetch' do
     it "loops through each stage and calls fetch" do
       manager.stages.each do |stage|
@@ -37,6 +41,56 @@ describe GTA::Manager do
     end
   end
 
+  describe '#final_stage' do
+    context "when there are more than one final stages" do
+      before do
+        manager.stages.first.stub(:final?).and_return(true)
+      end
+
+      it "returns the first stage that responds to #final? with true" do
+        manager.final_stage.should == manager.stages.first
+      end
+    end
+
+    context "when there is only one final stage" do
+      it "returns the only one defined" do
+        manager.final_stage.name.should == 'qa'
+      end
+    end
+
+    context "when there are no final stages" do
+      before do
+        manager.stages.each{|s| s.stub(:final?).and_return(false) }
+      end
+
+      it "chooses the last stage in the configuration" do
+        manager.final_stage.name.should == 'production'
+      end
+    end
+  end
+
+  describe '#hotfixer' do
+    context 'when not passed a stage name' do
+      it "returns the first stage that is hotfixable" do
+        manager.hotfixer.name.should == 'staging'
+      end
+    end
+
+    context "when passed a stage name" do
+      context "when the stage name matches a hotfixable stage" do
+        it "returns the stage" do
+          manager.hotfixer('qa').name.should == 'qa'
+        end
+      end
+
+      context "when the stage name matches as non hotfixbale stage" do
+        it "returns nil" do
+          manager.hotfixer('production').should == nil
+        end
+      end
+    end
+  end
+
   describe '#push_to' do
     before do
       manager.stub(:fetch)

data/spec/stage_spec.rb

@@ -98,7 +98,7 @@ describe GTA::Stage do
 
     context "when using internally defined source object" do
       it "sends the right git shell command" do
-        stage.should_receive(:sh).with("git push staging ci/master:master")
+        stage.should_receive(:sh).with("git push staging ci:master")
         stage.push
       end
     end
@@ -107,7 +107,7 @@ describe GTA::Stage do
       let(:origin) { GTA::Stage.new('origin', manager, opts.merge('branch' => 'sendit')) }
 
       it "sends the right git shell command" do
-        stage.should_receive(:sh).with("git push staging origin/sendit:master")
+        stage.should_receive(:sh).with("git push staging origin:master")
         stage.push(origin)
       end
     end
@@ -123,8 +123,10 @@ describe GTA::Stage do
 
     context "when the source has a tag" do
       let(:tag) { 'my-tag' }
+      let(:tag_finder) { double(newest: tag) }
 
       it "uses the tag as the source reference" do
+        GTA::TagFinder.should_receive(:new).with(tag).and_return(tag_finder)
         stage.should_receive(:sh).with("git push staging my-tag:master")
         stage.push
       end
@@ -132,7 +134,7 @@ describe GTA::Stage do
 
     context "force push" do
       it "adds the -f flag to the git command" do
-        stage.should_receive(:sh).with("git push -f staging ci/master:master")
+        stage.should_receive(:sh).with("git push -f staging ci:master")
         stage.force_push
       end
     end

data/spec/tag_finder_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe GTA::TagFinder do
+  let(:finder) { GTA::TagFinder.new(tag)}
+
+  describe '#newest' do
+    context 'it receives a tag' do
+      let(:tag) { 'ci/*' }
+      before do
+        finder.stub(:`).and_return(git_response)
+      end
+
+      context 'we get a list from git' do
+        let(:git_response) {
+          "ci/12310\nci/12313\nci/29374"
+        }
+
+        it 'should return the most recent one' do
+          finder.newest.should == "ci/29374"
+        end
+      end
+
+      context 'we get a single line from git' do
+        let(:git_response) {
+          "ci/29374"
+        }
+
+        it 'should return it' do
+          finder.newest.should == "ci/29374"
+        end
+      end
+
+      context 'we get an empty string from git' do
+        let(:git_response) { "" }
+
+        it 'should be nil' do
+          finder.newest.should == nil
+        end
+      end
+    end
+
+    context 'it receives nothing' do
+      let(:tag) { nil }
+
+      it "returns nothing" do
+        finder.newest.should == nil
+      end
+    end
+  end
+end

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: gta
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - socialchorus
 - Kane Baccigalupi
+- Ian Cooper
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-29 00:00:00.000000000 Z
+date: 2013-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ansi
@@ -83,18 +84,31 @@ files:
 - Rakefile
 - gta.gemspec
 - lib/gta.rb
+- lib/gta/db.rb
+- lib/gta/heroku_db.rb
+- lib/gta/hotfix.rb
+- lib/gta/local_db.rb
 - lib/gta/manager.rb
-- lib/gta/remote_db.rb
+- lib/gta/railtie.rb
 - lib/gta/sh.rb
 - lib/gta/stage.rb
+- lib/gta/tag_finder.rb
 - lib/gta/tasks.rb
 - lib/gta/tasks/deploy.rake
 - lib/gta/tasks/gta.rake
+- lib/gta/tasks/heroku_db.rake
+- lib/gta/tasks/hotfix.rake
 - lib/gta/version.rb
+- spec/db_spec.rb
+- spec/fixtures/config/database.yml
 - spec/fixtures/config/gta.yml
+- spec/heroku_db_spec.rb
+- spec/hotfix_spec.rb
+- spec/local_db_spec.rb
 - spec/manager_spec.rb
 - spec/spec_helper.rb
 - spec/stage_spec.rb
+- spec/tag_finder_spec.rb
 homepage: http://github.com/socialchorus/gta
 licenses:
 - MIT
@@ -121,7 +135,13 @@ specification_version: 4
 summary: 'GTA: the Git Transit Authority - A git based deploy tool for moving code
   from stage to stage.'
 test_files:
+- spec/db_spec.rb
+- spec/fixtures/config/database.yml
 - spec/fixtures/config/gta.yml
+- spec/heroku_db_spec.rb
+- spec/hotfix_spec.rb
+- spec/local_db_spec.rb
 - spec/manager_spec.rb
 - spec/spec_helper.rb
 - spec/stage_spec.rb
+- spec/tag_finder_spec.rb

data/lib/gta/remote_db.rb

@@ -1,22 +0,0 @@
-module Remote
-  class DB
-    attr_reader :env, :app
-
-    def initialize(env, app)
-      raise "Environment not allowed" unless ['qa', 'staging'].include?(env)
-      @env = env
-      @app = app
-    end
-
-    def reset
-      puts "==> RESETTING the #{app}-#{env} db..."
-      `heroku pg:reset DATABASE --app #{app}-#{env} --confirm #{app}-#{env}`
-    end
-
-    def restore
-      puts "==> RESTORING #{app}-#{env} from latest backup..."
-      `heroku pgbackups:restore DATABASE_URL "#{DB::Config.db_url(app)}" --app #{app}-#{env} --confirm #{app}-#{env}`
-    end
-  end
-end
-