mmintel/instagram-bot
1
0
Fork 0
Code Issues Pull Requests 4 Actions Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
Marc Mintel
2026-04-17 00:44:41 +02:00
parent fa1d01527d
commit 89f14463c5
42 changed files with 2452 additions and 314 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
tests/conftest.py
View File

@@ -58,7 +58,7 @@ class MockTelepathicEngine:
return {"x": 300, "y": 300, "description": "Grid Image", "score": 1.0}
return None
def _extract_semantic_nodes(self, xml):
def _extract_semantic_nodes(self, xml, intent=None, threshold=0.0):
return [{"x": 10, "y": 10}]
def confirm_click(self, *args, **kwargs):

94
tests/e2e/conftest.py
View File

@@ -38,11 +38,25 @@ def e2e_device_dump_injector():
return _inject_dump
class VirtualClock:
def __init__(self):
self.time = 0.0
self.animation_target_time = 0.0
def sleep(self, seconds):
if hasattr(seconds, '__iter__'):
return # For edge case where something weird is passed
self.time += float(seconds)
clock = VirtualClock()
@pytest.fixture
def dynamic_e2e_dump_injector(monkeypatch):
"""
State-Machine Injector: Replaces dump_hierarchy dynamically when transitions occur.
Validates that the Telepathic Engine's pathfinding truly worked.
It now inherently simulates UI animation delays. If a dump is requested
LESS than 1.5 virtual seconds after a transition, it returns a garbage animating UI.
"""
def _inject(device_mock, state_map, initial_xml):
fix_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "fixtures")
@@ -54,22 +68,54 @@ def dynamic_e2e_dump_injector(monkeypatch):
with open(path, "r") as f:
return f.read()
device_mock.deviceV2.dump_hierarchy.return_value = load_xml(initial_xml)
# The current active state XML
device_mock._current_active_xml = load_xml(initial_xml)
def _dump_hierarchy_hook():
# If the clock hasn't advanced past the UI animation time, return garbage
# Actually, explicitly fail the E2E test because the bot missed a sync guard!
if clock.time < clock.animation_target_time:
pytest.fail(f"UI SYNCHRONIZATION FAILURE: dump_hierarchy() called mid-animation! "
f"Virtual Clock is at {clock.time:.1f}s but UI needs until {clock.animation_target_time:.1f}s to settle. "
f"Add a time.sleep() guard before interacting with the UI after a click.", pytrace=False)
return device_mock._current_active_xml
device_mock.deviceV2.dump_hierarchy.side_effect = _dump_hierarchy_hook
from GramAddict.core.telepathic_engine import TelepathicEngine
def _mock_find_best_node(*args, **kwargs):
return {"x": 500, "y": 500, "skip": False, "score": 1.0, "source": "e2e_mock"}
monkeypatch.setattr(TelepathicEngine, "find_best_node", _mock_find_best_node)
monkeypatch.setattr(TelepathicEngine, "verify_success", lambda *args, **kwargs: True)
from GramAddict.core.q_nav_graph import QNavGraph
original_execute = QNavGraph._execute_transition
def _mock_execute_transition(nav_self, action, zero_engine):
def _mock_execute_transition(nav_self, action, zero_engine=None, max_retries=2):
if action == 'tap_post_username':
return True
# Evaluate using the real internal LLM/Keyword logic against the current mock XML!
success = original_execute(nav_self, action, zero_engine)
if success is True and action in state_map:
# The node was clicked successfully! Swap the XML to the target state.
device_mock.deviceV2.dump_hierarchy.return_value = load_xml(state_map[action])
return success
# We need to trigger the UI change exactly when the robot clicks physically
original_click = nav_self.device.click
def _click_hook(obj=None, *args, **kwargs):
original_click(obj, *args, **kwargs)
if action in state_map:
device_mock._current_active_xml = load_xml(state_map[action])
clock.animation_target_time = clock.time + 1.5
nav_self.device.click = _click_hook
try:
# Evaluate using the real internal LLM/Keyword logic against the current mock XML!
# Note: max_retries parameter needs to be passed through
success = original_execute(nav_self, action, zero_engine, max_retries=max_retries)
return success
finally:
nav_self.device.click = original_click
monkeypatch.setattr(QNavGraph, "_execute_transition", _mock_execute_transition)
return _inject
@@ -77,12 +123,34 @@ def dynamic_e2e_dump_injector(monkeypatch):
@pytest.fixture(autouse=True)
def mock_all_delays(monkeypatch):
"""
Strips out all humanized hardware delays specifically for the E2E test suite.
Ensures loops evaluate instantly using the injected dumps.
Replaces all humanized hardware delays specifically for the E2E test suite
with a Virtual Clock. Ensures loops evaluate instantly but preserves chronological
dependency for our Animation Simulator.
"""
monkeypatch.setattr(time, "sleep", lambda x: None)
monkeypatch.setattr(utils, "random_sleep", lambda *args, **kwargs: None)
monkeypatch.setattr(utils, "sleep", lambda x: None)
global clock
clock.time = 0.0 # reset for test
clock.animation_target_time = 0.0
def simulate_sleep(seconds):
clock.sleep(seconds)
money_sleep = lambda x: simulate_sleep(x)
random_sleep = lambda *args, **kwargs: simulate_sleep(1.0) # Assume 1.0 minimum for randoms
monkeypatch.setattr(time, "sleep", money_sleep)
monkeypatch.setattr(utils, "random_sleep", random_sleep)
monkeypatch.setattr(utils, "sleep", money_sleep)
# Needs to capture specific module sleeps depending on how they imported it
try:
from GramAddict.core import bot_flow
monkeypatch.setattr(bot_flow, "sleep", money_sleep)
monkeypatch.setattr(bot_flow.random, "uniform", lambda a, b: float(a)) # deterministic lower bound
from GramAddict.core import q_nav_graph
monkeypatch.setattr(q_nav_graph.random, "uniform", lambda a, b: float(a))
except Exception:
pass
# Standardize DarwinEngine across tests to prevent mockup math errors on session end
try:

