render_turbo_stream 0.1.46 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3efa13a85fa7384096fdd81f4bceb089e73111d07b074ddc579f98e27af2511e
-  data.tar.gz: 69f47bbda0dfc94d5af491dcce47cd2eb5df464d8e404058483adcd26b480cb9
+  metadata.gz: 1299653f6a308796e690ca3929cd4c1580f707604913583e223a4bf4d398f889
+  data.tar.gz: d6228eb9aeb0e64591b1a066d1007ab665ab634788f8645ad7124063c9ef2c0e
 SHA512:
-  metadata.gz: b20d62b2f1fc7617050300d5960bbec912562b86a498b41652f1956e52459aa3ab63ecde9386ecbe7849eb66f8c6ddb3d139f4a03c79cf8761f8e06c672b0f80
-  data.tar.gz: 2a8e3d7b5bc35b28e73e00da9c5c526a76bea089129c5c4fa8e8d93e50cb9359417b77c944935636d570c2f783ff7566236c9e7dad74e7ae0422b236ee51cfb1
+  metadata.gz: d660266f923b6e6efa8225162b9eab8f0eb56eb0ed9f289601106bc661abd74f2dd6832021133c5b9031314475c657c27a1d34388e2c063fbb84a65cb4680b40
+  data.tar.gz: c511dfd6b6799a9075ab594aa60d806c428cf63abfb42cc6f4cbcdcd718197e67f840e89a799a789375f21dd10bd4c78e7fe3c7e933dd132637a900ff2477909

data/README.md

@@ -2,12 +2,7 @@
 
 Defining templates like `(create|update).turbo_stream.haml` annoyed me.
 
