protected override void BuildDataList()
{
List<Tuple<string, string>> variableList;
ScenarioContext.Current.TryGetValue("variableList", out variableList);
if(variableList == null)
{
variableList = new List<Tuple<string, string>>();
ScenarioContext.Current.Add("variableList", variableList);
}
variableList.Add(new Tuple<string, string>(ResultVariable, ""));
BuildShapeAndTestData();
string body;
ScenarioContext.Current.TryGetValue("body", out body);
string subject;
ScenarioContext.Current.TryGetValue("subject", out subject);
string fromAccount;
ScenarioContext.Current.TryGetValue("fromAccount", out fromAccount);
string password;
ScenarioContext.Current.TryGetValue("password", out password);
string simulationOutput;
ScenarioContext.Current.TryGetValue("simulationOutput", out simulationOutput);
string to;
ScenarioContext.Current.TryGetValue("to", out to);
bool isHtml;
ScenarioContext.Current.TryGetValue("isHtml", out isHtml);
var server = SimpleSmtpServer.Start(25);
ScenarioContext.Current.Add("server", server);
var selectedEmailSource = new EmailSource
{
Host = "localhost",
Port = 25,
UserName = "",
Password = "",
ResourceName = Guid.NewGuid().ToString(),
ResourceID = Guid.NewGuid()
};
ResourceCatalog.Instance.SaveResource(Guid.Empty, selectedEmailSource);
var sendEmail = new DsfSendEmailActivity
{
Result = ResultVariable,
Body = string.IsNullOrEmpty(body) ? "" : body,
Subject = string.IsNullOrEmpty(subject) ? "" : subject,
FromAccount = string.IsNullOrEmpty(fromAccount) ? "" : fromAccount,
To = string.IsNullOrEmpty(to) ? "" : to,
SelectedEmailSource = selectedEmailSource,
IsHtml = isHtml
};
TestStartNode = new FlowStep
{
Action = sendEmail
};
ScenarioContext.Current.Add("activity", sendEmail);
}
public void EmailSourcesTestWithInvalidHostExpectedInvalidValidationResult()
{
var source = new EmailSource { Host = "smtp.foobar.com", Port = 25 }.ToString();
var handler = new EmailSources();
var result = handler.Test(source, Guid.Empty, Guid.Empty);
Assert.IsFalse(result.IsValid, result.ErrorMessage);
}
public void EmailSourceContructorWithDefaultExpectedInitializesProperties()
{
var source = new EmailSource();
Assert.AreEqual(Guid.Empty, source.ResourceID);
Assert.AreEqual(ResourceType.EmailSource, source.ResourceType);
Assert.AreEqual(EmailSource.DefaultTimeout, source.Timeout);
Assert.AreEqual(EmailSource.DefaultPort, source.Port);
}
public void EmailSourceContructorWithInvalidXmlExpectedDoesNotThrowExceptionAndInitializesProperties()
{
var xml = new XElement("root");
var source = new EmailSource(xml);
Assert.AreNotEqual(Guid.Empty, source.ResourceID);
Assert.IsTrue(source.IsUpgraded);
Assert.AreEqual(ResourceType.EmailSource, source.ResourceType);
Assert.AreEqual(EmailSource.DefaultTimeout, source.Timeout);
Assert.AreEqual(EmailSource.DefaultPort, source.Port);
}
// POST: Service/EmailSources/Get
public EmailSource Get(string resourceId, Guid workspaceId, Guid dataListId)
{
var result = new EmailSource();
try
{
var xmlStr = ResourceCatalog.Instance.GetResourceContents(workspaceId, Guid.Parse(resourceId)).ToString();
if(!string.IsNullOrEmpty(xmlStr))
{
var xml = XElement.Parse(xmlStr);
result = new EmailSource(xml);
}
}
catch(Exception ex)
{
RaiseError(ex);
}
return result;
}
void Verify_Constructor_DoesNotAutoCopyEmailSourceUserNameIntoFromAccount(string expectedFromAccount)
{
//------------Setup for test--------------------------
var activity = new DsfSendEmailActivity { FromAccount = expectedFromAccount };
var emailSource = new EmailSource
{
UserName = "******",
Password = "******",
EnableSsl = false,
Host = "mx.mydomain.com",
Port = 25,
ResourceID = Guid.NewGuid()
};
var modelItem = ModelItemUtils.CreateModelItem(activity);
var viewModel = CreateViewModel(null, modelItem);
//------------Execute Test---------------------------
viewModel.SelectedEmailSource = emailSource;
//------------Assert Results-------------------------
var fromAccount = modelItem.GetProperty<string>("FromAccount");
Assert.AreEqual(expectedFromAccount, fromAccount);
}
public void EmailDesignerViewModel_Handles_UpdateResourceMessageResourceIdAreNotTheSame_EmailSourceIsNotUpdated()
{
//------------Setup for test--------------------------
var emailSource = new EmailSource
{
ResourceID = Guid.NewGuid(),
ResourceName = "Email1",
UserName = "******",
Password = "******"
};
var emailSources = CreateEmailSources(2);
var modelItem = ModelItemUtils.CreateModelItem(new DsfSendEmailActivity
{
SelectedEmailSource = emailSource
});
var viewModel = CreateViewModel(new List<EmailSource> { emailSource }, modelItem);
var updatedEmailSource = new EmailSource(emailSources[0].ToXml())
{
ResourceID = Guid.NewGuid(),
UserName = "******",
Password = "******"
};
//var xaml = new StringBuilder
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(r => r.WorkflowXaml).Returns(new StringBuilder(updatedEmailSource.ToXml().ToString()));
var message = new UpdateResourceMessage(resourceModel.Object);
//------------Execute Test---------------------------
viewModel.Handle(message);
//------------Assert Results-------------------------
var selectedSource = viewModel.SelectedEmailSourceModelItemValue;
Assert.AreNotEqual(updatedEmailSource.UserName, selectedSource.UserName);
Assert.AreNotEqual(updatedEmailSource.Password, selectedSource.Password);
}
static void VerifySource(EmailSource actual, EmailSource expected)
{
Assert.IsNotNull(actual);
Assert.AreEqual(expected.ResourceID, actual.ResourceID);
Assert.AreEqual(expected.ResourceName, actual.ResourceName);
Assert.AreEqual(expected.ResourcePath, actual.ResourcePath);
Assert.AreEqual(expected.ResourceType, actual.ResourceType);
Assert.AreEqual(expected.ResourceType, actual.ResourceType);
Assert.AreEqual(expected.Host, actual.Host);
Assert.AreEqual(expected.Port, actual.Port);
Assert.AreEqual(expected.EnableSsl, actual.EnableSsl);
Assert.AreEqual(expected.UserName, actual.UserName);
Assert.AreEqual(expected.Password, actual.Password);
Assert.AreEqual(expected.Timeout, actual.Timeout);
}
public void Send(EmailSource emailSource, MailMessage mailMessage)
{
EmailSource = emailSource;
MailMessage = mailMessage;
emailSource.Send(mailMessage);
}
static EmailSource EmailSourceForTesting()
{
var emailSourceForTesting = new EmailSource
{
ResourceName = Guid.NewGuid().ToString(),
ResourceID = Guid.NewGuid(),
Host = "TestHost",
UserName = "******",
Password = "******"
};
ResourceCatalog.Instance.SaveResource(Guid.Empty, emailSourceForTesting);
return emailSourceForTesting;
}
static Mock<IEsbChannel> CreateMockEsbChannel(EmailSource emailSourceForTesting)
{
Mock<IEsbChannel> esbChannelMock = new Mock<IEsbChannel>();
ErrorResultTO errorResultTO;
esbChannelMock.Setup(channel => channel.FetchServerModel<EmailSource>(
It.IsAny<IDSFDataObject>(),
It.IsAny<Guid>(),
out errorResultTO, 0)).Returns(emailSourceForTesting);
return esbChannelMock;
}
void Verify_Execute_FromAccount_EmailSourceIsCorrect(bool isFromAccountGiven)
{
//------------Setup for test--------------------------
const string TestSourceAccount = "*****@*****.**";
const string TestSourcePassword = "******";
const string TestFromAccount = "*****@*****.**";
const string TestFromPassword = "******";
var testSource = new EmailSource
{
Host = "TestHost",
UserName = TestSourceAccount,
Password = TestSourcePassword,
ResourceName = Guid.NewGuid().ToString(),
ResourceID = Guid.NewGuid()
};
ResourceCatalog.Instance.SaveResource(Guid.Empty, testSource);
EmailSource sendSource = null;
MailMessage sendMessage = null;
var emailSender = new Mock<IEmailSender>();
emailSender.Setup(sender => sender.Send(It.IsAny<EmailSource>(), It.IsAny<MailMessage>()))
.Callback<EmailSource, MailMessage>((source, message) =>
{
sendSource = source;
sendMessage = message;
});
var activity = GetSendEmailActivity(emailSender);
activity.SelectedEmailSource = testSource;
activity.Body = "Hello world";
activity.To = "*****@*****.**";
activity.Subject = "This is the subject!";
if(isFromAccountGiven)
{
activity.FromAccount = TestFromAccount;
activity.Password = TestFromPassword;
}
else
{
activity.FromAccount = string.Empty;
activity.Password = string.Empty;
}
TestStartNode = new FlowStep
{
Action = activity
};
TestData = "<root></root>";
CurrentDl = "<ADL></ADL>";
var esbChannelMock = CreateMockEsbChannel(testSource);
//------------Execute Test---------------------------
ExecuteProcess(channel: esbChannelMock.Object, isDebug: true);
// remove test datalist ;)
//------------Assert Results-------------------------
emailSender.Verify(sender => sender.Send(It.IsAny<EmailSource>(), It.IsAny<MailMessage>()), Times.Once());
Assert.IsNotNull(sendSource);
Assert.IsNotNull(sendMessage);
Assert.AreNotSame(testSource, sendSource);
if(isFromAccountGiven)
{
Assert.AreEqual(TestFromAccount, sendSource.UserName);
Assert.AreEqual(TestFromPassword, sendSource.Password);
Assert.AreEqual(TestFromAccount, sendMessage.From.Address);
}
else
{
Assert.AreEqual(TestSourceAccount, sendSource.UserName);
Assert.AreEqual(TestSourcePassword, sendSource.Password);
Assert.AreEqual(TestSourceAccount, sendMessage.From.Address);
}
}
public void EmailSourceContructorWithValidXmlExpectedInitializesProperties()
{
var xml = XmlResource.Fetch("EmailSource");
var source = new EmailSource(xml);
Assert.AreEqual(Guid.Parse("bf810e43-3633-4638-9d0a-56473ef54151"), source.ResourceID);
Assert.AreEqual(ResourceType.EmailSource, source.ResourceType);
Assert.AreEqual("smtp.gmail.com", source.Host);
Assert.AreEqual(465, source.Port);
Assert.AreEqual(true, source.EnableSsl);
Assert.AreEqual(30000, source.Timeout);
Assert.AreEqual("*****@*****.**", source.UserName);
Assert.AreEqual("1234", source.Password);
}
public void EmailSourceContructorWithNullXmlExpectedThrowsArgumentNullException()
{
var source = new EmailSource(null);
}
void Verify_TestEmailAccount(bool isTestResultValid, bool hasFromAccount)
{
//------------Setup for test--------------------------
const string ExpectedUri = AppLocalhost + "/wwwroot/sources/Service/EmailSources/Test";
const string TestToAddress = "*****@*****.**";
const string TestFromAccount = "*****@*****.**";
const string TestFromPassword = "******";
var result = new ValidationResult { IsValid = isTestResultValid };
if (!isTestResultValid)
{
result.ErrorMessage = "Unable to connect to SMTP server";
}
var emailSource = new EmailSource
{
ResourceID = Guid.NewGuid(),
ResourceName = "EmailTest",
UserName = "******",
Password = "******",
};
var modelItem = CreateModelItem();
modelItem.SetProperty("SelectedEmailSource", emailSource);
modelItem.SetProperty("To", TestToAddress);
var expectedSource = new EmailSource(emailSource.ToXml()) { TestToAddress = TestToAddress };
if (hasFromAccount)
{
modelItem.SetProperty("FromAccount", TestFromAccount);
modelItem.SetProperty("Password", TestFromPassword);
expectedSource.UserName = TestFromAccount;
expectedSource.Password = TestFromPassword;
expectedSource.TestFromAddress = TestFromAccount;
}
else
{
expectedSource.TestFromAddress = emailSource.UserName;
}
var expectedPostData = expectedSource.ToString();
string postData = null;
var webRequestInvoker = new Mock<IWebRequestInvoker>();
webRequestInvoker.Setup(w => w.ExecuteRequest("POST", ExpectedUri, It.IsAny<string>(), null, It.IsAny<Action<string>>()))
.Callback((string method, string url, string data, List<Tuple<string, string>> headers, Action<string> asyncCallback) =>
{
postData = data;
asyncCallback(new Dev2JsonSerializer().Serialize(result));
}).Returns(string.Empty)
.Verifiable();
var viewModel = CreateViewModel(new List<EmailSource> { emailSource }, modelItem);
viewModel.WebRequestInvoker = webRequestInvoker.Object;
Assert.IsTrue(viewModel.CanTestEmailAccount);
//------------Execute Test---------------------------
viewModel.TestEmailAccountCommand.Execute(null);
//------------Assert Results-------------------------
webRequestInvoker.Verify(w => w.ExecuteRequest("POST", ExpectedUri, It.IsAny<string>(), null, It.IsAny<Action<string>>()));
Assert.IsNotNull(postData);
Assert.AreEqual(expectedPostData, postData);
Assert.IsTrue(viewModel.CanTestEmailAccount);
if (isTestResultValid)
{
Assert.IsNull(viewModel.Errors);
}
else
{
Assert.IsNotNull(viewModel.Errors);
Assert.AreEqual(result.ErrorMessage, viewModel.Errors[0].Message);
Assert.IsFalse(viewModel.IsFromAccountFocused);
viewModel.Errors[0].Do();
Assert.IsTrue(viewModel.IsFromAccountFocused);
}
}
ValidationResult CanConnectServer(EmailSource emailSource)
{
try
{
var userParts = emailSource.UserName.Split(new[] { '@' });
var smtp = new SmtpClient(emailSource.Host, emailSource.Port)
{
Credentials = new NetworkCredential(userParts[0], emailSource.Password),
EnableSsl = emailSource.EnableSsl,
DeliveryMethod = SmtpDeliveryMethod.Network,
Timeout = emailSource.Timeout
};
try
{
smtp.Send(emailSource.TestFromAddress, emailSource.TestToAddress, "Test Message", "This is a test message");
return new ValidationResult();
}
finally
{
smtp.Dispose();
}
}
catch(SmtpException sex)
{
RaiseError(sex);
var message = sex.Message;
if(sex.StatusCode == SmtpStatusCode.MustIssueStartTlsFirst && sex.Message.Contains("Learn more at"))
{
message = message.Replace(" Learn more at", "");
}
var errors = new StringBuilder();
errors.AppendFormat("{0} ", message);
Exception ex = sex.InnerException;
while(ex != null)
{
errors.AppendFormat("{0} ", ex.Message);
ex = ex.InnerException;
}
return new ValidationResult
{
IsValid = false,
ErrorMessage = errors.ToString()
};
}
}
public void EmailDesignerViewModel_TestEmailCommand_WhenToAddressIsVariable_ShouldBeError()
{
//------------Setup for test--------------------------
const string ExpectedUri = AppLocalhost + "/wwwroot/sources/Service/EmailSources/Test";
const string TestToAddress = "[[var1]]";
const string TestFromAccount = "*****@*****.**";
const string TestFromPassword = "******";
var emailSource = new EmailSource
{
ResourceID = Guid.NewGuid(),
ResourceName = "EmailTest",
UserName = "******",
Password = "******",
};
var modelItem = CreateModelItem();
modelItem.SetProperty("SelectedEmailSource", emailSource);
modelItem.SetProperty("To", TestToAddress);
var expectedSource = new EmailSource(emailSource.ToXml()) { TestToAddress = TestToAddress };
modelItem.SetProperty("FromAccount", TestFromAccount);
modelItem.SetProperty("Password", TestFromPassword);
expectedSource.UserName = TestFromAccount;
expectedSource.Password = TestFromPassword;
expectedSource.TestFromAddress = TestFromAccount;
var webRequestInvoker = new Mock<IWebRequestInvoker>();
webRequestInvoker.Setup(w => w.ExecuteRequest("POST", ExpectedUri, It.IsAny<string>(), null, It.IsAny<Action<string>>()))
.Returns(string.Empty)
.Verifiable();
var viewModel = CreateViewModel(new List<EmailSource> { emailSource }, modelItem);
viewModel.WebRequestInvoker = webRequestInvoker.Object;
Assert.IsTrue(viewModel.CanTestEmailAccount);
//------------Execute Test---------------------------
viewModel.TestEmailAccountCommand.Execute(null);
//------------Assert Results-------------------------
Assert.IsNotNull(viewModel.Errors);
Assert.AreEqual("Variable [[var1]] cannot be used while testing.", viewModel.Errors[0].Message);
Assert.IsFalse(viewModel.IsFromAccountFocused);
viewModel.Errors[0].Do();
Assert.IsTrue(viewModel.IsFromAccountFocused);
}
public void EmailSourceToXmlExpectedSerializesProperties()
{
var expected = new EmailSource
{
Host = "smtp.mydomain.com",
Port = 25,
EnableSsl = false,
UserName = "******",
Password = "******",
Timeout = 1000,
TestFromAddress = "*****@*****.**",
TestToAddress = "*****@*****.**"
};
var xml = expected.ToXml();
var actual = new EmailSource(xml);
Assert.AreEqual(expected.ResourceType, actual.ResourceType);
Assert.AreEqual(expected.Host, actual.Host);
Assert.AreEqual(expected.Port, actual.Port);
Assert.AreEqual(expected.EnableSsl, actual.EnableSsl);
Assert.AreEqual(expected.UserName, actual.UserName);
Assert.AreEqual(expected.Password, actual.Password);
Assert.AreEqual(expected.Timeout, actual.Timeout);
Assert.IsNull(actual.TestFromAddress);
Assert.IsNull(actual.TestToAddress);
}
