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));
}
