eetee 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+*.rbc
+.bundle
+Gemfile.lock
+coverage/
+doc/

data/.travis.yml

@@ -0,0 +1,5 @@
+bundler_args: --without development
+rvm:
+  - 1.9.3
+  - rbx-19mode
+

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rake'
+
+group(:test) do
+  gem 'mocha',          '~> 0.12.0'
+  
+  gem 'simplecov'
+  gem 'guard'
+  gem 'rb-fsevent'
+  gem 'growl'
+end

data/Guardfile

@@ -0,0 +1,8 @@
+
+# parameters:
+#  output     => the formatted to use
+#  backtrace  => number of lines, nil =  everything
+guard 'eetee', :output => "BetterOutput", :backtrace => nil do
+  watch(%r{^lib/eetee/(.+)\.rb$})     { |m| "specs/unit/#{m[1]}_spec.rb" }
+  watch(%r{specs/.+\.rb$})
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Julien Ammous
+
+MIT License
+
+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,101 @@
+
+# Continuous integration ([![Build Status](https://secure.travis-ci.org/schmurfy/eetee.png)](http://travis-ci.org/schmurfy/eetee))
+
+This gem is tested against these ruby by travis-ci.org:
+
+- MRI 1.9.3
+- rubinius (1.9 mode)
+
+# What is this name ?
+
+Finding an unused name is getting hard so I finally settled for E.T. because why not ?  
+I did not want to hve a gem with a two letters name so here is eetee !
+
+# What is this gem ?
+
+I used the bacon test framework for quite some time now but I have some issues with it which
+are mostly unfixable without rewriting internals, this is what E.T. is !  
+From the outside the specs should run the same on both but the changed internals allow better
+integration with guard amongst other things.
+
+My goals were:
+- as light as possible (like bacon)
+- minimal set of helpers, go check rspec if you want more
+- specs file should be executable as is, there is no "eetee" binary
+- specs can be grouped without changing anything in them (run all the spec folder)
+- keep bacon syntax as I am used to it and like it
+- a set of extensions I used often (but not required by default)
+
+# Usage
+
+E.T. is using itself for its tests, you can look at the spec_helper.rb file and its tests,
+here is a quickstart:
+
+create a test file (I suppose you are using bundler, if not you should !):
+```ruby
+require 'rubygems'
+require 'bundler/setup'
+require "eetee"
+
+include EEtee
+
+describe 'Tests' do
+  before do
+    @a = 3
+  end
+  
+  should 'have access to instance variables' do
+    @a.should == 3
+  end
+  
+  should 'wait 1s' do
+    sleep 1
+    1.should == 1
+  end
+  
+  should 'works 2' do
+    (40 + 5).should == 45
+  end
+  
+  should 'fails' do
+    "toto".should == 4
+  end
+end
+```
+
+and to run it:
+```bash
+$ ruby test.rb
+```
+
+# Available extensions
+
+## guard
+The guard is included inside the gem, just look at the Guardfile for the gem for the syntax (unfortunately guard init excepts the guard to live in a separate gem)
+
+## mocha
+Allow mocha expectations to be considered as E.T. expectations.
+
+## rack
+Boilet plate around rack-test to test rack applications.
+
+## time
+Some time helpers:
+  time_block{ ... } => return execution time in milliseconds
+  freeze_time => Time.now will return the same time inside the block
+
+
+# Setting up development environmeent
+
+```bash
+# clone the repository and:
+$ bundle
+$ bundle exec guard
+```
+
+the tests will run when a file changed, if only want to run all tests once:
+
+```bash
+$ bundle exec rake
+```
+

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'bundler/setup'
+require "bundler/gem_tasks"
+
+task :default => :test
+
+task :test do
+  
+  # do not generate coverage report under travis
+  unless ENV['TRAVIS']
+    
+    require 'simplecov'
+    SimpleCov.command_name "E.T."
+    SimpleCov.start do
+      add_filter ".*_spec"
+      add_filter "/helpers/"
+    end
+  end
+  
+  require 'eetee'
+  
+  runner = EEtee::Runner.new
+  runner.run_pattern('specs/**/*_spec.rb')
+  runner.report_results()
+  
+end
+

