opal-rspec-cj 0.4.4

data/spec/matchers_spec.rb

@@ -0,0 +1,201 @@
+describe "be_truthy" do
+  it "passes with truthy values" do
+    expect(true).to be_truthy
+    expect(1.0).to be_truthy
+    expect([]).to be_truthy
+  end
+
+  it "fails with falsey values" do
+    expect {
+      expect(false).to be_truthy
+    }.to raise_error(Exception)
+
+    expect {
+      expect(nil).to be_truthy
+    }.to raise_error(Exception)
+  end
+end
+
+describe "be_falsey" do
+  it "passes with falsey values" do
+    expect(false).to be_falsey
+    expect(nil).to be_falsey
+  end
+
+  it "fails with truthy values" do
+    expect {
+      expect(true).to be_falsey
+    }.to raise_error(Exception)
+
+    expect {
+      expect({}).to be_falsey
+    }.to raise_error(Exception)
+  end
+end
+
+describe "be_nil" do
+  it "passes when object is nil" do
+    expect(nil).to be_nil
+  end
+
+  it "fails with any other object" do
+    expect {
+      expect(false).to be_nil
+    }.to raise_error(Exception)
+
+    expect {
+      expect(:foo).to be_nil
+    }.to raise_error(Exception)
+  end
+end
+
+describe "be_kind_of" do
+  it "passes if actual is kind of expected class" do
+    expect("foo").to be_kind_of(String)
+    expect("foo").to_not be_kind_of(Numeric)
+  end
+
+  it "passes if actual is kind of superclass of expected class" do
+    expect([]).to be_kind_of(Object)
+  end
+
+  it "fails if expected is not a kind of expected" do
+    expect {
+      expect("foo").to be_kind_of(Integer)
+    }.to raise_error(Exception)
+
+    expect {
+      expect("foo").to_not be_kind_of(String)
+    }.to raise_error(Exception)
+  end
+end
+
+describe "eq" do
+  it "matches when actual == expected" do
+    expect(:foo).to eq(:foo)
+  end
+
+  it "does not match when actual != expected" do
+    expect(:foo).not_to eq(42)
+  end
+
+  it "fails if matcher does not match" do
+    expect {
+      expect(:foo).to eq(42)
+    }.to raise_error(Exception)
+
+    expect {
+      expect(:foo).not_to eq(:foo)
+    }.to raise_error(Exception)
+  end
+end
+
+describe "eql" do
+  it "matches when expected.eql?(actual)" do
+    expect(1).to eql(1)
+  end
+
+  it "does not match when !expected.eql?(actual)" do
+    expect(1).to_not eql(:foo)
+  end
+
+  it "fails if matcher does not match" do
+    expect {
+      expect(1).to eql(:bar)
+    }.to raise_error(Exception)
+
+    expect {
+      expect(2).to_not eql(2)
+    }.to raise_error(Exception)
+  end
+end
+
+describe "include" do
+  it "matches if actual includes expected" do
+    expect("foo").to include("f")
+    expect([:foo, :bar, :baz]).to include(:baz)
+    expect({ :yellow => 'lorry' }).to include(:yellow)
+  end
+
+  it "does not match if actual does not inlcude expected" do
+    expect("foo").to_not include("b")
+    expect([:foo, :bar, :baz]).to_not include(:kapow)
+    expect({ :yellow => 'lorry' }).to_not include(:red)
+  end
+
+  it "fails if matcher does not match" do
+    expect {
+      expect("bar").to include("z")
+    }.to raise_error(Exception)
+  end
+end
+
+describe "respond_to" do
+  it "matches if actual responds to sym" do
+    expect("foo").to respond_to(:upcase)
+  end
+
+  it "does not match if actual does not respond to sym" do
+    expect(Object.new).to_not respond_to(:upcase)
+  end
+
+  it "fails if actual does not respond to sym" do
+    expect {
+      expect(Object.new).to respond_to(:upcase)
+    }.to raise_error(Exception)
+  end
+end
+
+describe "match" do
+  it "matches if actual matches expected" do
+    expect("foobar").to match(/ar/)
+    expect("foobar").to match("oob")
+  end
+
+  it "does not match if actual does not match expected" do
+    expect("foobar").to_not match(/baz/)
+    expect("foobar").to_not match("woosh")
+  end
+
+  it "fails unless matcher matches" do
+    expect {
+      exprct("hello").to match(/world/)
+    }.to raise_error(Exception)
+  end
+end
+
+describe "operator ==" do
+  it "matches if actual == expected" do
+    "hello".should == "hello"
+  end
+
+  it "does not match when actual does not == expected" do
+    "hello".should_not == "world"
+  end
+
+  it "fails unless matcher matches" do
+    expect {
+      "hello".should == "world"
+    }.to raise_error(Exception)
+  end
+end
+
+class PredicateTest
+  def foo?
+    true
+  end
+
+  def bar?
+    false
+  end
+end
+
+describe "predicate matchers" do
+  it "works with positive expectations" do
+    expect(PredicateTest.new).to be_foo
+  end
+
+  it "work with negative expectations" do
+    expect(PredicateTest.new).to_not be_bar
+  end
+end

