observed 0.1.1 → 0.2.0.rc1

data/spec/configurable_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'observed/configurable'
+require 'observed/pluggable'
 
 module ConfigurableSpec
   class Foo
@@ -11,55 +12,164 @@ module ConfigurableSpec
 
     default :bar => 345
   end
+
+  module ConfigurableModule
+    include Observed::Configurable
+
+    attribute :baz
+  end
+
+  module IntermediateModule
+    include Observed::Configurable
+    include ConfigurableModule
+
+    attribute :bar, default: 234
+  end
+
+  class ConfigurableModuleIncluder
+    include Observed::Configurable
+    include ConfigurableModule
+
+    attribute :bar, default: 234
+    default :bar => 345
+    attribute :foo, default: 123
+  end
+
+  class IntermediateModuleIncluder
+    include Observed::Configurable
+    include IntermediateModule
+
+    default :bar => 345
+    attribute :foo, default: 123
+  end
+
+  class SpecialCMI < ConfigurableModuleIncluder
+    include Observed::Configurable
+  end
+
+  class SpecialIMI < IntermediateModuleIncluder
+    include Observed::Configurable
+  end
+
+  class Plugin
+    include Observed::Configurable
+    include Observed::Pluggable
+    include ConfigurableModule
+    attribute :bar, default: 234
+    default :bar => 345
+  end
+
+  class PluginImpl < Plugin
+    include Observed::Configurable
+    attribute :foo, default: 123
+  end
+
+  class Overriding
+    include Observed::Configurable
+    include IntermediateModule
+
+    def foo
+      @attributes[:foo] || 123
+    end
+
+    default :bar => 345
+    attribute :foo, default: 1234
+  end
 end
 
 describe Observed::Configurable do
 
-  context 'without parameters for the constructor' do
-    subject {
-      ConfigurableSpec::Foo.new
-    }
+  shared_examples_for 'a configurable object' do
     it 'uses default values for attributes' do
-      expect(subject.foo).to eq(123)
+      expect(subject.new.foo).to eq(123)
     end
+
     it 'overrides default values on `attribute name, :default => default_value`' do
-      expect(subject.bar).to eq(345)
+      expect(subject.new.bar).to eq(345)
     end
+
     it 'raises errors when attributes without values are read' do
-      expect { subject.baz }.to raise_error
+      expect { subject.new.baz }.to raise_error
+    end
+
+    context 'when configured via the `configure` method' do
+      it 'prefers arguments of the method over defaults' do
+        instance = subject.new
+
+        instance.configure foo: 1, bar: 2
+
+        expect(instance.foo).to eq(1)
+        expect(instance.bar).to eq(2)
+      end
+    end
+
+    context 'when configured via constructor parameters' do
+      context 'when the keys are symbols' do
+        it 'prefers values from constructor parameters over defaults' do
+          instance = subject.new({foo: 1, bar: 2, baz: 3})
+          expect(instance.foo).to eq(1)
+          expect(instance.bar).to eq(2)
+          expect(instance.baz).to eq(3)
+        end
+      end
+      context 'when the keys are strings' do
+        it 'does not prefer constructor parameters' do
+          instance = subject.new({'foo' => 1, 'bar' => 2, 'baz' => 3})
+          expect(instance.foo).to eq(123)
+          expect(instance.bar).to eq(345)
+          expect { instance.baz }.to raise_error
+        end
+      end
     end
   end
 
-  context 'with parameters for the constructor' do
+  context 'when included in a class' do
     subject {
-      ConfigurableSpec::Foo.new({foo: 1, bar: 2, baz: 3})
+      ConfigurableSpec::Foo
     }
-    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
+    it_behaves_like 'a configurable object'
   end
 
-  context 'configured through `configure(args)` method' do
+  context 'when included in a module' do
     subject {
-      foo = ConfigurableSpec::Foo.new
-      foo.configure(args)
-      foo
+      ConfigurableSpec::ConfigurableModuleIncluder
     }
