outpost 0.1.0 → 0.2.0

data/outpost.gemspec

@@ -16,6 +16,4 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")                
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }   
   s.require_paths = ["lib"]   
-
-  s.add_dependency("net-ping", "~> 1.3.7")
 end

data/test/integration/{basic_dsl_test.rb → basic_application_test.rb}

@@ -2,7 +2,7 @@ require 'test_helper'
 
 require 'outpost/scouts/http'
 
-describe "basic DSL integration test" do
+describe "basic application integration test" do
   before(:each) do
     @server = Server.new
     @server.boot(TestApp)
@@ -12,28 +12,28 @@ describe "basic DSL integration test" do
     end
   end
 
-  class ExampleSuccess < Outpost::DSL
+  class ExampleSuccess < Outpost::Application
     using Outpost::Scouts::Http => 'master http server' do
       options :host => 'localhost', :port => 9595
       report :up, :response_code => 200
     end
   end
 
-  class ExampleFailure < Outpost::DSL
+  class ExampleFailure < Outpost::Application
     using Outpost::Scouts::Http => 'master http server' do
       options :host => 'localhost', :port => 9595, :path => '/fail'
       report :up, :response_code => 200
     end
   end
 
-  class ExampleBodyFailure < Outpost::DSL
+  class ExampleBodyFailure < Outpost::Application
     using Outpost::Scouts::Http => 'master http server' do
       options :host => 'localhost', :port => 9595, :path => '/fail'
       report :down, :response_body => {:equals => 'Omg fail'}
     end
   end
 
-  class ExampleBodySuccess < Outpost::DSL
+  class ExampleBodySuccess < Outpost::Application
     using Outpost::Scouts::Http => 'master http server' do
       options :host => 'localhost', :port => 9595, :path => '/'
       report :up, :response_body => {:match => /Up/}

data/test/integration/more_complex_test.rb

@@ -2,8 +2,17 @@ require 'test_helper'
 
 require 'outpost/scouts'
 
-describe "using more complex DSL integration test" do
-  class ExamplePingAndHttp < Outpost::DSL
+describe "using more complex application integration test" do
+  before(:each) do
+    @server = Server.new
+    @server.boot(TestApp)
+
+    while !@server.responsive?
+      sleep 0.1
+    end
+  end
+
+  class ExamplePingAndHttp < Outpost::Application
     using Outpost::Scouts::Http => 'master http server' do
       options :host => 'localhost', :port => 9595, :path => '/'
       report :up, :response_body => {:match => /Up/}
@@ -15,7 +24,7 @@ describe "using more complex DSL integration test" do
     end
   end
 
-  class ExampleOneFailingOnePassing < Outpost::DSL
+  class ExampleOneFailingOnePassing < Outpost::Application
     using Outpost::Scouts::Http => 'master http server' do
       options :host => 'localhost', :port => 9595, :path => '/'
       report :up, :response_body => {:match => /Up/}
@@ -27,7 +36,7 @@ describe "using more complex DSL integration test" do
     end
   end
 
-  class ExampleAllFailing < Outpost::DSL
+  class ExampleAllFailing < Outpost::Application
     using Outpost::Scouts::Http => 'master http server' do
       options :host => 'localhost', :port => 9595, :path => '/fail'
       report :up, :response_body => {:match => /Up/}
@@ -55,10 +64,13 @@ describe "using more complex DSL integration test" do
     outpost = ExampleAllFailing.new
     outpost.run
 
-    assert_equal "Outpost::Scouts::Http: 'master http server' is reporting down.",
-      outpost.messages.first
+    assert outpost.messages.include?(
+      "Outpost::Scouts::Http: 'master http server' is reporting down."
+    )
+
+    assert outpost.messages.include?(
+      "Outpost::Scouts::Ping: 'load balancer' is reporting down."
+    )
 
-    assert_equal "Outpost::Scouts::Ping: 'load balancer' is reporting down.",
-      outpost.messages.last
   end
 end

