frostfs-s3-gw/api/router_test.go

package api

import (
	"bytes"
	"encoding/json"
	"encoding/xml"
	"fmt"
	"io"
	"net/http"
	"net/http/httptest"
	"net/url"
	"strconv"
	"testing"
	"time"

	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/data"
	apierr "git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/errors"
	s3middleware "git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/middleware"
	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/metrics"
	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object"
	engineiam "git.frostfs.info/TrueCloudLab/policy-engine/iam"
	"git.frostfs.info/TrueCloudLab/policy-engine/pkg/chain"
	"git.frostfs.info/TrueCloudLab/policy-engine/pkg/engine"
	"git.frostfs.info/TrueCloudLab/policy-engine/pkg/engine/inmemory"
	"git.frostfs.info/TrueCloudLab/policy-engine/schema/common"
	"git.frostfs.info/TrueCloudLab/policy-engine/schema/s3"
	"github.com/go-chi/chi/v5"
	"github.com/go-chi/chi/v5/middleware"
	"github.com/prometheus/client_golang/prometheus"
	"github.com/stretchr/testify/require"
	"go.uber.org/zap/zaptest"
)

type routerMock struct {
	t                  *testing.T
	router             *chi.Mux
	cfg                Config
	middlewareSettings *middlewareSettingsMock
	policyChecker      engine.LocalOverrideEngine
	handler            *handlerMock
}

func (m *routerMock) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	m.router.ServeHTTP(w, r)
}

type option func(*Config)

func frostFSIDValidation(flag bool) option {
	return func(cfg *Config) {
		cfg.FrostFSIDValidation = flag
	}
}

func prepareRouter(t *testing.T, opts ...option) *routerMock {
	middlewareSettings := &middlewareSettingsMock{}
	policyChecker := inmemory.NewInMemoryLocalOverrides()

	logger := zaptest.NewLogger(t)

	metricsConfig := metrics.AppMetricsConfig{
		Logger:         logger,
		PoolStatistics: &poolStatisticMock{},
		Registerer:     prometheus.NewRegistry(),
		Enabled:        true,
	}

	handlerTestMock := &handlerMock{t: t, cfg: middlewareSettings, buckets: map[string]*data.BucketInfo{}}

	cfg := Config{
		Throttle: middleware.ThrottleOpts{
			Limit:          10,
			BacklogTimeout: 30 * time.Second,
		},
		Handler:            handlerTestMock,
		Center:             &centerMock{t: t},
		Log:                logger,
		Metrics:            metrics.NewAppMetrics(metricsConfig),
		MiddlewareSettings: middlewareSettings,
		PolicyChecker:      policyChecker,
		FrostfsID:          &frostFSIDMock{},
		XMLDecoder:         &xmlMock{},
		Tagging:            &resourceTaggingMock{},
	}

	for _, o := range opts {
		o(&cfg)
	}

	return &routerMock{
		t:                  t,
		router:             NewRouter(cfg),
		cfg:                cfg,
		middlewareSettings: middlewareSettings,
		policyChecker:      policyChecker,
		handler:            handlerTestMock,
	}
}

func TestRouterUploadPart(t *testing.T) {
	chiRouter := prepareRouter(t)

	createBucket(chiRouter, "", "dkirillov")

	w := httptest.NewRecorder()
	r := httptest.NewRequest(http.MethodPut, "/dkirillov/fix-object", nil)
	query := make(url.Values)
	query.Set("uploadId", "some-id")
	query.Set("partNumber", "1")
	r.URL.RawQuery = query.Encode()

	chiRouter.ServeHTTP(w, r)
	resp := readResponse(t, w)
	require.Equal(t, "UploadPart", resp.Method)
}

func TestRouterListMultipartUploads(t *testing.T) {
	chiRouter := prepareRouter(t)

	createBucket(chiRouter, "", "test-bucket")

	w := httptest.NewRecorder()
	r := httptest.NewRequest(http.MethodGet, "/test-bucket", nil)
	query := make(url.Values)
	query.Set("uploads", "")
	r.URL.RawQuery = query.Encode()

	chiRouter.ServeHTTP(w, r)
	resp := readResponse(t, w)
	require.Equal(t, "ListMultipartUploads", resp.Method)
}

func TestRouterObjectWithSlashes(t *testing.T) {
	chiRouter := prepareRouter(t)

	ns, bktName, objName := "", "dkirillov", "/fix/object"

	createBucket(chiRouter, ns, bktName)
	resp := putObject(chiRouter, ns, bktName, objName, nil)
	require.Equal(t, objName, resp.ReqInfo.ObjectName)
}

