aptible-cli 0.14.1 → 0.15.0

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

@@ -4,10 +4,12 @@ class SocatHelperMock < OpenStruct
 end
 
 describe Aptible::CLI::Agent do
+  let(:token) { double('token') }
+
   before do
     allow(subject).to receive(:ask)
     allow(subject).to receive(:save_token)
-    allow(subject).to receive(:fetch_token) { double 'token' }
+    allow(subject).to receive(:fetch_token) { token }
   end
 
   let(:handle) { 'foobar' }
@@ -15,79 +17,114 @@ describe Aptible::CLI::Agent do
   let(:socat_helper) { SocatHelperMock.new(port: 4242) }
 
   describe '#db:create' do
-    let(:db) { Fabricate(:database) }
-    let(:op) { Fabricate(:operation) }
-    let(:account) { Fabricate(:account) }
-
     before do
       allow(Aptible::Api::Account).to receive(:all).and_return([account])
-      allow(db).to receive(:reload).and_return(db)
-      allow(op).to receive(:errors).and_return(Aptible::Resource::Errors.new)
     end
 
-    it 'creates a new DB' do
+    def expect_provision_database(create_opts, provision_opts = {})
+      db = Fabricate(:database)
+      expect(db).to receive(:reload).and_return(db)
+
+      op = Fabricate(:operation)
+
       expect(account).to receive(:create_database!)
-        .with(handle: 'foo', type: 'postgresql')
-        .and_return(db)
+        .with(**create_opts).and_return(db)
 
       expect(db).to receive(:create_operation)
-        .with(type: 'provision')
-        .and_return(op)
+        .with(type: 'provision', **provision_opts).and_return(op)
+
+      expect(subject).to receive(:attach_to_operation_logs).with(op)
+    end
+
+    let(:account) { Fabricate(:account) }
 
-      expect(subject).to receive(:attach_to_operation_logs)
-        .with(op)
+    it 'creates a new DB' do
+      expect_provision_database(handle: 'foo', type: 'postgresql')
 
       subject.options = { type: 'postgresql' }
       subject.send('db:create', 'foo')
     end
 
     it 'creates a new DB with a container size' do
-      expect(account).to receive(:create_database!)
-        .with(handle: 'foo', type: 'postgresql', initial_container_size: 1024)
-        .and_return(db)
-
-      expect(db).to receive(:create_operation)
-        .with(type: 'provision', container_size: 1024)
-        .and_return(op)
-
-      expect(subject).to receive(:attach_to_operation_logs)
-        .with(op)
+      expect_provision_database(
+        { handle: 'foo', type: 'postgresql', initial_container_size: 1024 },
+        { container_size: 1024 }
+      )
 
       subject.options = { type: 'postgresql', container_size: 1024 }
       subject.send('db:create', 'foo')
     end
 
     it 'creates a new DB with a disk size' do
-      expect(account).to receive(:create_database!)
-        .with(handle: 'foo', type: 'postgresql', initial_disk_size: 200)
-        .and_return(db)
-
-      expect(db).to receive(:create_operation)
-        .with(type: 'provision', disk_size: 200)
-        .and_return(op)
-
-      expect(subject).to receive(:attach_to_operation_logs)
-        .with(op)
+      expect_provision_database(
+        { handle: 'foo', type: 'postgresql', initial_disk_size: 200 },
+        { disk_size: 200 }
+      )
 
       subject.options = { type: 'postgresql', size: 200 }
       subject.send('db:create', 'foo')
     end
 
     it 'deprovisions the database if the operation cannot be created' do
-      op.errors.full_messages << 'oops!'
+      db = Fabricate(:database)
+
+      provision_op = Fabricate(:operation)
+      provision_op.errors.full_messages << 'oops'
+
+      deprovision_op = Fabricate(:operation)
 
       expect(account).to receive(:create_database!).and_return(db)
 
       expect(db).to receive(:create_operation)
-        .with(type: 'provision')
-        .once.ordered.and_return(op)
+        .with(type: 'provision').once.ordered.and_return(provision_op)
 
       expect(db).to receive(:create_operation!)
