Source file src/os/removeall_test.go

     1  // Copyright 2018 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package os_test
     6  
     7  import (
     8  	"bytes"
     9  	"fmt"
    10  	"internal/testenv"
    11  	. "os"
    12  	"path/filepath"
    13  	"runtime"
    14  	"strconv"
    15  	"strings"
    16  	"testing"
    17  )
    18  
    19  func TestRemoveAll(t *testing.T) {
    20  	t.Parallel()
    21  
    22  	tmpDir := t.TempDir()
    23  	if err := RemoveAll(""); err != nil {
    24  		t.Errorf("RemoveAll(\"\"): %v; want nil", err)
    25  	}
    26  
    27  	file := filepath.Join(tmpDir, "file")
    28  	path := filepath.Join(tmpDir, "_TestRemoveAll_")
    29  	fpath := filepath.Join(path, "file")
    30  	dpath := filepath.Join(path, "dir")
    31  
    32  	// Make a regular file and remove
    33  	fd, err := Create(file)
    34  	if err != nil {
    35  		t.Fatalf("create %q: %s", file, err)
    36  	}
    37  	fd.Close()
    38  	if err = RemoveAll(file); err != nil {
    39  		t.Fatalf("RemoveAll %q (first): %s", file, err)
    40  	}
    41  	if _, err = Lstat(file); err == nil {
    42  		t.Fatalf("Lstat %q succeeded after RemoveAll (first)", file)
    43  	}
    44  
    45  	// Make directory with 1 file and remove.
    46  	if err := MkdirAll(path, 0777); err != nil {
    47  		t.Fatalf("MkdirAll %q: %s", path, err)
    48  	}
    49  	fd, err = Create(fpath)
    50  	if err != nil {
    51  		t.Fatalf("create %q: %s", fpath, err)
    52  	}
    53  	fd.Close()
    54  	if err = RemoveAll(path); err != nil {
    55  		t.Fatalf("RemoveAll %q (second): %s", path, err)
    56  	}
    57  	if _, err = Lstat(path); err == nil {
    58  		t.Fatalf("Lstat %q succeeded after RemoveAll (second)", path)
    59  	}
    60  
    61  	// Make directory with file and subdirectory and remove.
    62  	if err = MkdirAll(dpath, 0777); err != nil {
    63  		t.Fatalf("MkdirAll %q: %s", dpath, err)
    64  	}
    65  	fd, err = Create(fpath)
    66  	if err != nil {
    67  		t.Fatalf("create %q: %s", fpath, err)
    68  	}
    69  	fd.Close()
    70  	fd, err = Create(dpath + "/file")
    71  	if err != nil {
    72  		t.Fatalf("create %q: %s", fpath, err)
    73  	}
    74  	fd.Close()
    75  	if err = RemoveAll(path); err != nil {
    76  		t.Fatalf("RemoveAll %q (third): %s", path, err)
    77  	}
    78  	if _, err := Lstat(path); err == nil {
    79  		t.Fatalf("Lstat %q succeeded after RemoveAll (third)", path)
    80  	}
    81  
    82  	// Chmod is not supported under Windows or wasip1 and test fails as root.
    83  	if runtime.GOOS != "windows" && runtime.GOOS != "wasip1" && Getuid() != 0 {
    84  		// Make directory with file and subdirectory and trigger error.
    85  		if err = MkdirAll(dpath, 0777); err != nil {
    86  			t.Fatalf("MkdirAll %q: %s", dpath, err)
    87  		}
    88  
    89  		for _, s := range []string{fpath, dpath + "/file1", path + "/zzz"} {
    90  			fd, err = Create(s)
    91  			if err != nil {
    92  				t.Fatalf("create %q: %s", s, err)
    93  			}
    94  			fd.Close()
    95  		}
    96  		if err = Chmod(dpath, 0); err != nil {
    97  			t.Fatalf("Chmod %q 0: %s", dpath, err)
    98  		}
    99  
   100  		// No error checking here: either RemoveAll
   101  		// will or won't be able to remove dpath;
   102  		// either way we want to see if it removes fpath
   103  		// and path/zzz. Reasons why RemoveAll might
   104  		// succeed in removing dpath as well include:
   105  		//	* running as root
   106  		//	* running on a file system without permissions (FAT)
   107  		RemoveAll(path)
   108  		Chmod(dpath, 0777)
   109  
   110  		for _, s := range []string{fpath, path + "/zzz"} {
   111  			if _, err = Lstat(s); err == nil {
   112  				t.Fatalf("Lstat %q succeeded after partial RemoveAll", s)
   113  			}
   114  		}
   115  	}
   116  	if err = RemoveAll(path); err != nil {
   117  		t.Fatalf("RemoveAll %q after partial RemoveAll: %s", path, err)
   118  	}
   119  	if _, err = Lstat(path); err == nil {
   120  		t.Fatalf("Lstat %q succeeded after RemoveAll (final)", path)
   121  	}
   122  }
   123  
   124  // Test RemoveAll on a large directory.
   125  func TestRemoveAllLarge(t *testing.T) {
   126  	if testing.Short() {
   127  		t.Skip("skipping in short mode")
   128  	}
   129  	t.Parallel()
   130  
   131  	tmpDir := t.TempDir()
   132  	path := filepath.Join(tmpDir, "_TestRemoveAllLarge_")
   133  
   134  	// Make directory with 1000 files and remove.
   135  	if err := MkdirAll(path, 0777); err != nil {
   136  		t.Fatalf("MkdirAll %q: %s", path, err)
   137  	}
   138  	for i := 0; i < 1000; i++ {
   139  		fpath := fmt.Sprintf("%s/file%d", path, i)
   140  		fd, err := Create(fpath)
   141  		if err != nil {
   142  			t.Fatalf("create %q: %s", fpath, err)
   143  		}
   144  		fd.Close()
   145  	}
   146  	if err := RemoveAll(path); err != nil {
   147  		t.Fatalf("RemoveAll %q: %s", path, err)
   148  	}
   149  	if _, err := Lstat(path); err == nil {
   150  		t.Fatalf("Lstat %q succeeded after RemoveAll", path)
   151  	}
   152  }
   153  
   154  func TestRemoveAllLongPath(t *testing.T) {
   155  	switch runtime.GOOS {
   156  	case "aix", "darwin", "ios", "dragonfly", "freebsd", "linux", "netbsd", "openbsd", "illumos", "solaris":
   157  		break
   158  	default:
   159  		t.Skip("skipping for not implemented platforms")
   160  	}
   161  
   162  	prevDir, err := Getwd()
   163  	if err != nil {
   164  		t.Fatalf("Could not get wd: %s", err)
   165  	}
   166  
   167  	startPath, err := MkdirTemp("", "TestRemoveAllLongPath-")
   168  	if err != nil {
   169  		t.Fatalf("Could not create TempDir: %s", err)
   170  	}
   171  	defer RemoveAll(startPath)
   172  
   173  	err = Chdir(startPath)
   174  	if err != nil {
   175  		t.Fatalf("Could not chdir %s: %s", startPath, err)
   176  	}
   177  
   178  	// Removing paths with over 4096 chars commonly fails
   179  	for i := 0; i < 41; i++ {
   180  		name := strings.Repeat("a", 100)
   181  
   182  		err = Mkdir(name, 0755)
   183  		if err != nil {
   184  			t.Fatalf("Could not mkdir %s: %s", name, err)
   185  		}
   186  
   187  		err = Chdir(name)
   188  		if err != nil {
   189  			t.Fatalf("Could not chdir %s: %s", name, err)
   190  		}
   191  	}
   192  
   193  	err = Chdir(prevDir)
   194  	if err != nil {
   195  		t.Fatalf("Could not chdir %s: %s", prevDir, err)
   196  	}
   197  
   198  	err = RemoveAll(startPath)
   199  	if err != nil {
   200  		t.Errorf("RemoveAll could not remove long file path %s: %s", startPath, err)
   201  	}
   202  }
   203  
   204  func TestRemoveAllDot(t *testing.T) {
   205  	prevDir, err := Getwd()
   206  	if err != nil {
   207  		t.Fatalf("Could not get wd: %s", err)
   208  	}
   209  	tempDir, err := MkdirTemp("", "TestRemoveAllDot-")
   210  	if err != nil {
   211  		t.Fatalf("Could not create TempDir: %s", err)
   212  	}
   213  	defer RemoveAll(tempDir)
   214  
   215  	err = Chdir(tempDir)
   216  	if err != nil {
   217  		t.Fatalf("Could not chdir to tempdir: %s", err)
   218  	}
   219  
   220  	err = RemoveAll(".")
   221  	if err == nil {
   222  		t.Errorf("RemoveAll succeed to remove .")
   223  	}
   224  
   225  	err = Chdir(prevDir)
   226  	if err != nil {
   227  		t.Fatalf("Could not chdir %s: %s", prevDir, err)
   228  	}
   229  }
   230  
   231  func TestRemoveAllDotDot(t *testing.T) {
   232  	t.Parallel()
   233  
   234  	tempDir := t.TempDir()
   235  	subdir := filepath.Join(tempDir, "x")
   236  	subsubdir := filepath.Join(subdir, "y")
   237  	if err := MkdirAll(subsubdir, 0777); err != nil {
   238  		t.Fatal(err)
   239  	}
   240  	if err := RemoveAll(filepath.Join(subsubdir, "..")); err != nil {
   241  		t.Error(err)
   242  	}
   243  	for _, dir := range []string{subsubdir, subdir} {
   244  		if _, err := Stat(dir); err == nil {
   245  			t.Errorf("%s: exists after RemoveAll", dir)
   246  		}
   247  	}
   248  }
   249  
   250  // Issue #29178.
   251  func TestRemoveReadOnlyDir(t *testing.T) {
   252  	t.Parallel()
   253  
   254  	tempDir := t.TempDir()
   255  	subdir := filepath.Join(tempDir, "x")
   256  	if err := Mkdir(subdir, 0); err != nil {
   257  		t.Fatal(err)
   258  	}
   259  
   260  	// If an error occurs make it more likely that removing the
   261  	// temporary directory will succeed.
   262  	defer Chmod(subdir, 0777)
   263  
   264  	if err := RemoveAll(subdir); err != nil {
   265  		t.Fatal(err)
   266  	}
   267  
   268  	if _, err := Stat(subdir); err == nil {
   269  		t.Error("subdirectory was not removed")
   270  	}
   271  }
   272  
   273  // Issue #29983.
   274  func TestRemoveAllButReadOnlyAndPathError(t *testing.T) {
   275  	switch runtime.GOOS {
   276  	case "js", "wasip1", "windows":
   277  		t.Skipf("skipping test on %s", runtime.GOOS)
   278  	}
   279  
   280  	if Getuid() == 0 {
   281  		t.Skip("skipping test when running as root")
   282  	}
   283  
   284  	t.Parallel()
   285  
   286  	tempDir := t.TempDir()
   287  	dirs := []string{
   288  		"a",
   289  		"a/x",
   290  		"a/x/1",
   291  		"b",
   292  		"b/y",
   293  		"b/y/2",
   294  		"c",
   295  		"c/z",
   296  		"c/z/3",
   297  	}
   298  	readonly := []string{
   299  		"b",
   300  	}
   301  	inReadonly := func(d string) bool {
   302  		for _, ro := range readonly {
   303  			if d == ro {
   304  				return true
   305  			}
   306  			dd, _ := filepath.Split(d)
   307  			if filepath.Clean(dd) == ro {
   308  				return true
   309  			}
   310  		}
   311  		return false
   312  	}
   313  
   314  	for _, dir := range dirs {
   315  		if err := Mkdir(filepath.Join(tempDir, dir), 0777); err != nil {
   316  			t.Fatal(err)
   317  		}
   318  	}
   319  	for _, dir := range readonly {
   320  		d := filepath.Join(tempDir, dir)
   321  		if err := Chmod(d, 0555); err != nil {
   322  			t.Fatal(err)
   323  		}
   324  
   325  		// Defer changing the mode back so that the deferred
   326  		// RemoveAll(tempDir) can succeed.
   327  		defer Chmod(d, 0777)
   328  	}
   329  
   330  	err := RemoveAll(tempDir)
   331  	if err == nil {
   332  		t.Fatal("RemoveAll succeeded unexpectedly")
   333  	}
   334  
   335  	// The error should be of type *PathError.
   336  	// see issue 30491 for details.
   337  	if pathErr, ok := err.(*PathError); ok {
   338  		want := filepath.Join(tempDir, "b", "y")
   339  		if pathErr.Path != want {
   340  			t.Errorf("RemoveAll(%q): err.Path=%q, want %q", tempDir, pathErr.Path, want)
   341  		}
   342  	} else {
   343  		t.Errorf("RemoveAll(%q): error has type %T, want *fs.PathError", tempDir, err)
   344  	}
   345  
   346  	for _, dir := range dirs {
   347  		_, err := Stat(filepath.Join(tempDir, dir))
   348  		if inReadonly(dir) {
   349  			if err != nil {
   350  				t.Errorf("file %q was deleted but should still exist", dir)
   351  			}
   352  		} else {
   353  			if err == nil {
   354  				t.Errorf("file %q still exists but should have been deleted", dir)
   355  			}
   356  		}
   357  	}
   358  }
   359  
   360  func TestRemoveUnreadableDir(t *testing.T) {
   361  	switch runtime.GOOS {
   362  	case "js":
   363  		t.Skipf("skipping test on %s", runtime.GOOS)
   364  	}
   365  
   366  	if Getuid() == 0 {
   367  		t.Skip("skipping test when running as root")
   368  	}
   369  
   370  	t.Parallel()
   371  
   372  	tempDir := t.TempDir()
   373  	target := filepath.Join(tempDir, "d0", "d1", "d2")
   374  	if err := MkdirAll(target, 0755); err != nil {
   375  		t.Fatal(err)
   376  	}
   377  	if err := Chmod(target, 0300); err != nil {
   378  		t.Fatal(err)
   379  	}
   380  	if err := RemoveAll(filepath.Join(tempDir, "d0")); err != nil {
   381  		t.Fatal(err)
   382  	}
   383  }
   384  
   385  // Issue 29921
   386  func TestRemoveAllWithMoreErrorThanReqSize(t *testing.T) {
   387  	if testing.Short() {
   388  		t.Skip("skipping in short mode")
   389  	}
   390  	t.Parallel()
   391  
   392  	tmpDir := t.TempDir()
   393  	path := filepath.Join(tmpDir, "_TestRemoveAllWithMoreErrorThanReqSize_")
   394  
   395  	// Make directory with 1025 read-only files.
   396  	if err := MkdirAll(path, 0777); err != nil {
   397  		t.Fatalf("MkdirAll %q: %s", path, err)
   398  	}
   399  	for i := 0; i < 1025; i++ {
   400  		fpath := filepath.Join(path, fmt.Sprintf("file%d", i))
   401  		fd, err := Create(fpath)
   402  		if err != nil {
   403  			t.Fatalf("create %q: %s", fpath, err)
   404  		}
   405  		fd.Close()
   406  	}
   407  
   408  	// Make the parent directory read-only. On some platforms, this is what
   409  	// prevents Remove from removing the files within that directory.
   410  	if err := Chmod(path, 0555); err != nil {
   411  		t.Fatal(err)
   412  	}
   413  	defer Chmod(path, 0755)
   414  
   415  	// This call should not hang, even on a platform that disallows file deletion
   416  	// from read-only directories.
   417  	err := RemoveAll(path)
   418  
   419  	if Getuid() == 0 {
   420  		// On many platforms, root can remove files from read-only directories.
   421  		return
   422  	}
   423  	if err == nil {
   424  		if runtime.GOOS == "windows" || runtime.GOOS == "wasip1" {
   425  			// Marking a directory as read-only in Windows does not prevent the RemoveAll
   426  			// from creating or removing files within it.
   427  			//
   428  			// For wasip1, there is no support for file permissions so we cannot prevent
   429  			// RemoveAll from removing the files.
   430  			return
   431  		}
   432  		t.Fatal("RemoveAll(<read-only directory>) = nil; want error")
   433  	}
   434  
   435  	dir, err := Open(path)
   436  	if err != nil {
   437  		t.Fatal(err)
   438  	}
   439  	defer dir.Close()
   440  
   441  	names, _ := dir.Readdirnames(1025)
   442  	if len(names) < 1025 {
   443  		t.Fatalf("RemoveAll(<read-only directory>) unexpectedly removed %d read-only files from that directory", 1025-len(names))
   444  	}
   445  }
   446  
   447  func TestRemoveAllNoFcntl(t *testing.T) {
   448  	if testing.Short() {
   449  		t.Skip("skipping in short mode")
   450  	}
   451  
   452  	const env = "GO_TEST_REMOVE_ALL_NO_FCNTL"
   453  	if dir := Getenv(env); dir != "" {
   454  		if err := RemoveAll(dir); err != nil {
   455  			t.Fatal(err)
   456  		}
   457  		return
   458  	}
   459  
   460  	// Only test on Linux so that we can assume we have strace.
   461  	// The code is OS-independent so if it passes on Linux
   462  	// it should pass on other Unix systems.
   463  	if runtime.GOOS != "linux" {
   464  		t.Skipf("skipping test on %s", runtime.GOOS)
   465  	}
   466  	if _, err := Stat("/bin/strace"); err != nil {
   467  		t.Skipf("skipping test because /bin/strace not found: %v", err)
   468  	}
   469  	me, err := Executable()
   470  	if err != nil {
   471  		t.Skipf("skipping because Executable failed: %v", err)
   472  	}
   473  
   474  	// Create 100 directories.
   475  	// The test is that we can remove them without calling fcntl
   476  	// on each one.
   477  	tmpdir := t.TempDir()
   478  	subdir := filepath.Join(tmpdir, "subdir")
   479  	if err := Mkdir(subdir, 0o755); err != nil {
   480  		t.Fatal(err)
   481  	}
   482  	for i := 0; i < 100; i++ {
   483  		subsubdir := filepath.Join(subdir, strconv.Itoa(i))
   484  		if err := Mkdir(filepath.Join(subdir, strconv.Itoa(i)), 0o755); err != nil {
   485  			t.Fatal(err)
   486  		}
   487  		if err := WriteFile(filepath.Join(subsubdir, "file"), nil, 0o644); err != nil {
   488  			t.Fatal(err)
   489  		}
   490  	}
   491  
   492  	cmd := testenv.Command(t, "/bin/strace", "-f", "-e", "fcntl", me, "-test.run=^TestRemoveAllNoFcntl$")
   493  	cmd = testenv.CleanCmdEnv(cmd)
   494  	cmd.Env = append(cmd.Env, env+"="+subdir)
   495  	out, err := cmd.CombinedOutput()
   496  	if len(out) > 0 {
   497  		t.Logf("%s", out)
   498  	}
   499  	if err != nil {
   500  		t.Fatal(err)
   501  	}
   502  
   503  	if got := bytes.Count(out, []byte("fcntl")); got >= 100 {
   504  		t.Errorf("found %d fcntl calls, want < 100", got)
   505  	}
   506  }
   507  

View as plain text