gopkg.in/zumata/godep.v14@v14.0.0-20151008182512-99082d62f381/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  		{ // update one dependency, keep other one, no rewrite
    58  			cwd:  "C",
    59  			args: []string{"D"},
    60  			start: []*node{
    61  				{
    62  					"D",
    63  					"",
    64  					[]*node{
    65  						{"main.go", pkg("D", "E") + decl("D1"), nil},
    66  						{"+git", "D1", nil},
    67  						{"main.go", pkg("D", "E") + decl("D2"), nil},
    68  						{"+git", "D2", nil},
    69  					},
    70  				},
    71  				{
    72  					"E",
    73  					"",
    74  					[]*node{
    75  						{"main.go", pkg("E") + decl("E1"), nil},
    76  						{"+git", "E1", nil},
    77  						{"main.go", pkg("E") + decl("E2"), nil},
    78  						{"+git", "E2", nil},
    79  					},
    80  				},
    81  				{
    82  					"C",
    83  					"",
    84  					[]*node{
    85  						{"main.go", pkg("main", "D", "E"), nil},
    86  						{"Godeps/Godeps.json", godeps("C", "D", "D1", "E", "E1"), nil},
    87  						{"Godeps/_workspace/src/D/main.go", pkg("D", "E") + decl("D1"), nil},
    88  						{"Godeps/_workspace/src/E/main.go", pkg("E") + decl("E1"), nil},
    89  						{"+git", "", nil},
    90  					},
    91  				},
    92  			},
    93  			want: []*node{
    94  				{"C/Godeps/_workspace/src/D/main.go", pkg("D", "E") + decl("D2"), nil},
    95  				{"C/Godeps/_workspace/src/E/main.go", pkg("E") + decl("E1"), nil},
    96  			},
    97  			wdep: Godeps{
    98  				ImportPath: "C",
    99  				Deps: []Dependency{
   100  					{ImportPath: "D", Comment: "D2"},
   101  					{ImportPath: "E", Comment: "E1"},
   102  				},
   103  			},
   104  		},
   105  		{ // update one dependency, keep other one, with rewrite
   106  			cwd:  "C",
   107  			args: []string{"D"},
   108  			start: []*node{
   109  				{
   110  					"D",
   111  					"",
   112  					[]*node{
   113  						{"main.go", pkg("D", "E") + decl("D1"), nil},
   114  						{"+git", "D1", nil},
   115  						{"main.go", pkg("D", "E") + decl("D2"), nil},
   116  						{"+git", "D2", nil},
   117  					},
   118  				},
   119  				{
   120  					"E",
   121  					"",
   122  					[]*node{
   123  						{"main.go", pkg("E") + decl("E1"), nil},
   124  						{"+git", "E1", nil},
   125  						{"main.go", pkg("E") + decl("E2"), nil},
   126  						{"+git", "E2", nil},
   127  					},
   128  				},
   129  				{
   130  					"C",
   131  					"",
   132  					[]*node{
   133  						{"main.go", pkg("main", "C/Godeps/_workspace/src/D", "C/Godeps/_workspace/src/E"), nil},
   134  						{"Godeps/Godeps.json", godeps("C", "D", "D1", "E", "E1"), nil},
   135  						{"Godeps/_workspace/src/D/main.go", pkg("D", "C/Godeps/_workspace/src/E") + decl("D1"), nil},
   136  						{"Godeps/_workspace/src/E/main.go", pkg("E") + decl("E1"), nil},
   137  						{"+git", "", nil},
   138  					},
   139  				},
   140  			},
   141  			want: []*node{
   142  				{"C/main.go", pkg("main", "C/Godeps/_workspace/src/D", "C/Godeps/_workspace/src/E"), nil},
   143  				{"C/Godeps/_workspace/src/D/main.go", pkg("D", "C/Godeps/_workspace/src/E") + "\n" + decl("D2"), nil},
   144  				{"C/Godeps/_workspace/src/E/main.go", pkg("E") + decl("E1"), nil},
   145  			},
   146  			wdep: Godeps{
   147  				ImportPath: "C",
   148  				Deps: []Dependency{
   149  					{ImportPath: "D", Comment: "D2"},
   150  					{ImportPath: "E", Comment: "E1"},
   151  				},
   152  			},
   153  		},
   154  		{ // update all dependencies
   155  			cwd:  "C",
   156  			args: []string{"..."},
   157  			start: []*node{
   158  				{
   159  					"D",
   160  					"",
   161  					[]*node{
   162  						{"main.go", pkg("D") + decl("D1"), nil},
   163  						{"+git", "D1", nil},
   164  						{"main.go", pkg("D") + decl("D2"), nil},
   165  						{"+git", "D2", nil},
   166  					},
   167  				},
   168  				{
   169  					"E",
   170  					"",
   171  					[]*node{
   172  						{"main.go", pkg("E") + decl("E1"), nil},
   173  						{"+git", "E1", nil},
   174  						{"main.go", pkg("E") + decl("E2"), nil},
   175  						{"+git", "E2", nil},
   176  					},
   177  				},
   178  				{
   179  					"C",
   180  					"",
   181  					[]*node{
   182  						{"main.go", pkg("main", "D", "E"), nil},
   183  						{"Godeps/Godeps.json", godeps("C", "D", "D1", "E", "E1"), nil},
   184  						{"Godeps/_workspace/src/D/main.go", pkg("D") + decl("D1"), nil},
   185  						{"Godeps/_workspace/src/E/main.go", pkg("E") + decl("E1"), nil},
   186  						{"+git", "", nil},
   187  					},
   188  				},
   189  			},
   190  			want: []*node{
   191  				{"C/Godeps/_workspace/src/D/main.go", pkg("D") + decl("D2"), nil},
   192  				{"C/Godeps/_workspace/src/E/main.go", pkg("E") + decl("E2"), nil},
   193  			},
   194  			wdep: Godeps{
   195  				ImportPath: "C",
   196  				Deps: []Dependency{
   197  					{ImportPath: "D", Comment: "D2"},
   198  					{ImportPath: "E", Comment: "E2"},
   199  				},
   200  			},
   201  		},
   202  		{ // one match of two patterns
   203  			cwd:  "C",
   204  			args: []string{"D", "X"},
   205  			start: []*node{
   206  				{
   207  					"D",
   208  					"",
   209  					[]*node{
   210  						{"main.go", pkg("D") + decl("D1"), nil},
   211  						{"+git", "D1", nil},
   212  						{"main.go", pkg("D") + decl("D2"), nil},
   213  						{"+git", "D2", nil},
   214  					},
   215  				},
   216  				{
   217  					"C",
   218  					"",
   219  					[]*node{
   220  						{"main.go", pkg("main", "D"), nil},
   221  						{"Godeps/Godeps.json", godeps("C", "D", "D1"), nil},
   222  						{"Godeps/_workspace/src/D/main.go", pkg("D") + decl("D1"), nil},
   223  						{"+git", "", nil},
   224  					},
   225  				},
   226  			},
   227  			want: []*node{
   228  				{"C/Godeps/_workspace/src/D/main.go", pkg("D") + decl("D2"), nil},
   229  			},
   230  			wdep: Godeps{
   231  				ImportPath: "C",
   232  				Deps: []Dependency{
   233  					{ImportPath: "D", Comment: "D2"},
   234  				},
   235  			},
   236  		},
   237  		{ // no matches
   238  			cwd:  "C",
   239  			args: []string{"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("D1"), nil},
   264  			},
   265  			wdep: Godeps{
   266  				ImportPath: "C",
   267  				Deps: []Dependency{
   268  					{ImportPath: "D", Comment: "D1"},
   269  				},
   270  			},
   271  			werr: true,
   272  		},
   273  		{ // update just one package of two in a repo skips it
   274  			cwd:  "C",
   275  			args: []string{"D/A", "E"},
   276  			start: []*node{
   277  				{
   278  					"D",
   279  					"",
   280  					[]*node{
   281  						{"A/main.go", pkg("A") + decl("D1"), nil},
   282  						{"B/main.go", pkg("B") + decl("D1"), nil},
   283  						{"+git", "D1", nil},
   284  						{"A/main.go", pkg("A") + decl("D2"), nil},
   285  						{"B/main.go", pkg("B") + decl("D2"), nil},
   286  						{"+git", "D2", nil},
   287  					},
   288  				},
   289  				{
   290  					"E",
   291  					"",
   292  					[]*node{
   293  						{"main.go", pkg("E") + decl("E1"), nil},
   294  						{"+git", "E1", nil},
   295  						{"main.go", pkg("E") + decl("E2"), nil},
   296  						{"+git", "E2", nil},
   297  					},
   298  				},
   299  				{
   300  					"C",
   301  					"",
   302  					[]*node{
   303  						{"main.go", pkg("main", "D/A", "D/B", "E"), nil},
   304  						{"Godeps/Godeps.json", godeps("C", "D/A", "D1", "D/B", "D1", "E", "E1"), nil},
   305  						{"Godeps/_workspace/src/D/A/main.go", pkg("A") + decl("D1"), nil},
   306  						{"Godeps/_workspace/src/D/B/main.go", pkg("B") + decl("D1"), nil},
   307  						{"Godeps/_workspace/src/E/main.go", pkg("E") + decl("E1"), nil},
   308  						{"+git", "", nil},
   309  					},
   310  				},
   311  			},
   312  			want: []*node{
   313  				{"C/Godeps/_workspace/src/D/A/main.go", pkg("A") + decl("D1"), nil},
   314  				{"C/Godeps/_workspace/src/D/B/main.go", pkg("B") + decl("D1"), nil},
   315  				{"C/Godeps/_workspace/src/E/main.go", pkg("E") + decl("E2"), nil},
   316  			},
   317  			wdep: Godeps{
   318  				ImportPath: "C",
   319  				Deps: []Dependency{
   320  					{ImportPath: "D/A", Comment: "D1"},
   321  					{ImportPath: "D/B", Comment: "D1"},
   322  					{ImportPath: "E", Comment: "E2"},
   323  				},
   324  			},
   325  		},
   326  		{ // update just one package of two in a repo, none left
   327  			cwd:  "C",
   328  			args: []string{"D/A"},
   329  			start: []*node{
   330  				{
   331  					"D",
   332  					"",
   333  					[]*node{
   334  						{"A/main.go", pkg("A") + decl("D1"), nil},
   335  						{"B/main.go", pkg("B") + decl("D1"), nil},
   336  						{"+git", "D1", nil},
   337  						{"A/main.go", pkg("A") + decl("D2"), nil},
   338  						{"B/main.go", pkg("B") + decl("D2"), nil},
   339  						{"+git", "D2", nil},
   340  					},
   341  				},
   342  				{
   343  					"C",
   344  					"",
   345  					[]*node{
   346  						{"main.go", pkg("main", "D/A", "D/B"), nil},
   347  						{"Godeps/Godeps.json", godeps("C", "D/A", "D1", "D/B", "D1"), nil},
   348  						{"Godeps/_workspace/src/D/A/main.go", pkg("A") + decl("D1"), nil},
   349  						{"Godeps/_workspace/src/D/B/main.go", pkg("B") + decl("D1"), nil},
   350  						{"+git", "", nil},
   351  					},
   352  				},
   353  			},
   354  			want: []*node{
   355  				{"C/Godeps/_workspace/src/D/A/main.go", pkg("A") + decl("D1"), nil},
   356  				{"C/Godeps/_workspace/src/D/B/main.go", pkg("B") + decl("D1"), nil},
   357  			},
   358  			wdep: Godeps{
   359  				ImportPath: "C",
   360  				Deps: []Dependency{
   361  					{ImportPath: "D/A", Comment: "D1"},
   362  					{ImportPath: "D/B", Comment: "D1"},
   363  				},
   364  			},
   365  			werr: true,
   366  		},
   367  	}
   368  
   369  	wd, err := os.Getwd()
   370  	if err != nil {
   371  		t.Fatal(err)
   372  	}
   373  	const gopath = "godeptest"
   374  	defer os.RemoveAll(gopath)
   375  	for _, test := range cases {
   376  		err = os.RemoveAll(gopath)
   377  		if err != nil {
   378  			t.Fatal(err)
   379  		}
   380  		src := filepath.Join(gopath, "src")
   381  		makeTree(t, &node{src, "", test.start}, "")
   382  
   383  		dir := filepath.Join(wd, src, test.cwd)
   384  		err = os.Chdir(dir)
   385  		if err != nil {
   386  			panic(err)
   387  		}
   388  		err = os.Setenv("GOPATH", filepath.Join(wd, gopath))
   389  		if err != nil {
   390  			panic(err)
   391  		}
   392  		log.SetOutput(ioutil.Discard)
   393  		err = update(test.args)
   394  		log.SetOutput(os.Stderr)
   395  		if g := err != nil; g != test.werr {
   396  			t.Errorf("update err = %v (%v) want %v", g, err, test.werr)
   397  		}
   398  		err = os.Chdir(wd)
   399  		if err != nil {
   400  			panic(err)
   401  		}
   402  
   403  		checkTree(t, &node{src, "", test.want})
   404  
   405  		f, err := os.Open(filepath.Join(dir, "Godeps/Godeps.json"))
   406  		if err != nil {
   407  			t.Error(err)
   408  		}
   409  		g := new(Godeps)
   410  		err = json.NewDecoder(f).Decode(g)
   411  		if err != nil {
   412  			t.Error(err)
   413  		}
   414  		f.Close()
   415  
   416  		if g.ImportPath != test.wdep.ImportPath {
   417  			t.Errorf("ImportPath = %s want %s", g.ImportPath, test.wdep.ImportPath)
   418  		}
   419  		for i := range g.Deps {
   420  			g.Deps[i].Rev = ""
   421  		}
   422  		if !reflect.DeepEqual(g.Deps, test.wdep.Deps) {
   423  			t.Errorf("Deps = %v want %v", g.Deps, test.wdep.Deps)
   424  		}
   425  	}
   426  }