Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

10.0 KB
Raw Blame
package api

import (
	"bytes"
	"context"
	"database/sql"
	"encoding/json"
	"errors"
	"net/http"
	"net/http/httptest"
	"strconv"
	"testing"

	"github.com/ente/museum/ente"
	model "github.com/ente/museum/ente/userentity"
	"github.com/ente/museum/internal/testutil"
	userentitycontroller "github.com/ente/museum/pkg/controller/userentity"
	userentityrepo "github.com/ente/museum/pkg/repo/userentity"
	"github.com/gin-gonic/gin"
)

func TestCreateUserEntityKeyIsIdempotentForReplay(t *testing.T) {
	handler, db := setupUserEntityHandlerTest(t)

	userID := testutil.InsertUser(t, db, testutil.UserFixture{
		UserID:       201,
		Email:        "[email protected]",
		CreationTime: 1,
	})

	body := map[string]any{
		"type":         "memory",
		"encryptedKey": "encrypted-key",
		"header":       "header",
	}

	first := performCreateUserEntityKeyRequest(t, handler, userID, body)
	if first.Code != http.StatusOK {
		t.Fatalf("unexpected status code on first create: got %d want %d; body=%s", first.Code, http.StatusOK, first.Body.String())
	}

	second := performCreateUserEntityKeyRequest(t, handler, userID, body)
	if second.Code != http.StatusOK {
		t.Fatalf("unexpected status code on duplicate replay: got %d want %d; body=%s", second.Code, http.StatusOK, second.Body.String())
	}
}

func TestCreateUserEntityKeyReturnsAlreadyExistsForConflictingCreate(t *testing.T) {
	handler, db := setupUserEntityHandlerTest(t)

	userID := testutil.InsertUser(t, db, testutil.UserFixture{
		UserID:       202,
		Email:        "[email protected]",
		CreationTime: 1,
	})

	firstBody := map[string]any{
		"type":         "memory",
		"encryptedKey": "encrypted-key",
		"header":       "header",
	}
	secondBody := map[string]any{
		"type":         "memory",
		"encryptedKey": "different-encrypted-key",
		"header":       "different-header",
	}

	first := performCreateUserEntityKeyRequest(t, handler, userID, firstBody)
	if first.Code != http.StatusOK {
		t.Fatalf("unexpected status code on first create: got %d want %d; body=%s", first.Code, http.StatusOK, first.Body.String())
	}

	second := performCreateUserEntityKeyRequest(t, handler, userID, secondBody)
	if second.Code != http.StatusConflict {
		t.Fatalf("unexpected status code: got %d want %d; body=%s", second.Code, http.StatusConflict, second.Body.String())
	}
	var apiErr ente.ApiError
	if err := json.Unmarshal(second.Body.Bytes(), &apiErr); err != nil {
		t.Fatalf("failed to decode response body: %v", err)
	}
	if apiErr.Code != ente.AlreadyExists || apiErr.Message != "Key already exists" {
		t.Fatalf("unexpected error response: %+v", apiErr)
	}
}

func TestEnsureUserEntityKeyReturnsExistingKeyForConflict(t *testing.T) {
	handler, db := setupUserEntityHandlerTest(t)

	userID := testutil.InsertUser(t, db, testutil.UserFixture{
		UserID:       203,
		Email:        "[email protected]",
		CreationTime: 1,
	})

	firstBody := map[string]any{
		"type":         "space",
		"encryptedKey": "encrypted-key",
		"header":       "header",
	}
	secondBody := map[string]any{
		"type":         "space",
		"encryptedKey": "different-encrypted-key",
		"header":       "different-header",
	}

	first := performEnsureUserEntityKeyRequest(t, handler, userID, firstBody)
	if first.Code != http.StatusOK {
		t.Fatalf("unexpected status code on first ensure: got %d want %d; body=%s", first.Code, http.StatusOK, first.Body.String())
	}
	if first.Header().Get("Cache-Control") != "no-store" {
		t.Fatalf("missing no-store cache header on first ensure: %q", first.Header().Get("Cache-Control"))
	}
	second := performEnsureUserEntityKeyRequest(t, handler, userID, secondBody)
	if second.Code != http.StatusOK {
		t.Fatalf("unexpected status code on duplicate ensure: got %d want %d; body=%s", second.Code, http.StatusOK, second.Body.String())
	}
	if second.Header().Get("Cache-Control") != "no-store" {
		t.Fatalf("missing no-store cache header on duplicate ensure: %q", second.Header().Get("Cache-Control"))
	}
	var response map[string]any
	if err := json.Unmarshal(second.Body.Bytes(), &response); err != nil {
		t.Fatalf("failed to decode ensure response: %v", err)
	}
	if response["encryptedKey"] != firstBody["encryptedKey"] || response["header"] != firstBody["header"] {
		t.Fatalf("ensure returned wrong key: got %v", response)
	}
}

