aptible-cli 0.26.2 → 0.26.5

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,15 +8,18 @@ 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])
   end
 
   before { allow(subject).to receive(:options) { { app: app.handle } } }
+  before do
+    allow(subject).to receive(:current_configuration, &:current_configuration)
+  end
   let(:operation) { Fabricate(:operation, resource: app) }
 
   describe '#config' do
@@ -60,6 +63,11 @@ describe Aptible::CLI::Agent do
   end
 
   describe '#config:get' do
+    it 'shows nothing for an unconfigured app' do
+      subject.send('config:get', 'FOO')
+      expect(captured_output_text).to eq('')
+    end
+
     it 'should show single environment variable specified' do
       app.current_configuration = Fabricate(
         :configuration, app: app, env: { 'FOO' => 'BAR', 'QUX' => 'two words' }

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

@@ -10,11 +10,20 @@ describe Aptible::CLI::Agent do
     allow(subject).to receive(:ask)
     allow(subject).to receive(:save_token)
     allow(subject).to receive(:fetch_token) { token }
+    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) }
 
@@ -148,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)
@@ -226,41 +235,6 @@ describe Aptible::CLI::Agent do
         expect { subject.send('db:tunnel', handle) }
           .to raise_error(/foobar is not provisioned/im)
       end
-
-      context 'v1 stack' do
-        before do
-          allow(database.account.stack).to receive(:version) { 'v1' }
-        end
-
-        it 'falls back to the database itself if no type is given' do
-          expect(subject).to receive(:with_local_tunnel).with(database, 0)
-          subject.send('db:tunnel', handle)
-        end
-
-        it 'falls back to the database itself if type matches' do
-          subject.options = { type: 'bar' }
-          allow(database).to receive(:type) { 'bar' }
-
-          expect(subject).to receive(:with_local_tunnel).with(database, 0)
-          subject.send('db:tunnel', handle)
-        end
-
-        it 'does not fall back to the database itself if type mismatches' do
-          subject.options = { type: 'bar' }
-          allow(database).to receive(:type) { 'foo' }
-
-          expect { subject.send('db:tunnel', handle) }
-            .to raise_error(/no credential with type bar/im)
-        end
-
-        it 'does not suggest other types that do not exist' do
-          expect(subject).to receive(:with_local_tunnel).with(database, 0)
-
-          subject.send('db:tunnel', handle)
-
-          expect(captured_logs).not_to match(/use --type type/i)
-        end
-      end
     end
   end
 
@@ -403,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([])
@@ -438,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') }
@@ -576,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])
@@ -659,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) }
 
@@ -674,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
@@ -681,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) }
 
@@ -696,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
@@ -703,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) }
 
@@ -768,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
@@ -775,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) }
 
@@ -815,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
@@ -840,41 +819,32 @@ 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/)
       end
-
-      context 'v1 stack' do
-        before do
-          allow(database.account.stack).to receive(:version) { 'v1' }
-        end
-
-        it 'returns the URL of a specified DB' do
-          connection_url = 'postgresql://aptible-v1:password@lega.cy:4242/db'
-          expect(database).to receive(:connection_url)
-            .and_return(connection_url)
-
-          subject.send('db:url', handle)
-
-          expect(captured_output_text.chomp).to eq(connection_url)
-        end
-      end
     end
   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)
@@ -883,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
 
@@ -915,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,
@@ -942,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
 
@@ -962,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 ' \
@@ -972,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') }
@@ -985,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',
@@ -1180,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}")
@@ -1188,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
 
@@ -1386,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
@@ -1457,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
@@ -1470,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

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

@@ -12,6 +12,9 @@ describe Aptible::CLI::Agent do
       .to receive(:all)
       .with(token: token, href: '/accounts?per_page=5000&no_embed=true')
       .and_return([a1, a2])
+    allow(Aptible::Api::Account).to receive(:find_by_url)
+      .with("/find/account?handle=#{a2.handle}", token: token)
+      .and_return(a2)
   end
 
   def expect_create_certificate(account, options)
@@ -67,10 +70,12 @@ describe Aptible::CLI::Agent do
     end
 
     before do
-      allow(Aptible::Api::Database)
-        .to receive(:all)
-        .with(token: token, href: '/databases?per_page=5000&no_embed=true')
-        .and_return([db, incomplete])
+      allow(Aptible::Api::Database).to receive(:find_by_url)
+        .with("/find/database?handle=#{incomplete.handle}", token: token)
+        .and_return(incomplete)
+      allow(Aptible::Api::Database).to receive(:find_by_url)
+        .with("/find/database?handle=#{db.handle}", token: token)
+        .and_return(db)
       allow(db).to receive(:class).and_return(Aptible::Api::Database)
       allow(incomplete).to receive(:class).and_return(Aptible::Api::Database)
       stub_options
@@ -78,6 +83,7 @@ describe Aptible::CLI::Agent do
 
     describe 'endpoints:database:create' do
       it 'fails if the DB does not exist' do
+        allow(Aptible::Api::Database).to receive(:find_by_url).and_return(nil)
         expect { subject.send('endpoints:database:create', 'some') }
           .to raise_error(/could not find database some/im)
       end
@@ -90,6 +96,9 @@ describe Aptible::CLI::Agent do
 
       it 'fails if the DB is not in the account' do
         stub_options(environment: 'bar')
+        expect(Aptible::Api::Database).to receive(:find_by_url)
+          .with("/find/database?handle=#{db.handle}&environment=bar", token: token)
+          .and_return(nil)
         expect { subject.send('endpoints:database:create', 'mydb') }
           .to raise_error(/could not find database mydb/im)
       end
