public async Task RunAsync_should_throw_if_saga_cannot_handle_message()
{
var message = UnhandledMessage.New();
var messageContext = NSubstitute.Substitute.For <IMessageContext <UnhandledMessage> >();
messageContext.Message.Returns(message);
var sagaStateService = NSubstitute.Substitute.For <ISagaStateService <DummySaga, DummySagaState> >();
var state = new DummySagaState(message.CorrelationId);
sagaStateService.GetAsync(messageContext, Arg.Any <CancellationToken>())
.Returns((state, Guid.NewGuid()));
var saga = NSubstitute.Substitute.ForPartsOf <DummySaga>(state);
var sagaFactory = NSubstitute.Substitute.For <ISagaFactory <DummySaga, DummySagaState> >();
sagaFactory.Create(state)
.Returns(saga);
var logger = NSubstitute.Substitute.For <ILogger <SagaRunner <DummySaga, DummySagaState> > >();
var transactionManager = NSubstitute.Substitute.For <ITransactionManager>();
var policyFactory = NSubstitute.Substitute.For <ISagaPolicyFactory <DummySaga> >();
var sut = new SagaRunner <DummySaga, DummySagaState>(sagaFactory, sagaStateService, transactionManager, policyFactory, logger);
await Assert.ThrowsAsync <ConsumerNotFoundException>(() => sut.RunAsync(messageContext, CancellationToken.None));
}
private void ServerOnMessage(object sender, MessageEventArgs evt)
{
var socket = (WsSocket)sender;
try
{
var msgOrig = JsonConvert.DeserializeObject <Message>(evt.Data);
var actionName = msgOrig.ActionName?.ToLowerInvariant();
var msg = msgOrig;
if (_actionNameToDataType.ContainsKey(actionName))
{
var type = _actionNameToDataType[actionName];
var data = DeserializeData(msgOrig.Data, type);
msg = new Message(socket)
{
ActionName = msgOrig.ActionName,
Type = msgOrig.Type,
Data = data,
Hash = msgOrig.Hash
};
}
else
{
msg.Sender = socket;
}
if (_actionFilters.Count != 0)
{
lock (_actionFiltersLock)
{
if (_actionFilters.Any(x => !x(msg)))
{
return;
}
}
}
if (!InvokeHandlers(actionName, msg))
{
UnhandledMessage?.Invoke(this, msg);
}
}
catch (Exception e)
{
var message = new Message
{
Type = MessageType.Response,
Data = "Received unknown data."
};
var text = JsonConvert.SerializeObject(message);
socket.Send(text);
Logger.Error(e, $"Failed to handle WebSocket message: {evt.Data}");
}
}
private void NewUnhandledMessage(UnhandledMessage obj)
{
var builder = new StringBuilder($"Name: {obj.GetType().Name}");
foreach (var propertyInfo in obj.Message.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
builder.Append($" - {propertyInfo.GetValue(obj.Message)}");
}
UnhandledMessages.Add(builder.ToString());
}
public void Create_should_return_null_when_message_has_wrong_type()
{
var state = new DummySagaState(Guid.NewGuid());
var message = UnhandledMessage.New();
Func <StartDummySaga, DummySagaState> factory = (msg) => state;
var sut = new LambdaSagaStateFactory <StartDummySaga, DummySagaState>(factory);
var result = sut.Create(message);
result.Should().BeNull();
}
public void Be_able_to_log_unhandled_messages()
{
using (var system = ActorSystem.Create("EventStreamSpecUnhandled", GetDebugUnhandledMessagesConfig()))
{
system.EventStream.Subscribe(TestActor, typeof(Debug));
var msg = new UnhandledMessage(42, system.DeadLetters, system.DeadLetters);
system.EventStream.Publish(msg);
var debugMsg = ExpectMsg <Debug>();
debugMsg.Message.ToString().StartsWith("Unhandled message from").ShouldBeTrue();
debugMsg.Message.ToString().EndsWith(": 42").ShouldBeTrue();
}
}
protected async Task Listen()
{
while (true)
{
var buffer = await _input.ReadLineAsync();
var splitBuffer = buffer.Split();
if (splitBuffer[0].Equals("PING"))
{
await SendPong(buffer);
}
else if (splitBuffer[1].Equals("PRIVMSG"))
{
var parsedMessage = IrcMessage.ParseMessage(buffer);
var parsedUser = IrcMessage.ParseUser(buffer);
MessageReceived?.Invoke(parsedMessage, parsedUser);
}
else
{
UnhandledMessage?.Invoke(buffer);
}
}
}
public void Handle(UnhandledMessage message)
{
ActorMonitoringExtension.Monitors(Context.System).IncrementUnhandledMessage();
}
internal void RaiseUnhandledMessage(JsonResponse message)
{
UnhandledMessage?.Invoke(this, message);
}
protected virtual void OnUnhandledMessage(MessageContext context)
{
UnhandledMessage?.Invoke(context);
}
async void Run()
{
var messageParser = new TwitchMessageParser();
int retries = 0;
while (Connection != null)
{
try
{
string data = Connection.Read();
if (string.IsNullOrEmpty(data))
{
// Failed to read, try again.
if (retries >= 3)
{
break;
}
retries += 1;
await Task.Delay(1000);
}
else
{
retries = 0;
}
var message = messageParser.Parse(data);
if (message == null)
{
continue;
}
// Completely ignore certain messages.
if (ignoredCommands.Contains(message.Command))
{
continue;
}
// Process specified commands.
ITwitchCommandProcessor commandProcessor;
if (commandProcessors.TryGetValue(message.Command, out commandProcessor))
{
commandProcessor.Process(Connection, message);
}
// Raise unhandled messages to UI thread.
else
{
Dispatcher.Invoke(() => UnhandledMessage?.Invoke(message));
}
}
catch (IOException)
{
continue;
}
}
try
{
// Raise disconnected event.
Dispatcher.Invoke(() => Disconnected?.Invoke());
}
catch (TaskCanceledException) {}
}
void Receive(UnhandledMessage message) => received++;
