hyper-react 0.99.6 → 1.0.0.lap21

data/spec/react/refs_callback_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe 'Refs callback', js: true do
+  before do
+    on_client do
+      class Foo
+        include React::Component
+        def self.bar
+          @@bar
+        end
+        def self.bar=(club)
+          @@bar = club
+        end
+      end
+    end
+  end
+
+  it "is invoked with the actual Ruby instance" do
+    expect_evaluate_ruby do
+      class Bar
+        include React::Component
+        def render
+          React.create_element('div')
+        end
+      end
+
+      Foo.class_eval do
+        def my_bar=(bars)
+          Foo.bar = bars
+        end
+
+        def render
+          React.create_element(Bar, ref: method(:my_bar=).to_proc)
+        end
+      end
+
+      element = React.create_element(Foo)
+      React::Test::Utils.render_into_document(element)
+      begin
+        "#{Foo.bar.class.name}"
+      rescue
+        "Club"
+      end
+    end.to eq('Bar')
+  end
+
+  it "is invoked with the actual DOM node" do
+    # client_option raise_on_js_errors: :off
+    expect_evaluate_ruby do
+      Foo.class_eval do
+        def my_div=(div)
+          Foo.bar = div
+        end
+
+        def render
+          React.create_element('div', ref: method(:my_div=).to_proc)
+        end
+      end
+
+      element = React.create_element(Foo)
+      React::Test::Utils.render_into_document(element)
+      "#{Foo.bar.JS['nodeType']}" # aboids json serialisation errors by using "#{}"
+    end.to eq("1")
+  end
+end

data/spec/react/server_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe 'React::Server', js: true do
+
+  describe "render_to_string" do
+    it "should render a React.Element to string" do
+      client_option render_on: :both
+      expect_evaluate_ruby do
+        ele = React.create_element('span') { "lorem" }
+        React::Server.render_to_string(ele).class.name
+      end.to eq("String")
+    end
+  end
+
+  describe "render_to_static_markup" do
+    it "should render a React.Element to static markup" do
+      client_option render_on: :both
+      expect_evaluate_ruby do
+        ele = React.create_element('span') { "lorem" }
+        React::Server.render_to_static_markup(ele)
+      end.to eq("<span>lorem</span>")
+    end
+  end
+end
+

data/spec/react/state_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe 'React::State', js: true do
+  it "can create dynamically initialized exported states" do
+    expect_evaluate_ruby do
+      class Foo
+        include React::Component
+        export_state(:foo) { 'bar' }
+      end
+      Hyperloop::Application::Boot.run
+      Foo.foo
+    end.to eq('bar')
+  end
+
+  # these will all require async operations and testing to see if things get
+  # re-rendered see spec_helper the "render" test method
+
+  # if Foo.foo is used during rendering then when Foo.foo changes we will
+  # rerender
+  it "sets up observers when exported states are read"
+
+  # React::State.set_state(object, attribute, value) +
+  # React::State.get_state(object, attribute)
+  it "can be accessed outside of react using get/set_state"
+
+  it 'ignores state updates during rendering' do
+    client_option render_on: :both    
+    evaluate_ruby do
+      class StateTest < React::Component::Base
+        export_state :boom
+        before_mount do
+          # force boom to be on the observing list during the current rendering cycle
+          StateTest.boom! !StateTest.boom
+          # this is automatically called by after_mount / after_update, but we don't want
+          # to have to setup a complicated async test, so we just force it now.
+          # if we don't do this, then updating boom will have no effect on the first render
+          React::State.update_states_to_observe
+        end
+        def render
+          (StateTest.boom ? "Boom" : "No Boom").tap { StateTest.boom! !StateTest.boom }
+        end
+      end
+      MARKUP = React::Server.render_to_static_markup(React.create_element(StateTest))
+    end
+    expect_evaluate_ruby("MARKUP").to eq('<span>Boom</span>')
+    expect_evaluate_ruby("StateTest.boom").to be_falsy
+    expect(page.driver.browser.manage.logs.get(:browser).reject { |entry|
+      entry_s = entry.to_s
+      entry_s.include?("Deprecated feature") || entry_s.include?("Mount() on the server. This is a no-op.")
+    }.size).to eq(0)
+  end
+end

