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