data/test/integration/notifiers_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+require 'outpost/scouts'
+require 'outpost/notifiers'
+
+describe "using notifiers" do
+  class ExampleMailNotifier < Outpost::Application
+    notify Outpost::Notifiers::Email, {
+      :from    => 'outpost@example.com',
+      :to      => 'sleep_deprived_admin@example.com',
+      :subject => 'System 1 status'
+    }
+
+    using Outpost::Scouts::Ping => 'load balancer' do
+      options :host => 'localhost'
+      report :down, :response_time => {:more_than => 0}
+    end
+  end
+
+  before(:each) do
+    Mail.defaults do
+      delivery_method :test
+    end
+
+    @outpost = ExampleMailNotifier.new
+    @outpost.run
+  end
+
+  after(:each) do
+    Mail::TestMailer.deliveries = []
+  end
+
+  it "should send email when asked to notify" do
+    @outpost.notify
+
+    refute_empty Mail::TestMailer.deliveries
+  end
+
+  it "should set email headers accordingly" do
+    @outpost.notify
+    message = Mail::TestMailer.deliveries.first
+
+    assert_equal 'outpost@example.com',              message.from.first.to_s
+    assert_equal 'sleep_deprived_admin@example.com', message.to.first.to_s
+    assert_equal 'System 1 status',                  message.subject.to_s
+  end
+
+  it "should not send email when not asked to notify" do
+    assert_empty Mail::TestMailer.deliveries
+  end
+end

data/test/outpost/dsl_test.rb

@@ -1,14 +1,30 @@
 require 'test_helper'
 
-describe Outpost::DSL do
+describe Outpost::Application do
   class ScoutMock
     class << self
       attr_accessor :status
     end
-    def run; self.class.status; end
+    def initialize(*args); end
+    def run              ; self.class.status ; end
   end
 
-  class ExampleOne < Outpost::DSL
+  class NotifierMock
+    class << self
+      attr_accessor :last_messages
+    end
+    attr_accessor :options
+
+    def initialize(options); @options = options; end
+
+    def notify(outpost)
+      self.class.last_messages = outpost.messages
+    end
+  end
+
+  class ExampleOne < Outpost::Application
+    notify NotifierMock, :email => 'mail@example.com'
+
     using ScoutMock => 'master http server' do
       options :host => 'localhost'
       report :up, :response_code => 200
@@ -30,6 +46,46 @@ describe Outpost::DSL do
     assert_equal({{:response_code => 200} => :up}, config.reports)
   end
 
+  it "should create notifiers configuration" do
+    notifiers = ExampleOne.notifiers
+    assert_equal({NotifierMock => {:email => 'mail@example.com'}}, notifiers)
+  end
+
+  describe "#run" do
+    it "should return up when scouts return up" do
+      ScoutMock.status = :up
+      assert_equal :up, ExampleOne.new.run
+    end
+
+    it "should return up when scouts return down" do
+      ScoutMock.status = :down
+      assert_equal :down, ExampleOne.new.run
+    end
+  end
+
+  describe "#notify" do
+    after(:each) do
+      NotifierMock.last_messages = nil
+    end
+
+    it "should run the notifications if there are reports to deliver" do
+      ScoutMock.status = :up
+
+      outpost = ExampleOne.new
+      outpost.run
+      outpost.notify
+
+      assert_equal "ScoutMock: 'master http server' is reporting up.",
+        NotifierMock.last_messages.first
+    end
+
+    it "should not run the notifications if there are no reports" do
+      ExampleOne.new.notify
+
+      refute NotifierMock.last_messages
+    end
+  end
+
   describe "#up?" do
     before(:each) do
       @outpost = ExampleOne.new
@@ -70,6 +126,21 @@ describe Outpost::DSL do
     end
   end
 
+  describe "#name" do
+    it "should be set as the class is informed" do
+      ExampleTwo = Class.new(ExampleOne)
+      ExampleTwo.class_eval do
+        name 'Example outpost'
+      end
+
+      assert_equal 'Example outpost', ExampleTwo.new.name
+    end
+
+    it "should be the class' name if it is not set" do
+      assert_equal 'ExampleOne', ExampleOne.new.name
+    end
+  end
+
   describe "#messages" do
     before(:each) do
       @outpost = ExampleOne.new

data/test/outpost/expectations/response_body_test.rb

@@ -16,58 +16,58 @@ describe Outpost::Expectations::ResponseBody do
 
   describe ".evaluate_response_body with match" do
     it "should return true when it matches" do
-      assert SubjectBody.evaluate_response_body(scout_mock, :match => /ll/)
+      assert SubjectBody.evaluate_response_body(scout_stub, :match => /ll/)
     end
 
     it "should return false when it doesn't" do
