glacier_on_rails 0.9

data/spec/models/application_data_backup_spec.rb

@@ -0,0 +1,226 @@
+require 'spec_helper'
+
+describe "ApplicationDataBackup#create" do
+  include HttpMockHelpers
+  include DummyAppDb
+  before do
+    @backup = ApplicationDataBackup.create
+  end
+
+  it "should have a single GlacierDbArchive association" do
+    expect(@backup.glacier_db_archive).to be_a GlacierDbArchive
+  end
+
+  it "should have a GlacierFileArchive for each file attachment" do
+    expect(@backup.glacier_file_archives.length).to eq 3 # DummyAppDb creates 3 files
+  end
+
+  it "should create exactly one ApplicationDataBackup instance" do
+    expect(ApplicationDataBackup.count).to eq 1
+  end
+
+  it "should create exactly one GlacierDbArchive" do
+    expect(GlacierDbArchive.count).to eq 1
+  end
+end
+
+describe "ApplicationDataBackup#initiate_retrieval" do
+  include HttpMockHelpers
+  include DummyAppDb
+  include AwsHelper
+  context "all aws responses are normal" do
+    before do
+      create_application_data_backup_with_available_components
+      FileUtils.rm(FakeModel::FilePath.join(FakeModel.first.file_id))
+      @application_data_backup.initiate_retrieval
+    end
+
+    it "should initiate retrieval for database and file archives" do
+      expect(@application_data_backup.glacier_db_archive.retrieval_status).to eq 'pending'
+      expect(@application_data_backup.glacier_file_archives[0].retrieval_status).to eq 'pending' # b/c its file was removed
+      expect(@application_data_backup.glacier_file_archives[1].retrieval_status).to eq 'exists'
+      expect(@application_data_backup.glacier_file_archives[2].retrieval_status).to eq 'exists'
+      expect(@application_data_backup.retrieval_status).to eq 'pending'
+      expect(initiate_retrieve_job).to have_been_requested.times(2) # one pending file and the db
+    end
+  end
+
+  context "one of the responses has an error" do
+    before do
+      stub_errored_response_for_initiate_retrieval
+      create_application_data_backup_with_available_components
+      FileUtils.rm(Dir.glob(FakeModel::FilePath.join('*')))
+      @application_data_backup.initiate_retrieval
+    end
+
+    it "does not change to pending status if one of the components returns error for the initiate" do
+      expect(@application_data_backup.glacier_db_archive.retrieval_status).to eq 'pending' # success response
+      expect(@application_data_backup.glacier_file_archives[0].retrieval_status).to eq 'pending' # success response
+      expect(@application_data_backup.glacier_file_archives[1].retrieval_status).to eq 'pending' # success response
+      expect(@application_data_backup.glacier_file_archives[2].retrieval_status).to eq 'available' # fail response
+      expect(@application_data_backup.glacier_file_archives[2].errors.full_messages.first).to eq 'Failed to initiate archive retrieval with: Aws::Glacier::Errors::BadRequest: '
+      expect(@application_data_backup.errors.full_messages.first).to eq 'Failed to initiate archive retrieval with: Aws::Glacier::Errors::BadRequest: '
+      expect(@application_data_backup.retrieval_status).to eq 'available'
+      expect(aws_log).to match /Failed to initiate archive retrieval with: Aws::Glacier::Errors::BadRequest:/
+    end
+  end
+end
+
+describe "ApplicationDataBackup#fetch" do
+  include HttpMockHelpers
+  include DummyAppDb
+  include AwsHelper
+  context "when retrieval job ids are current" do
+    before do
+      create_application_data_backup_with_ready_components
+      FakeModel.destroy_all
+      @application_data_backup.fetch_archive
+    end
+
+    it "should report aggregate status" do
+      expect(fetch_db_archive_retrieval_job_output).to have_been_requested.once
+      expect(fetch_file_archive_retrieval_job_output).to have_been_requested.times(3)
+      expect(@application_data_backup.retrieval_status).to eq "local"
+      expect(File.exists?(@application_data_backup.glacier_db_archive.backup_file)).to eq true
+      expect(File.exists?(@application_data_backup.glacier_file_archives[0].backup_file)).to eq true
+      expect(File.exists?(@application_data_backup.glacier_file_archives[1].backup_file)).to eq true
+      expect(File.exists?(@application_data_backup.glacier_file_archives[2].backup_file)).to eq true
+    end
+  end
+
+  context "when some retrieval job id has expired" do
+    before do
+      create_application_data_backup_with_ready_components
+      FakeModel.destroy_all
+      GlacierFileArchive.where(:filename => '1234abc').first.update_attributes(:archive_retrieval_job_id => 'expiredJobId')
+      fetch_expired_archive #setup response for expired job
+      @application_data_backup = ApplicationDataBackup.first
+      @application_data_backup.fetch_archive
+    end
+
+    it "does not change to local status if one of the component fetches fails with errors" do
+      expect(fetch_db_archive_retrieval_job_output).to have_been_requested.once
+      expect(fetch_file_archive_retrieval_job_output).to have_been_requested.times(2)
+      expect(fetch_expired_archive).to have_been_requested.once
+      expect(@application_data_backup.retrieval_status).to eq "available"
+      expect(File.exists?(@application_data_backup.glacier_db_archive.backup_file)).to eq true
+      expect(File.exists?(@application_data_backup.glacier_file_archives.find{|a| a.filename=="1234abc"}.backup_file)).to eq false
+      expect(File.exists?(@application_data_backup.glacier_file_archives.find{|a| a.filename=="4567def"}.backup_file)).to eq true
+      expect(File.exists?(@application_data_backup.glacier_file_archives.find{|a| a.filename=="8899bin"}.backup_file)).to eq true
+    end
+  end
+end
+
+describe "ApplicationDataBackup#restore" do
+  include DummyAppDb
+  include HttpMockHelpers
+  include AwsHelper
+  before do
+    create_application_data_backup_with_local_components
+    @application_data_backup = ApplicationDataBackup.first
+    @application_data_backup.glacier_db_archive.reload # not sure why!
+    FakeModel.destroy_all
+    8.times do |i|
+      FakeModel.create(:file_id => "abracadabra#{i}")
+    end
+    create_application_data_backup_with_local_components
+    @application_data_backup.restore
+  end
+
+  it "should restore database and each fetched file archive" do
+    expect(FakeModel.count).to eq 3
+    expect(Dir.glob(GlacierOnRails::Config.attached_files_directory.join('*')).length).to eq 3
+    expect(@application_data_backup.retrieval_status).to eq "available"
+  end
+
+  it "should move into the orphan_files_directory any files added since the application_data_backup being restored" do
+    expect(Dir.glob(GlacierOnRails::Config.orphan_files_directory.join('*')).length).to eq 8
+  end
+
+  it "should delete the fetched backup files" do
+    expect(Dir.glob( GlacierArchive::BackupFileDir.join('*')).length).to eq 9 # it leaves in place the files that were not restored
+  end
+
+  it "should retain and not overwrite application_data_backups table" do
+    expect(ApplicationDataBackup.count).to eq 2
+  end
+
+  it "should retain and not overwrite glacier_archives table" do
+    expect(GlacierDbArchive.count).to eq 2
+    expect(GlacierFileArchive.count).to eq 11
+  end
+end
+
+describe '#pick_lowest' do
+  before do
+    @app_db = ApplicationDataBackup.new
+  end
+
+  it "should pick the lowest status according as the earliest in the archive lifecycle" do
+    # just try some random combinations!
+    expect(@app_db.send(:pick_lowest, ["ready", "available", "local"])).to eq "available"
+    expect(@app_db.send(:pick_lowest, ["local", "ready", "available"])).to eq "available"
+    expect(@app_db.send(:pick_lowest, ["exists", "exists", "local"])).to eq "local"
+    expect(@app_db.send(:pick_lowest, ["pending", "exists", "ready"])).to eq "pending"
+    expect(@app_db.send(:pick_lowest, ["pending", "available", "ready"])).to eq "available"
+  end
+end
+
+describe '#retrieval_status' do
+  context "components have identical retrieval_status" do
+    before do
+      @application_data_backup = ApplicationDataBackup.new
+      allow_any_instance_of(GlacierFileArchive).to receive(:retrieval_status).and_return('pending')
+      allow_any_instance_of(GlacierDbArchive).to receive(:retrieval_status).and_return('pending')
+      allow(@application_data_backup).to receive(:glacier_file_archives).and_return([GlacierFileArchive.new(:filename => 'abc123')])
+      allow(@application_data_backup).to receive(:glacier_db_archive).and_return(GlacierDbArchive.new(:filename => GlacierDbArchive.filename_from_time))
+    end
+
+    it "should return pending for application_data_backup#retrieval_status" do
+      expect(@application_data_backup.retrieval_status).to eq 'pending'
+    end
+  end
+
+  context "components have disparate retrieval_status" do
+    before do
+      @application_data_backup = ApplicationDataBackup.new
+      allow_any_instance_of(GlacierFileArchive).to receive(:retrieval_status).and_return('pending')
+      allow_any_instance_of(GlacierDbArchive).to receive(:retrieval_status).and_return('ready')
+      allow(@application_data_backup).to receive(:glacier_file_archives).and_return([GlacierFileArchive.new(:filename => 'abc123')])
+      allow(@application_data_backup).to receive(:glacier_db_archive).and_return(GlacierDbArchive.new(:filename => GlacierDbArchive.filename_from_time))
+    end
+
+    it "should return pending for application_data_backup#retrieval_status" do
+      expect(@application_data_backup.retrieval_status).to eq 'pending'
+    end
+  end
+end
+
+describe '#destroy' do
+  include HttpMockHelpers
+  include DummyAppDb
+  include AwsHelper
+
+  context "glacier_file_archives do not belong to any other application_data_backups" do
+    before do
+      create_application_data_backup_with_ready_components
+    end
+
+    it "should destroy all associated archives" do
+      expect{@application_data_backup.destroy}.to change{ GlacierDbArchive.count }.from(1).to(0).
+                                               and change{ GlacierFileArchive.count }.from(3).to(0)
+    end
+  end
+
+  context "glacier_file_archives also belong to other application_data_backups" do
+    before do
+      create_application_data_backup_with_ready_components
+      create_application_data_backup_with_ready_components
+    end
+
+    it "should not destroy associated archives that also belong to another application_data_backup" do
+      expect{@application_data_backup.destroy}.to change{ GlacierDbArchive.count }.from(2).to(1)
+      expect( GlacierFileArchive.count ).to eq 3
+    end
+  end
+end

