public void Should_ThrowException_When_NullCommand()
{
var command = new RuleCommand <TestClass>(x => true);
var builder = new RuleCommandScopeBuilder <TestClass>(command);
Action action = () => builder.TryAdd(null);
action.Should().ThrowExactly <ArgumentNullException>();
}
public void Should_Get_RuleBlockBuilder()
{
Predicate <object> predicate = x => true;
var command = new RuleCommand <object>(predicate);
var blockBuilder = command.GetScopeBuilder();
blockBuilder.Should().NotBeNull();
blockBuilder.Should().BeAssignableTo <RuleCommandScopeBuilder <object> >();
}
public RuleCommandScopeBuilder(RuleCommand <T> ruleCommand)
{
ThrowHelper.NullArgument(ruleCommand, nameof(ruleCommand));
_ruleCommand = ruleCommand;
if (_ruleCommand.Message != null)
{
_errorsBuilder = new ErrorBuilder(_ruleCommand.Message, _ruleCommand.Args);
}
}
public void Should_ReturnRuleCommandScope()
{
var command = new RuleCommand <TestClass>(x => true);
var context = Substitute.For <IScopeBuilderContext>();
var builder = new RuleCommandScopeBuilder <TestClass>(command);
var builtScope = builder.Build(context);
builtScope.Should().BeOfType <RuleCommandScope <TestClass> >();
}
private async Task <object?> PublishIdempotentAsync(RuleCommand command)
{
var result = await PublishAsync(command);
var previousSnapshot = sut.Snapshot;
var previousVersion = sut.Snapshot.Version;
await PublishAsync(command);
Assert.Same(previousSnapshot, sut.Snapshot);
Assert.Equal(previousVersion, sut.Snapshot.Version);
return(result);
}
public void TestLoadCommand()
{
Mockery mockery = new Mockery();
IProjectSerializer serializer = mockery.NewMock <IProjectSerializer>();
RuleCommand rc = new RuleCommand();
Expect.Once.On(serializer).GetProperty("LineNumber").Will(Return.Value(1));
Expect.Once.On(serializer).Method("ReadTextToken").Will(Return.Value(new Token(TokenType.Text, "a", 0, 1)));
Expect.Once.On(serializer).Method("ReadTextToken").Will(Return.Value(null));
rc.LoadCommand(serializer);
Assert.AreEqual("a", rc.Rule);
mockery.VerifyAllExpectationsHaveBeenMet();
}
public void TestLoadCommand()
{
Mockery mockery = new Mockery();
IProjectSerializer serializer = mockery.NewMock<IProjectSerializer>();
RuleCommand rc = new RuleCommand();
Expect.Once.On(serializer).GetProperty("LineNumber").Will(Return.Value(1));
Expect.Once.On(serializer).Method("ReadTextToken").Will(Return.Value(new Token(TokenType.Text, "a", 0, 1)));
Expect.Once.On(serializer).Method("ReadTextToken").Will(Return.Value(null));
rc.LoadCommand(serializer);
Assert.AreEqual("a", rc.Rule);
mockery.VerifyAllExpectationsHaveBeenMet();
}
public void Should_ReturnRuleCommandScope_WithIsValidPredicate()
{
Predicate <TestClass> predicate = x => true;
var command = new RuleCommand <TestClass>(predicate);
var context = Substitute.For <IScopeBuilderContext>();
var builder = new RuleCommandScopeBuilder <TestClass>(command);
var builtScope = builder.Build(context);
builtScope.Should().BeOfType <RuleCommandScope <TestClass> >();
var ruleCommandScope = (RuleCommandScope <TestClass>)builtScope;
ruleCommandScope.IsValid.Should().Be(predicate);
}
public void Should_GetRuleBlock_With_Predicate()
{
Predicate <object> predicate = x => true;
var command = new RuleCommand <object>(predicate);
var blockBuilder = command.GetScopeBuilder();
var buildingContext = Substitute.For <IScopeBuilderContext>();
var block = blockBuilder.Build(buildingContext);
block.Should().BeOfType <RuleCommandScope <object> >();
var ruleBlock = (RuleCommandScope <object>)block;
ruleBlock.IsValid.Should().BeSameAs(predicate);
}
private async Task <object?> PublishAsync(RuleCommand command)
{
var result = await sut.ExecuteAsync(CreateRuleCommand(command));
return(result);
}
public CommandInvoker(RuleCommand newRuleCommand)
{
ruleCommand = newRuleCommand;
}
