aptible-cli 0.18.1 → 0.19.1

data/lib/aptible/cli/version.rb

@@ -1,5 +1,5 @@
 module Aptible
   module CLI
-    VERSION = '0.18.1'.freeze
+    VERSION = '0.19.1'.freeze
   end
 end

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

@@ -253,42 +253,6 @@ describe Aptible::CLI::Agent do
           .to raise_error(/provide at least/im)
       end
 
-      it 'should scale container count (legacy)' do
-        stub_options
-        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(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
-        stub_options(container_count: 2)
-        expect { subject.send('apps:scale', 'web', '3') }
-          .to raise_error(/count was passed via both/im)
-      end
-
-      it 'should fail when using both current and legacy size' do
-        stub_options(container_size: 1024, size: 512)
-        expect { subject.send('apps:scale', 'web') }
-          .to raise_error(/size was passed via both/im)
-      end
-
-      it 'should fail when using too many arguments' do
-        stub_options
-        expect { subject.send('apps:scale', 'web', '3', '4') }
-          .to raise_error(/usage:.*apps:scale/im)
-      end
-
       it 'should fail if the service does not exist' do
         stub_options(container_count: 2)
 
@@ -323,17 +287,6 @@ describe Aptible::CLI::Agent do
         subject.send('apps:scale', 'web')
       end.to raise_error(Thor::Error)
     end
-
-    it 'should fail if number is not a valid number (legacy)' do
-      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)
-
-      expect(captured_logs).to match(/deprecated/i)
-    end
   end
 
   describe '#apps:deprovision' do

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

@@ -112,7 +112,7 @@ describe Aptible::CLI::Agent do
           Fabricate(:database, account: account, handle: default_handle)
         end
 
-        subject.options = { size: s }
+        subject.options = { disk_size: s }
         subject.send('backup:restore', 1)
       end
 

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

@@ -57,16 +57,6 @@ describe Aptible::CLI::Agent do
       subject.send('db:create', 'foo')
     end
 
-    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 }
-      )
-
-      subject.options = { type: 'postgresql', size: 200 }
-      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 },
@@ -414,18 +404,6 @@ describe Aptible::CLI::Agent do
       expect(captured_logs).to match(/restarting foobar/i)
     end
 
-    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)
-
-      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 'allows restarting a database with a disk-size' do
       expect(database).to receive(:create_operation!)
         .with(type: 'restart', disk_size: 40).and_return(op)
@@ -581,10 +559,6 @@ describe Aptible::CLI::Agent 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

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

@@ -94,6 +94,45 @@ describe Aptible::CLI::Agent do
         stub_options(ip_whitelist: %w(1.1.1.1))
         subject.send('endpoints:database:create', 'mydb')
       end
+
+      it 'creates an internal Database Endpoint' do
+        expect_create_vhost(db.service, internal: true)
+        stub_options(internal: true)
+        subject.send('endpoints:database:create', 'mydb')
+      end
+    end
+
+    describe 'endpoints:database:modify' do
+      it 'does not change anything if no options are passed' do
+        v = Fabricate(:vhost, service: db.service)
+        expect_modify_vhost(v, {})
+        stub_options(database: 'mydb')
+        subject.send('endpoints:database:modify', v.external_host)
+      end
+
+      it 'adds an IP whitelist' do
+        v = Fabricate(:vhost, service: db.service)
+        expect_modify_vhost(v, ip_whitelist: %w(1.1.1.1))
+
+        stub_options(database: 'mydb', ip_whitelist: %w(1.1.1.1))
+        subject.send('endpoints:database:modify', v.external_host)
+      end
+
+      it 'removes an IP whitelist' do
+        v = Fabricate(:vhost, service: db.service)
+        expect_modify_vhost(v, ip_whitelist: [])
+
+        stub_options(database: 'mydb', :'no-ip_whitelist' => true)
+        subject.send('endpoints:database:modify', v.external_host)
+      end
+
+      it 'does not allow disabling and adding an IP whitelist' do
+        v = Fabricate(:vhost, service: db.service)
+        stub_options(database: 'mydb', ip_whitelist: %w(1.1.1.1),
+                     :'no-ip_whitelist' => true)
+        expect { subject.send('endpoints:database:modify', v.external_host) }
+          .to raise_error(/conflicting.*no-ip-whitelist.*ip-whitelist/im)
+      end
     end
 
     describe 'endpoints:list' do

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

