Inheritance: Waf.InformationManager.Common.Domain.ValidationModel, IValidatableObject
Example #1
0
 private static Email CreateEmail(string title, DateTime sent, string from, IReadOnlyList<string> to, IReadOnlyList<string> cc, string message)
 {
     var email = new Email() { Title = title, Message = message, Sent = sent, From = from };
     if (to != null) { email.To = to; }
     if (cc != null) { email.CC = cc; }
     return email;
 }
        public void FilterTest()
        {
            var viewModel = Container.GetExportedValue<EmailListViewModel>();

            var email1 = new Email() { Title = "Duis nunc", From = "*****@*****.**" };
            email1.To = new[] { "*****@*****.**", "*****@*****.**" };

            Assert.IsTrue(viewModel.Filter(email1));

            viewModel.FilterText = "dui";
            Assert.IsTrue(viewModel.Filter(email1));

            viewModel.FilterText = "user";
            Assert.IsTrue(viewModel.Filter(email1));

            viewModel.FilterText = "harry";
            Assert.IsTrue(viewModel.Filter(email1));

            viewModel.FilterText = "admin";
            Assert.IsTrue(viewModel.Filter(email1));

            viewModel.FilterText = "wrong filter";
            Assert.IsFalse(viewModel.Filter(new Email()));

            // Check that the filter works when the Email properties are null.
            Assert.IsFalse(viewModel.Filter(new Email()));
        }
Example #3
0
        public void AddAndRemoveEmails()
        {
            var emailDeletionService = new MockEmailDeletionService();
            var emailFolder = new EmailFolder(emailDeletionService);

            Assert.IsFalse(emailFolder.Emails.Any());
            var email1 = new Email();
            
            emailFolder.AddEmail(email1);
            Assert.AreEqual(email1, emailFolder.Emails.Single());

            var email2 = new Email();
            emailFolder.AddEmail(email2);
            Assert.IsTrue(emailFolder.Emails.SequenceEqual(new[] { email1, email2 }));

            bool deleteEmailCalled = false;
            emailDeletionService.DeleteEmailAction = (folder, email) =>
            {
                deleteEmailCalled = true;
                Assert.AreEqual(emailFolder, folder);
                Assert.AreEqual(email1, email);
            };
            emailFolder.RemoveEmail(email1);
            Assert.IsTrue(deleteEmailCalled);
        }
Example #4
0
        public void ValidateTest()
        {
            var longText = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";
            var email = new Email();

            Assert.AreEqual("", email.Validate("Title"));
            email.Title = longText;
            Assert.AreEqual("The field Title must be a string with a maximum length of 255.", email.Validate("Title"));
            email.Title = "";

            Assert.AreEqual("", email.Validate("From"));
            email.From = longText;
            Assert.AreEqual("The field From must be a string with a maximum length of 255.", email.Validate("From"));
            email.From = "";

            Assert.AreEqual("This email doesn't define a recipient.", email.Validate());

            email.To = new[] { "wrong email address" };
            email.CC = email.To;
            email.Bcc = email.To;
            Assert.AreEqual("The email wrong email address in the To field is not valid." + Environment.NewLine
                + "The email wrong email address in the CC field is not valid." + Environment.NewLine
                + "The email wrong email address in the BCC field is not valid.", email.Validate());

            email.To = new[] { "*****@*****.**" };
            email.CC = email.To;
            email.Bcc = email.To;
            Assert.AreEqual("", email.Validate());
        }
Example #5
0
 public void NotifyEmailDeleted(EmailFolder emailFolder, Email email)
 {
     if (emailFolder != Deleted)
     {
         Deleted.AddEmail(email);    
     }
 }
Example #6
0
        public void PropertiesTest()
        {
            var viewModel = Container.GetExportedValue<EmailViewModel>();

            var email = new Email();
            AssertHelper.PropertyChangedEvent(viewModel, x => x.Email, () => viewModel.Email = email);
            Assert.AreEqual(email, viewModel.Email);
        }
Example #7
0
        public void DeleteEmail(EmailFolder emailFolder, Email email)
        {
            emailFolder.Emails.Remove(email);

            if (emailFolder != Deleted)
            {
                Deleted.AddEmail(email);
            }
        }
Example #8
0
        public void EmailFolderTest()
        {
            var root = new EmailClientRoot();

            Assert.IsNotNull(root.Inbox);
            Assert.IsNotNull(root.Outbox);
            Assert.IsNotNull(root.Sent);
            Assert.IsNotNull(root.Drafts);
            Assert.IsNotNull(root.Deleted);

            var email1 = new Email();
            root.Inbox.AddEmail(email1);
            root.Inbox.RemoveEmail(email1);
            Assert.AreEqual(email1, root.Deleted.Emails.Single());

            root.Deleted.RemoveEmail(email1);
            Assert.IsFalse(root.Deleted.Emails.Any());
        }