-Working consistently with turbo_stream means shooting lots of partials from the backend to the frontend, which always
-needs the same attributes: ID, partial, and maybe some locals. This gem serializes that: Partials can be controlled
-directly from the controller.
-
-It sets the status, generates a flash message, handles redirection, pushes it all to the front and comes with predefined
-helpers for enabling request-specs.
+Working consistently with turbo_stream means shooting lots of partials from the backend to the frontend. This always requires the same attributes: the path to the partial, the html-id that turbo_stream points to, and maybe some locals. This gem serialises that: Partials can be controlled directly from the controller. It sets the status, generates a flash message, handles redirection, pushes it all to the front and comes with predefined helpers for enabling request-specs.
 
 An overview of how we design a rails-7 application with turbo
 is [published on dev.to](https://dev.to/chmich/rails-7-vite-wrapping-up-1pia).
@@ -33,6 +28,7 @@ spec/rails_helper.rb
 ```ruby
 RSpec.configure do |config|
   config.include RenderTurboStream::Test::RequestHelpers, type: :request
+  config.include RenderTurboStream::Test::RspecRequestHelpers, type: :request #=> if you are on rspec
 end
 ```
 
@@ -86,6 +82,8 @@ stream_partials(
 
 The `stream_partial` method is nothing else than a singular of `stream_partials`.
 
+**locals**: The hash for locals goes through a `symbolize_keys`, so you need to use locals in used partials like this: `locals[:message]`.
+
 ```ruby
 stream_partial(
   id,
@@ -95,65 +93,78 @@ stream_partial(
 )
 ```
 
-## Testing
-
-For system testing there is Capybara. This works great and is necessary for javascript and backend combined apps, but it
-is good practice to break tests into smaller pieces.
+## Testing Scenarios
 
-For the much faster request-level tests, there are some helpers:
+For system testing there is Capybara. Its the only way to check if frontend and backend work together. But its a good practice to break tests into smaller pieces. The much larger number of tests we will write on the much faster request tests, examples here in rspec.
 
 If the request format is not `turbo_stream`, which is the case on request specs, the method responds in a special html
 that contains the medadata that is interesting for our tests and is parsed by included test helpers. So tests could look
 like this:
 
-```ruby
-require 'rails_helper'
-include RenderTurboStream::TestHelpers
-
-RSpec.describe "Articles", type: :request do
+**The fastest**
 
-  let(:invalid_params) { { article: { title: '', desciption: 'abc' } } }
+If you want to check if a controller action succeeded, just check for `response.status`. The `turbo_stream_save` method returns three statuses: `200` if `save_action` is true, otherwise `422` and `302` for redirect. If one of the declared partials does not exist or breaks, the server will respond with exception anyway. 
 
-  it 'create failed' do
+**rspec**
 
-    post articles_path(params: invalid_params)
+For rspec there is a special helper, for a successful save action:
 
-    # partials_log: developer information about what the renderer did, and strings to copy and paste into test commands
-    expect(partials_log.join('')).to include('Article could not be created')
-    expect(partials_log.join('')).to include('layouts/flash')
+```ruby
+  it 'update failed' do
+  patch article_path(article, params: valid_params)
+  expect_successful_saved('form', 'flash-box')
+  # expects response.status 200
+  # Make sure that the responses point to exactly these 2 IDs ('form' and 'flash-box').
+  # Make sure that each ID is responded to exactly once.
+end
+```
 
-    # THERE ARE 3 COUNTS
+**Redirection**
+```ruby
+  it 'update success' do
+    patch article_path(article, params: valid_params)
+    expect(turbo_redirect_to).to eq(articles_path)
+  end
+```
 
-    # A) Number of partials: "form" and "flash" are 2 partials
-    
-    expect(partials_count).to eq(2)
+**Easier check what the partials have done**
 
-    # B) Total count of responses per partial (1 => is default)
-    
-    expect(partial_response_count('articles/form', total: 1, id: 'form')).to be_truthy
-    # id is the html id to which turbo-stream is pointing.
+For checking a little more inside the partial responses, but with a simple syntax that checks for a one-time response from a specific partial and may be sufficient for most cases:
+```ruby
+expect(partials_count).to eq(2)
+# Check the total number of responding partials, in most cases it will be one form and one flash.
+ 
+expect(partial_response('form')).to eq(true)
+# Make sure that the form part (controller_path is not checked) has responded exactly once.
+
+expect(partial_response('articles/form', id: 'form', css: '.field_with_errors', include_string: 'Title')).to eq(true)
+# Check the content inside at least one in any of the elements that match the given css and check the id that turbo has pointed to..
+```
 
-    # C) If a block is given: the number of matching responses returned by "partial_response_count".
-    
-    expect(partial_response_count('flash'){|r|r.inner_html.include?('Article could not be created')}).to eq(1)
-    # result is either nil (if 0 matched) or a integer >= 1
-    
-    expect(partial_response_count('flash'){|r|r.css('div').inner_html.include?('Article could not be created')}).to eq(1)
-    #=> you can use the validators of nokogiri, check: https://nokogiri.org/tutorials/parsing_an_html_xml_document.html
-  end
+**More detailed**
 
-end
-```
+Consider a controller action that should respond in 2 flashes.
 
-The test for a redirection might look something like this:
+Helper for writing the test: On Debugger, inside the test, copy and paste the output of `partials_log.join("\n")` to any place.
 
 ```ruby
-it 'update success' do
-  a = FactoryBot.create(:article)
-  patch article_path(a, params: valid_params)
-  expect(turbo_redirect_to).to eq(articles_path)
-end
+expect(partials_count).to eq(1)
+
+expect(
+  partial_response_count('flash', total: 2) do |p|
+    p.css('.callout.success').inner_html.include?('All perfect')
+  end
+).to eq(1)
+
+expect(
+  partial_response_count('layouts/flash', id: 'flash-box', total: 2) do |p|
+    p.css('.callout.alert').inner_html.include?('Something went wrong')
+  end
+).to eq(1)
 ```
+`partial_response_count` always returns the number of matched responses.
+
+Possible matches can be found at [Nokogiri](https://nokogiri.org/tutorials/searching_a_xml_html_document.html)
 
 P.S.:
 

data/lib/render_turbo_stream/test/request_helpers.rb

@@ -10,8 +10,6 @@ module RenderTurboStream
         RenderTurboStream::Libs.partials_count(response)
       end
 
-
-
       # log as helper for the developer to see which flash is set and which partials are rendered to wich ids
       def partials_log
         all_responses = RenderTurboStream::Libs.all_responses(response)
@@ -34,7 +32,6 @@ module RenderTurboStream
         r
       end
 
-
       # Returns the path to which turbo_stream.redirect_to would be applied.
       def turbo_redirect_to
         expect(response.status).to eq(302)
@@ -42,11 +39,28 @@ module RenderTurboStream
         r['redirected_to']
       end
 
-
       def partial_response_count(partial, id: nil, total: 1, &block)
-        RenderTurboStream::Libs.partial_response_count(response, partial, id, total, &block )
+        RenderTurboStream::Libs.partial_response_count(response, partial, id, total, &block)
       end
 
+      def partial_response(partial, id: nil, css: nil, include_string: nil)
+        c = partial_response_count(partial, id: id, total: 1) do |r|
+          if css && include_string
+            r.css(css).inner_html.include?(include_string)
+          elsif include_string
+            r.inner_html.include?(include_string)
+          elsif css
+            r.css(css)
+          else
+            r.inner_html
+          end
+        end
+        c == 1
+      end
+
+      def partial_ids
+        RenderTurboStream::Libs.partial_ids(response)
+      end
     end
   end
 end

data/lib/render_turbo_stream/test/rspec_request_helpers.rb

@@ -0,0 +1,26 @@
+module RenderTurboStream
+  module Test
+    module RspecRequestHelpers
+
+
+      # expect status 200 and a each one time response to given ids
+
+      def expect_successful_saved(*ids)
+        responses = RenderTurboStream::Libs.all_responses(response)
+        counts = {}
+        responses.each do |r|
+          counts[r['id']] ||= 0
+          counts[r['id']] +=1
+        end
+
+        expect(response.status).to eq(200)
+        expect(counts.keys.length).to eq(ids.length)
+        ids.each do |id|
+          expect(counts.key?(id)).to be_truthy
+          expect(counts[id]).to eq(1)
+        end
+      end
+
+    end
+  end
+end

data/lib/render_turbo_stream/version.rb

@@ -1,3 +1,3 @@
 module RenderTurboStream
-  VERSION = "0.1.46"
+  VERSION = "1.2.0"
 end

data/lib/render_turbo_stream.rb

@@ -2,6 +2,7 @@ require "render_turbo_stream/version"
 require "render_turbo_stream/railtie"
 require 'render_turbo_stream/engine'
 require 'render_turbo_stream/test/request_helpers'
+require 'render_turbo_stream/test/rspec_request_helpers'
 
 module RenderTurboStream
 
@@ -233,6 +234,18 @@ module RenderTurboStream
       part.length
     end
 
+    def self.partial_ids(response)
+      all = all_responses(response)
+      ids = []
+      all.each do |p|
+        _p = p['id']
+        unless ids.include?(_p)
+          ids.push(_p)
+        end
+      end
+      ids
+    end
+
     def self.partial_response_count(response, partial, id, total, &block)
       responses = select_responses(response, partial, id)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: render_turbo_stream
 version: !ruby/object:Gem::Version
-  version: 0.1.46
+  version: 1.2.0
 platform: ruby
 authors:
 - christian
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-20 00:00:00.000000000 Z
+date: 2023-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -44,6 +44,7 @@ files:
 - lib/render_turbo_stream/engine.rb
 - lib/render_turbo_stream/railtie.rb
 - lib/render_turbo_stream/test/request_helpers.rb
+- lib/render_turbo_stream/test/rspec_request_helpers.rb
 - lib/render_turbo_stream/version.rb
 - lib/tasks/render_turbo_stream_tasks.rake
 homepage: https://gitlab.com/sedl/renderturbostream
@@ -71,5 +72,5 @@ requirements: []
 rubygems_version: 3.4.12
 signing_key:
 specification_version: 4
-summary: Render turbo-stream partials directly from the controller. Test helpers included
+summary: Render turbo-stream partials directly from the controller. Test helpers included.
 test_files: []