Skip to content

feat: add KsefClientRateLimitGroup enum #237

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
sirmazur wants to merge 1 commit into
base: main
Choose a base branch
from
Open

feat: add KsefClientRateLimitGroup enum #237

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
70 changes: 70 additions & 0 deletions KSeF.Client.Core/Models/RateLimits/EffectiveApiRateLimitsExtensions.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,70 @@
using System;
using System.Collections.Generic;

namespace KSeF.Client.Core.Models.RateLimits;

/// <summary>
/// Klasa rozszerzająca funkcjonalność <see cref="EffectiveApiRateLimits"/> poprzez dodanie metod pomocniczych do pobierania limitów dla określonych grup
/// </summary>
public static class EffectiveApiRateLimitsExtensions
{
/// <summary>
/// Zwraca wartości limitów dla określonej grupy limitów żądań API KSeF.
/// </summary>
/// <param name="limits">Obiekt zawierający limity żądań API KSeF.</param>
/// <param name="group">Grupa limitów żądań API KSeF.</param>
/// <returns>Obiekt zawierający wartości limitów dla określonej grupy.</returns>
/// <exception cref="ArgumentNullException">Wyrzucany, gdy parametr <paramref name="limits"/> jest null.</exception>
/// <exception cref="ArgumentOutOfRangeException">Wyrzucany, gdy parametr <paramref name="group"/> nie jest obsługiwany.</exception>
public static EffectiveApiRateLimitValues GetRateLimitValues(
this EffectiveApiRateLimits limits,
KsefClientRateLimitGroup group)
{
if (limits is null)
{
throw new ArgumentNullException(nameof(limits));
}

return group switch
{
KsefClientRateLimitGroup.OnlineSession => limits.OnlineSession,
KsefClientRateLimitGroup.BatchSession => limits.BatchSession,
KsefClientRateLimitGroup.InvoiceSend => limits.InvoiceSend,
KsefClientRateLimitGroup.InvoiceStatus => limits.InvoiceStatus,
KsefClientRateLimitGroup.SessionList => limits.SessionList,
KsefClientRateLimitGroup.SessionInvoiceList => limits.SessionInvoiceList,
KsefClientRateLimitGroup.SessionMisc => limits.SessionMisc,
KsefClientRateLimitGroup.InvoiceMetadata => limits.InvoiceMetadata,
KsefClientRateLimitGroup.InvoiceExport => limits.InvoiceExport,
KsefClientRateLimitGroup.InvoiceExportStatus => limits.InvoiceExportStatus,
KsefClientRateLimitGroup.InvoiceDownload => limits.InvoiceDownload,
KsefClientRateLimitGroup.Other => limits.Other,
KsefClientRateLimitGroup.CollectiveIdentifier => limits.CollectiveIdentifier,
_ => throw new ArgumentOutOfRangeException(nameof(group), group, null)
};
}

/// <summary>
/// Zwraca słownik zawierający wszystkie grupy limitów żądań API KSeF wraz z odpowiadającymi im wartościami limitów.
/// </summary>
/// <param name="limits">Obiekt zawierający limity żądań API KSeF.</param>
/// <returns>Słownik zawierający wszystkie grupy limitów i odpowiadające im wartości.</returns>
/// <exception cref="ArgumentNullException">Wyrzucany, gdy parametr <paramref name="limits"/> jest null.</exception>
public static IReadOnlyDictionary<KsefClientRateLimitGroup, EffectiveApiRateLimitValues> GetAllRateLimitValues(
this EffectiveApiRateLimits limits)
{
if (limits is null)
{
throw new ArgumentNullException(nameof(limits));
}

Dictionary<KsefClientRateLimitGroup, EffectiveApiRateLimitValues> result = new();

foreach (KsefClientRateLimitGroup group in Enum.GetValues(typeof(KsefClientRateLimitGroup)))
{
result[group] = limits.GetRateLimitValues(group);
}

return result;
}
}
72 changes: 72 additions & 0 deletions KSeF.Client.Core/Models/RateLimits/KsefClientRateLimitGroup.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,72 @@
namespace KSeF.Client.Core.Models.RateLimits;

