run.id));", source)
- self.assertIn("_resolveNewlyCreatedRun(name, knownRunIds)", source)
- self.assertIn("_resolveNewlyCreatedRun(name, previousRunIds = new Set())", source)
- self.assertIn("const newlyDiscovered = this._runs.filter((run) => !previousRunIds.has(run.id));", source)
-
- def test_panel_cultivar_search_clears_stale_selection_and_ignores_old_responses(self):
- source = PANEL_JS.read_text(encoding="utf-8")
- self.assertIn("this._wizard.selected_cultivar = null;", source)
- self.assertIn('type: "plantrun/search_cultivar"', source)
- self.assertIn("this._suggestionCache = new Map();", source)
- self.assertIn("if (searchKey === this._lastSearchKey) return;", source)
- self.assertIn("const requestNonce = ++this._searchNonce;", source)
- self.assertIn("if (requestNonce !== this._searchNonce) return;", source)
- self.assertIn("this._renderSuggestionsOnly();", source)
-
- def test_panel_wizard_input_updates_do_not_render_while_typing(self):
- source = PANEL_JS.read_text(encoding="utf-8")
- self.assertIn("_handleInput(event)", source)
- self.assertIn("this._wizard = { ...this._wizard, [field]: target.value };", source)
- self.assertIn('this._wizard.target_days = "";', source)
- handle_input = source[source.index("_handleInput(event)") : source.index("_handleChange(event)")]
- self.assertNotIn("this.render()", handle_input)
-
- def test_panel_sensor_tap_attempts_native_history_deeplink_before_modal_fallback(self):
- source = PANEL_JS.read_text(encoding="utf-8")
- self.assertIn("Tap a sensor to inspect its run window.", source)
- self.assertIn("_renderHistoryInspector()", source)
- self.assertIn('type: "plantrun/get_run_binding_history_context"', source)
- self.assertIn("const EXPERIMENTAL_NATIVE_HISTORY_DEEPLINK = true;", source)
- self.assertIn("window.history.pushState(null, \"\", `/history?${params.toString()}`);", source)
- self.assertIn('data-action="open-native-history"', source)
-
- def test_panel_phase_control_is_canonical_timeline_with_confirmation(self):
- source = PANEL_JS.read_text(encoding="utf-8")
- self.assertIn('const CANONICAL_STAGES = ["Seedling", "Vegetative", "Flowering", "Harvested"]', source)
- self.assertIn('Phase
', source)
- self.assertIn('data-action="select-phase"', source)
- self.assertIn("_renderPhaseConfirmModal()", source)
- self.assertIn('data-action="confirm-phase-change"', source)
- self.assertNotIn("window.confirm(", source)
- self.assertNotIn("minus the cursed browser popup", source)
-
- def test_panel_binding_metric_changes_force_picker_refresh_and_edit_existing_bindings(self):
- source = PANEL_JS.read_text(encoding="utf-8")
- self.assertIn('data-action="edit-binding"', source)
- self.assertIn('this._openBinding(target.dataset.runId, target.dataset.bindingId);', source)
- self.assertIn('this._bindingDraft = binding', source)
- self.assertIn('this.render();', source)
-
- def test_panel_detail_editor_sends_explicit_nulls_when_fields_are_cleared(self):
- source = PANEL_JS.read_text(encoding="utf-8")
- self.assertIn("planted_date: draft.planted_date || null,", source)
- self.assertIn("notes_summary: draft.notes_summary || null,", source)
- self.assertIn('dry_yield_grams: draft.dry_yield_grams === "" ? null : Number(draft.dry_yield_grams),', source)
-
- def test_panel_detail_editor_persists_target_days_and_keeps_dialog_open_on_error(self):
- source = PANEL_JS.read_text(encoding="utf-8")
- self.assertIn("const targetDays = Number(draft.target_days || this._derivedTargetDays(draft.selected_cultivar));", source)
- self.assertIn("...(this._runs.find((item) => item.id === draft.run_id)?.base_config || {}),", source)
- self.assertIn("target_days: targetDays,", source)
- self.assertIn("this._detailDraft = null;", source)
- self.assertIn("this._error = err?.message || \"Unable to save run changes.\";", source)
-
- def test_panel_hero_uses_seedfinder_image_when_available(self):
- source = PANEL_JS.read_text(encoding="utf-8")
- self.assertIn("_heroMediaStyle(run)", source)
- self.assertIn('run.image_url ? " has-image" : ""', source)
- self.assertIn(".hero.has-image", source)
- self.assertIn("var(--hero-image)", source)
+ def test_panel_keeps_a_small_authenticated_transport_interface(self):
+ source = PANEL_API_JS.read_text(encoding="utf-8")
+ self.assertIn('type: "plantrun/get_state"', source)
+ self.assertIn('type: "plantrun/command"', source)
+ self.assertIn("async getState()", source)
+ self.assertIn("async command(command, payload = {})", source)
+ self.assertIn("async searchCultivar(breeder, query)", source)
+ self.assertIn("async getRecorderHistory(entityId, start, end)", source)
+ self.assertNotIn("callService", source)
+
+ def test_panel_uses_production_modules_and_no_prototype_fixtures(self):
+ source = PANEL_ENTRY_JS.read_text(encoding="utf-8")
+ for module in ("api", "dialogs", "domain", "styles", "views"):
+ self.assertIn(f'from "./plantrun-panel-{module}.js?v=0.7.0"', source)
+ self.assertNotIn('from "./prototype/', source.lower())
+ self.assertNotIn("Tangerine Dream Auto", source)
+ self.assertNotIn("Diesel Auto", source)
+
+ def test_state_normalizer_supports_first_class_and_embedded_records(self):
+ source = PANEL_DOMAIN_JS.read_text(encoding="utf-8")
+ self.assertIn("export function normalizeState(payload)", source)
+ self.assertIn("source.plants", source)
+ self.assertIn("run?.plant", source)
+ self.assertIn("source.journal_entries", source)
+ self.assertIn("run?.journal_entries", source)
+ self.assertIn("one plant", source.lower())
+ self.assertIn("source.sensor_bindings", source)
+ self.assertIn('owner === "run" ? "plant"', source)
+
+ def test_overview_is_tent_first_and_plant_dominant(self):
+ source = PANEL_VIEWS_JS.read_text(encoding="utf-8")
+ self.assertIn('class="tent-overview"', source)
+ self.assertIn('class="plant-gallery"', source)
+ self.assertIn('data-action="open-run"', source)
+ self.assertIn("Nächste Schätzung", source)
+ self.assertIn("Noch kein Pflanzenfoto", source)
+
+ def test_workspace_matches_accepted_information_order(self):
+ source = panel_source()
+ for text in (
+ "Lebenszyklus",
+ "Recorder-Verlauf",
+ "Zielbereich",
+ "Minimum",
+ "Durchschnitt",
+ "Maximum",
+ "Feste Daten",
+ "Letzter Journaleintrag",
+ ):
+ self.assertIn(text, source)
+ self.assertIn('data-action="select-metric"', source)
+ self.assertIn('data-action="select-stage"', source)
+ self.assertIn("PlantRun zeichnet keine erfundenen Messwerte.", source)
+
+ def test_frontend_uses_recorded_stage_history_and_real_archive_end(self):
+ domain = PANEL_DOMAIN_JS.read_text(encoding="utf-8")
+ views = PANEL_VIEWS_JS.read_text(encoding="utf-8")
+ self.assertIn("export function recordedStages(run)", domain)
+ self.assertIn("run?.stage_history", domain)
+ self.assertIn("recorded.has(stage.toLowerCase())", views)
+ self.assertIn("run?.ended_at || run?.archived_at", domain)
+ self.assertIn("runEnd(b) || 0", views)
+ self.assertIn("daysSince(runStart(run), runEnd(run))", views)
+
+ def test_energy_is_bindable_and_unbound_metrics_have_an_honest_owner_label(self):
+ domain = PANEL_DOMAIN_JS.read_text(encoding="utf-8")
+ panel = PANEL_ENTRY_JS.read_text(encoding="utf-8")
+ views = PANEL_VIEWS_JS.read_text(encoding="utf-8")
+ self.assertIn('{ key: "energy", label: "Energie"', domain)
+ self.assertIn('energy: ["energy", "kwh", "wh"]', panel.lower())
+ self.assertIn('itemBinding ? (itemBinding.owner_type === "tent" ? "Zelt" : "Pflanze") : "Nicht zugeordnet"', views)
+
+ def test_create_flow_is_three_steps_for_one_plant_and_one_run(self):
+ source = panel_source()
+ self.assertIn("1. Sorte und Pflanze", source)
+ self.assertIn("2. Ablauf und Sensoren", source)
+ self.assertIn("3. Prüfen und anlegen", source)
+ self.assertIn('command("create_run"', source)
+ self.assertIn("plant_name:", source)
+ self.assertIn("initial_stage:", source)
+ self.assertIn("stage_plan:", source)
+ self.assertIn("container:", source)
+ self.assertIn("substrate:", source)
+ self.assertIn("light_schedule:", source)
+ self.assertNotIn("Add plant", source)
+
+ def test_seedfinder_preview_does_not_import_until_confirmed(self):
+ panel = PANEL_ENTRY_JS.read_text(encoding="utf-8")
+ dialogs = PANEL_DIALOGS_JS.read_text(encoding="utf-8")
+ preview_start = panel.index("_previewCultivar(index)")
+ apply_start = panel.index("_applyCultivarPreview()")
+ self.assertNotIn("this._createDraft.strain =", panel[preview_start:apply_start])
+ self.assertIn("this._createDraft.strain =", panel[apply_start:])
+ self.assertIn("this._cultivarPreview", dialogs)
+ self.assertIn("Angaben übernehmen", dialogs)
+
+ def test_journal_is_history_first_with_on_demand_editor(self):
+ source = panel_source()
+ self.assertIn("Verlauf zuerst", source)
+ self.assertIn('data-action="open-journal-editor"', source)
+ self.assertIn('class="journal-drawer"', source)
+ self.assertIn('"create_journal_entry"', source)
+ self.assertIn('this._command(command, {', source)
+ self.assertIn("occurred_at:", source)
+ self.assertIn("run_ids:", source)
+ self.assertIn("const tentEntries", source)
+ self.assertIn("Sensorkontext wird beim Speichern angehängt", source)
+
+ def test_stage_change_is_direct_and_timestamped(self):
+ source = panel_source()
+ self.assertIn('data-action="select-stage"', source)
+ self.assertIn('data-stage-occurred-at', source)
+ self.assertIn('command("change_stage"', source)
+ self.assertIn("occurred_at:", source)
+
+ def test_archive_and_permanent_deletion_are_separate(self):
+ source = panel_source()
+ self.assertIn('command("archive_run"', source)
+ self.assertIn('command("delete_run"', source)
+ self.assertIn("Dauerhaft löschen", source)
+ self.assertIn("Diese Aktion kann nicht rückgängig gemacht werden.", source)
+ self.assertIn("confirmation_name:", source)
+ self.assertIn('data-delete-confirmation', source)
+ self.assertNotIn("vollständig lesbar und bearbeitbar", source)
+
+ def test_styles_follow_shape_mobile_focus_and_motion_contracts(self):
+ styles = PANEL_STYLES_JS.read_text(encoding="utf-8")
+ for token in ("--radius-work:24px", "--radius-group:18px", "--radius-control:12px"):
+ self.assertIn(token, styles)
+ self.assertIn("@media(max-width:720px)", styles)
+ self.assertIn("@media(prefers-reduced-motion:reduce)", styles)
+ self.assertIn(":focus-visible", styles)
+ self.assertIn(".mobile-nav", styles)
+
+ def test_lovelace_card_and_editor_remain_registered(self):
+ card = CARD_JS.read_text(encoding="utf-8")
+ editor = EDITOR_JS.read_text(encoding="utf-8")
+ self.assertIn('const TAG = "plantrun-card"', card)
+ self.assertIn("customElements.define(TAG, PlantRunCard)", card)
+ self.assertIn('const TAG = "plantrun-card-editor"', editor)
+ self.assertIn("customElements.define(TAG, PlantRunCardEditor)", editor)
if __name__ == "__main__":
diff --git a/tests/test_dashboard_panel_interactions.py b/tests/test_dashboard_panel_interactions.py
index 06fd28d..6eb4183 100644
--- a/tests/test_dashboard_panel_interactions.py
+++ b/tests/test_dashboard_panel_interactions.py
@@ -7,122 +7,97 @@ class DashboardPanelInteractionRegressionTests(unittest.TestCase):
def setUp(self):
self.source = load_panel_source()
- def test_short_tap_and_long_press_are_single_fire_paths(self):
- assert_has_snippets(
- self,
- self.source,
- [
- "this._pressState[key].longPressTriggered = true;",
- "this._openEntity(tile.dataset.entityId);",
- "const wasLongPress = !!state.longPressTriggered;",
- "if (!wasLongPress) this._openRunHistory(tile.dataset.runId, tile.dataset.entityId);",
- "binding_id: binding?.id || \"\"",
- 'type: "plantrun/get_run_binding_history_context"',
- "if (this._openNativeHistory(context)) return;",
- "delete this._pressState[key];",
- ],
- )
-
- def test_rapid_sensor_interactions_clear_prior_timer(self):
- assert_has_snippets(
- self,
- self.source,
- [
- 'if (event.target.closest("button, input, select, textarea, ha-selector")) return;',
- "const current = this._pressState[key];",
- "if (current?.timer) window.clearTimeout(current.timer);",
- "_handlePointerCancel(event)",
- "if (state?.timer) window.clearTimeout(state.timer);",
- ],
- )
-
- def test_delegated_clicks_are_scoped_to_shadow_root_actions(self):
- assert_has_snippets(
- self,
- self.source,
- [
- 'this.shadowRoot.addEventListener("click", this._boundClick);',
- 'const target = event.target.closest("[data-action]");',
- "if (!target || !this.shadowRoot.contains(target)) return;",
- "event.preventDefault();",
- ],
- )
-
- def test_modal_backdrops_close_dialogs_without_inputs_triggering_overlay_close(self):
- assert_has_snippets(
- self,
- self.source,
- [
- '',
- 'class="overlay-backdrop" data-action="close-wizard"',
- 'class="overlay-backdrop" data-action="close-binding"',
- 'class="overlay-backdrop" data-action="close-note-edit"',
- 'class="overlay-backdrop" data-action="close-note-delete"',
- 'class="overlay-backdrop" data-action="close-edit"',
- 'class="overlay-backdrop" data-action="close-history"',
- ],
- )
-
- def test_binding_tiles_expose_explicit_edit_action_and_filtered_picker_states(self):
- assert_has_snippets(
- self,
- self.source,
- [
- 'data-action="edit-binding"',
- 'No compatible Home Assistant sensors found',
- 'This sensor no longer matches the selected metric.',
- 'this._openBinding(target.dataset.runId, target.dataset.bindingId);',
- ],
- )
-
- def test_modal_overlays_are_scoped_to_panel_host(self):
- assert_has_snippets(
- self,
- self.source,
- [
- ":host { display:block; min-height:100%;",
- ".overlay { position:absolute; inset:0; z-index:20;",
- ".overlay-backdrop { position:absolute; inset:0;",
- "position:relative;",
- ],
- )
-
- def test_decorative_stage_art_does_not_steal_pointer_input(self):
- assert_has_snippets(
- self,
- self.source,
- [
- ".stage-glyph { position:absolute;",
- "pointer-events:none;",
- ".sensor-tile {",
- "touch-action:manipulation;",
- ".metric-badge { display:grid; place-items:center;",
- ],
- )
-
- def test_sound_feedback_is_user_gated_and_disableable(self):
- assert_has_snippets(
- self,
- self.source,
- [
- 'localStorage.getItem(STORAGE.sound) === "on"',
- 'data-action="toggle-sound"',
- "_clickSound()",
- "if (!this._sound) return;",
- ],
- )
-
- def test_theme_toggle_is_binary_and_has_local_light_dark_tokens(self):
- assert_has_snippets(
- self,
- self.source,
- [
- 'this._theme = localStorage.getItem(STORAGE.theme) || (window.matchMedia?.(THEME_QUERY).matches ? "light" : "dark")',
- 'this._theme = this._resolvedTheme() === "dark" ? "light" : "dark";',
- '.app.theme-light {',
- '.app.theme-dark {',
- ],
- )
+ def test_delegated_events_stay_inside_shadow_root(self):
+ assert_has_snippets(self, self.source, [
+ 'this.shadowRoot.addEventListener("click", this._boundClick);',
+ 'const action = event.target.closest("[data-action]");',
+ "if (!action || !this.shadowRoot.contains(action)) return;",
+ 'this.shadowRoot.addEventListener("keydown", this._boundKeydown);',
+ ])
+
+ def test_command_busy_state_and_mutation_errors_stay_recoverable(self):
+ assert_has_snippets(self, self.source, [
+ "this._busy = true;",
+ "this._busy = false;",
+ 'role="alert"',
+ "const message = error?.message",
+ "this._dialogError = message;",
+ "this._toast = message;",
+ ])
+ self.assertIn('this._error = error?.message || "Home Assistant hat keinen PlantRun-Zustand geliefert.";', self.source)
+
+ def test_create_flow_keeps_initial_stage_in_the_plan(self):
+ assert_has_snippets(self, self.source, [
+ 'target.dataset.createField === "initial_stage"',
+ "this._createDraft.stage_plan.includes(target.value)",
+ "stage === draft.initial_stage ? \"disabled\" : \"\"",
+ "if (stage === this._createDraft.initial_stage && !target.checked)",
+ ])
+
+ def test_cultivar_result_preview_requires_explicit_import(self):
+ assert_has_snippets(self, self.source, [
+ 'data-action="preview-cultivar"',
+ 'data-action="apply-cultivar"',
+ "this._previewCultivar(Number(action.dataset.index));",
+ "this._applyCultivarPreview();",
+ "_previewCultivar(index)",
+ "_applyCultivarPreview()",
+ "Angaben übernehmen",
+ ])
+
+ def test_recorder_fetch_ignores_stale_metric_requests(self):
+ assert_has_snippets(self, self.source, [
+ "const nonce = ++this._historyNonce;",
+ "if (nonce !== this._historyNonce) return;",
+ "this._api.getRecorderHistory(",
+ "this._historyPoints = points;",
+ ])
+
+ def test_dialogs_use_real_modal_semantics_and_backdrops(self):
+ assert_has_snippets(self, self.source, [
+ 'role="dialog"',
+ 'aria-modal="true"',
+ 'class="modal-backdrop"',
+ 'data-action="close-dialog"',
+ 'data-action="close-journal-editor"',
+ ])
+
+ def test_keyboard_shortcut_saves_journal_only_in_editor(self):
+ assert_has_snippets(self, self.source, [
+ 'event.key === "Enter"',
+ "event.ctrlKey || event.metaKey",
+ 'this._journalEditorOpen',
+ 'this._saveJournalEntry();',
+ ])
+
+ def test_sensor_bindings_can_be_reassigned_or_ended(self):
+ assert_has_snippets(self, self.source, [
+ 'data-action="open-binding-editor"',
+ 'this._command("set_binding"',
+ 'this._command("clear_binding"',
+ 'data-action="clear-binding"',
+ ])
+
+ def test_new_journal_entry_captures_current_bound_sensor_values(self):
+ assert_has_snippets(self, self.source, [
+ "_sensorSnapshot(run)",
+ "sensor_snapshot:",
+ "snapshot.captured_at = capturedAt;",
+ "entry?.sensor_snapshot",
+ ])
+
+ def test_snapshot_capture_time_is_metadata_not_a_sensor_value(self):
+ assert_has_snippets(self, self.source, [
+ 'key !== "captured_at"',
+ "contextRows.length",
+ ])
+
+ def test_delete_button_requires_exact_run_name(self):
+ assert_has_snippets(self, self.source, [
+ "confirmation !== this._runName(run)",
+ 'data-action="confirm-delete-run"',
+ "confirmation_name: confirmation",
+ ])
if __name__ == "__main__":
diff --git a/tests/test_domain_v3.py b/tests/test_domain_v3.py
new file mode 100644
index 0000000..7b863bf
--- /dev/null
+++ b/tests/test_domain_v3.py
@@ -0,0 +1,555 @@
+import unittest
+import json
+from datetime import datetime, timedelta, timezone
+from importlib.util import module_from_spec, spec_from_file_location
+from pathlib import Path
+
+
+DOMAIN_PATH = (
+ Path(__file__).resolve().parents[1]
+ / "custom_components"
+ / "plantrun"
+ / "domain.py"
+)
+SPEC = spec_from_file_location("plantrun_domain", DOMAIN_PATH)
+assert SPEC and SPEC.loader
+DOMAIN = module_from_spec(SPEC)
+SPEC.loader.exec_module(DOMAIN)
+
+BindingDraft = DOMAIN.BindingDraft
+JournalDraft = DOMAIN.JournalDraft
+PlantRunDomain = DOMAIN.PlantRunDomain
+RunDraft = DOMAIN.RunDraft
+SourcedDuration = DOMAIN.SourcedDuration
+StrainIdentity = DOMAIN.StrainIdentity
+
+
+UTC = timezone.utc
+PLANTED_AT = datetime(2026, 8, 25, 14, 0, tzinfo=UTC)
+NOW = datetime(2026, 8, 25, 18, 0, tzinfo=UTC)
+
+
+class PrefixIds:
+ def __init__(self) -> None:
+ self._counts: dict[str, int] = {}
+
+ def __call__(self, prefix: str) -> str:
+ count = self._counts.get(prefix, 0) + 1
+ self._counts[prefix] = count
+ return f"{prefix}-{count}"
+
+
+def make_domain() -> PlantRunDomain:
+ return PlantRunDomain(clock=lambda: NOW, id_factory=PrefixIds())
+
+
+def create_minimal_run(domain: PlantRunDomain, name: str = "Diesel Auto RQS"):
+ return domain.create_run(
+ RunDraft(
+ run_name=name,
+ tent_name="Growzelt",
+ plant_name=name,
+ planted_at=PLANTED_AT,
+ stage_plan=("Germination", "Seedling", "Flowering", "Harvested"),
+ initial_stage="Germination",
+ )
+ )
+
+
+class TestRunCreation(unittest.TestCase):
+ def test_creates_one_plant_run_with_sourced_duration_and_dated_bindings(self) -> None:
+ domain = make_domain()
+ duration = SourcedDuration(
+ minimum_days=90,
+ maximum_days=95,
+ meaning="seed to harvest",
+ start_event="germination",
+ source="https://example.test/diesel-auto",
+ original_wording="90-95 days after germination",
+ )
+
+ run = domain.create_run(
+ RunDraft(
+ run_name="Diesel Auto RQS",
+ tent_name="Growzelt",
+ plant_name="Diesel Auto",
+ planted_at=PLANTED_AT,
+ stage_plan=("Germination", "Seedling", "Vegetative", "Flowering", "Harvested"),
+ initial_stage="Germination",
+ strain=StrainIdentity(
+ name="Diesel Auto",
+ breeder="Royal Queen Seeds",
+ duration=duration,
+ ),
+ container="7 L final container",
+ substrate="All-Mix soil",
+ light_schedule="20:00 to 14:00, 18/6",
+ sensor_bindings=(
+ BindingDraft(
+ owner="tent",
+ metric_type="temperature",
+ entity_id="sensor.growzelt_temperature",
+ ),
+ BindingDraft(
+ owner="run",
+ metric_type="soil_moisture",
+ entity_id="sensor.diesel_soil_moisture",
+ ),
+ ),
+ )
+ )
+
+ snapshot = domain.snapshot()
+ self.assertEqual(len(snapshot.tents), 1)
+ self.assertEqual(len(snapshot.plants), 1)
+ self.assertEqual(len(snapshot.runs), 1)
+ self.assertEqual(run.plant_id, snapshot.plants[0].id)
+ self.assertEqual(run.tent_id, snapshot.tents[0].id)
+ self.assertEqual(run.current_stage, "Germination")
+ self.assertEqual(run.stage_history[0].occurred_at, PLANTED_AT)
+ self.assertEqual(snapshot.plants[0].strain.duration, duration)
+ self.assertEqual(snapshot.plants[0].container, "7 L final container")
+ self.assertEqual(snapshot.plants[0].substrate, "All-Mix soil")
+ self.assertEqual(snapshot.tents[0].light_schedule, "20:00 to 14:00, 18/6")
+ self.assertEqual(
+ [(binding.owner, binding.started_at) for binding in snapshot.bindings],
+ [("tent", PLANTED_AT), ("run", PLANTED_AT)],
+ )
+
+ def test_invalid_run_creation_is_atomic(self) -> None:
+ domain = make_domain()
+
+ with self.assertRaisesRegex(DOMAIN.ValidationError, "initial_stage"):
+ domain.create_run(
+ RunDraft(
+ run_name="Broken run",
+ tent_name="Growzelt",
+ plant_name="Broken plant",
+ planted_at=PLANTED_AT,
+ stage_plan=("Seedling", "Flowering"),
+ initial_stage="Germination",
+ )
+ )
+
+ snapshot = domain.snapshot()
+ self.assertEqual(snapshot.tents, ())
+ self.assertEqual(snapshot.plants, ())
+ self.assertEqual(snapshot.runs, ())
+
+ def test_reuses_persistent_tent_and_does_not_duplicate_shared_binding(self) -> None:
+ domain = make_domain()
+ shared = BindingDraft(
+ owner="tent",
+ metric_type="temperature",
+ entity_id="sensor.growzelt_temperature",
+ )
+ first = domain.create_run(
+ RunDraft(
+ run_name="Diesel Auto RQS",
+ tent_name="Growzelt",
+ plant_name="Diesel Auto",
+ planted_at=PLANTED_AT,
+ stage_plan=("Germination", "Harvested"),
+ initial_stage="Germination",
+ sensor_bindings=(shared,),
+ )
+ )
+ second = domain.create_run(
+ RunDraft(
+ run_name="Tangerine Dream Auto Zamnesia",
+ tent_name="growzelt",
+ plant_name="Tangerine Dream Auto",
+ planted_at=PLANTED_AT,
+ stage_plan=("Germination", "Harvested"),
+ initial_stage="Germination",
+ sensor_bindings=(shared,),
+ )
+ )
+
+ snapshot = domain.snapshot()
+ self.assertEqual(first.tent_id, second.tent_id)
+ self.assertEqual(len(snapshot.tents), 1)
+ self.assertEqual(len(snapshot.runs), 2)
+ self.assertEqual(len({run.plant_id for run in snapshot.runs}), 2)
+ self.assertEqual(len(snapshot.bindings), 1)
+
+
+class TestJournal(unittest.TestCase):
+ def test_adds_dated_entry_with_optional_details_and_sensor_context(self) -> None:
+ domain = make_domain()
+ run = create_minimal_run(domain)
+
+ entry = domain.add_journal_entry(
+ JournalDraft(
+ tent_id=run.tent_id,
+ run_ids=(run.id,),
+ entry_type="Water",
+ text="Soil wetted and a small unmeasured sprinkle over the seed.",
+ occurred_at=PLANTED_AT,
+ details={"amount_ml": None},
+ sensor_snapshot={"sensor.growzelt_temperature": 24.1},
+ )
+ )
+
+ self.assertEqual(entry.created_at, NOW)
+ self.assertEqual(entry.updated_at, NOW)
+ self.assertEqual(entry.occurred_at, PLANTED_AT)
+ self.assertEqual(entry.run_ids, (run.id,))
+ self.assertEqual(entry.details, {"amount_ml": None})
+ self.assertEqual(
+ entry.sensor_snapshot,
+ {"sensor.growzelt_temperature": 24.1},
+ )
+ self.assertEqual(domain.snapshot().journal_entries, (entry,))
+
+ def test_edit_preserves_creation_time_and_delete_removes_the_entry(self) -> None:
+ edited_at = NOW + timedelta(hours=1)
+ moments = iter((NOW, NOW, edited_at))
+ domain = PlantRunDomain(clock=lambda: next(moments), id_factory=PrefixIds())
+ run = create_minimal_run(domain)
+ entry = domain.add_journal_entry(
+ JournalDraft(
+ tent_id=run.tent_id,
+ run_ids=(run.id,),
+ entry_type="Inspect",
+ text="Seed checked.",
+ occurred_at=PLANTED_AT,
+ )
+ )
+
+ replacement = domain.edit_journal_entry(
+ entry.id,
+ JournalDraft(
+ tent_id=run.tent_id,
+ run_ids=(run.id,),
+ entry_type="Inspect",
+ text="Seed checked, soil still moist.",
+ occurred_at=PLANTED_AT + timedelta(minutes=15),
+ details={"follow_up": "tomorrow"},
+ ),
+ )
+
+ self.assertEqual(replacement.id, entry.id)
+ self.assertEqual(replacement.created_at, entry.created_at)
+ self.assertEqual(replacement.updated_at, edited_at)
+ self.assertEqual(replacement.occurred_at, PLANTED_AT + timedelta(minutes=15))
+ self.assertEqual(replacement.details, {"follow_up": "tomorrow"})
+ self.assertEqual(domain.delete_journal_entry(entry.id), replacement)
+ self.assertEqual(domain.snapshot().journal_entries, ())
+
+
+class TestStages(unittest.TestCase):
+ def test_can_switch_directly_to_any_planned_stage_and_reorder_without_rewriting_history(self) -> None:
+ domain = make_domain()
+ run = create_minimal_run(domain)
+ flowering_at = PLANTED_AT + timedelta(days=25)
+ correction_at = PLANTED_AT + timedelta(days=26)
+
+ flowering = domain.change_stage(run.id, "Flowering", flowering_at)
+ corrected = domain.change_stage(run.id, "Germination", correction_at)
+ history_before_reorder = corrected.stage_history
+ reordered = domain.set_stage_plan(
+ run.id,
+ ("Germination", "Flowering", "Seedling", "Harvested"),
+ )
+
+ self.assertEqual(flowering.current_stage, "Flowering")
+ self.assertEqual(corrected.current_stage, "Germination")
+ self.assertEqual(corrected.stage_history[-1].from_stage, "Flowering")
+ self.assertEqual(corrected.stage_history[-1].occurred_at, correction_at)
+ self.assertEqual(reordered.stage_history, history_before_reorder)
+ self.assertEqual(
+ reordered.stage_plan,
+ ("Germination", "Flowering", "Seedling", "Harvested"),
+ )
+
+ def test_stage_changes_and_run_end_cannot_break_timeline_order(self) -> None:
+ domain = make_domain()
+ run = create_minimal_run(domain)
+ flowering_at = PLANTED_AT + timedelta(days=25)
+ domain.change_stage(run.id, "Flowering", flowering_at)
+
+ with self.assertRaisesRegex(DOMAIN.ValidationError, "latest stage change"):
+ domain.change_stage(run.id, "Germination", flowering_at - timedelta(days=1))
+ with self.assertRaisesRegex(DOMAIN.ValidationError, "latest stage change"):
+ domain.finish_run(run.id, flowering_at - timedelta(hours=1))
+
+
+class TestRunEditingAndBindings(unittest.TestCase):
+ def test_updates_run_and_plant_identity_without_replacing_their_ids(self) -> None:
+ domain = make_domain()
+ run = create_minimal_run(domain)
+ corrected_planting = PLANTED_AT - timedelta(hours=1)
+ strain = StrainIdentity(name="Diesel Auto", breeder="Royal Queen Seeds")
+
+ updated = domain.update_run(
+ run.id,
+ run_name="Diesel Auto 2026",
+ nickname="Diesel",
+ plant_name="Diesel Auto",
+ strain=strain,
+ planted_at=corrected_planting,
+ image="/local/plantrun/diesel.jpg",
+ )
+
+ snapshot = domain.snapshot()
+ plant = snapshot.plants[0]
+ self.assertEqual(updated.id, run.id)
+ self.assertEqual(updated.plant_id, run.plant_id)
+ self.assertEqual(updated.name, "Diesel Auto 2026")
+ self.assertEqual(updated.nickname, "Diesel")
+ self.assertEqual(updated.planted_at, corrected_planting)
+ self.assertEqual(plant.id, run.plant_id)
+ self.assertEqual(plant.name, "Diesel Auto")
+ self.assertEqual(plant.strain, strain)
+ self.assertEqual(plant.image, "/local/plantrun/diesel.jpg")
+
+ def test_rebinding_a_metric_closes_the_old_assignment_at_the_change_time(self) -> None:
+ domain = make_domain()
+ run = domain.create_run(
+ RunDraft(
+ run_name="Diesel Auto RQS",
+ tent_name="Growzelt",
+ plant_name="Diesel Auto",
+ planted_at=PLANTED_AT,
+ stage_plan=("Germination", "Harvested"),
+ initial_stage="Germination",
+ sensor_bindings=(
+ BindingDraft(
+ owner="run",
+ metric_type="soil_moisture",
+ entity_id="sensor.soil_probe_1",
+ ),
+ ),
+ )
+ )
+ reassigned_at = PLANTED_AT + timedelta(days=7)
+
+ new_binding = domain.set_sensor_binding(
+ "run",
+ run.id,
+ "soil_moisture",
+ "sensor.soil_probe_2",
+ reassigned_at,
+ )
+
+ bindings = domain.snapshot().bindings
+ self.assertEqual(len(bindings), 2)
+ self.assertEqual(bindings[0].entity_id, "sensor.soil_probe_1")
+ self.assertEqual(bindings[0].ended_at, reassigned_at)
+ self.assertEqual(new_binding.entity_id, "sensor.soil_probe_2")
+ self.assertEqual(new_binding.started_at, reassigned_at)
+ self.assertIsNone(new_binding.ended_at)
+
+ def test_clearing_a_binding_ends_ownership_without_erasing_history(self) -> None:
+ domain = make_domain()
+ run = create_minimal_run(domain)
+ binding = domain.set_sensor_binding(
+ "run",
+ run.id,
+ "soil_moisture",
+ "sensor.diesel_soil",
+ PLANTED_AT,
+ )
+ cleared_at = PLANTED_AT + timedelta(days=2)
+
+ closed = domain.end_sensor_binding(
+ "run",
+ run.id,
+ "soil_moisture",
+ cleared_at,
+ )
+
+ self.assertEqual([item.id for item in closed], [binding.id])
+ self.assertEqual(domain.snapshot().bindings[0].ended_at, cleared_at)
+
+ def test_archived_run_cannot_receive_an_active_binding(self) -> None:
+ domain = make_domain()
+ run = create_minimal_run(domain)
+ ended_at = PLANTED_AT + timedelta(days=80)
+ domain.finish_run(run.id, ended_at)
+
+ with self.assertRaisesRegex(DOMAIN.ValidationError, "archived runs"):
+ domain.set_sensor_binding(
+ "run",
+ run.id,
+ "soil_moisture",
+ "sensor.late_probe",
+ ended_at,
+ )
+
+
+class TestArchiveAndDeletion(unittest.TestCase):
+ def test_finishing_archives_the_run_and_preserves_every_record(self) -> None:
+ domain = make_domain()
+ run = domain.create_run(
+ RunDraft(
+ run_name="Diesel Auto RQS",
+ tent_name="Growzelt",
+ plant_name="Diesel Auto",
+ planted_at=PLANTED_AT,
+ stage_plan=("Germination", "Harvested"),
+ initial_stage="Germination",
+ sensor_bindings=(
+ BindingDraft(
+ owner="run",
+ metric_type="soil_moisture",
+ entity_id="sensor.diesel_soil",
+ ),
+ ),
+ )
+ )
+ entry = domain.add_journal_entry(
+ JournalDraft(
+ tent_id=run.tent_id,
+ run_ids=(run.id,),
+ entry_type="Harvest",
+ text="Harvested and hung to dry.",
+ occurred_at=PLANTED_AT + timedelta(days=90),
+ )
+ )
+
+ archived = domain.finish_run(
+ run.id,
+ PLANTED_AT + timedelta(days=90),
+ harvest_details={"dry_yield_g": 48.5},
+ )
+
+ snapshot = domain.snapshot()
+ self.assertEqual(archived.status, "archived")
+ self.assertEqual(archived.ended_at, PLANTED_AT + timedelta(days=90))
+ self.assertEqual(archived.harvest_details, {"dry_yield_g": 48.5})
+ self.assertEqual(snapshot.journal_entries, (entry,))
+ self.assertEqual(len(snapshot.plants), 1)
+ self.assertEqual(len(snapshot.bindings), 1)
+ self.assertEqual(snapshot.bindings[0].ended_at, archived.ended_at)
+
+ def test_permanent_deletion_requires_exact_name_and_removes_only_run_owned_data(self) -> None:
+ domain = make_domain()
+ first = domain.create_run(
+ RunDraft(
+ run_name="Diesel Auto RQS",
+ tent_name="Growzelt",
+ plant_name="Diesel Auto",
+ planted_at=PLANTED_AT,
+ stage_plan=("Germination", "Harvested"),
+ initial_stage="Germination",
+ sensor_bindings=(
+ BindingDraft(
+ owner="tent",
+ metric_type="temperature",
+ entity_id="sensor.growzelt_temperature",
+ ),
+ BindingDraft(
+ owner="run",
+ metric_type="soil_moisture",
+ entity_id="sensor.diesel_soil",
+ ),
+ ),
+ )
+ )
+ second = create_minimal_run(domain, "Tangerine Dream Auto Zamnesia")
+ shared_entry = domain.add_journal_entry(
+ JournalDraft(
+ tent_id=first.tent_id,
+ run_ids=(first.id, second.id),
+ text="Both seeds planted directly into final pots.",
+ occurred_at=PLANTED_AT,
+ )
+ )
+ only_first_entry = domain.add_journal_entry(
+ JournalDraft(
+ tent_id=first.tent_id,
+ run_ids=(first.id,),
+ text="Only belongs to Diesel Auto RQS.",
+ occurred_at=PLANTED_AT,
+ )
+ )
+ before = domain.snapshot()
+
+ with self.assertRaises(DOMAIN.ConfirmationError):
+ domain.permanently_delete_run(first.id, "diesel auto rqs")
+ self.assertEqual(domain.snapshot(), before)
+
+ deleted = domain.permanently_delete_run(first.id, "Diesel Auto RQS")
+ snapshot = domain.snapshot()
+ self.assertEqual(deleted, first)
+ self.assertEqual([run.id for run in snapshot.runs], [second.id])
+ self.assertEqual([plant.id for plant in snapshot.plants], [second.plant_id])
+ self.assertEqual(len(snapshot.tents), 1)
+ self.assertEqual(
+ [(binding.owner, binding.entity_id) for binding in snapshot.bindings],
+ [("tent", "sensor.growzelt_temperature")],
+ )
+ self.assertEqual(snapshot.journal_entries[0].id, shared_entry.id)
+ self.assertEqual(snapshot.journal_entries[0].run_ids, (second.id,))
+ self.assertNotIn(only_first_entry.id, {entry.id for entry in snapshot.journal_entries})
+
+
+class TestPersistence(unittest.TestCase):
+ def test_exported_state_is_json_safe_and_round_trips_without_losing_meaning(self) -> None:
+ domain = make_domain()
+ duration = SourcedDuration(
+ minimum_days=70,
+ maximum_days=77,
+ meaning="seed to harvest",
+ start_event="germination",
+ source="https://example.test/tangerine-dream-auto",
+ original_wording="about 11 weeks after germination",
+ )
+ run = domain.create_run(
+ RunDraft(
+ run_name="Tangerine Dream Auto Zamnesia",
+ nickname="Tangerine",
+ tent_name="Growzelt",
+ plant_name="Tangerine Dream Auto",
+ planted_at=PLANTED_AT,
+ stage_plan=("Germination", "Seedling", "Flowering", "Harvested"),
+ initial_stage="Germination",
+ strain=StrainIdentity(
+ name="Tangerine Dream Auto",
+ breeder="Zamnesia",
+ duration=duration,
+ ),
+ image="https://example.test/tangerine.jpg",
+ container="7 L final container",
+ substrate="All-Mix soil",
+ light_schedule="20:00 to 14:00, 18/6",
+ )
+ )
+ domain.add_journal_entry(
+ JournalDraft(
+ tent_id=run.tent_id,
+ run_ids=(run.id,),
+ entry_type="Water",
+ text="Small unmeasured sprinkle over the seed.",
+ occurred_at=PLANTED_AT,
+ details={"amount_ml": None},
+ )
+ )
+ domain.change_stage(run.id, "Seedling", PLANTED_AT + timedelta(days=3))
+
+ state = domain.export_state()
+ encoded = json.dumps(state)
+ restored = PlantRunDomain.from_state(
+ json.loads(encoded),
+ clock=lambda: NOW,
+ id_factory=PrefixIds(),
+ )
+
+ self.assertEqual(
+ set(state),
+ {"tents", "plants", "runs", "journal_entries", "sensor_bindings"},
+ )
+ self.assertEqual(restored.snapshot(), domain.snapshot())
+ self.assertEqual(
+ restored.snapshot().plants[0].strain.duration.original_wording,
+ "about 11 weeks after germination",
+ )
+ self.assertEqual(restored.snapshot().plants[0].container, "7 L final container")
+ self.assertEqual(restored.snapshot().plants[0].substrate, "All-Mix soil")
+ self.assertEqual(restored.snapshot().tents[0].light_schedule, "20:00 to 14:00, 18/6")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_panel_autocomplete.py b/tests/test_panel_autocomplete.py
index dc97778..053510f 100644
--- a/tests/test_panel_autocomplete.py
+++ b/tests/test_panel_autocomplete.py
@@ -1,26 +1,19 @@
import unittest
-from pathlib import Path
-ROOT = Path(__file__).resolve().parents[1]
-PANEL_PATH = ROOT / "custom_components" / "plantrun" / "www" / "plantrun-panel.js"
+from tests.dashboard_js_test_utils import load_panel_source
class PanelAutocompleteTest(unittest.TestCase):
- def test_cultivar_input_supports_keyboard_click_and_stable_async_selection(self):
- source = PANEL_PATH.read_text(encoding="utf-8")
-
- self.assertIn("_handleKeydown(event)", source)
- self.assertIn('event.key === "Enter" || event.key === "Tab"', source)
- self.assertIn('event.key === "Escape"', source)
- self.assertIn('data-action="choose-cultivar"', source)
- self.assertIn('data-prevent-mousedown', source)
- self.assertIn('_handleMouseDown(event)', source)
- self.assertIn("_scheduleCultivarSearch()", source)
- self.assertIn("_scheduleDetailCultivarSearch()", source)
- self.assertIn('data-detail-cultivar-input', source)
- self.assertIn('data-action="choose-detail-cultivar"', source)
- self.assertIn("Refreshing results…", source)
- self.assertIn("_renderSuggestionsOnly()", source)
+ def test_cultivar_search_is_async_stable_and_manual_entry_remains_available(self):
+ source = load_panel_source()
+ self.assertIn("const nonce = ++this._searchNonce;", source)
+ self.assertIn("if (nonce !== this._searchNonce) return;", source)
+ self.assertIn("this._api.searchCultivar(", source)
+ self.assertIn('data-action="preview-cultivar"', source)
+ self.assertIn('data-action="apply-cultivar"', source)
+ self.assertIn("Manuell fortfahren", source)
+ self.assertIn("Die Suche blockiert das Anlegen nie.", source)
+ self.assertIn('["strain", "breeder"].includes', source)
if __name__ == "__main__":
diff --git a/tests/test_panel_notes_editing.py b/tests/test_panel_notes_editing.py
index 4e60c87..0446bcb 100644
--- a/tests/test_panel_notes_editing.py
+++ b/tests/test_panel_notes_editing.py
@@ -1,29 +1,19 @@
-from pathlib import Path
import unittest
+from tests.dashboard_js_test_utils import load_panel_source
-ROOT = Path(__file__).resolve().parents[1]
-PANEL_PATH = ROOT / "custom_components" / "plantrun" / "www" / "plantrun-panel.js"
-
-class PanelNotesEditingTests(unittest.TestCase):
- def test_notes_support_create_edit_delete_and_datetime_display(self):
- source = PANEL_PATH.read_text(encoding="utf-8")
-
- self.assertIn("formatDateTime", source)
- self.assertIn('data-action="add-note"', source)
- self.assertIn('data-action="edit-note"', source)
- self.assertIn('data-action="confirm-delete-note"', source)
- self.assertIn('data-action="save-note-edit"', source)
- self.assertIn('data-action="delete-note"', source)
- self.assertIn('data-note-edit-text', source)
- self.assertIn('S.formatDateTime(note.timestamp)', source)
- self.assertIn('_openNewNoteEditor(runId)', source)
- self.assertIn('
${isNew ? "New note" : "Edit note"}
', source)
- self.assertIn('this._hass.callService(DOMAIN, "add_note"', source)
- self.assertIn('this._hass.callService(DOMAIN, "update_note"', source)
- self.assertIn('this._hass.callService(DOMAIN, "delete_note"', source)
- self.assertNotIn('data-note-draft', source)
+class PanelJournalEditingTests(unittest.TestCase):
+ def test_journal_supports_create_edit_delete_and_occurrence_time(self):
+ source = load_panel_source()
+ self.assertIn('"create_journal_entry"', source)
+ self.assertIn('"update_journal_entry"', source)
+ self.assertIn('command("delete_journal_entry"', source)
+ self.assertIn('data-journal-occurred-at', source)
+ self.assertIn('data-action="edit-journal-entry"', source)
+ self.assertIn('data-action="request-delete-journal-entry"', source)
+ self.assertIn("occurred_at:", source)
+ self.assertIn("entry_id: entry.id", source)
if __name__ == "__main__":
diff --git a/tests/test_stability_lifecycle.py b/tests/test_stability_lifecycle.py
index 2a240a8..20c6dcb 100644
--- a/tests/test_stability_lifecycle.py
+++ b/tests/test_stability_lifecycle.py
@@ -1,5 +1,6 @@
import asyncio
import base64
+import hashlib
import importlib.util
import json
import shutil
@@ -527,10 +528,17 @@ def test_panel_script_is_loaded_as_a_versioned_module(self):
manifest_version = json.loads((PLANTRUN_DIR / "manifest.json").read_text(encoding="utf-8"))[
"version"
]
- panel_mtime = int((PLANTRUN_DIR / "www" / "plantrun-panel.js").stat().st_mtime)
- expected_url = f"/plantrun_frontend/plantrun-panel.js?v={manifest_version}-{panel_mtime}"
-
- self.assertNotIn('import {', panel_script)
+ module_paths = tuple(sorted((PLANTRUN_DIR / "www").glob("plantrun-panel*.js")))
+ expected_fingerprint = hashlib.sha256(
+ "|".join(
+ f"{path.name}:{path.stat().st_mtime_ns}:{path.stat().st_size}"
+ for path in module_paths
+ ).encode()
+ ).hexdigest()[:12]
+ expected_url = f"/plantrun_frontend/plantrun-panel.js?v={manifest_version}-{expected_fingerprint}"
+
+ self.assertIn('import { PlantRunApi }', panel_script)
+ self.assertIn('import { panelStyles }', panel_script)
self.assertIn('customElements.get("ha-panel-lovelace")', panel_script)
self.assertEqual(self.integration.PANEL_MODULE_URL, expected_url)
self.assertEqual(self.integration.PANEL_JS_URL, expected_url)
@@ -712,6 +720,27 @@ def test_create_run_service_initializes_default_phase(self):
self.assertEqual(len(storage.runs), 1)
self.assertEqual(storage.runs[0].phases[0].name, "Seedling")
+ def test_add_phase_service_accepts_a_custom_phase(self):
+ hass = self._build_hass()
+ entry = sys.modules["homeassistant.config_entries"].ConfigEntry("entry-custom-phase")
+ asyncio.run(self.integration.async_setup_entry(hass, entry))
+
+ storage = FakeStorage.instances[-1]
+ run = self.models.RunData(
+ id="run-custom-phase",
+ friendly_name="Tent Custom",
+ start_time="2026-03-10T00:00:00+00:00",
+ phases=[self.models.Phase(name="Vegetative", start_time="2026-03-10T00:00:00+00:00")],
+ )
+ storage.runs.append(run)
+ storage.active_run_id = run.id
+ handler = hass.services.get_handler(self.integration.DOMAIN, "add_phase")
+
+ asyncio.run(handler(sys.modules["homeassistant.core"].ServiceCall({"run_id": run.id, "phase_name": "Drying"})))
+
+ self.assertEqual(run.phases[-1].name, "Drying")
+ self.assertEqual(run.status, "active")
+
def test_set_cultivar_service_uses_shared_session(self):
hass = self._build_hass()
entry = sys.modules["homeassistant.config_entries"].ConfigEntry("entry-service")
diff --git a/tests/test_store_migration.py b/tests/test_store_migration.py
index b91020a..bbfde28 100644
--- a/tests/test_store_migration.py
+++ b/tests/test_store_migration.py
@@ -70,27 +70,29 @@ def test_migrates_v1_payload(self) -> None:
}
migrated, changed = PlantRunStorage._normalize_payload(payload)
self.assertTrue(changed)
- self.assertEqual(migrated["schema_version"], 2)
- self.assertIn("active_run_id", migrated)
- self.assertEqual(migrated["active_run_id"], None)
- self.assertEqual(migrated["runs"][0]["notes"], [])
- self.assertEqual(migrated["runs"][0]["phases"][0]["name"], "Seedling")
+ self.assertEqual(migrated["schema_version"], 3)
+ self.assertEqual(migrated["domain"]["runs"], [])
+ self.assertEqual(migrated["legacy_v2"]["active_run_id"], None)
+ self.assertEqual(migrated["legacy_v2"]["runs"][0]["notes"], [])
+ self.assertEqual(
+ migrated["legacy_v2"]["runs"][0]["phases"][0]["name"],
+ "Seedling",
+ )
def test_migration_is_idempotent(self) -> None:
payload = {
- "schema_version": 2,
+ "schema_version": 3,
"active_run_id": None,
"daily_rollups": {},
- "runs": [
- {
- "id": "run1",
- "friendly_name": "Run A",
- "start_time": "2026-03-01T00:00:00",
- "notes": [],
- "phases": [{"name": "Seedling", "start_time": "2026-03-01T00:00:00"}],
- "bindings": [],
- }
- ],
+ "domain": {
+ "tents": [],
+ "plants": [],
+ "runs": [],
+ "journal_entries": [],
+ "sensor_bindings": [],
+ },
+ "legacy_v2": {"runs": [], "active_run_id": None, "daily_rollups": {}},
+ "compatibility_runs": [],
}
first, first_changed = PlantRunStorage._normalize_payload(payload)
second, second_changed = PlantRunStorage._normalize_payload(first)
@@ -116,9 +118,12 @@ def test_schema_v2_run_without_phases_gets_default_phase(self) -> None:
}
migrated, changed = PlantRunStorage._normalize_payload(payload)
self.assertTrue(changed)
- self.assertEqual(migrated["runs"][0]["phases"][0]["name"], "Seedling")
+ self.assertEqual(
+ migrated["legacy_v2"]["runs"][0]["phases"][0]["name"],
+ "Seedling",
+ )
- def test_async_load_skips_malformed_runs_and_clears_invalid_active_run(self) -> None:
+ def test_async_load_preserves_legacy_runs_without_exposing_them(self) -> None:
storage = PlantRunStorage(object())
storage._store.saved = {
"schema_version": 2,
@@ -147,10 +152,163 @@ def test_async_load_skips_malformed_runs_and_clears_invalid_active_run(self) ->
asyncio.run(storage.async_load())
- self.assertEqual(len(storage.runs), 1)
- self.assertEqual(storage.runs[0].id, "run1")
+ self.assertEqual(storage.runs, [])
+ self.assertEqual(len(storage._data["legacy_v2"]["runs"]), 2)
self.assertIsNone(storage.active_run_id)
+ def test_domain_commit_round_trips_through_home_assistant_store(self) -> None:
+ import asyncio
+ from datetime import datetime, timezone
+
+ domain_module = _load_module(
+ "custom_components.plantrun.domain",
+ PLANTRUN_DIR / "domain.py",
+ )
+ domain = domain_module.PlantRunDomain()
+ domain.create_run(
+ domain_module.RunDraft(
+ run_name="Diesel Auto RQS",
+ tent_name="Growzelt",
+ plant_name="Diesel Auto",
+ planted_at=datetime(2026, 8, 25, 16, 0, tzinfo=timezone.utc),
+ stage_plan=("Germination", "Harvested"),
+ initial_stage="Germination",
+ )
+ )
+ storage = PlantRunStorage(object())
+
+ asyncio.run(storage.async_commit_domain(domain))
+ saved = storage._store.saved
+ restored = PlantRunStorage(object())
+ restored._store.saved = saved
+ asyncio.run(restored.async_load())
+
+ self.assertEqual(restored.public_state()["runs"][0]["name"], "Diesel Auto RQS")
+ self.assertEqual(restored.runs[0].phases[0].name, "Germination")
+
+ def test_legacy_service_run_creation_enters_the_visible_domain(self) -> None:
+ import asyncio
+
+ models = sys.modules["custom_components.plantrun.models"]
+ storage = PlantRunStorage(object())
+ run = models.RunData(
+ friendly_name="Service Run",
+ start_time="2026-08-25T16:00:00+02:00",
+ planted_date="2026-08-25T16:00:00+02:00",
+ phases=[models.Phase(name="Germination", start_time="2026-08-25T16:00:00+02:00")],
+ base_config={"plants": [{"name": "Service Plant"}]},
+ )
+
+ asyncio.run(storage.async_add_run(run))
+
+ state = storage.public_state()
+ self.assertEqual(state["runs"][0]["name"], "Service Run")
+ self.assertEqual(state["plants"][0]["name"], "Service Plant")
+ self.assertEqual(run.id, state["runs"][0]["id"])
+ self.assertEqual(storage._data["compatibility_runs"], [])
+
+ def test_legacy_service_updates_write_stage_and_journal_to_the_domain(self) -> None:
+ import asyncio
+
+ models = sys.modules["custom_components.plantrun.models"]
+ storage = PlantRunStorage(object())
+ run = models.RunData(
+ friendly_name="Service Run",
+ start_time="2026-08-25T16:00:00+02:00",
+ planted_date="2026-08-25T16:00:00+02:00",
+ phases=[models.Phase(name="Germination", start_time="2026-08-25T16:00:00+02:00")],
+ )
+ asyncio.run(storage.async_add_run(run))
+ projected = storage.get_run(run.id)
+ projected.phases.append(
+ models.Phase(name="Seedling", start_time="2026-08-28T12:00:00+02:00")
+ )
+ projected.notes.append(
+ models.Note(text="First leaves visible.", timestamp="2026-08-28T12:05:00+02:00")
+ )
+
+ asyncio.run(storage.async_update_run(projected))
+
+ state = storage.public_state()
+ self.assertEqual(state["runs"][0]["current_stage"], "Seedling")
+ self.assertEqual(state["journal_entries"][0]["text"], "First leaves visible.")
+
+ def test_domain_commit_preserves_an_explicit_active_run_selection(self) -> None:
+ import asyncio
+ from datetime import datetime, timezone
+
+ domain_module = sys.modules["custom_components.plantrun.domain"]
+ domain = domain_module.PlantRunDomain()
+ first = domain.create_run(
+ domain_module.RunDraft(
+ run_name="Diesel Auto RQS",
+ tent_name="Growzelt",
+ plant_name="Diesel Auto",
+ planted_at=datetime(2026, 8, 25, 16, 0, tzinfo=timezone.utc),
+ stage_plan=("Germination", "Harvested"),
+ initial_stage="Germination",
+ )
+ )
+ second = domain.create_run(
+ domain_module.RunDraft(
+ run_name="Tangerine Dream Auto Zamnesia",
+ tent_name="Growzelt",
+ plant_name="Tangerine Dream Auto",
+ planted_at=datetime(2026, 8, 25, 16, 0, tzinfo=timezone.utc),
+ stage_plan=("Germination", "Harvested"),
+ initial_stage="Germination",
+ )
+ )
+ storage = PlantRunStorage(object())
+ asyncio.run(storage.async_commit_domain(domain))
+ asyncio.run(storage.async_set_active_run_id(second.id))
+
+ candidate = domain_module.PlantRunDomain.from_state(storage.domain.export_state())
+ candidate.add_journal_entry(
+ domain_module.JournalDraft(
+ tent_id=first.tent_id,
+ run_ids=(first.id,),
+ text="Soil checked.",
+ occurred_at=datetime(2026, 8, 26, 10, 0, tzinfo=timezone.utc),
+ )
+ )
+ asyncio.run(storage.async_commit_domain(candidate))
+
+ self.assertEqual(storage.active_run_id, second.id)
+
+ def test_archived_binding_remains_in_compatibility_projection(self) -> None:
+ import asyncio
+ from datetime import datetime, timedelta, timezone
+
+ domain_module = sys.modules["custom_components.plantrun.domain"]
+ planted_at = datetime(2026, 8, 25, 16, 0, tzinfo=timezone.utc)
+ domain = domain_module.PlantRunDomain()
+ run = domain.create_run(
+ domain_module.RunDraft(
+ run_name="Diesel Auto RQS",
+ tent_name="Growzelt",
+ plant_name="Diesel Auto",
+ planted_at=planted_at,
+ stage_plan=("Germination", "Harvested"),
+ initial_stage="Germination",
+ sensor_bindings=(
+ domain_module.BindingDraft(
+ owner="run",
+ metric_type="soil_moisture",
+ entity_id="sensor.diesel_soil",
+ ),
+ ),
+ )
+ )
+ domain.finish_run(run.id, planted_at + timedelta(days=80))
+ storage = PlantRunStorage(object())
+
+ asyncio.run(storage.async_commit_domain(domain))
+
+ projected = storage.get_run(run.id)
+ self.assertEqual(len(projected.bindings), 1)
+ self.assertEqual(projected.bindings[0].sensor_id, "sensor.diesel_soil")
+
if __name__ == "__main__":
unittest.main()