stimulus_reflex 3.4.0.pre8 → 3.5.0.pre1

data/lib/stimulus_reflex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StimulusReflex
-  VERSION = "3.4.0.pre8"
+  VERSION = "3.5.0.pre1"
 end

data/lib/tasks/stimulus_reflex/install.rake

@@ -6,9 +6,10 @@ require "stimulus_reflex/version"
 namespace :stimulus_reflex do
   desc "Install StimulusReflex in this application"
   task install: :environment do
-    system "bundle exec rails webpacker:install:stimulus"
+    system "rails dev:cache" unless Rails.root.join("tmp", "caching-dev.txt").exist?
     gem_version = StimulusReflex::VERSION.gsub(".pre", "-pre")
     system "yarn add stimulus_reflex@#{gem_version}"
+    system "bundle exec rails webpacker:install:stimulus"
     main_folder = defined?(Webpacker) ? Webpacker.config.source_path.to_s.gsub("#{Rails.root}/", "") : "app/javascript"
 
     FileUtils.mkdir_p Rails.root.join("#{main_folder}/controllers"), verbose: true
@@ -39,18 +40,20 @@ namespace :stimulus_reflex do
 
     unless lines.find { |line| line.start_with?("import controller") }
       matches = lines.select { |line| line =~ /\A(require|import)/ }
-      lines.insert lines.index(matches.last).to_i + 1, "import controller from './application_controller'\n"
+      lines.insert lines.index(matches.last).to_i + 1, "import controller from '../controllers/application_controller'\n"
     end
 
     initialize_line = lines.find { |line| line.start_with?("StimulusReflex.initialize") }
-    lines << "StimulusReflex.initialize(application, { consumer, controller, isolate: true })\n" unless initialize_line
+    lines << "application.consumer = consumer\n"
+    lines << "StimulusReflex.initialize(application, { controller, isolate: true })\n" unless initialize_line
     lines << "StimulusReflex.debug = process.env.RAILS_ENV === 'development'\n" unless initialize_line
     File.open(filepath, "w") { |f| f.write lines.join }
 
     filepath = Rails.root.join("config/environments/development.rb")
     lines = File.open(filepath, "r") { |f| f.readlines }
     unless lines.find { |line| line.include?("config.session_store") }
-      lines.insert 3, "  config.session_store :cache_store\n\n"
+      matches = lines.select { |line| line =~ /\A(Rails.application.configure do)/ }
+      lines.insert lines.index(matches.last).to_i + 1, "  config.session_store :cache_store\n\n"
       File.open(filepath, "w") { |f| f.write lines.join }
     end
 
@@ -60,13 +63,17 @@ namespace :stimulus_reflex do
       lines.delete_at 1
       lines.insert 1, "  adapter: redis\n"
       lines.insert 2, "  url: <%= ENV.fetch(\"REDIS_URL\") { \"redis://localhost:6379/1\" } %>\n"
-      lines.insert 3, "  channel_prefix: " + File.basename(Rails.root.to_s).underscore + "_development\n"
+      lines.insert 3, "  channel_prefix: " + File.basename(Rails.root.to_s).tr("\\", "").tr("-. ", "_").underscore + "_development\n"
       File.open(filepath, "w") { |f| f.write lines.join }
     end
 
     system "bundle exec rails generate stimulus_reflex example"
     puts "Generating default StimulusReflex configuration file into your application config/initializers directory"
-    system "bundle exec rails generate stimulus_reflex:config"
-    system "rails dev:cache" unless Rails.root.join("tmp", "caching-dev.txt").exist?
+    system "bundle exec rails generate stimulus_reflex:initializer"
+
+    puts
+    puts "StimulusReflex and CableReady have been successfully installed!"
+    puts "Go to https://docs.stimulusreflex.com/hello-world/quickstart if you need help getting started."
+    puts
   end
 end

data/test/broadcasters/broadcaster_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "broadcaster_test_case"
 
 class StimulusReflex::BroadcasterTest < StimulusReflex::BroadcasterTestCase

data/test/broadcasters/broadcaster_test_case.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "../test_helper"
 
 class StimulusReflex::BroadcasterTestCase < ActionCable::Channel::TestCase
