rspec-xunit 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d48b5d54ba47473aa22ac7ec656b7b3f772b6cbeb64d1bd4fc2f6717d0cf0775
-  data.tar.gz: 8cd92f78030c96d6d2c73b2fb0dc6853ec1a2b399af134160263a9fcc0ba56be
+  metadata.gz: 713f3c53c0bd3aad430437522e74b80d908906ab961722eb20d9a69b22172dde
+  data.tar.gz: 04d407dfa15abe6a3916a9352d456a0b6397beebadfb6add22246889cca546ba
 SHA512:
-  metadata.gz: cbb7e89e1e735e8d593edf2c01b4b406a8af76ea2e59c81e4943e9ca72567460d431a61181c4826039dcf6fe7bfd7b0511f235c5b3e40a83b18f9022ab2c9e73
-  data.tar.gz: 70df062dddc7f78a23f67b7bb15429aa75459c65abeb4920f76048987662bf554790bc468f1974eca43f5081474527435f0774463a7e3c5f41aefa577cb45910
+  metadata.gz: e34fc54d2bc49c960802fbb767c53a3d30d4021f0fc02d9992d20b8c93eeca98a69f769f7361097f88919b132672cfea0284a24d7663bbc62fc475ca2dc2e353
+  data.tar.gz: 8e8e894a5ecefd0d7aba030909924a578c61ea707466354961bcce8c8b091a9c2ba0f5422362b3fc7b6cfff9d2ce4e8b4ea9bf0464b94eb58172851454030b27

data/Gemfile

@@ -4,3 +4,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in rspec-xunit.gemspec
 gemspec
+
+gem 'rspec-mocks'

data/README.md

@@ -138,7 +138,7 @@ end
 We have the aliases of `assert_raise` and `assert_raises` to
 `assert_raise_error` for that extra bittersweet xUnit feel. 🤤
 
-Some block-level assertions, though are hard to convert. Take this example,
+Some block-level assertions are hard to convert. Take this example,
 for example 😉:
 
 ```ruby
@@ -154,13 +154,13 @@ end
 ```
 
 We cannot translate `change { Session.count }.by(1)` to a nice assertion. This
