serg046 / autofake

Mock any type members including static and non-virtual ones

autofake's Issues

Add supporting for type fields

Refactoring of unit tests

Extract all initializations to constructor (SetUp) when possible

Add dotnetfiddle playground in ReadMe

If installed method has a return value (not void) Returns() must be calles

Add integration test for 'params object[]' method

Fake for current type (this.GetType()) cannot be executed

Execution method arguments along configured return values

Callback fuctionality

Unload fake's assembly after the test is done

Possibly a separate domain is required. If so MarshalByRefObject or some serialization mechanism (binarryformatter, protobuf, serializable, NFX) needs to be implemented

Possibility to test race condition

Provide functionality to inject the code to the top of method

[Blocked] Update StateTests with dynamic instance when it will be available

Waiting for jbevain/cecil#300

Apply a mock in scope of fake's type

Support two modes:

1. Existing mode. Scan all referenced methods of fake's module.
2. Add mode to scan only methods in fake's type (public/private). It should improve performance. Make it as default mode.

Add support internal members to TypeWrapper

Please uncomment FakeTests.Execute_Fake_CallbackExecuted as well

Possibility to use methods returning value of type from the fake's assembly

Since there is no way to cast type A from fake's assembly to type A from the current assembly, some new lambda based methods should be provided. Execute(Action<T> action) can be introduced as alternative to T Execute().

Roslyn analyzer to check if there is possibility to avoid AutoFake and use classic library

Roslyn diagnostic to check whether provided ctror's arguments meet contract or not

Add tests for verification functionality under params methods

Get rid of GeneratedObject.IsBuilt property

Ability to execute instance members under non-generic fake (Execute/GetStateValue/SetStateValue)

Avoid separate AppDomains when .NET Core 3+ is in use

Starting from .NET Core 3 we have assembly unloading supported

Mock of indexer (type of property)

ExpectedCalls(int) implementation

Currently only ExpectedCalls(Func<int, bool>) is supported. Please add support for ExpectedCalls(int) too. The thing is that we cannot simply use something like this:

ExpectedCalls(int number) => ExpectedCalls(x => x == number);

Because that code works only on the client side and cannot be placed inside the library as is.

Overloaded methods do not work

Mock two methods with same name with different return values

Add supporting for ldflda field-access instruction

Setting return value based on runtime method arguments or mock instance

Imagine you have the following type:

class SomeType
{
    public SomeType(int someProp) => SomeProp = someProp;
    public int SomeProp { get; }
    public int GetSomeProp(int arg) => SomeProp + arg;
    public SomeMethod(int arg) => Console.WriteLine(GetSomeProp(arg));
}

You might want to do something like this:

var fake = new Fake<SomeType>(5);
sut.Replace(f => f.GetSomeProp(3))
       .If((SomeType instance, object[] arguments) => instance.SomeProp > 0 && arguments.Single() is uint)
       .Return(-1);
sut.Replace(f => f.GetSomeProp(3))
       .If((SomeType instance, object[] arguments) => instance.SomeProp == 2 && !(arguments.Single() is uint))
       .Return(0);

Avoid installing the test method as mock (Recursion issue)

Types from different assemblies should work correctly

1. Create Type1 in assembly1 and Type2 in assembly2 as dependency of Type1.
2. Make fake for Type1 and mock anything of Type2
3. Check that FakeGenerator have access to assembly2 and correctly replace mocked member of Type2.
4. Modify Type2 as internal and add InternalsVisibleToAttribute to assembly1.
5. Check step 3. again.

Cover all branches of the code and switch to TDD

Avoid to install local variables

Verifiable and ExpectedCallsCount functionality must work only on the real execution way

void SomeMethod(int someVal)
{
    return someVal > 0 ? GetVal(someVal) : GetVal(0);
}

In this sample we need always get 1 as actual calls count of GetVal but now it is 2.
And if we setup 0 as verifiable argument of GetVal we need to have successful verification if SomeMethod is called with someVal <= 0, otherwise failed verification.

Check that types inside the fake are converted to source assembly before execution

Look for boxing operations, try to replace by generic tricks etc

Add ability to check argument by lamda (like It.Is<T>() from Moq)

Avoid installing the same method twice

Add verify functionality without method replacement

Support generic classes and methods

Null as installed method argument throws Exception

Async methods do not work

Unexpected StackOverflowException

See commented InsertTests.TestClass.Numbers property.
To reproduce, uncomment and use instead of the field

NullReferenceException when try to setup new DateTime() as argument of setup method

Add Regenerate() method

Since 'Execute()' method runs regeneration of the fake type, it should be indicated.
It needs to introduce a new method and force to use it before the second execution of 'Execute'.

Create or find TypeSwitcher (pattern-matching) and replace "is" operators.

If c# 7 is available use pattern-matching of c# 7

Mock of type constructor

Add ability to mock type constructor because it can run some undesirable actions like database access and so on.

Improve IsAsyncMethod

Try to create AsyncStateMachineAttribute right in the project with the proper namespace

Possibility to rewrite multiple fake members

FrameworkInstanceTest for field

Get rid of GetMonoCecilTypeName/GetClrName

• Extensions.EquivalentTo

public TypeReference GetType(string fullName, bool runtimeName)
    {
      return !runtimeName ? (TypeReference) this.GetType(fullName) : TypeParser.ParseType(this, fullName);
    }

GetStateValue should not have ability to run installed members

Force a separate AppDomain when there is a Dispose() call

We use the same AppDomain by defaut. It doesn't allow to unload the generated lib so that we cannot unload it. Please generate an exception if the fake is configured so that it is impossible to place the lib to a seaprate AppDomain.

Mock for struct's default constructor

It cannot be found by reflection. So it needs to find another way or throw an exception.