merge initial legacy support into master

NuGet.Config

@@ -1,6 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
 <configuration>
 	<packageSources>
-		<add key="nugetizer" value="https://ci.appveyor.com/nuget/nugetizer3000" />
+    <clear />
+    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
+    <add key="nugetizer" value="https://ci.appveyor.com/nuget/nugetizer3000" />
+    <add key="kzu" value="https://kzu.blob.core.windows.net/nuget/index.json" />
   </packageSources>
 </configuration>

src/Moq/Moq.CodeAnalysis/MockNamingConvention.cs

@@ -10,13 +10,13 @@ namespace Moq
     public class MockNamingConvention : NamingConvention
     {
         /// <summary>
-        /// Gets the generated code namespace, which is <see cref="MockNaming.Namespace"/>.
+        /// Gets the generated code namespace, which is <see cref="MockNaming.DefaultNamespace"/>.
         /// </summary>
-        public override string Namespace => MockNaming.Namespace;
+        public override string Namespace => MockNaming.DefaultNamespace;
 
         /// <summary>
-        /// Gets the generated type names suffix, which is <see cref="MockNaming.NameSuffix"/>.
+        /// Gets the generated type names suffix, which is <see cref="MockNaming.DefaultSuffix"/>.
         /// </summary>
-        public override string NameSuffix => MockNaming.NameSuffix;
+        public override string NameSuffix => MockNaming.DefaultSuffix;
     }
 }

src/Moq/Moq.CodeAnalysis/RecursiveMockAnalyzer.cs

@@ -119,7 +119,7 @@ static void ReportDiagnostics(SyntaxNodeAnalysisContext context, INamedTypeSymbo
                     new Dictionary<string, string>
                     {
                             { "TargetFullName", name },
-                            { "Symbols", type.ToFullMetadataName() },
+                            { "Symbols", type.ToFullName() },
                             { "RecursiveSymbols", "" },
                     }.ToImmutableDictionary(),
                     name));
@@ -136,7 +136,7 @@ static void ReportDiagnostics(SyntaxNodeAnalysisContext context, INamedTypeSymbo
                         new Dictionary<string, string>
                         {
                                 { "TargetFullName", name },
-                                { "Symbols", type.ToFullMetadataName() },
+                                { "Symbols", type.ToFullName() },
                                 { "RecursiveSymbols", "" },
                         }.ToImmutableDictionary(),
                         name));

src/Moq/Moq.CodeFix/MockGenerator.cs

@@ -20,7 +20,7 @@ public MockGenerator(NamingConvention naming)
                 {
                     new DefaultImports(typeof(LazyInitializer).Namespace, typeof(IMocked).Namespace),
                 }