data/spec/react/test/dsl_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+if RUBY_ENGINE == 'opal' 
+  RSpec.describe React::Test::DSL do
+    describe 'the DSL' do
+      let(:session) { Class.new { include React::Test::DSL }.new }
+
+      before do
+        React::Test.reset_session!
+
+        stub_const 'Greeter', Class.new
+        Greeter.class_eval do
+          include React::Component
+
+          params do
+            optional :message
+            optional :from
+          end
+
+          def render
+            span { "Hello #{params.message}" }
+          end
+        end
+      end
+
+      it 'is possible to include it in another class' do
+        session.mount(Greeter)
+        expect(session.instance).to be_a(Greeter)
+      end
+
+      it "should provide a 'component' shortcut for more expressive tests" do
+        session.component.mount(Greeter)
+        expect(session.component.instance).to be_a(Greeter)
+      end
+
+      React::Test::Session::DSL_METHODS.each do |method|
+        it "responds to all DSL method: #{method}" do
+          expect(session).to respond_to(method)
+        end
+      end
+    end
+  end
+end

data/spec/react/test/matchers/render_html_matcher_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+if RUBY_ENGINE == 'opal' 
+describe React::Test::Matchers::RenderHTMLMatcher do
+  let(:component) {
+    Class.new do
+      include React::Component
+      params do
+        optional :string
+      end
+      def render
+        div do
+          span { params.string } if params.string
+          'lorem'
+        end
+      end
+    end
+  }
+  let(:expected) { '<div>lorem</div>' }
+  let(:matcher) { described_class.new(expected) }
+
+  describe '#matches?' do
+    it 'is truthy when rendered component html equals expected html' do
+      expect(matcher.matches?(component)).to be_truthy
+    end
+
+    it 'is falsey when rendered component html does not equal expected html' do
+      matcher = described_class.new('foo')
+      expect(matcher.matches?(component)).to be_falsey
+    end
+  end
+
+  describe '#with_params' do
+    let(:expected) { '<div><span>str</span>lorem</div>' }
+
+    it 'renders the component with the given params' do
+      matcher.with_params(string: 'str')
+      expect(matcher.matches?(component)).to be_truthy
+    end
+  end
+
+  describe '#failure_message' do
+    let(:expected) { '<div><span>str</span>lorem</div>' }
+
+    it 'includes the name of the component' do
+      stub_const 'Foo', component
+      matcher.matches?(Foo)
+      expect(matcher.failure_message).to match(/expected 'Foo'/)
+    end
+
+    it 'includes the params hash' do
+      matcher.with_params(string: 'bar')
+      matcher.matches?(component)
+      expect(matcher.failure_message).to match(/with params '{"string"=>"bar"}'/)
+    end
+
+    it 'includes the expected html value' do
+      matcher.matches?(component)
+      expect(matcher.failure_message).to match(/to render '#{expected}'/)
+    end
+
+    it 'includes the actual html value' do
+      actual = '<div>lorem<\/div>'
+      matcher.matches?(component)
+      expect(matcher.failure_message).to match(/, but '#{actual}' was rendered/)
+    end
+
+    it 'does not include "to not render"' do
+      matcher.matches?(component)
+      expect(matcher.failure_message).to_not match(/to not render/)
+    end
+  end
+
+  describe '#negative_failure_message' do
+    let(:expected) { '<div><span>str</span>lorem</div>' }
+
+    it 'includes "to not render"' do
+      matcher.matches?(component)
+      expect(matcher.negative_failure_message).to match(/to not render/)
+    end
+  end
+end
+end