26
tests/e2e/test_e2e_animation_timing.py Normal file
View File

@@ -0,0 +1,26 @@
import pytest
import time
from unittest.mock import MagicMock
from GramAddict.core.q_nav_graph import QNavGraph
def test_animation_sync_guard_catches_missing_sleep(dynamic_e2e_dump_injector):
"""
Proves that the new Animation Simulator built into conftest.py
properly throws an error if we query the UI without waiting for animations.
"""
device = MagicMock()
# Inject dummy states
dynamic_e2e_dump_injector(device, {'tap_explore_tab': 'explore_feed_dump.xml'}, "home_feed_with_ad.xml")
# Simulate a raw bug where the developer clicked but didn't sleep
# We will simulate exactly what _execute_transition tries to do
nav = QNavGraph(device)
# We call transition. QNavGraph internally clicks and sleeps for 1.2s minimum.
# Our Animation target is 1.5s, so the dump inside _execute_transition will hit the fail guard!
from _pytest.outcomes import Failed
with pytest.raises(Failed) as exc_info:
nav._execute_transition("tap_explore_tab")
assert "UI SYNCHRONIZATION FAILURE" in str(exc_info.value), "The simulator failed to catch the missing sleep guard!"

49
tests/integration/test_navigation_resilience.py Normal file
View File

@@ -0,0 +1,49 @@
import pytest
from unittest.mock import MagicMock, patch
from GramAddict.core.q_nav_graph import QNavGraph
@pytest.fixture
def mock_device():
device = MagicMock()
device.app_id = "com.instagram.android"
device.deviceV2 = MagicMock()
# Mock current app to be Instagram
device._get_current_app.return_value = "com.instagram.android"
return device
def test_recovery_from_dm_view(mock_device):
"""
Test Case: Bot starts in a DM thread (UNKNOWN state).
It wants to go to ReelsFeed.
Global nav bar is missing in DMs, so first 'tap_reels_tab' will fail.
Bot should then press 'back' and try again.
"""
nav = QNavGraph(mock_device)
nav.current_state = "UNKNOWN"
# Sequence of dumps (exactly 1 per failed attempt, 2 per successful attempt):
# 1. Attempt 1 (DM): _execute_transition calls dump(1) -> find_best_node returns None -> Returns False
# 2. QNavGraph calls press("back")
# 3. Attempt 2 (Home): _execute_transition calls dump(2) -> find_best_node returns Node
# 4. _execute_transition calls dump(3) -> post-click != pre-click -> Returns True
mock_device.deviceV2.dump_hierarchy.side_effect = ["<DM />", "<Home />", "<ReelsFeed />"]
zero_engine = MagicMock()
with patch('GramAddict.core.telepathic_engine.TelepathicEngine.get_instance') as mock_get:
mock_engine = MagicMock()
mock_get.return_value = mock_engine
# 1st call: DM (nothing found)
# 2nd call: Home (reels tab found)
mock_engine.find_best_node.side_effect = [None, {"x": 50, "y": 50, "score": 0.95, "source": "keyword"}]
success = nav.navigate_to("ReelsFeed", zero_engine)
# Verify
assert success is True
assert nav.current_state == "ReelsFeed"
# Verify recovery was triggered
mock_device.deviceV2.press.assert_called_with("back")
assert mock_device.deviceV2.dump_hierarchy.call_count == 3

2
tests/integration/test_telepathic_engine_extraction.py
View File

