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*120)
  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 := getIps(ctx, mg)
  46
  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
 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
 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()
 213                 time.Sleep(5 * time.Second)
 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"
 236         wildcard=true
 237         credentials{
 238              login="aaaaaaa"
 239              password="adfshfjqdskjhgfksdgfkqgfk"
 240         }
 241 }
 242 `
 243
 244 const testAccDomainConfig_update = `
 245 resource "mailgun_domain" "exemple" {
 246         name="%s"
 247         credentials{
 248              login="aaaaaaa"
 249              password="adfshfjqdskjhgfksdgfkqgfk"
 250         }
 251
 252 }
 253 `
 254 const testAccDomainConfig_import = `
 255 resource "mailgun_domain" "exemple" {
 256         name = "%s"
 257 }
 258 `