519 lines
16 KiB
C#
519 lines
16 KiB
C#
using AyCode.Core.Tests.TestModels;
|
|
using AyCode.Services.SignalRs;
|
|
|
|
namespace AyCode.Services.Server.Tests.SignalRs;
|
|
|
|
/// <summary>
|
|
/// Test service with SignalR-attributed methods for testing ProcessOnReceiveMessage.
|
|
/// Uses shared DTOs from AyCode.Core.Tests.TestModels.
|
|
/// </summary>
|
|
public class TestSignalRService
|
|
{
|
|
#region Captured Values for Assertions
|
|
|
|
// Primitive captures
|
|
public bool SingleIntMethodCalled { get; private set; }
|
|
public int? ReceivedInt { get; private set; }
|
|
|
|
public bool TwoIntMethodCalled { get; private set; }
|
|
public (int A, int B)? ReceivedTwoInts { get; private set; }
|
|
|
|
public bool BoolMethodCalled { get; private set; }
|
|
public bool? ReceivedBool { get; private set; }
|
|
|
|
public bool StringMethodCalled { get; private set; }
|
|
public string? ReceivedString { get; private set; }
|
|
|
|
public bool GuidMethodCalled { get; private set; }
|
|
public Guid? ReceivedGuid { get; private set; }
|
|
|
|
public bool EnumMethodCalled { get; private set; }
|
|
public TestStatus? ReceivedEnum { get; private set; }
|
|
|
|
public bool NoParamsMethodCalled { get; private set; }
|
|
|
|
public bool MultipleTypesMethodCalled { get; private set; }
|
|
public (bool, string, int)? ReceivedMultipleTypes { get; private set; }
|
|
|
|
// Extended primitives
|
|
public bool DecimalMethodCalled { get; private set; }
|
|
public decimal? ReceivedDecimal { get; private set; }
|
|
|
|
public bool DateTimeMethodCalled { get; private set; }
|
|
public DateTime? ReceivedDateTime { get; private set; }
|
|
|
|
public bool DoubleMethodCalled { get; private set; }
|
|
public double? ReceivedDouble { get; private set; }
|
|
|
|
public bool LongMethodCalled { get; private set; }
|
|
public long? ReceivedLong { get; private set; }
|
|
|
|
// Complex object captures (using shared DTOs)
|
|
public bool TestOrderItemMethodCalled { get; private set; }
|
|
public TestOrderItem? ReceivedTestOrderItem { get; private set; }
|
|
|
|
public bool TestOrderMethodCalled { get; private set; }
|
|
public TestOrder? ReceivedTestOrder { get; private set; }
|
|
|
|
public bool SharedTagMethodCalled { get; private set; }
|
|
public SharedTag? ReceivedSharedTag { get; private set; }
|
|
|
|
// Collection captures
|
|
public bool IntArrayMethodCalled { get; private set; }
|
|
public int[]? ReceivedIntArray { get; private set; }
|
|
|
|
public bool GuidArrayMethodCalled { get; private set; }
|
|
public Guid[]? ReceivedGuidArray { get; private set; }
|
|
|
|
public bool StringListMethodCalled { get; private set; }
|
|
public List<string>? ReceivedStringList { get; private set; }
|
|
|
|
public bool TestOrderItemListMethodCalled { get; private set; }
|
|
public List<TestOrderItem>? ReceivedTestOrderItemList { get; private set; }
|
|
|
|
public bool IntListMethodCalled { get; private set; }
|
|
public List<int>? ReceivedIntList { get; private set; }
|
|
|
|
public bool BoolArrayMethodCalled { get; private set; }
|
|
public bool[]? ReceivedBoolArray { get; private set; }
|
|
|
|
public bool MixedWithArrayMethodCalled { get; private set; }
|
|
public (bool, int[], string)? ReceivedMixedWithArray { get; private set; }
|
|
|
|
public bool NestedListMethodCalled { get; private set; }
|
|
public List<List<int>>? ReceivedNestedList { get; private set; }
|
|
|
|
// Extended array captures for comprehensive testing
|
|
public bool LongArrayMethodCalled { get; private set; }
|
|
public long[]? ReceivedLongArray { get; private set; }
|
|
|
|
public bool DecimalArrayMethodCalled { get; private set; }
|
|
public decimal[]? ReceivedDecimalArray { get; private set; }
|
|
|
|
public bool DateTimeArrayMethodCalled { get; private set; }
|
|
public DateTime[]? ReceivedDateTimeArray { get; private set; }
|
|
|
|
public bool EnumArrayMethodCalled { get; private set; }
|
|
public TestStatus[]? ReceivedEnumArray { get; private set; }
|
|
|
|
public bool DoubleArrayMethodCalled { get; private set; }
|
|
public double[]? ReceivedDoubleArray { get; private set; }
|
|
|
|
public bool SharedTagArrayMethodCalled { get; private set; }
|
|
public SharedTag[]? ReceivedSharedTagArray { get; private set; }
|
|
|
|
public bool DictionaryMethodCalled { get; private set; }
|
|
public Dictionary<string, int>? ReceivedDictionary { get; private set; }
|
|
|
|
public bool ObjectArrayMethodCalled { get; private set; }
|
|
public object[]? ReceivedObjectArray { get; private set; }
|
|
|
|
// Mixed parameter captures
|
|
public bool IntAndDtoMethodCalled { get; private set; }
|
|
public (int, TestOrderItem?)? ReceivedIntAndDto { get; private set; }
|
|
|
|
public bool DtoAndListMethodCalled { get; private set; }
|
|
public (TestOrderItem?, List<int>?)? ReceivedDtoAndList { get; private set; }
|
|
|
|
public bool ThreeComplexParamsMethodCalled { get; private set; }
|
|
public (TestOrderItem?, List<string>?, SharedTag?)? ReceivedThreeComplexParams { get; private set; }
|
|
|
|
public bool FiveParamsMethodCalled { get; private set; }
|
|
public (int, string?, bool, Guid, decimal)? ReceivedFiveParams { get; private set; }
|
|
|
|
#endregion
|
|
|
|
#region Primitive Parameter Handlers
|
|
|
|
[SignalR(TestSignalRTags.SingleIntParam)]
|
|
public string HandleSingleInt(int value)
|
|
{
|
|
SingleIntMethodCalled = true;
|
|
ReceivedInt = value;
|
|
return $"Received: {value}";
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.TwoIntParams)]
|
|
public int HandleTwoInts(int a, int b)
|
|
{
|
|
TwoIntMethodCalled = true;
|
|
ReceivedTwoInts = (a, b);
|
|
return a + b;
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.BoolParam)]
|
|
public bool HandleBool(bool loadRelations)
|
|
{
|
|
BoolMethodCalled = true;
|
|
ReceivedBool = loadRelations;
|
|
return loadRelations;
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.StringParam)]
|
|
public string HandleString(string text)
|
|
{
|
|
StringMethodCalled = true;
|
|
ReceivedString = text;
|
|
return $"Echo: {text}";
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.GuidParam)]
|
|
public Guid HandleGuid(Guid id)
|
|
{
|
|
GuidMethodCalled = true;
|
|
ReceivedGuid = id;
|
|
return id;
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.EnumParam)]
|
|
public TestStatus HandleEnum(TestStatus status)
|
|
{
|
|
EnumMethodCalled = true;
|
|
ReceivedEnum = status;
|
|
return status;
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.NoParams)]
|
|
public string HandleNoParams()
|
|
{
|
|
NoParamsMethodCalled = true;
|
|
return "OK";
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.MultipleTypesParams)]
|
|
public string HandleMultipleTypes(bool flag, string text, int number)
|
|
{
|
|
MultipleTypesMethodCalled = true;
|
|
ReceivedMultipleTypes = (flag, text, number);
|
|
return $"{flag}-{text}-{number}";
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.ThrowsException)]
|
|
public void HandleThrowsException()
|
|
{
|
|
throw new InvalidOperationException("Test exception");
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.DecimalParam)]
|
|
public decimal HandleDecimal(decimal value)
|
|
{
|
|
DecimalMethodCalled = true;
|
|
ReceivedDecimal = value;
|
|
return value * 2;
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.DateTimeParam)]
|
|
public DateTime HandleDateTime(DateTime dateTime)
|
|
{
|
|
DateTimeMethodCalled = true;
|
|
ReceivedDateTime = dateTime;
|
|
return dateTime;
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.DoubleParam)]
|
|
public double HandleDouble(double value)
|
|
{
|
|
DoubleMethodCalled = true;
|
|
ReceivedDouble = value;
|
|
return value;
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.LongParam)]
|
|
public long HandleLong(long value)
|
|
{
|
|
LongMethodCalled = true;
|
|
ReceivedLong = value;
|
|
return value;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Complex Object Handlers (using shared DTOs)
|
|
|
|
[SignalR(TestSignalRTags.TestOrderItemParam)]
|
|
public TestOrderItem HandleTestOrderItem(TestOrderItem item)
|
|
{
|
|
TestOrderItemMethodCalled = true;
|
|
ReceivedTestOrderItem = item;
|
|
return new TestOrderItem
|
|
{
|
|
Id = item.Id,
|
|
ProductName = $"Processed: {item.ProductName}",
|
|
Quantity = item.Quantity * 2,
|
|
UnitPrice = item.UnitPrice
|
|
};
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.TestOrderParam)]
|
|
public TestOrder HandleTestOrder(TestOrder order)
|
|
{
|
|
TestOrderMethodCalled = true;
|
|
ReceivedTestOrder = order;
|
|
return order;
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.SharedTagParam)]
|
|
public SharedTag HandleSharedTag(SharedTag tag)
|
|
{
|
|
SharedTagMethodCalled = true;
|
|
ReceivedSharedTag = tag;
|
|
return tag;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Collection Parameter Handlers
|
|
|
|
[SignalR(TestSignalRTags.IntArrayParam)]
|
|
public int[] HandleIntArray(int[] values)
|
|
{
|
|
IntArrayMethodCalled = true;
|
|
ReceivedIntArray = values;
|
|
return values.Select(x => x * 2).ToArray();
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.GuidArrayParam)]
|
|
public Guid[] HandleGuidArray(Guid[] ids)
|
|
{
|
|
GuidArrayMethodCalled = true;
|
|
ReceivedGuidArray = ids;
|
|
return ids;
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.StringListParam)]
|
|
public List<string> HandleStringList(List<string> items)
|
|
{
|
|
StringListMethodCalled = true;
|
|
ReceivedStringList = items;
|
|
return items.Select(x => x.ToUpper()).ToList();
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.TestOrderItemListParam)]
|
|
public List<TestOrderItem> HandleTestOrderItemList(List<TestOrderItem> items)
|
|
{
|
|
TestOrderItemListMethodCalled = true;
|
|
ReceivedTestOrderItemList = items;
|
|
return items;
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.IntListParam)]
|
|
public List<int> HandleIntList(List<int> numbers)
|
|
{
|
|
IntListMethodCalled = true;
|
|
ReceivedIntList = numbers;
|
|
return numbers.Select(x => x * 2).ToList();
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.BoolArrayParam)]
|
|
public bool[] HandleBoolArray(bool[] flags)
|
|
{
|
|
BoolArrayMethodCalled = true;
|
|
ReceivedBoolArray = flags;
|
|
return flags;
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.MixedWithArrayParam)]
|
|
public string HandleMixedWithArray(bool flag, int[] numbers, string text)
|
|
{
|
|
MixedWithArrayMethodCalled = true;
|
|
ReceivedMixedWithArray = (flag, numbers, text);
|
|
return $"{flag}-[{string.Join(",", numbers)}]-{text}";
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.NestedListParam)]
|
|
public List<List<int>> HandleNestedList(List<List<int>> nestedList)
|
|
{
|
|
NestedListMethodCalled = true;
|
|
ReceivedNestedList = nestedList;
|
|
return nestedList;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Extended Array Parameter Handlers
|
|
|
|
[SignalR(TestSignalRTags.LongArrayParam)]
|
|
public long[] HandleLongArray(long[] values)
|
|
{
|
|
LongArrayMethodCalled = true;
|
|
ReceivedLongArray = values;
|
|
return values;
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.DecimalArrayParam)]
|
|
public decimal[] HandleDecimalArray(decimal[] values)
|
|
{
|
|
DecimalArrayMethodCalled = true;
|
|
ReceivedDecimalArray = values;
|
|
return values;
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.DateTimeArrayParam)]
|
|
public DateTime[] HandleDateTimeArray(DateTime[] values)
|
|
{
|
|
DateTimeArrayMethodCalled = true;
|
|
ReceivedDateTimeArray = values;
|
|
return values;
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.EnumArrayParam)]
|
|
public TestStatus[] HandleEnumArray(TestStatus[] values)
|
|
{
|
|
EnumArrayMethodCalled = true;
|
|
ReceivedEnumArray = values;
|
|
return values;
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.DoubleArrayParam)]
|
|
public double[] HandleDoubleArray(double[] values)
|
|
{
|
|
DoubleArrayMethodCalled = true;
|
|
ReceivedDoubleArray = values;
|
|
return values;
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.SharedTagArrayParam)]
|
|
public SharedTag[] HandleSharedTagArray(SharedTag[] tags)
|
|
{
|
|
SharedTagArrayMethodCalled = true;
|
|
ReceivedSharedTagArray = tags;
|
|
return tags;
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.DictionaryParam)]
|
|
public Dictionary<string, int> HandleDictionary(Dictionary<string, int> dict)
|
|
{
|
|
DictionaryMethodCalled = true;
|
|
ReceivedDictionary = dict;
|
|
return dict;
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.ObjectArrayParam)]
|
|
public object[] HandleObjectArray(object[] values)
|
|
{
|
|
ObjectArrayMethodCalled = true;
|
|
ReceivedObjectArray = values;
|
|
return values;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Mixed Parameter Handlers
|
|
|
|
[SignalR(TestSignalRTags.IntAndDtoParam)]
|
|
public string HandleIntAndDto(int id, TestOrderItem item)
|
|
{
|
|
IntAndDtoMethodCalled = true;
|
|
ReceivedIntAndDto = (id, item);
|
|
return $"{id}-{item?.ProductName}";
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.DtoAndListParam)]
|
|
public string HandleDtoAndList(TestOrderItem item, List<int> numbers)
|
|
{
|
|
DtoAndListMethodCalled = true;
|
|
ReceivedDtoAndList = (item, numbers);
|
|
return $"{item?.ProductName}-[{string.Join(",", numbers ?? [])}]";
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.ThreeComplexParams)]
|
|
public string HandleThreeComplexParams(TestOrderItem item, List<string> tags, SharedTag sharedTag)
|
|
{
|
|
ThreeComplexParamsMethodCalled = true;
|
|
ReceivedThreeComplexParams = (item, tags, sharedTag);
|
|
return $"{item?.ProductName}-{tags?.Count}-{sharedTag?.Name}";
|
|
}
|
|
|
|
[SignalR(TestSignalRTags.FiveParams)]
|
|
public string HandleFiveParams(int a, string b, bool c, Guid d, decimal e)
|
|
{
|
|
FiveParamsMethodCalled = true;
|
|
ReceivedFiveParams = (a, b, c, d, e);
|
|
return $"{a}-{b}-{c}-{d}-{e}";
|
|
}
|
|
|
|
#endregion
|
|
|
|
public void Reset()
|
|
{
|
|
// Primitive captures
|
|
SingleIntMethodCalled = false;
|
|
ReceivedInt = null;
|
|
TwoIntMethodCalled = false;
|
|
ReceivedTwoInts = null;
|
|
BoolMethodCalled = false;
|
|
ReceivedBool = null;
|
|
StringMethodCalled = false;
|
|
ReceivedString = null;
|
|
GuidMethodCalled = false;
|
|
ReceivedGuid = null;
|
|
EnumMethodCalled = false;
|
|
ReceivedEnum = null;
|
|
NoParamsMethodCalled = false;
|
|
MultipleTypesMethodCalled = false;
|
|
ReceivedMultipleTypes = null;
|
|
DecimalMethodCalled = false;
|
|
ReceivedDecimal = null;
|
|
DateTimeMethodCalled = false;
|
|
ReceivedDateTime = null;
|
|
DoubleMethodCalled = false;
|
|
ReceivedDouble = null;
|
|
LongMethodCalled = false;
|
|
ReceivedLong = null;
|
|
|
|
// Complex object captures
|
|
TestOrderItemMethodCalled = false;
|
|
ReceivedTestOrderItem = null;
|
|
TestOrderMethodCalled = false;
|
|
ReceivedTestOrder = null;
|
|
SharedTagMethodCalled = false;
|
|
ReceivedSharedTag = null;
|
|
|
|
// Collection captures
|
|
IntArrayMethodCalled = false;
|
|
ReceivedIntArray = null;
|
|
GuidArrayMethodCalled = false;
|
|
ReceivedGuidArray = null;
|
|
StringListMethodCalled = false;
|
|
ReceivedStringList = null;
|
|
TestOrderItemListMethodCalled = false;
|
|
ReceivedTestOrderItemList = null;
|
|
IntListMethodCalled = false;
|
|
ReceivedIntList = null;
|
|
BoolArrayMethodCalled = false;
|
|
ReceivedBoolArray = null;
|
|
MixedWithArrayMethodCalled = false;
|
|
ReceivedMixedWithArray = null;
|
|
NestedListMethodCalled = false;
|
|
ReceivedNestedList = null;
|
|
|
|
// Extended array captures
|
|
LongArrayMethodCalled = false;
|
|
ReceivedLongArray = null;
|
|
DecimalArrayMethodCalled = false;
|
|
ReceivedDecimalArray = null;
|
|
DateTimeArrayMethodCalled = false;
|
|
ReceivedDateTimeArray = null;
|
|
EnumArrayMethodCalled = false;
|
|
ReceivedEnumArray = null;
|
|
DoubleArrayMethodCalled = false;
|
|
ReceivedDoubleArray = null;
|
|
SharedTagArrayMethodCalled = false;
|
|
ReceivedSharedTagArray = null;
|
|
DictionaryMethodCalled = false;
|
|
ReceivedDictionary = null;
|
|
ObjectArrayMethodCalled = false;
|
|
ReceivedObjectArray = null;
|
|
|
|
// Mixed parameter captures
|
|
IntAndDtoMethodCalled = false;
|
|
ReceivedIntAndDto = null;
|
|
DtoAndListMethodCalled = false;
|
|
ReceivedDtoAndList = null;
|
|
ThreeComplexParamsMethodCalled = false;
|
|
ReceivedThreeComplexParams = null;
|
|
FiveParamsMethodCalled = false;
|
|
ReceivedFiveParams = null;
|
|
}
|
|
}
|