opal-connect-rspec 0.5.0

data/spec/opal/mock_spec.rb

@@ -0,0 +1,63 @@
+describe "RSpec mocks" do
+  describe "stubs" do
+    it "can stub basic methods" do
+      obj = Object.new
+      expect(obj).to receive(:foo) { 100 }
+      obj.foo.should == 100
+    end
+
+    it "raises an exception when stub returns wrong value" do
+      expect {
+        obj = Object.new
+        expect(obj).to receive(:bar) { 400 }
+        obj.bar.should == 42
+      }.to raise_error(Exception)
+    end
+
+    it "allow" do
+      obj = Object.new
+      allow(obj).to receive(:name) { "Adam B" }
+      allow(obj).to receive(:job).and_return("Eating Fruit Gums")
+
+      expect(obj.name).to eq("Adam B")
+      expect(obj.job).to eq("Eating Fruit Gums")
+    end
+
+    it "expecting arguments" do
+      person = double("person")
+      expect(person).to receive(:foo).with(4, 5, 6)
+      person.foo(4, 5, 6)
+    end
+  end
+
+  describe "doubles" do
+    it "define methods on double" do
+      person = double("person", :name => "Adam")
+      expect(person.name).to eq("Adam")
+    end
+
+    it "once" do
+      person = double("person")
+      expect(person).to receive(:name).once
+      person.name.should eq(nil)
+    end
+
+    it "twice" do
+      person = double("person")
+      expect(person).to receive(:name).twice
+      person.name
+      person.name.should
+    end
+  end
+
+  it "can mock existing methods on objects" do
+    expect(Time).to receive(:now).once.and_call_original
+    Time.now.should be_kind_of(Time)
+  end
+
+  describe 'stubs' do
+    it 'works and displays deprecation' do
+      Object.new.stub :foo
+    end
+  end
+end

data/spec/opal/should_syntax_spec.rb

@@ -0,0 +1,17 @@
+describe "One-liner should syntax" do
+  subject { 42 }
+
+  describe "should" do
+    it { should == 42 }
+    it { should_not == 43 }
+  end
+
+  describe "is_expected" do
+    it { is_expected.to eq(42) }
+    it { is_expected.to_not eq(43) }
+  end
+
+  describe "expect" do
+    it { expect(42).to eq(42) }
+  end
+end

data/spec/opal/skip_pending_spec.rb

@@ -0,0 +1,43 @@
+describe 'skip' do
+  it 'in example, no promise' do
+    skip 'want to skip within'
+  end
+  
+  it 'no implementation provided'
+
+  skip 'entire group' do
+    it 'example 1' do
+      1.should == 2
+    end
+
+    it 'example 2' do
+      1.should == 3
+    end
+  end
+
+  xit 'via xit' do
+    1.should == 3
+  end
+
+  it 'via variable', skip: true do
+    1.should == 3
+  end
+end
+
+describe 'pending' do
+  context 'in example' do
+    context 'no promise' do
+      it 'would fail otherwise' do
+        pending 'want to pend within example'
+        obj = [1, 2, 3, 4]
+        obj.should == [2, 2, 3, 4]    
+      end
+  
+      it 'would not fail otherwise, thus fails properly' do
+        pending 'want to pend within example'
+        obj = [1, 2, 3, 4]
+        obj.should == [1, 2, 3, 4]    
+      end
+    end
+  end  
+end

data/spec/opal/subject_spec.rb

