[github/fretlink/terraform-provider-mailgun.git] / mailgun / resource_mailgun_domain_test.go

package mailgun

import (
	"context"
	"fmt"
	"github.com/hashicorp/terraform/helper/resource"
	"github.com/hashicorp/terraform/terraform"
	"github.com/mailgun/mailgun-go/v3"
	"os"
	"strconv"
	"testing"
	"time"
)

type fullDomain struct {
	domainResponse   mailgun.DomainResponse
	domainConnection mailgun.DomainConnection
	domainTracking   mailgun.DomainTracking
	ipAddress        []string
	credentials      []mailgun.Credential
}

func getFullDomain(mg *mailgun.MailgunImpl, domainName string) (*fullDomain, error) {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*120)
	defer cancel()
	mg = mailgun.NewMailgun(domainName, mg.APIKey())

	var domain fullDomain
	var err error
	domain.domainResponse, err = mg.GetDomain(ctx, domainName)
	if err != nil {
		return nil, fmt.Errorf("Error Getting mailgun domain Details for %s: Error: %s", domainName, err)
	}

	domain.domainConnection, err = mg.GetDomainConnection(ctx, domainName)
	if err != nil {
		return nil, fmt.Errorf("Error Getting mailgun domain connection Details for %s: Error: %s", domainName, err)
	}

	domain.domainTracking, err = mg.GetDomainTracking(ctx, domainName)
	if err != nil {
		return nil, fmt.Errorf("Error Getting mailgun domain tracking Details for %s: Error: %s", domainName, err)
	}

	ipAddress, err := getIps(ctx, mg)

	if err != nil {
		return nil, fmt.Errorf("Error Getting mailgun domain ips2 for %s: Error: %s", domainName, err)
	}
	ips := make([]string, len(ipAddress))
	for i, r := range ipAddress {
		ips[i] = r.IP

	}
	domain.ipAddress = ips
	domain.credentials, err = ListCredentials(domainName, mg.APIKey())
	if err != nil {
		return nil, fmt.Errorf("Error Getting mailgun credentials for %s: Error: %s", domainName, err)
	}
	return &domain, nil
}

func TestAccMailgunDomain_basic(t *testing.T) {
	var domain fullDomain

	resource.Test(t, resource.TestCase{
		PreCheck:     func() { testAccPreCheck(t) },
		Providers:    testAccProviders,
		CheckDestroy: testAccDomainCheckDestroy(&domain),
		Steps: []resource.TestStep{
			{
				Config: interpolateTerraformTemplateDomain(testAccDomainConfig_basic),
				Check: resource.ComposeTestCheckFunc(
					testAccDomainCheckExists("mailgun_domain.exemple", &domain),
					testAccDomainCheckAttributes("mailgun_domain.exemple", &domain),
				),
			},
		},
	})
}

func TestAccMailgunDomain_withUpdate(t *testing.T) {
	var domain fullDomain

	resource.Test(t, resource.TestCase{
		PreCheck:     func() { testAccPreCheck(t) },
		Providers:    testAccProviders,
		CheckDestroy: testAccDomainCheckDestroy(&domain),
		Steps: []resource.TestStep{
			{
				Config: interpolateTerraformTemplateDomain(testAccDomainConfig_basic),
				Check: resource.ComposeTestCheckFunc(
					testAccDomainCheckExists("mailgun_domain.exemple", &domain),
					testAccDomainCheckAttributes("mailgun_domain.exemple", &domain),
				),
			},

			{
				Config: interpolateTerraformTemplateDomain(testAccDomainConfig_update),
				Check: resource.ComposeTestCheckFunc(
					testAccDomainCheckExists("mailgun_domain.exemple", &domain),
					testAccDomainCheckAttributes("mailgun_domain.exemple", &domain),
				),
			},
		},
	})
}


func TestDomain_importBasic(t *testing.T) {
	var domain fullDomain

	resource.Test(t, resource.TestCase{
		PreCheck:     func() { testAccPreCheck(t) },
		Providers:    testAccProviders,
		CheckDestroy: testAccDomainCheckDestroy(&domain),
		Steps: []resource.TestStep{
			{
				Config: interpolateTerraformTemplateDomain(testAccDomainConfig_import),
				Check: resource.ComposeTestCheckFunc(
					testAccDomainCheckExists("mailgun_domain.exemple",&domain),
				),
			},
			{
				ResourceName:      "mailgun_domain.exemple",
				ImportState:       true,
				ImportStateVerify: true,
			},
		},
	})
}

