aptible-cli 0.6.9 → 0.7.0

data/spec/aptible/cli/helpers/options_handle_strategy_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Aptible::CLI::Helpers::App::OptionsHandleStrategy do
+  it 'is usable when app is set' do
+    s = described_class.new(app: 'foo')
+    expect(s.usable?).to be_truthy
+  end
+
+  it 'passes options through' do
+    s = described_class.new(app: 'foo', environment: 'bar')
+    expect(s.app_handle).to eq('foo')
+    expect(s.env_handle).to eq('bar')
+  end
+end

data/spec/aptible/cli/helpers/tunnel_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'climate_control'
 
 describe Aptible::CLI::Helpers::Tunnel do
   around do |example|

data/spec/aptible/cli/subcommands/apps_spec.rb

@@ -1,16 +1,17 @@
-require 'ostruct'
-require 'spec_helper'
-
-class App < OpenStruct
-end
-
-class Service < OpenStruct
-end
-
-class Operation < OpenStruct
-end
-
-class Account < OpenStruct
+def dummy_strategy_factory(app_handle, env_handle, usable,
+                           options_receiver = [])
+  Class.new do
+    attr_reader :options
+
+    define_method(:initialize) { |options| options_receiver << options }
+    define_method(:app_handle) { app_handle }
+    define_method(:env_handle) { env_handle }
+    define_method(:usable?) { usable }
+
+    def explain
+      '(options from dummy)'
+    end
+  end
 end
 
 describe Aptible::CLI::Agent do
@@ -19,49 +20,40 @@ describe Aptible::CLI::Agent do
   before { subject.stub(:fetch_token) { double 'token' } }
   before { subject.stub(:attach_to_operation_logs) }
 
-  let(:service) { Service.new(process_type: 'web') }
-  let(:op) { Operation.new(status: 'succeeded') }
-  let(:account) do
-    Account.new(bastion_host: 'localhost',
-                dumptruck_port: 1234,
-                handle: 'aptible')
-  end
-  let(:services) { [service] }
-  let(:apps) do
-    [App.new(handle: 'hello', services: services, account: account)]
-  end
+  let!(:account) { Fabricate(:account) }
+  let!(:app) { Fabricate(:app, handle: 'hello', account: account) }
+  let!(:service) { Fabricate(:service, app: app) }
+  let(:op) { Fabricate(:operation, status: 'succeeded', resource: app) }
 
   describe '#apps:scale' do
+    before do
+      allow(Aptible::Api::App).to receive(:all) { [app] }
+      allow(Aptible::Api::Account).to receive(:all) { [account] }
+    end
+
     it 'should pass given correct parameters' do
-      allow(service).to receive(:create_operation) { op }
       allow(subject).to receive(:options) do
         { app: 'hello', environment: 'foobar' }
       end
-      allow(op).to receive(:resource) { apps.first }
-      allow(Aptible::Api::App).to receive(:all) { apps }
-
+      expect(service).to receive(:create_operation!) { op }
       expect(subject).to receive(:environment_from_handle)
         .with('foobar')
         .and_return(account)
-      expect(subject).to receive(:apps_from_handle).and_return(apps)
+      expect(subject).to receive(:apps_from_handle).and_return([app])
       subject.send('apps:scale', 'web', 3)
     end
 
     it 'should pass container size param to operation if given' do
-      expect(service).to receive(:create_operation)
-        .with(type: 'scale', container_count: 3, container_size: 90210)
-        .and_return(op)
       allow(subject).to receive(:options) do
         { app: 'hello', size: 90210, environment: 'foobar' }
       end
-
-      allow(op).to receive(:resource) { apps.first }
-      allow(Aptible::Api::App).to receive(:all) { apps }
-
+      expect(service).to receive(:create_operation!)
+        .with(type: 'scale', container_count: 3, container_size: 90210)
+        .and_return(op)
       expect(subject).to receive(:environment_from_handle)
         .with('foobar')
         .and_return(account)