-is where the `assert` fall-back comes in:
+is where the `assert!` fall-back comes in:
 
 ```ruby
 test "user authentication" do
   user = create :user
 
-  assert {
+  assert! {
     assert_valid? login
   }.to change { Session.count }.by(1)
 end
@@ -176,3 +176,8 @@ method on the asserted object.
 ```ruby
 assert_empty? object_responding_to_empty_question_mark
 ```
+
+### Stubs & Mocks
+
+To write stubs and mocks in xUnit fashion, use `stub` instead of `allow` and
+`mock` instead of `expect`. Everything else is the same.

data/lib/rspec/xunit/assertions.rb

@@ -9,11 +9,11 @@ module RSpec
         # Assertion match converts RSpec matchers into an XUnit friendly
         # assertions.
         #
-        # For example: `assertion_match :eq` will create an `assert_eq` method
-        # behaving in the same way as:
+        # For example, `assertion_match :eq` will create two methods:
         #
-        # `expect(action).to eq(expected)`
-        def assertion_match(matcher, suffix = guess_assertion_suffix(matcher))
+        # - `assert_eq` roughly `expect(action).to eq(expected)`
+        # - `assert_not_eq` roughly `expect(action).to_not eq(expected)`
+        def assertion_match(matcher, suffix = matcher)
           define_method "assert_#{suffix}" do |value, *args, &block|
             begin
               expect(value).to send(matcher, *args, &block)
@@ -21,16 +21,25 @@ module RSpec
               raise e, e.message, adjust_for_better_failure_message(e.backtrace), cause: nil
             end
           end
+
+          define_method "assert_not_#{suffix}" do |value, *args, &block|
+            begin
+              expect(value).to_not send(matcher, *args, &block)
+            rescue Expectations::ExpectationNotMetError => e
+              raise e, e.message, adjust_for_better_failure_message(e.backtrace), cause: nil
+            end
+          end
         end
 
         # Assertion match block converts RSpec block matchers into XUnit
         # friendly assertions.
         #
-        # For example: `assertion_match_block :raises, :raise_error` will
-        # create an `assert_raises` method behaving in the same way as:
+        # For example, `assertion_match_block :raises, :raise_error` will
+        # generate two methods:
         #
-        # `expect { bloc }.to raise_error`
-        def assertion_match_block(matcher, suffix = guess_assertion_suffix(matcher))
+        # - `assert_raises` roughly `expect { bloc }.to raise_error`
+        # - `assert_not_raises` roughly `expect { bloc }.to_not raise_error`
+        def assertion_match_block(matcher, suffix = matcher)
           define_method "assert_#{suffix}" do |*args, &block|
             begin
               expect(&block).to send(matcher, *args)
@@ -38,75 +47,84 @@ module RSpec
               raise e, e.message, adjust_for_better_failure_message(e.backtrace), cause: nil
             end
           end
-        end
-
-        private
-
-        MATCHER_CRUFT_REGEX = /((?:be_)|(?:have_))(.*)/.freeze
 
-        def guess_assertion_suffix(matcher_name)
-          MATCHER_CRUFT_REGEX.match(matcher_name) do |match|
-            match[2]
-          end || matcher_name
+          define_method "assert_not_#{suffix}" do |*args, &block|
+            begin
+              expect(&block).to_not send(matcher, *args)
+            rescue Expectations::ExpectationNotMetError => e
+              raise e, e.message, adjust_for_better_failure_message(e.backtrace), cause: nil
+            end
+          end
         end
       end
 
-      assertion_match :be_truthy
-      assertion_match :be_falsy
-      assertion_match :be_nil
-      assertion_match :be
-      assertion_match :be_a
+      # Useful aliaises.
+      assertion_match :be_truthy, :truthy
+      assertion_match :be_falsy, :falsy
+      assertion_match :be_nil, :nil
       assertion_match :be_a, :is_a
-      assertion_match :be_kind_of
-      assertion_match :be_instance_of
-      assertion_match :be_between
-      assertion_match :be_within
-      assertion_match :contain_exactly
-      assertion_match :cover
-      assertion_match :end_with
-      assertion_match :eq
-      assertion_match :equal
-      assertion_match :eql
-      assertion_match :exist
-      assertion_match :have_attributes
-      assertion_match :include
-      assertion_match :all
-      assertion_match :match
-      assertion_match :match_array
-      assertion_match :respond_to
-      assertion_match :satisfy
-      assertion_match :start_with
-      assertion_match :throw_symbol
-      assertion_match :throw_symbol, :throw
-      assertion_match :yield_control
-      assertion_match :yield_with_no_args
-      assertion_match :yield_successive_args
-
-      assertion_match_block :change
-      assertion_match_block :raise_error
+      assertion_match :be_kind_of, :kind_of
+      assertion_match :be_instance_of, :instance_of
+      assertion_match :be_between, :between
+      assertion_match :be_within, :within
+
       assertion_match_block :raise_error, :raise
       assertion_match_block :raise_error, :raises
-      assertion_match_block :output
+
+      # Exceptions to the block matcher rule.
+      assertion_match :satisfy
 
       # Assert is an alias to `expect`. Use it when all else fails or doesn't
       # feel right. The `change` assertion with a block is a good example:
       #
+      # `assert! { block }.to change { value }` or
       # `assert { block }.to change { value }`
-      def assert(value = Expectations::ExpectationTarget::UndefinedValue, &block)
+      def assert!(value = Expectations::ExpectationTarget::UndefinedValue, &block)
+        Expectations::ExpectationTarget.for(value, block)
+      end
+
+      alias assert assert!
+
+      # Mock is an XUnit alternative to the `expect` based mocking syntax.
+      #
+      # `mock(Post).to receive(:comments)`
+      def mock(value = Expectations::ExpectationTarget::UndefinedValue, &block)
         Expectations::ExpectationTarget.for(value, block)
       end
 
+      # Stub is an XUnit alternative to the `allow` based mocking syntax.
+      def stub(target)
+        RSpec::Mocks::AllowanceTarget.new(target)
+      end
+
       private
 
+      ASSERTION_REGEX = /^assert_(.*)$/.freeze
       ASSERTION_PREDICATE_REGEX = /^assert_(.*)\?$/.freeze
 
       def method_missing(method, *args, &block)
-        ASSERTION_PREDICATE_REGEX.match(method.to_s) do |match|
+        return if ASSERTION_PREDICATE_REGEX.match(method.to_s) do |match|
           value = args.shift
           matcher = "be_#{match[1]}"
 
           expect(value).to Matchers::BuiltIn::BePredicate.new(matcher, *args, &block)
-        end || super
+        end
+
+        return if ASSERTION_REGEX.match(method.to_s) do |match|
+          matcher = match[1]
+
+          RSpec::XUnit::Assertions.module_eval do
+            if block.nil?
+              assertion_match matcher
+            else
+              assertion_match_block matcher
+            end
+          end
+
+          send "assert_#{match[1]}", *args, &block
+        end
+
+        super
       end
 
       def respond_to_missing?(method, *)

data/lib/rspec/xunit/version.rb

@@ -2,6 +2,6 @@
 
 module RSpec
   module XUnit
-    VERSION = '0.4.0'
+    VERSION = '0.5.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-xunit
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Genadi Samokovarov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-10 00:00:00.000000000 Z
+date: 2020-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-core