datadog_backup 2.0.1 → 3.0.0.alpha.2

data/lib/datadog_backup/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DatadogBackup
-  VERSION = '2.0.1'
+  VERSION = '3.0.0.alpha.2'
 end

data/lib/datadog_backup.rb

@@ -2,17 +2,18 @@
 
 require 'concurrent'
 
-require 'dogapi'
-
 require_relative 'datadog_backup/local_filesystem'
 require_relative 'datadog_backup/options'
-
 require_relative 'datadog_backup/cli'
 require_relative 'datadog_backup/core'
 require_relative 'datadog_backup/dashboards'
 require_relative 'datadog_backup/monitors'
 require_relative 'datadog_backup/thread_pool'
 require_relative 'datadog_backup/version'
+require_relative 'datadog_backup/deprecations'
+DatadogBackup::Deprecations.check
+
 
 module DatadogBackup
 end
+

data/spec/datadog_backup/cli_spec.rb

@@ -3,64 +3,35 @@
 require 'spec_helper'
 
 describe DatadogBackup::Cli do
-  let(:api_service_double) { double(Dogapi::APIService) }
-  let(:client_double) { double }
+  let(:stubs) { Faraday::Adapter::Test::Stubs.new }
+  let(:api_client_double) { Faraday.new { |f| f.adapter :test, stubs } }
   let(:tempdir) { Dir.mktmpdir }
   let(:options) do
     {
       action: 'backup',
       backup_dir: tempdir,
-      client: client_double,
-      datadog_api_key: 1,
-      datadog_app_key: 1,
       diff_format: nil,
-      logger: Logger.new('/dev/null'),
       output_format: :json,
       resources: [DatadogBackup::Dashboards]
     }
   end
   let(:cli) { described_class.new(options) }
-  let(:dashboards) { DatadogBackup::Dashboards.new(options) }
+  let(:dashboards) do
+    dashboards = DatadogBackup::Dashboards.new(options)
+    allow(dashboards).to receive(:api_service).and_return(api_client_double)
+    return dashboards
+  end
 
   before do
     allow(cli).to receive(:resource_instances).and_return([dashboards])
   end
 
-  describe '#initialize_client' do
-    subject { described_class.new({ datadog_api_key: 1, datadog_app_key: 1 }).initialize_client }
-
-    it { is_expected.to be_a(Dogapi::Client) }
-
-    context 'when the environment variable DATADOG_HOST is set to a custom host like https://api.datadoghq.eu' do
-      before do
-        stub_const('ENV', 'DATADOG_HOST' => 'https://api.datadoghq.eu')
-      end
-
-      describe 'then #datadog_host is https://api.datadoghq.eu' do
-        subject { described_class.new({ datadog_api_key: 1, datadog_app_key: 1 }).initialize_client.datadog_host }
-
-        it { is_expected.to eq('https://api.datadoghq.eu') }
-      end
-    end
-
-    context 'when the environment variable DATADOG_HOST is not set' do
-      before do
-        stub_const('ENV', {})
-      end
-
-      describe 'then #datadog_host is https://api.datadoghq.eu' do
-        subject { described_class.new({ datadog_api_key: 1, datadog_app_key: 1 }).initialize_client.datadog_host }
-
-        it { is_expected.to eq('https://api.datadoghq.com') }
-      end
-    end
-  end
-
   describe '#backup' do
     context 'when dashboards are deleted in datadog' do