func TestCreateSmartAlbumEntityRestoresDeletedEntry(t *testing.T) {
	handler, db := setupUserEntityHandlerTest(t)

	userID := testutil.InsertUser(t, db, testutil.UserFixture{
		UserID:       204,
		Email:        "[email protected]",
		CreationTime: 1,
	})

	ctx := context.Background()
	id := "sa_204_12345"
	if err := handler.Controller.Repo.CreateKey(ctx, userID, model.EntityKeyRequest{
		Type:         model.SmartAlbum,
		EncryptedKey: "encrypted-key",
		Header:       "key-header",
	}); err != nil {
		t.Fatalf("failed to create entity key: %v", err)
	}
	if _, err := handler.Controller.Repo.Create(ctx, userID, model.EntityDataRequest{
		ID:            &id,
		Type:          model.SmartAlbum,
		EncryptedData: "old-data",
		Header:        "old-header",
	}); err != nil {
		t.Fatalf("failed to create smart album entity: %v", err)
	}
	if deleted, err := handler.Controller.Repo.Delete(ctx, userID, id); err != nil || !deleted {
		t.Fatalf("failed to delete smart album entity: deleted=%t err=%v", deleted, err)
	}

	recorder := performCreateUserEntityRequest(t, handler, userID, map[string]any{
		"id":            id,
		"type":          string(model.SmartAlbum),
		"encryptedData": "new-data",
		"header":        "new-header",
	})
	if recorder.Code != http.StatusOK {
		t.Fatalf("unexpected status code on recreate: got %d want %d; body=%s", recorder.Code, http.StatusOK, recorder.Body.String())
	}

	var entity model.EntityData
	if err := json.Unmarshal(recorder.Body.Bytes(), &entity); err != nil {
		t.Fatalf("failed to decode entity response %q: %v", recorder.Body.String(), err)
	}
	if entity.ID != id || entity.UserID != userID || entity.Type != model.SmartAlbum || entity.IsDeleted {
		t.Fatalf("unexpected restored entity: %+v", entity)
	}
	if entity.EncryptedData == nil || *entity.EncryptedData != "new-data" {
		t.Fatalf("unexpected encryptedData: got %v want %q", entity.EncryptedData, "new-data")
	}
	if entity.Header == nil || *entity.Header != "new-header" {
		t.Fatalf("unexpected header: got %v want %q", entity.Header, "new-header")
	}
}

func TestUpdateLibraryShareEntityRejectsStaleWrite(t *testing.T) {
	handler, db := setupUserEntityHandlerTest(t)

	userID := testutil.InsertUser(t, db, testutil.UserFixture{
		UserID:       205,
		Email:        "[email protected]",
		CreationTime: 1,
	})
	ctx := context.Background()
	if err := handler.Controller.Repo.CreateKey(ctx, userID, model.EntityKeyRequest{
		Type:         model.LibraryShare,
		EncryptedKey: "encrypted-key",
		Header:       "key-header",
	}); err != nil {
		t.Fatalf("failed to create entity key: %v", err)
	}

	id := "ls_205_206"
	if _, err := handler.Controller.Repo.Create(ctx, userID, model.EntityDataRequest{
		ID:            &id,
		Type:          model.LibraryShare,
		EncryptedData: "initial-data",
		Header:        "initial-header",
	}); err != nil {
		t.Fatalf("failed to create entity: %v", err)
	}
	created, err := handler.Controller.Repo.Get(ctx, userID, id)
	if err != nil {
		t.Fatalf("failed to fetch created entity: %v", err)
	}

	staleUpdatedAt := created.UpdatedAt - 1
	err = handler.Controller.Repo.Update(ctx, userID, model.UpdateEntityDataRequest{
		ID:                id,
		Type:              model.LibraryShare,
		EncryptedData:     "updated-data",
		Header:            "updated-header",
		ExpectedUpdatedAt: &staleUpdatedAt,
	})
	if !errors.Is(err, ente.ErrVersionMismatch) {
		t.Fatalf("stale update error = %v, want %v", err, ente.ErrVersionMismatch)
	}
}

func setupUserEntityHandlerTest(t *testing.T) (*UserEntityHandler, *sql.DB) {
	t.Helper()

	testutil.WithServerRoot(t)

	db := testutil.RequireTestDB(t)
	testutil.ResetTables(t, db)
	t.Cleanup(func() {
		testutil.ResetTables(t, db)
	})

	return &UserEntityHandler{
		Controller: &userentitycontroller.Controller{
			Repo: &userentityrepo.Repository{DB: db},
		},
	}, db
}

func performCreateUserEntityKeyRequest(
	t *testing.T,
	handler *UserEntityHandler,
	userID int64,
	body map[string]any,
) *httptest.ResponseRecorder {
	t.Helper()

	gin.SetMode(gin.TestMode)

	payload, err := json.Marshal(body)
	if err != nil {
		t.Fatalf("failed to marshal request body: %v", err)
	}

	recorder := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodPost, "/user-entity/key", bytes.NewReader(payload))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-Auth-User-ID", strconv.FormatInt(userID, 10))

	router := gin.New()
	router.POST("/user-entity/key", handler.CreateKey)
	router.ServeHTTP(recorder, req)

	return recorder
}

func performEnsureUserEntityKeyRequest(
	t *testing.T,
	handler *UserEntityHandler,
	userID int64,
	body map[string]any,
) *httptest.ResponseRecorder {
	t.Helper()

	gin.SetMode(gin.TestMode)

	payload, err := json.Marshal(body)
	if err != nil {
		t.Fatalf("failed to marshal request body: %v", err)
	}

	recorder := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodPost, "/user-entity/key/ensure", bytes.NewReader(payload))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-Auth-User-ID", strconv.FormatInt(userID, 10))

	router := gin.New()
	router.POST("/user-entity/key/ensure", handler.EnsureKey)
	router.ServeHTTP(recorder, req)

	return recorder
}

func performCreateUserEntityRequest(
	t *testing.T,
	handler *UserEntityHandler,
	userID int64,
	body map[string]any,
) *httptest.ResponseRecorder {
	t.Helper()

	gin.SetMode(gin.TestMode)

	payload, err := json.Marshal(body)
	if err != nil {
		t.Fatalf("failed to marshal request body: %v", err)
	}

	recorder := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodPost, "/user-entity/entity", bytes.NewReader(payload))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-Auth-User-ID", strconv.FormatInt(userID, 10))

	router := gin.New()
	router.POST("/user-entity/entity", handler.CreateEntity)
	router.ServeHTTP(recorder, req)

	return recorder
}