minitest_to_rspec 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dfbca8efedaf7c52597ad002776c9a91913ef953
-  data.tar.gz: f0338aab60ec0ed5c47a73b4da8efe10d219a7b7
+  metadata.gz: 7a27f05346fd70cc99e4153026b9fbbfec34c534
+  data.tar.gz: 56cb0bab1016ecde051d2fcb92f6142d2009c063
 SHA512:
-  metadata.gz: 5c19ee604832c47a8a2b29bf04f80a339e0542fd34d282d2fca7faa571cfdce424d556bc66c607413e9a8b48024b7714561d30b89a4b5f4cc0a4d149615f3a6e
-  data.tar.gz: c84d8763c6788a1e7f781256d7fdd84f673fe995fbd08aad97d26c51f770cce2bd607430c09ade0e9243b01cbe7ff2b3c85b708b3e1d28aa13b4c7a4f35aa93e
+  metadata.gz: f17804b35926a1820f7f521b421bf27a6840afa78a7c6fef1e3ceb97523b19d451ea749b7af3445904448f0a76d805faba95291a49b4b44251486ad0707dbe95
+  data.tar.gz: aee5ab8d4f585ac6a3798002400072278e0abf3b1d28a90fb6dcaf599424308b6d9d5907e75ef02b247f416827281fe7c713d6661a76395aa700d9482bde8870

data/.travis.yml

@@ -1,8 +1,8 @@
 language: ruby
 rvm:
   - "2.0.0-p598"
-  - "2.1.5"
-  - "2.2.1"
+  - "2.1.6"
+  - "2.2.2"
 script: bundle exec rake
 notifications:
   email: false

data/CHANGELOG.md

@@ -4,6 +4,18 @@ Change Log
 This project follows [semver 2.0.0][1] and the recommendations
 of [keepachangelog.com][2].
 
+0.4.0
+-----
+
+### Added
+- Experimental
+  - Conversion of mocha to rspec-mocks
+    - expects
+    - any_instance
+
+### Fixed
+- NoMethodError when input contains stabby lambda
+
 0.3.0
 -----
 

data/README.md

@@ -4,8 +4,9 @@ Converts [minitest][8] files to [rspec][9].
 
 [![Build Status][1]][2] [![Code Climate][3]][4] [![Test Coverage][7]][4]
 
-Uses [ruby_parser][14], [sexp_processor][15], and [ruby2ruby][16],
-in that order.  Thank you, [Ryan Davis][17]!
+Selected assertions from [Test::Unit][26], [minitest][8], and
+[ActiveSupport][27] are converted to [rspec-expectations][25].
+Selected methods from [mocha][28] are converted to [rspec-mocks][24].
 
 Example
 -------
@@ -14,11 +15,12 @@ Input:
 
 ```ruby
 require 'test_helper'
-
-# This comment will be discarded!
-class BananaTest < ActiveSupport::TestCase
-  test "is delicious" do
-    assert Banana.new.delicious?
+class ArrayTest < ActiveSupport::TestCase
+  test "changes length" do
+    ary = []
+    assert_difference "ary.length" do
+      ary.push(:x)
+    end
   end
 end
 ```
@@ -27,16 +29,16 @@ Output:
 
 ```ruby
 require("spec_helper")
-RSpec.describe(Banana) do
-  it("is delicious") { expect(Banana.new.delicious?).to(be_truthy) }
+RSpec.describe(Array) do
+  it("changes length") do
+    ary = []
+    expect { ary.push(:x) }.to(change { ary.length })
+  end
 end
 ```
 
-[RubyParser][14] discards all comments.
-
 The code style is whatever [ruby2ruby][6] feels like printing,
-and is not configurable.  The goal is not style, but to get to
-rspec quickly.
+and is not configurable.  Comments are discarded.
 
 Usage
 -----
@@ -45,7 +47,7 @@ Usage
 
 ```bash
 gem install minitest_to_rspec
-minitest_to_rspec --rails source_file target_file
+bundle exec minitest_to_rspec --rails source_file target_file
 ```
 
 ### Ruby
@@ -67,7 +69,8 @@ Assertion                   | Arity | Source
 --------------------------- | ----- | ------
 assert                      |       |
 assert_difference           | 1,2   |
-assert_equal                |       |
+[assert_equal][23]          | 2,3   | Test::Unit
+[assert_not_equal][22]      | 2,3   | Test::Unit
 assert_match                |       |
 assert_nil                  |       |
 [assert_no_difference][12]  |       | ActiveSupport
