public void AllowAddingNewVerifiables() { var verifiable1 = new MockVerifiable(); verifiable1.Verify.Return(new[] { new VerificationResult("My Verification", false) }); var verifiable2 = new MockVerifiable(); verifiable2.Verify.Return(new[] { new VerificationResult("My other verification", true) }); IVerifiable group = new VerificationGroup("My Group") { verifiable1, verifiable2 }; var groupResult = group.Verify(); var result = Assert.Single(groupResult); var expectedResult = new VerificationResult("Verification Group 'My Group':", new[] { new VerificationResult("My Verification", false), new VerificationResult("My other verification", true) }); result.AssertEquals(expectedResult); }
public void ReturnSingleSuccessfulResultIfEmpty() { IVerifiable group = new VerificationGroup(); var groupResult = group.Verify(); var result = Assert.Single(groupResult); Assert.True(result.Success); Assert.Equal("Verification Group:", result.Description); }
public void AcceptName() { IVerifiable group = new VerificationGroup("Group Name"); var groupResult = group.Verify(); var result = Assert.Single(groupResult); Assert.True(result.Success); Assert.Equal("Verification Group 'Group Name':", result.Description); }
public void NotThrowWhenAssertingSuccessfulGroup() { var verifiable = new MockVerifiable(); verifiable.Verify .Return(new[] { new VerificationResult("a passing test", true) }); var group = new VerificationGroup("My Group") { verifiable }; group.Assert(); }
/// <summary> /// Step that checks the number of times the method has been called. Adds the check to the verification group /// provided. /// </summary> /// <typeparam name="TParam">The method parameter type.</typeparam> /// <typeparam name="TResult">The method return type.</typeparam> /// <param name="caller">The mock or step to which this 'verification' step is added.</param> /// <param name="verificationGroup">The verification group to which this check is added.</param> /// <param name="name">A name that can be used to identify the check in its group.</param> /// <param name="expectedNumberOfCalls">The expected number of times the method has been called.</param> /// <returns>An <see cref="ICanHaveNextMethodStep{TParam, TResult}" /> that can be used to add further steps.</returns> public static ICanHaveNextMethodStep <TParam, TResult> ExpectedUsage <TParam, TResult>( this ICanHaveNextMethodStep <TParam, TResult> caller, VerificationGroup verificationGroup, string?name, int?expectedNumberOfCalls = null) { if (verificationGroup == null) { throw new ArgumentNullException(nameof(verificationGroup)); } var step = new ExpectedUsageMethodStep <TParam, TResult>(name, expectedNumberOfCalls); verificationGroup.Add(step); return(caller.SetNextStep(step)); }
/// <summary> /// Step that checks the number of times values have been read from or written to the indexer. Adds the check /// to the verification group provided. /// </summary> /// <typeparam name="TKey">The type of the indexer key.</typeparam> /// <typeparam name="TValue">The type of the indexer value.</typeparam> /// <param name="caller">The mock or step to which this 'verification' step is added.</param> /// <param name="verificationGroup">The verification group to which this check is added.</param> /// <param name="name">A name that can be used to identify the check in its group.</param> /// <param name="expectedNumberOfGets">The expected number of times values have been read from the indexer.</param> /// <param name="expectedNumberOfSets">The expected number of times values have been written to the indexer.</param> /// <returns>An <see cref="ICanHaveNextIndexerStep{TKey, TValue}" /> that can be used to add further steps.</returns> public static ICanHaveNextIndexerStep <TKey, TValue> ExpectedUsage <TKey, TValue>( this ICanHaveNextIndexerStep <TKey, TValue> caller, VerificationGroup verificationGroup, string?name, int?expectedNumberOfGets = null, int?expectedNumberOfSets = null) { if (verificationGroup == null) { throw new ArgumentNullException(nameof(verificationGroup)); } var step = new ExpectedUsageIndexerStep <TKey, TValue>(name, expectedNumberOfGets, expectedNumberOfSets); verificationGroup.Add(step); return(caller.SetNextStep(step)); }
/// <summary> /// Step that checks the number of times event handlers have been added or removed. Adds the check to the verification /// group provided. /// </summary> /// <typeparam name="THandler">The event handler type for the event.</typeparam> /// <param name="caller">The mock or step to which this 'verification' step is added.</param> /// <param name="verificationGroup">The verification group to which this check is added.</param> /// <param name="name">A name that can be used to identify the check in its group.</param> /// <param name="expectedNumberOfAdds">The expected number of times event handlers have been added.</param> /// <param name="expectedNumberOfRemoves">The expected number of times event handlers have been removed.</param> /// <returns>An <see cref="ICanHaveNextEventStep{THandler}" /> that can be used to add further steps.</returns> public static ICanHaveNextEventStep <THandler> ExpectedUsage <THandler>( this ICanHaveNextEventStep <THandler> caller, VerificationGroup verificationGroup, string?name, int?expectedNumberOfAdds = null, int?expectedNumberOfRemoves = null) where THandler : Delegate { if (verificationGroup == null) { throw new ArgumentNullException(nameof(verificationGroup)); } var step = new ExpectedUsageEventStep <THandler>(name, expectedNumberOfAdds, expectedNumberOfRemoves); verificationGroup.Add(step); return(caller.SetNextStep(step)); }
public void ExposesVerifiablesThroughIEnumerable() { var verifiable1 = new MockVerifiable(); verifiable1.Verify.Return(new[] { new VerificationResult("My Verification", false) }); var verifiable2 = new MockVerifiable(); verifiable2.Verify.Return(new[] { new VerificationResult("My other verification", true) }); var group = new VerificationGroup("My Group") { verifiable1, verifiable2 }; Assert.Equal(new IVerifiable[] { verifiable1, verifiable2 }, group); Assert.Equal(new IVerifiable[] { verifiable1, verifiable2 }, group.ToArray()); }
public void PassFormatProviderToGroupMembers() { var verifiable = new MockVerifiable(); verifiable.Verify .RecordBeforeCall(out var ledger) .Return(new[] { new VerificationResult("aha", true) }); IVerifiable group = new VerificationGroup("My Group") { verifiable }; var french = new CultureInfo("fr-FR"); var japanese = new CultureInfo("ja-JP"); group.Verify(french); group.Verify(japanese); Assert.Equal(new IFormatProvider[] { french, japanese }, ledger); Assert.Equal(new IFormatProvider[] { french, japanese }, ledger.ToArray()); }
public void ThrowWhenAssertingFailedGroup() { var verifiable = new MockVerifiable(); verifiable.Verify .Return(new[] { new VerificationResult("a failing test", false) }); var group = new VerificationGroup("My Group") { verifiable }; var ex = Assert.Throws <VerificationFailedException>(() => group.Assert()); ex.VerificationResult.AssertEquals(new VerificationResult("Verification Group 'My Group':", new[] { new VerificationResult("a failing test", false) })); Assert.Equal(@"Verification failed. FAILED: Verification Group 'My Group': FAILED: a failing test", ex.Message); }
/// <summary> /// Checks the current values in the indexer store. Adds the check to the verification group provided. /// </summary> /// <typeparam name="TKey">The type of the indexer key.</typeparam> /// <typeparam name="TValue">The type of the indexer value.</typeparam> /// <param name="indexer">The <see cref="IStoredIndexer{TKey,TValue}" /> whose values to check.</param> /// <param name="collector">The verification group to which this check is added.</param> /// <param name="name">A name that can be used to identify the check in its verification group.</param> /// <param name="expectedValues"> /// A list of key-value pairs to check. The check will retrieve the value for each key /// in the list and compare it to the value in the list. /// </param> /// <param name="comparer">Optional parameter with a comparer used to verify that the values are equal.</param> /// <returns>The <see cref="IStoredIndexer{TKey,TValue}" /> instance that can be used to add further checks.</returns> public static IStoredIndexer <TKey, TValue> CurrentValuesCheck <TKey, TValue>(this IStoredIndexer <TKey, TValue> indexer, VerificationGroup collector, string?name, IEnumerable <KeyValuePair <TKey, TValue> >?expectedValues, IEqualityComparer <TValue>?comparer = null) { collector.Add(new CurrentValuesIndexerCheck <TKey, TValue>(indexer, name, expectedValues, comparer)); return(indexer); }
/// <summary> /// Checks the current values in the property store. Adds the check to the verification group provided. /// </summary> /// <typeparam name="TValue">The type of the property.</typeparam> /// <param name="property">The <see cref="IStoredProperty{TValue}" /> whose value to check.</param> /// <param name="collector">The verification group to which this check is added.</param> /// <param name="name">A name that can be used to identify the check in its verification group.</param> /// <param name="expectedValue">The expected value. </param> /// <param name="comparer">Optional parameter with a comparer used to verify that the values are equal.</param> /// <returns>The <see cref="IStoredProperty{TValue}" /> instance that can be used to add further checks.</returns> public static IStoredProperty <TValue> CurrentValueCheck <TValue>(this IStoredProperty <TValue> property, VerificationGroup collector, string?name, TValue expectedValue, IEqualityComparer <TValue>?comparer = null) { collector.Add(new CurrentValuePropertyCheck <TValue>(property, name, expectedValue, comparer)); return(property); }