func TestRouterObjectEscaping(t *testing.T) {
	chiRouter := prepareRouter(t)

	ns, bktName := "", "dkirillov"
	createBucket(chiRouter, ns, bktName)

	for _, tc := range []struct {
		name            string
		expectedObjName string
		objName         string
	}{
		{
			name:            "simple",
			expectedObjName: "object",
			objName:         "object",
		},
		{
			name:            "with slashes",
			expectedObjName: "fix/object",
			objName:         "fix/object",
		},
		{
			name:            "with slash escaped",
			expectedObjName: "/foo/bar",
			objName:         "/foo%2fbar",
		},
		{
			name:            "with percentage escaped",
			expectedObjName: "fix/object%ac",
			objName:         "fix/object%25ac",
		},
		{
			name:            "with awful mint name",
			expectedObjName: "äöüex ®©µÄÆÐÕæŒƕƩDž 01000000 0x40 \u0040 amȡȹɆple&0a!-_.*'()&$@=;:+,?<>.pdf",
			objName:         "%C3%A4%C3%B6%C3%BCex%20%C2%AE%C2%A9%C2%B5%C3%84%C3%86%C3%90%C3%95%C3%A6%C5%92%C6%95%C6%A9%C7%85%2001000000%200x40%20%40%20am%C8%A1%C8%B9%C9%86ple%260a%21-_.%2A%27%28%29%26%24%40%3D%3B%3A%2B%2C%3F%3C%3E.pdf",
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			resp := putObject(chiRouter, ns, bktName, tc.objName, nil)
			require.Equal(t, tc.expectedObjName, resp.ReqInfo.ObjectName)
		})
	}
}

func TestPolicyChecker(t *testing.T) {
	chiRouter := prepareRouter(t)
	ns1, bktName1, objName1 := "", "bucket", "object"
	ns2, bktName2, objName2 := "custom-ns", "other-bucket", "object"

	createBucket(chiRouter, ns1, bktName1)
	createBucket(chiRouter, ns2, bktName1)
	createBucket(chiRouter, ns2, bktName2)

	ruleChain := &chain.Chain{
		ID: chain.ID("id"),
		Rules: []chain.Rule{{
			Status:    chain.AccessDenied,
			Actions:   chain.Actions{Names: []string{"*"}},
			Resources: chain.Resources{Names: []string{fmt.Sprintf(s3.ResourceFormatS3BucketObjects, bktName1)}},
		}},
	}

	_, _, err := chiRouter.policyChecker.MorphRuleChainStorage().AddMorphRuleChain(chain.S3, engine.NamespaceTarget(ns2), ruleChain)
	require.NoError(t, err)

	// check we can access 'bucket' in default namespace
	putObject(chiRouter, ns1, bktName1, objName1, nil)
	deleteObject(chiRouter, ns1, bktName1, objName1, nil)

	// check we can access 'other-bucket' in custom namespace
	putObject(chiRouter, ns2, bktName2, objName2, nil)
	deleteObject(chiRouter, ns2, bktName2, objName2, nil)

	// check we cannot access 'bucket' in custom namespace
	putObjectErr(chiRouter, ns2, bktName1, objName2, nil, apierr.ErrAccessDenied)
	deleteObjectErr(chiRouter, ns2, bktName1, objName2, nil, apierr.ErrAccessDenied)
}

func TestPolicyCheckerError(t *testing.T) {
	chiRouter := prepareRouter(t)
	ns1, bktName1, objName1 := "", "bucket", "object"
	putObjectErr(chiRouter, ns1, bktName1, objName1, nil, apierr.ErrNoSuchBucket)

	chiRouter = prepareRouter(t)
	chiRouter.cfg.FrostfsID.(*frostFSIDMock).userGroupsError = true
	putObjectErr(chiRouter, ns1, bktName1, objName1, nil, apierr.ErrInternalError)
}

func TestPolicyCheckerReqTypeDetermination(t *testing.T) {
	chiRouter := prepareRouter(t)
	bktName, objName := "bucket", "object"
	createBucket(chiRouter, "", bktName)

	policy := engineiam.Policy{
		Version: "2012-10-17",
		Statement: []engineiam.Statement{{
			Principal: map[engineiam.PrincipalType][]string{engineiam.Wildcard: {}},
			Effect:    engineiam.AllowEffect,
			Action:    engineiam.Action{"s3:*"},
			Resource:  engineiam.Resource{fmt.Sprintf(s3.ResourceFormatS3All)},
		}},
	}

	ruleChain, err := engineiam.ConvertToS3Chain(policy, nil)
	require.NoError(t, err)

	_, _, err = chiRouter.policyChecker.MorphRuleChainStorage().AddMorphRuleChain(chain.S3, engine.NamespaceTarget(""), ruleChain)
	require.NoError(t, err)

	createBucket(chiRouter, "", bktName)

	chiRouter.middlewareSettings.denyByDefault = true
	t.Run("can list buckets", func(t *testing.T) {
		w, r := httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/", nil)
		chiRouter.ServeHTTP(w, r)
		resp := readResponse(t, w)
		require.Equal(t, s3middleware.ListBucketsOperation, resp.Method)
	})

	t.Run("can head 'bucket'", func(t *testing.T) {
		w, r := httptest.NewRecorder(), httptest.NewRequest(http.MethodHead, "/"+bktName, nil)
		chiRouter.ServeHTTP(w, r)
		resp := readResponse(t, w)
		require.Equal(t, s3middleware.HeadBucketOperation, resp.Method)
	})

	t.Run("can put object into 'bucket'", func(t *testing.T) {
		w, r := httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, fmt.Sprintf("/%s/%s", bktName, objName), nil)
		chiRouter.ServeHTTP(w, r)
		resp := readResponse(t, w)
		require.Equal(t, s3middleware.PutObjectOperation, resp.Method)
	})
}

