Merge pull request #27 from x1unix/dev

Add some unit tests

Author: x1unix

.coveralls.yml

@@ -4,3 +4,4 @@
 node_modules
 /public/
 /target/
+*.out

.gitignore

@@ -0,0 +1,19 @@
+language: go
+
+go:
+  - "1.14.x"
+
+branches:
+  only:
+#    - master
+    - dev
+env:
+  - GO111MODULE=on
+install: true
+before_install:
+  - go get golang.org/x/tools/cmd/cover
+  - go get github.com/mattn/goveralls
+script:
+  - go list ./... | grep -v worker | xargs go vet
+  - cat tools/cover.txt | xargs go test -v -covermode=count -coverprofile=coverage.out
+  - $HOME/gopath/bin/goveralls -coverprofile=coverage.out -service=travis-ci -repotoken $COVERALLS_TOKEN

.travis.yml

@@ -19,3 +19,7 @@ run:
 ui:
 	@cd $(UI) && REACT_APP_LANG_SERVER=http://$(LISTEN_ADDR) REACT_APP_GTAG=$(GTAG) REACT_APP_VERSION=testing yarn start
 
+.PHONY: cover
+cover:
+	@cat tools/cover.txt | xargs go test -v -covermode=count -coverprofile=/tmp/cover.out && \
+	go tool cover -html=/tmp/cover.out

Makefile

@@ -1,14 +1,12 @@
-<p style="text-align: center;">
-	
 # Better Go Playground
 
