hyper-react 0.10.0

data/spec/reactive-ruby/isomorphic_helpers_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+RSpec.describe React::IsomorphicHelpers do
+  describe 'code execution context' do
+    let(:klass) { Class.send(:include, described_class) }
+
+    describe 'module class methods', :opal do
+      it { expect(described_class).to_not be_on_opal_server }
+      it { expect(described_class).to be_on_opal_client }
+    end
+
+    describe 'included class methods', :opal do
+      it { expect(klass).to_not be_on_opal_server }
+      it { expect(klass).to be_on_opal_client }
+    end
+
+    describe 'included instance methods', :opal do
+      it { expect(klass.new).to_not be_on_opal_server }
+      it { expect(klass.new).to be_on_opal_client }
+    end
+
+    describe 'module class methods', :ruby do
+      it { is_expected.to_not be_on_opal_server }
+      it { is_expected.to_not be_on_opal_client }
+    end
+
+    describe 'included class methods', :ruby do
+      subject { klass }
+      it { is_expected.to_not be_on_opal_server }
+      it { is_expected.to_not be_on_opal_client }
+    end
+
+    describe 'included instance methods', :ruby do
+      subject { klass.new }
+      it { is_expected.to_not be_on_opal_server }
+      it { is_expected.to_not be_on_opal_client }
+    end
+  end
+
+if ruby?
+  describe 'load_context', :ruby do
+    let(:v8_context) { TestV8Context.new }
+    let(:controller) { double('controller') }
+    let(:name) { double('name') }
+
+    it 'creates a context and sets a controller' do
+      context = described_class.load_context(v8_context, controller, name)
+      expect(context.controller).to eq(controller)
+    end
+
+    it 'creates a context and sets a unique_id' do
+      Timecop.freeze do
+        stamp = Time.now.to_i
+        context = described_class.load_context(v8_context, controller, name)
+        expect(context.unique_id).to eq("#{ controller.object_id }-#{ stamp }")
+      end
+    end
+  end
+
+  describe React::IsomorphicHelpers::Context do
+    class TestV8Context < Hash
+      def eval(args)
+        true
+      end
+    end
+
+    # Need to decouple/dry up this...
+    def test_context(files = nil)
+      js = ReactiveRuby::ServerRendering::ContextualRenderer::CONSOLE_POLYFILL.dup
+      js << Opal::Builder.build('opal').to_s
+      Array(files).each do |filename|
+        js << ::Rails.application.assets[filename].to_s
+      end
+      js = "#{React::ServerRendering::ExecJSRenderer::GLOBAL_WRAPPER}#{js}"
+      ctx = ExecJS.compile(js)
+      ctx = ReactiveRuby::ServerRendering.context_instance_for(ctx)
+    end
+
+    def react_context
+      test_context('components')
+    end
+
+    let(:v8_context) { TestV8Context.new }
+    let(:controller) { double('controller') }
+    let(:name) { double('name') }
+    before do
+      described_class.instance_variable_set :@before_first_mount_blocks, nil
+    end
+
+    describe '#initialize' do
+      it "sets the given V8 context's ServerSideIsomorphicMethods to itself" do
+        context = described_class.new('unique-id', v8_context, controller, name)
+        expect(v8_context['ServerSideIsomorphicMethods']).to eq(context)
+      end
+
+      it 'calls before mount callbacks' do
+        string = instance_double(String)
+        described_class.register_before_first_mount_block do
+          string.inspect
+        end
+        expect(string).to receive(:inspect).once
+        context = described_class.new('unique-id', v8_context, controller, name)
+      end
+    end
+
+    describe '#eval' do
+      it 'delegates to given context' do
+        context = described_class.new('unique-id', v8_context, controller, name)
+        js = 'true;'
+        expect(v8_context).to receive(:eval).with(js).once
+        context.eval(js)
+      end
+    end
+
+    describe '#send_to_opal' do
+      let(:opal_code) { Opal::Builder.new.build_str(ruby_code, __FILE__) }
+      let(:ruby_code) { %Q[
+        module React::IsomorphicHelpers
+          def self.greet(name)
+            "Hello, #\{name}!"
+          end
+
+          def self.valediction
+            'Goodbye'
+          end
+        end
+      ]}
+
+      it 'raises an error when react cannot be loaded' do
+        context = described_class.new('unique-id', v8_context, controller, name)
+        context.instance_variable_set(:@ctx, test_context)
+        expect {
+          context.send_to_opal(:foo)
+        }.to raise_error(/No react.rb components found/)
+      end
+
+      it 'executes method with args inside opal rubyracer context' do
+        ctx = react_context
+        context = described_class.new('unique-id', ctx, controller, name)
+        ctx.eval(opal_code)
+        result = context.send_to_opal(:greet, 'world')
+        expect(result).to eq('Hello, world!')
+      end
+
+      it 'executes the method inside opal rubyracer context' do
+        ctx = react_context
+        context = described_class.new('unique-id', ctx, controller, name)
+        ctx.eval(opal_code)
+        result = context.send_to_opal(:valediction)
+        expect(result).to eq('Goodbye')
+      end
+    end
+  end
+end
+end

