public async Task Saga_info_should_be_available_through_the_http_api()
{
MessagesView auditedMessage = null;
var context = await Define <MyContext>()
.WithEndpoint <EndpointThatIsHostingTheSaga>(b => b.When((bus, c) => bus.SendLocal(new MessageInitiatingSaga {
Id = "Id"
})))
.Done(async c =>
{
if (c.SagaId == Guid.Empty)
{
return(false);
}
var result = await this.TryGetSingle <MessagesView>("/api/messages", m => m.MessageId == c.MessageId);
auditedMessage = result;
return(result);
})
.Run(TimeSpan.FromSeconds(40));
Assert.NotNull(auditedMessage);
Assert.AreEqual(typeof(EndpointThatIsHostingTheSaga.MySaga).FullName, auditedMessage.InvokedSagas.Single().SagaType);
Assert.AreEqual(context.SagaId, auditedMessage.InvokedSagas.First().SagaId);
Assert.AreEqual("New", auditedMessage.InvokedSagas.First().ChangeStatus);
}
private void SaveInternal(string filename, bool all)
{
_messagesTimer.Stop();
try {
var config = new CsvConfiguration {
IgnorePrivateAccessor = true,
};
using (var writer = new StreamWriter(filename)) {
var csvWriter = new CsvWriter(writer, config);
csvWriter.WriteHeader <AlpcMessageViewModel>();
foreach (var msg in _messages)
{
if (all || MessagesView.Contains(msg))
{
csvWriter.WriteRecord(msg);
}
}
}
}
catch (Exception ex) {
UI.MessageBoxService.ShowMessage(ex.Message, App.Name);
}
finally {
_messagesTimer.Start();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageViewModel"/> class.
/// </summary>
public MessageViewModel()
{
_stateMachine = new StateMachine();
_stateMachine.StateChanged += _stateMachine_StateChanged;
_messages = new ObservableCollection <Message>();
MessagesView.SortDescriptions.Add(new SortDescription("MessageType", ListSortDirection.Descending));
MessagesView.MoveCurrentToPosition(0);
// set first tag of messagestate to lowest message priority
StateMachine.GetState <MessageState>().Tag = MessageType.Consumable.ToString();
}
public async Task Should_be_forwarded_to_remote()
{
SetInstanceSettings = ConfigureRemoteInstanceForMasterAsWellAsAuditAndErrorQueues;
var context = new MyContext();
HttpResponseMessage response = null;
MessagesView capturedMessage = null;
await Define(context, Remote1, Master)
.WithEndpoint <RemoteEndpoint>(b => b.Given(bus =>
{
context.Remote1InstanceId = InstanceIdGenerator.FromApiUrl(addressOfRemote);
bus.SendLocal(new MyMessage());
}))
.Done(async c =>
{
if (string.IsNullOrWhiteSpace(context.Remote1MessageId))
{
return(false);
}
if (!c.Remote1MessageAudited)
{
var result = await TryGetMany <MessagesView>("/api/messages", msg => msg.MessageId == c.Remote1MessageId, Master);
List <MessagesView> messages = result;
if (!result)
{
return(false);
}
c.Remote1MessageAudited = true;
capturedMessage = messages.Single(msg => msg.MessageId == c.Remote1MessageId);
}
response = await GetRaw($"/api/{capturedMessage.BodyUrl}", Master);
Console.WriteLine($"GetRaw for {c.Remote1MessageId} resulted in {response.StatusCode}");
return(response.StatusCode == HttpStatusCode.OK);
})
.Run(TimeSpan.FromMinutes(2));
Assert.AreEqual(context.Remote1MessageContentType, response.Content.Headers.ContentType.ToString(), "ContentType mismatch");
Assert.NotNull(response.Content.Headers.Expires, "Expires header missing");
Assert.GreaterOrEqual(response.Content.Headers.Expires.Value, DateTimeOffset.UtcNow.AddDays(360), "Unexpected Expires datetime year value");
Assert.NotNull(response.Content.Headers.ContentLength, "ContentLength not set");
Assert.AreEqual(context.Remote1MessageBody.Length, response.Content.Headers.ContentLength.Value, "ContentLength mismatch");
var body = await response.Content.ReadAsByteArrayAsync();
Assert.AreEqual(context.Remote1MessageBody, body, "Body bytes mismatch");
Assert.NotNull(response.Headers.GetValues("ETag").SingleOrDefault(), "Etag not set");
}
public async Task Should_be_forwarded_to_audit_instance()
{
CustomServiceControlAuditSettings = s => addressOfAuditInstance = s.ApiUrl;
HttpResponseMessage response = null;
MessagesView capturedMessage = null;
var context = await Define <MyContext>()
.WithEndpoint <RemoteEndpoint>(b => b.When(async(bus, ctx) =>
{
ctx.AuditInstanceId = InstanceIdGenerator.FromApiUrl(addressOfAuditInstance);
await bus.SendLocal(new MyMessage());
}))
.Done(async c =>
{
if (string.IsNullOrWhiteSpace(c.AuditInstanceMessageId))
{
return(false);
}
if (!c.MessageAudited)
{
var result = await this.TryGetMany <MessagesView>("/api/messages", msg => msg.MessageId == c.AuditInstanceMessageId, ServiceControlInstanceName);
List <MessagesView> messages = result;
if (!result)
{
return(false);
}
c.MessageAudited = true;
capturedMessage = messages.Single(msg => msg.MessageId == c.AuditInstanceMessageId);
}
response = await this.GetRaw($"/api/{capturedMessage.BodyUrl}", ServiceControlInstanceName);
Console.WriteLine($"GetRaw for {c.AuditInstanceMessageId} resulted in {response.StatusCode}");
return(response.StatusCode == HttpStatusCode.OK);
})
.Run(TimeSpan.FromMinutes(2));
Assert.AreEqual(context.MessageContentType, response.Content.Headers.ContentType.ToString(), "ContentType mismatch");
Assert.NotNull(response.Content.Headers.Expires, "Expires header missing");
Assert.GreaterOrEqual(response.Content.Headers.Expires.Value, DateTimeOffset.UtcNow.AddDays(360), "Unexpected Expires datetime year value");
Assert.NotNull(response.Content.Headers.ContentLength, "ContentLength not set");
Assert.AreEqual(context.MessageBody.Length, response.Content.Headers.ContentLength.Value, "ContentLength mismatch");
var body = await response.Content.ReadAsByteArrayAsync();
Assert.AreEqual(context.MessageBody, body, "Body bytes mismatch");
Assert.NotNull(response.Headers.GetValues("ETag").SingleOrDefault(), "Etag not set");
}
private void AddDebugMenuBottom()
{
m_MessageLog = new MessageLog();
var messagesView = new MessagesView {
DataContext = m_MessageLog
};
m_MessageLogWindow = m_Provider.ToolWindow.Create(messagesView, "Debug", new Guid(c_MessageWindowGuid));
m_MessageLogWindow.Window.Dock();
DisplayMessages();
}
public ref MessagesView GetMessagesView(User user, LocalData localData)
{
if (messagesView != null)
{
messagesView.Update(user, localData);
return(ref messagesView);
}
else
{
messagesView = new MessagesView(user, localData);
return(ref messagesView);
}
}
private async void MessagesView_OnPropertyChanged(object sender, PropertyChangedEventArgs e)
{
try
{
if (e.PropertyName == "Filter")
{
MessagesView.Opacity = 0.2;
await MessagesView.FadeTo(1, 650, Easing.Linear);
}
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
public void Info_on_emitted_saga_should_be_available_through_the_http_api()
{
var context = new MyContext();
MessagesView auditedMessage = null;
Define(context)
.WithEndpoint <EndpointThatIsHostingTheSaga>(b => b.Given((bus, c) => bus.SendLocal(new MessageInitiatingSaga())))
.Done(c => TryGetSingle("/api/messages", out auditedMessage, m => m.MessageId == c.MessageId))
.Run(TimeSpan.FromSeconds(40));
Assert.NotNull(auditedMessage.OriginatesFromSaga);
Assert.AreEqual(typeof(EndpointThatIsHostingTheSaga.MySaga).FullName, auditedMessage.OriginatesFromSaga.SagaType);
Assert.AreEqual(context.SagaId, auditedMessage.OriginatesFromSaga.SagaId);
}
public void SortByMessageType(string direction, int compareResult)
{
var comparer = GetComparerFromRequest("message_type", direction);
var lower = new MessagesView
{
MessageType = LowMessageType
};
var higher = new MessagesView
{
MessageType = HighMessageType
};
Assert.AreEqual(compareResult, comparer.Compare(lower, higher), "Should sort messages the other way around");
}
public void SortByStatus(string direction, int compareResult)
{
var comparer = GetComparerFromRequest("status", direction);
var lower = new MessagesView
{
Status = LowMessageStatus
};
var higher = new MessagesView
{
Status = HighMessageStatus
};
Assert.AreEqual(compareResult, comparer.Compare(lower, higher), "Should sort messages the other way around");
}
public void SortByProcessingTime(string direction, int compareResult)
{
var comparer = GetComparerFromRequest("processing_time", direction);
var lower = new MessagesView
{
ProcessingTime = LowProcessingTime
};
var higher = new MessagesView
{
ProcessingTime = HighProcessingTime
};
Assert.AreEqual(compareResult, comparer.Compare(lower, higher), "Should sort messages the other way around");
}
public void Null_TimeSent_should_not_be_cast_to_DateTimeMin()
{
MessagesView auditedMessage = null;
var context = new MyContext
{
MessageId = Guid.NewGuid().ToString()
};
Define(context)
.WithEndpoint <ThirdPartyEndpoint>()
.Done(c => TryGetSingle("/api/messages?include_system_messages=false&sort=id", out auditedMessage, m => m.MessageId == c.MessageId))
.Run();
Assert.IsNotNull(auditedMessage);
Assert.IsNull(auditedMessage.TimeSent);
}
public void SortByTimeSent(string direction, int compareResult)
{
var comparer = GetComparerFromRequest("time_sent", direction);
var lower = new MessagesView
{
TimeSent = LowMessageSent
};
var higher = new MessagesView
{
TimeSent = HighMessageSent
};
Assert.AreEqual(compareResult, comparer.Compare(lower, higher), "Should sort messages the other way around");
}
public void Should_be_listed_in_the_messages_list()
{
var context = new MyContext();
var failure = new MessagesView();
Define(context)
.WithEndpoint <Receiver>(b => b.Given(bus => bus.SendLocal(new MyMessage())))
.Done(c => TryGetSingle("/api/messages", out failure, m => m.MessageId == c.MessageId))
.Run(TimeSpan.FromMinutes(2));
Assert.AreEqual(context.UniqueMessageId, failure.Id, "The unique id should be returned");
Assert.AreEqual(MessageStatus.Failed, failure.Status, "Status of new messages should be failed");
Assert.AreEqual(context.EndpointNameOfReceivingEndpoint, failure.SendingEndpoint.Name);
Assert.AreEqual(context.EndpointNameOfReceivingEndpoint, failure.ReceivingEndpoint.Name);
}
public async Task Null_TimeSent_should_not_be_cast_to_DateTimeMin()
{
MessagesView auditedMessage = null;
await Define <MyContext>(ctx => { ctx.MessageId = Guid.NewGuid().ToString(); })
.WithEndpoint <ThirdPartyEndpoint>()
.Done(async c =>
{
var result = await this.TryGetSingle <MessagesView>("/api/messages?include_system_messages=false&sort=id", m => m.MessageId == c.MessageId);
auditedMessage = result;
return(result);
})
.Run();
Assert.IsNotNull(auditedMessage);
Assert.IsNull(auditedMessage.TimeSent);
}
public void Debug_session_id_should_be_present_in_header()
{
var context = new MyContext();
MessagesView message = null;
Define(context)
.WithEndpoint <ManagementEndpoint>(c => c.AppConfig(PathToAppConfig))
.WithEndpoint <Sender>(b => b.Given((bus, c) =>
{
bus.Send(new MyMessage());
}))
.WithEndpoint <Receiver>()
.Done(c => TryGetSingle("/api/messages", out message))
.Run(TimeSpan.FromSeconds(40));
Assert.NotNull(message, "No message was returned by the management api");
Assert.AreEqual(context.MessageId, message.Headers.SingleOrDefault(_ => _.Key == "ServiceControl.DebugSessionId").Value);
}
public void Should_set_the_IsSystemMessage_when_message_type_is_not_a_scheduled_task()
{
var context = new SystemMessageTestContext
{
MessageId = Guid.NewGuid().ToString(),
EnclosedMessageType = "SendOnlyError.SendSomeCommand, TestSendOnlyError, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null",
IncludeControlMessageHeader = false,
};
MessagesView auditMessage = null;
Define(context)
.WithEndpoint <ServerEndpoint>()
.Done(c => TryGetSingle("/api/messages", out auditMessage, r => r.MessageId == c.MessageId))
.Run();
Assert.IsNotNull(auditMessage);
Assert.IsFalse(auditMessage.IsSystemMessage);
}
public void Scheduled_task_messages_should_set_IsSystemMessage()
{
var context = new SystemMessageTestContext
{
MessageId = Guid.NewGuid().ToString(),
EnclosedMessageType = "NServiceBus.Scheduling.Messages.ScheduledTask, TestSendOnlyError, Version=5.0.0.0, Culture=neutral, PublicKeyToken=null",
IncludeControlMessageHeader = false,
};
MessagesView auditMessage = null;
Define(context)
.WithEndpoint <ServerEndpoint>()
.Done(c => TryGetSingle("/api/messages?include_system_messages=true&sort=id", out auditMessage, r => r.MessageId == c.MessageId))
.Run();
Assert.IsNotNull(auditMessage);
Assert.IsTrue(auditMessage.IsSystemMessage);
}
public void Should_set_the_IsSystemMessage_for_integration_scenario()
{
var context = new SystemMessageTestContext
{
MessageId = Guid.NewGuid().ToString(),
EnclosedMessageType = null,
IncludeControlMessageHeader = false
};
MessagesView auditMessage = null;
Define(context)
.WithEndpoint <ServerEndpoint>()
.Done(c => TryGetSingle("/api/messages", out auditMessage, r => r.MessageId == c.MessageId))
.Run();
Assert.IsNotNull(auditMessage);
Assert.IsFalse(auditMessage.IsSystemMessage);
}
public void Control_messages_should_not_be_audited()
{
var context = new SystemMessageTestContext
{
MessageId = Guid.NewGuid().ToString(),
EnclosedMessageType = "NServiceBus.Scheduling.Messages.ScheduledTask",
IncludeControlMessageHeader = true, // If the control message header is present, then its a system message regardless of the value
ControlMessageHeaderValue = null
};
MessagesView auditMessage = null;
Scenario.Define(context)
.WithEndpoint <ManagementEndpoint>(c => c.AppConfig(PathToAppConfig))
.WithEndpoint <ServerEndpoint>()
.Done(c => TryGetSingle("/api/messages", out auditMessage, r => r.MessageId == c.MessageId))
.Run();
Assert.IsNull(auditMessage);
}
private void SaveInternal(string filename, bool all)
{
_messagesTimer.Stop();
try {
var config = new Configuration {
IncludePrivateMembers = true,
};
using (var writer = new StreamWriter(filename)) {
var csvWriter = new CsvWriter(writer, config);
if (SelectedTab == 1)
{
csvWriter.WriteHeader <AlpcMessageViewModel>();
foreach (var msg in _messages)
{
if (all || MessagesView.Contains(msg))
{
csvWriter.WriteRecord(msg);
}
}
}
else
{
csvWriter.WriteHeader <AlpcEventViewModel>();
foreach (var evt in _events)
{
if (all || EventsView.Contains(evt))
{
csvWriter.WriteRecord(evt);
}
}
}
}
}
catch (Exception ex) {
UI.MessageBoxService.ShowMessage(ex.Message, App.Name);
}
finally {
_messagesTimer.Start();
}
}
public async Task Should_be_listed_in_the_messages_list()
{
var failure = new MessagesView();
var context = await Define <MyContext>()
.WithEndpoint <Receiver>(b => b.When(bus => bus.SendLocal(new MyMessage())).DoNotFailOnErrorMessages())
.Done(async c =>
{
var result = await this.TryGetSingle <MessagesView>("/api/messages", m => m.MessageId == c.MessageId);
failure = result;
return(result);
})
.Run(TimeSpan.FromMinutes(2));
Assert.AreEqual(context.UniqueMessageId, failure.Id, "The unique id should be returned");
Assert.AreEqual(MessageStatus.Failed, failure.Status, "Status of new messages should be failed");
Assert.AreEqual(context.EndpointNameOfReceivingEndpoint, failure.SendingEndpoint.Name);
Assert.AreEqual(context.EndpointNameOfReceivingEndpoint, failure.ReceivingEndpoint.Name);
}
public async Task Should_not_get_an_empty_audit_message_body_when_configured_MaxBodySizeToStore_is_greater_then_message_size()
{
//Arrange
SetSettings = settings => settings.MaxBodySizeToStore = MAX_BODY_SIZE;
var context = new Context();
byte[] body = null;
//Act
await Define(context)
.WithEndpoint <ServerEndpoint>(c => c.Given(b => b.SendLocal(
new BigFatMessage // An endpoint that is configured for audit
{
BigFatBody = new byte[MAX_BODY_SIZE - 10000]
}))
)
.Done(
async c =>
{
if (c.MessageId == null)
{
return(false);
}
var result = await TryGetSingle <MessagesView>("/api/messages", r => r.MessageId == c.MessageId);
MessagesView auditMessage = result;
if (!result)
{
return(false);
}
body = await DownloadData(auditMessage.BodyUrl);
return(true);
})
.Run();
//Assert
Assert.IsNotNull(body);
}
private void InitDisplay()
{
_uiMessagesView = new MessagesView();
_uiMessagesView.Dock = DockStyle.Fill;
this.panelLogView.Controls.Add(_uiMessagesView);
this.panelLogView.Visible = false;
this._isLogDisplay = false;
_uiConfigView.Dock = DockStyle.Fill;
this.panelConfigView.Controls.Add(_uiConfigView);
_uiDataBaseView.Dock = DockStyle.Fill;
this.panelDataBaseView.Controls.Add(_uiDataBaseView);
_uiDisplayView.Dock = DockStyle.Fill;
this.panelDisplayView.Controls.Add(_uiDisplayView);
this.tabControl1.SelectedIndex = 1;
return;
}
public async Task Info_on_emitted_saga_should_be_available_through_the_http_api()
{
MessagesView auditedMessage = null;
var context = await Define <MyContext>()
.WithEndpoint <EndpointThatIsHostingTheSaga>(b => b.When((bus, c) => bus.SendLocal(new MessageInitiatingSaga {
Id = "Id"
})))
.Done(async c =>
{
var result = await this.TryGetSingle <MessagesView>("/api/messages", m => m.MessageId == c.MessageId);
auditedMessage = result;
return(result);
})
.Run();
Assert.NotNull(auditedMessage.OriginatesFromSaga);
Assert.AreEqual(typeof(EndpointThatIsHostingTheSaga.MySaga).FullName, auditedMessage.OriginatesFromSaga.SagaType);
Assert.AreEqual(context.SagaId, auditedMessage.OriginatesFromSaga.SagaId);
}
public async Task Should_get_an_empty_audit_message_body_when_configured_MaxBodySizeToStore_is_less_then_message_size()
{
//Arrange
SetSettings = settings => settings.MaxBodySizeToStore = MAX_BODY_SIZE;
byte[] body = null;
//Act
await Define <Context>()
.WithEndpoint <FatMessageEndpoint>(c => c.When(b => b.SendLocal(
new BigFatMessage // An endpoint that is configured for audit
{
BigFatBody = new byte[MAX_BODY_SIZE + 1000]
}))
)
.Done(
async c =>
{
if (c.MessageId == null)
{
return(false);
}
var result = await this.TryGetSingle <MessagesView>("/api/messages", r => r.MessageId == c.MessageId);
MessagesView auditMessage = result;
if (!result)
{
return(false);
}
body = await this.DownloadData(auditMessage.BodyUrl, HttpStatusCode.NoContent);
return(true);
})
.Run();
//Assert
Assert.AreEqual(0, body.Length);
}
public async Task Scheduled_task_messages_should_set_IsSystemMessage()
{
MessagesView auditMessage = null;
await Define <SystemMessageTestContext>(ctx =>
{
ctx.MessageId = Guid.NewGuid().ToString();
ctx.EnclosedMessageType = "NServiceBus.Scheduling.Messages.ScheduledTask, TestSendOnlyError, Version=5.0.0.0, Culture=neutral, PublicKeyToken=null";
ctx.IncludeControlMessageHeader = false;
})
.WithEndpoint <SystemMessageEndpoint>()
.Done(async c =>
{
var result = await this.TryGetSingle <MessagesView>("/api/messages?include_system_messages=true&sort=id", r => r.MessageId == c.MessageId);
auditMessage = result;
return(result);
})
.Run();
Assert.IsNotNull(auditMessage);
Assert.IsTrue(auditMessage.IsSystemMessage);
}
public async Task Should_set_the_IsSystemMessage_when_message_type_is_not_a_scheduled_task()
{
MessagesView auditMessage = null;
await Define <SystemMessageTestContext>(ctx =>
{
ctx.MessageId = Guid.NewGuid().ToString();
ctx.EnclosedMessageType = "SendOnlyError.SendSomeCommand, TestSendOnlyError, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null";
ctx.IncludeControlMessageHeader = false;
})
.WithEndpoint <SystemMessageEndpoint>()
.Done(async c =>
{
var result = await this.TryGetSingle <MessagesView>("/api/messages", r => r.MessageId == c.MessageId);
auditMessage = result;
return(result);
})
.Run();
Assert.IsNotNull(auditMessage);
Assert.IsFalse(auditMessage.IsSystemMessage);
}
public async Task Should_set_the_IsSystemMessage_for_integration_scenario()
{
MessagesView auditMessage = null;
await Define <SystemMessageTestContext>(ctx =>
{
ctx.MessageId = Guid.NewGuid().ToString();
ctx.EnclosedMessageType = null;
ctx.IncludeControlMessageHeader = false;
})
.WithEndpoint <SystemMessageEndpoint>()
.Done(async c =>
{
var result = await this.TryGetSingle <MessagesView>("/api/messages", r => r.MessageId == c.MessageId);
auditMessage = result;
return(result);
})
.Run();
Assert.IsNotNull(auditMessage);
Assert.IsFalse(auditMessage.IsSystemMessage);
}
