public void ThrowsEnumerableIsEmptyException() { var emptyStringList = new List <string>(); Assert.Throws <EnumerableIsEmptyContractViolationException>(() => Contract.Argument(() => emptyStringList).NotNullOrEmptyEnumerable()); var exception = Assert.Throws <EnumerableIsEmptyContractViolationException>(() => Contract.Argument(() => emptyStringList).NotNullOrEmptyEnumerable()); exception.BadValue.Type.Should().Be(InspectionType.Argument); exception = Assert.Throws <EnumerableIsEmptyContractViolationException>(() => Contract.Invariant(() => emptyStringList).NotNullOrEmptyEnumerable()); exception.BadValue.Type.Should().Be(InspectionType.Invariant); exception = Assert.Throws <EnumerableIsEmptyContractViolationException>(() => ReturnValueContractHelper.Return(emptyStringList, inspected => inspected.NotNullOrEmptyEnumerable())); exception.BadValue.Type.Should().Be(InspectionType.ReturnValue); InspectionTestHelper.BatchTestInspection <EnumerableIsEmptyContractViolationException, IEnumerable <string> >( assert: inspected => inspected.NotNullOrEmptyEnumerable(), badValues: new List <IEnumerable <string> > { emptyStringList, new List <string>() }, goodValues: new List <IEnumerable <string> > { new List <string> { "" }, new List <string> { "" } }); }
public EmailToAccountMapQueryModel(Email email, Guid accountId) { Contract.Argument(() => email, () => accountId).NotNullOrDefault(); Email = email; AccountId = accountId; }
public void ThrowsObjectNullExceptionForNullValues() { InspectionTestHelper.BatchTestInspection <ObjectIsNullContractViolationException, object>( inspected => inspected.NotNull(), badValues: new List <object> { null, null }, goodValues: new List <object> { new object(), "", Guid.NewGuid() }); var nullString = (string)null; var anObject = new object(); Assert.Throws <ObjectIsNullContractViolationException>(() => Contract.Argument(() => nullString).NotNull()); Assert.Throws <ObjectIsNullContractViolationException>(() => Contract.Argument(() => anObject, () => nullString).NotNull()); Assert.Throws <ObjectIsNullContractViolationException>(() => Contract.Argument(() => nullString).NotNull()) .Message.Should().Contain("nullString"); Assert.Throws <ObjectIsNullContractViolationException>(() => Contract.Invariant(() => nullString).NotNull()); Assert.Throws <ObjectIsNullContractViolationException>(() => Contract.Invariant(() => anObject, () => nullString).NotNull()); Assert.Throws <ObjectIsNullContractViolationException>(() => Contract.Invariant(() => nullString).NotNull()) .Message.Should().Contain("nullString"); }
public void CorrectlyExtractsParameterNamesAndValues() { var notNullObject = new object(); string okString = "okString"; string emptyString = ""; string nullString = null; Assert.Throws <ObjectIsNullContractViolationException>(() => Contract.Argument(() => nullString).NotNull()) .Message.Should().Contain("nullString"); Assert.Throws <ObjectIsNullContractViolationException>(() => Contract.Argument(() => okString, () => nullString, () => notNullObject).NotNull()) .Message.Should().Contain("nullString"); Assert.Throws <StringIsEmptyContractViolationException>(() => Contract.Argument(() => okString, () => emptyString).NotNullOrEmpty()) .Message.Should().Contain("emptyString"); Assert.Throws <ObjectIsNullContractViolationException>(() => TestStringsForNullOrEmpty(nullString)) .Message.Should().Contain("singleString"); Assert.Throws <ObjectIsNullContractViolationException>(() => TestStringsForNullOrEmpty(okString, nullString, emptyString)) .Message.Should().Contain("secondString"); Assert.Throws <StringIsEmptyContractViolationException>(() => TestStringsForNullOrEmpty(okString, emptyString, okString)) .Message.Should().Contain("secondString"); Assert.Throws <StringIsEmptyContractViolationException>(() => TestStringsForNullOrEmpty(okString, okString, emptyString)) .Message.Should().Contain("thirdString"); }
public void ThrowsStringIsWhiteSpaceExceptionForStringConsistingOfTabsSpacesOrLineBreaks() { var space = " "; var tab = "\t"; var lineBreak = "\n"; var newLine = "\r\n"; var environmentNewLine = Environment.NewLine; Assert.Throws <StringIsWhitespaceContractViolationException>(() => Contract.Argument(() => space).NotNullEmptyOrWhiteSpace()); Assert.Throws <StringIsWhitespaceContractViolationException>(() => Contract.Argument(() => tab).NotNullEmptyOrWhiteSpace()); Assert.Throws <StringIsWhitespaceContractViolationException>(() => Contract.Argument(() => lineBreak).NotNullEmptyOrWhiteSpace()); Assert.Throws <StringIsWhitespaceContractViolationException>(() => Contract.Argument(() => newLine).NotNullEmptyOrWhiteSpace()); Assert.Throws <StringIsWhitespaceContractViolationException>(() => Contract.Argument(() => environmentNewLine).NotNullEmptyOrWhiteSpace()); Assert.Throws <StringIsWhitespaceContractViolationException>(() => Contract.Argument(() => environmentNewLine, () => space).NotNullEmptyOrWhiteSpace()); var badValues = new List <string> { space, tab, lineBreak, newLine, environmentNewLine }; var goodValues = new List <string> { "aoeu", "lorem" }; InspectionTestHelper.BatchTestInspection <StringIsWhitespaceContractViolationException, string>( assert: inspected => inspected.NotNullEmptyOrWhiteSpace(), badValues: badValues, goodValues: goodValues); }
public void ThrowsObjectIsDefaultExceptionIfAnyValueIsDefault() { var myStructure = new MyStructure(); // ReSharper disable ConvertToConstant.Local var zero = 0; // ReSharper restore ConvertToConstant.Local Assert.Throws <ObjectIsDefaultContractViolationException>(() => Contract.Argument(() => zero).NotDefault()); Assert.Throws <ObjectIsDefaultContractViolationException>(() => Contract.Argument(() => zero).NotDefault()); Assert.Throws <ObjectIsDefaultContractViolationException>(() => Contract.Argument(() => myStructure).NotDefault()); Assert.Throws <ObjectIsDefaultContractViolationException>(() => Contract.Argument(() => myStructure).NotDefault()); var badValues = new List <object> { zero, myStructure }; var goodValues = new List <object> { new Object(), "", Guid.NewGuid() }; InspectionTestHelper.InspectBadValue <ObjectIsDefaultContractViolationException, MyStructure>( inspected => inspected.NotDefault(), new MyStructure()); InspectionTestHelper.BatchTestInspection <ObjectIsDefaultContractViolationException, int>( inspected => inspected.NotDefault(), badValues: new List <int> { 0 }, goodValues: new List <int> { 1, 2, 3 }); }
public void ThrowsExceptionMatchingParameterNameIfTestDoesNotPass() { var nameargument = "bad"; Assert.Throws <ContractViolationException>(() => Contract.Argument(() => nameargument).Inspect(value => value != nameargument)) .Message.Should().Contain("nameargument"); }
public void ShouldUseArgumentNameForException() { var newLine = Environment.NewLine; Assert.Throws <StringIsWhitespaceContractViolationException>(() => Contract.Argument(() => newLine).NotNullEmptyOrWhiteSpace()) .Message.Should().Contain("newLine"); }
public void UsesArgumentNameForExceptionMessage() { string emptyString = ""; Assert.Throws <StringIsEmptyContractViolationException>(() => Contract.Argument(() => emptyString).NotNullOrEmpty()) .Message.Should().Contain("emptyString"); }
public void UsesArgumentNameForExceptionmessage() { string nullString = null; Assert.Throws <ObjectIsNullContractViolationException>(() => Contract.Argument(() => nullString).NotNull()) .Message.Should().Contain("nullString"); }
public void ThrowsArgumentNullForNullArguments() { String aNullString = null; // ReSharper disable ExpressionIsAlwaysNull Assert.Throws <ObjectIsNullContractViolationException>(() => Contract.Argument(() => aNullString).NotNullEmptyOrWhiteSpace()); // ReSharper restore ExpressionIsAlwaysNull }
public void ShouldRun50TestsInOneMillisecond() //The Activator.CreateInstance stuff in the default check had me a bit worried. Seems I had no reason to be. { var one = 1; TimeAsserter.Execute( action: () => Contract.Argument(() => one).NotNullOrDefault(), iterations: 500, maxTotal: 10.Milliseconds()); }
public void ChangePassword(string oldPassword, Password newPassword) { Contract.Argument(() => newPassword).NotNullOrDefault(); Contract.Argument(() => oldPassword).NotNullEmptyOrWhiteSpace(); Password.AssertIsCorrectPassword(oldPassword); RaiseEvent(new UserChangedAccountPassword(newPassword)); }
public void ShouldRun50TestsIn1Millisecond() //The expression compilation stuff was worrying but this should be OK except for tight loops. { var notNullOrDefault = new object(); TimeAsserter.Execute( action: () => Contract.Argument(() => notNullOrDefault).NotNullOrDefault(), iterations: 500, maxTotal: 10.Milliseconds() ); }
public void ThrowsArgumentNullExceptionIfAnyValueIsNull() { var anObject = new object(); object nullObject = null; string emptyString = ""; Assert.Throws <ObjectIsNullContractViolationException>(() => Contract.Argument(() => nullObject).NotNullOrDefault()); Assert.Throws <ObjectIsNullContractViolationException>(() => Contract.Argument(() => anObject, () => nullObject).NotNullOrDefault()); Assert.Throws <ObjectIsNullContractViolationException>(() => Contract.Argument(() => emptyString, () => nullObject, () => anObject).NotNullOrDefault()); }
public void AssertAccountDoesNotExist(Email email) { Contract.Argument(() => email).NotNull(); EmailToAccountMapQueryModel ignored; if (_querymodels.TryGet(email, out ignored)) { throw new DuplicateAccountException(email); } }
public static byte[] HashPassword(byte[] salt, string password) //Extract to a private nested PasswordHasher class if this class gets uncomfortably long. { Contract.Argument(() => salt, () => password).NotNullOrDefault(); var encodedPassword = Encoding.Unicode.GetBytes(password); var saltedPassword = salt.Concat(encodedPassword).ToArray(); using (var algorithm = SHA256.Create()) { return(algorithm.ComputeHash(saltedPassword)); } }
public static void InspectBadValue <TException, TInspected>(Action <Inspected <TInspected> > assert, TInspected inspectedValue) where TException : ContractViolationException { Expression <Func <TInspected> > fetchInspected = () => inspectedValue; var inspectedName = ContractsExpression.ExtractName(fetchInspected); var inspected = Contract.Argument(() => inspectedValue); AssertThrows <TException, TInspected>( inspected: inspected, assert: assert, inspectionType: InspectionType.Argument, badValueName: inspectedName); inspected = Contract.Argument(() => inspectedValue, () => inspectedValue); AssertThrows <TException, TInspected>( inspected: inspected, assert: assert, inspectionType: InspectionType.Argument, badValueName: inspectedName); inspected = Contract.Invariant(() => inspectedValue); AssertThrows <TException, TInspected>( inspected: inspected, assert: assert, inspectionType: InspectionType.Invariant, badValueName: inspectedName); inspected = Contract.Invariant(() => inspectedValue, () => inspectedValue); AssertThrows <TException, TInspected>( inspected: inspected, assert: assert, inspectionType: InspectionType.Invariant, badValueName: inspectedName); const string returnvalueName = "ReturnValue"; inspected = Contract.ReturnValue(inspectedValue); AssertThrows <TException, TInspected>( inspected: inspected, assert: assert, inspectionType: InspectionType.ReturnValue, badValueName: returnvalueName); var exception = Assert.Throws <TException>(() => Return(inspectedValue, assert)); exception.BadValue.Type.Should().Be(InspectionType.ReturnValue); exception.BadValue.Name.Should().Be(returnvalueName); exception = Assert.Throws <TException>(() => ReturnOptimized(inspectedValue, assert)); exception.BadValue.Type.Should().Be(InspectionType.ReturnValue); exception.BadValue.Name.Should().Be(returnvalueName); }
public void NotEmptyThrowsArgumentExceptionForEmptyGuid() { var emptyGuid = Guid.Empty; var aGuid = Guid.NewGuid(); Assert.Throws <GuidIsEmptyContractViolationException>(() => Contract.ReturnValue(emptyGuid).NotEmpty()) .Message.Should().Contain("ReturnValue"); Assert.Throws <GuidIsEmptyContractViolationException>(() => Contract.Argument(() => emptyGuid).NotEmpty()); Assert.Throws <GuidIsEmptyContractViolationException>(() => Contract.Argument(() => emptyGuid).NotEmpty()) .Message.Should().Contain("emptyGuid"); Assert.Throws <GuidIsEmptyContractViolationException>(() => Contract.Argument(() => aGuid, () => emptyGuid).NotEmpty()) .Message.Should().Contain("emptyGuid"); }
public static void InspectGoodValues <TInspected>(Action <Inspected <TInspected> > assert, TInspected goodValue) { Expression <Func <TInspected> > fetchInspected = () => goodValue; var inspectedName = ContractsExpression.ExtractName(fetchInspected); var inspected = Contract.Argument(() => goodValue); assert(inspected); inspected = Contract.Argument(() => goodValue); assert(inspected); inspected = Contract.Invariant(() => goodValue); assert(inspected); Return(goodValue, assert); }
/// <summary><para>Used when a user manually creates an account themselves.</para> /// <para>Note how this design with a named static creation method: </para> /// <para> * makes it clearear what the caller intends.</para> /// <para> * makes it impossible to use the class incorrectly, such as forgetting to check for duplicates or save the new instance in the repository.</para> /// <para> * reduces code duplication since multiple callers are not burdened with saving the instance, checking for duplicates etc.</para> /// </summary> public static Account Register( Email email, Password password, Guid accountId, IAccountRepository repository, IDuplicateAccountChecker duplicateAccountChecker) { //Ensure that it is impossible to call with invalid arguments. //Since all domain types should ensure that it is impossible to create a non-default value that is invalid we only have to disallow default values. Contract.Argument(() => email, () => password, () => accountId, () => repository, () => duplicateAccountChecker).NotNullOrDefault(); //The email is the unique identifier for logging into the account so obviously duplicates are forbidden. duplicateAccountChecker.AssertAccountDoesNotExist(email); var created = new Account(); created.RaiseEvent(new UserRegisteredAccountEvent(accountId: accountId, email: email, password: password)); repository.Add(created); return(Contract.Return(created, inspect => inspect.NotNull())); //Promise and ensure that you will never return null. }
public void ThrowsObjectIsDefaultExceptionIfAnyValueIsDefault() { var anObject = new object(); string emptyString = ""; var zero = 0; var defaultMyStructure = new MyStructure(); var aMyStructure = new MyStructure(1); Assert.Throws <ObjectIsDefaultContractViolationException>(() => Contract.Argument(() => zero).NotNullOrDefault()); Assert.Throws <ObjectIsDefaultContractViolationException>(() => Contract.Argument(() => anObject, () => zero).NotNullOrDefault()); Assert.Throws <ObjectIsDefaultContractViolationException>(() => Contract.Argument(() => emptyString, () => anObject, () => defaultMyStructure).NotNullOrDefault()); Contract.Argument(() => emptyString, () => anObject, () => aMyStructure).NotNullOrDefault(); InspectionTestHelper.BatchTestInspection <ObjectIsDefaultContractViolationException, object>( inspected => inspected.NotNullOrDefault(), badValues: new List <object> { zero, defaultMyStructure }, goodValues: new List <object> { new object(), "", Guid.NewGuid() }); }
public void ChangeEmail(Email email) { Contract.Argument(() => email).NotNullOrDefault(); RaiseEvent(new UserChangedAccountEmailEvent(email)); }
public void ThrowsIllegalArgumentAccessLambdaIfTheLambdaAccessesALiteral() { Assert.Throws <InvalidAccessorLambdaException>(() => Contract.Argument(() => "")); Assert.Throws <InvalidAccessorLambdaException>(() => Contract.Argument(() => 0)); }
private static void TestStringsForNullOrEmpty(string singleString) { Contract.Argument(() => singleString).NotNullOrEmpty(); }
public void ThrowsStringIsEmptyArgumentExceptionForEmptyStrings() { Assert.Throws <StringIsEmptyContractViolationException>(() => Contract.Argument(() => string.Empty).NotNullEmptyOrWhiteSpace()); }
private static void TestStringsForNullOrEmpty(string firstString, string secondString, string thirdString) { Contract.Argument(() => firstString, () => secondString, () => thirdString).NotNullOrEmpty(); }
public void NotEmptyThrowsStringIsEmptyArgumentExceptionForEmptyString() { string emptyString = ""; Assert.Throws <StringIsEmptyContractViolationException>(() => Contract.Argument(() => emptyString).NotNullOrEmpty()); }
public void ThrownContractExceptionIfTestDoesNotPass() { var nameArgument = "bad"; Assert.Throws <ContractViolationException>(() => Contract.Argument(() => nameArgument).Inspect(value => value != nameArgument)); }