github.com/danrjohnson/terraform@v0.7.0-rc2.0.20160627135212-d0fc1fa086ff/builtin/providers/test/resource_test.go (about)

     1  package test
     2  
     3  import (
     4  	"strings"
     5  	"testing"
     6  
     7  	"github.com/hashicorp/terraform/helper/resource"
     8  	"github.com/hashicorp/terraform/terraform"
     9  )
    10  
    11  func TestResource_basic(t *testing.T) {
    12  	resource.UnitTest(t, resource.TestCase{
    13  		Providers:    testAccProviders,
    14  		CheckDestroy: testAccCheckResourceDestroy,
    15  		Steps: []resource.TestStep{
    16  			resource.TestStep{
    17  				Config: strings.TrimSpace(`
    18  resource "test_resource" "foo" {
    19  	required = "yep"
    20  	required_map = {
    21  	    key = "value"
    22  	}
    23  }
    24  				`),
    25  				Check: func(s *terraform.State) error {
    26  					return nil
    27  				},
    28  			},
    29  		},
    30  	})
    31  }
    32  
    33  // Targeted test in TestContext2Apply_ignoreChangesCreate
    34  func TestResource_ignoreChangesRequired(t *testing.T) {
    35  	resource.UnitTest(t, resource.TestCase{
    36  		Providers:    testAccProviders,
    37  		CheckDestroy: testAccCheckResourceDestroy,
    38  		Steps: []resource.TestStep{
    39  			resource.TestStep{
    40  				Config: strings.TrimSpace(`
    41  resource "test_resource" "foo" {
    42          required = "yep"
    43  	required_map = {
    44  	    key = "value"
    45  	}
    46          lifecycle {
    47                  ignore_changes = ["required"]
    48          }
    49  }
    50                                 `),
    51  				Check: func(s *terraform.State) error {
    52  					return nil
    53  				},
    54  			},
    55  		},
    56  	})
    57  }
    58  
    59  func TestResource_ignoreChangesEmpty(t *testing.T) {
    60  	resource.UnitTest(t, resource.TestCase{
    61  		Providers:    testAccProviders,
    62  		CheckDestroy: testAccCheckResourceDestroy,
    63  		Steps: []resource.TestStep{
    64  			resource.TestStep{
    65  				Config: strings.TrimSpace(`
    66  resource "test_resource" "foo" {
    67  	required           = "yep"
    68  	required_map = {
    69  	    key = "value"
    70  	}
    71  	optional_force_new = "one"
    72  	lifecycle {
    73  		ignore_changes = []
    74  	}
    75  }
    76  				`),
    77  				Check: func(s *terraform.State) error {
    78  					return nil
    79  				},
    80  			},
    81  			resource.TestStep{
    82  				Config: strings.TrimSpace(`
    83  resource "test_resource" "foo" {
    84  	required           = "yep"
    85  	required_map = {
    86  	    key = "value"
    87  	}
    88  	optional_force_new = "two"
    89  	lifecycle {
    90  		ignore_changes = []
    91  	}
    92  }
    93  				`),
    94  				Check: func(s *terraform.State) error {
    95  					return nil
    96  				},
    97  			},
    98  		},
    99  	})
   100  }
   101  
   102  func TestResource_ignoreChangesForceNew(t *testing.T) {
   103  	resource.UnitTest(t, resource.TestCase{
   104  		Providers:    testAccProviders,
   105  		CheckDestroy: testAccCheckResourceDestroy,
   106  		Steps: []resource.TestStep{
   107  			resource.TestStep{
   108  				Config: strings.TrimSpace(`
   109  resource "test_resource" "foo" {
   110  	required           = "yep"
   111  	required_map = {
   112  	    key = "value"
   113  	}
   114  	optional_force_new = "one"
   115  	lifecycle {
   116  		ignore_changes = ["optional_force_new"]
   117  	}
   118  }
   119  				`),
   120  				Check: func(s *terraform.State) error {
   121  					return nil
   122  				},
   123  			},
   124  			resource.TestStep{
   125  				Config: strings.TrimSpace(`
   126  resource "test_resource" "foo" {
   127  	required           = "yep"
   128  	required_map = {
   129  	    key = "value"
   130  	}
   131  	optional_force_new = "two"
   132  	lifecycle {
   133  		ignore_changes = ["optional_force_new"]
   134  	}
   135  }
   136  				`),
   137  				Check: func(s *terraform.State) error {
   138  					return nil
   139  				},
   140  			},
   141  		},
   142  	})
   143  }
   144  
   145  // Covers specific scenario in #6005, handled by normalizing boolean strings in
   146  // helper/schema
   147  func TestResource_ignoreChangesForceNewBoolean(t *testing.T) {
   148  	resource.UnitTest(t, resource.TestCase{
   149  		Providers:    testAccProviders,
   150  		CheckDestroy: testAccCheckResourceDestroy,
   151  		Steps: []resource.TestStep{
   152  			resource.TestStep{
   153  				Config: strings.TrimSpace(`
   154  resource "test_resource" "foo" {
   155    required           = "yep"
   156    required_map = {
   157      key = "value"
   158    }
   159    optional_force_new = "one"
   160    optional_bool      = true
   161    lifecycle {
   162      ignore_changes = ["optional_force_new"]
   163    }
   164  }
   165  				`),
   166  				Check: func(s *terraform.State) error {
   167  					return nil
   168  				},
   169  			},
   170  			resource.TestStep{
   171  				Config: strings.TrimSpace(`
   172  resource "test_resource" "foo" {
   173    required           = "yep"
   174    required_map = {
   175      key = "value"
   176    }
   177    optional_force_new = "two"
   178    optional_bool      = true
   179    lifecycle {
   180      ignore_changes = ["optional_force_new"]
   181    }
   182  }
   183  				`),
   184  				Check: func(s *terraform.State) error {
   185  					return nil
   186  				},
   187  			},
   188  		},
   189  	})
   190  }
   191  
   192  func TestResource_ignoreChangesMap(t *testing.T) {
   193  	resource.UnitTest(t, resource.TestCase{
   194  		Providers:    testAccProviders,
   195  		CheckDestroy: testAccCheckResourceDestroy,
   196  		Steps: []resource.TestStep{
   197  			resource.TestStep{
   198  				Config: strings.TrimSpace(`
   199  resource "test_resource" "foo" {
   200  	required           = "yep"
   201  	required_map = {
   202  	  key = "value"
   203  	}
   204  	optional_computed_map {
   205  		foo = "bar"
   206  	}
   207  	lifecycle {
   208  		ignore_changes = ["optional_computed_map"]
   209  	}
   210  }
   211  				`),
   212  				Check: func(s *terraform.State) error {
   213  					return nil
   214  				},
   215  			},
   216  			resource.TestStep{
   217  				Config: strings.TrimSpace(`
   218  resource "test_resource" "foo" {
   219  	required           = "yep"
   220  	required_map = {
   221  	  key = "value"
   222  	}
   223  	optional_computed_map {
   224  		foo = "bar"
   225  		no  = "update"
   226  	}
   227  	lifecycle {
   228  		ignore_changes = ["optional_computed_map"]
   229  	}
   230  }
   231  				`),
   232  				Check: func(s *terraform.State) error {
   233  					return nil
   234  				},
   235  			},
   236  		},
   237  	})
   238  }
   239  
   240  func testAccCheckResourceDestroy(s *terraform.State) error {
   241  	return nil
   242  }