-                .Concat(GetDefaultProcessors())
+                .Concat(GetDefaultProcessors().Where(p => !(p is FixupImports)))
                 .Concat(new IDocumentProcessor[]
                 {
                     new CSharpMocked(),

src/Moq/Moq.CodeFix/Moq.props

@@ -10,8 +10,8 @@
 
     <!-- CodeFix analyzers should only be added to DTBs since they depend on 
          editor features that are not available from csc/vbc -->
-    <CodeFix Include="$(MSBuildThisFileDirectory)netstandard.dll" />
-    <CodeFix Include="$(MSBuildThisFileDirectory)Moq.CodeFix.dll" />
+    <CodeFix Include="$(MSBuildThisFileDirectory)netstandard.dll" NuGetPackageId="Moq" />
+    <CodeFix Include="$(MSBuildThisFileDirectory)Moq.CodeFix.dll" NuGetPackageId="Moq" />
   </ItemGroup>
 
   <ItemGroup>

src/Moq/Moq.Sdk.Tests/Fakes.cs

@@ -42,7 +42,7 @@ public class FakeSetup : IMockSetup
     public class FakeInvocation : IMethodInvocation
     {
         public FakeInvocation() => Target = new Mocked();
-
+        
         public IArgumentCollection Arguments { get; set; } 
 
         public IDictionary<string, object> Context { get; set; }
@@ -51,6 +51,8 @@ public class FakeInvocation : IMethodInvocation
 
         public object Target { get; set; }
 
+        public HashSet<Type> SkipBehaviors { get; } = new HashSet<Type>();
+
         public IMethodReturn CreateExceptionReturn(Exception exception) => new FakeReturn { Exception = exception };
 
         public IMethodReturn CreateValueReturn(object returnValue, params object[] allArguments) => new FakeReturn { ReturnValue = returnValue };

src/Moq/Moq.Sdk.Tests/Moq.Sdk.Tests.csproj

@@ -2,7 +2,7 @@
   <Sdk Name="Microsoft.Build.CentralPackageVersions" />
 
   <PropertyGroup>
-    <TargetFramework>net471</TargetFramework>
+    <TargetFramework>net472</TargetFramework>
     <IncludeXunit>true</IncludeXunit>
     <IncludeMSBuild>true</IncludeMSBuild>
 
@@ -16,6 +16,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\..\Stunts\Stunts.CodeFix\Stunts.CodeFix.csproj" />
     <ProjectReference Include="..\Moq.Sdk\Moq.Sdk.csproj" />
     <ProjectReference Include="..\..\Stunts\Stunts\Stunts.csproj" />
     <ProjectReference Include="..\..\Stunts\Stunts.Sdk\Stunts.Sdk.csproj" />

src/Moq/Moq.Sdk.Tests/StrictMockBehaviorTests.cs

@@ -13,19 +13,5 @@ public void AppliesToAllInvocations()
         public void ThrowsStrictMockException()
             => Assert.Throws<StrictMockException>(() =>
                 new StrictMockBehavior().Execute(new FakeInvocation(), () => throw new NotImplementedException()));
-
-        [Fact]
-        public void ThrowsIfNullInvocation()
-            => Assert.Throws<ArgumentNullException>(() =>
-                new StrictMockBehavior().Execute(null, () => throw new NotImplementedException()));
-
-        [Fact]
-        public void DoesNotThrowIfSetupScopeActive()
-        {
-            using (new SetupScope())
-            {
-                new StrictMockBehavior().Execute(new FakeInvocation(), () => (m, n) => m.CreateValueReturn(null));
-            }
-        }
     }
 }

src/Moq/Moq.Sdk/IMock`1.cs

@@ -3,7 +3,7 @@
     /// <summary>
     /// Provides introspection information about a mock.
     /// </summary>
-    public interface IMock<out T> : IMock, IFluentInterface
+    public interface IMock<out T> : IMock, IFluentInterface where T : class
     {
         /// <summary>
         /// The mock object this introspection data belongs to.

src/Moq/Moq.Sdk/MockDecorator`1.cs

@@ -1,13 +1,9 @@
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using Stunts;
-
-namespace Moq.Sdk
+namespace Moq.Sdk
 {
     /// <summary>
     /// Decorator implementation over an <see cref="IMock"/>.
     /// </summary>
-    public abstract class MockDecorator<T> : MockDecorator, IMock<T>
+    public abstract class MockDecorator<T> : MockDecorator, IMock<T> where T : class
     {
         readonly IMock<T> mock;
 

src/Moq/Moq.Sdk/MockExtensions.cs

@@ -18,14 +18,14 @@ public static class MockExtensions
         /// <summary>
         /// Gets the introspection information for a mocked object instance.
         /// </summary>
-        public static IMock<T> AsMock<T>(this T instance)
+        public static IMock<T> AsMock<T>(this T instance) where T : class
             => (instance as IMocked)?.Mock.As(instance) ?? throw new ArgumentException(Strings.TargetNotMock, nameof(instance));
 
         /// <summary>
         /// Clones a mock by creating a new instance of the <see cref="IMock.Object"/> 
         /// from <paramref name="mock"/> and copying its behaviors, invocations and state.
         /// </summary>
-        public static IMock<T> Clone<T>(this IMock<T> mock)
+        public static IMock<T> Clone<T>(this IMock<T> mock) where T : class
         {
             if (!mock.State.TryGetValue<object[]>(".ctor", out var ctor))
                 throw new ArgumentException("No constructor state found for cloning.");
@@ -52,7 +52,7 @@ public static IMock<T> Clone<T>(this IMock<T> mock)
         /// Gets the invocations performed on the mock so far that match the given 
         /// setup lambda.
         /// </summary>
-        public static IEnumerable<IMethodInvocation> InvocationsFor<T>(this IMock<T> mock, Action<T> action)
+        public static IEnumerable<IMethodInvocation> InvocationsFor<T>(this IMock<T> mock, Action<T> action) where T : class
         {
             using (new SetupScope())
             {
@@ -66,7 +66,7 @@ public static IEnumerable<IMethodInvocation> InvocationsFor<T>(this IMock<T> moc
         /// Gets the invocations performed on the mock so far that match the given 
         /// setup lambda.
         /// </summary>
-        public static IEnumerable<IMethodInvocation> InvocationsFor<T, TResult>(this IMock<T> mock, Func<T, TResult> function)
+        public static IEnumerable<IMethodInvocation> InvocationsFor<T, TResult>(this IMock<T> mock, Func<T, TResult> function) where T : class
         {
             using (new SetupScope())
             {
@@ -76,9 +76,9 @@ public static IEnumerable<IMethodInvocation> InvocationsFor<T, TResult>(this IMo
             }
         }
 
-        static IMock<T> As<T>(this IMock mock, T target) => mock == null ? null : new Mock<T>(mock, target);
+        static IMock<T> As<T>(this IMock mock, T target) where T : class => mock == null ? null : new Mock<T>(mock, target);
 
-        class Mock<T> : IMock<T>
+        class Mock<T> : IMock<T> where T : class
         {
             IMock mock;
 

src/Moq/Moq.Sdk/MockGeneratorAttribute.cs

@@ -6,7 +6,7 @@ namespace Moq
     /// Annotates a method that is a factory for mocks, so that a 
     /// compile-time or design-time generator can generate them ahead of time.
     /// </summary>
-    [AttributeUsage(AttributeTargets.Method)]
+    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor)]
     public class MockGeneratorAttribute : Attribute
     {
     }

src/Moq/Moq.Sdk/MockNaming.cs

@@ -1,6 +1,5 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
+using Stunts;
 
 namespace Moq.Sdk
 {
@@ -10,29 +9,46 @@ namespace Moq.Sdk
     public static class MockNaming
     {
         /// <summary>
-        /// The namespace where generated mocks are declared.
+        /// The default namespace where generated mocks are declared.
         /// </summary>
-        public const string Namespace = "Mocks";
+        public const string DefaultNamespace = "Mocks";
 
         /// <summary>
-        /// The suffix added to mock type names.
+        /// The default suffix added to mock type names.
         /// </summary>
-        public const string NameSuffix = "Mock";
+        public const string DefaultSuffix = "Mock";
 
         /// <summary>
-        /// Gets the runtime mock name from its base type and implemented interfaces.
+        /// Gets the runtime mock name from its base type and optional additional 
+        /// interfaces, using the <see cref="DefaultSuffix"/>.
         /// </summary>
-        public static string GetName(Type baseType, Type[] implementedInterfaces)
-        {
-            Array.Sort(implementedInterfaces, Comparer<Type>.Create((x, y) => x.Name.CompareTo(y.Name)));
+        public static string GetName(Type baseType, Type[] additionalInterfaces)
+            => GetName(DefaultSuffix, baseType, additionalInterfaces);
 
-            return baseType.Name + string.Join("", implementedInterfaces.Select(x => x.Name)) + NameSuffix;
-        }
+        /// <summary>
+        /// Gets the runtime mock name from its base type and optional additional interfaces 
+        /// and the given <paramref name="suffix"/> appended to the type name.
+        /// </summary>
+        public static string GetName(string suffix, Type baseType, Type[] additionalInterfaces)
+            => StuntNaming.GetName(suffix, baseType, additionalInterfaces);
+
+        /// <summary>
+        /// Gets the runtime mock full name from its base type and optional additional interfaces,
+        /// using the <see cref="DefaultNamespace"/> and <see cref="DefaultSuffix"/>.
+        /// </summary>
+        public static string GetFullName(Type baseType, params Type[] additionalInterfaces)
+            => GetFullName(DefaultNamespace, DefaultSuffix, baseType, additionalInterfaces);
+
+        /// <summary>
+        /// Gets the runtime mock full name from its base type and implemented interfaces.
+        /// </summary>
+        public static string GetFullName(string @namespace, Type baseType, params Type[] additionalInterfaces)
+            => GetFullName(@namespace, DefaultSuffix, baseType, additionalInterfaces);
 
         /// <summary>
         /// Gets the runtime mock full name from its base type and implemented interfaces.
         /// </summary>
-        public static string GetFullName(Type baseType, Type[] implementedInterfaces)
-            => Namespace + "." + GetName(baseType, implementedInterfaces);
+        public static string GetFullName(string @namespace, string suffix, Type baseType, params Type[] additionalInterfaces)
+            => StuntNaming.GetFullName(@namespace, suffix, baseType, additionalInterfaces);
     }
 }

src/Moq/Moq.Sdk/StrictMockBehavior.cs

@@ -10,8 +10,6 @@ namespace Moq.Sdk
     /// </summary>
     public class StrictMockBehavior : IStuntBehavior
     {
-        IStuntBehavior fallback = new DefaultValueBehavior();
-
         /// <summary>
         /// Always returns <see langword="true" />
         /// </summary>
@@ -20,16 +18,6 @@ public class StrictMockBehavior : IStuntBehavior
         /// <summary>
         /// Throws <see cref="StrictMockException"/>.
         /// </summary>
-        public IMethodReturn Execute(IMethodInvocation invocation, GetNextBehavior next)
-        {
-            if (invocation == null) throw new ArgumentNullException(nameof(invocation));
-
-            if (!SetupScope.IsActive)
-                throw new StrictMockException();
-
-            // Otherwise, fallback to returning default values so that 
-            // the fluent setup API can do its work.
-            return fallback.Execute(invocation, next);
-        }
+        public IMethodReturn Execute(IMethodInvocation invocation, GetNextBehavior next) => throw new StrictMockException();
     }
-}
+}

src/Moq/Moq.Tests/CallBaseTests.cs

@@ -0,0 +1,82 @@
+using Xunit;
+using Moq.Sdk;
+using Sample;
+
+namespace Moq.Tests
+{
+    public class CallBaseTests
+    {
+        [Fact]
+        public void CallBaseNotCalled()
+        {
+            var mock = Mock.Of<Calculator>();
+
+            mock.TurnOn();
+
+            Assert.False(mock.TurnOnCalled);
+        }
+
+        [Fact]
+        public void CallBaseCalledForMockConfig()
+        {
+            var mock = Mock.Of<Calculator>().CallBase();
+
+            mock.TurnOn();
+
+            Assert.True(mock.TurnOnCalled);
+        }
+
+        [Fact]
+        public void CallBaseCalledForInvocationConfig()
+        {
+            var mock = Mock.Of<Calculator>();
+
+            mock.Setup(x => x.TurnOn()).CallBase();
+
+            mock.TurnOn();
+
+            Assert.True(mock.TurnOnCalled);
+        }
+
+        [Fact]
+        public void ThrowsForStrictMockAndMissingSetup()
+        {
+            // Configure CallBase at the Mock level
+            var mock = Mock.Of<Calculator>(MockBehavior.Strict).CallBase();
+
+            Assert.Throws<StrictMockException>(() => mock.TurnOn());
+        }
+
+        [Fact]
+        public void CallBaseCalledForStrictMockAndMockConfig()
+        {
+            // Configure CallBase at the Mock level
+            var mock = Mock.Of<Calculator>(MockBehavior.Strict).CallBase();
+
+            mock.Setup(x => x.TurnOn());
+
+            mock.TurnOn();
+
+            Assert.True(mock.TurnOnCalled);
+
+            // And we make sure we throw for other missing setups
+            Assert.Throws<StrictMockException>(() => mock.Recall(""));
+        }
+
+        [Fact]
+        public void CallBaseCalledForStrickMockAndInvocationConfig()
+        {
+            var mock = Mock.Of<Calculator>(MockBehavior.Strict);
+
+            // Configure CallBase at the invocation level
+            mock.Setup(x => x.TurnOn()).CallBase();
+
+            mock.TurnOn();
+
+            Assert.True(mock.TurnOnCalled);
+
+            // And we make sure we throw for other missing setups
+            Assert.Throws<StrictMockException>(() => mock.Recall(""));
+        }
+    }
+}