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