func TestDefaultBehaviorPolicyChecker(t *testing.T) {
	chiRouter := prepareRouter(t)
	ns, bktName := "", "bucket"

	// check we can access bucket if rules not found
	createBucket(chiRouter, ns, bktName)

	// check we cannot access if rules not found when settings is enabled
	chiRouter.middlewareSettings.denyByDefault = true
	createBucketErr(chiRouter, ns, bktName, nil, apierr.ErrAccessDenied)
}

func TestDefaultPolicyCheckerWithUserTags(t *testing.T) {
	router := prepareRouter(t)
	ns, bktName := "", "bucket"
	router.middlewareSettings.denyByDefault = true

	allowOperations(router, ns, []string{"s3:CreateBucket"}, engineiam.Conditions{
		engineiam.CondStringEquals: engineiam.Condition{fmt.Sprintf(common.PropertyKeyFormatFrostFSIDUserClaim, "tag-test"): []string{"test"}},
	})
	createBucketErr(router, ns, bktName, nil, apierr.ErrAccessDenied)

	tags := make(map[string]string)
	tags["tag-test"] = "test"
	router.cfg.FrostfsID.(*frostFSIDMock).tags = tags
	createBucket(router, ns, bktName)
}

func TestRequestParametersCheck(t *testing.T) {
	t.Run("prefix parameter, allow specific value", func(t *testing.T) {
		router := prepareRouter(t)

		ns, bktName, prefix := "", "bucket", "prefix"
		router.middlewareSettings.denyByDefault = true

		allowOperations(router, ns, []string{"s3:CreateBucket"}, nil)
		createBucket(router, ns, bktName)

		// Add policies and check
		denyOperations(router, ns, []string{"s3:ListBucket"}, engineiam.Conditions{
			engineiam.CondStringNotEquals: engineiam.Condition{s3.PropertyKeyPrefix: []string{prefix}},
		})
		allowOperations(router, ns, []string{"s3:ListBucket"}, engineiam.Conditions{
			engineiam.CondStringEquals: engineiam.Condition{s3.PropertyKeyPrefix: []string{prefix}},
		})

		listObjectsV1(router, ns, bktName, prefix, "", "")
		listObjectsV1Err(router, ns, bktName, "", "", "", apierr.ErrAccessDenied)
		listObjectsV1Err(router, ns, bktName, "invalid", "", "", apierr.ErrAccessDenied)
	})

	t.Run("delimiter parameter, prohibit specific value", func(t *testing.T) {
		router := prepareRouter(t)

		ns, bktName, delimiter := "", "bucket", "delimiter"
		router.middlewareSettings.denyByDefault = true

		allowOperations(router, ns, []string{"s3:CreateBucket"}, nil)
		createBucket(router, ns, bktName)

		// Add policies and check
		denyOperations(router, ns, []string{"s3:ListBucket"}, engineiam.Conditions{
			engineiam.CondStringEquals: engineiam.Condition{s3.PropertyKeyDelimiter: []string{delimiter}},
		})
		allowOperations(router, ns, []string{"s3:ListBucket"}, engineiam.Conditions{
			engineiam.CondStringNotEquals: engineiam.Condition{s3.PropertyKeyDelimiter: []string{delimiter}},
		})

		listObjectsV1(router, ns, bktName, "", "", "")
		listObjectsV1(router, ns, bktName, "", "some-delimiter", "")
		listObjectsV1Err(router, ns, bktName, "", delimiter, "", apierr.ErrAccessDenied)
	})

	t.Run("max-keys parameter, allow specific value", func(t *testing.T) {
		router := prepareRouter(t)

		ns, bktName, maxKeys := "", "bucket", 10
		router.middlewareSettings.denyByDefault = true

		allowOperations(router, ns, []string{"s3:CreateBucket"}, nil)
		createBucket(router, ns, bktName)

		// Add policies and check
		denyOperations(router, ns, []string{"s3:ListBucket"}, engineiam.Conditions{
			engineiam.CondNumericNotEquals: engineiam.Condition{s3.PropertyKeyMaxKeys: []string{strconv.Itoa(maxKeys)}},
		})
		allowOperations(router, ns, []string{"s3:ListBucket"}, engineiam.Conditions{
			engineiam.CondNumericEquals: engineiam.Condition{s3.PropertyKeyMaxKeys: []string{strconv.Itoa(maxKeys)}},
		})

		listObjectsV1(router, ns, bktName, "", "", strconv.Itoa(maxKeys))
		listObjectsV1Err(router, ns, bktName, "", "", "", apierr.ErrAccessDenied)
		listObjectsV1Err(router, ns, bktName, "", "", strconv.Itoa(maxKeys-1), apierr.ErrAccessDenied)
		listObjectsV1Err(router, ns, bktName, "", "", "invalid", apierr.ErrAccessDenied)
	})

	t.Run("max-keys parameter, allow range of values", func(t *testing.T) {
		router := prepareRouter(t)

		ns, bktName, maxKeys := "", "bucket", 10
		router.middlewareSettings.denyByDefault = true

		allowOperations(router, ns, []string{"s3:CreateBucket"}, nil)
		createBucket(router, ns, bktName)

		// Add policies and check
		denyOperations(router, ns, []string{"s3:ListBucket"}, engineiam.Conditions{
			engineiam.CondNumericGreaterThan: engineiam.Condition{s3.PropertyKeyMaxKeys: []string{strconv.Itoa(maxKeys)}},
		})
		allowOperations(router, ns, []string{"s3:ListBucket"}, engineiam.Conditions{
			engineiam.CondNumericLessThanEquals: engineiam.Condition{s3.PropertyKeyMaxKeys: []string{strconv.Itoa(maxKeys)}},
		})

		listObjectsV1(router, ns, bktName, "", "", strconv.Itoa(maxKeys))
		listObjectsV1(router, ns, bktName, "", "", strconv.Itoa(maxKeys-1))
		listObjectsV1Err(router, ns, bktName, "", "", strconv.Itoa(maxKeys+1), apierr.ErrAccessDenied)
	})

	t.Run("max-keys parameter, prohibit specific value", func(t *testing.T) {
		router := prepareRouter(t)

		ns, bktName, maxKeys := "", "bucket", 10
		router.middlewareSettings.denyByDefault = true

		allowOperations(router, ns, []string{"s3:CreateBucket"}, nil)
		createBucket(router, ns, bktName)

		// Add policies and check
		denyOperations(router, ns, []string{"s3:ListBucket"}, engineiam.Conditions{
			engineiam.CondNumericEquals: engineiam.Condition{s3.PropertyKeyMaxKeys: []string{strconv.Itoa(maxKeys)}},
		})
		allowOperations(router, ns, []string{"s3:ListBucket"}, engineiam.Conditions{
			engineiam.CondNumericNotEquals: engineiam.Condition{s3.PropertyKeyMaxKeys: []string{strconv.Itoa(maxKeys)}},
		})

		listObjectsV1(router, ns, bktName, "", "", "")
		listObjectsV1(router, ns, bktName, "", "", strconv.Itoa(maxKeys-1))
		listObjectsV1Err(router, ns, bktName, "", "", strconv.Itoa(maxKeys), apierr.ErrAccessDenied)
	})
}

