observed 0.1.1

data/spec/builtin_plugins/stdout_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+require 'observed/builtin_plugins/stdout'
+
+describe Observed::BuiltinPlugins::Stdout do
+
+  subject {
+    reporter = Observed::BuiltinPlugins::Stdout.new
+    reporter.configure config
+    reporter
+  }
+
+  let(:config) {
+    { tag_pattern: /foo\..+/, format: formatter }
+  }
+
+  context 'with a specific formatter' do
+
+    let(:formatter) {
+      -> tag, time, data, fetcher { "foo #{time.to_i} #{data[:foo]} #{fetcher['bar.baz']}" }
+    }
+
+    it 'reports the formatted data to the stdout' do
+      time = Time.now
+      STDOUT.expects(:puts).with("foo #{time.to_i} 1 2")
+      expect { subject.report('foo', time, {foo: 1, bar: {baz: 2}}) }.to_not raise_error
+    end
+
+  end
+
+  context 'without a specific formatter' do
+
+    let(:formatter) {
+      nil
+    }
+
+    it 'reports the data formatted by the default formatter to the stdout' do
+      time = Time.now
+      STDOUT.expects(:puts).with("#{time.to_s} foo {:foo=>1}")
+      expect { subject.report('foo', time, {foo: 1}) }.to_not raise_error
+    end
+
+  end
+
+  context 'with the formatter whose number of parameters is not 3 nor 4' do
+
+    let(:formatter) {
+      -> a, b {}
+    }
+
+    it 'fails while reporting' do
+      pattern = /Number of parameters for the function for the key :format must be 3 or 4, but was 2/
+      expect { subject.report('foo', Time.now, {}) }.to raise_error(pattern)
+    end
+  end
+end

