github.com/opentofu/opentofu@v1.7.1/internal/backend/backend_test.go (about)

     1  // Copyright (c) The OpenTofu Authors
     2  // SPDX-License-Identifier: MPL-2.0
     3  // Copyright (c) 2023 HashiCorp, Inc.
     4  // SPDX-License-Identifier: MPL-2.0
     5  
     6  package backend
     7  
     8  import (
     9  	"io"
    10  	"os"
    11  	"os/user"
    12  	"strings"
    13  	"testing"
    14  
    15  	"github.com/mitchellh/go-homedir"
    16  )
    17  
    18  func TestReadPathOrContents_Path(t *testing.T) {
    19  	f, cleanup := testTempFile(t)
    20  	defer cleanup()
    21  
    22  	if _, err := io.WriteString(f, "foobar"); err != nil {
    23  		t.Fatalf("err: %s", err)
    24  	}
    25  	f.Close()
    26  
    27  	contents, err := ReadPathOrContents(f.Name())
    28  
    29  	if err != nil {
    30  		t.Fatalf("err: %s", err)
    31  	}
    32  	if contents != "foobar" {
    33  		t.Fatalf("expected contents %s, got %s", "foobar", contents)
    34  	}
    35  }
    36  
    37  func TestReadPathOrContents_TildePath(t *testing.T) {
    38  	home, err := homedir.Dir()
    39  	if err != nil {
    40  		t.Fatalf("err: %s", err)
    41  	}
    42  	f, cleanup := testTempFile(t, home)
    43  	defer cleanup()
    44  
    45  	if _, err := io.WriteString(f, "foobar"); err != nil {
    46  		t.Fatalf("err: %s", err)
    47  	}
    48  	f.Close()
    49  
    50  	r := strings.NewReplacer(home, "~")
    51  	homePath := r.Replace(f.Name())
    52  	contents, err := ReadPathOrContents(homePath)
    53  
    54  	if err != nil {
    55  		t.Fatalf("err: %s", err)
    56  	}
    57  	if contents != "foobar" {
    58  		t.Fatalf("expected contents %s, got %s", "foobar", contents)
    59  	}
    60  }
    61  
    62  func TestRead_PathNoPermission(t *testing.T) {
    63  	// This skip condition is intended to get this test out of the way of users
    64  	// who are building and testing OpenTofu from within a Linux-based Docker
    65  	// container, where it is common for processes to be running as effectively
    66  	// root within the container.
    67  	if u, err := user.Current(); err == nil && u.Uid == "0" {
    68  		t.Skip("This test is invalid when running as root, since root can read every file")
    69  	}
    70  
    71  	f, cleanup := testTempFile(t)
    72  	defer cleanup()
    73  
    74  	if _, err := io.WriteString(f, "foobar"); err != nil {
    75  		t.Fatalf("err: %s", err)
    76  	}
    77  	f.Close()
    78  
    79  	if err := os.Chmod(f.Name(), 0); err != nil {
    80  		t.Fatalf("err: %s", err)
    81  	}
    82  
    83  	contents, err := ReadPathOrContents(f.Name())
    84  
    85  	if err == nil {
    86  		t.Fatal("Expected error, got none!")
    87  	}
    88  	if contents != "" {
    89  		t.Fatalf("expected contents %s, got %s", "", contents)
    90  	}
    91  }
    92  
    93  func TestReadPathOrContents_Contents(t *testing.T) {
    94  	input := "hello"
    95  
    96  	contents, err := ReadPathOrContents(input)
    97  
    98  	if err != nil {
    99  		t.Fatalf("err: %s", err)
   100  	}
   101  	if contents != input {
   102  		t.Fatalf("expected contents %s, got %s", input, contents)
   103  	}
   104  }
   105  
   106  func TestReadPathOrContents_TildeContents(t *testing.T) {
   107  	input := "~/hello/notafile"
   108  
   109  	contents, err := ReadPathOrContents(input)
   110  
   111  	if err != nil {
   112  		t.Fatalf("err: %s", err)
   113  	}
   114  	if contents != input {
   115  		t.Fatalf("expected contents %s, got %s", input, contents)
   116  	}
   117  }
   118  
   119  // Returns an open tempfile based at baseDir and a function to clean it up.
   120  func testTempFile(t *testing.T, baseDir ...string) (*os.File, func()) {
   121  	base := ""
   122  	if len(baseDir) == 1 {
   123  		base = baseDir[0]
   124  	}
   125  	f, err := os.CreateTemp(base, "tf")
   126  	if err != nil {
   127  		t.Fatalf("err: %s", err)
   128  	}
   129  
   130  	return f, func() {
   131  		os.Remove(f.Name())
   132  	}
   133  }