func TestRequestTagsCheck(t *testing.T) {
	t.Run("put bucket tagging", func(t *testing.T) {
		router := prepareRouter(t)

		ns, bktName, tagKey, tagValue := "", "bucket", "tag", "value"
		router.middlewareSettings.denyByDefault = true

		allowOperations(router, ns, []string{"s3:CreateBucket"}, nil)
		createBucket(router, ns, bktName)

		// Add policies and check
		allowOperations(router, ns, []string{"s3:PutBucketTagging"}, engineiam.Conditions{
			engineiam.CondStringEquals: engineiam.Condition{fmt.Sprintf(s3.PropertyKeyFormatRequestTag, tagKey): []string{tagValue}},
		})
		denyOperations(router, ns, []string{"s3:PutBucketTagging"}, engineiam.Conditions{
			engineiam.CondStringNotEquals: engineiam.Condition{fmt.Sprintf(s3.PropertyKeyFormatRequestTag, tagKey): []string{tagValue}},
		})

		tagging, err := xml.Marshal(data.Tagging{TagSet: []data.Tag{{Key: tagKey, Value: tagValue}}})
		require.NoError(t, err)
		putBucketTagging(router, ns, bktName, tagging)

		tagging, err = xml.Marshal(data.Tagging{TagSet: []data.Tag{{Key: "key", Value: tagValue}}})
		require.NoError(t, err)
		putBucketTaggingErr(router, ns, bktName, tagging, apierr.ErrAccessDenied)

		tagging = nil
		putBucketTaggingErr(router, ns, bktName, tagging, apierr.ErrMalformedXML)
	})

	t.Run("put object with tag", func(t *testing.T) {
		router := prepareRouter(t)

		ns, bktName, objName, tagKey, tagValue := "", "bucket", "object", "tag", "value"
		router.middlewareSettings.denyByDefault = true

		allowOperations(router, ns, []string{"s3:CreateBucket"}, nil)
		createBucket(router, ns, bktName)

		// Add policies and check
		allowOperations(router, ns, []string{"s3:PutObject"}, engineiam.Conditions{
			engineiam.CondStringEquals: engineiam.Condition{fmt.Sprintf(s3.PropertyKeyFormatRequestTag, tagKey): []string{tagValue}},
		})
		denyOperations(router, ns, []string{"s3:PutObject"}, engineiam.Conditions{
			engineiam.CondStringNotEquals: engineiam.Condition{fmt.Sprintf(s3.PropertyKeyFormatRequestTag, tagKey): []string{tagValue}},
		})

		putObject(router, ns, bktName, objName, &data.Tag{Key: tagKey, Value: tagValue})

		putObjectErr(router, ns, bktName, objName, &data.Tag{Key: "key", Value: tagValue}, apierr.ErrAccessDenied)
	})
}

