Release 2.0.0 (#19)

* Move `DiagnosticRegistry` to `TestsHelper.SourceGenerator.Diagnostics` namespace

* Remove Attribute Requirements to parent class

* Remove obsolete `ClassPartialImplementation`

* Remove Unused Constructor

* Add README to misc folder

* Update README

* Remove Comment From Test

* Feature/setup method for mocks (#13)

* Store `ITypeSymbol` and rename `Name` to `ParameterName`

* Add Syntax Extensions Methods

* Use Syntax Extension methods

* Implement Setup Method Generation

* Change Samples And Test Sources To Use The Setup Method Generation

* Implement void support

* Moved models into `Models` Namespace

* Create WorkingClassInfo

* Move setting SelectedConstructor in SetClass

* Extracted Logics Outside `SyntaxTreeMockedFilledPartialClassCreator`

* Make `AttributeHelpers` to work with attribute full string string along type

* Move Cyber Logics Into A Project And Created An Attribute For GenerateMockWrappers

* Mark ClassToFillMockIn is it needs have GenerateMockWrappers attribute

* Remove String Cyber Code, Change Implementation to be optional

* fix test after generate mocks wrapper is optional, add test to cover this

* Use GenerateMockWrappers In Sample.Tests

* Update README

* Use Syntax Extension In `MockGenerator`

* Extracted `SetupMethodResult` to another file

* use named argument

* remove pipeline on pull_request

* add build badge to README

* Rename `WrapMockMethodResult`

* Rename `WrappingMockMethodCreator`

* Implemented Verify Creation, add to tests and add it Sample.Tests

* Update README about verify

* fix typo in README.md

* Udpdate Dev With Master (#17)

* Rename `MockFillerOutput` to `FileResult`

* Remove Field Declaration From GeneratedMock.cs

* Add Syntax Extensions

* Add `TypeMockResult` as the result for class type wrapper

* Make `IMockedFilledPartialClassCreator` `Build()` return multiple file result instead of one

* Fixed To Use Multiple Files

* `BuildMethodCreator` : Use `TypeMockResult` and new syntax extensions

* Implement Type Wrapping in `TypeMockWrapperCreator` and deleted the old wrapping method class

* Use New Type Mock Wrapping and return multiple files

* Update Sample.Tests to use new interface

* Update Test To the new interface

* Remove unused `WrapMockMethodResult`

* Do Not Create Method Wrapper Class When `createMockWrapperMethod` is false and fixed tests

* Used `typeMockResult.Namespace` to import wrapper class

* Replace `MockProperty` with `MockPropertyName`

* Rename `CreateExpressionLambda()` to `CreateMoqExpressionLambda()`

* suppress field not initialized

* remove unsued field

* Rename `_Value` to `ActualValue` and make the ctor private

* Removed Unused usings

* Format `Test`

* Now Using the non incremental generator

* Updated README with the new interface

* Put Some emojis in README

* Split Example Code in README

* Change Case of examples links

* Add Cyber Testing Project

* Add Expression Comparing From GitHub

* Refactor `ExpressionComparison` and make it assert instead of boolean

* Add Test To `Cyber` clas

* Incremented Version To `2.0.0`

Author: YarinOmesi

README.md

@@ -1,48 +1,54 @@
-# Mock Filler
+# Mock Filler :star:
 [![Build](https://github.com/YarinOmesi/MockFiller/actions/workflows/CI.yml/badge.svg)](https://github.com/YarinOmesi/MockFiller/actions/workflows/CI.yml)
 
 Creating tested class instance with mocks!
 
-refer to [Test File Example](./Sample.Tests/Test.cs) to see an example
-and [Source Generator Tests](./TestsHelper.SourceGenerator.Tests/MockFillerSourceGeneratorTests.cs).
+Refer to [Test File Example](./Sample.Tests/Test.cs) to see an example,
+Or the tests [Source Generator Tests](./TestsHelper.SourceGenerator.Tests/MockFillerSourceGeneratorTests.cs).
 
 ## How To Use
 
 All you need to do is to mark your test fixture class as `partial`.
 
 Create field of the desired tested class and mark it with attribute `[FillMocks]`.
 
-The Source Generator will fill mocks field and create a `Build()` method to create the instance.
+The Source Generator will Create **a field for each mocked parameters with the same name**, and create a `Build()` method to create the instance. 
 
 ### Features
 
 #### FillMocks
 
 To Fill Mocks for given tested class, create a field for that class and mark it with `[FillMocks]`
+```csharp
+[FillMocks]
+private TestedClass _testedClass;
+```
+
+To access a mock of parameter named `loggerFactory`
+```csharp
+_loggerFactory.Mock // Mock<ILoggerFactory>
+```
 
 #### Default Value
 
 To declare a default value instead of creating a mock, create a field with name as following:
 
 defaultValue[Constructor Parameter Name]
 
-> you can add underscore and change the casing
-
-##### Demonstration
+> :exclamation: Be aware that default value is case insensitive
 
+To set a default value for parameter named `factory`
 ```csharp
 private ILoggerFactory _defaultValueFactory = NullLoggerFactory.Instance;
 ```
 
-#### Generate Mock Wrappers
+#### Generate Mock Wrappers :crystal_ball:
 
-By marking the test fixture cass with `[TestsHelper.SourceGenerator.MockWrapping.GenerateMockWrappers]` attribute,
-it will generate mock wrappers.
+Generate Mock Wrappers By marking the class with `[TestsHelper.SourceGenerator.MockWrapping.GenerateMockWrappers]` attribute.
 
-A Setup and verify methods will be generated for each public method of dependencies.
+The mocked parameter **field will have a property for each public method** in the mocked type. 
 
-Setup method name template `Setup_<ParameterName>_<MethodName>()`
-Verify method name template `Verify_<ParameterName>_<MethodName>()`
+A `Setup` and `Verify` methods will be generated for each public method of the mocked type.
 
 ##### Demonstration
 
@@ -62,35 +68,31 @@ you can do this
 ```csharp
 /* -- Setup -- */ 
 // Default parameter is Any
-Setup_dependency_MakeString(name:"Yarin")
+_dependency.MakeString.Setup(name:"Yarin")
     .Returns<int>(n=> n.ToString());
 
 // Any Not Implicitly assumed
-Setup_dependency_MakeString(Value<int>.Any,"Yarin")
+_dependency.MakeString.Setup(Value<int>.Any, "Yarin")
     .Returns<int>(n=> n.ToString());
 
 /* -- Verify -- */
-Setup_dependency_MakeString(Value<int>.Any,"Yarin", Times.Once())
+_dependency.MakeString.Verify(Value<int>.Any, "Yarin", Times.Once())
 ```
 
 ### Example
 
 For This Code
 
 ```csharp
-// Class Being Tested
 public class TestedClass
 {
     private IDependency _dependency;
     private ILogger _logger;
 
-    public TestedClass(IDependency dependency, ILoggerFactory factory)
-    {
-        /* Code */    
-    }
+    public TestedClass(IDependency dependency, ILoggerFactory factory) // c'tor
 }
-
-// Test Fixture class
+```
+```csharp
 public partial class Test
 {
     [FillMocks]
@@ -104,15 +106,18 @@ The Generated Code Will Be
 
 ```csharp
 public partial class Test
-{
-    private Mock<IDependency> _dependencyMock;
-    private Mock<ILoggerFactory> _factoryMock;
-    
-    private TestedClass Build()
     {
-        _dependencyMock = new Mock<IDependency>();
-        _factoryMock = new Mock<ILoggerFactory>();
-        return new TestedClass(_dependencyMock.Object, _factoryMock.Object);
+        private Wrapper_IDependency _dependency;
+        private Wrapper_ILoggerFactory _factory;
+
+        private TestedClass Build()
+        {
+            _dependency = new Wrapper_IDependency(new Mock<IDependency>());
+            _factory = new Wrapper_ILoggerFactory(new Mock<ILoggerFactory>());
+            return new TestedClass(_dependency.Mock.Object, _factory.Mock.Object);
+        }
     }
-}
 ```
+Example of Wrapper class with `[GenerateMockWrappers]` attribute [IDependency with wrappers](./TestsHelper.SourceGenerator.Tests/Sources/Wrapper.IDependency.WithWrappers.generated.cs)
+
+Example of Wrapper class without mocked wrappers  [IDependency without wrappers](./TestsHelper.SourceGenerator.Tests/Sources/Wrapper.IDependency.generated.cs)

Sample.Tests/Test.cs

@@ -11,10 +11,9 @@ namespace Sample.Tests;
 [TestFixture]
 public partial class Test
 {
-    [FillMocks]
-    private TestedClass _testedClass;
+    [FillMocks] 
+    private TestedClass _testedClass = null!;
 
-    
     private readonly ILoggerFactory _defaultValueFactory = NullLoggerFactory.Instance;
 
     [SetUp]
@@ -29,15 +28,14 @@ public void Setup_WithoutWrapper()
         // Arrange
         int numbrer = 1;
 
-
-        _dependencyMock.Setup(dependency => dependency.MakeString(It.IsAny<int>()))
+        _dependency.Mock.Setup(dependency => dependency.MakeString(It.IsAny<int>()))
             .Returns<int>((number) => number.ToString());
 
         // Act
         string result = _testedClass.VeryComplicatedLogic(numbrer);
 
         // Assert
-        _dependencyMock.Verify(dependency => dependency.MakeString(2), Times.Once);
+        _dependency.Mock.Verify(dependency => dependency.MakeString(2), Times.Once);
         Assert.That(result, Is.EqualTo("2"));
     }
 
@@ -47,15 +45,14 @@ public void Setup_WithWrapper()
         // Arrange
         int number = 1;
 
-
-        Setup_dependency_MakeString()
+        _dependency.MakeString.Setup()
             .Returns<int>(n => n.ToString());
 
         // Act
         string result = _testedClass.VeryComplicatedLogic(number);
 
         // Assert
-        Verify_dependency_MakeString(2, Times.Once());
+        _dependency.MakeString.Verify(2, Times.Once());
         Assert.That(result, Is.EqualTo("2"));
     }
 }

TestsHelper.SourceGenerator.MockWrapping.Tests/CyberTests.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using Moq;
+using NUnit.Framework;
+using TestsHelper.SourceGenerator.MockWrapping.Tests.Expressions;
+
+namespace TestsHelper.SourceGenerator.MockWrapping.Tests;
+
+[TestFixture]
+public class CyberTests
+{
+    private ExpressionComparison _expressionComparison = null!;
+
+    [OneTimeSetUp]
+    public void Setup()
+    {
+        _expressionComparison = new ExpressionComparison();
+    }
+
+    [Test]
+    public void CreateExpressionFor_GivenAnyValue_CallItAny()
+    {
+        // Arrange
+        Value<int> anyValue = Value<int>.Any;
+        var expectedMethodCallExpression = GetLambdaBody<MethodCallExpression>(() => It.IsAny<int>());
+
+        // Act
+        Expression actualExpression = Cyber.CreateExpressionFor(anyValue);
+
+        // Assert
+        _expressionComparison.AssertEquals(actualExpression, expectedMethodCallExpression);
+    }
+
+    [Test]
+    public void CreateExpressionFor_GivenValue_CallItIs()
+    {
+        // Arrange
+        Value<int> value = 5;
+        var expectedMethodCallExpression = GetLambdaBody<MethodCallExpression>(() => It.Is(5, EqualityComparer<int>.Default));
+
+        // Act
+        Expression actualExpression = Cyber.CreateExpressionFor(value);
+
+        // Assert
+        _expressionComparison.AssertEquals(actualExpression, expectedMethodCallExpression);
+    }
+
+    [Test]
+    public void UpdateExpressionWithParameters_OnAllParameterNull_PatchExpressionToUseItAny()
+    {
+        // Arrange
+        var arguments = new List<Expression> {
+            Cyber.CreateExpressionFor(Value<int>.Any),
+            Cyber.CreateExpressionFor(Value<string>.Any),
+        };
+        
+        Expression<Action> method = () => MockMethod(Cyber.Fill<int>(), Cyber.Fill<string>());
+        Expression<Action> expectedExpression = () => MockMethod(It.IsAny<int>(), It.IsAny<string>());
+        
+        // Act
+        Expression<Action> patchedExpression = Cyber.UpdateExpressionWithParameters(method, arguments);
+
+        // Assert
+        _expressionComparison.AssertEquals(patchedExpression, expectedExpression);
+    } 
+    
+    [Test]
+    public void UpdateExpressionWithParameters_OnSomeAnyAndValue_PatchExpressionToUseItAnyOrItIs()
+    {
+        // Arrange
+        var arguments = new List<Expression> {
+            Cyber.CreateExpressionFor<int>(10),
+            Cyber.CreateExpressionFor(Value<string>.Any),
+        };
+        
+        Expression<Action> method = () => MockMethod(Cyber.Fill<int>(), Cyber.Fill<string>());
+        Expression<Action> expectedExpression = () => MockMethod(It.Is(10, EqualityComparer<int>.Default), It.IsAny<string>());
+        
+        // Act
+        Expression<Action> patchedExpression = Cyber.UpdateExpressionWithParameters(method, arguments);
+
+        // Assert
+        _expressionComparison.AssertEquals(patchedExpression, expectedExpression);
+    }
+
+    private void MockMethod(int age, string name)
+    {
+        
+    }
+
+    private static T GetLambdaBody<T>(Expression<Action> expression) where T : Expression => (T) expression.Body;
+}