interferon 0.1.0 → 0.1.3

data/spec/helpers/optica_helper.rb

@@ -1,93 +1,93 @@
 class OpticaHelper
   def self.example_node_1
     {
-      "ip" => "10.1.1.1",
-      "environment" => "production",
-      "role" => "role1",
-      "hostname" => "box1",
-      "uptime" => 37335310,
-      "az" => "us-east-1a",
-      "security_groups" => ["internal"],
-      "instance_type" => "m1.large",
-      "ami_id" => "ami-d9d6a6b0",
-      "failed" => false,
-      "roles" => ["role1"],
-      "recipes" => ["airbnb-base","cookbook1"],
-      "synapse_services" => ["service1","service2"],
-      "nerve_services" => [],
-      "ownership" => {
-        "people" => ["test_user@example.com"],
-        "groups" => ["admins"]
+      'ip' => '10.1.1.1',
+      'environment' => 'production',
+      'role' => 'role1',
+      'hostname' => 'box1',
+      'uptime' => 37_335_310,
+      'az' => 'us-east-1a',
+      'security_groups' => ['internal'],
+      'instance_type' => 'm1.large',
+      'ami_id' => 'ami-d9d6a6b0',
+      'failed' => false,
+      'roles' => ['role1'],
+      'recipes' => ['airbnb-base', 'cookbook1'],
+      'synapse_services' => %w(service1 service2),
+      'nerve_services' => [],
+      'ownership' => {
+        'people' => ['test_user@example.com'],
+        'groups' => ['admins'],
       },
-      "converger" => "ben_hughes"
+      'converger' => 'ben_hughes',
     }
   end
 
   def self.example_node_2
     {
-      "ip" => "10.1.1.2",
-      "environment" => "production",
-      "role" => "role2",
-      "hostname" => "box2",
-      "uptime" => 37335310,
-      "az" => "us-east-1b",
-      "security_groups" => ["internal"],
-      "instance_type" => "m1.large",
-      "ami_id" => "ami-d9d6a6b0",
-      "failed" => false,
-      "roles" => ["role2"],
-      "recipes" => ["airbnb-base","cookbook2"],
-      "synapse_services" => [],
-      "nerve_services" => ["service1"],
-      "ownership" => {
-        "people" => ["test_user@example.com"],
-        "groups" => ["admins"]
+      'ip' => '10.1.1.2',
+      'environment' => 'production',
+      'role' => 'role2',
+      'hostname' => 'box2',
+      'uptime' => 37_335_310,
+      'az' => 'us-east-1b',
+      'security_groups' => ['internal'],
+      'instance_type' => 'm1.large',
+      'ami_id' => 'ami-d9d6a6b0',
+      'failed' => false,
+      'roles' => ['role2'],
+      'recipes' => ['airbnb-base', 'cookbook2'],
+      'synapse_services' => [],
+      'nerve_services' => ['service1'],
+      'ownership' => {
+        'people' => ['test_user@example.com'],
+        'groups' => ['admins'],
       },
-      "converger" => "ben_hughes"
+      'converger' => 'ben_hughes',
     }
   end
 
   def self.example_node_3
     {
-      "ip" => "10.1.1.3",
-      "environment" => "production",
-      "role" => "role3",
-      "hostname" => "box3",
-      "uptime" => 37335310,
-      "az" => "us-east-1b",
-      "security_groups" => ["internal"],
-      "instance_type" => "m1.large",
-      "ami_id" => "ami-d9d6a6b0",
-      "failed" => false,
-      "roles" => ["role3"],
-      "recipes" => ["airbnb-base","cookbook3"],
-      "synapse_services" => [],
-      "nerve_services" => ["service2"],
-      "converger" => "ben_hughes"
+      'ip' => '10.1.1.3',
+      'environment' => 'production',
+      'role' => 'role3',
+      'hostname' => 'box3',
+      'uptime' => 37_335_310,
+      'az' => 'us-east-1b',
+      'security_groups' => ['internal'],
+      'instance_type' => 'm1.large',
+      'ami_id' => 'ami-d9d6a6b0',
+      'failed' => false,
+      'roles' => ['role3'],
+      'recipes' => ['airbnb-base', 'cookbook3'],
+      'synapse_services' => [],
+      'nerve_services' => ['service2'],
+      'converger' => 'ben_hughes',
     }
   end
 
   def self.example_node_4
     {
-      "ip" => "10.1.1.4",
-      "environment" => "production",
-      "role" => "role4",
-      "hostname" => "box4",
-      "uptime" => 37335310,
-      "az" => "us-east-1e",
-      "security_groups" => ["internal"],
-      "instance_type" => "m1.large",
-      "ami_id" => "ami-d9d6a6b0",
-      "failed" => false,
-      "roles" => ["role4"],
-      "recipes" => ["airbnb-base","cookbook4"],
-      "synapse_services" => [],
-      "nerve_services" => ["service1"],
-      "ownership" => {
-        "people" => ["test_user2@example.com"],
-        "groups" => ["engineers"]
+      'ip' => '10.1.1.4',
+      'environment' => 'production',
+      'role' => 'role4',
+      'hostname' => 'box4',
+      'uptime' => 37_335_310,
+      'az' => 'us-east-1e',
+      'security_groups' => ['internal'],
+      'instance_type' => 'm1.large',
+      'ami_id' => 'ami-d9d6a6b0',
+      'failed' => false,
+      'roles' => ['role4'],
+      'recipes' => ['airbnb-base', 'cookbook4'],
+      'synapse_services' => [],
+      'nerve_services' => ['service1'],
+      'ownership' => {
+        'people' => ['test_user2@example.com'],
+        'groups' => ['engineers'],
       },
-      "converger" => "ben_hughes"
+      'converger' => 'ben_hughes',
     }
   end
 
@@ -104,7 +104,7 @@ class OpticaHelper
     {
       'examined' => 3,
       'returned' => 3,
-      'nodes' =>  example_nodes
+      'nodes' => example_nodes,
     }
   end
 end

data/spec/lib/interferon/destinations/datadog_spec.rb

@@ -3,123 +3,122 @@ require 'interferon/destinations/datadog'
 
 describe Interferon::Destinations::Datadog do
   let(:retries) { 3 }
-  let(:datadog) {
-    Interferon::Destinations::Datadog.new({
+  let(:datadog) do
+    Interferon::Destinations::Datadog.new(
       'api_key' => 'TEST_API_KEY',
       'app_key' => 'TEST_APP_KEY',
-      'retries' => retries,
-    })
-  }
-  let(:datadog_dry_run) {
-    Interferon::Destinations::Datadog.new({
+      'retries' => retries
+    )
+  end
+  let(:datadog_dry_run) do
+    Interferon::Destinations::Datadog.new(
       'api_key' => 'TEST_API_KEY',
       'app_key' => 'TEST_APP_KEY',
       'retries' => retries,
-      'dry_run' => true,
-    })
-  }
+      'dry_run' => true
+    )
+  end
   let(:mock_alert_id) { 123 }
-  let(:mock_alert) {
+  let(:mock_alert) do
     {
       'id' => [mock_alert_id],
       'name' => 'Test Alert',
-      'message' => "Test Message",
+      'message' => 'Test Message',
       'metric' => { 'datadog_query' => 'avg:metric{*}' },
       'silenced' => {},
       'notify' => {},
     }
-  }
-  let(:mock_people) { ['foo', 'bar', 'baz'] }
-  let(:mock_response) {
+  end
+  let(:mock_people) { %w(foo bar baz) }
+  let(:mock_response) do
     {
-      "Test Alert" => {
-        "id" => 567,
-        "name" => 'Test Alert',
-        'message' => "Test Message",
-        "query" => 'avg:metric{*}',
-        "options" => {
-          "silenced" => {}
-        }
-      }
+      'Test Alert' => {
+        'id' => 567,
+        'name' => 'Test Alert',
+        'message' => 'Test Message',
+        'query' => 'avg:metric{*}',
+        'options' => {
+          'silenced' => {},
+        },
+      },
     }
-  }
+  end
 
-  describe ".get_existing_alerts" do
-    it "calls dogapi get_all_monitors" do
+  describe '.fetch_existing_alerts' do
+    it 'calls dogapi get_all_monitors' do
       expect_any_instance_of(Dogapi::Client).to receive(:get_all_monitors).and_return([200, []])
-      datadog.get_existing_alerts
+      datadog.fetch_existing_alerts
     end
   end
 
-  describe ".existing_alerts" do
-    it "retries dogapi get_all_monitors" do
-      return_vals = [[400, ""]] * (retries + 1)
+  describe '.existing_alerts' do
+    it 'retries dogapi get_all_monitors' do
+      return_vals = [[400, '']] * (retries + 1)
       expect_any_instance_of(Dogapi::Client).to receive(:get_all_monitors).and_return(*return_vals)
       expect { datadog.existing_alerts }.to raise_error RuntimeError
     end
   end
 
-  describe ".create_alert" do
-    it "calls dogapi monitor" do
-      expect_any_instance_of(Dogapi::Client).to receive(:monitor).and_return([200, ""])
+  describe '.create_alert' do
+    it 'calls dogapi monitor' do
+      expect_any_instance_of(Dogapi::Client).to receive(:monitor).and_return([200, ''])
       expect(datadog).to receive(:existing_alerts).and_return({})
       datadog.create_alert(mock_alert, mock_people)
     end
 
-    it "calls dogapi update_monitor when alert name is found" do
-      expect_any_instance_of(Dogapi::Client).to receive(:update_monitor).and_return([200, ""])
+    it 'calls dogapi update_monitor when alert name is found' do
+      expect_any_instance_of(Dogapi::Client).to receive(:update_monitor).and_return([200, ''])
       expect(datadog).to receive(:existing_alerts).and_return(mock_response)
       datadog.create_alert(mock_alert, mock_people)
     end
 
-    it "calls dogapi to delete and recreate when alert name is found" do
-      expect_any_instance_of(Dogapi::Client).to receive(:delete_monitor).and_return([200, ""])
-      expect_any_instance_of(Dogapi::Client).to receive(:monitor).and_return([200, ""])
-      mock_response["Test Alert"]["type"] = "event_alert"
+    it 'calls dogapi to delete and recreate when alert name is found' do
+      expect_any_instance_of(Dogapi::Client).to receive(:delete_monitor).and_return([200, ''])
+      expect_any_instance_of(Dogapi::Client).to receive(:monitor).and_return([200, ''])
+      mock_response['Test Alert']['type'] = 'event_alert'
       expect(datadog).to receive(:existing_alerts).and_return(mock_response)
       datadog.create_alert(mock_alert, mock_people)
     end
 
-    it "calls dogapi to unmute when exiting alert is muted" do
-      expect_any_instance_of(Dogapi::Client).to receive(:update_monitor).and_return([200, ""])
-      expect_any_instance_of(Dogapi::Client).to receive(:unmute_monitor).and_return([200, ""])
-      mock_response["Test Alert"]["options"]["silenced"] = { '*' => nil }
+    it 'calls dogapi to unmute when exiting alert is muted' do
+      expect_any_instance_of(Dogapi::Client).to receive(:update_monitor).and_return([200, ''])
+      expect_any_instance_of(Dogapi::Client).to receive(:unmute_monitor).and_return([200, ''])
+      mock_response['Test Alert']['options']['silenced'] = { '*' => nil }
       expect(datadog).to receive(:existing_alerts).and_return(mock_response)
       datadog.create_alert(mock_alert, mock_people)
     end
 
-    it "always calls monitor in dry-run" do
-      expect_any_instance_of(Dogapi::Client).to receive(:monitor).and_return([200, ""])
+    it 'always calls monitor in dry-run' do
+      expect_any_instance_of(Dogapi::Client).to receive(:monitor).and_return([200, ''])
       expect(datadog_dry_run).to receive(:existing_alerts).and_return(mock_response)
       datadog_dry_run.create_alert(mock_alert, mock_people)
     end
   end
 
-  describe ".remove_alert" do
-    it "calls dogapi delete_monitor with the correct alert id" do
-      mock_alert["message"] += Interferon::Destinations::Datadog::ALERT_KEY
-      expect_any_instance_of(Dogapi::Client).to receive(:delete_monitor).
-        with(mock_alert_id).and_return([200, ""])
+  describe '.remove_alert' do
+    it 'calls dogapi delete_monitor with the correct alert id' do
+      mock_alert['message'] += Interferon::Destinations::Datadog::ALERT_KEY
+      expect_any_instance_of(Dogapi::Client).to receive(:delete_monitor)
+        .with(mock_alert_id).and_return([200, ''])
       datadog.remove_alert(mock_alert)
     end
 
-    it "does not call dogapi delete_monitor in dry_run" do
-      mock_alert["message"] += Interferon::Destinations::Datadog::ALERT_KEY
+    it 'does not call dogapi delete_monitor in dry_run' do
+      mock_alert['message'] += Interferon::Destinations::Datadog::ALERT_KEY
       expect_any_instance_of(Dogapi::Client).to_not receive(:delete_monitor)
       datadog_dry_run.remove_alert(mock_alert)
     end
 
-    it "does not call dogapi delete_monitor when ALERT_KEY is missing" do
+    it 'does not call dogapi delete_monitor when ALERT_KEY is missing' do
       expect_any_instance_of(Dogapi::Client).to_not receive(:delete_monitor)
       datadog.remove_alert(mock_alert)
     end
-
   end
 
-  describe ".remove_alert_by_id" do
-    it "calls dogapi delete_monitor" do
-      expect_any_instance_of(Dogapi::Client).to receive(:delete_monitor).
-        with(mock_alert_id).and_return([200, ""])
+  describe '.remove_alert_by_id' do
+    it 'calls dogapi delete_monitor' do
+      expect_any_instance_of(Dogapi::Client).to receive(:delete_monitor)
+        .with(mock_alert_id).and_return([200, ''])
       datadog.remove_alert_by_id(mock_alert_id)
     end
   end

data/spec/lib/interferon/group_sources/filesystem_spec.rb

@@ -2,56 +2,61 @@ require 'spec_helper'
 require 'interferon/group_sources/filesystem'
 
 describe Interferon::GroupSources::Filesystem do
-  let (:fs_loader) { Interferon::GroupSources::Filesystem.new({'paths' => ['/tmp']}) }
+  let(:fs_loader) { Interferon::GroupSources::Filesystem.new('paths' => ['/tmp']) }
 
   describe 'list_groups' do
-    context "with basic groups" do
+    context 'with basic groups' do
       before do
-        group_a = double()
+        group_a = double
         expect(File).to receive(:read).with('group_a.yaml').and_return('group_a_text')
         expect(Psych).to receive(:parse).and_return(group_a)
-        expect(group_a).to receive(:to_ruby).and_return({'name' => 'group_a',
-                                                         'people' => ['Alice', 'Bob']})
+        expect(group_a).to receive(:to_ruby).and_return('name' => 'group_a',
+                                                        'people' => %w(Alice Bob))
 
-        group_b = double()
+        group_b = double
         expect(File).to receive(:read).with('group_b.yaml').and_return('group_b_text')
         expect(Psych).to receive(:parse).and_return(group_b)
-        expect(group_b).to receive(:to_ruby).and_return({'name' => 'group_b',
-                                                         'people' => ['Carol', 'Dave']})
+        expect(group_b).to receive(:to_ruby).and_return('name' => 'group_b',
+                                                        'people' => %w(Carol Dave))
       end
 
       it 'loads groups defined by YAML' do
         expect(Dir).to receive(:glob).and_return(['group_a.yaml', 'group_b.yaml'].each)
 
-        groups = fs_loader.list_groups()
-        expect(groups).to eq({'group_a' => ['Alice', 'Bob'], 'group_b' => ['Carol', 'Dave']})
+        groups = fs_loader.list_groups
+        expect(groups).to eq('group_a' => %w(Alice Bob), 'group_b' => %w(Carol Dave))
       end
 
       it 'allows groups to be aliased in YAML' do
-        expect(Dir).to receive(:glob).and_return(['group_a.yaml', 'group_b.yaml', 'group_c.yaml'].each)
-        group_c = double()
+        expect(Dir).to receive(:glob).and_return(['group_a.yaml',
+                                                  'group_b.yaml',
+                                                  'group_c.yaml',].each)
+        group_c = double
         expect(File).to receive(:read).with('group_c.yaml').and_return('group_c_text')
         expect(Psych).to receive(:parse).and_return(group_c)
-        expect(group_c).to receive(:to_ruby).and_return({'name' => 'group_c', 'alias_for' => 'group_b'})
+        expect(group_c).to receive(:to_ruby).and_return('name' => 'group_c',
+                                                        'alias_for' => 'group_b')
 
-        groups = fs_loader.list_groups()
-        expect(groups).to eq({'group_a' => ['Alice', 'Bob'],
-                              'group_b' => ['Carol', 'Dave'],
-                              'group_c' => ['Carol', 'Dave']})
+        groups = fs_loader.list_groups
+        expect(groups).to eq('group_a' => %w(Alice Bob),
+                             'group_b' => %w(Carol Dave),
+                             'group_c' => %w(Carol Dave))
       end
 
       it 'skips bad aliases in YAML' do
-        expect(Dir).to receive(:glob).and_return(['group_a.yaml', 'group_b.yaml', 'group_c.yaml'].each)
-        group_c = double()
+        expect(Dir).to receive(:glob).and_return(['group_a.yaml',
+                                                  'group_b.yaml',
+                                                  'group_c.yaml',].each)
+        group_c = double
         expect(File).to receive(:read).with('group_c.yaml').and_return('group_c_text')
         expect(Psych).to receive(:parse).and_return(group_c)
-        expect(group_c).to receive(:to_ruby).and_return({'name' => 'group_c', 'alias_for' => 'group_d'})
+        expect(group_c).to receive(:to_ruby).and_return('name' => 'group_c',
+                                                        'alias_for' => 'group_d')
 
-        groups = fs_loader.list_groups()
-        expect(groups).to eq({'group_a' => ['Alice', 'Bob'],
-                              'group_b' => ['Carol', 'Dave']})
+        groups = fs_loader.list_groups
+        expect(groups).to eq('group_a' => %w(Alice Bob),
+                             'group_b' => %w(Carol Dave))
       end
     end
   end
-
 end

data/spec/lib/interferon/host_sources/optica_services_spec.rb

@@ -3,7 +3,7 @@ require 'helpers/optica_helper'
 require 'interferon/host_sources/optica_services'
 
 describe Interferon::HostSources::OpticaServices do
-  let(:optica_services) { Interferon::HostSources::OpticaServices.new({'host'=>'127.0.0.1'}) }
+  let(:optica_services) { Interferon::HostSources::OpticaServices.new('host' => '127.0.0.1') }
 
   describe '.list_hosts' do
     before do
@@ -11,8 +11,8 @@ describe Interferon::HostSources::OpticaServices do
     end
 
     let(:list) { optica_services.list_hosts }
-    let(:service1) { list.select{|s| s[:service] == 'service1'}[0] }
-    let(:service2) { list.select{|s| s[:service] == 'service2'}[0] }
+    let(:service1) { list.select { |s| s[:service] == 'service1' }[0] }
+    let(:service2) { list.select { |s| s[:service] == 'service2' }[0] }
 
     it 'returns both of the services we know about' do
       expect(list.length).to eq(2)
@@ -27,7 +27,7 @@ describe Interferon::HostSources::OpticaServices do
           :owner_groups,
           :consumer_roles,
           :consumer_machine_count,
-          :provider_machine_count,
+          :provider_machine_count
         )
       end
     end
@@ -38,8 +38,11 @@ describe Interferon::HostSources::OpticaServices do
     end
 
     it 'knows that box1 is using both of the services' do
-      expect(list).to satisfy{|l| l.all?{
-          |s| s[:consumer_machine_count] == 1 && s[:consumer_roles] == ['role1']}}
+      expect(list).to satisfy do |l|
+        l.all? do |s|
+          s[:consumer_machine_count] == 1 && s[:consumer_roles] == ['role1']
+        end
+      end
     end
 
     it 'knows that service1 is provided by two machines' do
@@ -48,13 +51,12 @@ describe Interferon::HostSources::OpticaServices do
 
     it 'merges the ownership for all machines that provide service1' do
       all_owners = OpticaHelper.example_node_2['ownership']['people'] +
-        OpticaHelper.example_node_4['ownership']['people']
+                   OpticaHelper.example_node_4['ownership']['people']
       all_owner_groups = OpticaHelper.example_node_2['ownership']['groups'] +
-        OpticaHelper.example_node_4['ownership']['groups']
+                         OpticaHelper.example_node_4['ownership']['groups']
 
       expect(service1[:owners]).to contain_exactly(*all_owners)
       expect(service1[:owner_groups]).to contain_exactly(*all_owner_groups)
     end
   end
 end
-

data/spec/lib/interferon/host_sources/optica_spec.rb

@@ -3,7 +3,7 @@ require 'helpers/optica_helper'
 require 'interferon/host_sources/optica'
 
 describe Interferon::HostSources::Optica do
-  let(:optica) { Interferon::HostSources::Optica.new({'host'=>'127.0.0.1'}) }
+  let(:optica) { Interferon::HostSources::Optica.new('host' => '127.0.0.1') }
 
   describe '.list_hosts' do
     before do
@@ -23,8 +23,11 @@ describe Interferon::HostSources::Optica do
     end
 
     it 'does not barf if ownership info is missing' do
-      expect(list).to satisfy{|l| l.one?{|h| h[:owners].empty? && h[:owner_groups].empty?}}
+      expect(list).to satisfy do |l|
+        l.one? do |h|
+          h[:owners].empty? && h[:owner_groups].empty?
+        end
+      end
     end
   end
 end
-

data/spec/lib/interferon/loaders_spec.rb

@@ -1,5 +1,5 @@
-require "spec_helper"
-require "helpers/loader_helper"
+require 'spec_helper'
+require 'helpers/loader_helper'
 
 describe 'DynamicLoader' do
   describe 'custom class retrieval' do
@@ -10,7 +10,7 @@ describe 'DynamicLoader' do
 
     it 'throws an ArgumentError when the type cannot be found' do
       test_loader = TestLoader.new(['./spec/fixtures/loaders'])
-      expect{test_loader.get_klass('unknown_source')}.to raise_error(ArgumentError)
+      expect { test_loader.get_klass('unknown_source') }.to raise_error(ArgumentError)
     end
 
     it 'looks at custom paths in order' do
@@ -53,22 +53,25 @@ describe 'DynamicLoader' do
     it 'returns an instance for each enabled source' do
       instances = loader.get_all(
         [
-          {'type' => 'test_source', 'enabled' => true, 'options' => {}},
-          {'type' => 'secondary_source', 'enabled' => true, 'options' => {}},
-        ])
+          { 'type' => 'test_source', 'enabled' => true, 'options' => {} },
+          { 'type' => 'secondary_source', 'enabled' => true, 'options' => {} },
+        ]
+      )
 
       expect(instances.count).to eq(2)
       expect(instances).to contain_exactly(
         an_instance_of(Interferon::TestSources::TestSource),
-        an_instance_of(Interferon::TestSources::SecondarySource))
+        an_instance_of(Interferon::TestSources::SecondarySource)
+      )
     end
 
     it 'ignores non-enabled sources' do
       instances = loader.get_all(
         [
-          {'type' => 'test_source', 'enabled' => true, 'options' => {}},
-          {'type' => 'secondary_source', 'enabled' => false, 'options' => {}},
-        ])
+          { 'type' => 'test_source', 'enabled' => true, 'options' => {} },
+          { 'type' => 'secondary_source', 'enabled' => false, 'options' => {} },
+        ]
+      )
 
       expect(instances.count).to eq(1)
       expect(instances).to contain_exactly(an_instance_of(Interferon::TestSources::TestSource))
@@ -77,9 +80,10 @@ describe 'DynamicLoader' do
     it 'ignores sources with no type set' do
       instances = loader.get_all(
         [
-          {'type' => 'test_source', 'enabled' => true, 'options' => {}},
-          {'enabled' => true, 'options' => {}},
-        ])
+          { 'type' => 'test_source', 'enabled' => true, 'options' => {} },
+          { 'enabled' => true, 'options' => {} },
+        ]
+      )
 
       expect(instances.count).to eq(1)
       expect(instances).to contain_exactly(an_instance_of(Interferon::TestSources::TestSource))
@@ -87,10 +91,10 @@ describe 'DynamicLoader' do
 
     it 'properly sets options on classes it instantiates' do
       instances = loader.get_all(
-        [{'type' => 'test_source', 'enabled' => true, 'options' => {'testval' => 5}}])
+        [{ 'type' => 'test_source', 'enabled' => true, 'options' => { 'testval' => 5 } }]
+      )
 
       expect(instances[0].testval).to eq(5)
     end
   end
-
 end