Merge pull request #90 from ecofreshdatatechnologies/ClassesAreStatic

add AreStatic, AreNotStatic, BeStatic, NotBeStatic methods

Author: BenMorris

src/NetArchTest.Rules/Conditions.cs

@@ -344,6 +344,26 @@ public ConditionList NotBeInterfaces()
             return new ConditionList(_types, _should, _sequence);
         }
 
+        /// <summary>
+        /// Selects types that are static.
+        /// </summary>
+        /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
+        public ConditionList BeStatic()
+        {
+	        _sequence.AddFunctionCall(FunctionDelegates.BeStatic, true, true);
+	        return new ConditionList(_types, _should, _sequence);
+        }
+
+        /// <summary>
+        /// Selects types that are not static.
+        /// </summary>
+        /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
+        public ConditionList NotBeStatic()
+        {
+	        _sequence.AddFunctionCall(FunctionDelegates.BeStatic, true, false);
+	        return new ConditionList(_types, _should, _sequence);
+        }
+
         /// <summary>
         /// Selects types that are nested.
         /// </summary>

src/NetArchTest.Rules/FunctionDelegates.cs

@@ -1,4 +1,6 @@
-namespace NetArchTest.Rules
+using Mono.Cecil.Rocks;
+
+namespace NetArchTest.Rules
 {
     using System;
     using System.Collections.Generic;
@@ -194,6 +196,21 @@ internal static FunctionDelegate<string> MakeFunctionDelegateUsingStringComparer
             }
         };
 
+        /// <summary> Function for finding static classes. </summary>
+        internal static FunctionDelegate<bool> BeStatic = delegate(IEnumerable<TypeDefinition> input, bool dummy, bool condition)
+        {
+	        if (condition)
+	        {
+		        return input.Where(ClassIsStatic);
+	        }
+	        else
+	        {
+		        return input.Where(c => !ClassIsStatic(c));
+	        }
+
+	        bool ClassIsStatic(TypeDefinition c) => c.IsAbstract && c.IsSealed && !c.IsInterface && !c.GetConstructors().Any(m => m.IsPublic);
+        };
+
         /// <summary> Function for finding types with generic parameters. </summary>
         internal static FunctionDelegate<bool> BeGeneric = delegate (IEnumerable<TypeDefinition> input, bool dummy, bool condition)
         {

src/NetArchTest.Rules/NetArchTest.Rules.xml

@@ -351,6 +351,26 @@ public PredicateList AreNotInterfaces()
             return new PredicateList(_types, _sequence);
         }
 
+        /// <summary>
+        /// Selects types that are static.
+        /// </summary>
+        /// <returns>An updated set of predicates that can be applied to a list of types.</returns>
+        public PredicateList AreStatic()
+        {
+	        _sequence.AddFunctionCall(FunctionDelegates.BeStatic, true, true);
+	        return new PredicateList(_types, _sequence);
+        }
+
+        /// <summary>
+        /// Selects types that are not static.
+        /// </summary>
+        /// <returns>An updated set of predicates that can be applied to a list of types.</returns>
+        public PredicateList AreNotStatic()
+        {
+	        _sequence.AddFunctionCall(FunctionDelegates.BeStatic, true, false);
+	        return new PredicateList(_types, _sequence);
+        }
+
         /// <summary>
         /// Selects types that are nested.
         /// </summary>

src/NetArchTest.Rules/Predicates.cs

@@ -1,4 +1,6 @@
-namespace NetArchTest.Rules.UnitTests
+using NetArchTest.TestStructure.Classes;
+
+namespace NetArchTest.Rules.UnitTests
 {
     using System;
     using System.Linq;
@@ -416,6 +418,36 @@ public void AreNotInterfaces_MatchesFound_ClassesSelected()
             Assert.True(result.IsSuccessful);
         }
 
+        [Fact(DisplayName = "Types can be selected if they are static.")]
+        public void AreStatic_MatchesFound_ClassesSelected()
+        {
+	        var result = Types
+		        .InAssembly(Assembly.GetAssembly(typeof(ClassA1)))
+		        .That()
+		        .ResideInNamespace("NetArchTest.TestStructure.Classes")
+		        .And()
+		        .HaveNameEndingWith("StaticClass")
+		        .Should()
+		        .BeStatic().GetResult();
+
+	        Assert.True(result.IsSuccessful);
+        }
+
+        [Fact(DisplayName = "Types can be selected if they are not static.")]
+        public void AreNotStatic_MatchesFound_ClassesSelected()
+        {
+	        var result = Types
+		        .InAssembly(Assembly.GetAssembly(typeof(ClassA1)))
+		        .That()
+		        .ResideInNamespace("NetArchTest.TestStructure.Classes")
+		        .And()
+		        .HaveName(nameof(ExampleClass))
+		        .Should()
+		        .NotBeStatic().GetResult();
+
+	        Assert.True(result.IsSuccessful);
+        }
+
         [Fact(DisplayName = "Types can be selected if they are nested.")]
         public void AreNested_MatchesFound_ClassesSelected()
         {

test/NetArchTest.Rules.UnitTests/ConditionTests.cs

@@ -392,8 +392,9 @@ public void AreClasses_MatchesFound_ClassesSelected()
                 .And()
                 .AreClasses().GetTypes();
 
-            Assert.Single(result); // One type found
+            Assert.Equal(2, result.Count()); // Two types found
             Assert.Contains<Type>(typeof(ExampleClass), result);
+            Assert.Contains<Type>(typeof(ExampleStaticClass), result);
         }
 
         [Fact(DisplayName = "Types can be selected if they are not classes.")]
@@ -462,8 +463,38 @@ public void AreNotInterfaces_MatchesFound_ClassesSelected ()
                 .And()
                 .AreNotInterfaces().GetTypes();
 
-            Assert.Single(result); // One type found
+            Assert.Equal(2, result.Count()); // Two types found
+            Assert.Contains<Type>(typeof(ExampleClass), result);
+            Assert.Contains<Type>(typeof(ExampleStaticClass), result);
+        }
+
+        [Fact(DisplayName = "Types can be selected if they are static.")]
+        public void AreStatic_MatchesFound_ClassesSelected()
+        {
+	        var result = Types
+		        .InAssembly(Assembly.GetAssembly(typeof(ClassA1)))
+		        .That()
+		        .ResideInNamespace("NetArchTest.TestStructure.Classes")
+		        .And()
+		        .AreStatic().GetTypes();
+
+	        Assert.Single(result); // One type found
+	        Assert.Contains<Type>(typeof(ExampleStaticClass), result);
+        }
+
+        [Fact(DisplayName = "Types can be selected if they are not static.")]
+        public void AreNotStatic_MatchesFound_ClassesSelected()
+        {
+	        var result = Types
+		        .InAssembly(Assembly.GetAssembly(typeof(ClassA1)))
+		        .That()
+		        .ResideInNamespace("NetArchTest.TestStructure.Classes")
+		        .And()
+		        .AreNotStatic().GetTypes();
+
+	        Assert.Equal(2, result.Count()); // Two types found
             Assert.Contains<Type>(typeof(ExampleClass), result);
+	        Assert.Contains<Type>(typeof(IExampleInterface), result);
         }
 
         [Fact(DisplayName = "Types can be selected if they are nested.")]

test/NetArchTest.Rules.UnitTests/PredicateTests.cs

@@ -0,0 +1,12 @@
+namespace NetArchTest.TestStructure.Classes
+{
+	public static class ExampleStaticClass
+	{
+		static ExampleStaticClass()
+		{
+
+		}
+
+		public static bool SampleMethod() => true;
+	}
+}