pry-test 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bff3b5b582f2d0f20a0638c8f2d22fe2c8f34328
+  data.tar.gz: f47f593420062049f74de02e4c33ede5406c680b
+SHA512:
+  metadata.gz: 9fb57924837b12dea333bd4e62d98f65c504c29482b4f2e151eaa645f3f8e646d24f9e1f0ca19acd088d3a7a842390fcdbdae7f4b0024d6af6ba456a263d5a76
+  data.tar.gz: c97f1dc2c54058853a4aa3a2ebbf815a22ca5153184acca03a0cf26e6eac41823df4ad67e94feacf24afaf7c349d9a7cfb088181d0ddb933924fc155ccc8386d

data/bin/pry-test

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+require "optparse"
+require_relative "../lib/pry-test"
+
+include PryTest::Color
+
+# setup the formatters list ---------------------------------------------------
+formatter_names = PryTest.formatters.map(&:short_name).sort
+
+# setup the options -----------------------------------------------------------
+options = {}
+parser = OptionParser.new do |opts|
+  opts.banner = "PryTest Usage: pry-test [options] /path/to/test/dir_or_file"
+
+  desc = "Runs tests asynchronously."
+  opts.on("-a", "--async", desc) { |value| options[:async] = value }
+
+  desc = "Runs the PryTest test suite and some additional demo tests."
+  opts.on("--demo", desc) { |value| options[:demo] = value }
+
+  desc = "The formatter to use. [#{formatter_names.join(", ")}]"
+  opts.on("-f", "--formatter [FORMATTER]", desc) do |value|
+    options[:formatter] = value
+  end
+
+  desc = "Stops the test run after the first failure. "
+  opts.on("--fail-fast", desc) { |value| options[:fail_fast] = value }
+
+  desc = "Disabled pry during the test run. "
+  opts.on("--disable-pry", desc) { |value| options[:disable_pry] = value }
+
+  opts.on("-v", "--version", "Show version.") do
+    puts "PryTest #{PryTest::VERSION}"
+    exit 0
+  end
+
+  opts.on_tail("-h", "--help", "Show this message.") do
+    puts opts
+    exit 0
+  end
+end
+parser.parse!
+
+ENV["MT_DEMO"] = "true" if options[:demo]
+
+# setup the test path ---------------------------------------------------------
+path = ARGV.last unless ARGV.last =~ /^-/
+path = File.expand_path("../../test", __FILE__) if options[:demo]
+path ||= "test"
+path = File.join(Dir.pwd, path) unless path =~ /^\//
+unless File.exist?(path)
+  puts "#{path} not found."
+  puts "Please check the path and try again."
+  exit 1
+end
+if path =~ /\.rb$/
+  require path
+else
+  Dir[File.join(path, "**/*.rb")].each { |path| require path }
+end
+
+# setup the formatter ---------------------------------------------------------
+formatter = PryTest.formatters.find { |f| f.short_name == options[:formatter] }
+formatter ||= begin
+  if options[:async]
+    PryTest.formatters.find { |f| f.short_name == "default_async" }
+  else
+    PryTest.formatters.find { |f| f.short_name == "default" }
+  end
+end
+
+# setup the test runner -------------------------------------------------------
+runner = PryTest::Runner.new(formatter.new, options)
+
+# setup pry -------------------------------------------------------------------
+if options[:async] || RUBY_ENGINE == "jruby" || RUBY_ENGINE == "rbx"
+  optional[:disable_pry] = true
+end
+
+if options[:disable_pry]
+  puts magenta("Disabling pry when running with: [#{RUBY_ENGINE}] #{options.inspect}")
+  exit runner.run
+else
+  begin
+    require "pry"
+    require "pry-stack_explorer"
+    require "pry-rescue"
+  rescue Exception => e
+    puts red(e.message)
+    puts e.backtrace.join("\n")
+    puts red("This can be caused when pry-stack_explorer isn't specified in the Gemfile.")
+    puts red("It might also indicate that pry-stack_explorer & pry are out of sync.")
+    puts red("Try different cominations of GEM versions for pry & pry-stack_explorer.")
+    exit 1
+  end
+
+  Pry.config.hooks.add_hook :before_session, :print_instructions do |_, _, _pry_|
+    puts
+    puts magenta(" Pry session started")
+    puts magenta("".ljust(80, "-"))
+    puts " #{magenta "  Failures:"} Type #{green "up"} to see the line that failed"
+    puts " #{magenta "Exceptions:"} Type #{green "whereami"} to get your bearings"
+    puts
+    puts " Type #{green "exit"} or #{green "<CTL-D>"} to continue"
+    puts magenta("".ljust(80, "-"))
+    puts
+  end
+
+  exit Pry.rescue { runner.run }
+end