-      expect(subject).to receive(:apps_from_handle).and_return(apps)
+      expect(subject).to receive(:apps_from_handle).and_return([app])
       subject.send('apps:scale', 'web', 3)
     end
 
@@ -69,9 +61,8 @@ describe Aptible::CLI::Agent do
       allow(subject).to receive(:options) do
         { environment: 'foo', app: 'web' }
       end
-      allow(service).to receive(:create_operation) { op }
       allow(Aptible::Api::Account).to receive(:all) { [] }
-      allow(account).to receive(:apps) { [apps] }
+      allow(service).to receive(:create_operation!) { op }
 
       expect do
         subject.send('apps:scale', 'web', 3)
@@ -79,19 +70,14 @@ describe Aptible::CLI::Agent do
     end
 
     it 'should fail if app is non-existent' do
-      allow(service).to receive(:create_operation) { op }
-      allow(Aptible::Api::Account).to receive(:all) { [account] }
-      allow(account).to receive(:apps) { [] }
-
       expect do
         subject.send('apps:scale', 'web', 3)
       end.to raise_error(Thor::Error)
     end
 
     it 'should fail if number is not a valid number' do
-      allow(service).to receive(:create_operation) { op }
       allow(subject).to receive(:options) { { app: 'hello' } }
-      allow(Aptible::Api::App).to receive(:all) { apps }
+      allow(service).to receive(:create_operation) { op }
 
       expect do
         subject.send('apps:scale', 'web', 'potato')
@@ -105,8 +91,7 @@ describe Aptible::CLI::Agent do
       expect(subject).to receive(:environment_from_handle)
         .with('foobar')
         .and_return(account)
-      expect(subject).to receive(:apps_from_handle).and_return(apps)
-      allow(Aptible::Api::App).to receive(:all) { apps }
+      expect(subject).to receive(:apps_from_handle).and_return([app])
 
       expect do
         subject.send('apps:scale', 'potato', 1)
@@ -114,18 +99,16 @@ describe Aptible::CLI::Agent do
     end
 
     context 'no service' do
-      let(:services) { [] }
+      before { app.services = [] }
 
       it 'should fail if the app has no services' do
-        expect(subject).to receive(:environment_from_handle)
-          .with('foobar')
-          .and_return(account)
-        expect(subject).to receive(:apps_from_handle).and_return(apps)
         allow(subject).to receive(:options) do
           { app: 'hello', environment: 'foobar' }
         end
-
-        allow(Aptible::Api::App).to receive(:all) { apps }
+        expect(subject).to receive(:environment_from_handle)
+          .with('foobar')
+          .and_return(account)
+        expect(subject).to receive(:apps_from_handle).and_return([app])
 
         expect do
           subject.send('apps:scale', 'web', 1)
@@ -133,4 +116,108 @@ describe Aptible::CLI::Agent do
       end
     end
   end
