aptible-cli 0.19.4 → 0.19.7

data/spec/aptible/cli/helpers/s3_log_helpers_spec.rb

@@ -0,0 +1,334 @@
+require 'spec_helper'
+
+describe Aptible::CLI::Helpers::S3LogHelpers do
+  subject { Class.new.send(:include, described_class).new }
+  let(:v2_pfx) { 'mystack/shareable/v2/fakesha' }
+  let(:v3_pfx) { 'mystack/shareable/v3/fakesha' }
+  let(:v2app) do
+    "#{v2_pfx}/apps-321/fakebread-json.log.2022-06-29T18:30:01.bck.gz"
+  end
+  let(:v2app_rotated) do
+    "#{v2_pfx}/apps-321/fakebread-json.1.log.2022-06-29T18:30:01.bck.gz"
+  end
+  let(:v3app) do
+    "#{v3_pfx}/apps-321/service-123/deadbeef-json.log." \
+    '2022-08-24T21:12:33.2022-08-24T21:14:38.archived.gz'
+  end
+  let(:v3db) do
+    "#{v3_pfx}/databases-321/fakebread-json.log." \
+    '2022-08-24T21:12:33.2022-08-24T21:14:38.archived.gz'
+  end
+  let(:v3db_rotated) do
+    "#{v3_pfx}/databases-321/fakebread-json.log.1." \
+    '2022-08-24T21:12:33.2022-08-24T21:14:38.archived.gz'
+  end
+
+  describe '#ensure_aws_creds' do
+    it 'Raises if no keys are provided via ENV' do
+      expect { subject.ensure_aws_creds }
+        .to raise_error(Thor::Error, /Missing environment variable/)
+    end
+
+    it 'Accepts AWS keypair from the ENV' do
+      ENV['AWS_ACCESS_KEY_ID'] = 'foo'
+      ENV['AWS_SECRET_ACCESS_KEY'] = 'bar'
+      expect { subject.ensure_aws_creds }.to_not raise_error
+    end
+  end
+
+  describe '#info_from_path' do
+    context 'time zones are in UTC' do
+      it 'processes v2 upload time in UTC' do
+        result = subject.info_from_path(v2app)
+        expect(result[:uploaded_at].zone).to eq('UTC')
+      end
+
+      it 'processes v3 log times in UTC' do
+        result = subject.info_from_path(v3app)
+        expect(result[:start_time].zone).to eq('UTC')
+        expect(result[:end_time].zone).to eq('UTC')
+      end
+    end
+
+    it 'does not choke on v3 logs with unknown timestamps' do
+      path = "#{v3_pfx}/apps-321/service-123/deadbeef-json.log." \
+             'unknown.unknown.archived.gz'
+      result = subject.info_from_path(path)
+      expect(result[:start_time]).to be(nil)
+      expect(result[:end_time]).to be(nil)
+    end
+
+    it 'can read app data from v2 paths' do
+      result = subject.info_from_path(v2app)
+      expect(result[:schema]).to eq('v2')
+      expect(result[:shasum]).to eq('fakesha')
+      expect(result[:type]).to eq('apps')
+      expect(result[:id]).to eq(321)
+      expect(result[:service_id]).to be(nil)
+      expect(result[:container_id]).to eq('fakebread')
+      expect(result[:uploaded_at]).to eq('2022-06-29T18:30:01')
+      expect(result[:container_id]).to eq('fakebread')
+      expect(result[:start_time]).to be(nil)
+      expect(result[:end_time]).to be(nil)
+    end
+
+    it 'can read app data from v3 paths' do
+      result = subject.info_from_path(v3app)
+      expect(result[:schema]).to eq('v3')
+      expect(result[:shasum]).to eq('fakesha')
+      expect(result[:type]).to eq('apps')
+      expect(result[:id]).to eq(321)
+      expect(result[:service_id]).to eq(123)
+      expect(result[:container_id]).to eq('deadbeef')
+      expect(result[:uploaded_at]).to be(nil)
+      expect(result[:start_time]).to eq('2022-08-24T21:12:33')
+      expect(result[:end_time]).to eq('2022-08-24T21:14:38')
+    end
+
+    it 'can read db data from v3 paths' do
+      result = subject.info_from_path(v3db)
+      expect(result[:schema]).to eq('v3')
+      expect(result[:shasum]).to eq('fakesha')
+      expect(result[:type]).to eq('databases')
+      expect(result[:id]).to eq(321)
+      expect(result[:service_id]).to be(nil)
+      expect(result[:container_id]).to eq('fakebread')
+      expect(result[:uploaded_at]).to be(nil)
+      expect(result[:start_time]).to eq('2022-08-24T21:12:33')
+      expect(result[:end_time]).to eq('2022-08-24T21:14:38')
+    end
+
+    context 'files  that have been rotated by docker (.json.log.1)' do
+      it 'can read data from v3 paths' do
+        result = subject.info_from_path(v3db_rotated)
+        expect(result[:schema]).to eq('v3')
+        expect(result[:shasum]).to eq('fakesha')
+        expect(result[:type]).to eq('databases')
+        expect(result[:id]).to eq(321)
+        expect(result[:service_id]).to be(nil)
+        expect(result[:container_id]).to eq('fakebread')
+        expect(result[:uploaded_at]).to be(nil)
+        expect(result[:start_time]).to eq('2022-08-24T21:12:33')
+        expect(result[:end_time]).to eq('2022-08-24T21:14:38')
+      end
+
+      it 'can read app data from v2 paths' do
+        result = subject.info_from_path(v2app)
+        expect(result[:schema]).to eq('v2')
+        expect(result[:shasum]).to eq('fakesha')
+        expect(result[:type]).to eq('apps')
+        expect(result[:id]).to eq(321)
+        expect(result[:service_id]).to be(nil)
+        expect(result[:container_id]).to eq('fakebread')
+        expect(result[:uploaded_at]).to eq('2022-06-29T18:30:01')
+        expect(result[:container_id]).to eq('fakebread')
+        expect(result[:start_time]).to be(nil)
+        expect(result[:end_time]).to be(nil)
+      end
+    end
+  end
+
+  describe '#validate_log_search_options' do
+    it 'Forces you to identify the files with a supported option' do
+      opts = {}
+      expect { subject.validate_log_search_options(opts) }
+        .to raise_error(Thor::Error, / specify an option to identify/)
+    end
+
+    it 'Does not let you pass --string-matches and id options' do
+      opts = { string_matches: ['foo'], app_id: 123 }
+      expect { subject.validate_log_search_options(opts) }
+        .to raise_error(Thor::Error, /cannot pass/)
+    end
+
+    it 'Does not let you pass multiple id options' do
+      opts = { database_id: 12, app_id: 23 }
+      expect { subject.validate_log_search_options(opts) }
+        .to raise_error(Thor::Error, /specify only one of/)
+    end
+
+    it 'Does not let you use date options with string-matches' do
+      opts = { string_matches: 12, start_date: 'foo' }
+      expect { subject.validate_log_search_options(opts) }
+        .to raise_error(Thor::Error, /cannot be used when searching by string/)
+    end
+
+    it 'Does not allow open-ended date range.' do
+      opts = { app_id: 123, start_date: 'foo' }
+      expect { subject.validate_log_search_options(opts) }
+        .to raise_error(Thor::Error, /must pass both/)
+    end
+
+    it 'Ensures you have provided a long enough container ID' do
+      opts = { container_id: 'tooshort' }
+      expect { subject.validate_log_search_options(opts) }
+        .to raise_error(Thor::Error, /at least the first 12/)
+    end
+
+    it 'Requires you to pass keys when downloading' do
+      opts = { app_id: 123, download_location: 'asdf' }
+      expect { subject.validate_log_search_options(opts) }
+        .to raise_error(Thor::Error, /You must provide decryption keys/)
+    end
+  end
+
+  describe '#find_s3_files_by_string_match' do
+    client_stub = Aws::S3::Client.new(stub_responses: true)
+    client_stub.stub_responses(
+      :list_buckets, buckets: [{ name: 'bucket' }]
+    )
+    client_stub.stub_responses(
+      :list_objects_v2, contents: [
+        { key: 'stack/it/doesnt/matter' },
+        { key: 'stack/matter/it/does/not/yoda' }
+      ]
+    )
+    before do
+      subject.stub(:s3_client) do
+        Aws::S3::Resource.new(region: 'us-east-1', client: client_stub)
+      end
+    end
+
+    it 'finds files with a single matching string' do
+      strings = %w(yoda)
+      result = subject.find_s3_files_by_string_match('us-east-1', 'bucket',
+                                                     'stack', strings)
+      expect(result).to match_array(%w(stack/matter/it/does/not/yoda))
+    end
+
+    it 'finds files with two matching strings' do
+      strings = %w(it matter)
+      result = subject.find_s3_files_by_string_match('us-east-1', 'bucket',
+                                                     'stack', strings)
+      expect(result).to match_array(%w(stack/it/doesnt/matter
+                                       stack/matter/it/does/not/yoda))
+    end
+
+    it 'only find files with all matching strings' do
+      strings = %w(it yoda)
+      result = subject.find_s3_files_by_string_match('us-east-1', 'bucket',
+                                                     'stack', strings)
+      expect(result).to match_array(%w(stack/matter/it/does/not/yoda))
+    end
+  end
+
+  describe '#find_s3_files_by_attrs' do
+    before do
+      client_stub = Aws::S3::Client.new(stub_responses: true)
+      client_stub.stub_responses(
+        :list_buckets, buckets: [{ name: 'bucket' }]
+      )
+      client_stub.stub_responses(
+        :list_objects_v2, contents: [
+          { key: v2app },
+          { key: v2app_rotated },
+          { key: v3db_rotated },
+          { key: v3db },
+          { key: v3app }
+        ]
+      )
+      subject.stub(:s3_client) do
+        Aws::S3::Resource.new(region: 'us-east-1', client: client_stub)
+      end
+    end
+
+    it 'can find apps by id' do
+      attrs = { type: 'apps', id: 321 }
+      result = subject.find_s3_files_by_attrs('us-east-1', 'bucket',
+                                              'stack', attrs)
+      expect(result).to match_array([v3app, v2app, v2app_rotated])
+    end
+
+    it 'can find databases by id' do
+      attrs = { type: 'databases', id: 321 }
+      result = subject.find_s3_files_by_attrs('us-east-1', 'bucket',
+                                              'stack', attrs)
+      expect(result).to match_array([v3db, v3db_rotated])
+    end
+
+    it 'can find by other attributes of the log file like container id' do
+      attrs = { container_id: 'deadbeef' }
+      result = subject.find_s3_files_by_attrs('us-east-1', 'bucket',
+                                              'stack', attrs)
+      expect(result).to match_array([v3app])
+    end
+  end
+
+  describe '#time_match?' do
+    # Here's a represenation of the test cases.  We keep the file timestamps
+    # fixed and move  --start-date/--end-date around to all possible combos.
+    # Note that we do foce the start to be earlier than the end, which keeps the
+    # logic here quite simple.
+
+    #      |  |se
+    #      | s|e
+    #     s|  |e
+    #      |se|
+    #     s|e |
+    #    se|  |
+
+    # s = start / lower bound of search
+    # e = end / upper bound of search
+    # |'s are the first and last timestamp in the file
+
+    let(:first_log) { Time.parse('2022-08-01T00:00:00') }
+    let(:last_log) { Time.parse('2022-09-01T00:00:00') }
+    let(:before) { Time.parse('2022-07-01T00:00:00') }
+    let(:between) { Time.parse('2022-08-15T00:00:00') }
+    let(:after) { Time.parse('2022-10-01T00:00:00') }
+
+    context 'identifies files that may have lines within a range' do
+      it 'before before does not match' do
+        range = [before, before]
+        expect(subject.time_match?(range, first_log, last_log)).to be(false)
+      end
+
+      it 'before between matches' do
+        range = [before, between]
+        expect(subject.time_match?(range, first_log, last_log)).to be(true)
+      end
+
+      it 'between between matches' do
+        range = [between, between]
+        expect(subject.time_match?(range, first_log, last_log)).to be(true)
+      end
+
+      it 'before after matches' do
+        range = [before, after]
+        expect(subject.time_match?(range, first_log, last_log)).to be(true)
+      end
+
+      it 'between after matches' do
+        range = [between, after]
+        expect(subject.time_match?(range, first_log, last_log)).to be(true)
+      end
+
+      it 'after after does not match' do
+        range = [after, after]
+        expect(subject.time_match?(range, first_log, last_log)).to be(false)
+      end
+    end
+  end
+
+  describe '#utc_date' do
+    e = 'Please provide dates in YYYY-MM-DD format'
+
+    it 'converts strings to dates in UTC' do
+      result = subject.utc_date('2022-08-30')
+      expect(result).to be_a(Time)
+      expect(result).to eq(Time.utc(2022, 8, 30, 0, 0, 0))
+    end
+
+    it 'raises an error if the input is a valid date/tiem in wrong format' do
+      expect do
+        subject.utc_date('2022-08-30 11:32')
+      end.to raise_error(Thor::Error, e)
+    end
+
+    it 'raises an error if the input is wrong' do
+      expect do
+        subject.utc_date('foobar')
+      end.to raise_error(Thor::Error, e)
+    end
+  end
+end

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