@@ -0,0 +1,87 @@
+describe 'subject' do
+  context 'sync' do
+    context 'named' do
+      subject(:named_subject) { [1, 2, 3] }
+
+      it "should be the subject" do
+        subject.should be_kind_of(Array)
+      end
+
+      it "should be the named subject" do
+        subject.should eql(named_subject)
+      end
+    end
+
+    context 'unnamed' do
+      subject { 42 }
+
+      context 'passes' do
+        it { is_expected.to eq 42 }
+      end
+
+      context 'assertion fails properly' do
+        it { is_expected.to eq 43 }
+      end
+
+      context 'fails properly during subject create' do
+        subject do
+          raise 'did not work'
+        end
+
+        it { is_expected.to eq 42 }
+      end
+    end
+  end
+
+  context 'async' do
+    describe 'assertion' do
+      subject do
+        delay_with_promise 0 do
+          42
+        end
+      end
+
+      context 'explicit async' do
+        it 'passes' do
+          delay_with_promise 0 do
+            expect(subject).to eq 42
+          end
+        end
+
+        it 'fails properly' do
+          delay_with_promise 0 do
+            expect(subject).to eq 43
+          end
+        end
+      end
+
+      context 'implicit' do
+        context 'passes' do
+          it { is_expected.to eq 42 }
+        end
+
+        context 'fails properly' do
+          it { is_expected.to eq 43 }
+        end
+      end
+    end
+
+    context 'fails properly during creation' do
+      subject do
+        delay_with_promise 0 do
+          raise 'did not work'
+        end
+      end
+
+      context 'implicit usage' do
+        it { is_expected.to eq 42 }
+      end
+
+      it 'explicit async' do
+        delay_with_promise 0 do
+          expect(subject).to eq 42
+        end
+      end
+    end
+  end
+end

data/spec/other/color_on_by_default_spec.rb

@@ -0,0 +1,9 @@
+RSpec::configure do |c|
+  c.color = true
+end
+
+describe 'colors' do
+  subject { 42 }
+
+  it { is_expected.to eq 42 }
+end

data/spec/other/dummy_spec.rb

@@ -0,0 +1,5 @@
+describe 'foobar' do
+  subject { 42 }
+  
+  it { is_expected.to eq 42 }
+end

data/spec/other/formatter_dependency.rb

@@ -0,0 +1,3 @@
+module FormatterDependency
+
+end

data/spec/other/ignored_spec.opal

@@ -0,0 +1,5 @@
+describe 'nope' do
+  subject { 42 }
+  
+  it { is_expected.to eq 42 }
+end

data/spec/other/test_formatter.rb

@@ -0,0 +1,9 @@
+class TestFormatter < ::RSpec::Core::Formatters::JsonFormatter
+  include FormatterDependency
+  ::RSpec::Core::Formatters.register self, :message, :dump_summary, :dump_profile, :stop, :close
+
+  def close(_notification)
+    super
+    output.write 'test formatter ran!'
+  end
+end

data/spec/rspec/core/config.rb

@@ -0,0 +1,5 @@
+require 'opal/progress_json_formatter' # verify case uses this
+
+RSpec.configure do |c|
+  #c.full_description = 'uses the default color for the shared example backtrace line'
+end

data/spec/rspec/core/config.ru

@@ -0,0 +1,4 @@
+require 'opal/rspec'
+require_relative 'core_spec_loader'
+
+Opal::RSpec::CoreSpecLoader.run_rack_server self

data/spec/rspec/core/core_spec_loader.rb

@@ -0,0 +1,46 @@
+require_relative '../opal_rspec_spec_loader'
+
+module Opal
+  module RSpec
+    module CoreSpecLoader
+      extend Opal::RSpec::OpalRSpecSpecLoader
+
+      def self.expected_pending_count
+        1
+      end
+
+      def self.base_dir
+        'spec/rspec/core'
+      end
+
+      def self.files_with_line_continue
+        [/core\/example_spec.rb/, /pending_spec.rb/]
+      end
+
+      def self.default_path
+        'rspec-core/spec'
+      end
+
+      def self.spec_glob
+        %w{rspec-core/spec/**/*_spec.rb spec/rspec/core/opal_alternates/**/*_spec.rb}
+      end
+
+      def self.stubbed_requires
+        [
+            'rubygems',
+            'aruba/api', # Cucumber lib that supports file creation during testing, N/A for us
+            'simplecov', # hooks aren't available on Opal
+            'tmpdir',
+            'rspec/support/spec/shell_out', # only does stuff Opal can't support anyways
+            'rspec/support/spec/prevent_load_time_warnings'
+        ]
+      end
+
+      def self.additional_load_paths
+        [
+            'rspec-core/spec' # a few spec support files live outside of rspec-core/spec/rspec and live in support
+        ]
+      end
+    end
+  end
+end

