12265683069

Committed 10 Dec 2024 10:16PM UTC coverage: 78.038% (-0.2%) from 78.254%

Build # 12265683069

Build Type

push

github

Committed by

JaCraig

Commit Message

fix: Add logging capabilities and fixed testing issues

- Implemented IDisposable in OcrSubProcessor for resource management.
- Updated OcrSubProcessor to use a class-level TesseractEngine instance.
- Added Microsoft.Extensions.Logging package to Archivist.Tests.csproj.
- Introduced ILogger parameter to various classes and methods.
- Enhanced test classes to support dependency injection and logging.
- Added logging statements to multiple classes for better debugging.
- Ensured backward compatibility with null checks and default values.

Run Details

2482 of 3470 branches covered (71.53%)

Branch coverage included in aggregate %.

139 of 180 new or added lines in 39 files covered. (77.22%)

24 existing lines in 16 files now uncovered.

3221 of 3838 relevant lines covered (83.92%)

8671.95 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.05

/Archivist/BaseClasses/ReaderBaseClass.cs

﻿using Archivist.Interfaces;
using Microsoft.Extensions.Logging;
using System;
using System.Buffers;
using System.IO;
using System.Threading.Tasks;

namespace Archivist.BaseClasses
{
    /// <summary>
    /// Base class for format readers.
    /// </summary>
    /// <seealso cref="IFormatReader"/>
    /// <remarks>
    /// Initializes a new instance of the <see cref="ReaderBaseClass"/> class.
    /// </remarks>
    /// <param name="logger">The logger to use for logging.</param>
    public abstract class ReaderBaseClass(ILogger? logger) : IFormatReader
    {
        /// <summary>
        /// Gets the header information for the format.
        /// </summary>
        public abstract byte[] HeaderInfo { get; }

        /// <summary>
        /// Gets the logger to use for logging.
        /// </summary>
        protected ILogger? Logger { get; } = logger;

        /// <summary>
        /// Determines whether the reader can read the specified stream.
        /// </summary>
        /// <param name="stream">The stream to read.</param>
        /// <returns><c>true</c> if the reader can read the stream; otherwise, <c>false</c>.</returns>
        public bool CanRead(Stream? stream)
        {
            if (stream is null || !IsValidStream(stream))
            {
                Logger?.LogDebug("{readerName}.CanRead(): Stream is null or invalid.", GetType().Name);
                return false;
            }
            if (HeaderInfo.Length == 0)
                return InternalCanRead(stream);
            try
            {
                _ = stream.Seek(0, SeekOrigin.Begin);
                var StartIndex = FindStartIndex(stream);
                _ = stream.Seek(StartIndex, SeekOrigin.Begin);
                var Buffer = ArrayPool<byte>.Shared.Rent(HeaderInfo.Length);
                _ = stream.Read(Buffer, 0, Buffer.Length);
                _ = stream.Seek(0, SeekOrigin.Begin);
                for (var X = 0; X < HeaderInfo.Length; ++X)
                {
                    if (Buffer[X] != HeaderInfo[X])
                    {
                        ArrayPool<byte>.Shared.Return(Buffer);
                        return false;
                    }
                }
                ArrayPool<byte>.Shared.Return(Buffer);
                return InternalCanRead(stream);
            }
            catch (Exception Ex)
            {
                Logger?.LogError(Ex, "{readerName}.CanRead(): Error occurred while checking if the reader can read the stream.", GetType().Name);
                return false;
            }
        }

        /// <summary>
        /// Used to determine if a reader can actually read the file.
        /// </summary>
        /// <param name="stream">The stream to read.</param>
        /// <returns><c>true</c> if the reader can read the file; otherwise, <c>false</c>.</returns>
        public virtual bool InternalCanRead(Stream? stream) => true;

        /// <summary>
        /// Reads the file asynchronously.
        /// </summary>
        /// <param name="stream">The stream to read.</param>
        /// <returns>
        /// A task representing the asynchronous operation that returns the generic file.
        /// </returns>
        public abstract Task<IGenericFile?> ReadAsync(Stream? stream);

        /// <summary>
        /// Validates if the provided stream is readable, has a non-zero length, and supports seeking.
        /// </summary>
        /// <param name="stream">The stream to validate.</param>
        /// <returns><c>true</c> if the stream is valid; otherwise, <c>false</c>.</returns>
        protected static bool IsValidStream(Stream? stream)
        {
            if (stream?.CanRead != true)
                return false;
            if (stream.Length == 0)
                return false;
            if (!stream.CanSeek)
                return false;
            try
            {
                var TempBuffer = ArrayPool<byte>.Shared.Rent(1);
                _ = stream.Seek(0, SeekOrigin.Begin);
                _ = stream.Read(TempBuffer, 0, 1);
                _ = stream.Seek(0, SeekOrigin.Begin);
                ArrayPool<byte>.Shared.Return(TempBuffer);
            }
            catch
            {
                return false;
            }
            return true;
        }

        /// <summary>
        /// Finds the start index of the file.
        /// </summary>
        /// <param name="stream">The stream to read.</param>
        /// <returns>The start index of the file.</returns>
        private static int FindStartIndex(Stream stream)
        {
            if (stream.Length < 3)
                return 0;
            var BOMBuffer = ArrayPool<byte>.Shared.Rent(3);
            _ = stream.Read(BOMBuffer, 0, BOMBuffer.Length);
            _ = stream.Seek(0, SeekOrigin.Begin);
            var ReturnValue = BOMBuffer[0] == 0xEF && BOMBuffer[1] == 0xBB && BOMBuffer[2] == 0xBF ? 3 : 0;
            ArrayPool<byte>.Shared.Return(BOMBuffer);
            return ReturnValue;
        }
    }
}

