render_turbo_stream 3.0.4 → 4.0.0

data/lib/render_turbo_stream/test/request/channel_helpers.rb

@@ -9,29 +9,57 @@ module RenderTurboStream
 
           channel = "authenticated-user-#{user.id}"
 
-          libs = RenderTurboStream::Test::Request::Libs
+          libs = RenderTurboStream::Test::Request::Libs.new(response)
 
-          r = libs.select_responses(response, channel, target_id, action, type: :channel, &block)
+          r = libs.select_responses(channel, RenderTurboStream::Libs.target_id_to_target(target_id), action, &block)
 
           assert(
             r[:responses].length == count,
-            libs.assert_error_message(count, r[:responses].length, r[:log])
+            libs.class.assert_error_message(count, r[:responses].length, r[:log])
+          )
+        end
+
+        def assert_action_to_me(user, action, count: 1, &block)
+
+          channel = "authenticated-user-#{user.id}"
+
+          libs = RenderTurboStream::Test::Request::Libs.new(response)
+
+          r = libs.select_actions(channel, action, &block)
+
+          assert(
+            r[:responses].length == count,
+            libs.class.assert_error_message(count, r[:responses].length, r[:log])
           )
         end
 
         # Assert a action by turbo streams channel to a group of authenticated users
 
-        def assert_channel_to_authenticated_group(group, target_id, action: nil, count: 1, &block)
+        def assert_channel_to_authenticated_group(group, target_id, count: 1, &block)
+
+          channel = "authenticated-group-#{group}"
+
+          libs = RenderTurboStream::Test::Request::Libs.new(response)
+
+          r = libs.select_responses(channel, target_id, action, &block)
+
+          assert(
+            r[:responses].length == count,
+            libs.class.assert_error_message(count, r[:responses].length, r[:log])
+          )
+        end
+
+        def assert_action_to_authenticated_group(group, action, count: 1, &block)
 
           channel = "authenticated-group-#{group}"
 
-          libs = RenderTurboStream::Test::Request::Libs
+          libs = RenderTurboStream::Test::Request::Libs.new(response)
 
-          r = libs.select_responses(response, channel, target_id, action, type: :channel, &block)
+          r = libs.select_actions(channel, action, &block)
 
           assert(
             r[:responses].length == count,
-            libs.assert_error_message(count, r[:responses].length, r[:log])
+            libs.class.assert_error_message(count, r[:responses].length, r[:log])
           )
         end
 
@@ -39,13 +67,25 @@ module RenderTurboStream
 
         def assert_channel_to_all(target_id, action: nil, count: 1, &block)
 
-          libs = RenderTurboStream::Test::Request::Libs
+          libs = RenderTurboStream::Test::Request::Libs.new(response)
+
+          r = libs.select_responses('all', RenderTurboStream::Libs.target_id_to_target(target_id), action, &block)
+
+          assert(
+            r[:responses].length == count,
+            libs.class.assert_error_message(count, r[:responses].length, r[:log])
+          )
+        end
+
+        def assert_action_to_all(action, count: 1, &block)
+
+          libs = RenderTurboStream::Test::Request::Libs.new(response)
 
-          r = libs.select_responses(response, 'all', target_id, action, type: :channel, &block)
+          r = libs.select_actions('all', action, &block)
 
           assert(
             r[:responses].length == count,
-            libs.assert_error_message(count, r[:responses].length, r[:log])
+            libs.class.assert_error_message(count, r[:responses].length, r[:log])
           )
         end
 

data/lib/render_turbo_stream/test/request/helpers.rb

@@ -6,7 +6,7 @@ module RenderTurboStream
         # Assert that each of given target_ids is targeted exactly once
 
         def assert_once_targeted(*target_ids)
-          responses = RenderTurboStream::Test::Request::Libs.all_turbo_responses(response)
+          responses = RenderTurboStream::Test::Request::Libs.new(response).all_turbo_responses
           id_counts = {}
           responses.each do |r|
             if r['target'].is_a?(Array)
@@ -33,17 +33,17 @@ module RenderTurboStream
         # Helper for the developer for writing tests: Array with all attributes of all turbo-stream and turbo-channel actions that runned on the last request
 
         def all_turbo_responses
