private static async Task LockShouldBeReleasedWhenCallThrowsException <T>( ILockAssertions lockAssertions, T wrappingObject, T wrappedObjectMock, Func <T, Task> callToCheck) where T : class { try { wrappedObjectMock.When(callToCheck).Throw(_ => { lockAssertions.AssertLocked(); return(new LockNotReleasedWhenExceptionOccurs()); }); await callToCheck(wrappingObject); throw new Exception( // todo more specific exception "The specified method was probably not called by the proxy with exactly the same arguments it received"); } catch { lockAssertions.AssertUnlocked(); } finally { wrappedObjectMock.ClearReceivedCalls(); } }
private static void LockShouldBeReleasedAfterACall <T, TReturn>( T wrappingObject, T wrappedObjectMock, Func <T, TReturn> callToCheck, ILockAssertions lockAssertions) where T : class { try { Func <TReturn> instance = Root.Any.Instance <TReturn>; var cannedResult = instance(); callToCheck(wrappedObjectMock).Returns(ci => { lockAssertions.AssertLocked(); return(cannedResult); }); lockAssertions.AssertUnlocked(); var actualResult = callToCheck(wrappingObject); lockAssertions.AssertUnlocked(); actualResult.Should().Be( cannedResult, "{0}", "The specified method was probably not called by the proxy with exactly the same arguments it received or it did not return the value obtained from wrapped call"); } finally { wrappedObjectMock.ClearReceivedCalls(); } }
//bug add also for reference type assertions public static async Task SynchronizeAsyncAccessTo <T>( this ObjectAssertions assertions, Func <T, Task> callToCheck, ILockAssertions lockAssertions, T wrappedObjectMock) where T : class { await SynchronizationAssertions.SynchronizesAsync( (T)assertions.Subject, callToCheck, lockAssertions, wrappedObjectMock); }
public static void SynchronizeAccessTo <T>( this ObjectAssertions assertions, Action <T> callToCheck, ILockAssertions lockAssertions, T wrappedObjectMock) where T : class { SynchronizationAssertions.Synchronizes( (T)assertions.Subject, callToCheck, lockAssertions, wrappedObjectMock); }
public static void SynchronizeAccessTo <T, TAssertions>( this ReferenceTypeAssertions <T, TAssertions> assertions, Action <T> callToCheck, ILockAssertions lockAssertions, T wrappedObjectMock) where T : class where TAssertions : ReferenceTypeAssertions <T, TAssertions> { SynchronizationAssertions.Synchronizes( assertions.Subject, callToCheck, lockAssertions, wrappedObjectMock); }
private static void LockShouldBeReleasedAfterACall <T>( T wrappingObject, T wrappedObjectMock, Action <T> callToCheck, ILockAssertions lockAssertions) where T : class { try { wrappedObjectMock.When(callToCheck).Do(_ => lockAssertions.AssertLocked()); lockAssertions.AssertUnlocked(); callToCheck(wrappingObject); lockAssertions.AssertUnlocked(); callToCheck(wrappedObjectMock.Received(1)); } finally { wrappedObjectMock.ClearReceivedCalls(); } }
private static async Task LockShouldBeReleasedAfterACall <T>( T wrappingObject, T wrappedObjectMock, Func <T, Task> callToCheck, ILockAssertions lockAssertions) where T : class { try { callToCheck(wrappedObjectMock).Returns(async ci => { lockAssertions.AssertLocked(); }); lockAssertions.AssertUnlocked(); await callToCheck(wrappingObject); lockAssertions.AssertUnlocked(); } finally { wrappedObjectMock.ClearReceivedCalls(); } }
public static async Task SynchronizesAsync <T>(T wrappingObject, Func <T, Task> callToCheck, ILockAssertions lockAssertions, T wrappedObjectMock) where T : class { NSubstituteIsInCorrectVersion(wrappedObjectMock); await LockShouldBeReleasedAfterACall(wrappingObject, wrappedObjectMock, callToCheck, lockAssertions); await LockShouldBeReleasedWhenCallThrowsException(lockAssertions, wrappingObject, wrappedObjectMock, t => callToCheck(t)); }
public static void Synchronizes <T>(T wrappingObject, Action <T> callToCheck, ILockAssertions lockAssertions, T wrappedObjectMock) where T : class { NSubstituteIsInCorrectVersion(wrappedObjectMock); LockShouldBeReleasedAfterACall(wrappingObject, wrappedObjectMock, callToCheck, lockAssertions); LockShouldBeReleasedWhenCallThrowsException(lockAssertions, wrappingObject, wrappedObjectMock, callToCheck); }