github.com/aca02djr/gb@v0.4.1/importer/importer_test.go (about)

     1  package importer
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  	"path/filepath"
     7  	"reflect"
     8  	"runtime"
     9  	"syscall"
    10  	"testing"
    11  )
    12  
    13  func TestImporter(t *testing.T) {
    14  	patherr := func(path string) error {
    15  		op := "stat"
    16  		if runtime.GOOS == "windows" {
    17  			op = "GetFileAttributesEx"
    18  		}
    19  		return &os.PathError{
    20  			Op:   op,
    21  			Path: path,
    22  			Err:  syscall.ENOENT,
    23  		}
    24  	}
    25  	tests := []struct {
    26  		Importer
    27  		path string
    28  		want *Package
    29  		err  error
    30  	}{{
    31  		Importer: Importer{},
    32  		path:     "",
    33  		err:      fmt.Errorf("import %q: invalid import path", ""),
    34  	}, {
    35  		Importer: Importer{},
    36  		path:     ".",
    37  		err:      fmt.Errorf("import %q: relative import not supported", "."),
    38  	}, {
    39  		Importer: Importer{},
    40  		path:     "..",
    41  		err:      fmt.Errorf("import %q: relative import not supported", ".."),
    42  	}, {
    43  		Importer: Importer{},
    44  		path:     "./",
    45  		err:      fmt.Errorf("import %q: relative import not supported", "./"),
    46  	}, {
    47  		Importer: Importer{},
    48  		path:     "../",
    49  		err:      fmt.Errorf("import %q: relative import not supported", "../"),
    50  	}, {
    51  		Importer: Importer{},
    52  		path:     "/foo",
    53  		err:      fmt.Errorf("import %q: cannot import absolute path", "/foo"),
    54  	}, {
    55  		Importer: Importer{
    56  			Context: &Context{
    57  				GOOS:   "linux",
    58  				GOARCH: "amd64",
    59  			},
    60  			Root: filepath.Join(runtime.GOROOT()),
    61  		},
    62  		path: "errors",
    63  		want: &Package{
    64  			ImportPath: "errors",
    65  			Name:       "errors", // no yet
    66  			Dir:        filepath.Join(runtime.GOROOT(), "src", "errors"),
    67  			Root:       filepath.Join(runtime.GOROOT()),
    68  			SrcRoot:    filepath.Join(runtime.GOROOT(), "src"),
    69  			Standard:   true,
    70  
    71  			GoFiles:      []string{"errors.go"},
    72  			XTestGoFiles: []string{"errors_test.go", "example_test.go"},
    73  			XTestImports: []string{"errors", "fmt", "testing", "time"},
    74  		},
    75  	}, {
    76  		Importer: Importer{
    77  			Context: &Context{
    78  				GOOS:   "linux",
    79  				GOARCH: "amd64",
    80  			},
    81  			Root: filepath.Join(runtime.GOROOT()),
    82  		},
    83  		path: "database",
    84  		err:  &NoGoError{filepath.Join(runtime.GOROOT(), "src", "database")},
    85  	}, {
    86  		Importer: Importer{
    87  			Context: &Context{
    88  				GOOS:   "linux",
    89  				GOARCH: "amd64",
    90  			},
    91  			Root: filepath.Join(runtime.GOROOT()),
    92  		},
    93  		path: "missing",
    94  		err:  patherr(filepath.Join(runtime.GOROOT(), "src", "missing")),
    95  	}, {
    96  		Importer: Importer{
    97  			Context: &Context{
    98  				GOOS:       "linux",
    99  				GOARCH:     "amd64",
   100  				CgoEnabled: true,
   101  			},
   102  			Root: filepath.Join(runtime.GOROOT()),
   103  		},
   104  		path: "net",
   105  	}, {
   106  		Importer: Importer{
   107  			Context: &Context{
   108  				GOOS:       "linux",
   109  				GOARCH:     "amd64",
   110  				CgoEnabled: true,
   111  			},
   112  			Root: filepath.Join(runtime.GOROOT()),
   113  		},
   114  		path: "os/user",
   115  	}}
   116  
   117  	for _, tt := range tests {
   118  		got, err := tt.Import(tt.path)
   119  		if !reflect.DeepEqual(err, tt.err) {
   120  			t.Errorf("Import(%q): got err %v, want err %v", tt.path, err, tt.err)
   121  		}
   122  
   123  		if err != nil {
   124  			continue
   125  		}
   126  
   127  		if tt.want == nil {
   128  			t.Logf("Import(%q): skipping package contents check", tt.path)
   129  			continue
   130  		}
   131  
   132  		// fixups
   133  		want := tt.want
   134  		want.importer = got.importer
   135  		got.ImportPos = nil
   136  		got.TestImportPos = nil
   137  		got.XTestImportPos = nil
   138  
   139  		if !reflect.DeepEqual(got, want) {
   140  			t.Errorf("Import(%q): got %#v, want %#v", tt.path, got, want)
   141  		}
   142  	}
   143  }