Golang mailgun-go.NewMailgun函数代码示例

func TestGetStoredMessage(t *testing.T) {
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")
	id, err := findStoredMessageID(mg) // somehow...
	if err != nil {
		t.Fatal(err)
	}

	// First, get our stored message.
	msg, err := mg.GetStoredMessage(id)
	if err != nil {
		t.Fatal(err)
	}
	fields := map[string]string{
		"       From": msg.From,
		"     Sender": msg.Sender,
		"    Subject": msg.Subject,
		"Attachments": fmt.Sprintf("%d", len(msg.Attachments)),
		"    Headers": fmt.Sprintf("%d", len(msg.MessageHeaders)),
	}
	for k, v := range fields {
		fmt.Printf("%13s: %s\n", k, v)
	}

	// We're done with it; now delete it.
	err = mg.DeleteStoredMessage(id)
	if err != nil {
		t.Fatal(err)
	}
}

func RunApplication() {
	config := CreateConfigFromEnv()

	PrintConfig(config)

	mg := mailgun.NewMailgun(config.Domain, config.ApiKey, "")

	StartHttpServer(mg, config)
}

func TestDeleteTag(t *testing.T) {
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")
	err := mg.DeleteTag("newsletter")
	if err != nil {
		t.Fatal(err)
	}
}

func TestSendMGMIME(t *testing.T) {
	toUser := reqEnv(t, "MG_EMAIL_TO")
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")
	m := mg.NewMIMEMessage(ioutil.NopCloser(strings.NewReader(exampleMime)), toUser)
	msg, id, err := mg.Send(m)
	if err != nil {
		t.Fatal(err)
	}
	fmt.Println("TestSendMIME:MSG(" + msg + "),ID(" + id + ")")
}

