public Stream GetStream()
{
(Stream a, Stream b) = PairedStream.Create();
HalfStream = a;
ActiveStream = b;
return(b);
}
public async Task ReceiveNoData_Uncancellable()
{
(Stream a, Stream b) = PairedStream.Create();
var buffer = new byte[s_bytes.Length * 2];
await TaskHelpers.AssertNotTriggered(a.ReadAsync(buffer, 0, buffer.Length, CancellationToken.None));
await TaskHelpers.AssertNotTriggered(b.ReadAsync(buffer, 0, buffer.Length, CancellationToken.None));
}
public async Task ReceiveNoData()
{
(Stream a, Stream b) = PairedStream.Create();
var buffer = new byte[s_bytes.Length * 2];
await TaskHelpers.AssertNotTriggered(a.ReadAsync(buffer, 0, buffer.Length));
await TaskHelpers.AssertNotTriggered(b.ReadAsync(buffer, 0, buffer.Length));
}
/// <summary>
/// Creates a pair of streams that can be passed to two parties
/// to allow for interaction with each other.
/// </summary>
/// <returns>A pair of streams.</returns>
public static Tuple <Stream, Stream> CreatePair()
{
var stream1 = new PairedStream();
var stream2 = new PairedStream();
stream1.SetOtherStream(stream2);
stream2.SetOtherStream(stream1);
return(Tuple.Create <Stream, Stream>(stream1, stream2));
}
public async Task SendRecieveOneWay_WithToken()
{
(Stream a, Stream b) = PairedStream.Create();
await a.WriteAsync(s_bytes, 0, s_bytes.Length);
var buffer = new byte[s_bytes.Length * 2];
int read = await b.ReadAsync(buffer, 0, buffer.Length, CancellationToken.None);
Assert.Equal(s_bytes.Length, read);
Assert.Equal(s_bytes, new ArraySegment <byte>(buffer, 0, read));
}
public async Task ProcessAll_EhloStartTlsTest_NotTrusted()
{
var responseMessagesPreEncrypt = @"220-STARTTLS
220 example.com greets test.example.com (EHLO)
250 Ok, begin encryption (STARTTLS)
";
var mockMailReference = new MockMailReference(
"mock-1",
"*****@*****.**",
new[] { "*****@*****.**" }.ToImmutableList(),
true,
"Some text",
_queue);
_queue.References.Add(mockMailReference);
_dns.AddMx("external.example.com", "test.example.com", 10);
_dns.AddIp("test.example.com", IPAddress.Parse("10.20.30.40"));
(Stream keep, Stream give) = PairedStream.Create();
using (var recieveStream = new RedirectableStream(keep))
using (var reader = new StreamReader(recieveStream))
{
Task <IReadOnlyList <IMailReference> > sendMailsTask = Task.Run(
() => _transfer.TrySendMailsToStream(
"external.example.com",
new[] { mockMailReference },
// ReSharper disable once AccessToDisposedClosure
new UnclosableStream(give),
CancellationToken.None));
_transfer.RemoteCertificateValidationCallback = (sender, certificate, chain, errors) => false;
byte[] responseBytes = Encoding.ASCII.GetBytes(responseMessagesPreEncrypt);
await keep.WriteAsync(responseBytes, 0, responseBytes.Length);
await AssertCommandRecieved(reader, "EHLO");
await AssertCommandRecieved(reader, "STARTTLS");
var encrypted = new SslStream(keep);
await encrypted.AuthenticateAsServerAsync(TestHelpers.GetSelfSigned());
Assert.NotEmpty(await sendMailsTask);
Assert.Equal(1, _queue.References.Count);
Assert.Equal(0, _queue.DeletedReferences.Count);
encrypted.Dispose();
keep.Dispose();
give.Dispose();
}
}
public TestConnection(ITestOutputHelper output)
{
(Stream a, Stream b) = PairedStream.Create();
LocalStream = new RedirectableStream(a);
Reader = new StreamReader(LocalStream);
Writer = new StreamWriter(LocalStream)
{
AutoFlush = true
};
var builder = new ContainerBuilder();
builder.RegisterAssemblyTypes(typeof(SmtpSession).GetTypeInfo().Assembly)
.Where(t => t.GetTypeInfo().GetCustomAttribute <SmtpCommandAttribute>() != null)
.Keyed <ISmtpCommand>(t => t.GetTypeInfo().GetCustomAttribute <SmtpCommandAttribute>().Name);
builder.RegisterInstance(TestHelpers.MakeSettings("test.vaettir.net"))
.As <AgentSettings>()
.As <AgentSettings>();
builder.RegisterType <SmtpSession>()
.As <SmtpSession>()
.As <ISmtpMessageChannel>()
.As <IMailBuilder>()
.As <IProtocolSession>();
builder.RegisterType <SmtpAuthenticationTransport>()
.As <IAuthenticationTransport>();
builder.RegisterInstance(new SecurableConnection(b, PrivateKeyHolder.Fixed(s_serverCert)))
.As <IConnectionSecurity>()
.As <SecurableConnection>();
builder.RegisterInstance(new TestOutputLogger(output))
.As <ILogger>();
builder.RegisterInstance(new ConnectionInformation("127.0.0.1", "128.0.0.1"));
Container = builder.Build();
Connection = Container.Resolve <SecurableConnection>();
Session = Container.Resolve <SmtpSession>();
CancellationTokenSource = new CancellationTokenSource();
CancellationToken token = CancellationTokenSource.Token;
SessionTask = Task.Run(() => Session.RunAsync(token), token);
}
public async Task ProcessAll_NoEhloTest()
{
var responseMessages = @"554 No clue (EHLO)
220 example.com greets test.example.com (HELO)
250 Ok (MAIL)
250 Ok (RCPT)
354 End data with <CR><LF>.<CR><LF> (DATA)
250 Ok (DATA with .)
250 Bye (QUIT)
";
var mockMailReference = new MockMailReference(
"mock-1",
"*****@*****.**",
new[] { "*****@*****.**" }.ToImmutableList(),
true,
"Some text",
_queue);
_queue.References.Add(mockMailReference);
_dns.AddMx("external.example.com", "mx.external.example.com", 10);
_dns.AddIp("mx.external.example.com", IPAddress.Parse("10.20.30.40"));
(Stream keep, Stream give) = PairedStream.Create();
using (var reader = new StreamReader(keep))
{
byte[] responseBytes = Encoding.ASCII.GetBytes(responseMessages);
await keep.WriteAsync(responseBytes, 0, responseBytes.Length);
Assert.Empty(
await _transfer.TrySendMailsToStream(
"external.example.com",
new[] { mockMailReference },
new UnclosableStream(give),
CancellationToken.None));
Assert.Equal(0, _queue.References.Count);
Assert.Equal(1, _queue.DeletedReferences.Count);
await AssertCommandRecieved(reader, "EHLO");
await AssertCommandRecieved(reader, "HELO");
await AssertCommandRecieved(reader, "MAIL");
await AssertCommandRecieved(reader, "RCPT");
await AssertCommandRecieved(reader, "DATA");
give.Dispose();
}
}
public async Task SendPartialOneWay()
{
(Stream a, Stream b) = PairedStream.Create();
await a.WriteAsync(s_bytes, 0, s_bytes.Length);
var buffer = new byte[s_bytes.Length / 2];
int read = await b.ReadAsync(buffer, 0, buffer.Length);
Assert.InRange(read, 0, buffer.Length);
Assert.Equal(s_bytes.Take(read), new ArraySegment <byte>(buffer, 0, read));
buffer = new byte[s_bytes.Length - read];
int secondRead = await b.ReadAsync(buffer, 0, buffer.Length);
Assert.Equal(secondRead, buffer.Length);
Assert.Equal(s_bytes.Skip(secondRead), new ArraySegment <byte>(buffer, 0, secondRead));
}
public async Task SendBothRecieveBoth()
{
(Stream a, Stream b) = PairedStream.Create();
await a.WriteAsync(s_bytes, 0, s_bytes.Length);
await b.WriteAsync(s_bytes, 0, s_bytes.Length);
var buffer = new byte[s_bytes.Length * 2];
int read = await b.ReadAsync(buffer, 0, buffer.Length);
Assert.Equal(s_bytes.Length, read);
Assert.Equal(s_bytes, new ArraySegment <byte>(buffer, 0, read));
read = await a.ReadAsync(buffer, 0, buffer.Length);
Assert.Equal(s_bytes.Length, read);
Assert.Equal(s_bytes, new ArraySegment <byte>(buffer, 0, read));
}
public async Task ReceiveNoData_Cancelled()
{
(Stream a, Stream b) = PairedStream.Create();
var buffer = new byte[s_bytes.Length * 2];
var cts = new CancellationTokenSource();
Task[] tasks =
{
a.ReadAsync(buffer, 0, buffer.Length, cts.Token),
b.ReadAsync(buffer, 0, buffer.Length, cts.Token)
};
await TaskHelpers.AssertNotTriggered(tasks[0]);
await TaskHelpers.AssertNotTriggered(tasks[1]);
cts.Cancel();
await TaskHelpers.AssertCancelled(tasks[0]);
await TaskHelpers.AssertCancelled(tasks[1]);
}