-        .with(type: 'deprovision')
-        .once.ordered
+        .with(type: 'deprovision').once.ordered.and_return(deprovision_op)
 
       expect { subject.send('db:create', 'foo') }.to raise_error(/oops/im)
     end
+
+    context 'with version' do
+      let(:img) do
+        Fabricate(:database_image, type: 'postgresql', version: '9.4')
+      end
+
+      let(:alt_version) do
+        Fabricate(:database_image, type: 'postgresql', version: '10')
+      end
+
+      let(:alt_type) do
+        Fabricate(:database_image, type: 'redis', version: '9.4')
+      end
+
+      before do
+        allow(Aptible::Api::DatabaseImage).to receive(:all)
+          .with(token: token).and_return([alt_version, alt_type, img])
+      end
+
+      it 'provisions a Database with a matching Database Image' do
+        expect_provision_database(
+          handle: 'foo',
+          type: 'postgresql',
+          database_image: img
+        )
+
+        subject.options = { type: 'postgresql', version: '9.4' }
+        subject.send('db:create', 'foo')
+      end
+
+      it 'fails if the Database Image does not exist' do
+        subject.options = { type: 'postgresql', version: '123' }
+        expect { subject.send('db:create', 'foo') }
+          .to raise_error(Thor::Error, /no database image/i)
+      end
+
+      it 'fails if type is not passed' do
+        subject.options = { version: '123' }
+        expect { subject.send('db:create', 'foo') }
+          .to raise_error(Thor::Error, /type is required/i)
+      end
+    end
   end
 
   describe '#db:tunnel' do
@@ -108,17 +145,20 @@ describe Aptible::CLI::Agent do
         expect(subject).to receive(:with_local_tunnel).with(cred, 0)
           .and_yield(socat_helper)
 
-        expect(subject).to receive(:say)
-          .with('Creating foo tunnel to foobar...', :green)
+        subject.send('db:tunnel', handle)
 
         local_url = 'postgresql://aptible:password@localhost.aptible.in:4242/db'
-        expect(subject).to receive(:say)
-          .with("Connect at #{local_url}", :green)
 
-        # db:tunnel should also explain each component of the URL and suggest
-        # the --type argument:
-        expect(subject).to receive(:say).exactly(9).times
-        subject.send('db:tunnel', handle)
+        expect(captured_logs)
+          .to match(/creating foo tunnel to foobar/i)
+        expect(captured_logs)
+          .to match(/connect at #{Regexp.escape(local_url)}/i)
+
+        expect(captured_logs).to match(/host: localhost\.aptible\.in/i)
+        expect(captured_logs).to match(/port: 4242/i)
+        expect(captured_logs).to match(/username: aptible/i)
+        expect(captured_logs).to match(/password: password/i)
+        expect(captured_logs).to match(/database: db/i)
       end
 
       it 'defaults to a default credential' do
@@ -126,14 +166,12 @@ describe Aptible::CLI::Agent do
         Fabricate(:database_credential, database: database, type: 'foo')
         Fabricate(:database_credential, database: database, type: 'bar')
 
-        messages = []
-        allow(subject).to receive(:say) { |m, *| messages << m }
         expect(subject).to receive(:with_local_tunnel).with(ok, 0)
 
         subject.send('db:tunnel', handle)
 
-        expect(messages.grep(/use --type type/im)).not_to be_empty
-        expect(messages.grep(/valid types.*foo.*bar/im)).not_to be_empty
+        expect(captured_logs).to match(/use --type type/i)
+        expect(captured_logs).to match(/valid types.*foo.*bar/i)
       end
 
       it 'supports --type' do
@@ -143,7 +181,6 @@ describe Aptible::CLI::Agent do
         ok = Fabricate(:database_credential, type: 'foo', database: database)
         Fabricate(:database_credential, type: 'bar', database: database)
 
-        allow(subject).to receive(:say)
         expect(subject).to receive(:with_local_tunnel).with(ok, 0)
         subject.send('db:tunnel', handle)
       end
@@ -174,7 +211,6 @@ describe Aptible::CLI::Agent do
       context 'v1 stack' do
         before do
           allow(database.account.stack).to receive(:version) { 'v1' }
-          allow(subject).to receive(:say)
         end
 
         it 'falls back to the database itself if no type is given' do
@@ -199,13 +235,11 @@ describe Aptible::CLI::Agent do
         end
 
         it 'does not suggest other types that do not exist' do
-          messages = []
-          allow(subject).to receive(:say) { |m, *| messages << m }
           expect(subject).to receive(:with_local_tunnel).with(database, 0)
 
           subject.send('db:tunnel', handle)
 
-          expect(messages.grep(/use --type type/im)).to be_empty
+          expect(captured_logs).not_to match(/use --type type/i)
         end
       end
     end
@@ -216,9 +250,14 @@ describe Aptible::CLI::Agent 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)
+      [
+        [staging, 'staging-redis-db'],
+        [staging, 'staging-postgres-db'],
+        [prod, 'prod-elsearch-db'],
+        [prod, 'prod-postgres-db']
+      ].each do |a, h|
+        d = Fabricate(:database, account: a, handle: h)
+        Fabricate(:database_credential, database: d)
       end
 
       token = 'the-token'