data/ext/mkrf_conf.rb

@@ -0,0 +1,33 @@
+# based on instructions here:
+# http://en.wikibooks.org/wiki/Ruby_Programming/RubyGems#How_to_install_different_versions_of_gems_depending_on_which_version_of_ruby_the_installee_is_using
+require 'rubygems'
+require 'rubygems/command.rb'
+require 'rubygems/dependency_installer.rb'
+
+begin
+  Gem::Command.build_args = ARGV
+  rescue NoMethodError
+end
+
+installer = Gem::DependencyInstaller.new
+
+begin
+  if !(RUBY_ENGINE =~ /jruby/i)
+    puts "Installing pry and pry-stack_explorer."
+    installer.install "pry"
+    installer.install "pry-stack_explorer"
+    installer.install "pry-rescue"
+  else
+    puts "Platform is java... skip install for pry and pry-stack_explorer."
+  end
+rescue Exception => e
+  puts e.message
+  puts e.backtrace.join("\n")
+  exit(1)
+end
+
+f = File.open(File.expand_path("../Rakefile", __FILE__), "w")   # create dummy rakefile to indicate success
+f.write("task :default\n")
+f.close
+
+exit

data/lib/pry-test.rb

@@ -0,0 +1,5 @@
+path = File.expand_path("../pry-test/*.rb", __FILE__)
+Dir[path].each { |file| require file }
+
+path = File.expand_path("../pry-test/formatters/**/*.rb", __FILE__)
+Dir[path].each { |file| require file }

data/lib/pry-test/formatters/base_formatter.rb

@@ -0,0 +1,74 @@
+module PryTest
+
+  class << self
+    def formatters
+      @formatters ||= []
+    end
+  end
+
+  # The base class for formatters.
+  # Defines the API that formatters can/should implement
+  # to control test run output.
+  class BaseFormatter
+    attr_accessor :passed, :failed, :duration
+
+    class << self
+      def inherited(subclass)
+        PryTest.formatters << subclass
+      end
+
+      def short_name
+        @short_name || name
+      end
+
+      def set_short_name(value)
+        @short_name = value
+      end
+    end
+
+    def initialize
+      @duration = 0
+      @passed = 0
+      @failed = 0
+    end
+
+    def before_suite(test_classes)
+    end
+
+    def before_class(test_class)
+    end
+
+    def before_test(test)
+    end
+
+    def after_test(test)
+    end
+
+    def after_class(test_class)
+    end
+
+    def after_results(runner)
+      @duration = runner.duration
+      @passed = runner.passed
+      @failed = runner.failed
+    end
+
+    def after_suite(test_classes)
+    end
+
+    def render(template_name, template_context=nil)
+      puts text_to_render(template_name, template_context)
+    end
+
+    def render_inline(template_name, template_context=nil)
+      print text_to_render(template_name, template_context)
+    end
+
+    private
+
+    def text_to_render(template_name, template_context=nil)
+      Template.new(template_context || self).render_to_string(template_name)
+    end
+
+  end
+end

data/lib/pry-test/formatters/color.rb

@@ -0,0 +1,26 @@
+module PryTest
+  module Color
+    extend self
+
+    colors = {
+      :red     => 31,
+      :green   => 32,
+      :yellow  => 33,
+      :blue    => 34,
+      :magenta => 35,
+      :cyan    => 36,
+      :white   => 37,
+      :gray    => 90
+    }
+
+    def default(text)
+      text
+    end
+
+    colors.each do |name, code|
+      define_method name do |text|
+      "\e[#{code}m#{text}\e[0m"
+      end
+    end
+  end
+end

data/lib/pry-test/formatters/default_async_formatter.rb

