aptible-cli 0.14.1 → 0.15.0

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

@@ -18,7 +18,6 @@ end
 
 describe Aptible::CLI::Agent do
   before do
-    allow(subject).to receive(:ask)
     allow(subject).to receive(:save_token)
     allow(subject).to receive(:attach_to_operation_logs)
     allow(subject).to receive(:fetch_token) { double 'token' }
@@ -29,6 +28,135 @@ describe Aptible::CLI::Agent do
   let!(:service) { Fabricate(:service, app: app, process_type: 'web') }
   let(:op) { Fabricate(:operation, status: 'succeeded', resource: app) }
 
+  describe '#apps' do
+    it 'lists an app in an account' do
+      allow(Aptible::Api::Account).to receive(:all).and_return([account])
+      subject.send('apps')
+
+      expect(captured_output_text)
+        .to eq("=== #{account.handle}\n#{app.handle}\n")
+    end
+
+    it 'lists multiple apps in an account' do
+      allow(Aptible::Api::Account).to receive(:all).and_return([account])
+      app2 = Fabricate(:app, handle: 'foobar', account: account)
+      subject.send('apps')
+
+      expect(captured_output_text)
+        .to eq("=== #{account.handle}\n#{app.handle}\n#{app2.handle}\n")
+    end
+
+    it 'lists multiple apps, grouped by account in text output' do
+      account1 = Fabricate(:account, handle: 'Aaccount1')
+      app11 = Fabricate(:app, account: account1, handle: 'app11')
+
+      account2 = Fabricate(:account, handle: 'Baccount2')
+      app21 = Fabricate(:app, account: account2, handle: 'app21')
+      app22 = Fabricate(:app, account: account2, handle: 'app21')
+
+      allow(Aptible::Api::Account).to receive(:all)
+        .and_return([account1, account2])
+
+      subject.send('apps')
+
+      expected_text = [
+        "=== #{account1.handle}",
+        app11.handle,
+        '',
+        "=== #{account2.handle}",
+        app21.handle,
+        app22.handle,
+        ''
+      ].join("\n")
+
+      expect(captured_output_text).to eq(expected_text)
+    end
+
+    it 'lists filters down to one account' do
+      account2 = Fabricate(:account, handle: 'account2')
+      app2 = Fabricate(:app, account: account2, handle: 'app2')
+      allow(subject).to receive(:options)
+        .and_return(environment: account2.handle)
+
+      allow(Aptible::Api::Account).to receive(:all)
+        .and_return([account, account2])
+      subject.send('apps')
+
+      expect(captured_output_text)
+        .to eq("=== #{account2.handle}\n#{app2.handle}\n")
+    end
+
+    it 'includes services in JSON' do
+      account = Fabricate(:account, handle: 'account')
+      app = Fabricate(:app, account: account, handle: 'app')
+      allow(Aptible::Api::Account).to receive(:all).and_return([account])
+
+      s1 = Fabricate(
+        :service,
+        app: app, process_type: 's1', command: 'true', container_count: 2
+      )
+      s2 = Fabricate(
+        :service,
+        app: app, process_type: 's2', container_memory_limit_mb: 2048
+      )
+
+      expected_json = [
+        {
+          'environment' => {
+            'id' => account.id,
+            'handle' => account.handle
+          },
+          'handle' => app.handle,
+          'id' => app.id,
+          'status' => app.status,
+          'git_remote' => app.git_repo,
+          'services' => [
+            {
+              'service' => s1.process_type,
+              'id' => s1.id,
+              'command' => s1.command,
+              'container_count' => s1.container_count,
+              'container_size' => s1.container_memory_limit_mb
+            },
+            {
+              'service' => s2.process_type,
+              'id' => s2.id,
+              'command' => 'CMD',
+              'container_count' => s2.container_count,
+              'container_size' => s2.container_memory_limit_mb
+            }
+          ]
+        }
+      ]
+
+      subject.send('apps')
+
+      expect(captured_output_json).to eq(expected_json)
+    end
+  end
+
+  describe '#apps:create' do
+    before do
+      allow(Aptible::Api::Account).to receive(:all) { [account] }
+    end
+
+    it 'creates an app' do
+      expect(account).to receive(:create_app)
+        .with(handle: 'foo').and_return(app)
+
+      subject.send('apps:create', 'foo')
+    end
+
+    it 're-raises errors' do
+      app.errors.full_messages << 'oops'
+      expect(account).to receive(:create_app)
+        .with(handle: 'foo').and_return(app)
+
+      expect { subject.send('apps:create', 'foo') }
+        .to raise_error(Thor::Error, /oops/i)
+    end
+  end
+
   describe '#apps:scale' do
     before do
       allow(Aptible::Api::App).to receive(:all) { [app] }
@@ -54,29 +182,29 @@ describe Aptible::CLI::Agent do
 
       it 'should scale container size and count together' do
         stub_options(container_count: 3, container_size: 1024)