@@ -0,0 +1,207 @@
+require 'spec_helper'
+
+describe Aptible::CLI::Agent do
+  let(:account) { Fabricate(:account) }
+  let!(:log_drain) do
+    Fabricate(:log_drain, handle: 'test', account: account)
+  end
+
+  let(:token) { double('token') }
+  before { allow(subject).to receive(:fetch_token).and_return(token) }
+
+  before do
+    allow(Aptible::Api::Account).to receive(:all)
+      .with(token: token).and_return([account])
+  end
+
+  describe '#log_drain:list' do
+    it 'lists a log drains for an account' do
+      subject.send('log_drain:list')
+
+      out = "=== aptible\n" \
+            "test\n"
+      expect(captured_output_text).to eq(out)
+    end
+
+    it 'lists log drains across multiple accounts' do
+      other_account = Fabricate(:account)
+      Fabricate(:log_drain, handle: 'test2', account: other_account)
+      accounts = [account, other_account]
+      allow(Aptible::Api::Account).to receive(:all).and_return(accounts)
+
+      subject.send('log_drain:list')
+
+      out = "=== aptible\n" \
+            "test\n" \
+            "test2\n"
+      expect(captured_output_text).to eq(out)
+    end
+
+    it 'lists log drains for a single account when --environment is included' do
+      other_account = Fabricate(:account)
+      Fabricate(:log_drain, handle: 'test2', account: other_account)
+      accounts = [account, other_account]
+      allow(Aptible::Api::Account).to receive(:all).and_return(accounts)
+
+      subject.options = { environment: account.handle }
+      subject.send('log_drain:list')
+
+      out = "=== aptible\n" \
+            "test\n"
+      expect(captured_output_text).to eq(out)
+    end
+  end
+
+  describe '#log_drain:create' do
+    def expect_provision_log_drain(create_opts, provision_opts = {})
+      log_drain = Fabricate(:log_drain, account: account)
+      op = Fabricate(:operation)
+
+      expect(account).to receive(:create_log_drain!)
+        .with(**create_opts).and_return(log_drain)
+
+      expect(log_drain).to receive(:create_operation)
+        .with(type: :provision, **provision_opts).and_return(op)
+
+      expect(subject).to receive(:attach_to_operation_logs).with(op)
+    end
+
+    context 'elasticsearch' do
+      let(:db) { Fabricate(:database, account: account, id: 5) }
+
+      it 'creates a new Elasticsearch log drain' do
+        opts = {
+          handle: 'test',
+          drain_apps: nil,
+          drain_databases: nil,
+          drain_ephemeral_sessions: nil,
+          drain_proxies: nil,
+          drain_type: :elasticsearch_database,
+          logging_token: nil,
+          database_id: db.id
+        }
+        expect_provision_log_drain(opts)
+
+        subject.options = {
+          db: db.handle,
+          environment: account.handle
+        }
+        subject.send('log_drain:create:elasticsearch', 'test')
+      end
+
+      it 'creates a new Elasticsearch log drain with a pipeline' do
+        opts = {
+          handle: 'test-es',
+          drain_apps: nil,
+          drain_databases: nil,
+          drain_ephemeral_sessions: nil,
+          drain_proxies: nil,
+          drain_type: :elasticsearch_database,
+          logging_token: 'test-pipeline',
+          database_id: db.id
+        }
+        expect_provision_log_drain(opts)
+
+        subject.options = {
+          db: db.handle,
+          environment: account.handle,
+          pipeline: 'test-pipeline'
+        }
+        subject.send('log_drain:create:elasticsearch', 'test-es')
+      end
+    end
+
+    # HTTPS, Datadog, Sumologic, and LogDNA are all similar enough
+    # that they're not tested individually
+    context 'https' do
+      it 'creates a new HTTPS log drain' do
+        opts = {
+          handle: 'test-https',
+          drain_apps: nil,
+          drain_databases: nil,
+          drain_ephemeral_sessions: nil,
+          drain_proxies: nil,
+          drain_type: :https_post,
+          url: 'https://test.foo.com'
+        }
+        expect_provision_log_drain(opts)
+
+        subject.options = {
+          environment: account.handle,
+          url: 'https://test.foo.com'
+        }
+        subject.send('log_drain:create:https', 'test-https')
+      end
+    end
+
+    # Syslog and Papertrail are similar enough that they're
+    # not tested individually
+    context 'syslog' do
+      it 'creates a new syslog log drain' do
+        opts = {
+          handle: 'test-syslog',
+          drain_host: 'test.foo.com',
+          drain_port: 2468,
+          logging_token: nil,
+          drain_apps: nil,
+          drain_databases: nil,
+          drain_ephemeral_sessions: nil,
+          drain_proxies: nil,
+          drain_type: :syslog_tls_tcp
+        }
+        expect_provision_log_drain(opts)
+
+        subject.options = {
+          environment: account.handle,
+          host: 'test.foo.com',
+          port: 2468
+        }
+        subject.send('log_drain:create:syslog', 'test-syslog')
+      end
+
+      it 'creates a new syslog log drain with a logging token' do
+        opts = {
+          handle: 'test-syslog',
+          drain_host: 'test.foo.com',
+          drain_port: 2468,
+          logging_token: 'test-token',
+          drain_apps: nil,
+          drain_databases: nil,
+          drain_ephemeral_sessions: nil,
+          drain_proxies: nil,
+          drain_type: :syslog_tls_tcp
+        }
+        expect_provision_log_drain(opts)
+
+        subject.options = {
+          environment: account.handle,
+          host: 'test.foo.com',
+          port: 2468,
+          token: 'test-token'
+        }
+        subject.send('log_drain:create:syslog', 'test-syslog')
+      end
+    end
+  end
+
+  describe '#log_drain:deprovision' do
+    let(:operation) { Fabricate(:operation, resource: log_drain) }
+
+    it 'deprovisions a log drain' do
+      expect(log_drain).to receive(:create_operation)
+        .with(type: :deprovision).and_return(operation)
+      expect(subject).to receive(:attach_to_operation_logs).with(operation)
+      subject.send('log_drain:deprovision', log_drain.handle)
+    end
+
+    it 'does not fail if the operation cannot be found' do
+      expect(log_drain).to receive(:create_operation)
+        .with(type: :deprovision).and_return(operation)
+      response = Faraday::Response.new(status: 404)
+      error = HyperResource::ClientError.new('Not Found', response: response)
+      expect(subject).to receive(:attach_to_operation_logs).with(operation)
+        .and_raise(error)
+      subject.send('log_drain:deprovision', log_drain.handle)
+    end
+  end
+end

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

