Implemented test to check for readonly properties

2026-06-08 04:40:54 +00:00 · 2015-01-05 23:25:52 +01:00
parent 982849d4b9
commit 1fabaf4cc5
3 changed files with 88 additions and 47 deletions
@@ -1,46 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Linq;
-using Octokit.Tests.Helpers;
-using Xunit;
-using System.Collections.Generic;
-
-namespace Octokit.Tests.Conventions
-{
-    public class DebuggerDisplayOnModels
-    {
-        [Theory]
-        [MemberData("ModelTypes")]
-        public void CheckModelsForDebuggerDisplayAttribute(Type modelType)
-        {
-            AssertEx.HasAttribute<DebuggerDisplayAttribute>(modelType);
-        }
-
-        public static IEnumerable<object[]> ModelTypes
-        {
-            get
-            {
-                foreach (var exportedType in typeof(IEventsClient).Assembly.ExportedTypes)
-                {
-                    if (!exportedType.IsClientInterface())
-                    {
-                        continue;
-                    }
-
-                    var methods = exportedType.GetMethods();
-
-                    var parameterTypes = methods.SelectMany(method => method.GetParameters(), (method, parameter) => parameter.ParameterType);
-
-                    var returnTypes = methods.Select(method => method.ReturnType);
-
-                    var modelTypes = parameterTypes.Union(returnTypes).Where(type => type.IsModel());
-
-                    foreach (var modelType in modelTypes.Distinct())
-                    {
-                        yield return new object[] { modelType };
-                    }
-                }
-            }
-        }
-    }
-}
@@ -0,0 +1,87 @@
+using System;
+using System.Diagnostics;
+using System.Linq;
+using Octokit.Tests.Helpers;
+using Xunit;
+using System.Collections.Generic;
+
+namespace Octokit.Tests.Conventions
+{
+    public class ModelTests
+    {
+        [Theory]
+        [MemberData("ModelTypes")]
+        public void HasDebuggerDisplayAttribute(Type modelType)
+        {
+            AssertEx.HasAttribute<DebuggerDisplayAttribute>(modelType);
+        }
+
+        [Theory]
+        [MemberData("ResponseModelTypes")]
+        public void HasGetterOnlyProperties(Type modelType)
+        {
+            foreach (var property in modelType.GetProperties())
+            {
+                var setter = property.GetSetMethod(nonPublic: true);
+
+                Assert.True(setter == null || !setter.IsPublic);
+            }
+        }
+
+        public static IEnumerable<object[]> ModelTypes
+        {
+            get { return GetModelTypes(includeRequestModels: true).Select(type => new[] { type }); }
+        }
+
+        public static IEnumerable<object[]> ResponseModelTypes
+        {
+            get { return GetModelTypes(includeRequestModels: false).Select(type => new[] { type }); }
+        }
+
+        private static IEnumerable<Type> GetModelTypes(bool includeRequestModels)
+        {
+            var allModelTypes = new HashSet<Type>();
+
+            var clientInterfaces = typeof(IEventsClient).Assembly.ExportedTypes
+                .Where(type => type.IsClientInterface());
+
+            foreach (var exportedType in clientInterfaces)
+            {
+                var methods = exportedType.GetMethods();
+
+                var modelTypes = methods.Select(method => UnwrapGenericArgument(method.ReturnType));
+
+                if (includeRequestModels)
+                {
+                    var requestModels = methods.SelectMany(method => method.GetParameters(),
+                        (method, parameter) => parameter.ParameterType);
+
+                    modelTypes = modelTypes.Union(requestModels);
+                }
+
+                foreach (var modelType in modelTypes.Where(type => type.IsModel()))
+                {
+                    allModelTypes.Add(modelType);
+                }
+            }
+
+            return allModelTypes;
+        }
+
+        private static Type UnwrapGenericArgument(Type returnType)
+        {
+            if (returnType.IsGenericType)
+            {
+                var argument = returnType.GetGenericArgument();
+                if (argument.IsModel())
+                {
+                    return argument;
+                }
+
+                return UnwrapGenericArgument(argument);
+            }
+
+            return returnType;
+        }
+    }
+}
@@ -55,7 +55,7 @@
    </Reference>
  </ItemGroup>
  <ItemGroup>
-    <Compile Include="DebuggerDisplayOnModels.cs" />
+    <Compile Include="ModelTests.cs" />
    <Compile Include="Exception\InterfaceHasAdditionalMethodsException.cs" />
    <Compile Include="Exception\InterfaceMethodsMismatchException.cs" />
    <Compile Include="Exception\InterfaceMissingMethodsException.cs" />