@@ -60,4 +60,137 @@ describe Aptible::CLI::Agent do
       expect { subject.send(:logs) }.to raise_error(/only one of/im)
     end
   end
+
+  describe '#logs_from_archive' do
+    context 'using string-matches' do
+      let(:files) { %w(file_1 file_2) }
+
+      before do
+        subject.options = {
+          region: 'some-region',
+          bucket: 'some-bucket',
+          decryption_keys: 'mykey',
+          string_matches: 'foo',
+          download_location: './'
+        }
+        subject.stub(:info_from_path) { { shasum: 'foo' } }
+        subject.stub(:encryption_key) { subject.options[:decryption_keys] }
+      end
+
+      it 'download all files' do
+        expect(subject).to receive(:ensure_aws_creds)
+        expect(subject).to receive(:validate_log_search_options)
+          .with(subject.options)
+
+        expect(subject).to receive(:find_s3_files_by_string_match)
+          .with(
+            subject.options[:region],
+            subject.options[:bucket],
+            subject.options[:stack],
+            subject.options[:string_matches]
+          ).and_return(files)
+
+        files.each do |f|
+          expect(subject).to receive(:decrypt_and_translate_s3_file)
+            .with(
+              f,
+              subject.options[:decryption_keys],
+              subject.options[:region],
+              subject.options[:bucket],
+              subject.options[:download_location]
+            )
+        end
+        subject.send('logs_from_archive')
+      end
+    end
+
+    context 'using app/database/endpoint  id' do
+      let(:files) { %w(file_1 file_2) }
+
+      before do
+        subject.options = {
+          region: 'some-region',
+          bucket: 'some-bucket',
+          stack: 'mystack',
+          decryption_keys: 'mykey',
+          app_id: 123,
+          download_location: './'
+        }
+        subject.stub(:info_from_path) { { shasum: 'foo' } }
+        subject.stub(:encryption_key) { subject.options[:decryption_keys] }
+      end
+
+      it 'download all files' do
+        expect(subject).to receive(:ensure_aws_creds)
+        expect(subject).to receive(:validate_log_search_options)
+          .with(subject.options)
+
+        expect(subject).to receive(:find_s3_files_by_attrs)
+          .with(
+            subject.options[:region],
+            subject.options[:bucket],
+            subject.options[:stack],
+            { type: 'apps', id: 123 },
+            nil
+          ).and_return(files)
+
+        files.each do |f|
+          expect(subject).to receive(:decrypt_and_translate_s3_file)
+            .with(
+              f,
+              subject.options[:decryption_keys],
+              subject.options[:region],
+              subject.options[:bucket],
+              subject.options[:download_location]
+            )
+        end
+        subject.send('logs_from_archive')
+      end
+    end
+
+    context 'using container id' do
+      let(:files) { %w(file_1 file_2) }
+
+      before do
+        subject.options = {
+          region: 'some-region',
+          bucket: 'some-bucket',
+          stack: 'mystack',
+          decryption_keys: 'mykey',
+          container_id:
+            '9080b96447f98b31ef9831d5fd98b09e3c5c545269734e2e825644571152457c',
+          download_location: './'
+        }
+        subject.stub(:info_from_path) { { shasum: 'foo' } }
+        subject.stub(:encryption_key) { subject.options[:decryption_keys] }
+      end
+
+      it 'download all files' do
+        expect(subject).to receive(:ensure_aws_creds)
+        expect(subject).to receive(:validate_log_search_options)
+          .with(subject.options)
+
+        expect(subject).to receive(:find_s3_files_by_attrs)
+          .with(
+            subject.options[:region],
+            subject.options[:bucket],
+            subject.options[:stack],
+            { container_id: subject.options[:container_id] },
+            nil
+          ).and_return(files)
+
+        files.each do |f|
+          expect(subject).to receive(:decrypt_and_translate_s3_file)
+            .with(
+              f,
+              subject.options[:decryption_keys],
+              subject.options[:region],
+              subject.options[:bucket],
+              subject.options[:download_location]
+            )
+        end
+        subject.send('logs_from_archive')
+      end
+    end
+  end
 end

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

