Esempio n. 1
0
        private ICallSpecification UpdateCallSpecToMatchAnyArgs(ICallSpecification callSpecification)
        {
            var anyArgCallSpec = callSpecification.CreateCopyThatMatchesAnyArguments();

            _callActions.MoveActionsForSpecToNewSpec(callSpecification, anyArgCallSpec);
            return(anyArgCallSpec);
        }
Esempio n. 2
0
 public void MoveActionsForSpecToNewSpec(ICallSpecification oldCallSpecification, ICallSpecification newCallSpecification)
 {
     foreach (var action in _actions.Where(x => x.IsFor(oldCallSpecification)))
     {
         action.UpdateCallSpecification(newCallSpecification);
     }
 }
Esempio n. 3
0
 public override void Context()
 {
     base.Context();
     _initialCallSpec         = CreateMatchingCallSpec();
     _newSpec                 = CreateMatchingCallSpec();
     _callMatchingInitialSpec = mock <Action <CallInfo> >();
 }
Esempio n. 4
0
 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));
        }
Esempio n. 6
0
 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 MoveActionsForSpecToNewSpec(ICallSpecification oldCallSpecification, ICallSpecification newCallSpecification)
 {
     foreach (var action in _actions.Where(x => x.IsFor(oldCallSpecification)))
     {
         action.UpdateCallSpecification(newCallSpecification);
     }
 }
 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);
     }
 }
Esempio n. 11
0
 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.");
 }
Esempio n. 12
0
 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));
        }
Esempio n. 15
0
 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);
 }
Esempio n. 16
0
 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);
 }
Esempio n. 17
0
        /// <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));
        }
Esempio n. 19
0
        private static void CheckResultIsCompatibleWithCall(IReturn valueToReturn, ICallSpecification spec)
        {
            var requiredReturnType = spec.ReturnType();

            if (!valueToReturn.CanBeAssignedTo(requiredReturnType))
            {
                throw new CouldNotSetReturnDueToTypeMismatchException(valueToReturn.TypeOrNull(), spec.GetMethodInfo());
            }
        }
Esempio n. 20
0
        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);
            }
        }
Esempio n. 21
0
            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);
            }
Esempio n. 22
0
            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);
            }
Esempio n. 23
0
            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);
            }
Esempio n. 24
0
        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);
 }
Esempio n. 26
0
            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"));
         }
     }
 }
Esempio n. 29
0
            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> >();
            }
Esempio n. 30
0
            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);
            }
Esempio n. 31
0
 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);
     }
 }
Esempio n. 33
0
        /// <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));
        }
Esempio n. 34
0
            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());
        }
Esempio n. 36
0
            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());
 }
Esempio n. 39
0
 public void UpdateCallSpecification(ICallSpecification spec) { _callSpecification = spec; }
Esempio n. 40
0
 ICallSpecification UpdateCallSpecToMatchAnyArgs(ICallSpecification callSpecification)
 {
     var anyArgCallSpec = callSpecification.CreateCopyThatMatchesAnyArguments();
     _callActions.MoveActionsForSpecToNewSpec(callSpecification, anyArgCallSpec);
     return anyArgCallSpec;
 }
Esempio n. 41
0
 public ICallSpecification FromExistingSpec(ICallSpecification spec, MatchArgs matchArgs)
 {
     return matchArgs == MatchArgs.AsSpecifiedInCall ? spec : UpdateCallSpecToMatchAnyArgs(spec);
 }
Esempio n. 42
0
 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);
 }
Esempio n. 44
0
 public void Add(ICallSpecification callSpecification)
 {
     _actions.Add(new CallAction(callSpecification, EmptyAction));
 }
Esempio n. 45
0
 public CallAction(ICallSpecification callSpecification, Action<CallInfo> action)
 {
     CallSpecification = callSpecification;
     Action = action;
 }
Esempio n. 46
0
 ICallSpecification GetCallSpecForArgMatchStrategy(ICallSpecification callSpecification, MatchArgs matchArgs)
 {
     return matchArgs == MatchArgs.AsSpecifiedInCall ? callSpecification : UpdateCallSpecToMatchAnyArgs(callSpecification);
 }
Esempio n. 47
0
 public void ThrowIfCallNotFound(ICallSpecification callSpecification)
 {
     if (_stack.Any(receivedCall => callSpecification.IsSatisfiedBy(receivedCall))) return;
     throw new CallNotReceivedException();
 }
Esempio n. 48
0
 public string Format(ICall call, ICallSpecification withRespectToCallSpec)
 {
     return Format(call.GetMethodInfo(), call.GetArguments(), withRespectToCallSpec.NonMatchingArgumentIndicies(call));
 }
Esempio n. 49
0
 public void SetResult(ICallSpecification callSpecification, IReturn result)
 {
     _results.Add(new ResultForCallSpec(callSpecification, result));
 }
Esempio n. 50
0
 public ResultForCallSpec(ICallSpecification callSpecification, IReturn resultToReturn)
 {
     _callSpecification = callSpecification;
     _resultToReturn = resultToReturn;
 }
Esempio n. 51
0
 public bool IsFor(ICallSpecification spec) { return _callSpecification == spec; }
 public void Set(ICallSpecification callSpecification)
 {
     _pendingSpec = callSpecification;
 }
Esempio n. 53
0
 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 AddToQuery(object target, ICallSpecification callSpecification)
 {
     var query = _currentQuery.Value;
     if (query == null) { throw new NotRunningAQueryException(); }
     query.Add(callSpecification, target);
 }
 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);
            }
        }
Esempio n. 58
0
 public IEnumerable<ICall> FindMatchingCalls(ICallSpecification callSpecification)
 {
     return _stack.Where(x => callSpecification.IsSatisfiedBy(x));
 }
 public void SetCallSpecification(ICallSpecification callSpecification)
 {
     _substitutionContext.PendingSpecificationInfo = PendingSpecificationInfo.FromCallSpecification(callSpecification);
 }
Esempio n. 60
0
 void SetResultForCall(ICallSpecification callSpecification, IReturn valueToReturn, MatchArgs matchArgs)
 {
     var callSpecForReturnValue = GetCallSpecForArgMatchStrategy(callSpecification, matchArgs);
     _configuredResults.SetResult(callSpecForReturnValue, valueToReturn);
 }