ultra_marathon 0.0.1

data/spec/ultra_marathon/callbacks_spec.rb

@@ -0,0 +1,244 @@
+require 'spec_helper'
+
+describe UltraMarathon::Callbacks do
+  let(:test_class) do
+    anonymous_test_class do
+      include UltraMarathon::Callbacks
+      attr_writer :bubble_count
+      callbacks :before_bubbles, :after_bubbles, :on_error
+
+      def bubbles(&block)
+        begin
+          invoke_before_bubbles_callbacks
+          instance_exec &block
+          invoke_after_bubbles_callbacks
+        rescue StandardError => error
+          invoke_on_error_callbacks(error)
+        end
+      end
+
+      def bubble_count
+        @bubble_count ||= 0
+      end
+
+      def increment_bubbles
+        self.bubble_count += 1
+      end
+
+      def triple_bubbles
+        self.bubble_count *= 3
+      end
+
+      def i_can_handle_errors!(error)
+        self.bubble_count += error.message.to_i
+      end
+    end
+  end
+
+  let(:test_instance) { test_class.new }
+
+  describe 'callback memoization' do
+    it 'should add getter method' do
+      test_class.should be_respond_to :before_bubbles_callbacks
+      test_class.should be_respond_to :after_bubbles_callbacks
+    end
+
+    it 'should memoize an empty array' do
+      test_class.before_bubbles_callbacks.should eq []
+      test_class.after_bubbles_callbacks.should eq []
+    end
+  end
+
+  describe 'invoking callbacks' do
+    describe 'with lambdas' do
+      describe 'that do not take arguments' do
+        before(:each) do
+          test_class.before_bubbles ->{ self.bubble_count = 12 }
+          test_class.after_bubbles ->{ self.bubble_count += 1 }
+          test_class.on_error ->{ self.bubble_count += 8 }
+        end
+
+        it 'should invoke the callbacks in order' do
+          test_instance.bubbles { self.bubble_count /= 2 }
+          test_instance.bubble_count.should be 7
+        end
+
+        it 'should not pass arguments if the lambda takes none' do
+          # use a lambda, which will raise for incorrect arity
+          test_instance.bubbles &->{ raise 'the roof!' }
+          test_instance.bubble_count.should be 20
+        end
+      end
+
+      describe 'with arguments' do
+        before(:each) do
+          test_class.on_error ->(e){ self.bubble_count = e.message.to_i }
+        end
+
+        it 'should pass the argument to the lambda' do
+          test_instance.bubbles { raise '9001' }
+          test_instance.bubble_count.should be 9001
+        end
+
+        it 'should throw an error if not enough arguments are passed' do
+          expect {
+            test_instance.send :invoke_on_error_callbacks
+            }.to raise_error ArgumentError
+        end
+      end
+    end
+
+    describe 'passing in symbols' do
+      describe 'that do not take arguments' do
+        before(:each) do
+          test_class.before_bubbles :increment_bubbles
+          test_class.after_bubbles :triple_bubbles
+        end
+
+        it 'should invoke the callbacks in order' do
+          test_instance.bubbles { self.bubble_count -= 2 }
+          test_instance.bubble_count.should be -3
+        end
+
+        it 'allows passing the same symbol twice' do
+          test_class.before_bubbles :increment_bubbles
+          test_instance.bubbles { self.bubble_count -= 10 }
+          test_instance.bubble_count.should be -24
+        end
+
+        describe 'when the callback passes arguments' do
+          before(:each) { test_class.on_error :triple_bubbles }
+
+          it 'calls the method successfully' do
+            test_instance.bubbles { raise '9001' }
+            test_instance.bubble_count.should be 3
+          end
+        end
+      end
+
+      describe 'with arguments' do
+        before(:each) do
+          test_class.on_error :i_can_handle_errors!
+        end
+
+        it 'should pass the argument to the lambda' do
+          test_instance.bubbles { raise '9001' }
+          test_instance.bubble_count.should be 9001
+        end
+      end
+    end
+
+    describe 'options' do
+      describe ':if' do
+        describe 'with a symbol' do
+          before(:each) do
+            test_class.before_bubbles :increment_bubbles, :if => :ready_to_party?
+            test_class.before_bubbles :increment_bubbles
+          end
+
+          it 'should call the callback if the method is truthy' do
+            test_instance.stub(:ready_to_party?).and_return true
+            test_instance.bubbles { self.bubble_count *= 10 }
+            test_instance.bubble_count.should be 20
+          end
+
+          it 'should not call the callback if the method is falsy' do
+            test_instance.stub(:ready_to_party?).and_return false
+            test_instance.bubbles { self.bubble_count *= 10 }
+            test_instance.bubble_count.should be 10
+          end
+        end
+
+        describe 'with a lambda' do
+          before(:each) do
+            test_class.before_bubbles :increment_bubbles, if: -> { ready_to_party? }
+            test_class.before_bubbles :increment_bubbles
+          end
+
+          it 'should call the callback if the method is truthy' do
+            test_instance.stub(:ready_to_party?).and_return true
+            test_instance.bubbles { self.bubble_count *= 10 }
+            test_instance.bubble_count.should be 20
+          end
+
+          it 'should not call the callback if the method is falsy' do
+            test_instance.stub(:ready_to_party?).and_return false
+            test_instance.bubbles { self.bubble_count *= 10 }
+            test_instance.bubble_count.should be 10
+          end
+        end
+      end
+
+      describe ':unless' do
+        describe 'with a symbol' do
+          before(:each) do
+            test_class.before_bubbles :increment_bubbles, :unless => :ready_to_party?
+            test_class.before_bubbles :increment_bubbles
+          end
+
+          it 'should call the callback if the method is falsy' do
+            test_instance.stub(:ready_to_party?).and_return true
+            test_instance.bubbles { self.bubble_count *= 10 }
+            test_instance.bubble_count.should be 10
+          end
+
+          it 'should not call the callback if the method is truthy' do
+            test_instance.stub(:ready_to_party?).and_return false
+            test_instance.bubbles { self.bubble_count *= 10 }
+            test_instance.bubble_count.should be 20
+          end
+        end
+
+        describe 'with a lambda' do
+          before(:each) do
+            test_class.before_bubbles :increment_bubbles, unless: ->{ ready_to_party? }
+            test_class.before_bubbles :increment_bubbles
+          end
+
+          it 'should call the callback if the method is falsey' do
+            test_instance.stub(:ready_to_party?).and_return true
+            test_instance.bubbles { self.bubble_count *= 10 }
+            test_instance.bubble_count.should be 10
+          end
+
+          it 'should not call the callback if the method is truthy' do
+            test_instance.stub(:ready_to_party?).and_return false
+            test_instance.bubbles { self.bubble_count *= 10 }
+            test_instance.bubble_count.should be 20
+          end
+        end
+      end
+
+      describe ':context' do
+        let(:other_walrus) { test_class.new }
+
+        describe 'with a symbol' do
+          before(:each) do
+            test_class.before_bubbles :increment_bubbles, context: other_walrus
+            test_class.before_bubbles :increment_bubbles
+          end
+
+          it 'should call the callback on the other object' do
+            test_instance.bubbles { self.bubble_count *= 10 }
+            test_instance.bubble_count.should be 10
+            other_walrus.bubble_count.should be 1
+          end
+        end
+
+        describe 'with a block' do
+          before(:each) do
+            test_class.before_bubbles(Proc.new { increment_bubbles; triple_bubbles }, context: other_walrus)
+            test_class.before_bubbles :increment_bubbles
+          end
+
+          it 'should call the block on the other object' do
+            test_instance.stub(:ready_to_party?).and_return true
+            test_instance.bubbles { self.bubble_count *= 10 }
+            test_instance.bubble_count.should be 10
+            other_walrus.bubble_count.should be 3
+          end
+        end
+      end
+    end
+  end
+end

