mock_em 0.1.0

data/.gitignore

@@ -0,0 +1,61 @@
+# standard ignores
+log/*
+tmp/*
+TAGS
+.idea/*
+
+# Apparently this file should not be checked in, for GEM projects: http://yehudakatz.com/2010/12/16/clarifying-the-roles-of-the-gemspec-and-gemfile/
+Gemfile.lock
+
+# Rbenv
+.ruby-version
+
+# rcov generated
+coverage
+coverage.data
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# jeweler generated
+pkg
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+.DS_Store
+
+# For TextMate
+#*.tmproj
+#tmtags
+
+# For emacs:
+*~
+\#*
+.\#*
+
+# For vim:
+*.swp
+
+# For redcar:
+.redcar
+
+# For rubinius:
+*.rbc

data/.rspec

@@ -0,0 +1,3 @@
+--colour
+--format=documentation
+--backtrace

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mock_em.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009-2014 RightScale, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,73 @@
+# MockEM
+
+MockEM provides the same interface as [EM](https://github.com/eventmachine/eventmachine/) (a.k.a. [EventMachine](https://github.com/eventmachine/eventmachine/)), but simulates the passage of time to execute your 
+scheduled actions without delay. It is intended for use in tests.
+
+Uses [Timecop](https://github.com/travisjeffery/timecop) for simulating the passage of time.
+
+## Getting Started
+You'll need to add `require 'mock_em'`, as well as `require 'timecop'`.
+
+At the beginning of your spec you can use the following snippet to mock EM within the scope of that spec.
+
+```ruby
+# mock & restore EM
+before(:all) do
+  @logger = Logger.new(STDOUT)  # <-- Choose your own logger, as appropriate
+    
+  # Mock EM
+  @orig_EM = EM
+  EM = MockEM::MockEM.new(@logger, Timecop)
+end
+after(:all) do
+  EM = @orig_EM
+  Timecop.return
+end
+```
+
+Any references to `EM` will then be using MockEM.
+
+As a quick demonstration, the following code has a timer that would wait for 8 minutes with EM, but with MockEM it completes instantaneously:
+ 
+```ruby
+require 'timecop'
+require 'mock_em'
+logger = Logger.new(STDOUT)
+em = MockEM::MockEM.new(logger, Timecop)
+
+em.run do
+  em.add_timer(8 * 60) do
+    puts "Done!"
+    em.stop
+  end
+end    
+```
+
+## Supported Features
+MockEM supports many of the features of EM. Example of supported methods:
+
+  - Reactor: `run`, `stop`, `reactor_running?`
+  - Timers: `next_tick`, `add_timer`, `add_periodic_timer`, `cancel_timer`, `get_max_timer_count`
+  - Hooks: `add_shutdown_hook`, `error_handler`
+
+Refer to `mock_em_spec.rb` for more details, as it runs the same set of specs against both `MockEM` and `EM`,
+to verify the behavior is identical.
+
+## Unsupported Features
+Your mileage may vary.
+
+## TODO
+  - [ ] add Travis CI integration for specs
+
+## Compatibility
+Ruby 1.8.7 and above is supported.
+
+## Contributing
+Pull requests welcome.
+
+If you'd like to add missing functionality, you can use `mock_em_spec.rb` to verify that the behavior is identical in both `MockEM` and `EM`. 
+
+Maintained by the RightScale "Cornsilk_team"
+
+## License
+MIT License, see [LICENSE](LICENSE)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/mock_em/logger_with_prefix.rb

@@ -0,0 +1,27 @@
+module MockEM
+
+  # Logs all messages with the specified prefix.
+  # Warning: this is a not a full-fledged Logger implementation, it just logs string messages.
+  class LoggerWithPrefix
+
+    attr_reader :prefix
+    attr_reader :raw_logger
+
+    def initialize(prefix, logger)
+      @prefix     = prefix
+      @raw_logger = logger
+    end
+
+    def debug(msg); log_with_prefix(:debug, msg)  end
+    def info(msg);  log_with_prefix(:info,  msg)  end
+    def warn(msg);  log_with_prefix(:warn,  msg)  end
+    def error(msg); log_with_prefix(:error, msg)  end
+
+    private
+
+    def log_with_prefix(level, msg)
+      @raw_logger.__send__(level, "#{prefix}: #{msg}")
+    end
+  end
+
+end

data/lib/mock_em/mock_em.rb

@@ -0,0 +1,225 @@
+require 'logger'
+require 'mock_em/logger_with_prefix'
+require 'timecop'
+
+module MockEM
+
+  # Fake EM suitable for unit testing.
+  # Uses Timecop to accelerate time. Should run Timecop.return after spec, just to be safe.
+  class MockEM
+
+    # @param [Timecop] timecop
+    def initialize(logger, timecop)
+      @log = LoggerWithPrefix.new("MockEM", logger)
+      @timecop = timecop
+
+      @next_tick_procs = []
+      @scheduled_tasks = ScheduledTasks.new(@log)
+      @timer_objects   = []
+      @shutdown_hooks  = []
+      @is_stopped      = false
+
+      @max_timer_count = 100000  #TODO: not honored
+    end
+
+    def run(&block)
+      @reactor_running = true
+      @is_stopped = false
+      @log.info "run called. executing run block."
+
+      safely_run { block.call }
+
+      @log.info("Beginning tick loop.")
+      @tick_count = 0
+      while (!@is_stopped)
+        @tick_count += 1
+
+        due_tasks = @scheduled_tasks.pop_due_tasks(now_millis)
+        @log.info "Tick ##{@tick_count}, clock=#{now_millis}, due_tasks=#{due_tasks.count}, next_tick_procs=#{@next_tick_procs.count}"
+        this_tick_procs = due_tasks + @next_tick_procs
+        @next_tick_procs = []
+
+        if this_tick_procs.empty?
+          # accelerate time to next scheduled task
+          next_time = @scheduled_tasks.time_of_next_task
+          if next_time.nil?
+            @log.info "Nothing left to do! Returning."
+            break
+          else
+            delta = next_time - now_millis
+            @log.info "Nothing in this tick. Accelerating clock by #{delta / 1000.0}s to: #{next_time}"
+            set_clock(next_time)
+          end
+        end
+
+        this_tick_procs.each_with_index do |proc, index|
+          @log.info "Executing tick proc ##{index+1}"
+          safely_run { proc.call }
+        end
+      end
+      @log.info("Finished tick loop. Returning.")
+    ensure
+      @reactor_running = false
+      future_time = now_millis
+      @timecop.return
+      @log.debug "MockEM saved you #{(future_time - now_millis) / 1000} seconds."
+    end
+
+    def stop
+      @log.info "stop called"
+      @is_stopped = true
+      @next_tick_procs = []
+      @scheduled_tasks.clear_and_reset
+      hooks = @shutdown_hooks
+      @shutdown_hooks = []
+
+      if hooks.count > 0
+        @log.info "Executing #{hooks.count} shutdown hooks"
+        hooks.reverse.each(&:call)
+      end
+    end
+
+    def next_tick(proc = nil, &block)
+      proc ||= block
+      @log.info "Adding proc to next_tick"
+      @next_tick_procs << proc
+    end
+
+    def add_timer(delay_seconds, proc = nil, &block)
+      add_timer_internal(delay_seconds, nil, proc, &block)
+    end
+
+    def add_periodic_timer(period_seconds, proc = nil, &block)
+      proc ||= block
+      timer = MockTimer.new
+      @log.info "Creating periodic timer task: id=#{timer.id}, period_seconds=#{period_seconds}"
+
+      recursive_block = nil
+      recursive_block = lambda do
+        safely_run { proc.call }
+        if !timer.is_cancelled
+          @log.info "Rescheduling next run of periodic timer id=#{timer.id}"
+          add_timer_internal(period_seconds, timer, recursive_block)
+        end
+      end
+
+      add_timer_internal(period_seconds, timer, recursive_block)
+    end
+
+    def cancel_timer(timer)
+      #TODO: support looking up by timer ID as well
+      @timer_objects.delete(timer)
+      timer.cancel
+    end
+
+    def reactor_running?
+      !!(@reactor_running)
+    end
+
+    def get_max_timer_count
+      @max_timer_count
+    end
+
+    def add_shutdown_hook(&block)
+      @shutdown_hooks << block
+    end
+
+    def error_handler(proc = nil, &block)
+      proc ||= block
+      @log.info("Setting error_handler")
+      @error_handler = proc
+    end
+
+
+    # Simulates whatever EM.add_timer or EM.add_periodic_timer returns.
+    class MockTimer
+
+      @@id_seq = 0
+
+      attr_reader :id, :is_cancelled
+
+      def initialize
+        @is_cancelled = false
+        @id = @@id_seq += 1
+      end
+
+      def cancel
+        @is_cancelled = true
+      end
+    end
+
+
+    # Keeps track of tasks to execute in the future, each one consisting of a timestamp and proc to execute.
+    class ScheduledTasks
+      ScheduledTask = Struct.new(:timestamp, :proc)
+
+      def initialize(log)
+        @log = log
+        clear_and_reset
+      end
+
+      def add_task(timestamp_millis, &block)
+        @tasks << ScheduledTask.new(timestamp_millis, block)
+        @tasks = @tasks.sort_by(&:timestamp)
+      end
+
+      def pop_due_tasks(timestamp)
+        due_tasks = @tasks.take_while {|t| t.timestamp <= timestamp }
+        @tasks = @tasks - due_tasks
+        due_tasks.map(&:proc)
+      end
+
+      def time_of_next_task
+        task = @tasks.first
+        task && task.timestamp
+      end
+
+      def clear_and_reset
+        @tasks = []
+      end
+    end
+
+
+    private
+
+    def safely_run(&block)
+      begin
+        block.call
+      rescue => e
+        if @error_handler
+          @error_handler.call(e)
+        else
+          raise e
+        end
+      rescue Exception => e
+        @error_handler.call(e) if @error_handler
+        raise e
+      end
+    end
+
+    def set_clock(millis)
+      @timecop.travel(Time.at(millis / 1000.0))
+    end
+
+    def now_millis
+      (Time.now.utc.to_f * 1000.0).to_i
+    end
+
+    # same as add_timer, but adds an optional parameter: reuse_timer
+    def add_timer_internal(delay_seconds, reuse_timer, proc = nil, &block)
+      proc ||= block
+      timer = reuse_timer || MockTimer.new
+      @log.info "Adding timer task: id=#{timer.id}, delay_seconds=#{delay_seconds}"
+      @scheduled_tasks.add_task(now_millis + (delay_seconds * 1000)) do
+        if timer.is_cancelled
+          @log.debug "Skipping this timer task, it's already cancelled"
+        else
+          safely_run { proc.call }
+        end
+      end
+      @timer_objects << timer
+      timer
+    end
+
+  end
+end

data/lib/mock_em/version.rb

@@ -0,0 +1,3 @@
+module MockEM
+  VERSION = "0.1.0"
+end

data/lib/mock_em.rb

@@ -0,0 +1,3 @@
+require 'mock_em/mock_em'
+require 'mock_em/logger_with_prefix'
+

data/mock_em.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mock_em/version'
+
+Gem::Specification.new do |gem|
+  gem.name             = "mock_em"
+  gem.version          = MockEM::VERSION
+
+  gem.authors          = ['Jim Slattery, Dominic Metzger']
+  gem.date             = "2014-05-30"
+
+  gem.summary          = %q{Mock for EM for testing.}
+  gem.description      = %q{Mock EM}
+  gem.homepage         = "https://github.com/rightscale/mock_em"
+  gem.email            = 'support@rightscale.com'
+  gem.licenses         = ["MIT"]
+
+  gem.files            = `git ls-files`.split($/)
+  gem.executables      = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files       = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths    = [ "lib" ]
+  gem.extra_rdoc_files = [ "LICENSE", "README.md" ]
+  gem.rubygems_version = "1.8.26"
+
+  gem.add_dependency("timecop", "0.3.4")
+  # ---------------------------------------------------------------------
+  # Test suite
+  # ---------------------------------------------------------------------
+  gem.add_development_dependency("rspec",        '3.0.0')
+  gem.add_development_dependency('ruby-debug',   '0.10.4')
+  gem.add_development_dependency('eventmachine', '1.0.3')
+end

data/spec/lib/mock_em/mock_em_spec.rb

@@ -0,0 +1,210 @@
+require 'spec/spec_helper'
+require 'mock_em/mock_em'
+require 'eventmachine'
+
+describe MockEM::MockEM do
+
+  # Runs all of these specs on both real EM and MockEM,
+  # so we can immediately notice if their behavior is not identical.
+  [true, false].each do |use_real_em|
+    context "using #{use_real_em ? 'real' : 'fake'} em" do
+
+      before(:each) do
+        @logger = Logger.new(STDOUT)
+        @logger.level = Logger::WARN
+        @em = use_real_em ? EM : MockEM::MockEM.new(@logger, Timecop)
+      end
+      after(:each) do
+        Timecop.return
+      end
+
+      it "#run and #stop" do
+        inside_run = false
+        after_stop = false
+        @em.run do
+          inside_run = true
+          @em.stop
+          after_stop = true
+        end
+        expect(inside_run).to be true
+        expect(after_stop).to be true
+      end
+
+      it "#next_tick &block" do
+        after_stop = false
+        @em.run do
+          @em.next_tick do
+            @em.stop
+            after_stop = true
+          end
+        end
+        expect(after_stop).to be true
+      end
+
+      it "#next_tick proc" do
+        after_stop = false
+        proc = proc {
+          @em.stop
+          after_stop = true
+        }
+        @em.run do
+          @em.next_tick(proc)
+        end
+        expect(after_stop).to be true
+      end
+
+      it "#add_timer &block" do
+        counter = 0
+        @em.run do
+          @em.add_timer(0.1) do
+            expect(counter).to eq(0)
+            counter += 1
+            @em.add_timer(0.1) do
+              expect(counter).to eq(1)
+              @em.stop
+              counter +=1
+            end
+          end
+        end
+        expect(counter).to eq(2)
+      end
+
+      it "#add_timer proc" do
+        counter = 0
+        @em.run do
+          proc1 = proc do
+            expect(counter).to eq(0)
+            counter += 1
+            proc2 = proc do
+              expect(counter).to eq(1)
+              @em.stop
+              counter +=1
+            end
+            @em.add_timer(0.1, proc2)
+          end
+          @em.add_timer(0.1, proc1)
+        end
+        expect(counter).to eq(2)
+      end
+
+      it "#cancel_timer" do
+        @em.run do
+          timer = @em.add_timer(0.1) do
+            fail
+          end
+
+          @em.cancel_timer(timer)
+
+          @em.add_timer(0.3) do
+            @em.stop
+          end
+        end
+      end
+
+      it "#add_periodic_timer &block" do
+        count = 0
+        @em.run do
+          @em.add_periodic_timer(0.1) do
+            count += 1
+            if count > 5
+              @em.stop
+            end
+          end
+        end
+        expect(count).to eq(6)
+      end
+
+      it "#add_periodic_timer proc" do
+        count = 0
+        @em.run do
+          proc1 = proc do
+            count += 1
+            if count > 5
+              @em.stop
+            end
+          end
+          @logger.info "adding timer"
+
+          @em.add_periodic_timer(0.1, proc1)
+        end
+        expect(count).to eq(6)
+      end
+
+      it "cancelling periodic_timer" do
+        @em.run do
+          count = 0
+          timer = nil
+          timer = @em.add_periodic_timer(0.1) do
+            count += 1
+            if count >= 3
+              @em.cancel_timer(timer)
+            end
+          end
+
+          @em.add_timer(0.5) do
+            @em.stop
+            expect(count).to eq(3)
+          end
+        end
+      end
+
+      it "#is_reactor_running?" do
+        expect(@em.reactor_running?).to be false
+        @em.run do
+          expect(@em.reactor_running?).to be true
+          @em.stop
+          expect(@em.reactor_running?).to be true
+        end
+        expect(@em.reactor_running?).to be false
+      end
+
+      it "#add_shutdown_hook" do
+        sequence = []
+        @em.run do
+          @em.add_shutdown_hook { sequence.push(1) }
+          @em.add_shutdown_hook { sequence.push(2) }
+          @em.stop
+        end
+        expect(sequence).to eq([2,1])
+      end
+
+      it "#get_max_timer_count" do
+        expect(@em.get_max_timer_count).to eq(100000)
+      end
+
+      it "#error_handler" do
+        error_count = 0
+        @em.error_handler do |error|
+          @logger.info "Caught error: #{error.inspect}"
+          expect(error.message).to match(/fake_error/)
+          error_count += 1
+        end
+
+        @em.run do
+          @em.next_tick do
+            @em.next_tick do
+              @em.stop
+            end
+            raise "fake_error_2"
+          end
+          raise "fake_error_1"
+        end
+
+        expect(error_count).to eq(2)
+      end
+
+      it "#error_handler not defined, should re-raise error" do
+        expect do
+          @em.run do
+            @em.next_tick do
+              @em.next_tick do
+                raise "error"
+              end
+            end
+          end
+        end.to raise_error
+      end
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'mock_em'
+
+require 'logger'
+require 'timecop'
+
+require 'ruby-debug' # enable debugger support

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification 
+name: mock_em
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Jim Slattery, Dominic Metzger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2014-05-30 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: timecop
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 3
+        - 4
+        version: 0.3.4
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 63
+        segments: 
+        - 0
+        - 10
+        - 4
+        version: 0.10.4
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 17
+        segments: 
+        - 1
+        - 0
+        - 3
+        version: 1.0.3
+  type: :development
+  version_requirements: *id004
+description: Mock EM
+email: support@rightscale.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .gitignore
+- .rspec
+- CHANGELOG.rdoc
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/mock_em.rb
+- lib/mock_em/logger_with_prefix.rb
+- lib/mock_em/mock_em.rb
+- lib/mock_em/version.rb
+- mock_em.gemspec
+- spec/lib/mock_em/mock_em_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/rightscale/mock_em
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Mock for EM for testing.
+test_files: 
+- spec/lib/mock_em/mock_em_spec.rb
+- spec/spec_helper.rb
+has_rdoc: