public void Context()
        {
            const int emailId = 23;
            _email = MockRepository.GenerateMock<Email>();
            var emailRepository = MockRepository.GenerateStub<IRepository<Email>>();
            emailRepository.Stub(a => a.GetById(emailId)).Return(_email);

            var recipientParser = MockRepository.GenerateStub<IRecipientParser>();
            recipientParser.Stub(a => a.Parse(Recipients)).Return(new Dictionary<string, string>{{AddressOne, NameOne}, {AddressTwo, NameTwo}});

            var queryExecutor = MockRepository.GenerateStub<IQueryExecutor>();
            queryExecutor.Stub(
                a =>
                a.Execute<GetExistingRecipientsQuery, Recipient>(
                    Arg<GetExistingRecipientsQuery>.Matches(p => p.RecipientEmailAddresses.Contains(AddressOne)
                                                                           &&
                                                                           p.RecipientEmailAddresses.Contains(AddressTwo))))
                .Return(new[]
                            {
                                new Recipient(AddressOne, NameOne)
                            });

            _recipientRepository = MockRepository.GenerateMock<IRepository<Recipient>>();

            var handler = new EnqueueEmailToBeSentCommandHandler(emailRepository, recipientParser, queryExecutor, _recipientRepository);
            handler.Execute(new EnqueueEmailToBeSentCommand
                                {
                                    EmailId = emailId,
                                    FromAddress = FromAddress,
                                    Recipients = Recipients,
                                    Subject = Subject
                                });
        }
        public void Context()
        {
            const int emailId = 23;

            _email = A.Fake <Email>();
            var emailRepository = A.Fake <IRepository <Email> >();

            A.CallTo(() => emailRepository.GetAsync(emailId)).Returns(_email);

            var recipientParser = A.Fake <IRecipientParser>();

            A.CallTo(() => recipientParser.Parse(Recipients)).Returns(new Dictionary <string, string> {
                { AddressOne, NameOne }, { AddressTwo, NameTwo }
            });

            var queryExecutor = A.Fake <IQueryExecutor>();

            A.CallTo(() => queryExecutor.
                     ExecuteAsync <GetExistingRecipientsQuery, Recipient>(
                         A <GetExistingRecipientsQuery> .That.Matches(p => p.RecipientEmailAddresses.Contains(AddressOne)
                                                                      &&
                                                                      p.RecipientEmailAddresses.Contains(AddressTwo))))
            .Returns(new[]
            {
                new Recipient(AddressOne, NameOne)
            });

            _recipientRepository = A.Fake <IRepository <Recipient> >();

            var handler = new EnqueueEmailToBeSentCommandHandler(emailRepository, recipientParser, queryExecutor, _recipientRepository);

            handler.ExecuteAsync(new EnqueueEmailToBeSentCommand
            {
                EmailId     = emailId,
                FromAddress = FromAddress,
                Recipients  = Recipients,
                Subject     = Subject
            }).Wait();
        }