github.com/cloudogu/gomarkdoc@v0.4.1-8/lang/package_test.go (about) 1 package lang_test 2 3 import ( 4 "go/build" 5 "os" 6 "path/filepath" 7 "strings" 8 "testing" 9 10 "github.com/cloudogu/gomarkdoc/lang" 11 "github.com/cloudogu/gomarkdoc/logger" 12 "github.com/matryer/is" 13 ) 14 15 func TestPackage_Consts(t *testing.T) { 16 is := is.New(t) 17 18 pkg, err := loadPackage("../testData/lang/function") 19 is.NoErr(err) 20 21 consts := pkg.Consts() 22 is.Equal(len(consts), 1) 23 24 decl, err := consts[0].Decl() 25 is.NoErr(err) 26 is.Equal(decl, `const ( 27 ConstA = "string" 28 ConstB = true 29 )`) 30 } 31 32 func TestPackage_Vars(t *testing.T) { 33 is := is.New(t) 34 35 pkg, err := loadPackage("../testData/lang/function") 36 is.NoErr(err) 37 38 vars := pkg.Vars() 39 is.Equal(len(vars), 1) 40 41 decl, err := vars[0].Decl() 42 is.NoErr(err) 43 is.Equal(decl, `var Variable = 5`) 44 } 45 46 func TestPackage_dotImport(t *testing.T) { 47 is := is.New(t) 48 49 err := os.Chdir("../testData/lang/function") 50 is.NoErr(err) 51 52 defer func() { 53 _ = os.Chdir("../../../lang") 54 }() 55 56 pkg, err := loadPackage(".") 57 is.NoErr(err) 58 59 is.Equal(pkg.Import(), `import "github.com/cloudogu/gomarkdoc/testData/lang/function"`) 60 is.Equal(pkg.ImportPath(), `github.com/cloudogu/gomarkdoc/testData/lang/function`) 61 } 62 63 func TestPackage_strings(t *testing.T) { 64 is := is.New(t) 65 66 buildPkg, err := getBuildPackage("strings") 67 is.NoErr(err) 68 69 log := logger.New(logger.ErrorLevel) 70 pkg, err := lang.NewPackageFromBuild(log, buildPkg) 71 is.NoErr(err) 72 73 is.Equal(pkg.Level(), 1) // level should be root 74 is.True(strings.HasSuffix(pkg.Dir(), filepath.FromSlash("/strings"))) 75 is.Equal(pkg.Dirname(), "strings") 76 is.Equal(pkg.Name(), "strings") 77 is.Equal(pkg.Import(), `import "strings"`) 78 is.Equal(pkg.ImportPath(), `strings`) 79 is.Equal(pkg.Summary(), "Package strings implements simple functions to manipulate UTF-8 encoded strings.") 80 is.Equal(len(pkg.Consts()), 0) // strings should have no constants 81 is.Equal(len(pkg.Vars()), 0) // strings should have no vars 82 is.True(len(pkg.Funcs()) > 0) // strings should have top-level functions 83 is.True(len(pkg.Types()) > 0) // strings should have top-level types 84 is.Equal(len(pkg.Examples()), 0) // strings should have no top-level examples 85 } 86 87 func TestPackage_textScanner(t *testing.T) { 88 is := is.New(t) 89 90 buildPkg, err := getBuildPackage("text/scanner") 91 is.NoErr(err) 92 93 log := logger.New(logger.ErrorLevel) 94 pkg, err := lang.NewPackageFromBuild(log, buildPkg) 95 is.NoErr(err) 96 97 is.Equal(pkg.Level(), 1) // level should be root 98 is.True(strings.HasSuffix(pkg.Dir(), filepath.FromSlash("/text/scanner"))) 99 is.Equal(pkg.Dirname(), "scanner") 100 is.Equal(pkg.Name(), "scanner") 101 is.Equal(pkg.Import(), `import "text/scanner"`) 102 is.Equal(pkg.ImportPath(), `text/scanner`) 103 is.Equal(pkg.Summary(), "Package scanner provides a scanner and tokenizer for UTF-8-encoded text.") 104 is.True(len(pkg.Consts()) > 0) // text/scanner should have constants 105 is.Equal(len(pkg.Vars()), 0) // text/scanner should have no vars 106 is.True(len(pkg.Funcs()) > 0) // text/scanner should have top-level functions 107 is.True(len(pkg.Types()) > 0) // text/scanner should have top-level types 108 is.True(len(pkg.Examples()) > 0) // text/scanner should have top-level examples 109 } 110 111 func TestPackage_ioIoutil(t *testing.T) { 112 is := is.New(t) 113 114 buildPkg, err := getBuildPackage("io/ioutil") 115 is.NoErr(err) 116 117 log := logger.New(logger.ErrorLevel) 118 pkg, err := lang.NewPackageFromBuild(log, buildPkg) 119 is.NoErr(err) 120 121 is.Equal(pkg.Level(), 1) // level should be root 122 is.True(strings.HasSuffix(pkg.Dir(), filepath.FromSlash("/io/ioutil"))) 123 is.Equal(pkg.Dirname(), "ioutil") 124 is.Equal(pkg.Name(), "ioutil") 125 is.Equal(pkg.Import(), `import "io/ioutil"`) 126 is.Equal(pkg.ImportPath(), `io/ioutil`) 127 is.Equal(pkg.Summary(), "Package ioutil implements some I/O utility functions.") 128 is.Equal(len(pkg.Consts()), 0) // io/ioutil should have no constants 129 is.True(len(pkg.Vars()) > 0) // io/ioutil should have vars 130 is.True(len(pkg.Funcs()) > 0) // io/ioutil should have top-level functions 131 is.Equal(len(pkg.Types()), 0) // io/ioutil should have no top-level types 132 is.Equal(len(pkg.Examples()), 0) // io/ioutil should have no top-level examples 133 } 134 135 func TestPackage_encoding(t *testing.T) { 136 is := is.New(t) 137 138 buildPkg, err := getBuildPackage("encoding") 139 is.NoErr(err) 140 141 log := logger.New(logger.ErrorLevel) 142 pkg, err := lang.NewPackageFromBuild(log, buildPkg) 143 is.NoErr(err) 144 145 is.Equal(pkg.Level(), 1) // level should be root 146 is.True(strings.HasSuffix(pkg.Dir(), filepath.FromSlash("/encoding"))) 147 is.Equal(pkg.Dirname(), "encoding") 148 is.Equal(pkg.Name(), "encoding") 149 is.Equal(pkg.Import(), `import "encoding"`) 150 is.Equal(pkg.ImportPath(), `encoding`) 151 is.Equal(pkg.Summary(), "Package encoding defines interfaces shared by other packages that convert data to and from byte-level and textual representations.") 152 is.Equal(len(pkg.Consts()), 0) // encoding should have no constants 153 is.Equal(len(pkg.Vars()), 0) // encoding should have no vars 154 is.Equal(len(pkg.Funcs()), 0) // encoding should have no top-level functions 155 is.True(len(pkg.Types()) > 0) // encoding should have top-level types 156 is.Equal(len(pkg.Examples()), 0) // encoding should have no top-level examples 157 } 158 159 func getBuildPackage(path string) (*build.Package, error) { 160 wd, err := os.Getwd() 161 if err != nil { 162 return nil, err 163 } 164 165 return build.Import(path, wd, build.ImportComment) 166 } 167 168 func loadPackage(dir string) (*lang.Package, error) { 169 buildPkg, err := getBuildPackage(dir) 170 if err != nil { 171 return nil, err 172 } 173 174 log := logger.New(logger.ErrorLevel) 175 pkg, err := lang.NewPackageFromBuild(log, buildPkg) 176 if err != nil { 177 return nil, err 178 } 179 180 return pkg, nil 181 }