data/spec/ultra_marathon/instrumentation_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe UltraMarathon::Instrumentation do
+  let(:test_class) do
+    anonymous_test_class do
+      include UltraMarathon::Instrumentation
+
+      def run(&block)
+        instrument { block.call }
+      end
+    end
+  end
+
+  let(:test_instance) { test_class.new }
+  let(:start_time) { Time.local(1991, 1, 31, 15, 15, 00) }
+  let(:end_time) { Time.local(1991, 1, 31, 16, 00, 20) }
+  let(:run_block) do
+    # This is going to be evaluated in context of the instance
+    # so we need to wrap in an IIF to access `end_time`
+    Proc.new do |end_time|
+      Proc.new do
+        Timecop.travel(end_time)
+      end
+    end.call(end_time)
+  end
+
+  subject(:run) { test_instance.run &run_block }
+
+  before(:each) { Timecop.freeze(start_time) }
+  after(:each) { Timecop.return }
+
+  describe '#instrument' do
+
+    describe 'method signature' do
+      let(:run_block) { Proc.new { 'Bubbles!' } }
+
+      it 'should return the result of the passed in block' do
+        run.should eq 'Bubbles!'
+      end
+    end
+
+    describe 'setting instance variables' do
+      before(:each) { run }
+
+      it 'should set the start_time' do
+        test_instance.start_time.should eq start_time
+      end
+
+      it 'should set the end_time' do
+        test_instance.end_time.to_i.should eq end_time.to_i
+      end
+    end
+  end
+
+  describe 'total_time' do
+    before(:each) { run }
+
+    it 'should return the total seconds elapsed' do
+      test_instance.total_time.should eq 2720
+    end
+  end
+
+  describe '#formatted_total_time' do
+    before(:each) { run }
+
+    it 'should return the total time, formatted' do
+      test_instance.formatted_total_time.should eq '00:45:20'
+    end
+  end
+end