@@ -8,6 +10,6 @@ class StimulusReflex::BroadcasterTestCase < ActionCable::Channel::TestCase
     def connection.env
       @env ||= {}
     end
-    @reflex = StimulusReflex::Reflex.new(subscribe, url: "https://test.stimulusreflex.com")
+    @reflex = StimulusReflex::Reflex.new(subscribe, url: "https://test.stimulusreflex.com", client_attributes: {reflex_id: "666"})
   end
 end

data/test/broadcasters/nothing_broadcaster_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "broadcaster_test_case"
 
 class StimulusReflex::NothingBroadcasterTest < StimulusReflex::BroadcasterTestCase
@@ -11,7 +13,8 @@ class StimulusReflex::NothingBroadcasterTest < StimulusReflex::BroadcasterTestCa
           {
             "name" => "stimulus-reflex:server-message",
             "detail" => {
-              "reflexId" => nil,
+              "reflexId" => "666",
+              "payload" => {},
               "stimulusReflex" => {
                 "some" => :data,
                 "morph" => :nothing,
@@ -20,14 +23,15 @@ class StimulusReflex::NothingBroadcasterTest < StimulusReflex::BroadcasterTestCa
                   "body" => nil
                 }
               }
-            }
+            },
+            "reflexId" => "666"
           }
         ]
       }
     }
 
     assert_broadcast_on @reflex.stream_name, expected do
-      broadcaster.broadcast nil, some: :data
+      broadcaster.broadcast nil, {:some => :data, "reflexId" => "666"}
     end
   end
 end

data/test/broadcasters/page_broadcaster_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "broadcaster_test_case"
 
 class StimulusReflex::PageBroadcasterTest < StimulusReflex::BroadcasterTestCase
@@ -10,7 +12,7 @@ class StimulusReflex::PageBroadcasterTest < StimulusReflex::BroadcasterTestCase
   test "performs a page morph on body" do
     class << @reflex.controller.response
       def body
-        "<html><head></head><body>New Content</body></html>"
+        "<html><head></head><body><div>New Content</div><div>Another Content</div></body></html>"
       end
     end
 
@@ -22,13 +24,15 @@ class StimulusReflex::PageBroadcasterTest < StimulusReflex::BroadcasterTestCase
         "morph" => [
           {
             "selector" => "body",
-            "html" => "New Content",
+            "html" => "<div>New Content</div><div>Another Content</div>",
+            "payload" => {},
             "childrenOnly" => true,
             "permanentAttributeName" => nil,
             "stimulusReflex" => {
               "some" => :data,
               "morph" => :page
-            }
+            },
+            "reflexId" => "666"
           }
         ]
       }
@@ -55,12 +59,14 @@ class StimulusReflex::PageBroadcasterTest < StimulusReflex::BroadcasterTestCase
           {
             "selector" => "#foo",
             "html" => "New Content",
+            "payload" => {},
             "childrenOnly" => true,
             "permanentAttributeName" => nil,
             "stimulusReflex" => {
               "some" => :data,
               "morph" => :page
-            }
+            },
+            "reflexId" => "666"
           }
         ]
       }

data/test/broadcasters/selector_broadcaster_test.rb

