예제 #1
0
        public void Configure(IServiceCollection services)
        {
            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
            services.AddCors();

            services.AddDbContext <VideoGamerDbContext>(config =>
            {
                config.UseSqlServer(_configuration.GetConnectionString("VideoGamer"));
            });

            services.AddTransient <IUserService, EFUserService>()
            .AddTransient <IDeveloperService, EFDeveloperService>()
            .AddTransient <IGameService, EFGameService>()
            .AddTransient <IGenreService, EFGenreService>()
            .AddTransient <IRegisterService, EFRegisterService>()
            .AddTransient <ILoginService, EFLoginService>()
            .AddTransient <IPublisherService, EFPublisherService>();

            services.AddSingleton <IFileService, FileUploadService>();

            var section = _configuration.GetSection("Email");

            var sender = new SmtpEmailService(
                section["host"],
                Int32.Parse(section["port"]),
                section["fromaddress"],
                section["password"]
                );

            services.AddSingleton <IEmailService>(sender);

            services.AddSingleton
            <IPasswordHasher, PasswordHasher>((service) => new PasswordHasher(new RNGCryptoServiceProvider()));
        }
예제 #2
0
        public void SendEmail_InvalidInput_InvalidEmailTo2()
        {
            var emailservice = new SmtpEmailService(_mockedLog.Object, _mockSmtpEmailService.Object);

            _mockSmtpEmailService.Setup(m => m.Send(It.IsAny <MailMessage>()));
            Assert.IsFalse(emailservice.SendEmail("foo", "bar", "*****@*****.**", null, null, null));
        }
예제 #3
0
        public async Task Test_SendEmail_ByTemplate_WithDictionnary()
        {
            _smtpServer.ClearReceivedEmail();

            var emailTemplateProviderMoq = new Mock <IEmailTemplateProvider>();

            emailTemplateProviderMoq.Setup(e => e.GetTemplate(It.IsAny <string>())).ReturnsAsync(new EmailTemplate("Duy")
            {
                ToEmails = "[DuyEmail],{HBDEmail},[email protected]",
                Body     = "Hello [Name]",
            });

            using (var mailService = new SmtpEmailService(
                       new MailMessageProvider(emailTemplateProviderMoq.Object, new TransformerService()), new SmtpEmailOptions
            {
                FromEmailAddress = new MailAddress("*****@*****.**"),
                SmtpClientFactory = () => new SmtpClient("localhost", 25)
            }))
            {
                await mailService.SendAsync("Duy", new object[]
                {
                    new Dictionary <string, object>
                    {
                        ["DuyEmail"] = "*****@*****.**",
                        ["HBDEmail"] = "*****@*****.**",
                        ["Name"]     = "Duy Hoang"
                    }
                });
            }

            _smtpServer.ReceivedEmailCount.Should().BeGreaterOrEqualTo(1);
        }
예제 #4
0
 private static void Initialise()
 {
     _random            = new Random();
     _availableServices = new Dictionary <string, Func <ServiceSettings, DeliveryService> >();
     _deliveryServices  = new List <DeliveryService>();
     _emailService      = new SmtpEmailService(ConfigurationManager.AppSettings["smtphost"], ConfigurationManager.AppSettings["emailUsername"], ConfigurationManager.AppSettings["emailPassword"]);
     SetAvailableServices();
     LoadServices();
 }
예제 #5
0
        public void CanSendEmailAsync()
        {
            _client.Setup(x => x.SendMailAsync(It.IsAny <MailMessage>(), It.IsAny <CancellationToken>())).Returns(Task.CompletedTask);
            _clientFactory.Setup(x => x.CreateInstance()).Returns(_client.Object);

            var smtpService = new SmtpEmailService(new LoggingService(), _clientFactory.Object);
            var result      = smtpService.SendAsync(new MailAddress("*****@*****.**"), new MailAddress("*****@*****.**"), "subject", "content", CancellationToken.None).Result;

            Assert.True(result);
        }
예제 #6
0
        public void SendEmail_OtherException()
        {
            var emailservice = new SmtpEmailService(_mockedLog.Object, _mockSmtpEmailService.Object);
            var recipients   = new List <string> {
                "*****@*****.**"
            };

            _mockSmtpEmailService.Setup(m => m.Send(It.IsAny <MailMessage>())).Throws(new ArgumentNullException());
            Assert.IsFalse(emailservice.SendEmail("foo", "bar", "*****@*****.**", recipients, null, null));
        }
