opal-rspec 0.5.0.beta2 → 0.5.0.beta3

data/spec/rspec/expectations/filter/bugs/equal.txt

@@ -0,0 +1,3 @@
+# Long standing issue with doing defined?(@instance_var) - See https://github.com/opal/opal/blob/master/lib/opal/nodes/defined.rb, compile_ivar method
+# RSpec::Matchers::BuiltIn::BaseMatcher#description does one of these and when @expected is nil, it will not appear defined but it should be
+equal when the expected object is falsey in conditinal semantics describes itself with the expected object

data/spec/rspec/expectations/filter/bugs/expectation_target.txt

@@ -0,0 +1,2 @@
+# Arity
+RSpec::Expectations::ExpectationTarget when constructed via #expect raises a wrong number of args ArgumentError when given two args

data/spec/rspec/expectations/filter/bugs/expectations.txt

@@ -0,0 +1,2 @@
+# Probably more related to nesting lambdas in the test than with using raise_error - https://github.com/opal/opal/pull/1117
+RSpec::Expectations does not allow expectation failures to be caught by a bare rescue

data/spec/rspec/expectations/filter/bugs/have_attributes.rb

@@ -0,0 +1,8 @@
+rspec_filter 'have_attributes' do
+  # https://github.com/opal/opal/pull/1136 - operators and method missing issues with a_value > < etc
+  unless at_least_opal_0_9?
+    filter('#have_attributes matcher expect(...).to have_attributes(with_one_attribute) expect(...).to have_attributes(key => matcher) fails with a clear message when the matcher does not match')
+    filter('#have_attributes matcher expect(...).to have_attributes(with_one_attribute) expect(...).to have_attributes(key => matcher) provides a description')
+    filter('#have_attributes matcher expect(...).to have_attributes(with_one_attribute) expect(...).to have_attributes(key => matcher) passes when the matchers match')
+  end
+end

data/spec/rspec/expectations/filter/bugs/include.rb

@@ -0,0 +1,4 @@
+rspec_filter 'include' do
+  # https://github.com/opal/opal/pull/1136 - operators and method missing issues with a_value > < etc
+  filter('#include matcher Composing matchers with `include` expect(array).to include(matcher) works with comparison matchers').unless { at_least_opal_0_9? }
+end

data/spec/rspec/expectations/filter/bugs/operators.txt

@@ -0,0 +1,2 @@
+# https://github.com/opal/opal/pull/1136 - operators and method missing issues with a_value > < etc
+operator matchers.*

data/spec/rspec/expectations/filter/bugs/raise_error.txt

@@ -0,0 +1,2 @@
+# there are 2 examples w/ the same name, 1 fails because it used load (Opal), the other for the same reason as above
+expect { ... }.to raise_error\(NamedError\) fails if another error is raised \(NameError\)

data/spec/rspec/expectations/filter/bugs/respond_to.rb

@@ -0,0 +1,13 @@
+rspec_filter 'respond_to' do
+  # Also arity related, but looks like opal is returning the optional arg splat as arity
+  filter('expect(...).not_to respond_to(:sym).with(1).argument fails if target responds to :sym with one or more args').unless { at_least_opal_0_9? }
+  filter('expect(...).to respond_to(:sym).with(2).arguments passes if target responds to two or more arguments').unless { at_least_opal_0_9? }
+  filter 'expect(...).to respond_to(:sym).with(2).arguments passes if target responds to any number of arguments'
+  filter('expect(...).to respond_to(:sym).with(1).argument passes if target responds to one or more arguments').unless { at_least_opal_0_9? }
+
+  # arity related
+  filter('expect(...).to respond_to(:sym).with(1).argument passes if target responds to any number of arguments').if { at_least_opal_0_9? }
+  filter('expect(...).to respond_to(:sym).with(2).arguments passes if target responds to one or more arguments').if { at_least_opal_0_9? }
+  filter('expect(...).not_to respond_to(:sym).with(1).argument fails if target responds to :sym with any number of args').if { at_least_opal_0_9? }
+  filter('expect(...).not_to respond_to(:sym).with(2).arguments fails if target responds to :sym with one or more args').if { at_least_opal_0_9? }
+end

data/spec/rspec/expectations/filter/bugs/sandbox/undef.rb