+
+  describe '#ensure_app' do
+    it 'fails if no usable strategy is found' do
+      strategies = [dummy_strategy_factory(nil, nil, false)]
+      subject.stub(:handle_strategies) { strategies }
+
+      expect { subject.ensure_app }.to raise_error(/Could not find app/)
+    end
+
+    it 'fails if an environment is specified but not found' do
+      strategies = [dummy_strategy_factory('hello', 'aptible', true)]
+      subject.stub(:handle_strategies) { strategies }
+
+      expect(subject).to receive(:environment_from_handle).and_return(nil)
+
+      expect { subject.ensure_app }.to raise_error(/Could not find environment/)
+    end
+
+    context 'with apps' do
+      let(:apps) { [app] }
+
+      before do
+        account.apps = apps
+        allow(Aptible::Api::App).to receive(:all).and_return(apps)
+      end
+
+      it 'scopes the app search to an environment if provided' do
+        strategies = [dummy_strategy_factory('hello', 'aptible', true)]
+        subject.stub(:handle_strategies) { strategies }
+
+        expect(subject).to receive(:environment_from_handle).with('aptible')
+          .and_return(account)
+
+        expect(subject.ensure_app).to eq(apps.first)
+      end
+
+      it 'does not scope the app search to an environment if not provided' do
+        strategies = [dummy_strategy_factory('hello', nil, true)]
+        subject.stub(:handle_strategies) { strategies }
+
+        expect(subject.ensure_app).to eq(apps.first)
+      end
+
+      it 'fails if no app is found' do
+        apps.pop
+
+        strategies = [dummy_strategy_factory('hello', nil, true)]
+        subject.stub(:handle_strategies) { strategies }
+
+        expect { subject.ensure_app }.to raise_error(/not find app hello/)
+      end
+
+      it 'explains the strategy when it fails' do
+        apps.pop
+
+        strategies = [dummy_strategy_factory('hello', nil, true)]
+        subject.stub(:handle_strategies) { strategies }
+
+        expect { subject.ensure_app }.to raise_error(/from dummy/)
+      end
+
+      it 'indicates the environment when the app search was scoped' do
+        apps.pop
+
+        strategies = [dummy_strategy_factory('hello', 'aptible', true)]
+        subject.stub(:handle_strategies) { strategies }
+
+        expect(subject).to receive(:environment_from_handle).with('aptible')
+          .and_return(account)
+
+        expect { subject.ensure_app }.to raise_error(/in environment aptible/)
+      end
+
+      it 'fails if multiple apps are found' do
+        apps << Fabricate(:app, handle: 'hello')
+
+        strategies = [dummy_strategy_factory('hello', nil, true)]
+        subject.stub(:handle_strategies) { strategies }
+
+        expect { subject.ensure_app }.to raise_error(/Multiple apps/)
+      end
+
+      it 'falls back to another strategy when the first one is unusable' do
+        strategies = [
+          dummy_strategy_factory('hello', nil, false),
+          dummy_strategy_factory('hello', nil, true)
+        ]
+        subject.stub(:handle_strategies) { strategies }
+
+        expect(subject.ensure_app).to eq(apps.first)
+      end
+
+      it 'passes options to the strategy' do
+        receiver = []
+        strategies = [dummy_strategy_factory('hello', nil, false, receiver)]
+        subject.stub(:handle_strategies) { strategies }
+
+        options = { app: 'foo', environment: 'bar' }
+        expect { subject.ensure_app options }.to raise_error(/not find app/)
+
+        expect(receiver).to eq([options])
+      end
+    end
+  end
 end