@@ -0,0 +1,40 @@
+require_relative "base_formatter"
+
+module PryTest
+  class DefaultAsyncFormatter < PryTest::BaseFormatter
+    set_short_name "default_async"
+
+    def after_test(test)
+      render_inline "default_async/test", test
+    end
+
+    def after_suite(test_classes)
+      puts
+      test_classes.each do |test_class|
+        render_output_for_test_class test_class
+      end
+
+      render "default/suite"
+    end
+
+    private
+
+    def render_output_for_test_class(test_class)
+      render "default/class", test_class
+      test_class.tests.each do |test|
+        render_output_for_test test
+      end
+    end
+
+    def render_output_for_test(test)
+      return unless test.finished?
+
+      if test.passed?
+        render "default/test_pass", test
+      else
+        render "default/test_fail", test
+      end
+    end
+
+  end
+end

data/lib/pry-test/formatters/default_formatter.rb

@@ -0,0 +1,24 @@
+require_relative "base_formatter"
+
+module PryTest
+  class DefaultFormatter < PryTest::BaseFormatter
+    set_short_name "default"
+
+    def before_class(test_class)
+      render "default/class", test_class
+    end
+
+    def after_test(test)
+      if test.passed?
+        render "default/test_pass", test
+      else
+        render "default/test_fail", test
+      end
+    end
+
+    def after_suite(test_classes)
+      render "default/suite"
+    end
+
+  end
+end

data/lib/pry-test/formatters/template.rb

@@ -0,0 +1,50 @@
+require_relative "color"
+
+module PryTest
+  class Template
+    include Color
+
+    def self.view(name)
+      @views ||= {}
+      @views[name] ||= File.read(File.expand_path("../views/#{name}.txt.erb", __FILE__))
+    end
+
+    def initialize(context)
+      @context = context
+    end
+
+    def render_to_string(name)
+      instance_eval do
+        ERB.new(self.class.view(name), nil, "%<>-").result(binding)
+      end
+    end
+
+    def partial(name, *collection)
+      return render_to_string(name) if collection.empty?
+      collection.map do |item|
+        Template.new(item).render_to_string(name)
+      end.join("\n")
+    end
+
+    def duration_color(duration)
+      return :yellow if @context.duration <= 0.01
+      :red
+    end
+
+    def assert_lines(assert)
+      index = assert[:line_num] - 1
+      start = index - 2
+      start = 0 if start <= 0
+      finish = index + 2
+      finish = assert[:lines].length - 1 if finish >= assert[:lines].length
+      (start..finish).map do |i|
+        {
+          :line_num => (i + 1),
+          :line => assert[:lines][i],
+          :color => (i == index ? :red : :gray)
+        }
+      end
+    end
+
+  end
+end

data/lib/pry-test/formatters/views/default/assert_fail.txt.erb

@@ -0,0 +1,6 @@
+<%= @context[:file_path].strip %><%= gray ":" %><%= red @context[:line_num] %>
+<%= red "".ljust(80, "-") %>
+<% assert_lines(@context).each do |line| -%>
+<%= send line[:color], line[:line_num].to_s.rjust(4) %><%= gray "|" %> <%= send line[:color], line[:line] -%>
+<% end -%>
+<%= red "".ljust(80, "-") %>

data/lib/pry-test/formatters/views/default/class.txt.erb

@@ -0,0 +1,2 @@
+
+<%= @context.name.ljust(80, "-") %>

data/lib/pry-test/formatters/views/default/suite.txt.erb

@@ -0,0 +1,9 @@
+
+--------------------------------------------------------------------------------
+<%= green "#{@context.passed} Passed" -%>
+<% if @context.failed > 0 -%>
+, <%= red "#{@context.failed} Failed" -%>
+<% end -%>
+ Finished in <%= yellow @context.duration %> seconds.
+--------------------------------------------------------------------------------
+

data/lib/pry-test/formatters/views/default/test_fail.txt.erb

@@ -0,0 +1,2 @@
+  <%= send duration_color(@context.duration), @context.duration %> <%= red @context.desc -%>
+ <%= partial "default/assert_fail", *@context.failed_asserts -%>

data/lib/pry-test/formatters/views/default/test_pass.txt.erb

@@ -0,0 +1 @@
+  <%= send duration_color(@context.duration), @context.duration %> <%= green @context.desc -%>

data/lib/pry-test/formatters/views/default_async/test.txt.erb

@@ -0,0 +1 @@
+<%= gray "." -%>

data/lib/pry-test/runner.rb