@@ -0,0 +1,20 @@
+module Foo
+  def howdy
+    puts 'howdy'
+  end
+end
+
+class Stuff
+  include Foo
+end
+
+# This approach fails on opal-master
+# module Foo
+#   undef howdy
+# end
+#
+# Stuff.new.howdy
+
+# This approach also fails on opal-master
+Foo.send(:remove_method, :howdy)
+Stuff.new.howdy

data/spec/rspec/expectations/filter/unsupported/aliases.txt

@@ -0,0 +1,5 @@
+# opal symbols are strings
+RSpec::Matchers should have an alias for "have attributes \{\\"age\\" => 32\}" with description: "an object having attributes \{:age => 32\}"
+RSpec::Matchers should have an alias for "include \{\\"a\\" => 5\}" with description: "a hash including \{:a => 5\}"
+RSpec::Matchers should have an alias for "throw foo" with description: "a block throwing :foo"
+RSpec::Matchers should have an alias for "throw foo" with description: "throwing :foo"

data/spec/rspec/expectations/filter/unsupported/be.txt

@@ -0,0 +1,2 @@
+# no private methods in opal
+expect\(...\).to be_predicate fails when :predicate\? is private

data/spec/rspec/expectations/filter/unsupported/be_instance_of.txt

@@ -0,0 +1,3 @@
+# Fixnum/Numeric
+expect\(actual\).to be_an_instance_of\(expected\) provides a description
+expect\(actual\).to be_instance_of\(expected\) provides a description

data/spec/rspec/expectations/filter/unsupported/change.txt

@@ -0,0 +1,2 @@
+# strings are immutable
+expect { ... }.to change\(actual, message\) with a string passes when actual is modified by the block

data/spec/rspec/expectations/filter/unsupported/configuration.txt

@@ -0,0 +1,2 @@
+# backtrace/line #
+RSpec::Expectations::Configuration#backtrace_formatter defaults to rspec-core's backtrace formatter when rspec-core is loaded

data/spec/rspec/expectations/filter/unsupported/contain_exactly.txt

@@ -0,0 +1,2 @@
+# no timeout in opal
+expect\(array\).to contain_exactly\(\*other_array\) fails a match of 11 items with duplicates in a reasonable amount of time

data/spec/rspec/expectations/filter/unsupported/description_generation.txt

@@ -0,0 +1,6 @@
+# Symbols are strings
+Matchers should be able to generate their own descriptions expect\(...\).to have_key
+Matchers should be able to generate their own descriptions expect\(...\).not_to eql
+
+# throw not in Opal
+Matchers should be able to generate their own descriptions expect\(...\).to throw symbol.*

data/spec/rspec/expectations/filter/unsupported/dsl.txt

@@ -0,0 +1,8 @@
+# mutable strings, see opal alternates
+RSpec::Matchers::DSL::Matcher defined using the dsl raises NoMethodError for methods not in the running_example
+
+# Fixnum = Numeric on Opal, see opal alternates
+Spec::Matchers::DSL::Matcher wrapping another expectation \(expect\(...\).to eq ...\) can use the `include` matcher from a `match` block
+
+# regex compatibility, see opal alternates
+RSpec::Matchers::DSL::Matcher wrapping another expectation \(expect\(...\).to eq ...\) can use the `match` matcher from a `match` block

data/spec/rspec/expectations/filter/unsupported/eq.txt

@@ -0,0 +1,10 @@
+# no bigdecimal on opal
+eq with BigDecimal objects fails with a conventional representation of the decimal
+
+# no activesupport on opal
+eq Time Equality with DateTime objects.*
+eq Time Equality with Time objects produces different output for Times differing by milliseconds
+
+# symbols
+eq #description with "symbol" is "eq :symbol"
+eq #description with {"foo"=>"bar"} is "eq {:foo=>:bar}"

data/spec/rspec/expectations/filter/unsupported/equal.txt

@@ -0,0 +1,3 @@
+# == and .equal? on Opal are still largely the same
+equal suggests the `eq` matcher on failure
+equal does not match when \!actual.equal\?\(expected\)

data/spec/rspec/expectations/filter/unsupported/expectation_target.txt

@@ -0,0 +1,2 @@
+# Fixnum = Numeric on Opal, see opal alternates
+RSpec::Expectations::ExpectationTarget when constructed via #expect fails an invalid negative expectation

data/spec/rspec/expectations/filter/unsupported/expectations.txt

