github.com/aexvir/courtney@v0.3.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  	_, pdir, err := b.Package("a", map[string]string{
    30  		"a.go": `package a
    31  		
    32  			func Foo(i int) int {
    33  				i++
    34  				return i
    35  			}
    36  			
    37  			func Bar(i int) int {
    38  				i++
    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  	}
    73  	err = Run(setup)
    74  	if err == nil {
    75  		t.Fatalf("Error in %s. Run should error.", name)
    76  	}
    77  	expected := `Error - untested code:
    78  ns/a/a.go:8-11:
    79  	func Bar(i int) int {
    80  		i++
    81  		return i
    82  	}`
    83  	if !strings.Contains(err.Error(), expected) {
    84  		t.Fatalf("Error in %s err. Got: \n%s\nExpected to contain: \n%s\n", name, err.Error(), expected)
    85  	}
    86  
    87  	coverage, err := ioutil.ReadFile(filepath.Join(pdir, "coverage.out"))
    88  	if err != nil {
    89  		t.Fatalf("Error reading coverage file in %s: %s", name, err)
    90  	}
    91  	expected = `mode: set
    92  ns/a/a.go:3.24,6.5 2 1
    93  ns/a/a.go:8.24,11.5 2 0
    94  `
    95  	if string(coverage) != expected {
    96  		t.Fatalf("Error in %s coverage. Got: \n%s\nExpected: \n%s\n", name, string(coverage), expected)
    97  	}
    98  
    99  	setup = &shared.Setup{
   100  		Env:   env,
   101  		Paths: patsy.NewCache(env),
   102  	}
   103  	if err := Run(setup); err != nil {
   104  		t.Fatalf("Error running program (second try) in %s: %s", name, err)
   105  	}
   106  
   107  }
   108  
   109  func TestRun_load(t *testing.T) {
   110  	name := "load"
   111  	env := vos.Mock()
   112  	b, err := builder.New(env, "ns")
   113  	if err != nil {
   114  		t.Fatalf("Error creating builder in %s: %s", name, err)
   115  	}
   116  	defer b.Cleanup()
   117  
   118  	_, pdir, err := b.Package("a", map[string]string{
   119  		"a.go": `package a
   120  		
   121  			func Foo(i int) int {
   122  				i++
   123  				return i
   124  			}
   125  			
   126  			func Bar(i int) int {
   127  				i++
   128  				return i
   129  			}
   130  		`,
   131  		"a_test.go": `package a
   132  					
   133  			import "testing"
   134  			
   135  			func TestFoo(t *testing.T) {
   136  				// In "load" mode, this test will not run.
   137  				t.Fail()
   138  			}
   139  		`,
   140  		"a.out": `mode: set
   141  ns/a/a.go:3.24,6.5 2 1
   142  ns/a/a.go:8.24,11.5 2 0
   143  `,
   144  		"b.out": `mode: set
   145  ns/a/a.go:3.24,6.5 2 0
   146  ns/a/a.go:8.24,11.5 2 1
   147  `,
   148  	})
   149  	if err != nil {
   150  		t.Fatalf("Error creating builder in %s: %s", name, err)
   151  	}
   152  
   153  	if err := env.Setwd(pdir); err != nil {
   154  		t.Fatalf("Error in Setwd in %s: %s", name, err)
   155  	}
   156  
   157  	// annoyingly, filepath.Glob in "Load" method does not respect the mocked
   158  	// vos working directory
   159  	if err := os.Chdir(pdir); err != nil {
   160  		t.Fatalf("Error in os.Chdir in %s: %s", name, err)
   161  	}
   162  
   163  	sout := &bytes.Buffer{}
   164  	serr := &bytes.Buffer{}
   165  	env.Setstdout(sout)
   166  	env.Setstderr(serr)
   167  
   168  	setup := &shared.Setup{
   169  		Env:   env,
   170  		Paths: patsy.NewCache(env),
   171  		Load:  "*.out",
   172  	}
   173  	if err := Run(setup); err != nil {
   174  		t.Fatalf("Error running program in %s: %s", name, err)
   175  	}
   176  
   177  	coverage, err := ioutil.ReadFile(filepath.Join(pdir, "coverage.out"))
   178  	if err != nil {
   179  		t.Fatalf("Error reading coverage file in %s: %s", name, err)
   180  	}
   181  	expected := `mode: set
   182  ns/a/a.go:3.24,6.5 2 1
   183  ns/a/a.go:8.24,11.5 2 1
   184  `
   185  	if string(coverage) != expected {
   186  		t.Fatalf("Error in %s coverage. Got: \n%s\nExpected: \n%s\n", name, string(coverage), expected)
   187  	}
   188  }