@@ -82,11 +85,19 @@ Supported Mocha
 
 Mocha                 | Arity | Block | Notes
 --------------------- | ----- | ----- | -------
+[any_instance][29]    | 0     | n/a   |
+[expects][21]         | 1     | n/a   |
 [stub][19]            | 0,1,2 | no    |
 [stub_everything][18] | 0,1,2 | no    | Uses `as_null_object`, not the same.
 [stubs][20]           | 1     | n/a   |
 
-Notably not yet supported: `expects`, `any_instance`
+Notably not supported yet: [at_least, once, never, raises, etc.][30]
+
+Acknowledgements
+----------------
+
+Uses [ruby_parser][14], [sexp_processor][15], and [ruby2ruby][16]
+by [Ryan Davis][17].
 
 [1]: https://travis-ci.org/jaredbeck/minitest_to_rspec.svg
 [2]: https://travis-ci.org/jaredbeck/minitest_to_rspec
@@ -108,3 +119,13 @@ Notably not yet supported: `expects`, `any_instance`
 [18]: http://www.rubydoc.info/github/floehopper/mocha/Mocha/API:stub_everything
 [19]: http://www.rubydoc.info/github/floehopper/mocha/Mocha/API#stub-instance_method
 [20]: http://www.rubydoc.info/github/floehopper/mocha/Mocha/ObjectMethods#stubs-instance_method
+[21]: http://www.rubydoc.info/github/floehopper/mocha/Mocha/ObjectMethods:expects
+[22]: http://www.rubydoc.info/gems/test-unit/3.0.9/Test/Unit/Assertions#assert_not_equal-instance_method
+[23]: http://www.rubydoc.info/gems/test-unit/3.0.9/Test/Unit/Assertions#assert_equal-instance_method
+[24]: https://github.com/rspec/rspec-mocks
+[25]: https://github.com/rspec/rspec-expectations
+[26]: http://test-unit.github.io/
+[27]: https://rubygems.org/gems/activesupport
+[28]: http://gofreerange.com/mocha/docs/
+[29]: http://www.rubydoc.info/github/floehopper/mocha/Mocha/ClassMethods#any_instance-instance_method
+[30]: http://www.rubydoc.info/github/floehopper/mocha/Mocha/Expectation

data/lib/minitest_to_rspec/errors.rb

@@ -1,6 +1,15 @@
 module MinitestToRspec
   class Error < StandardError; end
   class ProcessingError < Error; end
+
+  # Raise `UnknownVariant` to indicate that an expression is
+  # not recognized.  This exception should always be rescued,
+  # and the original expression should be used in the output.
+  class UnknownVariant < Error; end
+
+  # Raise `NotImplemented` to indicate that an expression is
+  # recognized (not an `UnknownVariant`) but that `minitest_to_rspec`
+  # does not (yet) implement a conversion.
   class NotImplemented < Error; end
 
   class ModuleShorthandError < NotImplemented

data/lib/minitest_to_rspec/exp/call.rb

@@ -74,6 +74,10 @@ module MinitestToRspec
         @exp[2]
       end
 
+      def num_arguments
+        arguments.length
+      end
+
       def one_string_argument?
         arguments.length == 1 && string?(arguments[0])
       end

data/lib/minitest_to_rspec/exp/calls/returns.rb

@@ -1,3 +1,6 @@
+require_relative "../call"
+require_relative "../../errors"
+
 module MinitestToRspec
   module Exp
     module Calls
@@ -5,23 +8,57 @@ module MinitestToRspec
       # Represents a call to `returns`, the stubbing method
       # from `mocha`.
       class Returns < Call
+        KNOWN_RECEIVERS = %i[stubs expects]
+        RSPEC_MOCK_METHODS = { expects: :expect, stubs: :allow }
+
         def initialize(exp)
           @exp = exp
+          raise UnknownVariant unless known_variant?
+        end
+
+        def any_instance?
+          rcr = receiver_call.receiver
+          if !rcr.nil? && sexp_type?(:call, rcr)
+            Call.new(rcr).method_name == :any_instance
+          else
+            false
+          end
         end
 
         # The message recipient
         def msg_recipient
-          stubs_call.receiver
+          receiver_call.receiver
         end
 
         def known_variant?
