Files
Django_TasksApp/main/food/test_inventory_scanner.py
T

295 lines
17 KiB
Python

from datetime import timedelta
from decimal import Decimal
from unittest.mock import patch
from django.contrib.auth import get_user_model
from django.test import TestCase, override_settings
from django.urls import reverse
from django.utils import timezone
from food.models import (FoodProduct, InventoryLocation, InventoryScanBatch,
InventoryReviewPreference, InventoryScanItem, InventoryScanRun,
KitchenInventoryItem, OpenFoodFactsRequest)
from food.services.inventory_scanner import (ScanWorkflowError,
adjust_confirmed_count, approve_scan_item, approve_scan_items, confirm_scan_item, create_active_scan, get_or_create_active_run,
process_next_scan_item, save_review_item, submit_batch, update_review_preference)
from food.services.off_rate_limit import OpenFoodFactsRateLimited, off_http_request
from food.services.openfoodfacts import OpenFoodFactsTransientError
class InventoryScanQueueTests(TestCase):
def setUp(self):
self.user = get_user_model().objects.create_user(username='scanner-owner', password='test-password')
self.other = get_user_model().objects.create_user(username='scanner-other', password='test-password')
self.fridge = InventoryLocation.objects.create(user=self.user, name='Fridge')
self.shelf = InventoryLocation.objects.create(user=self.user, name='Shelf')
self.product = FoodProduct.objects.create(owner=self.user, barcode='12345678',
product_name='Oat drink', package_amount=Decimal('1000'), package_unit='ml')
def _confirmed_item(self, location=None, barcode='12345678'):
run = get_or_create_active_run(self.user, (location or self.fridge).pk)
item = create_active_scan(run, self.user, barcode)
confirm_scan_item(self.user, item.pk, {
'location_id': (location or self.fridge).pk, 'product_name': 'Oat drink',
'package_count': 2, 'package_amount': '1000', 'package_unit': 'ml',
})
return run, item
def test_location_batches_are_atomic_and_keep_original_locations(self):
run, item = self._confirmed_item()
batch = item.batch
updated = submit_batch(self.user, batch_id=batch.pk, next_location_id=self.shelf.pk)
batch.refresh_from_db()
new_batch = updated.batches.get(status=InventoryScanBatch.Status.DRAFT)
self.assertEqual((batch.status, batch.location), (InventoryScanBatch.Status.QUEUED, self.fridge))
self.assertEqual(new_batch.location, self.shelf)
self.assertEqual(item.location, self.fridge)
item.refresh_from_db()
self.assertEqual(item.status, InventoryScanItem.Status.QUEUED)
def test_batch_rejects_other_users_location(self):
run, item = self._confirmed_item()
foreign = InventoryLocation.objects.create(user=self.other, name='Other')
with self.assertRaises(ScanWorkflowError):
submit_batch(self.user, batch_id=item.batch_id, next_location_id=foreign.pk)
item.refresh_from_db()
self.assertEqual(item.status, InventoryScanItem.Status.CONFIRMED)
def test_active_run_resumes_and_rejects_second_active_scan(self):
run = get_or_create_active_run(self.user, self.fridge.pk)
item = create_active_scan(run, self.user, '12345678')
self.assertEqual(get_or_create_active_run(self.user, self.shelf.pk).pk, run.pk)
with self.assertRaises(ScanWorkflowError):
create_active_scan(run, self.user, '87654321')
def test_done_enqueues_and_worker_creates_separate_tracked_packages(self):
run, item = self._confirmed_item()
submit_batch(self.user, batch_id=item.batch_id, finish=True)
with patch('food.services.inventory_scanner._send_completion_notification') as notify:
self.assertTrue(process_next_scan_item())
item.refresh_from_db()
run.refresh_from_db()
self.assertEqual(item.status, InventoryScanItem.Status.COMPLETE)
self.assertEqual(item.inventory_item.product, self.product)
stock = KitchenInventoryItem.objects.filter(user=self.user, product=self.product)
self.assertEqual(stock.count(), 2)
self.assertTrue(all(row.original_amount == Decimal('1000') and row.inventory_unit == 'ml' for row in stock))
self.assertEqual(run.status, InventoryScanRun.Status.COMPLETE)
notify.assert_called_once_with(run.pk)
def test_transient_error_is_scheduled_and_bounded_by_ten_attempts(self):
run, item = self._confirmed_item(barcode='87654321')
submit_batch(self.user, batch_id=item.batch_id, finish=True)
def transient_request(*args, **kwargs):
kwargs['on_request_start']()
raise OpenFoodFactsTransientError('temporary failure', retry_after=30)
with patch('food.services.inventory_scanner.cached_product', side_effect=transient_request):
process_next_scan_item()
item.refresh_from_db()
self.assertEqual(item.attempts, 1)
self.assertEqual(item.status, InventoryScanItem.Status.QUEUED)
self.assertGreaterEqual(item.next_attempt_at, timezone.now() + timedelta(seconds=29))
def test_tenth_actual_transient_request_moves_item_to_review(self):
run, item = self._confirmed_item(barcode='87654321')
submit_batch(self.user, batch_id=item.batch_id, finish=True)
InventoryScanItem.objects.filter(pk=item.pk).update(attempts=9)
def transient_request(*args, **kwargs):
kwargs['on_request_start']()
raise OpenFoodFactsTransientError('temporary failure')
with patch('food.services.inventory_scanner.cached_product', side_effect=transient_request):
process_next_scan_item()
item.refresh_from_db()
self.assertEqual(item.attempts, 10)
self.assertEqual(item.status, InventoryScanItem.Status.NEEDS_REVIEW)
def test_unknown_product_moves_to_review_without_losing_user_fields(self):
run, item = self._confirmed_item(barcode='87654321')
submit_batch(self.user, batch_id=item.batch_id, finish=True)
with patch('food.services.inventory_scanner.cached_product', return_value=None):
process_next_scan_item()
item.refresh_from_db()
self.assertEqual(item.status, InventoryScanItem.Status.NEEDS_REVIEW)
self.assertEqual(item.product_name, 'Oat drink')
self.assertEqual(item.location, self.fridge)
self.assertIsNone(item.inventory_item)
class OpenFoodFactsGlobalLimitTests(TestCase):
def test_non_waiting_request_is_refused_when_shared_budget_is_full(self):
now = timezone.now()
OpenFoodFactsRequest.objects.bulk_create([
OpenFoodFactsRequest(requested_at=now - timedelta(seconds=10 * index), endpoint='product')
for index in range(5)
])
with self.assertRaises(OpenFoodFactsRateLimited):
with off_http_request('search', wait=False):
self.fail('The sixth actual request must not start.')
self.assertEqual(OpenFoodFactsRequest.objects.count(), 5)
def test_failed_actual_request_still_consumes_budget(self):
with self.assertRaises(RuntimeError):
with off_http_request('product', wait=False):
raise RuntimeError('network error after request start')
self.assertEqual(OpenFoodFactsRequest.objects.count(), 1)
class InventoryReviewServiceTests(TestCase):
def setUp(self):
self.user = get_user_model().objects.create_user(username='review-owner', password='test-password')
self.fridge = InventoryLocation.objects.create(user=self.user, name='Fridge')
self.shelf = InventoryLocation.objects.create(user=self.user, name='Shelf')
def _staged_item(self, barcode):
run = get_or_create_active_run(self.user, self.fridge.pk)
item = create_active_scan(run, self.user, barcode)
confirm_scan_item(self.user, item.pk, {'location_id': self.fridge.pk,
'product_name': 'Review beans', 'package_count': 2})
submit_batch(self.user, batch_id=item.batch_id, finish=True)
with patch('food.services.inventory_scanner.cached_product', return_value=None):
process_next_scan_item()
item.refresh_from_db()
return item
def test_mode_preference_persists_and_review_edits_are_saved(self):
item = self._staged_item('87654321')
self.assertEqual(update_review_preference(self.user, 'bulk').mode, 'bulk')
saved = save_review_item(self.user, item.pk, {'product_name': 'Edited beans',
'package_count': '3', 'location_id': self.shelf.pk, 'energy_kcal_100': '0'})
self.assertEqual((saved.product_name, saved.package_count, saved.location),
('Edited beans', 3, self.shelf))
self.assertEqual(saved.source_data['nutrition']['energy_kcal_100'], '0.000')
self.assertEqual(InventoryReviewPreference.objects.get(user=self.user).mode, 'bulk')
def test_repeated_confirmed_barcode_increments_pending_package_with_undo(self):
run = get_or_create_active_run(self.user, self.fridge.pk)
item = create_active_scan(run, self.user, '87654321')
confirm_scan_item(self.user, item.pk, {'location_id': self.fridge.pk, 'product_name': 'Beans'})
repeated = create_active_scan(run, self.user, '87654321')
self.assertEqual(repeated.pk, item.pk)
self.assertEqual(repeated.package_count, 2)
adjusted = adjust_confirmed_count(self.user, item.pk, -1)
self.assertEqual(adjusted.package_count, 1)
def test_individual_approval_keeps_unknown_nutrition_null_and_zero_known(self):
item = self._staged_item('87654321')
approved = approve_scan_item(self.user, item.pk, {
'product_name': 'Review beans', 'package_count': '2', 'location_id': self.fridge.pk,
'energy_kcal_100': '0', 'fat_100': '',
})
approved.product.refresh_from_db()
self.assertEqual(approved.status, InventoryScanItem.Status.COMPLETE)
self.assertEqual(approved.product.energy_kcal_100, Decimal('0.000'))
self.assertIsNone(approved.product.fat_100)
stock = KitchenInventoryItem.objects.get(product=approved.product)
self.assertEqual(stock.quantity, 2)
def test_bulk_approval_applies_shared_fields_to_selected_items_atomically(self):
run = get_or_create_active_run(self.user, self.fridge.pk)
items = []
for barcode, name in (('87654321', 'Beans'), ('87654322', 'Rice')):
item = create_active_scan(run, self.user, barcode)
confirm_scan_item(self.user, item.pk, {'location_id': self.fridge.pk, 'product_name': name})
items.append(item)
submit_batch(self.user, batch_id=items[0].batch_id, finish=True)
with patch('food.services.inventory_scanner.cached_product', return_value=None), \
patch('food.services.inventory_scanner._send_completion_notification'):
process_next_scan_item()
process_next_scan_item()
approved = approve_scan_items(self.user, [item.pk for item in items], {
'location_id': self.shelf.pk, 'category_name': 'Dry goods'})
self.assertEqual(len(approved), 2)
self.assertTrue(all(item.status == InventoryScanItem.Status.COMPLETE for item in approved))
self.assertTrue(all(item.inventory_item.location == self.shelf for item in approved))
self.assertEqual(KitchenInventoryItem.objects.filter(user=self.user, category__name='Dry goods').count(), 2)
@override_settings(SECURE_SSL_REDIRECT=False)
class InventoryScanWorkflowViewTests(TestCase):
def setUp(self):
self.user = get_user_model().objects.create_user(username='scanner-web', password='test-password')
self.other = get_user_model().objects.create_user(username='scanner-web-other', password='test-password')
self.fridge = InventoryLocation.objects.create(user=self.user, name='Fridge')
self.pantry = InventoryLocation.objects.create(user=self.user, name='Pantry')
self.client.force_login(self.user)
def test_scanner_page_starts_and_resumes_a_persisted_session(self):
response = self.client.get(reverse('food:scanner-inventory'))
self.assertContains(response, 'Choose a starting location')
response = self.client.post(reverse('food:inventory-scan-start'), {'location_id': self.fridge.pk})
self.assertRedirects(response, reverse('food:scanner-inventory'), fetch_redirect_response=False)
run = InventoryScanRun.objects.get(user=self.user)
response = self.client.get(reverse('food:scanner-inventory'))
self.assertContains(response, 'Camera scanner')
self.assertContains(response, 'Fridge')
self.assertContains(response, str(run.api_id))
def test_confirm_save_next_location_and_done_endpoints(self):
run = get_or_create_active_run(self.user, self.fridge.pk)
response = self.client.post(reverse('food:inventory-scan-create', args=[run.api_id]),
{'barcode': '1234567890123'})
self.assertEqual(response.status_code, 200)
item_id = response.json()['item']['id']
self.assertIn('Confirm & keep scanning', response.json()['html'])
response = self.client.post(reverse('food:inventory-scan-confirm', args=[item_id]), {
'location_id': self.fridge.pk, 'product_name': 'Black beans', 'package_count': '2',
'package_amount': '', 'package_unit': '', 'opened': '',
})
self.assertEqual(response.status_code, 200)
item = InventoryScanItem.objects.get(pk=item_id)
response = self.client.post(reverse('food:inventory-scan-submit', args=[item.batch_id]),
{'next_location_id': self.pantry.pk})
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['location'], 'Pantry')
next_batch = run.batches.get(status=InventoryScanBatch.Status.DRAFT)
response = self.client.post(reverse('food:inventory-scan-submit', args=[next_batch.pk]), {'finish': 'true'})
self.assertEqual(response.json()['redirect'], reverse('food:inventory'))
run.refresh_from_db()
self.assertEqual(run.status, InventoryScanRun.Status.PROCESSING)
def test_scan_item_and_queue_are_private_to_session_owner(self):
run = get_or_create_active_run(self.user, self.fridge.pk)
item = create_active_scan(run, self.user, '1234567890123')
self.client.force_login(self.other)
self.assertEqual(self.client.get(reverse('food:inventory-scan-queue', args=[run.api_id])).status_code, 404)
self.assertEqual(self.client.post(reverse('food:inventory-scan-discard', args=[item.pk])).status_code, 400)
def test_review_mode_switch_saves_edits_and_bulk_preview_shows_selected_products(self):
run = get_or_create_active_run(self.user, self.fridge.pk)
item = create_active_scan(run, self.user, '1234567890123')
confirm_scan_item(self.user, item.pk, {'location_id': self.fridge.pk, 'product_name': 'Lentils'})
submit_batch(self.user, batch_id=item.batch_id, finish=True)
with patch('food.services.inventory_scanner.cached_product', return_value=None):
process_next_scan_item()
item.refresh_from_db()
response = self.client.post(reverse('food:inventory-review-item', args=[item.pk]), {
'action': 'mode', 'mode': 'bulk', 'product_name': 'Green lentils', 'brand': '',
'location_id': self.pantry.pk, 'category_name': 'Pulses', 'package_count': '1',
'package_amount': '', 'package_unit': '', 'notes': '',
})
self.assertRedirects(response, reverse('food:inventory-review') + '?mode=bulk', fetch_redirect_response=False)
item.refresh_from_db()
self.assertEqual((item.product_name, item.location, item.category_name),
('Green lentils', self.pantry, 'Pulses'))
response = self.client.post(reverse('food:inventory-review'), {
'action': 'preview', 'item_ids': [str(item.pk)], 'location_id': self.fridge.pk,
'category_name': 'Dry goods',
})
self.assertContains(response, 'Preview selected products')
self.assertContains(response, 'Green lentils')
def test_deferred_items_have_separate_state_and_missing_names_are_individual_only(self):
run = InventoryScanRun.objects.create(user=self.user, selected_location=self.fridge)
batch = InventoryScanBatch.objects.create(run=run, location=self.fridge, sequence=1)
item = InventoryScanItem.objects.create(batch=batch, location=self.fridge, barcode='9876543210123',
status=InventoryScanItem.Status.DEFERRED, last_error='A name is needed.')
response = self.client.post(reverse('food:inventory-review'), {
'action': 'mode', 'mode': 'bulk', 'state': 'deferred'})
self.assertRedirects(response, reverse('food:inventory-review') + '?mode=bulk&state=deferred',
fetch_redirect_response=False)
response = self.client.get(reverse('food:inventory-review'), {'mode': 'bulk', 'state': 'deferred'})
self.assertContains(response, 'Deferred scan items')
self.assertContains(response, f'name="item_ids" value="{item.pk}" disabled')
self.assertEqual(response.context['eligible_bulk_count'], 0)
self.assertContains(response, 'data-bulk-preview-submit disabled')