import tempfile
from dataclasses import dataclass
from functools import lru_cache
-from math import ceil
from pathlib import Path
from typing import List
from typing import Optional
import magic
from django.conf import settings
from pdf2image import convert_from_path
+from pdf2image.exceptions import PDFPageCountError
from pikepdf import Page
-from pikepdf import PasswordError
from pikepdf import Pdf
-from pikepdf import PdfImage
from PIL import Image
from PIL import ImageSequence
from pyzbar import pyzbar
(page_number, barcode_text) tuples
"""
- def _pikepdf_barcode_scan(pdf_filepath: str) -> List[Barcode]:
- detected_barcodes = []
- with Pdf.open(pdf_filepath) as pdf:
- for page_num, page in enumerate(pdf.pages):
- for image_key in page.images:
- pdfimage = PdfImage(page.images[image_key])
-
- # This type is known to have issues:
- # https://github.com/pikepdf/pikepdf/issues/401
- if "/CCITTFaxDecode" in pdfimage.filters:
- raise BarcodeImageFormatError(
- "Unable to decode CCITTFaxDecode images",
- )
-
- # Not all images can be transcoded to a PIL image, which
- # is what pyzbar expects to receive, so this may
- # raise an exception, triggering fallback
- pillow_img = pdfimage.as_pil_image()
-
- # Scale the image down
- # See: https://github.com/paperless-ngx/paperless-ngx/issues/2385
- # TLDR: zbar has issues with larger images
- width, height = pillow_img.size
- if width > 1024:
- scaler = ceil(width / 1024)
- new_width = int(width / scaler)
- new_height = int(height / scaler)
- pillow_img = pillow_img.resize((new_width, new_height))
-
- width, height = pillow_img.size
- if height > 2048:
- scaler = ceil(height / 2048)
- new_width = int(width / scaler)
- new_height = int(height / scaler)
- pillow_img = pillow_img.resize((new_width, new_height))
-
- for barcode_value in barcode_reader(pillow_img):
- detected_barcodes.append(Barcode(page_num, barcode_value))
-
- return detected_barcodes
-
def _pdf2image_barcode_scan(pdf_filepath: str) -> List[Barcode]:
detected_barcodes = []
# use a temporary directory in case the file is too big to handle in memory
with tempfile.TemporaryDirectory() as path:
- pages_from_path = convert_from_path(pdf_filepath, output_folder=path)
+ pages_from_path = convert_from_path(
+ pdf_filepath,
+ dpi=300,
+ output_folder=path,
+ )
for current_page_number, page in enumerate(pages_from_path):
for barcode_value in barcode_reader(page):
detected_barcodes.append(
# Always try pikepdf first, it's usually fine, faster and
# uses less memory
try:
- barcodes = _pikepdf_barcode_scan(pdf_filepath)
+ barcodes = _pdf2image_barcode_scan(pdf_filepath)
# Password protected files can't be checked
- except PasswordError as e:
+ # This is the exception raised for those
+ except PDFPageCountError as e:
logger.warning(
f"File is likely password protected, not checking for barcodes: {e}",
)
- # Handle pikepdf related image decoding issues with a fallback to page
- # by page conversion to images in a temporary directory
- except Exception as e:
+ # This file is really borked, allow the consumption to continue
+ # but it may fail further on
+ except Exception as e: # pragma: no cover
logger.warning(
- f"Falling back to pdf2image because: {e}",
+ f"Exception during barcode scanning: {e}",
)
- try:
- barcodes = _pdf2image_barcode_scan(pdf_filepath)
- # This file is really borked, allow the consumption to continue
- # but it may fail further on
- except Exception as e: # pragma: no cover
- logger.warning(
- f"Exception during barcode scanning: {e}",
- )
-
else:
logger.warning(
f"Unsupported file format for barcode reader: {str(mime_type)}",
import tempfile
from unittest import mock
-import pikepdf
from django.conf import settings
from django.test import override_settings
from django.test import TestCase
BARCODE_SAMPLE_DIR = os.path.join(SAMPLE_DIR, "barcodes")
- def test_barcode_reader(self):
+ def test_barcode_reader_png(self):
+ """
+ GIVEN:
+ - PNG file with separator barcode
+ WHEN:
+ - Image is scanned for codes
+ THEN:
+ - The barcode is detected
+ """
test_file = os.path.join(self.BARCODE_SAMPLE_DIR, "barcode-39-PATCHT.png")
img = Image.open(test_file)
- separator_barcode = str(settings.CONSUMER_BARCODE_STRING)
+ separator_barcode = settings.CONSUMER_BARCODE_STRING
self.assertEqual(barcodes.barcode_reader(img), [separator_barcode])
- def test_barcode_reader2(self):
+ def test_barcode_reader_pbm(self):
+ """
+ GIVEN:
+ - Netpbm bitmap file with separator barcode
+ WHEN:
+ - Image is scanned for codes
+ THEN:
+ - The barcode is detected
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"patch-code-t.pbm",
separator_barcode = str(settings.CONSUMER_BARCODE_STRING)
self.assertEqual(barcodes.barcode_reader(img), [separator_barcode])
- def test_barcode_reader_distorsion(self):
+ def test_barcode_reader_distortion_scratchy(self):
+ """
+ GIVEN:
+ - Image containing high noise
+ WHEN:
+ - Image is scanned for codes
+ THEN:
+ - The barcode is detected
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
- "barcode-39-PATCHT-distorsion.png",
+ "barcode-39-PATCHT-distortion.png",
)
img = Image.open(test_file)
separator_barcode = str(settings.CONSUMER_BARCODE_STRING)
self.assertEqual(barcodes.barcode_reader(img), [separator_barcode])
- def test_barcode_reader_distorsion2(self):
+ def test_barcode_reader_distortion_stretched(self):
+ """
+ GIVEN:
+ - Image with a stretched barcode
+ WHEN:
+ - Image is scanned for codes
+ THEN:
+ - The barcode is detected
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
- "barcode-39-PATCHT-distorsion2.png",
+ "barcode-39-PATCHT-distortion2.png",
)
img = Image.open(test_file)
separator_barcode = str(settings.CONSUMER_BARCODE_STRING)
self.assertEqual(barcodes.barcode_reader(img), [separator_barcode])
def test_barcode_reader_unreadable(self):
+ """
+ GIVEN:
+ - Image with a truly unreadable barcode
+ WHEN:
+ - Image is scanned for codes
+ THEN:
+ - No barcode is detected
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"barcode-39-PATCHT-unreadable.png",
self.assertEqual(barcodes.barcode_reader(img), [])
def test_barcode_reader_qr(self):
+ """
+ GIVEN:
+ - Image file with QR separator barcode
+ WHEN:
+ - Image is scanned for codes
+ THEN:
+ - The barcode is detected
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"qr-code-PATCHT.png",
self.assertEqual(barcodes.barcode_reader(img), [separator_barcode])
def test_barcode_reader_128(self):
+ """
+ GIVEN:
+ - Image file with 128 style separator barcode
+ WHEN:
+ - Image is scanned for codes
+ THEN:
+ - The barcode is detected
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"barcode-128-PATCHT.png",
self.assertEqual(barcodes.barcode_reader(img), [separator_barcode])
def test_barcode_reader_no_barcode(self):
+ """
+ GIVEN:
+ - Image file with no barcode
+ WHEN:
+ - Image is scanned for codes
+ THEN:
+ - No barcode is detected
+ """
test_file = os.path.join(self.SAMPLE_DIR, "simple.png")
img = Image.open(test_file)
- self.assertEqual(barcodes.barcode_reader(img), [])
+ self.assertListEqual(barcodes.barcode_reader(img), [])
def test_barcode_reader_custom_separator(self):
+ """
+ GIVEN:
+ - Image file with custom separator barcode value
+ WHEN:
+ - Image is scanned for codes
+ THEN:
+ - The barcode is detected
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"barcode-39-custom.png",
self.assertEqual(barcodes.barcode_reader(img), ["CUSTOM BARCODE"])
def test_barcode_reader_custom_qr_separator(self):
+ """
+ GIVEN:
+ - Image file with custom separator barcode value as a QR code
+ WHEN:
+ - Image is scanned for codes
+ THEN:
+ - The barcode is detected
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"barcode-qr-custom.png",
self.assertEqual(barcodes.barcode_reader(img), ["CUSTOM BARCODE"])
def test_barcode_reader_custom_128_separator(self):
+ """
+ GIVEN:
+ - Image file with custom separator 128 barcode value
+ WHEN:
+ - Image is scanned for codes
+ THEN:
+ - The barcode is detected
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"barcode-128-custom.png",
self.assertEqual(barcodes.barcode_reader(img), ["CUSTOM-PREFIX-00123"])
def test_get_mime_type(self):
+ """
+ GIVEN:
+ -
+ WHEN:
+ -
+ THEN:
+ -
+ """
tiff_file = os.path.join(
self.SAMPLE_DIR,
"simple.tiff",
self.assertEqual(barcodes.get_file_mime_type(png_file), "image/png")
def test_convert_from_tiff_to_pdf(self):
+ """
+ GIVEN:
+ -
+ WHEN:
+ -
+ THEN:
+ -
+ """
test_file = os.path.join(
os.path.dirname(__file__),
"samples",
self.assertEqual(file_extension, ".pdf")
def test_convert_error_from_pdf_to_pdf(self):
+ """
+ GIVEN:
+ -
+ WHEN:
+ -
+ THEN:
+ -
+ """
test_file = os.path.join(
self.SAMPLE_DIR,
"simple.pdf",
self.assertIsNone(barcodes.convert_from_tiff_to_pdf(dst))
def test_scan_file_for_separating_barcodes(self):
+ """
+ GIVEN:
+ -
+ WHEN:
+ -
+ THEN:
+ -
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"patch-code-t.pdf",
self.assertListEqual(separator_page_numbers, [0])
def test_scan_file_for_separating_barcodes_none_present(self):
+ """
+ GIVEN:
+ -
+ WHEN:
+ -
+ THEN:
+ -
+ """
test_file = os.path.join(self.SAMPLE_DIR, "simple.pdf")
doc_barcode_info = barcodes.scan_file_for_barcodes(
test_file,
self.assertEqual(doc_barcode_info.pdf_path, test_file)
self.assertListEqual(separator_page_numbers, [])
- def test_scan_file_for_separating_barcodes3(self):
+ def test_scan_file_for_separating_barcodes_middle_page(self):
+ """
+ GIVEN:
+ - PDF file containing a separator on page 1 (zero indexed)
+ WHEN:
+ - File is scanned for barcodes
+ THEN:
+ - Barcode is detected on page 1 (zero indexed)
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"patch-code-t-middle.pdf",
self.assertEqual(doc_barcode_info.pdf_path, test_file)
self.assertListEqual(separator_page_numbers, [1])
- def test_scan_file_for_separating_barcodes4(self):
+ def test_scan_file_for_separating_barcodes_multiple_pages(self):
+ """
+ GIVEN:
+ - PDF file containing a separator on pages 2 and 5 (zero indexed)
+ WHEN:
+ - File is scanned for barcodes
+ THEN:
+ - Barcode is detected on pages 2 and 5 (zero indexed)
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"several-patcht-codes.pdf",
self.assertEqual(doc_barcode_info.pdf_path, test_file)
self.assertListEqual(separator_page_numbers, [2, 5])
- def test_scan_file_for_separating_barcodes_upsidedown(self):
+ def test_scan_file_for_separating_barcodes_upside_down(self):
+ """
+ GIVEN:
+ - PDF file containing a separator on page 1 (zero indexed)
+ - The barcode is upside down
+ WHEN:
+ - File is scanned for barcodes
+ THEN:
+ - Barcode is detected on page 1 (zero indexed)
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"patch-code-t-middle_reverse.pdf",
self.assertEqual(doc_barcode_info.pdf_path, test_file)
self.assertListEqual(separator_page_numbers, [1])
- def test_scan_file_for_barcodes_pillow_transcode_error(self):
- """
- GIVEN:
- - A PDF containing an image which cannot be transcoded to a PIL image
- WHEN:
- - The image tries to be transcoded to a PIL image, but fails
- THEN:
- - The barcode reader is still called
- """
-
- def _build_device_n_pdf(self, save_path: str):
- # Based on the pikepdf tests
- # https://github.com/pikepdf/pikepdf/blob/abb35ebe17d579d76abe08265e00cf8890a12a95/tests/test_image_access.py
- pdf = pikepdf.new()
- pdf.add_blank_page(page_size=(72, 72))
- imobj = pikepdf.Stream(
- pdf,
- bytes(range(0, 256)),
- BitsPerComponent=8,
- ColorSpace=pikepdf.Array(
- [
- pikepdf.Name.DeviceN,
- pikepdf.Array([pikepdf.Name.Black]),
- pikepdf.Name.DeviceCMYK,
- pikepdf.Stream(
- pdf,
- b"{0 0 0 4 -1 roll}", # Colorspace conversion function
- FunctionType=4,
- Domain=[0.0, 1.0],
- Range=[0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0],
- ),
- ],
- ),
- Width=16,
- Height=16,
- Type=pikepdf.Name.XObject,
- Subtype=pikepdf.Name.Image,
- )
- pim = pikepdf.PdfImage(imobj)
- self.assertEqual(pim.mode, "DeviceN")
- self.assertTrue(pim.is_device_n)
-
- pdf.pages[0].Contents = pikepdf.Stream(pdf, b"72 0 0 72 0 0 cm /Im0 Do")
- pdf.pages[0].Resources = pikepdf.Dictionary(
- XObject=pikepdf.Dictionary(Im0=imobj),
- )
- pdf.save(save_path)
-
- with tempfile.NamedTemporaryFile(suffix="pdf") as device_n_pdf:
- # Build an offending file
- _build_device_n_pdf(self, str(device_n_pdf.name))
- with mock.patch("documents.barcodes.barcode_reader") as reader:
- reader.return_value = list()
-
- _ = barcodes.scan_file_for_barcodes(
- str(device_n_pdf.name),
- )
-
- reader.assert_called()
-
def test_scan_file_for_separating_barcodes_fax_decode(self):
"""
GIVEN:
self.assertListEqual(separator_page_numbers, [1])
def test_scan_file_for_separating_qr_barcodes(self):
+ """
+ GIVEN:
+ - PDF file containing a separator on page 0 (zero indexed)
+ - The barcode is a QR code
+ WHEN:
+ - File is scanned for barcodes
+ THEN:
+ - Barcode is detected on page 0 (zero indexed)
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"patch-code-t-qr.pdf",
@override_settings(CONSUMER_BARCODE_STRING="CUSTOM BARCODE")
def test_scan_file_for_separating_custom_barcodes(self):
+ """
+ GIVEN:
+ - PDF file containing a separator on page 0 (zero indexed)
+ - The barcode separation value is customized
+ WHEN:
+ - File is scanned for barcodes
+ THEN:
+ - Barcode is detected on page 0 (zero indexed)
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"barcode-39-custom.pdf",
@override_settings(CONSUMER_BARCODE_STRING="CUSTOM BARCODE")
def test_scan_file_for_separating_custom_qr_barcodes(self):
+ """
+ GIVEN:
+ - PDF file containing a separator on page 0 (zero indexed)
+ - The barcode separation value is customized
+ - The barcode is a QR code
+ WHEN:
+ - File is scanned for barcodes
+ THEN:
+ - Barcode is detected on page 0 (zero indexed)
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"barcode-qr-custom.pdf",
@override_settings(CONSUMER_BARCODE_STRING="CUSTOM BARCODE")
def test_scan_file_for_separating_custom_128_barcodes(self):
+ """
+ GIVEN:
+ - PDF file containing a separator on page 0 (zero indexed)
+ - The barcode separation value is customized
+ - The barcode is a 128 code
+ WHEN:
+ - File is scanned for barcodes
+ THEN:
+ - Barcode is detected on page 0 (zero indexed)
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"barcode-128-custom.pdf",
self.assertListEqual(separator_page_numbers, [0])
def test_scan_file_for_separating_wrong_qr_barcodes(self):
+ """
+ GIVEN:
+ - PDF file containing a separator on page 0 (zero indexed)
+ - The barcode value is customized
+ - The separation value is NOT customized
+ WHEN:
+ - File is scanned for barcodes
+ THEN:
+ - No split pages are detected
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"barcode-39-custom.pdf",
self.assertListEqual(separator_page_numbers, [1])
def test_separate_pages(self):
+ """
+ GIVEN:
+ - Input PDF 2 pages after separation
+ WHEN:
+ - The input file separated at the barcode
+ THEN:
+ - Two new documents are produced
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"patch-code-t-middle.pdf",
)
- pages = barcodes.separate_pages(test_file, [1])
+ documents = barcodes.separate_pages(test_file, [1])
- self.assertEqual(len(pages), 2)
+ self.assertEqual(len(documents), 2)
def test_separate_pages_double_code(self):
"""
"""
test_file = os.path.join(
os.path.dirname(__file__),
- "samples",
- "barcodes",
+ self.BARCODE_SAMPLE_DIR,
"patch-code-t-double.pdf",
)
pages = barcodes.separate_pages(test_file, [1, 2])
self.assertEqual(len(pages), 2)
def test_separate_pages_no_list(self):
+ """
+ GIVEN:
+ - Input file to separate
+ WHEN:
+ - No separation pages are provided
+ THEN:
+ - No new documents are produced
+ - A warning is logged
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"patch-code-t-middle.pdf",
)
def test_save_to_dir(self):
+ """
+ GIVEN:
+ - File to save to a directory
+ WHEN:
+ - The file is saved
+ THEN:
+ - The file exists
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"patch-code-t.pdf",
)
- tempdir = tempfile.mkdtemp(prefix="paperless-", dir=settings.SCRATCH_DIR)
- barcodes.save_to_dir(test_file, target_dir=tempdir)
- target_file = os.path.join(tempdir, "patch-code-t.pdf")
+ barcodes.save_to_dir(test_file, target_dir=settings.SCRATCH_DIR)
+ target_file = os.path.join(settings.SCRATCH_DIR, "patch-code-t.pdf")
self.assertTrue(os.path.isfile(target_file))
- def test_save_to_dir2(self):
+ def test_save_to_dir_not_existing(self):
+ """
+ GIVEN:
+ - File to save to a directory
+ - The directory doesn't exist
+ WHEN:
+ - The file is saved
+ THEN:
+ - The file exists
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"patch-code-t.pdf",
nonexistingdir = "/nowhere"
if os.path.isdir(nonexistingdir):
self.fail("non-existing dir exists")
- else:
- with self.assertLogs("paperless.barcodes", level="WARNING") as cm:
- barcodes.save_to_dir(test_file, target_dir=nonexistingdir)
- self.assertEqual(
- cm.output,
- [
- f"WARNING:paperless.barcodes:{str(test_file)} or {str(nonexistingdir)} don't exist.",
- ],
- )
- def test_save_to_dir3(self):
+ with self.assertLogs("paperless.barcodes", level="WARNING") as cm:
+ barcodes.save_to_dir(test_file, target_dir=nonexistingdir)
+ self.assertEqual(
+ cm.output,
+ [
+ f"WARNING:paperless.barcodes:{str(test_file)} or {str(nonexistingdir)} don't exist.",
+ ],
+ )
+
+ def test_save_to_dir_given_name(self):
+ """
+ GIVEN:
+ - File to save to a directory
+ - There is a name override
+ WHEN:
+ - The file is saved
+ THEN:
+ - The file exists
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"patch-code-t.pdf",
)
- tempdir = tempfile.mkdtemp(prefix="paperless-", dir=settings.SCRATCH_DIR)
- barcodes.save_to_dir(test_file, newname="newname.pdf", target_dir=tempdir)
- target_file = os.path.join(tempdir, "newname.pdf")
+ barcodes.save_to_dir(
+ test_file,
+ newname="newname.pdf",
+ target_dir=settings.SCRATCH_DIR,
+ )
+ target_file = os.path.join(settings.SCRATCH_DIR, "newname.pdf")
self.assertTrue(os.path.isfile(target_file))
def test_barcode_splitter(self):
+ """
+ GIVEN:
+ - Input file containing barcodes
+ WHEN:
+ - Input file is split on barcodes
+ THEN:
+ - Correct number of files produced
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"patch-code-t-middle.pdf",
)
- tempdir = tempfile.mkdtemp(prefix="paperless-", dir=settings.SCRATCH_DIR)
doc_barcode_info = barcodes.scan_file_for_barcodes(
test_file,
self.assertTrue(len(separator_page_numbers) > 0)
document_list = barcodes.separate_pages(test_file, separator_page_numbers)
- self.assertTrue(document_list)
+ self.assertGreater(len(document_list), 0)
+
for document in document_list:
- barcodes.save_to_dir(document, target_dir=tempdir)
+ barcodes.save_to_dir(document, target_dir=settings.SCRATCH_DIR)
- target_file1 = os.path.join(tempdir, "patch-code-t-middle_document_0.pdf")
- target_file2 = os.path.join(tempdir, "patch-code-t-middle_document_1.pdf")
+ target_file1 = os.path.join(
+ settings.SCRATCH_DIR,
+ "patch-code-t-middle_document_0.pdf",
+ )
+ target_file2 = os.path.join(
+ settings.SCRATCH_DIR,
+ "patch-code-t-middle_document_1.pdf",
+ )
self.assertTrue(os.path.isfile(target_file1))
self.assertTrue(os.path.isfile(target_file2))
@override_settings(CONSUMER_ENABLE_BARCODES=True)
def test_consume_barcode_file(self):
+ """
+ GIVEN:
+ - Input file with barcodes given to consume task
+ WHEN:
+ - Consume task returns
+ THEN:
+ - The file was split
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"patch-code-t-middle.pdf",
CONSUMER_BARCODE_TIFF_SUPPORT=True,
)
def test_consume_barcode_tiff_file(self):
+ """
+ GIVEN:
+ - TIFF image containing barcodes
+ WHEN:
+ - Consume task returns
+ THEN:
+ - The file was split
+ """
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"patch-code-t-middle.tiff",
@mock.patch("documents.consumer.Consumer.try_consume_file")
def test_consume_barcode_unsupported_jpg_file(self, m):
"""
- This test assumes barcode and TIFF support are enabled and
- the user uploads an unsupported image file (e.g. jpg)
-
- The function shouldn't try to scan for separating barcodes
- and continue archiving the file as is.
+ GIVEN:
+ - JPEG image as input
+ WHEN:
+ - Consume task returns
+ THEN:
+ - Barcode reader reported warning
+ - Consumption continued with the file
"""
test_file = os.path.join(
self.SAMPLE_DIR,
)
dst = os.path.join(settings.SCRATCH_DIR, "simple.jpg")
shutil.copy(test_file, dst)
+
with self.assertLogs("paperless.barcodes", level="WARNING") as cm:
self.assertIn("Success", tasks.consume_file(dst))
+
self.assertListEqual(
cm.output,
[
)
def test_consume_barcode_supported_no_extension_file(self):
"""
- This test assumes barcode and TIFF support are enabled and
- the user uploads a supported image file, but without extension
+ GIVEN:
+ - TIFF image containing barcodes
+ - TIFF file is given without extension
+ WHEN:
+ - Consume task returns
+ THEN:
+ - The file was split
"""
test_file = os.path.join(
self.BARCODE_SAMPLE_DIR,
"""
GIVEN:
- Password protected PDF
- - pikepdf based scanning
WHEN:
- File is scanned for barcode
THEN:
- - Scanning handles the exception without exception
+ - Scanning handles the exception without crashing
"""
test_file = os.path.join(self.SAMPLE_DIR, "password-is-test.pdf")
doc_barcode_info = barcodes.scan_file_for_barcodes(
@override_settings(CONSUMER_ENABLE_ASN_BARCODE=True)
def test_asn_too_large(self):
-
+ """
+ GIVEN:
+ - ASN from barcode enabled
+ - Barcode contains too large an ASN value
+ WHEN:
+ - ASN from barcode checked for correctness
+ THEN:
+ - Exception is raised regarding size limits
+ """
src = os.path.join(
os.path.dirname(__file__),
"samples",
projects / thirdparty / paperless-ngx.git / commitdiff
