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 }