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