stimulus_reflex 3.4.0.pre5 → 3.4.0

data/test/broadcasters/broadcaster_test.rb

@@ -1,11 +1,8 @@
-require_relative "../test_helper"
+# frozen_string_literal: true
 
-class StimulusReflex::BroadcasterTest < ActiveSupport::TestCase
-  setup do
-    @reflex = Minitest::Mock.new
-    @reflex.expect :stream_name, "TestStream"
-  end
+require_relative "broadcaster_test_case"
 
+class StimulusReflex::BroadcasterTest < StimulusReflex::BroadcasterTestCase
   test "raises a NotImplementedError if called directly" do
     broadcaster = StimulusReflex::Broadcaster.new(@reflex)
 

data/test/broadcasters/broadcaster_test_case.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class StimulusReflex::BroadcasterTestCase < ActionCable::Channel::TestCase
+  tests StimulusReflex::Channel
+
+  setup do
+    stub_connection(session_id: SecureRandom.uuid)
+    def connection.env
+      @env ||= {}
+    end
+    @reflex = StimulusReflex::Reflex.new(subscribe, url: "https://test.stimulusreflex.com")
+  end
+end

data/test/broadcasters/nothing_broadcaster_test.rb

@@ -1,34 +1,35 @@
-require_relative "../test_helper"
+# frozen_string_literal: true
 
-class StimulusReflex::NothingBroadcasterTest < ActiveSupport::TestCase
-  setup do
-    @reflex = Minitest::Mock.new
-    @reflex.expect :stream_name, "TestStream"
-  end
+require_relative "broadcaster_test_case"
 
+class StimulusReflex::NothingBroadcasterTest < StimulusReflex::BroadcasterTestCase
   test "broadcasts a server message when called" do
     broadcaster = StimulusReflex::NothingBroadcaster.new(@reflex)
 
-    cable_ready_channels = Minitest::Mock.new
-    cable_ready_channel = Minitest::Mock.new
-    CableReady::Channels.stub :instance, cable_ready_channels do
-      cable_ready_channel.expect(:dispatch_event, nil, [{name: "stimulus-reflex:server-message",
-                                                         detail: {
-                                                           reflexId: nil,
-                                                           stimulus_reflex: {
-                                                             some: :data,
-                                                             morph: :nothing,
-                                                             server_message: {
-                                                               subject: "nothing", body: nil
-                                                             }
-                                                           }
-                                                         }}])
-      cable_ready_channels.expect(:[], cable_ready_channel, ["TestStream"])
-      cable_ready_channels.expect(:broadcast, nil)
-      broadcaster.broadcast(nil, {some: :data})
-    end
+    expected = {
+      "cableReady" => true,
+      "operations" => {
+        "dispatchEvent" => [
+          {
+            "name" => "stimulus-reflex:server-message",
+            "detail" => {
+              "reflexId" => nil,
+              "stimulusReflex" => {
+                "some" => :data,
+                "morph" => :nothing,
+                "serverMessage" => {
+                  "subject" => "nothing",
+                  "body" => nil
+                }
+              }
+            }
+          }
+        ]
+      }
+    }
 
-    assert_mock cable_ready_channels
-    assert_mock cable_ready_channel
+    assert_broadcast_on @reflex.stream_name, expected do
+      broadcaster.broadcast nil, some: :data
+    end
   end
 end

data/test/broadcasters/page_broadcaster_test.rb

@@ -1,69 +1,75 @@
-require_relative "../test_helper"
+# frozen_string_literal: true
 
-class StimulusReflex::PageBroadcasterTest < ActiveSupport::TestCase
-  setup do
-    @reflex = Minitest::Mock.new
-    @reflex.expect :params, {action: "show"}
-    @reflex.expect :stream_name, "TestStream"
-    @reflex.expect :permanent_attribute_name, "some-attribute"
-  end
+require_relative "broadcaster_test_case"
 
+class StimulusReflex::PageBroadcasterTest < StimulusReflex::BroadcasterTestCase
   test "returns if the response html is empty" do