data/spec/ultra_marathon/logging_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe UltraMarathon::Logging do
+  let(:test_class) do
+    anonymous_test_class do
+      include UltraMarathon::Logging
+    end
+  end
+
+  let(:test_instance) { test_class.new }
+
+  before(:each) { test_class.instance_variable_set(:@log_class, nil) }
+
+  describe '.log_class' do
+    let(:log_class) { anonymous_test_class }
+
+    context 'passing a proc' do
+      it 'it returns an instance of that class on instantiation' do
+        test_class.send :log_class, ->{ log_class }
+        test_instance.logger.should be_a log_class
+      end
+    end
+
+    context 'passing a class' do
+      it 'instantiates the logger as that class' do
+        test_class.send :log_class, log_class
+        test_instance.logger.should be_a log_class
+      end
+    end
+  end
+
+  describe '.logger' do
+    it 'defaults to the UltraMarathon::Logger class' do
+      test_instance.logger.should be_a UltraMarathon::Logger
+    end
+  end
+end

data/spec/ultra_marathon/store_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe UltraMarathon::Store do
+  let(:runner_class) do
+    anonymous_test_class do
+      attr_accessor :success, :name
+
+      def initialize(name)
+        @name = name.to_sym
+      end
+
+      # Helper methods for testing
+
+      def succeed!
+        self.success = true
+        self
+      end
+
+      def fail!
+        self.success = false
+        self
+      end
+    end
+  end
+
+  let(:test_instance) { described_class.new(maintenances) }
+  let(:maintenances) { [] }
+
+  describe '#initialize' do
+    let(:maintenances) do
+      [ runner_class.new(:frank), runner_class.new(:harold) ]
+    end
+
+    it 'should add them and regurgitate them' do
+      test_instance.sort_by(&:name).should eq maintenances
+    end
+  end
+
+  describe '#<<' do
+    it 'should add the maintenance to the storage' do
+      test_maintenance = runner_class.new(:heraldo)
+      test_instance << test_maintenance
+      test_instance[:heraldo].should be test_maintenance
+    end
+  end
+
+  describe '#add' do
+    it 'should add the maintenance to the storage' do
+      test_maintenance = runner_class.new(:heraldo)
+      test_instance.add test_maintenance
+      test_instance[:heraldo].should be test_maintenance
+    end
+  end
+
+  describe '#pluck' do
+    let(:maintenances) do
+      [ runner_class.new(:frank), runner_class.new(:harold) ]
+    end
+
+    it 'should return an array of calling the block on each instance' do
+      test_instance.pluck(&:name).sort.should eq [:frank, :harold]
+    end
+  end
+
+  describe '#failed?' do
+    let(:maintenances) { [ runner_class.new(:heraldo).fail! ] }
+
+    it 'returns true if the maintenance was not successful' do
+      test_instance.should be_failed :heraldo
+    end
+
+    it 'returns nil if the maintenance is not being stored' do
+      test_instance.failed?(:juanita).should be_nil
+    end
+  end
+
+  describe '#success?' do
+    let(:maintenances) { [ runner_class.new(:heraldo).succeed! ] }
+
+    it 'returns true if the maintenance was successful' do
+      test_instance.should be_success :heraldo
+    end
+
+    it 'returns nil if the maintenance is not being stored' do
+      test_instance.success?(:juanita).should be_nil
+    end
+  end
+
+  describe '==' do
+    let(:maintenances) { [ runner_class.new(:waldo), runner_class.new(:heraldo), runner_class.new(:geraldo) ] }
+    let(:other_instance) { described_class.new(other_maintenances) }
+
+    context 'when the names of the other maintenances are the same' do
+      # purposefully a different order
+      let(:other_maintenances) { [ runner_class.new(:heraldo), runner_class.new(:geraldo), runner_class.new(:waldo) ] }
+
+      it 'should return true' do
+        (other_instance == test_instance).should be true
+      end
+    end
+
+    context 'when the names of the other maintenances are a subset' do
+      let(:other_maintenances) { [ runner_class.new(:geraldo), runner_class.new(:waldo) ] }
+
+      it 'should return false' do
+        (other_instance == test_instance).should be false
+      end
+    end
+
+    context 'when they are both equal' do
+      let(:other_maintenances) { [] }
+
+      it 'should return false' do
+        (other_instance == test_instance).should be false
+      end
+    end
+  end
+
+  describe '!=' do
+    let(:maintenances) { [ runner_class.new(:waldo), runner_class.new(:heraldo), runner_class.new(:geraldo) ] }
+    let(:other_instance) { described_class.new(other_maintenances) }
+
+    context 'when the names of the other maintenances are the same' do
+      # purposefully a different order
+      let(:other_maintenances) { [ runner_class.new(:heraldo), runner_class.new(:geraldo), runner_class.new(:waldo) ] }
+
+      it 'should return false' do
+        (other_instance != test_instance).should be false
+      end
+    end
+
+    context 'when the names of the other maintenances are a subset' do
+      let(:other_maintenances) { [ runner_class.new(:geraldo), runner_class.new(:waldo) ] }
+
+      it 'should return true' do
+        (other_instance != test_instance).should be true
+      end
+    end
+
+    context 'when they are both equal' do
+      let(:other_maintenances) { [] }
+
+      it 'should return true' do
+        (other_instance != test_instance).should be true
+      end
+    end
+  end
+end