-          receiver_is_call_to_stubs? &&
+          r = receiver
+          !r.nil? &&
+            r.sexp_type == :call &&
+            KNOWN_RECEIVERS.include?(Call.new(r).method_name) &&
             !values.empty? &&
             message.sexp_type == :lit
         end
 
         def message
-          stubs_call.arguments[0]
+          receiver_call.arguments[0]
+        end
+
+        # To avoid a `ProcessingError` please check `known_variant?`
+        # before calling `rspec_mocks_method`.
+        def rspec_mocks_method
+          RSPEC_MOCK_METHODS[receiver_call.method_name]
+        end
+
+        # Returns `Sexp` representing the object that will receive
+        # the stubbed message.  Examples:
+        #
+        #     banana.stubs(:delicious?).returns(true)
+        #     Kiwi.any_instance.stubs(:delicious?).returns(false)
+        #
+        # The `rspec_msg_recipient` is `banana` and `Kiwi`, respectively.
+        #
+        def rspec_msg_recipient
+          any_instance? ? Call.new(msg_recipient).receiver : msg_recipient
         end
 
         # The return values
@@ -31,14 +68,9 @@ module MinitestToRspec
 
         private
 
-        def receiver_is_call_to_stubs?
-          r = receiver
-          !r.nil? &&
-            r.sexp_type == :call &&
-            Call.new(r).method_name == :stubs
-        end
-
-        def stubs_call
+        # The receiver of the `:returns` message is a `:call`
+        # either to `#stubs` or `#expects`.
+        def receiver_call
           Call.new(receiver)
         end
       end

data/lib/minitest_to_rspec/exp/hash_exp.rb

@@ -0,0 +1,19 @@
+module MinitestToRspec
+  module Exp
+
+    # Data object.  Represents a `:hash` S-expression.
+    class HashExp < Base
+      def initialize(sexp)
+        assert_sexp_type(:hash, sexp)
+        @exp = sexp.dup
+      end
+
+      # A slightly nicer implementation would be:
+      # `@exp[1..-1].each_slice(2).to_h`
+      # but that would require ruby >= 2.1
+      def to_h
+        Hash[@exp[1..-1].each_slice(2).to_a]
+      end
+    end
+  end
+end

data/lib/minitest_to_rspec/sexp_assertions.rb

@@ -2,6 +2,12 @@ module MinitestToRspec
 
   # Useful runtime assertions regarding S-expressions.
   module SexpAssertions
+    def assert_sexp_type_array(type, obj)
+      unless obj.is_a?(Array) && obj.all? { |x| sexp_type?(type, x) }
+        raise TypeError, "Expected array of #{type} sexp, got #{obj.inspect}"
+      end
+    end
+
     def assert_sexp_type(type, exp)
       unless sexp_type?(type, exp)
         raise TypeError, "Expected #{type} s-expression, got #{exp.inspect}"

data/lib/minitest_to_rspec/subprocessors/base.rb

@@ -6,36 +6,42 @@ module MinitestToRspec
       include SexpAssertions
 
       # Returns a s-expression representing an rspec-mocks stub.
-      def allow_to(msg_recipient, matcher)
-        target = s(:call, nil, :allow, msg_recipient)
+      def allow_to(msg_recipient, matcher, any_instance = false)
+        allow_method = any_instance ? :allow_any_instance_of : :allow
+        target = s(:call, nil, allow_method, msg_recipient)
         s(:call, target, :to, matcher)
       end
 
       # Returns a s-expression representing an RSpec expectation, i.e. the
       # combination of an "expectation target" and a matcher.
-      def expect(target, eager, phase, matcher)
-        s(:call, expectation_target(target, eager), phase, matcher)
+      def expect(target, eager, phase, matcher, any_instance)
+        et = expectation_target(target, eager, any_instance)
+        s(:call, et, phase, matcher)
       end
 
-      def expect_to(matcher, target, eager)
-        expect(target, eager, :to, matcher)
+      def expect_to(matcher, target, eager, any_instance = false)
+        expect(target, eager, :to, matcher, any_instance)
       end
 
       def expect_to_not(matcher, target, eager)
-        expect(target, eager, :to_not, matcher)
+        expect(target, eager, :to_not, matcher, false)
       end
 
       # In RSpec, `expect` returns an "expectation target".  This
       # can be based on an expression, as in `expect(1 + 1)` or it
       # can be based on a block, as in `expect { raise }`.  Either
       # way, it's called an "expectation target".