data/spec/config_builder_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+require 'observed/config_builder'
+
+describe Observed::ConfigBuilder do
+
+  include FakeFS::SpecHelpers
+
+  subject {
+    Observed::ConfigBuilder.new(
+        writer_plugins: writer_plugins,
+        reader_plugins: reader_plugins,
+        observer_plugins: observer_plugins,
+        reporter_plugins: reporter_plugins,
+        system: system
+    )
+  }
+
+  let(:system) {
+    mock('system')
+  }
+
+  let(:observer_plugins) {
+    my_file = Class.new(Observed::Observer) do
+      attribute :path
+      attribute :key
+      def observe
+        content = File.open(path, 'r') do |f|
+          f.read
+        end
+        system.report(tag, { key => content })
+      end
+    end
+    { 'my_file' => my_file }
+  }
+
+  let(:reporter_plugins) {
+    my_stdout = Class.new(Observed::Reporter) do
+      attribute :format
+      def match(tag)
+        true
+      end
+      def report(tag, time, data)
+        text = format.call tag, time, data, Observed::Hash::Fetcher.new(data)
+        STDOUT.puts text
+      end
+    end
+    { 'my_stdout' => my_stdout }
+  }
+
+  let(:writer_plugins) {
+    stdout = Class.new(Observed::Writer) do
+      attribute :format
+      def write(tag, time, data)
+        text = format.call tag, time, data, Observed::Hash::Fetcher.new(data)
+        STDOUT.puts text
+      end
+    end
+    { 'stdout' => stdout }
+  }
+
+  let(:reader_plugins) {
+    file = Class.new(Observed::Reader) do
+      attribute :path
+      attribute :key
+      def read
+        content = File.open(path, 'r') do |f|
+          f.read
+        end
+        { key => content }
+      end
+    end
+    {
+        'file' => file
+    }
+  }
+
+  it 'creates writers' do
+    time = Time.now
+    subject.write to: 'stdout', with: {
+      format: -> tag, time, data, d { "value:#{d['foo.bar']}" }
+    }
+    STDOUT.expects(:puts).with('value:123')
+    expect { subject.build.writers.first.write('foo.bar', time, {foo:{bar:123}}) }.to_not raise_error
+  end
+
+  it 'creates readers' do
+    subject.read from: 'file', with: {
+      path: 'foo.txt',
+      key: 'content'
+    }
+    File.open('foo.txt', 'w') do |f|
+      f.write('file content')
+    end
+    expect(subject.build.readers.first.read).to eq({ 'content' => 'file content' })
+  end
+
+  it 'creates observers from reader plugins' do
+    subject.observe 'foo.bar', from: 'file', with: {
+      path: 'foo.txt',
+      key: 'content'
+    }
+    File.open('foo.txt', 'w') do |f|
+      f.write('file content')
+    end
+    system.expects(:report).with('foo.bar', { 'content' => 'file content' })
+    expect { subject.build.observers.first.observe }.to_not raise_error
+  end
+
+  it 'creates observers from observer plugins' do
+    subject.observe 'foo.bar', via: 'my_file', which: {
+        path: 'foo.txt',
+        key: 'content'
+    }
+    File.open('foo.txt', 'w') do |f|
+      f.write('file content')
+    end
+    system.expects(:report).with('foo.bar', { 'content' => 'file content' })
+    expect { subject.build.observers.first.observe }.to_not raise_error
+  end
+
+  it 'creates reporters from writer plugins' do
+    tag = 'foo.bar'
+    time = Time.now
+
+    subject.report /foo\.bar/, to: 'stdout', with: {
+      format: -> tag, time, data, d { "foo.bar #{time} #{d[tag]}" }
+    }
+    reporter = subject.reporters.first
+    STDOUT.expects(:puts).with("foo.bar #{time} 123").once
+    expect(reporter.match(tag)).to be_true
+    expect { reporter.report(tag, time, { foo: { bar: 123 }}) }.to_not raise_error
+  end
+
+  it 'creates reporters from reporter plugins' do
+    tag = 'foo.bar'
+    time = Time.now
+
+    subject.report /foo\.bar/, via: 'my_stdout', with: {
+        format: -> tag, time, data, d { "foo.bar #{time} #{d[tag]}" }
+    }
+    reporter = subject.reporters.first
+    STDOUT.expects(:puts).with("foo.bar #{time} 123").once
+    expect(reporter.match(tag)).to be_true
+    expect { reporter.report(tag, time, { foo: { bar: 123 }}) }.to_not raise_error
+  end
+end

data/spec/config_dsl_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'observed/config_dsl'
+require 'observed/observer'
+require 'observed/reporter'
+require 'observed/reporter/regexp_matching'
+require 'observed/config_builder'
+
+describe Observed::ConfigDSL do
+  subject {
+    Observed::ConfigDSL.new(builder: Observed::ConfigBuilder.new(
+        observer_plugins: observer_plugins,
+        reporter_plugins: reporter_plugins,
+        system: sys
+    ))
+  }
+  let(:foo) {
+    Class.new(Observed::Observer) do
+      def observe
+
+      end
+      plugin_name 'foo'
+    end
+  }
+  let(:stdout) {
+    Class.new(Observed::Reporter) do
+      include Observed::Reporter::RegexpMatching
+      def report(tag, time, data)
+
+      end
+      plugin_name 'stdout'
+    end
+  }
+  let(:sys) {
+    mock('sys')
+  }
+  let(:observer_plugins) {
+    { 'foo' => foo }
+  }
+  let(:reporter_plugins) {
+    { 'stdout' => stdout }
+  }
+  it 'creates a config' do
+    subject.instance_eval do
+      observe 'foo', via: 'foo', with: { name: 'name' }
+      report /foo/, via: 'stdout'
+    end
+
+    #expect(subject.config).to eq({ observers: {'foo' => {plugin: 'foo', name: 'name'}}, reporters: {'foo' => {plugin: 'stdout'}}})
+  end
+end