data/spec/rspec/core/filter/core/async/example_group.txt

@@ -0,0 +1,13 @@
+# delay methods defined for async testing cause this to fail
+RSpec::Core::ExampleGroup minimizes the number of methods that users could inadvertantly overwrite
+
+# Invokes RSpec::Core::ExampleGroup#run directly, so of course it gets a promise back rather than false
+# see opal alternates
+RSpec::Core::ExampleGroup#before, after, and around hooks treats an error in before.* as a failure
+RSpec::Core::ExampleGroup#run_examples returns false if any of the examples fail
+RSpec::Core::ExampleGroup#run_examples runs all examples, regardless of any of them failing
+
+# Run return value is a promise, so we put our own spec in alternates
+RSpec::Core::ExampleGroup#run with fail_fast\? => true sets RSpec.world.wants_to_quit flag if encountering an exception in before\(:all\)
+RSpec::Core::ExampleGroup#run with nested example failing returns true
+RSpec::Core::ExampleGroup#run with top level example failing returns false

data/spec/rspec/core/filter/core/async/hooks.rb

@@ -0,0 +1,12 @@
+rspec_filter 'hooks' do
+  # promise, see opal alternates
+  filter /RSpec::Core::Hooks when an error happens in.* allows the error to propagate to the user/
+  filter('RSpec::Core::Hooks#around considers the hook to have run when passed as a block to a method that yields').unless { at_least_opal_0_9? }
+
+  # promise, for some reason succeeds on Opal 0.8, see opal alternates
+  filter('RSpec::Core::Hooks#around does not consider the hook to have run when passed as a block to a method that does not yield').if { at_least_opal_0_9? }
+  filter('RSpec::Core::Hooks#around when it does not run the example for a hook declared in the group converts the example to a skipped example so the user is made aware of it')
+      .if { at_least_opal_0_9? }
+  filter('RSpec::Core::Hooks#around when it does not run the example for a hook declared in config converts the example to a skipped example so the user is made aware of it')
+      .if { at_least_opal_0_9? }
+end

data/spec/rspec/core/filter/core/async/memoized_helpers.txt

@@ -0,0 +1,3 @@
+# promise, see opal alternates
+RSpec::Core::MemoizedHelpers using 'self' as an explicit subject delegates matcher to the ExampleGroup
+RSpec::Core::MemoizedHelpers using 'self' as an explicit subject supports a new expect-based syntax

data/spec/rspec/core/filter/core/async/metadata.txt

@@ -0,0 +1,2 @@
+# Promise on the run, see opal alternates
+RSpec::Core::Metadata backwards compatibility :example_group allows integration libraries like VCR to infer a fixture name from the example description by walking up nesting structure

data/spec/rspec/core/filter/core/bugs/filter_manager.txt

@@ -0,0 +1,4 @@
+# similar splat issue as the one noted in metadata bugs for these 3 (splat/description)
+RSpec::Core::FilterManager#exclusions#description includes an overriden :if filter
+RSpec::Core::FilterManager#exclusions#description includes an overriden :unless filter
+RSpec::Core::FilterManager#exclusions#description includes other filters

data/spec/rspec/core/filter/core/bugs/formatters.txt

@@ -0,0 +1,4 @@
+# These use mocking (as_stubbed_const), which isn't working, might be easier to figure out in the mocks specs:
+
+RSpec::Core::Formatters::Loader#add\(formatter\) when a legacy formatter is added with RSpec::LegacyFormatters loads formatters from the external gem
+RSpec::Core::Formatters::Loader#add\(formatter\) when a legacy formatter is added with RSpec::LegacyFormatters subscribes the formatter to the notifications the adaptor implements

data/spec/rspec/core/filter/core/bugs/memoized_helpers.rb

@@ -0,0 +1,11 @@
+rspec_filter 'memoized_helpers' do
+  # These depend on https://github.com/opal/opal/issues/1124, but you can only reproduce that with Opal 0.9
+  filter 'RSpec::Core::MemoizedHelpers explicit subject with a name when `super` is used raises a "not supported" error'
+  filter 'RSpec::Core::MemoizedHelpers explicit subject with a name when `super` is used with a `let` definition before the named subject raises a "not supported" error'
+
+  # This works right in Opal 0.9 (see sandbox/subject_issue_test), might be something with the class scoping PR (https://github.com/opal/opal/pull/1114) that requires compiler changes to fix
+  filter("RSpec::Core::MemoizedHelpers explicit subject with a name yields the example in which it is eval'd").unless { at_least_opal_0_9? }
+
+  # This works right in Opal 0.9 (Class === Enumerable), might be https://github.com/opal/opal/commit/304ab9c464754ca54ab03f1f31d5c137ae8e995d but not sure
+  filter('RSpec::Core::MemoizedHelpers implicit subject with a Module returns the Module').unless { at_least_opal_0_9? }
+end

data/spec/rspec/core/filter/core/bugs/metadata.txt

@@ -0,0 +1,5 @@
+# splat problem? something isn't right here, same issue for the following 3
+RSpec::Core::Metadata :description on a group with a non-string and a string concats the args
+RSpec::Core::Metadata :full_description with a 2nd arg starting with # removes the space
+RSpec::Core::Metadata :full_description with a 2nd arg starting with . removes the space
+RSpec::Core::Metadata :full_description with a 2nd arg starting with :: removes the space

data/spec/rspec/core/filter/core/bugs/sandbox/subject_issue_test.rb

