Move tests into the right places

Author: ReubenBond

Orleans.slnx

@@ -122,6 +122,7 @@
     <Project Path="test/Orleans.Placement.Tests/Orleans.Placement.Tests.csproj" />
     <Project Path="test/Orleans.GrainDirectory.Tests/Orleans.GrainDirectory.Tests.csproj" />
     <Project Path="test/Orleans.Streaming.Tests/Orleans.Streaming.Tests.csproj" />
+    <Project Path="test/Orleans.BroadcastChannel.Tests/Orleans.BroadcastChannel.Tests.csproj" />
     <Project Path="test/Orleans.EventSourcing.Tests/Orleans.EventSourcing.Tests.csproj" />
     <Project Path="test/Orleans.DurableJobs.Tests/Orleans.DurableJobs.Tests.csproj" />
   </Folder>

test/Orleans.BroadcastChannel.Tests/ConstructorChannelNamespacePredicateProviderTests.cs

@@ -0,0 +1,89 @@
+using System;
+using Orleans.BroadcastChannel;
+using Orleans.Serialization.TypeSystem;
+using Xunit;
+
+namespace UnitTests;
+
+/// <summary>
+/// Tests for <see cref="ConstructorChannelNamespacePredicateProvider"/> predicate type registration and resolution.
+/// </summary>
+[TestCategory("BVT"), TestCategory("Predicates")]
+public class ConstructorChannelNamespacePredicateProviderTests
+{
+    [Fact]
+    public void RegisteredPredicateType_Succeeds()
+    {
+        var provider = new ConstructorChannelNamespacePredicateProvider();
+        provider.RegisterPredicateType(typeof(TestChannelPredicate));
+        var pattern = ConstructorChannelNamespacePredicateProvider.FormatPattern(typeof(TestChannelPredicate), constructorArgument: null);
+
+        var result = provider.TryGetPredicate(pattern, out var predicate);
+
+        Assert.True(result);
+        Assert.NotNull(predicate);
+        Assert.IsType<TestChannelPredicate>(predicate);
+    }
+
+    [Fact]
+    public void RegisteredPredicateTypeWithArg_Succeeds()
+    {
+        var provider = new ConstructorChannelNamespacePredicateProvider();
+        provider.RegisterPredicateType(typeof(TestChannelPredicateWithArg));
+        var pattern = ConstructorChannelNamespacePredicateProvider.FormatPattern(typeof(TestChannelPredicateWithArg), constructorArgument: "ch-ns");
+
+        var result = provider.TryGetPredicate(pattern, out var predicate);
+
+        Assert.True(result);
+        Assert.NotNull(predicate);
+        Assert.IsType<TestChannelPredicateWithArg>(predicate);
+        Assert.True(predicate.IsMatch("ch-ns"));
+    }
+
+    [Fact]
+    public void UnregisteredType_Throws()
+    {
+        var provider = new ConstructorChannelNamespacePredicateProvider();
+        var pattern = $"ctor:{RuntimeTypeNameFormatter.Format(typeof(System.IO.FileInfo))}:C:\\temp\\evil.txt";
+
+        Assert.Throws<InvalidOperationException>(() => provider.TryGetPredicate(pattern, out _));
+    }
+
+    [Fact]
+    public void UnregisteredArbitraryType_Throws()
+    {
+        var provider = new ConstructorChannelNamespacePredicateProvider();
+        var pattern = $"ctor:{RuntimeTypeNameFormatter.Format(typeof(System.Collections.ArrayList))}";
+
+        Assert.Throws<InvalidOperationException>(() => provider.TryGetPredicate(pattern, out _));
+    }
+
+    [Fact]
+    public void NonMatchingPrefix_ReturnsFalse()
+    {
+        var provider = new ConstructorChannelNamespacePredicateProvider();
+
+        var result = provider.TryGetPredicate("namespace:test", out var predicate);
+
+        Assert.False(result);
+        Assert.Null(predicate);
+    }
+
+    public class TestChannelPredicate : IChannelNamespacePredicate
+    {
+        public string PredicatePattern => ConstructorChannelNamespacePredicateProvider.FormatPattern(typeof(TestChannelPredicate), constructorArgument: null);
+
+        public bool IsMatch(string streamNamespace) => true;
+    }
+
+    public class TestChannelPredicateWithArg : IChannelNamespacePredicate
+    {
+        private readonly string _namespace;
+
+        public TestChannelPredicateWithArg(string ns) => _namespace = ns;
+
+        public string PredicatePattern => ConstructorChannelNamespacePredicateProvider.FormatPattern(typeof(TestChannelPredicateWithArg), _namespace);
+
+        public bool IsMatch(string streamNamespace) => string.Equals(_namespace, streamNamespace, StringComparison.Ordinal);
+    }
+}