data/spec/models/application_file_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe '.list' do
+  include DummyAppDb
+  it "should list filenames" do
+    expect(ApplicationFile.list).to match_array ['1234abc', '4567def', '8899bin']
+  end
+end

data/spec/models/glacier_db_archive_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+# helpers are all required in spec helper
+
+
+describe 'GlacierDbArchive.create' do
+  include HttpMockHelpers
+  include AwsHelper
+
+  before do
+    @archive = GlacierDbArchive.create
+  end
+
+  it 'should create instance of GlacierDbArchive in the database' do
+    expect(upload_archive_post).to have_been_requested.once
+
+    expect(@archive.archive_id).not_to be_nil
+    expect(@archive.checksum).not_to be_nil
+    expect(@archive.location).not_to be_nil
+    expect(@archive.retrieval_status).to eq 'available'
+  end
+end
+
+describe 'GlacierDbArchive.create with error' do
+  include HttpMockHelpers
+  include AwsHelper
+
+  before do
+    upload_archive_post_with_error_response
+    @archive = GlacierDbArchive.create
+  end
+
+  it 'should not create instance of GlacierDbArchive in the database' do
+    expect(upload_archive_post_with_error_response).to have_been_requested.once
+    expect(aws_log).to match /Failed to create archive with: Aws::Glacier::Errors::InvalidParameterValueException: Invalid Content-Length: 0/
+
+    expect(@archive.id).to be_nil
+    expect(@archive.errors.full_messages[0]).to eq "Failed to create archive with: Aws::Glacier::Errors::InvalidParameterValueException: Invalid Content-Length: 0"
+  end
+end
+
+describe GlacierOnRails::AwsSnsSubscriptionsController, :type => :controller do
+  include HttpMockHelpers
+  include AwsHelper
+
+  routes { GlacierOnRails::Engine.routes }
+
+  before do
+    @archive = GlacierDbArchive.create
+  end
+
+  it "should send archive retrieval job initiation request" do
+    expect(@archive.reload.retrieval_status).to eq 'available'
+    @archive.initiate_retrieve_job
+    expect(initiate_retrieve_job).to have_been_requested.once
+    expect(@archive.retrieval_status).to eq 'pending'
+  end
+
+  it "should change status to ready when notification is received" do
+    @archive.initiate_retrieve_job
+    expect(@archive.retrieval_status).to eq 'pending'
+    receive_notification
+    expect(@archive.reload.retrieval_status).to eq 'ready'
+  end
+
+end
+
+describe GlacierOnRails::ApplicationDataBackupsController, :type => :controller do
+  include HttpMockHelpers
+  include AwsHelper
+  routes { GlacierOnRails::Engine.routes }
+
+  context "when archive retrieval job is fresh" do
+    before do
+      @archive = GlacierDbArchive.create(:notification => "got a notification", :archive_retrieval_job_id => "validJobId")
+    end
+
+    it "should retrieve the archive" do
+      expect(@archive.fetch_archive).to eq true
+      expect(@archive.notification).to be_nil
+      expect(@archive.archive_retrieval_job_id).to be_nil
+      expect(@archive.retrieval_status).to eq 'local'
+    end
+  end
+
+  context "when archive retrieval job has expired" do
+    before do
+      fetch_expired_archive # set up the webmock stub
+      @archive = GlacierDbArchive.create(:notification => "got a notification", :archive_retrieval_job_id => "expiredJobId")
+    end
+
+    it "should return to available status" do
+      expect(@archive.fetch_archive).to eq false
+      expect(fetch_expired_archive).to have_been_requested.once
+      expect(aws_log).to match /Fetch archive failed with: Aws::Glacier::Errors::ResourceNotFoundException: The job ID was not found/
+      expect(@archive.notification).to be_nil
+      expect(@archive.archive_retrieval_job_id).to be_nil
+      expect(@archive.retrieval_status).to eq 'available'
+    end
+  end
+
+end
+
+describe "GlacierDbArchive#restore" do
+  include HttpMockHelpers
+  include AwsHelper
+
+  before do
+    @archive = GlacierDbArchive.create(:notification => "got a notification", :archive_retrieval_job_id => "validJobId")
+    create_compressed_archive(@archive)
+    change_database
+    @archive.restore
+  end
+
+  it "should restore the database" do
+    expect(ActiveRecord::Base.connection.execute("select * from test").first["foo"]).to eq 'bar'
+  end
+
+end

