public void IfThereIsAnExceptionBuildMessageShouldPublishExceptionMessage()
{
DynamicMock mock = new DynamicMock(typeof(IMessageBuilder));
mock.ExpectAndThrow("BuildMessage", new Exception("oops"), new IsAnything());
publisher = new EmailPublisher((IMessageBuilder) mock.MockInstance);
string message = publisher.CreateMessage(new IntegrationResult());
AssertContains("oops", message);
}
public void ShouldNotSendMessageIfRecipientIsNotSpecifiedAndBuildIsSuccessful()
{
mockGateway.ExpectNoCall("Send", typeof(MailMessage));
publisher = new EmailPublisher();
publisher.EmailGateway = (EmailGateway) mockGateway.MockInstance;
publisher.IndexedEmailUsers.Add("bar", new EmailUser("bar", "foo", "*****@*****.**"));
publisher.IndexedEmailGroups.Add("foo", new EmailGroup("foo", new EmailGroup.NotificationType[] { EmailGroup.NotificationType.Change }));
publisher.Run(IntegrationResultMother.CreateStillSuccessful());
mockGateway.Verify();
}
public void ShouldSendMessageIfBuildFailed()
{
mockGateway.Expect("Send", new MailMessageRecipientValidator(1));
publisher = new EmailPublisher();
publisher.FromAddress = "*****@*****.**";
publisher.EmailGateway = (EmailGateway) mockGateway.MockInstance;
publisher.IndexedEmailUsers.Add("bar", new EmailUser("bar", "foo", "*****@*****.**"));
publisher.IndexedEmailGroups.Add("foo", new EmailGroup("foo", new EmailGroup.NotificationType[] { EmailGroup.NotificationType.Failed }));
publisher.Run(IntegrationResultMother.CreateFailed() );
mockGateway.Verify();
}
protected void CreatePublisher()
{
publisher = new EmailPublisher();
publisher.IndexedEmailGroups.Add(alwaysGroup.Name, alwaysGroup);
publisher.IndexedEmailGroups.Add(changedGroup.Name, changedGroup);
publisher.IndexedEmailGroups.Add(failedGroup.Name, failedGroup);
publisher.IndexedEmailGroups.Add(successGroup.Name, successGroup);
publisher.IndexedEmailUsers.Add(always.Name, always);
publisher.IndexedEmailUsers.Add(failed.Name, failed);
publisher.IndexedEmailUsers.Add(changed.Name, changed);
publisher.IndexedEmailUsers.Add(success.Name, success);
publisher.IndexedEmailUsers.Add(modifier.Name, modifier);
}
/// <summary>
/// constructor
/// </summary>
/// <param name="result"></param>
/// <param name="emailPublisher"></param>
public EmailMessage(IIntegrationResult result, EmailPublisher emailPublisher)
{
this.result = result;
this.emailPublisher = emailPublisher;
// copy into own lookuptable for easier processing
SetSubjects = new Hashtable();
string mySubject;
foreach (EmailSubject setValue in emailPublisher.SubjectSettings)
{
SetSubjects.Add(setValue.BuildResult, setValue.Value);
}
//add missing defaults for each notificationtype
foreach (EmailSubject.BuildResultType item in System.Enum.GetValues(typeof(EmailSubject.BuildResultType)))
{
if (!SetSubjects.ContainsKey(item))
{
switch (item)
{
case EmailSubject.BuildResultType.Broken:
mySubject = "${CCNetProject} Build Failed";
break;
case EmailSubject.BuildResultType.Exception:
mySubject = "${CCNetProject} Exception in Build !";
break;
case EmailSubject.BuildResultType.Fixed:
mySubject = "${CCNetProject} Build Fixed: Build ${CCNetLabel}";
break;
case EmailSubject.BuildResultType.StillBroken:
mySubject = "${CCNetProject} is still broken";
break;
case EmailSubject.BuildResultType.Success:
mySubject = "${CCNetProject} Build Successful: Build ${CCNetLabel}";
break;
default:
throw new CruiseControlException("Unknown BuildResult : " + item);
}
SetSubjects.Add(item, mySubject);
}
}
}
public void ShouldSendMessageIfBuildFailedAndPreviousFailed()
{
mockGateway.Expect("Send", new MailMessageRecipientValidator(1));
publisher = new EmailPublisher();
publisher.FromAddress = "*****@*****.**";
publisher.EmailGateway = (EmailGateway)mockGateway.MockInstance;
publisher.IndexedEmailUsers.Add("dev", new EmailUser("dev", "changing", "*****@*****.**"));
publisher.IndexedEmailUsers.Add("admin", new EmailUser("admin", "failing", "*****@*****.**"));
publisher.IndexedEmailGroups.Add("changing", new EmailGroup("changing", new EmailGroup.NotificationType[] { EmailGroup.NotificationType.Change }));
publisher.IndexedEmailGroups.Add("failing", new EmailGroup("failing", new EmailGroup.NotificationType[] { EmailGroup.NotificationType.Failed }));
publisher.Run(IntegrationResultMother.CreateFailed(IntegrationStatus.Failure) );
mockGateway.Verify();
}
public void PopulateFromConfiguration()
{
publisher = EmailPublisherMother.Create();
Assert.AreEqual("smtp.telus.net", publisher.MailHost);
Assert.AreEqual(26, publisher.MailPort);
Assert.AreEqual("mailuser", publisher.MailhostUsername);
Assert.IsNotNull(publisher.MailhostPassword);
Assert.AreEqual("mailpassword", publisher.MailhostPassword.PrivateValue);
Assert.AreEqual("*****@*****.**", publisher.FromAddress);
Assert.AreEqual(2, publisher.ModifierNotificationTypes.Length);
Assert.AreEqual(EmailGroup.NotificationType.Failed, publisher.ModifierNotificationTypes[0]);
Assert.AreEqual(EmailGroup.NotificationType.Fixed, publisher.ModifierNotificationTypes[1]);
Assert.AreEqual(1, publisher.Converters.Length);
Assert.AreEqual("$", ((EmailRegexConverter) publisher.Converters[0]).Find);
Assert.AreEqual("@TheCompany.com", ((EmailRegexConverter) publisher.Converters[0]).Replace);
Assert.AreEqual(6, publisher.EmailUsers.Count);
ArrayList expected = new ArrayList();
expected.Add(new EmailUser("buildmaster", "buildmaster", "*****@*****.**"));
expected.Add(new EmailUser("orogers", "developers", "*****@*****.**"));
expected.Add(new EmailUser("manders", "developers", "*****@*****.**"));
expected.Add(new EmailUser("dmercier", "developers", "*****@*****.**"));
expected.Add(new EmailUser("rwan", "developers", "*****@*****.**"));
expected.Add(new EmailUser("owjones", "successdudes", "*****@*****.**"));
for (int i = 0; i < expected.Count; i++)
{
Assert.IsTrue(publisher.EmailUsers.ContainsValue(expected[i]));
}
Assert.AreEqual(3, publisher.EmailGroups.Count);
EmailGroup developers = new EmailGroup("developers", new EmailGroup.NotificationType[] { EmailGroup.NotificationType.Change });
EmailGroup buildmaster = new EmailGroup("buildmaster", new EmailGroup.NotificationType[] { EmailGroup.NotificationType.Always });
EmailGroup successdudes = new EmailGroup("successdudes", new EmailGroup.NotificationType[] { EmailGroup.NotificationType.Success });
Assert.AreEqual(developers, publisher.EmailGroups["developers"]);
Assert.AreEqual(buildmaster, publisher.EmailGroups["buildmaster"]);
Assert.AreEqual(successdudes, publisher.EmailGroups["successdudes"]);
}
public EmailMessage(IIntegrationResult result, EmailPublisher emailPublisher)
{
this.result = result;
this.emailPublisher = emailPublisher;
}
public void ShouldSendToModifiersAndFailureUsers()
{
mockGateway.Expect("Send", new MailMessageRecipientValidator(2));
publisher = new EmailPublisher();
publisher.FromAddress = "*****@*****.**";
publisher.EmailGateway = (EmailGateway)mockGateway.MockInstance;
publisher.EmailUsers.Add("user1", new EmailUser("user1", null, "*****@*****.**"));
publisher.EmailUsers.Add("user2", new EmailUser("user2", null, "*****@*****.**"));
IntegrationResult result;
Modification modification;
result = IntegrationResultMother.CreateFailed();
result.FailureUsers.Add("user1");
modification = new Modification();
modification.UserName = "******";
modification.ModifiedTime = new DateTime(1973, 12, 24, 2, 30, 00);
result.Modifications = new Modification[] { modification };
publisher.Run(result);
mockGateway.Verify();
}
public EmailMessage(IIntegrationResult result, EmailPublisher emailPublisher)
{
this.result = result;
this.emailPublisher = emailPublisher;
}
public void ShouldPopulateFromMinimalConfiguration()
{
string configXml = @"<email from=""*****@*****.**"" mailhost=""smtp.example.com""> <users/> <groups/> </email>";
XmlDocument configXmlDocument = XmlUtil.CreateDocument(configXml);
publisher = EmailPublisherMother.Create(configXmlDocument.DocumentElement);
Assert.AreEqual("smtp.example.com", publisher.MailHost);
Assert.AreEqual(25, publisher.MailPort);
Assert.AreEqual(null, publisher.MailhostUsername);
Assert.AreEqual(null, publisher.MailhostPassword);
Assert.AreEqual(null, publisher.ReplyToAddress);
Assert.AreEqual(false, publisher.IncludeDetails);
Assert.AreEqual("*****@*****.**", publisher.FromAddress);
Assert.AreEqual(1, publisher.ModifierNotificationTypes.Length);
Assert.AreEqual(EmailGroup.NotificationType.Always, publisher.ModifierNotificationTypes[0]);
Assert.AreEqual(0, publisher.Converters.Length);
Assert.AreEqual(0, publisher.EmailUsers.Count);
Assert.AreEqual(0, publisher.EmailGroups.Count);
}
public void ShouldPopulateXslFiles()
{
string configXml = @"<email from=""*****@*****.**"" mailhost=""smtp.example.com""> <users/> <groups/>
<xslFiles>
<file>xsl\NCover.xsl</file>
<file>xsl\NCoverExplorer.xsl</file>
</xslFiles>
</email>";
XmlDocument configXmlDocument = XmlUtil.CreateDocument(configXml);
publisher = EmailPublisherMother.Create(configXmlDocument.DocumentElement);
Assert.AreEqual(2, publisher.XslFiles.Length);
Assert.AreEqual(@"xsl\NCover.xsl", publisher.XslFiles[0]);
Assert.AreEqual(@"xsl\NCoverExplorer.xsl", publisher.XslFiles[1]);
}
public void SetUp()
{
publisher = EmailPublisherMother.Create();
mockGateway = new DynamicMock(typeof(EmailGateway));
publisher.EmailGateway = (EmailGateway) mockGateway.MockInstance;
}
public void SerializeToXml()
{
publisher = EmailPublisherMother.Create();
string xml = NetReflector.Write(publisher);
XmlUtil.VerifyXmlIsWellFormed(xml);
}
public void HandleEmailUserWithUnspecifiedGroup()
{
publisher = new EmailPublisher();
publisher.EmailUsers.Add(modifier.Name, modifier);
publisher.EmailUsers.Add("foo", new EmailUser("foo", null, "*****@*****.**"));
IIntegrationResult result = AddModification(IntegrationResultMother.CreateFailed());
Assert.AreEqual(ExpectedRecipients(modifier), new EmailMessage(result, publisher).Recipients);
}
public void OnlyEmailModifierRecipientsOnBuildFailure()
{
publisher = new EmailPublisher();
publisher.EmailUsers.Add(modifier.Name, modifier);
publisher.EmailUsers.Add(changed.Name, changed);
IIntegrationResult result = AddModification(IntegrationResultMother.CreateFailed());
Assert.AreEqual(ExpectedRecipients(modifier), new EmailMessage(result, publisher).Recipients);
}
public void ShouldConvertUsernamesToEmailAddresses()
{
EmailPublisher myPublisher = new EmailPublisher();
myPublisher.Converters = new IEmailConverter[1];
myPublisher.Converters[0] = new EmailRegexConverter("^([^@]*)$", @"[email protected]");
IIntegrationResult result = IntegrationResultMother.CreateFailed();
Modification modification = new Modification();
modification.UserName = "******";
result.Modifications = new Modification[1] { modification };
EmailMessage message = new EmailMessage(result, myPublisher);
Assert.AreEqual("*****@*****.**", message.Recipients);
}