@@ -1,55 +1,173 @@
-# 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
+# frozen_string_literal: true
+
+require_relative "broadcaster_test_case"
+
+module StimulusReflex
+  class 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"><div>bar</div><div>baz</div></div>')
+
+      expected = {
+        "cableReady" => true,
+        "operations" => {
+          "morph" => [
+            {
+              "selector" => "#foo",
+              "html" => "<div>bar</div><div>baz</div>",
+              "payload" => {},
+              "childrenOnly" => true,
+              "permanentAttributeName" => nil,
+              "stimulusReflex" => {
+                "some" => "data",
+                "morph" => "selector"
+              },
+              "reflexId" => "666"
+            }
+          ]
+        }
+      }
+
+      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>',
+              "payload" => {},
+              "stimulusReflex" => {
+                "some" => "data",
+                "morph" => "selector"
+              },
+              "reflexId" => "666"
+            }
+          ]
+        }
+      }
+
+      assert_broadcast_on @reflex.stream_name, expected do
+        broadcaster.broadcast nil, some: :data
+      end
+    end
+
+    test "morphs the contents of an element to an empty string if no content specified" do
+      broadcaster = StimulusReflex::SelectorBroadcaster.new(@reflex)
+      broadcaster.append_morph("#foo", nil)
+
+      expected = {
+        "cableReady" => true,
+        "operations" => {
+          "innerHtml" => [
+            {
+              "selector" => "#foo",
+              "html" => "",
+              "payload" => {},
+              "stimulusReflex" => {
+                "some" => "data",
+                "morph" => "selector"
+              },
+              "reflexId" => "666"
+            }
+          ]
+        }
+      }
+
+      assert_broadcast_on @reflex.stream_name, expected do
+        broadcaster.broadcast nil, some: :data
+      end
+    end
+
+    test "morphs the contents of an element to an empty string if empty specified" do
+      broadcaster = StimulusReflex::SelectorBroadcaster.new(@reflex)
+      broadcaster.append_morph("#foo", "")
+
+      expected = {
+        "cableReady" => true,
+        "operations" => {
+          "innerHtml" => [
+            {
+              "selector" => "#foo",
+              "html" => "",
+              "payload" => {},
+              "stimulusReflex" => {
+                "some" => "data",
+                "morph" => "selector"
+              },
+              "reflexId" => "666"
+            }
+          ]
+        }
+      }
+
+      assert_broadcast_on @reflex.stream_name, expected do
+        broadcaster.broadcast nil, some: :data
+      end
+    end
+
+    test "morphs the contents of an element to an empty string if no content specified, hash form" do
+      broadcaster = StimulusReflex::SelectorBroadcaster.new(@reflex)
+      broadcaster.append_morph({"#foo": nil}, nil)
+
+      expected = {
+        "cableReady" => true,
+        "operations" => {
+          "innerHtml" => [
+            {
+              "selector" => "#foo",
+              "html" => "",
+              "payload" => {},
+              "stimulusReflex" => {
+                "some" => "data",
+                "morph" => "selector"
+              },
+              "reflexId" => "666"
+            }
+          ]
+        }
+      }
+
+      assert_broadcast_on @reflex.stream_name, expected do
+        broadcaster.broadcast nil, some: :data
+      end
+    end
+
+    test "morphs the contents of an element to specified HTML, hash form" do
+      broadcaster = StimulusReflex::SelectorBroadcaster.new(@reflex)
+      broadcaster.append_morph({"#foo": '<div id="foo"><div>bar</div><div>baz</div></div>'}, nil)
+
+      expected = {
+        "cableReady" => true,
+        "operations" => {
+          "morph" => [
+            {
+              "selector" => "#foo",
+              "html" => "<div>bar</div><div>baz</div>",
+              "payload" => {},
+              "childrenOnly" => true,
+              "permanentAttributeName" => nil,
+              "stimulusReflex" => {
+                "some" => "data",
+                "morph" => "selector"
+              },
+              "reflexId" => "666"
+            }
+          ]
+        }
+      }
+
+      assert_broadcast_on @reflex.stream_name, expected do
+        broadcaster.broadcast nil, some: :data
+      end
+    end
+  end
+end

data/test/callbacks_test.rb