/// <summary>
/// Enum określający grupy limitów żądań API KSeF.
/// </summary>
public enum KsefClientRateLimitGroup
{
/// <summary>
/// Limity otwierania/zamykania sesji interaktywnych.
/// </summary>
OnlineSession = 0,

/// <summary>
/// Limity otwierania/zamykania sesji wsadowych.
/// </summary>
BatchSession = 1,

/// <summary>
/// Limity wysyłki faktur.
/// </summary>
InvoiceSend = 2,

/// <summary>
/// Limity pobierania statusu faktury z sesji.
/// </summary>
InvoiceStatus = 3,

/// <summary>
/// Limity pobierania listy sesji.
/// </summary>
SessionList = 4,

/// <summary>
/// Limity pobierania listy faktur w sesji.
/// </summary>
SessionInvoiceList = 5,

/// <summary>
/// Limity pozostałych operacji w ramach sesji.
/// </summary>
SessionMisc = 6,

/// <summary>
/// Limity pobierania metadanych faktur.
/// </summary>
InvoiceMetadata = 7,

/// <summary>
/// Limity eksportu paczki faktur.
/// </summary>
InvoiceExport = 8,

/// <summary>
/// Limity pobierania statusu eksportu paczki faktur.
/// </summary>
InvoiceExportStatus = 9,

/// <summary>
/// Limity pobierania faktur po numerze KSeF.
/// </summary>
InvoiceDownload = 10,

/// <summary>
/// Limity pozostałych operacji API.
/// </summary>
Other = 11,

/// <summary>
/// Limity generowania identyfikatorów zbiorczych.
/// </summary>
CollectiveIdentifier = 12
}
83 changes: 19 additions & 64 deletions KSeF.Client.Tests.Core/E2E/Limits/RateLimitsE2ETests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -661,21 +661,14 @@ private static int Adjust(int current, int delta, int min, int max)

private static bool AreRateLimitsEqual(EffectiveApiRateLimits expected, EffectiveApiRateLimits actual)
{
return AreRateLimitValuesEqual(expected.OnlineSession, actual.OnlineSession)
&& AreRateLimitValuesEqual(expected.BatchSession, actual.BatchSession)
&& AreRateLimitValuesEqual(expected.InvoiceSend, actual.InvoiceSend)
&& AreRateLimitValuesEqual(expected.InvoiceStatus, actual.InvoiceStatus)
&& AreRateLimitValuesEqual(expected.SessionList, actual.SessionList)
&& AreRateLimitValuesEqual(expected.SessionInvoiceList, actual.SessionInvoiceList)
&& AreRateLimitValuesEqual(expected.SessionMisc, actual.SessionMisc)
&& AreRateLimitValuesEqual(expected.InvoiceMetadata, actual.InvoiceMetadata)
&& AreRateLimitValuesEqual(expected.InvoiceExport, actual.InvoiceExport)
&& AreRateLimitValuesEqual(expected.InvoiceExportStatus, actual.InvoiceExportStatus)
&& AreRateLimitValuesEqual(expected.InvoiceDownload, actual.InvoiceDownload)
&& AreRateLimitValuesEqual(expected.CollectiveIdentifier, actual.CollectiveIdentifier)
&& AreRateLimitValuesEqual(expected.Other, actual.Other);
}
IReadOnlyDictionary<KsefClientRateLimitGroup, EffectiveApiRateLimitValues> expectedGroups = expected.GetAllRateLimitValues();
IReadOnlyDictionary<KsefClientRateLimitGroup, EffectiveApiRateLimitValues> actualGroups = actual.GetAllRateLimitValues();