data/spec/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/named_subject_spec.rb

@@ -0,0 +1,11 @@
+describe "named subject" 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

data/spec/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/vendor/spec_runner.js

@@ -0,0 +1,50 @@
+/*
+ * Test runner for phantomjs
+ */
+var args = phantom.args;
+var page = require('webpage').create();
+
+page.onConsoleMessage = function(msg) {
+  console.log(msg);
+};
+
+page.onInitialized = function() {
+  page.evaluate(function () {
+    window.OPAL_SPEC_PHANTOM = true;
+  });
+};
+
+/*
+ * Exit phantom instance "safely" see - https://github.com/ariya/phantomjs/issues/12697
+ * https://github.com/nobuoka/gulp-qunit/commit/d242aff9b79de7543d956e294b2ee36eda4bac6c
+ */
+function phantom_exit(code) {
+  page.close();
+  setTimeout(function () { phantom.exit(code); }, 0);
+}
+
+page.open(args[0], function(status) {
+  if (status !== 'success') {
+    console.error("Cannot load: " + args[0]);
+    phantom_exit(1);
+  } else {
+    var timeout = parseInt(args[1] || 60000, 10);
+    var start = Date.now();
+    var interval = setInterval(function() {
+      if (Date.now() > start + timeout) {
+        console.error("Specs timed out");
+        phantom_exit(124);
+      } else {
+        var code = page.evaluate(function() {
+          return window.OPAL_SPEC_CODE;
+        });
+
+        if (code === 0 || code === 1) {
+          clearInterval(interval);
+          phantom_exit(code);
+        }
+      }
+    }, 500);
+  }
+});
+

data/vendor_lib/rspec-expectations.rb

@@ -0,0 +1 @@
+require "rspec/expectations"

data/vendor_lib/rspec.rb

@@ -0,0 +1,3 @@
+require 'rspec/core'
+require 'rspec/version'
+

data/vendor_lib/rspec/autorun.rb

@@ -0,0 +1,2 @@
+require 'rspec/core'
+RSpec::Core::Runner.autorun

data/vendor_lib/rspec/core.rb

