github.com/ben-turner/terraform@v0.11.8-0.20180503104400-0cc9e050ecd4/command/output_test.go (about)

     1  package command
     2  
     3  import (
     4  	"os"
     5  	"path/filepath"
     6  	"strings"
     7  	"testing"
     8  
     9  	"github.com/hashicorp/terraform/terraform"
    10  	"github.com/mitchellh/cli"
    11  )
    12  
    13  func TestOutput(t *testing.T) {
    14  	originalState := &terraform.State{
    15  		Modules: []*terraform.ModuleState{
    16  			{
    17  				Path: []string{"root"},
    18  				Outputs: map[string]*terraform.OutputState{
    19  					"foo": {
    20  						Value: "bar",
    21  						Type:  "string",
    22  					},
    23  				},
    24  			},
    25  		},
    26  	}
    27  
    28  	statePath := testStateFile(t, originalState)
    29  
    30  	ui := new(cli.MockUi)
    31  	c := &OutputCommand{
    32  		Meta: Meta{
    33  			testingOverrides: metaOverridesForProvider(testProvider()),
    34  			Ui:               ui,
    35  		},
    36  	}
    37  
    38  	args := []string{
    39  		"-state", statePath,
    40  		"foo",
    41  	}
    42  	if code := c.Run(args); code != 0 {
    43  		t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
    44  	}
    45  
    46  	actual := strings.TrimSpace(ui.OutputWriter.String())
    47  	if actual != "bar" {
    48  		t.Fatalf("bad: %#v", actual)
    49  	}
    50  }
    51  
    52  func TestModuleOutput(t *testing.T) {
    53  	originalState := &terraform.State{
    54  		Modules: []*terraform.ModuleState{
    55  			{
    56  				Path: []string{"root"},
    57  				Outputs: map[string]*terraform.OutputState{
    58  					"foo": {
    59  						Value: "bar",
    60  						Type:  "string",
    61  					},
    62  				},
    63  			},
    64  			{
    65  				Path: []string{"root", "my_module"},
    66  				Outputs: map[string]*terraform.OutputState{
    67  					"blah": {
    68  						Value: "tastatur",
    69  						Type:  "string",
    70  					},
    71  				},
    72  			},
    73  		},
    74  	}
    75  
    76  	statePath := testStateFile(t, originalState)
    77  
    78  	ui := new(cli.MockUi)
    79  	c := &OutputCommand{
    80  		Meta: Meta{
    81  			testingOverrides: metaOverridesForProvider(testProvider()),
    82  			Ui:               ui,
    83  		},
    84  	}
    85  
    86  	args := []string{
    87  		"-state", statePath,
    88  		"-module", "my_module",
    89  		"blah",
    90  	}
    91  
    92  	if code := c.Run(args); code != 0 {
    93  		t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
    94  	}
    95  
    96  	actual := strings.TrimSpace(ui.OutputWriter.String())
    97  	if actual != "tastatur" {
    98  		t.Fatalf("bad: %#v", actual)
    99  	}
   100  }
   101  
   102  func TestModuleOutputs(t *testing.T) {
   103  	originalState := &terraform.State{
   104  		Modules: []*terraform.ModuleState{
   105  			{
   106  				Path: []string{"root"},
   107  				Outputs: map[string]*terraform.OutputState{
   108  					"foo": {
   109  						Value: "bar",
   110  						Type:  "string",
   111  					},
   112  				},
   113  			},
   114  			{
   115  				Path: []string{"root", "my_module"},
   116  				Outputs: map[string]*terraform.OutputState{
   117  					"blah": {
   118  						Value: "tastatur",
   119  						Type:  "string",
   120  					},
   121  				},
   122  			},
   123  		},
   124  	}
   125  
   126  	statePath := testStateFile(t, originalState)
   127  
   128  	ui := new(cli.MockUi)
   129  	c := &OutputCommand{
   130  		Meta: Meta{
   131  			testingOverrides: metaOverridesForProvider(testProvider()),
   132  			Ui:               ui,
   133  		},
   134  	}
   135  
   136  	args := []string{
   137  		"-state", statePath,
   138  		"-module", "my_module",
   139  	}
   140  
   141  	if code := c.Run(args); code != 0 {
   142  		t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
   143  	}
   144  
   145  	actual := strings.TrimSpace(ui.OutputWriter.String())
   146  	if actual != "blah = tastatur" {
   147  		t.Fatalf("bad: %#v", actual)
   148  	}
   149  }
   150  
   151  func TestOutput_nestedListAndMap(t *testing.T) {
   152  	originalState := &terraform.State{
   153  		Modules: []*terraform.ModuleState{
   154  			{
   155  				Path: []string{"root"},
   156  				Outputs: map[string]*terraform.OutputState{
   157  					"foo": {
   158  						Value: []interface{}{
   159  							map[string]interface{}{
   160  								"key":  "value",
   161  								"key2": "value2",
   162  							},
   163  							map[string]interface{}{
   164  								"key": "value",
   165  							},
   166  						},
   167  						Type: "list",
   168  					},
   169  				},
   170  			},
   171  		},
   172  	}
   173  
   174  	statePath := testStateFile(t, originalState)
   175  
   176  	ui := new(cli.MockUi)
   177  	c := &OutputCommand{
   178  		Meta: Meta{
   179  			testingOverrides: metaOverridesForProvider(testProvider()),
   180  			Ui:               ui,
   181  		},
   182  	}
   183  
   184  	args := []string{
   185  		"-state", statePath,
   186  	}
   187  	if code := c.Run(args); code != 0 {
   188  		t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
   189  	}
   190  
   191  	actual := strings.TrimSpace(ui.OutputWriter.String())
   192  	expected := "foo = [\n    {\n        key = value,\n        key2 = value2\n    },\n    {\n        key = value\n    }\n]"
   193  	if actual != expected {
   194  		t.Fatalf("bad:\n%#v\n%#v", expected, actual)
   195  	}
   196  }
   197  
   198  func TestOutput_json(t *testing.T) {
   199  	originalState := &terraform.State{
   200  		Modules: []*terraform.ModuleState{
   201  			{
   202  				Path: []string{"root"},
   203  				Outputs: map[string]*terraform.OutputState{
   204  					"foo": {
   205  						Value: "bar",
   206  						Type:  "string",
   207  					},
   208  				},
   209  			},
   210  		},
   211  	}
   212  
   213  	statePath := testStateFile(t, originalState)
   214  
   215  	ui := new(cli.MockUi)
   216  	c := &OutputCommand{
   217  		Meta: Meta{
   218  			testingOverrides: metaOverridesForProvider(testProvider()),
   219  			Ui:               ui,
   220  		},
   221  	}
   222  
   223  	args := []string{
   224  		"-state", statePath,
   225  		"-json",
   226  	}
   227  	if code := c.Run(args); code != 0 {
   228  		t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
   229  	}
   230  
   231  	actual := strings.TrimSpace(ui.OutputWriter.String())
   232  	expected := "{\n    \"foo\": {\n        \"sensitive\": false,\n        \"type\": \"string\",\n        \"value\": \"bar\"\n    }\n}"
   233  	if actual != expected {
   234  		t.Fatalf("bad:\n%#v\n%#v", expected, actual)
   235  	}
   236  }
   237  
   238  func TestMissingModuleOutput(t *testing.T) {
   239  	originalState := &terraform.State{
   240  		Modules: []*terraform.ModuleState{
   241  			{
   242  				Path: []string{"root"},
   243  				Outputs: map[string]*terraform.OutputState{
   244  					"foo": {
   245  						Value: "bar",
   246  						Type:  "string",
   247  					},
   248  				},
   249  			},
   250  		},
   251  	}
   252  
   253  	statePath := testStateFile(t, originalState)
   254  
   255  	ui := new(cli.MockUi)
   256  	c := &OutputCommand{
   257  		Meta: Meta{
   258  			testingOverrides: metaOverridesForProvider(testProvider()),
   259  			Ui:               ui,
   260  		},
   261  	}
   262  
   263  	args := []string{
   264  		"-state", statePath,
   265  		"-module", "not_existing_module",
   266  		"blah",
   267  	}
   268  
   269  	if code := c.Run(args); code != 1 {
   270  		t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
   271  	}
   272  }
   273  
   274  func TestOutput_badVar(t *testing.T) {
   275  	originalState := &terraform.State{
   276  		Modules: []*terraform.ModuleState{
   277  			{
   278  				Path: []string{"root"},
   279  				Outputs: map[string]*terraform.OutputState{
   280  					"foo": {
   281  						Value: "bar",
   282  						Type:  "string",
   283  					},
   284  				},
   285  			},
   286  		},
   287  	}
   288  
   289  	statePath := testStateFile(t, originalState)
   290  
   291  	ui := new(cli.MockUi)
   292  	c := &OutputCommand{
   293  		Meta: Meta{
   294  			testingOverrides: metaOverridesForProvider(testProvider()),
   295  			Ui:               ui,
   296  		},
   297  	}
   298  
   299  	args := []string{
   300  		"-state", statePath,
   301  		"bar",
   302  	}
   303  	if code := c.Run(args); code != 1 {
   304  		t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
   305  	}
   306  }
   307  
   308  func TestOutput_blank(t *testing.T) {
   309  	originalState := &terraform.State{
   310  		Modules: []*terraform.ModuleState{
   311  			{
   312  				Path: []string{"root"},
   313  				Outputs: map[string]*terraform.OutputState{
   314  					"foo": {
   315  						Value: "bar",
   316  						Type:  "string",
   317  					},
   318  					"name": {
   319  						Value: "john-doe",
   320  						Type:  "string",
   321  					},
   322  				},
   323  			},
   324  		},
   325  	}
   326  
   327  	statePath := testStateFile(t, originalState)
   328  
   329  	ui := new(cli.MockUi)
   330  	c := &OutputCommand{
   331  		Meta: Meta{
   332  			testingOverrides: metaOverridesForProvider(testProvider()),
   333  			Ui:               ui,
   334  		},
   335  	}
   336  
   337  	args := []string{
   338  		"-state", statePath,
   339  		"",
   340  	}
   341  
   342  	if code := c.Run(args); code != 0 {
   343  		t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
   344  	}
   345  
   346  	expectedOutput := "foo = bar\nname = john-doe\n"
   347  	output := ui.OutputWriter.String()
   348  	if output != expectedOutput {
   349  		t.Fatalf("Expected output: %#v\ngiven: %#v", expectedOutput, output)
   350  	}
   351  }
   352  
   353  func TestOutput_manyArgs(t *testing.T) {
   354  	ui := new(cli.MockUi)
   355  	c := &OutputCommand{
   356  		Meta: Meta{
   357  			testingOverrides: metaOverridesForProvider(testProvider()),
   358  			Ui:               ui,
   359  		},
   360  	}
   361  
   362  	args := []string{
   363  		"bad",
   364  		"bad",
   365  	}
   366  	if code := c.Run(args); code != 1 {
   367  		t.Fatalf("bad: \n%s", ui.OutputWriter.String())
   368  	}
   369  }
   370  
   371  func TestOutput_noArgs(t *testing.T) {
   372  	ui := new(cli.MockUi)
   373  	c := &OutputCommand{
   374  		Meta: Meta{
   375  			testingOverrides: metaOverridesForProvider(testProvider()),
   376  			Ui:               ui,
   377  		},
   378  	}
   379  
   380  	args := []string{}
   381  	if code := c.Run(args); code != 1 {
   382  		t.Fatalf("bad: \n%s", ui.OutputWriter.String())
   383  	}
   384  }
   385  
   386  func TestOutput_noState(t *testing.T) {
   387  	originalState := &terraform.State{}
   388  	statePath := testStateFile(t, originalState)
   389  
   390  	ui := new(cli.MockUi)
   391  	c := &OutputCommand{
   392  		Meta: Meta{
   393  			testingOverrides: metaOverridesForProvider(testProvider()),
   394  			Ui:               ui,
   395  		},
   396  	}
   397  
   398  	args := []string{
   399  		"-state", statePath,
   400  		"foo",
   401  	}
   402  	if code := c.Run(args); code != 1 {
   403  		t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
   404  	}
   405  }
   406  
   407  func TestOutput_noVars(t *testing.T) {
   408  	originalState := &terraform.State{
   409  		Modules: []*terraform.ModuleState{
   410  			{
   411  				Path:    []string{"root"},
   412  				Outputs: map[string]*terraform.OutputState{},
   413  			},
   414  		},
   415  	}
   416  
   417  	statePath := testStateFile(t, originalState)
   418  
   419  	ui := new(cli.MockUi)
   420  	c := &OutputCommand{
   421  		Meta: Meta{
   422  			testingOverrides: metaOverridesForProvider(testProvider()),
   423  			Ui:               ui,
   424  		},
   425  	}
   426  
   427  	args := []string{
   428  		"-state", statePath,
   429  		"bar",
   430  	}
   431  	if code := c.Run(args); code != 1 {
   432  		t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
   433  	}
   434  }
   435  
   436  func TestOutput_stateDefault(t *testing.T) {
   437  	originalState := &terraform.State{
   438  		Modules: []*terraform.ModuleState{
   439  			{
   440  				Path: []string{"root"},
   441  				Outputs: map[string]*terraform.OutputState{
   442  					"foo": {
   443  						Value: "bar",
   444  						Type:  "string",
   445  					},
   446  				},
   447  			},
   448  		},
   449  	}
   450  
   451  	// Write the state file in a temporary directory with the
   452  	// default filename.
   453  	td := testTempDir(t)
   454  	statePath := filepath.Join(td, DefaultStateFilename)
   455  
   456  	f, err := os.Create(statePath)
   457  	if err != nil {
   458  		t.Fatalf("err: %s", err)
   459  	}
   460  	err = terraform.WriteState(originalState, f)
   461  	f.Close()
   462  	if err != nil {
   463  		t.Fatalf("err: %s", err)
   464  	}
   465  
   466  	// Change to that directory
   467  	cwd, err := os.Getwd()
   468  	if err != nil {
   469  		t.Fatalf("err: %s", err)
   470  	}
   471  	if err := os.Chdir(filepath.Dir(statePath)); err != nil {
   472  		t.Fatalf("err: %s", err)
   473  	}
   474  	defer os.Chdir(cwd)
   475  
   476  	ui := new(cli.MockUi)
   477  	c := &OutputCommand{
   478  		Meta: Meta{
   479  			testingOverrides: metaOverridesForProvider(testProvider()),
   480  			Ui:               ui,
   481  		},
   482  	}
   483  
   484  	args := []string{
   485  		"foo",
   486  	}
   487  	if code := c.Run(args); code != 0 {
   488  		t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
   489  	}
   490  
   491  	actual := strings.TrimSpace(ui.OutputWriter.String())
   492  	if actual != "bar" {
   493  		t.Fatalf("bad: %#v", actual)
   494  	}
   495  }