aptible-cli 0.18.3 → 0.19.0

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/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

data/spec/fabricators/account_fabricator.rb

@@ -26,5 +26,7 @@ Fabricator(:account, from: :stub_account) do
   apps { [] }
   databases { [] }
   certificates { [] }
+  log_drains { [] }
+  metric_drains { [] }
   created_at { Time.now }
 end