func TestResourceTagsCheck(t *testing.T) {
	t.Run("bucket tagging", func(t *testing.T) {
		router := prepareRouter(t)

		ns, bktName, tagKey, tagValue := "", "bucket", "tag", "value"
		router.middlewareSettings.denyByDefault = true

		allowOperations(router, ns, []string{"s3:CreateBucket"}, nil)
		createBucket(router, ns, bktName)

		// Add policies and check
		allowOperations(router, ns, []string{"s3:ListBucket"}, engineiam.Conditions{
			engineiam.CondStringEquals: engineiam.Condition{fmt.Sprintf(s3.PropertyKeyFormatResourceTag, tagKey): []string{tagValue}},
		})
		denyOperations(router, ns, []string{"s3:ListBucket"}, engineiam.Conditions{
			engineiam.CondStringNotEquals: engineiam.Condition{fmt.Sprintf(s3.PropertyKeyFormatResourceTag, tagKey): []string{tagValue}},
		})

		router.cfg.Tagging.(*resourceTaggingMock).bucketTags = map[string]string{tagKey: tagValue}
		listObjectsV1(router, ns, bktName, "", "", "")

		router.cfg.Tagging.(*resourceTaggingMock).bucketTags = map[string]string{}
		listObjectsV1Err(router, ns, bktName, "", "", "", apierr.ErrAccessDenied)
	})

	t.Run("object tagging", func(t *testing.T) {
		router := prepareRouter(t)

		ns, bktName, objName, tagKey, tagValue := "", "bucket", "object", "tag", "value"
		router.middlewareSettings.denyByDefault = true

		allowOperations(router, ns, []string{"s3:CreateBucket", "s3:PutObject"}, nil)
		createBucket(router, ns, bktName)
		putObject(router, ns, bktName, objName, nil)

		// Add policies and check
		allowOperations(router, ns, []string{"s3:GetObject"}, engineiam.Conditions{
			engineiam.CondStringEquals: engineiam.Condition{fmt.Sprintf(s3.PropertyKeyFormatResourceTag, tagKey): []string{tagValue}},
		})
		denyOperations(router, ns, []string{"s3:GetObject"}, engineiam.Conditions{
			engineiam.CondStringNotEquals: engineiam.Condition{fmt.Sprintf(s3.PropertyKeyFormatResourceTag, tagKey): []string{tagValue}},
		})

		router.cfg.Tagging.(*resourceTaggingMock).objectTags = map[string]string{tagKey: tagValue}
		getObject(router, ns, bktName, objName)

		router.cfg.Tagging.(*resourceTaggingMock).objectTags = map[string]string{}
		getObjectErr(router, ns, bktName, objName, apierr.ErrAccessDenied)
	})

	t.Run("non-existent resources", func(t *testing.T) {
		router := prepareRouter(t)
		ns, bktName, objName := "", "bucket", "object"

		listObjectsV1Err(router, ns, bktName, "", "", "", apierr.ErrNoSuchBucket)

		router.cfg.Tagging.(*resourceTaggingMock).noSuchBucketKey = true
		createBucket(router, ns, bktName)
		getBucketErr(router, ns, bktName, apierr.ErrNoSuchKey)

		router.cfg.Tagging.(*resourceTaggingMock).noSuchObjectKey = true
		createBucket(router, ns, bktName)
		getObjectErr(router, ns, bktName, objName, apierr.ErrNoSuchKey)
	})
}

func TestAccessBoxAttributesCheck(t *testing.T) {
	router := prepareRouter(t)

	ns, bktName, attrKey, attrValue := "", "bucket", "key", "true"
	router.middlewareSettings.denyByDefault = true

	allowOperations(router, ns, []string{"s3:CreateBucket"}, nil)
	createBucket(router, ns, bktName)

	// Add policy and check
	allowOperations(router, ns, []string{"s3:ListBucket"}, engineiam.Conditions{
		engineiam.CondBool: engineiam.Condition{fmt.Sprintf(s3.PropertyKeyFormatAccessBoxAttr, attrKey): []string{attrValue}},
	})

	listObjectsV1Err(router, ns, bktName, "", "", "", apierr.ErrAccessDenied)

	var attr object.Attribute
	attr.SetKey(attrKey)
	attr.SetValue(attrValue)
	router.cfg.Center.(*centerMock).attrs = []object.Attribute{attr}
	listObjectsV1(router, ns, bktName, "", "", "")
}