@@ -0,0 +1,8 @@
+# diff on Opal
+RSpec::Expectations includes a diff if expected and actual are diffable
+RSpec::Expectations does not include the diff if expected and actual are not diffable
+RSpec::Expectations uses matcher descriptions in place of matchers in diffs
+RSpec::Expectations tells the differ to use color
+
+# Dir
+RSpec::Expectations behaves like a library that issues no warnings when loaded issues no warnings when loaded

data/spec/rspec/expectations/filter/unsupported/has.txt

@@ -0,0 +1,2 @@
+# private method
+expect\(...\).to have_sym\(\*args\) fails if #has_sym\?\(\*args\) is private

data/spec/rspec/expectations/filter/unsupported/include.txt

@@ -0,0 +1,3 @@
+# Diff
+.include matcher expect\(...\).to include\(with_one_arg\) for a string target includes a diff when actual is multiline and there are multiple expecteds
+.include matcher expect\(...\).to include\(with_one_arg\) for a string target includes a diff when actual is multiline

data/spec/rspec/expectations/filter/unsupported/match.txt

@@ -0,0 +1,2 @@
+# diffing on Opal
+expect\(...\).to match\(expected\) provides a diff on failure

data/spec/rspec/expectations/filter/unsupported/matchers.txt

@@ -0,0 +1,11 @@
+# diffs not yet supported on Opal
+RSpec::Matchers::DSL::Matcher handles multiline string diffs
+
+# throw not in Opal
+RSpec::Matchers::BuiltIn::ThrowSymbol.*
+
+# subprocess/threading
+RSpec::Matchers can be mixed into `main`
+
+# minitest/opal compatibility
+built in matchers RSpec::Matchers method_missing hook when invoked in a Minitest::Test behaves like a well-behaved method_missing hook raises a NoMethodError \(and not SystemStackError\) for an undefined method

data/spec/rspec/expectations/filter/unsupported/output.txt

@@ -0,0 +1,14 @@
+# diff
+output.to_stdout matcher expect { ... }.to_not output\(matcher\).to_stdout fails if the block outputs a string to stdout that passes the given matcher
+output.to_stdout matcher expect { ... }.to output\(matcher\).to_stdout fails if the block outputs a string to stdout that does not pass the given matcher
+output.to_stdout matcher expect { ... }.to_not output\(/regex/\).to_stdout fails if the block outputs a string to stdout that matches the regex
+output.to_stdout matcher expect { ... }.to output\(/regex/\).to_stdout fails if the block outputs a string to stdout that does not match
+output.to_stdout matcher expect { ... }.to output\(/regex/\).to_stdout fails if the block does not output to stdout
+output.to_stderr matcher expect { ... }.to_not output\(matcher\).to_stderr fails if the block outputs a string to stderr that passes the given matcher
+output.to_stderr matcher expect { ... }.to output\(matcher\).to_stderr fails if the block outputs a string to stderr that does not pass the given matcher
+output.to_stderr matcher expect { ... }.to_not output\(/regex/\).to_stderr fails if the block outputs a string to stderr that matches the regex
+output.to_stderr matcher expect { ... }.to output\(/regex/\).to_stderr fails if the block outputs a string to stderr that does not match
+output.to_stderr matcher expect { ... }.to output\(/regex/\).to_stderr fails if the block does not output to stderr
+
+# $VERBOSE global variable
+output..* matcher does not produce warnings when the failure message is accessed first

data/spec/rspec/expectations/filter/unsupported/raise_error.txt

@@ -0,0 +1,3 @@
+# backtrace / line numbers
+expect { ... }.to raise_error\(message\) includes the backtrace of any other error in the failure message
+expect { ... }.not_to raise_error with no specific error class includes the backtrace of the error that was raised in the error message

data/spec/rspec/expectations/filter/unsupported/respond_to.rb

@@ -0,0 +1,5 @@
+rspec_filter 'respond_to' do
+  # arity
+  filter('expect(...).not_to respond_to(:sym).with(2).arguments fails if target responds to :sym with two or more args').unless { at_least_opal_0_9? }
+  filter('expect(...).not_to respond_to(:sym).with(2).arguments fails if target responds to :sym with any number args')
+end

data/spec/rspec/expectations/filter/unsupported/syntax.txt

@@ -0,0 +1,3 @@
+# these tests are using symbols but in Opal symbols are strings
+RSpec::Expectations::Syntax when passing a message to an expectation expect\(...\).to prints a warning when the message object isn't a String
+RSpec::Expectations::Syntax when passing a message to an expectation expect\(...\).not_to prints a warning when the message object isn't a String