@@ -229,45 +268,38 @@ describe Aptible::CLI::Agent do
 
     context 'when no account is specified' do
       it 'prints out the grouped database handles for all accounts' do
-        allow(subject).to receive(:say)
-
         subject.send('db:list')
 
-        expect(subject).to have_received(:say).with('=== staging')
-        expect(subject).to have_received(:say).with('staging-redis-db')
-        expect(subject).to have_received(:say).with('staging-postgres-db')
+        expect(captured_output_text).to include('=== staging')
+        expect(captured_output_text).to include('staging-redis-db')
+        expect(captured_output_text).to include('staging-postgres-db')
 
-        expect(subject).to have_received(:say).with('=== production')
-        expect(subject).to have_received(:say).with('prod-elsearch-db')
-        expect(subject).to have_received(:say).with('prod-postgres-db')
+        expect(captured_output_text).to include('=== production')
+        expect(captured_output_text).to include('prod-elsearch-db')
+        expect(captured_output_text).to include('prod-postgres-db')
       end
     end
 
     context 'when a valid account is specified' do
       it 'prints out the database handles for the account' do
-        allow(subject).to receive(:say)
-
         subject.options = { environment: 'staging' }
         subject.send('db:list')
 
-        expect(subject).to have_received(:say).with('=== staging')
-        expect(subject).to have_received(:say).with('staging-redis-db')
-        expect(subject).to have_received(:say).with('staging-postgres-db')
+        expect(captured_output_text).to include('=== staging')
+        expect(captured_output_text).to include('staging-redis-db')
+        expect(captured_output_text).to include('staging-postgres-db')
 
-        expect(subject).to_not have_received(:say).with('=== production')
-        expect(subject).to_not have_received(:say).with('prod-elsearch-db')
-        expect(subject).to_not have_received(:say).with('prod-postgres-db')
+        expect(captured_output_text).not_to include('=== production')
+        expect(captured_output_text).not_to include('prod-elsearch-db')
+        expect(captured_output_text).not_to include('prod-postgres-db')
       end
     end
 
     context 'when an invalid account is specified' do
       it 'prints out an error' do
-        allow(subject).to receive(:say)
-
         subject.options = { environment: 'foo' }
-        expect { subject.send('db:list') }.to raise_error(
-          'Specified account does not exist'
-        )
+        expect { subject.send('db:list') }
+          .to raise_error('Specified account does not exist')
       end
     end
   end
@@ -281,10 +313,11 @@ describe Aptible::CLI::Agent do
     it 'allows creating a new backup' do
       expect(database).to receive(:create_operation!)
         .with(type: 'backup').and_return(op)
-      expect(subject).to receive(:say).with('Backing up foobar...')
       expect(subject).to receive(:attach_to_operation_logs).with(op)
 
       subject.send('db:backup', handle)
+
+      expect(captured_logs).to match(/backing up foobar/i)
     end
 
     it 'fails if the DB is not found' do
@@ -302,10 +335,11 @@ describe Aptible::CLI::Agent do
     it 'allows reloading a database' do
       expect(database).to receive(:create_operation!)
         .with(type: 'reload').and_return(op)
-      expect(subject).to receive(:say).with('Reloading foobar...')
       expect(subject).to receive(:attach_to_operation_logs).with(op)
 
       subject.send('db:reload', handle)