func TestSourceIPCheck(t *testing.T) {
	router := prepareRouter(t)

	ns, bktName, hdr := "", "bucket", "Source-Ip"
	router.middlewareSettings.denyByDefault = true

	// Add policy and check
	allowOperations(router, ns, []string{"s3:CreateBucket"}, engineiam.Conditions{
		engineiam.CondIPAddress: engineiam.Condition{"aws:SourceIp": []string{"192.0.2.0/24"}},
	})

	router.middlewareSettings.sourceIPHeader = hdr
	header := map[string][]string{hdr: {"192.0.3.0"}}
	createBucketErr(router, ns, bktName, header, apierr.ErrAccessDenied)

	router.middlewareSettings.sourceIPHeader = ""
	createBucket(router, ns, bktName)
}

func TestMFAPolicy(t *testing.T) {
	router := prepareRouter(t)

	ns, bktName := "", "bucket"
	router.middlewareSettings.denyByDefault = true

	allowOperations(router, ns, []string{"s3:CreateBucket"}, nil)
	denyOperations(router, ns, []string{"s3:CreateBucket"}, engineiam.Conditions{
		engineiam.CondBool: engineiam.Condition{s3.PropertyKeyAccessBoxAttrMFA: []string{"false"}},
	})
	createBucketErr(router, ns, bktName, nil, apierr.ErrAccessDenied)

	var attr object.Attribute
	attr.SetKey("IAM-MFA")
	attr.SetValue("true")
	router.cfg.Center.(*centerMock).attrs = []object.Attribute{attr}

	createBucket(router, ns, bktName)
}

func allowOperations(router *routerMock, ns string, operations []string, conditions engineiam.Conditions) {
	addPolicy(router, ns, "allow", engineiam.AllowEffect, operations, conditions)
}

func denyOperations(router *routerMock, ns string, operations []string, conditions engineiam.Conditions) {
	addPolicy(router, ns, "deny", engineiam.DenyEffect, operations, conditions)
}

func addPolicy(router *routerMock, ns string, id string, effect engineiam.Effect, operations []string, conditions engineiam.Conditions) {
	policy := engineiam.Policy{
		Version: "2012-10-17",
		Statement: []engineiam.Statement{{
			Principal:  map[engineiam.PrincipalType][]string{engineiam.Wildcard: {}},
			Effect:     effect,
			Action:     engineiam.Action(operations),
			Resource:   engineiam.Resource{fmt.Sprintf(s3.ResourceFormatS3All)},
			Conditions: conditions,
		}},
	}

	ruleChain, err := engineiam.ConvertToS3Chain(policy, nil)
	require.NoError(router.t, err)
	ruleChain.ID = chain.ID(id)

	_, _, err = router.policyChecker.MorphRuleChainStorage().AddMorphRuleChain(chain.S3, engine.NamespaceTarget(ns), ruleChain)
	require.NoError(router.t, err)
}

func createBucket(router *routerMock, namespace, bktName string) {
	w := createBucketBase(router, namespace, bktName, nil)
	resp := readResponse(router.t, w)
	require.Equal(router.t, s3middleware.CreateBucketOperation, resp.Method)
}

func createBucketErr(router *routerMock, namespace, bktName string, header http.Header, errCode apierr.ErrorCode) {
	w := createBucketBase(router, namespace, bktName, header)
	assertAPIError(router.t, w, errCode)
}

func createBucketBase(router *routerMock, namespace, bktName string, header http.Header) *httptest.ResponseRecorder {
	w, r := httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/"+bktName, nil)
	r.Header.Set(FrostfsNamespaceHeader, namespace)
	for key := range header {
		r.Header.Set(key, header.Get(key))
	}

	router.ServeHTTP(w, r)
	return w
}

func getBucketErr(router *routerMock, namespace, bktName string, errCode apierr.ErrorCode) {
	w := getBucketBase(router, namespace, bktName)
	assertAPIError(router.t, w, errCode)
}

func getBucketBase(router *routerMock, namespace, bktName string) *httptest.ResponseRecorder {
	w, r := httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/"+bktName, nil)
	r.Header.Set(FrostfsNamespaceHeader, namespace)
	router.ServeHTTP(w, r)
	return w
}

func putObject(router *routerMock, namespace, bktName, objName string, tag *data.Tag) handlerResult {
	w := putObjectBase(router, namespace, bktName, objName, tag)
	resp := readResponse(router.t, w)
	require.Equal(router.t, s3middleware.PutObjectOperation, resp.Method)
	return resp
}