data/eetee.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/eetee/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Julien Ammous"]
+  gem.email         = ["schmurfy@gmail.com"]
+  gem.description   = %q{Test framework inspired by Bacon}
+  gem.summary       = %q{Another test framework}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.name          = "eetee"
+  gem.require_paths = ["lib"]
+  gem.version       = EEtee::VERSION
+  
+  
+  gem.add_dependency 'term-ansicolor', '~> 1.0.7'
+end

data/examples/extensions/extension.rb

@@ -0,0 +1,17 @@
+
+module SimpleExtension
+  def run(&block)
+    super{ run_with_changes(&block) }
+  end
+
+private
+  def run_with_changes(&block)
+    Thread.current[:eetee_simple_extension] = [1]
+    # puts "I did something before the test"
+    block.call
+    # puts "and after the test"
+    Thread.current[:eetee_simple_extension] << 2
+  end
+    
+end
+

data/examples/extensions/test.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'eetee'
+
+require_relative 'extension'
+EEtee::Test.__send__(:include, SimpleExtension)
+
+describe 'context' do
+  should 'use extension' do
+    true.should == true
+  end
+end

data/examples/focus/focus.rb

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require "eetee"
+
+include EEtee
+
+EEtee.enable_focus_mode = true
+
+describe 'Tests' do
+  before do
+    @a = 3
+  end
+  
+  should 'have access to instance variables' do
+    @a.should == 3
+  end
+  
+  should 'wait 1s' do
+    sleep 1
+    1.should == 1
+  end
+  
+  should 'works 2', :focus => true do
+    (40 + 5).should == 45
+  end
+  
+  should 'fails' do
+    "toto".should == 4
+  end
+  
+  describe 'nested context' do
+    should 'also have access to instance variables' do
+      @a.should == 3
+    end
+  end
+end
+

data/examples/shared/shared.rb

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'bundler/setup'
+require "eetee"
+
+include EEtee
+
+
+shared(:valid_object) do |obj, n|
+  should 'receive correct number' do
+    n.should == 42
+  end
+  
+  should 'respond to :to_i' do
+    obj.should.respond_to?(:to_i)
+  end
+  
+  describe 'nested' do
+    should 'have a length higher than 2' do
+      obj.size.should > 2
+    end
+  end
+end
+
+
+describe 'Tests' do
+  before do
+    @obj = "string"
+  end
+  
+  in_scope do
+    run_shared(:valid_object, @obj, 42)
+  end
+  
+end

data/examples/simple/simple.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require "eetee"
+
+include EEtee
+
+
+describe 'Tests' do
+  before do
+    @a = 3
+  end
+  
+  should 'have access to instance variables' do
+    @a.should == 3
+  end
+  
+  should 'wait 1s' do
+    sleep 1
+    1.should == 1
+  end
+  
+  should 'works 2' do
+    (40 + 5).should == 45
+  end
+  
+  should 'fails' do
+    "toto".should == 4
+  end
+  
+  describe 'nested context' do
+    should 'also have access to instance variables' do
+      @a.should == 3
+    end
+  end
+end

data/lib/eetee/assertion_wrapper.rb

