295 lines
17 KiB
Python
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')
|