-        expect($stderr).not_to receive(:puts)
         expect(service).to receive(:create_operation!)
           .with(type: 'scale', container_count: 3, container_size: 1024)
           .and_return(op)
         subject.send('apps:scale', 'web')
+        expect(captured_logs).not_to match(/deprecated/i)
       end
 
       it 'should scale container count alone' do
         stub_options(container_count: 3)
-        expect($stderr).not_to receive(:puts)
         expect(service).to receive(:create_operation!)
           .with(type: 'scale', container_count: 3)
           .and_return(op)
         subject.send('apps:scale', 'web')
+        expect(captured_logs).not_to match(/deprecated/i)
       end
 
       it 'should scale container size alone' do
         stub_options(container_size: 1024)
-        expect($stderr).not_to receive(:puts)
         expect(service).to receive(:create_operation!)
           .with(type: 'scale', container_size: 1024)
           .and_return(op)
         subject.send('apps:scale', 'web')
+        expect(captured_logs).not_to match(/deprecated/i)
       end
 
       it 'should fail if neither container_count nor container_size is set' do
@@ -87,20 +215,20 @@ describe Aptible::CLI::Agent do
 
       it 'should scale container count (legacy)' do
         stub_options
-        expect($stderr).to receive(:puts).once
         expect(service).to receive(:create_operation!)
           .with(type: 'scale', container_count: 3)
           .and_return(op)
         subject.send('apps:scale', 'web', '3')
+        expect(captured_logs).to match(/deprecated/i)
       end
 
       it 'should scale container size (legacy)' do
         stub_options(size: 90210)
-        expect($stderr).to receive(:puts).once
         expect(service).to receive(:create_operation!)
           .with(type: 'scale', container_size: 90210)
           .and_return(op)
         subject.send('apps:scale', 'web')
+        expect(captured_logs).to match(/deprecated/i)
       end
 
       it 'should fail when using both current and legacy count' do
@@ -157,41 +285,29 @@ describe Aptible::CLI::Agent do
     end
 
     it 'should fail if number is not a valid number (legacy)' do
-      expect($stderr).to receive(:puts).once
       allow(subject).to receive(:options) { { app: 'hello' } }
       allow(service).to receive(:create_operation) { op }
 
       expect do
         subject.send('apps:scale', 'web', 'potato')
       end.to raise_error(ArgumentError)
-    end
-  end
 
-  describe '#config:set' do
-    before do
-      allow(Aptible::Api::App).to receive(:all) { [app] }
-      allow(Aptible::Api::Account).to receive(:all) { [account] }
+      expect(captured_logs).to match(/deprecated/i)
     end
+  end
 
-    it 'should reject environment variables that start with -' do
-      allow(subject).to receive(:options) { { app: 'hello' } }
+  describe '#apps:deprovision' do
+    let(:operation) { Fabricate(:operation, resource: app) }
 
-      expect { subject.send('config:set', '-foo=bar') }
-        .to raise_error(/invalid argument/im)
-    end
-  end
+    before { allow(subject).to receive(:ensure_app).and_return(app) }
 
-  describe '#config:rm' do
-    before do
-      allow(Aptible::Api::App).to receive(:all) { [app] }
-      allow(Aptible::Api::Account).to receive(:all) { [account] }
-    end
+    it 'deprovisions an app' do
+      expect(app).to receive(:create_operation!)
+        .with(type: 'deprovision').and_return(operation)
 
-    it 'should reject environment variables that start with -' do
-      allow(subject).to receive(:options) { { app: 'hello' } }
+      expect(subject).not_to receive(:attach_to_operation_logs)
 
-      expect { subject.send('config:rm', '-foo') }
-        .to raise_error(/invalid argument/im)
+      subject.send('apps:deprovision')
     end
   end
 

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

@@ -7,21 +7,23 @@ describe Aptible::CLI::Agent do
   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))
+    Fabricate(
+      :backup,
+      database: database, created_at: Time.at(1465910651), account: account
+    )
   end
 
-  let(:messages) { [] }
+  let(:default_handle) { 'some-db-at-2016-06-14-13-24-11' }
 
   before do
     allow(subject).to receive(:fetch_token).and_return(token)
-    allow(subject).to receive(:say) { |m| messages << m }
     allow(Aptible::Api::Account).to receive(:all) { [account, alt_account] }
   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(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')
@@ -31,23 +33,26 @@ describe Aptible::CLI::Agent 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)
+        expect(Aptible::Api::Backup).to receive(:find)
+          .with(1, token: token).and_return(backup)
       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[:handle]).to eq(default_handle)
           expect(options[:disk_size]).not_to be_present
           expect(options[:destination_account]).not_to be_present
           op
         end
 
+        expect(subject).to receive(:attach_to_operation_logs).with(op) do
+          Fabricate(:database, account: account, handle: default_handle)
+        end
+
         subject.send('backup:restore', 1)
