[andrewabestGH-87] Added new (Cecil based) convention to check that code doesn't directly call Guid.NewGuid()

A possible use-case is code written in a functional style (that wants to avoid non-deterministic behaviour)

Author: eddie.stanley

src/Core/Conventional.Tests/Conventional/Conventions/Cecil/CecilConventionSpecificationTests.cs

@@ -515,5 +515,63 @@ public void LibraryCodeShouldCallConfigureAwaitWhenAwaitingTasks_FailsWhenConfig
             result.IsSatisfied.Should().BeFalse();
             result.Failures.Single().Should().Be(expectedFailureMessage);
         }
+
+        # region MustNotUseGuidNewGuid
+
+        private interface IGuidProvider
+        {
+            Guid CreateIdentifier();
+        }
+
+        private class GoodGuidCreationCitizen
+        {
+            public GoodGuidCreationCitizen(IGuidProvider guidProvider)
+            {
+                guidProvider.CreateIdentifier();
+            }
+        }
+
+        [Test]
+        public void MustNotUseGuidCreationNowConventionSpecification_Success()
+        {
+            typeof(GoodGuidCreationCitizen)
+                .MustConformTo(Convention.MustNotUseGuidNewGuid)
+                .IsSatisfied
+                .Should()
+                .BeTrue();
+        }
+
+        private class OffendingGuidCreationCitizen
+        {
+             public OffendingGuidCreationCitizen()
+             {
+                 Guid.NewGuid();
+             }
+        }
+
+        private class AsyncOffendingGuidCreationCitizen
+        {
+            public async Task<Guid> ResolveIdentifier()
+            {
+                await Task.Delay(1);
+                return Guid.NewGuid();
+            }
+        }
+
+        [Test]
+        public void MustNotUseGuidCreationNowConventionSpecification_FailsWhenACallToGuidCreationNowOrGuidCreationUtcNowExists()
+        {
+            var result = new []
+                {
+                    typeof(OffendingGuidCreationCitizen),
+                    typeof(AsyncOffendingGuidCreationCitizen)
+                }
+                .MustConformTo(Convention.MustNotUseGuidNewGuid);
+
+            result.Results.Should().OnlyContain(x => x.IsSatisfied == false);
+            result.Failures.Should().HaveCount(2);
+        }
+
+        # endregion
     }
 }

src/Core/Conventional/Convention.Cecil.cs

@@ -9,6 +9,8 @@ public static partial class Convention
 
         public static MustNotUseDateTimeOffsetNowConventionSpecification MustNotUseDateTimeOffsetNow => new MustNotUseDateTimeOffsetNowConventionSpecification();
 
+        public static MustNotUseGuidNewGuidConventionSpecification MustNotUseGuidNewGuid => new MustNotUseGuidNewGuidConventionSpecification();
+
         public static ExceptionsThrownMustBeDerivedFromConventionSpecification ExceptionsThrownMustBeDerivedFrom(Type baseType)
         {
             return new ExceptionsThrownMustBeDerivedFromConventionSpecification(baseType);

src/Core/Conventional/Conventions/Cecil/MustNotUseGuidNewGuidConventionSpecification.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace Conventional.Conventions.Cecil
+{
+    public class MustNotUseGuidNewGuidConventionSpecification :
+        MustNotCallMethodConventionSpecification
+    {
+        private static MethodInfo GetMethod()
+        {
+            Expression<Func<Guid>> expr = () => Guid.NewGuid();
+            return ((MethodCallExpression)expr.Body).Method;
+        }
+
+        public MustNotUseGuidNewGuidConventionSpecification()
+            : base(new[] { GetMethod() })
+        {
+        }
+    }
+}