func testAccDomainCheckExists(rn string, domain *fullDomain) resource.TestCheckFunc {
	return func(s *terraform.State) error {
		rs, ok := s.RootModule().Resources[rn]
		if !ok {
			return fmt.Errorf("resource not found: %s", rn)
		}

		if rs.Primary.ID == "" {
			return fmt.Errorf("domainID not set")
		}

		mg := testAccProvider.Meta().(*mailgun.MailgunImpl)

		domainId := rs.Primary.ID

		gotDomain, err := getFullDomain(mg, domainId)
		if err != nil {
			return fmt.Errorf("error getting domain: %s", err)
		}

		*domain = *gotDomain

		return nil
	}
}

func testAccDomainCheckAttributes(rn string, domain *fullDomain) resource.TestCheckFunc {
	return func(s *terraform.State) error {
		attrs := s.RootModule().Resources[rn].Primary.Attributes

		check := func(key, stateValue, domainValue string) error {
			if domainValue != stateValue {
				return fmt.Errorf("different values for %s in state (%s) and in mailgun (%s)",
					key, stateValue, domainValue)
			}
			return nil
		}

		for key, value := range attrs {
			var err error

			switch key {
			case "name":
				err = check(key, value, domain.domainResponse.Domain.Name)
			case "smtp_password":
				err = check(key, value, domain.domainResponse.Domain.SMTPPassword)
			case "smtp_login":
				err = check(key, value, domain.domainResponse.Domain.SMTPLogin)
			case "wildcard":
				err = check(key, value, strconv.FormatBool(domain.domainResponse.Domain.Wildcard))
			case "state":
				err = check(key, value, domain.domainResponse.Domain.State)
			case "open_tracking_settings_active":
				err = check(key, value, strconv.FormatBool(domain.domainTracking.Open.Active))
			case "click_tracking_settings_active":
				err = check(key, value, strconv.FormatBool(domain.domainTracking.Click.Active))
			case "unsubscribe_tracking_settings_active":
				err = check(key, value, strconv.FormatBool(domain.domainTracking.Unsubscribe.Active))
			case "unsubscribe_tracking_settings_html_footer":
				err = check(key, value, domain.domainTracking.Unsubscribe.HTMLFooter)
			case "unsubscribe_tracking_settings_text_footer":
				err = check(key, value, domain.domainTracking.Unsubscribe.TextFooter)
			case "skip_verification":
				err = check(key, value, strconv.FormatBool(domain.domainConnection.SkipVerification))
			case "require_tls":
				err = check(key, value, strconv.FormatBool(domain.domainConnection.RequireTLS))
			}
			if err != nil {
				return err
			}
		}
		return nil
	}
}

func testAccDomainCheckDestroy(domain *fullDomain) resource.TestCheckFunc {
	return func(s *terraform.State) error {
		mg := testAccProvider.Meta().(*mailgun.MailgunImpl)
		ctx, cancel := context.WithTimeout(context.Background(), time.Second*30)
		defer cancel()
		time.Sleep(5 * time.Second)
		_, err := mg.GetDomain(ctx, domain.domainResponse.Domain.Name)
		if err == nil {
			return fmt.Errorf("domain still exists")
		}

		return nil
	}
}

func interpolateTerraformTemplateDomain(template string) string {
	domainName := ""

	if v := os.Getenv("MAILGUN_DOMAIN"); v != "" {
		domainName = v
	}

	return fmt.Sprintf(template, domainName)
}

const testAccDomainConfig_basic = `
resource "mailgun_domain" "exemple" {
	name="%s"
        wildcard=true
        credentials{
             login="aaaaaaa"
             password="adfshfjqdskjhgfksdgfkqgfk"
        }
}
`

