opal-spec 0.0.1 → 0.2.8

data/.gitignore

@@ -1,8 +1,7 @@
 .DS_Store
 doc
 /pkg
-/tmp
-.yardoc
-extras
-/opal-test*.js
-
+/*.js
+/*.gem
+/build
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,6 @@
+source :rubygems
+gemspec
+
+gem 'rake'
+gem 'opal'
+gem 'sprockets'

data/README.md

@@ -1,4 +1,91 @@
-OpalSpec
-=========
+# opal-spec
 
-Spec framework for opal.
+opal-spec is a minimal spec lib for opal, inspired by RSpec and MSpec.
+It is designed to run on [opal](http://opalrb.org), and provides the
+bare minimum to get specs running.
+
+## Writing Specs
+
+Your specs should go into the `/spec` directory of your app. They take
+the same form as rspec/mspec:
+
+```ruby
+describe MyClass do
+  it 'should do some feature' do
+    1.should == 1
+  end
+
+  it 'does something else' do
+    nil.should be_nil
+    false.should be_false
+    true.should be_true
+  end
+end
+```
+
+### Running specs
+
+Loading these specs in a browser won't just work. You need to run them.
+The best place to do this is inside `spec/spec_helper.rb`, and with a
+simple call:
+
+```ruby
+Opal::Spec::Runner.autorun
+```
+
+###  Async examples
+
+Examples can be async, and need to be defined as so:
+
+```ruby
+  describe 'MyClass' do
+    # normal, sync example
+    it 'does something' do
+      # ...
+    end
+
+    # async example
+    async 'does something else too' do
+      # ...
+    end
+  end
+```
+
+This just marks the example as being async. To actually handle the async
+result, you also need to use a `run_async` call inside some future handler:
+
+```ruby
+async 'HTTP requests should work' do
+  HTTP.get('users/1.json') do |response|
+    run_async {
+      response.ok?.should be_true
+    }
+  end
+end
+```
+
+The end of the block passed to `run_async` informs opal-spec that you are
+done with this test, so it can move on.
+
+Change Log
+----------
+
+### 0.2.7
+
+* Can be built using asset pipeline/sprockets
+* BrowserFormatter is now default
+
+### 0.0.3
+
+* Allow group names to be non-strings
+* Nested groups now have outer group name as prefix
+* Nested groups should inherit `before` and `after` blocks
+
+### 0.0.2
+
+* Added seperate BrowserFormatter class for cleaner output
+* Update Rake tasks to use new Opal::Builder class
+
+### 0.0.1
+
+Initial release

data/Rakefile

@@ -0,0 +1,27 @@
+require 'bundler'
+Bundler.require
+
+desc "Build opal-spec (with opal) into build"
+task :build => [:dir] do
+  File.open('build/opal-spec.js', 'w+') do |out|
+    out.puts Opal.process('opal-spec')
+  end
+end
+
+desc "Build example specs ready to run"
+task :build_specs => [:dir] do
+  Opal.append_path File.join(File.dirname(__FILE__), 'spec')
+
+  File.open('build/specs.js', 'w+') do |out|
+    out.puts Opal.process('specs')
+  end
+end
+task :dir do
+  FileUtils.mkdir_p 'build'
+end
+
+task :test do
+  Opal::Spec.runner
+end
+
+task :default => [:build_specs, :test]

data/lib/assets/javascripts/opal/spec/browser_formatter.rb

@@ -0,0 +1,194 @@
+module Opal
+  module Spec
+    class BrowserFormatter
+      CSS = <<-EOS
+
+        body {
+          font-size: 14px;
+          font-family: Helvetica Neue, Helvetica, Arial, sans-serif;
+        }
+
+        pre {
+          font-family: "Bitstream Vera Sans Mono", Monaco, "Lucida Console", monospace;
+          font-size: 12px;
+          color: #444444;
+          white-space: pre;
+          padding: 3px 0px 3px 12px;
+          margin: 0px 0px 8px;
+
+          background: #FAFAFA;
+          -webkit-box-shadow: rgba(0,0,0,0.07) 0 1px 2px inset;
+          -webkit-border-radius: 3px;
+          -moz-border-radius: 3px;
+          border-radius: 3px;
+          border: 1px solid #DDDDDD;
+        }
+
+        ul.example_groups {
+          list-style-type: none;
+        }
+
+        li.group.passed .group_description {
+          color: #597800;
+          font-weight: bold;
+        }
+
+        li.group.failed .group_description {
+          color: #FF000E;
+          font-weight: bold;
+        }
+
+        li.example.passed {
+          color: #597800;
+        }
+
+        li.example.failed {
+          color: #FF000E;
+        }
+
+        .examples {
+          list-style-type: none;
+        }
+      EOS
+
+      def initialize
+        @examples        = []
+        @failed_examples = []
+      end
+
+      def start
+        %x{
+          if (!document || !document.body) {
+            #{ raise "Not running in browser." };
+          }
+
+          var summary_element = document.createElement('p');
+          summary_element.className = 'summary';
+          summary_element.innerHTML = "Running...";
+
+          var groups_element = document.createElement('ul');
+          groups_element.className = 'example_groups';
+
+          var target = document.getElementById('opal-spec-output');
+
+          if (!target) {
+            target = document.body;
+          }
+
+          target.appendChild(summary_element);
+          target.appendChild(groups_element);
+
+          var styles = document.createElement('style');
+          styles.type = 'text/css';
+
+          if (styles.styleSheet) {
+            styles.styleSheet.cssText = __scope.CSS;
+          }
+          else {
+            styles.appendChild(document.createTextNode(__scope.CSS));
+          }
+
+          document.getElementsByTagName('head')[0].appendChild(styles);
+        }
+
+        @start_time = Time.now.to_f
+        @groups_element = `groups_element`
+        @summary_element = `summary_element`
+      end
+
+      def finish
+        time = Time.now.to_f - @start_time
+        text = "\n#{example_count} examples, #{@failed_examples.size} failures (time taken: #{time})"
+        `#{@summary_element}.innerHTML = text`
+      end
+
+      def example_group_started group
+        @example_group = group
+        @example_group_failed = false
+
+        %x{
+          var group_element = document.createElement('li');
+
+          var description = document.createElement('span');
+          description.className = 'group_description';
+          description.innerHTML = #{group.description.to_s};
+          group_element.appendChild(description);
+
+          var example_list = document.createElement('ul');
+          example_list.className = 'examples';
+          group_element.appendChild(example_list);
+
+          #@groups_element.appendChild(group_element);
+        }
+
+        @group_element = `group_element`
+        @example_list  = `example_list`
+      end
+
+      def example_group_finished group
+        if @example_group_failed
+          `#@group_element.className = 'group failed';`
+        else
+          `#@group_element.className = 'group passed';`
+        end
+      end
+
+      def example_started example
+        @examples << example
+        @example = example
+      end
+
+      def example_failed example
+        @failed_examples << example
+        @example_group_failed = true
+
+        exception = example.exception
+
+        case exception
+        when Opal::Spec::ExpectationNotMetError
+          output  = exception.message
+        else
+          output  = "#{exception.class.name}: #{exception.message}\n"
+          output += "    #{exception.backtrace.join "\n    "}\n"
+        end
+
+        %x{
+          var wrapper = document.createElement('li');
+          wrapper.className = 'example failed';
+
+          var description = document.createElement('span');
+          description.className = 'example_description';
+          description.innerHTML = #{example.description};
+
+          var exception = document.createElement('pre');
+          exception.className = 'exception';
+          exception.innerHTML = output;
+
+          wrapper.appendChild(description);
+          wrapper.appendChild(exception);
+
+          #@example_list.appendChild(wrapper);
+          #@example_list.style.display = 'list-item';
+        }
+      end
+
+      def example_passed example
+        %x{
+          var wrapper = document.createElement('li');
+          wrapper.className = 'example passed';
+
+          var description = document.createElement('span');
+          description.className = 'example_description';
+          description.innerHTML = #{example.description};
+
+          wrapper.appendChild(description);
+          #@example_list.appendChild(wrapper);
+        }
+      end
+
+      def example_count
+        @examples.size
+      end
+    end
+  end
+end

data/lib/assets/javascripts/opal/spec/example.rb

@@ -0,0 +1,78 @@
+module Opal
+  module Spec
+    class Example
+      attr_reader :description, :example_group, :exception
+      attr_accessor :asynchronous
+
+      def initialize(group, desc, block)
+        @example_group = group
+        @description   = desc
+        @__block__     = block
+      end
+
+      def finish_running
+        if @exception
+          @example_group.example_failed self
+        else
+          @example_group.example_passed self
+        end
+      end
+
+      def run
+        begin
+          @example_group.example_started self
+          run_before_hooks
+          instance_eval(&@__block__)
+        rescue => e
+          @exception = e
+        ensure
+          run_after_hooks unless @asynchronous
+        end
+
+        if @asynchronous
+          # must wait ...
+        else
+          finish_running
+        end
+      end
+
+      def run_after_hooks
+        begin
+          @example_group.after_hooks.each do |after|
+          instance_eval &after
+          end
+        rescue => e
+          @exception = e
+        end
+      end
+
+      def run_before_hooks
+        @example_group.before_hooks.each do |before|
+          instance_eval &before
+        end
+      end
+
+      def run_async(&block)
+        begin
+          block.call
+        rescue => e
+          @exception = e
+        ensure
+          run_after_hooks
+        end
+
+        finish_running
+      end
+
+      def set_timeout(duration, &block)
+        %x{
+          setTimeout(function() {
+            #{ block.call };
+          }, duration);
+        }
+
+        self
+      end
+    end
+  end
+end

data/lib/assets/javascripts/opal/spec/example_group.rb

@@ -0,0 +1,94 @@
+module Opal
+  module Spec
+    class ExampleGroup
+      @example_groups = []
+      def self.example_groups
+        @example_groups
+      end
+
+      @stack = []
+      def self.create desc, block
+        group = self.new desc, @stack.last
+        @example_groups << group
+
+        @stack << group
+        group.instance_eval &block
+        @stack.pop
+      end
+
+      def initialize desc, parent
+        @desc     = desc.to_s
+        @parent   = parent
+        @examples = []
+
+        @before_hooks = []
+        @after_hooks  = []
+      end
+
+      def it(desc, &block)
+        @examples << Example.new(self, desc, block)
+      end
+
+      def async(desc, &block)
+        example = Example.new(self, desc, block)
+        example.asynchronous = true
+        @examples << example
+      end
+
+      def it_behaves_like(*objs)
+      end
+
+      def before type = :each, &block
+        raise "unsupported before type: #{type}" unless type == :each
+        @before_hooks << block
+      end
+
+      def after type = :each, &block
+        raise "unsupported after type: #{type}" unless type == :each
+        @after_hooks << block
+      end
+
+      def before_hooks
+        @parent ? [].concat(@parent.before_hooks).concat(@before_hooks) : @before_hooks
+      end
+
+      def after_hooks
+        @parent ? [].concat(@parent.after_hooks).concat(@after_hooks) : @after_hooks
+      end
+
+      def run(runner)
+        @runner = runner
+        @runner.example_group_started self
+
+        @running_examples = @examples.dup
+        run_next_example
+      end
+
+      def run_next_example
+        if @running_examples.empty?
+          @runner.example_group_finished self
+        else
+          @running_examples.shift.run
+        end
+      end
+
+      def example_started(example)
+        @runner.example_started(example)
+      end
+
+      def example_passed(example)
+        @runner.example_passed(example)
+        run_next_example
+      end
+
+      def example_failed(example)
+        @runner.example_failed(example)
+        run_next_example
+      end
+
+      def description
+        @parent ? "#{@parent.description} #{@desc}" : @desc
+      end
+    end
+  end
+end

data/lib/assets/javascripts/opal/spec/expectations.rb

@@ -0,0 +1,55 @@
+module Opal
+  module Spec
+    class ExpectationNotMetError < StandardError; end
+
+    module Expectations
+      def should matcher = nil
+        if matcher
+          matcher.match self
+        else
+          Opal::Spec::PositiveOperatorMatcher.new self
+        end
+      end
+
+      def should_not matcher = nil
+        if matcher
+          matcher.not_match self
+        else
+          Opal::Spec::NegativeOperatorMatcher.new self
+        end
+      end
+
+      def be_kind_of expected
+        Opal::Spec::BeKindOfMatcher.new expected
+      end
+
+      def be_nil
+        Opal::Spec::BeNilMatcher.new nil
+      end
+
+      def be_true
+        Opal::Spec::BeTrueMatcher.new true
+      end
+
+      def be_false
+        Opal::Spec::BeFalseMatcher.new false
+      end
+
+      def eq(expected)
+        Opal::Spec::EqlMatcher.new expected
+      end
+
+      def equal expected
+        Opal::Spec::EqualMatcher.new expected
+      end
+
+      def raise_error expected
+        Opal::Spec::RaiseErrorMatcher.new expected
+      end
+    end
+  end
+end
+
+class Object
+  include Opal::Spec::Expectations
+end

data/lib/{opal → assets/javascripts/opal}/spec/kernel.rb

@@ -1,6 +1,6 @@
 module Kernel
   def describe desc, &block
-    OpalSpec::ExampleGroup.create desc, block
+    Opal::Spec::ExampleGroup.create desc, block
   end
 
   def mock obj

data/lib/assets/javascripts/opal/spec/matchers.rb

@@ -0,0 +1,106 @@
+module Opal
+  module Spec
+    class Matcher
+      def initialize actual
+        @actual = actual
+      end
+
+      def failure message
+        raise Opal::Spec::ExpectationNotMetError, message
+      end
+    end
+
+    class PositiveOperatorMatcher < Matcher
+      def == expected
+        if @actual == expected
+          true
+        else
+          failure "expected: #{expected.inspect}, got: #{@actual.inspect} (using ==)."
+        end
+      end
+    end
+
+    class NegativeOperatorMatcher < Matcher
+      def == expected
+        if @actual == expected
+          failure "expected: #{expected.inspect} not to be #{@actual.inspect} (using ==)."
+        end
+      end
+    end
+
+    class BeKindOfMatcher < Matcher
+      def match expected
+        unless expected.kind_of? @actual
+          failure "expected #{expected.inspect} to be a kind of #{@actual.name}, not #{expected.class.name}."
+        end
+      end
+    end
+
+    class BeNilMatcher < Matcher
+      def match expected
+        unless expected.nil?
+          failure "expected #{expected.inspect} to be nil."
+        end
+      end
+    end
+
+    class BeTrueMatcher < Matcher
+      def match expected
+        unless expected == true
+          failure "expected #{expected.inspect} to be true."
+        end
+      end
+    end
+
+    class BeFalseMatcher < Matcher
+      def match expected
+        unless expected == false
+          failure "expected #{expected.inspect} to be false."
+        end
+      end
+    end
+
+    class EqlMatcher < Matcher
+      def match(expected)
+        unless expected == @actual
+          failure "expected: #{expected.inspect}, got: #{@actual.inspect} (using ==)."
+        end
+      end
+
+      def not_match(expected)
+        if expected.equal? @actual
+          failure "expected: #{expected.inspect} not to be #{@actual.inspect} (using ==)."
+        end
+      end
+    end
+
+    class EqualMatcher < Matcher
+      def match expected
+        unless expected.equal? @actual
+          failure "expected #{@actual.inspect} to be the same as #{expected.inspect}."
+        end
+      end
+
+      def not_match expected
+        if expected.equal? @actual
+          failure "expected #{@actual.inspect} not to be equal to #{expected.inspect}."
+        end
+      end
+    end
+
+    class RaiseErrorMatcher < Matcher
+      def match block
+        should_raise = false
+        begin
+          block.call
+          should_raise = true
+        rescue => e
+        end
+
+        if should_raise
+          failure "expected #{@actual} to be raised, but nothing was."
+        end
+      end
+    end
+  end
+end