public void factory_creates_instance_correctly(Guid streamId, Command1 payload)
{
StreamCommand <Command1> actual = StreamCommand.Create(streamId, payload);
actual.StreamId.Should().Be(streamId);
actual.Payload.Should().Be(payload);
}
public void ReturnsOneHandlers()
{
var command = new Command1();
var handler = new TestHandlersLookup().Handler(command);
Assert.Single(handler);
}
public string Buf()
{
string str = Header1.Trim() + " " + Command1.Trim() + " " + Datalen1.Trim() + " " + Checksum1.Trim() + " " + Data1.Trim() + " " + Data_checksum1.Trim();
str = str.ToUpper();
return(str);
}
public void when_receives_message_then_notifies_registered_handler()
{
var handlerAMock = new Mock <ICommandHandler>();
handlerAMock.As <ICommandHandler <Command1> >();
var handlerBMock = new Mock <ICommandHandler>();
handlerBMock.As <ICommandHandler <Command2> >();
this.processor.Register(handlerAMock.Object);
this.processor.Register(handlerBMock.Object);
this.processor.Start();
var command1 = new Command1 {
Id = Guid.NewGuid()
};
var command2 = new Command2 {
Id = Guid.NewGuid()
};
this.receiverMock.Raise(r => r.MessageReceived += null, new MessageReceivedEventArgs(new Message(Serialize(command1))));
this.receiverMock.Raise(r => r.MessageReceived += null, new MessageReceivedEventArgs(new Message(Serialize(command2))));
handlerAMock.As <ICommandHandler <Command1> >().Verify(h => h.Handle(It.Is <Command1>(e => e.Id == command1.Id)));
handlerBMock.As <ICommandHandler <Command2> >().Verify(h => h.Handle(It.Is <Command2>(e => e.Id == command2.Id)));
}
} // コンストラクタで生成するので初期化不要
public ReactiveCommand1ViewModel()
{
// 宣言時にインスタンスを作ってて、コンストラクタで Subscribe()
Command1
.Subscribe(() => Counter1.Increment())
.AddTo(CompositeDisposable);
// View の CommandParameter を加算。 WithSubscribeにより宣言からDispose登録まで一気通貫。
Command2 = new ReactiveCommand <int>()
.WithSubscribe(x => Counter2.Increment(x), CompositeDisposable.Add);
// CheckBox により（IObservable<bool>）から ReactiveCommand を作成
Command31 = CheckFlag31.ToReactiveCommand(initialValue: false)
.WithSubscribe(() => Counter3.Increment(), CompositeDisposable.Add);
var updateTimeTrigger = new Subject <Unit>();
CompositeDisposable.Add(updateTimeTrigger);
// IObservable<bool> から ReactiveCommand を作成
// 実行後に一定時間は CanExecute を無効にする (ひねくれずに AsyncReactiveCommand を使えばよいと思う)
Command32 = Observable.Merge(
updateTimeTrigger.Select(_ => false),
updateTimeTrigger.Delay(TimeSpan.FromSeconds(0.5)).Select(_ => true))
.ToReactiveCommand()
.AddTo(CompositeDisposable);
Command32
.Do(_ => updateTimeTrigger.OnNext(Unit.Default))
.Subscribe(_ => Counter3.Increment())
.AddTo(CompositeDisposable);
}
// Use this for initialization
void Start () {
Invoker invoker = new Invoker ();
IReceive reveive = new Receive1 ();
ICommand command = new Command1 ();
command.ConstructCommand (reveive, "command");
invoker.AddCommand (command);
invoker.AddCommand (command);
invoker.Execute ();
}
public async Task PostFilterAsync_Pops()
{
var command = new Command1();
await sut.PreFilterAsync(command);
await sut.PostFilterAsync(command, null);
commandContextStack.PeekOrDefault.Should().BeNull();
}
public async Task FilterExceptionAsync_Pops()
{
var command = new Command1();
await sut.PreFilterAsync(command);
await sut.FilterExceptionAsync(command, new IOException());
commandContextStack.PeekOrDefault.Should().BeNull();
}
public async Task PreFilterAsync_CreatesNewCommandContext()
{
var command = new Command1();
await sut.PreFilterAsync(command);
commandContextStack.CurrentCommand.Should().Be(command);
unitOfWorkFactory.Received(1).CreateUnitOfWork();
commandContextStack.UnitOfWork.Should().Be(unitOfWork);
}
public async Task PostFilterAsync_CommitsForCommands()
{
var command = new Command1();
await sut.PreFilterAsync(command);
await sut.PostFilterAsync(command, null);
unitOfWorkFactory.Received(1).CreateUnitOfWork();
unitOfWork.Received(1).CommitAsync();
}
public async Task HandleAsync_PopsCommandContextOnException()
{
var command = new Command1();
CommandBusMiddlewareDelegate next = async paramCommand => { throw new Exception(); };
await sut.Awaiting(x => x.HandleAsync(command, CommandExecutionOptions.Default,
next, CancellationToken.None)).Should().ThrowExactlyAsync <Exception>();
commandContextStack.PeekOrDefault.Should().BeNull();
}
private async Task Publish1Async()
{
var q = CreateQueue <Command1>();
for (var i = 0; i < 10; i++)
{
var cmd = new Command1(100 + i);
_logger.LogInformation($"{DateTime.UtcNow:O}: Publish\tCommand1 {cmd.Id}");
await q.EnqueueAsync(cmd);
}
}
public void WHEN_throws_THEN_retries()
{
this.processor.Register(new BuggyCommandHandler());
this.processor.Start();
var command1 = new Command1 {
Id = Guid.NewGuid()
};
Assert.Throws(new Exception().GetType(),
() => this.receiverMock.Raise(r => r.MessageReceived += null, new MessageReceivedEventArgs(new MessageForDelivery(Serialize(command1)))));
}
public async Task HandleAsync_DoesNotCommitWhenConfigured()
{
var command = new Command1();
CommandBusMiddlewareDelegate next = async paramCommand =>
{
commandContextStack.UnitOfWork.Should().BeNull();
return(null);
};
await sut.HandleAsync(command, new CommandExecutionOptions(false, null),
next, CancellationToken.None);
unitOfWorkFactory.DidNotReceive().CreateUnitOfWork();
}
private void cmddelete_Click(object sender, EventArgs e)
{
DataRowView drv = (DataRowView)grid1.SelectedRows[0].DataBoundItem;
int id = int.Parse(drv.Row["id"].ToString());
Command1.Connection = Connection1;
Command1.CommandText = "DELETE FROM rahnimaghaze WHERE ID = " + id.ToString();
Connection1.Open();
Command1.ExecuteNonQuery();
Connection1.Close();
BindData();
}
public async Task HandleAsync_CommitsForCommands()
{
var command = new Command1();
CommandBusMiddlewareDelegate next = async paramCommand =>
{
commandContextStack.UnitOfWork.Should().Be(unitOfWork);
return(null);
};
await sut.HandleAsync(command, CommandExecutionOptions.Default,
next, CancellationToken.None);
unitOfWorkFactory.Received(1).CreateUnitOfWork();
unitOfWork.Received(1).CommitAsync();
}
public void DoStuff()
{
var invoker = new Invoker();
var receiver = new Receiver();
var command = new Command1(receiver, "CommandStuff 1");
invoker.SetCommand(command);
invoker.ExecuteCommand();
command = new Command1(receiver, "CommandStuff 2");
invoker.SetCommand(command);
invoker.ExecuteCommand();
}
public void when_receives_message_then_notifies_registered_handler()
{
var handlerAMock = new Mock<ICommandHandler>();
handlerAMock.As<ICommandHandler<Command1>>();
var handlerBMock = new Mock<ICommandHandler>();
handlerBMock.As<ICommandHandler<Command2>>();
this.processor.Register(handlerAMock.Object);
this.processor.Register(handlerBMock.Object);
this.processor.Start();
var command1 = new Command1 { Id = Guid.NewGuid() };
var command2 = new Command2 { Id = Guid.NewGuid() };
this.receiverMock.Raise(r => r.MessageReceived += null, new MessageReceivedEventArgs(new Message(Serialize(command1))));
this.receiverMock.Raise(r => r.MessageReceived += null, new MessageReceivedEventArgs(new Message(Serialize(command2))));
handlerAMock.As<ICommandHandler<Command1>>().Verify(h => h.Handle(It.Is<Command1>(e => e.Id == command1.Id)));
handlerBMock.As<ICommandHandler<Command2>>().Verify(h => h.Handle(It.Is<Command2>(e => e.Id == command2.Id)));
}
public async Task HandleAsync_PushesAndPopsCommandContext()
{
var command = new Command1();
var expectedResult = new object();
int invokedNext = 0;
CommandBusMiddlewareDelegate next = async paramCommand =>
{
paramCommand.Should().Be(command);
commandContextStack.CurrentCommand.Should().Be(command);
unitOfWorkFactory.Received(1).CreateUnitOfWork();
commandContextStack.UnitOfWork.Should().Be(unitOfWork);
invokedNext++;
return(expectedResult);
};
var result = await sut.HandleAsync(command, CommandExecutionOptions.Default,
next, CancellationToken.None);
invokedNext.Should().Be(1);
result.Should().Be(expectedResult);
commandContextStack.PeekOrDefault.Should().BeNull();
}
public Task Handle(Command1 command)
{
return(Task.CompletedTask);
}
public CommandFactory(Command1 command)
{
_command = command;
}
public void Handle(Command1 command)
{
}
public Task Handle(Command1 message, IMessageHandlerContext context)
{
Console.WriteLine("Received Command1");
return(Task.FromResult(0));
}
public void Handle(Command1 command)
{
Value = command.Value;
}
public bool CanExecute(object parameter)
{
return
((Command1 == null || Command1.CanExecute(parameter)) &&
(Command2 == null || Command2.CanExecute(parameter)));
}
public async Task Handle(Command1 command)
{
await Bus.Publish(new Command1ExecutedEvent(), command);
}
private void SelectedItemChanged(object sender, EventArgs e)
{
// Update the command status.
Command1.RaiseCanExecuteChanged();
}
public int Handle(Command1 command)
{
return 1;
}
public void Execute(object parameter)
{
Command1?.Execute(parameter);
Command2?.Execute(parameter);
}
private void InitializeCommands()
{
Command1 = new Command1(this);
}