data/spec/configurable_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'observed/configurable'
+
+module ConfigurableSpec
+  class Foo
+    include Observed::Configurable
+
+    attribute :foo, default: 123
+    attribute :bar, default: 234
+    attribute :baz
+
+    default :bar => 345
+  end
+end
+
+describe Observed::Configurable do
+
+  context 'without parameters for the constructor' do
+    subject {
+      ConfigurableSpec::Foo.new
+    }
+    it 'uses default values for attributes' do
+      expect(subject.foo).to eq(123)
+    end
+    it 'overrides default values on `attribute name, :default => default_value`' do
+      expect(subject.bar).to eq(345)
+    end
+    it 'raises errors when attributes without values are read' do
+      expect { subject.baz }.to raise_error
+    end
+  end
+
+  context 'with parameters for the constructor' do
+    subject {
+      ConfigurableSpec::Foo.new({foo: 1, bar: 2, baz: 3})
+    }
+    it 'prefers values from constructor parameters over defaults' do
+      expect(subject.foo).to eq(1)
+      expect(subject.bar).to eq(2)
+      expect(subject.baz).to eq(3)
+    end
+  end
+
+  context 'configured through `configure(args)` method' do
+    subject {
+      foo = ConfigurableSpec::Foo.new
+      foo.configure(args)
+      foo
+    }
+    shared_examples_for 'values are set' do
+      it 'prefers values from `configure(args)` over defaults' do
+        expect(subject.foo).to eq(1)
+        expect(subject.bar).to eq(2)
+        expect(subject.baz).to eq(3)
+      end
+    end
+    context 'when args has symbol keys' do
+      let(:args) {
+        {foo: 1, bar: 2, baz: 3}
+      }
+      it_behaves_like 'values are set'
+    end
+  end
+
+end

data/spec/fixtures/configure_by_conf/foo_plugin.rb

@@ -0,0 +1,12 @@
+module OneshotSpec
+  class FooPlugin < Observed::Observer
+
+    def observe
+      sleep_duration = rand / 20
+      sleep sleep_duration
+      system.report(tag, system.now, "Foo #{sleep_duration}")
+    end
+
+    plugin_name 'foo'
+  end
+end

data/spec/fixtures/configure_by_conf/observed.conf

@@ -0,0 +1,6 @@
+require 'observed/builtin_plugins'
+require_relative 'foo_plugin'
+
+observe 'foo_1', via: 'foo'
+
+report 'foo_1', via: 'stdout'

data/spec/fixtures/configure_by_conf_dot_d/foo_plugin.rb

@@ -0,0 +1,18 @@
+module OneshotSpec
+  class FooPlugin < Observed::Observer
+    default :timeout_in_milliseconds => 5000
+    default :number_of_trials => 10
+
+    def sample
+      sleep_duration = rand / 20
+      sleep sleep_duration
+      "Foo #{sleep_duration}"
+    end
+
+    def logger
+      Logger.new(STDOUT)
+    end
+
+    plugin_name 'foo'
+  end
+end

data/spec/fixtures/configure_by_conf_dot_d/observed.conf.d/check_foo_1.rb

@@ -0,0 +1 @@
+observe 'foo_1', via: 'foo'

data/spec/fixtures/configure_by_conf_dot_d/observed.conf.d/plugins.rb

@@ -0,0 +1 @@
+require_relative '../foo_plugin'

data/spec/fixtures/configure_by_require/observed_conf.rb

@@ -0,0 +1,6 @@
+require 'observed'
+include Observed
+
+require_relative '../configure_by_conf/foo_plugin'
+
+observe 'foo', via: 'foo'

data/spec/hash/builder_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'observed/hash/builder'
+
+describe Observed::Hash::Builder do
+
+  subject {
+    described_class.new(hash)
+  }
+
+  context 'with a source hash' do
+
+    let(:hash) { {} }
+
+    context 'with a key path' do
+      it 'decodes the key path and recursively creates missing Hash object for each part in the key path' do
+        subject['foo.bar'] = 1
+
+        expect(subject.build).to eq({foo:{bar:1}})
+      end
+    end
+
+    context 'with a regular string key' do
+      it 'updates the value for the key' do
+        subject['foo'] = 1
+        expect(subject.build).to eq({foo:1})
+      end
+    end
+
+    context 'with a regular symbol key' do
+      it 'updates the value for the key' do
+        subject[:foo] = 1
+        expect(subject.build).to eq({foo:1})
+      end
+    end
+  end
+end