-      def expectation_target(exp, eager = true)
-        m = "expectation_target_%s" % [eager ? "eager" : "lazy"]
-        send(m, exp)
+      def expectation_target(exp, eager, any_instance)
+        if eager
+          expectation_target_eager(exp, any_instance)
+        else
+          expectation_target_lazy(exp)
+        end
       end
 
-      def expectation_target_eager(exp)
-        s(:call, nil, :expect, exp)
+      def expectation_target_eager(exp, any_instance)
+        expect_method = any_instance ? :expect_any_instance_of : :expect
+        s(:call, nil, expect_method, exp)
       end
 
       def expectation_target_lazy(block)
@@ -46,14 +52,19 @@ module MinitestToRspec
         )
       end
 
-      # Run `exp` through a new `Processor`.  This is useful for expressions
-      # that cannot be fully understood by a single subprocessor.  For
-      # example, we process :iter expressions, because we're interested in
-      # :iter that contain e.g. an `assert_difference`.  However, if the :iter
-      # turns out to be uninteresting, we still want to fully process its
-      # sub-expressions. TODO: `full_process` may not be the best name.
-      def full_process(exp)
-        Processor.new(false).process(exp)
+      # If it's a `Sexp`, run `obj` through a new `Processor`.  Otherwise,
+      # return `obj`.
+      #
+      # This is useful for expressions that cannot be fully understood by a
+      # single subprocessor.  For example, we must begin processing all :iter
+      # expressions, because some :iter represent calls we're interested in,
+      # e.g. `assert_difference`.  However, if the :iter turns out to be
+      # uninteresting (perhaps it has no assertions) we still want to fully
+      # process its sub-expressions.
+      #
+      # TODO: `full_process` may not be the best name.
+      def full_process(obj)
+        obj.is_a?(Sexp) ? Processor.new(false).process(obj) : obj
       end
 
       def matcher(name, *args)

data/lib/minitest_to_rspec/subprocessors/call.rb

@@ -1,5 +1,6 @@
 require_relative "../exp/call"
 require_relative "../exp/calls/returns"
+require_relative "../exp/hash_exp"
 require_relative "base"
 
 module MinitestToRspec
@@ -22,8 +23,12 @@ module MinitestToRspec
 
       private
 
-      def allow_receive_and_return(msg_recipient, msg, return_values)
-        allow_to(msg_recipient, receive_and_return(msg, return_values))
+      # - msg_rcp.  Message recipient.  The object to be stubbed.
+      # - msg.  Message.  The name of the stubbed method.
+      # - ret_vals.  Return values.
+      # - any_ins.  Any instance?  True if this is an `any_instance` stub.
+      def allow_receive_and_return(msg_rcp, msg, ret_vals, any_ins = false)
+        allow_to(msg_rcp, receive_and_return(msg, ret_vals), any_ins)
       end
 
       def be_falsey
@@ -42,6 +47,25 @@ module MinitestToRspec
         matcher(:eq, exp)
       end
 
+      # - msg_rcp.  Message recipient.  The object to be stubbed.
+      # - msg.  Message.  The name of the stubbed method.
+      # - ret_vals.  Return values.
+      # - any_ins.  Any instance?  True if this is an `any_instance` stub.
+      def expect_receive_and_return(msg_rcp, msg, ret_vals, any_ins = false)
+        expect_to(receive_and_return(msg, ret_vals), msg_rcp, true, any_ins)
+      end
+
+      # Given a `Sexp` representing a `Hash` of message expectations,
+      # return an array of `Sexp`, each representing an expectation
+      # in rspec-mocks syntax.
+      def hash_to_expectations(sexp, receiver)
+        Exp::HashExp.new(sexp).to_h.map { |msg, ret_val|
+          expect_receive_and_return(
+            receiver.deep_clone, msg, wrap_sexp(ret_val)
+          )
+        }
+      end
+
       def match(pattern)
         matcher(:match, pattern)
       end
@@ -66,6 +90,20 @@ module MinitestToRspec
         expect_to(be_nil, @exp.arguments[0], true)
       end
 
+      def method_assert_not_equal
+        expected = @exp.arguments[0]
+        calculated = @exp.arguments[1]
+        expect_to_not(eq(expected), calculated, true)
+      end
+
+      def method_expects
+        if @exp.num_arguments == 1
+          mocha_expects
+        else
+          @exp.original
+        end
+      end
+
       def method_refute
         expect_to(be_falsey, @exp.arguments[0], true)
       end
