github.com/covergates/covergates@v0.2.2-0.20201009050117-42ef8a19fb95/service/perl/report_test.go (about)

     1  package perl
     2  
     3  import (
     4  	"archive/zip"
     5  	"context"
     6  	"io/ioutil"
     7  	"os"
     8  	"path/filepath"
     9  	"testing"
    10  )
    11  
    12  type Node struct {
    13  	name    string
    14  	entries []*Node // nil if the entry is a file
    15  	mark    int
    16  }
    17  
    18  func walkTree(n *Node, path string, f func(path string, n *Node)) {
    19  	f(path, n)
    20  	for _, e := range n.entries {
    21  		walkTree(e, filepath.Join(path, e.name), f)
    22  	}
    23  }
    24  
    25  func makeTree(t *testing.T, tree *Node) {
    26  	walkTree(tree, tree.name, func(path string, n *Node) {
    27  		if n.entries == nil {
    28  			fd, err := os.Create(path)
    29  			if err != nil {
    30  				t.Errorf("makeTree: %v", err)
    31  				return
    32  			}
    33  			fd.Close()
    34  		} else {
    35  			os.Mkdir(path, 0770)
    36  		}
    37  	})
    38  }
    39  
    40  func unzip(file, folder string) error {
    41  	z, err := zip.OpenReader(file)
    42  	if err != nil {
    43  		return err
    44  	}
    45  	cwd, err := os.Getwd()
    46  	if err != nil {
    47  		return err
    48  	}
    49  	defer os.Chdir(cwd)
    50  	if err := os.Chdir(folder); err != nil {
    51  		return err
    52  	}
    53  	for _, file := range z.File {
    54  		if file.FileInfo().IsDir() {
    55  			if err := os.Mkdir(file.Name, os.ModePerm); err != nil {
    56  				return err
    57  			}
    58  		} else {
    59  			fo, err := file.Open()
    60  			if err != nil {
    61  				return err
    62  			}
    63  			data, err := ioutil.ReadAll(fo)
    64  			fo.Close()
    65  			if err != nil {
    66  				return err
    67  			}
    68  			if err := ioutil.WriteFile(file.Name, data, os.ModePerm); err != nil {
    69  				return err
    70  			}
    71  		}
    72  	}
    73  	return nil
    74  }
    75  
    76  func TestPerlCoverageService(t *testing.T) {
    77  	file := filepath.Join("testdata", "cover_db.zip")
    78  	f, err := os.Open(file)
    79  	if err != nil {
    80  		t.Error(err)
    81  		return
    82  	}
    83  	s := &CoverageService{}
    84  	ctx, cancel := context.WithCancel(context.Background())
    85  	defer cancel()
    86  	report, err := s.Report(ctx, f)
    87  	if err != nil {
    88  		t.Error(err)
    89  		return
    90  	}
    91  	if len(report.Files) <= 0 {
    92  		t.Fail()
    93  		return
    94  	}
    95  	if report.StatementCoverage <= 0 {
    96  		t.Fail()
    97  		return
    98  	}
    99  }
   100  
   101  func TestPerlCoverageWithStringStatementHits(t *testing.T) {
   102  	file := filepath.Join("testdata", "JSON_db.zip")
   103  	f, err := os.Open(file)
   104  	if err != nil {
   105  		t.Error(err)
   106  		return
   107  	}
   108  	s := &CoverageService{}
   109  	report, err := s.Report(context.Background(), f)
   110  	if err != nil {
   111  		t.Error(err)
   112  		return
   113  	}
   114  	if len(report.Files) <= 0 {
   115  		t.Fail()
   116  		return
   117  	}
   118  	if report.StatementCoverage <= 0 {
   119  		t.Fail()
   120  		return
   121  	}
   122  }
   123  
   124  func TestFindReport(t *testing.T) {
   125  	tree := &Node{
   126  		"repository",
   127  		[]*Node{
   128  			{"dir", []*Node{
   129  				{"cover_db", nil, 0},
   130  			}, 0},
   131  			{"cover_db", []*Node{
   132  				{"cover.14", nil, 0},
   133  			}, 0},
   134  		},
   135  		0,
   136  	}
   137  	tmpDir, err := ioutil.TempDir("./", "TestWalk")
   138  	if err != nil {
   139  		t.Fatal(err)
   140  	}
   141  	defer os.RemoveAll(tmpDir)
   142  	originDir, err := os.Getwd()
   143  	if err != nil {
   144  		t.Fatal(err)
   145  	}
   146  	if err = os.Chdir(tmpDir); err != nil {
   147  		t.Fatal(err)
   148  	}
   149  	defer os.Chdir(originDir)
   150  	makeTree(t, tree)
   151  	service := &CoverageService{}
   152  	report, err := service.Find(context.Background(), tree.name)
   153  	if err != nil {
   154  		t.Error(err)
   155  		return
   156  	}
   157  	if report != filepath.Join("repository", "cover_db") {
   158  		t.Log(report)
   159  		t.Fail()
   160  	}
   161  }
   162  
   163  func TestOpenReport(t *testing.T) {
   164  	file := filepath.Join("testdata", "cover_db.zip")
   165  	tmpDir, err := ioutil.TempDir("./", "TestOpenReport")
   166  	if err != nil {
   167  		t.Fatal(err)
   168  	}
   169  	defer os.RemoveAll(tmpDir)
   170  
   171  	if err := unzip(file, tmpDir); err != nil {
   172  		t.Fatal(err)
   173  	}
   174  
   175  	service := &CoverageService{}
   176  	r, err := service.Open(context.Background(), tmpDir)
   177  	if err != nil {
   178  		t.Fatal(err)
   179  	}
   180  	report, err := service.Report(context.Background(), r)
   181  	if err != nil {
   182  		t.Fatal(err)
   183  	}
   184  	if report.StatementCoverage <= 0 {
   185  		t.Fail()
   186  	}
   187  	if len(report.Files) <= 0 {
   188  		t.Fail()
   189  	}
   190  }