data/spec/models/glacier_file_archive_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe 'GlacierFileArchive.all!' do
+  include HttpMockHelpers
+  include AwsHelper
+  include DummyAppDb
+  before do
+    GlacierFileArchive.all!
+  end
+
+  it "should create an archive for each file attachment" do
+    # just verifying FakeModel here!
+    expect(File.exists?(FakeModel::FilePath.join('1234abc'))).to eq true
+    expect(File.exists?(FakeModel::FilePath.join('4567def'))).to eq true
+    expect(File.exists?(FakeModel::FilePath.join('8899bin'))).to eq true
+    expect(GlacierFileArchive.pluck(:filename)).to match_array ['1234abc', '4567def', '8899bin']
+  end
+
+  it "should add new files" do
+    FakeModel.create(:file_id => '6666zyx')
+    expect(GlacierFileArchive.pluck(:filename)).to match_array ['1234abc', '4567def', '8899bin']
+    GlacierFileArchive.all!
+    expect(GlacierFileArchive.pluck(:filename)).to match_array ['1234abc', '4567def', '8899bin', '6666zyx']
+  end
+
+end
+
+describe '#initiate_retrieve_job' do
+  include HttpMockHelpers
+  context "when file does not exist in the filesystem" do
+    before do
+      FakeModel.create(:file_id => '6666zyx')
+      @archive = GlacierFileArchive.create(:filename => '6666zyx')
+      FileUtils.rm(FakeModel::FilePath.join('6666zyx'))
+      @archive.initiate_retrieve_job
+    end
+
+    it "should send a job initiation request and change status to pending" do
+      expect(initiate_retrieve_job).to have_been_requested.once
+      expect(@archive.retrieval_status).to eq 'pending'
+    end
+  end
+
+  context "when file exists in the filesystem" do
+    before do
+      FakeModel.create(:file_id => '6666zyx')
+      @archive = GlacierFileArchive.create(:filename => '6666zyx')
+      @archive.initiate_retrieve_job
+    end
+
+    it "should not send a job initiation request and should change status to exists" do
+      expect(initiate_retrieve_job).not_to have_been_requested
+      expect(@archive.retrieval_status).to eq 'exists'
+    end
+  end
+end