-    controller = Minitest::Mock.new
-    controller.expect(:process, nil, ["show"])
-    @reflex.expect :controller, controller
-    @reflex.expect :controller, controller
+    broadcaster = StimulusReflex::PageBroadcaster.new(@reflex)
+    broadcaster.broadcast(["#foo"], {some: :data})
+    # TODO: figure out how to refute_broadcast_on
+  end
 
-    # stub the controller response with a struct responding to :body
-    controller.expect(:response, Struct.new(:body).new(nil))
+  test "performs a page morph on body" do
+    class << @reflex.controller.response
+      def body
+        "<html><head></head><body>New Content</body></html>"
+      end
+    end
 
     broadcaster = StimulusReflex::PageBroadcaster.new(@reflex)
 
-    cable_ready_channels = Minitest::Mock.new
-    cable_ready_channels.expect(:broadcast, nil)
-
-    broadcaster.broadcast(["#foo"], {some: :data})
+    expected = {
+      "cableReady" => true,
+      "operations" => {
+        "morph" => [
+          {
+            "selector" => "body",
+            "html" => "New Content",
+            "childrenOnly" => true,
+            "permanentAttributeName" => nil,
+            "stimulusReflex" => {
+              "some" => :data,
+              "morph" => :page
+            }
+          }
+        ]
+      }
+    }
 
-    assert_raises { cable_ready_channels.verify }
+    assert_broadcast_on @reflex.stream_name, expected do
+      broadcaster.broadcast(["body"], {some: :data})
+    end
   end
 
   test "performs a page morph given an array of reflex root selectors" do
-    controller = Minitest::Mock.new
-    controller.expect(:process, nil, ["show"])
-    @reflex.expect :controller, controller
-    @reflex.expect :controller, controller
-
-    # stub the controller response with a struct responding to :body
-    controller.expect(:response, Struct.new(:body).new("<html></html>"))
+    class << @reflex.controller.response
+      def body
+        "<html><head></head><body><div id=\"foo\">New Content</div></body></html>"
+      end
+    end
 
     broadcaster = StimulusReflex::PageBroadcaster.new(@reflex)
 
