github.com/22Acacia/terraform@v0.6.5-0.20160105010053-c57aae34c157/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("bad:\n\n%s", 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 tf, err := ioutil.TempFile("", "tf") 228 if err != nil { 229 t.Fatalf("err: %s", err) 230 } 231 232 result := tf.Name() 233 234 if err := tf.Close(); err != nil { 235 t.Fatalf("err: %s", err) 236 } 237 if err := os.Remove(result); err != nil { 238 t.Fatalf("err: %s", err) 239 } 240 241 return result 242 } 243 244 func testTempDir(t *testing.T) string { 245 d, err := ioutil.TempDir("", "tf") 246 if err != nil { 247 t.Fatalf("err: %s", err) 248 } 249 250 return d 251 } 252 253 // testCwd is used to change the current working directory 254 // into a test directory that should be remoted after 255 func testCwd(t *testing.T) (string, string) { 256 tmp, err := ioutil.TempDir("", "tf") 257 if err != nil { 258 t.Fatalf("err: %v", err) 259 } 260 261 cwd, err := os.Getwd() 262 if err != nil { 263 t.Fatalf("err: %v", err) 264 } 265 266 if err := os.Chdir(tmp); err != nil { 267 t.Fatalf("err: %v", err) 268 } 269 270 return tmp, cwd 271 } 272 273 // testFixCwd is used to as a defer to testDir 274 func testFixCwd(t *testing.T, tmp, cwd string) { 275 if err := os.Chdir(cwd); err != nil { 276 t.Fatalf("err: %v", err) 277 } 278 279 if err := os.RemoveAll(tmp); err != nil { 280 t.Fatalf("err: %v", err) 281 } 282 }