data/spec/aptible/cli/subcommands/backup_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe Aptible::CLI::Agent do
+  let(:token) { 'some-token' }
+  let(:account) { Fabricate(:account) }
+  let(:database) { Fabricate(:database, account: account, handle: 'some-db') }
+  let!(:backup) do
+    # created_at: 2016-06-14 13:24:11 +0000
+    Fabricate(:backup, database: database, created_at: Time.at(1465910651))
+  end
+
+  let(:messages) { [] }
+
+  before do
+    allow(subject).to receive(:fetch_token).and_return(token)
+    allow(subject).to receive(:say) { |m| messages << m }
+  end
+
+  describe '#backup:restore' do
+    it 'fails if the backup cannot be found' do
+      expect(Aptible::Api::Backup).to receive(:find).with(1, token: token)
+        .and_return(nil)
+
+      expect { subject.send('backup:restore', 1) }
+        .to raise_error('Backup #1 not found')
+    end
+
+    context 'successful restore' do
+      let(:op) { Fabricate(:operation, resource: backup) }
+
+      before do
+        expect(Aptible::Api::Backup).to receive(:find).with(1, token: token)
+          .and_return(backup)
+        expect(subject).to receive(:attach_to_operation_logs).with(op)
+      end
+
+      it 'provides a default handle and no disk size' do
+        h = 'some-db-at-2016-06-14-13-24-11'
+
+        expect(backup).to receive(:create_operation!) do |options|
+          expect(options[:handle]).to eq(h)
+          expect(options[:disk_size]).not_to be_present
+          op
+        end
+
+        subject.send('backup:restore', 1)
+        expect(messages).to eq(["Restoring backup into #{h}"])
+      end
+
+      it 'accepts a custom handle and disk size' do
+        h = 'some-handle'
+        s = 40
+
+        expect(backup).to receive(:create_operation!) do |options|
+          expect(options[:handle]).to eq(h)
+          expect(options[:disk_size]).to eq(s)
+          op
+        end
+
+        subject.options = { handle: h, size: s }
+        subject.send('backup:restore', 1)
+        expect(messages).to eq(["Restoring backup into #{h}"])
+      end
+    end
+  end
+
+  describe '#backup:list' do
+    before { allow(Aptible::Api::Account).to receive(:all) { [account] } }
+    before { allow(Aptible::Api::Database).to receive(:all) { [database] } }
+
+    before do
+      m = allow(database).to receive(:each_backup)
+
+      [
+        1.day, 2.days, 3.days, 4.days,
+        5.days, 2.weeks, 3.weeks, 1.month,
+        1.year
+      ].each do |age|
+        b = Fabricate(:backup, database: database, created_at: age.ago)
+        m.and_yield(b)
+      end
+    end
+
+    # The default value isn't set when we run sepcs
+    before { subject.options = { max_age: '1w' } }
+
+    it 'can show a subset of backups' do
+      subject.send('backup:list', database.handle)
+      expect(messages.size).to eq(5)
+    end
+
+    it 'allows scoping via environment' do
+      subject.options = { max_age: '1w', environment: database.account.handle }
+      subject.send('backup:list', database.handle)
+      expect(messages.size).to eq(5)
+    end
+
+    it 'shows more backups if requested' do
+      subject.options = { max_age: '2y' }
+      subject.send('backup:list', database.handle)
+      expect(messages.size).to eq(9)
+    end
+
+    it 'errors out if max_age is invalid' do
+      subject.options = { max_age: 'foobar' }
+      expect { subject.send('backup:list', database.handle) }
+        .to raise_error(Thor::Error, 'Invalid age: foobar')
+    end
+
+    it 'fails if the DB is not found' do
+      expect { subject.send('backup:list', 'nope') }
+        .to raise_error(Thor::Error, 'Could not find database nope')
+    end
+  end
+end

data/spec/aptible/cli/subcommands/db_spec.rb

@@ -1,12 +1,5 @@
-require 'ostruct'
 require 'spec_helper'
 
-class Database < OpenStruct
-end
-
-class Account < OpenStruct
-end
-
 class SocatHelperMock < OpenStruct
 end
 
@@ -15,33 +8,16 @@ describe Aptible::CLI::Agent do
   before { subject.stub(:save_token) }
   before { subject.stub(:fetch_token) { double 'token' } }
 
-  let(:account) do
-    Account.new(bastion_host: 'localhost',
-                dumptruck_port: 1234,
-                handle: 'aptible')
-  end
-  let(:database) do
-    Database.new(
-      type: 'postgresql',
-      handle: 'foobar',
-      passphrase: 'password',
-      connection_url: 'postgresql://aptible:password@10.252.1.125:49158/db',
-      account: account
-    )
-  end
-
-  let(:socat_helper) do
-    SocatHelperMock.new(
-      port: 4242
-    )
-  end
+  let(:handle) { 'foobar' }
+  let(:database) { Fabricate(:database, handle: handle) }
+  let(:socat_helper) { SocatHelperMock.new(port: 4242) }
 
   describe '#db:tunnel' do
     it 'should fail if database is non-existent' do
       allow(Aptible::Api::Database).to receive(:all) { [] }
       expect do
-        subject.send('db:tunnel', 'foobar')
-      end.to raise_error('Could not find database foobar')
+        subject.send('db:tunnel', handle)
+      end.to raise_error("Could not find database #{handle}")
     end
 
     it 'should print a message about how to connect' do