@@ -0,0 +1,183 @@
+require 'spec_helper'
+
+describe Aptible::CLI::Agent do
+  let(:account) { Fabricate(:account) }
+  let!(:metric_drain) do
+    Fabricate(:metric_drain, handle: 'test', account: account)
+  end
+
+  let(:token) { double('token') }
+  before { allow(subject).to receive(:fetch_token).and_return(token) }
+
+  before do
+    allow(Aptible::Api::Account).to receive(:all)
+      .with(token: token).and_return([account])
+  end
+
+  describe '#metric_drain:list' do
+    it 'lists a metric drains for an account' do
+      subject.send('metric_drain:list')
+
+      out = "=== aptible\n" \
+            "test\n"
+      expect(captured_output_text).to eq(out)
+    end
+
+    it 'lists metric drains across multiple accounts' do
+      other_account = Fabricate(:account)
+      Fabricate(:metric_drain, handle: 'test2', account: other_account)
+      accounts = [account, other_account]
+      allow(Aptible::Api::Account).to receive(:all).and_return(accounts)
+
+      subject.send('metric_drain:list')
+
+      out = "=== aptible\n" \
+            "test\n" \
+            "test2\n"
+      expect(captured_output_text).to eq(out)
+    end
+
+    it 'lists metric drains for a single account with --environment' do
+      other_account = Fabricate(:account)
+      Fabricate(:metric_drain, handle: 'test2', account: other_account)
+      accounts = [account, other_account]
+      allow(Aptible::Api::Account).to receive(:all).and_return(accounts)
+
+      subject.options = { environment: account.handle }
+      subject.send('metric_drain:list')
+
+      out = "=== aptible\n" \
+            "test\n"
+      expect(captured_output_text).to eq(out)
+    end
+  end
+
+  describe '#metric_drain:create' do
+    def expect_provision_metric_drain(create_opts, provision_opts = {})
+      metric_drain = Fabricate(:metric_drain, account: account)
+      op = Fabricate(:operation)
+
+      expect(account).to receive(:create_metric_drain!)
+        .with(**create_opts).and_return(metric_drain)
+
+      expect(metric_drain).to receive(:create_operation)
+        .with(type: :provision, **provision_opts).and_return(op)
+
+      expect(subject).to receive(:attach_to_operation_logs).with(op)
+    end
+
+    context 'influxdb' do
+      let(:db) { Fabricate(:database, account: account, id: 5) }
+
+      it 'creates a new InfluxDB metric drain' do
+        opts = {
+          handle: 'test-influxdb',
+          drain_type: :influxdb_database,
+          database_id: db.id
+        }
+        expect_provision_metric_drain(opts)
+
+        subject.options = {
+          db: db.handle,
+          environment: account.handle
+        }
+        subject.send('metric_drain:create:influxdb', 'test-influxdb')
+      end
+    end
+
+    context 'influxdb:custom' do
+      it 'creates a new InfluxDB metric drain' do
+        opts = {
+          handle: 'test-influxdb-custom',
+          drain_type: :influxdb,
+          drain_configuration: {
+            address: 'https://test.foo.com:443',
+            database: 'foobar',
+            password: 'bar',
+            username: 'foo'
+          }
+        }
+        expect_provision_metric_drain(opts)
+
+        subject.options = {
+          environment: account.handle,
+          username: 'foo',
+          password: 'bar',
+          db: 'foobar',
+          url: 'https://test.foo.com:443'
+        }
+        subject.send('metric_drain:create:influxdb:custom',
+                     'test-influxdb-custom')
+      end
+    end
+
+    context 'datadog' do
+      it 'creates a new Datadog metric drain' do
+        opts = {
+          handle: 'test-datadog',
+          drain_type: :datadog,
+          drain_configuration: {
+            api_key: 'foobar'
+          }
+        }
+        expect_provision_metric_drain(opts)
+
+        subject.options = {
+          environment: account.handle,
+          api_key: 'foobar'
+        }
+        subject.send('metric_drain:create:datadog', 'test-datadog')
+      end
+
+      it 'raises an error when the Datadog site is invalid' do
+        subject.options = {
+          environment: account.handle,
+          api_key: 'foobar',
+          site: 'BAD'
+        }
+        expect { subject.send('metric_drain:create:datadog', 'test-datadog') }
+          .to raise_error(Thor::Error, /Invalid Datadog site/i)
+      end
+
+      it 'creates a new Datadog metric drain with a Datadog site defined' do
+        opts = {
+          handle: 'test-datadog',
+          drain_type: :datadog,
+          drain_configuration: {
+            api_key: 'foobar',
+            series_url: 'https://app.datadoghq.eu'
+          }
+        }
+        expect_provision_metric_drain(opts)
+
+        subject.options = {
+          environment: account.handle,
+          api_key: 'foobar',
+          site: 'EU1'
+        }
+        subject.send('metric_drain:create:datadog', 'test-datadog')
+      end
+    end
+  end
+
+  describe '#metric_drain:deprovision' do
+    let(:operation) { Fabricate(:operation, resource: metric_drain) }
+
+    it 'deprovisions a log drain' do
+      expect(metric_drain).to receive(:create_operation)
+        .with(type: :deprovision).and_return(operation)
+      expect(subject).to receive(:attach_to_operation_logs).with(operation)
+      subject.send('metric_drain:deprovision', metric_drain.handle)
+    end
+
+    it 'does not fail if the operation cannot be found' do
+      expect(metric_drain).to receive(:create_operation)
+        .with(type: :deprovision).and_return(operation)
+      response = Faraday::Response.new(status: 404)
+      error = HyperResource::ClientError.new('Not Found', response: response)
+      expect(subject).to receive(:attach_to_operation_logs).with(operation)
+        .and_raise(error)
+      subject.send('metric_drain:deprovision', metric_drain.handle)
+    end
+  end
+end