Come si crea un mockup di System.Net.Mail MailMessage?

Question

Quindi ho alcune cose SMTP nel mio codice e sto provando a testare il metodo.

Così ho provato a Mockup MailMessage ma sembra non funzionare mai. Credo che nessuno dei metodi sono virtuali o astratta, quindi non posso usare moq per deridere l'alto :(.

Quindi penso che devo farlo a mano ed è lì che mi sono bloccato.

* a mano intendo witting l'interfaccia e il wrapper ma lasciando moq ancora mockup l'interfaccia

Non so come scrivere la mia interfaccia e il mio wrapper (una classe che implementerà l'interfaccia che avrà il codice MailMessage effettivo così, quando il mio codice reale viene eseguito, fa esattamente ciò che deve fare)

Quindi prima non sono sicuro di come configurare la mia interfaccia. dai un'occhiata a uno dei campi che devo simulare.

MailMessage mail = new MailMessage(); 

mail.To.Add("test@hotmail.com"); 

quindi questa è la prima cosa che devo fingere.

così guardarla so che "A" è una struttura colpendo F12 su "A" mi porta a questa linea:

public MailAddressCollection To { get; } 

quindi è MailAddressCollection Proprietà. Ma alcuni come sono permesso di andare oltre e fare "Aggiungi".

Quindi ora la mia domanda è nella mia interfaccia che cosa faccio?

faccio una proprietà? Questa proprietà dovrebbe essere MailAddressCollection?

O dovrei avere un metodo come?

void MailAddressCollection To(string email); 

or 

void string To.Add(string email); 

Allora come sarebbe il mio involucro?

Quindi come potete vedere sono molto confuso. Poiché ce ne sono così tanti. Sto indovinando che sto solo simulando quelli che sto usando.

modificare il codice

Credo che in in un vero senso avrei solo per testare più le eccezioni ma voglio provare a fare in modo che tutto viene inviato allora otterrà alla risposta = successo.

string response = null; 
      try 
      { 

       MembershipUser userName = Membership.GetUser(user); 

       string newPassword = userName.ResetPassword(securityAnswer); 

       MailMessage mail = new MailMessage(); 

       mail.To.Add(userName.Email); 

       mail.From = new MailAddress(ConfigurationManager.AppSettings["FROMEMAIL"]); 
       mail.Subject = "Password Reset"; 

       string body = userName + " Your Password has been reset. Your new temporary password is: " + newPassword; 

       mail.Body = body; 
       mail.IsBodyHtml = false; 


       SmtpClient smtp = new SmtpClient(); 

       smtp.Host = ConfigurationManager.AppSettings["SMTP"]; 
       smtp.Credentials = new System.Net.NetworkCredential(ConfigurationManager.AppSettings["FROMEMAIL"], ConfigurationManager.AppSettings["FROMPWD"]); 

       smtp.EnableSsl = true; 

       smtp.Port = Convert.ToInt32(ConfigurationManager.AppSettings["FROMPORT"]); 

       smtp.Send(mail); 

       response = "Success"; 
      } 
      catch (ArgumentNullException ex) 
      { 
       response = ex.Message; 

      } 
      catch (ArgumentException ex) 
      { 
       response = ex.Message; 

      } 
      catch (ConfigurationErrorsException ex) 
      { 
       response = ex.Message; 
      } 
      catch (ObjectDisposedException ex) 
      { 
       response = ex.Message; 
      } 
      catch (InvalidOperationException ex) 
      { 
       response = ex.Message; 
      } 
      catch (SmtpFailedRecipientException ex) 
      { 
       response = ex.Message; 
      } 
      catch (SmtpException ex) 
      { 
       response = ex.Message; 
      } 



      return response; 

     } 

Grazie

Answer 1

Perché prendere in giro MailMessage? SmtpClient riceve MailMessages e li invia; questa è la classe che vorrei avvolgere a scopo di test. Quindi, se si sta scrivendo un certo tipo di sistema che pone gli ordini, se si sta cercando di verificare che il vostro OrderService sempre e-mail quando viene fatto un ordine, si avrebbe una classe simile al seguente:

class OrderService : IOrderSerivce 
{ 
    private IEmailService _mailer; 
    public OrderService(IEmailService mailSvc) 
    { 
     this. _mailer = mailSvc; 
    } 

    public void SubmitOrder(Order order) 
    { 
     // other order-related code here 

     System.Net.Mail.MailMessage confirmationEmail = ... // create the confirmation email 
     _mailer.SendEmail(confirmationEmail); 
    } 

} 

Con l'implementazione predefinita di IEmailService avvolgimento SmtpClient:

in questo modo, quando si va a scrivere il test di unità, di testare il comportamento del codice che utilizza le classi SmtpClient/EmailMessage, non il comportamento delle classi SmtpClient/EmailMessage Se stessi:

