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); }