chore: remove server tests

test/server/auth_test.go

@@ -1,96 +0,0 @@
-package testserver
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"testing"
-
-	"github.com/pkg/errors"
-	"github.com/stretchr/testify/require"
-
-	apiv1 "github.com/usememos/memos/api/v1"
-)
-
-func TestAuthServer(t *testing.T) {
-	ctx := context.Background()
-	s, err := NewTestingServer(ctx, t)
-	require.NoError(t, err)
-	defer s.Shutdown(ctx)
-
-	signup := &apiv1.SignUp{
-		Username: "testuser",
-		Password: "testpassword",
-	}
-	user, err := s.postAuthSignUp(signup)
-	require.NoError(t, err)
-	require.Equal(t, signup.Username, user.Username)
-
-	signin := &apiv1.SignIn{
-		Username: "testuser",
-		Password: "testpassword",
-	}
-	user, err = s.postAuthSignIn(signin)
-	require.NoError(t, err)
-	require.Equal(t, signup.Username, user.Username)
-	err = s.postSignOut()
-	require.NoError(t, err)
-	_, err = s.getCurrentUser()
-	require.Error(t, err)
-}
-
-func (s *TestingServer) postAuthSignUp(signup *apiv1.SignUp) (*apiv1.User, error) {
-	rawData, err := json.Marshal(&signup)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshal signup")
-	}
-	reader := bytes.NewReader(rawData)
-	body, err := s.post("/api/v1/auth/signup", reader, nil)
-	if err != nil {
-		return nil, errors.Wrap(err, "fail to post request")
-	}
-
-	buf := &bytes.Buffer{}
-	_, err = buf.ReadFrom(body)
-	if err != nil {
-		return nil, errors.Wrap(err, "fail to read response body")
-	}
-
-	user := &apiv1.User{}
-	if err = json.Unmarshal(buf.Bytes(), user); err != nil {
-		return nil, errors.Wrap(err, "fail to unmarshal post signup response")
-	}
-	return user, nil
-}
-
-func (s *TestingServer) postAuthSignIn(signip *apiv1.SignIn) (*apiv1.User, error) {
-	rawData, err := json.Marshal(&signip)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshal signin")
-	}
-	reader := bytes.NewReader(rawData)
-	body, err := s.post("/api/v1/auth/signin", reader, nil)
-	if err != nil {
-		return nil, errors.Wrap(err, "fail to post request")
-	}
-
-	buf := &bytes.Buffer{}
-	_, err = buf.ReadFrom(body)
-	if err != nil {
-		return nil, errors.Wrap(err, "fail to read response body")
-	}
-
-	user := &apiv1.User{}
-	if err = json.Unmarshal(buf.Bytes(), user); err != nil {
-		return nil, errors.Wrap(err, "fail to unmarshal post signin response")
-	}
-	return user, nil
-}
-
-func (s *TestingServer) postSignOut() error {
-	_, err := s.post("/api/v1/auth/signout", nil, nil)
-	if err != nil {
-		return errors.Wrap(err, "fail to post request")
-	}
-	return nil
-}

test/server/memo_relation_test.go

