aptible-cli 0.18.0 → 0.19.0

data/lib/aptible/cli/version.rb

@@ -1,5 +1,5 @@
 module Aptible
   module CLI
-    VERSION = '0.18.0'.freeze
+    VERSION = '0.19.0'.freeze
   end
 end

data/spec/aptible/cli/resource_formatter_spec.rb

@@ -27,6 +27,7 @@ describe Aptible::CLI::ResourceFormatter do
         'Id: 12',
         'Hostname: foo.io',
         'Status: provisioned',
+        "Created At: #{fmt_time(service.created_at)}",
         'Type: https',
         'Port: default',
         'Internal: false',

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

@@ -104,26 +104,30 @@ describe Aptible::CLI::Agent do
         {
           'environment' => {
             'id' => account.id,
-            'handle' => account.handle
+            'handle' => account.handle,
+            'created_at' => fmt_time(account.created_at)
           },
           'handle' => app.handle,
           'id' => app.id,
           'status' => app.status,
           'git_remote' => app.git_repo,
+          'created_at' => fmt_time(app.created_at),
           'services' => [
             {
               'service' => s1.process_type,
               'id' => s1.id,
               'command' => s1.command,
               'container_count' => s1.container_count,
-              'container_size' => s1.container_memory_limit_mb
+              'container_size' => s1.container_memory_limit_mb,
+              'created_at' => fmt_time(s1.created_at)
             },
             {
               'service' => s2.process_type,
               'id' => s2.id,
               'command' => 'CMD',
               'container_count' => s2.container_count,
-              'container_size' => s2.container_memory_limit_mb
+              'container_size' => s2.container_memory_limit_mb,
+              'created_at' => fmt_time(s2.created_at)
             }
           ]
         }
@@ -145,12 +149,14 @@ describe Aptible::CLI::Agent do
         {
           'environment' => {
             'id' => account.id,
-            'handle' => account.handle
+            'handle' => account.handle,
+            'created_at' => fmt_time(account.created_at)
           },
           'handle' => app.handle,
           'id' => app.id,
           'status' => app.status,
           'git_remote' => app.git_repo,
+          'created_at' => fmt_time(app.created_at),
           'last_deploy_operation' =>
             {
               'id' => op.id,
@@ -247,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)
 
@@ -317,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/environment_spec.rb

@@ -32,11 +32,13 @@ describe Aptible::CLI::Agent do
     expected_accounts = [
       {
         'handle' => 'foo',
-        'ca_body' => 'account 1 cert'
+        'ca_body' => 'account 1 cert',
+        'created_at' => fmt_time(a1.created_at)
       },
       {
         'handle' => 'bar',
-        'ca_body' => '--account 2 cert--'
+        'ca_body' => '--account 2 cert--',
+        'created_at' => fmt_time(a2.created_at)
       }
     ]
     expect(captured_output_json.map! { |account| account.except('id') })

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