public async Task StartConsumingPublishesConsumedMessageToMediator()
{
var fakeMessage = new FakeMessage("some-key-id", "some-property-value");
var cancellationTokenSource = new CancellationTokenSource();
var mockMediator = new Mock <IMediator>();
var serviceProvider = BuildServiceProvider(mockMediator.Object);
var stubLogger = Mock.Of <ILogger <KafkaTopicMessageConsumer> >();
var stubConsumer = new Mock <IConsumer <string, string> >();
stubConsumer
.Setup(x => x.Consume(It.IsAny <CancellationToken>()))
.Returns(BuildFakeConsumeResult(fakeMessage));
var stubMessageConsumerBuilder = new Mock <IKafkaConsumerBuilder>();
stubMessageConsumerBuilder
.Setup(x => x.Build())
.Returns(stubConsumer.Object);
// TODO: find better way to test than relying on async timing
var sut = new KafkaTopicMessageConsumer(stubLogger, stubMessageConsumerBuilder.Object, serviceProvider);
Task.Run(() => sut.StartConsuming("fake-messages", cancellationTokenSource.Token));
await Task.Delay(500);
cancellationTokenSource.Cancel();
mockMediator.Verify(x =>
x.Publish(
It.Is <object>(i => i.GetType() == typeof(MessageNotification <FakeMessage>)),
It.IsAny <CancellationToken>()));
}
public IActionResult Add(int id, string message) // satıcı id gelir. alanId
{
if (!(Convert.ToBoolean(HttpContext.Session.GetString("Active"))))
{
return(RedirectToAction("Login", "IO"));
}
string tempId = HttpContext.Session.GetString("id");
int userId = int.Parse(tempId); //yollayanId
Message mesaj = new Message()
{
AlanId = id,
YollayanId = userId,
Mesaj = message,
MesajTarihi = DateTime.Now
};
_messageService.Add(mesaj);
FakeMessage fakeMessage = new FakeMessage() // fake mesaj veritabanına ürün eklendi
{
RealMessageId = mesaj.Id,
AlanId = id,
Mesaj = message,
MesajTarihi = mesaj.MesajTarihi,
YollayanId = userId
};
_fakeMessageService.Add(fakeMessage);
return(RedirectToAction("GetAll", "Product"));
}
public void AfterReceiveReply(ref Message reply, object correlationState)
{
if (reply.IsFault)
{
reply = new FakeMessage(reply.Version, (string)correlationState);
}
}
protected override void given_the_context_of()
{
_node = Mock<IInteractionNode>();
_element = new FakeElement();
_message = new FakeMessage {AvailabilityEffect = Mock<IAvailabilityEffect>()};
}
public void methods_with_parameters_equal_to_those_provided_should_yield_provided()
{
const string param1 = "a string";
const int param2 = 56;
var message = new FakeMessage
{
Parameters = new FreezableCollection<Parameter>
{
new Parameter {Value = param1},
new Parameter {Value = param2}
}
};
message.Initialize(_sourceNode);
var requirements = new List<RequiredParameter>
{
new RequiredParameter("param1", typeof(string)),
new RequiredParameter("param2", typeof(int))
};
var result = _binder.DetermineParameters(
message, requirements, _handlingNode, null
);
Assert.That(result, Has.Length(2));
Assert.That(result, Has.Member(param1));
Assert.That(result, Has.Member(param2));
}
public void parameters_should_be_coerced_to_the_proper_type()
{
const int param1 = 56;
const double param2 = 34.0;
var message = new FakeMessage
{
Parameters = new FreezableCollection<Parameter>
{
new Parameter {Value = param1},
new Parameter {Value = param2}
}
};
message.Initialize(_sourceNode);
var requirements = new List<RequiredParameter>
{
new RequiredParameter("param1", typeof(string)),
new RequiredParameter("param2", typeof(int))
};
var result = _binder.DetermineParameters(
message, requirements, _handlingNode, null
);
Assert.That(result, Has.Length(2));
Assert.That(result, Has.Member(param1.ToString()));
Assert.That(result, Has.Member(Convert.ToInt32(param2)));
}
public void if_none_are_provided_check_for_value()
{
var source = new TextBox {
Text = "the text"
};
sourceNode.Stub(x => x.UIElement).Return(source);
var defaults = Stub <IElementConvention>();
conventionManager.Expect(x => x.GetElementConvention(typeof(TextBox)))
.Return(defaults);
defaults.Expect(x => x.GetValue(source)).Return(source.Text);
var message = new FakeMessage();
message.Initialize(sourceNode);
var element = new ControlHost();
handlingNode.Stub(x => x.UIElement).Return(element).Repeat.Twice();
var requirements = new List <RequiredParameter>
{
new RequiredParameter("value", typeof(object)),
};
var result = binder.DetermineParameters(
message, requirements, handlingNode, null
);
result.Length.ShouldBe(1);
result.Contains(source.Text).ShouldBeTrue();
}
public void TestUnencrypted()
{
using var buffer = new PacketBuffer();
using (var message = new FakeMessage {
Text = text, MessageFlags = MessageFlags.Unencrypted
})
{
message.WritePacket(buffer, PacketRole.Client);
}
buffer.Position = 0;
byte[]? content;
using (var received = new FakeMessage())
{
received.ReadPacket(buffer, PacketRole.Server);
content = received.PacketContent;
Assert.AreEqual(text, received.Text);
}
// Reading a packet must not alter its contents
Assert.IsNotNull(content);
using var contentBuffer = new PacketBuffer(content);
Assert.AreEqual(text, contentBuffer.ReadMediumString());
}
public void parameters_should_be_coerced_to_the_proper_type()
{
const int param1 = 56;
const double param2 = 34.0;
var message = new FakeMessage
{
Parameters = new FreezableCollection <Parameter>
{
new Parameter {
Value = param1
},
new Parameter {
Value = param2
}
}
};
message.Initialize(sourceNode);
var requirements = new List <RequiredParameter>
{
new RequiredParameter("param1", typeof(string)),
new RequiredParameter("param2", typeof(int))
};
var result = binder.DetermineParameters(
message, requirements, handlingNode, null
);
result.Length.ShouldBe(2);
result.Contains(param1.ToString()).ShouldBeTrue();
result.Contains(Convert.ToInt32(param2)).ShouldBeTrue();
}
public async Task ProcessMessagesAsync_Message_VerifyVerison()
{
// assert
const int testVersion = 1;
Message testMesage = new Message();
var deserializedMessage = new FakeMessage(testVersion);
var handlerMock = new Mock <IMessageHandler>();
var messageSerialzier = new Mock <IMessageSerializer>();
messageSerialzier.Setup(x => x.Deserialize <IMessage>(It.IsAny <Message>()))
.Returns(deserializedMessage);
var versionChecker = new Mock <IVersionChecker>();
versionChecker.Setup(x => x.Check(It.IsAny <int>(), It.IsAny <Type>())).Callback <int, Type>((y, t) =>
{
});
var handler = new MessageProcessor(handlerMock.Object, versionChecker.Object, messageSerialzier.Object);
// act
await handler.ProcessMessagesAsync(testMesage, CancellationToken.None);
// arrange
versionChecker.Verify(x => x.Check(It.Is <int>(ver => ver == testVersion), It.Is <Type>(type => type == deserializedMessage.GetType())), Times.Once);
messageSerialzier.Verify(x => x.Deserialize <IMessage>(It.Is <Message>(msg => msg == testMesage)), Times.Once);
}
public void if_none_are_provided_check_for_dataContext()
{
var source = new Button {
DataContext = new object()
};
sourceNode.Stub(x => x.UIElement).Return(source);
var message = new FakeMessage();
message.Initialize(sourceNode);
var element = new ControlHost();
handlingNode.Stub(x => x.UIElement).Return(element).Repeat.Twice();
var requirements = new List <RequiredParameter>
{
new RequiredParameter("datacontext", typeof(object)),
};
var result = binder.DetermineParameters(
message, requirements, handlingNode, null
);
result.Length.ShouldBe(1);
result.Contains(source.DataContext).ShouldBeTrue();
}
public void ItShouldGetConsumersFromTheContainer()
{
using (var container = new Container()) {
var consumerAssemblies = new[] { GetType().Assembly };
container.Register(typeof(Consumes <> .All), consumerAssemblies);
var endpointUri = new Uri("loopback://localhost/queue");
container.RegisterSingleton(() =>
ServiceBusFactory.New(sbc => {
sbc.ReceiveFrom(endpointUri);
sbc.Subscribe(subs => {
// ReSharper disable AccessToDisposedClosure
subs.LoadFrom(container);
// ReSharper restore AccessToDisposedClosure
});
}));
container.Verify();
var bus = container.GetInstance <IServiceBus>();
var message = new FakeMessage {
Moment = DateTime.Now
};
bus.GetEndpoint(endpointUri).Send(message);
Thread.Sleep(100);
Assert.Equal(1, FakeMessage.MessageConsumedCount);
}
}
public void should_resolve_special_parameter_dataContext()
{
const string param1 = "$dataContext";
var source = new Button {
DataContext = new object()
};
var message = new FakeMessage
{
Parameters = new FreezableCollection <Parameter>
{
new Parameter {
Value = param1
},
}
};
sourceNode.Stub(x => x.UIElement).Return(source);
message.Initialize(sourceNode);
var requirements = new List <RequiredParameter>
{
new RequiredParameter("param1", typeof(object))
};
var result = binder.DetermineParameters(
message, requirements, handlingNode, null
);
result.Length.ShouldBe(1);
result.Contains(source.DataContext).ShouldBeTrue();
}
public void Start_ConsumingPublishesConsumedMessageToMediator()
{
//Arrange
var fakeMessage = new FakeMessage("some-property-value");
var cancellationTokenSource = new CancellationTokenSource();
var mockMediator = new Mock <IMediator>();
var stubMapper = Mock.Of <IMapper>();
var serviceProvider = BuildServiceProvider(mockMediator.Object);
var stubLogger = Mock.Of <ILogger <KafkaTopicMessageConsumer <FakeAvro, FakeMessage> > >();
var stubConsumer = new Mock <IConsumer <string, FakeAvro> >();
stubConsumer
.Setup(x => x.Consume(It.IsAny <CancellationToken>()))
.Returns(BuildFakeConsumeResult(fakeMessage));
var stubMessageConsumerBuilder = new Mock <IKafkaConsumerBuilder <FakeAvro> >();
stubMessageConsumerBuilder
.Setup(x => x.Build())
.Returns(stubConsumer.Object);
//Act
var sut = new KafkaTopicMessageConsumer <FakeAvro, FakeMessage>(stubLogger, stubMessageConsumerBuilder.Object, serviceProvider, stubMapper);
//Running inside another thread to use "cancellationTokenSource.Cancel()"
Task.Run(() => sut.StartConsuming("fake-messages", cancellationTokenSource.Token));
Task.Delay(500).Wait();
cancellationTokenSource.Cancel();
//Assert
mockMediator.Verify(x =>
x.Publish(
It.Is <object>(i => i.GetType() == typeof(MessageNotification <FakeMessage>)),
It.IsAny <CancellationToken>()));
}
public void should_resolve_special_parameter_parameter()
{
const string param1 = "$parameter";
var context = new object();
var message = new FakeMessage
{
Parameters = new FreezableCollection <Parameter>
{
new Parameter {
Value = param1
},
}
};
message.Initialize(sourceNode);
var requirements = new List <RequiredParameter>
{
new RequiredParameter("param1", typeof(object))
};
var result = binder.DetermineParameters(
message, requirements, handlingNode, context
);
result.Length.ShouldBe(1);
result.Contains(context).ShouldBeTrue();
}
public void methods_with_parameters_equal_to_those_provided_should_yield_provided()
{
const string param1 = "a string";
const int param2 = 56;
var message = new FakeMessage
{
Parameters = new FreezableCollection <Parameter>
{
new Parameter {
Value = param1
},
new Parameter {
Value = param2
}
}
};
message.Initialize(sourceNode);
var requirements = new List <RequiredParameter>
{
new RequiredParameter("param1", typeof(string)),
new RequiredParameter("param2", typeof(int))
};
var result = binder.DetermineParameters(
message, requirements, handlingNode, null
);
result.Length.ShouldBe(2);
result.Contains(param1).ShouldBeTrue();
result.Contains(param2).ShouldBeTrue();
}
public void ConstructorReturnsMessageNotification()
{
var fakeMessage = new FakeMessage("some-key", "some-property");
var sut = new MessageNotification <FakeMessage>(fakeMessage);
Assert.Equal(fakeMessage, sut.Message);
}
protected override void given_the_context_of()
{
node = Mock <IInteractionNode>();
element = new FakeElement();
message = new FakeMessage {
AvailabilityEffect = Mock <IAvailabilityEffect>()
};
}
public override void Context()
{
base.Context();
SubscriptionManager.subscribe <FakeMessage>(x =>
{
_wasCalled = true;
_localFakeMessage = x;
}, null, null);
}
public void cannot_process_a_non_action_message()
{
Assert.Throws <CaliburnException>(() => {
var context = new object();
var message = new FakeMessage();
handler.Process(message, context);
});
}
public override void Context()
{
base.Context();
SubscriptionManager.subscribe<FakeMessage>(x =>
{
_wasCalled = true;
_localFakeMessage = x;
}, null, null);
}
public void cannot_update_trigger_for_a_non_action_message()
{
Assert.Throws <CaliburnException>(() => {
var message = new FakeMessage();
var trigger = Mock <IMessageTrigger>();
trigger.Stub(x => x.Message).Return(message);
handler.UpdateAvailability(trigger);
});
}
public void Constructor_ReturnsMessageNotification()
{
//Arrange
var fakeMessage = new FakeMessage("some-property");
//Act
var sut = new MessageNotification <FakeMessage>(fakeMessage);
//Assert
Assert.Equal(fakeMessage, sut.Message);
}
public override void Context()
{
base.Context();
SubscriptionManager.subscribe <FakeMessage>(m =>
{
//stuff is happening
Thread.Sleep(2000);
_wasCalled = true;
_localFakeMessage = m;
Console.WriteLine("event complete");
}, null, null);
}
public void TestPacketContentUnencrypted()
{
byte[]? content;
using (var message = new FakeMessage {
Text = text, MessageFlags = MessageFlags.Unencrypted
})
content = message.PacketContent;
Assert.IsNotNull(content);
using var buffer = new PacketBuffer(content);
Assert.AreEqual(text, buffer.ReadMediumString());
}
public void tryexecute_chooses_the_right_path()
{
var fakeMessage = new FakeMessage();
var consumerCalled = false;
var fakeEnvelope = new Envelope();
Services.Inject(fakeEnvelope);
Services.PartialMockTheClassUnderTest();
ClassUnderTest.TryExecute(fakeMessage, _ => consumerCalled = true);
Assert.IsTrue(consumerCalled);
ClassUnderTest.AssertWasNotCalled(x => x.Execute(fakeMessage));
}
public void can_process_message_if_node_has_handler()
{
var context = new object();
var message = new FakeMessage();
var handler = Mock <IRoutedMessageHandler>();
handler.Expect(x => x.Initialize(node));
handler.Expect(x => x.Handles(message)).Return(true);
handler.Expect(x => x.Process(message, context));
node.RegisterHandler(handler);
node.ProcessMessage(message, context);
}
public void Send_Null_Message_Exception()
{
using (var test = CreateQueue())
{
Assert.Throws <ArgumentNullException>(
delegate
{
FakeMessage message = null;
// ReSharper disable once ExpressionIsAlwaysNull
test.Send(message);
});
}
}
private static ConsumeResult <string, string> BuildFakeConsumeResult(FakeMessage fakeMessage)
{
return(new ConsumeResult <string, string>
{
Message = new Message <string, string>
{
Value = JsonConvert.SerializeObject(fakeMessage),
Headers = new Headers
{
{ "message-type", Encoding.UTF8.GetBytes(fakeMessage.GetType().AssemblyQualifiedName) }
}
}
});
}
private static ConsumeResult <string, FakeAvro> BuildFakeConsumeResult(FakeMessage fakeMessage)
{
return(new ConsumeResult <string, FakeAvro>
{
Message = new Message <string, FakeAvro>
{
Value = fakeMessage,
Headers = new Headers
{
{ "message-type", Encoding.UTF8.GetBytes(fakeMessage.GetType().AssemblyQualifiedName) }
}
}
});
}
public void can_determine_if_a_message_is_handled()
{
var message = new FakeMessage();
var handler = Mock<IRoutedMessageHandler>();
handler.Expect(x => x.Initialize(_node));
handler.Expect(x => x.Handles(message)).Return(true);
_node.RegisterHandler(handler);
bool result = _node.Handles(message);
Assert.That(result, Is.True);
}
public void Serialize_Message_ReturnsConfiguratedMessage()
{
// arrange
var serializer = new MessageSerializer();
var message = new FakeMessage(1);
// act
var brokeredMessage = serializer.Serialize(message);
var body = new MemoryStream(brokeredMessage.Body);
// assert
Assert.Equal(brokeredMessage.UserProperties[CustomMessageProperties.MessageTypeProperty], message.GetType().FullName);
Assert.NotNull(body);
}
public void can_determine_if_a_message_is_handled()
{
var message = new FakeMessage();
var handler = Mock <IRoutedMessageHandler>();
handler.Expect(x => x.Initialize(node));
handler.Expect(x => x.Handles(message)).Return(true);
node.RegisterHandler(handler);
bool result = node.Handles(message);
result.ShouldBeTrue();
}
public void can_update_availability_if_node_has_handler()
{
var message = new FakeMessage();
var handler = Mock <IRoutedMessageHandler>();
var trigger = Mock <IMessageTrigger>();
handler.Expect(x => x.Initialize(node));
trigger.Expect(x => x.Message).Return(message);
handler.Expect(x => x.Handles(message)).Return(true);
handler.Expect(x => x.UpdateAvailability(trigger));
node.RegisterHandler(handler);
node.UpdateAvailability(trigger);
}
public void will_throw_exception_if_processing_node_is_not_found()
{
Assert.Throws <CaliburnException>(() => {
var context = new object();
var message = new FakeMessage();
var handler = Mock <IRoutedMessageHandler>();
node.RegisterHandler(handler);
handler.Expect(x => x.Handles(message)).Return(false);
controller.Expect(x => x.GetParent(element)).Return(null);
node.ProcessMessage(message, context);
});
}
public override void Context()
{
Message = new FakeMessage("yo", 12);
SubscriptionManager = new MessageSubscriptionManagerService(new EventAggregator());
}
public override void Context()
{
base.Context();
SubscriptionManager.subscribe<FakeMessage>(m =>
{
//stuff is happening
Thread.Sleep(2000);
_wasCalled = true;
_localFakeMessage = m;
Console.WriteLine("event complete");
}, null, null);
}
public void should_resolve_special_parameter_parameter()
{
const string param1 = "$parameter";
var context = new object();
var message = new FakeMessage
{
Parameters = new FreezableCollection<Parameter>
{
new Parameter {Value = param1},
}
};
message.Initialize(_sourceNode);
var requirements = new List<RequiredParameter>
{
new RequiredParameter("param1", typeof(object))
};
var result = _binder.DetermineParameters(
message, requirements, _handlingNode, context
);
Assert.That(result, Has.Length(1));
Assert.That(result, Has.Member(context));
}
public void will_throw_exception_if_processing_node_is_not_found()
{
var context = new object();
var message = new FakeMessage();
var handler = Mock<IRoutedMessageHandler>();
_node.RegisterHandler(handler);
handler.Expect(x => x.Handles(message)).Return(false);
_controller.Expect(x => x.GetParent(_element)).Return(null);
_node.ProcessMessage(message, context);
}
public void can_update_availability_if_parent_node_has_handler()
{
var message = new FakeMessage();
var handler = Mock<IRoutedMessageHandler>();
var parentHandler = Mock<IRoutedMessageHandler>();
var trigger = Mock<IMessageTrigger>();
_node.RegisterHandler(handler);
_parentNode.RegisterHandler(parentHandler);
trigger.Expect(x => x.Message).Return(message);
handler.Expect(x => x.Handles(message)).Return(false);
_controller.Expect(x => x.GetParent(_element)).Return(_parentNode);
parentHandler.Expect(x => x.Handles(message)).Return(true);
parentHandler.Expect(x => x.UpdateAvailability(trigger));
_node.UpdateAvailability(trigger);
}
public void if_none_are_provided_check_for_eventArgs()
{
var context = EventArgs.Empty;
var message = new FakeMessage();
message.Initialize(_sourceNode);
var element = new ControlHost();
_handlingNode.Stub(x => x.UIElement).Return(element).Repeat.Twice();
var requirements = new List<RequiredParameter>
{
new RequiredParameter("eventArgs", typeof(EventArgs)),
};
var result = _binder.DetermineParameters(
message, requirements, _handlingNode, context
);
Assert.That(result, Has.Length(1));
Assert.That(result, Has.Member(context));
}
public void if_none_are_provided_check_for_dataContext()
{
var source = new Button { DataContext = new object() };
_sourceNode.Stub(x => x.UIElement).Return(source);
var message = new FakeMessage();
message.Initialize(_sourceNode);
var element = new ControlHost();
_handlingNode.Stub(x => x.UIElement).Return(element).Repeat.Twice();
var requirements = new List<RequiredParameter>
{
new RequiredParameter("datacontext", typeof(object)),
};
var result = _binder.DetermineParameters(
message, requirements, _handlingNode, null
);
Assert.That(result, Has.Length(1));
Assert.That(result, Has.Member(source.DataContext));
}
public void if_none_are_provided_check_for_value()
{
var source = new TextBox { Text = "the text" };
_sourceNode.Stub(x => x.UIElement).Return(source);
var defaults = Stub<IElementConvention>();
_conventionManager.Expect(x => x.GetElementConvention(typeof(TextBox)))
.Return(defaults);
defaults.Expect(x => x.GetValue(source)).Return(source.Text);
var message = new FakeMessage();
message.Initialize(_sourceNode);
var element = new ControlHost();
_handlingNode.Stub(x => x.UIElement).Return(element).Repeat.Twice();
var requirements = new List<RequiredParameter>
{
new RequiredParameter("value", typeof(object)),
};
var result = _binder.DetermineParameters(
message, requirements, _handlingNode, null
);
Assert.That(result, Has.Length(1));
Assert.That(result, Has.Member(source.Text));
}
public void can_process_message_if_node_has_handler()
{
var context = new object();
var message = new FakeMessage();
var handler = Mock<IRoutedMessageHandler>();
handler.Expect(x => x.Initialize(_node));
handler.Expect(x => x.Handles(message)).Return(true);
handler.Expect(x => x.Process(message, context));
_node.RegisterHandler(handler);
_node.ProcessMessage(message, context);
}
public void will_throw_exception_if_trigger_update_node_is_not_found()
{
var trigger = Mock<IMessageTrigger>();
var message = new FakeMessage();
var handler = Mock<IRoutedMessageHandler>();
_node.RegisterHandler(handler);
trigger.Expect(x => x.Message).Return(message);
handler.Expect(x => x.Handles(message)).Return(false);
_controller.Expect(x => x.GetParent(_element)).Return(null);
_node.UpdateAvailability(trigger);
}
public void if_none_are_provided_should_search_the_UI()
{
const int param1 = 56;
const double param2 = 34.0;
var element = new ControlHost();
element.SetParam1(param1);
element.SetParam2(param2);
_handlingNode.Stub(x => x.UIElement).Return(element).Repeat.Twice();
var defaults = Mock<IElementConvention>();
_conventionManager.Expect(x => x.GetElementConvention(typeof(TextBox)))
.Return(defaults).Repeat.Twice();
defaults.Expect(x => x.GetValue(Arg<DependencyObject>.Is.Anything)).Return(param1);
defaults.Expect(x => x.GetValue(Arg<DependencyObject>.Is.Anything)).Return(param2);
var message = new FakeMessage();
message.Initialize(_sourceNode);
var requirements = new List<RequiredParameter>
{
new RequiredParameter("param1", typeof(string)),
new RequiredParameter("param2", typeof(int))
};
var result = _binder.DetermineParameters(
message, requirements, _handlingNode, null
);
Assert.That(result, Has.Length(2));
Assert.That(result, Has.Member(param1.ToString()));
Assert.That(result, Has.Member(Convert.ToInt32(param2)));
}
public void can_update_availability_if_node_has_handler()
{
var message = new FakeMessage();
var handler = Mock<IRoutedMessageHandler>();
var trigger = Mock<IMessageTrigger>();
handler.Expect(x => x.Initialize(_node));
trigger.Expect(x => x.Message).Return(message);
handler.Expect(x => x.Handles(message)).Return(true);
handler.Expect(x => x.UpdateAvailability(trigger));
_node.RegisterHandler(handler);
_node.UpdateAvailability(trigger);
}
public void represents_availability_consistently_through_ICommand_for_non_disable_availability_when_available()
{
_message = new FakeMessage {AvailabilityEffect = AvailabilityEffect.Hide};
var trigger = new GestureMessageTrigger
{
Modifiers = ModifierKeys.Alt,
Key = Key.S,
Message = _message
};
_node.Expect(x => x.UIElement).Return(_element);
_node.Expect(x => x.UIElement).Return(_element);
trigger.Attach(_node);
trigger.UpdateAvailabilty(true);
Assert.That(_element.IsEnabled);
}
public void should_resolve_special_parameter_value()
{
const string param1 = "$value";
var source = new TextBox { Text = "the value" };
var convention = Mock<IElementConvention>();
_conventionManager.Expect(x => x.GetElementConvention(typeof(TextBox)))
.Return(convention);
convention.Expect(x => x.GetValue(source)).Return(source.Text);
var message = new FakeMessage
{
Parameters = new FreezableCollection<Parameter>
{
new Parameter {Value = param1},
}
};
_sourceNode.Stub(x => x.UIElement).Return(source);
message.Initialize(_sourceNode);
var requirements = new List<RequiredParameter>
{
new RequiredParameter("param1", typeof(object))
};
var result = _binder.DetermineParameters(
message, requirements, _handlingNode, null
);
Assert.That(result, Has.Length(1));
Assert.That(result, Has.Member(source.Text));
}
public void should_resolve_special_parameter_dataContext()
{
const string param1 = "$dataContext";
var source = new Button { DataContext = new object() };
var message = new FakeMessage
{
Parameters = new FreezableCollection<Parameter>
{
new Parameter {Value = param1},
}
};
_sourceNode.Stub(x => x.UIElement).Return(source);
message.Initialize(_sourceNode);
var requirements = new List<RequiredParameter>
{
new RequiredParameter("param1", typeof(object))
};
var result = _binder.DetermineParameters(
message, requirements, _handlingNode, null
);
Assert.That(result, Has.Length(1));
Assert.That(result, Has.Member(source.DataContext));
}
public void can_process_message_if_parent_node_has_handler()
{
var context = new object();
var message = new FakeMessage();
var handler = Mock<IRoutedMessageHandler>();
var parentHandler = Mock<IRoutedMessageHandler>();
_node.RegisterHandler(handler);
_parentNode.RegisterHandler(parentHandler);
handler.Expect(x => x.Handles(message)).Return(false);
_controller.Expect(x => x.GetParent(_element)).Return(_parentNode);
parentHandler.Expect(x => x.Handles(message)).Return(true);
parentHandler.Expect(x => x.Process(message, context));
_node.ProcessMessage(message, context);
}