예제 #7
0
        public void SendEmail_ValidInputs_SMTPFormat2()
        {
            var emailservice = new SmtpEmailService(_mockedLog.Object, _mockSmtpEmailService.Object);
            var recipients   = new List <string> {
                "*****@*****.**"
            };

            _mockSmtpEmailService.Setup(m => m.Send(It.IsAny <MailMessage>()));
            Assert.IsTrue(emailservice.SendEmail("foo", "bar", "\"testBar(test)\"<*****@*****.**>", recipients, null, null));
        }
예제 #8
0
        public void SendEmail_ValidInputs_BadDomain_WithDefault()
        {
            var emailservice = new SmtpEmailService(_mockedLog.Object, _mockSmtpEmailService.Object);
            var recipients   = new List <string> {
                "*****@*****.**"
            };

            _mockSmtpEmailService.Setup(m => m.Send(It.IsAny <MailMessage>()));
            Assert.IsTrue(emailservice.SendEmail("foo", "bar", "*****@*****.**", recipients, null, null));
        }
예제 #9
0
        public void SendEmail_InvalidInput_InvalidEmailTo4()
        {
            var emailservice = new SmtpEmailService(_mockedLog.Object, _mockSmtpEmailService.Object);
            var recipients   = new List <string> {
                "*****@*****.**", "foobar"
            };

            _mockSmtpEmailService.Setup(m => m.Send(It.IsAny <MailMessage>()));
            Assert.IsFalse(emailservice.SendEmail("foo", "bar", "*****@*****.**", recipients, null, null));
        }
예제 #10
0
        public void SendEmail_ValidInputs_HTMLBody()
        {
            var emailservice = new SmtpEmailService(_mockedLog.Object, _mockSmtpEmailService.Object);
            var recipients   = new List <string> {
                "*****@*****.**"
            };

            _mockSmtpEmailService.Setup(m => m.Send(It.IsAny <MailMessage>()));
            Assert.IsTrue(emailservice.SendEmail("foo", "<html>Foo</html>", "*****@*****.**", recipients, null, null));
        }
예제 #11
0
        public void ThrowsOnNullRecipientEmailAddress()
        {
            _client.Setup(x => x.SendMailAsync(It.IsAny <MailMessage>(), It.IsAny <CancellationToken>())).Returns(Task.CompletedTask);
            _clientFactory.Setup(x => x.CreateInstance()).Returns(_client.Object);

            var smtpService = new SmtpEmailService(new LoggingService(), _clientFactory.Object);

            Assert.ThrowsAsync <ArgumentNullException>(async() => {
                await smtpService.SendAsync(new MailAddress("*****@*****.**"), null, "subject", "content", CancellationToken.None);
            });
        }
예제 #12
0
        public void ThrowsSmtpExceptionOnFailedSend()
        {
            _client.Setup(x => x.SendMailAsync(It.IsAny <MailMessage>(), It.IsAny <CancellationToken>())).Throws <SmtpException>();
            _clientFactory.Setup(x => x.CreateInstance()).Returns(_client.Object);

            var smtpService = new SmtpEmailService(new LoggingService(), _clientFactory.Object);

            Assert.ThrowsAsync <SmtpException>(async() =>
            {
                await smtpService.SendAsync(new MailAddress("*****@*****.**"), new MailAddress("*****@*****.**"), "subject", "content", CancellationToken.None);
            });
        }
        public async Task SendEmailShouldReturnEmailMessage()
        {
            var configuration = TestsPrerequisites.GetConfiguration();
            var emailService  = new SmtpEmailService(configuration);
            var receiver      = "*****@*****.**";
            var subject       = "Xunit test";
            var message       = "Xunit test message";
            var sender        = "LearningPlus Tests";

            var emailMessage = await emailService.SendEmailAsync(receiver, subject, message, sender);

            Assert.Equal(message, emailMessage.Body);
        }
예제 #14
0
        public void SendEmail_ValidInputs_withInvalidAttachments5()
        {
            var emailservice = new SmtpEmailService(_mockedLog.Object, _mockSmtpEmailService.Object);
            var recipients   = new List <string> {
                "*****@*****.**"
            };
            var attachments = new List <FileAttachment>();

            attachments.Add(new FileAttachment {
                Content = "  ", Name = "bar"
            });
            _mockSmtpEmailService.Setup(m => m.Send(It.IsAny <MailMessage>()));
            Assert.IsFalse(emailservice.SendEmail("foo", "bar", "*****@*****.**", recipients, recipients, attachments));
        }
