public void ArgumentMustExistAndDoesTest()
{
// Setup
DirectoryPath path = new DirectoryPath(testDirectoryName);
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.SetupGetArgumentSingle(
requiredArgName,
testDirectoryName
);
Mock <IDirectory> Directory = new Mock <IDirectory>(MockBehavior.Strict);
Directory.Setup(
m => m.Exists
).Returns(true);
this.cakeDirectorySystem.Setup(
// Can't pass in the path above, as DirectoryPath does not implement Equals(),
// so it does a reference equals by default, which is a problem
// since we create a new instance of the class.
m => m.GetDirectory(It.IsAny <DirectoryPath>())
).Returns(Directory.Object);
// Act
MustExistArgument uut = ArgumentBinderAliases.CreateFromArguments <MustExistArgument>(this.cakeContext.Object);
// Check
Assert.AreEqual(testDirectoryName, uut.DirectoryPathProperty.ToString());
}
public void ArgumentMustExistAndDoesNotSinceItsNullTest()
{
// Setup
DirectoryPath path = new DirectoryPath(testDirectoryName);
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.SetupGetArgumentSingle(
requiredArgName,
testDirectoryName
);
this.cakeDirectorySystem.Setup(
// Can't pass in the path above, as DirectoryPath does not implement Equals(),
// so it does a reference equals by default, which is a problem
// since we create a new instance of the class.
m => m.GetDirectory(It.IsAny <DirectoryPath>())
).Returns(default(IDirectory));
// Act
AggregateException e = Assert.Throws <AggregateException>(
() => ArgumentBinderAliases.CreateFromArguments <MustExistArgument>(this.cakeContext.Object)
);
// Check
Assert.AreEqual(1, e.InnerExceptions.Count);
Assert.IsTrue(e.InnerExceptions[0] is DirectoryNotFoundException);
}
public void InRangeSpecifiedRequiredArgumentTest()
{
{
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.Setup(
m => m.GetArgument(requiredArgName)
).Returns((minValue + 1).ToString());
RequiredArgument uut = ArgumentBinderAliases.CreateFromArguments <RequiredArgument>(this.cakeContext.Object);
Assert.AreEqual(minValue + 1, uut.IntProperty);
}
{
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.Setup(
m => m.GetArgument(requiredArgName)
).Returns((maxValue - 1).ToString());
RequiredArgument uut = ArgumentBinderAliases.CreateFromArguments <RequiredArgument>(this.cakeContext.Object);
Assert.AreEqual(maxValue - 1, uut.IntProperty);
}
}
public void WrongPassedInTypeTest()
{
AggregateException e = Assert.Throws <AggregateException>(
() => ArgumentBinderAliases.CreateFromArguments <WrongPassedInTypeArgument>(this.cakeContext.Object)
);
Assert.AreEqual(1, e.InnerExceptions.Count);
Assert.IsTrue(e.InnerExceptions[0] is ArgumentException);
}
public void EmptyArgumentTest()
{
AggregateException e = Assert.Throws <AggregateException>(
() => ArgumentBinderAliases.CreateFromArguments <EmptyArgument>(this.cakeContext.Object)
);
Assert.AreEqual(1, e.InnerExceptions.Count);
Assert.IsTrue(e.InnerExceptions[0] is AttributeValidationException);
}
public void WrongTypeTest()
{
AggregateException e = Assert.Throws <AggregateException>(
() => ArgumentBinderAliases.CreateFromArguments <MismatchedTypeArgument>(this.cakeContext.Object)
);
Assert.AreEqual(1, e.InnerExceptions.Count);
Assert.IsTrue(e.InnerExceptions[0] is InvalidPropertyTypeForAttributeException);
}
public void UnspecifiedOptionalArgumentTest()
{
this.cakeArgs.Setup(
m => m.HasArgument(optionalArgName)
).Returns(false);
OptionalArgument uut = ArgumentBinderAliases.CreateFromArguments <OptionalArgument>(this.cakeContext.Object);
Assert.AreEqual(defaultValue, uut.StringProperty);
}
public void UnspecifiedOptionalArgumentTest()
{
this.cakeArgs.Setup(
m => m.HasArgument(optionalArgName)
).Returns(false);
OptionalArgument uut = ArgumentBinderAliases.CreateFromArguments <OptionalArgument>(this.cakeContext.Object);
Assert.IsTrue(uut.BoolProperty);
}
public void MisconfiguredArgumentTest()
{
// Act
AggregateException e = Assert.Throws <AggregateException>(
() => ArgumentBinderAliases.CreateFromArguments <InvalidMustExistArgument>(this.cakeContext.Object)
);
// Check
Assert.AreEqual(1, e.InnerExceptions.Count);
Assert.IsTrue(e.InnerExceptions[0] is AttributeValidationException);
}
public void UnspecifiedOptionalArgumentTest2()
{
this.cakeArgs.Setup(
m => m.HasArgument(optionalArgName)
).Returns(false);
OptionalArgument3 uut = ArgumentBinderAliases.CreateFromArguments <OptionalArgument3>(this.cakeContext.Object);
// Should be the enum set to 0.
Assert.AreEqual(Enum3.Value8, uut.Enum3Property);
}
public void UnspecifiedOptionalArgumentTest()
{
// Setup
this.cakeArgs.Setup(
m => m.HasArgument(optionalArgName)
).Returns(false);
// Act
OptionalArgument uut = ArgumentBinderAliases.CreateFromArguments <OptionalArgument>(this.cakeContext.Object);
// Check
Assert.AreEqual(testDirectoryName, uut.DirectoryPathProperty.ToString());
}
public void DoesNotHaveRequiredArgumentTest()
{
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(false);
AggregateException e = Assert.Throws <AggregateException>(
() => ArgumentBinderAliases.CreateFromArguments <RequiredArgument>(this.cakeContext.Object)
);
Assert.AreEqual(1, e.InnerExceptions.Count);
Assert.IsTrue(e.InnerExceptions[0] is MissingRequiredArgumentException);
}
public void HasRequiredArgumentTest()
{
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.Setup(
m => m.GetArgument(requiredArgName)
).Returns("true");
RequiredArgument uut = ArgumentBinderAliases.CreateFromArguments <RequiredArgument>(this.cakeContext.Object);
Assert.IsTrue(uut.BoolProperty);
}
public void EmptyStringTest()
{
this.cakeArgs.Setup(
m => m.HasArgument(optionalArgName)
).Returns(true);
this.cakeArgs.Setup(
m => m.GetArgument(optionalArgName)
).Returns(string.Empty);
OptionalArgument uut = ArgumentBinderAliases.CreateFromArguments <OptionalArgument>(this.cakeContext.Object);
Assert.AreEqual(string.Empty, uut.StringProperty);
}
public void HasRequiredArgumentTest()
{
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.Setup(
m => m.GetArgument(requiredArgName)
).Returns(minValue.ToString());
RequiredArgument uut = ArgumentBinderAliases.CreateFromArguments <RequiredArgument>(this.cakeContext.Object);
Assert.AreEqual(minValue, uut.IntProperty);
}
public void SpecifiedOptionalArgumentTest()
{
this.cakeArgs.Setup(
m => m.HasArgument(optionalArgName)
).Returns(true);
this.cakeArgs.Setup(
m => m.GetArgument(optionalArgName)
).Returns(maxValue.ToString());
OptionalArgument uut = ArgumentBinderAliases.CreateFromArguments <OptionalArgument>(this.cakeContext.Object);
Assert.AreEqual(maxValue, uut.IntProperty);
}
public void SpecifiedOptionalArgumentTest()
{
this.cakeArgs.Setup(
m => m.HasArgument(optionalArgName)
).Returns(true);
this.cakeArgs.SetupGetArgumentSingle(
optionalArgName,
"false"
);
OptionalArgument uut = ArgumentBinderAliases.CreateFromArguments <OptionalArgument>(this.cakeContext.Object);
Assert.IsFalse(uut.BoolProperty);
}
public void MinEqualsMaxTest()
{
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.SetupGetArgumentSingle(
requiredArgName,
defaultValue.ToString()
);
MinEqualsMaxArgument uut = ArgumentBinderAliases.CreateFromArguments <MinEqualsMaxArgument>(this.cakeContext.Object);
Assert.AreEqual(defaultValue, uut.IntProperty);
}
public void HasRequiredArgumentTest()
{
const string value = "Arg Value";
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.Setup(
m => m.GetArgument(requiredArgName)
).Returns(value);
RequiredArgument uut = ArgumentBinderAliases.CreateFromArguments <RequiredArgument>(this.cakeContext.Object);
Assert.AreEqual(value, uut.StringProperty);
}
public void SpecifiedOptionalArgumentTest()
{
const string value = "My Value";
this.cakeArgs.Setup(
m => m.HasArgument(optionalArgName)
).Returns(true);
this.cakeArgs.Setup(
m => m.GetArgument(optionalArgName)
).Returns(value);
OptionalArgument uut = ArgumentBinderAliases.CreateFromArguments <OptionalArgument>(this.cakeContext.Object);
Assert.AreEqual(value, uut.StringProperty);
}
public void FormatExceptionTest()
{
this.cakeArgs.Setup(
m => m.HasArgument(optionalArgName)
).Returns(true);
this.cakeArgs.Setup(
m => m.GetArgument(optionalArgName)
).Returns("lolImNotABool");
AggregateException e = Assert.Throws <AggregateException>(
() => ArgumentBinderAliases.CreateFromArguments <OptionalArgument>(this.cakeContext.Object)
);
Assert.AreEqual(1, e.InnerExceptions.Count);
Assert.IsTrue(e.InnerExceptions[0] is ArgumentFormatException);
}
public void HasRequiredArgumentIgnoreCaseTest()
{
const Enum1 expectedValue = Enum1.Value2;
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.SetupGetArgumentSingle(
requiredArgName,
expectedValue.ToString().ToLowerInvariant()
);
RequiredArgumentIgnoreCase uut = ArgumentBinderAliases.CreateFromArguments <RequiredArgumentIgnoreCase>(this.cakeContext.Object);
Assert.AreEqual(expectedValue, uut.Enum1Property);
}
public void RequiredEnumHasNoDefaultValueTest()
{
const NoDefaultValueEnum expectedValue = NoDefaultValueEnum.Value9;
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.SetupGetArgumentSingle(
requiredArgName,
expectedValue.ToString()
);
NoDefaultValueRequiredArgument uut = ArgumentBinderAliases.CreateFromArguments <NoDefaultValueRequiredArgument>(this.cakeContext.Object);
Assert.AreEqual(expectedValue, uut.NoDefaultProperty);
}
public void ArgumentTooSmallTest()
{
this.cakeArgs.Setup(
m => m.HasArgument(optionalArgName)
).Returns(true);
this.cakeArgs.Setup(
m => m.GetArgument(optionalArgName)
).Returns((minValue - 1).ToString());
AggregateException e = Assert.Throws <AggregateException>(
() => ArgumentBinderAliases.CreateFromArguments <OptionalArgument>(this.cakeContext.Object)
);
Assert.AreEqual(1, e.InnerExceptions.Count);
Assert.IsTrue(e.InnerExceptions[0] is ArgumentTooSmallException);
}
public void SpecifiedOptionalArgumentTest()
{
const Enum2 expectedValue = Enum2.Value5;
this.cakeArgs.Setup(
m => m.HasArgument(optionalArgName)
).Returns(true);
this.cakeArgs.SetupGetArgumentSingle(
optionalArgName,
expectedValue.ToString()
);
OptionalArgument2 uut = ArgumentBinderAliases.CreateFromArguments <OptionalArgument2>(this.cakeContext.Object);
Assert.AreEqual(expectedValue, uut.Enum2Property);
}
public void EmptyStringTest()
{
// Setup
this.cakeArgs.Setup(
m => m.HasArgument(optionalArgName)
).Returns(true);
this.cakeArgs.SetupGetArgumentSingle(
optionalArgName,
string.Empty
);
// Act
OptionalArgument uut = ArgumentBinderAliases.CreateFromArguments <OptionalArgument>(this.cakeContext.Object);
// Check
Assert.AreEqual(string.Empty, uut.DirectoryPathProperty.ToString());
}
public void InvalidStringTest()
{
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.SetupGetArgumentSingle(
requiredArgName,
"not_an_enum"
);
AggregateException e = Assert.Throws <AggregateException>(
() => ArgumentBinderAliases.CreateFromArguments <RequiredArgument>(this.cakeContext.Object)
);
Assert.AreEqual(1, e.InnerExceptions.Count);
Assert.IsTrue(e.InnerExceptions[0] is ArgumentFormatException);
}
public void SpecifiedOptionalArgumentTest()
{
// Setup
const string value = "somefile.txt";
this.cakeArgs.Setup(
m => m.HasArgument(optionalArgName)
).Returns(true);
this.cakeArgs.SetupGetArgumentSingle(
optionalArgName,
value
);
// Act
OptionalArgument uut = ArgumentBinderAliases.CreateFromArguments <OptionalArgument>(this.cakeContext.Object);
// Check
Assert.AreEqual(value, uut.FilePathProperty.ToString());
}
public void HasRequiredArgumentTest()
{
// Setup
const string value = "somedir";
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.SetupGetArgumentSingle(
requiredArgName,
value
);
// Act
RequiredArgument uut = ArgumentBinderAliases.CreateFromArguments <RequiredArgument>(this.cakeContext.Object);
// Check
Assert.AreEqual(value, uut.DirectoryPathProperty.ToString());
}
public void ArgumentMustExistAndDoesNotTest()
{
// Setup
FilePath path = new FilePath(testFileName);
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.SetupGetArgumentSingle(
requiredArgName,
testFileName
);
Mock <IFile> file = new Mock <IFile>(MockBehavior.Strict);
file.Setup(
m => m.Exists
).Returns(false);
this.cakeFileSystem.Setup(
// Can't pass in the path above, as FilePath does not implement Equals(),
// so it does a reference equals by default, which is a problem
// since we create a new instance of the class.
m => m.GetFile(It.IsAny <FilePath>())
).Returns(file.Object);
// Act
AggregateException e = Assert.Throws <AggregateException>(
() => ArgumentBinderAliases.CreateFromArguments <MustExistArgument>(this.cakeContext.Object)
);
// Check
Assert.AreEqual(1, e.InnerExceptions.Count);
Assert.IsTrue(e.InnerExceptions[0] is FileNotFoundException);
}
