github.com/seilagamo/poc-lava-release@v0.3.3-rc3/internal/gitserver/gitserver_test.go (about)

     1  // Copyright 2023 Adevinta
     2  
     3  package gitserver
     4  
     5  import (
     6  	"fmt"
     7  	"net"
     8  	"net/http"
     9  	"os"
    10  	"path/filepath"
    11  	"testing"
    12  
    13  	"github.com/seilagamo/poc-lava-release/internal/gitserver/gittest"
    14  )
    15  
    16  func TestServer_AddRepository(t *testing.T) {
    17  	// Not parallel: uses global test hook.
    18  	defer func() { testHookServerServe = nil }()
    19  
    20  	tmpPath, err := gittest.ExtractTemp(filepath.Join("testdata", "testrepo.tar"))
    21  	if err != nil {
    22  		t.Fatalf("unable to create a repository: %v", err)
    23  	}
    24  	defer os.RemoveAll(tmpPath)
    25  
    26  	gs, err := New()
    27  	if err != nil {
    28  		t.Fatalf("unable to create a server: %v", err)
    29  	}
    30  	defer gs.Close()
    31  
    32  	lnc := make(chan net.Listener)
    33  	testHookServerServe = func(gs *Server, ln net.Listener) {
    34  		lnc <- ln
    35  	}
    36  
    37  	go gs.ListenAndServe("127.0.0.1:0") //nolint:errcheck
    38  
    39  	ln := <-lnc
    40  
    41  	repoName, err := gs.AddRepository(tmpPath)
    42  	if err != nil {
    43  		t.Fatalf("unable to add a repository: %v", err)
    44  	}
    45  
    46  	repoPath, err := gittest.CloneTemp(fmt.Sprintf("http://%v/%s", ln.Addr(), repoName))
    47  	if err != nil {
    48  		t.Fatalf("unable to clone the repo %s: %v", repoName, err)
    49  	}
    50  	defer os.RemoveAll(repoPath)
    51  
    52  	if _, err := os.Stat(filepath.Join(repoPath, "foo.txt")); err != nil {
    53  		t.Fatalf("unexpected error: %v", err)
    54  	}
    55  }
    56  
    57  func TestServer_AddRepository_no_repo(t *testing.T) {
    58  	tmpPath, err := os.MkdirTemp("", "")
    59  	if err != nil {
    60  		t.Fatalf("unable to create a temporary dir")
    61  	}
    62  	defer os.RemoveAll(tmpPath)
    63  
    64  	gs, err := New()
    65  	if err != nil {
    66  		t.Fatalf("unable to create a server: %v", err)
    67  	}
    68  	defer gs.Close() //nolint:staticcheck
    69  
    70  	if _, err = gs.AddRepository(tmpPath); err == nil {
    71  		t.Fatal("expected error adding repository")
    72  	}
    73  }
    74  
    75  func TestServer_AddRepository_invalid_dir(t *testing.T) {
    76  	gs, err := New()
    77  	if err != nil {
    78  		t.Fatalf("unable to create a server: %v", err)
    79  	}
    80  	defer gs.Close() //nolint:staticcheck
    81  
    82  	if _, err = gs.AddRepository("/fakedir"); err == nil {
    83  		t.Fatal("expected error adding repository")
    84  	}
    85  }
    86  
    87  func TestServer_AddRepository_invalid_dir_2(t *testing.T) {
    88  	tmpPath, err := os.MkdirTemp("", "")
    89  	if err != nil {
    90  		t.Fatalf("unable to create a temporary dir")
    91  	}
    92  	defer os.RemoveAll(tmpPath)
    93  
    94  	gs := &Server{
    95  		basePath: "testdata/fakedir",
    96  		repos:    make(map[string]string),
    97  		httpsrv:  &http.Server{Handler: newSmartServer(tmpPath)},
    98  	}
    99  	defer gs.Close() //nolint:staticcheck
   100  
   101  	if _, err = gs.AddRepository(tmpPath); err == nil {
   102  		t.Fatal("expected error adding repository")
   103  	}
   104  }
   105  
   106  func TestServer_AddRepository_do_not_cache_error(t *testing.T) {
   107  	gs, err := New()
   108  	if err != nil {
   109  		t.Fatalf("unable to create a server: %v", err)
   110  	}
   111  	defer gs.Close() //nolint:staticcheck
   112  
   113  	if _, err = gs.AddRepository("/fakedir"); err == nil {
   114  		t.Fatal("expected error adding repository")
   115  	}
   116  
   117  	if _, err = gs.AddRepository("/fakedir"); err == nil {
   118  		t.Fatal("expected error adding repository")
   119  	}
   120  }
   121  
   122  func TestServer_AddRepository_already_added(t *testing.T) {
   123  	tmpPath, err := gittest.ExtractTemp(filepath.Join("testdata", "testrepo.tar"))
   124  	if err != nil {
   125  		t.Fatalf("unable to create a repository: %v", err)
   126  	}
   127  	defer os.RemoveAll(tmpPath)
   128  
   129  	gs, err := New()
   130  	if err != nil {
   131  		t.Fatalf("unable to create a server: %v", err)
   132  	}
   133  	defer gs.Close()
   134  
   135  	repoName, err := gs.AddRepository(tmpPath)
   136  	if err != nil {
   137  		t.Fatalf("unable to add a repository: %v", err)
   138  	}
   139  	repoName2, err := gs.AddRepository(tmpPath)
   140  	if err != nil {
   141  		t.Fatalf("unable to add a repository: %v", err)
   142  	}
   143  
   144  	if repoName != repoName2 {
   145  		t.Fatalf("%s should be the same as %s", repoName, repoName2)
   146  	}
   147  }
   148  
   149  func TestServer_AddPath(t *testing.T) {
   150  	// Not parallel: uses global test hook.
   151  	defer func() { testHookServerServe = nil }()
   152  
   153  	gs, err := New()
   154  	if err != nil {
   155  		t.Fatalf("unable to create a server: %v", err)
   156  	}
   157  	defer gs.Close()
   158  
   159  	lnc := make(chan net.Listener)
   160  	testHookServerServe = func(gs *Server, ln net.Listener) {
   161  		lnc <- ln
   162  	}
   163  
   164  	go gs.ListenAndServe("127.0.0.1:0") //nolint:errcheck
   165  
   166  	ln := <-lnc
   167  
   168  	repoName, err := gs.AddPath("testdata/dir")
   169  	if err != nil {
   170  		t.Fatalf("unable to add a repository: %v", err)
   171  	}
   172  
   173  	repoPath, err := gittest.CloneTemp(fmt.Sprintf("http://%v/%s", ln.Addr(), repoName))
   174  	if err != nil {
   175  		t.Fatalf("unable to clone the repo %s: %v", repoName, err)
   176  	}
   177  	defer os.RemoveAll(repoPath)
   178  
   179  	if _, err := os.Stat(filepath.Join(repoPath, "foo.txt")); err != nil {
   180  		t.Fatalf("unexpected error: %v", err)
   181  	}
   182  }
   183  
   184  func TestServer_AddPath_file(t *testing.T) {
   185  	// Not parallel: uses global test hook.
   186  	defer func() { testHookServerServe = nil }()
   187  
   188  	gs, err := New()
   189  	if err != nil {
   190  		t.Fatalf("unable to create a server: %v", err)
   191  	}
   192  	defer gs.Close()
   193  
   194  	lnc := make(chan net.Listener)
   195  	testHookServerServe = func(gs *Server, ln net.Listener) {
   196  		lnc <- ln
   197  	}
   198  
   199  	go gs.ListenAndServe("127.0.0.1:0") //nolint:errcheck
   200  
   201  	ln := <-lnc
   202  
   203  	repoName, err := gs.AddPath("testdata/dir/foo.txt")
   204  	if err != nil {
   205  		t.Fatalf("unable to add a repository: %v", err)
   206  	}
   207  
   208  	repoPath, err := gittest.CloneTemp(fmt.Sprintf("http://%v/%s", ln.Addr(), repoName))
   209  	if err != nil {
   210  		t.Fatalf("unable to clone the repo %s: %v", repoName, err)
   211  	}
   212  	defer os.RemoveAll(repoPath)
   213  
   214  	if _, err := os.Stat(filepath.Join(repoPath, "foo.txt")); err != nil {
   215  		t.Fatalf("unexpected error: %v", err)
   216  	}
   217  }
   218  
   219  func TestServer_AddPath_repo(t *testing.T) {
   220  	// Not parallel: uses global test hook.
   221  	defer func() { testHookServerServe = nil }()
   222  
   223  	tmpPath, err := gittest.ExtractTemp(filepath.Join("testdata", "testrepo.tar"))
   224  	if err != nil {
   225  		t.Fatalf("unable to create a repository: %v", err)
   226  	}
   227  	defer os.RemoveAll(tmpPath)
   228  
   229  	gs, err := New()
   230  	if err != nil {
   231  		t.Fatalf("unable to create a server: %v", err)
   232  	}
   233  	defer gs.Close()
   234  
   235  	lnc := make(chan net.Listener)
   236  	testHookServerServe = func(gs *Server, ln net.Listener) {
   237  		lnc <- ln
   238  	}
   239  
   240  	go gs.ListenAndServe("127.0.0.1:0") //nolint:errcheck
   241  
   242  	ln := <-lnc
   243  
   244  	repoName, err := gs.AddPath(tmpPath)
   245  	if err != nil {
   246  		t.Fatalf("unable to add a repository: %v", err)
   247  	}
   248  
   249  	repoPath, err := gittest.CloneTemp(fmt.Sprintf("http://%v/%s", ln.Addr(), repoName))
   250  	if err != nil {
   251  		t.Fatalf("unable to clone the repo %s: %v", repoName, err)
   252  	}
   253  	defer os.RemoveAll(repoPath)
   254  
   255  	if _, err := os.Stat(filepath.Join(repoPath, "foo.txt")); err != nil {
   256  		t.Fatalf("unexpected error: %v", err)
   257  	}
   258  }
   259  
   260  func TestServer_AddPath_invalid_path(t *testing.T) {
   261  	gs, err := New()
   262  	if err != nil {
   263  		t.Fatalf("unable to create a server: %v", err)
   264  	}
   265  	defer gs.Close() //nolint:staticcheck
   266  
   267  	if _, err = gs.AddPath("/fakedir"); err == nil {
   268  		t.Fatal("expected error adding path")
   269  	}
   270  }
   271  
   272  func TestServer_AddPath_do_not_cache_error(t *testing.T) {
   273  	gs, err := New()
   274  	if err != nil {
   275  		t.Fatalf("unable to create a server: %v", err)
   276  	}
   277  	defer gs.Close() //nolint:staticcheck
   278  
   279  	if _, err = gs.AddPath("/fakedir"); err == nil {
   280  		t.Fatal("expected error adding path")
   281  	}
   282  
   283  	if _, err = gs.AddPath("/fakedir"); err == nil {
   284  		t.Fatal("expected error adding path")
   285  	}
   286  }
   287  
   288  func TestServer_AddPath_already_added(t *testing.T) {
   289  	gs, err := New()
   290  	if err != nil {
   291  		t.Fatalf("unable to create a server: %v", err)
   292  	}
   293  	defer gs.Close()
   294  
   295  	repoName, err := gs.AddPath("testdata/dir")
   296  	if err != nil {
   297  		t.Fatalf("unable to add a repository: %v", err)
   298  	}
   299  
   300  	repoName2, err := gs.AddPath("testdata/dir")
   301  	if err != nil {
   302  		t.Fatalf("unable to add a repository: %v", err)
   303  	}
   304  
   305  	if repoName != repoName2 {
   306  		t.Fatalf("%s should be the same as %s", repoName, repoName2)
   307  	}
   308  }