phlex-reactive 0.11.2 → 0.11.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac1f001e762b40825811633d86a7cb9e050b85d32a7f7c11a44196b48f486af6
-  data.tar.gz: a969a678bf9f0d293b953529f9c31eb4871263dc391477e4301d3fedd5cec6fb
+  metadata.gz: 23b25b41281afc59503c63e9e4fbcee696d1265b96682c1c97bfd0adf385055d
+  data.tar.gz: 7204885d357720c85e57c8b44192d6e000f91c985346177a7ddcefc28f7451cc
 SHA512:
-  metadata.gz: 8378be9d18bd169e2f78dfbd5171931e952ecbb875c74df0ba5328518ea0a74c641e7840807a7d6eb216d647ecd0daa6f32cdf70468d049e6ed47fa2d0169903
-  data.tar.gz: 7ec7fb3754b137191feb9d38dca9ef9b14b6993da9909dd10ea0f25b661660259c3839b4fa011982dec206d687b765b0a70e7d762ca62c09ed22cbf7f055dba0
+  metadata.gz: 2afb0dfef67df5cc60f176db516ca7c4ed5553e7f24a9df9ff098dc7a897e1085594c698661d437f8ea336b4eab5d6bc76b884073f0f52b37b09a8f5fe4bd711
+  data.tar.gz: 411a32490ecdc9224d18e5db37b443286d1d3e47210e733e2cb9e6083aac5af2ac5ead6f96e54ab1cf0629483addd3f888de209976a6b2161259c5a6d9c0a93e

data/CHANGELOG.md

@@ -47,6 +47,16 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Fixed
 
