A C#/.NET Attributes Based Command Line Argument Parser

//
// NAttrArgs
//
// Copyright (c) 2012 Pete Barber
//
// Licensed under the The Code Project Open License (CPOL.html)
// http://www.codeproject.com/info/cpol10.aspx 
//
using System.Collections.Generic;
using NUnit.Framework;

namespace NAttrArgs.Test
{
	class ArgParserTests : SamplesSetup
	{
		List<MemberAttribute> _empty = new List<MemberAttribute>();

		[Test]
		public void Parse_SingleRequiredIntArgOf7_Is7()
		{
			string[] args = new string[] { "7" };

			_parserForTestClassWithIntSampleArgument.Parse(_testClassWithIntSampleArgument, args);

			Assert.That(_testClassWithIntSampleArgument.SampleArgumentValue, Is.EqualTo(7));
		}

        [Test]
        public void Parse_OptionalWhenNoArgsSupplied_DoesNotThrow()
        {
            Assert.That(() => _parserForTestClassWithOneOptional.Parse(_testClassWithOneOptional, new string[] { }), Throws.Nothing);
        }


		[Test]
		public void Parse_OptionalWithArgumentWhenNoArgsSupplied_DoesNotThrow()
		{
			Assert.That(() => _parserForTestClassWithOneOptionalWithArgument.Parse(_testClassWithOneOptionalWithArgument, new string[]{}), Throws.Nothing);
		}

        [Test]
        public void Parse_OptionalWithArgumentWhenOnlyOptionSupplied_DoesThrow()
        {
            Assert.That(() => _parserForTestClassWithOneOptionalWithArgument.Parse(_testClassWithOneOptionalWithArgument, new string[] { "-SetSomething" }),
                            Throws.TypeOf<NArgException>().With.Message.EqualTo("Usage: TestProg [-SetSomething <test>]"));
        }

		[Test]
		public void Parse_Optional_IsSet()
		{
            _parserForTestClassWithOneOptional.Parse(_testClassWithOneOptional, new string[] { "-SetSomething" });

            Assert.That(_testClassWithOneOptional.SetSomethingValue, Is.True);
		}
		[Test]
		public void Parse_OptionalWithIntArgOf9_Is9()
		{
            _parserForTestClassWithOneOptionalWithArgument.Parse(_testClassWithOneOptionalWithArgument, new string[] { "-SetSomething", "9" });

            Assert.That(_testClassWithOneOptionalWithArgument.SetSomethingValue, Is.EqualTo(9));
		}

		[Test]
		public void Parse_WhenOneArgumentIsExpectedAndNoneAreSupplied_ThrowsWithCorrectInnerException()
		{
			Assert.That(() => _parserForTestClassWithIntSampleArgument.Parse(_testClassWithIntSampleArgument, _emptyArgs),
				Throws.TypeOf<NArgException>().With.InnerException.Message.EqualTo("Number of required arguments and actual arguments don't match"));
		}

		[Test]
		public void Parse_UnexpectedMandatoryArgument_Throws()
		{
			var args = new string[] { "-ZOptRank2", "-POptRank1", "-QOptRank3", "-COptRank4", "foo" };

			Assert.That(() => _parserForTestClassWithOptionalRankedArguments.Parse(_testClassWithOptionalRankedArguments, args),
				Throws.TypeOf<NArgException>().With.InnerException.Message.EqualTo("Unexpected arguments"));
		}

		[Test]
		public void Parse_UnexpectedArgumentAfterTwoOptionalWithArguments_Throws()
		{
			var args = new string[] { "-SetSomethingElse", "1", "-SetSomething", "2", "foo" };

			Assert.That(() => _parserForTestClassWithTwoOptionalWithArgument.Parse(_testClassWithTwoOptionalWithArgument, args),
				Throws.TypeOf<NArgException>().With.InnerException.Message.EqualTo("Unexpected arguments"));
		}

