github.com/mohanarpit/terraform@v0.6.16-0.20160909104007-291f29853544/builtin/providers/aws/resource_aws_efs_file_system_test.go (about) 1 package aws 2 3 import ( 4 "fmt" 5 "reflect" 6 "testing" 7 8 "github.com/aws/aws-sdk-go/aws" 9 "github.com/aws/aws-sdk-go/aws/awserr" 10 "github.com/aws/aws-sdk-go/service/efs" 11 12 "github.com/hashicorp/terraform/helper/acctest" 13 "github.com/hashicorp/terraform/helper/resource" 14 "github.com/hashicorp/terraform/terraform" 15 ) 16 17 func TestResourceAWSEFSFileSystem_validateReferenceName(t *testing.T) { 18 var value string 19 var errors []error 20 21 value = acctest.RandString(128) 22 _, errors = validateReferenceName(value, "reference_name") 23 if len(errors) == 0 { 24 t.Fatalf("Expected to trigger a validation error") 25 } 26 27 value = acctest.RandString(32) 28 _, errors = validateReferenceName(value, "reference_name") 29 if len(errors) != 0 { 30 t.Fatalf("Expected not to trigger a validation error") 31 } 32 } 33 34 func TestResourceAWSEFSFileSystem_validatePerformanceModeType(t *testing.T) { 35 _, errors := validatePerformanceModeType("incorrect", "performance_mode") 36 if len(errors) == 0 { 37 t.Fatalf("Expected to trigger a validation error") 38 } 39 40 var testCases = []struct { 41 Value string 42 ErrCount int 43 }{ 44 { 45 Value: "generalPurpose", 46 ErrCount: 0, 47 }, 48 { 49 Value: "maxIO", 50 ErrCount: 0, 51 }, 52 } 53 54 for _, tc := range testCases { 55 _, errors := validatePerformanceModeType(tc.Value, "performance_mode") 56 if len(errors) != tc.ErrCount { 57 t.Fatalf("Expected not to trigger a validation error") 58 } 59 } 60 } 61 62 func TestResourceAWSEFSFileSystem_hasEmptyFileSystems(t *testing.T) { 63 fs := &efs.DescribeFileSystemsOutput{ 64 FileSystems: []*efs.FileSystemDescription{}, 65 } 66 67 var actual bool 68 69 actual = hasEmptyFileSystems(fs) 70 if !actual { 71 t.Fatalf("Expected return value to be true, got %t", actual) 72 } 73 74 // Add an empty file system. 75 fs.FileSystems = append(fs.FileSystems, &efs.FileSystemDescription{}) 76 77 actual = hasEmptyFileSystems(fs) 78 if actual { 79 t.Fatalf("Expected return value to be false, got %t", actual) 80 } 81 82 } 83 84 func TestAccAWSEFSFileSystem_basic(t *testing.T) { 85 resource.Test(t, resource.TestCase{ 86 PreCheck: func() { testAccPreCheck(t) }, 87 Providers: testAccProviders, 88 CheckDestroy: testAccCheckEfsFileSystemDestroy, 89 Steps: []resource.TestStep{ 90 resource.TestStep{ 91 Config: testAccAWSEFSFileSystemConfig, 92 Check: resource.ComposeTestCheckFunc( 93 testAccCheckEfsFileSystem( 94 "aws_efs_file_system.foo", 95 ), 96 testAccCheckEfsFileSystemPerformanceMode( 97 "aws_efs_file_system.foo", 98 "generalPurpose", 99 ), 100 ), 101 }, 102 resource.TestStep{ 103 Config: testAccAWSEFSFileSystemConfigWithTags, 104 Check: resource.ComposeTestCheckFunc( 105 testAccCheckEfsFileSystem( 106 "aws_efs_file_system.foo-with-tags", 107 ), 108 testAccCheckEfsFileSystemPerformanceMode( 109 "aws_efs_file_system.foo-with-tags", 110 "generalPurpose", 111 ), 112 testAccCheckEfsFileSystemTags( 113 "aws_efs_file_system.foo-with-tags", 114 map[string]string{ 115 "Name": "foo-efs", 116 "Another": "tag", 117 }, 118 ), 119 ), 120 }, 121 resource.TestStep{ 122 Config: testAccAWSEFSFileSystemConfigWithPerformanceMode, 123 Check: resource.ComposeTestCheckFunc( 124 testAccCheckEfsFileSystem( 125 "aws_efs_file_system.foo-with-performance-mode", 126 ), 127 testAccCheckEfsCreationToken( 128 "aws_efs_file_system.foo-with-performance-mode", 129 "supercalifragilisticexpialidocious", 130 ), 131 testAccCheckEfsFileSystemPerformanceMode( 132 "aws_efs_file_system.foo-with-performance-mode", 133 "maxIO", 134 ), 135 ), 136 }, 137 }, 138 }) 139 } 140 141 func testAccCheckEfsFileSystemDestroy(s *terraform.State) error { 142 conn := testAccProvider.Meta().(*AWSClient).efsconn 143 for _, rs := range s.RootModule().Resources { 144 if rs.Type != "aws_efs_file_system" { 145 continue 146 } 147 148 resp, err := conn.DescribeFileSystems(&efs.DescribeFileSystemsInput{ 149 FileSystemId: aws.String(rs.Primary.ID), 150 }) 151 if err != nil { 152 if efsErr, ok := err.(awserr.Error); ok && efsErr.Code() == "FileSystemNotFound" { 153 // gone 154 return nil 155 } 156 return fmt.Errorf("Error describing EFS in tests: %s", err) 157 } 158 if len(resp.FileSystems) > 0 { 159 return fmt.Errorf("EFS file system %q still exists", rs.Primary.ID) 160 } 161 } 162 163 return nil 164 } 165 166 func testAccCheckEfsFileSystem(resourceID string) resource.TestCheckFunc { 167 return func(s *terraform.State) error { 168 rs, ok := s.RootModule().Resources[resourceID] 169 if !ok { 170 return fmt.Errorf("Not found: %s", resourceID) 171 } 172 173 if rs.Primary.ID == "" { 174 return fmt.Errorf("No ID is set") 175 } 176 177 conn := testAccProvider.Meta().(*AWSClient).efsconn 178 _, err := conn.DescribeFileSystems(&efs.DescribeFileSystemsInput{ 179 FileSystemId: aws.String(rs.Primary.ID), 180 }) 181 182 if err != nil { 183 return err 184 } 185 186 return nil 187 } 188 } 189 190 func testAccCheckEfsCreationToken(resourceID string, expectedToken string) resource.TestCheckFunc { 191 return func(s *terraform.State) error { 192 rs, ok := s.RootModule().Resources[resourceID] 193 if !ok { 194 return fmt.Errorf("Not found: %s", resourceID) 195 } 196 197 if rs.Primary.ID == "" { 198 return fmt.Errorf("No ID is set") 199 } 200 201 conn := testAccProvider.Meta().(*AWSClient).efsconn 202 resp, err := conn.DescribeFileSystems(&efs.DescribeFileSystemsInput{ 203 FileSystemId: aws.String(rs.Primary.ID), 204 }) 205 206 fs := resp.FileSystems[0] 207 if *fs.CreationToken != expectedToken { 208 return fmt.Errorf("Creation Token mismatch.\nExpected: %s\nGiven: %v", 209 expectedToken, *fs.CreationToken) 210 } 211 212 if err != nil { 213 return err 214 } 215 216 return nil 217 } 218 } 219 220 func testAccCheckEfsFileSystemTags(resourceID string, expectedTags map[string]string) resource.TestCheckFunc { 221 return func(s *terraform.State) error { 222 rs, ok := s.RootModule().Resources[resourceID] 223 if !ok { 224 return fmt.Errorf("Not found: %s", resourceID) 225 } 226 227 if rs.Primary.ID == "" { 228 return fmt.Errorf("No ID is set") 229 } 230 231 conn := testAccProvider.Meta().(*AWSClient).efsconn 232 resp, err := conn.DescribeTags(&efs.DescribeTagsInput{ 233 FileSystemId: aws.String(rs.Primary.ID), 234 }) 235 236 if !reflect.DeepEqual(expectedTags, tagsToMapEFS(resp.Tags)) { 237 return fmt.Errorf("Tags mismatch.\nExpected: %#v\nGiven: %#v", 238 expectedTags, resp.Tags) 239 } 240 241 if err != nil { 242 return err 243 } 244 245 return nil 246 } 247 } 248 249 func testAccCheckEfsFileSystemPerformanceMode(resourceID string, expectedMode string) resource.TestCheckFunc { 250 return func(s *terraform.State) error { 251 rs, ok := s.RootModule().Resources[resourceID] 252 if !ok { 253 return fmt.Errorf("Not found: %s", resourceID) 254 } 255 256 if rs.Primary.ID == "" { 257 return fmt.Errorf("No ID is set") 258 } 259 260 conn := testAccProvider.Meta().(*AWSClient).efsconn 261 resp, err := conn.DescribeFileSystems(&efs.DescribeFileSystemsInput{ 262 FileSystemId: aws.String(rs.Primary.ID), 263 }) 264 265 fs := resp.FileSystems[0] 266 if *fs.PerformanceMode != expectedMode { 267 return fmt.Errorf("Performance Mode mismatch.\nExpected: %s\nGiven: %v", 268 expectedMode, *fs.PerformanceMode) 269 } 270 271 if err != nil { 272 return err 273 } 274 275 return nil 276 } 277 } 278 279 const testAccAWSEFSFileSystemConfig = ` 280 resource "aws_efs_file_system" "foo" { 281 reference_name = "radeksimko" 282 } 283 ` 284 285 const testAccAWSEFSFileSystemConfigWithTags = ` 286 resource "aws_efs_file_system" "foo-with-tags" { 287 reference_name = "yada_yada" 288 tags { 289 Name = "foo-efs" 290 Another = "tag" 291 } 292 } 293 ` 294 295 const testAccAWSEFSFileSystemConfigWithPerformanceMode = ` 296 resource "aws_efs_file_system" "foo-with-performance-mode" { 297 creation_token = "supercalifragilisticexpialidocious" 298 performance_mode = "maxIO" 299 } 300 `