public void Allow_Auto_Help_To_Be_Registered()
{
// arrange
var mockRenderer = new Mock <ITemplateRenderer>();
mockRenderer.SetupAllProperties();
var isHelpRequested = false;
var builder = DefaultBuilder.CreateDefaultBuilder()
.RegisterExtensions()
.AddAutoHelp((results, exceptions) =>
{
isHelpRequested = true;
var first = results.Keys.OfType <UtilOptions>().FirstOrDefault();
if (first != null && first.IsHelpRequested)
{
return(results[first].Id);
}
return(null);
}, factory =>
{
factory.TemplateRenderer = mockRenderer.Object;
return(factory);
});
// act
builder.Parse("-h".Split(' '));
// assert
isHelpRequested.Should().BeTrue();
}
public void Work_With_Letters()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
var root = builder.Context.ParserRepository.Get("util");
string value = null;
var sut = new SeparatedSwitch(root, 'v', "value", (o, s) => { value = s; })
{
Separator = ":"
};
var info = new IterationInfo("-v:a".Split(' '));
// act
// assert
var canConsumeResult = sut.CanConsume("", info);
canConsumeResult.ConsumingParameter.Should().BeSameAs(sut);
canConsumeResult.NumConsumed.Should().Be(1);
canConsumeResult.ParseExceptions.Should().BeEmpty();
canConsumeResult.Info.Index.Should().Be(1);
var consumeResult = sut.Consume("", new ConsumptionRequest(info));
consumeResult.ConsumingParameter.Should().BeSameAs(sut);
consumeResult.NumConsumed.Should().Be(1);
consumeResult.ParseExceptions.Should().BeEmpty();
consumeResult.Info.Index.Should().Be(1);
}
public void Not_Throw_If_An_Unexpected_Argument_Is_Found()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
var strat = new ParseStrategy(builder.Context);
var mock = new Mock <IPotentialConsumerStrategy>();
mock.SetupAllProperties();
mock.Setup(s => s.IdentifyPotentialConsumer(It.IsAny <PotentialConsumerRequest>())).Returns(
new PotentialConsumerResult(builder.Context.PathToRoot("util"), new ConsumptionResult[0],
new IterationInfo("-h".Split(' '))));
strat.PotentialConsumerStrategy = mock.Object;
IParseResult res = null;
Action mightThrow = () => res = strat.Parse("-h".Split(' '));
// act
// assert
mightThrow.Should().NotThrow();
var isParsed = false;
res.WhenError(exceptions =>
{
exceptions.Single().Should().BeOfType <UnexpectedArgException>();
isParsed = true;
});
isParsed.Should().BeTrue();
}
public void Can_build_book()
{
var book = DefaultBuilder.Create <Book>()
.Build();
Assert.IsInstanceOfType(book, typeof(Book));
}
public void TestPipOutputFingerprinting(FileExistence existence, FileExistence anotherExistence)
{
// Arrange
var pathTable = m_context.PathTable;
var executable = FileArtifact.CreateSourceFile(AbsolutePath.Create(pathTable, X("/x/pkgs/tool.exe")));
AbsolutePath outputPath = AbsolutePath.Create(pathTable, X("/x/obj/working/out.bin"));
FileArtifactWithAttributes output = new FileArtifactWithAttributes(outputPath, rewriteCount: 1, fileExistence: existence);
Process process = DefaultBuilder.WithOutputs(output).Build();
Process processSecondVersion = DefaultBuilder.WithOutputs(output.CreateNextWrittenVersion()).Build();
var outputWithDifferenceExistence = new FileArtifactWithAttributes(outputPath, rewriteCount: 1, fileExistence: anotherExistence);
var processWithDifferenceExistence = DefaultBuilder.WithOutputs(outputWithDifferenceExistence).Build();
var fingerprinter = CreateFingerprinter(executable);
// Act
var fingerprint = fingerprinter.ComputeFingerprint(process);
// Assert
XAssert.AreEqual(fingerprint, fingerprinter.ComputeFingerprint(processSecondVersion),
"RewriteCount should not affect the fingerprint");
XAssert.AreNotEqual(fingerprint, fingerprinter.ComputeFingerprint(processWithDifferenceExistence),
"Two process with the same output path but with different attributes should produce different fingerprints");
}
public void BindDefault(DefaultBuilder builder)
{
_defaultBuilders.Add(builder);
// new types available - clear caches
ClearCaches();
}
public void Can_assert_result()
{
DefaultBuilder.Create <TestingClass>()
.When()
.Invoke(x => 5000)
.ThenIs(5000);
}
public void Not_Throw_If_Asking_For_An_Unregistered_Context()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
Action mightThrow0 = () => builder.Context.ToExtensionContext();
// act
// assert
mightThrow0.Should().NotThrow();
}
public void Return_The_Children_Of_The_Requested_Node()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
// act
// assert
builder.Context.HierarchyRepository.GetChildren("util").Should()
.Contain("clipboard convert firewall".Split(' '));
}
public void Book_requires_title_and_serial()
{
var bookWithoutTitle = DefaultBuilder.Create <Book>()
.Build();
_sut.When()
.Validate(bookWithoutTitle)
.ThenExpectException <ArgumentException>();
}
public void Valid_book_is_valid()
{
DefaultBuilder.Create <Book>()
.Valid()
.When()
.PerformValidateModel("book")
.ThenSuccess();
}
public void Default_book_isnt_valid()
{
DefaultBuilder.Create <Book>()
.When()
.PerformValidateModel("book")
.ThenExpectException <ArgumentException>()
.WithParameter("book");
}
public void Calls_book_serial_validator_validate_method()
{
var book = DefaultBuilder.Create <Book>()
.Valid()
.Build();
_sut.When()
.Validate(book)
.ThenReceived(BookSerialValidator, x => x.Validate(book.Serial));
}
public void Can_validate_valid_book()
{
var book = DefaultBuilder.Create <Book>()
.Valid()
.Build();
_sut.When()
.Validate(book)
.ThenSuccess();
}
public void Allow_Themes_To_Be_Set_After_They_Have_Been_Created()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder()
.SetTheme("util", Theme.Cool)
.SetTheme("util", Theme.Warm);
// act
// assert
ContextBuilderExtensions.ParserThemes[builder.Context.ParserRepository.Get("util")].Should().Be(Theme.Warm);
}
public void Valid_serial_is_valid()
{
var serial = DefaultBuilder.Create <BookSerial>()
.Valid()
.Build();
_sut.When()
.Validate(serial)
.ThenSuccess();
}
public void Only_Group_If_The_Entire_Arg_Matches_And_Not_When_A_Subtring_Matches()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
var request = new MutateArgsRequest("--help".Split(' '), builder.Context.ParserRepository.Get("util").ToEnumerableOfOne(), builder.Context);
var mutator = new ArgsMutator(builder.Context);
// act
// assert
mutator.Mutate(request).Should().BeEquivalentTo("--help".ToEnumerableOfOne(), "Although the arg contains -h, it is not the entire arg and thus does not match");
}
public void First_group_must_be_3_characters_long()
{
var serial = DefaultBuilder.Create <BookSerial>()
.Valid()
.SetGroup(0, "12")
.Build();
_sut.When()
.Validate(serial)
.ThenExpectException <GroupParseException>();
}
public void Serial_must_have_three_groups()
{
var serial = DefaultBuilder.Create <BookSerial>()
.WithGroup("123")
.WithGroup("123")
.Build();
_sut.When()
.Validate(serial)
.ThenExpectException <GroupCountException>();
}
public void Checking_result_from_action_raises_error()
{
var test = DefaultBuilder.Create <TestingClass>()
.When()
.Invoke(x => { });
void When()
{
test.ThenIs(true);
}
Assert.ThrowsException <NoResultFromActionException>((Action)When);
}
public void Then_success_fails_if_exception_is_thrown()
{
var test = DefaultBuilder.Create <TestingClass>()
.When()
.Invoke(x => throw new Exception());
void When()
{
test.ThenSuccess();
}
Assert.ThrowsException <TestFailedException>((Action)When);
}
public void Asserting_incorrect_result_raises_Exception()
{
var test = DefaultBuilder.Create <TestingClass>()
.When()
.Invoke(x => 4999);
void When()
{
test.ThenIs(5000);
}
Assert.ThrowsException <TestFailedException>((Action)When);
}
public void Create_A_Theme_Repository_With_All_Added_Themes()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
builder.SetTheme("util", Theme.Cool);
// act
var res = builder.Context.ToExtensionContext();
// assert
res.ThemeRepository.Get("util").Should().BeSameAs(Theme.Cool);
}
public void Not_Do_Anything_For_Positionals()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
builder.SetSwitchTokens("#", "##");
// act
builder.AddParser("whatever").WithPositional((o, s) => { });
// assert
builder.Context.ParserRepository.Get("whatever").Should().NotBeNull();
}
public void Book_title_cannot_be_null()
{
var bookWithoutTitle = DefaultBuilder.Create <Book>()
.Valid()
.With(x => x.Title = null)
.Build();
_sut.When()
.Validate(bookWithoutTitle)
.ThenExpectException <ArgumentException>()
.WithParameter(nameof(Book.Title));
}
public void Doesnt_stop_exception_from_validate()
{
BookSerialValidator.When(x => x.Validate(Arg.Any <string>())).Throw <TestingException>();
var book = DefaultBuilder.Create <Book>()
.Valid()
.Build();
_sut.When()
.Validate(book)
.ThenExpectException <TestingException>();
}
public void ShouldBuiltDateReturnGoodValueForDefault()
{
//Arrange
var firstDate = new DateTime(2000, 1, 1);
var secondDate = new DateTime(2021, 5, 14);
const string expedtedDateString = "01.01.2000 - 14.05.2021";
var builder = new DefaultBuilder();
//Act
var actualOutput = builder.BuildDate(firstDate, secondDate);
//Assert
Assert.Equal(expedtedDateString, actualOutput);
}
public void Only_Consume_Until_The_Mutated_Args_No_Longer_Match()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
var fac = new IterationInfoFactory(builder.Context);
var parsers = builder.Context.PathToRoot("firewall").Reverse();
var res = new ChainIdentificationResult(parsers, new[] { "firewall" });
var req = new IterationInfoRequest(res, "firewall -s -l".Split(' '), "firewall -h -h -h".Split(' '));
// act
var result = fac.Create(req);
// assert
result.Args.Should().BeEquivalentTo("firewall -s -l".Split(' '));
result.Index.Should().Be(1);
}
public void Consume_Everything_After_The_Separator_As_A_Single_Value0()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
var root = builder.Context.ParserRepository.Get("util");
string value = null;
var sut = new SeparatedSwitch(root, 'v', "value", (o, s) => { value = s; });
// act
var info = new IterationInfo("-v=a".Split(' '));
var res = sut.Consume("", new ConsumptionRequest(info));
// assert
res.ConsumingParameter.Should().BeSameAs(sut);
value.Should().Be("a");
}
private static string GetRegex(int rule, IDictionary <int, Body> rules, IDictionary <int, Builder> overrides)
{
IDictionary <int, string> cache = new Dictionary <int, string>();
DefaultBuilder defaultBuilder = new DefaultBuilder();
string GetRegexInternal(int rule, IDictionary <int, Body> rules, IDictionary <int, Builder> overrides)
{
if (!overrides.TryGetValue(rule, out Builder builder))
{
builder = defaultBuilder;
}
return(builder.Build(rules[rule], r => GetRegexInternal(r, rules, overrides)));
}
return(GetRegexInternal(rule, rules, overrides));
}