@@ -0,0 +1,73 @@
+require "os"
+require "thread"
+
+module PryTest
+  class Runner
+    class << self
+      attr_accessor :exit
+    end
+
+    attr_reader :formatter, :options, :active_test, :duration, :passed, :failed
+
+    def initialize(formatter, options={})
+      @formatter = formatter
+      @options = options
+      reset
+    end
+
+    def run
+      test_classes = PryTest::Test.subclasses.shuffle
+      tests = test_classes.map{ |klass| klass.tests }.flatten
+      formatter.before_suite(test_classes)
+      start = Time.now
+
+      test_classes.each do |test_class|
+        formatter.before_class(test_class)
+        test_class.tests.shuffle.each do |test|
+          @active_test = test
+          if @options[:async]
+            @tests ||= Queue.new
+            @tests << test
+          else
+            test.invoke(@formatter, @options)
+          end
+        end
+        formatter.after_class(test_class)
+      end
+
+      run_threads if @options[:async]
+
+      @duration = Time.now - start
+      @passed = tests.select{ |test| test.passed? }.count
+      @failed = tests.select{ |test| !test.passed? }.count
+      formatter.after_results(self)
+      formatter.after_suite(test_classes)
+      @failed
+    end
+
+    def reset
+      @duration = 0
+      @passed = 0
+      @failed = 0
+    end
+
+    protected
+
+    def run_threads
+      threads = []
+      thread_count = OS.cpu_count
+      thread_count = 2 if thread_count < 2
+      puts "PryTest is running #{thread_count} threads."
+      thread_count.times do
+        threads << Thread.new do
+          while @tests.empty? == false
+            Thread.current.kill if PryTest::Runner.exit
+            @tests.pop.invoke(@formatter, @options)
+          end
+        end
+      end
+      threads.each { |t| t.join }
+    end
+
+  end
+end

data/lib/pry-test/test.rb

@@ -0,0 +1,85 @@
+module PryTest
+
+  # Superclass for all test classes.
+  # @example Create a subclass with a test.
+  #   class SimpleTest < PryTest::Test
+  #     test "common sense" do
+  #       assert 1 > 0
+  #     end
+  #   end
+  class Test
+    class << self
+
+      # All subclasses of this class.
+      # @return [Array<PryTest::Test>]
+      def subclasses
+        @subclasses ||= []
+      end
+
+      # All individual tests defined in this class.
+      # @return [Array<PryTest::TestWrapper>]
+      def tests
+        @tests ||= []
+      end
+
+      # All files that define subclasses of this class.
+      # @note Primarily used in the context of PryTest::Test.
+      # @example Files are stored in a Hash with the following format.
+      #   {
+      #     "path/to/file1.rb" => ["line 1", "line 2", "line 3", ...],
+      #     "path/to/file2.rb" => ["line 1", "line 2", "line 3", ...]
+      #   }
+      # @return [Hash]
+      def files
+        @files ||= {}
+      end
+
+      # Resets the state in preparation for a new test run.
+      def reset
+        tests.each { |test| test.reset }
+        subclasses.each { |subclass| subclass.reset }
+      end
+
+      # A callback provided by Ruby that is invoked whenever a subclass is created.
+      def inherited(subclass)
+        file_path = caller[0][0, caller[0].index(/:[0-9]+:/)]
+        files[file_path] = File.open(file_path).readlines
+        subclasses << subclass
+      end
+
+      # Defines a setup method that will run before each individual test.
+      # @param [Symbol] what Deprecated but maintained for backwards compatibility.
+      # @yield A block of code that will serve as the setup method.
+      def before(what=nil, &block)
+        @before = block
+      end
+
+      # Defines a teardown method that will run after each individual test.
+      # @param [Symbol] what Deprecated but maintained for backwards compatibility.
+      # @yield A block of code that will serve as the teardown method.
+      def after(what=nil, &block)
+        @after = block
+      end
+
+      # Defines a test.
+      # Allows subclasses to define tests in their class definition.
+      #
+      # @param [String] desc A description for the test.
+      # @yield A block that defines the test code.
+      #
+      # @example
+      #   class SimpleTest < PryTest::Test
+      #     test "common sense" do
+      #       assert 1 > 0
+      #     end
+      #   end
+      def test(desc, &block)
+        wrapper = PryTest::TestWrapper.new(self, desc, &block)
+        wrapper.create_method(:before, &@before) if @before
+        wrapper.create_method(:after, &@after) if @after
+        tests << wrapper
+      end
+
+    end
+  end
+end