-          RenderTurboStream::Test::Request::Libs.all_turbo_responses(response)
+          RenderTurboStream::Test::Request::Libs.new(response).all_turbo_responses
         end
 
         # Returns Array of all target_ids that arre affected at least once on the last response
         def turbo_targets
-          RenderTurboStream::Test::Request::Libs.turbo_targets(response)
+          RenderTurboStream::Test::Request::Libs.new(response).turbo_targets
         end
 
         # Returns the path sent to turbo_stream.redirect_to.
-        def turbo_redirect_to
-          resps = RenderTurboStream::Test::Request::Libs.all_turbo_responses(response)
+        def assert_turbo_redirect_to(path)
+          resps = RenderTurboStream::Test::Request::Libs.new(response).all_turbo_responses
           url = nil
           resps.each do |r|
             if r['type'] == 'stream-command'
@@ -56,19 +56,31 @@ module RenderTurboStream
               end
             end
           end
-          url
+          assert url == path, "Expected turbo_redirect_to «#{path}» but got: «#{url}»"
         end
 
         # assert one or more specific actions to a target_id
-        def assert_stream_response(target_id, action: nil, count: 1, type: :stream, &block)
+        def assert_stream_response(target_id, action: nil, count: 1, &block)
 
-          libs = RenderTurboStream::Test::Request::Libs
+          libs = RenderTurboStream::Test::Request::Libs.new(response)
 
-          r = libs.select_responses(response, false, target_id, action, type: type, &block)
+          r = libs.select_responses( false, RenderTurboStream::Libs.target_id_to_target(target_id), action, &block)
 
           assert(
             r[:responses].length == count,
-            libs.assert_error_message(count, r[:responses].length, r[:log])
+            libs.class.assert_error_message(count, r[:responses].length, r[:log])
+          )
+        end
+
+        def assert_stream_action(action, target_id: nil, count: 1, &block)
+
+          libs = RenderTurboStream::Test::Request::Libs.new(response)
+
+          r = libs.select_actions( false, action, &block)
+
+          assert(
+            r[:responses].length == count,
+            libs.class.assert_error_message(count, r[:responses].length, r[:log])
           )
         end
 

data/lib/render_turbo_stream/test/request/libs.rb

@@ -2,10 +2,15 @@ module RenderTurboStream
   module Test
     module Request
       class Libs
-        def self.all_turbo_responses(response)
-          e = Nokogiri::HTML(response.body).search('#rendered-partials').first
+
+        def initialize(response)
+          @response = response
+        end
+
+        def all_turbo_responses
+          e = Nokogiri::HTML(@response.body).search('#rendered-partials').first
           res = (e.present? ? JSON.parse(e.inner_html) : [])
-          response.headers.each do |k, v|
+          @response.headers.each do |k, v|
             next unless k.match(/^test-turbo-channel-[\d]+$/)
             h = JSON.parse(v)
             res.push(h)
@@ -13,90 +18,119 @@ module RenderTurboStream
           res
         end
 
-        def self.select_responses(response, channel, target_id, action, type: nil, prohibit_multiple_to_same_target: [:replace], &block)
-          all = all_turbo_responses(response)
+        # checks only for rendered partials, not for actions
+
+        def select_responses(channel, target, action, prohibit_multiple_to_same_target: [:replace], &block)
+          all = all_turbo_responses
           res = { log: [], responses: [] }
+          raise 'Missing argument: target' unless target.present?
 
-          if !target_id.present?
-            res[:log].push("No target «##{target_id}» provided!")
+          if !target.present?
+            res[:log].push("missing argument: target")
           elsif prohibit_multiple_to_same_target.present?
             has_prohibited_action = false
             c = all.select do |e|
               if prohibit_multiple_to_same_target.include?(e['action']&.to_sym)
                 has_prohibited_action = true
               end
-              e['target'] == "##{target_id}"
+              e['target'] == target
             end.length
             if c >= 2 && has_prohibited_action
