public override MocksRepository ResolveRepository(UnresolvedContextBehavior unresolvedContextBehavior) { lock (this.repositorySync) { var testMethod = this.GetTestMethod(); if (testMethod != null) { return(repositories[testMethod.DeclaringType]); } if (unresolvedContextBehavior == UnresolvedContextBehavior.DoNotCreateNew) { return(null); } var stackTrace = new StackTrace(); var frames = stackTrace.EnumerateFrames().ToList(); var caller = frames.FirstOrDefault(method => method.Module.Assembly != typeof(MocksRepository).Assembly); var mspecTestClass = caller.DeclaringType; MocksRepository parentRepo; repositories.TryGetValue(mspecTestClass.BaseType, out parentRepo); var repo = new MocksRepository(parentRepo, caller); repositories.Add(mspecTestClass, repo); return(repo); } }
public static MocksRepository ResolveRepository(UnresolvedContextBehavior unresolvedContextBehavior) { var stackTrace = new StackTrace(); MethodBase callingMethodOutsideJustmock = null; foreach (var method in stackTrace.EnumerateFrames()) { if (contextMethod == method) { return(contextRepository); } if (callingMethodOutsideJustmock == null && method.Module.Assembly != typeof(MocksRepository).Assembly) { callingMethodOutsideJustmock = method; } } if (callingMethodOutsideJustmock != null && unresolvedContextBehavior == UnresolvedContextBehavior.CreateNewContextualOrLocal) { // don't reset the old repository - because the mocks created from it may still be used, e.g. if the method // associated with ResolveRepository works as a factory for mocks which are then exercised elsewhere contextMethod = callingMethodOutsideJustmock; contextRepository = new MocksRepository(null, contextMethod); return(contextRepository); } return(null); }
private bool MustReturnMock(Invocation invocation, bool checkPropertyOnTestFixture = false) { if (checkPropertyOnTestFixture) { #if !LITE_EDITION var stackTrace = new StackTrace(); var methodCallingArrange = stackTrace.EnumerateFrames() .SkipWhile(m => !Attribute.IsDefined(m, typeof(ArrangeMethodAttribute))) .SkipWhile(m => m.Module.Assembly == typeof(MocksRepository).Assembly) .FirstOrDefault(); if (methodCallingArrange != null && invocation.Method.DeclaringType.IsAssignableFrom(methodCallingArrange.DeclaringType)) { return(false); } #endif } // mock invocations in static constructors according to the behavior if (invocation.InRunClassConstructor) { return(invocation.InArrange && !invocation.CallOriginal); } return(invocation.InArrange && !invocation.InArrangeArgMatching || this.type == RecursiveMockingBehaviorType.ReturnMock); }
public override MethodBase GetTestMethod() { var stackTrace = new StackTrace(); var frames = stackTrace.EnumerateFrames().ToList(); var testMethod = this.FindExistingTestMethod(frames); return(testMethod); }
public static void RetireRepository() { var stackTrace = new StackTrace(); if (stackTrace.EnumerateFrames().Contains(contextMethod)) { contextRepository.Retire(); contextMethod = null; contextRepository = null; } }
private MethodBase FindTestMethod(out int repoIdx, out RepositoryOperationsBase entryOps) { var stackTrace = new StackTrace(); var q = from method in stackTrace.EnumerateFrames() where repoOperations.Any(repo => repo.MatchesMethod(method)) select method; var allTestMethods = q.Distinct().ToArray(); if (allTestMethods.Length > 1) { var message = "Calling one test method from another could result in unexpected behavior and must be avoided. Extract common mocking logic to a non-test method. At:\n" + stackTrace; DebugView.DebugTrace(message); } var testMethod = allTestMethods.FirstOrDefault(); if (testMethod != null) { var disableAttr = Attribute.GetCustomAttribute(testMethod, typeof(DisableAutomaticRepositoryResetAttribute)) as DisableAutomaticRepositoryResetAttribute; if (disableAttr != null && ProfilerInterceptor.IsProfilerAttached && !disableAttr.AllowMocking) { throw new MockException("Using the mocking API in a test method decorated with DisableAutomaticRepositoryResetAttribute is unsafe. Read the documentation of the DisableAutomaticRepositoryResetAttribute class for further information and possible solutions."); } } repoIdx = 0; entryOps = null; if (testMethod != null) { for (repoIdx = 0; repoIdx < this.repoOperations.Count; ++repoIdx) { var ops = this.repoOperations[repoIdx]; if (ops.MatchesMethod(testMethod)) { entryOps = ops; break; } } Debug.Assert(entryOps != null); } return(testMethod); }
public override bool RetireRepository() { var stackTrace = new StackTrace(); var testMethod = FindExistingTestMethod(stackTrace.EnumerateFrames()); if (testMethod == null) { return(false); } var key = testMethod.DeclaringType; var repo = repositories[key]; repositories.Remove(key); repo.Retire(); return(true); }
public override MethodBase GetTestMethod() { var stackTrace = new StackTrace(); var q = from method in stackTrace.EnumerateFrames() where repoOperations.Any(repo => repo.MatchesMethod(method)) select method; var allTestMethods = q.Distinct().ToArray(); if (allTestMethods.Length > 1) { string message = "Calling one test method from another could result in unexpected behavior and must be avoided. Extract common mocking logic to a non-test method. At:\n" + stackTrace; DebugView.DebugTrace(message); } MethodBase testMethod = allTestMethods.FirstOrDefault(); return(testMethod); }
private MethodBase FindTestMethod(out int repoIdx, out RepositoryOperationsBase entryOps) { var stackTrace = new StackTrace(); var q = from method in stackTrace.EnumerateFrames() where repoOperations.Any(repo => repo.MatchesMethod(method)) select method; var testMethod = q.FirstOrDefault(); if (testMethod != null) { var disableAttr = Attribute.GetCustomAttribute(testMethod, typeof(DisableAutomaticRepositoryResetAttribute)) as DisableAutomaticRepositoryResetAttribute; if (disableAttr != null && ProfilerInterceptor.IsProfilerAttached && !disableAttr.AllowMocking) { throw new MockException("Using the mocking API in a test method decorated with DisableAutomaticRepositoryResetAttribute is unsafe. Read the documentation of the DisableAutomaticRepositoryResetAttribute class for further information and possible solutions."); } } repoIdx = 0; entryOps = null; if (testMethod != null) { for (repoIdx = 0; repoIdx < this.repoOperations.Count; ++repoIdx) { var ops = this.repoOperations[repoIdx]; if (ops.MatchesMethod(testMethod)) { entryOps = ops; break; } } Debug.Assert(entryOps != null); } return(testMethod); }
public void Process(Invocation invocation) { if (invocation.IsReturnValueSet) { return; } var returnType = invocation.Method.GetReturnType(); if (returnType == typeof(void) || returnType.IsValueType) { return; } if (invocation.Method.Name == "ToString" && invocation.Method.GetParameters().Length == 0 && invocation.UserProvidedImplementation) { return; } object mock = null; List <KeyValuePair <object, object> > mocksList; if (mocks.TryGetValue(invocation.Method, out mocksList)) { // can't put the key part in a Dictionary, // because we can't be sure that GetHashCode() works mock = mocksList.FirstOrDefault(kvp => Equals(kvp.Key, invocation.Instance)).Value; } if (mock == null) { var parentMock = MocksRepository.GetMockMixinFromInvocation(invocation); var repository = parentMock.Repository; var replicator = parentMock as IMockReplicator; bool mustReturnAMock = invocation.InArrange || this.type == RecursiveMockingBehaviorType.ReturnMock; if (mustReturnAMock || this.type == RecursiveMockingBehaviorType.ReturnDefault) { if (returnType.IsArray) { mock = Array.CreateInstance(returnType.GetElementType(), Enumerable.Repeat(0, returnType.GetArrayRank()).ToArray()); } var idictionaryType = returnType.GetImplementationOfGenericInterface(typeof(IDictionary <,>)); if (mock == null && idictionaryType != null) { var dictType = typeof(Dictionary <,>).MakeGenericType(idictionaryType.GetGenericArguments()); mock = MockCollection.Create(returnType, repository, replicator, (IEnumerable)MockingUtil.CreateInstance(dictType)); } var ienumerableType = returnType.GetImplementationOfGenericInterface(typeof(IEnumerable <>)); if (mock == null && ienumerableType != null) { var listType = typeof(List <>).MakeGenericType(ienumerableType.GetGenericArguments()); mock = MockCollection.Create(returnType, repository, replicator, (IEnumerable)MockingUtil.CreateInstance(listType)); } if (mock == null && mustReturnAMock) { #if !LITE_EDITION var stackTrace = new StackTrace(); var methodCallingArrange = stackTrace.EnumerateFrames() .SkipWhile(m => !Attribute.IsDefined(m, typeof(ArrangeMethodAttribute))) .SkipWhile(m => m.Module.Assembly == typeof(MocksRepository).Assembly) .FirstOrDefault(); if (methodCallingArrange != null && invocation.Method.DeclaringType.IsAssignableFrom(methodCallingArrange.DeclaringType)) { return; } #endif if (typeof(String) == returnType) { mock = String.Empty; } else { try { mock = replicator.CreateSimilarMock(repository, returnType, null, true, null); } catch (MockException) { } } } } if (mock == null) { return; } if (mocksList == null) { mocksList = new List <KeyValuePair <object, object> >(); mocks.Add(invocation.Method, mocksList); } mocksList.Add(new KeyValuePair <object, object>(invocation.Instance, mock)); var mockMixin = MocksRepository.GetMockMixin(mock, null); if (parentMock != null && mockMixin != null) { parentMock.DependentMocks.Add(mock); } } invocation.ReturnValue = mock; invocation.CallOriginal = false; invocation.UserProvidedImplementation = true; }