data/spec/rspec/expectations/filter/unsupported/yield.txt

@@ -0,0 +1,2 @@
+# symbols == strings, see opal alternates
+yield_successive_args matcher has a description

data/spec/rspec/expectations/fixes/example_patches.rb

@@ -0,0 +1,32 @@
+module Opal
+  module RSpec
+    def self.get_constants_for(object)
+      result = []
+      %x{
+        for (var prop in #{object}) {
+          if (#{object}.hasOwnProperty(prop) && #{!`prop`.start_with?('$')}) {
+            #{result << `prop`}
+          }
+        }
+      }
+      result.reject { |c| c == 'constructor' }
+    end
+  end
+end
+
+unless Opal::RSpec::Compatibility.constant_resolution_works_right?
+  groups_are_in = RSpec::ExampleGroups
+  built_in_spec = :BuiltInMatchers
+  # in case we aren't running all of the examples
+  if groups_are_in.const_defined? built_in_spec
+    example_group = groups_are_in.const_get built_in_spec
+    example_group.let(:matchers) do
+      # .constants is broken in Opal, this is a hack
+      constants = Opal::RSpec.get_constants_for(RSpec::Matchers::BuiltIn) - [:NullCapture, :CaptureStdOut, :CaptureStdErr]
+      constants.map { |n| RSpec::Matchers::BuiltIn.const_get(n) }.select do |m|
+        #BuiltIn.constants.map { |n| BuiltIn.const_get(n) }.select do |m|
+        m.method_defined?(:matches?) && m.method_defined?(:failure_message)
+      end
+    end
+  end
+end

data/spec/rspec/expectations/fixes/missing_constants.rb

@@ -0,0 +1,12 @@
+ComplexStruct = Struct.new(:args)
+
+def Complex(*args)
+  ComplexStruct.new(args)
+end
+
+# In Opal 0.9
+unless Object.const_defined?(:Math) && Object.const_defined?(:PI)
+  module Math
+    PI = `Math.PI`
+  end
+end

data/spec/rspec/expectations/fixes/not_compatible.rb

@@ -0,0 +1,6 @@
+module RSpec::Support::ShellOut
+end
+
+# Uses forking/threads
+module ::RSpec::Support::InSubProcess
+end

data/spec/rspec/expectations/fixes/opal_itself.rb

@@ -0,0 +1,140 @@
+# https://github.com/opal/opal/issues/1110, fixed in Opal 0.9
+unless Opal::RSpec::Compatibility.class_within_class_new_works?
+  require 'delegate'
+
+  class ArrayDelegate < DelegateClass(Array)
+    def initialize(array)
+      @internal_array = array
+      super(@internal_array)
+    end
+
+    def large?
+      @internal_array.size >= 5
+    end
+  end
+
+  class FooError < StandardError
+    def foo;
+      :bar;
+    end
+  end
+
+  # description_generaiton_spec
+  class Parent;
+  end
+  class Child < Parent
+    def child_of?(*parents)
+      parents.all? { |parent| self.is_a?(parent) }
+    end
+  end
+
+  # be_between spec
+  class SizeMatters
+    include Comparable
+    attr :str
+
+    def <=>(other)
+      str.size <=> other.str.size
+    end
+
+    def initialize(str)
+      @str = str
+    end
+
+    def inspect
+      @str
+    end
+  end
+end
+
+# https://github.com/opal/opal/pull/1135
+unless Opal::RSpec::Compatibility.ostruct_works_right?
+  class OpenStruct
+    def initialize(hash = nil)
+      @table = {}
+
+      hash.each_pair { |key, value|
+        @table[new_ostruct_member(key)] = value
+      } if hash
+    end
+
+    def []=(name, value)
+      @table[new_ostruct_member(name)] = value
+    end
+
+    def method_missing(name, *args)
+      if args.length > 2
+        raise NoMethodError.new "undefined method `#{name}' for #<OpenStruct>"
+      end
+      if name.end_with? '='
+        if args.length != 1
+          raise ArgumentError.new "wrong number of arguments (0 for 1)"
+        end
+        @table[new_ostruct_member(name[0 .. -2])] = args[0]
+      else
+        @table[name.to_sym]
+      end
+    end
+
+    attr_reader :table
+
+    def delete_field(name)
+      sym = name.to_sym
+      begin
+        singleton_class.__send__(:remove_method, sym, "#{sym}=")
+      rescue NameError
+      end
+      @table.delete sym
+    end
+
+    def new_ostruct_member(name)
+      name = name.to_sym
+      unless respond_to?(name)
+        define_singleton_method(name) { @table[name] }
+        define_singleton_method("#{name}=") { |x| @table[name] = x }
+      end
+      name
+    end
+
+    `var ostruct_ids;`
+
+    def inspect
+      %x{
+          var top = (ostruct_ids === undefined),
+              ostruct_id = self.$object_id();
+        }
+      begin
+        result = "#<#{self.class}"
+        %x{
+            if (top) {
+              ostruct_ids = {};
+            }
+
+            if (ostruct_ids.hasOwnProperty(ostruct_id)) {
+              return #{result + ' ...>'};
+            }
+
+            ostruct_ids[ostruct_id] = true;
+          }
+
+        result += ' ' if @table.any?
+
+        result += each_pair.map { |name, value|
+          "#{name}=#{value.inspect}"
+        }.join ", "
+
+        result += ">"
+
+        result
+      ensure
+        %x{
+            if (top) {
+              ostruct_ids = undefined;
+            }
+          }
+      end
+    end
+
+    alias to_s inspect
+  end
+end