data/spec/ultra_marathon/sub_runner_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe UltraMarathon::SubRunner do
+  let(:test_class) do
+    anonymous_test_class do
+      attr_writer :bubble_count
+
+      def bubble_count
+        @bubble_count ||= 0
+      end
+
+      def increment_bubbles
+        self.bubble_count += 1
+      end
+
+      def triple_bubbles
+        self.bubble_count *= 3
+      end
+    end
+  end
+
+  let(:test_instance) { described_class.new(options, run_block) }
+  let(:options) do
+    { context: context, name: name }
+  end
+  let(:name) { :frank }
+  let(:context) { test_class.new }
+
+  context '#run' do
+    let(:run_block) { ->{ increment_bubbles } }
+    subject { test_instance.run! }
+
+    it 'runs in the context that was passed in' do
+      subject
+      context.bubble_count.should be 1
+    end
+
+    it 'starts the logs with its name' do
+      subject
+      test_instance.logger.contents.should be_start_with "Running '#{name}' SubRunner"
+    end
+
+    describe 'logging' do
+      let(:run_block) { ->{ logger.info('Draws those who are willing, drags those who are not.') } }
+
+      it 'logs to the sub maintenance' do
+        subject
+        test_instance.logger.contents.should include 'Draws those who are willing, drags those who are not.'
+      end
+    end
+  end
+end

data/ultra_marathon.gemspec

@@ -0,0 +1,20 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ultra_marathon/version'
+
+Gem::Specification.new do |spec|
+  spec.authors     = ['Chris Maddox']
+  spec.date        = '2013-10-02'
+  spec.description = 'Managing long running processes.'
+  spec.email       = 'tyre77@gmail.com'
+  spec.files       = %w(LICENSE.md README.md ultra_marathon.gemspec)
+  spec.files      += Dir.glob('lib/**/*.rb')
+  spec.files      += Dir.glob('spec/**/*')
+  spec.homepage    = 'https://github.com/tyre/ultra_marathon'
+  spec.licenses    = ['MIT']
+  spec.name        = 'ultra_marathon'
+  spec.summary     = 'Managing ultra long running processes.'
+  spec.test_files += Dir.glob('spec/**/*')
+  spec.version     = UltraMarathon::Version.to_s
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: ultra_marathon
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Chris Maddox
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-02 00:00:00.000000000 Z
+dependencies: []
+description: Managing long running processes.
+email: tyre77@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- lib/ultra_marathon.rb
+- lib/ultra_marathon/abstract_runner.rb
+- lib/ultra_marathon/callbacks.rb
+- lib/ultra_marathon/instrumentation.rb
+- lib/ultra_marathon/logger.rb
+- lib/ultra_marathon/logging.rb
+- lib/ultra_marathon/store.rb
+- lib/ultra_marathon/sub_runner.rb
+- lib/ultra_marathon/version.rb
+- spec/spec_helper.rb
+- spec/support/file_mutexes.rb
+- spec/support/test_helpers.rb
+- spec/ultra_marathon/abstract_runner_spec.rb
+- spec/ultra_marathon/callbacks_spec.rb
+- spec/ultra_marathon/instrumentation_spec.rb
+- spec/ultra_marathon/logging_spec.rb
+- spec/ultra_marathon/store_spec.rb
+- spec/ultra_marathon/sub_runner_spec.rb
+- ultra_marathon.gemspec
+homepage: https://github.com/tyre/ultra_marathon
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: Managing ultra long running processes.
+test_files:
+- spec/spec_helper.rb
+- spec/support/file_mutexes.rb
+- spec/support/test_helpers.rb
+- spec/ultra_marathon/abstract_runner_spec.rb
+- spec/ultra_marathon/callbacks_spec.rb
+- spec/ultra_marathon/instrumentation_spec.rb
+- spec/ultra_marathon/logging_spec.rb
+- spec/ultra_marathon/store_spec.rb
+- spec/ultra_marathon/sub_runner_spec.rb