public async Task AuthenticatedLargeMessageAccepted()
{
var expectedBody = "From:[email protected]\r\n\r\nFirst Line\r\nSecond Line\r\n";
(MockMailQueue queue, MockMailBuilder builder, MockSmtpChannel channel, DataCommand command) = Prepare(
expectedBody + ".\r\n",
TestHelpers.MakeSettings(unauthenticatedMessageSizeLimit: 1));
channel.AuthenticatedUser = new UserData("*****@*****.**");
builder.PendingMail = new SmtpMailMessage(new SmtpPath("*****@*****.**"))
{
Recipents = { "*****@*****.**" }
};
await command.ExecuteAsync(CancellationToken.None);
Assert.Equal(2, channel.Entries.Count);
SmtpTestHelper.AssertResponse(channel.Entries[0], SmtpReplyCode.StartMail);
SmtpTestHelper.AssertResponse(channel.Entries[1], SmtpReplyCode.Okay);
Assert.Equal(1, queue.References.Count);
MockMailReference mailReference = queue.References[0];
Assert.True(mailReference.IsSaved);
Assert.Equal("*****@*****.**", mailReference.Sender);
SequenceAssert.SameSet(new[] { "*****@*****.**" }, mailReference.Recipients);
Assert.Throws <ObjectDisposedException>(() => mailReference.BodyStream.WriteByte(1));
string mailBody = Encoding.UTF8.GetString(mailReference.BackupBodyStream.ToArray());
Assert.EndsWith(expectedBody, mailBody);
Assert.StartsWith("Received:", mailBody);
Assert.Null(builder.PendingMail);
}
public void WithConvertBackFunction_UsingConverterParameter()
{
// with a wrong target type (use default error strategy)
SequenceAssert.AreEqual(
new object[] { null },
MultiValueConverter.Create <string, int, bool>(convertBackFunction: e => null).ConvertBack(1, new[] { typeof(bool) }, true, null));
// without a target type
Assert.IsNull(MultiValueConverter.Create <string, int, bool>(convertBackFunction: e => null).ConvertBack(1, new Type[] { }, true, null));
Assert.IsNull(
MultiValueConverter.Create <string, int, bool>(convertBackFunction: e => null)
.ConvertBack(1, new[] { typeof(string), null }, true, null));
SequenceAssert.AreEqual(
new[] { "a", "b" },
MultiValueConverter.Create <string, int, bool>(convertBackFunction: e => new[] { "a", "b" }).ConvertBack(1, null, true, null));
// with an unexpected parameter (use default error strategy)
SequenceAssert.AreEqual(
new object[] { null },
MultiValueConverter.Create <string, int, bool>(convertBackFunction: e => null).ConvertBack(1, new[] { typeof(string) }, "p", null));
SequenceAssert.AreEqual(
new object[] { null },
MultiValueConverter.Create <string, int, bool>(convertBackFunction: e => null).ConvertBack(1, new[] { typeof(string) }, null, null));
// with an input value of an unexpected type (use default error strategy)
SequenceAssert.AreEqual(
new object[] { null },
MultiValueConverter.Create <string, int, bool>(convertBackFunction: e => null).ConvertBack(true, new[] { typeof(string) }, true, null));
SequenceAssert.AreEqual(
new object[] { null },
MultiValueConverter.Create <string, int, bool>(convertBackFunction: e => null).ConvertBack(null, new[] { typeof(string) }, true, null));
// with a valid input value
SequenceAssert.AreEqual(
new[] { "a", "b" },
MultiValueConverter.Create <string, int, bool>(convertBackFunction: e => new[] { "a", "b" })
.ConvertBack(1, new[] { typeof(string), typeof(string) }, true, null));
SequenceAssert.AreEqual(
new[] { "1", "1" },
MultiValueConverter.Create <string, int, bool>(
convertBackFunction: e =>
{
Assert.AreEqual(1, e.Value);
Assert.AreEqual(true, e.Parameter);
Assert.IsNull(e.Culture);
return(new[] { e.Value.ToString(), e.Value.ToString() });
}).ConvertBack(1, new[] { typeof(string), typeof(string) }, true, null));
SequenceAssert.AreEqual(
new[] { "1", "1" },
MultiValueConverter.Create <string, int, bool>(
convertBackFunction: e =>
{
Assert.AreEqual(1, e.Value);
Assert.AreEqual(false, e.Parameter);
Assert.AreEqual(new CultureInfo("en-GB"), e.Culture);
return(new[] { e.Value.ToString(), e.Value.ToString() });
}).ConvertBack(1, new[] { typeof(string), typeof(string) }, false, new CultureInfo("en-GB")));
}
public async Task Unsecured_Certificate_ExtendedHelloResponds()
{
var channel = new MockSmtpChannel();
var conn = new MockConnectionSecurity();
conn.Certificate = TestHelpers.GetSelfSigned();
var command = new ExtendedHelloCommand(
TestHelpers.GetAuths(),
conn,
channel,
TestHelpers.MakeSettings("test.vaettir.net"),
new MockLogger());
command.Initialize("Sender.net");
await command.ExecuteAsync(CancellationToken.None);
Assert.True(channel.Entries.All(c => c.Code == SmtpReplyCode.Okay));
Assert.True(channel.Entries.Take(channel.Entries.Count - 1).All(e => e.More));
Assert.False(channel.Entries.Last().More);
Assert.Contains(channel.Entries, e => e.Message == "STARTTLS");
List <MockSmtpChannel.Entry> authReplies = channel.Entries.Where(e => e.Message.StartsWith("AUTH")).ToList();
Assert.Single(authReplies);
List <string> authParts = authReplies[0].Message.Split(' ').Skip(1).ToList();
SequenceAssert.SameSet(new[] { "PLN" }, authParts);
MockSmtpChannel.Entry signoff = channel.Entries.First();
Assert.Contains("test.vaettir.net", signoff.Message);
Assert.Contains("Sender.net", signoff.Message);
}
public void SkipTakeTest()
{
// Arrange
string firstNameStart = TestUser.FirstName.Substring(0, 1);
int skip = 1;
int take = 2;
IEnumerable <User> expected;
IEnumerable <User> actual;
// Act
using (var context = new DirectoryContextMock()) {
var queryBase = context.Users.Where(u => u.FirstName.StartsWith(firstNameStart));
int total = queryBase.Count();
if (total <= skip + take)
{
Assert.Inconclusive("Not enough elements for this test.");
}
expected = queryBase.ToArray().Skip(skip).Take(take);
actual = queryBase.Skip(skip).Take(take).ToArray();
}
// Assert
SequenceAssert.AreEqual(expected.Select(u => u.LastName), actual.Select(u => u.LastName));
}
public async Task InternalSenderCanSendAnywhere()
{
var body = "My body\nNext Line";
_queue.References.Add(
new MockMailReference(
"ext-mail",
"*****@*****.**",
new[] { "*****@*****.**" }.ToImmutableList(),
true,
body,
_queue));
await _dispatcher.ProcessAllMailReferencesAsync(CancellationToken.None);
Assert.Empty(_queue.References);
Assert.Equal(1, _queue.DeletedReferences.Count);
Assert.Equal(1, _transfer.References.Count(r => r.IsSaved));
string newBody;
using (MockMailReference reference = _transfer.References.FirstOrDefault(r => r.IsSaved))
{
Assert.NotNull(reference);
Assert.Equal("*****@*****.**", reference.Sender);
SequenceAssert.SameSet(new[] { "*****@*****.**" }, reference.Recipients);
newBody = await StreamUtility.ReadAllFromStreamAsync(reference.BackupBodyStream);
}
Assert.Equal(body, newBody);
Assert.Empty(_mailbox.References);
}
public void ParseMailboxListHeader_MultiSingleQuoted()
{
SequenceAssert.SameSet(
new[] { "*****@*****.**", "*****@*****.**" },
_dispatcher.ParseMailboxListHeader(
"\"Box, The\" <*****@*****.**>, \"Guy, Other\" <*****@*****.**>".ToEnumerable()));
}
public void ResolveDomains_ExpandsKeepsOthers()
{
SequenceAssert.SameSet(
new[] { "*****@*****.**", "*****@*****.**", "*****@*****.**" },
_dispatcher.ExpandDistributionLists(
"*****@*****.**",
new[] { "*****@*****.**", "*****@*****.**" },
new HashSet <string>()));
}
public void WriteVersion5(string inputResourceName, Type resourceAnchor, byte[] expectedWevt)
{
var manifest = TestHelper.LoadManifest(resourceAnchor, inputResourceName);
using var tempFile = new TempFile();
using (var writer = new EventTemplateWriter(tempFile.Stream))
writer.Write(manifest.Providers);
SequenceAssert.SequenceEqual(expectedWevt, tempFile.Stream.ReadAllBytes());
}
public void ResolveDomains_RespectExclusion()
{
SequenceAssert.SameSet(
new[] { "*****@*****.**" },
_dispatcher.ExpandDistributionLists(
"*****@*****.**",
new[] { "*****@*****.**" },
new HashSet <string> {
"*****@*****.**"
}));
}
public void ParseMailboxListHeader_MultiMulti()
{
SequenceAssert.SameSet(
new[] { "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**" },
_dispatcher.ParseMailboxListHeader(
new[]
{
"\"Box, The\" <*****@*****.**>, \"Guy, Other\" <*****@*****.**>",
"[email protected], [email protected]"
}));
}
public void Write(string inputResourceName, Type resourceAnchor, byte[] expectedMsgTable)
{
var manifest = TestHelper.LoadManifest(resourceAnchor, inputResourceName);
Assert.Single(manifest.Resources);
using var tempStream = new MemoryStream();
using (var writer = new MessageTableWriter(tempStream))
writer.Write(manifest.Resources[0].Strings.Select(CreateMessage), diags);
SequenceAssert.SequenceEqual(expectedMsgTable, tempStream.ReadAllBytes());
}
public void WithConvertFunction_UsingConverterParameter()
{
// with a wrong target type (use default error strategy)
Assert.IsNull(MultiValueConverter.Create <int, string?, bool>(e => null).Convert(new object[] { 1, 2 }, typeof(bool), true, null));
// without a target type
Assert.AreEqual("a", MultiValueConverter.Create <int, string, bool>(e => "a").Convert(new object[] { 1, 2 }, null, true, null));
// with an unexpected parameter (use default error strategy)
Assert.IsNull(MultiValueConverter.Create <int, string?, bool>(e => null).Convert(new object[] { 1, 2 }, typeof(string), "p", null));
Assert.IsNull(MultiValueConverter.Create <int, string?, bool>(e => null).Convert(new object[] { 1, 2 }, typeof(string), null, null));
// with an input value of an unexpected type (use default error strategy)
Assert.IsNull(
MultiValueConverter.Create <int, string?, bool>(e => null).Convert(new object?[] { true, null }, typeof(string), true, null));
Assert.IsNull(
MultiValueConverter.Create <int, string?, bool>(e => null).Convert(new object?[] { null, true }, typeof(string), true, null));
Assert.IsNull(
MultiValueConverter.Create <int, string?, bool>(e => null).Convert(ArrayUtils.GetEmpty <object>(), typeof(string), true, null));
Assert.IsNull(MultiValueConverter.Create <int, string?, bool>(e => null).Convert(null, typeof(string), true, null));
// with a valid input value
Assert.AreEqual("a", MultiValueConverter.Create <int, string, bool>(e => "a").Convert(new object[] { 1, 2 }, typeof(string), true, null));
Assert.AreEqual(
"3",
MultiValueConverter.Create <int, string, bool>(
e =>
{
SequenceAssert.AreEqual(new[] { 1, 2 }, e.Values);
Assert.AreEqual(true, e.Parameter);
Assert.IsNull(e.Culture);
return(e.Values.Sum().ToString());
})
.Convert(new object[] { 1, 2 }, typeof(string), true, null));
Assert.AreEqual(
"3",
MultiValueConverter.Create <int, string, bool>(
e =>
{
SequenceAssert.AreEqual(new[] { 1, 2 }, e.Values);
Assert.AreEqual(false, e.Parameter);
Assert.AreEqual(new CultureInfo("en-GB"), e.Culture);
return(e.Values.Sum().ToString());
})
.Convert(new object[] { 1, 2 }, typeof(string), false, new CultureInfo("en-GB")));
}
public async Task AcceptMultiple()
{
var channel = new MockSmtpChannel();
var mail = new SmtpMailMessage(new SmtpPath("*****@*****.**"));
mail.Recipents.Add("*****@*****.**");
var builder = new MockMailBuilder {
PendingMail = mail
};
var command = new RecipientCommand(
builder,
channel,
TestHelpers.MakeSettings(
"test.vaettir.net",
new[] { new SmtpAcceptDomain("test.vaettir.net") })
);
command.Initialize("TO:<*****@*****.**>");
await command.ExecuteAsync(CancellationToken.None);
SmtpTestHelper.AssertResponse(channel, SmtpReplyCode.Okay);
Assert.Same(mail, builder.PendingMail);
SequenceAssert.SameSet(new[] { "*****@*****.**", "*****@*****.**" }, mail.Recipents);
}
public void NoFunctions_UsingConverterParameter()
{
// invalid error strategy
ExceptionAssert.Throws <ArgumentOutOfRangeException>(
() => MultiValueConverter.Create <int, string, bool>(errorStrategy: (ConverterErrorStrategy)int.MaxValue),
"errorStrategy");
// with ConverterErrorStrategy.ReturnDefaultValue (default)
Assert.AreEqual(null, MultiValueConverter.Create <int, string, bool>().Convert(null, null, null, null));
Assert.AreEqual(null, MultiValueConverter.Create <int, string, bool>().Convert(ArrayUtils.GetEmpty <object>(), null, null, null));
Assert.AreEqual(null, MultiValueConverter.Create <int, string, bool>().Convert(new object[] { 1, 2 }, null, null, null));
Assert.AreEqual(0, MultiValueConverter.Create <int, int, bool>().Convert(null, null, null, null));
Assert.AreEqual(0, MultiValueConverter.Create <int, int, bool>().Convert(ArrayUtils.GetEmpty <object>(), null, null, null));
Assert.AreEqual(0, MultiValueConverter.Create <int, int, bool>().Convert(new object[] { 1, 2 }, null, null, null));
Assert.AreEqual(false, MultiValueConverter.Create <int, bool, bool>().Convert(null, null, null, null));
Assert.AreEqual(false, MultiValueConverter.Create <int, bool, bool>().Convert(ArrayUtils.GetEmpty <object>(), null, null, null));
Assert.AreEqual(false, MultiValueConverter.Create <int, bool, bool>().Convert(new object[] { 1, 2 }, null, null, null));
Assert.IsNull(MultiValueConverter.Create <string, int, bool>().ConvertBack(1, null, null, null));
SequenceAssert.AreEqual(
ArrayUtils.GetEmpty <object>(),
MultiValueConverter.Create <string, int, bool>().ConvertBack(1, ArrayUtils.GetEmpty <Type>(), null, null));
SequenceAssert.AreEqual(
new object[2],
MultiValueConverter.Create <string, int, bool>().ConvertBack(1, new[] { typeof(int), typeof(string) }, null, null));
Assert.IsNull(MultiValueConverter.Create <int, int, bool>().ConvertBack(1, null, null, null));
SequenceAssert.AreEqual(
ArrayUtils.GetEmpty <object>(),
MultiValueConverter.Create <int, int, bool>().ConvertBack(1, ArrayUtils.GetEmpty <Type>(), null, null));
SequenceAssert.AreEqual(
new object[] { 0, 0 },
MultiValueConverter.Create <int, int, bool>().ConvertBack(1, new[] { typeof(int), typeof(string) }, null, null));
Assert.IsNull(MultiValueConverter.Create <bool, int, bool>().ConvertBack(1, null, null, null));
SequenceAssert.AreEqual(
ArrayUtils.GetEmpty <object>(),
MultiValueConverter.Create <bool, int, bool>().ConvertBack(1, ArrayUtils.GetEmpty <Type>(), null, null));
SequenceAssert.AreEqual(
new object[] { false, false },
MultiValueConverter.Create <bool, int, bool>().ConvertBack(1, new[] { typeof(int), typeof(string) }, null, null));
// with ConverterErrorStrategy.UseFallbackOrDefaultValue
Assert.AreEqual(
DependencyProperty.UnsetValue,
MultiValueConverter.Create <int, string, bool>(errorStrategy: ConverterErrorStrategy.UseFallbackOrDefaultValue)
.Convert(null, null, null, null));
Assert.AreEqual(
DependencyProperty.UnsetValue,
MultiValueConverter.Create <int, string, bool>(errorStrategy: ConverterErrorStrategy.UseFallbackOrDefaultValue)
.Convert(ArrayUtils.GetEmpty <object>(), null, null, null));
Assert.AreEqual(
DependencyProperty.UnsetValue,
MultiValueConverter.Create <int, string, bool>(errorStrategy: ConverterErrorStrategy.UseFallbackOrDefaultValue)
.Convert(new object[] { 1, 2 }, null, null, null));
Assert.IsNull(
MultiValueConverter.Create <string, int, bool>(errorStrategy: ConverterErrorStrategy.UseFallbackOrDefaultValue)
.ConvertBack(1, null, null, null));
SequenceAssert.AreEqual(
ArrayUtils.GetEmpty <object>(),
MultiValueConverter.Create <string, int, bool>(errorStrategy: ConverterErrorStrategy.UseFallbackOrDefaultValue)
.ConvertBack(1, ArrayUtils.GetEmpty <Type>(), null, null));
SequenceAssert.AreEqual(
new[] { DependencyProperty.UnsetValue, DependencyProperty.UnsetValue },
MultiValueConverter.Create <string, int, bool>(errorStrategy: ConverterErrorStrategy.UseFallbackOrDefaultValue)
.ConvertBack(1, new[] { typeof(int), typeof(string) }, null, null));
// with ConverterErrorStrategy.DoNothing
Assert.AreEqual(
Binding.DoNothing,
MultiValueConverter.Create <int, string, bool>(errorStrategy: ConverterErrorStrategy.DoNothing).Convert(null, null, null, null));
Assert.AreEqual(
Binding.DoNothing,
MultiValueConverter.Create <int, string, bool>(errorStrategy: ConverterErrorStrategy.DoNothing)
.Convert(ArrayUtils.GetEmpty <object>(), null, null, null));
Assert.AreEqual(
Binding.DoNothing,
MultiValueConverter.Create <int, string, bool>(errorStrategy: ConverterErrorStrategy.DoNothing)
.Convert(new object[] { 1, 2 }, null, null, null));
Assert.IsNull(
MultiValueConverter.Create <string, int, bool>(errorStrategy: ConverterErrorStrategy.DoNothing).ConvertBack(1, null, null, null));
SequenceAssert.AreEqual(
ArrayUtils.GetEmpty <object>(),
MultiValueConverter.Create <string, int, bool>(errorStrategy: ConverterErrorStrategy.DoNothing)
.ConvertBack(1, ArrayUtils.GetEmpty <Type>(), null, null));
SequenceAssert.AreEqual(
new[] { Binding.DoNothing, Binding.DoNothing },
MultiValueConverter.Create <string, int, bool>(errorStrategy: ConverterErrorStrategy.DoNothing)
.ConvertBack(1, new[] { typeof(int), typeof(string) }, null, null));
}
public void NoDependencies()
=>
SequenceAssert.DoesNotContain(
from assemblyName in Assembly.GetReferencedAssemblies() select assemblyName.Name,
"JetBrains.Annotations");
public void ParseMailboxListHeader_HeaderParsing_Single()
{
SequenceAssert.SameSet(
new[] { "*****@*****.**" },
_dispatcher.ParseMailboxListHeader("*****@*****.**".ToEnumerable()));
}
public void ResolveDomains_NoResolve()
{
SequenceAssert.SameSet(
new[] { "*****@*****.**" },
_dispatcher.ExpandDistributionLists("*****@*****.**", new[] { "*****@*****.**" }, new HashSet <string>()));
}
