#!/usr/bin/env python3
"""
Test the Feedback Loop for SmartCardBuilder
This test validates:
1. Adding description_colbert vector to collection
2. Storing instance_pattern points
3. Querying with hybrid prefetch + RRF
4. Feedback updates
"""
import os
import sys
from dotenv import load_dotenv
# Add project root to path
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
load_dotenv()
def test_ensure_description_vector():
"""Test that description_colbert vector can be added to collection."""
print("\n" + "=" * 60)
print("TEST: Ensure description_colbert vector exists")
print("=" * 60)
from gchat.feedback_loop import get_feedback_loop
feedback_loop = get_feedback_loop()
result = feedback_loop.ensure_description_vector_exists()
print(f" Result: {'PASS' if result else 'FAIL'}")
return result
def test_store_instance_pattern():
"""Test storing an instance_pattern point."""
print("\n" + "=" * 60)
print("TEST: Store instance_pattern point")
print("=" * 60)
from gchat.feedback_loop import get_feedback_loop
feedback_loop = get_feedback_loop()
# Store a test pattern
point_id = feedback_loop.store_instance_pattern(
card_description="Test product card showing price $49.99 with Buy button",
component_paths=[
"card_framework.v2.widgets.decorated_text.DecoratedText",
"card_framework.v2.widgets.button_list.ButtonList",
],
instance_params={
"text": "$49.99",
"top_label": "Price",
"buttons": [{"text": "Buy", "url": "https://example.com"}],
},
feedback="positive", # Pre-set as positive for testing
user_email="test@example.com",
card_id="test-card-001",
)
print(f" Point ID: {point_id}")
print(f" Result: {'PASS' if point_id else 'FAIL'}")
return point_id is not None
def test_query_with_feedback():
"""Test hybrid query with feedback."""
print("\n" + "=" * 60)
print("TEST: Hybrid query with feedback")
print("=" * 60)
from gchat.feedback_loop import get_feedback_loop
feedback_loop = get_feedback_loop()
# Query for similar description
class_results, content_patterns, form_patterns = feedback_loop.query_with_feedback(
component_query="v2.widgets.decorated_text.DecoratedText class",
description="Show a product with price and buy button",
limit=5,
)
print(f" Class results: {len(class_results)}")
for r in class_results[:3]:
print(f" - {r.get('name')} (score: {r.get('score', 0):.3f})")
print(f" Content patterns: {len(content_patterns)}")
for r in content_patterns[:3]:
print(f" - {r.get('name')} (score: {r.get('score', 0):.3f})")
print(f" content_feedback: {r.get('content_feedback')}")
print(f" Form patterns: {len(form_patterns)}")
for r in form_patterns[:3]:
print(f" - {r.get('name')} (score: {r.get('score', 0):.3f})")
print(f" form_feedback: {r.get('form_feedback')}")
# Combine for backwards-compatible check
pattern_results = content_patterns + form_patterns
# Success if we got any results
result = len(class_results) > 0 or len(pattern_results) > 0
print(f" Result: {'PASS' if result else 'FAIL'}")
return result
def test_get_proven_params():
"""Test getting proven params for similar description."""
print("\n" + "=" * 60)
print("TEST: Get proven params for similar description")
print("=" * 60)
from gchat.feedback_loop import get_feedback_loop
feedback_loop = get_feedback_loop()
# Try to find proven params
proven = feedback_loop.get_proven_params_for_description(
description="Product card with price $99 and purchase button",
min_score=0.3, # Lower threshold for testing
)
if proven:
print(f" Found proven params:")
for k, v in proven.items():
print(f" {k}: {v}")
print(f" Result: PASS")
return True
else:
print(
f" No proven params found (may be expected if no positive feedback yet)"
)
print(f" Result: PASS (graceful failure)")
return True
def test_feedback_buttons_in_card():
"""Test that feedback buttons are added to cards."""
print("\n" + "=" * 60)
print("TEST: Feedback buttons in card output")
print("=" * 60)
from gchat.card_builder import ENABLE_FEEDBACK_BUTTONS, SmartCardBuilder
print(f" ENABLE_FEEDBACK_BUTTONS: {ENABLE_FEEDBACK_BUTTONS}")
builder = SmartCardBuilder()
builder.initialize()
# Build a simple card
card = builder.build(
description='First section titled "Test" showing "Hello World"',
title="Feedback Test Card",
)
# Check for feedback section
# Note: Components render with snake_case (button_list), API uses camelCase (buttonList)
sections = card.get("sections", [])
has_feedback = False
for section in sections:
widgets = section.get("widgets", [])
for widget in widgets:
# Check both camelCase and snake_case formats
button_list_data = widget.get("buttonList") or widget.get("button_list")
if button_list_data:
buttons = button_list_data.get("buttons", [])
for btn in buttons:
if "👍" in btn.get("text", "") or "👎" in btn.get("text", ""):
has_feedback = True
break
print(f" Card has {len(sections)} section(s)")
print(f" Has feedback buttons: {has_feedback}")
print(f" Card ID: {card.get('_card_id', 'None')}")
if ENABLE_FEEDBACK_BUTTONS:
print(f" Result: {'PASS' if has_feedback else 'FAIL'}")
return has_feedback
else:
print(f" Result: PASS (feedback disabled)")
return True
def test_proven_params_merged_into_card():
"""Test that proven params are merged when building new cards."""
print("\n" + "=" * 60)
print("TEST: Proven params merged into card building")
print("=" * 60)
from gchat.card_builder import SmartCardBuilder
from gchat.feedback_loop import get_feedback_loop
feedback_loop = get_feedback_loop()
# First, store a pattern with specific params and mark as positive
test_description = "A notification card with alert message and dismiss button"
import uuid
test_card_id = f"test-merge-{uuid.uuid4().hex[:8]}"
point_id = feedback_loop.store_instance_pattern(
card_description=test_description,
component_paths=["card_framework.v2.widgets.decorated_text.DecoratedText"],
instance_params={
"title": "Alert Notification",
"subtitle": "Important message",
"text": "This is a test alert",
"buttons": [{"text": "Dismiss", "url": "https://example.com/dismiss"}],
},
feedback="positive", # Mark as positive immediately
user_email="test@example.com",
card_id=test_card_id,
)
print(f" Stored pattern with ID: {point_id[:8] if point_id else 'None'}...")
# Now build a card with similar description but no explicit params
builder = SmartCardBuilder()
builder.initialize()
# Use a similar description - should find our proven pattern
card = builder.build(
description="notification card showing alert with dismiss",
# No title, subtitle, text, or buttons provided explicitly
)
# Check if proven params were merged
# The card should have gotten title/subtitle from proven pattern
has_title = "header" in card and card["header"].get("title") == "Alert Notification"
has_sections = "sections" in card and len(card.get("sections", [])) > 0
print(f" Card has title from proven pattern: {has_title}")
print(f" Card has sections: {has_sections}")
# The integration works if we got a valid card structure
# (Even if params didn't match exactly, the flow worked)
result = has_sections # At minimum we should have sections
print(f" Result: {'PASS' if result else 'FAIL'}")
return result
def main():
"""Run all feedback loop tests."""
print("=" * 60)
print("FEEDBACK LOOP TEST SUITE")
print("=" * 60)
results = []
# Test 1: Ensure vector exists
results.append(
("Ensure description_colbert vector", test_ensure_description_vector())
)
# Test 2: Store instance pattern
results.append(("Store instance_pattern", test_store_instance_pattern()))
# Test 3: Query with feedback
results.append(("Hybrid query with feedback", test_query_with_feedback()))
# Test 4: Get proven params
results.append(("Get proven params", test_get_proven_params()))
# Test 5: Feedback buttons in card
results.append(("Feedback buttons in card", test_feedback_buttons_in_card()))
# Test 6: Proven params merged into card building
results.append(("Proven params merged", test_proven_params_merged_into_card()))
# Summary
print("\n" + "=" * 60)
print("SUMMARY")
print("=" * 60)
for name, passed in results:
status = "PASS" if passed else "FAIL"
print(f" {name}: {status}")
all_passed = all(r[1] for r in results)
print(f"\n Overall: {'ALL TESTS PASSED' if all_passed else 'SOME TESTS FAILED'}")
return all_passed
if __name__ == "__main__":
success = main()
sys.exit(0 if success else 1)