@@ -0,0 +1,652 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+# standard:disable Lint/ConstantDefinitionInBlock
+
+class CallbacksTest < ActionCable::Channel::TestCase
+  tests StimulusReflex::Channel
+
+  setup do
+    stub_connection(session_id: SecureRandom.uuid)
+    def connection.env
+      @env ||= {}
+    end
+  end
+
+  test "basic before_reflex works" do
+    class BeforeCallbackReflex < StimulusReflex::Reflex
+      before_reflex :init_counter
+
+      def increment
+        @count += 1
+      end
+
+      private
+
+      def init_counter
+        @count = 5
+      end
+    end
+
+    reflex = BeforeCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 6, reflex.instance_variable_get("@count")
+  end
+
+  test "before_reflex with block works" do
+    class BeforeBlockCallbackReflex < StimulusReflex::Reflex
+      before_reflex do
+        @count = 5
+      end
+
+      def increment
+        @count += 1
+      end
+    end
+
+    reflex = BeforeBlockCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 6, reflex.instance_variable_get("@count")
+  end
+
+  test "basic after_reflex works" do
+    class AfterCallbackReflex < StimulusReflex::Reflex
+      after_reflex :reset
+
+      def increment
+        @count = 5
+      end
+
+      private
+
+      def reset
+        @count = 1
+      end
+    end
+
+    reflex = AfterCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 1, reflex.instance_variable_get("@count")
+  end
+
+  test "after_reflex with block works" do
+    class AfterBlockCallbackReflex < StimulusReflex::Reflex
+      after_reflex do
+        @count = 1
+      end
+
+      def increment
+        @count = 5
+      end
+    end
+
+    reflex = AfterBlockCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 1, reflex.instance_variable_get("@count")
+  end
+
+  test "basic around_reflex works" do
+    class AroundCallbackReflex < StimulusReflex::Reflex
+      around_reflex :around
+
+      def increment
+        @count += 8
+      end
+
+      private
+
+      def around
+        @count = 2
+        yield
+        @count += 4
+      end
+    end
+
+    reflex = AroundCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 14, reflex.instance_variable_get("@count")
+  end
+
+  test "execute methods in order" do
+    class CallbackOrderReflex < StimulusReflex::Reflex
+      before_reflex :one
+      before_reflex :two, :three
+
+      def increment
+      end
+
+      private
+
+      def one
+        @count = 1
+      end
+
+      def two
+        @count = 2 if @count == 1
+      end
+
+      def three
+        @count = 3 if @count == 2
+      end
+    end
+
+    reflex = CallbackOrderReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 3, reflex.instance_variable_get("@count")
+  end
+
+  test "basic if option works" do
+    class IfCallbackReflex < StimulusReflex::Reflex
+      before_reflex :init, if: :present
+      around_reflex :around, if: :blank
+      after_reflex :after, if: :present
+
+      def increment
+        @count += 8
+      end
+
+      private
+
+      def present
+        true
+      end
+
+      def blank
+        false
+      end
+
+      def init
+        @count = 5
+      end
+
+      def around
+        @count += 2
+        yield
+        @count += 4
+      end
+
+      def after
+        @count += 10
+      end
+    end
+
+    reflex = IfCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 23, reflex.instance_variable_get("@count")
+  end
+
+  test "if option with proc/lambda works" do
+    class IfProcCallbackReflex < StimulusReflex::Reflex
+      before_reflex :init, if: -> { true }
+      around_reflex :around, if: lambda { false }
+      after_reflex :after, if: proc { true }
+
+      def increment
+        @count += 8
+      end
+
+      private
+
+      def init
+        @count = 5
+      end
+
+      def around
+        @count += 2
+        yield
+        @count += 4
+      end
+
+      def after
+        @count += 10
+      end
+    end
+
+    reflex = IfProcCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 23, reflex.instance_variable_get("@count")
+  end
+
+  test "basic unless option works" do
+    class UnlessCallbackReflex < StimulusReflex::Reflex
+      before_reflex :init, unless: :blank
+      around_reflex :around, unless: :present
+      after_reflex :after, unless: :blank
+
+      def increment
+        @count += 8
+      end
+
+      private
+
+      def present
+        true
+      end
+
+      def blank
+        false
+      end
+
+      def init
+        @count = 5
+      end
+
+      def around
+        @count += 2
+        yield
+        @count += 4
+      end
+
+      def after
+        @count += 10
+      end
+    end
+
+    reflex = UnlessCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 23, reflex.instance_variable_get("@count")
+  end
+
+  test "unless option with proc/lambda works" do
+    class UnlessProcCallbackReflex < StimulusReflex::Reflex
+      before_reflex :init, unless: -> { false }
+      around_reflex :around, unless: lambda { true }
+      after_reflex :after, unless: proc { false }
+
+      def increment
+        @count += 8
+      end
+
+      private
+
+      def init
+        @count = 5
+      end
+
+      def around
+        @count += 2
+        yield
+        @count += 4
+      end
+
+      def after
+        @count += 10
+      end
+    end
+
+    reflex = UnlessProcCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 23, reflex.instance_variable_get("@count")
+  end
+
+  test "only option works" do
+    class OnlyCallbackReflex < StimulusReflex::Reflex
+      before_reflex :init
+      before_reflex :increment_bonus, only: :increment
+      before_reflex :decrement_bonus, only: [:decrement]
+
+      def increment
+        @count += 1
+      end
+
+      def decrement
+        @count -= 1
+      end
+
+      private
+
+      def init
+        @count = 0
+      end
+
+      def increment_bonus
+        @count += 5
+      end
+
+      def decrement_bonus
+        @count -= 7
+      end
+    end
+
+    reflex = OnlyCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :decrement)
+    reflex.process(:decrement)
+    assert_equal(-8, reflex.instance_variable_get("@count"))
+  end
+
+  test "except option works" do
+    class ExceptCallbackReflex < StimulusReflex::Reflex
+      before_reflex :init
+      before_reflex :increment_bonus, except: [:decrement]
+      before_reflex :decrement_bonus, except: :increment
+
+      def increment
+        @count += 1
+      end
+
+      def decrement
+        @count -= 1
+      end
+
+      private
+
+      def init
+        @count = 0
+      end
+
+      def increment_bonus
+        @count += 5
+      end
+
+      def decrement_bonus
+        @count -= 7
+      end
+    end
+
+    reflex = ExceptCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 6, reflex.instance_variable_get("@count")
+
+    reflex = ExceptCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :decrement)
+    reflex.process(:decrement)
+    assert_equal(-8, reflex.instance_variable_get("@count"))
+  end
+
+  test "skip_before_reflex works" do
+    class SkipBeforeCallbackReflex < StimulusReflex::Reflex
+      before_reflex :blowup
+      before_reflex :init_counter
+      before_reflex :bonus
+
+      skip_before_reflex :blowup
+      skip_before_reflex :init_counter, if: -> { false }
+      skip_before_reflex :bonus, if: -> { true }
+
+      def increment
+        @count += 1
+      end
+
+      private
+
+      def blowup
+        raise StandardError
+      end
+
+      def init_counter
+        @count = 5
+      end
+
+      def bonus
+        @count += 100
+      end
+    end
+
+    reflex = SkipBeforeCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 6, reflex.instance_variable_get("@count")
+  end
+
+  test "skip_after_reflex works" do
+    class SkipAfterCallbackReflex < StimulusReflex::Reflex
+      after_reflex :blowup
+      after_reflex :reset
+      after_reflex :clear
+
+      skip_after_reflex :blowup
+      skip_after_reflex :reset, if: -> { false }
+      skip_after_reflex :clear, if: -> { true }
+
+      def increment
+        @count = 0
+      end
+
+      private
+
+      def blowup
+        raise StandardError
+      end
+
+      def reset
+        @count += 1
+      end
+
+      def clear
+        @count += 10
+      end
+    end
+
+    reflex = SkipAfterCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 1, reflex.instance_variable_get("@count")
+  end
+
+  test "skip_around_reflex works" do
+    class SkipAroundCallbackReflex < StimulusReflex::Reflex
+      around_reflex :blowup
+      around_reflex :around
+      around_reflex :bonus
+
+      skip_around_reflex :blowup
+      skip_around_reflex :around, if: -> { false }
+      skip_around_reflex :bonus, if: -> { true }
+
+      def increment
+        @count += 2
+      end
+
+      private
+
+      def blowup
+        raise StandardError
+      end
+
+      def around
+        @count = 1
+        yield
+        @count += 4
+      end
+
+      def bonus
+        @count += 100
+        yield
+        @count += 1000
+      end
+    end
+
+    reflex = SkipAroundCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 7, reflex.instance_variable_get("@count")
+  end
+
+  test "skip_before_reflex works in inherited reflex" do
+    class SkipApplicationReflex < StimulusReflex::Reflex
+      before_reflex :blowup
+      before_reflex :init_counter
+
+      private
+
+      def blowup
+        raise StandardError
+      end
+
+      def init_counter
+        @count = 5
+      end
+    end
+
+    class InheritedSkipApplicationReflex < SkipApplicationReflex
+      skip_before_reflex :blowup
+
+      def increment
+        @count += 1
+      end
+    end
+
+    reflex = InheritedSkipApplicationReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 6, reflex.instance_variable_get("@count")
+  end
+
+  test "basic prepend_before_reflex works" do
+    class SimplePrependBeforeCallbackReflex < StimulusReflex::Reflex
+      before_reflex :two
+      prepend_before_reflex :one
+
+      def increment
+        @count += 1 if @count == 2
+      end
+
+      private
+
+      def one
+        @count = 1
+      end
+
+      def two
+        @count += 1 if @count == 1
+      end
+    end
+
+    reflex = SimplePrependBeforeCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 3, reflex.instance_variable_get("@count")
+  end
+
+  test "prepend_before_reflex with block works" do
+    class BlockPrependBeforeCallbackReflex < StimulusReflex::Reflex
+      before_reflex do
+        @count += 1 if @count == 1
+      end
+
+      prepend_before_reflex do
+        @count = 1
+      end
+
+      def increment
+        @count += 1 if @count == 2
+      end
+    end
+
+    reflex = BlockPrependBeforeCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 3, reflex.instance_variable_get("@count")
+  end
+
+  test "basic prepend_before_reflex works in inherited reflex" do
+    class PrependBeforeCallbackReflex < StimulusReflex::Reflex
+      before_reflex :two
+
+      def increment
+        @count += 5 if @count == 4
+      end
+
+      private
+
+      def two
+        @count += 3 if @count == 1
+      end
+    end
+
+    class InheritedPrependBeforeCallbackReflex < PrependBeforeCallbackReflex
+      prepend_before_reflex :one
+
+      private
+
+      def one
+        @count = 1
+      end
+    end
+
+    reflex = InheritedPrependBeforeCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 9, reflex.instance_variable_get("@count")
+  end
+
+  test "basic prepend_around_reflex works" do
+    class SimplePrependAroundCallbackReflex < StimulusReflex::Reflex
+      around_reflex :two
+      prepend_around_reflex :one
+
+      def increment
+        @count += 10
+      end
+
+      private
+
+      def one
+        @count = 1
+        yield
+        @count += 3 if @count == 23
+      end
+
+      def two
+        @count += 5 if @count == 1
+        yield
+        @count += 7 if @count == 16
+      end
+    end
+
+    reflex = SimplePrependAroundCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 26, reflex.instance_variable_get("@count")
+  end
+
+  test "basic prepend_after_reflex works" do
+    class SimplePrependAfterCallbackReflex < StimulusReflex::Reflex
+      after_reflex :two
+      prepend_after_reflex :one
+
+      def increment
+        @count = 1
+      end
+
+      private
+
+      def one
+        @count += 3 if @count == 6
+      end
+
+      def two
+        @count += 5 if @count == 1
+      end
+    end
+
+    reflex = SimplePrependAfterCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 9, reflex.instance_variable_get("@count")
+  end
+
+  test "append before_, around_ and after_reflex works" do
+    class AppendCallbackReflex < StimulusReflex::Reflex
+      append_before_reflex :before
+      append_around_reflex :around
+      append_after_reflex :after
+
+      def increment
+        @count += 5 if @count == 4
+      end
+
+      private
+
+      def before
+        @count = 1 unless @counts
+      end
+
+      def around
+        @count += 3 if @count == 1
+        yield
+        @count += 9 if @count == 16
+      end
+
+      def after
+        @count += 7 if @count == 9
+      end
+    end
+
+    reflex = AppendCallbackReflex.new(subscribe, url: "https://test.stimulusreflex.com", method_name: :increment)
+    reflex.process(:increment)
+    assert_equal 25, reflex.instance_variable_get("@count")
+  end
+end
+
+# standard:enable Lint/ConstantDefinitionInBlock