play around with default resolver tests

Chatterino · Apr 23, 2022 · 87687e3 · 87687e3
1 parent d82b13a
commit 87687e3
Show file tree

Hide file tree

Showing 5 changed files with 178 additions and 8 deletions.
diff --git a/internal/resolvers/betterttv/emote_resolver_test.go b/internal/resolvers/betterttv/emote_resolver_test.go
@@ -93,8 +93,6 @@ func TestEmoteResolver(t *testing.T) {
 				},
 			}
 
-			const q = `SELECT value FROM cache WHERE key=$1`
-
 			for _, test := range tests {
 				c.Run(test.label, func(c *qt.C) {
 					outputBytes, outputError := resolver.Run(ctx, test.inputURL, test.inputReq)
@@ -141,8 +139,6 @@ func TestEmoteResolver(t *testing.T) {
 				},
 			}
 
-			const q = `SELECT value FROM cache WHERE key=$1`
-
 			for _, test := range tests {
 				c.Run(test.label, func(c *qt.C) {
 					rows := pgxmock.NewRows([]string{"value"}).AddRow(test.expectedBytes)
@@ -194,8 +190,6 @@ func TestEmoteResolver(t *testing.T) {
 				},
 			}
 
-			const q = `SELECT value FROM cache WHERE key=$1`
-
 			for _, test := range tests {
 				c.Run(test.label, func(c *qt.C) {
 					pool.ExpectQuery("SELECT").WillReturnError(pgx.ErrNoRows)

diff --git a/internal/resolvers/default/link_resolver_test.go b/internal/resolvers/default/link_resolver_test.go
@@ -0,0 +1,120 @@
+package defaultresolver
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"regexp"
+	"testing"
+
+	"github.com/Chatterino/api/internal/logger"
+	"github.com/Chatterino/api/pkg/config"
+	"github.com/Chatterino/api/pkg/resolver"
+	qt "github.com/frankban/quicktest"
+	"github.com/go-chi/chi/v5"
+	"github.com/jackc/pgx/v4"
+	"github.com/pashagolub/pgxmock"
+)
+
+func newRequest(t *testing.T, ctx context.Context, method string, url string, payload io.Reader) *http.Request {
+	req, err := http.NewRequestWithContext(ctx, method, url, payload)
+	if err != nil {
+		t.Fatal("Unable to create request")
+	}
+
+	return req
+}
+
+func newLinkResolverRequest(t *testing.T, ctx context.Context, method string, u string, payload io.Reader) *http.Request {
+	finalURL := "/link_resolver/" + url.QueryEscape(u)
+	fmt.Println("Final URL", finalURL)
+	req, err := http.NewRequestWithContext(ctx, method, finalURL, payload)
+	if err != nil {
+		t.Fatal("Unable to create request")
+	}
+
+	return req
+}
+
+func TestLinkResolver(t *testing.T) {
+	ctx := logger.OnContext(context.Background(), logger.NewTest())
+	c := qt.New(t)
+
+	cfg := config.APIConfig{
+		MaxContentLength: 1024,
+	}
+	pool, _ := pgxmock.NewPool()
+
+	resolver.InitializeStaticResponses(ctx, cfg)
+
+	router := chi.NewRouter()
+
+	r := New(ctx, cfg, pool, nil)
+
+	router.Get("/link_resolver/{url}", r.HandleRequest)
+	router.Get("/thumbnail/{url}", r.HandleThumbnailRequest)
+
+	var resolverResponses = map[string]string{}
+
+	resolverResponses["/"] = "<html><head><title>/ title</title></head><body>xD</body></html>"
+
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if response, ok := resolverResponses[r.URL.Path]; ok {
+			w.Write([]byte(response))
+			return
+		}
+		http.Error(w, http.StatusText(404), 404)
+	}))
+	defer ts.Close()
+
+	c.Run("Request", func(c *qt.C) {
+		tests := []struct {
+			inputReq     *http.Request
+			inputLinkKey string
+			expected     resolver.Response
+		}{
+			{
+				inputReq:     newLinkResolverRequest(t, ctx, "GET", ts.URL, nil),
+				inputLinkKey: ts.URL,
+				expected: resolver.Response{
+					Status:  200,
+					Link:    ts.URL,
+					Tooltip: `.*`,
+				},
+			},
+		}
+
+		for _, test := range tests {
+			c.Run("", func(c *qt.C) {
+				respRec := httptest.NewRecorder()
+
+				pool.ExpectQuery("SELECT").WillReturnError(pgx.ErrNoRows)
+				pool.ExpectExec("INSERT INTO cache").
+					WithArgs("default:link:"+test.inputLinkKey, pgxmock.AnyArg(), pgxmock.AnyArg()).
+					WillReturnResult(pgxmock.NewResult("INSERT", 1))
+
+				router.ServeHTTP(respRec, test.inputReq)
+				resp := respRec.Result()
+				response := resolver.Response{}
+				err := json.NewDecoder(resp.Body).Decode(&response)
+				c.Assert(err, qt.IsNil)
+
+				c.Assert(response.Status, qt.Equals, test.expected.Status)
+				c.Assert(response.Link, qt.Equals, test.expected.Link)
+
+				unescapedTooltip, err := url.QueryUnescape(response.Tooltip)
+				c.Assert(err, qt.IsNil)
+
+				fmt.Println(unescapedTooltip)
+				fmt.Println(test.expected.Tooltip)
+				c.Assert("asd\nasd", qt.Matches, regexp.MustCompile(`.*`))
+
+				c.Assert(pool.ExpectationsWereMet(), qt.IsNil)
+			})
+		}
+	})
+}
diff --git a/internal/resolvers/default/model_test.go b/internal/resolvers/default/model_test.go
@@ -0,0 +1,56 @@
+package defaultresolver
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestTooltipData(t *testing.T) {
+	c := qt.New(t)
+
+	c.Run("Truncate", func(c *qt.C) {
+		tests := []struct {
+			input    tooltipData
+			expected tooltipData
+		}{
+			{
+				input: tooltipData{
+					Title:       "foo",
+					Description: "bar",
+				},
+				expected: tooltipData{
+					Title:       "foo",
+					Description: "bar",
+				},
+			},
+			{
+				input: tooltipData{
+					Title:       "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxy",
+					Description: "bar",
+				},
+				expected: tooltipData{
+					Title:       "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxy",
+					Description: "bar",
+				},
+			},
+			{
+				input: tooltipData{
+					Title:       "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyz",
+					Description: "bar",
+				},
+				expected: tooltipData{
+					Title:       "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx…",
+					Description: "bar",
+				},
+			},
+		}
+
+		for _, test := range tests {
+			c.Run("", func(c *qt.C) {
+				test.input.Truncate()
+				c.Assert(test.input, qt.DeepEquals, test.expected)
+			})
+		}
+	})
+}
diff --git a/pkg/utils/string.go b/pkg/utils/string.go
@@ -5,7 +5,7 @@ import "strings"
 // TruncateString truncates string down to the maximum length with a unicode triple dot if truncation took place
 func TruncateString(s string, maxLength int) string {
 	runes := []rune(s)
-	if len(runes) < maxLength {
+	if len(runes) <= maxLength {
 		return s
 	}
 

diff --git a/pkg/utils/string_test.go b/pkg/utils/string_test.go
@@ -22,7 +22,7 @@ func TestTruncateString(t *testing.T) {
 		{
 			input:          "foobar",
 			maxLength:      6,
-			expectedOutput: "fooba…",
+			expectedOutput: "foobar",
 		},
 		{
 			input:          "foobar",