Implement Append/Prepend for source members

Serg046 · Aug 4, 2019 · ecc6ec6 · ecc6ec6
1 parent 1570666
commit ecc6ec6
Show file tree

Hide file tree

Showing 22 changed files with 346 additions and 305 deletions.
diff --git a/AutoFake.IntegrationTests/InsertTests.cs b/AutoFake.IntegrationTests/InsertTests.cs
@@ -9,15 +9,14 @@ public class InsertTests
         public void Should_AddNumberInTheEnd_When_Append()
         {
             var fake = new Fake<TestClass>();
-            fake.Append(() => TestClass.Numbers.Add(5));
+            fake.Append(() => TestClass.Numbers.Add(-1));
             fake.Rewrite(t => t.SomeMethod());
 
             fake.Execute(tst =>
             {
                 Assert.Empty(TestClass.Numbers);
                 tst.SomeMethod();
-                Assert.Equal(7, TestClass.Numbers[0]);
-                Assert.Equal(5, TestClass.Numbers[1]);
+                Assert.Equal(new[] {3, 5, 7, -1}, TestClass.Numbers);
                 TestClass.Numbers.Clear();
             });
         }
@@ -26,26 +25,77 @@ public void Should_AddNumberInTheEnd_When_Append()
         public void Should_AddNumberInTheBeginning_When_Prepend()
         {
             var fake = new Fake<TestClass>();
-            fake.Prepend(() => TestClass.Numbers.Add(5));
+            fake.Prepend(() => TestClass.Numbers.Add(-1));
             fake.Rewrite(t => t.SomeMethod());
 
             fake.Execute(tst =>
             {
                 Assert.Empty(TestClass.Numbers);
                 tst.SomeMethod();
-                Assert.Equal(5, TestClass.Numbers[0]);
-                Assert.Equal(7, TestClass.Numbers[1]);
+                Assert.Equal(new[] {-1, 3, 5, 7}, TestClass.Numbers);
+                TestClass.Numbers.Clear();
+            });
+        }
+
+        [Fact]
+        public void Should_AddNumberAfterCmd_When_AppendWithSourceMember()
+        {
+            var fake = new Fake<TestClass>();
+            fake.Append(() => TestClass.Numbers.Add(-1))
+                .After((List<int> list) => list.AddRange(new int[0]));
+            fake.Rewrite(t => t.SomeMethod());
+
+            fake.Execute(tst =>
+            {
+                Assert.Empty(TestClass.Numbers);
+                tst.SomeMethod();
+                Assert.Equal(new[] { 3, 5, -1, 7 }, TestClass.Numbers);
+                TestClass.Numbers.Clear();
+            });
+        }
+
+        [Fact]
+        public void Should_AddBothNumbers_When_MultipleCallbacks()
+        {
+            var fake = new Fake<TestClass>();
+            fake.Prepend(() => TestClass.Numbers.Add(-1));
+            fake.Append(() => TestClass.Numbers.Add(-2));
+            fake.Rewrite(t => t.SomeMethod());
+
+            fake.Execute(tst =>
+            {
+                Assert.Empty(TestClass.Numbers);
+                tst.SomeMethod();
+                Assert.Equal(new[] { -1, 3, 5, 7, -2 }, TestClass.Numbers);
+                TestClass.Numbers.Clear();
+            });
+        }
+
+        [Fact]
+        public void Should_AddNumberBeforeCmd_When_PrependWithSourceMember()
+        {
+            var fake = new Fake<TestClass>();
+            fake.Prepend(() => TestClass.Numbers.Add(-1))
+                .Before((List<int> list) => list.AddRange(new int[0]));
+            fake.Rewrite(t => t.SomeMethod());
+
+            fake.Execute(tst =>
+            {
+                Assert.Empty(TestClass.Numbers);
+                tst.SomeMethod();
+                Assert.Equal(new[] { 3, -1, 5, 7 }, TestClass.Numbers);
                 TestClass.Numbers.Clear();
             });
         }
 
         private class TestClass
         {
-            //public static List<int> Numbers { get; } = new List<int>();
-            public static readonly List<int> Numbers = new List<int>();
+            public static List<int> Numbers { get; } = new List<int>();
 
             public void SomeMethod()
             {
+                Numbers.Add(3);
+                Numbers.AddRange(new [] {5});
                 Numbers.Add(7);
             }
         }