const testAccDomainConfig_update = `
resource "mailgun_domain" "exemple" {
	name="%s"
        credentials{
             login="aaaaaaa"
             password="adfshfjqdskjhgfksdgfkqgfk"
        }

}
`
const testAccDomainConfig_import = `
resource "mailgun_domain" "exemple" {
	name = "%s"
}
`
Commit	Line	Data
40587421 AG	1	package mailgun
	2
	3	import (
	4	"context"
	5	"fmt"
	6	"github.com/hashicorp/terraform/helper/resource"
	7	"github.com/hashicorp/terraform/terraform"
7c735cfa	8	"github.com/mailgun/mailgun-go/v3"
40587421 AG	9	"os"
	10	"strconv"
	11	"testing"
	12	"time"
	13	)
	14
	15	type fullDomain struct {
	16	domainResponse mailgun.DomainResponse
	17	domainConnection mailgun.DomainConnection
	18	domainTracking mailgun.DomainTracking
	19	ipAddress []string
	20	credentials []mailgun.Credential
	21	}
	22
	23	func getFullDomain(mg mailgun.MailgunImpl, domainName string) (fullDomain, error) {
5976bba0	24	ctx, cancel := context.WithTimeout(context.Background(), time.Second*120)
40587421 AG	25	defer cancel()
	26	mg = mailgun.NewMailgun(domainName, mg.APIKey())
	27
	28	var domain fullDomain
	29	var err error
	30	domain.domainResponse, err = mg.GetDomain(ctx, domainName)
	31	if err != nil {
	32	return nil, fmt.Errorf("Error Getting mailgun domain Details for %s: Error: %s", domainName, err)
	33	}
	34
	35	domain.domainConnection, err = mg.GetDomainConnection(ctx, domainName)
	36	if err != nil {
	37	return nil, fmt.Errorf("Error Getting mailgun domain connection Details for %s: Error: %s", domainName, err)
	38	}
	39
	40	domain.domainTracking, err = mg.GetDomainTracking(ctx, domainName)
	41	if err != nil {
	42	return nil, fmt.Errorf("Error Getting mailgun domain tracking Details for %s: Error: %s", domainName, err)
	43	}
	44
5976bba0 AG	45	ipAddress, err := getIps(ctx, mg)
5976bba0 AG	46
40587421 AG	47	if err != nil {
	48	return nil, fmt.Errorf("Error Getting mailgun domain ips2 for %s: Error: %s", domainName, err)
	49	}
	50	ips := make([]string, len(ipAddress))
	51	for i, r := range ipAddress {
	52	ips[i] = r.IP
	53
	54	}
	55	domain.ipAddress = ips
	56	domain.credentials, err = ListCredentials(domainName, mg.APIKey())
	57	if err != nil {
	58	return nil, fmt.Errorf("Error Getting mailgun credentials for %s: Error: %s", domainName, err)
	59	}
	60	return &domain, nil
	61	}
	62
	63	func TestAccMailgunDomain_basic(t *testing.T) {
	64	var domain fullDomain
	65
	66	resource.Test(t, resource.TestCase{
	67	PreCheck: func() { testAccPreCheck(t) },
	68	Providers: testAccProviders,
	69	CheckDestroy: testAccDomainCheckDestroy(&domain),
	70	Steps: []resource.TestStep{
	71	{
	72	Config: interpolateTerraformTemplateDomain(testAccDomainConfig_basic),
	73	Check: resource.ComposeTestCheckFunc(
	74	testAccDomainCheckExists("mailgun_domain.exemple", &domain),
	75	testAccDomainCheckAttributes("mailgun_domain.exemple", &domain),
	76	),
	77	},
	78	},
	79	})
	80	}
	81
	82	func TestAccMailgunDomain_withUpdate(t *testing.T) {
	83	var domain fullDomain
	84
	85	resource.Test(t, resource.TestCase{
	86	PreCheck: func() { testAccPreCheck(t) },
	87	Providers: testAccProviders,
	88	CheckDestroy: testAccDomainCheckDestroy(&domain),
	89	Steps: []resource.TestStep{
	90	{
	91	Config: interpolateTerraformTemplateDomain(testAccDomainConfig_basic),
	92	Check: resource.ComposeTestCheckFunc(
	93	testAccDomainCheckExists("mailgun_domain.exemple", &domain),
	94	testAccDomainCheckAttributes("mailgun_domain.exemple", &domain),
	95	),
	96	},
	97
	98	{
	99	Config: interpolateTerraformTemplateDomain(testAccDomainConfig_update),
	100	Check: resource.ComposeTestCheckFunc(
	101	testAccDomainCheckExists("mailgun_domain.exemple", &domain),
	102	testAccDomainCheckAttributes("mailgun_domain.exemple", &domain),
	103	),
	104	},
	105	},
	106	})
	107	}
	108
70ac6365 AG	109
	110	func TestDomain_importBasic(t *testing.T) {
	111	var domain fullDomain
	112
	113	resource.Test(t, resource.TestCase{
	114	PreCheck: func() { testAccPreCheck(t) },
	115	Providers: testAccProviders,
	116	CheckDestroy: testAccDomainCheckDestroy(&domain),
	117	Steps: []resource.TestStep{
	118	{
	119	Config: interpolateTerraformTemplateDomain(testAccDomainConfig_import),
	120	Check: resource.ComposeTestCheckFunc(
	121	testAccDomainCheckExists("mailgun_domain.exemple",&domain),
	122	),
	123	},
	124	{
	125	ResourceName: "mailgun_domain.exemple",
	126	ImportState: true,
	127	ImportStateVerify: true,
	128	},
	129	},
	130	})
	131	}
	132
