Clean up testing

Author: zetachang

lib/react/testing.rb

@@ -0,0 +1,14 @@
+module React
+  module Testing
+    `var ReactTestUtils = React.addons.TestUtils`
+    
+    def simulate_event(event_name, dom_element, event_data = {})
+      simulator = Native(`ReactTestUtils.Simulate`)
+      simulator[event_name].call(dom_element, event_data)
+    end
+    
+    def render_to_document(element)
+      `ReactTestUtils.renderIntoDocument(element)`
+    end
+  end
+end

spec/component_spec.rb

@@ -1,10 +1,6 @@
 require "spec_helper"
 
 describe React::Component do
-  after(:each) do
-    React::ComponentFactory.clear_component_class_cache
-  end
-
   it "should define component spec methods" do
     stub_const 'Foo', Class.new
     Foo.class_eval do
@@ -50,7 +46,7 @@ def bar2; end
       expect_any_instance_of(Foo).to receive(:bar)
       expect_any_instance_of(Foo).to receive(:bar2)
 
-      renderToDocument(Foo)
+      render_to_document(React.create_element(Foo))
     end
 
     it "should invoke `after_mount` registered methods when `componentDidMount()`" do
@@ -63,7 +59,7 @@ def bar4; end
       expect_any_instance_of(Foo).to receive(:bar3)
       expect_any_instance_of(Foo).to receive(:bar4)
 
-      renderToDocument(Foo)
+      render_to_document(React.create_element(Foo))
     end
 
     it "should allow multiple class declared life cycle hooker" do
@@ -84,7 +80,7 @@ def render
 
       expect_any_instance_of(Foo).to receive(:bar)
 
-      renderToDocument(Foo)
+      render_to_document(React.create_element(Foo))
     end
 
     it "should allow block for life cycle callback" do
@@ -96,8 +92,8 @@ def render
         end
       end
 
-      element = renderToDocument(Foo)
-      expect(element.state[:foo]).to be("bar")
+      instance = render_to_document(React.create_element(Foo))
+      expect(instance.state[:foo]).to be("bar")
     end
   end
 
@@ -121,17 +117,17 @@ def set_up
         end
       end
 
-      element = renderToDocument(Foo)
-      expect(element.state[:foo]).to be("bar")
+      instance = render_to_document(React.create_element(Foo))
+      expect(instance.state[:foo]).to be("bar")
     end
 
     it "should define init state by passing a block to `define_state`" do
       Foo.class_eval do
         define_state(:foo) { 10 }
       end
 
-      element = renderToDocument(Foo)
-      expect(element.state[:foo]).to be(10)
+      instance = render_to_document(React.create_element(Foo))
+      expect(instance.state[:foo]).to be(10)
     end
 
     it "should define getter using `define_state`" do
@@ -143,8 +139,8 @@ def bump
         end
       end
 
-      element = renderToDocument(Foo)
-      expect(element.state[:foo]).to be(30)
+      instance = render_to_document(React.create_element(Foo))
+      expect(instance.state[:foo]).to be(30)
     end
 
     it "should define multiple state accessor by passing symols array to `define_state`" do
@@ -157,9 +153,9 @@ def set_up
         end
       end
 
-      element = renderToDocument(Foo)
-      expect(element.state[:foo]).to be(10)
-      expect(element.state[:foo2]).to be(20)
+      instance = render_to_document(React.create_element(Foo))
+      expect(instance.state[:foo]).to be(10)
+      expect(instance.state[:foo2]).to be(20)
     end
 
     it "should invoke `define_state` multiple times to define states" do
@@ -168,9 +164,9 @@ def set_up
         define_state(:foo2) { 40 }
       end
 
-      element = renderToDocument(Foo)
-      expect(element.state[:foo]).to be(30)
-      expect(element.state[:foo2]).to be(40)
+      instance = render_to_document(React.create_element(Foo))
+      expect(instance.state[:foo]).to be(30)
+      expect(instance.state[:foo2]).to be(40)
     end
 
     it "should raise error if multiple states and block given at the same time" do
@@ -189,8 +185,8 @@ def render
         end
       end
 
-      element = renderToDocument(Foo)
-      expect(element.dom_node.textContent).to eq("10")
+      instance = render_to_document(React.create_element(Foo))
+      expect(instance.dom_node.textContent).to eq("10")
     end
 
     it "should support original `setState` as `set_state` method" do
@@ -200,8 +196,8 @@ def render
         end
       end
 
-      element = renderToDocument(Foo)
-      expect(element.state[:foo]).to be("bar")
+      instance = render_to_document(React.create_element(Foo))
+      expect(instance.state[:foo]).to be("bar")
     end
 
     it "should support originl `state` method" do
@@ -251,8 +247,8 @@ def render
           end
         end
 
-        element = renderToDocument(Foo, prop: "foobar")
-        expect(element.dom_node.textContent).to eq("foobar")
+        instance = render_to_document(React.create_element(Foo, prop: "foobar"))
+        expect(instance.dom_node.textContent).to eq("foobar")
       end
 
       it "should access nested params as orignal Ruby object" do
@@ -262,8 +258,8 @@ def render
           end
         end
 
-        element = renderToDocument(Foo, prop: [{foo: 10}])
-        expect(element.dom_node.textContent).to eq("10")
+        instance = render_to_document(React.create_element(Foo, prop: [{foo: 10}]))
+        expect(instance.dom_node.textContent).to eq("10")
       end
     end
 
@@ -303,7 +299,7 @@ def render; div; end
           var org_console = window.console;
           window.console = {warn: function(str){log.push(str)}}
         }