-      refute SubjectBody.evaluate_response_body(scout_mock, :match => /omg/)
+      refute SubjectBody.evaluate_response_body(scout_stub, :match => /omg/)
     end
   end
 
   describe ".evaluate_response_body with not_match" do
     it "should return true when it matches" do
-      assert SubjectBody.evaluate_response_body(scout_mock, :not_match => /omg/)
+      assert SubjectBody.evaluate_response_body(scout_stub, :not_match => /omg/)
     end
 
     it "should return false when it doesn't" do
-      refute SubjectBody.evaluate_response_body(scout_mock, :not_match => /Hello/)
+      refute SubjectBody.evaluate_response_body(scout_stub, :not_match => /Hello/)
     end
   end
 
   describe ".evaluate_response_body with equals" do
     it "should return true when it matches" do
-      assert SubjectBody.evaluate_response_body(scout_mock, :equals => "Hello!")
+      assert SubjectBody.evaluate_response_body(scout_stub, :equals => "Hello!")
     end
 
     it "should return false when it doesn't" do
-      refute SubjectBody.evaluate_response_body(scout_mock, :equals => "Hell")
+      refute SubjectBody.evaluate_response_body(scout_stub, :equals => "Hell")
     end
   end
 
   describe ".evaluate_response_body with differs" do
     it "should return true when it matches" do
-      assert SubjectBody.evaluate_response_body(scout_mock, :differs => "Hell")
+      assert SubjectBody.evaluate_response_body(scout_stub, :differs => "Hell")
     end
 
     it "should return false when it doesn't" do
-      refute SubjectBody.evaluate_response_body(scout_mock, :differs => "Hello!")
+      refute SubjectBody.evaluate_response_body(scout_stub, :differs => "Hello!")
     end
   end
 
   describe ".evaluate_response_body with multiple rules" do
     it "should return true when all rules matches" do
       rules = {:differs => 'omg', :match => /ll/}
-      assert SubjectBody.evaluate_response_body(scout_mock, rules)
+      assert SubjectBody.evaluate_response_body(scout_stub, rules)
     end
 
     it "should return false when there are no matches" do
       rules = {:equals => 'omg', :not_match => /ll/}
-      refute SubjectBody.evaluate_response_body(scout_mock, rules)
+      refute SubjectBody.evaluate_response_body(scout_stub, rules)
     end
 
     it "should return false when at least one rule doesn't match" do
       rules = {:equals => 'Hello!', :match => /Hell/, :differs => 'Hello!'}
-      refute SubjectBody.evaluate_response_body(scout_mock, rules)
+      refute SubjectBody.evaluate_response_body(scout_stub, rules)
     end
   end
 
@@ -81,9 +81,7 @@ describe Outpost::Expectations::ResponseBody do
   end
 
   private
-  def scout_mock
-    @scout_mock ||= OpenStruct.new.tap do |scout_mock|
-      scout_mock.response_body = 'Hello!'
-    end
+  def scout_stub
+    build_stub(:response_body => 'Hello!')
   end
 end

data/test/outpost/expectations/response_code_test.rb

@@ -16,15 +16,15 @@ describe Outpost::Expectations::ResponseCode do
   end
 
   it "should return true when response codes match" do
-    assert SubjectCode.evaluate_response_code(scout_mock, 200)
+    assert SubjectCode.evaluate_response_code(scout_stub, 200)
   end
 
   it "should return false when response codes doesn't match" do
-    refute SubjectCode.evaluate_response_code(scout_mock, 404)
+    refute SubjectCode.evaluate_response_code(scout_stub, 404)
   end
 
   it "should convert types accordinly" do
-    assert SubjectCode.evaluate_response_code(scout_mock, "200")
+    assert SubjectCode.evaluate_response_code(scout_stub, "200")
   end
 
   it "should set expectation correctly" do
@@ -37,9 +37,7 @@ describe Outpost::Expectations::ResponseCode do
   end
 
   private
-  def scout_mock
-    @scout_mock ||= OpenStruct.new.tap do |scout_mock|
-      scout_mock.response_code = 200
-    end
+  def scout_stub
+    build_stub(:response_code => 200)
   end
 end

data/test/outpost/expectations/response_time_test.rb

