github.com/aca02djr/gb@v0.4.1/build_test.go (about) 1 package gb 2 3 import ( 4 "errors" 5 "io/ioutil" 6 "os" 7 "path/filepath" 8 "reflect" 9 "sort" 10 "testing" 11 12 "github.com/constabulary/gb/importer" 13 ) 14 15 func TestBuild(t *testing.T) { 16 opts := func(o ...func(*Context) error) []func(*Context) error { return o } 17 tests := []struct { 18 pkg string 19 opts []func(*Context) error 20 err error 21 }{{ 22 pkg: "a", 23 err: nil, 24 }, { 25 pkg: "b", // actually command 26 err: nil, 27 }, { 28 pkg: "c", 29 err: nil, 30 }, { 31 pkg: "d.v1", 32 err: nil, 33 }, { 34 pkg: "x", 35 err: errors.New("import cycle detected: x -> y -> x"), 36 }, { 37 pkg: "cgomain", 38 err: nil, 39 }, { 40 pkg: "cgotest", 41 err: nil, 42 }, { 43 pkg: "notestfiles", 44 err: nil, 45 }, { 46 pkg: "cgoonlynotest", 47 err: nil, 48 }, { 49 pkg: "testonly", 50 err: nil, 51 }, { 52 pkg: "extestonly", 53 err: nil, 54 }, { 55 pkg: "mainnoruntime", 56 err: nil, 57 }, { 58 pkg: "h", // imports "blank", which is blank, see issue #131 59 err: &importer.NoGoError{filepath.Join(getwd(t), "testdata", "src", "blank")}, 60 }, { 61 pkg: "cppmain", 62 }, { 63 pkg: "tags1", 64 opts: opts(Tags("x")), // excludes the test file in package 65 err: &importer.NoGoError{filepath.Join(getwd(t), "testdata", "src", "tags1")}, 66 }, { 67 pkg: "tags2", 68 err: &importer.NoGoError{filepath.Join(getwd(t), "testdata", "src", "tags2")}, 69 }, { 70 pkg: "tags2", 71 opts: opts(Tags("x")), 72 }, { 73 pkg: "nosource", 74 err: &importer.NoGoError{filepath.Join(getwd(t), "testdata", "src", "nosource")}, 75 }} 76 77 proj := testProject(t) 78 for _, tt := range tests { 79 ctx, err := proj.NewContext(tt.opts...) 80 ctx.Force = true 81 defer ctx.Destroy() 82 pkg, err := ctx.ResolvePackage(tt.pkg) 83 if !reflect.DeepEqual(err, tt.err) { 84 t.Errorf("ctx.ResolvePackage(%v): want %v, got %v", tt.pkg, tt.err, err) 85 continue 86 } 87 if err != nil { 88 continue 89 } 90 if err := Build(pkg); !reflect.DeepEqual(err, tt.err) { 91 t.Errorf("ctx.Build(%v): want %v, got %v", tt.pkg, tt.err, err) 92 } 93 } 94 } 95 96 func TestBuildPackage(t *testing.T) { 97 tests := []struct { 98 pkg string 99 err error 100 }{{ 101 pkg: "a", 102 err: nil, 103 }, { 104 pkg: "b", // actually command 105 err: nil, 106 }, { 107 pkg: "c", 108 err: nil, 109 }, { 110 pkg: "d.v1", 111 err: nil, 112 }, { 113 pkg: "cgomain", 114 err: nil, 115 }, { 116 pkg: "cgotest", 117 err: nil, 118 }, { 119 pkg: "notestfiles", 120 err: nil, 121 }, { 122 pkg: "cgoonlynotest", 123 err: nil, 124 }, { 125 pkg: "testonly", 126 err: errors.New(`compile "testonly": no go files supplied`), 127 }, { 128 pkg: "extestonly", 129 err: errors.New(`compile "extestonly": no go files supplied`), 130 }} 131 132 for _, tt := range tests { 133 ctx := testContext(t) 134 defer ctx.Destroy() 135 pkg, err := ctx.ResolvePackage(tt.pkg) 136 if err != nil { 137 t.Errorf("ctx.ResolvePackage(%v): %v", tt.pkg, err) 138 continue 139 } 140 targets := make(map[string]*Action) 141 if _, err := BuildPackage(targets, pkg); !reflect.DeepEqual(err, tt.err) { 142 t.Errorf("ctx.BuildPackage(%v): want %v, got %v", tt.pkg, tt.err, err) 143 } 144 } 145 } 146 147 func TestBuildPackages(t *testing.T) { 148 tests := []struct { 149 pkgs []string 150 actions []string 151 options []func(*Context) error // set of options to apply to the test context 152 err error 153 }{{ 154 pkgs: []string{"a", "b", "c"}, 155 actions: []string{"compile: a", "compile: c", "link: b"}, 156 }, { 157 pkgs: []string{"cgotest", "cgomain", "notestfiles", "cgoonlynotest", "testonly", "extestonly"}, 158 actions: []string{"compile: notestfiles", "link: cgomain", "pack: cgoonlynotest", "pack: cgotest"}, 159 }, { 160 pkgs: []string{"a", "b", "c"}, 161 options: []func(*Context) error{WithRace}, 162 actions: []string{"compile: a", "compile: c", "link: b"}, 163 }} 164 165 for _, tt := range tests { 166 ctx := testContext(t, tt.options...) 167 defer ctx.Destroy() 168 var pkgs []*Package 169 for _, pkg := range tt.pkgs { 170 pkg, err := ctx.ResolvePackage(pkg) 171 if err != nil { 172 t.Errorf("ctx.ResolvePackage(%v): %v", pkg, err) 173 continue 174 } 175 pkgs = append(pkgs, pkg) 176 } 177 a, err := BuildPackages(pkgs...) 178 if !reflect.DeepEqual(err, tt.err) { 179 t.Errorf("ctx.BuildPackages(%v): want %v, got %v", pkgs, tt.err, err) 180 } 181 var names []string 182 for _, a := range a.Deps { 183 names = append(names, a.Name) 184 } 185 sort.Strings(names) 186 if !reflect.DeepEqual(tt.actions, names) { 187 t.Errorf("ctx.BuildPackages(%v): want %v, got %v", pkgs, tt.actions, names) 188 } 189 } 190 } 191 192 func TestObjfile(t *testing.T) { 193 var tests = []struct { 194 pkg string // package name 195 want string // objfile result 196 }{ 197 {pkg: "b", want: "b/main.a"}, 198 {pkg: "nested/a", want: "nested/a.a"}, 199 {pkg: "nested/b", want: "nested/b.a"}, 200 } 201 202 for _, tt := range tests { 203 ctx := testContext(t) 204 defer ctx.Destroy() 205 pkg, err := ctx.ResolvePackage(tt.pkg) 206 if err != nil { 207 t.Fatal(err) 208 } 209 got := objfile(pkg) 210 want := filepath.Join(ctx.Workdir(), tt.want) 211 if want != got { 212 t.Errorf("(%s).Objdir(): want %s, got %s", tt.pkg, want, got) 213 } 214 } 215 } 216 217 func TestCgoobjdir(t *testing.T) { 218 var tests = []struct { 219 pkg string // package name 220 want string // objdir result 221 }{ 222 {pkg: "b", want: "b/_cgo"}, 223 {pkg: "nested/a", want: "nested/a/_cgo"}, 224 {pkg: "nested/b", want: "nested/b/_cgo"}, 225 } 226 227 ctx := testContext(t) 228 defer ctx.Destroy() 229 for _, tt := range tests { 230 pkg, err := ctx.ResolvePackage(tt.pkg) 231 if err != nil { 232 t.Fatal(err) 233 } 234 got := cgoworkdir(pkg) 235 want := filepath.Join(ctx.Workdir(), tt.want) 236 if want != got { 237 t.Errorf("(%s).cgoobjdir(): want %s, got %s", tt.pkg, want, got) 238 } 239 } 240 } 241 242 func TestWorkdir(t *testing.T) { 243 var tests = []struct { 244 pkg string // package name 245 want string // objdir result 246 }{ 247 {pkg: "b", want: ""}, 248 {pkg: "nested/a", want: "nested"}, 249 {pkg: "nested/b", want: "nested"}, 250 } 251 252 ctx := testContext(t) 253 defer ctx.Destroy() 254 for _, tt := range tests { 255 pkg, err := ctx.ResolvePackage(tt.pkg) 256 if err != nil { 257 t.Error(err) 258 continue 259 } 260 got := Workdir(pkg) 261 want := filepath.Join(ctx.Workdir(), tt.want) 262 if want != got { 263 t.Errorf("Workdir(Package{Name: %v, ImportPath: %v, TestScope: %v}): want %s, got %s", pkg.Name, pkg.ImportPath, pkg.TestScope, want, got) 264 } 265 } 266 } 267 268 func TestPkgname(t *testing.T) { 269 var tests = []struct { 270 pkg *Package 271 want string 272 }{{ 273 pkg: &Package{ 274 Package: &importer.Package{ 275 Name: "main", 276 ImportPath: "main", 277 }, 278 }, 279 want: "main", 280 }, { 281 pkg: &Package{ 282 Package: &importer.Package{ 283 Name: "a", 284 ImportPath: "main", 285 }, 286 }, 287 want: "a", 288 }, { 289 pkg: &Package{ 290 Package: &importer.Package{ 291 Name: "main", 292 ImportPath: "a", 293 }, 294 }, 295 want: "a", 296 }, { 297 pkg: &Package{ 298 Package: &importer.Package{ 299 Name: "main", 300 ImportPath: "testmain", 301 }, 302 }, 303 want: "testmain", 304 }, { 305 pkg: &Package{ 306 Package: &importer.Package{ 307 Name: "main", 308 ImportPath: "main", 309 }, 310 TestScope: true, 311 }, 312 want: "main", 313 }, { 314 pkg: &Package{ 315 Package: &importer.Package{ 316 Name: "a", 317 ImportPath: "main", 318 }, 319 TestScope: true, 320 }, 321 want: "main", 322 }, { 323 pkg: &Package{ 324 Package: &importer.Package{ 325 Name: "main", 326 ImportPath: "a", 327 }, 328 TestScope: true, 329 }, 330 want: "a", 331 }, { 332 pkg: &Package{ 333 Package: &importer.Package{ 334 Name: "main", 335 ImportPath: "a/a", 336 }, 337 TestScope: true, 338 }, 339 want: "a", 340 }, { 341 pkg: &Package{ 342 Package: &importer.Package{ 343 Name: "main", 344 ImportPath: "testmain", 345 }, 346 TestScope: true, 347 }, 348 want: "testmain", 349 }} 350 351 for _, tt := range tests { 352 got := pkgname(tt.pkg) 353 if got != tt.want { 354 t.Errorf("pkgname(Package{Name:%q, ImportPath: %q, TestScope:%v}): got %v, want %v", tt.pkg.Name, tt.pkg.ImportPath, tt.pkg.TestScope, got, tt.want) 355 } 356 } 357 } 358 359 func getwd(t *testing.T) string { 360 cwd, err := os.Getwd() 361 if err != nil { 362 t.Fatal(err) 363 } 364 return cwd 365 } 366 367 func mktemp(t *testing.T) string { 368 s, err := mktmp() 369 if err != nil { 370 t.Fatal(err) 371 } 372 return s 373 } 374 375 func mktmp() (string, error) { 376 return ioutil.TempDir("", "gb-test-") 377 }