pipeline_test.go

   1 package main
   2
   3 import (
   4         "bytes"
   5         "fmt"
   6         "io"
   7         "io/ioutil"
   8         "os"
   9         "sync"
  10
  11         "gopkg.in/check.v1"
  12 )
  13
  14 type pipelineSuite struct{}
  15
  16 var _ = check.Suite(&pipelineSuite{})
  17
  18 func (s *pipelineSuite) TestImport(c *check.C) {
  19         for _, infile := range []string{
  20                 "testdata/pipeline1/",
  21                 "testdata/ref.fasta",
  22         } {
  23                 c.Logf("TestImport: %s", infile)
  24                 var wg sync.WaitGroup
  25
  26                 statsin, importout := io.Pipe()
  27                 wg.Add(1)
  28                 go func() {
  29                         defer wg.Done()
  30                         code := (&importer{}).RunCommand("lightning import", []string{"-local=true", "-skip-ooo=true", "-output-tiles", "-tag-library", "testdata/tags", infile}, bytes.NewReader(nil), importout, os.Stderr)
  31                         c.Check(code, check.Equals, 0)
  32                         importout.Close()
  33                 }()
  34                 statsout := &bytes.Buffer{}
  35                 wg.Add(1)
  36                 go func() {
  37                         defer wg.Done()
  38                         code := (&stats{}).RunCommand("lightning stats", []string{"-local"}, statsin, statsout, os.Stderr)
  39                         c.Check(code, check.Equals, 0)
  40                 }()
  41                 wg.Wait()
  42                 c.Logf("%s", statsout.String())
  43         }
  44 }
  45
  46 func (s *pipelineSuite) TestImportMerge(c *check.C) {
  47         libfile := make([]string, 2)
  48         tmpdir := c.MkDir()
  49
  50         var wg sync.WaitGroup
  51         for i, infile := range []string{
  52                 "testdata/ref.fasta",
  53                 "testdata/pipeline1/",
  54         } {
  55                 i, infile := i, infile
  56                 c.Logf("TestImportMerge: %s", infile)
  57                 libfile[i] = fmt.Sprintf("%s/%d.gob", tmpdir, i)
  58                 wg.Add(1)
  59                 go func() {
  60                         defer wg.Done()
  61                         args := []string{"-local=true", "-o=" + libfile[i], "-skip-ooo=true", "-output-tiles", "-tag-library", "testdata/tags"}
  62                         if i == 0 {
  63                                 // ref only
  64                                 args = append(args, "-include-no-calls")
  65                         }
  66                         args = append(args, infile)
  67                         code := (&importer{}).RunCommand("lightning import", args, bytes.NewReader(nil), &bytes.Buffer{}, os.Stderr)
  68                         c.Check(code, check.Equals, 0)
  69                 }()
  70         }
  71         wg.Wait()
  72
  73         merged := &bytes.Buffer{}
  74         code := (&merger{}).RunCommand("lightning merge", []string{"-local", libfile[0], libfile[1]}, bytes.NewReader(nil), merged, os.Stderr)
  75         c.Check(code, check.Equals, 0)
  76         c.Logf("len(merged) %d", merged.Len())
  77
  78         statsout := &bytes.Buffer{}
  79         code = (&stats{}).RunCommand("lightning stats", []string{"-local"}, bytes.NewReader(merged.Bytes()), statsout, os.Stderr)
  80         c.Check(code, check.Equals, 0)
  81         c.Check(statsout.Len() > 0, check.Equals, true)
  82         c.Logf("%s", statsout.String())
  83
  84         c.Check(ioutil.WriteFile(tmpdir+"/merged.gob", merged.Bytes(), 0666), check.IsNil)
  85
  86         hgvsout := &bytes.Buffer{}
  87         code = (&exporter{}).RunCommand("lightning export", []string{"-local", "-ref", "testdata/ref.fasta", "-output-format", "hgvs", "-i", tmpdir + "/merged.gob"}, bytes.NewReader(nil), hgvsout, os.Stderr)
  88         c.Check(code, check.Equals, 0)
  89         c.Check(hgvsout.Len() > 0, check.Equals, true)
  90         c.Logf("%s", hgvsout.String())
  91         c.Check(hgvsout.String(), check.Equals, `chr1:g.1_3delinsGGC
  92 chr1:g.[41_42delinsAA];[41=]
  93 chr1:g.[161=];[161A>T]
  94 chr1:g.[178=];[178A>T]
  95 chr1:g.222_224del
  96 chr1:g.[302=];[302_305delinsAAAA]
  97 chr2:g.[813_826del];[813=]
  98 chr2:g.[830_841delinsAA];[830=]
  99 chr2:g.[887C>A];[887=]
 100 chr2:g.[1042_1044del];[1042=]
 101 chr2:g.[1043=];[1043_1044delinsAA]
 102 `)
 103
 104         vcfout := &bytes.Buffer{}
 105         code = (&exporter{}).RunCommand("lightning export", []string{"-local", "-ref", "testdata/ref.fasta", "-output-format", "vcf", "-i", tmpdir + "/merged.gob", "-output-bed", tmpdir + "/export.bed"}, bytes.NewReader(nil), vcfout, os.Stderr)
 106         c.Check(code, check.Equals, 0)
 107         c.Check(vcfout.Len() > 0, check.Equals, true)
 108         c.Logf("%s", vcfout.String())
 109         c.Check(vcfout.String(), check.Equals, `chr1    1       NNN     GGC     1/1
 110 chr1    41      TT      AA      1/0
 111 chr1    161     A       T       0/1
 112 chr1    178     A       T       0/1
 113 chr1    221     TCCA    T       1/1
 114 chr1    302     TTTT    AAAA    0/1
 115 chr2    812     ATTTTTCTTGCTCTC A       1/0
 116 chr2    830     CCTTGTATTTTT    AA      1/0
 117 chr2    887     C       A       1/0
 118 chr2    1041    GTGG    G       1/0
 119 chr2    1043    GG      AA      0/1
 120 `)
 121         bedout, err := ioutil.ReadFile(tmpdir + "/export.bed")
 122         c.Check(err, check.IsNil)
 123         c.Logf("%s", string(bedout))
 124         c.Check(string(bedout), check.Equals, `chr1 0 248 0 1000 . 0 224
 125 chr1 224 372 1 500 . 248 348
 126 chr1 348 496 2 0 . 372 472
 127 chr1 472 572 3 0 . 496 572
 128 chr2 572 820 4 500 . 0 796
 129 chr2 796 944 5 0 . 820 920
 130 chr2 920 1068 6 1000 . 944 1044
 131 chr2 1044 1144 7 0 . 1068 1144
 132 `)
 133 }