1	using Archivist.Interfaces;
2	using Microsoft.Extensions.Logging;
3	using System;
4	using System.Buffers;
5	using System.IO;
6	using System.Threading.Tasks;
7
8	namespace Archivist.BaseClasses
9	{
10	/// <summary>
11	/// Base class for format readers.
12	/// </summary>
13	/// <seealso cref="IFormatReader"/>
14	/// <remarks>
15	/// Initializes a new instance of the <see cref="ReaderBaseClass"/> class.
16	/// </remarks>
17	/// <param name="logger">The logger to use for logging.</param>
18	public abstract class ReaderBaseClass(ILogger? logger) : IFormatReader	389✔
19	{
20	/// <summary>
21	/// Gets the header information for the format.
22	/// </summary>
23	public abstract byte[] HeaderInfo { get; }
24
25	/// <summary>
26	/// Gets the logger to use for logging.
27	/// </summary>
28	protected ILogger? Logger { get; } = logger;	1,978✔
29
30	/// <summary>
31	/// Determines whether the reader can read the specified stream.
32	/// </summary>
33	/// <param name="stream">The stream to read.</param>
34	/// <returns><c>true</c> if the reader can read the stream; otherwise, <c>false</c>.</returns>
35	public bool CanRead(Stream? stream)
36	{
37	if (stream is null \|\| !IsValidStream(stream))	647✔
38	{
39	Logger?.LogDebug("{readerName}.CanRead(): Stream is null or invalid.", GetType().Name);	638!
40	return false;	638✔
41	}
42	if (HeaderInfo.Length == 0)	9✔
43	return InternalCanRead(stream);	5✔
44	try
45	{
46	_ = stream.Seek(0, SeekOrigin.Begin);	4✔
47	var StartIndex = FindStartIndex(stream);	4✔
48	_ = stream.Seek(StartIndex, SeekOrigin.Begin);	4✔
49	var Buffer = ArrayPool<byte>.Shared.Rent(HeaderInfo.Length);	4✔
50	_ = stream.Read(Buffer, 0, Buffer.Length);	4✔
51	_ = stream.Seek(0, SeekOrigin.Begin);	4✔
52	for (var X = 0; X < HeaderInfo.Length; ++X)	30✔
53	{
54	if (Buffer[X] != HeaderInfo[X])	14✔
55	{
56	ArrayPool<byte>.Shared.Return(Buffer);	3✔
57	return false;	3✔
58	}
59	}
60	ArrayPool<byte>.Shared.Return(Buffer);	1✔
61	return InternalCanRead(stream);	1✔
62	}
NEW 63	catch (Exception Ex)	×
64	{
NEW 65	Logger?.LogError(Ex, "{readerName}.CanRead(): Error occurred while checking if the reader can read the stream.", GetType().Name);	×
UNCOV 66	return false;	×
67	}
68	}	4✔
69
70	/// <summary>
71	/// Used to determine if a reader can actually read the file.
72	/// </summary>
73	/// <param name="stream">The stream to read.</param>
74	/// <returns><c>true</c> if the reader can read the file; otherwise, <c>false</c>.</returns>
75	public virtual bool InternalCanRead(Stream? stream) => true;	97✔
76
77	/// <summary>
78	/// Reads the file asynchronously.
79	/// </summary>
80	/// <param name="stream">The stream to read.</param>
81	/// <returns>
82	/// A task representing the asynchronous operation that returns the generic file.
83	/// </returns>
84	public abstract Task<IGenericFile?> ReadAsync(Stream? stream);
85
86	/// <summary>
87	/// Validates if the provided stream is readable, has a non-zero length, and supports seeking.
88	/// </summary>
89	/// <param name="stream">The stream to validate.</param>
90	/// <returns><c>true</c> if the stream is valid; otherwise, <c>false</c>.</returns>
91	protected static bool IsValidStream(Stream? stream)
92	{
93	if (stream?.CanRead != true)	1,594!
94	return false;	6✔
95	if (stream.Length == 0)	1,588✔
96	return false;	18✔
97	if (!stream.CanSeek)	1,570!
98	return false;	×
99	try
100	{
101	var TempBuffer = ArrayPool<byte>.Shared.Rent(1);	1,570✔
102	_ = stream.Seek(0, SeekOrigin.Begin);	1,570✔
103	_ = stream.Read(TempBuffer, 0, 1);	74✔
104	_ = stream.Seek(0, SeekOrigin.Begin);	74✔
105	ArrayPool<byte>.Shared.Return(TempBuffer);	74✔
106	}	74✔
107	catch	1,496✔
108	{
109	return false;	1,496✔
110	}
111	return true;	74✔
112	}	1,496✔
113
114	/// <summary>
115	/// Finds the start index of the file.
116	/// </summary>
117	/// <param name="stream">The stream to read.</param>
118	/// <returns>The start index of the file.</returns>
119	private static int FindStartIndex(Stream stream)
120	{
121	if (stream.Length < 3)	4!
122	return 0;	×
123	var BOMBuffer = ArrayPool<byte>.Shared.Rent(3);	4✔
124	_ = stream.Read(BOMBuffer, 0, BOMBuffer.Length);	4✔
125	_ = stream.Seek(0, SeekOrigin.Begin);	4✔
126	var ReturnValue = BOMBuffer[0] == 0xEF && BOMBuffer[1] == 0xBB && BOMBuffer[2] == 0xBF ? 3 : 0;	4!
127	ArrayPool<byte>.Shared.Return(BOMBuffer);	4✔
128	return ReturnValue;	4✔
129	}
130	}
131	}

JaCraig / Archivist / 12265683069

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous