mirror of
https://github.com/yusufipk/dikte.git
synced 2026-09-11 19:06:11 +00:00
Merge pull request #59 from Oztturk/gemini-and-agy-cleanup
Clean up on Google AI Studio, or on Antigravity
This commit is contained in:
Yusuf İpek
@@ -119,9 +119,22 @@ class ExtractError(unittest.TestCase):
|
||||
body = json.dumps({"error": {"code": 42}})
|
||||
self.assertIn("42", api._extract_error(body))
|
||||
|
||||
def test_an_error_wrapped_in_an_array(self):
|
||||
"""Google's 503 arrives this way, and .get() on a list raises."""
|
||||
body = json.dumps([{"error": {"code": 503,
|
||||
"message": "The model is overloaded."}}])
|
||||
self.assertEqual(api._extract_error(body), "The model is overloaded.")
|
||||
|
||||
def test_a_body_that_is_not_json(self):
|
||||
self.assertEqual(api._extract_error("<html>502</html>"), "<html>502</html>")
|
||||
|
||||
def test_no_shape_at_all_still_comes_back_as_a_string(self):
|
||||
"""It runs while an ApiError is being raised: throwing here would
|
||||
escape the `except ApiError` holding the raw transcript."""
|
||||
for body in ("[]", "[1, 2]", '"a string"', "null", "17"):
|
||||
with self.subTest(body=body):
|
||||
self.assertIsInstance(api._extract_error(body), str)
|
||||
|
||||
def test_a_wall_of_html_is_cut_short(self):
|
||||
self.assertEqual(len(api._extract_error("x" * 5000)), 300)
|
||||
|
||||
@@ -384,6 +397,37 @@ class Cleanup(DikteTest):
|
||||
self.assertEqual(sent_json(calls[0])["reasoning"],
|
||||
{"effort": "high", "exclude": True})
|
||||
|
||||
def test_gemini_takes_openai_s_flat_field_rather_than_the_object(self):
|
||||
_, calls = self.call(chat_reply("Hello."), reasoning="low",
|
||||
provider="gemini", service="Google AI Studio")
|
||||
payload = sent_json(calls[0])
|
||||
self.assertEqual(payload["reasoning_effort"], "low")
|
||||
self.assertNotIn("reasoning", payload)
|
||||
|
||||
def test_off_is_asked_for_as_the_lowest_rung_google_actually_has(self):
|
||||
"""Sending "none" is a 400, and Flash left alone thinks."""
|
||||
_, calls = self.call(chat_reply("Hello."), reasoning="none",
|
||||
provider="gemini", service="Google AI Studio")
|
||||
self.assertEqual(sent_json(calls[0])["reasoning_effort"], "minimal")
|
||||
|
||||
def test_a_rung_google_does_not_have_lands_on_the_nearest_one(self):
|
||||
for asked in ("xhigh", "max"):
|
||||
with self.subTest(asked=asked):
|
||||
_, calls = self.call(chat_reply("Hello."), reasoning=asked,
|
||||
provider="gemini", service="Google AI Studio")
|
||||
self.assertEqual(sent_json(calls[0])["reasoning_effort"], "high")
|
||||
|
||||
def test_gemini_left_on_the_model_s_own_default_is_told_nothing(self):
|
||||
_, calls = self.call(chat_reply("Hello."), provider="gemini",
|
||||
service="Google AI Studio")
|
||||
self.assertNotIn("reasoning_effort", sent_json(calls[0]))
|
||||
|
||||
def test_a_missing_gemini_key_says_google_ai_studio(self):
|
||||
with self.assertRaises(api.ApiError) as caught:
|
||||
api.cleanup("hello", "", "gemini-3.5-flash-lite", "prompt",
|
||||
provider="gemini", service="Google AI Studio")
|
||||
self.assertIn("Google AI Studio", str(caught.exception))
|
||||
|
||||
def test_a_local_base_url(self):
|
||||
_, calls = self.call(chat_reply("Hello."), base_url="http://localhost:1234/v1")
|
||||
self.assertEqual(calls[0].full_url, "http://localhost:1234/v1/chat/completions")
|
||||
@@ -513,6 +557,40 @@ class ModelLists(DikteTest):
|
||||
api.openai_models("", api.GROQ_URL, "Groq")
|
||||
self.assertIn("Groq", str(caught.exception))
|
||||
|
||||
def test_gemini_keeps_only_the_models_that_answer_a_chat_request(self):
|
||||
with fake_urlopen({"data": [{"id": "gemini-3.5-flash"},
|
||||
{"id": "text-embedding-004"},
|
||||
{"id": "imagen-4.0"},
|
||||
{"id": "gemini-2.5-flash-lite"}]}) as calls:
|
||||
models = api.gemini_models("AIza-test")
|
||||
self.assertEqual(calls[0].full_url,
|
||||
"https://generativelanguage.googleapis.com/v1beta/openai/models")
|
||||
self.assertEqual(models, ["gemini-2.5-flash-lite", "gemini-3.5-flash"])
|
||||
|
||||
def test_the_long_form_of_an_id_is_shortened_to_what_a_request_wants(self):
|
||||
with fake_urlopen({"data": [{"id": "models/gemini-3.5-flash-lite"}]}):
|
||||
self.assertEqual(api.gemini_models("AIza-test"),
|
||||
["gemini-3.5-flash-lite"])
|
||||
|
||||
def test_a_gemini_id_that_is_not_a_chat_model_is_left_out(self):
|
||||
"""Google names its pictures and its voices `gemini` too."""
|
||||
with fake_urlopen({"data": [{"id": "gemini-3.5-flash"},
|
||||
{"id": "gemini-embedding-001"},
|
||||
{"id": "gemini-2.5-flash-image"},
|
||||
{"id": "gemini-2.5-flash-preview-tts"},
|
||||
{"id": "gemini-2.5-native-audio"}]}):
|
||||
self.assertEqual(api.gemini_models("AIza-test"), ["gemini-3.5-flash"])
|
||||
|
||||
def test_gemini_sends_the_key_as_a_bearer_token(self):
|
||||
with fake_urlopen({"data": []}) as calls:
|
||||
api.gemini_models("AIza-test")
|
||||
self.assertEqual(calls[0].get_header("Authorization"), "Bearer AIza-test")
|
||||
|
||||
def test_a_missing_gemini_key_says_google_ai_studio(self):
|
||||
with self.assertRaises(api.ApiError) as caught:
|
||||
api.gemini_models("")
|
||||
self.assertIn("Google AI Studio", str(caught.exception))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
||||
+200
-24
@@ -97,15 +97,36 @@ class Provider(DikteTest):
|
||||
def test_what_each_one_runs(self):
|
||||
self.assertEqual(assistant.executable("claude"), "claude")
|
||||
self.assertEqual(assistant.executable("codex"), "codex")
|
||||
self.assertEqual(assistant.executable("agy"), "agy")
|
||||
self.assertEqual(assistant.executable("openrouter"), "")
|
||||
|
||||
def test_the_model_recorded_is_the_one_that_answered(self):
|
||||
"""The history used to write Claude's setting whoever had answered."""
|
||||
self.assertEqual(assistant.model(self.config()), "sonnet")
|
||||
self.assertEqual(
|
||||
assistant.model(self.config(assistant_provider="codex")), "codex")
|
||||
self.assertEqual(
|
||||
assistant.model(self.config(assistant_provider="agy")), "agy")
|
||||
self.assertEqual(
|
||||
assistant.model(self.config(assistant_provider="agy",
|
||||
assistant_agy_model="gemini-3.1-pro-low")),
|
||||
"gemini-3.1-pro-low")
|
||||
self.assertEqual(
|
||||
assistant.model(self.config(assistant_provider="openrouter")),
|
||||
"google/gemini-3.5-flash")
|
||||
|
||||
def test_what_each_one_is_called(self):
|
||||
self.assertEqual(assistant.display_name(self.config()), "Claude")
|
||||
self.assertEqual(
|
||||
assistant.display_name(self.config(assistant_provider="codex")), "Codex")
|
||||
self.assertEqual(
|
||||
assistant.display_name(self.config(assistant_provider="openrouter")),
|
||||
"OpenRouter")
|
||||
for name, called in (("codex", "Codex"), ("agy", "Antigravity"),
|
||||
("openrouter", "OpenRouter")):
|
||||
with self.subTest(name=name):
|
||||
self.assertEqual(
|
||||
assistant.display_name(self.config(assistant_provider=name)),
|
||||
called)
|
||||
|
||||
def test_every_provider_has_a_name_to_be_called_by(self):
|
||||
"""_conclude writes its errors in it, so a gap here is a bare id."""
|
||||
self.assertEqual(set(assistant.SERVICES), set(assistant.PROVIDERS))
|
||||
|
||||
|
||||
class Effort(unittest.TestCase):
|
||||
@@ -113,21 +134,26 @@ class Effort(unittest.TestCase):
|
||||
|
||||
def test_the_scales_cover_the_same_settings(self):
|
||||
self.assertEqual(set(assistant.CLAUDE_EFFORT), set(assistant.CODEX_EFFORT))
|
||||
self.assertEqual(set(assistant.CLAUDE_EFFORT), set(assistant.AGY_EFFORT))
|
||||
|
||||
def test_codex_has_no_rung_above_high(self):
|
||||
self.assertEqual(assistant.CODEX_EFFORT["xhigh"], "high")
|
||||
self.assertEqual(assistant.CODEX_EFFORT["max"], "high")
|
||||
def test_neither_codex_nor_agy_has_a_rung_above_high(self):
|
||||
for scale in (assistant.CODEX_EFFORT, assistant.AGY_EFFORT):
|
||||
self.assertEqual(scale["xhigh"], "high")
|
||||
self.assertEqual(scale["max"], "high")
|
||||
|
||||
def test_neither_one_asks_for_a_rung_below_low(self):
|
||||
def test_none_of_them_asks_for_a_rung_below_low(self):
|
||||
# Claude has none; Codex has one, but calls it "minimal" on the older
|
||||
# models and "none" on the newer ones, and refuses the wrong word.
|
||||
for scale in (assistant.CLAUDE_EFFORT, assistant.CODEX_EFFORT):
|
||||
# models and "none" on the newer ones, and refuses the wrong word; agy
|
||||
# has three rungs and no word for off at all.
|
||||
for scale in (assistant.CLAUDE_EFFORT, assistant.CODEX_EFFORT,
|
||||
assistant.AGY_EFFORT):
|
||||
self.assertEqual(scale["none"], "low")
|
||||
self.assertEqual(scale["minimal"], "low")
|
||||
|
||||
def test_an_empty_setting_asks_for_nothing(self):
|
||||
self.assertEqual(assistant.CLAUDE_EFFORT.get("", ""), "")
|
||||
self.assertEqual(assistant.CODEX_EFFORT.get("", ""), "")
|
||||
for scale in (assistant.CLAUDE_EFFORT, assistant.CODEX_EFFORT,
|
||||
assistant.AGY_EFFORT):
|
||||
self.assertEqual(scale.get("", ""), "")
|
||||
|
||||
|
||||
class Session(DikteTest):
|
||||
@@ -276,25 +302,32 @@ class Conclude(DikteTest):
|
||||
|
||||
def test_an_answer_and_its_session(self):
|
||||
answer, warning = assistant._conclude(
|
||||
self.found(answer="done", session="abc"), 0, "", "", "Claude")
|
||||
self.found(answer="done", session="abc"), 0, "", "", "claude")
|
||||
self.assertEqual(answer, "done")
|
||||
self.assertEqual(warning, "")
|
||||
self.assertEqual(assistant.read_session("claude", 1800), "abc")
|
||||
|
||||
def test_codex_stores_under_its_own_name(self):
|
||||
assistant._conclude(self.found(answer="done", session="t-1"), 0, "",
|
||||
"", "Codex")
|
||||
self.assertEqual(assistant.read_session("codex", 1800), "t-1")
|
||||
def test_each_one_stores_under_its_own_name(self):
|
||||
for name, session in (("codex", "t-1"), ("agy", "c-9")):
|
||||
with self.subTest(name=name):
|
||||
assistant._conclude(self.found(answer="done", session=session),
|
||||
0, "", "", name)
|
||||
self.assertEqual(assistant.read_session(name, 1800), session)
|
||||
|
||||
def test_the_error_is_written_in_the_provider_s_own_name(self):
|
||||
with self.assertRaises(assistant.AssistantError) as caught:
|
||||
assistant._conclude(self.found(), 1, "", "", "agy")
|
||||
self.assertIn("Antigravity", str(caught.exception))
|
||||
|
||||
def test_a_non_zero_exit_with_nothing_to_show_for_it(self):
|
||||
with self.assertRaises(assistant.AssistantError) as caught:
|
||||
assistant._conclude(self.found(), 1, "it all went wrong\n", "", "Claude")
|
||||
assistant._conclude(self.found(), 1, "it all went wrong\n", "", "claude")
|
||||
self.assertIn("it all went wrong", str(caught.exception))
|
||||
|
||||
def test_a_session_that_is_gone_is_raised_apart(self):
|
||||
with self.assertRaises(assistant._SessionGone):
|
||||
assistant._conclude(self.found(), 1, "session abc not found",
|
||||
"abc", "Claude")
|
||||
"abc", "claude")
|
||||
|
||||
def test_the_recovery_no_longer_hangs_on_the_words_the_cli_chose(self):
|
||||
# The complaint used to be matched by substring, which a CLI update or
|
||||
@@ -321,11 +354,11 @@ class Conclude(DikteTest):
|
||||
def test_a_session_that_is_gone_only_matters_when_one_was_resumed(self):
|
||||
with self.assertRaises(assistant.AssistantError):
|
||||
assistant._conclude(self.found(), 1, "session abc not found",
|
||||
"", "Claude")
|
||||
"", "claude")
|
||||
|
||||
def test_an_answer_survives_a_non_zero_exit(self):
|
||||
answer, _ = assistant._conclude(self.found(answer="done"), 1, "noise",
|
||||
"", "Claude")
|
||||
"", "claude")
|
||||
self.assertEqual(answer, "done")
|
||||
|
||||
def test_an_answer_on_a_resumed_session_is_kept_rather_than_retried(self):
|
||||
@@ -336,12 +369,12 @@ class Conclude(DikteTest):
|
||||
def test_a_reported_failure_with_no_answer(self):
|
||||
with self.assertRaises(assistant.AssistantError) as caught:
|
||||
assistant._conclude(self.found(failure="the model refused"), 0, "",
|
||||
"", "Claude")
|
||||
"", "claude")
|
||||
self.assertIn("refused", str(caught.exception))
|
||||
|
||||
def test_a_run_that_said_nothing_at_all(self):
|
||||
with self.assertRaises(assistant.AssistantError) as caught:
|
||||
assistant._conclude(self.found(), 0, "", "", "Codex")
|
||||
assistant._conclude(self.found(), 0, "", "", "codex")
|
||||
self.assertIn("Codex", str(caught.exception))
|
||||
|
||||
|
||||
@@ -565,6 +598,109 @@ class AskCodex(DikteTest):
|
||||
self.assertIn("quota", str(caught.exception))
|
||||
|
||||
|
||||
class AskAgy(DikteTest):
|
||||
"""agy's stream is shaped nothing like the other two: the key is `event`,
|
||||
the answer arrives whole in `result.response`, and the conversation to
|
||||
resume is named in the first line rather than the last."""
|
||||
|
||||
def run_ask(self, conf=None, events=None, session=""):
|
||||
conf = conf or self.config(assistant_provider="agy")
|
||||
proc = FakeCli(events or [
|
||||
{"event": "init", "conversation_id": "c-9", "init": {"cwd": "/home"}},
|
||||
{"event": "result",
|
||||
"result": {"conversation_id": "c-9", "status": "SUCCESS",
|
||||
"response": " done "}},
|
||||
])
|
||||
stages = []
|
||||
with only_these_tools("agy"), \
|
||||
mock.patch.object(subprocess, "Popen", return_value=proc) as popen:
|
||||
result = assistant._ask_agy("book it", conf, session,
|
||||
stages.append, None)
|
||||
return result, popen.call_args.args[0], stages
|
||||
|
||||
def test_the_answer_comes_back_stripped(self):
|
||||
(answer, warning), _, _ = self.run_ask()
|
||||
self.assertEqual(answer, "done")
|
||||
self.assertEqual(warning, "")
|
||||
|
||||
def test_the_instruction_is_kept_apart_from_the_command(self):
|
||||
"""agy takes no system prompt, so the two must not read as one."""
|
||||
conf = self.config(assistant_provider="agy")
|
||||
_, cmd, _ = self.run_ask(conf)
|
||||
body = cmd[cmd.index("-p") + 1]
|
||||
self.assertTrue(body.startswith(conf.assistant_prompt()))
|
||||
self.assertIn("\n\n---\n\n", body)
|
||||
self.assertTrue(body.endswith("book it"))
|
||||
|
||||
def test_a_first_command_starts_a_project_of_its_own(self):
|
||||
"""Without it agy works in whichever project it was last in."""
|
||||
_, cmd, _ = self.run_ask()
|
||||
self.assertIn("--new-project", cmd)
|
||||
self.assertNotIn("--conversation", cmd)
|
||||
|
||||
def test_a_second_command_carries_the_conversation_rather_than_starting_one(self):
|
||||
_, cmd, _ = self.run_ask(session="c-9")
|
||||
self.assertEqual(cmd[cmd.index("--conversation") + 1], "c-9")
|
||||
self.assertNotIn("--new-project", cmd)
|
||||
|
||||
def test_the_conversation_is_kept_under_agy_s_own_name(self):
|
||||
self.run_ask()
|
||||
self.assertEqual(assistant.read_session("agy", 1800), "c-9")
|
||||
|
||||
def test_it_is_not_left_to_give_up_before_the_caller_does(self):
|
||||
conf = self.config(assistant_provider="agy", assistant_timeout=90)
|
||||
_, cmd, _ = self.run_ask(conf)
|
||||
self.assertEqual(cmd[cmd.index("--print-timeout") + 1], "90s")
|
||||
|
||||
def test_no_model_named_means_whatever_agy_is_set_to(self):
|
||||
_, cmd, _ = self.run_ask()
|
||||
self.assertNotIn("--model", cmd)
|
||||
|
||||
def test_a_model_of_your_own(self):
|
||||
_, cmd, _ = self.run_ask(
|
||||
self.config(assistant_provider="agy",
|
||||
assistant_agy_model="gemini-3.1-pro-low"))
|
||||
self.assertEqual(cmd[cmd.index("--model") + 1], "gemini-3.1-pro-low")
|
||||
|
||||
def test_a_tool_is_named_in_the_corner_as_it_starts(self):
|
||||
_, _, stages = self.run_ask(events=[
|
||||
{"event": "step_update",
|
||||
"step_update": {"step_type": "tool", "state": "ACTIVE",
|
||||
"tool_name": "run_command"}},
|
||||
{"event": "step_update",
|
||||
"step_update": {"step_type": "tool", "state": "DONE",
|
||||
"tool_name": "run_command"}},
|
||||
{"event": "result",
|
||||
"result": {"status": "SUCCESS", "response": "done"}},
|
||||
])
|
||||
self.assertEqual(stages, ["Running a command…"])
|
||||
|
||||
def test_the_two_dozen_browser_tools_are_one_line_between_them(self):
|
||||
_, _, stages = self.run_ask(events=[
|
||||
{"event": "step_update",
|
||||
"step_update": {"step_type": "tool", "state": "ACTIVE",
|
||||
"tool_name": "browser_click_element"}},
|
||||
{"event": "result",
|
||||
"result": {"status": "SUCCESS", "response": "done"}},
|
||||
])
|
||||
self.assertEqual(stages, ["Working in the browser…"])
|
||||
|
||||
def test_a_turn_that_did_not_succeed_is_a_failure_rather_than_an_answer(self):
|
||||
with self.assertRaises(assistant.AssistantError) as caught:
|
||||
self.run_ask(events=[
|
||||
{"event": "result",
|
||||
"result": {"status": "ERROR", "response": "the model refused"}},
|
||||
])
|
||||
self.assertIn("refused", str(caught.exception))
|
||||
|
||||
def test_a_failure_with_nothing_to_say_is_still_named(self):
|
||||
with self.assertRaises(assistant.AssistantError) as caught:
|
||||
self.run_ask(events=[
|
||||
{"event": "result", "result": {"status": "ERROR"}},
|
||||
])
|
||||
self.assertIn("Antigravity", str(caught.exception))
|
||||
|
||||
|
||||
class AskOpenRouter(DikteTest):
|
||||
def test_a_question_and_an_answer(self):
|
||||
conf = self.config(assistant_provider="openrouter",
|
||||
@@ -710,5 +846,45 @@ class CodexModels(DikteTest):
|
||||
self.assertEqual(assistant.codex_models(), [])
|
||||
|
||||
|
||||
class AgyModels(DikteTest):
|
||||
"""The model list read off `agy models`: one id, a tab, a display name."""
|
||||
|
||||
LISTING = ("gemini-4-flash-high\tGemini 4 Flash (High)\n"
|
||||
"gemini-4-flash-low\tGemini 4 Flash (Low)\n"
|
||||
"a line with no tab is not a model\n"
|
||||
"\ta tab with no id in front of it is not one either\n")
|
||||
|
||||
def models(self, reply, code=0):
|
||||
with only_these_tools("agy"), \
|
||||
mock.patch.object(subprocess, "run",
|
||||
return_value=FakeCompleted(
|
||||
returncode=code, stdout=reply)) as run:
|
||||
found = assistant.agy_models()
|
||||
self.run_call = run
|
||||
return found
|
||||
|
||||
def test_the_listing_arrives_in_agy_s_own_order(self):
|
||||
found = self.models(self.LISTING)
|
||||
self.assertEqual(found, ["gemini-4-flash-high", "gemini-4-flash-low"])
|
||||
self.assertEqual(self.run_call.call_args.args[0], ["agy", "models"])
|
||||
|
||||
def test_an_agy_that_is_not_installed_is_not_run(self):
|
||||
with only_these_tools(), \
|
||||
mock.patch.object(subprocess, "run") as run:
|
||||
self.assertEqual(assistant.agy_models(), [])
|
||||
run.assert_not_called()
|
||||
|
||||
def test_a_call_that_failed_answers_with_nothing(self):
|
||||
self.assertEqual(self.models("error: not logged in", code=1), [])
|
||||
self.assertEqual(self.models(""), [])
|
||||
|
||||
def test_an_agy_that_hangs_is_given_up_on(self):
|
||||
with only_these_tools("agy"), \
|
||||
mock.patch.object(subprocess, "run",
|
||||
side_effect=subprocess.TimeoutExpired(
|
||||
["agy"], 30)):
|
||||
self.assertEqual(assistant.agy_models(), [])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
||||
@@ -57,7 +57,9 @@ class Provider(DikteTest):
|
||||
def test_what_each_one_runs(self):
|
||||
self.assertEqual(cleanup.executable("claude"), "claude")
|
||||
self.assertEqual(cleanup.executable("codex"), "codex")
|
||||
self.assertEqual(cleanup.executable("agy"), "agy")
|
||||
self.assertEqual(cleanup.executable("openrouter"), "")
|
||||
self.assertEqual(cleanup.executable("gemini"), "")
|
||||
|
||||
def test_the_model_named_in_the_history_is_the_one_that_did_it(self):
|
||||
self.assertEqual(cleanup.model(self.config(cleanup_model="some/model")),
|
||||
@@ -73,6 +75,16 @@ class Provider(DikteTest):
|
||||
self.assertEqual(
|
||||
cleanup.model(self.config(cleanup_provider="codex",
|
||||
cleanup_codex_model="gpt-5.4")), "gpt-5.4")
|
||||
self.assertEqual(
|
||||
cleanup.model(self.config(cleanup_provider="gemini")),
|
||||
"gemini-3.5-flash-lite")
|
||||
# Antigravity is left on its own default the way Codex is.
|
||||
self.assertEqual(
|
||||
cleanup.model(self.config(cleanup_provider="agy")), "agy")
|
||||
self.assertEqual(
|
||||
cleanup.model(self.config(cleanup_provider="agy",
|
||||
cleanup_agy_model="gemini-3.7-flash-low")),
|
||||
"gemini-3.7-flash-low")
|
||||
|
||||
|
||||
class OpenRouter(DikteTest):
|
||||
@@ -94,6 +106,46 @@ class OpenRouter(DikteTest):
|
||||
self.assertEqual(calls, [])
|
||||
|
||||
|
||||
class GoogleAiStudio(DikteTest):
|
||||
"""Cleanup over Google's OpenAI-compatible endpoint: one request, no CLI."""
|
||||
|
||||
def setUp(self):
|
||||
super().setUp()
|
||||
self.conf = self.config(cleanup_provider="gemini",
|
||||
gemini_api_key="AIza-test")
|
||||
|
||||
def test_it_goes_to_google_with_the_settings_as_they_were(self):
|
||||
self.conf["cleanup_reasoning"] = "none"
|
||||
with fake_urlopen(chat_reply("Done.")) as calls:
|
||||
self.assertEqual(cleanup.run("uh, done", self.conf, "the rules"),
|
||||
"Done.")
|
||||
self.assertEqual(
|
||||
calls[0].full_url,
|
||||
"https://generativelanguage.googleapis.com/v1beta/openai/chat/completions")
|
||||
payload = sent_json(calls[0])
|
||||
self.assertEqual(payload["model"], "gemini-3.5-flash-lite")
|
||||
self.assertEqual(payload["reasoning_effort"], "minimal")
|
||||
self.assertIn("uh, done", payload["messages"][1]["content"])
|
||||
|
||||
def test_the_key_travels_as_a_bearer_token(self):
|
||||
with fake_urlopen(chat_reply("Done.")) as calls:
|
||||
cleanup.run("uh, done", self.conf, "the rules")
|
||||
self.assertEqual(calls[0].get_header("Authorization"), "Bearer AIza-test")
|
||||
|
||||
def test_a_missing_key_names_google_rather_than_openrouter(self):
|
||||
self.conf["gemini_api_key"] = ""
|
||||
with mock.patch.dict(os.environ, {}, clear=True), \
|
||||
self.assertRaises(api.ApiError) as caught:
|
||||
cleanup.run("uh, done", self.conf, "the rules")
|
||||
self.assertIn("Google AI Studio", str(caught.exception))
|
||||
|
||||
def test_no_cli_is_started_for_it(self):
|
||||
patcher, calls = fake_cli(stdout="never")
|
||||
with patcher, fake_urlopen(chat_reply("Done.")):
|
||||
cleanup.run("uh, done", self.conf, "the rules")
|
||||
self.assertEqual(calls, [])
|
||||
|
||||
|
||||
class ClaudeCode(DikteTest):
|
||||
def setUp(self):
|
||||
super().setUp()
|
||||
@@ -221,6 +273,63 @@ class Codex(DikteTest):
|
||||
self.run_cleanup(stdout="tokens used 400", last_message="")
|
||||
|
||||
|
||||
class Antigravity(DikteTest):
|
||||
def setUp(self):
|
||||
super().setUp()
|
||||
self.conf = self.config(cleanup_provider="agy")
|
||||
self.patch_attr(cleanup.shutil, "which", lambda name: f"/usr/bin/{name}")
|
||||
|
||||
def run_cleanup(self, text="uh, book it", **kwargs):
|
||||
patcher, calls = fake_cli(**kwargs)
|
||||
with patcher:
|
||||
answer = cleanup.run(text, self.conf, "the rules")
|
||||
return answer, calls[0]
|
||||
|
||||
def test_the_rules_ride_in_front_of_the_transcript(self):
|
||||
answer, cmd = self.run_cleanup(stdout="Book it.\n")
|
||||
self.assertEqual(answer, "Book it.")
|
||||
self.assertEqual(cmd[0], "agy")
|
||||
self.assertEqual(cmd[cmd.index("-p") + 1],
|
||||
"the rules\n\n---\n\n<transcript>\nuh, book it\n</transcript>")
|
||||
|
||||
def test_it_starts_somewhere_of_its_own_and_takes_no_slash_commands(self):
|
||||
"""Without --new-project agy works in whichever project it was last in."""
|
||||
_, cmd = self.run_cleanup(stdout="Book it.")
|
||||
self.assertIn("--new-project", cmd)
|
||||
self.assertIn("--disable-slash-commands", cmd)
|
||||
self.assertEqual(cmd[cmd.index("--output-format") + 1], "text")
|
||||
|
||||
def test_it_is_not_left_to_give_up_before_the_caller_does(self):
|
||||
_, cmd = self.run_cleanup(stdout="Book it.")
|
||||
self.assertEqual(cmd[cmd.index("--print-timeout") + 1], "180s")
|
||||
|
||||
def test_the_model_is_left_alone_until_one_is_typed_in(self):
|
||||
_, cmd = self.run_cleanup(stdout="Book it.")
|
||||
self.assertNotIn("--model", cmd)
|
||||
self.conf["cleanup_agy_model"] = "gemini-3.7-flash-low"
|
||||
_, cmd = self.run_cleanup(stdout="Book it.")
|
||||
self.assertEqual(cmd[cmd.index("--model") + 1], "gemini-3.7-flash-low")
|
||||
|
||||
def test_the_thinking_setting_lands_on_the_nearest_rung_agy_has(self):
|
||||
self.conf["cleanup_reasoning"] = "max"
|
||||
_, cmd = self.run_cleanup(stdout="Book it.")
|
||||
self.assertEqual(cmd[cmd.index("--effort") + 1], "high")
|
||||
|
||||
def test_no_thinking_setting_means_no_flag(self):
|
||||
_, cmd = self.run_cleanup(stdout="Book it.")
|
||||
self.assertNotIn("--effort", cmd)
|
||||
|
||||
def test_an_answer_of_nothing_is_a_failure_rather_than_an_empty_paste(self):
|
||||
with self.assertRaises(cleanup.CleanupError):
|
||||
self.run_cleanup(stdout=" ")
|
||||
|
||||
def test_a_program_that_is_not_installed_says_so_before_running_anything(self):
|
||||
self.patch_attr(cleanup.shutil, "which", lambda name: "")
|
||||
with self.assertRaises(cleanup.CleanupError) as caught:
|
||||
self.run_cleanup(stdout="Book it.")
|
||||
self.assertIn("agy", str(caught.exception))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
||||
|
||||
@@ -15,6 +15,7 @@ from typing import ClassVar
|
||||
from unittest import mock
|
||||
|
||||
from dikte import audio
|
||||
from dikte import cleanup
|
||||
from dikte import cli
|
||||
from dikte import config as cfg
|
||||
from dikte import ggml
|
||||
@@ -503,6 +504,26 @@ class Doctor(DikteTest):
|
||||
self.assertIn("OpenRouter key, cleaning up on some/model",
|
||||
self.run_doctor(as_json=False, cleanup_model="some/model"))
|
||||
|
||||
def test_it_survives_every_provider_cleanup_can_be_set_to(self):
|
||||
"""It used to raise KeyError on the local model, whose executable is ""."""
|
||||
for name in cleanup.PROVIDERS:
|
||||
with self.subTest(provider=name):
|
||||
reply = self.run_doctor(cleanup_provider=name)
|
||||
self.assertEqual(reply["cleanup"]["provider"], name)
|
||||
self.run_doctor(as_json=False, cleanup_provider=name)
|
||||
|
||||
def test_a_provider_with_no_key_to_check_says_so_rather_than_no(self):
|
||||
"""A CLI needs none, so `false` there would read as one gone missing."""
|
||||
self.assertIsNone(self.run_doctor(cleanup_provider="claude")["cleanup"]["key"])
|
||||
self.assertIsNone(self.run_doctor(cleanup_provider="local")["cleanup"]["key"])
|
||||
self.assertIs(self.run_doctor(cleanup_provider="gemini")["cleanup"]["key"],
|
||||
False)
|
||||
|
||||
def test_cleanup_on_google_is_a_question_about_its_own_key(self):
|
||||
line = self.run_doctor(as_json=False, cleanup_provider="gemini",
|
||||
cleanup_gemini_model="gemini-2.5-flash")
|
||||
self.assertIn("Google AI Studio key, cleaning up on gemini-2.5-flash", line)
|
||||
|
||||
def test_it_asks_after_the_programs_this_desktop_actually_uses(self):
|
||||
"""A missing ydotool on a Mac is a red mark with nothing behind it."""
|
||||
with mock.patch.object(cli.paste, "desktop", return_value=paste.MACOS):
|
||||
|
||||
@@ -187,6 +187,8 @@ class Keys(DikteTest):
|
||||
def test_every_provider_falls_back_to_the_variable_of_its_own_name(self):
|
||||
with mock.patch.dict(os.environ, {"GROQ_API_KEY": "gsk-env"}):
|
||||
self.assertEqual(cfg.Config().groq_key(), "gsk-env")
|
||||
with mock.patch.dict(os.environ, {"GEMINI_API_KEY": "AIza-env"}):
|
||||
self.assertEqual(cfg.Config().gemini_key(), "AIza-env")
|
||||
|
||||
|
||||
class TranscribeTarget(DikteTest):
|
||||
@@ -574,6 +576,12 @@ class Defaults(unittest.TestCase):
|
||||
def test_the_keys_ship_empty(self):
|
||||
self.assertEqual(cfg.DEFAULTS["openai_api_key"], "")
|
||||
self.assertEqual(cfg.DEFAULTS["openrouter_api_key"], "")
|
||||
self.assertEqual(cfg.DEFAULTS["gemini_api_key"], "")
|
||||
|
||||
def test_google_ai_studio_is_a_cleanup_provider_and_not_a_transcriber(self):
|
||||
"""Its compatible endpoint has no /audio/transcriptions behind it."""
|
||||
self.assertNotIn("gemini", cfg.TRANSCRIBERS)
|
||||
self.assertIn("gemini", cleanup.PROVIDERS)
|
||||
|
||||
def test_every_language_specific_prompt_has_both_languages(self):
|
||||
for name in ("CLEANUP_PROMPT", "FILE_CLEANUP_PROMPT", "MEETING_PROMPT",
|
||||
|
||||
+95
-1
@@ -28,6 +28,11 @@ from dikte import settings_ui
|
||||
from dikte import update
|
||||
from tests.support import DikteTest, only_these_tools
|
||||
|
||||
# The harness below replaces this method on the class so that opening a window
|
||||
# in a test never calls anybody; taken here, before any test runs, so the two
|
||||
# tests about what it does when called still have the real one.
|
||||
REAL_LOAD_HOSTED_MODELS = settings_ui.SettingsWindow._load_hosted_models
|
||||
|
||||
# One application for the whole run; Qt allows no second one.
|
||||
_app = QApplication.instance() or QApplication([])
|
||||
|
||||
@@ -51,6 +56,7 @@ CHANGED = {
|
||||
"openai_api_key": "sk-test-key",
|
||||
"groq_api_key": "gsk-test-key",
|
||||
"openrouter_api_key": "sk-or-test-key",
|
||||
"gemini_api_key": "AIza-test-key",
|
||||
"transcribe_provider": "openrouter",
|
||||
"transcribe_model": "whisper-1",
|
||||
"groq_transcribe_model": "whisper-large-v3",
|
||||
@@ -60,6 +66,8 @@ CHANGED = {
|
||||
"cleanup_model": "some/other-model",
|
||||
"cleanup_claude_model": "opus",
|
||||
"cleanup_codex_model": "gpt-5",
|
||||
"cleanup_gemini_model": "gemini-2.5-flash",
|
||||
"cleanup_agy_model": "gemini-3.1-pro-low",
|
||||
"cleanup_reasoning": "high",
|
||||
"local_model": "ggml-small.bin",
|
||||
"local_gpu": False,
|
||||
@@ -79,6 +87,7 @@ CHANGED = {
|
||||
"assistant_codex_model": "gpt-5",
|
||||
"assistant_codex_sandbox": "read-only",
|
||||
"assistant_openrouter_model": "some/agent-model",
|
||||
"assistant_agy_model": "gemini-3.1-pro-low",
|
||||
"assistant_reasoning": "high",
|
||||
"assistant_dir": "/tmp",
|
||||
"assistant_timeout": 600,
|
||||
@@ -136,6 +145,10 @@ class Settings(DikteTest):
|
||||
"_load_transcribe_models"))
|
||||
self.enterContext(mock.patch.object(settings_ui.SettingsWindow,
|
||||
"_load_codex_models"))
|
||||
self.enterContext(mock.patch.object(settings_ui.SettingsWindow,
|
||||
"_load_agy_models"))
|
||||
self.enterContext(mock.patch.object(settings_ui.SettingsWindow,
|
||||
"_load_hosted_models"))
|
||||
# The local model boxes fetch their own list the moment they are shown,
|
||||
# from a thread, which is nobody's test failing but a real request.
|
||||
self.enterContext(mock.patch.object(settings_ui.LocalModelBox,
|
||||
@@ -285,6 +298,53 @@ class Settings(DikteTest):
|
||||
self.assertEqual(window.cleanup_codex_model.currentText(),
|
||||
"my-own-model")
|
||||
|
||||
def test_agy_answering_refills_both_of_its_boxes(self):
|
||||
"""The same arrangement as Codex: both boxes, nothing chosen is lost."""
|
||||
conf = self.config(cleanup_agy_model="my-own-model")
|
||||
window = self.window(conf)
|
||||
window._on_agy_models_loaded(["gemini-4-flash-low", "gemini-4-pro-low"])
|
||||
for combo in (window.cleanup_agy_model, window.assistant_agy_model):
|
||||
with self.subTest(combo=combo.objectName() or "combo"):
|
||||
offered = [combo.itemText(i) for i in range(combo.count())]
|
||||
self.assertEqual(offered[1:],
|
||||
["gemini-4-flash-low", "gemini-4-pro-low"])
|
||||
self.assertEqual(window.cleanup_agy_model.currentText(), "my-own-model")
|
||||
|
||||
def test_openrouter_s_list_arriving_at_open_refills_cleanup_and_meetings(self):
|
||||
conf = self.config(cleanup_model="my/own-model")
|
||||
window = self.window(conf)
|
||||
window._on_hosted_models_loaded("openrouter", ["a/one", "b/two"])
|
||||
for combo in (window.cleanup_model, window.meeting_model):
|
||||
with self.subTest(combo=combo.objectName() or "combo"):
|
||||
offered = [combo.itemText(i) for i in range(combo.count())]
|
||||
self.assertEqual(offered, ["a/one", "b/two"])
|
||||
self.assertEqual(window.cleanup_model.currentText(), "my/own-model")
|
||||
|
||||
def test_google_s_list_arriving_at_open_refills_its_own_box_only(self):
|
||||
window = self.window(self.config(cleanup_gemini_model="gemini-x"))
|
||||
before = window.cleanup_model.count()
|
||||
window._on_hosted_models_loaded("gemini", ["gemini-4-flash"])
|
||||
offered = [window.cleanup_gemini_model.itemText(i)
|
||||
for i in range(window.cleanup_gemini_model.count())]
|
||||
self.assertEqual(offered, ["gemini-4-flash"])
|
||||
self.assertEqual(window.cleanup_gemini_model.currentText(), "gemini-x")
|
||||
self.assertEqual(window.cleanup_model.count(), before)
|
||||
|
||||
def test_no_key_no_call_home_at_open(self):
|
||||
"""Opening Settings is not consent to be talked about to two vendors."""
|
||||
window = self.window(self.config())
|
||||
with mock.patch.dict(os.environ, {}, clear=True), \
|
||||
mock.patch.object(settings_ui.threading, "Thread") as thread:
|
||||
REAL_LOAD_HOSTED_MODELS(window)
|
||||
thread.assert_not_called()
|
||||
|
||||
def test_a_key_on_file_is_fetched_with_at_open(self):
|
||||
window = self.window(self.config(openrouter_api_key="sk-or-x",
|
||||
gemini_api_key="AIza-x"))
|
||||
with mock.patch.object(settings_ui.threading, "Thread") as thread:
|
||||
REAL_LOAD_HOSTED_MODELS(window)
|
||||
self.assertEqual(thread.call_count, 2)
|
||||
|
||||
def test_the_update_line_names_the_version_that_is_running(self):
|
||||
window = self.window(cfg.Config())
|
||||
self.assertIn(settings_ui.__version__, window.update_status.text())
|
||||
@@ -1013,7 +1073,11 @@ class MeetingSources(DikteTest):
|
||||
mock.patch.object(settings_ui.SettingsWindow,
|
||||
"_load_transcribe_models"), \
|
||||
mock.patch.object(settings_ui.SettingsWindow,
|
||||
"_load_codex_models"):
|
||||
"_load_codex_models"), \
|
||||
mock.patch.object(settings_ui.SettingsWindow,
|
||||
"_load_agy_models"), \
|
||||
mock.patch.object(settings_ui.SettingsWindow,
|
||||
"_load_hosted_models"):
|
||||
window = settings_ui.SettingsWindow(cfg.Config())
|
||||
self.addCleanup(window.deleteLater)
|
||||
self.addCleanup(window.close)
|
||||
@@ -1045,6 +1109,10 @@ class LocalModels(DikteTest):
|
||||
# And one with Codex on it would ask it for its model list.
|
||||
self.enterContext(mock.patch.object(settings_ui.SettingsWindow,
|
||||
"_load_codex_models"))
|
||||
self.enterContext(mock.patch.object(settings_ui.SettingsWindow,
|
||||
"_load_agy_models"))
|
||||
self.enterContext(mock.patch.object(settings_ui.SettingsWindow,
|
||||
"_load_hosted_models"))
|
||||
|
||||
def window(self, conf):
|
||||
window = settings_ui.SettingsWindow(conf)
|
||||
@@ -1125,3 +1193,29 @@ class LocalModels(DikteTest):
|
||||
self.assertFalse(window.cleanup_form.isRowVisible(window.cleanup_model_row))
|
||||
# Its own thinking box, because the two default to opposite things.
|
||||
self.assertFalse(window.cleanup_form.isRowVisible(window.cleanup_reasoning))
|
||||
|
||||
def test_each_cleaner_brings_its_own_model_row_and_no_other(self):
|
||||
window = self.window(cfg.Config())
|
||||
rows = {"openrouter": window.cleanup_model_row,
|
||||
"gemini": window.cleanup_gemini_model_row,
|
||||
"claude": window.cleanup_claude_model,
|
||||
"codex": window.cleanup_codex_model,
|
||||
"agy": window.cleanup_agy_model}
|
||||
for chosen, row in rows.items():
|
||||
with self.subTest(provider=chosen):
|
||||
window._select_data(window.cleanup_provider, chosen)
|
||||
for name, other in rows.items():
|
||||
self.assertEqual(window.cleanup_form.isRowVisible(other),
|
||||
name == chosen)
|
||||
|
||||
def test_each_agent_brings_its_own_box_and_no_other(self):
|
||||
window = self.window(cfg.Config())
|
||||
boxes = {"claude": window.claude_box, "codex": window.codex_box,
|
||||
"agy": window.agy_box, "openrouter": window.openrouter_box}
|
||||
for chosen, box in boxes.items():
|
||||
with self.subTest(provider=chosen):
|
||||
window._select_data(window.assistant_provider, chosen)
|
||||
for name, other in boxes.items():
|
||||
# isHidden rather than isVisible: the window itself is never
|
||||
# shown in a test, so nothing in it is ever visible.
|
||||
self.assertEqual(other.isHidden(), name != chosen)
|
||||
|
||||
Reference in New Issue
Block a user