data/spec/reactive-ruby/rails/asset_pipeline_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+if ruby?
+RSpec.describe 'test_app generator' do
+  it "does not interfer with asset precompilation" do
+    cmd = "cd spec/test_app; BUNDLE_GEMFILE=#{ENV['REAL_BUNDLE_GEMFILE']} bundle exec rake assets:precompile"
+    expect(system(cmd)).to be_truthy
+  end
+end
+end

data/spec/reactive-ruby/rails/component_mount_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+if ruby?
+RSpec.describe ReactiveRuby::Rails::ComponentMount do
+  let(:helper) { described_class.new }
+
+  before do
+    helper.setup(ActionView::TestCase::TestController.new)
+  end
+
+  describe '#react_component' do
+    it 'renders a div' do
+      html = helper.react_component('Components::HelloWorld')
+      expect(html).to match(/<div.*><\/div>/)
+    end
+
+    it 'accepts a pre-render option' do
+      html = helper.react_component('Components::HelloWorld', {}, prerender: true)
+      expect(html).to match(/<div.*><span.*>Hello, World!<\/span><\/div>/)
+    end
+
+    it 'sets data-react-class to React.TopLevelRailsComponent' do
+      html = helper.react_component('Components::HelloWorld')
+      top_level_class = 'React.TopLevelRailsComponent'
+      expect(attr_value(html, 'data-react-class')).to eq(top_level_class)
+    end
+
+    it 'sets component_name in data-react-props hash' do
+      html = helper.react_component('Components::HelloWorld')
+      props = react_props_for(html)
+
+      expect(props['component_name']).to eq('Components::HelloWorld')
+    end
+
+    it 'sets render_params in data-react-props hash' do
+      html = helper.react_component('Components::HelloWorld', {'foo' => 'bar'})
+      props = react_props_for(html)
+
+      expect(props['render_params']).to include({ 'foo' => 'bar' })
+    end
+
+    it 'sets controller in data-react-props hash' do
+      html = helper.react_component('Components::HelloWorld')
+      props = react_props_for(html)
+
+      expect(props['controller']).to eq('ActionView::TestCase::Test')
+    end
+
+    it 'passes additional options through as html attributes' do
+      html = helper.react_component('Components::HelloWorld', {},
+                                    { 'foo-bar' => 'biz-baz' })
+
+      expect(attr_value(html, 'foo-bar')).to eq('biz-baz')
+    end
+  end
+
+  def attr_value(html, attr)
+    matches = html.match(/#{attr}=["']((?:.(?!["']\s+(?:\S+)=|[>"']))+.)["']?/)
+    matches.captures.first
+  end
+
+  def react_props_for(html)
+    JSON.parse(CGI.unescapeHTML("#{attr_value(html, 'data-react-props')}"))
+  end
+end
+end

data/spec/reactive-ruby/server_rendering/contextual_renderer_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+if ruby?
+RSpec.describe ReactiveRuby::ServerRendering::ContextualRenderer do
+  let(:renderer) { described_class.new({}) }
+  let(:init) { Proc.new {} }
+  let(:options) { { context_initializer: init } }
+
+  describe '#render' do
+    it 'pre-renders HTML' do
+      result = renderer.render('Components.Todo',
+                                { todo: 'finish reactive-ruby' },
+                                options)
+      expect(result).to match(/<li.*>finish reactive-ruby<\/li>/)
+      expect(result).to match(/data-react-checksum/)
+    end
+
+    it 'accepts props as a string' do
+      result = renderer.render('Components.Todo',
+                                { todo: 'finish reactive-ruby' }.to_json,
+                                options)
+      expect(result).to match(/<li.*>finish reactive-ruby<\/li>/)
+      expect(result).to match(/data-react-checksum/)
+    end
+
+    it 'pre-renders static content' do
+      result = renderer.render('Components.Todo',
+                                { todo: 'finish reactive-ruby' },
+                                :static)
+      expect(result).to match(/<li.*>finish reactive-ruby<\/li>/)
+      expect(result).to_not match(/data-react-checksum/)
+    end
+  end
+end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,115 @@
+ENV["RAILS_ENV"] ||= 'test'
+
+require 'opal'
+require 'opal-rspec'
+require 'opal-jquery'
+
+def opal?
+  RUBY_ENGINE == 'opal'
+end
+
+def ruby?
+  !opal?
+end
+
+
+if RUBY_ENGINE == 'opal'
+  require File.expand_path('../vendor/jquery-2.2.4.min', __FILE__)
+  require 'react/react-source'
+  require 'hyper-react'
+  require 'react/test/rspec'
+
+  require File.expand_path('../support/react/spec_helpers', __FILE__)
+
+  module Opal
+    module RSpec
+      module AsyncHelpers
+        module ClassMethods
+          def rendering(title, &block)
+            klass = Class.new do
+              include React::Component
+
+              def self.block
+                @block
+              end
+
+              def self.name
+                "dummy class"
+              end
+
+              def render
+                instance_eval &self.class.block
+              end
+
+              def self.should_generate(opts={}, &block)
+                sself = self
+                @self.async(@title, opts) do
+                  expect_component_to_eventually(sself, &block)
+                end
+              end
+
+              def self.should_immediately_generate(opts={}, &block)
+                sself = self
+                @self.it(@title, opts) do
+                  element = build_element sself, {}
+                  context = block.arity > 0 ? self : element
+                  expect((element and context.instance_exec(element, &block))).to be(true)
+                end
+              end
+
+            end
+            klass.instance_variable_set("@block", block)
+            klass.instance_variable_set("@self", self)
+            klass.instance_variable_set("@title", "it can render #{title}")
+            klass
+          end
+        end
+      end
+    end
+  end
+
+
+  RSpec.configure do |config|
+    config.include React::SpecHelpers
+    config.filter_run_excluding :ruby
+    if `(React.version.search(/^0\.13/) === -1)`
+      config.filter_run_excluding :v13_only
+    else
+      config.filter_run_excluding :v13_exclude
+    end
+  end
+end
+
+if RUBY_ENGINE != 'opal'
+  begin
+    require File.expand_path('../test_app/config/environment', __FILE__)
+  rescue LoadError
+    puts 'Could not load test application. Please ensure you have run `bundle exec rake test_app`'
+  end
+  require 'rspec/rails'
+  require 'timecop'
+
+  Dir["./spec/support/**/*.rb"].sort.each { |f| require f }
+
+  RSpec.configure do |config|
+    config.color = true
+    config.fail_fast = ENV['FAIL_FAST'] || false
+    config.fixture_path = File.join(File.expand_path(File.dirname(__FILE__)), "fixtures")
+    config.infer_spec_type_from_file_location!
+    config.mock_with :rspec
+    config.raise_errors_for_deprecations!
+
+    # If you're not using ActiveRecord, or you'd prefer not to run each of your
+    # examples within a transaction, comment the following line or assign false
+    # instead of true.
+    config.use_transactional_fixtures = true
+
+    config.before :each do
+      Rails.cache.clear
+    end
+
+    config.filter_run_including focus: true
+    config.filter_run_excluding opal: true
+    config.run_all_when_everything_filtered = true
+  end
+end

data/spec/support/react/spec_helpers.rb

@@ -0,0 +1,64 @@
+if opal?
+module React
+  module SpecHelpers
+    `var ReactTestUtils = React.addons.TestUtils`
+
+    def render_to_html(type, options = {})
+      element = React.create_element(type, options)
+      React.render_to_static_markup(element)
+    end
+
+    def renderToDocument(type, options = {})
+      element = React.create_element(type, options)
+      renderElementToDocument(element)
+    end
+
+    def renderElementToDocument(element)
+      instance = Native(`ReactTestUtils.renderIntoDocument(#{element.to_n})`)
+      instance.class.include(React::Component::API)
+      instance
+    end
+
+    def simulateEvent(event, element, params = {})
+      simulator = Native(`ReactTestUtils.Simulate`)
+      simulator[event.to_s].call(element.dom_node, params)
+    end
+
+    def isElementOfType(element, type)
+      `React.addons.TestUtils.isElementOfType(#{element.to_n}, #{type.cached_component_class})`
+    end
+
+    def build_element(type, options)
+      component = React.create_element(type, options)
+      element = `ReactTestUtils.renderIntoDocument(#{component.to_n})`
+      if `typeof React.findDOMNode === 'undefined'`
+        `$(element.getDOMNode())`          # v0.12
+      else
+        `$(React.findDOMNode(element))`    # v0.13
+      end
+    end
+
+    def expect_component_to_eventually(component_class, opts = {}, &block)
+      # Calls block after each update of a component until it returns true.
+      # When it does set the expectation to true.  Uses the after_update
+      # callback of the component_class, then instantiates an element of that
+      # class The call back is only called on updates, so the call back is
+      # manually called right after the element is created.  Because React.rb
+      # runs the callback inside the components context, we have to setup a
+      # lambda to get back to correct context before executing run_async.
+      # Because run_async can only be run once it is protected by clearing
+      # element once the test passes.
+      element = nil
+      check_block = lambda do
+        context = block.arity > 0 ? self : element
+        run_async do
+          element = nil; expect(true).to be(true)
+        end if element and context.instance_exec(element, &block)
+      end
+      component_class.after_update { check_block.call  }
+      element = build_element component_class, opts
+      check_block.call
+    end
+  end
+end
+end