-      let(:all_boards) do
+      let(:all_dashboards) do
         [
-          '200',
+          200,
+          {},
           {
             'dashboards' => [
               { 'id' => 'stillthere' },
@@ -75,22 +46,9 @@ describe DatadogBackup::Cli do
         dashboards.write_file('{"text": "diff"}', "#{tempdir}/dashboards/alsostillthere.json")
         dashboards.write_file('{"text": "diff"}', "#{tempdir}/dashboards/deleted.json")
 
-        allow(client_double).to receive(:instance_variable_get).with(:@dashboard_service).and_return(api_service_double)
-        allow(api_service_double).to receive(:request).with(Net::HTTP::Get,
-                                                            '/api/v1/dashboard',
-                                                            nil,
-                                                            nil,
-                                                            false).and_return(all_boards)
-        allow(api_service_double).to receive(:request).with(Net::HTTP::Get,
-                                                            '/api/v1/dashboard/stillthere',
-                                                            nil,
-                                                            nil,
-                                                            false).and_return(['200', {}])
-        allow(api_service_double).to receive(:request).with(Net::HTTP::Get,
-                                                            '/api/v1/dashboard/alsostillthere',
-                                                            nil,
-                                                            nil,
-                                                            false).and_return(['200', {}])
+        stubs.get('/api/v1/dashboard') { all_dashboards }
+        stubs.get('/api/v1/dashboard/stillthere') {[200, {}, {}]}
+        stubs.get('/api/v1/dashboard/alsostillthere') {[200, {}, {}]}
       end
 
       it 'deletes the file locally as well' do
@@ -108,7 +66,6 @@ describe DatadogBackup::Cli do
       dashboards.write_file('{"text": "diff"}', "#{tempdir}/dashboards/diffs2.json")
       dashboards.write_file('{"text": "diff"}', "#{tempdir}/dashboards/diffs3.json")
       allow(dashboards).to receive(:get_by_id).and_return({ 'text' => 'diff2' })
-      allow(cli).to receive(:initialize_client).and_return(client_double)
     end
 
     it {
@@ -126,7 +83,6 @@ describe DatadogBackup::Cli do
     before do
       dashboards.write_file('{"text": "diff"}', "#{tempdir}/dashboards/diffs1.json")
       allow(dashboards).to receive(:get_by_id).and_return({ 'text' => 'diff2' })
-      allow(cli).to receive(:initialize_client).and_return(client_double)
     end
 
     example 'starts interactive restore' do

data/spec/datadog_backup/core_spec.rb

@@ -3,43 +3,23 @@
 require 'spec_helper'
 
 describe DatadogBackup::Core do
-  let(:api_service_double) { double(Dogapi::APIService) }
-  let(:client_double) { double }
+  let(:stubs) { Faraday::Adapter::Test::Stubs.new }
+  let(:api_client_double) { Faraday.new { |f| f.adapter :test, stubs } }
   let(:tempdir) { Dir.mktmpdir }
   let(:core) do
-    described_class.new(
+    core = described_class.new(
       action: 'backup',
-      api_service: api_service_double,
-      client: client_double,
       backup_dir: tempdir,
       diff_format: nil,
       resources: [],
-      output_format: :json,
-      logger: Logger.new('/dev/null')
+      output_format: :json
     )
+    allow(core).to receive(:api_service).and_return(api_client_double)
+    return core
   end
 
-  describe '#client' do
-    subject { core.client }
 
-    it { is_expected.to eq client_double }
-  end
-
-  describe '#with_200' do
-    context 'with 200' do
-      subject { core.with_200 { ['200', { foo: :bar }] } }
-
-      it { is_expected.to eq({ foo: :bar }) }
-    end
 
-    context 'with not 200' do
-      subject { core.with_200 { ['400', 'Error message'] } }
-
-      it 'raises an error' do
-        expect { subject }.to raise_error(RuntimeError)
-      end
-    end
-  end
 
   describe '#diff' do
     subject { core.diff('diff') }
@@ -84,52 +64,44 @@ describe DatadogBackup::Core do
   describe '#create' do
     subject { core.create({ 'a' => 'b' }) }
 
-    example 'it calls Dogapi::APIService.request' do
-      stub_const('Dogapi::APIService::API_VERSION', 'v1')
-      allow(core).to receive(:api_service).and_return(api_service_double)
+    example 'it will post /api/v1/dashboard' do
       allow(core).to receive(:api_version).and_return('v1')
       allow(core).to receive(:api_resource_name).and_return('dashboard')
-      expect(api_service_double).to receive(:request).with(Net::HTTP::Post,
-                                                           '/api/v1/dashboard',
-                                                           nil,
-                                                           { 'a' => 'b' },
-                                                           true).and_return(['200', { 'id' => 'whatever-id-abc' }])
+      stubs.post('/api/v1/dashboard', {'a' => 'b'}) {[200, {},  {'id' => 'whatever-id-abc' }]}
       subject
+      stubs.verify_stubbed_calls
     end
   end
 
   describe '#update' do
     subject { core.update('abc-123-def', { 'a' => 'b' }) }
 
-    example 'it calls Dogapi::APIService.request' do
-      stub_const('Dogapi::APIService::API_VERSION', 'v1')
-      allow(core).to receive(:api_service).and_return(api_service_double)
+    example 'it puts /api/v1/dashboard' do
       allow(core).to receive(:api_version).and_return('v1')
       allow(core).to receive(:api_resource_name).and_return('dashboard')
-      expect(api_service_double).to receive(:request).with(Net::HTTP::Put,
-                                                           '/api/v1/dashboard/abc-123-def',
-                                                           nil,
-                                                           { 'a' => 'b' },
-                                                           true).and_return(['200', { 'id' => 'whatever-id-abc' }])
+      stubs.put('/api/v1/dashboard/abc-123-def', {'a' => 'b'}) {[200, {},  {'id' => 'whatever-id-abc' }]}
       subject
+      stubs.verify_stubbed_calls
+    end
+
+    context 'when the id is not found' do
+      before do
+        allow(core).to receive(:api_version).and_return('v1')
+        allow(core).to receive(:api_resource_name).and_return('dashboard')
+        stubs.put('/api/v1/dashboard/abc-123-def', {'a' => 'b'}) {[404, {},  {'id' => 'whatever-id-abc' }]}
+      end
+      it 'raises an error' do
+        expect { subject }.to raise_error(RuntimeError, 'update failed with error 404')
+      end
     end
   end
 
   describe '#restore' do
     before do
-      allow(core).to receive(:api_service).and_return(api_service_double)
       allow(core).to receive(:api_version).and_return('api-version-string')
       allow(core).to receive(:api_resource_name).and_return('api-resource-name-string')
-      allow(api_service_double).to receive(:request).with(Net::HTTP::Get,
-                                                          '/api/api-version-string/api-resource-name-string/abc-123-def',
-                                                          nil,
-                                                          nil,
-                                                          false).and_return(['200', { test: :ok }])
-      allow(api_service_double).to receive(:request).with(Net::HTTP::Get,
-                                                          '/api/api-version-string/api-resource-name-string/bad-123-id',
-                                                          nil,
-                                                          nil,
-                                                          false).and_return(['404', { error: :blahblah_not_found }])
+      stubs.get('/api/api-version-string/api-resource-name-string/abc-123-def') {[200, {},  {'test'  => 'ok' }]}
+      stubs.get('/api/api-version-string/api-resource-name-string/bad-123-id') {[404, {},  {'error'  => 'blahblah_not_found' }]}
       allow(core).to receive(:load_from_file_by_id).and_return({ 'load' => 'ok' })
     end
 
@@ -142,19 +114,13 @@ describe DatadogBackup::Core do
       end
     end
 
-    context 'when id does not exist' do
+    context 'when id does not exist on remote' do
       subject { core.restore('bad-123-id') }
 
       before do
-        allow(api_service_double).to receive(:request).with(Net::HTTP::Put,
-                                                            '/api/api-version-string/api-resource-name-string/bad-123-id',
-                                                            nil, { 'load' => 'ok' },
-                                                            true).and_return(['404', { 'Error' => 'my not found' }])
-        allow(api_service_double).to receive(:request).with(Net::HTTP::Post,
-                                                            '/api/api-version-string/api-resource-name-string',
-                                                            nil,
-                                                            { 'load' => 'ok' },
-                                                            true).and_return(['200', { 'id' => 'my-new-id' }])
+        allow(core).to receive(:load_from_file_by_id).and_return({ 'load' => 'ok' })
+        stubs.put('/api/api-version-string/api-resource-name-string/bad-123-id') {[404, {},  {'error'  => 'id not found' }]}
+        stubs.post('/api/api-version-string/api-resource-name-string', {'load' => 'ok'}) {[200, {},  {'id' => 'my-new-id' }]}
       end
 
       example 'it calls out to create then saves the new file and deletes the new file' do

data/spec/datadog_backup/dashboards_spec.rb

@@ -3,18 +3,18 @@
 require 'spec_helper'
 
 describe DatadogBackup::Dashboards do
-  let(:api_service_double) { double(Dogapi::APIService) }
-  let(:client_double) { double }
+  let(:stubs) { Faraday::Adapter::Test::Stubs.new }
+  let(:api_client_double) { Faraday.new { |f| f.adapter :test, stubs } }
   let(:tempdir) { Dir.mktmpdir }
   let(:dashboards) do
-    described_class.new(
+    dashboards = described_class.new(
       action: 'backup',
-      client: client_double,
       backup_dir: tempdir,
       output_format: :json,
-      resources: [],
-      logger: Logger.new('/dev/null')
+      resources: []
     )
+    allow(dashboards).to receive(:api_service).and_return(api_client_double)
+    return dashboards
   end
   let(:dashboard_description) do
     {
@@ -23,9 +23,10 @@ describe DatadogBackup::Dashboards do
       'title' => 'foo'
     }
   end
-  let(:all_boards) do
+  let(:all_dashboards) do
     [
-      '200',
+      200,
+      {},
       {
         'dashboards' => [
           dashboard_description
@@ -35,7 +36,8 @@ describe DatadogBackup::Dashboards do
   end
   let(:example_dashboard) do
     [
-      '200',
+      200,
+      {},
       board_abc_123_def
     ]
   end
@@ -61,11 +63,8 @@ describe DatadogBackup::Dashboards do
   end
 
   before do
-    allow(client_double).to receive(:instance_variable_get).with(:@dashboard_service).and_return(api_service_double)
-    allow(api_service_double).to receive(:request).with(Net::HTTP::Get, '/api/v1/dashboard', nil, nil,
-                                                        false).and_return(all_boards)
-    allow(api_service_double).to receive(:request).with(Net::HTTP::Get, '/api/v1/dashboard/abc-123-def', nil, nil,
-                                                        false).and_return(example_dashboard)
+    stubs.get('/api/v1/dashboard') { all_dashboards }
+    stubs.get('/api/v1/dashboard/abc-123-def') { example_dashboard }
   end
 
   describe '#backup' do
@@ -81,8 +80,8 @@ describe DatadogBackup::Dashboards do
     end
   end
 
-  describe '#all_boards' do
-    subject { dashboards.all_boards }
+  describe '#all_dashboards' do
+    subject { dashboards.all_dashboards }
 
     it { is_expected.to eq [dashboard_description] }
   end

data/spec/datadog_backup/deprecations_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DatadogBackup::Deprecations do
+  let(:logger) { double }
+
+  before do
+    stub_const('LOGGER', logger)
+    allow(logger).to receive(:warn)
+  end
+
+  %w[2.4.10 2.5.9 2.6.8].each do |ruby_version|
+    describe "#check#{ruby_version}" do
+      subject { described_class.check }
+
+      it 'does warn' do
+        stub_const('RUBY_VERSION', ruby_version)
+        expect(logger).to receive(:warn).with(/ruby-#{ruby_version} is deprecated./)
+        subject
+      end
+    end
+  end
+
+  %w[2.7.4 3.0.4 3.1.2 3.2.0-preview1].each do |ruby_version|
+    describe "#check#{ruby_version}" do
+      subject { described_class.check }
+
+      it 'does not warn' do
+        stub_const('RUBY_VERSION', ruby_version)
+        expect(logger).to_not receive(:warn).with(/ruby-#{ruby_version} is deprecated./)
+        subject
+      end
+    end
+  end
+end

data/spec/datadog_backup/local_filesystem_spec.rb

@@ -3,26 +3,21 @@
 require 'spec_helper'
 
 describe DatadogBackup::LocalFilesystem do
-  let(:client_double) { double }
   let(:tempdir) { Dir.mktmpdir }
   let(:core) do
     DatadogBackup::Core.new(
       action: 'backup',
-      client: client_double,
       backup_dir: tempdir,
       resources: [DatadogBackup::Dashboards],
-      output_format: :json,
-      logger: Logger.new('/dev/null')
+      output_format: :json
     )
   end
   let(:core_yaml) do
     DatadogBackup::Core.new(
       action: 'backup',
-      client: client_double,
       backup_dir: tempdir,
       resources: [],
-      output_format: :yaml,
-      logger: Logger.new('/dev/null')
+      output_format: :yaml
     )
   end
 

data/spec/datadog_backup/monitors_spec.rb

@@ -3,19 +3,20 @@
 require 'spec_helper'
 
 describe DatadogBackup::Monitors do
-  let(:api_service_double) { double(Dogapi::APIService) }
-  let(:client_double) { double }
+  let(:stubs) { Faraday::Adapter::Test::Stubs.new }
+  let(:api_client_double) { Faraday.new { |f| f.adapter :test, stubs } }
   let(:tempdir) { Dir.mktmpdir }
   let(:monitors) do
-    described_class.new(
+    monitors = described_class.new(
       action: 'backup',
-      client: client_double,
       backup_dir: tempdir,
       output_format: :json,
-      resources: [],
-      logger: Logger.new('/dev/null')
+      resources: []
     )
+    allow(monitors).to receive(:api_service).and_return(api_client_double)
+    return monitors
   end
+
   let(:monitor_description) do
     {
       'query' => 'bar',
@@ -36,7 +37,8 @@ describe DatadogBackup::Monitors do
   end
   let(:all_monitors) do
     [
-      '200',
+      200,
+      {},
       [
         monitor_description
       ]
@@ -44,17 +46,15 @@ describe DatadogBackup::Monitors do
   end
   let(:example_monitor) do
     [
-      '200',
+      200,
+      {},
       monitor_description
     ]
   end
 
   before do
-    allow(client_double).to receive(:instance_variable_get).with(:@monitor_svc).and_return(api_service_double)
-    allow(api_service_double).to receive(:request).with(Net::HTTP::Get, '/api/v1/monitor', nil, nil,
-                                                        false).and_return(all_monitors)
-    allow(api_service_double).to receive(:request).with(Net::HTTP::Get, '/api/v1/dashboard/123455', nil, nil,
-                                                        false).and_return(example_monitor)
+    stubs.get('/api/v1/monitor') { all_monitors }
+    stubs.get('/api/v1/dashboard/123455') { example_monitor }
   end
 
   describe '#all_monitors' do
@@ -79,9 +79,10 @@ describe DatadogBackup::Monitors do
   describe '#diff and #except' do
     example 'it ignores `overall_state` and `overall_state_modified`' do
       monitors.write_file(monitors.dump(monitor_description), monitors.filename(123_455))
-      allow(api_service_double).to receive(:request).and_return(
+      stubs.get('/api/v1/dashboard/123455') {
         [
-          '200',
+          200,
+          {},
           [
             {
               'query' => 'bar',
@@ -93,7 +94,7 @@ describe DatadogBackup::Monitors do
             }
           ]
         ]
-      )
+      }
 
       expect(monitors.diff(123_455)).to eq ''
 

data/spec/datadog_backup_bin_spec.rb

@@ -17,13 +17,13 @@ describe 'bin/datadog_backup' do
         i.close
       end
 
-      Timeout.timeout(2.0) do
+      Timeout.timeout(4.0) do
         oe.each do |v|
           output += v
         end
       end
     rescue Timeout::Error
-      LOGGER.warn "Timing out #{t.inspect} after 2 second"
+      LOGGER.error "Timing out #{t.inspect} after 4 second"
       Process.kill(15, pid)
     ensure
       status = t.value
@@ -32,8 +32,8 @@ describe 'bin/datadog_backup' do
   end
 
   required_vars = %w[
-    DATADOG_API_KEY
-    DATADOG_APP_KEY
+    DD_API_KEY
+    DD_APP_KEY
   ]
 
   env = {}
@@ -52,7 +52,7 @@ describe 'bin/datadog_backup' do
   it 'supplies help' do
     stub_const('ENV', env)
     out_err, status = run_bin('--help')
-    expect(out_err).to match(/Usage: DATADOG_API_KEY=/)
+    expect(out_err).to match(/Usage: DD_API_KEY=/)
     expect(status).to be_success
   end
 end

data/spec/spec_helper.rb

@@ -2,16 +2,17 @@
 
 $LOAD_PATH.unshift(File.expand_path('../lib', File.dirname(__FILE__)))
 
-require 'datadog_backup'
 require 'logger'
-require 'tmpdir'
-require 'dogapi'
-
 $stdout.sync = $stderr.sync = true
-LOGGER = Logger.new($stderr) unless defined?(LOGGER)
-LOGGER.level = Logger::INFO
+LOGGER = Logger.new($stderr)
+LOGGER.level = Logger::ERROR
 $stdout = File.new('/dev/null', 'w+')
 
+require 'tmpdir'
+require 'datadog_backup'
+
+
+
 SPEC_ROOT = __dir__
 WORK_ROOT = File.expand_path(File.join(SPEC_ROOT, '..'))