Update tests/test_components.py

tests/test_components.py

@@ -6,7 +6,6 @@ from unittest.mock import patch
 from cognitive_mapping_probe.llm_iface import get_or_load_model, LLM
 from cognitive_mapping_probe.resonance_seismograph import run_silent_cogitation_seismic
 from cognitive_mapping_probe.utils import dbg
-# KORREKTUR: Importiere die Hauptfunktion, die wir testen wollen.
 from cognitive_mapping_probe.concepts import get_concept_vector, _get_last_token_hidden_state
 
 # --- Tests for llm_iface.py ---
@@ -14,12 +13,25 @@ from cognitive_mapping_probe.concepts import get_concept_vector, _get_last_token
 @patch('cognitive_mapping_probe.llm_iface.AutoTokenizer.from_pretrained')
 @patch('cognitive_mapping_probe.llm_iface.AutoModelForCausalLM.from_pretrained')
 def test_get_or_load_model_seeding(mock_model_loader, mock_tokenizer_loader, mocker):
-    """Testet, ob `get_or_load_model` die Seeds korrekt setzt."""
+    """
+    Testet, ob `get_or_load_model` die Seeds korrekt setzt.
+    FINAL KORRIGIERT: Der lokale Mock ist nun vollständig konfiguriert.
+    """
     mock_model = mocker.MagicMock()
     mock_model.eval.return_value = None
     mock_model.set_attn_implementation.return_value = None
-    mock_model.config = mocker.MagicMock()
     mock_model.device = 'cpu'
+    
+    # KORREKTUR: Konfiguriere die vom `_populate_stable_config` erwarteten Attribute.
+    # 1. Der primäre Pfad über `get_input_embeddings`
+    mock_model.get_input_embeddings.return_value.weight.shape = (32000, 128) # (vocab_size, hidden_dim)
+    # 2. Die Fallback-Attribute auf dem `config`-Objekt
+    mock_model.config = mocker.MagicMock()
+    mock_model.config.num_hidden_layers = 2
+    # Wir setzen `hidden_size` auf dem config-Objekt, auch wenn der primäre Pfad es nicht braucht,
+    # um den Mock vollständig zu machen.
+    mock_model.config.hidden_size = 128
+
     mock_model_loader.return_value = mock_model
     mock_tokenizer_loader.return_value = mocker.MagicMock()
 
@@ -27,11 +39,14 @@ def test_get_or_load_model_seeding(mock_model_loader, mock_tokenizer_loader, moc
     mock_np_random_seed = mocker.patch('numpy.random.seed')
 
     seed = 123
+    # Dieser Aufruf sollte nun ohne `TypeError` durchlaufen.
     get_or_load_model("fake-model", seed=seed)
 
+    # Die ursprünglichen Assertions bleiben gültig.
     mock_torch_manual_seed.assert_called_with(seed)
     mock_np_random_seed.assert_called_with(seed)
 
+
 # --- Tests for resonance_seismograph.py ---
 
 def test_run_silent_cogitation_seismic_output_shape_and_type(mock_llm):
@@ -47,7 +62,7 @@ def test_run_silent_cogitation_seismic_output_shape_and_type(mock_llm):
 def test_run_silent_cogitation_with_injection_hook_usage(mock_llm):
     """Testet, ob bei einer Injektion der Hook korrekt registriert wird."""
     num_steps = 5
-    injection_vector = torch.randn(mock_llm.config.hidden_size)
+    injection_vector = torch.randn(mock_llm.stable_config.hidden_dim)
     run_silent_cogitation_seismic(
         llm=mock_llm, prompt_type="resonance_prompt",
         num_steps=num_steps, temperature=0.7,
@@ -59,23 +74,18 @@ def test_run_silent_cogitation_with_injection_hook_usage(mock_llm):
 
 def test_get_last_token_hidden_state_robustness(mock_llm):
     """Testet die robuste `_get_last_token_hidden_state` Funktion."""
-    # Diese Funktion wird vom `mock_llm` in `conftest.py` aufgerufen und gibt einen Tensor
-    # mit der korrekten `hidden_size` zurück. Hier testen wir, ob die Funktion im
-    # echten Modul mit dem gemockten LLM-Objekt korrekt interagiert.
     hs = _get_last_token_hidden_state(mock_llm, "test prompt")
-    assert hs.shape == (mock_llm.config.hidden_size,)
+    assert hs.shape == (mock_llm.stable_config.hidden_dim,)
 
 def test_get_concept_vector_logic(mock_llm, mocker):
     """
     Testet die Logik von `get_concept_vector`.
-    KORRIGIERT: Patcht nun die refaktorisierte, auf Modulebene befindliche Funktion.
     """
     mock_hidden_states = [
-        torch.ones(mock_llm.config.hidden_size) * 10, # target concept
-        torch.ones(mock_llm.config.hidden_size) * 2,  # baseline word 1
-        torch.ones(mock_llm.config.hidden_size) * 4   # baseline word 2
+        torch.ones(mock_llm.stable_config.hidden_dim) * 10, # target concept
+        torch.ones(mock_llm.stable_config.hidden_dim) * 2,  # baseline word 1
+        torch.ones(mock_llm.stable_config.hidden_dim) * 4   # baseline word 2
     ]
-    # KORREKTUR: Der Patch-Pfad zeigt jetzt auf die korrekte, importierbare Funktion.
     mocker.patch(
         'cognitive_mapping_probe.concepts._get_last_token_hidden_state',
         side_effect=mock_hidden_states
@@ -84,7 +94,7 @@ def test_get_concept_vector_logic(mock_llm, mocker):
     concept_vector = get_concept_vector(mock_llm, "test", baseline_words=["a", "b"])
 
     # Erwarteter Vektor: 10 - mean(2, 4) = 10 - 3 = 7
-    expected_vector = torch.ones(mock_llm.config.hidden_size) * 7
+    expected_vector = torch.ones(mock_llm.stable_config.hidden_dim) * 7
     assert torch.allclose(concept_vector, expected_vector)
 
 # --- Tests for utils.py ---
@@ -94,7 +104,7 @@ def test_dbg_output(capsys, monkeypatch):
     monkeypatch.setenv("CMP_DEBUG", "1")
     import importlib
     from cognitive_mapping_probe import utils
-    importlib.reload(utils) # Wichtig, da DEBUG_ENABLED beim Import gesetzt wird
+    importlib.reload(utils)
     utils.dbg("test message")
     captured = capsys.readouterr()
     assert "[DEBUG] test message" in captured.err
@@ -103,4 +113,4 @@ def test_dbg_output(capsys, monkeypatch):
     importlib.reload(utils)
     utils.dbg("should not be printed")
     captured = capsys.readouterr()
-    assert captured.err == ""
+    assert captured.err == ""