func putObjectErr(router *routerMock, namespace, bktName, objName string, tag *data.Tag, errCode apierr.ErrorCode) {
	w := putObjectBase(router, namespace, bktName, objName, tag)
	assertAPIError(router.t, w, errCode)
}

func putObjectBase(router *routerMock, namespace, bktName, objName string, tag *data.Tag) *httptest.ResponseRecorder {
	w, r := httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/"+bktName+"/"+objName, nil)
	if tag != nil {
		queries := url.Values{
			tag.Key: []string{tag.Value},
		}
		r.Header.Set(AmzTagging, queries.Encode())
	}
	r.Header.Set(FrostfsNamespaceHeader, namespace)
	router.ServeHTTP(w, r)
	return w
}

func deleteObject(router *routerMock, namespace, bktName, objName string, tag *data.Tag) handlerResult {
	w := deleteObjectBase(router, namespace, bktName, objName, tag)
	resp := readResponse(router.t, w)
	require.Equal(router.t, s3middleware.DeleteObjectOperation, resp.Method)
	return resp
}

func deleteObjectErr(router *routerMock, namespace, bktName, objName string, tag *data.Tag, errCode apierr.ErrorCode) {
	w := deleteObjectBase(router, namespace, bktName, objName, tag)
	assertAPIError(router.t, w, errCode)
}

func deleteObjectBase(router *routerMock, namespace, bktName, objName string, tag *data.Tag) *httptest.ResponseRecorder {
	w, r := httptest.NewRecorder(), httptest.NewRequest(http.MethodDelete, "/"+bktName+"/"+objName, nil)
	if tag != nil {
		queries := url.Values{
			tag.Key: []string{tag.Value},
		}
		r.Header.Set(AmzTagging, queries.Encode())
	}
	r.Header.Set(FrostfsNamespaceHeader, namespace)
	router.ServeHTTP(w, r)
	return w
}

func putBucketTagging(router *routerMock, namespace, bktName string, tagging []byte) handlerResult {
	w := putBucketTaggingBase(router, namespace, bktName, tagging)
	resp := readResponse(router.t, w)
	require.Equal(router.t, s3middleware.PutBucketTaggingOperation, resp.Method)
	return resp
}

func putBucketTaggingErr(router *routerMock, namespace, bktName string, tagging []byte, errCode apierr.ErrorCode) {
	w := putBucketTaggingBase(router, namespace, bktName, tagging)
	assertAPIError(router.t, w, errCode)
}

func putBucketTaggingBase(router *routerMock, namespace, bktName string, tagging []byte) *httptest.ResponseRecorder {
	queries := url.Values{}
	queries.Add(s3middleware.TaggingQuery, "")

	w, r := httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/"+bktName, bytes.NewBuffer(tagging))
	r.URL.RawQuery = queries.Encode()
	r.Header.Set(FrostfsNamespaceHeader, namespace)
	router.ServeHTTP(w, r)
	return w
}

func getObject(router *routerMock, namespace, bktName, objName string) handlerResult {
	w := getObjectBase(router, namespace, bktName, objName)
	resp := readResponse(router.t, w)
	require.Equal(router.t, s3middleware.GetObjectOperation, resp.Method)
	return resp
}

func getObjectErr(router *routerMock, namespace, bktName, objName string, errCode apierr.ErrorCode) {
	w := getObjectBase(router, namespace, bktName, objName)
	assertAPIError(router.t, w, errCode)
}

func getObjectBase(router *routerMock, namespace, bktName, objName string) *httptest.ResponseRecorder {
	w, r := httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/"+bktName+"/"+objName, nil)
	r.Header.Set(FrostfsNamespaceHeader, namespace)
	router.ServeHTTP(w, r)
	return w
}

func listObjectsV1(router *routerMock, namespace, bktName, prefix, delimiter, maxKeys string) handlerResult {
	w := listObjectsV1Base(router, namespace, bktName, prefix, delimiter, maxKeys)
	resp := readResponse(router.t, w)
	require.Equal(router.t, s3middleware.ListObjectsV1Operation, resp.Method)
	return resp
}

func listObjectsV1Err(router *routerMock, namespace, bktName, prefix, delimiter, maxKeys string, errCode apierr.ErrorCode) {
	w := listObjectsV1Base(router, namespace, bktName, prefix, delimiter, maxKeys)
	assertAPIError(router.t, w, errCode)
}

func listObjectsV1Base(router *routerMock, namespace, bktName, prefix, delimiter, maxKeys string) *httptest.ResponseRecorder {
	queries := url.Values{}
	if len(prefix) > 0 {
		queries.Add(s3middleware.QueryPrefix, prefix)
	}
	if len(delimiter) > 0 {
		queries.Add(s3middleware.QueryDelimiter, delimiter)
	}
	if len(maxKeys) > 0 {
		queries.Add(s3middleware.QueryMaxKeys, maxKeys)
	}
	encoded := queries.Encode()

	w, r := httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/"+bktName, nil)
	r.URL.RawQuery = encoded
	r.Header.Set(FrostfsNamespaceHeader, namespace)
	router.ServeHTTP(w, r)
	return w
}