-    cable_ready_channels = Minitest::Mock.new
-    cable_ready_channel = Minitest::Mock.new
-    document = Minitest::Mock.new
-    Nokogiri::HTML.stub :parse, document do
-      document.expect(:css, "something that is present", ["#foo"])
-      document.expect(:css, Struct.new(:inner_html).new("<span>bar</span>"), ["#foo"])
-
-      CableReady::Channels.stub :instance, cable_ready_channels do
-        cable_ready_channel.expect(:morph, nil, [{
-          selector: "#foo",
-          html: "<span>bar</span>",
-          children_only: true,
-          permanent_attribute_name: "some-attribute",
-          stimulus_reflex: {
-            some: :data,
-            morph: :page
+    expected = {
+      "cableReady" => true,
+      "operations" => {
+        "morph" => [
+          {
+            "selector" => "#foo",
+            "html" => "New Content",
+            "childrenOnly" => true,
+            "permanentAttributeName" => nil,
+            "stimulusReflex" => {
+              "some" => :data,
+              "morph" => :page
+            }
           }
-        }])
-        cable_ready_channels.expect(:[], cable_ready_channel, ["TestStream"])
-        cable_ready_channels.expect(:broadcast, nil)
+        ]
+      }
+    }
 
-        broadcaster.broadcast(["#foo"], {some: :data})
-      end
+    assert_broadcast_on @reflex.stream_name, expected do
+      broadcaster.broadcast(["#foo"], {some: :data})
     end
-
-    assert_mock cable_ready_channels
-    assert_mock cable_ready_channel
   end
 end

data/test/broadcasters/selector_broadcaster_test.rb

@@ -1,83 +1,57 @@
-require_relative "../test_helper"
-
-class StimulusReflex::SelectorBroadcasterTest < ActiveSupport::TestCase
-  setup do
-    @reflex = Minitest::Mock.new
-    @reflex.expect :stream_name, "TestStream"
-    @reflex.expect :permanent_attribute_name, "some-attribute"
-  end
-
-  test "morphs the contents of an element if the selector(s) are present in both original and morphed html fragments" do
-    broadcaster = StimulusReflex::SelectorBroadcaster.new(@reflex)
-
-    cable_ready_channels = Minitest::Mock.new
-    cable_ready_channel = Minitest::Mock.new
-    fragment = Minitest::Mock.new
-    match = Minitest::Mock.new
-    Nokogiri::HTML.stub :fragment, fragment do
-      fragment.expect(:at_css, match, ["#foo"])
-      match.expect(:present?, true)
-
-      # we need to mock `!`, because `blank?` returns
-      # respond_to?(:empty?) ? !!empty? : !self
-      match.expect(:!, false)
-      match.expect(:inner_html, "<span>bar</span>")
-      CableReady::Channels.stub :instance, cable_ready_channels do
-        broadcaster.append_morph("#foo", "<div id=\"foo\"><span>bar</span></div>")
-        cable_ready_channel.expect(:morph, nil, [{
-          selector: "#foo",
-          html: "<span>bar</span>",
-          children_only: true,
-          permanent_attribute_name: "some-attribute",
-          stimulus_reflex: {
-            some: :data,
-            morph: :selector
-          }
-        }])
-        cable_ready_channels.expect(:[], cable_ready_channel, ["TestStream"])
-        cable_ready_channels.expect(:broadcast, nil)
-
-        broadcaster.broadcast(nil, {some: :data})
-      end
-    end
-
-    assert_mock cable_ready_channels
-    assert_mock cable_ready_channel
-  end
-
-  test "replaces the contents of an element and ignores permanent-attributes if the selector(s) aren't present in the replacing html fragment" do
-    broadcaster = StimulusReflex::SelectorBroadcaster.new(@reflex)
-
-    cable_ready_channels = Minitest::Mock.new
-    cable_ready_channel = Minitest::Mock.new
-    fragment = Minitest::Mock.new
-    match = Minitest::Mock.new
-    Nokogiri::HTML.stub :fragment, fragment do
-      fragment.expect(:at_css, match, ["#foo"])
-      fragment.expect(:to_html, "<div id=\"baz\"><span>bar</span></div>")
-      match.expect(:present?, false)
-
-      # we need to mock `!`, because `blank?` returns
-      # respond_to?(:empty?) ? !!empty? : !self
-      match.expect(:!, true)
-      CableReady::Channels.stub :instance, cable_ready_channels do
-        broadcaster.append_morph("#foo", "<div id=\"baz\"><span>bar</span></div>")
-        cable_ready_channel.expect(:inner_html, nil, [{
-          selector: "#foo",
-          html: "<div id=\"baz\"><span>bar</span></div>",
-          stimulus_reflex: {
-            some: :data,
-            morph: :selector
-          }
-        }])
-        cable_ready_channels.expect(:[], cable_ready_channel, ["TestStream"])
-        cable_ready_channels.expect(:broadcast, nil)
-
-        broadcaster.broadcast(nil, {some: :data})
-      end
-    end
-
-    assert_mock cable_ready_channels
-    assert_mock cable_ready_channel
-  end
-end
+# frozen_string_literal: true
+
+# require_relative "broadcaster_test_case"
+
+# class StimulusReflex::SelectorBroadcasterTest < StimulusReflex::BroadcasterTestCase
+# test "morphs the contents of an element if the selector(s) are present in both original and morphed html fragments" do
+# broadcaster = StimulusReflex::SelectorBroadcaster.new(@reflex)
+# broadcaster.append_morph("#foo", "<div id=\"foo\"><span>bar</span></div>")
+
+# expected = {
+# "cableReady" => true,
+# "operations" => {
+# "morph" => [
+# {
+# "selector" => "#foo",
+# "html" => "<span>bar</span>",
+# "childrenOnly" => true,
+# "permanentAttributeName" => nil,
+# "stimulusReflex" => {
+# "some" => :data,
+# "morph" => :selector
+# }
+# }
+# ]
+# }
+# }
+
+# assert_broadcast_on @reflex.stream_name, expected do
+# broadcaster.broadcast nil, some: :data
+# end
+# end
+
+# test "replaces the contents of an element and ignores permanent-attributes if the selector(s) aren't present in the replacing html fragment" do
+# broadcaster = StimulusReflex::SelectorBroadcaster.new(@reflex)
+# broadcaster.append_morph("#foo", "<div id=\"baz\"><span>bar</span></div>")
+
+# expected = {
+# "cableReady" => true,
+# "operations" => {
+# "innerHtml" => [
+# {
+# "selector" => "#foo",
+# "html" => "<div id=\"baz\"><span>bar</span></div>",
+# "stimulusReflex" => {
+# "some" => :data,
+# "morph" => :selector
+# }
+# }
+# ]
+# }
+# }
+
+# assert_broadcast_on @reflex.stream_name, expected do
+# broadcaster.broadcast nil, some: :data
+# end
+# end
+# end

data/test/reflex_test.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class StimulusReflex::ReflexTest < ActionCable::Channel::TestCase
+  tests StimulusReflex::Channel
+
+  setup do
+    stub_connection(session_id: SecureRandom.uuid)
+    def connection.env
+      @env ||= {}
+    end
+    @reflex = StimulusReflex::Reflex.new(subscribe, url: "https://test.stimulusreflex.com")
+    @reflex.controller_class.view_paths << Rails.root.join("test/views")
+  end
+
+  test "render plain" do
+    assert @reflex.render(plain: "Some text") == "Some text"
+  end
+
+  test "render template" do
+    assert @reflex.render("/hello_template", assigns: {message: "Testing 123"}) == "<p>Hello from template! Testing 123</p>\n"
+  end
+
+  test "render partial" do
+    assert @reflex.render(partial: "/hello_partial", assigns: {message: "Testing 123"}) == "<p>Hello from partial! Testing 123</p>\n"
+  end
+
+  test "dom_id" do
+    assert @reflex.dom_id(TestModel.new(id: 123)) == "test_model_123"
+  end
+end

data/test/test_helper.rb

@@ -1,6 +1,47 @@
 # frozen_string_literal: true
 
-require "minitest/mock"
-
 ENV["RAILS_ENV"] ||= "test"
+
+require "minitest/mock"
+require "rails"
+require "active_model"
+require "action_controller"
+require "pry"
 require_relative "../lib/stimulus_reflex"
+
+class TestApp < Rails::Application
+  routes.draw { root to: "test#index" }
+end
+
+class ApplicationController < ActionController::Base; end
+
+class TestController < ApplicationController
+  include Rails.application.routes.url_helpers
+
+  def index
+    head :ok
+  end
+end
+
+class SessionMock
+  def load!
+    nil
+  end
+end
+
+class ActionDispatch::Request
+  def session
+    @session ||= SessionMock.new
+  end
+end
+
+class TestModel
+  include ActiveModel::Model
+  attr_accessor :id
+end
+
+StimulusReflex.configuration.parent_channel = "ActionCable::Channel::Base"
+ActionCable::Server::Base.config.cable = {adapter: "test"}
+ActionCable::Server::Base.config.logger = Logger.new(nil)
+
+require_relative "../app/channels/stimulus_reflex/channel"

data/test/tmp/app/reflexes/application_reflex.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 class ApplicationReflex < StimulusReflex::Reflex
-  # Put application wide Reflex behavior in this file.
+  # Put application-wide Reflex behavior and callbacks in this file.
   #
   # Example:
   #
   #   # If your ActionCable connection is: `identified_by :current_user`
   #   delegate :current_user, to: :connection
   #
-  # Learn more at: https://docs.stimulusreflex.com
+  # Learn more at: https://docs.stimulusreflex.com/reflexes#reflex-classes
 end