aptible-cli 0.16.2 → 0.16.7

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

@@ -2,14 +2,17 @@ require 'spec_helper'
 
 describe Aptible::CLI::Agent do
   let(:token) { 'some-token' }
-  let(:account) { Fabricate(:account, handle: 'test') }
+  let(:account) { Fabricate(:account, handle: 'test', id: 1) }
   let(:alt_account) { Fabricate(:account, handle: 'alt') }
   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), account: account
+      database_with_deleted: database,
+      created_at: Time.at(1465910651),
+      account: account,
+      id: 1
     )
   end
 
@@ -178,4 +181,78 @@ describe Aptible::CLI::Agent do
         .to raise_error(Thor::Error, 'Could not find database nope')
     end
   end
+
+  describe '#backup:orphaned' do
+    before { allow(Aptible::Api::Account).to receive(:all) { [account] } }
+    before do
+      m = allow(account).to receive(:each_orphaned_backup)
+      ages = [
+        1.day, 2.days, 3.days, 4.days,
+        5.days, 2.weeks, 3.weeks, 1.month,
+        1.year
+      ]
+      ages.each do |age|
+        b = Fabricate(:backup, database: database, created_at: age.ago,
+                               account: account)
+        allow(b).to receive(:database_with_deleted).and_return(database)
+        m.and_yield(b)
+        b
+      end
+    end
+    before { subject.options = { max_age: '1w' } }
+
+    it 'can show a subset of backups' do
+      subject.send('backup:orphaned')
+      puts captured_output_text
+      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:orphaned')
+      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:orphaned')
+      expect(captured_output_text.split("\n").size).to eq(9)
+    end
+
+    it 'errors out if max_age is invalid' do
+      subject.options = { max_age: 'foobar' }
+      expect { subject.send('backup:orphaned') }
+        .to raise_error(Thor::Error, 'Invalid age: foobar')
+    end
+  end
+
+  describe '#backup:purge' 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:purge', 1) }
+        .to raise_error('Backup #1 not found')
+    end
+
+    context 'successful purge' do
+      let(:op) { Fabricate(:operation, resource: backup) }
+
+      before do
+        expect(Aptible::Api::Backup).to receive(:find)
+          .with(1, token: token).and_return(backup)
+      end
+
+      it 'creates a purge operation on the backup' do
+        expect(backup).to receive(:create_operation!) do |options|
+          expect(options[:type]).to eq('purge')
+          op
+        end
+
+        expect(subject).to receive(:attach_to_operation_logs).with(op)
+
+        subject.send('backup:purge', 1)
+      end
+    end
+  end
 end

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

@@ -55,7 +55,7 @@ describe Aptible::CLI::Agent do
       subject.send('db:create', 'foo')
     end
 
