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