return expectedGroups.Count == actualGroups.Count
&& expectedGroups.All(pair =>
actualGroups.TryGetValue(pair.Key, out EffectiveApiRateLimitValues? actualValues)
&& AreRateLimitValuesEqual(pair.Value, actualValues));
}
private static bool AreRateLimitValuesEqual(EffectiveApiRateLimitValues? expected, EffectiveApiRateLimitValues? actual)
{
if (expected is null || actual is null)
Expand Down Expand Up @@ -711,55 +704,17 @@ private static void AssertRateLimitsEqual(EffectiveApiRateLimits expected, Effec
Assert.NotNull(expected);
Assert.NotNull(actual);

// OnlineSession
Assert.Equal(expected.OnlineSession.PerSecond, actual.OnlineSession.PerSecond);
Assert.Equal(expected.OnlineSession.PerMinute, actual.OnlineSession.PerMinute);
Assert.Equal(expected.OnlineSession.PerHour, actual.OnlineSession.PerHour);
// BatchSession
Assert.Equal(expected.BatchSession.PerSecond, actual.BatchSession.PerSecond);
Assert.Equal(expected.BatchSession.PerMinute, actual.BatchSession.PerMinute);
Assert.Equal(expected.BatchSession.PerHour, actual.BatchSession.PerHour);
// InvoiceSend
Assert.Equal(expected.InvoiceSend.PerSecond, actual.InvoiceSend.PerSecond);
Assert.Equal(expected.InvoiceSend.PerMinute, actual.InvoiceSend.PerMinute);
Assert.Equal(expected.InvoiceSend.PerHour, actual.InvoiceSend.PerHour);
// InvoiceStatus
Assert.Equal(expected.InvoiceStatus.PerSecond, actual.InvoiceStatus.PerSecond);
Assert.Equal(expected.InvoiceStatus.PerMinute, actual.InvoiceStatus.PerMinute);
Assert.Equal(expected.InvoiceStatus.PerHour, actual.InvoiceStatus.PerHour);
// SessionList
Assert.Equal(expected.SessionList.PerSecond, actual.SessionList.PerSecond);
Assert.Equal(expected.SessionList.PerMinute, actual.SessionList.PerMinute);
Assert.Equal(expected.SessionList.PerHour, actual.SessionList.PerHour);
// SessionInvoiceList
Assert.Equal(expected.SessionInvoiceList.PerSecond, actual.SessionInvoiceList.PerSecond);
Assert.Equal(expected.SessionInvoiceList.PerMinute, actual.SessionInvoiceList.PerMinute);
Assert.Equal(expected.SessionInvoiceList.PerHour, actual.SessionInvoiceList.PerHour);
// SessionMisc
Assert.Equal(expected.SessionMisc.PerSecond, actual.SessionMisc.PerSecond);
Assert.Equal(expected.SessionMisc.PerMinute, actual.SessionMisc.PerMinute);
Assert.Equal(expected.SessionMisc.PerHour, actual.SessionMisc.PerHour);
// InvoiceMetadata
Assert.Equal(expected.InvoiceMetadata.PerSecond, actual.InvoiceMetadata.PerSecond);
Assert.Equal(expected.InvoiceMetadata.PerMinute, actual.InvoiceMetadata.PerMinute);
Assert.Equal(expected.InvoiceMetadata.PerHour, actual.InvoiceMetadata.PerHour);
// InvoiceExport
Assert.Equal(expected.InvoiceExport.PerSecond, actual.InvoiceExport.PerSecond);
Assert.Equal(expected.InvoiceExport.PerMinute, actual.InvoiceExport.PerMinute);
Assert.Equal(expected.InvoiceExport.PerHour, actual.InvoiceExport.PerHour);
// InvoiceExportStatus
AssertRateLimitValuesEqual(expected.InvoiceExportStatus, actual.InvoiceExportStatus);
// InvoiceDownload
Assert.Equal(expected.InvoiceDownload.PerSecond, actual.InvoiceDownload.PerSecond);
Assert.Equal(expected.InvoiceDownload.PerMinute, actual.InvoiceDownload.PerMinute);
Assert.Equal(expected.InvoiceDownload.PerHour, actual.InvoiceDownload.PerHour);
// CollectiveIdentifier
Assert.Equal(expected.CollectiveIdentifier.PerSecond, actual.CollectiveIdentifier.PerSecond);
Assert.Equal(expected.CollectiveIdentifier.PerMinute, actual.CollectiveIdentifier.PerMinute);
Assert.Equal(expected.CollectiveIdentifier.PerHour, actual.CollectiveIdentifier.PerHour);
// Other
Assert.Equal(expected.Other.PerSecond, actual.Other.PerSecond);
Assert.Equal(expected.Other.PerMinute, actual.Other.PerMinute);
Assert.Equal(expected.Other.PerHour, actual.Other.PerHour);
IReadOnlyDictionary<KsefClientRateLimitGroup, EffectiveApiRateLimitValues> expectedGroups = expected.GetAllRateLimitValues();
IReadOnlyDictionary<KsefClientRateLimitGroup, EffectiveApiRateLimitValues> actualGroups = actual.GetAllRateLimitValues();

Assert.Equal(expectedGroups.Count, actualGroups.Count);

foreach (KeyValuePair<KsefClientRateLimitGroup, EffectiveApiRateLimitValues> pair in expectedGroups)
{
Assert.True(
actualGroups.TryGetValue(pair.Key, out EffectiveApiRateLimitValues? actualValues),
$"Brak grupy limitów '{pair.Key}' w aktualnych wartościach.");
AssertRateLimitValuesEqual(pair.Value, actualValues);
}
}
}
Loading