reactrb 0.7.42

data/spec/reactive-ruby/component_loader_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+if ruby?
+RSpec.describe ReactiveRuby::ComponentLoader do
+  GLOBAL_WRAPPER = <<-JS
+    var global = global || this;
+    var self = self || this;
+    var window = window || this;
+  JS
+
+  let(:js) { ::Rails.application.assets['components'].to_s }
+  let(:context) { ExecJS.compile(GLOBAL_WRAPPER + js) }
+  let(:v8_context) { ReactiveRuby::ServerRendering.context_instance_for(context) }
+
+  describe '.new' do
+    it 'raises a meaningful exception when initialized without a context' do
+      expect {
+        described_class.new(nil)
+      }.to raise_error(/Could not obtain ExecJS runtime context/)
+    end
+  end
+
+  describe '#load' do
+    it 'loads given asset file into context' do
+      loader = described_class.new(v8_context)
+
+      expect {
+        loader.load
+      }.to change { !!v8_context.eval('Opal.React') }.from(false).to(true)
+    end
+
+    it 'is truthy upon successful load' do
+      loader = described_class.new(v8_context)
+      expect(loader.load).to be_truthy
+    end
+
+    it 'fails silently returning false' do
+      loader = described_class.new(v8_context)
+      expect(loader.load('foo')).to be_falsey
+    end
+  end
+
+  describe '#load!' do
+    it 'is truthy upon successful load' do
+      loader = described_class.new(v8_context)
+      expect(loader.load!).to be_truthy
+    end
+
+    it 'raises an expection if loading fails' do
+      loader = described_class.new(v8_context)
+      expect { loader.load!('foo') }.to raise_error(/No react\.rb components/)
+    end
+  end
+
+  describe '#loaded?' do
+    it 'is truthy if components file is already loaded' do
+      loader = described_class.new(v8_context)
+      loader.load
+      expect(loader).to be_loaded
+    end
+
+    it 'is false if components file is not loaded' do
+      loader = described_class.new(v8_context)
+      expect(loader).to_not be_loaded
+    end
+  end
+end
+end

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,9 @@
+require 'spec_helper'
+
+if ruby?
+  RSpec.describe 'test_app generator' do
+    it "does not interfer with asset precompilation" do
+      expect(system("cd spec/test_app; bundle exec rake assets:precompile")).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,109 @@
+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-latest'
+  require 'reactive-ruby'
+
+  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
+  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