github.com/memsql/terraform@v0.7.0-rc2.0.20160706152241-21e2173e0a32/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 Version: 2, 120 Modules: []*terraform.ModuleState{ 121 &terraform.ModuleState{ 122 Path: []string{"root"}, 123 Resources: map[string]*terraform.ResourceState{ 124 "test_instance.foo": &terraform.ResourceState{ 125 Type: "test_instance", 126 Primary: &terraform.InstanceState{ 127 ID: "bar", 128 }, 129 }, 130 }, 131 Outputs: map[string]*terraform.OutputState{}, 132 }, 133 }, 134 } 135 } 136 137 func testStateFile(t *testing.T, s *terraform.State) string { 138 path := testTempFile(t) 139 140 f, err := os.Create(path) 141 if err != nil { 142 t.Fatalf("err: %s", err) 143 } 144 defer f.Close() 145 146 if err := terraform.WriteState(s, f); err != nil { 147 t.Fatalf("err: %s", err) 148 } 149 150 return path 151 } 152 153 // testStateFileDefault writes the state out to the default statefile 154 // in the cwd. Use `testCwd` to change into a temp cwd. 155 func testStateFileDefault(t *testing.T, s *terraform.State) string { 156 f, err := os.Create(DefaultStateFilename) 157 if err != nil { 158 t.Fatalf("err: %s", err) 159 } 160 defer f.Close() 161 162 if err := terraform.WriteState(s, f); err != nil { 163 t.Fatalf("err: %s", err) 164 } 165 166 return DefaultStateFilename 167 } 168 169 // testStateFileRemote writes the state out to the remote statefile 170 // in the cwd. Use `testCwd` to change into a temp cwd. 171 func testStateFileRemote(t *testing.T, s *terraform.State) string { 172 path := filepath.Join(DefaultDataDir, DefaultStateFilename) 173 if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil { 174 t.Fatalf("err: %s", err) 175 } 176 177 f, err := os.Create(path) 178 if err != nil { 179 t.Fatalf("err: %s", err) 180 } 181 defer f.Close() 182 183 if err := terraform.WriteState(s, f); err != nil { 184 t.Fatalf("err: %s", err) 185 } 186 187 return path 188 } 189 190 // testStateOutput tests that the state at the given path contains 191 // the expected state string. 192 func testStateOutput(t *testing.T, path string, expected string) { 193 f, err := os.Open(path) 194 if err != nil { 195 t.Fatalf("err: %s", err) 196 } 197 198 newState, err := terraform.ReadState(f) 199 f.Close() 200 if err != nil { 201 t.Fatalf("err: %s", err) 202 } 203 204 actual := strings.TrimSpace(newState.String()) 205 expected = strings.TrimSpace(expected) 206 if actual != expected { 207 t.Fatalf("expected:\n%s\nactual:\n%s", expected, actual) 208 } 209 } 210 211 func testProvider() *terraform.MockResourceProvider { 212 p := new(terraform.MockResourceProvider) 213 p.DiffReturn = &terraform.InstanceDiff{} 214 p.RefreshFn = func( 215 info *terraform.InstanceInfo, 216 s *terraform.InstanceState) (*terraform.InstanceState, error) { 217 return s, nil 218 } 219 p.ResourcesReturn = []terraform.ResourceType{ 220 terraform.ResourceType{ 221 Name: "test_instance", 222 }, 223 } 224 225 return p 226 } 227 228 func testTempFile(t *testing.T) string { 229 return filepath.Join(testTempDir(t), "state.tfstate") 230 } 231 232 func testTempDir(t *testing.T) string { 233 d, err := ioutil.TempDir("", "tf") 234 if err != nil { 235 t.Fatalf("err: %s", err) 236 } 237 238 return d 239 } 240 241 // testCwd is used to change the current working directory 242 // into a test directory that should be remoted after 243 func testCwd(t *testing.T) (string, string) { 244 tmp, err := ioutil.TempDir("", "tf") 245 if err != nil { 246 t.Fatalf("err: %v", err) 247 } 248 249 cwd, err := os.Getwd() 250 if err != nil { 251 t.Fatalf("err: %v", err) 252 } 253 254 if err := os.Chdir(tmp); err != nil { 255 t.Fatalf("err: %v", err) 256 } 257 258 return tmp, cwd 259 } 260 261 // testFixCwd is used to as a defer to testDir 262 func testFixCwd(t *testing.T, tmp, cwd string) { 263 if err := os.Chdir(cwd); err != nil { 264 t.Fatalf("err: %v", err) 265 } 266 267 if err := os.RemoveAll(tmp); err != nil { 268 t.Fatalf("err: %v", err) 269 } 270 }