func TestSendLegacyPlain(t *testing.T) {
	toUser := reqEnv(t, "MG_EMAIL_TO")
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	publicApiKey := reqEnv(t, "MG_PUBLIC_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, publicApiKey)
	m := mailgun.NewMessage(fromUser, exampleSubject, exampleText, toUser)
	msg, id, err := mg.Send(m)
	if err != nil {
		t.Fatal(err)
	}
	fmt.Println("TestSendPlain:MSG(" + msg + "),ID(" + id + ")")
}

func TestSendMGPlainAt(t *testing.T) {
	toUser := reqEnv(t, "MG_EMAIL_TO")
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	publicApiKey := reqEnv(t, "MG_PUBLIC_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, publicApiKey)
	m := mg.NewMessage(fromUser, exampleSubject, exampleText, toUser)
	m.SetDeliveryTime(time.Now().Add(5 * time.Minute))
	msg, id, err := mg.Send(m)
	if err != nil {
		t.Fatal(err)
	}
	fmt.Println("TestSendPlainAt:MSG(" + msg + "),ID(" + id + ")")
}

func TestGetBounces(t *testing.T) {
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")
	n, bounces, err := mg.GetBounces(-1, -1)
	if err != nil {
		t.Fatal(err)
	}
	if n > 0 {
		t.Fatal("Expected no bounces for what should be a clean domain.")
	}
	if n != len(bounces) {
		t.Fatalf("Expected length of bounces %d to equal returned length %d", len(bounces), n)
	}
}

func (cfg MailgunEmailerConfig) Emailer(fromAddr string) (Emailer, error) {
	from := cfg.FromAddr
	if from == "" {
		from = fromAddr
	}

	if from == "" {
		return nil, errors.New(`missing "from" field in email config`)
	}
	mg := mailgun.NewMailgun(cfg.Domain, cfg.PrivateAPIKey, cfg.PublicAPIKey)
	return &mailgunEmailer{
		mg:   mg,
		from: from,
	}, nil
}

// sendWithMailgun handles the main send and logging logic for any single email deploy
func (c *Client) sendWithMailgun() (string, error) {
	var err error

	c.Body, err = c.prepareTmpl()
	if err != nil {
		return "", err
	}

	gun := mg.NewMailgun(Conf["mailgun"]["domain"], Conf["mailgun"]["secret"], Conf["mailgun"]["public"])

	// override the http client
	client := urlfetch.Client(c.context)
	gun.SetClient(client)

	// generate mailgun message
	message := mg.NewMessage(fmt.Sprintf("%s <%s>", Conf["default"]["fromname"], Conf["default"]["fromemail"]), c.Subject, c.Body, c.Recipient[0].Render)
	message.SetHtml(strings.Replace(c.Body, "\\", "", -1))

	// add additional recipients
	for k, v := range c.Recipient {
		if k > 0 {
			err := message.AddRecipient(v.Render)
			if err != nil {
				c.context.Errorf("Could not append [%s] as Mailgun recipient: %v", v.Render, err)
				return "", err
			}
		}
	}

	// send the email
	_, id, err := gun.Send(message)
	if err != nil {
		c.context.Errorf("Error: %v", err)
		return "", err
	}

	if Conf["default"]["logmessages"] == "true" {
		// if the id is not empty then add to the message log
		if id != "" {
			_, logErr := c.addMessageLog()
			if logErr != nil {
				c.context.Errorf("Failed to add message to log: %v", logErr)
			}
		}
	}

	return id, err
}

func NotifyUser(name, email, subject, message string) {
	fmt.Printf("Notifying %s with subject:\n", email)
	fmt.Printf("%s\n", subject)

	mailto := fmt.Sprintf("%s <%s>", name, email)
	gun := mailgun.NewMailgun("mail.ckpt.no", os.Getenv("CKPT_MAILGUN_KEY"), "pubkey-b3e133632123a0da24d1e2c5842039b6")
	m := mailgun.NewMessage("CKPT <[email protected]>", subject, message, mailto)
	m.AddHeader("Content-Type", "text/plain; charset=\"utf-8\"")
	response, id, err := gun.Send(m)

	if err != nil {
		fmt.Printf("Error:\n%+v\n", err.Error())
	}
	fmt.Printf("Response ID: %s\n", id)
	fmt.Printf("Message from server: %s\n", response)
}

func TestSendMGBatchFailRecipients(t *testing.T) {
	toUser := reqEnv(t, "MG_EMAIL_TO")
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")
	m := mg.NewMessage(fromUser, exampleSubject, exampleText+"Batch\n")
	for i := 0; i < mailgun.MaxNumberOfRecipients; i++ {
		m.AddRecipient("") // We expect this to indicate a failure at the API
	}
	err := m.AddRecipientAndVariables(toUser, nil)
	if err == nil {
		// If we're here, either the SDK didn't send the message,
		// OR the API didn't check for empty To: headers.
		t.Fatal("Expected to fail!!")
	}
}

func TestSendMGTag(t *testing.T) {
	toUser := reqEnv(t, "MG_EMAIL_TO")
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	publicApiKey := reqEnv(t, "MG_PUBLIC_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, publicApiKey)
	m := mg.NewMessage(fromUser, exampleSubject, exampleText+"Tags Galore!\n", toUser)
	m.AddTag("FooTag")
	m.AddTag("BarTag")
	m.AddTag("BlortTag")
	msg, id, err := mg.Send(m)
	if err != nil {
		t.Fatal(err)
	}
	fmt.Println("TestSendTag:MSG(" + msg + "),ID(" + id + ")")
}

func TestGetCredentials(t *testing.T) {
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")
	n, cs, err := mg.GetCredentials(mailgun.DefaultLimit, mailgun.DefaultSkip)
	if err != nil {
		t.Fatal(err)
	}
	tw := &tabwriter.Writer{}
	tw.Init(os.Stdout, 2, 8, 2, ' ', 0)
	fmt.Fprintf(tw, "Login\tCreated At\t\n")
	for _, c := range cs {
		fmt.Fprintf(tw, "%s\t%s\t\n", c.Login, c.CreatedAt)
	}
	tw.Flush()
	fmt.Printf("%d credentials listed out of %d\n", len(cs), n)
}

func setup(t *testing.T) (mailgun.Mailgun, string) {
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")

	address := fmt.Sprintf("[email protected]%s", domain)
	_, err := mg.CreateList(mailgun.List{
		Address:     address,
		Name:        address,
		Description: "TestMailingListMembers-related mailing list",
		AccessLevel: mailgun.Members,
	})
	if err != nil {
		t.Fatal(err)
	}
	return mg, address
}

func TestGetSingleBounce(t *testing.T) {
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")
	exampleEmail := fmt.Sprintf("[email protected]%s", domain)
	_, err := mg.GetSingleBounce(exampleEmail)
	if err == nil {
		t.Fatal("Did not expect a bounce to exist")
	}
	ure, ok := err.(*mailgun.UnexpectedResponseError)
	if !ok {
		t.Fatal("Expected UnexpectedResponseError")
	}
	if ure.Actual != 404 {
		t.Fatalf("Expected 404 response code; got %d", ure.Actual)
	}
}