aptible-cli 0.26.4 → 0.26.6

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

@@ -20,13 +20,17 @@ describe Aptible::CLI::Agent do
   before do
     allow(subject).to receive(:save_token)
     allow(subject).to receive(:attach_to_operation_logs)
-    allow(subject).to receive(:fetch_token) { double 'token' }
+    allow(subject).to receive(:fetch_token) { token }
+    allow(Aptible::Api::Account).to receive(:find_by_url)
+      .with("/find/account?handle=#{account.handle}", token: token)
+      .and_return(account)
   end
 
   let!(:account) { Fabricate(:account) }
   let!(:app) { Fabricate(:app, handle: 'hello', account: account) }
   let!(:service) { Fabricate(:service, app: app, process_type: 'web') }
   let(:op) { Fabricate(:operation, status: 'succeeded', resource: app) }
+  let(:token) { double 'token' }
 
   describe '#apps' do
     it 'lists an app in an account' do
@@ -83,13 +87,14 @@ describe Aptible::CLI::Agent do
 
     it 'lists filters down to one account' do
       account2 = Fabricate(:account, handle: 'account2')
+      allow(Aptible::Api::Account).to receive(:find_by_url)
+        .with("/find/account?handle=#{account2.handle}", token: token)
+        .and_return(account2)
       app2 = Fabricate(:app, account: account2, handle: 'app2')
       allow(subject).to receive(:options)
         .and_return(environment: account2.handle)
       allow(Aptible::Api::App).to receive(:all).and_return([app2])
 
-      allow(Aptible::Api::Account).to receive(:all)
-        .and_return([account, account2])
       subject.send('apps')
 
       expect(captured_output_text)
@@ -215,8 +220,11 @@ describe Aptible::CLI::Agent do
 
   describe '#apps:rename' do
     before do
-      allow(Aptible::Api::App).to receive(:all) { [app] }
-      allow(Aptible::Api::Account).to receive(:all) { [account] }
+      allow(Aptible::Api::App).to receive(:find_by_url)
+        .and_return(nil)
+      allow(Aptible::Api::App).to receive(:find_by_url)
+        .with("/find/app?handle=#{app.handle}&environment=#{account.handle}", token: token)
+        .and_return(app)
     end
 
     before(:each) do
@@ -256,7 +264,6 @@ describe Aptible::CLI::Agent do
 
   describe '#apps:scale' do
     before do
-      allow(Aptible::Api::App).to receive(:all) { [app] }
       allow(Aptible::Api::Account).to receive(:all) { [account] }
     end
 
@@ -268,9 +275,9 @@ describe Aptible::CLI::Agent do
           .with('foobar')
           .and_return(account)
 
-        expect(subject).to receive(:apps_from_handle)
+        expect(subject).to receive(:app_from_handle)
           .with('hello', account)
-          .and_return([app])
+          .and_return(app)
       end
 
       def stub_options(**opts)
@@ -330,7 +337,7 @@ describe Aptible::CLI::Agent do
       allow(subject).to receive(:options) do
         { environment: 'foo', app: 'web', container_count: 2 }
       end
-      allow(Aptible::Api::Account).to receive(:all) { [] }
+      allow(Aptible::Api::Account).to receive(:find_by_url).and_return(nil)
       allow(service).to receive(:create_operation!) { op }
 
       expect do
@@ -394,7 +401,14 @@ describe Aptible::CLI::Agent do
 
       before do
         account.apps = apps
-        allow(Aptible::Api::App).to receive(:all).and_return(apps)
+        allow(Aptible::Api::App).to receive(:find_by_url)
+          .and_return(nil)
+        allow(Aptible::Api::App).to receive(:find_by_url)
+          .with("/find/app?handle=#{app.handle}&environment=#{account.handle}", token: token)
+          .and_return(app)
+        allow(Aptible::Api::App).to receive(:find_by_url)
+          .with("/find/app?handle=#{app.handle}", token: token)
+          .and_return(app)
       end
 
       it 'scopes the app search to an environment if provided' do