@@ -0,0 +1,107 @@
+module EEtee
+  
+  module Assertions
+    def be_a(klass)
+      object_class = @object.class
+      
+      invert_helper(
+        "expected instance of #{klass}, got #{object_class}",
+        "instance of #{klass} not expected"
+      ) do
+        object_class.should == klass
+      end
+      
+    end
+    
+    def raise(error_class = RuntimeError)
+      @object.should.be_a ::Proc
+      
+      err = nil
+      begin
+        self.call()
+      rescue => ex
+        err = ex
+      end
+      
+      invert_helper(
+        "expected to raise #{error_class}, got #{err.class}",
+        "expected not to raise #{error_class}"
+      ) do
+        err.class.should == error_class
+      end
+      
+      err
+    end
+    
+    def close?(target, error_margin)
+      invert_helper(
+        "expected #{target} += #{error_margin}, got #{target}",
+        "expected to be outside of #{target} += #{error_margin}, got #{target}"
+      ) do
+        (target-error_margin .. target+error_margin).should.include?(@object)
+      end
+    end
+    
+  end
+  
+  class AssertionWrapper < BasicObject
+    
+    instance_methods.each do |name|
+      if name =~ /\?|^\W+$/
+        undef_method(name)
+      end
+    end
+    
+    include Assertions
+    
+    def initialize(object)
+      @object = object
+      @invert = false
+    end
+    
+    def method_missing(name, *args, &block)
+      ::EEtee.current_test.reporter.increment_assertions()
+      ret = @object.__send__(name, *args, &block)
+      
+      if !!ret == !!@invert
+        if args.empty?
+          msg = "#{@object.inspect}.#{name}() => #{ret}"
+        else
+          msg = "#{@object.inspect}.#{name}(#{args}) => #{ret}"
+        end
+        
+        ::Kernel.raise AssertionFailed.new("#{@invert ? '[not] ' : ''}#{msg}")
+      end
+    end
+    
+    def not
+      @invert = true
+      self
+    end
+    
+    def be
+      self
+    end
+  
+  private
+    ##
+    # invert result if needed.
+    def invert_helper(message, invert_message)
+      err = nil
+      
+      begin
+        ret = yield
+      rescue AssertionFailed => ex
+        err = ex
+      end
+      
+      if err || @invert
+        ::Kernel.raise AssertionFailed.new(@invert ? invert_message : message)
+      end
+      
+      ret
+    end
+  
+  end
+  
+end

data/lib/eetee/context.rb

@@ -0,0 +1,67 @@
+module EEtee
+  
+  module SharedContextMethods
+    def before(&block)
+      instance_eval(&block)
+    end
+    
+    def describe(description, &block)
+      vars = {}
+      
+      instance_variables.reject{|name| name.to_s.start_with?('@_') }.each do |name|
+        value = instance_variable_get(name)
+        vars[name] = value
+      end
+      
+      Context.new(description, @_level + 1, @_reporter, vars, @_focus_mode, &block)
+    end
+    
+    def should(label, opts = {}, &block)
+      it("should #{label}", opts, &block)
+    end
+        
+    def it(label, opts = {}, &block)
+      if !@_focus_mode || opts[:focus]
+        Test.new(label, @_reporter, &block)
+      end
+    end
+  end
+  
+  class Context
+    attr_reader :description, :level
+    
+    include SharedContextMethods
+    
+    def description; @_description; end
+    def level; @_level; end
+    
+    def initialize(description, level, reporter, vars = {}, focus_mode = false, &block)
+      vars.each do |name, value|
+        instance_variable_set(name, value)
+      end
+      
+      @_focus_mode = focus_mode
+      
+      @_description = description
+      @_level = level
+      @_reporter = reporter
+      @_reporter.around_context(self) do
+        run(&block)
+      end
+    end
+    
+    def run(&block)
+      instance_eval(&block)
+    end
+    
+    def run_shared(name, *args)
+      Shared.run(name, @_reporter, @_level, *args)
+    end
+    
+    def in_scope(&block)
+      instance_eval(&block)
+    end
+    
+  end
+
+end

data/lib/eetee/errors.rb

@@ -0,0 +1,17 @@
+module EEtee
+  
+  class AssertionFailed < RuntimeError
+    attr_accessor :test
+        
+  end
+  
+  class Error < RuntimeError
+    attr_accessor :error, :test
+    
+    def initialize(error, test)
+      @error = error
+      @test = test
+    end
+  end
+  
+end

data/lib/eetee/ext/mocha.rb

