这是基于vue-vben-admin 模板适用于abp vNext的前端管理项目
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

442 lines
16 KiB

using LINGYUN.Abp.Notifications;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging.Abstractions;
using Shouldly;
using System;
using System.Linq;
using System.Text.Json;
using System.Threading.Tasks;
using Xunit;
namespace LINGYUN.Abp.Notifications.ChannelData.Tests;
/// <summary>
/// 渠道数据(载荷)框架契约测试
/// </summary>
/// <remarks>
/// <para>
/// 本文件只测试**框架契约**本身: 弱类型转换、存在性判定、注册期校验、
/// 优先级排序、JSON 往返。测试用载荷是本文件内定义的 stub 类型。
/// </para>
/// <para>
/// **具体渠道**的数据测试在各自的测试项目中(先 new 消息对象 →
/// <c>IJsonSerializer</c> 序列化 → 渠道侧验证):
/// <list type="bullet">
/// <item><c>LINGYUN.Abp.Notifications.WeChat.Work.Tests</c></item>
/// <item><c>LINGYUN.Abp.Notifications.Webhook.WeChat.Work.Tests</c></item>
/// <item><c>LINGYUN.Abp.Notifications.WeChat.MiniProgram.Tests</c></item>
/// <item><c>LINGYUN.Abp.Notifications.WxPusher.Tests</c></item>
/// <item><c>LINGYUN.Abp.Notifications.PushPlus.Tests</c></item>
/// </list>
/// </para>
/// </remarks>
public class NotificationChannelData_Tests
{
// ---------- 1. 弱类型转换 ----------
[Theory]
[InlineData((byte)1)]
[InlineData(1)]
[InlineData(1L)]
[InlineData("1")]
[InlineData("\"1\"")]
[InlineData(true)]
[InlineData("true")]
public void Should_Coerce_All_Representations_To_Bool(object stored)
{
var data = new NotificationData();
data.TrySetData("key", stored);
CreateResolver().GetValue(data, "key", false).ShouldBeTrue();
}
[Fact]
public void Should_Distinguish_Unset_From_Explicit_False()
{
var unset = new NotificationData();
CreateResolver().GetValue<bool>(unset, "key").ShouldBeNull();
var explicitFalse = new NotificationData();
explicitFalse.TrySetData("key", 0);
CreateResolver().GetValue<bool>(explicitFalse, "key").ShouldBe(false);
}
[Fact]
public void Should_Read_Values_After_Json_RoundTrip()
{
// 通知数据在持久化/失败重试/跨进程投递后必然经历 JSON 往返
var data = new NotificationData();
data.TrySetData("key", (byte)1);
var roundTripped = RoundTrip(data);
roundTripped.ExtraProperties["key"].ShouldNotBeOfType<byte>();
CreateResolver().GetValue(roundTripped, "key", false).ShouldBeTrue();
}
[Fact]
public void Should_Match_Keys_Case_Insensitively()
{
var data = new NotificationData();
data.TrySetData("my-stub:key", "value-1");
var resolver = CreateResolver();
// 精确命中
resolver.GetOrNull(data, "my-stub:key").ShouldBe("value-1");
// 任意大小写都应命中
resolver.GetOrNull(data, "MY-STUB:KEY").ShouldBe("value-1");
resolver.GetOrNull(data, "My-Stub:Key").ShouldBe("value-1");
}
// ---------- 2. 存在性判定(声明式) ----------
[Fact]
public void Should_Detect_Explicit_Payload()
{
var data = new NotificationData();
ChannelData().Write(data, new PriorityStubA { A = "a" });
CreateResolver().IsDeclared(data, typeof(PriorityStubA)).ShouldBeTrue();
CreateResolver().IsDeclared(data, typeof(PriorityStubB)).ShouldBeFalse();
}
[Fact]
public void Should_Not_Treat_Ignored_Properties_As_Payload()
{
var data = new NotificationData();
// 只写被标记为"仅读取"的属性: 不得视为声明了载荷
data.TrySetData("stubB:optional", "value");
CreateResolver().IsDeclared(data, typeof(PriorityStubB)).ShouldBeFalse();
}
[Fact]
public void Should_Apply_AnyDeclaredProperty_Presence_Mode()
{
var resolver = CreateResolver();
var first = new NotificationData();
first.TrySetData("stub-many:first", "v");
resolver.IsDeclared(first, typeof(AnyDeclaredPropertyStub)).ShouldBeTrue();
var second = new NotificationData();
second.TrySetData("stub-many:second", "v");
resolver.IsDeclared(second, typeof(AnyDeclaredPropertyStub)).ShouldBeTrue();
// 声明了按键判定, 但一个键都没写 -> 不存在
resolver.IsDeclared(new NotificationData(), typeof(AnyDeclaredPropertyStub)).ShouldBeFalse();
}
[Fact]
public void Should_Ignore_Matching_For_Optional_Properties()
{
var data = new NotificationData();
// 只写"仅读取"的属性 -> 不算载荷
data.TrySetData("stubB:optional", "value");
CreateResolver().IsDeclared(data, typeof(PriorityStubB)).ShouldBeFalse();
// 写标识键 -> 算载荷
var withIdentity = new NotificationData();
withIdentity.TrySetData("stub:b", "value");
CreateResolver().IsDeclared(withIdentity, typeof(PriorityStubB)).ShouldBeTrue();
}
[Fact]
public void Should_Allow_Always_Present_Payload()
{
var resolver = CreateResolver();
// Presence = None: 无条件存在
resolver.IsDeclared(new NotificationData(), typeof(AlwaysPresentStub)).ShouldBeTrue();
var payload = resolver.Resolve<AlwaysPresentStub>(new NotificationData());
payload.ShouldNotBeNull();
}
// ---------- 3. 注册期校验 ----------
[Fact]
public void Should_Throw_When_Presence_Declared_Without_Matchable_Property()
{
var exception = Should.Throw<AbpNotificationChannelDataConfigurationException>(
() => CreateOptions().Add<MissingMatchablePropertyStub>());
exception.Message.ShouldContain("matchable property");
}
[Fact]
public void Should_Reject_Missing_Channel_Data_Attribute()
{
var exception = Should.Throw<AbpNotificationChannelDataConfigurationException>(
() => CreateOptions().Add<NoAttributeStub>());
exception.Message.ShouldContain("NotificationChannelDataAttribute");
}
[Fact]
public void Should_Reject_Duplicate_Priority_In_Same_Provider()
{
var options = CreateOptions();
options.Add<PriorityStubA>();
var exception = Should.Throw<AbpNotificationChannelDataConfigurationException>(
() => options.Add<DuplicatePriorityStub>());
exception.Message.ShouldContain("same priority");
}
// ---------- 4. 解析与排序 ----------
[Fact]
public void Should_Resolve_Payloads_In_Declared_Priority_Order()
{
var data = new NotificationData();
ChannelData().Write(data, new PriorityStubB { B = "b" });
ChannelData().Write(data, new PriorityStubA { A = "a" });
var resolved = CreateResolver().Resolve(TestProvider, data);
// 只声明了 A 与 B; AnyDeclaredPropertyStub 未写入, AlwaysPresentStub(Presence=None)
// 无条件存在, 因此共 3 个
resolved.Count.ShouldBe(3);
// Priority: AlwaysPresentStub=400, A=100, B=200 -> 排序后 A, B, Always
resolved[0].ShouldBeOfType<PriorityStubA>();
resolved[1].ShouldBeOfType<PriorityStubB>();
resolved[2].ShouldBeOfType<AlwaysPresentStub>();
}
[Fact]
public void Should_Resolve_Payload_After_Json_RoundTrip()
{
var data = new NotificationData();
ChannelData().Write(data, new PriorityStubA { A = "卡片标题" });
// 复杂载荷以 JSON 字符串形式存储, 往返后仍必须能还原为强类型
data.ExtraProperties["stub:a"].ShouldBeOfType<string>();
var payload = CreateResolver().Resolve<PriorityStubA>(RoundTrip(data));
payload.ShouldNotBeNull();
payload!.A.ShouldBe("卡片标题");
}
[Fact]
public void Should_Not_Throw_For_Invalid_Payload_But_Report_Declared()
{
var data = new NotificationData();
// 复杂载荷以 JSON 字符串存储; 这里写入非法 JSON
data.TrySetData("stub:json", "{ this is not json }");
var resolver = CreateResolver();
// IsDeclared 仍为 true(生产者确实写了), Resolve 返回 null(解析失败, 仅记日志)
resolver.IsDeclared(data, typeof(JsonPayloadStub)).ShouldBeTrue();
resolver.Resolve<JsonPayloadStub>(data).ShouldBeNull();
// 诊断信息给出实际命中的键名
resolver.GetKey(data, typeof(JsonPayloadStub)).ShouldBe("stub:json");
}
[Fact]
public void Should_Resolve_Complex_Payload_After_Json_RoundTrip()
{
var data = new NotificationData();
ChannelData().Write(data, new JsonPayloadStub
{
Payload = new StubPayload { Name = "标题", Count = 3 }
});
// 复杂类型以 JSON 字符串形式存储
data.ExtraProperties["stub:json"].ShouldBeOfType<string>();
var payload = CreateResolver().Resolve<JsonPayloadStub>(RoundTrip(data));
payload.ShouldNotBeNull();
payload!.Payload.ShouldNotBeNull();
payload.Payload!.Name.ShouldBe("标题");
payload.Payload.Count.ShouldBe(3);
}
// ---------- 5. 属性元数据缓存的并发行为 ----------
/// <remarks>
/// 投递路径上每个载荷都会读取属性元数据缓存, 而缓存首次构建要做反射与
/// 表达式编译, 因此"高并发下只构建一次且读路径无锁"是必须保证的属性。
/// </remarks>
[Fact]
public void Should_Build_Property_Metadata_Once_Under_Concurrency()
{
var payloadTypes = new[]
{
typeof(JsonPayloadStub),
typeof(PriorityStubA),
typeof(PriorityStubB),
typeof(AnyDeclaredPropertyStub),
typeof(AlwaysPresentStub)
};
// 每个类型并发取多次, 覆盖"多线程同时首次构建同一类型"的竞争
var results = new NotificationChannelDataProperty[payloadTypes.Length * 64][];
Parallel.For(0, results.Length, index =>
{
results[index] = NotificationChannelDataPropertyCache.GetProperties(
payloadTypes[index % payloadTypes.Length]);
});
foreach (var payloadType in payloadTypes)
{
var expected = NotificationChannelDataPropertyCache.GetProperties(payloadType);
var observed = results
.Where(x => x.Length == expected.Length)
.Where(x => x.Select(p => p.Key).SequenceEqual(expected.Select(p => p.Key)))
.ToArray();
// 所有并发调用必须看到同一份元数据(同一实例), 证明只构建了一次
observed.ShouldNotBeEmpty();
observed.ShouldAllBe(x => ReferenceEquals(x, expected));
}
}
[Fact]
public void Should_Return_Same_Instance_On_Repeated_Calls()
{
var first = NotificationChannelDataPropertyCache.GetProperties(typeof(JsonPayloadStub));
var second = NotificationChannelDataPropertyCache.GetProperties(typeof(JsonPayloadStub));
ReferenceEquals(first, second).ShouldBeTrue();
}
// ---------- 6. 测试用载荷 ----------
private const string TestProvider = "stub";
[NotificationChannelData(TestProvider, Priority = 100)]
private class PriorityStubA : NotificationChannelData
{
[NotificationChannelProperty("stub:a")]
public string? A { get; set; }
}
[NotificationChannelData(TestProvider, Priority = 200)]
private class PriorityStubB : NotificationChannelData
{
[NotificationChannelProperty("stub:b")]
public string? B { get; set; }
[NotificationChannelProperty("stubB:optional", IgnoreWhenMatching = true)]
public string? Optional { get; set; }
}
[NotificationChannelData(TestProvider, Priority = 100)]
private class DuplicatePriorityStub : NotificationChannelData
{
[NotificationChannelProperty("stub:dup")]
public string? Value { get; set; }
}
[NotificationChannelData(TestProvider, Priority = 300,
Presence = NotificationChannelDataPresenceMode.AnyDeclaredProperty)]
private class AnyDeclaredPropertyStub : NotificationChannelData
{
[NotificationChannelProperty("stub-many:first")]
public string? First { get; set; }
[NotificationChannelProperty("stub-many:second")]
public string? Second { get; set; }
}
[NotificationChannelData(TestProvider, Priority = 400,
Presence = NotificationChannelDataPresenceMode.None)]
private class AlwaysPresentStub : NotificationChannelData
{
[NotificationChannelProperty("stub-always:value")]
public string? Value { get; set; }
}
[NotificationChannelData(TestProvider, Priority = 500,
Presence = NotificationChannelDataPresenceMode.DeclaredProperties)]
private class MissingMatchablePropertyStub : NotificationChannelData
{
// 没有任何带 [NotificationChannelProperty] 的属性
public string? Value { get; set; }
}
/// <summary>
/// 复杂载荷(以 JSON 字符串存储)
/// </summary>
[NotificationChannelData(TestProvider, Priority = 600)]
private class JsonPayloadStub : NotificationChannelData
{
[NotificationChannelProperty("stub:json")]
public StubPayload? Payload { get; set; }
}
private class StubPayload
{
public string? Name { get; set; }
public int Count { get; set; }
}
private class NoAttributeStub : NotificationChannelData
{
public string? Value { get; set; }
}
// ---------- 辅助 ----------
private static AbpNotificationChannelDataOptions CreateOptions()
{
// 选项是纯数据: 存在性判定为纯静态, 注册时无需解析任何服务
return new AbpNotificationChannelDataOptions();
}
private static NotificationChannelDataResolver CreateResolver()
{
var services = new ServiceCollection();
services.AddLogging();
services.AddSingleton<INotificationChannelDataJsonSerializer,
TestNotificationChannelDataJsonSerializer>();
services.AddSingleton<INotificationChannelDataAccessor, NotificationChannelDataAccessor>();
services.AddSingleton<INotificationChannelDataPresenceProvider, NotificationChannelDataPresenceProvider>();
services.AddSingleton<INotificationChannelDataResolver, NotificationChannelDataResolver>();
services.PostConfigure<AbpNotificationChannelDataOptions>(options =>
{
options.Add<PriorityStubA>();
options.Add<PriorityStubB>();
options.Add<AnyDeclaredPropertyStub>();
options.Add<AlwaysPresentStub>();
options.Add<JsonPayloadStub>();
});
var provider = services.BuildServiceProvider();
return (NotificationChannelDataResolver)provider.GetRequiredService<INotificationChannelDataResolver>();
}
private static INotificationChannelDataSerializer ChannelData()
{
var services = new ServiceCollection();
services.AddLogging();
services.AddSingleton<INotificationChannelDataJsonSerializer,
TestNotificationChannelDataJsonSerializer>();
services.AddSingleton<INotificationChannelDataAccessor, NotificationChannelDataAccessor>();
services.AddSingleton<INotificationChannelDataPresenceProvider, NotificationChannelDataPresenceProvider>();
services.AddSingleton<INotificationChannelDataSerializer, NotificationChannelDataSerializer>();
return services.BuildServiceProvider().GetRequiredService<INotificationChannelDataSerializer>();
}
private static NotificationData RoundTrip(NotificationData data)
{
var json = JsonSerializer.Serialize(data.ExtraProperties);
return new NotificationData
{
ExtraProperties = JsonSerializer.Deserialize<Volo.Abp.Data.ExtraPropertyDictionary>(json)!
};
}
}