github.com/anthonyme00/gomarkdoc@v1.0.0/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/anthonyme00/gomarkdoc/lang"
    11  	"github.com/anthonyme00/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/anthonyme00/gomarkdoc/testData/lang/function"`)
    60  	is.Equal(pkg.ImportPath(), `github.com/princjef/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  }