data/lib/pry-test/test_wrapper.rb

@@ -0,0 +1,144 @@
+require "monitor"
+
+module PryTest
+
+  # A wrapper class for individual tests.
+  # Exists for the purpose of isolating the test method so it can run in its own thread.
+  class TestWrapper
+    include MonitorMixin
+    attr_reader :test_class, :desc, :asserts
+
+    # Constructor.
+    # @param [PryTest::Test] test_class The test class that defines the test being wrapped.
+    # @param [String] desc The test description.
+    # @yield The block that defines the test code.
+    def initialize(test_class, desc, &block)
+      super() # inits MonitorMixin
+      @test_class = test_class
+      @desc = desc
+      create_method(:test, &block)
+      reset
+    end
+
+    # Creates a method on this instance.
+    # @param [Symbol] name The name of the method.
+    # @yield The block of code that will serve as the method's implementation.
+    def create_method(name, &block)
+      eigen = class << self; self; end
+      eigen.send(:define_method, name, &block)
+    end
+
+    # callback stubs
+    def before; end
+    def after; end
+
+    # Runs the test code.
+    # @formatter [PryTest::Formatter] The formatter to use.
+    # @options [Hash]
+    def invoke(formatter, options={})
+      reset
+      @formatter = formatter
+      @options = options
+      @formatter.before_test(self)
+      start = Time.now
+      before
+      test
+      @invoked = true
+      after
+      @duration = Time.now - start
+      @formatter.after_test(self)
+    end
+
+    # A basic assert method to be used within tests.
+    #
+    # @param [Object] value The value to assert.
+    #
+    # @example
+    #   class SimpleTest < PryTest::Test
+    #     test "common sense" do
+    #       assert 1 > 0
+    #     end
+    #   end
+    def assert(value)
+      @asserts << assert_info(caller).merge(:value => value)
+
+      if !value
+        binding.pry(:quiet => true) unless @options[:disable_pry]
+
+        # I don't really like the coupling to the runner here
+        PryTest::Runner.exit = true if @options[:fail_fast]
+      end
+
+      value
+    end
+
+    # Indicates if this test has finished running.
+    # @return [Boolean]
+    def finished?
+      !@duration.nil?
+    end
+
+    # Indicates if this test passed.
+    def passed?
+      return true if !@invoked || @asserts.empty?
+      return false if @asserts.empty?
+      @asserts.map{ |a| !!a[:value] }.uniq == [true]
+    end
+
+    # Returns a list of all failed asserts.
+    def failed_asserts
+      return [] if passed?
+      @asserts.select { |a| !a[:value] }
+    end
+
+    # Resets this test in preparation for a clean test run.
+    def reset
+      @invoked = false
+      @asserts = []
+      @duration = nil
+    end
+
+    # Rounded duration.
+    def duration
+      return nil if @duration.nil?
+      (@duration * 10**4).ceil.to_f / 10**4
+    end
+
+    private
+
+    # Builds a Hash of assert information for the given call stack.
+    #
+    # @param [Array<String>] stack The call stack to extract info from.
+    #
+    # @example
+    #   {
+    #     :file_path => "/path/to/test_file.rb",
+    #     :line_num => 100,
+    #     :line => "  assert 'something' do"
+    #   }
+    #
+    # @return [Hash]
+    def assert_info(stack)
+      file_path = stack[0][0, stack[0].index(/:[0-9]+:/)]
+      lines = PryTest::Test.files[file_path]
+      line_num = line_number(stack, 0)
+      line_index = line_num - 1
+      line = lines[line_index]
+      {
+        :file_path => file_path,
+        :lines => lines,
+        :line_num => line_num,
+        :line => line
+      }
+    end
+
+    # Returns a line number from a call stack.
+    # @param [Array<String>] stack The call stack to pull a path from.
+    # @param [Integer] index The index of the call stack entry to use.
+    # @return [String]
+    def line_number(stack, index)
+      stack[index].scan(/:[0-9]+:/).first.gsub(/:/, "").to_i
+    end
+
+  end
+end

data/lib/pry-test/version.rb

@@ -0,0 +1,3 @@
+module PryTest
+  VERSION = "0.5.0"
+end

data/test/color_test.rb