@@ -0,0 +1,203 @@
+require_rspec = if defined?(require_relative)
+  lambda do |path|
+    require_relative path
+  end
+else # for 1.8.7
+  lambda do |path|
+    require "rspec/#{path}"
+  end
+end
+
+require 'set'
+require 'time'
+require 'rbconfig'
+
+require_rspec['core/version']
+
+require 'rspec/support/caller_filter'
+require 'rspec/core/warnings'
+require 'rspec/support/warnings'
+
+require_rspec['core/flat_map']
+require_rspec['core/filter_manager']
+require_rspec['core/dsl']
+require_rspec['core/reporter']
+
+require_rspec['core/hooks']
+require_rspec['core/memoized_helpers']
+require_rspec['core/metadata']
+require_rspec['core/pending']
+require_rspec['core/formatters']
+require_rspec['core/ordering']
+
+require_rspec['core/world']
+require_rspec['core/configuration']
+require_rspec['core/option_parser']
+require_rspec['core/configuration_options']
+require_rspec['core/command_line']
+require_rspec['core/runner']
+require_rspec['core/example']
+require_rspec['core/shared_example_group/collection']
+require_rspec['core/shared_example_group']
+require_rspec['core/example_group']
+
+module RSpec
+  autoload :SharedContext, 'rspec/core/shared_context'
+
+  # @private
+  def self.wants_to_quit
+  # Used internally to determine what to do when a SIGINT is received
+    world.wants_to_quit
+  end
+
+  # @private
+  # Used internally to determine what to do when a SIGINT is received
+  def self.wants_to_quit=(maybe)
+    world.wants_to_quit=(maybe)
+  end
+
+  # @private
+  # Internal container for global non-configuration data
+  def self.world
+    @world ||= RSpec::Core::World.new
+  end
+
+  # @private
+  # Used internally to set the global object
+  def self.world=(new_world)
+    @world = new_world
+  end
+
+  # @private
+  # Used internally to ensure examples get reloaded between multiple runs in
+  # the same process.
+  def self.reset
+    @world = nil
+    @configuration = nil
+  end
+
+  # Returns the global [Configuration](RSpec/Core/Configuration) object. While you
+  # _can_ use this method to access the configuration, the more common
+  # convention is to use [RSpec.configure](RSpec#configure-class_method).
+  #
+  # @example
+  #     RSpec.configuration.drb_port = 1234
+  # @see RSpec.configure
+  # @see Core::Configuration
+  def self.configuration
+    if block_given?
+      RSpec.warn_deprecation <<-WARNING
+
+*****************************************************************
+DEPRECATION WARNING
+
+* RSpec.configuration with a block is deprecated and has no effect.
+* please use RSpec.configure with a block instead.
+
+Called from #{CallerFilter.first_non_rspec_line}
+*****************************************************************
+
+WARNING
+    end
+    @configuration ||= RSpec::Core::Configuration.new
+  end
+
+  # @private
+  # Used internally to set the global object
+  def self.configuration=(new_configuration)
+    @configuration = new_configuration
+  end
+
+  # Yields the global configuration to a block.
+  # @yield [Configuration] global configuration
+  #
+  # @example
+  #     RSpec.configure do |config|
+  #       config.add_formatter 'documentation'
+  #     end
+  # @see Core::Configuration
+  def self.configure
+    yield configuration if block_given?
+  end
+
+  # @private
+  # Used internally to clear remaining groups when fail_fast is set
+  def self.clear_remaining_example_groups
+    world.example_groups.clear
+  end
+
+  # The example being executed.
+  #
+  # The primary audience for this method is library authors who need access
+  # to the example currently being executed and also want to support all
+  # versions of RSpec 2 and 3.
+  #
+  # @example
+  #
+  #     RSpec.configure do |c|
+  #       # context.example is deprecated, but RSpec.current_example is not
+  #       # available until RSpec 3.0.
+  #       fetch_current_example = RSpec.respond_to?(:current_example) ?
+  #         proc { RSpec.current_example } : proc { |context| context.example }
+  #
+  #       c.before(:each) do
+  #         example = fetch_current_example.call(self)
+  #
+  #         # ...
+  #       end
+  #     end
+  #
+  def self.current_example
+    Thread.current[:_rspec_current_example]
+  end
+
+  # Set the current example being executed.
+  # @api private
+  def self.current_example=(example)
+    Thread.current[:_rspec_current_example] = example
+  end
+
+  # @private
+  def self.windows_os?
+    RbConfig::CONFIG['host_os'] =~ /cygwin|mswin|mingw|bccwin|wince|emx/
+  end
+
+  module Core
+    # @private
+    # This avoids issues with reporting time caused by examples that
+    # change the value/meaning of Time.now without properly restoring
+    # it.
+    class Time
+      class << self
+        define_method(:now, &::Time.method(:now))
+      end
+    end
+
+    # @private path to executable file
+    def self.path_to_executable
+      @path_to_executable ||= File.expand_path('../../../exe/rspec', __FILE__)
+    end
+  end
+
+  MODULES_TO_AUTOLOAD = {
+    :Matchers     => "rspec/expectations",
+    :Expectations => "rspec/expectations",
+    :Mocks        => "rspec/mocks"
+  }
+
+  def self.const_missing(name)
+    # Load rspec-expectations when RSpec::Matchers is referenced. This allows
+    # people to define custom matchers (using `RSpec::Matchers.define`) before
+    # rspec-core has loaded rspec-expectations (since it delays the loading of
+    # it to allow users to configure a different assertion/expectation
+    # framework). `autoload` can't be used since it works with ruby's built-in
+    # require (e.g. for files that are available relative to a load path dir),
+    # but not with rubygems' extended require.
+    #
+    # As of rspec 2.14.1, we no longer require `rspec/mocks` and
+    # `rspec/expectations` when `rspec` is required, so we want
+    # to make them available as an autoload. For more info, see:
+    require MODULES_TO_AUTOLOAD.fetch(name) { return super }
+    ::RSpec.const_get(name)
+  end
+end