-        expect(messages).to eq(["Restoring backup into #{h}"])
+
+        expect(captured_logs)
+          .to match(/restoring backup into #{default_handle}/im)
       end
 
       it 'accepts a handle' do
@@ -61,9 +66,13 @@ describe Aptible::CLI::Agent do
           op
         end
 
+        expect(subject).to receive(:attach_to_operation_logs).with(op) do
+          Fabricate(:database, account: account, handle: h)
+        end
+
         subject.options = { handle: h }
         subject.send('backup:restore', 1)
-        expect(messages).to eq(["Restoring backup into #{h}"])
+        expect(captured_logs).to match(/restoring backup into #{h}/im)
       end
 
       it 'accepts a container size' do
@@ -77,6 +86,10 @@ describe Aptible::CLI::Agent do
           op
         end
 
+        expect(subject).to receive(:attach_to_operation_logs).with(op) do
+          Fabricate(:database, account: account, handle: default_handle)
+        end
+
         subject.options = { container_size: s }
         subject.send('backup:restore', 1)
       end
@@ -92,6 +105,10 @@ describe Aptible::CLI::Agent do
           op
         end
 
+        expect(subject).to receive(:attach_to_operation_logs).with(op) do
+          Fabricate(:database, account: account, handle: default_handle)
+        end
+
         subject.options = { size: s }
         subject.send('backup:restore', 1)
       end
@@ -103,6 +120,10 @@ describe Aptible::CLI::Agent do
           op
         end
 
+        expect(subject).to receive(:attach_to_operation_logs).with(op) do
+          Fabricate(:database, account: alt_account, handle: default_handle)
+        end
+
         subject.options = { environment: 'alt' }
         subject.send('backup:restore', 1)
       end
@@ -131,19 +152,19 @@ describe Aptible::CLI::Agent do
 
     it 'can show a subset of backups' do
       subject.send('backup:list', database.handle)
-      expect(messages.size).to eq(5)
+      expect(captured_output_text.split("\n").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)
+      expect(captured_output_text.split("\n").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)
+      expect(captured_output_text.split("\n").size).to eq(9)
     end
 
     it 'errors out if max_age is invalid' do

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

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Aptible::CLI::Agent do
+  let(:account) { Fabricate(:account) }
+  let(:app) { Fabricate(:app, account: account) }
+
+  let(:token) { double('token') }
+  before { allow(subject).to receive(:fetch_token).and_return(token) }
+
+  before do
+    allow(Aptible::Api::App).to receive(:all)
+      .with(token: token).and_return([app])
+    allow(Aptible::Api::Account).to receive(:all)
+      .with(token: token).and_return([account])
+  end
+
+  before { allow(subject).to receive(:options) { { app: app.handle } } }
+  let(:operation) { Fabricate(:operation, resource: app) }
+
+  describe '#config' do
+    before { allow(subject).to receive(:options).and_return(app: app.handle) }
+
+    it 'shows nothing for an unconfigured app' do
+      subject.send('config')
+      expect(captured_output_text).to eq('')
+      expect(captured_output_json).to match_array([])
+    end
+
+    it 'shows an empty configuration' do
+      app.current_configuration = Fabricate(:configuration, app: app)
+      subject.send('config')
+      expect(captured_output_text).to eq('')
+      expect(captured_output_json).to match_array([])
+    end
+
+    it 'should show environment variables' do
+      app.current_configuration = Fabricate(
+        :configuration, app: app, env: { 'FOO' => 'BAR', 'QUX' => 'two words' }
+      )
+      subject.send('config')
+
+      expect(captured_output_text).to match(/FOO=BAR/)
+      expect(captured_output_text).to match(/QUX=two\\ words/)
+
+      expected = [
+        {
+          'key' => 'FOO', 'value' => 'BAR',
+          'shell_export' => 'FOO=BAR'
+        },
+        {
+          'key' => 'QUX', 'value' => 'two words',
+          'shell_export' => 'QUX=two\\ words'
+        }
+      ]
+
+      expect(captured_output_json).to match_array(expected)
+    end
+  end
+
+  describe '#config:set' do
+    it 'sets environment variables' do
+      expect(app).to receive(:create_operation!)
+        .with(type: 'configure', env: { 'FOO' => 'BAR' })
+        .and_return(operation)
+
+      expect(subject).to receive(:attach_to_operation_logs)
+        .with(operation)
+
+      subject.send('config:set', 'FOO=BAR')
+    end
+
+    it 'rejects environment variables that start with -' do
+      expect { subject.send('config:set', '-foo=bar') }
+        .to raise_error(/invalid argument/im)
+    end
+  end
+
+  describe '#config:rm' do
+    it 'unsets environment variables' do
+      expect(app).to receive(:create_operation!)
+        .with(type: 'configure', env: { 'FOO' => '' })
+        .and_return(operation)
+
+      expect(subject).to receive(:attach_to_operation_logs)
+        .with(operation)
+
+      subject.send('config:unset', 'FOO')
+    end
+
+    it 'rejects environment variables that start with -' do
+      expect { subject.send('config:rm', '-foo') }
+        .to raise_error(/invalid argument/im)
+    end
+  end
+end