+[![Build Status](https://travis-ci.org/x1unix/go-playground.svg?branch=master)](https://travis-ci.org/x1unix/go-playground) 
 [![Coverage Status](https://coveralls.io/repos/github/x1unix/go-playground/badge.svg?branch=master)](https://coveralls.io/github/x1unix/go-playground?branch=master)
 [![Goreportcard](https://goreportcard.com/badge/github.com/x1unix/go-playground)](https://goreportcard.com/report/github.com/x1unix/go-playground)
 
 Improved Go Playground powered by Monaco Editor and React
 
 ![alt text](./docs/demo.gif)
-</p>
 
 ## Features
 
@@ -23,7 +21,7 @@ And more
 
 ## Demo
 
-[http://goplay.tools/](goplay.tools)
+[https://goplay.tools/](https://goplay.tools)
 
 ## Installation
 

README.md

@@ -0,0 +1,123 @@
+package analyzer
+
+import (
+	"github.com/stretchr/testify/require"
+	"github.com/x1unix/go-playground/pkg/testutil"
+	"testing"
+)
+
+func TestSetLogger(t *testing.T) {
+	l := testutil.GetLogger(t).Desugar()
+	SetLogger(l)
+}
+
+func TestSetRoot(t *testing.T) {
+	root := "/go"
+	SetRoot(root)
+	require.Equal(t, root, goRoot)
+}
+
+func TestReadPackagesFile(t *testing.T) {
+	cases := map[string]struct {
+		file string
+		want []*Package
+		err  string
+	}{
+		"valid package": {
+			file: "pkg1.json",
+			want: []*Package{
+				{
+					Name:     "time",
+					Synopsis: "Package time provides functionality for measuring and displaying time.\n\n[\"time\" on pkg.go.dev](https://pkg.go.dev/time/)",
+					URL:      "https://pkg.go.dev/time/",
+					Path:     "time",
+				},
+				{
+					Name:     "unicode",
+					Synopsis: "Package unicode provides data and functions to test some properties of Unicode code points.\n\n[\"unicode\" on pkg.go.dev](https://pkg.go.dev/unicode/)",
+					URL:      "https://pkg.go.dev/unicode/",
+					Path:     "unicode",
+					Children: []*Package{
+						{
+							Name:     "utf16",
+							Synopsis: "Package utf16 implements encoding and decoding of UTF-16 sequences.\n\n[\"unicode/utf16\" on pkg.go.dev](https://pkg.go.dev/unicode/utf16/)",
+							URL:      "https://pkg.go.dev/unicode/utf16/",
+							Path:     "unicode/utf16",
+						},
+						{
+							Name:     "utf8",
+							Synopsis: "Package utf8 implements functions and constants to support text encoded in UTF-8.\n\n[\"unicode/utf8\" on pkg.go.dev](https://pkg.go.dev/unicode/utf8/)",
+							URL:      "https://pkg.go.dev/unicode/utf8/",
+							Path:     "unicode/utf8",
+						},
+					},
+				},
+			},
+		},
+		"bad JSON": {
+			file: "bad.txt",
+			err:  "invalid character",
+		},
+		"invalid file": {
+			file: "foobar",
+			err:  "no such file",
+		},
+	}
+
+	for n, c := range cases {
+		t.Run(n, func(t *testing.T) {
+			got, err := ReadPackagesFile(testutil.TestdataPath(c.file))
+			if c.err != "" {
+				testutil.ContainsError(t, err, c.err)
+				return
+			}
+			require.NoError(t, err)
+			require.Equal(t, c.want, got)
+		})
+	}
+}
+
+func TestBuildPackageIndex(t *testing.T) {
+	pkgs, err := ReadPackagesFile(testutil.TestdataPath("pkg2.json"))
+	require.NoError(t, err)
+	index := BuildPackageIndex(pkgs)
+	require.Equal(t, pkgs, index.Packages)
+	require.Equal(t, len(pkgs), index.Len())
+
+	expectSymbols := make(map[string][]*CompletionItem, len(pkgs))
+
+	for _, pkg := range pkgs {
+		got, ok := index.PackageByName(pkg.Name)
+		require.True(t, ok)
+		require.Equal(t, pkg, got)
+
+		char := string(pkg.Name[0])
+		expectSymbols[char] = append(expectSymbols[char], &CompletionItem{
+			Label:         pkg.Name,
+			Kind:          Module,
+			Detail:        pkg.Name,
+			Documentation: pkg.documentation(),
+			InsertText:    pkg.Name,
+		})
+
+		for _, child := range pkg.Children {
+			got, ok := index.PackageByName(child.Name)
+			require.True(t, ok)
+			require.Equal(t, child, got)
+
+			char := string(pkg.Name[0])
+			expectSymbols[char] = append(expectSymbols[char], &CompletionItem{
+				Label:         child.Name,
+				Kind:          Module,
+				Detail:        child.Name,
+				Documentation: child.documentation(),
+				InsertText:    child.Name,
+			})
+		}
+	}
+
+	for char, expect := range expectSymbols {
+		match := index.Match(char)
+		require.Equal(t, expect, match)
+	}
+}

pkg/analyzer/analyzer_test.go

@@ -0,0 +1,87 @@
+package analyzer
+
+import (
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestPackage_IsBuiltin(t *testing.T) {
+	pkg1 := Package{Name: "foo"}
+	pkg2 := Package{Name: "builtin"}
+	require.False(t, pkg1.IsBuiltin())
+	require.True(t, pkg2.IsBuiltin())
+}
+
+func TestPackage_GetLocation(t *testing.T) {
+	SetRoot("/")
+	want := "/src/foo/bar"
+	pkg := Package{Path: "foo/bar"}
+	require.Equal(t, want, pkg.GetLocation())
+}
+
+func TestPackage_SymbolByChar(t *testing.T) {
+	funcs := &CompletionItem{Label: "bar", Kind: Function}
+	syms := &CompletionItem{Label: "baz", Kind: Constant}
+
+	allFuncs := []*CompletionItem{{Label: "aaaa", Kind: Function}, funcs}
+	allSyms := []*CompletionItem{{Label: "xxxx", Kind: Constant}, syms}
+	pkg := Package{
+		Synopsis: "test doc",
+		PackageSummary: PackageSummary{
+			Functions: newSymbolIndex(allFuncs),
+			Values:    newSymbolIndex(allSyms),
+		},
+	}
+
+	require.Equal(t, MarkdownString{Value: "test doc"}, pkg.documentation())
+	wantByChar := []*CompletionItem{funcs, syms}
+	gotChar := pkg.SymbolByChar("b")
+	require.Equal(t, wantByChar, gotChar)
+
+	wantAll := make([]*CompletionItem, 0, len(allSyms)+len(allFuncs))
+	wantAll = append(wantAll, allFuncs...)
+	wantAll = append(wantAll, allSyms...)
+	gotAll := pkg.AllSymbols()
+	require.Equal(t, wantAll, gotAll)
+}
+
+func TestPackages_GetCompletionItems(t *testing.T) {
+	want := []*CompletionItem{
+		{
+			Label:         "a",
+			Kind:          Module,
+			Detail:        "a",
+			InsertText:    "a",
+			Documentation: MarkdownString{},
+		},
+		{
+			Label:         "b",
+			Kind:          Module,
+			Detail:        "b",
+			InsertText:    "b",
+			Documentation: MarkdownString{},
+		},
+	}
+
+	pkgs := make(Packages, 0, len(want))
+	for _, sym := range want {
+		pkgs = append(pkgs, &Package{
+			Name: sym.Label,
+		})
+	}
+
+	got := pkgs.GetCompletionItems()
+	require.Equal(t, want, got)
+}
+
+func TestPackage_HasChildren(t *testing.T) {
+	pkg := Package{Children: make([]*Package, 2)}
+	require.True(t, pkg.HasChildren())
+
+	pkg.Children = nil
+	require.False(t, pkg.HasChildren())
+}
+
+func TestPackage_AllSymbols(t *testing.T) {
+
+}

pkg/analyzer/package_test.go

@@ -0,0 +1,46 @@
+package analyzer
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestSymbolIndex(t *testing.T) {
+	syms := []*CompletionItem{
+		{Label: "foo"},
+		{Label: "bar"},
+		{Label: "baz"},
+	}
+
+	index := newSymbolIndex(syms)
+	require.Equal(t, syms, index.Symbols)
+	require.Equal(t, len(syms), index.Len())
+
+	expectSymbols := make(map[string][]*CompletionItem, len(syms))
+
+	for _, s := range syms {
+		got := index.SymbolByName(s.Label)
+		require.NotNil(t, got)
+		require.Equal(t, s, got)
+
+		char := string(s.Label[0])
+		expectSymbols[char] = append(expectSymbols[char], s)
+	}
+
+	for char, expect := range expectSymbols {
+		match := index.Match(char)
+		require.Equal(t, expect, match)
+	}
+}
+
+func TestSymbolIndex_Append(t *testing.T) {
+	idx := emptySymbolIndex()
+	sym := &CompletionItem{Label: "test"}
+	idx.Append(sym)
+	idx.Append(nil)
+	require.Equal(t, 1, idx.Len())
+	got := idx.SymbolByName(sym.Label)
+	require.NotNil(t, got)
+	require.Equal(t, sym, got)
+}

pkg/analyzer/sym_index_test.go

@@ -0,0 +1 @@
+badval

pkg/analyzer/testdata/bad.txt

@@ -0,0 +1,32 @@
+[
+  {
+    "name": "time",
+    "synopsis": "Package time provides functionality for measuring and displaying time.\n\n[\"time\" on pkg.go.dev](https://pkg.go.dev/time/)",
+    "url": "https://pkg.go.dev/time/",
+    "path": "time",
+    "depth": 0
+  },
+  {
+    "name": "unicode",
+    "synopsis": "Package unicode provides data and functions to test some properties of Unicode code points.\n\n[\"unicode\" on pkg.go.dev](https://pkg.go.dev/unicode/)",
+    "url": "https://pkg.go.dev/unicode/",
+    "path": "unicode",
+    "depth": 0,
+    "children": [
+      {
+        "name": "utf16",
+        "synopsis": "Package utf16 implements encoding and decoding of UTF-16 sequences.\n\n[\"unicode/utf16\" on pkg.go.dev](https://pkg.go.dev/unicode/utf16/)",
+        "url": "https://pkg.go.dev/unicode/utf16/",
+        "path": "unicode/utf16",
+        "depth": 20
+      },
+      {
+        "name": "utf8",
+        "synopsis": "Package utf8 implements functions and constants to support text encoded in UTF-8.\n\n[\"unicode/utf8\" on pkg.go.dev](https://pkg.go.dev/unicode/utf8/)",
+        "url": "https://pkg.go.dev/unicode/utf8/",
+        "path": "unicode/utf8",
+        "depth": 20
+      }
+    ]
+  }
+]