github.com/devopsjen/devopstool-terraform@v0.11.12-beta1/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 TestOutput_emptyOutputsErr(t *testing.T) {
   239  	originalState := &terraform.State{
   240  		Modules: []*terraform.ModuleState{
   241  			{
   242  				Path:    []string{"root"},
   243  				Outputs: map[string]*terraform.OutputState{},
   244  			},
   245  		},
   246  	}
   247  
   248  	statePath := testStateFile(t, originalState)
   249  
   250  	p := testProvider()
   251  	ui := new(cli.MockUi)
   252  	c := &OutputCommand{
   253  		Meta: Meta{
   254  			testingOverrides: metaOverridesForProvider(p),
   255  			Ui:               ui,
   256  		},
   257  	}
   258  
   259  	args := []string{
   260  		"-state", statePath,
   261  	}
   262  	if code := c.Run(args); code != 1 {
   263  		t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
   264  	}
   265  }
   266  
   267  func TestOutput_jsonEmptyOutputs(t *testing.T) {
   268  	originalState := &terraform.State{
   269  		Modules: []*terraform.ModuleState{
   270  			{
   271  				Path:    []string{"root"},
   272  				Outputs: map[string]*terraform.OutputState{},
   273  			},
   274  		},
   275  	}
   276  
   277  	statePath := testStateFile(t, originalState)
   278  
   279  	p := testProvider()
   280  	ui := new(cli.MockUi)
   281  	c := &OutputCommand{
   282  		Meta: Meta{
   283  			testingOverrides: metaOverridesForProvider(p),
   284  			Ui:               ui,
   285  		},
   286  	}
   287  
   288  	args := []string{
   289  		"-state", statePath,
   290  		"-json",
   291  	}
   292  	if code := c.Run(args); code != 0 {
   293  		t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
   294  	}
   295  
   296  	actual := strings.TrimSpace(ui.OutputWriter.String())
   297  	expected := "{}"
   298  	if actual != expected {
   299  		t.Fatalf("bad:\n%#v\n%#v", expected, actual)
   300  	}
   301  }
   302  
   303  func TestMissingModuleOutput(t *testing.T) {
   304  	originalState := &terraform.State{
   305  		Modules: []*terraform.ModuleState{
   306  			{
   307  				Path: []string{"root"},
   308  				Outputs: map[string]*terraform.OutputState{
   309  					"foo": {
   310  						Value: "bar",
   311  						Type:  "string",
   312  					},
   313  				},
   314  			},
   315  		},
   316  	}
   317  
   318  	statePath := testStateFile(t, originalState)
   319  
   320  	ui := new(cli.MockUi)
   321  	c := &OutputCommand{
   322  		Meta: Meta{
   323  			testingOverrides: metaOverridesForProvider(testProvider()),
   324  			Ui:               ui,
   325  		},
   326  	}
   327  
   328  	args := []string{
   329  		"-state", statePath,
   330  		"-module", "not_existing_module",
   331  		"blah",
   332  	}
   333  
   334  	if code := c.Run(args); code != 1 {
   335  		t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
   336  	}
   337  }
   338  
   339  func TestOutput_badVar(t *testing.T) {
   340  	originalState := &terraform.State{
   341  		Modules: []*terraform.ModuleState{
   342  			{
   343  				Path: []string{"root"},
   344  				Outputs: map[string]*terraform.OutputState{
   345  					"foo": {
   346  						Value: "bar",
   347  						Type:  "string",
   348  					},
   349  				},
   350  			},
   351  		},
   352  	}
   353  
   354  	statePath := testStateFile(t, originalState)
   355  
   356  	ui := new(cli.MockUi)
   357  	c := &OutputCommand{
   358  		Meta: Meta{
   359  			testingOverrides: metaOverridesForProvider(testProvider()),
   360  			Ui:               ui,
   361  		},
   362  	}
   363  
   364  	args := []string{
   365  		"-state", statePath,
   366  		"bar",
   367  	}
   368  	if code := c.Run(args); code != 1 {
   369  		t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
   370  	}
   371  }
   372  
   373  func TestOutput_blank(t *testing.T) {
   374  	originalState := &terraform.State{
   375  		Modules: []*terraform.ModuleState{
   376  			{
   377  				Path: []string{"root"},
   378  				Outputs: map[string]*terraform.OutputState{
   379  					"foo": {
   380  						Value: "bar",
   381  						Type:  "string",
   382  					},
   383  					"name": {
   384  						Value: "john-doe",
   385  						Type:  "string",
   386  					},
   387  				},
   388  			},
   389  		},
   390  	}
   391  
   392  	statePath := testStateFile(t, originalState)
   393  
   394  	ui := new(cli.MockUi)
   395  	c := &OutputCommand{
   396  		Meta: Meta{
   397  			testingOverrides: metaOverridesForProvider(testProvider()),
   398  			Ui:               ui,
   399  		},
   400  	}
   401  
   402  	args := []string{
   403  		"-state", statePath,
   404  		"",
   405  	}
   406  
   407  	if code := c.Run(args); code != 0 {
   408  		t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
   409  	}
   410  
   411  	expectedOutput := "foo = bar\nname = john-doe\n"
   412  	output := ui.OutputWriter.String()
   413  	if output != expectedOutput {
   414  		t.Fatalf("Expected output: %#v\ngiven: %#v", expectedOutput, output)
   415  	}
   416  }
   417  
   418  func TestOutput_manyArgs(t *testing.T) {
   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  		"bad",
   429  		"bad",
   430  	}
   431  	if code := c.Run(args); code != 1 {
   432  		t.Fatalf("bad: \n%s", ui.OutputWriter.String())
   433  	}
   434  }
   435  
   436  func TestOutput_noArgs(t *testing.T) {
   437  	ui := new(cli.MockUi)
   438  	c := &OutputCommand{
   439  		Meta: Meta{
   440  			testingOverrides: metaOverridesForProvider(testProvider()),
   441  			Ui:               ui,
   442  		},
   443  	}
   444  
   445  	args := []string{}
   446  	if code := c.Run(args); code != 1 {
   447  		t.Fatalf("bad: \n%s", ui.OutputWriter.String())
   448  	}
   449  }
   450  
   451  func TestOutput_noState(t *testing.T) {
   452  	originalState := &terraform.State{}
   453  	statePath := testStateFile(t, originalState)
   454  
   455  	ui := new(cli.MockUi)
   456  	c := &OutputCommand{
   457  		Meta: Meta{
   458  			testingOverrides: metaOverridesForProvider(testProvider()),
   459  			Ui:               ui,
   460  		},
   461  	}
   462  
   463  	args := []string{
   464  		"-state", statePath,
   465  		"foo",
   466  	}
   467  	if code := c.Run(args); code != 1 {
   468  		t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
   469  	}
   470  }
   471  
   472  func TestOutput_noVars(t *testing.T) {
   473  	originalState := &terraform.State{
   474  		Modules: []*terraform.ModuleState{
   475  			{
   476  				Path:    []string{"root"},
   477  				Outputs: map[string]*terraform.OutputState{},
   478  			},
   479  		},
   480  	}
   481  
   482  	statePath := testStateFile(t, originalState)
   483  
   484  	ui := new(cli.MockUi)
   485  	c := &OutputCommand{
   486  		Meta: Meta{
   487  			testingOverrides: metaOverridesForProvider(testProvider()),
   488  			Ui:               ui,
   489  		},
   490  	}
   491  
   492  	args := []string{
   493  		"-state", statePath,
   494  		"bar",
   495  	}
   496  	if code := c.Run(args); code != 1 {
   497  		t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
   498  	}
   499  }
   500  
   501  func TestOutput_stateDefault(t *testing.T) {
   502  	originalState := &terraform.State{
   503  		Modules: []*terraform.ModuleState{
   504  			{
   505  				Path: []string{"root"},
   506  				Outputs: map[string]*terraform.OutputState{
   507  					"foo": {
   508  						Value: "bar",
   509  						Type:  "string",
   510  					},
   511  				},
   512  			},
   513  		},
   514  	}
   515  
   516  	// Write the state file in a temporary directory with the
   517  	// default filename.
   518  	td := testTempDir(t)
   519  	statePath := filepath.Join(td, DefaultStateFilename)
   520  
   521  	f, err := os.Create(statePath)
   522  	if err != nil {
   523  		t.Fatalf("err: %s", err)
   524  	}
   525  	err = terraform.WriteState(originalState, f)
   526  	f.Close()
   527  	if err != nil {
   528  		t.Fatalf("err: %s", err)
   529  	}
   530  
   531  	// Change to that directory
   532  	cwd, err := os.Getwd()
   533  	if err != nil {
   534  		t.Fatalf("err: %s", err)
   535  	}
   536  	if err := os.Chdir(filepath.Dir(statePath)); err != nil {
   537  		t.Fatalf("err: %s", err)
   538  	}
   539  	defer os.Chdir(cwd)
   540  
   541  	ui := new(cli.MockUi)
   542  	c := &OutputCommand{
   543  		Meta: Meta{
   544  			testingOverrides: metaOverridesForProvider(testProvider()),
   545  			Ui:               ui,
   546  		},
   547  	}
   548  
   549  	args := []string{
   550  		"foo",
   551  	}
   552  	if code := c.Run(args); code != 0 {
   553  		t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
   554  	}
   555  
   556  	actual := strings.TrimSpace(ui.OutputWriter.String())
   557  	if actual != "bar" {
   558  		t.Fatalf("bad: %#v", actual)
   559  	}
   560  }