| // Copyright 2015 The Vanadium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package main |
| |
| import ( |
| "bytes" |
| "fmt" |
| "io" |
| "os" |
| "path/filepath" |
| "regexp" |
| "testing" |
| |
| "v.io/jiri/gitutil" |
| "v.io/jiri/jiritest" |
| "v.io/jiri/project" |
| "v.io/jiri/tool" |
| ) |
| |
| func TestCopyright(t *testing.T) { |
| fake, cleanup := jiritest.NewFakeJiriRoot(t) |
| defer cleanup() |
| |
| var errOut bytes.Buffer |
| fake.X.Context = tool.NewContext(tool.ContextOpts{ |
| Stderr: io.MultiWriter(os.Stderr, &errOut), |
| }) |
| |
| // Load assets. |
| assets, err := loadAssets(fake.X, filepath.Join("..", "tooldata", "data")) |
| if err != nil { |
| t.Fatalf("%v", err) |
| } |
| |
| if err := fake.CreateRemoteProject("test"); err != nil { |
| t.Fatalf("%v", err) |
| } |
| if err := fake.AddProject(project.Project{ |
| Name: "test", |
| Path: "test", |
| Remote: fake.Projects["test"], |
| }); err != nil { |
| t.Fatalf("%v", err) |
| } |
| if err := fake.UpdateUniverse(false); err != nil { |
| t.Fatalf("%v", err) |
| } |
| |
| allFiles := map[string]string{} |
| for file, data := range assets.MatchFiles { |
| allFiles[file] = data |
| } |
| for file, data := range assets.MatchPrefixFiles { |
| allFiles[file] = data |
| } |
| |
| // Write out test licensing files and sample source code files to a |
| // project and verify that the project checks out. |
| projectPath := filepath.Join(fake.X.Root, "test") |
| project := project.Project{Path: projectPath} |
| s := fake.X.NewSeq() |
| for _, lang := range languages { |
| file := "test" + lang.FileExtension |
| if err := s.WriteFile(filepath.Join(projectPath, file), nil, os.FileMode(0600)).Done(); err != nil { |
| t.Fatalf("%v", err) |
| } |
| missing, err := checkFile(fake.X, filepath.Join(project.Path, file), assets, true) |
| if err != nil { |
| t.Fatalf("%v", err) |
| } |
| if got, want := missing, false; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| if err := gitutil.New(fake.X.NewSeq(), gitutil.RootDirOpt(projectPath)).CommitFile(file, "adding "+file); err != nil { |
| t.Fatalf("%v", err) |
| } |
| } |
| for file, data := range allFiles { |
| if err := s.WriteFile(filepath.Join(projectPath, file), []byte(data), os.FileMode(0600)).Done(); err != nil { |
| t.Fatalf("%v", err) |
| } |
| if err := gitutil.New(fake.X.NewSeq(), gitutil.RootDirOpt(projectPath)).CommitFile(file, "adding "+file); err != nil { |
| t.Fatalf("%v", err) |
| } |
| } |
| missing, err := checkProject(fake.X, project, assets, false) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got, want := missing, false; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| if got, want := errOut.String(), ""; got != want { |
| t.Fatalf("unexpected error message: got %q, want %q", got, want) |
| } |
| // Check that missing licensing files are reported correctly. |
| for file, _ := range allFiles { |
| errOut.Reset() |
| missing, err := checkProject(fake.X, project, assets, true) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got, want := missing, false; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| path := filepath.Join(projectPath, file) |
| if err := gitutil.New(fake.X.NewSeq(), gitutil.RootDirOpt(projectPath)).Remove(file); err != nil { |
| t.Fatalf("%v", err) |
| } |
| missing, err = checkProject(fake.X, project, assets, false) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got, want := missing, true; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| if got, want := errOut.String(), fmt.Sprintf("%v is missing\n", path); got != want { |
| t.Fatalf("unexpected error message: got %q, want %q", got, want) |
| } |
| } |
| // Check that out-of-date licensing files are reported correctly. |
| for file, _ := range allFiles { |
| errOut.Reset() |
| missing, err := checkProject(fake.X, project, assets, true) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got, want := missing, false; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| path := filepath.Join(projectPath, file) |
| if err := s.WriteFile(path, []byte("garbage"), os.FileMode(0600)).Done(); err != nil { |
| t.Fatalf("%v", err) |
| } |
| missing, err = checkProject(fake.X, project, assets, false) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got, want := missing, true; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| if got, want := errOut.String(), fmt.Sprintf("%v is not up-to-date\n", path); got != want { |
| t.Fatalf("unexpected error message: got %q, want %q", got, want) |
| } |
| } |
| |
| // Check that source code files without the copyright header are |
| // reported correctly. |
| for _, lang := range languages { |
| errOut.Reset() |
| missing, err := checkProject(fake.X, project, assets, true) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got, want := missing, false; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| path := filepath.Join(projectPath, "test"+lang.FileExtension) |
| if err := s.WriteFile(path, []byte("garbage"), os.FileMode(0600)).Done(); err != nil { |
| t.Fatalf("%v", err) |
| } |
| missing, err = checkProject(fake.X, project, assets, false) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got, want := missing, true; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| if got, want := errOut.String(), fmt.Sprintf("%v copyright is missing\n", path); got != want { |
| t.Fatalf("unexpected error message: got %q, want %q", got, want) |
| } |
| } |
| |
| // Check that missing licensing files are fixed up correctly. |
| for file, _ := range allFiles { |
| errOut.Reset() |
| missing, err := checkProject(fake.X, project, assets, true) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got, want := missing, false; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| path := filepath.Join(projectPath, file) |
| if err := s.RemoveAll(path).Done(); err != nil { |
| t.Fatalf("%v", err) |
| } |
| missing, err = checkProject(fake.X, project, assets, true) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got, want := missing, false; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| missing, err = checkProject(fake.X, project, assets, false) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got, want := missing, false; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| if got, want := errOut.String(), ""; got != want { |
| t.Fatalf("unexpected error message: got %q, want %q", got, want) |
| } |
| } |
| |
| // Check that out-of-date licensing files are fixed up correctly. |
| for file, _ := range allFiles { |
| errOut.Reset() |
| missing, err := checkProject(fake.X, project, assets, true) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got, want := missing, false; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| path := filepath.Join(projectPath, file) |
| if err := s.WriteFile(path, []byte("garbage"), os.FileMode(0600)).Done(); err != nil { |
| t.Fatalf("%v", err) |
| } |
| missing, err = checkProject(fake.X, project, assets, true) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got, want := missing, false; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| missing, err = checkProject(fake.X, project, assets, false) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got, want := missing, false; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| if got, want := errOut.String(), ""; got != want { |
| t.Fatalf("unexpected error message: got %q, want %q", got, want) |
| } |
| } |
| |
| // Check that source code files missing the copyright header are |
| // fixed up correctly. |
| for _, lang := range languages { |
| errOut.Reset() |
| missing, err := checkProject(fake.X, project, assets, true) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got, want := missing, false; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| path := filepath.Join(projectPath, "test"+lang.FileExtension) |
| if err := s.WriteFile(path, []byte("garbage"), os.FileMode(0600)).Done(); err != nil { |
| t.Fatalf("%v", err) |
| } |
| missing, err = checkProject(fake.X, project, assets, true) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got, want := missing, false; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| missing, err = checkProject(fake.X, project, assets, false) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got, want := missing, false; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| if got, want := errOut.String(), ""; got != want { |
| t.Fatalf("unexpected error message: got %q, want %q", got, want) |
| } |
| } |
| |
| // Check that third-party files are skipped when checking for copyright |
| // headers. |
| errOut.Reset() |
| missing, err = checkProject(fake.X, project, assets, true) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got, want := missing, false; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| path := filepath.Join(projectPath, "third_party") |
| gpath := filepath.Join(path, "test.go") |
| if err := s.MkdirAll(path, 0700). |
| WriteFile(gpath, []byte("garbage"), os.FileMode(0600)).Done(); err != nil { |
| t.Fatalf("%v", err) |
| } |
| // Since this file is in a subdir, we must run "git add" to have git track it. |
| // Without this, the test passes regardless of the subdir name. |
| if err := gitutil.New(fake.X.NewSeq(), gitutil.RootDirOpt(projectPath)).Add(path); err != nil { |
| t.Fatalf("%v", err) |
| } |
| missing, err = checkProject(fake.X, project, assets, false) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got, want := missing, false; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| if errOut.Len() != 0 { |
| t.Fatalf("unexpected error message: %q", errOut.String()) |
| } |
| |
| // Test .jiriignore functionality. |
| errOut.Reset() |
| // Add .jiriignore file. |
| ignoreFile := filepath.Join(projectPath, jiriIgnore) |
| publicDir := filepath.Join(projectPath, "public") |
| filename := filepath.Join(publicDir, "fancy.js") |
| |
| if err := s. |
| WriteFile(ignoreFile, []byte("public/fancy.js"), os.FileMode(0600)). |
| MkdirAll(publicDir, 0700). |
| WriteFile(filename, []byte("garbage"), os.FileMode(0600)).Done(); err != nil { |
| t.Fatalf("%v", err) |
| } |
| |
| // Since the copyright check only applies to tracked files, we must run "git |
| // add" to have git track it. Without this, the test passes regardless of the |
| // subdir name. |
| if err := gitutil.New(fake.X.NewSeq(), gitutil.RootDirOpt(projectPath)).Add(filename); err != nil { |
| t.Fatalf("%v", err) |
| } |
| missing, err = checkProject(fake.X, project, assets, false) |
| if err != nil { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got, want := missing, false; got != want { |
| t.Errorf("got %v, want %v", got, want) |
| } |
| if errOut.Len() != 0 { |
| t.Fatalf("unexpected error message: %q", errOut.String()) |
| } |
| } |
| |
| func TestCopyrightIsIgnored(t *testing.T) { |
| lines := []string{ |
| "public/bundle.*", |
| "build/", |
| "dist/min.js", |
| } |
| expressions := []*regexp.Regexp{} |
| for _, line := range lines { |
| expression, err := regexp.Compile(line) |
| if err != nil { |
| t.Fatalf("unexpected regexp.Compile(%v) failed: %v", line, err) |
| } |
| |
| expressions = append(expressions, expression) |
| } |
| |
| shouldIgnore := []string{ |
| "public/bundle.js", |
| "public/bundle.css", |
| "dist/min.js", |
| "build/bar", |
| } |
| |
| for _, path := range shouldIgnore { |
| if ignore, _ := isIgnored(path, expressions); !ignore { |
| t.Errorf("isIgnored(%s, expressions) == %v, should be %v", path, ignore, true) |
| } |
| } |
| |
| shouldNotIgnore := []string{"foo", "bar"} |
| for _, path := range shouldNotIgnore { |
| if ignore, _ := isIgnored(path, expressions); ignore { |
| t.Errorf("isIgnored(%s, expressions) == %v, should be %v", path, ignore, false) |
| } |
| } |
| } |
