test(recorded): consume shared harness in library rail tests

Fold library/helpers.py onto the shared build_rails()/async_chunks() instead of its own
LLMRails(load_config(...)) + local _chunks (D11/F), and assert the content-safety output
block via assert_blocked_generation (refusal + rail stop) rather than the weak
assert_generation_response non-empty check (D6).

Author: Pouyanpi

tests/recorded/rails/library/helpers.py

@@ -17,24 +17,19 @@
 
 from typing import Any
 
-from nemoguardrails import LLMRails
 from nemoguardrails.rails.llm.options import RailType
-from tests.recorded.rails_config import RailsConfigSource, enable_streaming, load_config
+from tests.recorded.rails.helpers import async_chunks, build_rails
+from tests.recorded.rails_config import RailsConfigSource
 from tests.utils import FakeLLMModel
 
 
-async def _chunks(values: list[str]):
-    for value in values:
-        yield value
-
-
 async def check_rails(
     config: RailsConfigSource,
     messages: list[dict[str, Any]],
     *,
     rail_types: tuple[RailType, ...] | None = None,
 ):
-    rails = LLMRails(load_config(config), verbose=False)
+    rails = build_rails(config)
     return await rails.check_async(messages, rail_types=list(rail_types) if rail_types is not None else None)
 
 
@@ -43,7 +38,7 @@ async def generate_with_fake_main(
     main_output: str,
     messages: list[dict[str, Any]],
 ):
-    rails = LLMRails(load_config(config), llm=FakeLLMModel(responses=[main_output]), verbose=False)
+    rails = build_rails(config, llm=FakeLLMModel(responses=[main_output]))
     return await rails.generate_async(
         messages=messages,
         options={"log": {"activated_rails": True, "llm_calls": True}},
@@ -55,11 +50,11 @@ async def stream_with_fake_main(
     main_output: str,
     messages: list[dict[str, Any]],
 ):
-    rails = LLMRails(enable_streaming(load_config(config)), verbose=False)
+    rails = build_rails(config, streaming=True)
     chunks = []
     async for chunk in rails.stream_async(
         messages=messages,
-        generator=_chunks([main_output]),
+        generator=async_chunks([main_output]),
         options={"rails": ["output"]},
     ):
         chunks.append(chunk)

tests/recorded/rails/library/test_content_safety.py

@@ -20,8 +20,8 @@
 from nemoguardrails.exceptions import LLMCallException
 from nemoguardrails.rails.llm.options import RailStatus, RailType
 from tests.recorded.assertions import (
+    assert_blocked_generation,
     assert_blocked_stream_error,
-    assert_generation_response,
     assert_rails_result,
 )
 from tests.recorded.normalization import normalize_generation_response, normalize_rails_result, normalize_stream_chunks
@@ -89,7 +89,7 @@ async def test_content_safety_output_blocks_fake_main_generation(nvidia_api_key)
         [{"role": "user", "content": "hello"}],
     )
 
-    result = assert_generation_response(result)
+    result = assert_blocked_generation(result, refusal="I'm sorry, I can't respond to that.")
 
     assert normalize_generation_response(result) == snapshot(
         {