@@ -0,0 +1,47 @@
+unless ENV["MT_DEMO"]
+  require_relative "test_helper"
+
+  class ColorTest < PryTest::Test
+    class Crayon
+      include PryTest::Color
+    end
+    CRAYON = Crayon.new
+
+    test "red" do
+      assert PryTest::Color.red("foo") == "\e[31mfoo\e[0m"
+      assert ColorTest::CRAYON.red("foo") == "\e[31mfoo\e[0m"
+    end
+
+    test "green" do
+      assert PryTest::Color.green("foo") == "\e[32mfoo\e[0m"
+      assert ColorTest::CRAYON.green("foo") == "\e[32mfoo\e[0m"
+    end
+
+    test "yellow" do
+      assert PryTest::Color.yellow("foo") == "\e[33mfoo\e[0m"
+      assert ColorTest::CRAYON.yellow("foo") == "\e[33mfoo\e[0m"
+    end
+
+    test "blue" do
+      assert PryTest::Color.blue("foo") == "\e[34mfoo\e[0m"
+      assert ColorTest::CRAYON.blue("foo") == "\e[34mfoo\e[0m"
+    end
+
+    test "magenta" do
+      assert PryTest::Color.magenta("foo") == "\e[35mfoo\e[0m"
+      assert ColorTest::CRAYON.magenta("foo") == "\e[35mfoo\e[0m"
+    end
+
+    test "cyan" do
+      assert PryTest::Color.cyan("foo") == "\e[36mfoo\e[0m"
+      assert ColorTest::CRAYON.cyan("foo") == "\e[36mfoo\e[0m"
+    end
+
+    test "white" do
+      assert PryTest::Color.white("foo") == "\e[37mfoo\e[0m"
+      assert ColorTest::CRAYON.white("foo") == "\e[37mfoo\e[0m"
+    end
+
+  end
+
+end

data/test/cpu_latency_test.rb

@@ -0,0 +1,30 @@
+if ENV["MT_DEMO"]
+  require_relative "test_helper"
+
+  class TestCPULatency < PryTest::Test
+
+    before do
+      @count = 35
+    end
+
+    test "fibonacci recursion 1" do
+      @count.times { |i| TestCPULatency.fib(i) }
+      assert true
+    end
+
+    test "fibonacci recursion 2" do
+      @count.times { |i| TestCPULatency.fib(i) }
+      assert true
+    end
+
+    test "fibonacci recursion 3" do
+      @count.times { |i| TestCPULatency.fib(i) }
+      assert true
+    end
+
+    def self.fib(n)
+      n < 2 ? n : fib(n-1) + fib(n-2)
+    end
+
+  end
+end

data/test/fail_test.rb

@@ -0,0 +1,18 @@
+if ENV["MT_DEMO"]
+  require_relative "test_helper"
+
+  class Fail < PryTest::Test
+
+    before do
+      @var = "fubar"
+    end
+
+    test "fail on purpose" do
+      # Failing on purpose for the demo.
+      # Use pry to check out the current binding.
+      # For example, type @var.
+      assert false
+    end
+
+  end
+end

data/test/io_latency_test.rb

@@ -0,0 +1,22 @@
+if ENV["MT_DEMO"]
+  require_relative "test_helper"
+
+  class TestIOLatency < PryTest::Test
+
+    test "sleep 1 sec" do
+      sleep 1
+      assert true
+    end
+
+    test "sleep another 1 sec" do
+      sleep 1
+      assert true
+    end
+
+    test "sleep a third 1 sec" do
+      sleep 1
+      assert true
+    end
+
+  end
+end

data/test/runner_test.rb

@@ -0,0 +1,15 @@
+unless ENV["MT_DEMO"]
+  require_relative "test_helper"
+
+  class TestRunner < PryTest::Test
+
+    before do
+      @runner = PryTest::Runner.new(PryTest::DefaultFormatter.new)
+    end
+
+    test ".running" do
+      assert true
+    end
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require "coveralls"
+Coveralls.wear!
+
+require_relative "../lib/pry-test"

data/test/test_test.rb

