mailgun/resource_mailgun_domain_test.go

   1 package mailgun
   2
   3 import (
   4         "context"
   5         "fmt"
   6         "github.com/hashicorp/terraform/helper/resource"
   7         "github.com/hashicorp/terraform/terraform"
   8         "github.com/mailgun/mailgun-go/v3"
   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) {
  24         ctx, cancel := context.WithTimeout(context.Background(), time.Second*30)
  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
  45         ipAddress, err := mg.ListDomainIPS(ctx)
  46         if err != nil {
  47                 return nil, fmt.Errorf("Error Getting mailgun domain ips2 for %s: Error: %s", domainName, err)
  48         }
  49         ips := make([]string, len(ipAddress))
  50         for i, r := range ipAddress {
  51                 ips[i] = r.IP
  52
  53         }
  54         domain.ipAddress = ips
  55         domain.credentials, err = ListCredentials(domainName, mg.APIKey())
  56         if err != nil {
  57                 return nil, fmt.Errorf("Error Getting mailgun credentials for %s: Error: %s", domainName, err)
  58         }
  59         return &domain, nil
  60 }
  61
  62 func TestAccMailgunDomain_basic(t *testing.T) {
  63         var domain fullDomain
  64
  65         resource.Test(t, resource.TestCase{
  66                 PreCheck:     func() { testAccPreCheck(t) },
  67                 Providers:    testAccProviders,
  68                 CheckDestroy: testAccDomainCheckDestroy(&domain),
  69                 Steps: []resource.TestStep{
  70                         {
  71                                 Config: interpolateTerraformTemplateDomain(testAccDomainConfig_basic),
  72                                 Check: resource.ComposeTestCheckFunc(
  73                                         testAccDomainCheckExists("mailgun_domain.exemple", &domain),
  74                                         testAccDomainCheckAttributes("mailgun_domain.exemple", &domain),
  75                                 ),
  76                         },
  77                 },
  78         })
  79 }
  80
  81 func TestAccMailgunDomain_withUpdate(t *testing.T) {
  82         var domain fullDomain
  83
  84         resource.Test(t, resource.TestCase{
  85                 PreCheck:     func() { testAccPreCheck(t) },
  86                 Providers:    testAccProviders,
  87                 CheckDestroy: testAccDomainCheckDestroy(&domain),
  88                 Steps: []resource.TestStep{
  89                         {
  90                                 Config: interpolateTerraformTemplateDomain(testAccDomainConfig_basic),
  91                                 Check: resource.ComposeTestCheckFunc(
  92                                         testAccDomainCheckExists("mailgun_domain.exemple", &domain),
  93                                         testAccDomainCheckAttributes("mailgun_domain.exemple", &domain),
  94                                 ),
  95                         },
  96
  97                         {
  98                                 Config: interpolateTerraformTemplateDomain(testAccDomainConfig_update),
  99                                 Check: resource.ComposeTestCheckFunc(
 100                                         testAccDomainCheckExists("mailgun_domain.exemple", &domain),
 101                                         testAccDomainCheckAttributes("mailgun_domain.exemple", &domain),
 102                                 ),
 103                         },
 104                 },
 105         })
 106 }
 107
 108 func testAccDomainCheckExists(rn string, domain *fullDomain) resource.TestCheckFunc {
 109         return func(s *terraform.State) error {
 110                 rs, ok := s.RootModule().Resources[rn]
 111                 if !ok {
 112                         return fmt.Errorf("resource not found: %s", rn)
 113                 }
 114
 115                 if rs.Primary.ID == "" {
 116                         return fmt.Errorf("domainID not set")
 117                 }
 118
 119                 mg := testAccProvider.Meta().(*mailgun.MailgunImpl)
 120
 121                 domainId := rs.Primary.ID
 122
 123                 gotDomain, err := getFullDomain(mg, domainId)
 124                 if err != nil {
 125                         return fmt.Errorf("error getting domain: %s", err)
 126                 }
 127
 128                 *domain = *gotDomain
 129
 130                 return nil
 131         }
 132 }
 133
 134 func testAccDomainCheckAttributes(rn string, domain *fullDomain) resource.TestCheckFunc {
 135         return func(s *terraform.State) error {
 136                 attrs := s.RootModule().Resources[rn].Primary.Attributes
 137
 138                 check := func(key, stateValue, domainValue string) error {
 139                         if domainValue != stateValue {
 140                                 return fmt.Errorf("different values for %s in state (%s) and in mailgun (%s)",
 141                                         key, stateValue, domainValue)
 142                         }
 143                         return nil
 144                 }
 145
 146                 for key, value := range attrs {
 147                         var err error
 148
 149                         switch key {
 150                         case "name":
 151                                 err = check(key, value, domain.domainResponse.Domain.Name)
 152                         case "smtp_password":
 153                                 err = check(key, value, domain.domainResponse.Domain.SMTPPassword)
 154                         case "smtp_login":
 155                                 err = check(key, value, domain.domainResponse.Domain.SMTPLogin)
 156                         case "wildcard":
 157                                 err = check(key, value, strconv.FormatBool(domain.domainResponse.Domain.Wildcard))
 158                         case "state":
 159                                 err = check(key, value, domain.domainResponse.Domain.State)
 160                         case "open_tracking_settings_active":
 161                                 err = check(key, value, strconv.FormatBool(domain.domainTracking.Open.Active))
 162                         case "click_tracking_settings_active":
 163                                 err = check(key, value, strconv.FormatBool(domain.domainTracking.Click.Active))
 164                         case "unsubscribe_tracking_settings_active":
 165                                 err = check(key, value, strconv.FormatBool(domain.domainTracking.Unsubscribe.Active))
 166                         case "unsubscribe_tracking_settings_html_footer":
 167                                 err = check(key, value, domain.domainTracking.Unsubscribe.HTMLFooter)
 168                         case "unsubscribe_tracking_settings_text_footer":
 169                                 err = check(key, value, domain.domainTracking.Unsubscribe.TextFooter)
 170                         case "skip_verification":
 171                                 err = check(key, value, strconv.FormatBool(domain.domainConnection.SkipVerification))
 172                         case "require_tls":
 173                                 err = check(key, value, strconv.FormatBool(domain.domainConnection.RequireTLS))
 174                         }
 175                         if err != nil {
 176                                 return err
 177                         }
 178                 }
 179                 return nil
 180         }
 181 }
 182
 183 func testAccDomainCheckDestroy(domain *fullDomain) resource.TestCheckFunc {
 184         return func(s *terraform.State) error {
 185                 mg := testAccProvider.Meta().(*mailgun.MailgunImpl)
 186                 ctx, cancel := context.WithTimeout(context.Background(), time.Second*30)
 187                 defer cancel()
 188
 189                 _, err := mg.GetDomain(ctx, domain.domainResponse.Domain.Name)
 190                 if err == nil {
 191                         return fmt.Errorf("domain still exists")
 192                 }
 193
 194                 return nil
 195         }
 196 }
 197
 198 func interpolateTerraformTemplateDomain(template string) string {
 199         domainName := ""
 200
 201         if v := os.Getenv("MAILGUN_DOMAIN"); v != "" {
 202                 domainName = v
 203         }
 204
 205         return fmt.Sprintf(template, domainName)
 206 }
 207
 208 const testAccDomainConfig_basic = `
 209 resource "mailgun_domain" "exemple" {
 210         name="%s"
 211         wildcard=true
 212         credentials{
 213              login="aaaaaaa"
 214              password="adfshfjqdskjhgfksdgfkqgfk"
 215         }
 216 }
 217 `
 218
 219 const testAccDomainConfig_update = `
 220 resource "mailgun_domain" "exemple" {
 221         name="%s"
 222         credentials{
 223              login="aaaaaaa"
 224              password="adfshfjqdskjhgfksdgfkqgfk"
 225         }
 226
 227 }
 228 `