예제 #15
0
        public async Task <IHttpActionResult> Register(RegisterBindingModel model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }


            var user = new ApplicationUser()
            {
                UserName = model.Email, Email = model.Email
            };

            IdentityResult result = await UserManager.CreateAsync(user, model.Password);

            if (!result.Succeeded)
            {
                return(GetErrorResult(result));
            }


            //this sends a congratulatory Email

            SmtpEmailService messageSvc = new SmtpEmailService();
            string           envPath    = HttpRuntime.AppDomainAppPath;
            string           htmlBody   = File.ReadAllText($"{envPath}\\Messaging\\Email.html");


            htmlBody = htmlBody.Replace("$customerName$", model.Email).Replace("$emailAddress$", model.Email).Replace("$password$", model.Password);

            EmailMessage msg = new EmailMessage()
            {
                Body      = htmlBody,
                Subject   = "Welcome To Find Jobs Fast",
                Recipient = model.Email
            };

            messageSvc.SendEmail(msg);


            //adds admin and set up the admin role
            string email    = "*****@*****.**";
            string password = "******";
            string role     = "ADMIN";

            var roleMgr = Startup.RoleManagerFactory.Invoke();


            if (!roleMgr.RoleExists(role))
            {
                var irole = new IdentityRole()
                {
                    Name = role
                };
                roleMgr.Create(irole);
            }

            bool check = UserManager.IsInRole(user.Id, role);



            if (!check && email == model.Email && password == model.Password)
            {
                IdentityResult roleResult = UserManager.AddToRole(user.Id, role);
            }


            return(Ok());
        }
예제 #16
0
        public void SendEmail_DefaultSmptpService()
        {
            var emailservice = new SmtpEmailService(_mockedLog.Object);

            Assert.IsNotNull(emailservice);
        }
        public void FirstSignature()
        {
            var mockSmtpClient = new Mock<ISmtpClient>();
            var emailService = new SmtpEmailService(mockSmtpClient.Object);

            mockSmtpClient.Setup(x => x.Send(It.IsAny<MailMessage>())).Callback((MailMessage mailMessage) =>
            {
                mailMessage.To.Any(x => x.Address == _to).Should().BeTrue();
                mailMessage.Subject.Should().Be(_subject);
                mailMessage.Body.Should().Be(_body);
                mailMessage.IsBodyHtml.Should().BeFalse();
            });

            emailService.Send(_to, _subject, _body);
            mockSmtpClient.VerifyAll();

            mockSmtpClient.Setup(x => x.Send(It.IsAny<MailMessage>())).Callback((MailMessage mailMessage) =>
            {
                mailMessage.To.Any(x => x.Address == _to).Should().BeTrue();
                mailMessage.Subject.Should().Be(_subject);
                mailMessage.Body.Should().Be(_body);
                mailMessage.IsBodyHtml.Should().BeTrue();
            });

            emailService.Send(_to, _subject, _body, true);
            mockSmtpClient.VerifyAll();

            mockSmtpClient.Setup(x => x.Send(It.IsAny<MailMessage>())).Callback((MailMessage mailMessage) =>
            {
                mailMessage.To.Any(x => x.Address == _to).Should().BeTrue();
                mailMessage.Subject.Should().Be(_subject);
                mailMessage.Body.Should().Be(_body);
                mailMessage.IsBodyHtml.Should().BeFalse();
                mailMessage.Attachments.Any(x => x == _attachment).Should().BeTrue();
            });

            emailService.Send(_to, _subject, _body, new[] { _attachment });
            mockSmtpClient.VerifyAll();

            mockSmtpClient.Setup(x => x.Send(It.IsAny<MailMessage>())).Callback((MailMessage mailMessage) =>
            {
                mailMessage.To.Any(x => x.Address == _to).Should().BeTrue();
                mailMessage.Subject.Should().Be(_subject);
                mailMessage.Body.Should().Be(_body);
                mailMessage.IsBodyHtml.Should().BeTrue();
                mailMessage.Attachments.Any(x => x == _attachment).Should().BeTrue();
            });

            emailService.Send(_to, _subject, _body, new[] { _attachment }, true);
            mockSmtpClient.VerifyAll();

            mockSmtpClient.Setup(x => x.Send(It.IsAny<MailMessage>())).Callback((MailMessage mailMessage) =>
            {
                mailMessage.To.Any(x => x.Address == _to).Should().BeTrue();
                mailMessage.Subject.Should().Be(_subject);
                mailMessage.Body.Should().Be(_body);
                mailMessage.IsBodyHtml.Should().BeFalse();
            });

            emailService.Send(new[] {_to}, _subject, _body);
            mockSmtpClient.VerifyAll();
        }