@@ -0,0 +1,70 @@
+unless ENV["MT_DEMO"]
+  require_relative "test_helper"
+
+  class TestTest < PryTest::Test
+
+    before do
+      @test_test = TestTest.clone
+      @test_test.instance_eval { @subclasses = [] }
+      @test_test.instance_eval { @tests = [] }
+      @Example = Class.new(@test_test) do
+        before {}
+        after {}
+        test("truth") { assert true }
+      end
+      @before_callback = @Example.before
+      @after_callback = @Example.after
+    end
+
+    test "adds subclass" do
+      assert @test_test.subclasses.length == 1
+      assert @test_test.subclasses[0] == @Example
+    end
+
+    test "stores subclasses" do
+      assert @test_test.subclasses.is_a?(Array)
+      assert @test_test.subclasses.length == 1
+      assert @test_test.subclasses.first == @Example
+    end
+
+    test "stores tests" do
+      assert @Example.tests.is_a?(Array)
+      assert @Example.tests.length == 1
+      assert @Example.tests.first.is_a?(PryTest::TestWrapper)
+    end
+
+    test "stores files" do
+      file = __FILE__
+      assert @test_test.files[file].is_a?(Array)
+      assert @test_test.files[file].select{ |l| l.start_with?("      assert @test_test.files[file].select{ |l| l.start_with?(") }.length > 0
+    end
+
+    test ".reset" do
+      @Example.tests.first.instance_eval do
+        @asserts = nil
+        @duration = nil
+      end
+      @Example.reset
+      assert @Example.tests.length == 1
+      assert @Example.tests.first.asserts == []
+      assert @Example.tests.first.duration == nil
+    end
+
+    test ".before" do
+      assert @Example.instance_eval { @before } == @before_callback
+    end
+
+    test ".after" do
+      assert @Example.instance_eval { @after } == @after_callback
+    end
+
+    test "tests" do
+      t = lambda {}
+      @Example.send :test, :add_a_test, &t
+      assert @Example.tests.length == 2
+      assert @Example.tests.last.is_a?(PryTest::TestWrapper)
+      assert @Example.tests.last.desc == :add_a_test
+    end
+
+  end
+end

data/test/test_wrapper_test.rb

@@ -0,0 +1,19 @@
+unless ENV["MT_DEMO"]
+  require_relative "test_helper"
+
+  class TestWrapperTest < PryTest::Test
+
+    test ".new" do
+      desc = "test_#{rand(999**10)}"
+      meth = lambda { ".new" }
+      t = PryTest::TestWrapper.new(TestWrapperTest, desc, &meth)
+      assert t.desc == desc
+      assert t.test == ".new"
+      assert t.passed?
+      assert t.finished? == false
+      assert t.duration.nil?
+      assert t.asserts.empty?
+    end
+
+  end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: pry-test
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Nathan Hopkins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: os
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A testing framework that supports debugging test failures & errors as
+  they happen.
+email:
+- natehop@gmail.com
+executables:
+- pry-test
+extensions:
+- ext/mkrf_conf.rb
+extra_rdoc_files: []
+files:
+- bin/pry-test
+- ext/mkrf_conf.rb
+- lib/pry-test.rb
+- lib/pry-test/formatters/base_formatter.rb
+- lib/pry-test/formatters/color.rb
+- lib/pry-test/formatters/default_async_formatter.rb
+- lib/pry-test/formatters/default_formatter.rb
+- lib/pry-test/formatters/template.rb
+- lib/pry-test/formatters/views/default/assert_fail.txt.erb
+- lib/pry-test/formatters/views/default/class.txt.erb
+- lib/pry-test/formatters/views/default/suite.txt.erb
+- lib/pry-test/formatters/views/default/test_fail.txt.erb
+- lib/pry-test/formatters/views/default/test_pass.txt.erb
+- lib/pry-test/formatters/views/default_async/test.txt.erb
+- lib/pry-test/runner.rb
+- lib/pry-test/test.rb
+- lib/pry-test/test_wrapper.rb
+- lib/pry-test/version.rb
+- test/color_test.rb
+- test/cpu_latency_test.rb
+- test/fail_test.rb
+- test/io_latency_test.rb
+- test/runner_test.rb
+- test/test_helper.rb
+- test/test_test.rb
+- test/test_wrapper_test.rb
+homepage: https://github.com/hopsoft/pry-test
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A testing framework that supports debugging test failures & errors as they
+  happen.
+test_files:
+- test/color_test.rb
+- test/cpu_latency_test.rb
+- test/fail_test.rb
+- test/io_latency_test.rb
+- test/runner_test.rb
+- test/test_helper.rb
+- test/test_test.rb
+- test/test_wrapper_test.rb