Example #9
0
        public void PropertiesTest()
        {
            var email = new Email();

            AssertHelper.PropertyChangedEvent(email, x => x.EmailType, () => email.EmailType = EmailType.Sent);
            Assert.AreEqual(EmailType.Sent, email.EmailType);

            AssertHelper.PropertyChangedEvent(email, x => x.Title, () => email.Title = "Duis nunc");
            Assert.AreEqual("Duis nunc", email.Title);

            AssertHelper.PropertyChangedEvent(email, x => x.From, () => email.From = "*****@*****.**");
            Assert.AreEqual("*****@*****.**", email.From);

            var to = new[] { "*****@*****.**", "*****@*****.**" };
            AssertHelper.PropertyChangedEvent(email, x => x.To, () => email.To = to);
            Assert.AreEqual(to, email.To);
            AssertHelper.ExpectedException<ArgumentNullException>(() => email.To = null);
            Assert.AreEqual(to, email.To);

            var cc = new[] { "*****@*****.**" };
            AssertHelper.PropertyChangedEvent(email, x => x.CC, () => email.CC = cc);
            Assert.AreEqual(cc, email.CC);
            AssertHelper.ExpectedException<ArgumentNullException>(() => email.CC = null);
            Assert.AreEqual(cc, email.CC);

            var bcc = new[] { "*****@*****.**" };
            AssertHelper.PropertyChangedEvent(email, x => x.Bcc, () => email.Bcc = bcc);
            Assert.AreEqual(bcc, email.Bcc);
            AssertHelper.ExpectedException<ArgumentNullException>(() => email.Bcc = null);
            Assert.AreEqual(bcc, email.Bcc);

            var sent = new DateTime(2012, 8, 2);
            AssertHelper.PropertyChangedEvent(email, x => x.Sent, () => email.Sent = sent);
            Assert.AreEqual(sent, email.Sent);

            AssertHelper.PropertyChangedEvent(email, x => x.Message, () => email.Message = "abc");
            Assert.AreEqual("abc", email.Message);
        }
Example #10
0
 public void RemoveEmail(Email email)
 {
     EmailDeletionService.DeleteEmail(this, email);
 }
Example #11
0
 public void AddEmail(Email email)
 {
     emails.Add(email);
 }
Example #12
0
        public void PropertiesTest()
        {
            var viewModel = Container.GetExportedValue<NewEmailViewModel>();

            var emptyCommand = new DelegateCommand(() => { });
            AssertHelper.PropertyChangedEvent(viewModel, x => x.SelectContactCommand, () => viewModel.SelectContactCommand = emptyCommand);
            Assert.AreEqual(emptyCommand, viewModel.SelectContactCommand);

            AssertHelper.PropertyChangedEvent(viewModel, x => x.SendCommand, () => viewModel.SendCommand = emptyCommand);
            Assert.AreEqual(emptyCommand, viewModel.SendCommand);

            // Email accounts tests

            var emailAccounts = new List<EmailAccount>()
            {
                new EmailAccount(),
                new EmailAccount()
            };

            AssertHelper.PropertyChangedEvent(viewModel, x => x.EmailAccounts, () => viewModel.EmailAccounts = emailAccounts);
            Assert.AreEqual(emailAccounts, viewModel.EmailAccounts);

            AssertHelper.PropertyChangedEvent(viewModel, x => x.SelectedEmailAccount, () => viewModel.SelectedEmailAccount = emailAccounts.First());
            Assert.AreEqual(emailAccounts.First(), viewModel.SelectedEmailAccount);

            // Email tests

            var email = new Email();
            AssertHelper.PropertyChangedEvent(viewModel, x => x.Email, () => viewModel.Email = email);
            Assert.AreEqual(email, viewModel.Email);

            string to = "*****@*****.**";
            AssertHelper.PropertyChangedEvent(viewModel, x => x.To, () => viewModel.To = to);
            Assert.AreEqual(to, viewModel.To);
            Assert.AreEqual(to, email.To.Single());

            string cc1 = "*****@*****.**";
            string cc2 = "*****@*****.**";
            string cc = cc1 + ", " + cc2;
            AssertHelper.PropertyChangedEvent(viewModel, x => x.CC, () => viewModel.CC = cc);
            Assert.AreEqual(cc1 + "; " + cc2, viewModel.CC);
            Assert.IsTrue(email.CC.SequenceEqual(new[] { cc1, cc2 }));

            string bcc1 = "*****@*****.**";
            string bcc2 = "*****@*****.**";
            string bcc3 = "*****@*****.**";
            string bcc = bcc1 + "; " + bcc2 + "  " + bcc3;
            AssertHelper.PropertyChangedEvent(viewModel, x => x.Bcc, () => viewModel.Bcc = bcc);
            Assert.AreEqual(bcc1 + "; " + bcc2 + "; " + bcc3, viewModel.Bcc);
            Assert.IsTrue(email.Bcc.SequenceEqual(new[] { bcc1, bcc2, bcc3 }));

            string newEmail = "*****@*****.**";
            AssertHelper.PropertyChangedEvent(viewModel, x => x.To, () => email.To = new[] { newEmail });
            Assert.AreEqual(newEmail, viewModel.To);

            AssertHelper.PropertyChangedEvent(viewModel, x => x.CC, () => email.CC = new[] { newEmail });
            Assert.AreEqual(newEmail, viewModel.CC);

            AssertHelper.PropertyChangedEvent(viewModel, x => x.Bcc, () => email.Bcc = new[] { newEmail });
            Assert.AreEqual(newEmail, viewModel.Bcc);

            viewModel.Email = new Email();
        }
 public void DeleteEmail(EmailFolder emailFolder, Email email)
 {
     DeleteEmailAction(emailFolder, email);
 }
Example #14
0
 public void NotifyEmailDeleted(EmailFolder emailFolder, Email email)
 {
     DeleteEmailAction(emailFolder, email);    
 }
Example #15
0
 public void RemoveEmail(Email email)
 {
     emails.Remove(email);
     EmailDeletionService.NotifyEmailDeleted(this, email);
 }