@@ -16,38 +16,38 @@ describe Outpost::Expectations::ResponseTime do
 
   describe ".evaluate_response_time with less_than" do
     it "should return true when it matches" do
-      assert SubjectTime.evaluate_response_time(scout_mock, :less_than => 5000)
+      assert SubjectTime.evaluate_response_time(scout_stub, :less_than => 5000)
     end
 
     it "should return false when it doesn't" do
-      refute SubjectTime.evaluate_response_time(scout_mock, :less_than => 1)
+      refute SubjectTime.evaluate_response_time(scout_stub, :less_than => 1)
     end
   end
 
   describe ".evaluate_response_time with more_than" do
     it "should return true when it matches" do
-      assert SubjectTime.evaluate_response_time(scout_mock, :more_than => 1)
+      assert SubjectTime.evaluate_response_time(scout_stub, :more_than => 1)
     end
 
     it "should return false when it doesn't" do
-      refute SubjectTime.evaluate_response_time(scout_mock, :more_than => 5000)
+      refute SubjectTime.evaluate_response_time(scout_stub, :more_than => 5000)
     end
   end
 
   describe ".evaluate_response_time with multiple rules" do
     it "should return true when all rules matches" do
       rules = {:more_than => 200, :less_than => 5000}
-      assert SubjectTime.evaluate_response_time(scout_mock, rules)
+      assert SubjectTime.evaluate_response_time(scout_stub, rules)
     end
 
     it "should return false when there are no matches" do
       rules = {:more_than => 700, :less_than => 200}
-      refute SubjectTime.evaluate_response_time(scout_mock, rules)
+      refute SubjectTime.evaluate_response_time(scout_stub, rules)
     end
 
     it "should return false when at least one rule doesn't match" do
       rules = {:more_than => 100, :less_than => 200}
-      refute SubjectTime.evaluate_response_time(scout_mock, rules)
+      refute SubjectTime.evaluate_response_time(scout_stub, rules)
     end
   end
 
@@ -61,10 +61,8 @@ describe Outpost::Expectations::ResponseTime do
   end
 
   private
-  def scout_mock
-    @scout_mock ||= OpenStruct.new.tap do |scout_mock|
-      scout_mock.response_time = 300
-    end
+  def scout_stub
+    build_stub(:response_time => 300)
   end
 end
 

data/test/outpost/notifiers/campfire_test.rb

@@ -0,0 +1,72 @@
+require 'test_helper'
+
+describe Outpost::Notifiers::Campfire do
+  class CampfireMock
+    class << self
+      attr_accessor :mock
+    end
+    def initialize(*args);                        end
+    def find_room_by_name(room); self.class.mock; end
+  end
+
+  describe "#initialize" do
+    it "should raise argument error if token is missing" do
+      params = {:subdomain => '123', :room => '123'}
+
+      assert_raises ArgumentError do
+        campfire = Outpost::Notifiers::Campfire.new(params)
+      end
+    end
+
+    it "should raise argument error if subdomain is missing" do
+      params = {:token => '123', :room => '123'}
+
+      assert_raises ArgumentError do
+        campfire = Outpost::Notifiers::Campfire.new(params)
+      end
+    end
+
+    it "should raise argument error if room is missing" do
+      params = {:token => '123', :subdomain => '123'}
+
+      assert_raises ArgumentError do
+        campfire = Outpost::Notifiers::Campfire.new(params)
+      end
+    end
+
+    it "should raise argument error if no attributes were supplied" do
+      assert_raises ArgumentError do
+        campfire = Outpost::Notifiers::Campfire.new
+      end
+    end
+  end
+
+  describe "#notify" do
+    it "should build the message" do
+      campfire_room_mock = MiniTest::Mock.new
+      campfire_room_mock.expect :speak, nil, ["System is up: 1,2"]
+
+      CampfireMock.mock = campfire_room_mock
+
+      params = {
+        :token             => '123',
+        :subdomain         => '123',
+        :room              => '123',
+        :campfire_notifier => CampfireMock
+      }
+
+      campfire = Outpost::Notifiers::Campfire.new(params)
+      campfire.notify(outpost_stub)
+
+      campfire_room_mock.verify
+    end
+  end
+
+  def outpost_stub
+    build_stub(
+      :name        => 'test outpost',
+      :last_status => :up,
+      :messages    => ['1', '2']
+    )
+  end
+end