@@ -0,0 +1,189 @@
+require 'spec_helper'
+
+describe Aptible::CLI::Agent do
+  include Aptible::CLI::Helpers::DateHelpers
+
+  let(:token) { double('token') }
+
+  before do
+    allow(subject).to receive(:ask)
+    allow(subject).to receive(:save_token)
+    allow(subject).to receive(:fetch_token) { token }
+  end
+
+  let(:handle) { 'foobar' }
+  let(:stack) { Fabricate(:stack, internal_domain: 'aptible.in') }
+  let(:account) { Fabricate(:account, stack: stack) }
+  let(:database) { Fabricate(:database, handle: handle, account: account) }
+  let(:staging) { Fabricate(:account, handle: 'staging') }
+  let(:prod) { Fabricate(:account, handle: 'production') }
+  let(:window_start) { '2073-09-05T22:00:00.000Z' }
+  let(:window_end) { '2073-09-05T23:00:00.000Z' }
+  let(:maintenance_dbs) do
+    [
+      [staging, 'staging-redis-db', [window_start, window_end]],
+      [staging, 'staging-postgres-db', nil],
+      [prod, 'prod-elsearch-db', [window_start, window_end]],
+      [prod, 'prod-postgres-db', nil]
+    ].map do |a, h, m|
+      Fabricate(
+        :maintenance_database,
+        account: a,
+        handle: h,
+        maintenance_deadline: m
+      )
+    end
+  end
+  let(:maintenance_apps) do
+    [
+      [staging, 'staging-app-1', [window_start, window_end]],
+      [staging, 'staging-app-2', nil],
+      [prod, 'prod-app-1', [window_start, window_end]],
+      [prod, 'prod-app-2', nil]
+    ].map do |a, h, m|
+      Fabricate(
+        :maintenance_app,
+        account: a,
+        handle: h,
+        maintenance_deadline: m
+      )
+    end
+  end
+
+  describe '#maintenance:dbs' do
+    before do
+      token = 'the-token'
+      allow(subject).to receive(:fetch_token) { token }
+      allow(Aptible::Api::Account).to receive(:all)
+        .with(token: token)
+        .and_return([staging, prod])
+      allow(Aptible::Api::MaintenanceDatabase).to receive(:all)
+        .with(token: token)
+        .and_return(maintenance_dbs)
+    end
+
+    context 'when no account is specified' do
+      it 'prints out the grouped database handles for all accounts' do
+        subject.send('maintenance:dbs')
+
+        expect(captured_output_text).to include('=== staging')
+        expect(captured_output_text).to include('staging-redis-db')
+        expect(captured_output_text).to include('2073-09-05 22:00:00 UTC')
+        expect(captured_output_text).to include('2073-09-05 23:00:00 UTC')
+        expect(captured_output_text).not_to include('staging-postgres-db')
+
+        expect(captured_output_text).to include('=== production')
+        expect(captured_output_text).to include('prod-elsearch-db')
+        expect(captured_output_text).to include('2073-09-05 22:00:00 UTC')
+        expect(captured_output_text).to include('2073-09-05 23:00:00 UTC')
+        expect(captured_output_text).not_to include('prod-postgres-db')
+
+        expect(captured_output_json.to_s)
+          .to include(
+            'aptible db:restart staging-redis-db --environment staging'
+          )
+        expect(captured_output_json.to_s)
+          .to include(
+            'aptible db:restart prod-elsearch-db --environment production'
+          )
+      end
+    end
+
+    context 'when a valid account is specified' do
+      it 'prints out the database handles for the account' do
+        subject.options = { environment: 'staging' }
+        subject.send('maintenance:dbs')
+
+        expect(captured_output_text).to include('=== staging')
+        expect(captured_output_text).to include('staging-redis-db')
+        expect(captured_output_text).to include('2073-09-05 22:00:00 UTC')
+        expect(captured_output_text).to include('2073-09-05 23:00:00 UTC')
+        expect(captured_output_text).not_to include('staging-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')
+
+        expect(captured_output_json.to_s)
+          .to include(
+            'aptible db:restart staging-redis-db --environment staging'
+          )
+      end
+    end
+
+    context 'when an invalid account is specified' do
+      it 'prints out an error' do
+        subject.options = { environment: 'foo' }
+        expect { subject.send('maintenance:dbs') }
+          .to raise_error('Specified account does not exist')
+      end
+    end
+  end
+  describe '#maintenance:apps' do
+    before do
+      token = 'the-token'
+      allow(subject).to receive(:fetch_token) { token }
+      allow(Aptible::Api::Account).to receive(:all).with(token: token)
+        .and_return([staging, prod])
+      allow(Aptible::Api::MaintenanceApp).to receive(:all).with(token: token)
+        .and_return(maintenance_apps)
+    end
+
+    context 'when no account is specified' do
+      it 'prints out the grouped app handles for all accounts' do
+        subject.send('maintenance:apps')
+
+        expect(captured_output_text).to include('=== staging')
+        expect(captured_output_text).to include('staging-app-1')
+        expect(captured_output_text).to include('2073-09-05 22:00:00 UTC')
+        expect(captured_output_text).to include('2073-09-05 23:00:00 UTC')
+        expect(captured_output_text).not_to include('staging-app-2')
+
+        expect(captured_output_text).to include('=== production')
+        expect(captured_output_text).to include('prod-app-1')
+        expect(captured_output_text).to include('2073-09-05 22:00:00 UTC')
+        expect(captured_output_text).to include('2073-09-05 23:00:00 UTC')
+        expect(captured_output_text).not_to include('prod-app-2')
+
+        expect(captured_output_json.to_s)
+          .to include(
+            'aptible restart --app staging-app-1 --environment staging'
+          )
+        expect(captured_output_json.to_s)
+          .to include(
+            'aptible restart --app prod-app-1 --environment production'
+          )
+      end
+    end
+
+    context 'when a valid account is specified' do
+      it 'prints out the app handles for the account' do
+        subject.options = { environment: 'staging' }
+        subject.send('maintenance:apps')
+
+        expect(captured_output_text).to include('=== staging')
+        expect(captured_output_text).to include('staging-app-1')
+        expect(captured_output_text).to include('2073-09-05 22:00:00 UTC')
+        expect(captured_output_text).to include('2073-09-05 23:00:00 UTC')
+        expect(captured_output_text).not_to include('staging-app-2')
+
+        expect(captured_output_text).not_to include('=== production')
+        expect(captured_output_text).not_to include('prod-app-1')
+        expect(captured_output_text).not_to include('prod-app-2')
+
+        expect(captured_output_json.to_s)
+          .to include(
+            'aptible restart --app staging-app-1 --environment staging'
+          )
+      end
+    end
+
+    context 'when an invalid account is specified' do
+      it 'prints out an error' do
+        subject.options = { environment: 'foo' }
+        expect { subject.send('maintenance:apps') }
+          .to raise_error('Specified account does not exist')
+      end
+    end
+  end
+end

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

@@ -86,7 +86,7 @@ describe Aptible::CLI::Agent do
     end
 
     context 'influxdb:custom' do
-      it 'creates a new InfluxDB metric drain' do
+      it 'creates a new InfluxDB v1 metric drain' do
         opts = {
           handle: 'test-influxdb-custom',
           drain_type: :influxdb,
@@ -111,6 +111,32 @@ describe Aptible::CLI::Agent do
       end
     end
 
+    context 'influxdb:customv2' do
+      it 'creates a new InfluxDB v2 metric drain' do
+        opts = {
+          handle: 'test-influxdb2-custom',
+          drain_type: :influxdb2,
+          drain_configuration: {
+            address: 'https://test.foo.com:443',
+            org: 'foobar',
+            authToken: 'bar',
+            bucket: 'foo'
+          }
+        }
+        expect_provision_metric_drain(opts)
+
+        subject.options = {
+          environment: account.handle,
+          bucket: 'foo',
+          token: 'bar',
+          org: 'foobar',
+          url: 'https://test.foo.com:443'
+        }
+        subject.send('metric_drain:create:influxdb:customv2',
+                     'test-influxdb2-custom')
+      end
+    end
+
     context 'datadog' do
       it 'creates a new Datadog metric drain' do
         opts = {