data/spec/models/postgres_adapter_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+# helpers are all required in spec helper
+
+describe "PostgresAdapter#create_object_restoral_list_omitting_exclusions" do
+  include HttpMockHelpers
+  include AwsHelper
+
+  before do
+    @archive = GlacierDbArchive.create(:notification => "got a notification", :archive_retrieval_job_id => "validJobId")
+    create_compressed_archive(@archive)
+    change_database
+    db_config = ActiveRecord::Base.configurations["test"]
+    postgres_adapter = ApplicationDatabase::PostgresAdapter.new(db_config)
+    postgres_adapter.send(:generate_object_restoral_list, @archive.backup_file)
+  end
+
+  it "should create intermediate file with list of objects to be restored" do
+    expect(File.exists?(ApplicationDatabase::PostgresAdapter::RestoreList)).to eq true
+    ApplicationDatabase::PostgresAdapter::RestoreExclusions.each do |table|
+      expect(File.read(ApplicationDatabase::PostgresAdapter::RestoreList)).not_to match /#{table}/
+    end
+  end
+
+end
+
+describe "PostgresAdapter#restore_from_list" do
+  include HttpMockHelpers
+  include AwsHelper
+
+  before do
+    @archive = GlacierDbArchive.create(:notification => "got a notification", :archive_retrieval_job_id => "validJobId")
+    GlacierDbArchive.create(:notification => "got a notification", :archive_retrieval_job_id => "validJobId")
+    create_compressed_archive(@archive)
+    change_database
+    db_config = ActiveRecord::Base.configurations["test"]
+    postgres_adapter = ApplicationDatabase::PostgresAdapter.new(db_config)
+    postgres_adapter.send(:generate_object_restoral_list, @archive.backup_file)
+    postgres_adapter.send(:restore_from_list, @archive.backup_file)
+  end
+
+  it "should create intermediate file with list of objects to be restored" do
+    expect(ActiveRecord::Base.connection.execute("select * from test").first["foo"]).to eq 'bar'
+    expect(GlacierDbArchive.count).to eq 2
+  end
+
+end