public Class When_an_order_is_placed 
{ 
    [Setup] 
    public void TestSetup() { 
     Order o = CreateTestOrder(); 
     mockedEmailService = CreateTestEmailService(); // this is what you want to mock 
     IOrderService orderService = CreateTestOrderService(mockedEmailService); 
     orderService.SubmitOrder(o); 
    } 

    [Test] 
    public void A_confirmation_email_should_be_sent() { 
     Assert.IsTrue(mockedEmailService.SentMailMessage != null); 
    } 


    [Test] 
    public void The_email_should_go_to_the_customer() { 
     Assert.IsTrue(mockedEmailService.SentMailMessage.To.Contains("test@hotmail.com")); 
    } 

} 

Modifica: per affrontare i vostri commenti qui sotto, che ci si vuole due implementazioni separate di EmailService - solo si potrebbe usare SmtpClient, che usereste nel codice dell'applicazione:

class EmailService : IEmailService { 
    private SmtpClient client; 

    public EmailService() { 
     client = new SmtpClient(); 
     object settings = ConfigurationManager.AppSettings["SMTP"]; 
     // assign settings to SmtpClient, and set any other behavior you 
     // from SmtpClient in your application, such as ssl, host, credentials, 
     // delivery method, etc 
    } 

    public void SendEmail(MailMessage message) { 
     client.Send(message); 
    } 

} 

tuo deriso/falso servizio di posta elettronica (non hai bisogno di una struttura di derisione per questo, ma aiuta) non toccherebbe SmtpClient o SmtpSettings; registrerebbe solo il fatto che, ad un certo punto, è stata inviata una e-mail tramite SendEmail. È quindi possibile utilizzare questo per verificare se SendEmail è stato chiamato, e con quali parametri:

class MockEmailService : IEmailService { 
    private EmailMessage sentMessage;; 

    public SentMailMessage { get { return sentMessage; } } 

    public void SendEmail(MailMessage message) { 
     sentMessage = message; 
    } 

} 

La prova reale o meno l'e-mail è stato inviato al server SMTP e consegnati dovrebbe cadere al di fuori dei confini della vostra test unitario. È necessario sapere se questo funziona, ed è possibile impostare una seconda serie di test per testare specificamente questo (in genere chiamati test di integrazione), ma si tratta di test distinti separati dal codice che verifica il comportamento principale dell'applicazione.

Answer 2

In .NET 4.0 è possibile utilizzare il "duck-digitando" di passare un'altra classe al posto di "System.Net.Mail". Ma nella versione precedente temo che non ci sia un altro modo, piuttosto che creare wrapper attorno a "System.Net.Mail" e alla classe di simulazione.

Se è un altro (migliore) modo, mi piacerebbe impararlo :).

EDIT:

public interface IMailWrapper { 
    /* members used from System.Net.Mail class */ 
} 

public class MailWrapper { 
    private System.Net.Mail original; 
    public MailWrapper(System.Net.Mail original) { 
     this.original = original; 
    } 

    /* members used from System.Net.Mail class delegated to "original" */ 
} 

public class MockMailWrapper { 
    /* mocked members used from System.Net.Mail class */ 
} 


void YourMethodUsingMail(IMailWrapper mail) { 
    /* do something */ 
} 

Answer 3

si finirà beffardo diverse classi qui (almeno due). Innanzitutto, è necessario un wrapper per la classe MailMessage.Creerei un'interfaccia per il wrapper, quindi il wrapper implementerà l'interfaccia. Nel tuo test, prenderai in giro l'interfaccia. In secondo luogo, fornirai un'implementazione fittizia come aspettativa all'interfaccia fittizia per MailAddressCollection. Poiché MailAddressCollection implementa Collection<MailAddress>, questo dovrebbe essere abbastanza semplice. Se il mocking di MailAddressCollection è problematico a causa di proprietà aggiuntive (non ho controllato), potresti avere il tuo wrapper restituirlo come IList<MailAddress>, che come interfaccia dovrebbe essere facile da prendere in giro.

public interface IMailMessageWrapper 
{ 
    MailAddressCollection To { get; } 
} 

public class MailMessageWrapper 
{ 
    private MailMessage Message { get; set; } 

    public MailMessageWrapper(MailMessage message) 
    { 
     this.Message = message; 
    } 

    public MailAddressCollection To 
    { 
     get { return this.Message.To; } 
    } 
} 

// RhinoMock syntax, sorry -- but I don't use Moq 
public void MessageToTest() 
{ 
    var message = MockRepository.GenerateMock<IMailMessageWrapper>() 
    var to = MockRepository.GenerateMock<MailAddressCollection>(); 

    var expectedAddress = "test@example.com"; 

    message.Expect(m => m.To).Return(to).Repeat.Any(); 
    to.Expect(t => t.Add(expectedAddress)); 
    ... 
} 

Answer 4

disclaimer: io lavoro a Typemock Invece di trovare qualche trucco è possibile utilizzare Typemock Isolator semplicemente falso che classe in una sola riga di codice:

var fakeMailMessage = Isolate.Fake.Instance<MailMessage>(); 

quindi è possibile impostare il comportamento su di esso utilizzando Isolate.WhenCalled