@@ -415,27 +429,21 @@ describe Aptible::CLI::Agent do
       end
 
       it 'fails if no app is found' do
-        apps.pop
-
-        strategies = [dummy_strategy_factory('hello', nil, true)]
+        strategies = [dummy_strategy_factory('goodbye', nil, true)]
         allow(subject).to receive(:handle_strategies) { strategies }
 
-        expect { subject.ensure_app }.to raise_error(/not find app hello/)
+        expect { subject.ensure_app }.to raise_error(/not find app goodbye/)
       end
 
       it 'explains the strategy when it fails' do
-        apps.pop
-
-        strategies = [dummy_strategy_factory('hello', nil, true)]
+        strategies = [dummy_strategy_factory('goodbye', nil, true)]
         allow(subject).to receive(: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)]
+        strategies = [dummy_strategy_factory('goodbye', 'aptible', true)]
         allow(subject).to receive(:handle_strategies) { strategies }
 
         expect(subject).to receive(:environment_from_handle).with('aptible')
@@ -445,7 +453,12 @@ describe Aptible::CLI::Agent do
       end
 
       it 'fails if multiple apps are found' do
-        apps << Fabricate(:app, handle: 'hello')
+        error = HyperResource::ClientError.new('multiple resources found')
+        allow(error).to receive(:body)
+          .and_return('error' => 'multiple_resources_found')
+        allow(Aptible::Api::App).to receive(:find_by_url)
+          .with('/find/app?handle=hello', token: token)
+          .and_raise(error)
 
         strategies = [dummy_strategy_factory('hello', nil, true)]
         allow(subject).to receive(:handle_strategies) { strategies }

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

@@ -13,7 +13,9 @@ describe Aptible::CLI::Agent do
 
   before do
     allow(subject).to receive(:fetch_token).and_return(token)
-    allow(Aptible::Api::Account).to receive(:all) { [account] }
+    allow(Aptible::Api::Account).to receive(:find_by_url)
+      .with("/find/account?handle=#{account.handle}", token: token)
+      .and_return(account)
   end
 
   describe '#backup_retention_policy' do

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

@@ -20,7 +20,24 @@ describe Aptible::CLI::Agent do
 
   before do
     allow(subject).to receive(:fetch_token).and_return(token)
-    allow(Aptible::Api::Account).to receive(:all) { [account, alt_account] }
+    allow(Aptible::Api::Account).to receive(:find_by_url)
+      .with("/find/account?handle=#{account.handle}", token: token)
+      .and_return(account)
+    allow(Aptible::Api::Account).to receive(:find_by_url)
+      .with("/find/account?handle=#{alt_account.handle}", token: token)
+      .and_return(alt_account)
+    allow(Aptible::Api::Database).to receive(:find_by_url)
+      .with("/find/database?handle=#{default_handle}", token: token)
+      .and_return(database)
+    allow(Aptible::Api::Database).to receive(:find_by_url)
+      .with("/find/database?handle=#{default_handle}&environment=#{account.handle}", token: token)
+      .and_return(database)
+    allow(Aptible::Api::Database).to receive(:find_by_url)
+      .with("/find/database?handle=#{database.handle}", token: token)
+      .and_return(database)
+    allow(Aptible::Api::Database).to receive(:find_by_url)
+      .with("/find/database?handle=#{database.handle}&environment=#{account.handle}", token: token)
+      .and_return(database)
   end
 
   describe '#backup:restore' do
@@ -60,6 +77,11 @@ describe Aptible::CLI::Agent do
 
       it 'accepts a handle' do
         h = 'some-handle'
+        restored = Fabricate(:database, account: account, handle: h)
+
+        allow(Aptible::Api::Database).to receive(:find_by_url)
+          .with("/find/database?handle=#{h}&environment=#{account.handle}", token: token)
+          .and_return(database)
 
         expect(backup).to receive(:create_operation!) do |options|
           expect(options[:handle]).to eq(h)