-        renderToDocument(Foo, bar: 10, lorem: Lorem.new)
+        render_to_document(React.create_element(Foo, bar: 10, lorem: Lorem.new))
         `window.console = org_console;`
         expect(`log`).to eq(["Warning: Failed propType: In component `Foo`\nRequired prop `foo` was not specified\nProvided prop `bar` was not the specified type `String`"])
       end
@@ -325,7 +321,7 @@ def render; div; end
           var org_console = window.console;
           window.console = {warn: function(str){log.push(str)}}
         }
-        renderToDocument(Foo, foo: 10, bar: "10", lorem: Lorem.new)
+        render_to_document(React.create_element(Foo, foo: 10, bar: "10", lorem: Lorem.new))
         `window.console = org_console;`
         expect(`log`).to eq([])
       end
@@ -371,9 +367,8 @@ def render
         end
       end
 
-      element = React.create_element(Foo)
-      instance = renderElementToDocument(element)
-      simulateEvent(:click, instance)
+      instance = render_to_document(React.create_element(Foo))
+      simulate_event(:click, React.find_dom_node(instance))
       expect(instance.state[:clicked]).to eq(true)
     end
 
@@ -392,7 +387,7 @@ def render
 
       expect { |b|
         element = React.create_element(Foo).on(:foo_submit, &b)
-        renderElementToDocument(element)
+        render_to_document(element)
       }.to yield_with_args("bar")
     end
 
@@ -411,7 +406,7 @@ def render
 
       expect { |b|
         element = React.create_element(Foo).on(:foo_invoked, &b)
-        renderElementToDocument(element)
+        render_to_document(element)
       }.to yield_with_args([1,2,3], "bar")
     end
   end
@@ -431,8 +426,8 @@ def render
         end
       end
 
-      element = renderToDocument(Foo)
-      expect(element.refs[:field]).not_to be_nil
+      instance = render_to_document(React.create_element(Foo))
+      expect(instance.refs[:field]).not_to be_nil
     end
 
     it "should access refs through `refs` method" do
@@ -444,10 +439,10 @@ def render
         end
       end
 
-      element = renderToDocument(Foo)
-      simulateEvent(:click, element)
+      instance = render_to_document(React.create_element(Foo))
+      simulate_event(:click, React.find_dom_node(instance))
 
-      expect(element.refs[:field].value).to eq("some_stuff")
+      expect(instance.refs[:field].value).to eq("some_stuff")
     end
   end
 
@@ -529,7 +524,7 @@ def render
 
       expect(Kernel).to receive(:p).with("first")
       expect(Kernel).to receive(:p).with("second")
-      renderToDocument(Foo)
+      render_to_document(React.create_element(Foo))
     end
   end
 end

spec/element_spec.rb

@@ -54,20 +54,20 @@
     it "should be subscribable through `on(:event_name)` method" do
       expect { |b|
         element = React.create_element("div").on(:click, &b)
-        instance = renderElementToDocument(element)
-        simulateEvent(:click, instance)
+        instance = render_to_document(element)
+        simulate_event(:click, React.find_dom_node(instance))
       }.to yield_with_args(React::Event)
 
       expect { |b|
         element = React.create_element("div").on(:key_down, &b)
-        instance = renderElementToDocument(element)
-        simulateEvent(:keyDown, instance, {key: "Enter"})
+        instance = render_to_document(element)
+        simulate_event(:keyDown, React.find_dom_node(instance), {key: "Enter"})
       }.to yield_control
 
       expect { |b|
         element = React.create_element("form").on(:submit, &b)
-        instance = renderElementToDocument(element)
-        simulateEvent(:submit, instance, {})
+        instance = render_to_document(element)
+        simulate_event(:submit, React.find_dom_node(instance), {})
       }.to yield_control
     end
 

spec/event_spec.rb

@@ -16,7 +16,7 @@
       expect(event).to respond_to(:prevent_default)
       expect(event).to respond_to(:stop_propagation)
     end
-    instance = renderElementToDocument(element)
-    simulateEvent(:click, instance)
+    instance = render_to_document(element)
+    simulate_event(:click, React.find_dom_node(instance))
   end
-end
+end

spec/react_spec.rb

@@ -1,10 +1,6 @@
 require "spec_helper"
 
 describe React do
-  after(:each) do
-    React::ComponentFactory.clear_component_class_cache
-  end
-
   describe "is_valid_element" do
     it "should return true if passed a valid element" do
       element = `React.createElement('div')`
@@ -105,8 +101,8 @@ def render
           end
         end
 
-        renderToDocument(Foo)
-        renderToDocument(Foo)
+        render_to_document(React.create_element(Foo))
+        render_to_document(React.create_element(Foo))
 
         expect(`count`).to eq(2)
       end

spec/spec_helper.rb

@@ -1,27 +1,9 @@
 require 'react'
-
-module ReactTestHelpers
-  `var ReactTestUtils = React.addons.TestUtils`
-
-  def renderToDocument(type, options = {})
-    element = React.create_element(type, options)
-    return renderElementToDocument(element)
-  end
-
-  def renderElementToDocument(element)
-    `ReactTestUtils.renderIntoDocument(#{element})`
-  end
-
-  def simulateEvent(event, component, params = {})
-    simulator = Native(`ReactTestUtils.Simulate`)
-    simulator[event.to_s].call(`React.findDOMNode(#{component})`, params)
-  end
-
-  def isElementOfType(element, type)
-    `React.addons.TestUtils.isElementOfType(#{element}, #{type.cached_component_class})`
-  end
-end
+require 'react/testing'
 
 RSpec.configure do |config|
-  config.include ReactTestHelpers
+  config.include React::Testing
+  config.after :each do
+    React::ComponentFactory.clear_component_class_cache
+  end
 end