data/spec/rspec/expectations/opal_alternates/be_instance_of_spec.rb

@@ -0,0 +1,11 @@
+[:be_an_instance_of, :be_instance_of].each do |method|
+  describe "Opal expect(actual).to #{method}(expected)" do
+    it "provides a description" do
+      matcher = be_an_instance_of(Fixnum)
+      matcher.matches?(Numeric)
+      # opal fixnum == numeric
+      # expect(matcher.description).to eq "be an instance of Fixnum"
+      expect(matcher.description).to eq "be an instance of Numeric"
+    end
+  end
+end

data/spec/rspec/expectations/opal_alternates/dsl_spec.rb

@@ -0,0 +1,66 @@
+describe 'Opal RSpec::Matchers::DSL::Matcher' do
+  context "defined using the dsl" do
+    it "raises NoMethodError for methods not in the running_example" do |example|
+      RSpec::Matchers.define(:__raise_no_method_error) do
+        match do |actual|
+          self.a_method_not_in_the_example == "method defined in the example"
+        end
+      end
+
+      # mutable strings
+      #expected_msg = "RSpec::Matchers::DSL::Matcher"
+      #expected_msg << " __raise_no_method_error" unless rbx?
+      expected_msg = "RSpec::Matchers::DSL::Matcher" + " __raise_no_method_error"
+
+      expect {
+        expect(example).to __raise_no_method_error
+      }.to raise_error(NoMethodError, /#{expected_msg}/)
+    end
+  end
+
+  context "wrapping another expectation (expect(...).to eq ...)" do
+    it "can use the `include` matcher from a `match` block" do
+      RSpec::Matchers.define(:descend_from) do |mod|
+        match do |klass|
+          expect(klass.ancestors).to include(mod)
+        end
+      end
+
+      expect(Fixnum).to descend_from(Object)
+      expect(Fixnum).not_to descend_from(Array)
+
+      expect {
+        expect(Fixnum).to descend_from(Array)
+      }.to fail_with(/expected Numeric to descend from Array/)
+      # Fixnum = Numeric on Opal
+      #}.to fail_with(/expected Fixnum to descend from Array/)
+
+      expect {
+        expect(Fixnum).not_to descend_from(Object)
+        # Fixnum = Numeric on Opal
+      }.to fail_with(/expected Numeric not to descend from Object/)
+      #}.to fail_with(/expected Fixnum not to descend from Object/)
+    end
+
+    it "can use the `match` matcher from a `match` block" do
+      RSpec::Matchers.define(:be_a_phone_number_string) do
+        match do |string|
+          # \A and \Z in JS regex
+          # expect(string).to match(/\A\d{3}\-\d{3}\-\d{4}\z/)
+          expect(string).to match(/^\d{3}\-\d{3}\-\d{4}$/)
+        end
+      end
+
+      expect("206-123-1234").to be_a_phone_number_string
+      expect("foo").not_to be_a_phone_number_string
+
+      expect {
+        expect("foo").to be_a_phone_number_string
+      }.to fail_with(/expected "foo" to be a phone number string/)
+
+      expect {
+        expect("206-123-1234").not_to be_a_phone_number_string
+      }.to fail_with(/expected "206-123-1234" not to be a phone number string/)
+    end
+  end
+end