@@ -70,7 +92,7 @@ describe Aptible::CLI::Agent do
         end
 
         expect(subject).to receive(:attach_to_operation_logs).with(op) do
-          Fabricate(:database, account: account, handle: h)
+          restored
         end
 
         subject.options = { handle: h }
@@ -143,6 +165,9 @@ describe Aptible::CLI::Agent do
         end
 
         subject.options = { environment: 'alt' }
+        allow(Aptible::Api::Database).to receive(:find_by_url)
+          .with("/find/database?handle=#{default_handle}&environment=alt", token: token)
+          .and_return(database)
         subject.send('backup:restore', 1)
       end
     end
@@ -150,7 +175,6 @@ describe Aptible::CLI::Agent do
 
   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)
@@ -192,6 +216,7 @@ describe Aptible::CLI::Agent do
     end
 
     it 'fails if the DB is not found' do
+      allow(Aptible::Api::Database).to receive(:find_by_url).and_return(nil)
       expect { subject.send('backup:list', 'nope') }
         .to raise_error(Thor::Error, 'Could not find database nope')
     end

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

@@ -8,9 +8,9 @@ describe Aptible::CLI::Agent do
   before { allow(subject).to receive(:fetch_token).and_return(token) }
 
   before do
-    allow(Aptible::Api::App).to receive(:all)
-      .with(token: token, href: '/apps?per_page=5000&no_embed=true')
-      .and_return([app])
+    allow(Aptible::Api::App).to receive(:find_by_url)
+      .with("/find/app?handle=#{app.handle}", token: token)
+      .and_return(app)
     allow(Aptible::Api::Account).to receive(:all)
       .with(token: token, href: '/apps?per_page=5000&no_embed=true')
       .and_return([account])

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

@@ -13,11 +13,17 @@ describe Aptible::CLI::Agent do
     allow(Aptible::Api::DatabaseCredential).to receive(:all) do
       database.database_credentials
     end
+    allow(Aptible::Api::Database).to receive(:find_by_url)
+      .with("/find/database?handle=#{handle}", token: token)
+      .and_return(database)
+    allow(Aptible::Api::Database).to receive(:find_by_url)
+      .with("/find/database?handle=#{handle}&environment=#{account.handle}", token: token)
+      .and_return(database)
   end
 
   let(:handle) { 'foobar' }
   let(:stack) { Fabricate(:stack, internal_domain: 'aptible.in') }
-  let(:account) { Fabricate(:account, stack: stack) }
+  let(:account) { Fabricate(:account, stack: stack, handle: 'aptible') }
   let(:database) { Fabricate(:database, handle: handle, account: account) }
   let(:socat_helper) { SocatHelperMock.new(port: 4242) }
 
@@ -151,15 +157,15 @@ describe Aptible::CLI::Agent do
 
   describe '#db:tunnel' do
     it 'should fail if database is non-existent' do
-      allow(Aptible::Api::Database).to receive(:all) { [] }
+      allow(Aptible::Api::Database).to receive(:find_by_url)
+        .with("/find/database?handle=#{handle}", token: token)
+        .and_return(nil)
       expect do
         subject.send('db:tunnel', handle)
       end.to raise_error("Could not find database #{handle}")
     end
 
     context 'valid database' do
-      before { allow(Aptible::Api::Database).to receive(:all) { [database] } }
-
       it 'prints a message explaining how to connect' do
         cred = Fabricate(:database_credential, default: true, type: 'foo',
                                                database: database)
@@ -371,6 +377,9 @@ describe Aptible::CLI::Agent do
       allow(Aptible::Api::Account).to receive(:all)
         .with(token: token, href: '/accounts?per_page=5000&no_embed=true')
         .and_return([staging, prod])
+      allow(Aptible::Api::Account).to receive(:find_by_url)
+        .with("/find/account?handle=#{staging.handle}", token: token)
+        .and_return(staging)
       allow(Aptible::Api::ExternalAwsResource).to receive(:all)
         .with(token: token)
         .and_return([])
@@ -406,6 +415,7 @@ describe Aptible::CLI::Agent do
     end
 
     context 'when an invalid account is specified' do
+      before { allow(Aptible::Api::Account).to receive(:find_by_url).and_return(nil) }
       it 'prints out an error' do
         subject.options = { environment: 'foo' }
         expect { subject.send('db:list') }
@@ -544,6 +554,9 @@ describe Aptible::CLI::Agent do
       allow(Aptible::Api::Account).to receive(:all)
         .with(token: token, href: '/accounts?per_page=5000&no_embed=true')
         .and_return([staging, prod])
+      allow(Aptible::Api::Account).to receive(:find_by_url)
+        .with("/find/account?handle=#{staging.handle}", token: token)
+        .and_return(staging)
       allow(Aptible::Api::ExternalAwsResource).to receive(:all)
         .with(token: token)
         .and_return([staging_rds, prod_rds, unattached_rds])
@@ -627,7 +640,6 @@ describe Aptible::CLI::Agent do
 
   describe '#db:backup' do
     before { allow(Aptible::Api::Account).to receive(:all) { [account] } }
-    before { allow(Aptible::Api::Database).to receive(:all) { [database] } }
 
     let(:op) { Fabricate(:operation) }
 
@@ -642,6 +654,7 @@ describe Aptible::CLI::Agent do
     end
 
     it 'fails if the DB is not found' do
+      allow(Aptible::Api::Database).to receive(:find_by_url).and_return(nil)
       expect { subject.send('db:backup', 'nope') }
         .to raise_error(Thor::Error, 'Could not find database nope')
     end
@@ -649,7 +662,6 @@ describe Aptible::CLI::Agent do
 
   describe '#db:reload' do
     before { allow(Aptible::Api::Account).to receive(:all) { [account] } }
-    before { allow(Aptible::Api::Database).to receive(:all) { [database] } }
 
     let(:op) { Fabricate(:operation) }
 
@@ -664,6 +676,7 @@ describe Aptible::CLI::Agent do
     end
 
     it 'fails if the DB is not found' do
+      allow(Aptible::Api::Database).to receive(:find_by_url).and_return(nil)
       expect { subject.send('db:reload', 'nope') }
         .to raise_error(Thor::Error, 'Could not find database nope')
     end
@@ -671,7 +684,6 @@ describe Aptible::CLI::Agent do
 
   describe '#db:restart' do
     before { allow(Aptible::Api::Account).to receive(:all) { [account] } }
-    before { allow(Aptible::Api::Database).to receive(:all) { [database] } }
 
     let(:op) { Fabricate(:operation) }
 
@@ -736,6 +748,7 @@ describe Aptible::CLI::Agent do
     end
 
     it 'fails if the DB is not found' do
+      allow(Aptible::Api::Database).to receive(:find_by_url).and_return(nil)
       expect { subject.send('db:restart', 'nope') }
         .to raise_error(Thor::Error, 'Could not find database nope')
     end
@@ -743,7 +756,6 @@ describe Aptible::CLI::Agent do
 
   describe '#db:modify' do
     before { allow(Aptible::Api::Account).to receive(:all) { [account] } }
-    before { allow(Aptible::Api::Database).to receive(:all) { [database] } }
 
     let(:op) { Fabricate(:operation) }
 
@@ -783,16 +795,15 @@ describe Aptible::CLI::Agent do
     end
 
     it 'fails if the DB is not found' do
+      allow(Aptible::Api::Database).to receive(:find_by_url).and_return(nil)
       expect { subject.send('db:modify', 'nope') }
         .to raise_error(Thor::Error, 'Could not find database nope')
     end
   end
 
   describe '#db:url' do