func TestOwnerIDRetrieving(t *testing.T) {
	chiRouter := prepareRouter(t)

	ns, bktName, objName := "", "test-bucket", "test-object"

	createBucket(chiRouter, ns, bktName)

	resp := putObject(chiRouter, ns, bktName, objName, nil)
	require.NotEqual(t, "anon", resp.ReqInfo.User)

	chiRouter.cfg.Center.(*centerMock).anon = true
	resp = putObject(chiRouter, ns, bktName, objName, nil)
	require.Equal(t, "anon", resp.ReqInfo.User)
}

func TestBillingMetrics(t *testing.T) {
	chiRouter := prepareRouter(t)

	ns, bktName, objName := "", "test-bucket", "test-object"

	createBucket(chiRouter, ns, bktName)
	dump := chiRouter.cfg.Metrics.UsersAPIStats().DumpMetrics()
	require.Len(t, dump.Requests, 1)
	require.NotEqual(t, "anon", dump.Requests[0].User)
	require.Equal(t, metrics.PUTRequest, dump.Requests[0].Operation)
	require.Equal(t, bktName, dump.Requests[0].Bucket)
	require.Equal(t, 1, dump.Requests[0].Requests)

	chiRouter.cfg.Center.(*centerMock).anon = true
	putObject(chiRouter, ns, bktName, objName, nil)
	dump = chiRouter.cfg.Metrics.UsersAPIStats().DumpMetrics()
	require.Len(t, dump.Requests, 1)
	require.Equal(t, "anon", dump.Requests[0].User)
}

func TestAuthenticate(t *testing.T) {
	chiRouter := prepareRouter(t)
	createBucket(chiRouter, "", "bkt-1")

	chiRouter = prepareRouter(t)
	chiRouter.cfg.Center.(*centerMock).noAuthHeader = true
	createBucket(chiRouter, "", "bkt-2")

	chiRouter = prepareRouter(t)
	chiRouter.cfg.Center.(*centerMock).isError = true
	createBucketErr(chiRouter, "", "bkt-3", nil, apierr.ErrAccessDenied)
}

func TestFrostFSIDValidation(t *testing.T) {
	// successful frostFSID validation
	chiRouter := prepareRouter(t, frostFSIDValidation(true))
	createBucket(chiRouter, "", "bkt-1")

	// anon request, skip frostFSID validation
	chiRouter = prepareRouter(t, frostFSIDValidation(true))
	chiRouter.cfg.Center.(*centerMock).anon = true
	createBucket(chiRouter, "", "bkt-2")

	// frostFSID validation failed
	chiRouter = prepareRouter(t, frostFSIDValidation(true))
	chiRouter.cfg.FrostfsID.(*frostFSIDMock).validateError = true
	createBucketErr(chiRouter, "", "bkt-3", nil, apierr.ErrInternalError)
}

func TestRouterListObjectsV2Domains(t *testing.T) {
	chiRouter := prepareRouter(t, enableVHSDomains("domain.com"))

	chiRouter.handler.buckets["bucket"] = &data.BucketInfo{}

	w := httptest.NewRecorder()
	r := httptest.NewRequest(http.MethodGet, "/", nil)
	r.Host = "bucket.domain.com"
	query := make(url.Values)
	query.Set(s3middleware.ListTypeQuery, "2")
	r.URL.RawQuery = query.Encode()

	chiRouter.ServeHTTP(w, r)
	resp := readResponse(t, w)
	require.Equal(t, s3middleware.ListObjectsV2Operation, resp.Method)
}

func enableVHSDomains(domains ...string) option {
	return func(cfg *Config) {
		setting := cfg.MiddlewareSettings.(*middlewareSettingsMock)
		setting.vhsEnabled = true
		setting.domains = domains
	}
}

func readResponse(t *testing.T, w *httptest.ResponseRecorder) handlerResult {
	var res handlerResult

	resData, err := io.ReadAll(w.Result().Body)
	require.NoError(t, err)

	err = json.Unmarshal(resData, &res)
	require.NoErrorf(t, err, "actual body: '%s'", string(resData))
	return res
}

func assertAPIError(t *testing.T, w *httptest.ResponseRecorder, expectedErrorCode apierr.ErrorCode) {
	actualErrorResponse := &s3middleware.ErrorResponse{}
	err := xml.NewDecoder(w.Result().Body).Decode(actualErrorResponse)
	require.NoError(t, err)

	expectedError := apierr.GetAPIError(expectedErrorCode)

	require.Equal(t, expectedError.HTTPStatusCode, w.Code)
	require.Equal(t, expectedError.Code, actualErrorResponse.Code)

	if expectedError.ErrCode != apierr.ErrInternalError {
		require.Contains(t, actualErrorResponse.Message, expectedError.Description)
	}
}