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