data/spec/hash/fetcher_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+require 'observed/hash/fetcher'
+
+describe Observed::Hash::Fetcher do
+
+  subject {
+    described_class.new(hash)
+  }
+
+  context 'when the source hash is nil' do
+
+    let(:hash) { nil }
+
+    it 'fails' do
+      expect { subject }.to raise_error
+    end
+  end
+
+  context 'when the source hash is nested' do
+
+    let(:hash) { {foo:{bar:1},baz:2} }
+
+    it 'decodes the key path to recursively find the value' do
+      expect(subject['foo.bar']).to eq(1)
+      expect(subject['baz']).to eq(2)
+    end
+  end
+end

data/spec/input_helpers/timer_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'observed/observer_helpers/timer'
+require 'observed/observer'
+
+describe Observed::ObserverHelpers::Timer do
+
+  include Observed::SpecHelpers
+
+  before {
+    class ExampleTimerPlugin < Observed::Observer
+      include Observed::ObserverHelpers::Timer
+
+      attribute :timeout_in_milliseconds
+      attribute :time_to_sleep
+
+      def observe
+        time_and_report(timeout_in_seconds: self.timeout_in_milliseconds / 1000.0) do
+          sleep(time_to_sleep)
+          time_to_sleep
+        end
+      end
+
+      def self.plugin_name
+        'timer'
+      end
+    end
+  }
+
+  subject {
+    input = ExampleTimerPlugin.new
+    input.configure system: system, tag: 'foo.timed', time_to_sleep: 0.001, timeout_in_milliseconds: 1000
+    input
+  }
+
+  let(:system) {
+    m = mock('system')
+    m.stubs(:now).returns(1.0)
+      .then.returns(2.0)
+      .then.returns(3.0)
+      .then.returns(5.0)
+      .then.returns(6.0)
+      .then.returns(9.0)
+    m
+  }
+
+  it 'should report results with elapsed times' do
+    system.expects(:report).with('foo.timed.success', status: :success, elapsed_time: 1.0, result: 0.001)
+    system.expects(:report).with('foo.timed.success', status: :success, elapsed_time: 2.0, result: 0.001)
+    system.expects(:report).with('foo.timed.success', status: :success, elapsed_time: 3.0, result: 0.001)
+    subject.observe
+    subject.observe
+    subject.observe
+  end
+end

data/spec/observed_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+require 'observed'
+require 'observed/builtin_plugins'
+
+describe Observed do
+  include FakeFS::SpecHelpers
+
+  describe '#load!`' do
+
+    context 'with a relative file path under the current working directory' do
+
+      subject do
+        mod = Module.new do
+          extend Observed
+        end
+        mod.load! './observed.rb'
+        mod.config
+      end
+
+      context 'with invalid file path' do
+        it 'should raise an error while loading' do
+          expect { subject }.to raise_error(%r|No such file or directory.+observed\.rb|)
+        end
+      end
+
+      context 'with a valid relative file path' do
+        before do
+          File.open('./observed.rb', 'w') do |file|
+            file.write(
+                <<-EOS
+                report /foo/, via: 'stdout'
+                EOS
+            )
+          end
+        end
+
+        it 'should load observed.rb' do
+          expect { subject }.to_not raise_error
+        end
+      end
+    end
+
+    context 'with an absolute file path' do
+
+      subject {
+        mod = Module.new do
+          extend Observed
+        end
+        mod.load! '/tmp/foo/observed_conf.rb'
+        mod.config
+      }
+
+      context 'when the file does not exist' do
+
+        it 'fails to load it' do
+          expect { subject }.to raise_error(%r|No such file or directory - /tmp/foo/observed_conf.rb|)
+        end
+      end
+
+      context 'when the file exists' do
+
+        before {
+          FileUtils.mkdir_p('/tmp/foo')
+          File.open('/tmp/foo/observed_conf.rb', 'w') do |f|
+            f.write(
+                <<-EOS
+                report /foo/, via: 'stdout'
+                EOS
+            )
+          end
+        }
+
+        it 'succeeds to load it' do
+          expect { subject }.to_not raise_error
+        end
+      end
+    end
+  end
+end

