github.com/miquella/terraform@v0.6.17-0.20160517195040-40db82f25ec0/command/command_test.go (about) 1 package command 2 3 import ( 4 "io/ioutil" 5 "os" 6 "path/filepath" 7 "strings" 8 "testing" 9 10 "github.com/hashicorp/go-getter" 11 "github.com/hashicorp/terraform/config/module" 12 "github.com/hashicorp/terraform/terraform" 13 ) 14 15 // This is the directory where our test fixtures are. 16 var fixtureDir = "./test-fixtures" 17 18 func init() { 19 test = true 20 21 // Expand the fixture dir on init because we change the working 22 // directory in some tests. 23 var err error 24 fixtureDir, err = filepath.Abs(fixtureDir) 25 if err != nil { 26 panic(err) 27 } 28 } 29 30 func tempDir(t *testing.T) string { 31 dir, err := ioutil.TempDir("", "tf") 32 if err != nil { 33 t.Fatalf("err: %s", err) 34 } 35 if err := os.RemoveAll(dir); err != nil { 36 t.Fatalf("err: %s", err) 37 } 38 39 return dir 40 } 41 42 func testFixturePath(name string) string { 43 return filepath.Join(fixtureDir, name) 44 } 45 46 func testCtxConfig(p terraform.ResourceProvider) *terraform.ContextOpts { 47 return &terraform.ContextOpts{ 48 Providers: map[string]terraform.ResourceProviderFactory{ 49 "test": func() (terraform.ResourceProvider, error) { 50 return p, nil 51 }, 52 }, 53 } 54 } 55 56 func testCtxConfigWithShell(p terraform.ResourceProvider, pr terraform.ResourceProvisioner) *terraform.ContextOpts { 57 return &terraform.ContextOpts{ 58 Providers: map[string]terraform.ResourceProviderFactory{ 59 "test": func() (terraform.ResourceProvider, error) { 60 return p, nil 61 }, 62 }, 63 Provisioners: map[string]terraform.ResourceProvisionerFactory{ 64 "shell": func() (terraform.ResourceProvisioner, error) { 65 return pr, nil 66 }, 67 }, 68 } 69 } 70 71 func testModule(t *testing.T, name string) *module.Tree { 72 mod, err := module.NewTreeModule("", filepath.Join(fixtureDir, name)) 73 if err != nil { 74 t.Fatalf("err: %s", err) 75 } 76 77 s := &getter.FolderStorage{StorageDir: tempDir(t)} 78 if err := mod.Load(s, module.GetModeGet); err != nil { 79 t.Fatalf("err: %s", err) 80 } 81 82 return mod 83 } 84 85 func testPlanFile(t *testing.T, plan *terraform.Plan) string { 86 path := testTempFile(t) 87 88 f, err := os.Create(path) 89 if err != nil { 90 t.Fatalf("err: %s", err) 91 } 92 defer f.Close() 93 94 if err := terraform.WritePlan(plan, f); err != nil { 95 t.Fatalf("err: %s", err) 96 } 97 98 return path 99 } 100 101 func testReadPlan(t *testing.T, path string) *terraform.Plan { 102 f, err := os.Open(path) 103 if err != nil { 104 t.Fatalf("err: %s", err) 105 } 106 defer f.Close() 107 108 p, err := terraform.ReadPlan(f) 109 if err != nil { 110 t.Fatalf("err: %s", err) 111 } 112 113 return p 114 } 115 116 // testState returns a test State structure that we use for a lot of tests. 117 func testState() *terraform.State { 118 return &terraform.State{ 119 Modules: []*terraform.ModuleState{ 120 &terraform.ModuleState{ 121 Path: []string{"root"}, 122 Resources: map[string]*terraform.ResourceState{ 123 "test_instance.foo": &terraform.ResourceState{ 124 Type: "test_instance", 125 Primary: &terraform.InstanceState{ 126 ID: "bar", 127 }, 128 }, 129 }, 130 }, 131 }, 132 } 133 } 134 135 func testStateFile(t *testing.T, s *terraform.State) string { 136 path := testTempFile(t) 137 138 f, err := os.Create(path) 139 if err != nil { 140 t.Fatalf("err: %s", err) 141 } 142 defer f.Close() 143 144 if err := terraform.WriteState(s, f); err != nil { 145 t.Fatalf("err: %s", err) 146 } 147 148 return path 149 } 150 151 // testStateFileDefault writes the state out to the default statefile 152 // in the cwd. Use `testCwd` to change into a temp cwd. 153 func testStateFileDefault(t *testing.T, s *terraform.State) string { 154 f, err := os.Create(DefaultStateFilename) 155 if err != nil { 156 t.Fatalf("err: %s", err) 157 } 158 defer f.Close() 159 160 if err := terraform.WriteState(s, f); err != nil { 161 t.Fatalf("err: %s", err) 162 } 163 164 return DefaultStateFilename 165 } 166 167 // testStateFileRemote writes the state out to the remote statefile 168 // in the cwd. Use `testCwd` to change into a temp cwd. 169 func testStateFileRemote(t *testing.T, s *terraform.State) string { 170 path := filepath.Join(DefaultDataDir, DefaultStateFilename) 171 if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil { 172 t.Fatalf("err: %s", err) 173 } 174 175 f, err := os.Create(path) 176 if err != nil { 177 t.Fatalf("err: %s", err) 178 } 179 defer f.Close() 180 181 if err := terraform.WriteState(s, f); err != nil { 182 t.Fatalf("err: %s", err) 183 } 184 185 return path 186 } 187 188 // testStateOutput tests that the state at the given path contains 189 // the expected state string. 190 func testStateOutput(t *testing.T, path string, expected string) { 191 f, err := os.Open(path) 192 if err != nil { 193 t.Fatalf("err: %s", err) 194 } 195 196 newState, err := terraform.ReadState(f) 197 f.Close() 198 if err != nil { 199 t.Fatalf("err: %s", err) 200 } 201 202 actual := strings.TrimSpace(newState.String()) 203 expected = strings.TrimSpace(expected) 204 if actual != expected { 205 t.Fatalf("expected:\n%s\nactual:\n%s", expected, actual) 206 } 207 } 208 209 func testProvider() *terraform.MockResourceProvider { 210 p := new(terraform.MockResourceProvider) 211 p.DiffReturn = &terraform.InstanceDiff{} 212 p.RefreshFn = func( 213 info *terraform.InstanceInfo, 214 s *terraform.InstanceState) (*terraform.InstanceState, error) { 215 return s, nil 216 } 217 p.ResourcesReturn = []terraform.ResourceType{ 218 terraform.ResourceType{ 219 Name: "test_instance", 220 }, 221 } 222 223 return p 224 } 225 226 func testTempFile(t *testing.T) string { 227 return filepath.Join(testTempDir(t), "state.tfstate") 228 } 229 230 func testTempDir(t *testing.T) string { 231 d, err := ioutil.TempDir("", "tf") 232 if err != nil { 233 t.Fatalf("err: %s", err) 234 } 235 236 return d 237 } 238 239 // testCwd is used to change the current working directory 240 // into a test directory that should be remoted after 241 func testCwd(t *testing.T) (string, string) { 242 tmp, err := ioutil.TempDir("", "tf") 243 if err != nil { 244 t.Fatalf("err: %v", err) 245 } 246 247 cwd, err := os.Getwd() 248 if err != nil { 249 t.Fatalf("err: %v", err) 250 } 251 252 if err := os.Chdir(tmp); err != nil { 253 t.Fatalf("err: %v", err) 254 } 255 256 return tmp, cwd 257 } 258 259 // testFixCwd is used to as a defer to testDir 260 func testFixCwd(t *testing.T, tmp, cwd string) { 261 if err := os.Chdir(cwd); err != nil { 262 t.Fatalf("err: %v", err) 263 } 264 265 if err := os.RemoveAll(tmp); err != nil { 266 t.Fatalf("err: %v", err) 267 } 268 }