/// <summary>
/// The forum repo suppose to get 1 question and all the answer, if any,
/// </summary>
/// <param name="logger"></param>
/// <param name="userRepo"></param>
/// <param name="sentMessage"></param>
/// <param name="forumRepo"></param>
public ForumController(ILogger <ForumController> logger, IUserRepo userRepo, ISentMessage sentMessage, IForumRepo forumRepo)
{
_forumRepo = forumRepo ?? throw new ArgumentNullException(nameof(sentMessage));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_userRepo = userRepo ?? throw new ArgumentNullException(nameof(userRepo));
_messageSender = sentMessage ?? throw new ArgumentNullException(nameof(sentMessage));
}
public async Task Should_contain_the_same_payloads()
{
EndpointConvention.Map <B>(InputQueueAddress);
var sendObserver = new TestSendObserver(TimeSpan.FromSeconds(3));
using (Bus.ConnectSendObserver(sendObserver))
{
await InputQueueSendEndpoint.Send(new A());
ISentMessage <A> a = sendObserver.Messages.Select <A>().FirstOrDefault();
ISentMessage <B> b = sendObserver.Messages.Select <B>().FirstOrDefault();
a.ShouldNotBeNull();
b.ShouldNotBeNull();
Dictionary <string, object> ah = a.Context.Headers.GetAll().ToDictionary(x => x.Key, x => x.Value);
Dictionary <string, object> bh = b.Context.Headers.GetAll().ToDictionary(x => x.Key, x => x.Value);
ah.ShouldContainKey("x-send-filter");
ah.ShouldContainKey("x-send-message-filter");
ah["x-send-filter"].ShouldBe("send-filter");
ah["x-send-message-filter"].ShouldBe("send-message-filter");
bh.ShouldContainKey("x-send-filter");
bh.ShouldContainKey("x-send-message-filter");
// those fails, as while they DO have ",has-consume-context" they don't have access to SomePayload
bh["x-send-filter"].ShouldBe("send-filter,has-consume-context,has-some-payload:hello");
bh["x-send-message-filter"].ShouldBe("send-message-filter,has-consume-context,has-some-payload:hello");
}
}
public async Task Should_have_sent_message_to_bus_address()
{
ISentMessage <B> message = await _harness.Sent.SelectAsync <B>().First();
message.ShouldNotBeNull();
message.Context.DestinationAddress.ShouldBe(_harness.BusAddress);
}
protected void GivenSentMessage()
{
Message = new Message(new MessageHeaders
{
MessageId = MessageId.Generate()
}, "Hello, world!");
SentMessage = ReplyHub.CreateSentMessage(Message);
}
public void Add(ISentMessage message)
{
lock (_messages)
{
if (_messages.Add(message))
{
_received.Set();
}
}
}
public Message(ISentMessage message)
: this(message.Context)
{
MessageType = message.MessageType;
ShortTypeName = message.ShortTypeName;
EventType = MessageEventType.Send;
StartTime = message.StartTime;
ElapsedTime = message.ElapsedTime;
}
/// <summary>
/// Observes the sent message replies until the first reply is received
/// or a timeout occurs
/// </summary>
/// <param name="sentMessage">The sent message</param>
/// <param name="cancellationToken">(Optional) A token that can be provided by the caller
/// to interrupt the reply wait</param>
/// <returns>Returns a task whose result will be the deserialized content of the
/// reply message</returns>
public static Task <object> GetReply(this ISentMessage sentMessage, CancellationToken cancellationToken = default(CancellationToken))
{
var tcs = new TaskCompletionSource <object>(cancellationToken);
var replyTask = tcs.Task;
var subscription = sentMessage.ObserveReplies().Subscribe(r =>
{
tcs.TrySetResult(r);
});
return(replyTask.ContinueWith(t =>
{
subscription.Dispose();
return t.Result;
}, cancellationToken));
}
/// <summary>
/// Observes the sent message replies until the first reply is received
/// or a timeout occurs
/// </summary>
/// <param name="sentMessage">The sent message</param>
/// <param name="timeout">The maximum amount of time to wait for a reply</param>
/// <returns>Returns a task whose result will be the deserialized content of the
/// reply message</returns>
public static Task <object> GetReply(this ISentMessage sentMessage, TimeSpan timeout = default(TimeSpan))
{
var cts = timeout >= TimeSpan.Zero
? new CancellationTokenSource(timeout)
: new CancellationTokenSource();
var ct = cts.Token;
// ReSharper disable once MethodSupportsCancellation
return(sentMessage.GetReply(ct).ContinueWith(t =>
{
cts.Dispose();
return t.Result;
}));
}
public async Task Setup()
{
_harness = new InMemoryTestHarness();
_harness.OnConfigureInMemoryBus += configurator => configurator.ConnectSendAuditObservers(AuditStore);
_harness.Consumer <TestConsumer>();
await _harness.Start();
await _harness.InputQueueSendEndpoint.Send(new A { Data = TestData });
_sent = _harness.Sent.Select <A>().First();
List <AuditDocument> audit = await GetAuditRecords("Send");
_auditDocument = audit.Single();
}
bool Filter(ISentMessage element)
{
return(element is ISentMessage <T> result && filter(result));
}
/// <summary>
/// Initializes a new instance of the <see cref="QueueOutputMessage" /> class.
/// </summary>
/// <param name="sentMessage">The sent message.</param>
public QueueOutputMessage(ISentMessage sentMessage)
{
SentMessage = sentMessage;
}
/// <summary>
/// Initializes a new instance of the <see cref="QueueOutputMessage" /> class.
/// </summary>
/// <param name="sentMessage">The sent message.</param>
/// <param name="error">The error.</param>
public QueueOutputMessage(ISentMessage sentMessage,
Exception error)
{
SentMessage = sentMessage;
SendingException = error;
}
/// <summary>
/// Initializes a new instance of the <see cref="QueueOutputMessage" /> class.
/// </summary>
/// <param name="sentMessage">The sent message.</param>
public QueueOutputMessage(ISentMessage sentMessage)
{
SentMessage = sentMessage;
}
/// <summary>
/// Initializes a new instance of the <see cref="QueueOutputMessage" /> class.
/// </summary>
/// <param name="sentMessage">The sent message.</param>
/// <param name="error">The error.</param>
public QueueOutputMessage(ISentMessage sentMessage,
Exception error)
{
SentMessage = sentMessage;
SendingException = error;
}
protected async Task WhenMessageSent()
{
SentMessage = await Sender.Send(Message, new SendOptions { Synchronous = true });
}
public void AddSent(ISentMessage message)
{
_sent.Add(message);
}