+- **`have_reactive_value` now reads the field's `.value` property, so it can verify a
+  reducer-set disabled/computed field (#204).** The matcher (added in #201) delegated to
+  Capybara's `have_field(with:)`, which matches the value **attribute** — but a
+  `reactive_compute` reducer paints a computed output by setting its JS `.value`
+  **property** (`el.value = …`), and for a **disabled / read-only** output the attribute
+  never reflects that. So the matcher read `""` and failed on exactly the fields it was
+  built for. It now re-resolves the field by id **or name** each poll and asserts the live
+  `.value` property (via `evaluate_script`), covering enabled AND disabled/computed fields
+  while keeping the morph-immunity. `have_reactive_text` (textContent) was unaffected.
+
 - **A freshly-rendered `reactive_compute` root now self-seeds its derived fields on connect (#199).**
   Before, a compute root computed nothing until the first user `input` — a fresh render
   (or a server validation-error re-render that replaced the body) left every derived

data/lib/phlex/reactive/test_helpers/system.rb

@@ -63,21 +63,24 @@ module Phlex
         end
 
         # Assert (waiting) that the field with DOM id `id` has value `value`,
-        # RE-RESOLVING the field by its id on every poll. Use it as the barrier for
-        # a value that settles a beat after the triggering action — a reactive_compute
-        # re-seed or a morph replaces the input node AFTER the action returns, so a
-        # node captured by `find` would go stale; keying on the id and letting
-        # Capybara re-query each cycle is immune to that.
+        # RE-RESOLVING the field by its id on every poll and reading its live
+        # `.value` PROPERTY (issue #204) — NOT the value attribute. A
+        # reactive_compute reducer paints a computed output with `el.value = …`
+        # (the property); for a DISABLED / read-only output the value attribute
+        # never reflects that, so an attribute-based matcher reads "" and fails.
+        # Reading the property covers enabled AND disabled/computed fields — the
+        # exact case this matcher was built for — and keeps the morph-immunity
+        # (each poll re-finds the node by id, so a re-seed/morph that replaces the
+        # input can't surface a stale node or a transient blank).
         #
         #   expect(page).to have_reactive_value("total", "6")
         #
-        # A thin, intention-revealing wrapper over Capybara's field matcher scoped
-        # by id — the value the app is waiting on, named for what it is. The
-        # `have_` prefix is Capybara-matcher convention (have_field/have_css), NOT a
-        # predicate — hence the PredicatePrefix disable, mirroring matchers.rb.
+        # `timeout:` (or `wait:`) overrides Capybara's default max wait. The
+        # `have_` prefix is Capybara-matcher convention (have_field/have_css), NOT
+        # a predicate — hence the PredicatePrefix disable, mirroring matchers.rb.
         # rubocop:disable Naming/PredicatePrefix
-        def have_reactive_value(id, value, **)
-          have_field(id, with: value, **)
+        def have_reactive_value(id, value, timeout: nil, wait: nil)
+          ReactiveValueMatcher.new(id, value, wait: timeout || wait)
         end
 
         # Assert (waiting) that the node with DOM id `id` has TEXT `value`,
@@ -91,6 +94,91 @@ module Phlex
         end
         # rubocop:enable Naming/PredicatePrefix
 
+        # A waiting matcher that asserts a field's live `.value` PROPERTY (issue
+        # #204), read by id via evaluate_script so it sees a value a reducer set
+        # on a DISABLED output (where the value attribute stays blank). Polls until
+        # the property equals the expected value or the wait budget elapses,
+        # re-resolving the node by id every cycle (morph-immune). Supports negation
+        # (`not_to`) the Capybara way: the negative holds as soon as the property
+        # differs from the expected value (an absent field reads nil, which never
+        # equals a String expectation — so a missing field satisfies `not_to`).
+        #
+        # A plain class (not RSpec::Matchers.define) so it needs no RSpec at load
+        # time beyond the duck-typed matcher protocol RSpec calls (matches?,
+        # does_not_match?, failure_message*), keeping System loadable under Capybara
+        # alone. The expected value is stringified because a DOM `.value` is always
+        # a JS string on the wire (a numeric literal like 6 compares as "6").
+        class ReactiveValueMatcher
+          def initialize(id, value, wait: nil)
+            @id = id
+            @expected = value.to_s
+            @wait = wait
+          end
+
+          def matches?(page)
+            @page = page
+            poll_until { current_value == @expected }
+          end
+
+          # does_not_match? is RSpec's REQUIRED negated-matcher protocol method — its
+          # name is fixed by RSpec, not a predicate we get to rename.
+          # rubocop:disable Naming/PredicatePrefix
+          def does_not_match?(page)
+            @page = page
+            # The negative is satisfied the moment the property is NOT the expected
+            # value (or the field is absent → nil). poll_until returns true as soon
+            # as that holds, false if it stayed equal for the whole budget.
+            poll_until { current_value != @expected }
+          end
+          # rubocop:enable Naming/PredicatePrefix
+
+          def failure_message
+            "expected ##{@id} to have value #{@expected.inspect} (its .value property), " \
+              "but after waiting it was #{current_value.inspect}"
+          end
+
+          def failure_message_when_negated
+            "expected ##{@id} NOT to have value #{@expected.inspect} (its .value property), but it did"
+          end
+
+          private
+
+          # The field's live `.value` property, re-resolved each call. The
+          # identifier is matched by DOM id OR name (mirroring Capybara's
+          # have_field, which matches id/name/label) — reactive_field emits a
+          # `name`, not an `id`, so an id-only lookup would find nothing. Returns
+          # the String value, or nil when the field is absent (Playwright serializes
+          # a JS null as an empty Hash, so a non-String result is normalized to nil
+          # — the matcher then treats it as "not settled yet" and keeps polling
+          # rather than comparing a Hash to the expected String).
+          def current_value
+            raw = @page.evaluate_script(<<~JS)
+              (() => {
+                const k = #{@id.to_json}
+                const el = document.getElementById(k) || document.getElementsByName(k)[0]
+                return el ? el.value : null
+              })()
+            JS
+            raw.is_a?(::String) ? raw : nil
+          end
+
+          # Bounded poll on a JS-property condition Capybara can't express as a
+          # built-in waiting matcher. Uses the monotonic clock and the configured
+          # (or overridden) Capybara max wait — the same shape the system specs'
+          # hand-rolled wait_for used, now lifted into the helper.
+          def poll_until
+            deadline = now + (@wait || ::Capybara.default_max_wait_time)
+            loop do
+              return true if yield
+              return false if now >= deadline
+
+              sleep 0.05
+            end
+          end
+
+          def now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        end
+
         private
 
         # Fold an explicit `timeout:` into Capybara's `wait:` option, or omit it so

data/lib/phlex/reactive/version.rb

@@ -2,6 +2,6 @@
 
 module Phlex
   module Reactive
-    VERSION = "0.11.2"
+    VERSION = "0.11.3"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: phlex-reactive
 version: !ruby/object:Gem::Version
-  version: 0.11.2
+  version: 0.11.3
 platform: ruby
 authors:
 - Mikael Henriksson