Seal metadata type and cleanup InterceptorCollection (#462)

Author: JamesNK

src/Grpc.AspNetCore.Server/GrpcMethodMetadata.cs

@@ -24,7 +24,7 @@ namespace Grpc.AspNetCore.Server
     /// <summary>
     /// Metadata for a gRPC method endpoint.
     /// </summary>
-    public class GrpcMethodMetadata
+    public sealed class GrpcMethodMetadata
     {
         /// <summary>
         /// Creates a new instance of <see cref="GrpcMethodMetadata"/> with the provided service type and method.

src/Grpc.AspNetCore.Server/InterceptorCollection.cs

@@ -28,21 +28,44 @@ namespace Grpc.AspNetCore.Server
     /// </summary>
     public class InterceptorCollection : Collection<InterceptorRegistration>
     {
+        internal InterceptorCollection()
+        {
+        }
+
         /// <summary>
         /// Add an interceptor to the end of the pipeline.
         /// </summary>
         /// <typeparam name="TInterceptor">The interceptor type.</typeparam>
         /// <param name="args">The list of arguments to pass to the interceptor constructor when creating an instance.</param>
         public void Add<TInterceptor>(params object[] args) where TInterceptor : Interceptor
         {
-            Add(new InterceptorRegistration(typeof(TInterceptor), args));
+            Add(typeof(TInterceptor), args);
+        }
+
+        /// <summary>
+        /// Add an interceptor to the end of the pipeline.
+        /// </summary>
+        /// <param name="interceptorType">The interceptor type.</param>
+        /// <param name="args">The list of arguments to pass to the interceptor constructor when creating an instance.</param>
+        public void Add(Type interceptorType, params object[] args)
+        {
+            if (interceptorType == null)
+            {
+                throw new ArgumentNullException(nameof(interceptorType));
+            }
+            if (!interceptorType.IsSubclassOf(typeof(Interceptor)))
+            {
+                throw new ArgumentException($"Type must inherit from {typeof(Interceptor).FullName}.", nameof(interceptorType));
+            }
+
+            Add(new InterceptorRegistration(interceptorType, args));
         }
 
         /// <summary>
         /// Append a set of interceptor registrations to the end of the pipeline.
         /// </summary>
         /// <param name="registrations">The set of interceptor registrations to add.</param>
-        public void AddRange(IEnumerable<InterceptorRegistration> registrations)
+        internal void AddRange(IEnumerable<InterceptorRegistration> registrations)
         {
             if (registrations == null)
             {

test/Grpc.AspNetCore.Server.Tests/InterceptorCollectionTests.cs

@@ -0,0 +1,121 @@
+#region Copyright notice and license
+
+// Copyright 2019 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#endregion
+
+using System;
+using Grpc.AspNetCore.Server;
+using Grpc.Core.Interceptors;
+using NUnit.Framework;
+
+namespace Grpc.AspNetCore.FunctionalTests.Server
+{
+    [TestFixture]
+    public class InterceptorCollectionTests
+    {
+        [Test]
+        public void Add_NonGeneric_AddedToCollection()
+        {
+            // Arrange
+            var interceptors = new InterceptorCollection();
+
+            // Act
+            interceptors.Add(typeof(TestInterceptor));
+
+            // Assert
+            Assert.AreEqual(1, interceptors.Count);
+            Assert.AreEqual(typeof(TestInterceptor), interceptors[0].Type);
+            Assert.AreEqual(0, interceptors[0].Arguments.Count);
+        }
+
+        [Test]
+        public void Add_NonGenericInterceptorBaseType_ThrowError()
+        {
+            // Arrange
+            var interceptors = new InterceptorCollection();
+
+            // Act
+            var ex = Assert.Throws<ArgumentException>(() => interceptors.Add(typeof(Interceptor)));
+
+            // Assert
+            Assert.AreEqual("Type must inherit from Grpc.Core.Interceptors.Interceptor. (Parameter 'interceptorType')", ex.Message);
+        }
+
+        [Test]
+        public void Add_Generic_AddedToCollection()
+        {
+            // Arrange
+            var interceptors = new InterceptorCollection();
+
+            // Act
+            interceptors.Add<TestInterceptor>();
+
+            // Assert
+            Assert.AreEqual(1, interceptors.Count);
+            Assert.AreEqual(typeof(TestInterceptor), interceptors[0].Type);
+            Assert.AreEqual(0, interceptors[0].Arguments.Count);
+        }
+
+        [Test]
+        public void Add_GenericInterceptorBaseType_AddedToCollection()
+        {
+            // Arrange
+            var interceptors = new InterceptorCollection();
+
+            // Act
+            var ex = Assert.Throws<ArgumentException>(() => interceptors.Add<Interceptor>());
+
+            // Assert
+            Assert.AreEqual("Type must inherit from Grpc.Core.Interceptors.Interceptor. (Parameter 'interceptorType')", ex.Message);
+        }
+
+        [Test]
+        public void Add_NonGenericWithArgs_AddedToCollection()
+        {
+            // Arrange
+            var interceptors = new InterceptorCollection();
+
+            // Act
+            interceptors.Add(typeof(TestInterceptor), "Arg");
+
+            // Assert
+            Assert.AreEqual(1, interceptors.Count);
+            Assert.AreEqual(typeof(TestInterceptor), interceptors[0].Type);
+            Assert.AreEqual(1, interceptors[0].Arguments.Count);
+            Assert.AreEqual("Arg", interceptors[0].Arguments[0]);
+        }
+
+        [Test]
+        public void Add_GenericWithArgs_AddedToCollection()
+        {
+            // Arrange
+            var interceptors = new InterceptorCollection();
+
+            // Act
+            interceptors.Add<TestInterceptor>("Arg");
+
+            // Assert
+            Assert.AreEqual(1, interceptors.Count);
+            Assert.AreEqual(typeof(TestInterceptor), interceptors[0].Type);
+            Assert.AreEqual(1, interceptors[0].Arguments.Count);
+            Assert.AreEqual("Arg", interceptors[0].Arguments[0]);
+        }
+
+        private class TestInterceptor : Interceptor
+        {
+        }
+    }
+}