40587421 AG	133	func testAccDomainCheckExists(rn string, domain *fullDomain) resource.TestCheckFunc {
	134	return func(s *terraform.State) error {
	135	rs, ok := s.RootModule().Resources[rn]
	136	if !ok {
	137	return fmt.Errorf("resource not found: %s", rn)
	138	}
	139
	140	if rs.Primary.ID == "" {
	141	return fmt.Errorf("domainID not set")
	142	}
	143
	144	mg := testAccProvider.Meta().(*mailgun.MailgunImpl)
	145
	146	domainId := rs.Primary.ID
	147
	148	gotDomain, err := getFullDomain(mg, domainId)
	149	if err != nil {
	150	return fmt.Errorf("error getting domain: %s", err)
	151	}
	152
	153	domain = gotDomain
	154
	155	return nil
	156	}
	157	}
	158
	159	func testAccDomainCheckAttributes(rn string, domain *fullDomain) resource.TestCheckFunc {
	160	return func(s *terraform.State) error {
	161	attrs := s.RootModule().Resources[rn].Primary.Attributes
	162
	163	check := func(key, stateValue, domainValue string) error {
	164	if domainValue != stateValue {
	165	return fmt.Errorf("different values for %s in state (%s) and in mailgun (%s)",
	166	key, stateValue, domainValue)
	167	}
	168	return nil
	169	}
	170
	171	for key, value := range attrs {
	172	var err error
	173
	174	switch key {
	175	case "name":
	176	err = check(key, value, domain.domainResponse.Domain.Name)
	177	case "smtp_password":
	178	err = check(key, value, domain.domainResponse.Domain.SMTPPassword)
	179	case "smtp_login":
	180	err = check(key, value, domain.domainResponse.Domain.SMTPLogin)
	181	case "wildcard":
	182	err = check(key, value, strconv.FormatBool(domain.domainResponse.Domain.Wildcard))
	183	case "state":
	184	err = check(key, value, domain.domainResponse.Domain.State)
	185	case "open_tracking_settings_active":
	186	err = check(key, value, strconv.FormatBool(domain.domainTracking.Open.Active))
	187	case "click_tracking_settings_active":
	188	err = check(key, value, strconv.FormatBool(domain.domainTracking.Click.Active))
	189	case "unsubscribe_tracking_settings_active":
	190	err = check(key, value, strconv.FormatBool(domain.domainTracking.Unsubscribe.Active))
	191	case "unsubscribe_tracking_settings_html_footer":
	192	err = check(key, value, domain.domainTracking.Unsubscribe.HTMLFooter)
	193	case "unsubscribe_tracking_settings_text_footer":
	194	err = check(key, value, domain.domainTracking.Unsubscribe.TextFooter)
	195	case "skip_verification":
	196	err = check(key, value, strconv.FormatBool(domain.domainConnection.SkipVerification))
197	case "require_tls":
198	err = check(key, value, strconv.FormatBool(domain.domainConnection.RequireTLS))
199	}
200	if err != nil {
201	return err
202	}
203	}
204	return nil
205	}
206	}
207
208	func testAccDomainCheckDestroy(domain *fullDomain) resource.TestCheckFunc {
209	return func(s *terraform.State) error {
210	mg := testAccProvider.Meta().(*mailgun.MailgunImpl)
211	ctx, cancel := context.WithTimeout(context.Background(), time.Second*30)
212	defer cancel()
5976bba0	213	time.Sleep(5 * time.Second)
40587421 AG	214	_, err := mg.GetDomain(ctx, domain.domainResponse.Domain.Name)
	215	if err == nil {
	216	return fmt.Errorf("domain still exists")
	217	}
	218
	219	return nil
	220	}
	221	}
	222
	223	func interpolateTerraformTemplateDomain(template string) string {
	224	domainName := ""
	225
	226	if v := os.Getenv("MAILGUN_DOMAIN"); v != "" {
	227	domainName = v
	228	}
	229
	230	return fmt.Sprintf(template, domainName)
	231	}
	232
	233	const testAccDomainConfig_basic = `
	234	resource "mailgun_domain" "exemple" {
	235	name="%s"
3d14d0f6 AG	236	wildcard=true
	237	credentials{
	238	login="aaaaaaa"
	239	password="adfshfjqdskjhgfksdgfkqgfk"
	240	}
40587421 AG	241	}
	242	`
	243
	244	const testAccDomainConfig_update = `
	245	resource "mailgun_domain" "exemple" {
	246	name="%s"
3d14d0f6 AG	247	credentials{
	248	login="aaaaaaa"
	249	password="adfshfjqdskjhgfksdgfkqgfk"
	250	}
	251
40587421 AG	252	}
40587421 AG	253	`
70ac6365 AG	254	const testAccDomainConfig_import = `
	255	resource "mailgun_domain" "exemple" {
	256	name = "%s"
	257	}
	258	`