gopkg.in/tools/godep.v39@v39.0.0-20151216234527-2721f686f09e/update_test.go (about)

     1  package main
     2  
     3  import (
     4  	"encoding/json"
     5  	"io/ioutil"
     6  	"log"
     7  	"os"
     8  	"path/filepath"
     9  	"reflect"
    10  	"testing"
    11  )
    12  
    13  func TestUpdate(t *testing.T) {
    14  	var cases = []struct {
    15  		cwd   string
    16  		args  []string
    17  		start []*node
    18  		want  []*node
    19  		wdep  Godeps
    20  		werr  bool
    21  	}{
    22  		{ // simple case, update one dependency
    23  			cwd:  "C",
    24  			args: []string{"D"},
    25  			start: []*node{
    26  				{
    27  					"D",
    28  					"",
    29  					[]*node{
    30  						{"main.go", pkg("D") + decl("D1"), nil},
    31  						{"+git", "D1", nil},
    32  						{"main.go", pkg("D") + decl("D2"), nil},
    33  						{"+git", "D2", nil},
    34  					},
    35  				},
    36  				{
    37  					"C",
    38  					"",
    39  					[]*node{
    40  						{"main.go", pkg("main", "D"), nil},
    41  						{"Godeps/Godeps.json", godeps("C", "D", "D1"), nil},
    42  						{"Godeps/_workspace/src/D/main.go", pkg("D") + decl("D1"), nil},
    43  						{"+git", "", nil},
    44  					},
    45  				},
    46  			},
    47  			want: []*node{
    48  				{"C/Godeps/_workspace/src/D/main.go", pkg("D") + decl("D2"), nil},
    49  			},
    50  			wdep: Godeps{
    51  				ImportPath: "C",
    52  				Deps: []Dependency{
    53  					{ImportPath: "D", Comment: "D2"},
    54  				},
    55  			},
    56  		},
    57  		{ // simple case, update one dependency, trailing slash
    58  			cwd:  "C",
    59  			args: []string{"D/"},
    60  			start: []*node{
    61  				{
    62  					"D",
    63  					"",
    64  					[]*node{
    65  						{"main.go", pkg("D") + decl("D1"), nil},
    66  						{"+git", "D1", nil},
    67  						{"main.go", pkg("D") + decl("D2"), nil},
    68  						{"+git", "D2", nil},
    69  					},
    70  				},
    71  				{
    72  					"C",
    73  					"",
    74  					[]*node{
    75  						{"main.go", pkg("main", "D"), nil},
    76  						{"Godeps/Godeps.json", godeps("C", "D", "D1"), nil},
    77  						{"Godeps/_workspace/src/D/main.go", pkg("D") + decl("D1"), nil},
    78  						{"+git", "", nil},
    79  					},
    80  				},
    81  			},
    82  			want: []*node{
    83  				{"C/Godeps/_workspace/src/D/main.go", pkg("D") + decl("D2"), nil},
    84  			},
    85  			wdep: Godeps{
    86  				ImportPath: "C",
    87  				Deps: []Dependency{
    88  					{ImportPath: "D", Comment: "D2"},
    89  				},
    90  			},
    91  		},
    92  		{ // update one dependency, keep other one, no rewrite
    93  			cwd:  "C",
    94  			args: []string{"D"},
    95  			start: []*node{
    96  				{
    97  					"D",
    98  					"",
    99  					[]*node{
   100  						{"main.go", pkg("D", "E") + decl("D1"), nil},
   101  						{"+git", "D1", nil},
   102  						{"main.go", pkg("D", "E") + decl("D2"), nil},
   103  						{"+git", "D2", nil},
   104  					},
   105  				},
   106  				{
   107  					"E",
   108  					"",
   109  					[]*node{
   110  						{"main.go", pkg("E") + decl("E1"), nil},
   111  						{"+git", "E1", nil},
   112  						{"main.go", pkg("E") + decl("E2"), nil},
   113  						{"+git", "E2", nil},
   114  					},
   115  				},
   116  				{
   117  					"C",
   118  					"",
   119  					[]*node{
   120  						{"main.go", pkg("main", "D", "E"), nil},
   121  						{"Godeps/Godeps.json", godeps("C", "D", "D1", "E", "E1"), nil},
   122  						{"Godeps/_workspace/src/D/main.go", pkg("D", "E") + decl("D1"), nil},
   123  						{"Godeps/_workspace/src/E/main.go", pkg("E") + decl("E1"), nil},
   124  						{"+git", "", nil},
   125  					},
   126  				},
   127  			},
   128  			want: []*node{
   129  				{"C/Godeps/_workspace/src/D/main.go", pkg("D", "E") + decl("D2"), nil},
   130  				{"C/Godeps/_workspace/src/E/main.go", pkg("E") + decl("E1"), nil},
   131  			},
   132  			wdep: Godeps{
   133  				ImportPath: "C",
   134  				Deps: []Dependency{
   135  					{ImportPath: "D", Comment: "D2"},
   136  					{ImportPath: "E", Comment: "E1"},
   137  				},
   138  			},
   139  		},
   140  		{ // update one dependency, keep other one, with rewrite
   141  			cwd:  "C",
   142  			args: []string{"D"},
   143  			start: []*node{
   144  				{
   145  					"D",
   146  					"",
   147  					[]*node{
   148  						{"main.go", pkg("D", "E") + decl("D1"), nil},
   149  						{"+git", "D1", nil},
   150  						{"main.go", pkg("D", "E") + decl("D2"), nil},
   151  						{"+git", "D2", nil},
   152  					},
   153  				},
   154  				{
   155  					"E",
   156  					"",
   157  					[]*node{
   158  						{"main.go", pkg("E") + decl("E1"), nil},
   159  						{"+git", "E1", nil},
   160  						{"main.go", pkg("E") + decl("E2"), nil},
   161  						{"+git", "E2", nil},
   162  					},
   163  				},
   164  				{
   165  					"C",
   166  					"",
   167  					[]*node{
   168  						{"main.go", pkg("main", "C/Godeps/_workspace/src/D", "C/Godeps/_workspace/src/E"), nil},
   169  						{"Godeps/Godeps.json", godeps("C", "D", "D1", "E", "E1"), nil},
   170  						{"Godeps/_workspace/src/D/main.go", pkg("D", "C/Godeps/_workspace/src/E") + decl("D1"), nil},
   171  						{"Godeps/_workspace/src/E/main.go", pkg("E") + decl("E1"), nil},
   172  						{"+git", "", nil},
   173  					},
   174  				},
   175  			},
   176  			want: []*node{
   177  				{"C/main.go", pkg("main", "C/Godeps/_workspace/src/D", "C/Godeps/_workspace/src/E"), nil},
   178  				{"C/Godeps/_workspace/src/D/main.go", pkg("D", "C/Godeps/_workspace/src/E") + "\n" + decl("D2"), nil},
   179  				{"C/Godeps/_workspace/src/E/main.go", pkg("E") + decl("E1"), nil},
   180  			},
   181  			wdep: Godeps{
   182  				ImportPath: "C",
   183  				Deps: []Dependency{
   184  					{ImportPath: "D", Comment: "D2"},
   185  					{ImportPath: "E", Comment: "E1"},
   186  				},
   187  			},
   188  		},
   189  		{ // update all dependencies
   190  			cwd:  "C",
   191  			args: []string{"..."},
   192  			start: []*node{
   193  				{
   194  					"D",
   195  					"",
   196  					[]*node{
   197  						{"main.go", pkg("D") + decl("D1"), nil},
   198  						{"+git", "D1", nil},
   199  						{"main.go", pkg("D") + decl("D2"), nil},
   200  						{"+git", "D2", nil},
   201  					},
   202  				},
   203  				{
   204  					"E",
   205  					"",
   206  					[]*node{
   207  						{"main.go", pkg("E") + decl("E1"), nil},
   208  						{"+git", "E1", nil},
   209  						{"main.go", pkg("E") + decl("E2"), nil},
   210  						{"+git", "E2", nil},
   211  					},
   212  				},
   213  				{
   214  					"C",
   215  					"",
   216  					[]*node{
   217  						{"main.go", pkg("main", "D", "E"), nil},
   218  						{"Godeps/Godeps.json", godeps("C", "D", "D1", "E", "E1"), nil},
   219  						{"Godeps/_workspace/src/D/main.go", pkg("D") + decl("D1"), nil},
   220  						{"Godeps/_workspace/src/E/main.go", pkg("E") + decl("E1"), nil},
   221  						{"+git", "", nil},
   222  					},
   223  				},
   224  			},
   225  			want: []*node{
   226  				{"C/Godeps/_workspace/src/D/main.go", pkg("D") + decl("D2"), nil},
   227  				{"C/Godeps/_workspace/src/E/main.go", pkg("E") + decl("E2"), nil},
   228  			},
   229  			wdep: Godeps{
   230  				ImportPath: "C",
   231  				Deps: []Dependency{
   232  					{ImportPath: "D", Comment: "D2"},
   233  					{ImportPath: "E", Comment: "E2"},
   234  				},
   235  			},
   236  		},
   237  		{ // one match of two patterns
   238  			cwd:  "C",
   239  			args: []string{"D", "X"},
   240  			start: []*node{
   241  				{
   242  					"D",
   243  					"",
   244  					[]*node{
   245  						{"main.go", pkg("D") + decl("D1"), nil},
   246  						{"+git", "D1", nil},
   247  						{"main.go", pkg("D") + decl("D2"), nil},
   248  						{"+git", "D2", nil},
   249  					},
   250  				},
   251  				{
   252  					"C",
   253  					"",
   254  					[]*node{
   255  						{"main.go", pkg("main", "D"), nil},
   256  						{"Godeps/Godeps.json", godeps("C", "D", "D1"), nil},
   257  						{"Godeps/_workspace/src/D/main.go", pkg("D") + decl("D1"), nil},
   258  						{"+git", "", nil},
   259  					},
   260  				},
   261  			},
   262  			want: []*node{
   263  				{"C/Godeps/_workspace/src/D/main.go", pkg("D") + decl("D2"), nil},
   264  			},
   265  			wdep: Godeps{
   266  				ImportPath: "C",
   267  				Deps: []Dependency{
   268  					{ImportPath: "D", Comment: "D2"},
   269  				},
   270  			},
   271  		},
   272  		{ // no matches
   273  			cwd:  "C",
   274  			args: []string{"X"},
   275  			start: []*node{
   276  				{
   277  					"D",
   278  					"",
   279  					[]*node{
   280  						{"main.go", pkg("D") + decl("D1"), nil},
   281  						{"+git", "D1", nil},
   282  						{"main.go", pkg("D") + decl("D2"), nil},
   283  						{"+git", "D2", nil},
   284  					},
   285  				},
   286  				{
   287  					"C",
   288  					"",
   289  					[]*node{
   290  						{"main.go", pkg("main", "D"), nil},
   291  						{"Godeps/Godeps.json", godeps("C", "D", "D1"), nil},
   292  						{"Godeps/_workspace/src/D/main.go", pkg("D") + decl("D1"), nil},
   293  						{"+git", "", nil},
   294  					},
   295  				},
   296  			},
   297  			want: []*node{
   298  				{"C/Godeps/_workspace/src/D/main.go", pkg("D") + decl("D1"), nil},
   299  			},
   300  			wdep: Godeps{
   301  				ImportPath: "C",
   302  				Deps: []Dependency{
   303  					{ImportPath: "D", Comment: "D1"},
   304  				},
   305  			},
   306  			werr: true,
   307  		},
   308  		{ // update just one package of two in a repo skips it
   309  			cwd:  "C",
   310  			args: []string{"D/A", "E"},
   311  			start: []*node{
   312  				{
   313  					"D",
   314  					"",
   315  					[]*node{
   316  						{"A/main.go", pkg("A") + decl("D1"), nil},
   317  						{"B/main.go", pkg("B") + decl("D1"), nil},
   318  						{"+git", "D1", nil},
   319  						{"A/main.go", pkg("A") + decl("D2"), nil},
   320  						{"B/main.go", pkg("B") + decl("D2"), nil},
   321  						{"+git", "D2", nil},
   322  					},
   323  				},
   324  				{
   325  					"E",
   326  					"",
   327  					[]*node{
   328  						{"main.go", pkg("E") + decl("E1"), nil},
   329  						{"+git", "E1", nil},
   330  						{"main.go", pkg("E") + decl("E2"), nil},
   331  						{"+git", "E2", nil},
   332  					},
   333  				},
   334  				{
   335  					"C",
   336  					"",
   337  					[]*node{
   338  						{"main.go", pkg("main", "D/A", "D/B", "E"), nil},
   339  						{"Godeps/Godeps.json", godeps("C", "D/A", "D1", "D/B", "D1", "E", "E1"), nil},
   340  						{"Godeps/_workspace/src/D/A/main.go", pkg("A") + decl("D1"), nil},
   341  						{"Godeps/_workspace/src/D/B/main.go", pkg("B") + decl("D1"), nil},
   342  						{"Godeps/_workspace/src/E/main.go", pkg("E") + decl("E1"), nil},
   343  						{"+git", "", nil},
   344  					},
   345  				},
   346  			},
   347  			want: []*node{
   348  				{"C/Godeps/_workspace/src/D/A/main.go", pkg("A") + decl("D1"), nil},
   349  				{"C/Godeps/_workspace/src/D/B/main.go", pkg("B") + decl("D1"), nil},
   350  				{"C/Godeps/_workspace/src/E/main.go", pkg("E") + decl("E2"), nil},
   351  			},
   352  			wdep: Godeps{
   353  				ImportPath: "C",
   354  				Deps: []Dependency{
   355  					{ImportPath: "D/A", Comment: "D1"},
   356  					{ImportPath: "D/B", Comment: "D1"},
   357  					{ImportPath: "E", Comment: "E2"},
   358  				},
   359  			},
   360  		},
   361  		{ // update just one package of two in a repo, none left
   362  			cwd:  "C",
   363  			args: []string{"D/A"},
   364  			start: []*node{
   365  				{
   366  					"D",
   367  					"",
   368  					[]*node{
   369  						{"A/main.go", pkg("A") + decl("D1"), nil},
   370  						{"B/main.go", pkg("B") + decl("D1"), nil},
   371  						{"+git", "D1", nil},
   372  						{"A/main.go", pkg("A") + decl("D2"), nil},
   373  						{"B/main.go", pkg("B") + decl("D2"), nil},
   374  						{"+git", "D2", nil},
   375  					},
   376  				},
   377  				{
   378  					"C",
   379  					"",
   380  					[]*node{
   381  						{"main.go", pkg("main", "D/A", "D/B"), nil},
   382  						{"Godeps/Godeps.json", godeps("C", "D/A", "D1", "D/B", "D1"), nil},
   383  						{"Godeps/_workspace/src/D/A/main.go", pkg("A") + decl("D1"), nil},
   384  						{"Godeps/_workspace/src/D/B/main.go", pkg("B") + decl("D1"), nil},
   385  						{"+git", "", nil},
   386  					},
   387  				},
   388  			},
   389  			want: []*node{
   390  				{"C/Godeps/_workspace/src/D/A/main.go", pkg("A") + decl("D1"), nil},
   391  				{"C/Godeps/_workspace/src/D/B/main.go", pkg("B") + decl("D1"), nil},
   392  			},
   393  			wdep: Godeps{
   394  				ImportPath: "C",
   395  				Deps: []Dependency{
   396  					{ImportPath: "D/A", Comment: "D1"},
   397  					{ImportPath: "D/B", Comment: "D1"},
   398  				},
   399  			},
   400  			werr: true,
   401  		},
   402  	}
   403  
   404  	wd, err := os.Getwd()
   405  	if err != nil {
   406  		t.Fatal(err)
   407  	}
   408  	const gopath = "godeptest"
   409  	defer os.RemoveAll(gopath)
   410  	for pos, test := range cases {
   411  		clearPkgCache()
   412  		err = os.RemoveAll(gopath)
   413  		if err != nil {
   414  			t.Fatal(err)
   415  		}
   416  		src := filepath.Join(gopath, "src")
   417  		makeTree(t, &node{src, "", test.start}, "")
   418  
   419  		dir := filepath.Join(wd, src, test.cwd)
   420  		err = os.Chdir(dir)
   421  		if err != nil {
   422  			panic(err)
   423  		}
   424  		setGOPATH(filepath.Join(wd, gopath))
   425  		log.SetOutput(ioutil.Discard)
   426  		err = update(test.args)
   427  		log.SetOutput(os.Stderr)
   428  		if g := err != nil; g != test.werr {
   429  			t.Errorf("update err = %v (%v) want %v", g, err, test.werr)
   430  		}
   431  		err = os.Chdir(wd)
   432  		if err != nil {
   433  			panic(err)
   434  		}
   435  
   436  		checkTree(t, pos, &node{src, "", test.want})
   437  
   438  		f, err := os.Open(filepath.Join(dir, "Godeps/Godeps.json"))
   439  		if err != nil {
   440  			t.Error(err)
   441  		}
   442  		g := new(Godeps)
   443  		err = json.NewDecoder(f).Decode(g)
   444  		if err != nil {
   445  			t.Error(err)
   446  		}
   447  		f.Close()
   448  
   449  		if g.ImportPath != test.wdep.ImportPath {
   450  			t.Errorf("ImportPath = %s want %s", g.ImportPath, test.wdep.ImportPath)
   451  		}
   452  		for i := range g.Deps {
   453  			g.Deps[i].Rev = ""
   454  		}
   455  		if !reflect.DeepEqual(g.Deps, test.wdep.Deps) {
   456  			t.Errorf("Deps = %v want %v", g.Deps, test.wdep.Deps)
   457  		}
   458  	}
   459  }