test/Orleans.BroadcastChannel.Tests/Orleans.BroadcastChannel.Tests.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <RootNamespace>UnitTests</RootNamespace>
+    <TargetFrameworks>$(TestTargetFrameworks)</TargetFrameworks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="$(SourceRoot)src\Orleans.BroadcastChannel\Orleans.BroadcastChannel.csproj" />
+    <ProjectReference Include="$(SourceRoot)test\TestInfrastructure\TestExtensions\TestExtensions.csproj" />
+  </ItemGroup>
+</Project>

test/Orleans.Core.Tests/General/ConstructorPredicateProviderTests.cs

@@ -0,0 +1,89 @@
+using System;
+using Orleans.Serialization.TypeSystem;
+using Orleans.Streams;
+using Xunit;
+
+namespace UnitTests;
+
+/// <summary>
+/// Tests for <see cref="ConstructorStreamNamespacePredicateProvider"/> predicate type registration and resolution.
+/// </summary>
+[TestCategory("BVT"), TestCategory("Predicates")]
+public class ConstructorStreamNamespacePredicateProviderTests
+{
+    [Fact]
+    public void RegisteredPredicateType_Succeeds()
+    {
+        var provider = new ConstructorStreamNamespacePredicateProvider();
+        provider.RegisterPredicateType(typeof(TestStreamPredicate));
+        var pattern = ConstructorStreamNamespacePredicateProvider.FormatPattern(typeof(TestStreamPredicate), constructorArgument: null);
+
+        var result = provider.TryGetPredicate(pattern, out var predicate);
+
+        Assert.True(result);
+        Assert.NotNull(predicate);
+        Assert.IsType<TestStreamPredicate>(predicate);
+    }
+
+    [Fact]
+    public void RegisteredPredicateTypeWithArg_Succeeds()
+    {
+        var provider = new ConstructorStreamNamespacePredicateProvider();
+        provider.RegisterPredicateType(typeof(TestStreamPredicateWithArg));
+        var pattern = ConstructorStreamNamespacePredicateProvider.FormatPattern(typeof(TestStreamPredicateWithArg), constructorArgument: "test-ns");
+
+        var result = provider.TryGetPredicate(pattern, out var predicate);
+
+        Assert.True(result);
+        Assert.NotNull(predicate);
+        Assert.IsType<TestStreamPredicateWithArg>(predicate);
+        Assert.True(predicate.IsMatch("test-ns"));
+    }
+
+    [Fact]
+    public void UnregisteredType_Throws()
+    {
+        var provider = new ConstructorStreamNamespacePredicateProvider();
+        var pattern = $"ctor:{RuntimeTypeNameFormatter.Format(typeof(System.IO.FileInfo))}:C:\\temp\\evil.txt";
+
+        Assert.Throws<InvalidOperationException>(() => provider.TryGetPredicate(pattern, out _));
+    }
+
+    [Fact]
+    public void UnregisteredArbitraryType_Throws()
+    {
+        var provider = new ConstructorStreamNamespacePredicateProvider();
+        var pattern = $"ctor:{RuntimeTypeNameFormatter.Format(typeof(System.Collections.ArrayList))}";
+
+        Assert.Throws<InvalidOperationException>(() => provider.TryGetPredicate(pattern, out _));
+    }
+
+    [Fact]
+    public void NonMatchingPrefix_ReturnsFalse()
+    {
+        var provider = new ConstructorStreamNamespacePredicateProvider();
+
+        var result = provider.TryGetPredicate("namespace:test", out var predicate);
+
+        Assert.False(result);
+        Assert.Null(predicate);
+    }
+
+    public class TestStreamPredicate : IStreamNamespacePredicate
+    {
+        public string PredicatePattern => ConstructorStreamNamespacePredicateProvider.FormatPattern(typeof(TestStreamPredicate), constructorArgument: null);
+
+        public bool IsMatch(string streamNamespace) => true;
+    }
+
+    public class TestStreamPredicateWithArg : IStreamNamespacePredicate
+    {
+        private readonly string _namespace;
+
+        public TestStreamPredicateWithArg(string ns) => _namespace = ns;
+
+        public string PredicatePattern => ConstructorStreamNamespacePredicateProvider.FormatPattern(typeof(TestStreamPredicateWithArg), _namespace);
+
+        public bool IsMatch(string streamNamespace) => string.Equals(_namespace, streamNamespace, StringComparison.Ordinal);
+    }
+}