hunk.code_window: 	userNotifyProps["push_status"] = model.STATUS_OFFLINE
   	// WHEN props is AWAY and user is offline
   	if !DoesStatusAllowPushNotification(userNotifyProps, offline, channelId) {
   		t.Fatal("Should have been true")
   	}
  
hunk.labels: keep replace keep keep keep keep
hunk.after_edit: 	// WHEN props is OFFLINE and user is offline
  
hunk.file_path: app/notification_test.go
hunk.type: replace
file: package gomail
  
  import (
  	"crypto/tls"
  	"fmt"
  	"io"
  	"net"
  	"net/smtp"
  )
  
  // A Dialer is a dialer to an SMTP server.
  type Dialer struct {
  	// Host represents the host of the SMTP server.
  	Host string
  	// Port represents the port of the SMTP server.
  	Port int
  	// Auth represents the authentication mechanism used to authenticate to the
  	// SMTP server.
  	Auth smtp.Auth
  	// SSL defines whether an SSL connection is used. It should be false in
  	// most cases since the authentication mechanism should use the STARTTLS
  	// extension instead.
  	SSL bool
  	// TSLConfig represents the TLS configuration used for the TLS (when the
  	// STARTTLS extension is used) or SSL connection.
  	TLSConfig *tls.Config
  }
  
  // NewPlainDialer returns a Dialer. The given parameters are used to connect to
  // the SMTP server via a PLAIN authentication mechanism.
  //
  // It fallbacks to the LOGIN mechanism if it is the only mechanism advertised by
  // the server.
  func NewPlainDialer(host string, port int, username, password string) *Dialer {
  	return &Dialer{
  		Host: host,
  		Port: port,
  		Auth: &plainAuth{
  			username: username,
  			password: password,
  			host:     host,
  		},
  		SSL: port == 465,
  	}
  }
  
  // Dial dials and authenticates to an SMTP server. The returned SendCloser
  // should be closed when done using it.
  func (d *Dialer) Dial() (SendCloser, error) {
  	c, err := d.dial()
  	if err != nil {
  		return nil, err
  	}
  
  	if d.Auth != nil {
  		if ok, _ := c.Extension("AUTH"); ok {
  			if err = c.Auth(d.Auth); err != nil {
  				c.Close()
  				return nil, err
  			}
  		}
  	}
  
  	return &smtpSender{c}, nil
  }
  
  func (d *Dialer) dial() (smtpClient, error) {
  	if d.SSL {
  		return d.sslDial()
  	}
  	return d.starttlsDial()
  }
  
  func (d *Dialer) starttlsDial() (smtpClient, error) {
  	c, err := smtpDial(addr(d.Host, d.Port))
  	if err != nil {
  		return nil, err
  	}
  
  	if ok, _ := c.Extension("STARTTLS"); ok {
  		if err := c.StartTLS(d.tlsConfig()); err != nil {
  			c.Close()
  			return nil, err
  		}
  	}
  
  	return c, nil
  }
  
  func (d *Dialer) sslDial() (smtpClient, error) {
  	conn, err := tlsDial("tcp", addr(d.Host, d.Port), d.tlsConfig())
  	if err != nil {
  		return nil, err
  	}
  
  	return newClient(conn, d.Host)
  }
  
  func (d *Dialer) tlsConfig() *tls.Config {
  	if d.TLSConfig == nil {
  		return &tls.Config{ServerName: d.Host}
  	}
  
  	return d.TLSConfig
  }
  
  func addr(host string, port int) string {
  	return fmt.Sprintf("%s:%d", host, port)
  }
  
  // DialAndSend opens a connection to the SMTP server, sends the given emails and
  // closes the connection.
  func (d *Dialer) DialAndSend(m ...*Message) error {
  	s, err := d.Dial()
  	if err != nil {
  		return err
  	}
  	defer s.Close()
  
  	return Send(s, m...)
  }
  
  type smtpSender struct {
  	smtpClient
  }
  
  func (c *smtpSender) Send(from string, to []string, msg io.WriterTo) error {
  	if err := c.Mail(from); err != nil {
  		return err
  	}
  
  	for _, addr := range to {
  		if err := c.Rcpt(addr); err != nil {
  			return err
  		}
  	}
  
  	w, err := c.Data()
  	if err != nil {
  		return err
  	}
  
  	if _, err = msg.WriteTo(w); err != nil {
  		w.Close()
  		return err
  	}
  
  	return w.Close()
  }
  
  func (c *smtpSender) Close() error {
  	return c.Quit()
  }
  
  // Stubbed out for tests.
  var (
  	smtpDial = func(addr string) (smtpClient, error) {
  		return smtp.Dial(addr)
  	}
  	tlsDial   = tls.Dial
  	newClient = func(conn net.Conn, host string) (smtpClient, error) {
  		return smtp.NewClient(conn, host)
  	}
  )
  
  type smtpClient interface {
  	Extension(string) (bool, string)
  	StartTLS(*tls.Config) error
  	Auth(smtp.Auth) error
  	Mail(string) error
  	Rcpt(string) error
  	Data() (io.WriteCloser, error)
  	Quit() error
  	Close() error
  }
  