internal/validate/validate_test.go - master - advanceddev/license-server

internal/validate/validate_test.go
152 строки4 KB
advanceddev
fix: security & reliability hardening for rate limiter, auth, and audit
10 авг 2026, 23:52
10 авг 2026, 23:52aef6073
package validate

import (
	"strings"
	"testing"

	"gitverse.ru/advanceddev/license-server/internal/domain"

	"github.com/google/uuid"
)

func TestDecodeStrict_CreateLicenseInput_Valid(t *testing.T) {
	body := strings.NewReader(`{
		"partner_id": "550e8400-e29b-41d4-a716-446655440000",
		"brand_name": "Test Brand",
		"expires_at": "2027-08-08T00:00:00Z"
	}`)

	var input domain.CreateLicenseInput
	err := DecodeStrict(body, &input)
	if err != nil {
		t.Fatalf("expected no error, got: %v", err)
	}
	if input.PartnerID != uuid.MustParse("550e8400-e29b-41d4-a716-446655440000") {
		t.Errorf("unexpected partner_id: %s", input.PartnerID)
	}
	if input.BrandName != "Test Brand" {
		t.Errorf("unexpected brand_name: %s", input.BrandName)
	}
}

func TestDecodeStrict_CreateLicenseInput_MissingRequired(t *testing.T) {
	body := strings.NewReader(`{"brand_name": "Test"}`)

	var input domain.CreateLicenseInput
	err := DecodeStrict(body, &input)
	if err == nil {
		t.Fatal("expected validation error, got nil")
	}
	if !IsValidationError(err) {
		t.Fatalf("expected ValidationError, got: %T", err)
	}
	if !strings.Contains(err.Error(), "PartnerID") {
		t.Errorf("expected PartnerID in error, got: %s", err.Error())
	}
}

func TestDecodeStrict_CreateLicenseInput_UnknownField(t *testing.T) {
	body := strings.NewReader(`{
		"partner_id": "550e8400-e29b-41d4-a716-446655440000",
		"brand_name": "Test",
		"unknown_field": "value"
	}`)

	var input domain.CreateLicenseInput
	err := DecodeStrict(body, &input)
	if err == nil {
		t.Fatal("expected decode error for unknown field, got nil")
	}
	if !IsDecodeError(err) {
		t.Fatalf("expected DecodeError, got: %T", err)
	}
	if !strings.Contains(err.Error(), "unknown field") {
		t.Errorf("expected 'unknown field' in error, got: %s", err.Error())
	}
}

func TestDecodeStrict_CreateLicenseInput_InvalidUUID(t *testing.T) {
	body := strings.NewReader(`{
		"partner_id": "not-a-uuid",
		"brand_name": "Test"
	}`)

	var input domain.CreateLicenseInput
	err := DecodeStrict(body, &input)
	if err == nil {
		t.Fatal("expected error for invalid UUID, got nil")
	}
}

func TestDecodeStrict_CreateLicenseInput_BrandNameTooLong(t *testing.T) {
	longName := strings.Repeat("a", 129)
	body := strings.NewReader(`{
		"partner_id": "550e8400-e29b-41d4-a716-446655440000",
		"brand_name": "` + longName + `"
	}`)

	var input domain.CreateLicenseInput
	err := DecodeStrict(body, &input)
	if err == nil {
		t.Fatal("expected validation error for long brand_name, got nil")
	}
	if !IsValidationError(err) {
		t.Fatalf("expected ValidationError, got: %T", err)
	}
}

func TestDecodeStrict_UpdateLicenseInput_EmptyBody(t *testing.T) {
	body := strings.NewReader(`{}`)

	var input domain.UpdateLicenseInput
	err := DecodeStrict(body, &input)
	if err != nil {
		t.Fatalf("empty update should be valid, got: %v", err)
	}
}

func TestDecodeStrict_ValidateRequest_MissingKey(t *testing.T) {
	body := strings.NewReader(`{"instance_id": "test"}`)

	var req domain.ValidateRequest
	err := DecodeStrict(body, &req)
	if err == nil {
		t.Fatal("expected validation error, got nil")
	}
	if !IsValidationError(err) {
		t.Fatalf("expected ValidationError, got: %T", err)
	}
}

func TestDecodeStrict_InvalidJSON(t *testing.T) {
	body := strings.NewReader(`{malformed`)

	var input domain.CreateLicenseInput
	err := DecodeStrict(body, &input)
	if err == nil {
		t.Fatal("expected decode error, got nil")
	}
	if !IsDecodeError(err) {
		t.Fatalf("expected DecodeError, got: %T", err)
	}
}

func TestDecodeStrict_ValidateRequest_InstanceIDTooLong(t *testing.T) {
	longID := strings.Repeat("a", 129)
	body := strings.NewReader(`{
		"license_key": "test-key",
		"instance_id": "` + longID + `"
	}`)

	var req domain.ValidateRequest
	err := DecodeStrict(body, &req)
	if err == nil {
		t.Fatal("expected validation error for long instance_id, got nil")
	}
	if !IsValidationError(err) {
		t.Fatalf("expected ValidationError, got: %T", err)
	}
	if !strings.Contains(err.Error(), "InstanceID") {
		t.Errorf("expected InstanceID in error, got: %s", err.Error())
	}
}