-    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
+    it_behaves_like 'a configurable object'
+  end
+
+  context 'when included via a intermediate module' do
+    subject {
+      ConfigurableSpec::IntermediateModuleIncluder
+    }
+    it_behaves_like 'a configurable object'
+  end
+
+  context 'when extended from a class which is a Plugin' do
+    subject {
+      ConfigurableSpec::PluginImpl
+    }
+    it_behaves_like 'a configurable object'
+  end
+
+  context 'when inherited from a class included the intermediate module' do
+    subject {
+      ConfigurableSpec::SpecialIMI
+    }
+    it_behaves_like 'a configurable object'
+  end
+
+  context 'when inherited from a class included the module includes it' do
+    subject {
+      ConfigurableSpec::SpecialCMI
+    }
+    it_behaves_like 'a configurable object'
+  end
+
+  context 'when there is a method named exactly same as the attribute' do
+    subject {
+      ConfigurableSpec::Overriding
+    }
+    it_behaves_like 'a configurable object'
   end
 
 end

data/spec/event_bus_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'observed/event_bus'
+
+describe Observed::EventBus do
+  it 'calls the handler for the emitted event' do
+    handler_one_called = false
+    handler_two_called = false
+    bus = Observed::EventBus.new
+    expect { bus.emit('foo') }.to_not raise_error
+    expect { bus.on_receive(/^bar$/) { handler_one_called = true } }.to_not raise_error
+    expect { bus.on_receive(/^baz$/) { handler_two_called = true } }.to_not raise_error
+    expect { bus.emit('bar') }.to_not raise_error
+    expect(handler_one_called).to be_true
+    expect(handler_two_called).to be_false
+  end
+end

data/spec/execution_job_factory_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'observed/execution_job_factory'
+
+describe Observed::ExecutionJobFactory do
+  subject {
+    Observed::ExecutionJobFactory.new
+  }
+  it 'should convert observers, translators, reporters to jobs' do
+    output = mock('output')
+
+    the_observer = Class.new(Observed::Observer) do
+      def observe(data)
+        data.merge(b:2)
+      end
+    end.new
+    the_reporter = Class.new(Observed::Reporter) do
+      attribute :output
+      def report(tag, time, data)
+        output.write(tag: tag, time: time, data: data)
+      end
+    end.new(output: output)
+    the_translator = Class.new(Observed::Translator) do
+      def translate(tag, time, data)
+        data.merge(c:3)
+      end
+    end.new
+    job = subject.convert_to_job(the_observer)
+      .then(subject.convert_to_job(the_translator))
+      .then(subject.convert_to_job(the_reporter))
+    tag = 'the_tag'
+    time = Time.now
+    output.expects(:write).with(tag: tag, time: time, data: {a:1,b:2,c:3})
+    job.now({a:1}, {tag: tag, time: time})
+  end
+end

data/spec/job_factory_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'observed/job'
+
+describe Observed::JobFactory do
+  context 'when the executor not given' do
+    it 'fails to initialize' do
+      expect { Observed::JobFactory.new() }.to raise_error
+    end
+  end
+
+  context 'when a logger given' do
+    it 'may prefer the given logger over the default one' do
+      Observed::JobFactory.new(executor: mock('executor'), logger: ::Logger.new(STDERR))
+    end
+  end
+end

data/spec/job_spec.rb