@@ -55,14 +31,28 @@ describe Aptible::CLI::Agent do
 
       # db:tunnel should also explain each component of the URL:
       expect(subject).to receive(:say).exactly(7).times
-      subject.send('db:tunnel', 'foobar')
+      subject.send('db:tunnel', handle)
     end
   end
 
   describe '#db:list' do
+    before do
+      staging = Fabricate(:account, handle: 'staging')
+      prod = Fabricate(:account, handle: 'production')
+
+      [[staging, 'staging-redis-db'], [staging, 'staging-postgres-db'],
+       [prod, 'prod-elsearch-db'], [prod, 'prod-postgres-db']].each do |a, h|
+        Fabricate(:database, account: a, handle: h)
+      end
+
+      token = 'the-token'
+      allow(subject).to receive(:fetch_token).and_return(token)
+      allow(Aptible::Api::Account).to receive(:all).with(token: token)
+        .and_return([staging, prod])
+    end
+
     context 'when no account is specified' do
       it 'prints out the grouped database handles for all accounts' do
-        setup_prod_and_staging_accounts
         allow(subject).to receive(:say)
 
         subject.send('db:list')
@@ -79,7 +69,6 @@ describe Aptible::CLI::Agent do
 
     context 'when a valid account is specified' do
       it 'prints out the database handles for the account' do
-        setup_prod_and_staging_accounts
         allow(subject).to receive(:say)
 
         subject.options = { environment: 'staging' }
@@ -97,7 +86,6 @@ describe Aptible::CLI::Agent do
 
     context 'when an invalid account is specified' do
       it 'prints out an error' do
-        setup_prod_and_staging_accounts
         allow(subject).to receive(:say)
 
         subject.options = { environment: 'foo' }
@@ -108,37 +96,23 @@ describe Aptible::CLI::Agent do
     end
   end
 
-  def setup_prod_and_staging_accounts
-    staging_redis = Database.new(handle: 'staging-redis-db')
-    staging_postgres = Database.new(handle: 'staging-postgres-db')
-    prod_elsearch = Database.new(handle: 'prod-elsearch-db')
-    prod_postgres = Database.new(handle: 'prod-postgres-db')
-
-    stub_local_token_with('the-token')
-    setup_new_accounts_with_dbs(
-      token: 'the-token',
-      account_db_mapping: {
-        'staging' => [staging_redis, staging_postgres],
-        'production' => [prod_elsearch, prod_postgres]
-      }
-    )
-  end
+  describe '#db:backup' do
+    before { allow(Aptible::Api::Account).to receive(:all) { [account] } }
+    before { allow(Aptible::Api::Database).to receive(:all) { [database] } }
 
-  def setup_new_accounts_with_dbs(options)
-    token = options.fetch(:token)
-    account_db_mapping = options.fetch(:account_db_mapping)
+    let(:op) { Fabricate(:operation) }
 
-    accounts_with_dbs = []
-    account_db_mapping.each do |account_handle, dbs|
-      account = Account.new(handle: account_handle, databases: dbs)
-      accounts_with_dbs << account
-    end
+    it 'allows creating a new backup' do
+      expect(database).to receive(:create_operation!).and_return(op)
+      expect(subject).to receive(:say).with('Backing up foobar...')
+      expect(subject).to receive(:attach_to_operation_logs).with(op)
 
-    allow(Aptible::Api::Account).to receive(:all).with(token: token)
-      .and_return(accounts_with_dbs)
-  end
+      subject.send('db:backup', handle)
+    end
 
-  def stub_local_token_with(token)
-    allow(subject).to receive(:fetch_token).and_return(token)
+    it 'fails if the DB is not found' do
+      expect { subject.send('db:backup', 'nope') }
+        .to raise_error(Thor::Error, 'Could not find database nope')
+    end
   end
 end