github.com/goenning/courtney@v0.2.0/courtney_test.go (about)

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