8401264958

Committed 23 Mar 2024 10:46AM UTC coverage: 89.113% (-7.0%) from 96.15%

Build # 8401264958

Build Type

Pull #102

github

Committed by

web-flow

Commit Message

Merge 30054ca70 into a117ef5ce

Pull Request Pull Request #102: #101 Async work done

Run Details

308 of 387 branches covered (79.59%)

Branch coverage included in aggregate %.

364 of 497 new or added lines in 26 files covered. (73.24%)

12 existing lines in 2 files now uncovered.

1812 of 1992 relevant lines covered (90.96%)

21.76 hits per line

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

90.38

/source/core/Kyameru.Core/Chain/BaseChain.cs

﻿using System.Threading;
using System.Threading.Tasks;
using Kyameru.Core.Contracts;
using Kyameru.Core.Entities;
using Kyameru.Core.Extensions;
using Microsoft.Extensions.Logging;

namespace Kyameru.Core.Chain
{
    /// <summary>
    /// Base chain for processing
    /// </summary>
    internal abstract class BaseChain : Contracts.IChain<Entities.Routable>
    {
        /// <summary>
        /// Logger interface.
        /// </summary>
        protected readonly ILogger Logger;

        /// <summary>
        /// Route identity.
        /// </summary>
        protected readonly string identity;

        /// <summary>
        /// Initializes a new instance of the <see cref="BaseChain"/> class.
        /// </summary>
        /// <param name="logger">Logging class.</param>
        /// <param name="identity">Identity of route.</param>
        protected BaseChain(ILogger logger, string identity)
        {
            this.Logger = logger;
            this.identity = identity;
        }

        /// <summary>
        /// Gets or sets the next component.
        /// </summary>
        private IChain<Entities.Routable> Next { get; set; }

        /// <summary>
        /// Pass the processing onto the next component.
        /// </summary>
        /// <param name="item">Message to process.</param>
        public virtual void Handle(Routable item)
        {
            if (!item.ExitRoute)
            {

                this.Next?.Handle(item);
            }
            else
            {
                this.Logger.KyameruWarning(this.identity, string.Format(Resources.WARNING_ROUTE_EXIT, item.ExitReason));
            }
        }

        /// <summary>
        /// Pass the processing onto the next component.
        /// </summary>
        /// <param name="item">Message to process.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        public virtual async Task HandleAsync(Routable item, CancellationToken cancellationToken)
        {
            if (!item.ExitRoute)
            {
                // Really?
                if (this.Next != null)
                {
                    await this.Next?.HandleAsync(item, cancellationToken);
                }

            }
            else
            {
                this.Logger.KyameruWarning(this.identity, string.Format(Resources.WARNING_ROUTE_EXIT, item.ExitReason));
            }

        }

        /// <summary>
        /// Sets the next component in the chain.
        /// </summary>
        /// <param name="next">Next component.</param>
        /// <returns>Returns an instance of the <see cref="IChain{T}"/>/> interface.</returns>
        public IChain<Routable> SetNext(IChain<Routable> next)
        {
            this.Next = next;
            return this.Next;
        }

        /// <summary>
        /// Logging event handler.
        /// </summary>
        /// <param name="sender">Class sending the event.</param>
        /// <param name="e">Log object.</param>
        protected void OnLog(object sender, Log e)
        {
            if (e.Error == null)
            {
                this.Logger.KyameruLog(this.identity, e.Message, e.LogLevel);
            }
            else
            {
                this.Logger.KyameruError(this.identity, e.Message);
            }
        }
    }
}

1	using System.Threading;
2	using System.Threading.Tasks;
3	using Kyameru.Core.Contracts;
4	using Kyameru.Core.Entities;
5	using Kyameru.Core.Extensions;
6	using Microsoft.Extensions.Logging;
7
8	namespace Kyameru.Core.Chain
9	{
10	/// <summary>
11	/// Base chain for processing
12	/// </summary>
13	internal abstract class BaseChain : Contracts.IChain<Entities.Routable>
14	{
15	/// <summary>
16	/// Logger interface.
17	/// </summary>
18	protected readonly ILogger Logger;
19
20	/// <summary>
21	/// Route identity.
22	/// </summary>
23	protected readonly string identity;
24
25	/// <summary>
26	/// Initializes a new instance of the <see cref="BaseChain"/> class.
27	/// </summary>
28	/// <param name="logger">Logging class.</param>
29	/// <param name="identity">Identity of route.</param>
30	protected BaseChain(ILogger logger, string identity)	61✔
31	{	61✔
32	this.Logger = logger;	61✔
33	this.identity = identity;	61✔
34	}	61✔
35
36	/// <summary>
37	/// Gets or sets the next component.
38	/// </summary>
39	private IChain<Entities.Routable> Next { get; set; }	139✔
40
41	/// <summary>
42	/// Pass the processing onto the next component.
43	/// </summary>
44	/// <param name="item">Message to process.</param>
45	public virtual void Handle(Routable item)
46	{	37✔
47	if (!item.ExitRoute)	37✔
48	{	35✔
49
50	this.Next?.Handle(item);	35✔
51	}	35✔
52	else
53	{	2✔
54	this.Logger.KyameruWarning(this.identity, string.Format(Resources.WARNING_ROUTE_EXIT, item.ExitReason));	2✔
55	}	2✔
56	}	37✔
57
58	/// <summary>
59	/// Pass the processing onto the next component.
60	/// </summary>
61	/// <param name="item">Message to process.</param>
62	/// <param name="cancellationToken">Cancellation token</param>
63	public virtual async Task HandleAsync(Routable item, CancellationToken cancellationToken)
64	{	4✔
65	if (!item.ExitRoute)	4!
66	{	4✔
67	// Really?
68	if (this.Next != null)	4✔
69	{	2✔
70	await this.Next?.HandleAsync(item, cancellationToken);	2!
71	}	2✔
72
73	}	4✔
74	else
NEW 75	{	×
NEW 76	this.Logger.KyameruWarning(this.identity, string.Format(Resources.WARNING_ROUTE_EXIT, item.ExitReason));	×
NEW 77	}	×
78
79	}	4✔
80
81	/// <summary>
82	/// Sets the next component in the chain.
83	/// </summary>
84	/// <param name="next">Next component.</param>
85	/// <returns>Returns an instance of the <see cref="IChain{T}"/>/> interface.</returns>
86	public IChain<Routable> SetNext(IChain<Routable> next)
87	{	49✔
88	this.Next = next;	49✔
89	return this.Next;	49✔
90	}	49✔
91
92	/// <summary>
93	/// Logging event handler.
94	/// </summary>
95	/// <param name="sender">Class sending the event.</param>
96	/// <param name="e">Log object.</param>
97	protected void OnLog(object sender, Log e)
98	{	22✔
99	if (e.Error == null)	22✔
100	{	16✔
101	this.Logger.KyameruLog(this.identity, e.Message, e.LogLevel);	16✔
102	}	16✔
103	else
104	{	6✔
105	this.Logger.KyameruError(this.identity, e.Message);	6✔
106	}	6✔
107	}	22✔
108	}
109	}

djsuperchief / Kyameru / 8401264958

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