-    let(:databases) { [database] }
-    before { expect(Aptible::Api::Database).to receive(:all) { databases } }
-
     it 'fails if the DB is not found' do
+      allow(Aptible::Api::Database).to receive(:find_by_url).and_return(nil)
       expect { subject.send('db:url', 'nope') }
         .to raise_error(Thor::Error, 'Could not find database nope')
     end
@@ -808,7 +819,12 @@ describe Aptible::CLI::Agent do
       end
 
       it 'fails if multiple DBs are found' do
-        databases << database
+        error = HyperResource::ClientError.new('multiple resources found')
+        allow(error).to receive(:body)
+          .and_return('error' => 'multiple_resources_found')
+        allow(Aptible::Api::Database).to receive(:find_by_url)
+          .with("/find/database?handle=#{handle}", token: token)
+          .and_raise(error)
 
         expect { subject.send('db:url', handle) }
           .to raise_error(/Multiple databases/)
@@ -817,16 +833,18 @@ describe Aptible::CLI::Agent do
   end
 
   describe '#db:replicate' do
-    let(:databases) { [] }
-    before { allow(Aptible::Api::Database).to receive(:all) { databases } }
+    let(:master) { Fabricate(:database, handle: 'master') }
+    let(:replica) { Fabricate(:database, account: master.account, handle: 'replica') }
+    before do
+      allow(Aptible::Api::Database).to receive(:find_by_url)
+        .with("/find/database?handle=#{master.handle}", token: token)
+        .and_return(master)
+      allow(Aptible::Api::Database).to receive(:find_by_url)
+        .with("/find/database?handle=#{replica.handle}&environment=#{account.handle}", token: token)
+        .and_return(replica)
+    end
 
     def expect_replicate_database(opts = {})
-      master = Fabricate(:database, handle: 'master')
-      databases << master
-      replica = Fabricate(:database,
-                          account: master.account,
-                          handle: 'replica')
-
       op = Fabricate(:operation)
 
       params = { type: 'replicate', handle: 'replica' }.merge(opts)
@@ -835,7 +853,6 @@ describe Aptible::CLI::Agent do
         .with(**params).and_return(op)
 
       expect(subject).to receive(:attach_to_operation_logs).with(op) do
-        databases << replica
         replica
       end
 
@@ -867,17 +884,12 @@ describe Aptible::CLI::Agent do
     end
 
     it 'fails if the DB is not found' do
+      allow(Aptible::Api::Database).to receive(:find_by_url).and_return(nil)
       expect { subject.send('db:replicate', 'nope', 'replica') }
         .to raise_error(Thor::Error, 'Could not find database nope')
     end
 
     it 'allows logical replication of a database with --version set' do
-      master = Fabricate(:database, handle: 'master')
-      databases << master
-      replica = Fabricate(:database,
-                          account: master.account,
-                          handle: 'replica')
-
       dbimg = Fabricate(:database_image,
                         type: 'postgresql',
                         version: 10,
@@ -894,7 +906,6 @@ describe Aptible::CLI::Agent do
         .with(**params).and_return(op)
 
       expect(subject).to receive(:attach_to_operation_logs).with(op) do
-        databases << replica
         replica
       end
 
@@ -914,9 +925,6 @@ describe Aptible::CLI::Agent do
     end
 
     it 'fails if logical replication requested without --version' do
-      master = Fabricate(:database, handle: 'master', type: 'postgresql')
-      databases << master
-
       subject.options = { type: 'replicate', handle: 'replica', logical: true }
       expect { subject.send('db:replicate', 'master', 'replica') }
         .to raise_error(Thor::Error, '--version is required for logical ' \
@@ -924,9 +932,7 @@ describe Aptible::CLI::Agent do
     end
 
     it 'fails if logical replication requested for non-postgres db' do
-      master = Fabricate(:database, handle: 'master', type: 'mysql')
-      databases << master
-
+      master.type = 'mysql'
       subject.options = { type: 'replicate', handle: 'replica',
                           logical: true, version: 10 }
       expect { subject.send('db:replicate', 'master', 'replica') }
@@ -937,17 +943,13 @@ describe Aptible::CLI::Agent do
 
   describe '#db:dump' do
     it 'should fail if database is non-existent' do
-      allow(Aptible::Api::Database).to receive(:all) { [] }
+      allow(Aptible::Api::Database).to receive(:find_by_url).and_return(nil)
       expect do
         subject.send('db:dump', handle)
       end.to raise_error("Could not find database #{handle}")
     end
 
     context 'valid database' do
-      before do
-        allow(Aptible::Api::Database).to receive(:all) { [database] }
-      end
-
       it 'exits with the same code as pg_dump' do
         exit_status = 123
         cred = Fabricate(:database_credential, default: true, type: 'foo',
@@ -1132,7 +1134,7 @@ describe Aptible::CLI::Agent do
   describe '#db:execute' do
     sql_path = 'file.sql'
     it 'should fail if database is non-existent' do
-      allow(Aptible::Api::Database).to receive(:all) { [] }
+      allow(Aptible::Api::Database).to receive(:find_by_url).and_return(nil)
       expect do
         subject.send('db:execute', handle, sql_path)
       end.to raise_error("Could not find database #{handle}")
@@ -1140,7 +1142,6 @@ describe Aptible::CLI::Agent do
 
     context 'valid database' do
       before do
-        allow(Aptible::Api::Database).to receive(:all) { [database] }
         allow(subject).to receive(:`).with(/psql .*/) { `exit 0` }
       end
 
@@ -1338,8 +1339,6 @@ describe Aptible::CLI::Agent do
   end
 
   describe '#db:deprovision' do
-    before { expect(Aptible::Api::Database).to receive(:all) { [database] } }
-
     let(:operation) { Fabricate(:operation, resource: database) }
 
     it 'deprovisions a database' do
@@ -1409,7 +1408,9 @@ describe Aptible::CLI::Agent do
     before do
       allow(subject).to receive(:options)
         .and_return(environment: account.handle)
-      allow(Aptible::Api::Account).to receive(:all) { [account] }
+      allow(Aptible::Api::Account).to receive(:find_by_url)
+        .with("/find/account?handle=#{account.handle}", token: token)
+        .and_return(account)
     end
     context 'with environment and db' do
       it 'should rename properly' do
@@ -1422,6 +1423,7 @@ describe Aptible::CLI::Agent do
         )
       end
       it 'should fail if db does not exist' do
+        allow(Aptible::Api::Database).to receive(:find_by_url).and_return(nil)
         expect { subject.send('db:rename', 'foo2', 'foo3') }
           .to raise_error(/Could not find database foo2/)
       end

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

@@ -4,12 +4,17 @@ describe Aptible::CLI::Agent do
   let!(:account) { Fabricate(:account, handle: 'foobar') }
   let!(:app) { Fabricate(:app, handle: 'hello', account: account) }
   let(:operation) { Fabricate(:operation) }
+  let(:token) { double 'token' }
 
   describe '#deploy' do
     before do
-      allow(Aptible::Api::App).to receive(:all) { [app] }
-      allow(Aptible::Api::Account).to receive(:all) { [account] }
-      allow(subject).to receive(:fetch_token) { double'token' }
+      allow(Aptible::Api::App).to receive(:find_by_url)
+        .with("/find/app?handle=#{app.handle}&environment=#{account.handle}", token: token)
+        .and_return(app)
+      allow(subject).to receive(:fetch_token) { token }
+      allow(Aptible::Api::Account).to receive(:find_by_url)
+        .with("/find/account?handle=#{account.handle}", token: token)
+        .and_return(account)
     end
 
     context 'with app' do