491 lines
27 KiB
Python
491 lines
27 KiB
Python
import hashlib
|
|
import json
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
from django.contrib.auth import get_user_model
|
|
from django.test import TestCase, override_settings
|
|
from django.urls import reverse
|
|
|
|
from groceries.models import GroceryItem
|
|
from planner.models import Task
|
|
from .client import ConnectionError, _get_json, _request_json, decrypt_token, encrypt_token, get_items, normalize_url
|
|
from .models import HomeAssistantConnection, HomeAssistantItemMap, HomeAssistantSyncRun
|
|
from .sync import _schedule_after_failure, build_plan, confirm_and_sync, preview, run_due_syncs
|
|
from .task_sync import confirm_task_sync, preview_tasks
|
|
|
|
|
|
def dns_for(address):
|
|
return [(2, 1, 6, '', (address, 8123))]
|
|
|
|
|
|
@override_settings(SECURE_SSL_REDIRECT=False)
|
|
class ConnectionTests(TestCase):
|
|
def setUp(self):
|
|
self.user = get_user_model().objects.create_user(username='ha-user', password='example-password')
|
|
self.other = get_user_model().objects.create_user(username='other-user', password='example-password')
|
|
self.client.force_login(self.user)
|
|
self.url = reverse('home_assistant:settings')
|
|
|
|
@patch('home_assistant.client.socket.getaddrinfo', return_value=dns_for('192.168.1.10'))
|
|
def test_token_is_encrypted_and_never_rendered(self, _dns):
|
|
response = self.client.post(self.url, {'action': 'save', 'base_url': 'http://ha.local:8123/', 'token': 'private-token'})
|
|
self.assertEqual(response.status_code, 302)
|
|
connection = HomeAssistantConnection.objects.get(user=self.user)
|
|
self.assertEqual(connection.base_url, 'http://ha.local:8123')
|
|
self.assertNotIn('private-token', connection.encrypted_token)
|
|
self.assertEqual(decrypt_token(connection.encrypted_token), 'private-token')
|
|
self.assertNotContains(self.client.get(self.url), 'private-token')
|
|
|
|
@patch('home_assistant.client.socket.getaddrinfo', return_value=dns_for('192.168.1.10'))
|
|
def test_blank_token_keeps_previous_value_and_owner_isolation(self, _dns):
|
|
HomeAssistantConnection.objects.create(user=self.user, base_url='http://ha.local:8123', encrypted_token=encrypt_token('old'))
|
|
HomeAssistantConnection.objects.create(user=self.other, base_url='https://other.example', encrypted_token=encrypt_token('other'))
|
|
self.client.post(self.url, {'action': 'save', 'base_url': 'http://ha.local:8123', 'token': ''})
|
|
self.assertEqual(decrypt_token(HomeAssistantConnection.objects.get(user=self.user).encrypted_token), 'old')
|
|
self.assertEqual(decrypt_token(HomeAssistantConnection.objects.get(user=self.other).encrypted_token), 'other')
|
|
|
|
@patch('home_assistant.client.socket.getaddrinfo', return_value=dns_for('192.168.1.10'))
|
|
@patch('home_assistant.views.test_connection', return_value='2026.10.0')
|
|
@patch('home_assistant.views.discover_entities', return_value=[{'id': 'todo.shopping', 'name': 'Shopping'}])
|
|
def test_discover_and_select_only_known_entity(self, _discover, _test, _dns):
|
|
HomeAssistantConnection.objects.create(user=self.user, base_url='http://ha.local:8123', encrypted_token=encrypt_token('secret'))
|
|
self.client.post(self.url, {'action': 'discover'})
|
|
connection = HomeAssistantConnection.objects.get(user=self.user)
|
|
self.assertEqual(connection.version, '2026.10.0')
|
|
self.assertEqual(connection.entities[0]['id'], 'todo.shopping')
|
|
self.client.post(self.url, {'action': 'select', 'grocery_entity_id': 'todo.foreign'})
|
|
connection.refresh_from_db()
|
|
self.assertEqual(connection.grocery_entity_id, '')
|
|
self.client.post(self.url, {'action': 'select', 'grocery_entity_id': 'todo.shopping'})
|
|
connection.refresh_from_db()
|
|
self.assertEqual(connection.grocery_entity_id, 'todo.shopping')
|
|
|
|
def test_optional_task_entity_requires_discovery_and_can_be_disconnected(self):
|
|
connection = HomeAssistantConnection.objects.create(user=self.user,
|
|
base_url='https://ha.example', encrypted_token=encrypt_token('secret'),
|
|
grocery_entity_id='todo.shopping', entities=[
|
|
{'id': 'todo.shopping', 'name': 'Shopping'},
|
|
{'id': 'todo.tasks', 'name': 'Tasks'},
|
|
])
|
|
self.client.post(self.url, {'action': 'select-task', 'task_entity_id': 'todo.unknown'})
|
|
connection.refresh_from_db()
|
|
self.assertEqual(connection.task_entity_id, '')
|
|
self.client.post(self.url, {'action': 'select-task', 'task_entity_id': 'todo.tasks'})
|
|
connection.refresh_from_db()
|
|
self.assertEqual(connection.task_entity_id, 'todo.tasks')
|
|
self.client.post(self.url, {'action': 'select-task', 'task_entity_id': ''})
|
|
connection.refresh_from_db()
|
|
self.assertEqual(connection.task_entity_id, '')
|
|
self.assertEqual(connection.grocery_entity_id, 'todo.shopping')
|
|
|
|
@patch('home_assistant.client.socket.getaddrinfo', return_value=dns_for('8.8.8.8'))
|
|
def test_public_http_rejected(self, _dns):
|
|
with self.assertRaises(ConnectionError):
|
|
normalize_url('http://example.com:8123')
|
|
|
|
def test_url_credentials_and_paths_rejected(self):
|
|
for value in ('https://user:secret@example.com', 'https://example.com/api', 'file:///etc/passwd'):
|
|
with self.subTest(value=value), self.assertRaises(ConnectionError):
|
|
normalize_url(value)
|
|
|
|
@patch('home_assistant.client.socket.getaddrinfo', return_value=dns_for('192.168.1.10'))
|
|
def test_changing_host_requires_new_token(self, _dns):
|
|
HomeAssistantConnection.objects.create(user=self.user, base_url='http://old.local:8123', encrypted_token=encrypt_token('old'))
|
|
self.client.post(self.url, {'action': 'save', 'base_url': 'http://new.local:8123', 'token': ''})
|
|
connection = HomeAssistantConnection.objects.get(user=self.user)
|
|
self.assertEqual(connection.base_url, 'http://old.local:8123')
|
|
|
|
@patch('home_assistant.views.test_connection', side_effect=ConnectionError('Token rejected (401).'))
|
|
def test_test_failure_is_sanitized_and_saved(self, _test):
|
|
HomeAssistantConnection.objects.create(user=self.user, base_url='https://ha.example', encrypted_token=encrypt_token('secret'))
|
|
self.client.post(self.url, {'action': 'test'})
|
|
connection = HomeAssistantConnection.objects.get(user=self.user)
|
|
self.assertEqual(connection.last_error, 'Token rejected (401).')
|
|
self.assertNotIn('secret', connection.last_error)
|
|
self.assertIsNone(connection.last_tested_at)
|
|
|
|
@patch('home_assistant.client.socket.getaddrinfo', return_value=dns_for('192.168.1.10'))
|
|
@patch('home_assistant.client.http.client.HTTPConnection')
|
|
def test_api_rejects_redirect_and_unauthorized(self, connection_class, _dns):
|
|
connection = connection_class.return_value
|
|
response = MagicMock()
|
|
connection.getresponse.return_value = response
|
|
for status, expected in ((302, 'redirected'), (401, 'Token rejected')):
|
|
response.status = status
|
|
with self.subTest(status=status), self.assertRaisesRegex(ConnectionError, expected):
|
|
_get_json('http://ha.local:8123', 'secret', '/api/config')
|
|
self.assertEqual(connection.request.call_count, 2)
|
|
self.assertEqual(connection.request.call_args.args[:2], ('GET', '/api/config'))
|
|
|
|
@patch('home_assistant.client.socket.getaddrinfo', return_value=dns_for('192.168.1.10'))
|
|
@patch('home_assistant.client.http.client.HTTPConnection')
|
|
def test_unavailable_entity_error_is_actionable(self, connection_class, _dns):
|
|
response = connection_class.return_value.getresponse.return_value
|
|
response.status = 500
|
|
response.read.return_value = b'{"message":"Service call requested response data but did not match any entities"}'
|
|
with self.assertRaisesRegex(ConnectionError, 'selected Home Assistant to-do list is unavailable'):
|
|
_request_json('http://ha.local:8123', 'secret', '/api/services/todo/get_items?return_response', {})
|
|
|
|
@patch('home_assistant.client._get_json', return_value=[
|
|
{'entity_id': 'todo.active', 'state': '0', 'attributes': {'friendly_name': 'Active'}},
|
|
{'entity_id': 'todo.offline', 'state': 'unavailable', 'attributes': {'friendly_name': 'Offline'}},
|
|
])
|
|
def test_discovery_marks_unavailable_entities(self, _get):
|
|
from .client import discover_entities
|
|
found = discover_entities('https://ha.example', 'token')
|
|
self.assertTrue(next(entity for entity in found if entity['id'] == 'todo.active')['available'])
|
|
self.assertFalse(next(entity for entity in found if entity['id'] == 'todo.offline')['available'])
|
|
|
|
@patch('home_assistant.client._request_json')
|
|
def test_get_items_parses_service_response_and_rejects_duplicate_uids(self, request):
|
|
request.return_value = {'changed_states': [], 'service_response': {'todo.shopping': {'items': [
|
|
{'uid': 'one', 'summary': 'Milk', 'status': 'needs_action'},
|
|
{'uid': 'two', 'summary': 'Bread', 'status': 'completed'},
|
|
]}}}
|
|
result = get_items('https://ha.example', 'token', 'todo.shopping')
|
|
self.assertEqual(set(result), {'one', 'two'})
|
|
self.assertEqual(request.call_args.args[2], '/api/services/todo/get_items?return_response')
|
|
request.return_value['service_response']['todo.shopping']['items'][1]['uid'] = 'one'
|
|
with self.assertRaises(ConnectionError):
|
|
get_items('https://ha.example', 'token', 'todo.shopping')
|
|
|
|
|
|
class FakeHomeAssistant:
|
|
def __init__(self, items=None):
|
|
self.items = {item['uid']: item.copy() for item in (items or [])}
|
|
self.calls = []
|
|
self.next_id = 1
|
|
|
|
def get(self, *_args):
|
|
return {uid: item.copy() for uid, item in self.items.items()}
|
|
|
|
def add(self, _url, _token, _entity, name):
|
|
self.calls.append(('add', name))
|
|
uid = f'new-{self.next_id}'
|
|
self.next_id += 1
|
|
self.items[uid] = {'uid': uid, 'name': name, 'status': 'needs_action'}
|
|
|
|
def update(self, _url, _token, _entity, uid, *, name=None, status=None):
|
|
self.calls.append(('update', uid, name, status))
|
|
if name is not None:
|
|
self.items[uid]['name'] = name
|
|
if status is not None:
|
|
self.items[uid]['status'] = status
|
|
|
|
|
|
class FakeTaskHomeAssistant:
|
|
def __init__(self, items=None):
|
|
self.items = {item['uid']: item.copy() for item in (items or [])}
|
|
self.next_id = 1
|
|
|
|
def get(self, *_args):
|
|
return {uid: item.copy() for uid, item in self.items.items()}
|
|
|
|
def add(self, _url, _token, _entity, name, *, due_date=None, description=None):
|
|
uid = f'task-{self.next_id}'
|
|
self.next_id += 1
|
|
self.items[uid] = {'uid': uid, 'name': name, 'status': 'needs_action',
|
|
'due': due_date, 'description': description or ''}
|
|
|
|
def update(self, _url, _token, _entity, uid, *, name=None, status=None,
|
|
due_date=None, description=None):
|
|
item = self.items[uid]
|
|
if name is not None:
|
|
item['name'] = name
|
|
if status is not None:
|
|
item['status'] = status
|
|
if due_date is not None:
|
|
item['due'] = due_date
|
|
if description is not None:
|
|
item['description'] = description
|
|
|
|
|
|
@override_settings(SECURE_SSL_REDIRECT=False)
|
|
class GrocerySyncTests(TestCase):
|
|
def setUp(self):
|
|
self.user = get_user_model().objects.create_user(username='sync-user')
|
|
self.other = get_user_model().objects.create_user(username='sync-other')
|
|
self.connection = HomeAssistantConnection.objects.create(
|
|
user=self.user, base_url='https://ha.example', encrypted_token=encrypt_token('secret'),
|
|
grocery_entity_id='todo.shopping',
|
|
entities=[{'id': 'todo.shopping', 'name': 'Shopping', 'features': 5}])
|
|
|
|
def local(self, name, status='needed', user=None):
|
|
return GroceryItem.objects.create(user=user or self.user, name=name, quantity=1,
|
|
unit='pieces', status=status)
|
|
|
|
def run_with(self, fake):
|
|
with patch('home_assistant.sync.get_items', side_effect=fake.get), \
|
|
patch('home_assistant.sync.add_item', side_effect=fake.add), \
|
|
patch('home_assistant.sync.update_item', side_effect=fake.update):
|
|
plan = preview(self.connection)
|
|
result = confirm_and_sync(self.connection, plan['digest'])
|
|
return plan, result
|
|
|
|
def test_first_sync_import_export_and_repeat_is_duplicate_free(self):
|
|
local = self.local('Milk', 'purchased')
|
|
self.local('Private', user=self.other)
|
|
fake = FakeHomeAssistant([{'uid': 'ha-1', 'name': 'Bread', 'status': 'completed'}])
|
|
plan, (done, _) = self.run_with(fake)
|
|
self.assertEqual({action['kind'] for action in plan['operations']}, {'import', 'export'})
|
|
self.assertEqual(done, 2)
|
|
self.assertEqual(fake.items['new-1']['status'], 'completed')
|
|
self.assertEqual(HomeAssistantItemMap.objects.filter(connection=self.connection).count(), 2)
|
|
self.assertEqual(GroceryItem.objects.get(user=self.user, name='Bread').status, 'purchased')
|
|
self.assertEqual(GroceryItem.objects.get(pk=local.pk).name, 'Milk')
|
|
second, (done_again, _) = self.run_with(fake)
|
|
self.assertEqual(second['operations'], [])
|
|
self.assertEqual(done_again, 0)
|
|
self.assertEqual(fake.calls.count(('add', 'Milk')), 1)
|
|
self.assertFalse(GroceryItem.objects.filter(user=self.user, name='Private').exists())
|
|
|
|
def test_ambiguous_same_title_is_not_merged_or_duplicated(self):
|
|
self.local('Eggs')
|
|
fake = FakeHomeAssistant([{'uid': 'ha-1', 'name': 'Eggs', 'status': 'needs_action'}])
|
|
plan, (done, _) = self.run_with(fake)
|
|
self.assertEqual(done, 0)
|
|
self.assertEqual(plan['operations'], [])
|
|
self.assertTrue(plan['issues'])
|
|
self.assertEqual(fake.calls, [])
|
|
|
|
def test_remote_edit_and_completion_pull_into_local(self):
|
|
item = self.local('Tea')
|
|
fake = FakeHomeAssistant([{'uid': 'ha-1', 'name': 'Tea', 'status': 'needs_action'}])
|
|
self.run_with(fake)
|
|
# Initial same-title items are deliberately not matched; create a known mapping.
|
|
HomeAssistantItemMap.objects.create(connection=self.connection, entity_id='todo.shopping', grocery=item,
|
|
ha_uid='ha-1', last_local_hash='x', last_remote_hash='x')
|
|
fake.items['ha-1'].update(name='Green tea', status='completed')
|
|
with patch('home_assistant.sync.get_items', side_effect=fake.get):
|
|
plan = preview(self.connection)
|
|
self.assertEqual(plan['operations'][0]['kind'], 'pull')
|
|
with patch('home_assistant.sync.get_items', side_effect=fake.get):
|
|
confirm_and_sync(self.connection, plan['digest'])
|
|
item.refresh_from_db()
|
|
self.assertEqual((item.name, item.status), ('Green tea', 'purchased'))
|
|
|
|
def test_missing_remote_does_not_delete_local(self):
|
|
item = self.local('Rice')
|
|
HomeAssistantItemMap.objects.create(connection=self.connection, entity_id='todo.shopping', grocery=item,
|
|
ha_uid='gone', last_local_hash='x', last_remote_hash='x')
|
|
fake = FakeHomeAssistant()
|
|
plan, (done, _) = self.run_with(fake)
|
|
self.assertEqual(done, 0)
|
|
self.assertTrue(plan['issues'])
|
|
self.assertTrue(GroceryItem.objects.filter(pk=item.pk).exists())
|
|
|
|
def test_outbound_failure_stays_pending_and_does_not_retry_blindly(self):
|
|
self.local('Oats')
|
|
fake = FakeHomeAssistant()
|
|
with patch('home_assistant.sync.get_items', side_effect=fake.get), \
|
|
patch('home_assistant.sync.add_item', side_effect=ConnectionError('Connection timed out.')):
|
|
plan = preview(self.connection)
|
|
with self.assertRaises(ConnectionError):
|
|
confirm_and_sync(self.connection, plan['digest'])
|
|
mapping = HomeAssistantItemMap.objects.get(connection=self.connection)
|
|
self.assertTrue(mapping.pending_create)
|
|
with patch('home_assistant.sync.get_items', side_effect=fake.get):
|
|
next_plan = preview(self.connection)
|
|
self.assertFalse(next_plan['operations'])
|
|
self.assertTrue(next_plan['issues'])
|
|
|
|
def test_two_sided_conflict_defaults_to_home_assistant(self):
|
|
item = self.local('Original')
|
|
fake = FakeHomeAssistant([{'uid': 'ha-1', 'name': 'Home edit', 'status': 'completed'}])
|
|
baseline = hashlib.sha256(json.dumps(['Original', 'needs_action'], ensure_ascii=False).encode()).hexdigest()
|
|
HomeAssistantItemMap.objects.create(connection=self.connection, entity_id='todo.shopping', grocery=item,
|
|
ha_uid='ha-1', last_local_hash=baseline, last_remote_hash=baseline)
|
|
item.name = 'TasksNest edit'
|
|
item.save()
|
|
plan, (done, _) = self.run_with(fake)
|
|
self.assertEqual(plan['operations'][0]['kind'], 'pull')
|
|
self.assertEqual(done, 1)
|
|
item.refresh_from_db()
|
|
self.assertEqual((item.name, item.status), ('Home edit', 'purchased'))
|
|
|
|
def test_two_sided_conflict_can_choose_tasksnest(self):
|
|
item = self.local('Local edit')
|
|
fake = FakeHomeAssistant([{'uid': 'ha-1', 'name': 'Home edit', 'status': 'completed'}])
|
|
HomeAssistantItemMap.objects.create(connection=self.connection, entity_id='todo.shopping', grocery=item,
|
|
ha_uid='ha-1', last_local_hash='old', last_remote_hash='old')
|
|
self.connection.conflict_winner = 'tasksnest'
|
|
self.connection.save()
|
|
plan, (done, _) = self.run_with(fake)
|
|
self.assertEqual(plan['operations'][0]['kind'], 'push')
|
|
self.assertEqual(done, 1)
|
|
self.assertEqual(fake.items['ha-1']['name'], 'Local edit')
|
|
self.assertEqual(fake.items['ha-1']['status'], 'needs_action')
|
|
|
|
def test_direction_to_ha_pushes_and_unsupported_update_is_blocked(self):
|
|
item = self.local('Original')
|
|
fake = FakeHomeAssistant([{'uid': 'ha-1', 'name': 'Home edit', 'status': 'needs_action'}])
|
|
HomeAssistantItemMap.objects.create(connection=self.connection, entity_id='todo.shopping', grocery=item,
|
|
ha_uid='ha-1', last_local_hash='previous', last_remote_hash='previous')
|
|
self.connection.direction = 'to_ha'
|
|
self.connection.save()
|
|
plan, (done, _) = self.run_with(fake)
|
|
self.assertEqual(plan['operations'][0]['kind'], 'push')
|
|
self.assertEqual(done, 1)
|
|
self.assertEqual(fake.items['ha-1']['name'], 'Original')
|
|
self.connection.entities = [{'id': 'todo.shopping', 'features': 1}]
|
|
self.connection.save()
|
|
item.name = 'Another edit'
|
|
item.save()
|
|
with patch('home_assistant.sync.get_items', side_effect=fake.get):
|
|
blocked = preview(self.connection)
|
|
self.assertFalse(blocked['operations'])
|
|
self.assertTrue(blocked['issues'])
|
|
|
|
def test_stale_preview_cannot_write(self):
|
|
item = self.local('Apples')
|
|
fake = FakeHomeAssistant()
|
|
with patch('home_assistant.sync.get_items', side_effect=fake.get), \
|
|
patch('home_assistant.sync.add_item', side_effect=fake.add):
|
|
digest = preview(self.connection)['digest']
|
|
item.name = 'Oranges'
|
|
item.save()
|
|
with self.assertRaisesRegex(ConnectionError, 'changed after the preview'):
|
|
confirm_and_sync(self.connection, digest)
|
|
self.assertEqual(fake.calls, [])
|
|
|
|
def test_preview_page_requires_signed_confirmation(self):
|
|
self.client.force_login(self.user)
|
|
self.local('Bananas')
|
|
fake = FakeHomeAssistant()
|
|
with patch('home_assistant.sync.get_items', side_effect=fake.get):
|
|
response = self.client.get(reverse('home_assistant:preview'))
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertContains(response, 'Bananas')
|
|
bad = self.client.post(reverse('home_assistant:preview'), {'preview_token': 'invalid'})
|
|
self.assertEqual(bad.status_code, 302)
|
|
self.assertEqual(fake.calls, [])
|
|
|
|
def test_pending_addition_can_only_be_reset_after_checked_absent(self):
|
|
item = self.local('Oats')
|
|
mapping = HomeAssistantItemMap.objects.create(connection=self.connection,
|
|
entity_id='todo.shopping', grocery=item, pending_create=True)
|
|
self.client.force_login(self.user)
|
|
with patch('home_assistant.sync.get_items', return_value={}):
|
|
response = self.client.get(reverse('home_assistant:preview'))
|
|
token = response.context['preview_token']
|
|
refused = self.client.post(reverse('home_assistant:preview'), {
|
|
'action': 'reset-pending', 'mapping_id': mapping.pk, 'preview_token': token,
|
|
})
|
|
self.assertEqual(refused.status_code, 302)
|
|
self.assertTrue(HomeAssistantItemMap.objects.filter(pk=mapping.pk).exists())
|
|
reset = self.client.post(reverse('home_assistant:preview'), {
|
|
'action': 'reset-pending', 'mapping_id': mapping.pk,
|
|
'checked_absent': 'yes', 'preview_token': token,
|
|
})
|
|
self.assertEqual(reset.status_code, 302)
|
|
self.assertFalse(HomeAssistantItemMap.objects.filter(pk=mapping.pk).exists())
|
|
|
|
def test_auto_sync_preferences_and_due_run_are_recorded(self):
|
|
self.client.force_login(self.user)
|
|
self.connection.initial_sync_confirmed = True
|
|
self.connection.save(update_fields=['initial_sync_confirmed', 'updated_at'])
|
|
self.client.post(reverse('home_assistant:settings'), {
|
|
'action': 'sync-options', 'direction': 'both', 'conflict_winner': 'ha',
|
|
'sync_interval_minutes': '5', 'auto_sync_enabled': 'on',
|
|
})
|
|
self.connection.refresh_from_db()
|
|
self.assertTrue(self.connection.auto_sync_enabled)
|
|
self.assertEqual(self.connection.sync_interval_minutes, '5')
|
|
self.connection.task_entity_id = 'todo.tasks'
|
|
self.connection.task_initial_sync_confirmed = True
|
|
self.connection.entities.append({'id': 'todo.tasks', 'features': 85})
|
|
self.connection.save(update_fields=['task_entity_id', 'task_initial_sync_confirmed', 'entities', 'updated_at'])
|
|
fake = FakeHomeAssistant()
|
|
with patch('home_assistant.sync.get_items', side_effect=fake.get), \
|
|
patch('home_assistant.task_sync.get_items', side_effect=fake.get):
|
|
result = run_due_syncs()
|
|
self.assertEqual(result, {'attempted': 2, 'succeeded': 2, 'failed': 0})
|
|
runs = HomeAssistantSyncRun.objects.filter(connection=self.connection)
|
|
self.assertEqual(runs.count(), 2)
|
|
self.assertTrue(all(run.succeeded and run.automatic for run in runs))
|
|
self.connection.refresh_from_db()
|
|
self.assertIsNotNone(self.connection.next_sync_at)
|
|
self.assertEqual(self.connection.consecutive_sync_failures, 0)
|
|
|
|
def test_automatic_retries_stop_after_five_consecutive_failures(self):
|
|
self.connection.auto_sync_enabled = True
|
|
self.connection.sync_interval_minutes = '5'
|
|
self.connection.consecutive_sync_failures = 4
|
|
self.connection.save()
|
|
_schedule_after_failure(self.connection, ConnectionError('Home Assistant is unreachable.'), True)
|
|
self.connection.refresh_from_db()
|
|
self.assertFalse(self.connection.auto_sync_enabled)
|
|
self.assertIsNone(self.connection.next_sync_at)
|
|
self.assertEqual(self.connection.consecutive_sync_failures, 5)
|
|
run = self.connection.sync_runs.first()
|
|
self.assertIn('disabled after five', run.summary)
|
|
|
|
def test_task_sync_maps_due_description_and_completion_without_losing_planner_fields(self):
|
|
local = Task.objects.create(owner=self.user, title='Read a book', description='Chapter 4',
|
|
scheduled_for='2026-11-02', priority=Task.Priority.HIGH, is_completed=True,
|
|
is_outdoor=True, weather_profile=Task.WeatherProfile.SUNNY)
|
|
self.connection.task_entity_id = 'todo.tasks'
|
|
self.connection.entities.append({'id': 'todo.tasks', 'features': 85})
|
|
self.connection.save()
|
|
remote = FakeTaskHomeAssistant([{'uid': 'remote-1', 'name': 'Pay a bill',
|
|
'status': 'completed', 'due': '2026-11-03', 'description': 'Online'}])
|
|
with patch('home_assistant.task_sync.get_items', side_effect=remote.get), \
|
|
patch('home_assistant.task_sync.add_item', side_effect=remote.add), \
|
|
patch('home_assistant.task_sync.update_item', side_effect=remote.update):
|
|
plan = preview_tasks(self.connection)
|
|
self.assertEqual({item['kind'] for item in plan['operations']}, {'task_export', 'task_import'})
|
|
done, _ = confirm_task_sync(self.connection, plan['digest'])
|
|
self.assertEqual(done, 2)
|
|
next_plan = preview_tasks(self.connection)
|
|
self.assertFalse(next_plan['operations'])
|
|
local.refresh_from_db()
|
|
self.assertEqual((local.title, local.description, local.priority, local.is_outdoor,
|
|
local.weather_profile, local.is_completed),
|
|
('Read a book', 'Chapter 4', Task.Priority.HIGH, True,
|
|
Task.WeatherProfile.SUNNY, True))
|
|
imported = Task.objects.get(owner=self.user, title='Pay a bill')
|
|
self.assertEqual((imported.description, imported.scheduled_for.isoformat(), imported.is_completed),
|
|
('Online', '2026-11-03', True))
|
|
self.assertEqual(remote.items['task-1']['status'], 'completed')
|
|
|
|
def test_task_sync_skips_recurring_and_remote_tasks_without_due_dates(self):
|
|
Task.objects.create(owner=self.user, title='Daily journal', scheduled_for='2026-10-22', is_recurring=True)
|
|
self.connection.task_entity_id = 'todo.tasks'
|
|
self.connection.entities.append({'id': 'todo.tasks', 'features': 85})
|
|
self.connection.save()
|
|
remote = FakeTaskHomeAssistant([{'uid': 'remote-1', 'name': 'Unscheduled',
|
|
'status': 'needs_action', 'due': None, 'description': ''}])
|
|
with patch('home_assistant.task_sync.get_items', side_effect=remote.get):
|
|
plan = preview_tasks(self.connection)
|
|
self.assertFalse(plan['operations'])
|
|
self.assertTrue(any('recurs' in issue for issue in plan['issues']))
|
|
self.assertTrue(any('requires a scheduled date' in issue for issue in plan['issues']))
|
|
|
|
def test_reopening_and_local_completion_both_propagate(self):
|
|
fake = FakeHomeAssistant([{'uid': 'ha-1', 'name': 'Coffee', 'status': 'completed'}])
|
|
self.run_with(fake)
|
|
item = GroceryItem.objects.get(user=self.user, name='Coffee')
|
|
self.assertEqual(item.status, 'purchased')
|
|
fake.items['ha-1']['status'] = 'needs_action'
|
|
plan, _ = self.run_with(fake)
|
|
self.assertEqual(plan['operations'][0]['kind'], 'pull')
|
|
item.refresh_from_db()
|
|
self.assertEqual(item.status, 'needed')
|
|
item.status = 'purchased'
|
|
item.save()
|
|
plan, _ = self.run_with(fake)
|
|
self.assertEqual(plan['operations'][0]['kind'], 'push')
|
|
self.assertEqual(fake.items['ha-1']['status'], 'completed')
|
|
|
|
def test_uncertain_addition_reconciles_uid_without_duplicate(self):
|
|
item = self.local('Yoghurt')
|
|
HomeAssistantItemMap.objects.create(connection=self.connection, entity_id='todo.shopping',
|
|
grocery=item, pending_create=True)
|
|
fake = FakeHomeAssistant([{'uid': 'ha-created', 'name': 'Yoghurt', 'status': 'needs_action'}])
|
|
plan, (done, _) = self.run_with(fake)
|
|
self.assertEqual([action['kind'] for action in plan['operations']], ['reconcile'])
|
|
self.assertEqual(done, 1)
|
|
mapping = HomeAssistantItemMap.objects.get(connection=self.connection)
|
|
self.assertEqual(mapping.ha_uid, 'ha-created')
|
|
self.assertEqual(fake.calls, [])
|