@@ -1,92 +0,0 @@
-package testserver
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"testing"
-
-	"github.com/pkg/errors"
-	"github.com/stretchr/testify/require"
-
-	apiv1 "github.com/usememos/memos/api/v1"
-)
-
-func TestMemoRelationServer(t *testing.T) {
-	ctx := context.Background()
-	s, err := NewTestingServer(ctx, t)
-	require.NoError(t, err)
-	defer s.Shutdown(ctx)
-
-	signup := &apiv1.SignUp{
-		Username: "testuser",
-		Password: "testpassword",
-	}
-	user, err := s.postAuthSignUp(signup)
-	require.NoError(t, err)
-	require.Equal(t, signup.Username, user.Username)
-	memo, err := s.postMemoCreate(&apiv1.CreateMemoRequest{
-		Content: "test memo",
-	})
-	require.NoError(t, err)
-	require.Equal(t, "test memo", memo.Content)
-	memo2, err := s.postMemoCreate(&apiv1.CreateMemoRequest{
-		Content: "test memo2",
-		RelationList: []*apiv1.UpsertMemoRelationRequest{
-			{
-				RelatedMemoID: memo.ID,
-				Type:          apiv1.MemoRelationReference,
-			},
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, "test memo2", memo2.Content)
-	memoList, err := s.getMemoList()
-	require.NoError(t, err)
-	require.Len(t, memoList, 2)
-	require.Len(t, memo2.RelationList, 1)
-	err = s.deleteMemoRelation(memo2.ID, memo.ID, apiv1.MemoRelationReference)
-	require.NoError(t, err)
-	memo2, err = s.getMemo(memo2.ID)
-	require.NoError(t, err)
-	require.Len(t, memo2.RelationList, 0)
-	memoRelation, err := s.postMemoRelationUpsert(memo2.ID, &apiv1.UpsertMemoRelationRequest{
-		RelatedMemoID: memo.ID,
-		Type:          apiv1.MemoRelationReference,
-	})
-	require.NoError(t, err)
-	require.Equal(t, memo.ID, memoRelation.RelatedMemoID)
-	memo2, err = s.getMemo(memo2.ID)
-	require.NoError(t, err)
-	require.Len(t, memo2.RelationList, 1)
-}
-
-func (s *TestingServer) postMemoRelationUpsert(memoID int32, memoRelationUpsert *apiv1.UpsertMemoRelationRequest) (*apiv1.MemoRelation, error) {
-	rawData, err := json.Marshal(&memoRelationUpsert)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshal memo relation upsert")
-	}
-	reader := bytes.NewReader(rawData)
-	body, err := s.post(fmt.Sprintf("/api/v1/memo/%d/relation", memoID), reader, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	buf := &bytes.Buffer{}
-	_, err = buf.ReadFrom(body)
-	if err != nil {
-		return nil, errors.Wrap(err, "fail to read response body")
-	}
-
-	memoRelation := &apiv1.MemoRelation{}
-	if err = json.Unmarshal(buf.Bytes(), memoRelation); err != nil {
-		return nil, errors.Wrap(err, "fail to unmarshal post memo relation upsert response")
-	}
-	return memoRelation, nil
-}
-
-func (s *TestingServer) deleteMemoRelation(memoID int32, relatedMemoID int32, relationType apiv1.MemoRelationType) error {
-	_, err := s.delete(fmt.Sprintf("/api/v1/memo/%d/relation/%d/type/%s", memoID, relatedMemoID, relationType), nil)
-	return err
-}

test/server/memo_test.go

@@ -1,176 +0,0 @@
-package testserver
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"testing"
-
-	"github.com/pkg/errors"
-	"github.com/stretchr/testify/require"
-
-	apiv1 "github.com/usememos/memos/api/v1"
-)
-
-func TestMemoServer(t *testing.T) {
-	ctx := context.Background()
-	s, err := NewTestingServer(ctx, t)
-	require.NoError(t, err)
-	defer s.Shutdown(ctx)
-
-	signup := &apiv1.SignUp{
-		Username: "testuser",
-		Password: "testpassword",
-	}
-	user, err := s.postAuthSignUp(signup)
-	require.NoError(t, err)
-	require.Equal(t, signup.Username, user.Username)
-	memo, err := s.postMemoCreate(&apiv1.CreateMemoRequest{
-		Content: "test memo",
-	})
-	require.NoError(t, err)
-	require.Equal(t, "test memo", memo.Content)
-	memoList, err := s.getMemoList()
-	require.NoError(t, err)
-	require.Len(t, memoList, 1)
-	updatedContent := "updated memo"
-	memo, err = s.patchMemo(&apiv1.PatchMemoRequest{
-		ID:      memo.ID,
-		Content: &updatedContent,
-	})
-	require.NoError(t, err)
-	require.Equal(t, updatedContent, memo.Content)
-	require.Equal(t, false, memo.Pinned)
-	_, err = s.postMemoOrganizer(memo.ID, &apiv1.UpsertMemoOrganizerRequest{
-		Pinned: true,
-	})
-	require.NoError(t, err)
-	memo, err = s.patchMemo(&apiv1.PatchMemoRequest{
-		ID:      memo.ID,
-		Content: &updatedContent,
-	})
-	require.NoError(t, err)
-	require.Equal(t, updatedContent, memo.Content)
-	require.Equal(t, true, memo.Pinned)
-	err = s.deleteMemo(memo.ID)
-	require.NoError(t, err)
-	memoList, err = s.getMemoList()
-	require.NoError(t, err)
-	require.Len(t, memoList, 0)
-}
-
-func (s *TestingServer) getMemo(memoID int32) (*apiv1.Memo, error) {
-	body, err := s.get(fmt.Sprintf("/api/v1/memo/%d", memoID), nil)
-	if err != nil {
-		return nil, err
-	}
-
-	buf := &bytes.Buffer{}
-	_, err = buf.ReadFrom(body)
-	if err != nil {
-		return nil, errors.Wrap(err, "fail to read response body")
-	}
-
-	memo := &apiv1.Memo{}
-	if err = json.Unmarshal(buf.Bytes(), memo); err != nil {
-		return nil, errors.Wrap(err, "fail to unmarshal get memo response")
-	}
-	return memo, nil
-}
-
-func (s *TestingServer) getMemoList() ([]*apiv1.Memo, error) {
-	body, err := s.get("/api/v1/memo", nil)
-	if err != nil {
-		return nil, err
-	}
-
-	buf := &bytes.Buffer{}
-	_, err = buf.ReadFrom(body)
-	if err != nil {
-		return nil, errors.Wrap(err, "fail to read response body")
-	}
-
-	memoList := []*apiv1.Memo{}
-	if err = json.Unmarshal(buf.Bytes(), &memoList); err != nil {
-		return nil, errors.Wrap(err, "fail to unmarshal get memo list response")
-	}
-	return memoList, nil
-}
-
-func (s *TestingServer) postMemoCreate(memoCreate *apiv1.CreateMemoRequest) (*apiv1.Memo, error) {
-	rawData, err := json.Marshal(&memoCreate)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshal memo create")
-	}
-	reader := bytes.NewReader(rawData)
-	body, err := s.post("/api/v1/memo", reader, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	buf := &bytes.Buffer{}
-	_, err = buf.ReadFrom(body)
-	if err != nil {
-		return nil, errors.Wrap(err, "fail to read response body")
-	}
-
-	memo := &apiv1.Memo{}
-	if err = json.Unmarshal(buf.Bytes(), memo); err != nil {
-		return nil, errors.Wrap(err, "fail to unmarshal post memo create response")
-	}
-	return memo, nil
-}
-
-func (s *TestingServer) patchMemo(memoPatch *apiv1.PatchMemoRequest) (*apiv1.Memo, error) {
-	rawData, err := json.Marshal(&memoPatch)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshal memo patch")
-	}
-	reader := bytes.NewReader(rawData)
-	body, err := s.patch(fmt.Sprintf("/api/v1/memo/%d", memoPatch.ID), reader, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	buf := &bytes.Buffer{}
-	_, err = buf.ReadFrom(body)
-	if err != nil {
-		return nil, errors.Wrap(err, "fail to read response body")
-	}
-
-	memo := &apiv1.Memo{}
-	if err = json.Unmarshal(buf.Bytes(), memo); err != nil {
-		return nil, errors.Wrap(err, "fail to unmarshal patch memo response")
-	}
-	return memo, nil
-}
-
-func (s *TestingServer) deleteMemo(memoID int32) error {
-	_, err := s.delete(fmt.Sprintf("/api/v1/memo/%d", memoID), nil)
-	return err
-}
-
-func (s *TestingServer) postMemoOrganizer(memoID int32, memosOrganizer *apiv1.UpsertMemoOrganizerRequest) (*apiv1.Memo, error) {
-	rawData, err := json.Marshal(&memosOrganizer)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshal memos organizer")
-	}
-	reader := bytes.NewReader(rawData)
-	body, err := s.post(fmt.Sprintf("/api/v1/memo/%d/organizer", memoID), reader, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	buf := &bytes.Buffer{}
-	_, err = buf.ReadFrom(body)
-	if err != nil {
-		return nil, errors.Wrap(err, "fail to read response body")
-	}
-
-	memo := &apiv1.Memo{}
-	if err = json.Unmarshal(buf.Bytes(), memo); err != nil {
-		return nil, errors.Wrap(err, "fail to unmarshal organizer memo create response")
-	}
-	return memo, err
-}

test/server/server.go

@@ -1,181 +0,0 @@
-package testserver
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/pkg/errors"
-	// sqlite driver.
-	_ "modernc.org/sqlite"
-
-	"github.com/usememos/memos/api/auth"
-	"github.com/usememos/memos/server"
-	"github.com/usememos/memos/server/profile"
-	"github.com/usememos/memos/store"
-	"github.com/usememos/memos/store/db"
-	"github.com/usememos/memos/test"
-)
-
-type TestingServer struct {
-	server  *server.Server
-	client  *http.Client
-	profile *profile.Profile
-	cookie  string
-}
-
-func NewTestingServer(ctx context.Context, t *testing.T) (*TestingServer, error) {
-	profile := test.GetTestingProfile(t)
-	dbDriver, err := db.NewDBDriver(profile)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to create db driver")
-	}
-	if err := dbDriver.Migrate(ctx); err != nil {
-		return nil, errors.Wrap(err, "failed to migrate db")
-	}
-
-	store := store.New(dbDriver, profile)
-	server, err := server.NewServer(ctx, profile, store)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to create server")
-	}
-
-	s := &TestingServer{
-		server:  server,
-		client:  &http.Client{},
-		profile: profile,
-		cookie:  "",
-	}
-	errChan := make(chan error, 1)
-
-	go func() {
-		if err := s.server.Start(ctx); err != nil {
-			if err != http.ErrServerClosed {
-				errChan <- errors.Wrap(err, "failed to run main server")
-			}
-		}
-	}()
-
-	if err := s.waitForServerStart(errChan); err != nil {
-		return nil, errors.Wrap(err, "failed to start server")
-	}
-
-	return s, nil
-}
-
-func (s *TestingServer) Shutdown(ctx context.Context) {
-	s.server.Shutdown(ctx)
-}
-
-func (s *TestingServer) waitForServerStart(errChan <-chan error) error {
-	ticker := time.NewTicker(100 * time.Millisecond)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-ticker.C:
-			if s == nil {
-				continue
-			}
-			e := s.server.GetEcho()
-			if e == nil {
-				continue
-			}
-			addr := e.ListenerAddr()
-			if addr != nil && strings.Contains(addr.String(), ":") {
-				return nil // was started
-			}
-		case err := <-errChan:
-			if err == http.ErrServerClosed {
-				return nil
-			}
-			return err
-		}
-	}
-}
-
-func (s *TestingServer) request(method, uri string, body io.Reader, params, header map[string]string) (io.ReadCloser, error) {
-	fullURL := fmt.Sprintf("http://localhost:%d%s", s.profile.Port, uri)
-	req, err := http.NewRequest(method, fullURL, body)
-	if err != nil {
-		return nil, errors.Wrapf(err, "fail to create a new %s request(%q)", method, fullURL)
-	}
-
-	for k, v := range header {
-		req.Header.Set(k, v)
-	}
-
-	q := url.Values{}
-	for k, v := range params {
-		q.Add(k, v)
-	}
-	if len(q) > 0 {
-		req.URL.RawQuery = q.Encode()
-	}
-
-	resp, err := s.client.Do(req)
-	if err != nil {
-		return nil, errors.Wrapf(err, "fail to send a %s request(%q)", method, fullURL)
-	}
-	if resp.StatusCode != http.StatusOK {
-		body, err := io.ReadAll(resp.Body)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to read http response body")
-		}
-		return nil, errors.Errorf("http response error code %v body %q", resp.StatusCode, string(body))
-	}
-
-	if method == "POST" {
-		if strings.Contains(uri, "/api/v1/auth/login") || strings.Contains(uri, "/api/v1/auth/signup") {
-			cookie := ""
-			h := resp.Header.Get("Set-Cookie")
-			parts := strings.Split(h, "; ")
-			for _, p := range parts {
-				if strings.HasPrefix(p, fmt.Sprintf("%s=", auth.AccessTokenCookieName)) {
-					cookie = p
-					break
-				}
-			}
-			if cookie == "" {
-				return nil, errors.New("unable to find access token in the login response headers")
-			}
-			s.cookie = cookie
-		} else if strings.Contains(uri, "/api/v1/auth/signout") {
-			s.cookie = ""
-		}
-	}
-	return resp.Body, nil
-}
-
-// get sends a GET client request.
-func (s *TestingServer) get(url string, params map[string]string) (io.ReadCloser, error) {
-	return s.request("GET", url, nil, params, map[string]string{
-		"Cookie": s.cookie,
-	})
-}
-
-// post sends a POST client request.
-func (s *TestingServer) post(url string, body io.Reader, params map[string]string) (io.ReadCloser, error) {
-	return s.request("POST", url, body, params, map[string]string{
-		"Cookie": s.cookie,
-	})
-}
-
-// patch sends a PATCH client request.
-func (s *TestingServer) patch(url string, body io.Reader, params map[string]string) (io.ReadCloser, error) {
-	return s.request("PATCH", url, body, params, map[string]string{
-		"Cookie": s.cookie,
-	})
-}
-
-// delete sends a DELETE client request.
-func (s *TestingServer) delete(url string, params map[string]string) (io.ReadCloser, error) {
-	return s.request("DELETE", url, nil, params, map[string]string{
-		"Cookie": s.cookie,
-	})
-}