@@ -77,12 +115,9 @@ module MinitestToRspec
       end
 
       def method_returns
-        r = Exp::Calls::Returns.new(@exp.original)
-        if r.known_variant?
-          allow_receive_and_return(r.msg_recipient, r.message, r.values)
-        else
-          @exp.original
-        end
+        mocha_returns(Exp::Calls::Returns.new(@exp.original))
+      rescue UnknownVariant
+        @exp.original
       end
 
       def method_require
@@ -127,14 +162,82 @@ module MinitestToRspec
         s(:call, nil, :it, *@exp.arguments)
       end
 
+      def mocha_expects
+        arg = @exp.arguments.first
+        if sexp_type?(:hash, arg)
+          mocha_expects_hash(arg)
+        elsif sexp_type?(:lit, arg)
+          mocha_expects_lit(arg)
+        else
+          @exp.original
+        end
+      end
+
+      def mocha_expects_hash(hash_sexp)
+        assert_sexp_type(:hash, hash_sexp)
+        pointless_lambda(hash_to_expectations(hash_sexp, @exp.receiver))
+      end
+
+      def mocha_expects_lit(lit_sexp)
+        assert_sexp_type(:lit, lit_sexp)
+        expect_to(receive_and_call_original(lit_sexp), @exp.receiver, true)
+      end
+
+      # Given `r`, a `Exp::Calls::Returns`, return a `Sexp` representing
+      # the equivalent stub or message expectation in RSpec.
+      def mocha_returns(r)
+        subprocessor_method = "#{r.rspec_mocks_method}_receive_and_return"
+        send(subprocessor_method,
+          r.rspec_msg_recipient,
+          r.message,
+          r.values,
+          r.any_instance?
+        )
+      end
+
       def name_of_processing_method
         "method_#{@exp.method_name}".to_sym
       end
 
+      # Given `array_of_calls`, returns a `Sexp` representing a
+      # self-executing lambda.
+      #
+      # This works around the fact that `sexp_processor` expects us to return
+      # a single `Sexp`, not an array of `Sexp`.  We also can't return a
+      # `:block`, or else certain input would produce nested blocks (e.g.
+      # `s(:block, s(:block, ..))`) which `ruby2ruby` (naturally) does not know
+      # how to process.  So, the easiest solution I could think of is a
+      # self-executing lambda.
+      #
+      # Currently, the only `:call` which we process into multiple calls is
+      # the hash form of a mocha `#expects`, thankfully uncommon.
+      #
+      # To get better output (without a pointless lambda) we would have to
+      # process `:block` *and* `:defn`, which we are not yet doing.
+
+      def pointless_lambda(array_of_calls)
+        assert_sexp_type_array(:call, array_of_calls)
+        s(:call,
+          s(:iter,
+            s(:call, nil, :lambda),
+            s(:args),
+            s(:block,
+              s(:str, "Sorry for the pointless lambda here."),
+              *array_of_calls
+            )
+          ),
+          :call
+        )
+      end
+
       def receive(message)
         s(:call, nil, :receive, message)
       end
 
+      def receive_and_call_original(message)
+        s(:call, s(:call, nil, :receive, message), :and_call_original)
+      end
+
       def receive_and_return(message, return_values)
         s(:call, receive(message), :and_return, *return_values)
       end
@@ -143,6 +246,11 @@ module MinitestToRspec
         prefix = @rails ? "rails" : "spec"
         s(:call, nil, :require, s(:str, "#{prefix}_helper"))
       end
+
+      # Wraps `obj` in an `Array` if it is a `Sexp`
+      def wrap_sexp(obj)
+        obj.is_a?(Sexp) ? [obj] : obj
+      end
     end
   end
 end

data/lib/minitest_to_rspec/version.rb

@@ -1,3 +1,3 @@
 module MinitestToRspec
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest_to_rspec
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Jared Beck
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-19 00:00:00.000000000 Z
+date: 2015-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby_parser
@@ -168,6 +168,7 @@ files:
 - lib/minitest_to_rspec/exp/base.rb
 - lib/minitest_to_rspec/exp/call.rb
 - lib/minitest_to_rspec/exp/calls/returns.rb
+- lib/minitest_to_rspec/exp/hash_exp.rb
 - lib/minitest_to_rspec/exp/iter.rb
 - lib/minitest_to_rspec/exp/klass.rb
 - lib/minitest_to_rspec/processor.rb