		[Test]
		public void Parse_IncorrectOptionalArgumentWhenOnlyOneAllowed_Throws()
		{
			Assert.That(() => _parserForTestClassWithOneOptional.Parse(_testClassWithOneOptional, new string[] { "-foo" }),
							Throws.TypeOf<NArgException>().With.InnerException.Message.EqualTo("No matching argument for: foo"));
		}

		[Test]
		public void Parse_IncorrectOptionalArgumentWhenMultipleOptionsAllow()
		{
			Assert.That(() => _parserForTestClassWithOptionalRankedArguments.Parse(_testClassWithOptionalRankedArguments, new string[] { "-POptRank1", "-foo", "-QOptRank3" }),
							Throws.TypeOf<NArgException>().With.InnerException.Message.EqualTo("No matching argument for: foo"));

		}

		[Test]
		public void Parse_WhenOneArgumentIsExpectedAndTwoAreSupplied_ThrowsWithThrowsWithCorrectInnerException()
		{
			string[] args = new string[] { "7", "unexpected" };

			Assert.That(() => _parserForTestClassWithIntSampleArgument.Parse(_testClassWithIntSampleArgument, args),
				Throws.TypeOf<NArgException>().With.InnerException.Message.EqualTo("Unexpected arguments"));
		}

		[Test]
		public void Parse_TooManyRequiredArgs_Throws()
		{
			string[] args = new string[] { "1", "2", "3", "4", "5" };

			Assert.That(() => _parserForTestClassWithRequiredRankedArguments.Parse(_testClassWithRequiredRankedArguments, args),
						Throws.TypeOf<NArgException>().With.InnerException.Message.EqualTo("Unexpected arguments"));
		}

		[Test]
		public void Parse_TooManyRequiredArgsEvenThoughOptionalArgsAllowed_Throws()
		{
			string[] args = new string[] { "1", "2", "3", "4", "5" };

			Assert.That(() => _parserForTestClassWithRankedRequiredAndOptionalArguments.Parse(_testClassWithRankedRequiredAndOptionalArguments, args),
						Throws.TypeOf<NArgException>().With.InnerException.Message.EqualTo("Unexpected arguments"));
		}

		[Test]
		public void Parse_UsingNonAllowedValues_Throws()
		{
			string[] args = new string[] { "4" };

			Assert.That(() => _parserForTestClassWithIntArgumentWithAllowedValues.Parse(_testClassWithIntArgumentWithAllowedValues, args),
						Throws.TypeOf<NArgException>().With.InnerException.Message.EqualTo("Not an allowed value:4"));
		}

		[Test]
		public void Parse_WhenConsumeRemaingSetButNothingLeft_TheRestIsNullOrEmpty()
		{
			_parserForTestClassWithIntArgAndConsumeRemaining.Parse(_testClassWithIntArgAndConsumeRemaining, new string[] {"1"});

			Assert.That(_testClassWithIntArgAndConsumeRemaining.SampleArgumentValue, Is.EqualTo(1));
			Assert.That(_testClassWithIntArgAndConsumeRemaining.TheRest, Is.Empty);
		}

		[Test]
		public void Parse_WhenConsumeRemaingSetWithArgs1234_TheRestIs234()
		{
			_parserForTestClassWithIntArgAndConsumeRemaining.Parse(_testClassWithIntArgAndConsumeRemaining, new string[] { "1", "2", "3", "4" });

			Assert.That(_testClassWithIntArgAndConsumeRemaining.SampleArgumentValue, Is.EqualTo(1));
			Assert.That(_testClassWithIntArgAndConsumeRemaining.TheRest, Is.EqualTo(new string[] { "2", "3", "4"}));
		}

		[Test]
		public void Parse_WhenOnlyConsumeRemaingSetWithArgs1234_TheRestIs1234()
		{
			_parserForTestClassWithOnlyConsumeRemaining.Parse(_testClassWithOnlyConsumeRemaining, new string[] { "1", "2", "3", "4" });

			Assert.That(_testClassWithOnlyConsumeRemaining.TheRest, Is.EqualTo(new string[] { "1", "2", "3", "4" }));
		}
	}
}