data/spec/observer_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+require 'observed/observer'
+
+describe Observed::Observer do
+
+  subject {
+    described_class.new(tag: 'the_tag', system: sys)
+  }
+
+  let(:sys) { mock('system') }
+
+  it 'fails when the method `observe` is not overrode' do
+    expect { subject.observe }.to raise_error
+  end
+
+  describe 'attribute' do
+
+    it 'can be given by constructor parameters' do
+      klass = Class.new(Observed::Observer) do
+                attribute :timeout_in_milliseconds
+                attribute :number_of_trials
+              end
+
+      subject = klass.new(
+          timeout_in_milliseconds: 5000,
+          number_of_trials: 5000,
+          tag: 'tag'
+      )
+
+      expect(subject.timeout_in_milliseconds).to eq(5000)
+      expect(subject.number_of_trials).to eq(5000)
+      expect(subject.tag).to eq('tag')
+    end
+
+    it 'can have a default value' do
+      klass = Class.new(Observed::Observer) do
+                attribute :timeout_in_milliseconds
+                attribute :number_of_trials
+                default :timeout_in_milliseconds => 5000
+                default :number_of_trials => 5000
+                default :tag => 'tag'
+              end
+
+      subject = klass.new
+
+      expect(subject.timeout_in_milliseconds).to eq(5000)
+      expect(subject.number_of_trials).to eq(5000)
+      expect(subject.tag).to eq('tag')
+    end
+
+    context 'without a default value or a given value' do
+      it 'raises errors when accessed' do
+        klass = Class.new(Observed::Observer) do
+                  attribute :timeout_in_milliseconds
+                  attribute :number_of_trials
+                end
+
+        subject = klass.new
+
+        expect { subject.timeout_in_milliseconds }.to raise_error
+        expect { subject.number_of_trials }.to raise_error
+        expect { subject.tag }.to raise_error
+      end
+    end
+
+  end
+
+  describe '.find_plugin_named' do
+
+    it 'returns nil when no plugin with the specific name found' do
+      expect(Observed::Observer.find_plugin_named('an_invalid_name')).to be_nil
+    end
+
+    context 'with one named plugin' do
+      let(:klass) {
+        Class.new(Observed::Observer) do
+          attribute :timeout_in_milliseconds
+          attribute :number_of_trials
+
+          default :timeout_in_milliseconds => 5000
+          default :number_of_trials => 2
+
+          def sample
+            time_to_sleep = rand / 100
+            sleep rand
+            "Foo #{time_to_sleep}"
+          end
+
+          plugin_name 'observer_spec_foo'
+        end
+      }
+      before {
+        klass
+      }
+      it 'returns the plugin' do
+        expect(Observed::Observer.find_plugin_named('observer_spec_foo')).to eq(klass)
+      end
+    end
+
+    context 'with two named plugins' do
+      let(:bar) {
+        Class.new(Observed::Observer) do
+          plugin_name 'observer_spec_bar'
+        end
+      }
+      let(:baz) {
+        Class.new(Observed::Observer) do
+          plugin_name 'observer_spec_baz'
+        end
+      }
+      before {
+        bar
+        baz
+      }
+      it 'returns each plugin' do
+        expect(Observed::Observer.find_plugin_named('observer_spec_bar')).to eq(bar)
+        expect(Observed::Observer.find_plugin_named('observer_spec_baz')).to eq(baz)
+      end
+    end
+
+  end
+
+end