github.com/suzuken/ghq@v0.7.5-0.20160607064937-214ded0f64ec/vcs_test.go (about)

     1  package main
     2  
     3  import (
     4  	"io/ioutil"
     5  	"net/url"
     6  	"os/exec"
     7  	"path/filepath"
     8  	"testing"
     9  
    10  	"github.com/motemen/ghq/utils"
    11  	. "github.com/onsi/gomega"
    12  )
    13  
    14  func TestGitBackend(t *testing.T) {
    15  	RegisterTestingT(t)
    16  
    17  	tempDir, err := ioutil.TempDir("", "ghq-test")
    18  	if err != nil {
    19  		t.Fatal(err)
    20  	}
    21  
    22  	localDir := filepath.Join(tempDir, "repo")
    23  
    24  	remoteURL, err := url.Parse("https://example.com/git/repo")
    25  	if err != nil {
    26  		t.Fatal(err)
    27  	}
    28  
    29  	commands := []*exec.Cmd{}
    30  	lastCommand := func() *exec.Cmd { return commands[len(commands)-1] }
    31  	utils.CommandRunner = func(cmd *exec.Cmd) error {
    32  		commands = append(commands, cmd)
    33  		return nil
    34  	}
    35  
    36  	err = GitBackend.Clone(remoteURL, localDir, false)
    37  
    38  	Expect(err).NotTo(HaveOccurred())
    39  	Expect(commands).To(HaveLen(1))
    40  	Expect(lastCommand().Args).To(Equal([]string{
    41  		"git", "clone", remoteURL.String(), localDir,
    42  	}))
    43  
    44  	err = GitBackend.Clone(remoteURL, localDir, true)
    45  
    46  	Expect(err).NotTo(HaveOccurred())
    47  	Expect(commands).To(HaveLen(2))
    48  	Expect(lastCommand().Args).To(Equal([]string{
    49  		"git", "clone", "--depth", "1", remoteURL.String(), localDir,
    50  	}))
    51  
    52  	err = GitBackend.Update(localDir)
    53  
    54  	Expect(err).NotTo(HaveOccurred())
    55  	Expect(commands).To(HaveLen(3))
    56  	Expect(lastCommand().Args).To(Equal([]string{
    57  		"git", "pull", "--ff-only",
    58  	}))
    59  	Expect(lastCommand().Dir).To(Equal(localDir))
    60  }
    61  
    62  func TestSubversionBackend(t *testing.T) {
    63  	RegisterTestingT(t)
    64  
    65  	tempDir, err := ioutil.TempDir("", "ghq-test")
    66  	if err != nil {
    67  		t.Fatal(err)
    68  	}
    69  
    70  	localDir := filepath.Join(tempDir, "repo")
    71  
    72  	remoteURL, err := url.Parse("https://example.com/git/repo")
    73  	if err != nil {
    74  		t.Fatal(err)
    75  	}
    76  
    77  	commands := []*exec.Cmd{}
    78  	lastCommand := func() *exec.Cmd { return commands[len(commands)-1] }
    79  	utils.CommandRunner = func(cmd *exec.Cmd) error {
    80  		commands = append(commands, cmd)
    81  		return nil
    82  	}
    83  
    84  	err = SubversionBackend.Clone(remoteURL, localDir, false)
    85  
    86  	Expect(err).NotTo(HaveOccurred())
    87  	Expect(commands).To(HaveLen(1))
    88  	Expect(lastCommand().Args).To(Equal([]string{
    89  		"svn", "checkout", remoteURL.String(), localDir,
    90  	}))
    91  
    92  	err = SubversionBackend.Clone(remoteURL, localDir, true)
    93  
    94  	Expect(err).NotTo(HaveOccurred())
    95  	Expect(commands).To(HaveLen(2))
    96  	Expect(lastCommand().Args).To(Equal([]string{
    97  		"svn", "checkout", "--depth", "1", remoteURL.String(), localDir,
    98  	}))
    99  
   100  	err = SubversionBackend.Update(localDir)
   101  
   102  	Expect(err).NotTo(HaveOccurred())
   103  	Expect(commands).To(HaveLen(3))
   104  	Expect(lastCommand().Args).To(Equal([]string{
   105  		"svn", "update",
   106  	}))
   107  	Expect(lastCommand().Dir).To(Equal(localDir))
   108  }
   109  
   110  func TestGitsvnBackend(t *testing.T) {
   111  	RegisterTestingT(t)
   112  
   113  	tempDir, err := ioutil.TempDir("", "ghq-test")
   114  	if err != nil {
   115  		t.Fatal(err)
   116  	}
   117  
   118  	localDir := filepath.Join(tempDir, "repo")
   119  
   120  	remoteURL, err := url.Parse("https://example.com/git/repo")
   121  	if err != nil {
   122  		t.Fatal(err)
   123  	}
   124  
   125  	commands := []*exec.Cmd{}
   126  	lastCommand := func() *exec.Cmd { return commands[len(commands)-1] }
   127  	utils.CommandRunner = func(cmd *exec.Cmd) error {
   128  		commands = append(commands, cmd)
   129  		return nil
   130  	}
   131  
   132  	err = GitsvnBackend.Clone(remoteURL, localDir, false)
   133  
   134  	Expect(err).NotTo(HaveOccurred())
   135  	Expect(commands).To(HaveLen(1))
   136  	Expect(lastCommand().Args).To(Equal([]string{
   137  		"git", "svn", "clone", remoteURL.String(), localDir,
   138  	}))
   139  
   140  	err = GitsvnBackend.Clone(remoteURL, localDir, true)
   141  
   142  	Expect(err).NotTo(HaveOccurred())
   143  	Expect(commands).To(HaveLen(2))
   144  	Expect(lastCommand().Args).To(Equal([]string{
   145  		"git", "svn", "clone", remoteURL.String(), localDir,
   146  	}))
   147  	err = GitsvnBackend.Update(localDir)
   148  
   149  	Expect(err).NotTo(HaveOccurred())
   150  	Expect(commands).To(HaveLen(3))
   151  	Expect(lastCommand().Args).To(Equal([]string{
   152  		"git", "svn", "rebase",
   153  	}))
   154  	Expect(lastCommand().Dir).To(Equal(localDir))
   155  }
   156  
   157  func TestMercurialBackend(t *testing.T) {
   158  	RegisterTestingT(t)
   159  
   160  	tempDir, err := ioutil.TempDir("", "ghq-test")
   161  	if err != nil {
   162  		t.Fatal(err)
   163  	}
   164  
   165  	localDir := filepath.Join(tempDir, "repo")
   166  
   167  	remoteURL, err := url.Parse("https://example.com/git/repo")
   168  	if err != nil {
   169  		t.Fatal(err)
   170  	}
   171  
   172  	commands := []*exec.Cmd{}
   173  	lastCommand := func() *exec.Cmd { return commands[len(commands)-1] }
   174  	utils.CommandRunner = func(cmd *exec.Cmd) error {
   175  		commands = append(commands, cmd)
   176  		return nil
   177  	}
   178  
   179  	err = MercurialBackend.Clone(remoteURL, localDir, false)
   180  
   181  	Expect(err).NotTo(HaveOccurred())
   182  	Expect(commands).To(HaveLen(1))
   183  	Expect(lastCommand().Args).To(Equal([]string{
   184  		"hg", "clone", remoteURL.String(), localDir,
   185  	}))
   186  
   187  	err = MercurialBackend.Clone(remoteURL, localDir, true)
   188  
   189  	Expect(err).NotTo(HaveOccurred())
   190  	Expect(commands).To(HaveLen(2))
   191  	Expect(lastCommand().Args).To(Equal([]string{
   192  		"hg", "clone", remoteURL.String(), localDir,
   193  	}))
   194  	err = MercurialBackend.Update(localDir)
   195  
   196  	Expect(err).NotTo(HaveOccurred())
   197  	Expect(commands).To(HaveLen(3))
   198  	Expect(lastCommand().Args).To(Equal([]string{
   199  		"hg", "pull", "--update",
   200  	}))
   201  	Expect(lastCommand().Dir).To(Equal(localDir))
   202  }
   203  
   204  func TestDarcsBackend(t *testing.T) {
   205  	RegisterTestingT(t)
   206  
   207  	tempDir, err := ioutil.TempDir("", "ghq-test")
   208  	if err != nil {
   209  		t.Fatal(err)
   210  	}
   211  
   212  	localDir := filepath.Join(tempDir, "repo")
   213  
   214  	remoteURL, err := url.Parse("https://example.com/git/repo")
   215  	if err != nil {
   216  		t.Fatal(err)
   217  	}
   218  
   219  	commands := []*exec.Cmd{}
   220  	lastCommand := func() *exec.Cmd { return commands[len(commands)-1] }
   221  	utils.CommandRunner = func(cmd *exec.Cmd) error {
   222  		commands = append(commands, cmd)
   223  		return nil
   224  	}
   225  
   226  	err = DarcsBackend.Clone(remoteURL, localDir, false)
   227  
   228  	Expect(err).NotTo(HaveOccurred())
   229  	Expect(commands).To(HaveLen(1))
   230  	Expect(lastCommand().Args).To(Equal([]string{
   231  		"darcs", "get", remoteURL.String(), localDir,
   232  	}))
   233  
   234  	err = DarcsBackend.Clone(remoteURL, localDir, true)
   235  
   236  	Expect(err).NotTo(HaveOccurred())
   237  	Expect(commands).To(HaveLen(2))
   238  	Expect(lastCommand().Args).To(Equal([]string{
   239  		"darcs", "get", "--lazy", remoteURL.String(), localDir,
   240  	}))
   241  
   242  	err = DarcsBackend.Update(localDir)
   243  
   244  	Expect(err).NotTo(HaveOccurred())
   245  	Expect(commands).To(HaveLen(3))
   246  	Expect(lastCommand().Args).To(Equal([]string{
   247  		"darcs", "pull",
   248  	}))
   249  }