@@ -0,0 +1,328 @@
+module RSpec
+  def self.current_example=(ex)
+    @ex = ex
+  end
+
+  def self.current_example
+    @ex
+  end
+end
+
+module MemoizedHelpers
+  module ClassMethods
+    def let(name, &block)
+      MemoizedHelpers.module_for(self).__send__(:define_method, name, &block)
+
+      define_method(name) {
+        super(RSpec.current_example, &nil)
+      }
+    end
+
+    def subject(name=nil, &block)
+      if name
+        let(name, &block)
+        alias_method :subject, name
+
+        self::NamedSubjectPreventSuper.__send__(:define_method, name) do
+          raise NotImplementedError, "`super` in named subjects is not supported"
+        end
+      else
+        let(:subject, &block)
+      end
+    end
+  end
+
+  def self.module_for(example_group)
+    get_constant_or_yield(example_group, :LetDefinitions) do
+      mod = Module.new do
+        # Maybe same problem w/ scoping as class.new anon?
+        include Module.new {
+                  example_group.const_set(:NamedSubjectPreventSuper, self)
+                }
+      end
+
+      example_group.const_set(:LetDefinitions, mod)
+      mod
+    end
+  end
+
+  def self.define_helpers_on(example_group)
+    example_group.__send__(:include, module_for(example_group))
+  end
+
+  if Module.method(:const_defined?).arity == 1 # for 1.8
+    # @private
+    #
+    # Gets the named constant or yields.
+    # On 1.8, const_defined? / const_get do not take into
+    # account the inheritance hierarchy.
+    def self.get_constant_or_yield(example_group, name)
+      if example_group.const_defined?(name)
+        example_group.const_get(name)
+      else
+        yield
+      end
+    end
+  else
+    # @private
+    #
+    # Gets the named constant or yields.
+    # On 1.9, const_defined? / const_get take into account the
+    # the inheritance by default, and accept an argument to
+    # disable this behavior. It's important that we don't
+    # consider inheritance here; each example group level that
+    # uses a `let` should get its own `LetDefinitions` module.
+    def self.get_constant_or_yield(example_group, name)
+      if example_group.const_defined?(name, (check_ancestors = false))
+        example_group.const_get(name, check_ancestors)
+      else
+        yield
+      end
+    end
+  end
+end
+
+module Support
+  # Provides recursive constant lookup methods useful for
+  # constant stubbing.
+  module RecursiveConstMethods
+    # We only want to consider constants that are defined directly on a
+    # particular module, and not include top-level/inherited constants.
+    # Unfortunately, the constant API changed between 1.8 and 1.9, so
+    # we need to conditionally define methods to ignore the top-level/inherited
+    # constants.
+    #
+    # Given:
+    #   class A; B = 1; end
+    #   class C < A; end
+    #
+    # On 1.8:
+    #   - C.const_get("Hash") # => ::Hash
+    #   - C.const_defined?("Hash") # => false
+    #   - C.constants # => ["B"]
+    #   - None of these methods accept the extra `inherit` argument
+    # On 1.9:
+    #   - C.const_get("Hash") # => ::Hash
+    #   - C.const_defined?("Hash") # => true
+    #   - C.const_get("Hash", false) # => raises NameError
+    #   - C.const_defined?("Hash", false) # => false
+    #   - C.constants # => [:B]
+    #   - C.constants(false) #=> []
+    if Module.method(:const_defined?).arity == 1
+      def const_defined_on?(mod, const_name)
+        mod.const_defined?(const_name)
+      end
+
+      def get_const_defined_on(mod, const_name)
+        return mod.const_get(const_name) if const_defined_on?(mod, const_name)
+
+        raise NameError, "uninitialized constant #{mod.name}::#{const_name}"
+      end
+
+      def constants_defined_on(mod)
+        mod.constants.select { |c| const_defined_on?(mod, c) }
+      end
+    else
+      def const_defined_on?(mod, const_name)
+        mod.const_defined?(const_name, false)
+      end
+
+      def get_const_defined_on(mod, const_name)
+        mod.const_get(const_name, false)
+      end
+
+      def constants_defined_on(mod)
+        mod.constants(false)
+      end
+    end
+
+    def recursive_const_get(const_name)
+      normalize_const_name(const_name).split('::').inject(Object) do |mod, name|
+        get_const_defined_on(mod, name)
+      end
+    end
+
+    def recursive_const_defined?(const_name)
+      parts = normalize_const_name(const_name).split('::')
+      parts.inject([Object, '']) do |(mod, full_name), name|
+        yield(full_name, name) if block_given? && !(Module === mod)
+        return false unless const_defined_on?(mod, name)
+        [get_const_defined_on(mod, name), [mod, name].join('::')]
+      end
+    end
+
+    def normalize_const_name(const_name)
+      #const_name.sub(/\A::/, '')
+      # the \A, which means 'beginning of string' does not work in Opal/JS regex, ^ is beginning of line, which for constant names, should work OK
+      const_name.sub(/^::/, '')
+    end
+  end
+end
+
+module ExampleGroups
+  extend Support::RecursiveConstMethods
+
+  original_constants = method(:constants)
+
+  self.class.send(:define_method, :constants) do
+    original_constants.call().dup
+  end
+
+  def self.assign_const(group)
+    base_name = base_name_for(group)
+    const_scope = constant_scope_for(group)
+    name = disambiguate(base_name, const_scope)
+
+    const_scope.const_set(name, group)
+  end
+
+  def self.constant_scope_for(group)
+    const_scope = group.superclass
+    const_scope = self if const_scope == BaseExampleGroup
+    const_scope
+  end
+
+  def self.base_name_for(group)
+    return "Anonymous" if group.description.empty?
+
+    # convert to CamelCase
+    name = ' ' + group.description
+
+    # replaced gsub! with name = name.gsub (mutable strings)
+    name = name.gsub(/[^0-9a-zA-Z]+([0-9a-zA-Z])/) { Regexp.last_match[1].upcase }
+
+    # mutable strings on these 2
+    name = name.lstrip # Remove leading whitespace
+    name = name.gsub(/\W/, '') # JRuby, RBX and others don't like non-ascii in const names
+
+    # Ruby requires first const letter to be A-Z. Use `Nested`
+    # as necessary to enforce that.
+    # name.gsub!(/\A([^A-Z]|\z)/, 'Nested\1')
+    # opal-rspec, mutable strings, also substituted in ^ for \A since \A is not supported in JS regex
+    name = name.gsub(/^([^A-Z]|\z)/, 'Nested\1')
+
+    name
+  end
+
+  if RUBY_VERSION == '1.9.2'
+    class << self
+      alias _base_name_for base_name_for
+
+      def base_name_for(group)
+        _base_name_for(group) + '_'
+      end
+    end
+    private_class_method :_base_name_for
+  end
+
+  def self.disambiguate(name, const_scope)
+    return name unless const_defined_on?(const_scope, name)
+
+    # Add a trailing number if needed to disambiguate from an existing constant.
+    name = name + "_2"
+
+    while const_defined_on?(const_scope, name)
+      name = name.next
+    end
+
+    name
+  end
+end
+
+class BaseExampleGroup
+  @description = nil
+  include MemoizedHelpers
+  extend MemoizedHelpers::ClassMethods
+
+  def self.description
+    @description
+  end
+
+  def self.describe(description='default', &example_group_block)
+    children = []
+    subclass(self, description, &example_group_block).tap do |child|
+      children << child
+    end
+  end
+
+  def self.set_it_up(description)
+    @description = description
+  end
+
+  def self.examples
+    @examples ||= []
+  end
+
+  def self.subclass(parent, description, &example_group_block)
+    subclass = Class.new(parent)
+    subclass.set_it_up description
+    ExampleGroups.assign_const(subclass)
+    subclass.module_exec(&example_group_block) if example_group_block
+
+    # The LetDefinitions module must be included _after_ other modules
+    # to ensure that it takes precedence when there are name collisions.
+    # Thus, we delay including it until after the example group block
+    # has been eval'd.
+    MemoizedHelpers.define_helpers_on(subclass)
+
+    subclass
+  end
+
+  def self.example(&block)
+    examples << ExampleClass.new(self, block)
+    examples.last
+  end
+
+  def self.run
+    examples.each do |ex|
+      instance = new
+      ex.run instance
+    end
+  end
+end
+
+class ExampleClass
+  def initialize(example_group_class, example_block=nil)
+    @example_group_class = example_group_class
+    @example_block = example_block
+  end
+
+  def run(example_group_inst)
+    RSpec.current_example = self
+    example_group_inst.instance_exec self, &@example_block
+    RSpec.current_example = nil
+  end
+end
+
+
+eg = BaseExampleGroup.describe
+example_yielded_to_subject = nil
+# this works in both 0.8 and 0.9
+# eg.let(:bah) do |something|
+#   example_yielded_to_subject = something
+# end
+
+# only works on 0.9
+# eg.subject(:bah) do |something|
+#   puts 'subje executed'
+#   # adding super gets expected error on ruby, not on opal (even on 0.9) - https://github.com/opal/opal/issues/1124
+#   #super()
+#   example_yielded_to_subject = something
+# end
+
+# Works on 0.8 and 0.9
+eg.subject() do |something|
+  puts 'subje executed'
+  # adding super gets expected error on ruby, not on opal (even on 0.9) - https://github.com/opal/opal/issues/1124
+  #super()
+  example_yielded_to_subject = something
+end
+
+example_yielded_to_example = nil
+eg.example { |e|
+  subject
+  example_yielded_to_example = e
+}
+eg.run
+
+puts "expected #{example_yielded_to_example}, got #{example_yielded_to_subject}"