pgbackups-archive 0.3.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0b1dfe7b8843a859e5eff6c7bac691d919a647d0
-  data.tar.gz: 506782bd0780f16a5a2ea1c9729aa74d8065b486
+  metadata.gz: 8c51d872d12dc01426e3a9185e63a118b204ecdd
+  data.tar.gz: 92b49a4dcbb9ef8eae5d2ed1f6a9892bfa01f52b
 SHA512:
-  metadata.gz: 0edd75f6f73cbd37b5fd5be1e6c78a2c517c7c28841cead96a6c4489951cdd806c5d04792ec5bd4f05a97018c2aa685bef884b6617bad32a808d5e0a806f3c13
-  data.tar.gz: a7e4855f4e3f3541457d7cc0356b9972bdd4f710d013caf9aa35e460f46964d5b99eb4e5b24b0fee3fd8232486abd6b20777c52748e7cc1928b7fe79f969fc34
+  metadata.gz: 409279267d694930ee6e35452bdfdbb23cf5955769be967ea9fef96fe133683306bf541623a969e65823245559c84ae448b52466f8493371017228ffc5f817a7
+  data.tar.gz: 021689847fb1cbade0f0c45829d1a351ed2d89dd6e10df572ec7e5fd09dc10ab6418bca37fd092c591fbbe9e3ac5286bd870b1b198406228f9d357967d291584

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2014 Kenny Johnston
+Copyright 2015 Kenny Johnston
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -3,66 +3,64 @@
 [![Gem Version](https://badge.fury.io/rb/pgbackups-archive.svg)](http://badge.fury.io/rb/pgbackups-archive)
 [![Code Climate](https://codeclimate.com/github/kjohnston/pgbackups-archive/badges/gpa.svg)](https://codeclimate.com/github/kjohnston/pgbackups-archive)
 
-A means of automating Heroku's pgbackups and archiving them to Amazon S3.
+A means of automating Heroku PGBackups and archiving them to Amazon S3.
+
+## Upgrade Alert
+
+As of v1.0.0, `pgbackups-archive` works with the new [Heroku PGBackups](https://devcenter.heroku.com/articles/heroku-postgres-backups) service, which replaced the older [PG Backups](https://devcenter.heroku.com/articles/pgbackups) add-on.
+
+If you're still using an older version of `pgbackups-archive`, it's time to upgrade!
+
+Read more about this transition in Heroku's offerings on the Heroku Blog: [PG Backups Levels Up](https://blog.heroku.com/archives/2015/3/11/pgbackups-levels-up)
+
+Please note that the environment variables that need to be defined have changed with
+v1.0.0.
 
 ## Overview
 
-The `pgbackups:archive` rake task this gem provides will capture a pgbackup, wait for it to complete, then store it within the Amazon S3 bucket you specify.  This rake task can be scheduled via the Heroku Scheduler, thus producing automated, offsite, backups.
+The `pgbackups:archive` rake task this gem provides will capture a Heroku PGBackup, wait for it to complete, then store it within the Amazon S3 bucket you specify.  This rake task can be scheduled via the Heroku Scheduler, thus producing automated, offsite, backups.
+
+This gem doesn't interfere with or utilze automated backups, so feel free to schedule those with the `pg:backups schedule` command as you desire.
 
-The rake task will use pgbackups' `--expire` flag to remove the oldest pgbackup Heroku is storing when there are no free slots remaining.
+You can configure how many manual backups (created by you or this gem) you'd like to keep at the Heroku PGBackups level to ensure there is always space to capture a new backup.
 
 You can configure retention settings at the Amazon S3 bucket level from within the AWS Console if you like.
 
 ## Use
 
-### Determine which Heroku app to run the task under
-
-#### Option 1 - Add `pgbackups-archive` to your existing application
-
-Recommended for apps with light memory usage.
+### Install the gem
 
 Add the gem to your Gemfile and bundle:
 
     gem "pgbackups-archive"
     bundle install
 
-#### Option 2 - Add `pgbackups-archive` to a standalone application
-
-Recommended for apps with heavier memory usage.
-
-* Create a new repo with `pgackups-archive` added to that app's Gemfile and push
-it to a new Heroku app.
-* Ensure the `PGBACKUPS_DATABASE_URL` environment variable you set for your
-backup app points to your main app's `DATABASE_URL`, or other follower URL, so
-that `pgbackups-archive` in your backup app knows to backup your real app's
-database.
+### Install Heroku Scheduler add-on
 
-This option exists because the streaming download & upload of the backup file
-will utilize a certain amount of memory beyond what an instance of your
-application uses and if you're close to the threshold of your Dyno size as it
-is, this increment could put the instance over the limit and cause it to
-encounter [memory allocation errors](https://devcenter.heroku.com/articles/error-codes#r14-memory-quota-exceeded).
-By running a dedicated Heroku app to run
-`pgbackups-archive` the task will have ample room at the 1X Dyno level to stream
-the backup files.
+    heroku addons:add scheduler:standard
 
-### Install Heroku addons
+### Setup an AWS IAM user, S3 bucket and policy
 
-    heroku addons:add pgbackups
-    heroku addons:add scheduler:standard
+A good security measure would be to use a dedicated set of AWS credentials with a security policy only allowing access to the bucket you're specifying.  See this Pro Tip on [Assigning an AWS IAM user access to a single S3 bucket](http://coderwall.com/p/dwhlma).
 
-### Apply environment variables
+### Apply Environment Variables
 
+    # Required
+    heroku config:add HEROKU_API_KEY="collaborator-api-key"
+    heroku config:add PGBACKUPS_APP="myapp"
     heroku config:add PGBACKUPS_AWS_ACCESS_KEY_ID="XXX"
     heroku config:add PGBACKUPS_AWS_SECRET_ACCESS_KEY="YYY"
     heroku config:add PGBACKUPS_BUCKET="myapp-backups"
     heroku config:add PGBACKUPS_REGION="us-west-2"
-    heroku config:add PGBACKUPS_DATABASE_URL="your main app's DATABASE_URL or other follower URL here"
 
-* `PGBACKUPS_DATABASE_URL` can be set either to `DATABASE_URL` or a follower database you setup if you would prefer to not backup from your primary databse for performance reasons.
-* If `PGBACKUPS_DATABASE_URL` is omitted, `pgbackups-archive` will default to the `DATABASE_URL` of the Heroku app it runs under.  This setting will be required going forward, so you'll want to have it set.
-* As mentioned above, the `PGBACKUPS_DATABASE_URL` is mandatory if you are the using Option 2 above.
-* A good security measure would be to use a dedicated set of AWS credentials with a security policy only allowing access to the bucket you're specifying.  See this Pro Tip on [Assigning an AWS IAM user access to a single S3 bucket](http://coderwall.com/p/dwhlma).
+    # Optional: If you wish to backup a database other than the one that
+    # DATABASE_URL points to, set this to the name of the variable for that
+    # database (useful for follower databases).
+    heroku config:add PGBACKUPS_DATABASE="HEROKU_POSTGRESQL_BLACK_URL"
+
+    # Optional: If you wish to customize the number of manual backups kept at
+    # the Heroku PGBackups level, set this.
+    heroku config:add PGBACKUPS_KEEP="30"
 
 ### Add the rake task to scheduler
 
@@ -92,11 +90,11 @@ I shouldn't have to say this, but I will.  Your backups are your responsibility.
 
 ## Contributing
 
-1. [Fork it](https://github.com/kjohnston/pgbackups-archive/fork_select)
+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 a Pull Request](https://github.com/kjohnston/pgbackups-archive/pull/new)
+5. Create a Pull Request
 
 ## Contributors
 

data/lib/pgbackups-archive.rb

@@ -1,5 +1,5 @@
 module PgbackupsArchive
-  require "pgbackups-archive/heroku/client/pgbackups_archive"
+  require "pgbackups-archive/job"
   require "pgbackups-archive/railtie"
   require "pgbackups-archive/storage"
 end

data/lib/pgbackups-archive/job.rb

@@ -0,0 +1,109 @@
+require "heroku/command/pg"
+require "heroku/command/pg_backups"
+require "heroku/api"
+require "tmpdir"
+
+class PgbackupsArchive::Job
+
+  attr_reader :client
+  attr_accessor :backup_url, :created_at
+
+  def self.call
+    new.call
+  end
+
+  def initialize(attrs={})
+    Heroku::Command.load
+    @client = Heroku::Command::Pg.new([], :app => ENV["PGBACKUPS_APP"])
+  end
+
+  def call
+    expire
+    capture
+    download
+    archive
+    delete
+  end
+
+  def archive
+    if PgbackupsArchive::Storage.new(key, file).store
+      client.display "Backup archived"
+    end
+  end
+
+  def capture
+    attachment = client.send(:generate_resolver).resolve(database)
+    backup = client.send(:hpg_client, attachment).backups_capture
+    client.send(:poll_transfer, "backup", backup[:uuid])
+
+    self.created_at = backup[:created_at]
+
+    self.backup_url = Heroku::Client::HerokuPostgresqlApp
+      .new(ENV["PGBACKUPS_APP"]).transfers_public_url(backup[:num])[:url]
+  end
+
+  def delete
+    File.delete(temp_file)
+  end
+
+  def download
+    File.open(temp_file, "wb") do |output|
+      streamer = lambda do |chunk, remaining_bytes, total_bytes|
+        output.write chunk
+      end
+
+      # https://github.com/excon/excon/issues/475
+      Excon.get backup_url,
+        :response_block    => streamer,
+        :omit_default_port => true
+    end
+  end
+
+  def expire
+    transfers = client.send(:hpg_app_client, ENV["PGBACKUPS_APP"]).transfers
+      .select  { |b| b[:from_type] == "pg_dump" && b[:to_type] == "gof3r" }
+      .sort_by { |b| b[:created_at] }
+
+    if transfers.size > pgbackups_to_keep
+      backup_id  = "b%03d" % transfers.first[:num]
+      backup_num = client.send(:backup_num, backup_id)
+
+      expire_backup(backup_num)
+
+      client.display "Backup #{backup_id} expired"
+    end
+  end
+
+  private
+
+  def expire_backup(backup_num)
+    client.send(:hpg_app_client, ENV["PGBACKUPS_APP"])
+      .transfers_delete(backup_num)
+  end
+
+  def database
+    ENV["PGBACKUPS_DATABASE"] || "DATABASE_URL"
+  end
+
+  def environment
+    defined?(Rails) ? Rails.env : nil
+  end
+
+  def file
+    File.open(temp_file, "r")
+  end
+
+  def key
+    timestamp = created_at.gsub(/\/|\:|\.|\s/, "-").concat(".dump")
+    ["pgbackups", environment, timestamp].compact.join("/")
+  end
+
+  def pgbackups_to_keep
+    var = ENV["PGBACKUPS_KEEP"] ? var.to_i : 30
+  end
+
+  def temp_file
+    "#{Dir.tmpdir}/pgbackup"
+  end
+
+end

data/lib/pgbackups-archive/version.rb

@@ -1,3 +1,3 @@
 module PgbackupsArchive
-  VERSION = "0.3.0"
+  VERSION = "1.0.0"
 end

data/lib/tasks/pgbackups_archive.rake

@@ -1,8 +1,8 @@
 namespace :pgbackups do
 
-  desc "Perform a pgbackups backup then archive to S3."
+  desc "Capture a Heroku PGBackups backup and archive it to Amazon S3."
   task :archive do
-    Heroku::Client::PgbackupsArchive.perform
+    PgbackupsArchive::Job.call
   end
 
 end

data/test/lib/pgbackups-archive/job_test.rb

@@ -0,0 +1,131 @@
+require "test_helper"
+
+describe PgbackupsArchive::Job do
+
+  describe ".call" do
+    it { PgbackupsArchive::Job.must_respond_to(:call) }
+  end
+
+  describe "instance methods" do
+    before do
+      @app = "foobar"
+      ENV["PGBACKUPS_APP"] = @app
+      @job = PgbackupsArchive::Job.new
+      @client = @job.client
+      @backup_url = "https://raw.githubusercontent.com/kjohnston/pgbackups-archive/master/pgbackups-archive.gemspec"
+      @created_at = Time.now
+    end
+
+    describe "#initialize" do
+      it do
+        @client.must_be_kind_of(Heroku::Command::Pg)
+        @client.options[:app].must_equal @app
+      end
+    end
+
+    describe "#call" do
+      before do
+        @job.expects(:expire)
+        @job.expects(:capture)
+        @job.expects(:download)
+        @job.expects(:archive)
+        @job.expects(:delete)
+      end
+
+      it { @job.call }
+    end
+
+    describe "#archive" do
+      before do
+        @key  = "some-key"
+        @file = "some-file"
+        @job.stubs(:key).returns(@key)
+        @job.stubs(:file).returns(@file)
+
+        PgbackupsArchive::Storage.expects(:new).with(@key, @file)
+          .returns(mock(store: true))
+
+        @client.expects(:display)
+      end
+
+      it { @job.archive }
+    end
+
+    describe "#capture" do
+      before do
+        @client.stubs(:generate_resolver).returns(mock(:resolve))
+        @client.stubs(:hpg_client)
+          .returns(
+            mock(backups_capture: {
+              uuid:      "baz",
+              num:       "10",
+              created_at: @created_at }
+            )
+          )
+        @client.stubs(:poll_transfer)
+
+        Heroku::Client::HerokuPostgresqlApp.expects(:new).with(@app)
+          .returns(mock(transfers_public_url: { url: @backup_url }))
+      end
+
+      it do
+        @job.capture
+        @job.created_at.must_equal @created_at
+        @job.backup_url.must_equal @backup_url
+      end
+    end
+
+    describe "#delete" do
+      it do
+        @temp_file = @job.send(:temp_file)
+        File.write(@temp_file, "content")
+        File.exist?(@temp_file).must_equal true
+        @job.delete
+        File.exist?(@temp_file).must_equal false
+      end
+    end
+
+    describe "#download" do
+      before { @job.backup_url = @backup_url }
+
+      it do
+        @job.download
+        @job.send(:file).read.must_match /Gem::Specification/
+      end
+    end
+
+    describe "#expire" do
+      before do
+        @transfers = [
+          { from_type: "pg_dump", to_type: "gof3r", created_at: Date.today, num: 20 },
+          { from_type: "pg_dump", to_type: "gof3r", created_at: Date.today-2, num: 17 },
+          { from_type: "pg_dump", to_type: "gof3r", created_at: Date.today-1, num: 18 },
+          { from_type: "pg_dump", to_type: "foo", created_at: Date.today-1, num: 19 }
+        ]
+
+        @client.expects(:hpg_app_client).with(@app).returns(mock(transfers: @transfers))
+      end
+
+      describe "when slots are available" do
+        it "does not expire a backup" do
+          @job.expire
+        end
+      end
+
+      describe "when a slot needs to be freed" do
+        before do
+          ENV["PGBACKUPS_KEEP"] = "2"
+          @client.expects(:backup_num).with("b017").returns("017")
+          @job.expects(:expire_backup).with("017")
+          @client.expects(:display)
+        end
+
+        it "expires a backup" do
+          @job.expire
+        end
+      end
+    end
+
+  end
+
+end

data/test/lib/pgbackups-archive/storage_test.rb

@@ -1,33 +1,33 @@
 require "test_helper"
 
 describe PgbackupsArchive::Storage do
-  let(:connection) {
-    Fog::Storage.new(
-      :provider              => "AWS",
-      :aws_access_key_id     => "XXX",
-      :aws_secret_access_key => "YYY")
-  }
-  let(:bucket)     { connection.directories.create(:key => "someapp-backups") }
-  let(:key)        { "pgbackups/test/2012-08-02-12-00-00.dump" }
-  let(:file)       { "test" }
-  let(:storage)    { PgbackupsArchive::Storage.new(key, file) }
-
   before do
     Fog.mock!
-    storage.stubs(:connection).returns(connection)
-    storage.stubs(:bucket).returns(bucket)
+
+    @connection = Fog::Storage.new(
+      provider:              "AWS",
+      aws_access_key_id:     "XXX",
+      aws_secret_access_key: "YYY"
+    )
+    @bucket  = @connection.directories.create(key: "someapp-backups")
+    @key     = "pgbackups/test/2012-08-02-12-00-00.dump"
+    @file    = "test"
+    @storage = PgbackupsArchive::Storage.new(@key, @file)
+
+    @storage.stubs(:connection).returns(@connection)
+    @storage.stubs(:bucket).returns(@bucket)
   end
 
   it "should create a fog connection" do
-    storage.connection.class.must_equal Fog::Storage::AWS::Mock
+    @storage.connection.class.must_equal Fog::Storage::AWS::Mock
   end
 
   it "should create a fog directory" do
-    storage.bucket.class.must_equal Fog::Storage::AWS::Directory
+    @storage.bucket.class.must_equal Fog::Storage::AWS::Directory
   end
 
   it "should create a fog file" do
-    storage.store.class.must_equal Fog::Storage::AWS::File
+    @storage.store.class.must_equal Fog::Storage::AWS::File
   end
 
 end

metadata

@@ -1,43 +1,49 @@
 --- !ruby/object:Gem::Specification
 name: pgbackups-archive
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Kenny Johnston
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-20 00:00:00.000000000 Z
+date: 2015-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: fog-aws
+  name: heroku
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.28'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.28.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.28'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.28.6
 - !ruby/object:Gem::Dependency
-  name: heroku
+  name: fog-aws
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.34.0
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.34.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +72,26 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.12'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.12.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.12'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.12.5
 - !ruby/object:Gem::Dependency
   name: guard-minitest
   requirement: !ruby/object:Gem::Requirement
@@ -146,8 +172,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.9.1
-description: A means of automating Heroku's pgbackups and archiving them to Amazon
-  S3 via the fog gem.
+description: A means of automating Heroku PGBackups and archiving them to Amazon S3.
 email:
 - kjohnston.ca@gmail.com
 executables: []
@@ -158,7 +183,7 @@ files:
 - README.md
 - Rakefile
 - lib/pgbackups-archive.rb
-- lib/pgbackups-archive/heroku/client/pgbackups_archive.rb
+- lib/pgbackups-archive/job.rb
 - lib/pgbackups-archive/railtie.rb
 - lib/pgbackups-archive/storage.rb
 - lib/pgbackups-archive/version.rb
@@ -166,7 +191,7 @@ files:
 - lib/tasks/test.rake
 - test/ci/before_script.sh
 - test/ci/ci_runner.sh
-- test/lib/pgbackups-archive/heroku/client/pgbackups_archive_test.rb
+- test/lib/pgbackups-archive/job_test.rb
 - test/lib/pgbackups-archive/storage_test.rb
 - test/support/mocha.rb
 - test/test_helper.rb
@@ -193,11 +218,11 @@ rubyforge_project:
 rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: Automates archival of Heroku's pgbackups to S3
+summary: Automates archival of Heroku PGBackups to S3
 test_files:
 - test/ci/before_script.sh
 - test/ci/ci_runner.sh
-- test/lib/pgbackups-archive/heroku/client/pgbackups_archive_test.rb
+- test/lib/pgbackups-archive/job_test.rb
 - test/lib/pgbackups-archive/storage_test.rb
 - test/support/mocha.rb
 - test/test_helper.rb

data/lib/pgbackups-archive/heroku/client/pgbackups_archive.rb

@@ -1,77 +0,0 @@
-require "heroku/client"
-require "tmpdir"
-
-class Heroku::Client::PgbackupsArchive
-
-  attr_reader :client, :pgbackup
-
-  def self.perform
-    backup = new
-    backup.capture
-    backup.download
-    backup.archive
-    backup.delete
-  end
-
-  def initialize(attrs={})
-    Heroku::Command.load
-    @client   = Heroku::Client::Pgbackups.new pgbackups_url
-    @pgbackup = nil
-  end
-
-  def archive
-    PgbackupsArchive::Storage.new(key, file).store
-  end
-
-  def capture
-    @pgbackup = @client.create_transfer(database_url, database_url, nil,
-      "BACKUP", :expire => true)
-
-    until @pgbackup["finished_at"]
-      print "."
-      sleep 1
-      @pgbackup = @client.get_transfer @pgbackup["id"]
-    end
-  end
-
-  def delete
-    File.delete temp_file
-  end
-
-  def download
-    File.open(temp_file, "wb") do |output|
-      streamer = lambda do |chunk, remaining_bytes, total_bytes|
-        output.write chunk
-      end
-      Excon.get(@pgbackup["public_url"], :response_block => streamer)
-    end
-  end
-
-  private
-
-  def database_url
-    ENV["PGBACKUPS_DATABASE_URL"] || ENV["DATABASE_URL"]
-  end
-
-  def environment
-    defined?(Rails) ? Rails.env : nil
-  end
-
-  def file
-    File.open temp_file, "r"
-  end
-
-  def key
-    ["pgbackups", environment, @pgbackup["finished_at"]
-      .gsub(/\/|\:|\.|\s/, "-").concat(".dump")].compact.join("/")
-  end
-
-  def pgbackups_url
-    ENV["PGBACKUPS_URL"]
-  end
-
-  def temp_file
-    "#{Dir.tmpdir}/#{URI(@pgbackup['public_url']).path.split('/').last}"
-  end
-
-end

data/test/lib/pgbackups-archive/heroku/client/pgbackups_archive_test.rb

@@ -1,181 +0,0 @@
-require "test_helper"
-require "heroku/client"
-
-describe Heroku::Client::PgbackupsArchive do
-
-  describe "#self.perform" do
-    before do
-      Heroku::Client::PgbackupsArchive.expects(:new).returns(
-        mock(
-          :capture  => stub,
-          :download => stub,
-          :archive  => stub,
-          :delete   => stub
-        )
-      )
-    end
-
-    it { Heroku::Client::PgbackupsArchive.perform }
-  end
-
-  describe "An instance" do
-    let(:database_url)  { "db_url" }
-    let(:pgbackups_url) { "https://ip:password@pgbackups.heroku.com/client" }
-    let(:backup)        { Heroku::Client::PgbackupsArchive.new }
-
-    before do
-      ENV["PGBACKUPS_URL"] = pgbackups_url
-    end
-
-    describe "#initialize" do
-      it "should set client to a Heroku::Client::Pgbackups instance" do
-        backup.client.class.must_equal Heroku::Client::Pgbackups
-      end
-    end
-
-    describe "#archive" do
-      let(:key)  { "some-key" }
-      let(:file) { "some-file" }
-
-      before do
-        backup.stubs(:key).returns(key)
-        backup.stubs(:file).returns(file)
-
-        PgbackupsArchive::Storage.expects(:new).with(key, file)
-          .returns(mock(:store => stub))
-      end
-
-      it "should use a storage instance to store the archive" do
-        backup.archive
-      end
-    end
-
-    describe "#capture" do
-      let(:pgbackup) { { "finished_at" => "some-timestamp" } }
-
-      before do
-        backup.stubs(:database_url).returns(database_url)
-
-        backup.client.expects(:create_transfer)
-          .with(database_url, database_url, nil, "BACKUP", :expire => true)
-          .returns(pgbackup)
-      end
-
-      it "uses the client to create a pgbackup" do
-        backup.capture
-      end
-    end
-
-    describe "#delete" do
-      let(:temp_file) { "temp-file" }
-
-      before do
-        backup.stubs(:temp_file).returns(temp_file)
-        File.expects(:delete).with(temp_file).returns(true)
-      end
-
-      it "should delete the temp file" do
-        backup.delete
-      end
-    end
-
-    describe "#download" do
-      let(:pgbackup) do
-        {
-          "public_url" => "https://raw.github.com/kjohnston/" +
-            "pgbackups-archive/master/pgbackups-archive.gemspec"
-        }
-      end
-
-      before do
-        backup.instance_eval do
-          @pgbackup = {
-            "public_url" => "https://raw.githubusercontent.com/kjohnston/pgbackups-archive/master/pgbackups-archive.gemspec"
-          }
-        end
-        backup.download
-      end
-
-      it "downloads the backup file" do
-        backup.send(:file).read.must_match /Gem::Specification/
-      end
-
-      after do
-        backup.delete
-      end
-    end
-
-    describe "#database_url" do
-      describe "when an alternate database to backup is not set" do
-        before do
-          ENV["PGBACKUPS_DATABASE_URL"] = nil
-          ENV["DATABASE_URL"] = "default_url"
-        end
-
-        it "defaults to using the DATABASE_URL" do
-          backup.send(:database_url).must_equal "default_url"
-        end
-      end
-
-      describe "an alternate database to backup is set" do
-        before do
-          ENV["PGBACKUPS_DATABASE_URL"] = "alternate_url"
-          ENV["DATABASE_URL"] = "default_url"
-        end
-
-        it "uses the PGBACKUPS_DATABASE_URL" do
-          backup.send(:database_url).must_equal "alternate_url"
-        end
-      end
-    end
-
-    describe "#file" do
-      let(:temp_file) { "temp-file" }
-
-      before do
-        backup.stubs(:temp_file).returns(temp_file)
-        File.expects(:open).with(temp_file, "r").returns("")
-      end
-
-      it { backup.send(:file) }
-    end
-
-    describe "#key" do
-      before do
-        backup.instance_eval do
-          @pgbackup = {
-            "finished_at" => "timestamp"
-          }
-        end
-      end
-
-      it "should be composed properly" do
-        path = ["pgbackups", backup.send(:environment), "timestamp.dump"]
-          .compact.join("/")
-        backup.send(:key).must_equal path
-      end
-    end
-
-    describe "#pgbackups_url" do
-      it { backup.send(:pgbackups_url).must_equal pgbackups_url }
-    end
-
-    describe "#temp_file" do
-      before do
-        backup.instance_eval do
-          @pgbackup = {
-            "public_url" => "https://raw.github.com/kjohnston/pgbackups-archive/master/pgbackups-archive.gemspec"
-          }
-        end
-      end
-
-      it "should be composed properly" do
-        temp_file = backup.send(:temp_file)
-        temp_file.must_match /^\/var\//
-        temp_file.must_match /\/pgbackups-archive.gemspec$/
-      end
-    end
-
-  end
-
-end