data/spec/react/test/rspec_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+if RUBY_ENGINE == 'opal' 
+  RSpec.describe 'react/test/rspec', type: :component do
+    before do
+      stub_const 'Greeter', Class.new
+      Greeter.class_eval do
+        include React::Component
+        params do
+          optional :message
+          optional :from
+        end
+
+        def render
+          span { "Hello #{params.message}" }
+        end
+      end
+    end
+
+    it 'should include react/test in rspec' do
+      comp = mount(Greeter)
+      expect(component.instance).to eq(comp)
+    end
+
+    it 'includes rspec matchers' do
+      expect(Greeter).to render_static_html(
+        '<span>Hello world</span>'
+      ).with_params(message: 'world')
+    end
+
+    describe 'resetting the session' do
+      it 'creates an instance of the mounted component in one example' do
+        mount(Greeter)
+      end
+
+      it '...then is not availalbe in the next' do
+        expect { component.instance }.to raise_error
+      end
+    end
+  end
+
+  RSpec.describe 'react/test/rspec', type: :other do
+    before do
+      stub_const 'Greeter', Class.new
+      Greeter.class_eval do
+        include React::Component
+        params do
+          optional :message
+          optional :from
+        end
+
+        def render
+          span { "Hello #{params.message}" }
+        end
+      end
+    end
+
+    it 'should not include react/test in rspec' do
+      expect { mount(Greeter) }.to raise_error
+    end
+  end
+end

data/spec/react/test/session_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+if RUBY_ENGINE == 'opal' 
+  RSpec.describe React::Test::Session do
+    subject { described_class.new }
+    before do
+      stub_const 'Greeter', Class.new
+      Greeter.class_eval do
+        include React::Component
+
+        params do
+          optional :message
+          optional :from
+        end
+
+        def render
+          span { "Hello #{params.message}" }
+        end
+      end
+    end
+
+    describe '#mount' do
+      it 'returns an instance of the mounted component' do
+        expect(subject.mount(Greeter)).to be_a(Greeter)
+      end
+
+      it 'actualy mounts the component' do
+        expect(subject.mount(Greeter)).to be_mounted
+      end
+
+      it 'optionaly passes params to the component' do
+        instance = subject.mount(Greeter, message: 'world')
+        expect(instance.params.message).to eq('world')
+      end
+    end
+
+    describe '#instance' do
+      it 'returns the instance of the mounted component' do
+        instance = subject.mount(Greeter)
+        expect(subject.instance).to eq(instance)
+      end
+    end
+
+    describe '#html' do
+      it 'returns the component rendered to static html' do
+        subject.mount(Greeter, message: 'world')
+        expect(subject.html).to eq('<span>Hello world</span>')
+      end
+
+      async 'returns the updated static html' do
+        subject.mount(Greeter)
+        subject.update_params(message: 'moon') do
+          run_async {
+            expect(subject.html).to eq('<span>Hello moon</span>')
+          }
+        end
+      end
+    end
+
+    describe '#update_params' do
+      it 'sends new params to the component' do
+        instance = subject.mount(Greeter, message: 'world')
+        subject.update_params(message: 'moon')
+        expect(instance.params.message).to eq('moon')
+      end
+
+      it 'leaves unspecified params in tact' do
+        instance = subject.mount(Greeter, message: 'world', from: 'outerspace')
+        subject.update_params(message: 'moon')
+        expect(instance.params.from).to eq('outerspace')
+      end
+
+      it 'causes the component to render' do
+        instance = subject.mount(Greeter, message: 'world')
+        expect(instance).to receive(:render)
+        subject.update_params(message: 'moon')
+      end
+    end
+
+    describe 'instance#force_update!' do
+      it 'causes the component to render' do
+        instance = subject.mount(Greeter)
+        expect(instance).to receive(:render)
+        subject.instance.force_update!
+      end
+    end
+  end
+end

data/spec/react/test/utils_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+if RUBY_ENGINE == 'opal' 
+  RSpec.describe React::Test::Utils do
+    it 'simulates' do
+      stub_const 'Foo', Class.new
+      Foo.class_eval do
+        include React::Component
+
+        def render
+          div { 'Click Me' }.on(:click) { |e| click(e) }
+        end
+      end
+
+      instance = React::Test::Utils.render_into_document(React.create_element(Foo))
+      expect(instance).to receive(:click)
+      described_class.simulate(:click, instance.dom_node)
+    end
+
+    describe "render_into_document" do
+      it "works with native element" do
+        expect {
+          described_class.render_into_document(React.create_element('div'))
+        }.to_not raise_error
+      end
+    end
+  end
+end