private ICallSpecification UpdateCallSpecToMatchAnyArgs(ICallSpecification callSpecification) { var anyArgCallSpec = callSpecification.CreateCopyThatMatchesAnyArguments(); _callActions.MoveActionsForSpecToNewSpec(callSpecification, anyArgCallSpec); return(anyArgCallSpec); }
public void MoveActionsForSpecToNewSpec(ICallSpecification oldCallSpecification, ICallSpecification newCallSpecification) { foreach (var action in _actions.Where(x => x.IsFor(oldCallSpecification))) { action.UpdateCallSpecification(newCallSpecification); } }
public override void Context() { base.Context(); _initialCallSpec = CreateMatchingCallSpec(); _newSpec = CreateMatchingCallSpec(); _callMatchingInitialSpec = mock <Action <CallInfo> >(); }
public override void Context() { base.Context(); _callSpecification = mock <ICallSpecification>(); _relatedCalls = new ICall[0]; _descriptionOfCall = _callSpecification.ToString(); }
private string DescribeNonMatches(ICall call, ICallSpecification callSpecification) { var nonMatches = callSpecification.NonMatchingArguments(call) ?? new ArgumentMatchInfo[0]; var nonMatchingArgDescriptions = nonMatches.Select(x => x.DescribeNonMatch()).Where(x => !string.IsNullOrEmpty(x)).ToArray(); return(string.Join("\n", nonMatchingArgDescriptions)); }
public override void Context() { base.Context(); _lastCallSpecification = mock <ICallSpecification>(); _pendingSpecification.stub(x => x.HasPendingCallSpec()).Return(true); _pendingSpecification.stub(x => x.UseCallSpec()).Return(_lastCallSpecification); }
public void ShouldHaveBeenToldToThrowWith(ICallSpecification callSpecification, IEnumerable <ICall> matchingCalls, IEnumerable <ICall> nonMatchingCalls, Quantity requiredQuantity) { Assert.That(_callSpecification, Is.EqualTo(callSpecification)); Assert.That(_matchingCalls.ToArray(), Is.EquivalentTo(matchingCalls.ToArray())); Assert.That(_nonMatchingCalls.ToArray(), Is.EquivalentTo(nonMatchingCalls.ToArray())); Assert.That(_requiredQuantity, Is.EqualTo(requiredQuantity)); }
public ICallSpecification UseCallSpec() { var specToUse = _pendingSpec; _pendingSpec = null; return(specToUse); }
private void AddArgumentSpecsToCallSpec(ICallSpecification callSpec, IEnumerable<IArgumentSpecification> argSpecs) { foreach (var spec in argSpecs) { callSpec.ArgumentSpecifications.Add(spec); } }
public void AddToQuery(object target, ICallSpecification callSpecification) { // We cannot simulate the API anymore as it changed drastically. // That should be fine, as this method was expected to be called from the NSubstitute core only. throw new NotSupportedException( "This API was obsolete and is not supported anymore. " + "Please Use the " + nameof(ThreadContext) + "." + nameof(IThreadLocalContext.RegisterInContextQuery) + "() method instead."); }
private static void CheckResultIsCompatibleWithCall(IReturn valueToReturn, ICallSpecification spec) { var requiredReturnType = spec.ReturnType(); if (!valueToReturn.CanBeAssignedTo(requiredReturnType)) { throw new CouldNotSetReturnDueToTypeMismatchException(valueToReturn.TypeOrNull(), spec.GetMethodInfo()); } }
public void Throw(ICallSpecification callSpecification, IEnumerable <ICall> matchingCalls, IEnumerable <ICall> nonMatchingCalls, Quantity requiredQuantity) { _wasCalled = true; _callSpecification = callSpecification; _matchingCalls = matchingCalls; _nonMatchingCalls = nonMatchingCalls; _requiredQuantity = requiredQuantity; }
/// <inheritdoc /> public void Exclude(ICallSpecification callSpecification) { if (callSpecification == null) { throw new ArgumentNullException(nameof(callSpecification)); } Rules.Enqueue(new CallBaseRule(callSpecification, callBase: false)); }
public override void Context() { _call = mock <ICall>(); _callSpec = mock <ICallSpecification>(); _callActions = mock <ICallActions>(); _pendingSpec = mock <IPendingSpecification>(); _callSpecFactory = mock <ICallSpecificationFactory>(); _callSpecFactory.stub(x => x.CreateFrom(_call, MatchArgs.AsSpecifiedInCall)).Return(_callSpec); }
public override void Context() { base.Context(); _callSpecForAnyArgs = mock <ICallSpecification>(); _lastCallSpecification = mock <ICallSpecification>(); _pendingSpecification.stub(x => x.HasPendingCallSpec()).Return(true); _pendingSpecification.stub(x => x.UseCallSpec()).Return(_lastCallSpecification); _lastCallSpecification.stub(x => x.CreateCopyThatMatchesAnyArguments()).Return(_callSpecForAnyArgs); }
/// <inheritdoc /> public void Exclude(ICallSpecification callSpecification) { if (callSpecification == null) { throw new ArgumentNullException(nameof(callSpecification)); } Exclusions.Enqueue(callSpecification); }
/// <inheritdoc /> public void Include(ICallSpecification callSpecification) { if (callSpecification == null) { throw new ArgumentNullException(nameof(callSpecification)); } Rules.Push(new CallBaseRule(callSpecification, callBase: true)); }
public void Add(ICallSpecification callSpecification, object target) { _querySpec.Add(new CallSpecAndTarget(callSpecification, target)); var allMatchingCallsOnTarget = target.ReceivedCalls().Where(callSpecification.IsSatisfiedBy); foreach (var matchingCall in allMatchingCallsOnTarget) { _matchingCalls.Add(matchingCall); } }
public override void Context() { base.Context(); _lastCallSpecification = mock <ICallSpecification>(); _pendingSpecification.stub(x => x.HasPendingCallSpecInfo()).Return(true); var specificationInfo = PendingSpecificationInfo.FromCallSpecification(_lastCallSpecification); _pendingSpecification.stub(x => x.UseCallSpecInfo()).Return(specificationInfo); }
public override void Context() { _callSpec = mock <ICallSpecification>(); _call = mock <ICall>(); _callSpecFactory = mock <ICallSpecificationFactory>(); _context = mock <ISubstitutionContext>(); _call.stub(x => x.Target()).Return(_target); _callSpecFactory.stub(x => x.CreateFrom(_call, MatchArgs.AsSpecifiedInCall)).Return(_callSpec); }
public override void Context() { base.Context(); _call = mock <ICall>(); _callStack.stub(x => x.Pop()).Return(_call); _pendingSpecification.stub(x => x.HasPendingCallSpec()).Return(false); _callSpecification = mock <ICallSpecification>(); _callSpecificationFactory.stub(x => x.CreateFrom(_call, _argMatchStrategy)).Return(_callSpecification); }
public void AddToQuery(object target, ICallSpecification callSpecification) { var query = _currentQuery.Value; if (query == null) { throw new NotRunningAQueryException(); } query.Add(callSpecification, target); }
public override void Context() { _context = mock <ISubstitutionContext>(); _receivedCalls = mock <IReceivedCalls>(); _call = mock <ICall>(); _callSpecFromCall = mock <ICallSpecification>(); _callSpecificationFactory = mock <ICallSpecificationFactory>(); _exceptionThrower = new FakeExceptionThrower(); _callSpecFromCall.stub(x => x.IsSatisfiedBy(_call)).Return(true); _callSpecificationFactory.stub(x => x.CreateFrom(_call, _argMatching)).Return(_callSpecFromCall); }
public override void Context() { _call = mock <ICall>(); _action = args => { }; _callActions = mock <ICallActions>(); _callSpec = mock <ICallSpecification>(); _matchArgs = MatchArgs.AsSpecifiedInCall; _callSpecificationFactory = mock <ICallSpecificationFactory>(); _callSpecificationFactory.stub(x => x.CreateFrom(_call, _matchArgs)).Return(_callSpec); }
private void WriteCallsWithRespectToCallSpec(ICallSpecification callSpecification, IEnumerable<ICall> relatedCalls, StringBuilder builder) { foreach (var call in relatedCalls) { builder.AppendFormat("\t{0}\n", callSpecification.Format(call)); var nonMatches = DescribeNonMatches(call, callSpecification).Trim(); if (!string.IsNullOrEmpty(nonMatches)) { builder.AppendFormat("\t\t{0}\n", nonMatches.Replace("\n", "\n\t\t")); } } }
private void WriteCallsWithRespectToCallSpec(ICallSpecification callSpecification, IEnumerable <ICall> relatedCalls, StringBuilder builder) { foreach (var call in relatedCalls) { builder.AppendFormat("\t{0}\n", callSpecification.Format(call)); var nonMatches = DescribeNonMatches(call, callSpecification).Trim(); if (!string.IsNullOrEmpty(nonMatches)) { builder.AppendFormat("\t\t{0}\n", nonMatches.Replace("\n", "\n\t\t")); } } }
public override void Context() { base.Context(); _firstMatchingCallSpec = CreateMatchingCallSpec(); _secondMatchingCallSpec = CreateMatchingCallSpec(); _nonMatchingCallSpec = mock <ICallSpecification>(); _firstMatchingAction = mock <Action <CallInfo> >(); _secondMatchingAction = mock <Action <CallInfo> >(); _nonMatchingAction = mock <Action <CallInfo> >(); }
public override void Context() { base.Context(); _call = mock <ICall>(); _callSpecification = mock <ICallSpecification>(); _callSpecification.stub(x => x.IsSatisfiedBy(_call)).Return(true); var callInfo = StubCallInfoForCall(_call); _resultToReturn = mock <IReturn>(); _resultToReturn.stub(x => x.ReturnFor(callInfo)).Return(_expectedResult); }
public override void Context() { base.Context(); _call = mock <ICall>(); _call.stub(x => x.GetReturnType()).Return(_type); _callResults = mock <ICallResults>(); _callSpecification = mock <ICallSpecification>(); _callSpecificationFactory = mock <ICallSpecificationFactory>(); _callSpecificationFactory.stub(x => x.CreateFrom(_call, MatchArgs.AsSpecifiedInCall)).Return(_callSpecification); _firstAutoValueProvider = mock <IAutoValueProvider>(); _secondAutoValueProvider = mock <IAutoValueProvider>(); }
private void AppendMatchingCalls(ICallSpecification callSpecification, IEnumerable<ICall> matchingCalls, StringBuilder builder) { var numberOfMatchingCalls = matchingCalls.Count(); if (numberOfMatchingCalls == 0) { builder.AppendLine("Actually received no matching calls."); } else { builder.AppendLine(string.Format("Actually received {0} matching {1}:", numberOfMatchingCalls, numberOfMatchingCalls == 1 ? "call" : "calls")); WriteCallsWithRespectToCallSpec(callSpecification, matchingCalls, builder); } }
/// <inheritdoc /> public void AddResult(ICallSpecification callSpecification, CallResultData result) { if (callSpecification == null) { throw new ArgumentNullException(nameof(callSpecification)); } if (result == null) { throw new ArgumentNullException(nameof(result)); } this.CallResults.Push(new ResultForCallSpec(callSpecification, result)); }
public override void Context() { base.Context(); _callSpecification = mock <ICallSpecification>(); _call = mock <ICall>(); _callSpecification.stub(x => x.IsSatisfiedBy(_call)).Return(true); var callInfo = StubCallInfoForCall(_call); _returnOriginalResult = mock <IReturn>(); _returnOriginalResult.stub(x => x.ReturnFor(callInfo)).Return(_originalResult); _returnOverriddenResult = mock <IReturn>(); _returnOverriddenResult.stub(x => x.ReturnFor(callInfo)).Return(_overriddenResult); }
public void Throw(ICallSpecification callSpecification, IEnumerable<ICall> matchingCalls, IEnumerable<ICall> nonMatchingCalls, Quantity requiredQuantity) { var builder = new StringBuilder(); builder.AppendLine(string.Format("Expected to receive {0} matching:\n\t{1}", requiredQuantity.Describe("call", "calls"), callSpecification)); AppendMatchingCalls(callSpecification, matchingCalls, builder); if (requiredQuantity.RequiresMoreThan(matchingCalls)) { AppendNonMatchingCalls(callSpecification, nonMatchingCalls, builder); } throw new ReceivedCallsException(builder.ToString()); }
public override void Context() { base.Context(); _call = mock <ICall>(); var specificationInfo = PendingSpecificationInfo.FromLastCall(_call); _pendingSpecification.stub(x => x.HasPendingCallSpecInfo()).Return(true); _pendingSpecification.stub(x => x.UseCallSpecInfo()).Return(specificationInfo); _callSpecification = mock <ICallSpecification>(); _callSpecificationFactory.stub(x => x.CreateFrom(_call, _argMatchStrategy)).Return(_callSpecification); }
private void AppendNonMatchingCalls(ICallSpecification callSpecification, IEnumerable<ICall> nonMatchingCalls, StringBuilder builder) { if (nonMatchingCalls.Any()) { var numberOfRelatedCalls = nonMatchingCalls.Count(); builder.AppendLine( string.Format( "Received {0} non-matching {1} (non-matching arguments indicated with '*' characters):", numberOfRelatedCalls, numberOfRelatedCalls == 1 ? "call" : "calls") ); WriteCallsWithRespectToCallSpec(callSpecification, nonMatchingCalls, builder); } }
public void Throw(ICallSpecification callSpecification, IEnumerable<ICall> actualCalls) { var builder = new StringBuilder(); builder.AppendLine("Expected to receive call:\n\t" + callSpecification.Format(_callFormatter)); if (!actualCalls.Any()) { builder.AppendLine("Actually received no calls that resemble the expected call."); } else { builder.AppendLine("Actually received (non-matching arguments indicated with '*' characters):"); foreach (var call in actualCalls) { builder.AppendFormat("\t{0}\n", _callFormatter.Format(call, callSpecification)); } } throw new CallNotReceivedException(builder.ToString()); }
public void UpdateCallSpecification(ICallSpecification spec) { _callSpecification = spec; }
ICallSpecification UpdateCallSpecToMatchAnyArgs(ICallSpecification callSpecification) { var anyArgCallSpec = callSpecification.CreateCopyThatMatchesAnyArguments(); _callActions.MoveActionsForSpecToNewSpec(callSpecification, anyArgCallSpec); return anyArgCallSpec; }
public ICallSpecification FromExistingSpec(ICallSpecification spec, MatchArgs matchArgs) { return matchArgs == MatchArgs.AsSpecifiedInCall ? spec : UpdateCallSpecToMatchAnyArgs(spec); }
public CallSpecAndTarget(ICallSpecification callSpecification, object target) { CallSpecification = callSpecification; Target = target; }
private string DescribeNonMatches(ICall call, ICallSpecification callSpecification) { var nonMatches = callSpecification.NonMatchingArguments(call) ?? new ArgumentMatchInfo[0]; var nonMatchingArgDescriptions = nonMatches.Select(x => x.DescribeNonMatch()).Where(x => !string.IsNullOrEmpty(x)).ToArray(); return string.Join("\n", nonMatchingArgDescriptions); }
public void Add(ICallSpecification callSpecification) { _actions.Add(new CallAction(callSpecification, EmptyAction)); }
public CallAction(ICallSpecification callSpecification, Action<CallInfo> action) { CallSpecification = callSpecification; Action = action; }
ICallSpecification GetCallSpecForArgMatchStrategy(ICallSpecification callSpecification, MatchArgs matchArgs) { return matchArgs == MatchArgs.AsSpecifiedInCall ? callSpecification : UpdateCallSpecToMatchAnyArgs(callSpecification); }
public void ThrowIfCallNotFound(ICallSpecification callSpecification) { if (_stack.Any(receivedCall => callSpecification.IsSatisfiedBy(receivedCall))) return; throw new CallNotReceivedException(); }
public string Format(ICall call, ICallSpecification withRespectToCallSpec) { return Format(call.GetMethodInfo(), call.GetArguments(), withRespectToCallSpec.NonMatchingArgumentIndicies(call)); }
public void SetResult(ICallSpecification callSpecification, IReturn result) { _results.Add(new ResultForCallSpec(callSpecification, result)); }
public ResultForCallSpec(ICallSpecification callSpecification, IReturn resultToReturn) { _callSpecification = callSpecification; _resultToReturn = resultToReturn; }
public bool IsFor(ICallSpecification spec) { return _callSpecification == spec; }
public void Set(ICallSpecification callSpecification) { _pendingSpec = callSpecification; }
public void Add(ICallSpecification callSpecification, Action<CallInfo> action) { _actions.Add(new CallAction(callSpecification, action)); }
public ICallSpecification UseCallSpec() { var specToUse = _pendingSpec; _pendingSpec = null; return specToUse; }
public void Throw(ICallSpecification callSpecification) { throw new CallReceivedException("Unexpected call to: " + callSpecification.Format(_callFormatter)); }
public void AddToQuery(object target, ICallSpecification callSpecification) { if (!IsQuerying) throw new NotRunningAQueryException(); if (query.Value == null) { // Must be a legacy query, delegate innerContext.AddToQuery(target, callSpecification); } else { query.Value.Add(callSpecification, target); } }
public IEnumerable<ICall> FindMatchingCalls(ICallSpecification callSpecification) { return _stack.Where(x => callSpecification.IsSatisfiedBy(x)); }
public void SetCallSpecification(ICallSpecification callSpecification) { _substitutionContext.PendingSpecificationInfo = PendingSpecificationInfo.FromCallSpecification(callSpecification); }
void SetResultForCall(ICallSpecification callSpecification, IReturn valueToReturn, MatchArgs matchArgs) { var callSpecForReturnValue = GetCallSpecForArgMatchStrategy(callSpecification, matchArgs); _configuredResults.SetResult(callSpecForReturnValue, valueToReturn); }