diff --git a/AutoFake.UnitTests/AutoFake.UnitTests.csproj b/AutoFake.UnitTests/AutoFake.UnitTests.csproj
@@ -80,7 +80,6 @@
     <Compile Include="Setup\ReplaceMockTests.cs" />
     <Compile Include="Setup\VerifyMockInstallerTests.cs" />
     <Compile Include="Setup\VerifyMockTests.cs" />
-    <Compile Include="Setup\SourceConstructorTests.cs" />
     <Compile Include="Setup\SourceFieldTests.cs" />
     <Compile Include="Setup\SourceMethodTests.cs" />
     <Compile Include="TestUtils\Cil.cs" />

diff --git a/AutoFake.UnitTests/FakeTests.cs b/AutoFake.UnitTests/FakeTests.cs
@@ -293,55 +293,55 @@ public async Task Execute_Fake_CallbackExecuted()
             }));
         }
 
-        [Fact]
-        public void Append_GenericFake_MockAdded()
+        [Theory]
+        [MemberData(nameof(GetActions))]
+        public void Append_GenericFake_MockAdded(dynamic callback)
         {
             var fake = new Fake<TestClass>();
-            Action action = () => { };
+            var action = callback.Compile();
 
             fake.Append(action);
 
             var mock = Assert.IsType<InsertMock>(fake.Mocks.Single());
-            Assert.Equal(action.Method.DeclaringType.FullName, mock.Action.DeclaringType);
             Assert.Equal(action.Method.Name, mock.Action.Name);
         }
 
-        [Fact]
-        public void Append_Fake_MockAdded()
+        [Theory]
+        [MemberData(nameof(GetActions))]
+        public void Append_Fake_MockAdded(dynamic callback)
         {
             var fake = new Fake(typeof(TestClass));
-            Action action = () => { };
+            var action = callback.Compile();
 
             fake.Append(action);
 
             var mock = Assert.IsType<InsertMock>(fake.Mocks.Single());
-            Assert.Equal(action.Method.DeclaringType.FullName, mock.Action.DeclaringType);
             Assert.Equal(action.Method.Name, mock.Action.Name);
         }
 
-        [Fact]
-        public void Prepend_GenericFake_MockAdded()
+        [Theory]
+        [MemberData(nameof(GetActions))]
+        public void Prepend_GenericFake_MockAdded(dynamic callback)
         {
             var fake = new Fake<TestClass>();
-            Action action = () => { };
+            var action = callback.Compile();
 
             fake.Prepend(action);
 
             var mock = Assert.IsType<InsertMock>(fake.Mocks.Single());
-            Assert.Equal(action.Method.DeclaringType.FullName, mock.Action.DeclaringType);
             Assert.Equal(action.Method.Name, mock.Action.Name);
         }
 
-        [Fact]
-        public void Prepend_Fake_MockAdded()
+        [Theory]
+        [MemberData(nameof(GetActions))]
+        public void Prepend_Fake_MockAdded(dynamic callback)
         {
             var fake = new Fake(typeof(TestClass));
-            Action action = () => { };
+            var action = callback.Compile();
 
             fake.Prepend(action);
 
             var mock = Assert.IsType<InsertMock>(fake.Mocks.Single());
-            Assert.Equal(action.Method.DeclaringType.FullName, mock.Action.DeclaringType);
             Assert.Equal(action.Method.Name, mock.Action.Name);
         }
 

diff --git a/AutoFake.UnitTests/MockerTests.cs b/AutoFake.UnitTests/MockerTests.cs
@@ -244,8 +244,10 @@ public void ReplaceToRetValueField_ValidInput_InstructionReplaced()
             Assert.Equal(mocker.MemberInfo.RetValueField, replacedCmd.Operand);
         }
 