data/spec/rails_helper.rb

@@ -0,0 +1,59 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV['RAILS_ENV'] ||= 'test'
+require 'byebug'
+
+require File.expand_path('spec/dummy/config/environment')
+require 'rspec/rails'
+$:.unshift File.expand_path '../helpers', __FILE__
+# Add additional requires below this line. Rails is not loaded until this point!
+
+# Requires supporting ruby files with custom matchers and macros, etc, in
+# spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
+# run as spec files by default. This means that files in spec/support that end
+# in _spec.rb will both be required and run as specs, causing the specs to be
+# run twice. It is recommended that you do not name files matching this glob to
+# end with _spec.rb. You can configure this pattern with the --pattern
+# option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
+#
+# The following line is provided for convenience purposes. It has the downside
+# of increasing the boot-up time by auto-requiring all files in the support
+# directory. Alternatively, in the individual `*_spec.rb` files, manually
+# require only the support files necessary.
+#
+# Dir[Rails.root.join('spec/support/**/*.rb')].each { |f| require f }
+
+# Checks for pending migrations before tests are run.
+# If you are not using ActiveRecord, you can remove this line.
+ActiveRecord::Migration.maintain_test_schema!
+
+RSpec.configure do |config|
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  # 
+  # for reasons I don't fully understand, transactional fixtures cause test failures
+  # when using the capybara selenium driver, so disable them here
+  # and use database cleaner instead!
+  #config.use_transactional_fixtures = true
+  config.use_transactional_fixtures = false
+
+  # RSpec Rails can automatically mix in different behaviours to your tests
+  # based on their file location, for example enabling you to call `get` and
+  # `post` in specs under `spec/controllers`.
+  #
+  # You can disable this behaviour by removing the line below, and instead
+  # explicitly tag your specs with their type, e.g.:
+  #
+  #     RSpec.describe UsersController, :type => :controller do
+  #       # ...
+  #     end
+  #
+  # The different available types are documented in the features, such as in
+  # https://relishapp.com/rspec/rspec-rails/docs
+  config.infer_spec_type_from_file_location!
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,110 @@
+ENV["RAILS_ENV"] ||= 'test'
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require 'rspec/rails'
+require 'byebug'
+require 'webmock/rspec'
+require 'capybara/poltergeist'
+require 'selenium-webdriver'
+include WebMock::API
+require 'database_cleaner'
+
+ENGINE_RAILS_ROOT= GlacierOnRails::Engine.root
+# this is intended to be the Capistrano shared files directory.
+# in development we store them in tmp
+# in production it's typically at ../shared
+GlacierOnRails::Engine::TempDirectory = Rails.root.join('tmp')
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.join(ENGINE_RAILS_ROOT, "spec/support/*.rb")].each {|f| require f }
+Dir[File.join(ENGINE_RAILS_ROOT, "spec/helpers/*.rb")].each {|f| require f }
+
+Capybara.register_driver :chrome do |app|
+  #caps = Selenium::WebDriver::Remote::Capabilities.chrome(
+    #"chromeOptions" => {
+      #"args" => [ "--window-size=1400,800"],
+      #"prefs" => {"download.default_directory" => DownloadHelpers::PATH }
+    #}
+  #)
+  #Capybara::Selenium::Driver.new(app, :browser => :chrome, :desired_capabilities => caps)
+  Capybara::Selenium::Driver.new(app, :browser => :chrome)
+end
+
+
+Capybara.register_driver :poltergeist do |app|
+# use this configuration to show the messages between poltergeist and phantomjs
+  #Capybara::Poltergeist::Driver.new(app, :debug => true)
+# use this configuration to enable the page.driver.debug interface
+# see https://github.com/teampoltergeist/poltergeist
+  #Capybara::Poltergeist::Driver.new(app, :inspector => true, :timeout => 300)
+  Capybara::Poltergeist::Driver.new(:window_size => [1600,900])
+end
+
+if ENV["client"] =~ /(sel|ff)/i
+  puts "Browser: Firefox via Selenium"
+  Capybara.javascript_driver = :selenium
+elsif ENV["client"] =~ /chr/i
+  puts "Browser: Chrome"
+
+  Capybara.javascript_driver = :chrome
+elsif ENV["client"] =~ /ie/i
+  puts "Browser: IE"
+  CONFIGURATION FOR REMOTE TESTING OF IE
+  require 'capybara/rspec'
+
+
+  Capybara.server_port = 3010
+  ip = `ifconfig | grep 'inet ' | grep -v 127.0.0.1 | cut -d ' ' -f2`.strip
+  puts "this machine ip is #{ip}"
+
+  Capybara.app_host = "http://#{ip}:#{Capybara.server_port}"
+  Capybara.current_driver = :remote
+  Capybara.javascript_driver = :remote
+  Capybara.run_server = false
+  Capybara.remote = true
+
+else
+  puts "Browser: Phantomjs via Poltergeist"
+
+  Capybara.javascript_driver = :poltergeist
+end
+
+
+WebMock.disable_net_connect!(allow_localhost: true)
+
+RSpec.configure do |config|
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  # NOTE:this creates db locking problems with pg_dump, psql etc when run from within tests
+  #config.use_transactional_fixtures = true
+
+  # If true, the base class of anonymous controllers will be inferred
+  # automatically. This will be the default behavior in future versions of
+  # rspec-rails.
+  config.infer_base_class_for_anonymous_controllers = false
+
+  # 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"
+
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+    mocks.verify_partial_doubles = true
+  end
+
+  config.before(:each) do |example|
+    DatabaseCleaner.strategy = :truncation
+    DatabaseCleaner.start
+  end
+  config.after(:each) do
+    DatabaseCleaner.clean
+    FileUtils.rm Dir.glob FakeModel::FilePath.join('*')
+    FileUtils.rm Dir.glob GlacierArchive::BackupFileDir.join('*')
+    FileUtils.rm Dir.glob GlacierOnRails::Config.orphan_files_directory.join('*')
+    `:> #{AwsLog::LogFile}`
+  end
+
+end

data/spec/support/wait_for_ajax.rb

@@ -0,0 +1,22 @@
+# thank you Thoughtbot!
+# https://robots.thoughtbot.com/automatically-wait-for-ajax-with-capybara
+module WaitForAjax
+  def wait_for_ajax
+    earlier_version = Capybara::VERSION == "2.5.0.dev" || Capybara::VERSION.to_f <= 2.4
+    wait_time = earlier_version ? "default_wait_time" : "default_max_wait_time"
+    Timeout.timeout(Capybara.send(wait_time)) do
+      loop until finished_all_ajax_requests?
+    end
+  end
+
+  def finished_all_ajax_requests?
+    # see http://stackoverflow.com/a/3148506/451893
+    # this MAY change to jQuery.ajax.active in a later release
+    page.evaluate_script('jQuery.active').zero?
+  end
+
+end
+
+RSpec.configure do |config|
+  config.include WaitForAjax, type: :feature
+end