test/server/system_test.go

@@ -1,64 +0,0 @@
-package testserver
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"testing"
-
-	"github.com/pkg/errors"
-	"github.com/stretchr/testify/require"
-
-	apiv1 "github.com/usememos/memos/api/v1"
-)
-
-func TestSystemServer(t *testing.T) {
-	ctx := context.Background()
-	s, err := NewTestingServer(ctx, t)
-	require.NoError(t, err)
-	defer s.Shutdown(ctx)
-
-	status, err := s.getSystemStatus()
-	require.NoError(t, err)
-	require.Equal(t, (*apiv1.User)(nil), status.Host)
-
-	signup := &apiv1.SignUp{
-		Username: "testuser",
-		Password: "testpassword",
-	}
-	user, err := s.postAuthSignUp(signup)
-	require.NoError(t, err)
-	require.Equal(t, signup.Username, user.Username)
-	err = s.pingSystem()
-	require.NoError(t, err)
-	status, err = s.getSystemStatus()
-	require.NoError(t, err)
-	require.Equal(t, user.ID, status.Host.ID)
-}
-
-func (s *TestingServer) pingSystem() error {
-	_, err := s.get("/api/v1/ping", nil)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func (s *TestingServer) getSystemStatus() (*apiv1.SystemStatus, error) {
-	body, err := s.get("/api/v1/status", nil)
-	if err != nil {
-		return nil, err
-	}
-
-	buf := &bytes.Buffer{}
-	_, err = buf.ReadFrom(body)
-	if err != nil {
-		return nil, errors.Wrap(err, "fail to read response body")
-	}
-
-	systemStatus := &apiv1.SystemStatus{}
-	if err = json.Unmarshal(buf.Bytes(), systemStatus); err != nil {
-		return nil, errors.Wrap(err, "fail to unmarshal get system status response")
-	}
-	return systemStatus, nil
-}

test/server/user_test.go

@@ -1,104 +0,0 @@
-package testserver
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"testing"
-
-	"github.com/pkg/errors"
-	"github.com/stretchr/testify/require"
-
-	apiv1 "github.com/usememos/memos/api/v1"
-)
-
-func TestUserServer(t *testing.T) {
-	ctx := context.Background()
-	s, err := NewTestingServer(ctx, t)
-	require.NoError(t, err)
-	defer s.Shutdown(ctx)
-
-	signup := &apiv1.SignUp{
-		Username: "testuser",
-		Password: "testpassword",
-	}
-	user, err := s.postAuthSignUp(signup)
-	require.NoError(t, err)
-	require.Equal(t, signup.Username, user.Username)
-	user, err = s.getCurrentUser()
-	require.NoError(t, err)
-	require.Equal(t, signup.Username, user.Username)
-	user, err = s.getUserByID(user.ID)
-	require.NoError(t, err)
-	require.Equal(t, signup.Username, user.Username)
-	newEmail := "test@usermemos.com"
-	userPatch := &apiv1.UpdateUserRequest{
-		Email: &newEmail,
-	}
-	user, err = s.patchUser(user.ID, userPatch)
-	require.NoError(t, err)
-	require.Equal(t, newEmail, user.Email)
-}
-
-func (s *TestingServer) getCurrentUser() (*apiv1.User, error) {
-	body, err := s.get("/api/v1/user/me", nil)
-	if err != nil {
-		return nil, err
-	}
-
-	buf := &bytes.Buffer{}
-	_, err = buf.ReadFrom(body)
-	if err != nil {
-		return nil, errors.Wrap(err, "fail to read response body")
-	}
-
-	user := &apiv1.User{}
-	if err = json.Unmarshal(buf.Bytes(), &user); err != nil {
-		return nil, errors.Wrap(err, "fail to unmarshal get user response")
-	}
-	return user, nil
-}
-
-func (s *TestingServer) getUserByID(userID int32) (*apiv1.User, error) {
-	body, err := s.get(fmt.Sprintf("/api/v1/user/%d", userID), nil)
-	if err != nil {
-		return nil, err
-	}
-
-	buf := &bytes.Buffer{}
-	_, err = buf.ReadFrom(body)
-	if err != nil {
-		return nil, errors.Wrap(err, "fail to read response body")
-	}
-
-	user := &apiv1.User{}
-	if err = json.Unmarshal(buf.Bytes(), &user); err != nil {
-		return nil, errors.Wrap(err, "fail to unmarshal get user response")
-	}
-	return user, nil
-}
-
-func (s *TestingServer) patchUser(userID int32, request *apiv1.UpdateUserRequest) (*apiv1.User, error) {
-	rawData, err := json.Marshal(&request)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshal request")
-	}
-	reader := bytes.NewReader(rawData)
-	body, err := s.patch(fmt.Sprintf("/api/v1/user/%d", userID), reader, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	buf := &bytes.Buffer{}
-	_, err = buf.ReadFrom(body)
-	if err != nil {
-		return nil, errors.Wrap(err, "fail to read response body")
-	}
-
-	user := &apiv1.User{}
-	if err = json.Unmarshal(buf.Bytes(), user); err != nil {
-		return nil, errors.Wrap(err, "fail to unmarshal patch user response")
-	}
-	return user, nil
-}