-        [Fact]
-        public void InjectCallback_ValidInput_Injected()
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void InjectCallback_ValidInput_Injected(bool beforeInstruction)
         {
             var method = _typeInfo.Methods.Single(m => m.Name == nameof(TestType.SomeMethodWithBody));
             var proc = method.Body.GetILProcessor();
@@ -255,13 +257,16 @@ public void InjectCallback_ValidInput_Injected()
                 _typeInfo.GetMonoCecilTypeName(typeof(TestType)),
                 nameof(TestType.SomeMethodWithArguments));
 
-            mocker.InjectCallback(proc, cmd, mtDescr);
+            mocker.InjectCallback(proc, cmd, mtDescr, beforeInstruction);
 
-            Assert.True(proc.Body.Instructions.Ordered(
+            var sourceCmd = new[] {Cil.Cmd(cmd.OpCode, cmd.Operand)};
+            var cmds = new[]
+            {
                 Cil.Cmd(OpCodes.Newobj, (MethodReference m) => m.Name == ".ctor" && m.DeclaringType.FullName == mtDescr.DeclaringType),
-                Cil.Cmd(OpCodes.Call, (MethodReference m) => m.Name == mtDescr.Name && m.DeclaringType.FullName == mtDescr.DeclaringType),
-                Cil.Cmd(cmd.OpCode, cmd.Operand)
-                ));
+                Cil.Cmd(OpCodes.Call, (MethodReference m) => m.Name == mtDescr.Name && m.DeclaringType.FullName == mtDescr.DeclaringType)
+            };
+            var orderedCmds = beforeInstruction ? cmds.Concat(sourceCmd) : sourceCmd.Concat(cmds);
+            Assert.True(proc.Body.Instructions.Ordered(orderedCmds.ToArray()));
         }
 
         [Theory]

diff --git a/AutoFake.UnitTests/Setup/InsertMockTests.cs b/AutoFake.UnitTests/Setup/InsertMockTests.cs
@@ -1,6 +1,4 @@
-using System;
-using AutoFake.Setup;
-using Mono.Cecil;
+using AutoFake.Setup;
 using Mono.Cecil.Cil;
 using Moq;
 using Xunit;
@@ -20,7 +18,7 @@ internal void IsSourceInstruction_Instruction_Success(InsertMock.Location locati
             method.Instructions.Add(firstInstruction);
             method.Instructions.Add(lastInstruction);
 
-            var mock = new InsertMock(() => { }, location);
+            var mock = new InsertMock(null, location);
 
             Assert.True(mock.IsSourceInstruction(null, method, shouldBeFirst ? firstInstruction : lastInstruction));
             Assert.False(mock.IsSourceInstruction(null, method, shouldBeFirst ? lastInstruction : firstInstruction));
@@ -30,18 +28,18 @@ internal void IsSourceInstruction_Instruction_Success(InsertMock.Location locati
         public void Inject_Instruction_Injected()
         {
             var mocker = new Mock<IMethodMocker>();
-            var mock = new InsertMock(() => { }, InsertMock.Location.Top);
+            var mock = new InsertMock(null, InsertMock.Location.Top);
             var cmd = Instruction.Create(OpCodes.Nop);
 
             mock.Inject(mocker.Object, null, cmd);
 
-            mocker.Verify(m => m.InjectCallback(null, cmd, It.IsAny<MethodDescriptor>()));
+            mocker.Verify(m => m.InjectCallback(null, cmd, It.IsAny<MethodDescriptor>(), true));
         }
 
         [Fact]
         public void Initialize_GeneratedType_Nothing()
         {
-            var mock = new InsertMock(() => { }, InsertMock.Location.Top);
+            var mock = new InsertMock(null, InsertMock.Location.Top);
 
             var parameters = mock.Initialize(null, null);
 

diff --git a/AutoFake.UnitTests/Setup/SourceConstructorTests.cs b/AutoFake.UnitTests/Setup/SourceConstructorTests.cs