@@ -0,0 +1,228 @@
+require 'spec_helper'
+require 'observed/job'
+
+describe Observed::MutableJob do
+  let(:factory) {
+    Observed::JobFactory.new(:executor => Observed::BlockingJobExecutor.new)
+  }
+
+  it 'yields the given block' do
+    yielded = nil
+    job = factory.mutable_job { |data|
+      data
+    }
+    job.now({a:1}, {b:2}) do |data, options|
+      yielded = [data, options]
+    end
+    expect(yielded).to eq([{a:1}, {b:2}])
+  end
+
+  it 'executes the job regardless of whether or not a block is given' do
+    executed = nil
+    job = factory.mutable_job { |data, options|
+      executed = [data, options]
+      data
+    }
+    job.now({a:1}, {b:2})
+    expect(executed).to eq([{a:1}, {b:2}])
+  end
+end
+
+describe Observed::ParallelJob do
+  let(:factory) {
+    Observed::JobFactory.new(:executor => Observed::BlockingJobExecutor.new)
+  }
+
+  it 'yields the given block' do
+    job1 = factory.job { |data, |
+      data.merge(c:3)
+    }
+    job2 = factory.job { |data|
+      data.merge(d:4)
+    }
+    par = Observed::ParallelJob.new([job1, job2])
+    yielded = []
+    par.now({a:1}, {b:2}) do |data, options|
+      yielded.push([data, options])
+    end
+    expect(yielded).to eq([[{a:1,c:3},{b:2}], [{a:1,d:4},{b:2}]])
+  end
+
+  it 'executes the job regardless of whether or not a block is given' do
+    executed = []
+    job1 = factory.job { |data, options|
+      r = data.merge(c:3)
+      executed.push([r, options])
+      r
+    }
+    job2 = factory.job { |data, options|
+      r = data.merge(d:4)
+      executed.push([r, options])
+      r
+    }
+    par = Observed::ParallelJob.new([job1, job2])
+    par.now({a:1}, {b:2})
+    expect(executed).to eq([[{a:1,c:3},{b:2}], [{a:1,d:4},{b:2}]])
+  end
+end
+
+describe Observed::SequenceJob do
+  let(:factory) {
+    Observed::JobFactory.new(:executor => Observed::BlockingJobExecutor.new)
+  }
+
+  it 'yields the given block' do
+    job1 = factory.job { |data|
+      data.merge(c:3)
+    }
+    job2 = factory.job { |data|
+      data.merge(d:4)
+    }
+    seq = Observed::SequenceJob.new(job1, job2)
+    yielded = []
+    seq.now({a:1}, {b:2}) do |data, options|
+      yielded.push([data, options])
+    end
+    expect(yielded).to eq([[{a:1,c:3,d:4},{b:2}]])
+  end
+
+  it 'executes the job regardless of whether or not a block is given' do
+    executed = []
+    job1 = factory.job { |data, options|
+      r = data.merge(c:3)
+      executed.push([r, options])
+      r
+    }
+    job2 = factory.job { |data, options|
+      r = data.merge(d:4)
+      executed.push([r, options])
+      r
+    }
+    seq = Observed::SequenceJob.new(job1, job2)
+    seq.now({a:1}, {b:2})
+    expect(executed).to eq([[{a:1,c:3},{b:2}], [{a:1,c:3,d:4},{b:2}]])
+  end
+end
+
+describe Observed::Job do
+  context 'in simple use cases' do
+    let(:factory) {
+      Observed::JobFactory.new(:executor => Observed::BlockingJobExecutor.new)
+    }
+    context 'when the options as input are given' do
+      it 'propagates the options from the input' do
+        job1 = factory.job { |data, options|
+          expect(options).to eq({b:2})
+          data
+        }
+        job2 = factory.job { |_, options|
+          expect(options).to eq({b:2})
+        }
+        seq = job1.then(job2)
+        seq.now({a:1}, {b:2})
+      end
+      it 'allows to override the options from the input in subsequent jobs' do
+        job1 = factory.job { |data, options|
+          expect(options).to eq({b:2})
+          [data, {b:3}]
+        }
+        job2 = factory.job { |_, options|
+          expect(options).to eq({b:3})
+        }
+        seq = job1.then(job2)
+        seq.now({a:1}, {b:2})
+      end
+    end
+    context 'when the options as input are not given' do
+      it 'provides nil in the block parameter and allows to override it in subsequent jobs' do
+        job1 = factory.job { |data, options|
+          expect(options).to be_nil
+          [data, {b:3}]
+        }
+        job2 = factory.job { |_, options|
+          expect(options).to eq({b:3})
+        }
+        seq = job1.then(job2)
+        seq.now({a:1})
+      end
+    end
+  end
+  context 'when used in an immutable way' do
+    it 'propagates the resulting data to next jobs' do
+      factory = Observed::JobFactory.new(:executor => Observed::BlockingJobExecutor.new)
+      output = mock('output')
+      input_data = { input: 1 }
+      a = factory.job { |data|
+        data.merge(a: 2)
+      }
+      b = factory.job { |data, options|
+        data.merge(b: 3)
+      }
+      c = factory.job { |data, options|
+        output.write data.merge(c: 4)
+      }
+      d = factory.job { |data|
+        output.write data.merge(d: 5)
+      }
+      foo = a.then(b).then(c, d)
+      output.expects(:write).with({input:1,a:2,b:3,c:4})
+      output.expects(:write).with({input:1,a:2,b:3,d:5})
+      foo.now(input_data)
+    end
+  end
+
+  context 'when used in a mutable way' do
+    it 'propagates the resulting data to next jobs' do
+      factory = Observed::JobFactory.new(:executor => Observed::BlockingJobExecutor.new)
+      output = mock('output')
+      input_data = { input: 1 }
+      a = factory.mutable_job { |data|
+        data.merge(a: 2)
+      }
+      b = factory.job { |data, options|
+        data.merge(b: 3)
+      }
+      c = factory.job { |data, options|
+        output.write data.merge(c: 4)
+      }
+      d = factory.job { |data|
+        output.write data.merge(d: 5)
+      }
+      a.then(b).then(c, d)
+      output.expects(:write).with({input:1,a:2,b:3,c:4})
+      output.expects(:write).with({input:1,a:2,b:3,d:5})
+      a.now(input_data)
+    end
+  end
+
+  context 'when listeners given' do
+    it 'notifies listeners with resulting data' do
+
+      listener = mock('listener')
+      factory = Observed::JobFactory.new(
+          :executor => Observed::BlockingJobExecutor.new,
+          :listener => listener
+      )
+      output = mock('output')
+      input_data = { input: 1 }
+      a = factory.job { |data|
+        data.merge(a: 2)
+      }
+      b = factory.job { |data, options|
+        data.merge(b: 3)
+      }
+      c = factory.job { |data, options|
+        output.write data.merge(c: 4)
+      }
+      d = factory.job { |data|
+        output.write data.merge(d: 5)
+      }
+      foo = a.then(b).then(c, d)
+      output.expects(:write).with({input:1,a:2,b:3,c:4})
+      output.expects(:write).with({input:1,a:2,b:3,d:5})
+      listener.expects(:on_result).with({input:1,a:2}, {opt:1})
+      listener.expects(:on_result).with({input:1,a:2,b:3}, {opt:1})
+      foo.now(input_data, {opt:1})
+    end
+  end
+end

data/spec/jobbed_event_bus_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+require 'observed/job'
+require 'observed/jobbed_event_bus'
+
+describe Observed::JobbedEventBus do
+  let(:out) {
+    mock('out')
+  }
+  let(:factory) {
+    executor = Observed::BlockingJobExecutor.new
+    Observed::JobFactory.new(executor: executor)
+  }
+  let(:the_job) {
+    factory.job { |data, options|
+      out.write data, options
+    }
+  }
+  let(:bus) {
+    Observed::JobbedEventBus.new(job_factory: factory)
+  }
+  it 'should invoke jobs when the corresponding events are emitted' do
+    bus.emit('foo')
+    bus.receive(/^bar$/).then(the_job)
+    bus.emit('baz')
+    out.expects(:write).with({a:1}, {b:2})
+    bus.emit('bar', {a:1}, {b:2})
+    bus.emit('blah')
+  end
+  it 'should return the job to emit events' do
+    bus.pipe_to_emit('foo').now
+    bus.receive(/^bar$/).then(the_job)
+    bus.pipe_to_emit('baz').now
+    out.expects(:write).with({a:1}, {b:2})
+    bus.pipe_to_emit('bar').now({a:1}, {b:2})
+    bus.pipe_to_emit('blah').now
+  end
+end