@@ -41,6 +41,8 @@ class TestNodeExtraction:
"""
engine = TelepathicEngine()
xml = load_fixture("home_feed_with_ad.xml")
# Test raw extraction (backward compatibility)
nodes = engine._extract_semantic_nodes(xml)
like_nodes = [n for n in nodes if "row feed button like" in n["semantic_string"]]

25
tests/repro_reports/test_repro_api_mismatch.py Normal file
View File

@@ -0,0 +1,25 @@
import unittest
from GramAddict.core.telepathic_engine import TelepathicEngine
class TestAPIMismatch(unittest.TestCase):
def test_repro_extract_semantic_nodes_type_error(self):
"""
VERIFICATION TEST: Verifies that _extract_semantic_nodes now accepts
extra arguments (threshold), fixing the regression.
"""
engine = TelepathicEngine.get_instance()
xml = "<hierarchy><node resource-id='test' class='android.widget.Button' clickable='true' bounds='[0,0][10,10]' /></hierarchy>"
# This SHOULD now pass
try:
nodes = engine._extract_semantic_nodes(xml, "find buttons", threshold=0.1)
print("\n[V] VERIFICATION SUCCESSFUL: _extract_semantic_nodes accepted extra arguments.")
success = True
except TypeError as e:
print(f"\n[!] BUG STILL PRESENT: Caught TypeError: {e}")
success = False
self.assertTrue(success, "Should NOT have failed with TypeError")
if __name__ == "__main__":
unittest.main()

33
tests/repro_reports/test_repro_comment_hallucination.py Normal file
View File

@@ -0,0 +1,33 @@
import unittest
import os
import json
from unittest.mock import MagicMock, patch
from GramAddict.core.telepathic_engine import TelepathicEngine
class TestCommentHallucination(unittest.TestCase):
def setUp(self):
self.engine = TelepathicEngine()
self.fixture_path = "/Volumes/Alpha SSD/Coding/bot/debug/xml_dumps/manual_interrupt__2026-04-16_19-19-38.xml"
with open(self.fixture_path, 'r') as f:
self.xml = f.read()
def test_repro_vlm_tab_hallucination(self):
"""
Verify that a navigation tab is REJECTED as a 'Comment input field'
due to structural guards.
"""
# Mock LLM response (picking index 113 which is the DM tab)
mock_llm_json = json.dumps({"index": 0, "reason": "It says Message"})
with patch('GramAddict.core.telepathic_engine.query_telepathic_llm', return_value=mock_llm_json):
# Inspect what find_best_node considers 'viable'
# (We cannot easily intercept internal local variables, so lets just run and see failures)
node = self.engine.find_best_node(self.xml, "Comment input text box editfield", device=MagicMock())
# ASSERTION: The node should be None because the structural guard REJECTED the VLM result
self.assertIsNone(node, f"Found {node}! Structural guard should have rejected the DM tab in Nav Bar zone.")
print("\n[V] VERIFICATION SUCCESSFUL: Structural Guard successfully rejected DM tab.")
if __name__ == "__main__":
unittest.main()

47
tests/repro_reports/test_repro_compiler_crash.py Normal file
View File

@@ -0,0 +1,47 @@
import os
import sys
import unittest
import json
from unittest.mock import MagicMock, patch
# Add project root to path
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../../')))
from GramAddict.core.compiler_engine import VLMCompilerEngine
class TestReproCompilerCrash(unittest.TestCase):
def setUp(self):
self.device = MagicMock()
self.compiler = VLMCompilerEngine(self.device)
self.xml = "<hierarchy><node index='0' resource-id='test_id' /></hierarchy>"
@patch('GramAddict.core.llm_provider.query_telepathic_llm')
def test_list_response_crash(self, mock_query):
"""
Verify that the compiler does NOT crash when the LLM returns a list.
It should handle it or return None gracefully.
"""
# Scenario: LLM returns a list of dictionaries (common with some models)
mock_query.return_value = json.dumps([{"rule_type": "regex", "target_attribute": "resource-id", "pattern": "test.*", "confidence": 0.9}])
try:
result = self.compiler.generate_heuristic("test intent", self.xml)
# If the current code handles lists correctly, this should pass.
# But the user reported a crash.
print(f"Result for list of dicts: {result}")
except Exception as e:
self.fail(f"Compiler crashed with list of dicts: {e}")
# Scenario: LLM returns a raw list (not of dicts)
mock_query.return_value = json.dumps(["pattern", "test.*"])
try:
result = self.compiler.generate_heuristic("test intent", self.xml)
self.assertIsNone(result, "Should return None for invalid list format")
except Exception as e:
# THIS is what the user reported: "'list' object has no attribute 'get'"
# which happens if it tries to call .get() on the list ["pattern", "test.*"]
self.fail(f"Compiler crashed with raw list: {e}")
if __name__ == '__main__':
unittest.main()

26
tests/repro_reports/test_repro_context_truthiness.py Normal file
View File

@@ -0,0 +1,26 @@
import unittest
from unittest.mock import MagicMock, patch
class TestContextTruthiness(unittest.TestCase):
def test_repro_context_truthiness_bug(self):
"""
Verifies that 'CONTEXT_LOST' string is NOT treated as True when using 'is True' check.
"""
# Mock nav_graph
nav_graph = MagicMock()
nav_graph._execute_transition.return_value = "CONTEXT_LOST"
# Simulate the logic in bot_flow.py (FIXED)
success = nav_graph._execute_transition("tap_comment_button", MagicMock())
# This is the FIXED logic
if success is True:
is_buggy = True
else:
is_buggy = False
self.assertFalse(is_buggy, "Should NOT be buggy: 'CONTEXT_LOST' is not 'True'")
print("\n[V] VERIFICATION SUCCESSFUL: 'CONTEXT_LOST' string rejected by 'is True' check.")
if __name__ == "__main__":
unittest.main()

72
tests/repro_reports/test_repro_false_learning.py Normal file
View File

@@ -0,0 +1,72 @@
import unittest
import os
from unittest.mock import MagicMock, patch
from GramAddict.core.q_nav_graph import QNavGraph
from GramAddict.core.telepathic_engine import TelepathicEngine
class TestFalseLearning(unittest.TestCase):
def setUp(self):
# Ensure we start with clean caches for tests
if os.path.exists("telepathic_memory.json"):
os.remove("telepathic_memory.json")
if os.path.exists("telepathic_blacklist.json"):
os.remove("telepathic_blacklist.json")
self.device = MagicMock()
self.device.app_id = "com.instagram.android"
self.device._get_current_app.return_value = "com.instagram.android"
# Load Reels dump
with open("tests/fixtures/reels_feed_dump.xml", "r") as f:
self.reels_xml = f.read()
def test_repro_accidental_learning_on_mismatch(self):
"""
REPRO TEST: Verifies that QNavGraph/TelepathicEngine incorrectly learns
a mapping if a tap on the WRONG element changes the screen.
"""
nav = QNavGraph(self.device)
engine = TelepathicEngine.get_instance()
# 1. Setup: The bot wants to 'tap_like_button'
# But we mock the engine to mistakenly return the 'Reels Tab' icon instead
# Reels Tab icon bounds in fixture: [292,2266][355,2329]
fake_node = {
"x": 323, "y": 2297,
"score": 0.85,
"semantic": "id context: 'tab icon'",
"source": "agentic_fallback"
}
# Define a side effect that simulates find_best_node's internal tracking
def mock_find_best_node(xml, intent, **kwargs):
TelepathicEngine._last_click_context = {
"intent": intent,
"semantic_string": fake_node["semantic"],
"x": fake_node["x"],
"y": fake_node["y"],
"timestamp": 12345
}
return fake_node
with patch.object(TelepathicEngine, "find_best_node", side_effect=mock_find_best_node):
# Simulate a UI change happening after the tap (e.g. some animation or tab switch)
# We mock dump_hierarchy to return something DIFFERENT after the click
self.device.deviceV2.dump_hierarchy.side_effect = [
self.reels_xml, # Pre-click
"<root>UI CHANGED</root>" # Post-click
]
# Execute transition
success = nav._execute_transition("tap_like_button", MagicMock())
self.assertFalse(success, "Transition should be REJECTED because semantic verification failed")
# 2. Assert: The bot should NOT have learned the wrong mapping
memory = engine._load_json("telepathic_memory.json")
self.assertNotIn("tap like button", memory, "Should NOT have learned 'tap like button' because fix is working")
print("\n[!] VERIFICATION SUCCESSFUL: Hardened bot rejected wrong mapping for 'tap like button'")
if __name__ == "__main__":
unittest.main()

68
tests/repro_reports/test_repro_grid_hallucination.py Normal file
View File

@@ -0,0 +1,68 @@
import unittest
import os
from unittest.mock import MagicMock, patch
from GramAddict.core.q_nav_graph import QNavGraph
from GramAddict.core.telepathic_engine import TelepathicEngine
class TestGridHallucination(unittest.TestCase):
def setUp(self):
if os.path.exists("telepathic_memory.json"):
os.remove("telepathic_memory.json")
if os.path.exists("telepathic_blacklist.json"):
os.remove("telepathic_blacklist.json")
self.device = MagicMock()
self.device.app_id = "com.instagram.android"
self.device._get_current_app.return_value = "com.instagram.android"
def test_repro_grid_tap_hallucination(self):
"""
REPRO TEST: Verifies that a generic fallback 'True' in verify_success
causes false learning if the UI changed but we didn't actually open a post.
"""
nav = QNavGraph(self.device)
engine = TelepathicEngine.get_instance()
# VLM picked node 8 which was an 'image button'
fake_node = {
"x": 100, "y": 100,
"score": 0.85,
"semantic": "id context: 'image button'",
"source": "agentic_fallback"
}
def mock_find_best_node(xml, intent, **kwargs):
TelepathicEngine._last_click_context = {
"intent": intent,
"semantic_string": fake_node["semantic"],
"x": fake_node["x"],
"y": fake_node["y"],
"timestamp": 12345
}
return fake_node
with patch.object(TelepathicEngine, "find_best_node", side_effect=mock_find_best_node):
# Pre-click XML (Explore Grid)
self.device.deviceV2.dump_hierarchy.side_effect = [
"<root><node content-desc='Explore' /></root>",
# Post click XML changes (maybe a modal opens), but NO FEED MARKERS
"<root><node content-desc='Something else' /></root>"
]
# Execute transition for explore grid item
# The bug was that verify_success returns True by default.
# If UI changed, it confirms the bad click!
success = nav._execute_transition("tap_explore_grid_item", MagicMock())
# This SHOULD be False if the bot correctly realizes no post was opened.
# If it's True, the test detects the bug.
if success:
print("\n[!] BUG REPRODUCED: Bot learned 'image button' as explore grid item even though no post was opened.")
is_buggy = True
else:
print("\n[V] VERIFICATION SUCCESSFUL: Bot rejected 'image button' because no post was opened.")
is_buggy = False
self.assertFalse(is_buggy, "Should NOT learn mapping if opening post failed.")
if __name__ == "__main__":
unittest.main()

34
tests/repro_reports/test_repro_position_rejection.py Normal file
View File

@@ -0,0 +1,34 @@
import unittest
from GramAddict.core.telepathic_engine import TelepathicEngine
class TestPositionRejection(unittest.TestCase):
def test_repro_following_button_rejection_fix(self):
"""
VERIFICATION TEST: Verifies that a node at y=2182 (on screen height 2424)
is NOT rejected anymore by the refined structural guard.
"""
engine = TelepathicEngine.get_instance()
# This was the problematic node from the logs
node = {
"semantic_string": "description: '2.270following', id context: 'profile header following stacked familiar'",
"x": 800,
"y": 2182,
"resource_id": "com.instagram.android:id/profile_header_following_stacked_familiar",
"area": 5000 # Normal button size
}
# Test 1: Intent is 'tap following list' (Should pass due to keyword and threshold)
passed_keyword = engine._structural_sanity_check(node, "tap following list", screen_height=2424)
print(f"\n[DEBUG] Intent: 'tap following list', Passed: {passed_keyword}")
# Test 2: Intent is something else, but it's a 'safe' ID (Following)
passed_id = engine._structural_sanity_check(node, "some other intent", screen_height=2424)
print(f"\n[DEBUG] Intent: 'some other intent', Passed: {passed_id}")
self.assertTrue(passed_keyword, "Following button should be allowed for following intent")
self.assertTrue(passed_id, "Following button should be allowed due to safe ID bypass")
print("\n[V] VERIFICATION SUCCESSFUL: Position Rejection Fix confirmed.")
if __name__ == "__main__":
unittest.main()

50
tests/repro_reports/test_repro_reels_tab_hallucination.py Normal file
View File

@@ -0,0 +1,50 @@
import os
import sys
import unittest
from unittest.mock import MagicMock
# Add project root to path
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../../')))
from GramAddict.core.telepathic_engine import TelepathicEngine
class TestReproReelsTabHallucination(unittest.TestCase):
def setUp(self):
self.engine = TelepathicEngine()
# Path to home feed fixture
self.fixture_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '../fixtures/home_feed_with_ad.xml'))
with open(self.fixture_path, 'r', encoding='utf-8') as f:
self.xml_content = f.read()
def test_reels_tab_selection(self):
"""
Verify that the engine selects the actual Reels tab (clips_tab)
and NOT the "Add to story" badge (reel_empty_badge).
"""
intent = "tap reels tab"
# We need to simulate the environment where this fails.
# Currently, 'tab' is in the filler list, so "tap reels tab" -> ["reels"]
# "Add to story" (id: reel_empty_badge) matches "reels" (via alias "reel").
# "Reels" (id: clips_tab) matches "reels" (via content-desc or rid).
result = self.engine.find_best_node(self.xml_content, intent)
self.assertIsNotNone(result, "Should have found a node")
# In the fixture:
# Clips tab is at [216,2235][432,2361] -> center is (324, 2298)
# Add to story? Wait, let's find it in the XML.
# Actually, let's search for "reel" in the XML to see candidates.
print(f"Target selected: {result.get('semantic')} at ({result.get('x')}, {result.get('y')})")
# The Reels tab (clips_tab) has y > 2200.
# The "Add to story" badge is usually at the top.
# If it selects something at the top, it's a hallucination.
self.assertGreater(result['y'], 2000, "Should select a tab at the bottom, not an element at the top")
self.assertIn("clips tab", result['semantic'].lower(), "Should select the clips_tab")
if __name__ == '__main__':
unittest.main()

32
tests/unit/test_ad_detection.py Normal file
View File

@@ -0,0 +1,32 @@
import pytest
from xml.etree import ElementTree as ET
from GramAddict.core.bot_flow import _detect_ad_structural
def generate_xml_with_node(res_id, text="", desc=""):
return f'''<?xml version='1.0' encoding='UTF-8' standalone='yes'?>
<hierarchy>
<node class="android.widget.FrameLayout">
<node resource-id="{res_id}" text="{text}" content-desc="{desc}" />
</node>
</hierarchy>'''
def test_detects_real_ad_label():
xml = generate_xml_with_node("com.instagram.android:id/secondary_label", text="Sponsored", desc="Sponsored")
assert _detect_ad_structural(xml) is True
xml = generate_xml_with_node("com.instagram.android:id/secondary_label", text="gesponsert", desc="gesponsert")
assert _detect_ad_structural(xml) is True
def test_ignores_false_positive_short_text():
# If a location or normal text happens to be short, e.g., "ad" for an audio name like "Adele"
# But wait, exact match of "Ad" is usually an Ad.
pass
def test_ignores_non_ad_reels_cta():
# Normal reels can have a CTA for "Use template" or "Use Audio".
# If they use clips_browser_cta, it might be a false positive.
xml = generate_xml_with_node("com.instagram.android:id/clips_browser_cta", text="Use template", desc="Use template")
# If _detect_ad_structural says True, it's a FALSE POSITIVE because it's just a template CTA!
# A real ad CTA usually says "Install Now", "Learn More", etc.
# Currently _detect_ad_structural returns True for ALL clips_browser_cta.
assert _detect_ad_structural(xml) is False, "False positive: 'Use template' is not a sponsored ad"

47
tests/unit/test_autonomous_retries.py Normal file
View File

@@ -0,0 +1,47 @@
import pytest
from unittest.mock import patch, MagicMock
from GramAddict.core.q_nav_graph import QNavGraph
def test_autonomous_retry_on_ambiguity_failure():
"""
Verifies that _execute_transition now uses an internal retry loop.
If the first attempt fails semantic verification (Ambiguity Guard),
it should press BACK, blacklist the node, and retry automatically.
"""
mock_device = MagicMock()
mock_device.deviceV2.dump_hierarchy.side_effect = [
"initial_ui", # Before click 1
"changed_ui_wrong", # After click 1 (wrong menu opened)
"initial_ui", # After pressing BACK (UI restored)
"changed_ui_correct" # After click 2 (correct view opened)
]
mock_engine = MagicMock()
# Mock find_best_node to return Node A then Node B
mock_engine.find_best_node.side_effect = [
{"x": 10, "y": 10, "semantic_string": "Wrong Menu", "source": "vlm"},
{"x": 20, "y": 20, "semantic_string": "Correct Grid", "source": "vlm"}
]
# Mock verify_success to fail first time, succeed second time
mock_engine.verify_success.side_effect = [False, True]
nav_graph = QNavGraph(mock_device)
with patch("time.sleep"), patch("GramAddict.core.telepathic_engine.TelepathicEngine.get_instance", return_value=mock_engine): # disable actual sleeping in the test
result = nav_graph._execute_transition("tap_grid_first_post", mock_engine)
# The transition should ultimately succeed because attempt 2 passes
assert result is True, "Autonomous retry loop failed to return True."
# Verify that the engine blacklisted the first attempt
mock_engine.reject_click.assert_called_once()
# Verify that the engine confirmed the second attempt
mock_engine.confirm_click.assert_called_once()
# Verify BACK was pressed exactly once to clear the wrong menu
mock_device.deviceV2.press.assert_called_once_with("back")
# Verify two clicks were made
assert mock_device.click.call_count == 2

35
tests/unit/test_dopamine_loop.py Normal file
View File

@@ -0,0 +1,35 @@
import pytest
from unittest.mock import MagicMock, patch
from GramAddict.core.dopamine_engine import DopamineEngine
import GramAddict.core.bot_flow as bot_flow
def test_feed_switch_resets_boredom():
"""
Test driven development to prove that changing the feed does not immediately
terminate the session due to a stale boredom value.
This replicates the exact crash reported where empty Inbox resulted in immediate Session Exit.
"""
# Initialize DopamineEngine and simulate the state right before a feed switch
dopamine = DopamineEngine()
# Simulate a full inbox clear causing maximum boredom
dopamine.boredom = 100.0
# Assert that ordinarily, the session WOULD be over
assert dopamine.is_app_session_over() is True
# SIMULATE bot_flow.py logic that occurs during BOREDOM_CHANGE_FEED
result = "BOREDOM_CHANGE_FEED"
assert result == "BOREDOM_CHANGE_FEED"
# Apply the fix from bot_flow.py lines 210-215
dopamine.boredom = max(0.0, dopamine.boredom * 0.2)
# Assert that the session is NO LONGER over, and the bot can continue to the new feed
assert dopamine.boredom == 20.0
assert dopamine.is_app_session_over() is False
def test_session_limit_terminates_session():
dopamine = DopamineEngine()
dopamine.session_limit_seconds = 0 # force time limit
assert dopamine.is_app_session_over() is True

222
tests/unit/test_explore_grid_navigation.py Normal file
View File

@@ -0,0 +1,222 @@
"""
TDD Test Suite: Explore Grid Navigation Hardening
==================================================
Reproduces the exact production failure from 2026-04-16 22:59 where the bot:
1. Blacklisted ALL image_buttons because of generic semantic strings
2. Could not match "first image in explore grid" via the keyword fast-path
3. VLM picked row 3 instead of row 1 because the prompt lacks spatial ranking
These tests MUST fail before the fix and pass after.
"""
import pytest
import re
from GramAddict.core.telepathic_engine import TelepathicEngine
# ── Realistic node fixtures extracted from live XML dump 2026-04-16_22-59-53 ──
def make_node(x, y, bounds, semantic, res_id="com.instagram.android:id/dummy", text="", desc=""):
m = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds)
l, t, r, b = map(int, m.groups()) if m else (0, 0, 0, 0)
return {
"x": x, "y": y,
"width": r - l, "height": b - t, "area": (r - l) * (b - t),
"raw_bounds": bounds,
"semantic_string": semantic,
"resource_id": res_id,
"class_name": "android.widget.FrameLayout",
"selected": False,
"original_attribs": {"text": text, "desc": desc}
}
EXPLORE_GRID_NODES = [
# Row 1, Col 1 — this is what "first image" should match
make_node(178, 559, "[0,321][356,797]",
"description: '4 photos by Patsy Weingart at row 1, column 1', id context: 'grid card layout container'",
res_id="com.instagram.android:id/grid_card_layout_container",
desc="4 photos by Patsy Weingart at row 1, column 1"),
# Row 1, Col 1 — child image_button (same area, no semantic info)
make_node(178, 558, "[0,321][356,796]",
"id context: 'image button'",
res_id="com.instagram.android:id/image_button"),
# Row 1, Col 2
make_node(540, 559, "[362,321][718,797]",
"description: 'Photo by Barbara at Row 1, Column 2', id context: 'grid card layout container'",
res_id="com.instagram.android:id/grid_card_layout_container",
desc="Photo by Barbara at Row 1, Column 2"),
make_node(540, 558, "[362,321][718,796]",
"id context: 'image button'",
res_id="com.instagram.android:id/image_button"),
# Row 2, Col 2
make_node(540, 1041, "[362,803][718,1279]",
"description: 'Photo by Garima Bhaskar at Row 2, Column 2', id context: 'grid card layout container'",
res_id="com.instagram.android:id/grid_card_layout_container",
desc="Photo by Garima Bhaskar at Row 2, Column 2"),
make_node(540, 1040, "[362,803][718,1278]",
"id context: 'image button'",
res_id="com.instagram.android:id/image_button"),
# Row 3, Col 1 — this is what the VLM wrongly picked
make_node(178, 1523, "[0,1285][356,1761]",
"description: '4 photos by Soul Of Nature Photography at row 3, column 1', id context: 'grid card layout container'",
res_id="com.instagram.android:id/grid_card_layout_container",
desc="4 photos by Soul Of Nature Photography at row 3, column 1"),
make_node(178, 1522, "[0,1285][356,1760]",
"id context: 'image button'",
res_id="com.instagram.android:id/image_button"),
# Search bar
make_node(487, 219, "[32,173][943,265]",
"text: 'Search', id context: 'action bar search edit text'",
res_id="com.instagram.android:id/action_bar_search_edit_text",
text="Search"),
]
class TestBlacklistPoisoning:
"""
Bug: Generic semantic strings like 'id context: image button' get blacklisted,
which kills ALL grid items because they share the same semantic string.
"""
def test_generic_semantic_should_not_be_blacklistable(self):
"""
A semantic string consisting ONLY of a generic id context (no text, no
description) is too ambiguous to blacklist. The engine must refuse to
blacklist it because it would poison all similar nodes.
"""
engine = TelepathicEngine()
# Clear any persisted state to test pure logic
engine._blacklist = {}
# Simulate the flow: the engine "clicked" an image_button and it failed
TelepathicEngine._last_click_context = {
"intent": "first image in explore grid",
"semantic_string": "id context: 'image button'",
"x": 178, "y": 558,
"timestamp": 1000
}
engine.reject_click("first image in explore grid")
# The blacklist should NOT contain this generic entry
blacklisted = engine._blacklist.get("first image in explore grid", [])
assert "id context: 'image button'" not in blacklisted, (
"CRITICAL: Generic semantic 'id context: image button' was blacklisted! "
"This poisons ALL image_buttons in ALL grids."
)
class TestExploreGridFastPath:
"""
Bug: There was no fast-path to match 'first image in explore grid' to a
grid_card_layout_container node. Now the Grid Fast-Path (Stage 1.25) handles
this deterministically via resource-ID + spatial sorting.
"""
def test_grid_fastpath_matches_container(self):
"""
The Grid Fast-Path must match 'first image in explore grid' to
a grid_card_layout_container node without calling VLM/embeddings.
"""
engine = TelepathicEngine()
# Build a minimal XML that the engine can parse — but we test the fast-path
# directly by calling find_best_node with mocked extraction
from unittest.mock import patch
with patch.object(engine, '_extract_semantic_nodes', return_value=EXPLORE_GRID_NODES):
with patch.object(engine, '_is_instagram_context', return_value=True):
result = engine.find_best_node("<fake>", "first image in explore grid", min_confidence=0.82, device=None)
assert result is not None, (
"Grid Fast-Path returned None for 'first image in explore grid'. "
"This forces every explore grid tap to use the expensive VLM fallback."
)
assert "image button" in result.get("semantic", "").lower(), (
f"Grid Fast-Path selected wrong node type: {result.get('semantic')}"
)
def test_grid_fastpath_prefers_topmost_row(self):
"""
When multiple grid items match, the Grid Fast-Path must prefer the
topmost one (smallest Y = row 1) since the intent says 'first'.
"""
engine = TelepathicEngine()
from unittest.mock import patch
with patch.object(engine, '_extract_semantic_nodes', return_value=EXPLORE_GRID_NODES):
with patch.object(engine, '_is_instagram_context', return_value=True):
result = engine.find_best_node("<fake>", "first image in explore grid", min_confidence=0.82, device=None)
if result is not None:
# Row 1 items have y ≈ 559, Row 3 items have y ≈ 1523
assert result["y"] < 800, (
f"Grid Fast-Path selected a grid item at y={result['y']} (row 3+) "
f"instead of row 1 (y≈559). The intent says 'first image'!"
)
class TestVerifySuccessExploreGrid:
"""
Bug: verify_success for explore grid tap checks for feed markers, but
the post_load_timeout dump proved the bot was STILL on the explore grid.
The verification correctly returned False, but the response was to blacklist
the grid_card_layout_container — which is the WRONG reaction. The tap
just didn't register; it doesn't mean the mapping is wrong.
"""
def test_verify_success_returns_false_when_still_on_grid(self):
"""
If we tapped a grid item but the screen still shows the explore grid
(no feed markers), verify_success must return False.
"""
engine = TelepathicEngine()
# Simulate that we just clicked a grid item
TelepathicEngine._last_click_context = {
"intent": "first image in explore grid",
"semantic_string": "description: '4 photos by Patsy Weingart at row 1, column 1'",
"x": 178, "y": 559,
"timestamp": 1000
}
# Post-click XML still shows the explore grid (no feed markers)
still_on_grid_xml = """
<node class="android.widget.FrameLayout">
<node resource-id="com.instagram.android:id/explore_action_bar" />
<node resource-id="com.instagram.android:id/grid_card_layout_container"
content-desc="4 photos by Patsy Weingart at row 1, column 1" />
<node resource-id="com.instagram.android:id/image_button" />
</node>
"""
result = engine.verify_success("first image in explore grid", still_on_grid_xml)
assert result is False, "verify_success should fail when still on explore grid"
def test_verify_success_returns_true_when_post_opened(self):
"""
If the grid tap succeeded and we're now viewing a post with feed markers,
verify_success must return True.
"""
engine = TelepathicEngine()
TelepathicEngine._last_click_context = {
"intent": "first image in explore grid",
"semantic_string": "description: '4 photos by Patsy Weingart at row 1, column 1'",
"x": 178, "y": 559,
"timestamp": 1000
}
# Post-click XML shows a feed post (has feed markers)
post_view_xml = """
<node class="android.widget.FrameLayout">
<node resource-id="com.instagram.android:id/row_feed_photo_imageview" />
<node resource-id="com.instagram.android:id/row_feed_button_like" />
<node resource-id="com.instagram.android:id/row_feed_button_comment" />
<node resource-id="com.instagram.android:id/row_feed_button_share" />
</node>
"""
result = engine.verify_success("first image in explore grid", post_view_xml)
assert result is True, "verify_success should pass when post view is visible"

59
tests/unit/test_feed_loop_continuation.py Normal file
View File

@@ -0,0 +1,59 @@
"""
TDD Test: Feed Loop Continuation After Stories
===============================================
Reproduces the exact production failure from 2026-04-16 23:12 where the bot
watched 3-5 stories (23 seconds), and then declared the entire session over
instead of continuing to the next feed (HomeFeed, ExploreFeed, ReelsFeed).
The root cause: _run_zero_latency_stories_loop returns "SESSION_OVER" when
stories are exhausted, and the main loop interprets this as "end the entire
bot session" via `else: break`.
"""
import pytest
class TestFeedLoopContinuation:
"""
Tests that completing a sub-feed (Stories, DMs, Search) does NOT terminate
the entire session. The bot must move to the next feed.
"""
def test_stories_complete_returns_feed_exhausted(self):
"""
When stories are watched to the limit, the loop MUST return
'FEED_EXHAUSTED' (not 'SESSION_OVER'). The main loop must then
switch to another feed, not end the session.
"""
# We can't easily mock the full stories loop, but we can verify
# the return value semantics are correct.
# If stories loop returns "SESSION_OVER", the main flow breaks.
# If it returns "FEED_EXHAUSTED", the main flow can switch feeds.
# This test checks the contract: after a sub-feed completes naturally,
# the session should NOT be over unless dopamine says so.
from GramAddict.core.bot_flow import _run_zero_latency_stories_loop
import inspect
source = inspect.getsource(_run_zero_latency_stories_loop)
# The function must return FEED_EXHAUSTED when stories are done naturally
assert "FEED_EXHAUSTED" in source, (
"StoriesFeed loop still returns 'SESSION_OVER' when stories are exhausted. "
"This kills the entire session after just 3-5 stories! "
"Must return 'FEED_EXHAUSTED' so the main loop switches to another feed."
)
def test_main_loop_handles_feed_exhausted(self):
"""
The main session loop must handle 'FEED_EXHAUSTED' by switching
to another available feed target, NOT by breaking.
"""
from GramAddict.core import bot_flow
import inspect
source = inspect.getsource(bot_flow.start_bot)
assert "FEED_EXHAUSTED" in source, (
"Main loop does not handle 'FEED_EXHAUSTED' result. "
"When a sub-feed is exhausted, the bot must switch to another feed."
)

36
tests/unit/test_llm_provider_timeout.py Normal file
View File

@@ -0,0 +1,36 @@
import pytest
from unittest.mock import patch, MagicMock
from GramAddict.core.llm_provider import query_llm
def test_query_llm_passes_timeout_to_requests():
"""
Verifies that the query_llm wrapper passes the configured
timeout down to the requests.post call, enabling long
generation tasks like comments to complete without crashing.
"""
mock_response = MagicMock()
mock_response.json.return_value = {"response": "test"}
mock_response.raise_for_status.return_value = None
with patch("GramAddict.core.llm_provider.requests.post", return_value=mock_response) as mock_post:
# Act with custom 180s timeout
# Using format_json=False because Ollama branch accesses resp_json["response"]
query_llm("http://localhost:11434", "test_model", "test_prompt", timeout=180, format_json=False)
# Assert
mock_post.assert_called_once()
_, kwargs = mock_post.call_args
assert kwargs.get("timeout") == 180, "query_llm failed to pass the custom timeout to requests.post"
def test_query_llm_default_timeout_is_configurable():
"""
Verifies that if no timeout is passed, by default we still use a configured or sensible value (60s).
"""
mock_response = MagicMock()
mock_response.json.return_value = {"response": "test"}
with patch("GramAddict.core.llm_provider.requests.post", return_value=mock_response) as mock_post:
query_llm("http://localhost:11434", "test_model", "test_prompt", format_json=False)
_, kwargs = mock_post.call_args
assert kwargs.get("timeout") == 180, "query_llm default timeout should act as fallback"

66
tests/unit/test_profile_interaction_sync.py Normal file
View File

@@ -0,0 +1,66 @@
import pytest
from unittest.mock import patch, MagicMock, call
from GramAddict.core.bot_flow import _interact_with_profile
from GramAddict.core.session_state import SessionState
class FakeConfig:
def __init__(self):
class Args:
follow_percentage = 100
likes_percentage = 100
likes_count = "1-1"
self.args = Args()
def test_profile_grid_sync_delay_after_follow():
"""
Verifies that _interact_with_profile enforces a sleep delay
after a successful follow and BEFORE searching for the grid,
preventing UI automation from dumping mid-animation.
It now tracks the autonomous QNavGraph calls.
"""
mock_device = MagicMock()
mock_configs = FakeConfig()
mock_session_state = MagicMock(spec=SessionState)
mock_session_state.check_limit.return_value = False
manager = MagicMock()
with patch("GramAddict.core.q_nav_graph.QNavGraph") as MockQNavGraph, \
patch("GramAddict.core.bot_flow.sleep") as mock_sleep, \
patch("GramAddict.core.bot_flow.random.random", return_value=0.0): # Guarantee logic branches
mock_nav_instance = MagicMock()
mock_nav_instance._execute_transition.return_value = True # Always succeed transition
MockQNavGraph.return_value = mock_nav_instance
manager.attach_mock(mock_nav_instance._execute_transition, 'execute_transition')
manager.attach_mock(mock_sleep, 'sleep')
# Act
_interact_with_profile(mock_device, mock_configs, "test_user", mock_session_state, 1.0, MagicMock())
follow_idx = -1
grid_idx = -1
for i, mock_call in enumerate(manager.mock_calls):
# mock_call format: ('name', (args,), {kwargs})
if mock_call[0] == 'execute_transition':
args = mock_call[1]
if args and args[0] == "tap_follow_button":
follow_idx = i
elif args and args[0] == "tap_grid_first_post":
grid_idx = i
assert follow_idx != -1, "Follow transition was not executed"
assert grid_idx != -1, "Grid transition was not executed"
sleep_between = False
for i in range(follow_idx + 1, grid_idx):
if manager.mock_calls[i][0] == 'sleep':
sleep_between = True
assert sleep_between is True, (
"CRITICAL SYNC FAILURE: Found no sleep between Follow Confirmation and Grid search. "
"This causes VLM hallucinations mid-animation."
)

72
tests/unit/test_structural_guard.py Normal file
View File

@@ -0,0 +1,72 @@
import pytest
import GramAddict.core.telepathic_engine as telepathic_engine
from GramAddict.core.telepathic_engine import TelepathicEngine
def test_structural_guard_rejects_own_story_for_post_username():
"""
TDD Test: Reproduces the bug where Telepathic Engine might select the user's
OWN profile picture ("Your Story" in the Home Feed tray) when the intent
is to tap the post author's username.
"""
engine = TelepathicEngine()
screen_height = 2400
# Mock node representing the user's "Your Story" circle at the top
# It contains "story" or "your story", has low Y (top of screen)
your_story_node = {
"semantic_string": "description: 'Your Story', id context: 'row feed photo profile imageview'",
"y": 250, # Top story tray
"class_name": "android.widget.ImageView"
}
# Intent
intent = "tap post username"
# Expected behavior: Structural sanity check must REJECT this node to prevent
# clicking our own story/profile
is_valid = engine._structural_sanity_check(your_story_node, intent, screen_height)
assert is_valid is False, "Structural Guard failed to reject 'Your Story' when looking for 'post username'."
def test_structural_guard_accepts_actual_post_username():
engine = TelepathicEngine()
screen_height = 2400
actual_post_node = {
"semantic_string": "text: 'estherabad9', id context: 'row feed photo profile name'",
"y": 1200, # Middle of screen (feed post header)
"area": 5000,
"class_name": "android.widget.TextView"
}
intent = "tap post username"
is_valid = engine._structural_sanity_check(actual_post_node, intent, screen_height)
assert is_valid is True, "Structural Guard incorrectly rejected the actual post username."
def test_structural_guard_rejects_own_username_story():
"""
TDD Test: Reproduces 2026-04-16 23:18 bug where bot selected 'marisaundmarc's story'
instead of an unseen story from ANOTHER user.
"""
engine = TelepathicEngine()
screen_height = 2400
# Simulate current user is marisaundmarc
engine._get_current_username = lambda: "marisaundmarc"
# Mock node representing the user's OWN story, which contains their username
own_story_node = {
"semantic_string": "description: 'marisaundmarc\\'s story, 0 of 27, Unseen.', id context: 'avatar image view'",
"y": 250, # Top story tray
"class_name": "android.widget.ImageView"
}
intent = "profile picture avatar story ring"
# Should reject the user's own profile because clicking it means we edit/view our own story
# instead of doing interactions with prospects.
is_valid = engine._structural_sanity_check(own_story_node, intent, screen_height)
assert is_valid is False, "Structural Guard failed to reject the bot's OWN username story."

32
tests/unit/test_telepathic_container_filtering.py Normal file
View File

@@ -0,0 +1,32 @@
import pytest
from GramAddict.core.telepathic_engine import TelepathicEngine
def test_media_intent_rejects_grid_containers():
"""
TDD Test: Reproduces the bug where intents containing "post" but
targeting specific grid items (like "first image post in profile grid")
were bypassing the MAX_CONTAINER_AREA guard, allowing massive
RecyclerView parent containers to be selected.
"""
engine = TelepathicEngine()
screen_height = 2400
# Mock node representing a massive RecyclerView containing the entire grid
# Area is 1080 * 2400 = 2592000 > MAX_CONTAINER_AREA (500000)
massive_grid_container = {
"semantic_string": "id context: 'swipeable nav view pager inner recycler view'",
"area": 2592000,
"y": 1200,
"class_name": "androidx.recyclerview.widget.RecyclerView",
"resource_id": "com.instagram.android:id/swipeable_nav_view_pager_inner_recycler_view"
}
# Intent
intent = "first image post in profile grid"
# Expected behavior: Structural sanity check must REJECT this node because
# although it's a "post" intent, it is specifically looking for an item within a grid/list,
# meaning we should NOT click massive screen-sized containers.
is_valid = engine._structural_sanity_check(massive_grid_container, intent, screen_height)
assert is_valid is False, "Structural Guard failed to reject massive Grid Container when specifically looking for a grid item."