-    it 'creates a new DB with a disk size' do
+    it 'creates a new DB with a (implicitly) disk size' do
       expect_provision_database(
         { handle: 'foo', type: 'postgresql', initial_disk_size: 200 },
         { disk_size: 200 }
@@ -65,6 +65,16 @@ describe Aptible::CLI::Agent do
       subject.send('db:create', 'foo')
     end
 
+    it 'creates a new DB with a disk-size' do
+      expect_provision_database(
+        { handle: 'foo', type: 'postgresql', initial_disk_size: 200 },
+        { disk_size: 200 }
+      )
+
+      subject.options = { type: 'postgresql', disk_size: 200 }
+      subject.send('db:create', 'foo')
+    end
+
     it 'deprovisions the database if the operation cannot be created' do
       db = Fabricate(:database)
 
@@ -377,7 +387,7 @@ describe Aptible::CLI::Agent do
       expect(captured_logs).to match(/restarting foobar/i)
     end
 
-    it 'allows restarting a database with a disk size' do
+    it 'allows restarting a database with (implicitly disk) size' do
       expect(database).to receive(:create_operation!)
         .with(type: 'restart', disk_size: 40).and_return(op)
 
@@ -389,6 +399,18 @@ describe Aptible::CLI::Agent do
       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(:attach_to_operation_logs).with(op)
+
+      subject.options = { disk_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
       expect { subject.send('db:restart', 'nope') }
         .to raise_error(Thor::Error, 'Could not find database nope')
@@ -439,6 +461,129 @@ describe Aptible::CLI::Agent do
     end
   end
 
+  describe '#db:replicate' do
+    let(:databases) { [] }
+    before { allow(Aptible::Api::Database).to receive(:all) { databases } }
+
+    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)
+      params[:disk_size] = params.delete(:size) if params[:size]
+      expect(master).to receive(:create_operation!)
+        .with(**params).and_return(op)
+
+      expect(subject).to receive(:attach_to_operation_logs).with(op) do
+        databases << replica
+        replica
+      end
+
+      provision = Fabricate(:operation)
+
+      expect(replica).to receive_message_chain(:operations, :last)
+        .and_return(provision)
+
+      expect(subject).to receive(:attach_to_operation_logs).with(provision)
+
+      expect(replica).to receive(:reload).and_return(replica)
+
+      subject.options = opts
+      subject.send('db:replicate', 'master', 'replica')
+
+      expect(captured_logs).to match(/replicating master/i)
+    end
+
+    it 'allows replicating an existing database' do
+      expect_replicate_database
+    end
+
+    it 'allows replicating a database with a container size' do
+      expect_replicate_database(container_size: 40)
+    end
+
+    it 'allows replicating a database with an (implicitly) disk size option' do
+      expect_replicate_database(size: 40)
+    end
+
+    it 'allows replicating a database with a disk-size option' do
+      expect_replicate_database(disk_size: 40)
+    end
+
+    it 'fails if the DB is not found' do
+      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,
+                        docker_repo: 'aptible/postgresql:10')
+
+      expect(subject).to receive(:find_database_image).with('postgresql', 10)
+        .and_return(dbimg)
+
+      op = Fabricate(:operation)
+
+      params = { type: 'replicate_logical', handle: 'replica',
+                 docker_ref: dbimg.docker_repo }
+      expect(master).to receive(:create_operation!)
+        .with(**params).and_return(op)
+
+      expect(subject).to receive(:attach_to_operation_logs).with(op) do
+        databases << replica
+        replica
+      end
+
+      provision = Fabricate(:operation)
+
+      expect(replica).to receive_message_chain(:operations, :last)
+        .and_return(provision)
+
+      expect(subject).to receive(:attach_to_operation_logs).with(provision)
+
+      expect(replica).to receive(:reload).and_return(replica)
+
+      subject.options = { logical: true, version: 10 }
+      subject.send('db:replicate', 'master', 'replica')
+
+      expect(captured_logs).to match(/replicating master/i)
+    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 ' \
+                                     'replication')
+    end
+
+    it 'fails if logical replication requested for non-postgres db' do
+      master = Fabricate(:database, handle: 'master', type: 'mysql')
+      databases << master
+
+      subject.options = { type: 'replicate', handle: 'replica',
+                          logical: true, version: 10 }
+      expect { subject.send('db:replicate', 'master', 'replica') }
+        .to raise_error(Thor::Error, 'Logical replication only works for ' \
+                                     'PostgreSQL')
+    end
+  end
+
   describe '#db:dump' do
     it 'should fail if database is non-existent' do
       allow(Aptible::Api::Database).to receive(:all) { [] }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aptible-cli
 version: !ruby/object:Gem::Version
-  version: 0.16.2
+  version: 0.16.7
 platform: ruby
 authors:
 - Frank Macreery
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-11 00:00:00.000000000 Z
+date: 2020-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aptible-resource
@@ -30,28 +30,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: aptible-auth
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: aptible-billing
   requirement: !ruby/object:Gem::Requirement
@@ -277,7 +277,9 @@ files:
 - lib/aptible/cli/helpers/database.rb
 - lib/aptible/cli/helpers/environment.rb
 - lib/aptible/cli/helpers/operation.rb
+- lib/aptible/cli/helpers/security_key.rb
 - lib/aptible/cli/helpers/ssh.rb
+- lib/aptible/cli/helpers/system.rb
 - lib/aptible/cli/helpers/token.rb
 - lib/aptible/cli/helpers/tunnel.rb
 - lib/aptible/cli/helpers/vhost.rb
@@ -372,8 +374,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Command-line interface for Aptible services