github.com/raba-jp/starlark_iac@v0.0.1/functions/symlink_test.go (about)

     1  package functions_test
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"os"
     7  	"path/filepath"
     8  	"testing"
     9  
    10  	"github.com/raba-jp/starlark_iac/functions"
    11  	"github.com/spf13/afero"
    12  	"go.starlark.net/starlark"
    13  )
    14  
    15  func TestSymlink(t *testing.T) {
    16  	wd, _ := os.Getwd()
    17  	defer func() {
    18  		os.Chdir(wd)
    19  	}()
    20  	fs := afero.NewOsFs()
    21  
    22  	workDir, err := afero.TempDir(fs, "", "symlink_iac")
    23  	if err != nil {
    24  		t.Fatal(err)
    25  	}
    26  
    27  	defer func() {
    28  		fs.RemoveAll(workDir)
    29  	}()
    30  
    31  	tests := []struct {
    32  		data string
    33  		src  string
    34  		dest string
    35  	}{
    36  		{
    37  			data: fmt.Sprintf(
    38  				`symlink(src="%s", dest="%s")`,
    39  				filepath.Join(workDir, "src.txt"),
    40  				filepath.Join(workDir, "dest.txt"),
    41  			),
    42  			src:  filepath.Join(workDir, "src.txt"),
    43  			dest: filepath.Join(workDir, "dest.txt"),
    44  		},
    45  		{
    46  			data: fmt.Sprintf(
    47  				`symlink("%s", "%s")`,
    48  				filepath.Join(workDir, "src1.txt"),
    49  				filepath.Join(workDir, "dest1.txt"),
    50  			),
    51  			src:  filepath.Join(workDir, "src1.txt"),
    52  			dest: filepath.Join(workDir, "dest1.txt"),
    53  		},
    54  	}
    55  
    56  	for _, tt := range tests {
    57  		t.Run(tt.data, func(t *testing.T) {
    58  			afero.WriteFile(fs, tt.src, []byte("test file"), 0777)
    59  
    60  			predeclared := starlark.StringDict{
    61  				"symlink": starlark.NewBuiltin("symlink", functions.Symlink(context.Background(), fs)),
    62  			}
    63  
    64  			thread := &starlark.Thread{
    65  				Name: "testing",
    66  			}
    67  
    68  			_, err := starlark.ExecFile(thread, "test.star", tt.data, predeclared)
    69  			if err != nil {
    70  				t.Fatal(err)
    71  			}
    72  
    73  			lst, _ := fs.(afero.Lstater)
    74  			_, ok, err := lst.LstatIfPossible(tt.dest)
    75  			if !ok {
    76  				if err != nil {
    77  					t.Fatalf("Error calling lstat: %v", err)
    78  				} else {
    79  					t.Fatal("Error calling lstat(not link)")
    80  				}
    81  			}
    82  		})
    83  	}
    84  }
    85  
    86  func TestSymlink_AlreadyExistsFile(t *testing.T) {
    87  	wd, _ := os.Getwd()
    88  	defer func() {
    89  		os.Chdir(wd)
    90  	}()
    91  	fs := afero.NewOsFs()
    92  
    93  	workDir, err := afero.TempDir(fs, "", "symlink_iac")
    94  	if err != nil {
    95  		t.Fatal(err)
    96  	}
    97  
    98  	defer func() {
    99  		fs.RemoveAll(workDir)
   100  	}()
   101  
   102  	tests := []struct {
   103  		data string
   104  		src  string
   105  		dest string
   106  	}{
   107  		{
   108  			data: fmt.Sprintf(
   109  				`symlink(src="%s", dest="%s")`,
   110  				filepath.Join(workDir, "src.txt"),
   111  				filepath.Join(workDir, "dest.txt"),
   112  			),
   113  			src:  filepath.Join(workDir, "src.txt"),
   114  			dest: filepath.Join(workDir, "dest.txt"),
   115  		},
   116  	}
   117  
   118  	for _, tt := range tests {
   119  		t.Run(tt.data, func(t *testing.T) {
   120  			afero.WriteFile(fs, tt.src, []byte("test file"), 0777)
   121  			afero.WriteFile(fs, tt.dest, []byte("test file"), 0777)
   122  
   123  			predeclared := starlark.StringDict{
   124  				"symlink": starlark.NewBuiltin("symlink", functions.Symlink(context.Background(), fs)),
   125  			}
   126  
   127  			thread := &starlark.Thread{
   128  				Name: "testing",
   129  			}
   130  
   131  			_, err := starlark.ExecFile(thread, "test.star", tt.data, predeclared)
   132  			if err != nil {
   133  				t.Fatal(err)
   134  			}
   135  
   136  			_, err = fs.Stat(tt.dest)
   137  			if err != nil {
   138  				t.Fatalf("%v", err)
   139  			}
   140  		})
   141  	}
   142  }
   143  
   144  func TestSymlink_AlreadyExistsSymlink(t *testing.T) {
   145  	wd, _ := os.Getwd()
   146  	defer func() {
   147  		os.Chdir(wd)
   148  	}()
   149  	fs := afero.NewOsFs()
   150  
   151  	workDir, err := afero.TempDir(fs, "", "symlink_iac")
   152  	if err != nil {
   153  		t.Fatal(err)
   154  	}
   155  
   156  	defer func() {
   157  		fs.RemoveAll(workDir)
   158  	}()
   159  
   160  	tests := []struct {
   161  		data string
   162  		src  string
   163  		dest string
   164  	}{
   165  		{
   166  			data: fmt.Sprintf(
   167  				`symlink(src="%s", dest="%s")`,
   168  				filepath.Join(workDir, "src.txt"),
   169  				filepath.Join(workDir, "dest.txt"),
   170  			),
   171  			src:  filepath.Join(workDir, "src.txt"),
   172  			dest: filepath.Join(workDir, "dest.txt"),
   173  		},
   174  	}
   175  
   176  	for _, tt := range tests {
   177  		t.Run(tt.data, func(t *testing.T) {
   178  			afero.WriteFile(fs, tt.src, []byte("test file"), 0777)
   179  			another := filepath.Join(workDir, "another.txt")
   180  			afero.WriteFile(fs, another, []byte("another test file"), 0777)
   181  			l, _ := fs.(afero.Linker)
   182  			l.SymlinkIfPossible(another, tt.dest)
   183  
   184  			predeclared := starlark.StringDict{
   185  				"symlink": starlark.NewBuiltin("symlink", functions.Symlink(context.Background(), fs)),
   186  			}
   187  
   188  			thread := &starlark.Thread{
   189  				Name: "testing",
   190  			}
   191  
   192  			_, err := starlark.ExecFile(thread, "test.star", tt.data, predeclared)
   193  			if err != nil {
   194  				t.Fatal(err)
   195  			}
   196  
   197  			data, err := afero.ReadFile(fs, tt.dest)
   198  			if err != nil {
   199  				t.Fatalf("%v", err)
   200  			}
   201  			if string(data) != "another test file" {
   202  				t.Fatal("unexpected symlink")
   203  			}
   204  		})
   205  	}
   206  }