func TestAll(t *testing.T) {
dir, err := packages.GetDirFromPackage(context.Background(), "kego.io")
require.NoError(t, err)
// walk each file in the working directory
walker := func(path string, file os.FileInfo, err error) error {
// skip anything starting with a period, or not ending in .go.
if strings.HasPrefix(path, ".") || !strings.HasSuffix(path, ".go") {
return nil
}
return walkFile(path, t)
}
filepath.Walk(dir, walker)
untested := map[string][]string{}
for id, def := range all {
if !def.thrown && (def.tested || def.skipped) {
// Well, if the test isn't thrown the test should fail. Let's test
// for it here anyway.
assert.Fail(t, "Error tested but not thrown", id)
}
if def.thrown && def.new && !def.tested && !def.skipped {
arr, ok := untested[def.pkg]
if !ok {
arr = []string{}
}
untested[def.pkg] = append(arr, id)
}
}
//for pkg, def := range pkgs {
// if !def.tested && !def.notest {
//assert.Fail(t, fmt.Sprintf("%s has no tests.", pkg))
// }
//}
if len(untested) > 0 {
for pkg, tests := range untested {
assert.Fail(t, fmt.Sprintf("Errors thrown in %s but not tested: %v", pkg, tests))
}
}
}
func ScanForEnv(ctx context.Context, path string) (env *envctx.Env, err error) {
// Scan the local directory for as system:package object
dir, err := packages.GetDirFromPackage(ctx, path)
if err != nil {
return nil, kerr.Wrap("LASRFKILIH", err)
}
env = &envctx.Env{Path: path, Aliases: map[string]string{}, Recursive: false, Dir: dir}
pkg, err := scanForPackage(ctx, env)
if err != nil {
return nil, kerr.Wrap("DTAEUSHJTQ", err)
}
if pkg != nil {
env.Aliases = pkg.Aliases
env.Recursive = pkg.Recursive
}
return env, nil
}
func TestKego(t *testing.T) {
ctx := ke.NewContext(context.Background(), "kego.io/system", nil)
_, err := ke.Open(ctx, "")
assert.IsError(t, err, "CXIULJCEBE")
systemDir, err := packages.GetDirFromPackage(ctx, "kego.io/system")
require.NoError(t, err)
i, err := ke.Open(ctx, filepath.Join(systemDir, "type.json"))
require.NoError(t, err)
_, ok := i.(*system.Type)
assert.True(t, ok)
b, err := ioutil.ReadFile(filepath.Join(systemDir, "type.json"))
require.NoError(t, err)
var i1 interface{}
err = ke.Unmarshal(ctx, b, &i1)
require.NoError(t, err)
_, ok = i1.(*system.Type)
assert.True(t, ok)
r := &system.Reference{}
err = ke.Unmarshal(ctx, []byte(`"type"`), r)
require.NoError(t, err)
assert.Equal(t, *system.NewReference("kego.io/system", "type"), *r)
b3, err := ke.Marshal(ctx, system.NewReference("kego.io/system", "type"))
require.NoError(t, err)
assert.Equal(t, "{\"type\":\"reference\",\"value\":\"type\"}", string(b3))
b4, err := ke.MarshalIndent(ctx, &system.Package{Recursive: true}, "", " ")
require.NoError(t, err)
assert.Equal(t, "{\n \"recursive\": true\n}", string(b4))
}
func parse(ctx context.Context, path string, queue []string) (*sysctx.SysPackageInfo, error) {
scache := sysctx.FromContext(ctx)
cmd := cmdctx.FromContext(ctx)
for _, q := range queue {
if q == path {
return nil, kerr.New("SCSCFJPPHD", "Circular import %v -> %v", queue, path)
}
}
if _, found := scache.Get("kego.io/json"); !found {
system.RegisterJsonTypes(ctx)
}
hash := &PackageHasher{Path: path, Aliases: map[string]string{}, Types: map[string]uint64{}, Exports: map[string]uint64{}}
importPackage := func(importPath string, importAlias string) error {
if _, found := scache.Get(importPath); !found {
_, err := parse(ctx, importPath, append(queue, path))
if err != nil {
return kerr.Wrap("RIARRSCMVE", err)
}
}
hash.Aliases[importAlias] = importPath
return nil
}
packageDirectoryExists := true
_, err := packages.GetDirFromPackage(ctx, path)
if err != nil {
_, ok := kerr.Source(err).(gopackages.NotFoundError)
if ok {
packageDirectoryExists = false
}
}
if !packageDirectoryExists || cmd.Update {
if err := GoGet(ctx, path); err != nil {
return nil, kerr.Wrap("SBALWXUPKN", err)
}
}
env, err := ScanForEnv(ctx, path)
if err != nil {
return nil, kerr.Wrap("GJRHNGGWFD", err)
}
// Always scan the system package first if we don't have it already
if path != "kego.io/system" {
if err := importPackage("kego.io/system", "system"); err != nil {
return nil, kerr.Wrap("ORRCDNUPOX", err)
}
}
for aliasName, aliasPath := range env.Aliases {
if aliasPath == "kego.io/system" || aliasName == "system" {
return nil, kerr.New("EWMLNJDXKC", "Illegal import %s", aliasName)
}
if err := importPackage(aliasPath, aliasName); err != nil {
return nil, kerr.Wrap("NOVMGYKHHI", err)
}
}
pcache := scache.SetEnv(env)
cmd.Printf("Parsing %s...", path)
if err := scanForTypesAndExports(ctx, env, pcache, hash); err != nil {
return nil, kerr.Wrap("VFUNPHUFHD", err)
}
cmd.Println(" OK.")
h, err := hash.Hash()
if err != nil {
return nil, kerr.Wrap("MIODRYNEJQ", err)
}
env.Hash = h
return pcache, nil
}
