render_turbo_stream 0.1.45 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30eb2a0495b25d67ff59b2194b7b54cf20c8d0f813ade47a6809616d13231ba3
-  data.tar.gz: a934e1be22f6610a10fd16ce642a5601d8ef11224bfd1a9d70f1f1d471a83d71
+  metadata.gz: 8c88aab0f6268663008843f37d2b7cd052f5883d4751c8c1558a16a166e06752
+  data.tar.gz: 97188c8d6d19998f7a6e617eb07a9de4a92c88b96d917908b738932301a0bc11
 SHA512:
-  metadata.gz: c12cc64cbf409f74a7bf8f2faf6c6aa63fbe063a0bca4d8ec5939fea06b77011f873633e71daa44d6ef518f70686e382a115ac9c0da6b426413fb8665486c770
-  data.tar.gz: e6f689292afcc93064d1a67ee5d13a1bcd68a85cfb2b21a600624e5224585c4d5db7d6b21232ee30716924d5de82255ed321cab0a8ccf0d65c048aa7c9228325
+  metadata.gz: cd3b7d91aa83267ff6f6f5da938fbf8e65704396b60cba5ff14ca82f9d15ad88954b330bbe170043514cba4cb67f7971ac57b55062828860e9e13c7129ef91b7
+  data.tar.gz: 3d7c1b8917846500a637dbb8ccb46b0535db82e4d64690c488d0fe8b98d070b51a88cb7d3c5cd41296c55f9f5d51b2bec66a0dea8fd981e9ab407e273568a93c

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).
@@ -86,6 +81,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,64 +92,68 @@ 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 easiest test**
 
-  let(:invalid_params) { { article: { title: '', desciption: 'abc' } } }
+If you want to check if a controller action succeeded, just check for `response.status`.
 
-  it 'create failed' do
+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. So a test might look like this:
+```ruby
+  it 'update failed' do
+  patch article_path(article, params: invalid_params)
+  expect(response.status).to eq(422)
+end
+```
 
-    post articles_path(params: invalid_params)
+**Test redirection**
+```ruby
+  it 'update success' do
+    patch article_path(article, params: valid_params)
+    expect(turbo_redirect_to).to eq(articles_path)
+  end
+```
 
-    # 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')
+**Easier check what the partials have done**
 
-    # THERE ARE 3 COUNTS
+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..
+```
 
-    # A) Number of partials: "form" and "flash" are 2 partials
-    
-    expect(partials_count).to eq(2)
+**More detailed test**
 
-    # 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.
+Consider a controller action that should respond in 2 flashes.
 
-    # 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
+Helper for writing the test: On Debugger, inside the test, copy and paste the output of `partials_log.join("\n")` to any place.
 
-end
-```
+```ruby
+expect(partials_count).to eq(1)
 
-The test for a redirection might look something like this:
+expect(
+  partial_response_count('flash', total: 2) do |p|
+    p.css('.callout.success').inner_html.include?('All perfect')
+  end
+).to eq(1)
 
-```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(
+  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)
 ```
 
 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,9 +39,23 @@ 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
 
     end

data/lib/render_turbo_stream/version.rb

@@ -1,3 +1,3 @@
 module RenderTurboStream
-  VERSION = "0.1.45"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: render_turbo_stream
 version: !ruby/object:Gem::Version
-  version: 0.1.45
+  version: 1.1.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
@@ -71,6 +71,5 @@ requirements: []
 rubygems_version: 3.4.12
 signing_key:
 specification_version: 4
-summary: Render turbo-stream partials directly from the controller, including test
-  helpers
+summary: Render turbo-stream partials directly from the controller. Test helpers included
 test_files: []