@@ -0,0 +1,47 @@
+gem 'mocha', '~> 0.12.0'
+require 'mocha_standalone'
+
+#
+# This extension ensure that mocha expectations are considered
+# as bacon tests. Amongst other thing it allows to have a test
+# containing only mocha expectations.
+class MochaCounterWrapper
+  def initialize(reporter)
+    @reporter = reporter
+  end
+  
+  def increment
+    @reporter.increment_assertions()
+  end
+end
+
+
+
+module MochaSpec
+  def self.included(klass)
+    klass.__send__(:include, Mocha::API)
+  end
+  
+  def run(&block)
+    super{ run_with_mocha(&block) }
+  end
+    
+private
+  def run_with_mocha(&block)
+    begin
+      mocha_setup
+      block.call
+      mocha_verify(MochaCounterWrapper.new(@reporter))
+    rescue Mocha::ExpectationError => e
+      raise EEtee::AssertionFailed.new(e.message)
+      # raise EEte::Error.new(:failed, "#{e.message}\n#{e.backtrace[0...10].join("\n")}")
+    ensure
+      mocha_teardown
+    end
+  end
+  
+end
+
+EEtee::Context.__send__(:include, Mocha::API)
+EEtee::Test.__send__(:include, MochaSpec)
+

data/lib/eetee/ext/rack.rb

@@ -0,0 +1,78 @@
+
+gem 'rack-test', '~> 0.6.2'
+require 'rack/test'
+
+module HTTPTest
+  def serve_app(app)
+    @app = Rack::Test::Session.new(
+        Rack::MockSession.new(app)
+      )
+  end
+  
+  def request(method, url, opts = {})
+    @app.request(url, opts.merge(method: method))
+    @app.last_response
+  end
+  
+  def propfind(url, properties = :all, opts = {})
+    namespaces = {
+      'DAV:' => 'D',
+      'urn:ietf:params:xml:ns:carddav' => 'C',
+      'http://calendarserver.org/ns/' => 'APPLE1'
+    }
+    
+    if properties == :all
+      body = "<D:allprop />"
+      
+    else
+      properties = properties.map do |(name, ns)|
+        ns_short = namespaces[ns]
+        raise "unknown namespace: #{ns}" unless ns_short
+        %.<#{ns_short}:#{name}/>.
+      end
+      
+      body = "<D:prop>#{properties.join("\n")}</D:prop>"
+    end
+    
+    
+    data = <<-EOS
+<?xml version="1.0" encoding="UTF-8"?>
+<D:propfind xmlns:D="DAV:" xmlns:C="urn:ietf:params:xml:ns:carddav" xmlns:APPLE1="http://calendarserver.org/ns/">
+  #{body}
+</D:propfind>
+    EOS
+    
+    request('PROPFIND', url, opts.merge(input: data))
+  end
+  
+  def ensure_element_exists(response, expr, namespaces = {'D' => 'DAV:'})
+    ret = Nokogiri::XML(response.body)
+    ret.css(expr, namespaces).tap{|elements| elements.should.not.be.empty? }
+  rescue EEtee::AssertionFailed => err
+    raise EEtee::AssertionFailed.new("XML did not match: #{expr}")
+  end
+  
+  def ensure_element_does_not_exists(response, expr, namespaces = {})
+    ret = Nokogiri::XML(response.body)
+    ret.css(expr, namespaces).should.be.empty?
+  rescue EEtee::AssertionFailed => err
+    raise EEtee::AssertionFailed.new("XML did match: #{expr}")
+  end
+  
+  def element_content(response, expr, namespaces = {})
+    ret = Nokogiri::XML(response.body)
+    elements = ret.css(expr, namespaces)
+    if elements.empty?
+      :missing
+    else
+      children = elements.first.element_children
+      if children.empty?
+        :empty
+      else
+        children.first.text
+      end
+    end
+  end
+end
+
+EEtee::Context.__send__(:include, HTTPTest)

data/lib/eetee/ext/time.rb

@@ -0,0 +1,25 @@
+module EEteeTimeHelpers
+  def time_block
+    started_at = Time.now
+    yield
+    (Time.now - started_at) * 1000
+  end
+  
+  # load the mocha extension first to enable
+  # this.
+  if defined?(MochaCounterWrapper)
+    ##
+    # Freeze the time, in this block Time.now
+    # will always return the same value.
+    def freeze_time(t = Time.now)
+      Time.stubs(:now).returns(t)
+      if block_given?
+        yield
+        Time.unstub(:now)
+      end
+    end
+  end
+  
+end
+
+EEtee::Context.__send__(:include, EEteeTimeHelpers)