@@ -223,6 +232,13 @@ describe Aptible::CLI::Agent do
         .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)
+        .and_return(nil)
+      allow(Aptible::Api::App).to receive(:find_by_url)
+        .with("/find/app?handle=#{app.handle}", token: token)
+        .and_return(app)
+
       allow(app).to receive(:class).and_return(Aptible::Api::App)
       stub_options
     end

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

@@ -16,6 +16,9 @@ describe Aptible::CLI::Agent do
       .to receive(:all)
       .with(token: token, href: '/accounts?per_page=5000&no_embed=true')
       .and_return([a1, a2])
+    allow(Aptible::Api::Account).to receive(:find_by_url)
+      .with("/find/account?handle=#{a1.handle}", token: token)
+      .and_return(a1)
   end
 
   describe('#environment:list') do
@@ -123,6 +126,7 @@ describe Aptible::CLI::Agent do
       )
     end
     it 'should fail if env does not exist' do
+      allow(Aptible::Api::Account).to receive(:find_by_url).and_return(nil)
       expect { subject.send('environment:rename', 'foo1', 'foo2') }
         .to raise_error(/Could not find environment foo1/)
     end

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

@@ -14,9 +14,19 @@ describe Aptible::CLI::Agent do
       .with(token: token, href: '/log_drains?per_page=5000')
       .and_return([log_drain])
 
+    allow(Aptible::Api::LogDrain).to receive(:all)
+      .with(token: token, href: "/accounts/#{account.id}/log_drains")
+      .and_return([log_drain])
+
     allow(Aptible::Api::Account).to receive(:all)
       .with(token: token, href: '/accounts?per_page=5000&no_embed=true')
       .and_return([account])
+
+    allow(Aptible::Api::Account).to receive(:find_by_url)
+      .with("/find/account?handle=#{account.handle}", token: token)
+      .and_return(account)
+
+    allow(account).to receive(:reload).and_return(account)
   end
 
   describe '#log_drain:list' do
@@ -81,6 +91,11 @@ describe Aptible::CLI::Agent do
 
     context 'elasticsearch' do
       let(:db) { Fabricate(:database, account: account, id: 5) }
+      before do
+        allow(Aptible::Api::Database).to receive(:find_by_url)
+          .with("/find/database?handle=#{db.handle}&environment=#{db.account.handle}", token: token)
+          .and_return(db)
+      end
 
       it 'creates a new Elasticsearch log drain' do
         opts = {

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

@@ -4,18 +4,23 @@ describe Aptible::CLI::Agent do
   before do
     allow(subject).to receive(:ask)
     allow(subject).to receive(:save_token)
-    allow(subject).to receive(:fetch_token) { 'some token' }
+    allow(subject).to receive(:fetch_token) { token }
   end
 
+  let(:token) { 'some token' }
   let(:app) { Fabricate(:app, handle: 'foo') }
   let(:database) { Fabricate(:database, handle: 'bar', status: 'provisioned') }
   let(:service) { Fabricate(:service, app: app) }
 
   describe '#logs' do
-    before { allow(Aptible::Api::Account).to receive(:all) { [app.account] } }
+    before do
+      allow(Aptible::Api::Account).to receive(:all) { [app.account] }
+      allow(Aptible::Api::App).to receive(:find_by_url)
+        .with("/find/app?handle=#{app.handle}", token: 'some token')
+        .and_return(app)
+    end
 
     context 'App resource' do
-      before { allow(Aptible::Api::App).to receive(:all) { [app] } }
       before { subject.options = { app: app.handle } }
 
       it 'should fail if the app is unprovisioned' do
@@ -35,7 +40,14 @@ describe Aptible::CLI::Agent do
     end
 
     context 'Database resource' do
-      before { allow(Aptible::Api::Database).to receive(:all) { [database] } }
+      before do
+        allow(Aptible::Api::Database).to receive(:find_by_url)
+          .with("/find/database?handle=#{database.handle}&environment=#{database.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)
+      end
       before { subject.options = { database: database.handle } }
 
       it 'should fail if the database is unprovisioned' do

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

@@ -9,6 +9,9 @@ describe Aptible::CLI::Agent do
     allow(subject).to receive(:ask)
     allow(subject).to receive(:save_token)
     allow(subject).to receive(:fetch_token) { token }
+    allow(Aptible::Api::Account).to receive(:find_by_url)
+      .with("/find/account?handle=#{staging.handle}", token: token)
+      .and_return(staging)
   end
 
   let(:handle) { 'foobar' }
@@ -52,7 +55,6 @@ describe Aptible::CLI::Agent do
 
   describe '#maintenance:dbs' do
     before do
-      token = 'the-token'
       allow(subject).to receive(:fetch_token) { token }
       allow(Aptible::Api::Account).to receive(:all)
         .with(token: token, href: '/accounts?per_page=5000&no_embed=true')
@@ -112,6 +114,8 @@ 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('maintenance:dbs') }
@@ -121,7 +125,6 @@ describe Aptible::CLI::Agent do
   end
   describe '#maintenance:apps' do
     before do
-      token = 'the-token'
       allow(subject).to receive(:fetch_token) { token }
       allow(Aptible::Api::Account).to receive(:all)
         .with(token: token, href: '/accounts?per_page=5000&no_embed=true')
@@ -180,6 +183,8 @@ 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('maintenance:apps') }