github.com/lixvbnet/courtney@v0.0.0-20221025031132-0dcb02231211/courtney_test.go (about)

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