-              res[:log].push("Target «##{target_id}» is targeted #{c} #{'time'.pluralize(c)} which is prohibited for the actions #{prohibit_multiple_to_same_target.join(', ')}")
+              res[:log].push("Target «#{target}» is targeted #{c} #{'time'.pluralize(c)} which is prohibited for the actions #{prohibit_multiple_to_same_target.join(', ')}")
               return res
             end
           end
 
-          id_matched = false
+          target_matched = false
+          permitted_types = if channel == false
+                             ['stream-partial', 'stream-template']
+                           else
+                             ['stream-partial', 'stream-template', 'channel-partial', 'channel-template']
+                           end
 
           responses = all.select do |a|
-            types = [a['type']]
-            if ['channel-partial', 'channel-template'].include?(a['type'])
-              types.push('channel')
-            elsif ['stream-partial'].include?(a['type'])
-              types.push('stream')
-            elsif ['stream-command'].include?(a['type'])
-              types.push('command')
-              types.push('stream')
-            elsif ['channel-command'].include?(a['type'])
-              types.push('command')
-              types.push('channel')
-            end
 
-            if target_id.present? && a['target'] == "##{target_id}"
-              id_matched = true
+            if a['target'] == target
+              target_matched = true
             end
 
-            if target_id.present? && a['target'] != "##{target_id}"
+            if a['target'] != target
               false
-            elsif type.present? && !types.include?(type.to_s)
-              res[:log].push("Target «##{target_id}»: Types #{types.join(', ')} not matching with given type «#{type}»")
+            elsif !permitted_types.include?(a['type'])
+              res[:log].push("Type «#{a['type']}» does not match the types you are looking for: #{permitted_types}")
               false
             elsif channel.present? && a['channel'] != channel.to_s
-              res[:log].push("Target «##{target_id}»: Channel #{a['channel']} not matching with given channel «#{channel}»")
+              res[:log].push("Target «#{target}»: Channel #{a['channel']} not matching with given channel «#{channel}»")
               false
             elsif action.present? && a['action'] != action.to_s
-              res[:log].push("Target «##{target_id}»: Action #{a['action']} not matching with given action «#{action}»")
+              res[:log].push("Target «#{target}»: Action «#{a['action']}» not matching with given action «#{action}»")
               false
             elsif block_given?
-              if types.include?('command')
-                args = a['array'][1..-1]
-                if yield(args)
+                nok = Nokogiri::HTML(a['html_response'])
+                if yield(nok).present?
                   true
                 else
-                  res[:log].push("Given block not matching Arguments => «#{args}»")
+                  res[:log].push("Target «#{target}»: Given block not matching in => «#{nok.inner_html}»")
                   false
                 end
-              else
-                nok = Nokogiri::HTML(a['html_response'])
-                if yield(nok).present?
+            else
+              true
+            end
+          end
+
+          unless target_matched
+            res[:log].push("Target «#{target}» not found in targets: #{turbo_targets}")
+          end
+
+          res[:responses] = responses
+          res
+        end
+
+        # checks only for commands, not for rendered partials
+        def select_actions(channel, action, &block)
+          all = all_turbo_responses
+          res = { log: [], responses: [] }
+          possible_types = ['stream-command', 'channel-command']
+          raise 'Missing argument: action' unless action.present?
+
+          action_found = false
+
+          responses = all.select do |a|
+            if a['action'] == action.to_s
+              action_found = true
+            end
+
+            if a['action'] != action.to_s
+              false
+            elsif !possible_types.include?(a['type'])
+              res[:log].push("Action «#{action}» is type «#{a['type']}» (accepted types are: #{possible_types.join(', ')})")
+              false
+            elsif channel.present? && a['channel'] != channel.to_s
+              res[:log].push("Channel «#{channel}» not found within action «#{action}»")
+              false
+            elsif block_given?
+                args = a['array'][1..-1]
+                if yield(args)
                   true
                 else
-                  res[:log].push("Target «##{target_id}»: Given block not matching (checked by .present?)")
+                  res[:log].push("Given block not matching Arguments => «#{args}»")
                   false
                 end
-              end
             else
               true
             end
           end
 
-          unless id_matched
-            res[:log].push("Target «##{target_id}» not found")
+          unless action_found
+            res[:log].push("Action «#{action}» not found under responded actions: #{turbo_actions}")
           end
 
           res[:responses] = responses
           res
         end
 
