go.dsage.org/courtney@v0.4.1-0.20240216163045-2a9a7e4f5143/courtney_test.go (about)

     1  package main
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"io/ioutil"
     7  	"os"
     8  	"path/filepath"
     9  	"strings"
    10  	"testing"
    11  
    12  	"github.com/dave/patsy"
    13  	"github.com/dave/patsy/builder"
    14  	"github.com/dave/patsy/vos"
    15  
    16  	"go.dsage.org/courtney/shared"
    17  )
    18  
    19  func TestRun(t *testing.T) {
    20  	for _, gomod := range []bool{true, false} {
    21  		t.Run(fmt.Sprintf("gomod=%v", gomod), func(t *testing.T) {
    22  			name := "run"
    23  			env := vos.Mock()
    24  			b, err := builder.New(env, "ns", gomod)
    25  			if err != nil {
    26  				t.Fatalf("Error creating builder in %s: %s", name, err)
    27  			}
    28  			defer b.Cleanup()
    29  
    30  			_, pdir, err := b.Package("a", map[string]string{
    31  				"a.go": `package a
    32  		
    33  			func Foo(i int) int {
    34  				i++
    35  				return i
    36  			}
    37  			
    38  			func Bar(i int) int {
    39  				i++
    40  				return i
    41  			}
    42  		`,
    43  				"a_test.go": `package a
    44  					
    45  			import "testing"
    46  			
    47  			func TestFoo(t *testing.T) {
    48  				i := Foo(1)
    49  				if i != 2 {
    50  					t.Fail()
    51  				}
    52  			}
    53  		`,
    54  			})
    55  			if err != nil {
    56  				t.Fatalf("Error creating builder in %s: %s", name, err)
    57  			}
    58  
    59  			if err := env.Setwd(pdir); err != nil {
    60  				t.Fatalf("Error in Setwd in %s: %s", name, err)
    61  			}
    62  
    63  			sout := &bytes.Buffer{}
    64  			serr := &bytes.Buffer{}
    65  			env.Setstdout(sout)
    66  			env.Setstderr(serr)
    67  
    68  			setup := &shared.Setup{
    69  				Env:     env,
    70  				Paths:   patsy.NewCache(env),
    71  				Enforce: true,
    72  				Verbose: true,
    73  			}
    74  			err = Run(setup)
    75  			if err == nil {
    76  				t.Fatalf("Error in %s. Run should error.", name)
    77  			}
    78  			expected := `Error - untested code:
    79  ns/a/a.go:8-11:
    80  	func Bar(i int) int {
    81  		i++
    82  		return i
    83  	}`
    84  			if !strings.Contains(err.Error(), expected) {
    85  				t.Fatalf("Error in %s err. Got: \n%s\nExpected to contain: \n%s\n", name, err.Error(), expected)
    86  			}
    87  
    88  			coverage, err := ioutil.ReadFile(filepath.Join(pdir, "coverage.out"))
    89  			if err != nil {
    90  				t.Fatalf("Error reading coverage file in %s: %s", name, err)
    91  			}
    92  			expected = `mode: set
    93  ns/a/a.go:3.24,6.5 2 1
    94  ns/a/a.go:8.24,11.5 2 0
    95  `
    96  			if string(coverage) != expected {
    97  				t.Fatalf("Error in %s coverage. Got: \n%s\nExpected: \n%s\n", name, string(coverage), expected)
    98  			}
    99  
   100  			setup = &shared.Setup{
   101  				Env:   env,
   102  				Paths: patsy.NewCache(env),
   103  			}
   104  			if err := Run(setup); err != nil {
   105  				t.Fatalf("Error running program (second try) in %s: %s", name, err)
   106  			}
   107  		})
   108  	}
   109  }
   110  
   111  func TestRun_load(t *testing.T) {
   112  	for _, gomod := range []bool{true, false} {
   113  		t.Run(fmt.Sprintf("gomod=%v", gomod), func(t *testing.T) {
   114  			name := "load"
   115  			env := vos.Mock()
   116  			b, err := builder.New(env, "ns", gomod)
   117  			if err != nil {
   118  				t.Fatalf("Error creating builder in %s: %s", name, err)
   119  			}
   120  			defer b.Cleanup()
   121  
   122  			_, pdir, err := b.Package("a", map[string]string{
   123  				"a.go": `package a
   124  		
   125  			func Foo(i int) int {
   126  				i++
   127  				return i
   128  			}
   129  			
   130  			func Bar(i int) int {
   131  				i++
   132  				return i
   133  			}
   134  		`,
   135  				"a_test.go": `package a
   136  					
   137  			import "testing"
   138  			
   139  			func TestFoo(t *testing.T) {
   140  				// In "load" mode, this test will not run.
   141  				t.Fail()
   142  			}
   143  		`,
   144  				"a.out": `mode: set
   145  ns/a/a.go:3.24,6.5 2 1
   146  ns/a/a.go:8.24,11.5 2 0
   147  `,
   148  				"b.out": `mode: set
   149  ns/a/a.go:3.24,6.5 2 0
   150  ns/a/a.go:8.24,11.5 2 1
   151  `,
   152  			})
   153  			if err != nil {
   154  				t.Fatalf("Error creating builder in %s: %s", name, err)
   155  			}
   156  
   157  			if err := env.Setwd(pdir); err != nil {
   158  				t.Fatalf("Error in Setwd in %s: %s", name, err)
   159  			}
   160  
   161  			// annoyingly, filepath.Glob in "Load" method does not respect the mocked
   162  			// vos working directory
   163  			if err := os.Chdir(pdir); err != nil {
   164  				t.Fatalf("Error in os.Chdir in %s: %s", name, err)
   165  			}
   166  
   167  			sout := &bytes.Buffer{}
   168  			serr := &bytes.Buffer{}
   169  			env.Setstdout(sout)
   170  			env.Setstderr(serr)
   171  
   172  			setup := &shared.Setup{
   173  				Env:   env,
   174  				Paths: patsy.NewCache(env),
   175  				Load:  "*.out",
   176  			}
   177  			if err := Run(setup); err != nil {
   178  				t.Fatalf("Error running program in %s: %s", name, err)
   179  			}
   180  
   181  			coverage, err := ioutil.ReadFile(filepath.Join(pdir, "coverage.out"))
   182  			if err != nil {
   183  				t.Fatalf("Error reading coverage file in %s: %s", name, err)
   184  			}
   185  			expected := `mode: set
   186  ns/a/a.go:3.24,6.5 2 1
   187  ns/a/a.go:8.24,11.5 2 1
   188  `
   189  			if string(coverage) != expected {
   190  				t.Fatalf("Error in %s coverage. Got: \n%s\nExpected: \n%s\n", name, string(coverage), expected)
   191  			}
   192  		})
   193  	}
   194  }