upkg/controller/file_manager/local_test.go

package file_manager

import (
	"bytes"
	"context"
	"os"
	"testing"
	"time"
)

func TestLocalUploadDownload(t *testing.T) {
	fm := New(
		WithDir("/tmp/upkg-test"),
		WithTimeout(10*time.Minute),
		WithExpire(24*time.Hour),
	)
	defer fm.CloseManager()

	ctx := context.Background()

	content := []byte("hello world from local")
	size := int64(len(content))
	reader := bytes.NewReader(content)

	result, err := fm.Create(ctx, "test.txt", size, "")
	if err != nil {
		t.Fatalf("Create failed: %v", err)
	}

	total, written, err := fm.Upload(ctx, result.Code, 0, size, reader)
	if err != nil {
		t.Fatalf("Upload failed: %v", err)
	}
	if total != size {
		t.Errorf("expected total %d, got %d", size, total)
	}
	if written != size {
		t.Errorf("expected written %d, got %d", size, written)
	}

	data, err := fm.Get(ctx, result.Code)
	if err != nil {
		t.Fatalf("Get failed: %v", err)
	}
	if !bytes.Equal(data, content) {
		t.Errorf("data mismatch, expected %s, got %s", content, data)
	}

	info, err := fm.GetInfo(ctx, result.Code)
	if err != nil {
		t.Fatalf("GetInfo failed: %v", err)
	}
	if info.Filename != "test.txt" {
		t.Errorf("expected filename test.txt, got %s", info.Filename)
	}
	if info.Size != size {
		t.Errorf("expected size %d, got %d", size, info.Size)
	}
	if !info.Complete {
		t.Error("expected complete to be true")
	}
	if info.SHA256 == "" {
		t.Error("expected sha256 to be set")
	}

	err = fm.Delete(ctx, result.Code)
	if err != nil {
		t.Fatalf("Delete failed: %v", err)
	}

	_, err = fm.Get(ctx, result.Code)
	if err == nil {
		t.Error("expected error after delete")
	}
}

func TestLocalUploadLargeFile(t *testing.T) {
	fm := New(
		WithDir("/tmp/upkg-test-large"),
		WithTimeout(30*time.Minute),
		WithExpire(24*time.Hour),
	)
	defer fm.CloseManager()

	ctx := context.Background()

	filePath := "../../x-file/VID_20240215_195046.mp4"
	file, err := os.Open(filePath)
	if err != nil {
		t.Fatalf("open file failed: %v", err)
	}
	defer file.Close()

	stat, err := file.Stat()
	if err != nil {
		t.Fatalf("stat file failed: %v", err)
	}

	result, err := fm.Create(ctx, "video.mp4", stat.Size(), "")
	if err != nil {
		t.Fatalf("Create failed: %v", err)
	}

	total, written, err := fm.Upload(ctx, result.Code, 0, stat.Size(), file)
	if err != nil {
		t.Fatalf("Upload failed: %v", err)
	}
	if total != stat.Size() {
		t.Errorf("expected total %d, got %d", stat.Size(), total)
	}
	if written != stat.Size() {
		t.Errorf("expected written %d, got %d", stat.Size(), written)
	}

	data, err := fm.Get(ctx, result.Code)
	if err != nil {
		t.Fatalf("Get failed: %v", err)
	}
	if int64(len(data)) != stat.Size() {
		t.Errorf("expected size %d, got %d", stat.Size(), len(data))
	}

	err = fm.Delete(ctx, result.Code)
	if err != nil {
		t.Fatalf("Delete failed: %v", err)
	}
}

func TestLocalUploadWithSHA256(t *testing.T) {
	fm := New(
		WithDir("/tmp/upkg-test-sha256"),
		WithTimeout(10*time.Minute),
		WithExpire(24*time.Hour),
	)
	defer fm.CloseManager()

	ctx := context.Background()

	content := []byte("hello world with sha256")
	size := int64(len(content))
	reader := bytes.NewReader(content)

	sha256 := "54a1932f09c34bd2c29f4fb3c3abbf6b5f65afcadeabbf13a1c5165782f6b08b"

	result, err := fm.Create(ctx, "test-sha256.txt", size, sha256)
	if err != nil {
		t.Fatalf("Create failed: %v", err)
	}

	_, _, err = fm.Upload(ctx, result.Code, 0, size, reader)
	if err != nil {
		t.Fatalf("Upload failed: %v", err)
	}

	data, err := fm.Get(ctx, result.Code)
	if err != nil {
		t.Fatalf("Get failed: %v", err)
	}
	if !bytes.Equal(data, content) {
		t.Errorf("data mismatch")
	}

	err = fm.Delete(ctx, result.Code)
	if err != nil {
		t.Fatalf("Delete failed: %v", err)
	}
}

func TestLocalCloseAndReopen(t *testing.T) {
	dir := "/tmp/upkg-test-reopen"
	fm := New(
		WithDir(dir),
		WithTimeout(1*time.Minute),
		WithExpire(24*time.Hour),
	)

	ctx := context.Background()

	content := []byte("test close and reopen")
	size := int64(len(content))

	result, err := fm.Create(ctx, "reopen.txt", size, "")
	if err != nil {
		t.Fatalf("Create failed: %v", err)
	}

	reader := bytes.NewReader(content)
	_, _, err = fm.Upload(ctx, result.Code, 0, size, reader)
	if err != nil {
		t.Fatalf("Upload failed: %v", err)
	}

	fm.CloseManager()

	fm2 := New(
		WithDir(dir),
		WithTimeout(1*time.Minute),
		WithExpire(24*time.Hour),
	)
	defer fm2.CloseManager()

	data, err := fm2.Get(ctx, result.Code)
	if err != nil {
		t.Fatalf("Get after reopen failed: %v", err)
	}
	if !bytes.Equal(data, content) {
		t.Errorf("data mismatch after reopen")
	}

	err = fm2.Delete(ctx, result.Code)
	if err != nil {
		t.Fatalf("Delete failed: %v", err)
	}
}