+
+      expect(captured_logs).to match(/reloading foobar/i)
     end
 
     it 'fails if the DB is not found' do
@@ -324,32 +358,35 @@ describe Aptible::CLI::Agent do
       expect(database).to receive(:create_operation!)
         .with(type: 'restart').and_return(op)
 
-      expect(subject).to receive(:say).with('Restarting foobar...')
       expect(subject).to receive(:attach_to_operation_logs).with(op)
 
       subject.send('db:restart', handle)
+
+      expect(captured_logs).to match(/restarting foobar/i)
     end
 
     it 'allows restarting a database with a container size' do
       expect(database).to receive(:create_operation!)
         .with(type: 'restart', container_size: 40).and_return(op)
 
-      expect(subject).to receive(:say).with('Restarting foobar...')
       expect(subject).to receive(:attach_to_operation_logs).with(op)
 
       subject.options = { container_size: 40 }
       subject.send('db:restart', handle)
+
+      expect(captured_logs).to match(/restarting foobar/i)
     end
 
     it 'allows restarting a database with a disk size' do
       expect(database).to receive(:create_operation!)
         .with(type: 'restart', disk_size: 40).and_return(op)
 
-      expect(subject).to receive(:say).with('Restarting foobar...')
       expect(subject).to receive(:attach_to_operation_logs).with(op)
 
       subject.options = { size: 40 }
       subject.send('db:restart', handle)
+
+      expect(captured_logs).to match(/restarting foobar/i)
     end
 
     it 'fails if the DB is not found' do
@@ -369,13 +406,12 @@ describe Aptible::CLI::Agent do
 
     context 'valid database' do
       it 'returns the URL of a specified DB' do
-        cred = Fabricate(:database_credential, default: true, type: 'foo',
-                                               database: database)
-
-        expect(subject).to receive(:say).with(cred.connection_url)
+        cred = Fabricate(
+          :database_credential, default: true, type: 'foo', database: database
+        )
         expect(database).not_to receive(:connection_url)
-
         subject.send('db:url', handle)
+        expect(captured_output_text.chomp).to eq(cred.connection_url)
       end
 
       it 'fails if multiple DBs are found' do
@@ -388,19 +424,75 @@ describe Aptible::CLI::Agent do
       context 'v1 stack' do
         before do
           allow(database.account.stack).to receive(:version) { 'v1' }
-          allow(subject).to receive(:say)
         end
 
         it 'returns the URL of a specified DB' do
           connection_url = 'postgresql://aptible-v1:password@lega.cy:4242/db'
-
-          expect(subject).to receive(:say).with(connection_url)
           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:deprovision' do
+    before { expect(Aptible::Api::Database).to receive(:all) { [database] } }
+
+    let(:operation) { Fabricate(:operation, resource: database) }
+
+    it 'deprovisions a database' do
+      expect(database).to receive(:create_operation!)
+        .with(type: 'deprovision').and_return(operation)
+
+      expect(subject).not_to receive(:attach_to_operation_logs)
+
+      subject.send('db:deprovision', handle)
+    end
+  end
+
+  describe '#db:versions' do
+    let(:token) { double('token') }
+
+    before do
+      allow(subject).to receive(:save_token)
+      allow(subject).to receive(:fetch_token) { token }
+    end
+
+    let(:i1) do
+      Fabricate(:database_image, type: 'postgresql', version: '9.4')
+    end
+
+    let(:i2) do
+      Fabricate(:database_image, type: 'postgresql', version: '10')
+    end
+
+    let(:i3) do
+      Fabricate(:database_image, type: 'redis', version: '3.0')
+    end
+
+    before do
+      allow(Aptible::Api::DatabaseImage).to receive(:all)
+        .with(token: token).and_return([i1, i2, i3])
+    end
+
+    it 'lists grouped existing Database versions' do
+      subject.send('db:versions')
+
+      expected = [
+        '=== postgresql',
+        '9.4',
+        '10',
+        '',
+        '=== redis',
+        '3.0',
+        ''
+      ].join("\n")
+
+      expect(captured_output_text).to eq(expected)
+    end
+  end
 end