-        def self.turbo_targets(response)
-          responses = all_turbo_responses(response)
+        def turbo_targets
+          responses = all_turbo_responses
           targets = []
           responses.each do |r|
             if r['target'].is_a?(Array)
@@ -111,6 +145,27 @@ module RenderTurboStream
           targets
         end
 
+        def turbo_actions
+          responses = all_turbo_responses
+          actions = []
+          responses.each do |r|
+            actions.push(r['action']) unless actions.include?(r['action'])
+          end
+
+          actions
+        end
+
+        def targets_counts
+          responses = all_turbo_responses
+          targets = {}
+          responses.each do |r|
+            targets[r['target']] ||= 0
+            targets[r['target']] += 1
+          end
+
+          targets
+        end
+
         def self.assert_error_message(expected, received, log)
           [
             "Expected #{expected} #{'response'.pluralize(expected)} but found #{received}.",

data/lib/render_turbo_stream/version.rb

@@ -1,3 +1,3 @@
 module RenderTurboStream
-  VERSION = "3.0.4"
+  VERSION = "4.0.0"
 end

data/lib/render_turbo_stream.rb

@@ -12,4 +12,7 @@ require 'render_turbo_stream/controller_channel_helpers'
 require 'render_turbo_stream/channel_view_helpers'
 
 require 'render_turbo_stream/channel_libs'
+require 'render_turbo_stream/controller_libs'
+require 'render_turbo_stream/check_template'
+require 'render_turbo_stream/libs'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: render_turbo_stream
 version: !ruby/object:Gem::Version
-  version: 3.0.4
+  version: 4.0.0
 platform: ruby
 authors:
 - christian
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-12 00:00:00.000000000 Z
+date: 2023-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -24,11 +24,12 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 7.0.3
-description: Handles translated flash messages, sets status and renders partials via
-  Turbo Stream or Turbo::StreamsChannel directly from the controller. No need to write
-  *.turbo_stream.* templates. Together with the turbo_power gem or custom turbo_stream
-  actions, it can run javascript. Redirects can be handled easily and in multiple
-  ways. Through request testing helpers, this allows for consistent testing strategy.
+description: Handles translated flash messages, sets status, wrapps partials in the
+  necessary frames and renders via Turbo Stream or Turbo::StreamsChannel directly
+  from the controller. No need to write *.turbo_stream.* templates. Together with
+  the turbo_power gem or custom turbo_stream actions, it can run javascript. Redirects
+  can be handled easily and in multiple ways. Through request testing helpers, this
+  allows for consistent testing strategy.
 email:
 - christian@sedlmair.ch
 executables: []
@@ -39,6 +40,7 @@ files:
 - Rakefile
 - app/controllers/render_turbo_stream/application_controller.rb
 - app/controllers/render_turbo_stream/render_turbo_stream_render_controller.rb
+- app/views/layouts/_add_turbo_frame_tag.html.erb
 - app/views/render_turbo_stream.turbo_stream.erb
 - app/views/render_turbo_stream_command.html.erb
 - app/views/render_turbo_stream_empty_template.html.erb
@@ -46,9 +48,12 @@ files:
 - lib/render_turbo_stream.rb
 - lib/render_turbo_stream/channel_libs.rb
 - lib/render_turbo_stream/channel_view_helpers.rb
+- lib/render_turbo_stream/check_template.rb
 - lib/render_turbo_stream/controller_channel_helpers.rb
 - lib/render_turbo_stream/controller_helpers.rb
+- lib/render_turbo_stream/controller_libs.rb
 - lib/render_turbo_stream/engine.rb
+- lib/render_turbo_stream/libs.rb
 - lib/render_turbo_stream/railtie.rb
 - lib/render_turbo_stream/test/request/channel_helpers.rb
 - lib/render_turbo_stream/test/request/helpers.rb
@@ -80,6 +85,5 @@ requirements: []
 rubygems_version: 3.4.12
 signing_key:
 specification_version: 4
-summary: Complete workflow for turbo streams and channels. With testing strategy.
-  Rails like.
+summary: Complete workflow for turbo that just works and has a testing strategy.
 test_files: []