object_id_test.go

package test

import (
	"testing"

	"git.perx.ru/perxis/perxis-go/id"
	_ "git.perx.ru/perxis/perxis-go/id/system"
	"git.perx.ru/perxis/perxis-go/pkg/clients"
	"git.perx.ru/perxis/perxis-go/pkg/collections"
	"git.perx.ru/perxis/perxis-go/pkg/environments"
	"git.perx.ru/perxis/perxis-go/pkg/items"
	"git.perx.ru/perxis/perxis-go/pkg/locales"
	"git.perx.ru/perxis/perxis-go/pkg/organizations"
	"git.perx.ru/perxis/perxis-go/pkg/roles"
	"git.perx.ru/perxis/perxis-go/pkg/spaces"
	"git.perx.ru/perxis/perxis-go/pkg/users"
	"github.com/stretchr/testify/require"
)

func Test_OrganizationId(t *testing.T) {

	tests := []struct {
		name   string
		in     any
		out    string
		result *id.ObjectId
		err    error
	}{
		{
			name:   "valid string",
			in:     "/orgs/<org_id>",
			result: &id.ObjectId{Descriptor: &id.OrganizationId{OrganizationID: "<org_id>"}},
		},
		{
			name:   "valid object",
			in:     &organizations.Organization{ID: "<org_id>"},
			out:    "/orgs/<org_id>",
			result: &id.ObjectId{Descriptor: &id.OrganizationId{OrganizationID: "<org_id>"}},
		},
		{
			name:   "valid map",
			in:     map[string]any{"type": "organization", "org_id": "<org_id>"},
			out:    "/orgs/<org_id>",
			result: &id.ObjectId{Descriptor: &id.OrganizationId{OrganizationID: "<org_id>"}},
		},
		{
			name:   "invalid map",
			in:     map[string]any{"type": "organization"},
			out:    "/orgs/<org_id>",
			result: &id.ObjectId{Descriptor: &id.OrganizationId{OrganizationID: "<org_id>"}},
			err:    id.ErrInvalidID,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			i, err := id.NewObjectId(tt.in)

			if tt.err != nil {
				require.ErrorIs(t, err, tt.err)
				return
			}

			require.NoError(t, err)
			require.Equal(t, tt.result, i)
			if tt.out == "" {
				require.Equal(t, tt.in, i.String())
			} else {
				require.Equal(t, tt.out, i.String())
			}
		})
	}
}

func Test_ServiceId(t *testing.T) {

	tests := []struct {
		name   string
		in     any
		out    string
		result *id.ObjectId
		err    error
	}{
		{
			name:   "valid string",
			in:     "/services/<service_id>",
			result: &id.ObjectId{Descriptor: &id.ServiceId{ServiceID: "<service_id>"}},
		},
		{
			name:   "valid map",
			in:     map[string]any{"type": "service", "service_id": "<service_id>"},
			out:    "/services/<service_id>",
			result: &id.ObjectId{Descriptor: &id.ServiceId{ServiceID: "<service_id>"}},
		},
		{
			name:   "invalid map",
			in:     map[string]any{"type": "service"},
			out:    "/services/<service_id>",
			result: &id.ObjectId{Descriptor: &id.ServiceId{ServiceID: "<service_id>"}},
			err:    id.ErrInvalidID,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			i, err := id.NewObjectId(tt.in)

			if tt.err != nil {
				require.ErrorIs(t, err, tt.err)
				return
			}

			require.NoError(t, err)
			require.Equal(t, tt.result, i)
			if tt.out == "" {
				require.Equal(t, tt.in, i.String())
			} else {
				require.Equal(t, tt.out, i.String())
			}
		})
	}
}

func Test_UserId(t *testing.T) {

	tests := []struct {
		name   string
		in     any
		out    string
		result *id.ObjectId
		err    error
	}{
		{
			name:   "valid string",
			in:     "/users/<user_id>",
			result: &id.ObjectId{Descriptor: &id.UserId{UserID: "<user_id>"}},
		},
		{
			name:   "valid object",
			in:     &users.User{ID: "<user_id>"},
			out:    "/users/<user_id>",
			result: &id.ObjectId{Descriptor: &id.UserId{UserID: "<user_id>"}},
		},
		{
			name:   "valid map",
			in:     map[string]any{"type": "user", "user_id": "<user_id>"},
			out:    "/users/<user_id>",
			result: &id.ObjectId{Descriptor: &id.UserId{UserID: "<user_id>"}},
		},
		{
			name:   "invalid map",
			in:     map[string]any{"type": "user"},
			out:    "/users/<user_id>",
			result: &id.ObjectId{Descriptor: &id.UserId{UserID: "<user_id>"}},
			err:    id.ErrInvalidID,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			i, err := id.NewObjectId(tt.in)

			if tt.err != nil {
				require.ErrorIs(t, err, tt.err)
				return
			}

			require.NoError(t, err)
			require.Equal(t, tt.result, i)
			if tt.out == "" {
				require.Equal(t, tt.in, i.String())
			} else {
				require.Equal(t, tt.out, i.String())
			}
		})
	}
}

func Test_SpaceId(t *testing.T) {

	tests := []struct {
		name   string
		in     any
		out    string
		result *id.ObjectId
		err    error
	}{
		{
			name:   "valid string",
			in:     "/spaces/<space_id>",
			result: &id.ObjectId{Descriptor: &id.SpaceId{SpaceID: "<space_id>"}},
		},
		{
			name:   "valid object",
			in:     &spaces.Space{ID: "<space_id>"},
			out:    "/spaces/<space_id>",
			result: &id.ObjectId{Descriptor: &id.SpaceId{SpaceID: "<space_id>"}},
		},
		{
			name:   "valid map",
			in:     map[string]any{"type": "space", "space_id": "<space_id>"},
			out:    "/spaces/<space_id>",
			result: &id.ObjectId{Descriptor: &id.SpaceId{SpaceID: "<space_id>"}},
		},
		{
			name:   "invalid map",
			in:     map[string]any{"type": "space"},
			out:    "/spaces/<space_id>",
			result: &id.ObjectId{Descriptor: &id.SpaceId{SpaceID: "<space_id>"}},
			err:    id.ErrInvalidID,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			i, err := id.NewObjectId(tt.in)

			if tt.err != nil {
				require.ErrorIs(t, err, tt.err)
				return
			}

			require.NoError(t, err)
			require.Equal(t, tt.result, i)
			if tt.out == "" {
				require.Equal(t, tt.in, i.String())
			} else {
				require.Equal(t, tt.out, i.String())
			}
		})
	}
}

func Test_EnvironmentId(t *testing.T) {

	tests := []struct {
		name   string
		in     any
		out    string
		result *id.ObjectId
		err    error
	}{
		{
			name: "valid string",
			in:   "/spaces/<space_id>/envs/<env_id>",
			result: &id.ObjectId{Descriptor: &id.EnvironmentId{
				SpaceId:       id.SpaceId{SpaceID: "<space_id>"},
				EnvironmentID: "<env_id>",
			}},
		},
		{
			name: "invalid string",
			in:   "/envs/<env_id>",
			result: &id.ObjectId{Descriptor: &id.EnvironmentId{
				SpaceId:       id.SpaceId{SpaceID: "<space_id>"},
				EnvironmentID: "<env_id>",
			}},
			err: id.ErrInvalidID,
		},
		{
			name: "valid object",
			in:   &environments.Environment{SpaceID: "<space_id>", ID: "<env_id>"},
			out:  "/spaces/<space_id>/envs/<env_id>",
			result: &id.ObjectId{Descriptor: &id.EnvironmentId{
				SpaceId:       id.SpaceId{SpaceID: "<space_id>"},
				EnvironmentID: "<env_id>",
			}},
		},
		{
			name: "valid map",
			in:   map[string]any{"type": "environment", "space_id": "<space_id>", "env_id": "<env_id>"},
			out:  "/spaces/<space_id>/envs/<env_id>",
			result: &id.ObjectId{Descriptor: &id.EnvironmentId{
				SpaceId:       id.SpaceId{SpaceID: "<space_id>"},
				EnvironmentID: "<env_id>",
			}},
		},
		{
			name: "invalid map 1",
			in:   map[string]any{"type": "environment", "space_id": "<space_id>"},
			out:  "/spaces/<space_id>/envs/<env_id>",
			result: &id.ObjectId{Descriptor: &id.EnvironmentId{
				SpaceId:       id.SpaceId{SpaceID: "<space_id>"},
				EnvironmentID: "<env_id>",
			}},
			err: id.ErrInvalidID,
		},
		{
			name: "invalid map 2",
			in:   map[string]any{"type": "environment", "env_id": "<env_id>"},
			out:  "/spaces/<space_id>/envs/<env_id>",
			result: &id.ObjectId{Descriptor: &id.EnvironmentId{
				SpaceId:       id.SpaceId{SpaceID: "<space_id>"},
				EnvironmentID: "<env_id>",
			}},
			err: id.ErrInvalidID,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			i, err := id.NewObjectId(tt.in)

			if tt.err != nil {
				require.ErrorIs(t, err, tt.err)
				return
			}

			require.NoError(t, err)
			require.Equal(t, tt.result, i)
			if tt.out == "" {
				require.Equal(t, tt.in, i.String())
			} else {
				require.Equal(t, tt.out, i.String())
			}
		})
	}
}

func Test_ClientId(t *testing.T) {

	tests := []struct {
		name   string
		in     any
		out    string
		result *id.ObjectId
		err    error
	}{
		{
			name: "valid string",
			in:   "/spaces/<space_id>/clients/<client_id>",
			result: &id.ObjectId{Descriptor: &id.ClientId{
				SpaceId:  id.SpaceId{SpaceID: "<space_id>"},
				ClientID: "<client_id>",
			}},
		},
		{
			name: "invalid string",
			in:   "/clients/<client_id>",
			result: &id.ObjectId{Descriptor: &id.ClientId{
				SpaceId:  id.SpaceId{SpaceID: "<space_id>"},
				ClientID: "<client_id>",
			}},
			err: id.ErrInvalidID,
		},
		{
			name: "valid object",
			in:   &clients.Client{SpaceID: "<space_id>", ID: "<client_id>"},
			out:  "/spaces/<space_id>/clients/<client_id>",
			result: &id.ObjectId{Descriptor: &id.ClientId{
				SpaceId:  id.SpaceId{SpaceID: "<space_id>"},
				ClientID: "<client_id>",
			}},
		},
		{
			name: "valid map",
			in:   map[string]any{"type": "client", "space_id": "<space_id>", "client_id": "<client_id>"},
			out:  "/spaces/<space_id>/clients/<client_id>",
			result: &id.ObjectId{Descriptor: &id.ClientId{
				SpaceId:  id.SpaceId{SpaceID: "<space_id>"},
				ClientID: "<client_id>",
			}},
		},
		{
			name: "invalid map 1",
			in:   map[string]any{"type": "client", "space_id": "<space_id>"},
			out:  "/spaces/<space_id>/clients/<client_id>",
			result: &id.ObjectId{Descriptor: &id.ClientId{
				SpaceId:  id.SpaceId{SpaceID: "<space_id>"},
				ClientID: "<client_id>",
			}},
			err: id.ErrInvalidID,
		},
		{
			name: "invalid map 2",
			in:   map[string]any{"type": "client", "client_id": "<client_id>"},
			out:  "/spaces/<space_id>/clients/<client_id>",
			result: &id.ObjectId{Descriptor: &id.ClientId{
				SpaceId:  id.SpaceId{SpaceID: "<space_id>"},
				ClientID: "<client_id>",
			}},
			err: id.ErrInvalidID,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			i, err := id.NewObjectId(tt.in)

			if tt.err != nil {
				require.ErrorIs(t, err, tt.err)
				return
			}

			require.NoError(t, err)
			require.Equal(t, tt.result, i)
			if tt.out == "" {
				require.Equal(t, tt.in, i.String())
			} else {
				require.Equal(t, tt.out, i.String())
			}
		})
	}
}

func Test_RoleId(t *testing.T) {

	tests := []struct {
		name   string
		in     any
		out    string
		result *id.ObjectId
		err    error
	}{
		{
			name: "valid string",
			in:   "/spaces/<space_id>/roles/<role_id>",
			result: &id.ObjectId{Descriptor: &id.RoleId{
				SpaceId: id.SpaceId{SpaceID: "<space_id>"},
				RoleID:  "<role_id>",
			}},
		},
		{
			name: "invalid string",
			in:   "/roles/<role_id>",
			result: &id.ObjectId{Descriptor: &id.RoleId{
				SpaceId: id.SpaceId{SpaceID: "<space_id>"},
				RoleID:  "<role_id>",
			}},
			err: id.ErrInvalidID,
		},
		{
			name: "valid object",
			in:   &roles.Role{SpaceID: "<space_id>", ID: "<role_id>"},
			out:  "/spaces/<space_id>/roles/<role_id>",
			result: &id.ObjectId{Descriptor: &id.RoleId{
				SpaceId: id.SpaceId{SpaceID: "<space_id>"},
				RoleID:  "<role_id>",
			}},
		},
		{
			name: "valid map",
			in:   map[string]any{"type": "role", "space_id": "<space_id>", "role_id": "<role_id>"},
			out:  "/spaces/<space_id>/roles/<role_id>",
			result: &id.ObjectId{Descriptor: &id.RoleId{
				SpaceId: id.SpaceId{SpaceID: "<space_id>"},
				RoleID:  "<role_id>",
			}},
		},
		{
			name: "invalid map 1",
			in:   map[string]any{"type": "client", "space_id": "<space_id>"},
			out:  "/spaces/<space_id>/roles/<role_id>",
			result: &id.ObjectId{Descriptor: &id.RoleId{
				SpaceId: id.SpaceId{SpaceID: "<space_id>"},
				RoleID:  "<role_id>",
			}},
			err: id.ErrInvalidID,
		},
		{
			name: "invalid map 2",
			in:   map[string]any{"type": "role", "role_id": "<role_id>"},
			out:  "/spaces/<space_id>/roles/<role_id>",
			result: &id.ObjectId{Descriptor: &id.RoleId{
				SpaceId: id.SpaceId{SpaceID: "<space_id>"},
				RoleID:  "<role_id>",
			}},
			err: id.ErrInvalidID,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			i, err := id.NewObjectId(tt.in)

			if tt.err != nil {
				require.ErrorIs(t, err, tt.err)
				return
			}

			require.NoError(t, err)
			require.Equal(t, tt.result, i)
			if tt.out == "" {
				require.Equal(t, tt.in, i.String())
			} else {
				require.Equal(t, tt.out, i.String())
			}
		})
	}
}

func Test_CollectionId(t *testing.T) {

	tests := []struct {
		name   string
		in     any
		out    string
		result *id.ObjectId
		err    error
	}{
		{
			name: "valid string",
			in:   "/spaces/<space_id>/envs/<env_id>/cols/<collection_id>",
			result: &id.ObjectId{Descriptor: &id.CollectionId{
				EnvironmentId: id.EnvironmentId{SpaceId: id.SpaceId{SpaceID: "<space_id>"}, EnvironmentID: "<env_id>"},
				CollectionID:  "<collection_id>",
			}},
		},
		{
			name: "valid object",
			in:   &collections.Collection{SpaceID: "<space_id>", EnvID: "<env_id>", ID: "<collection_id>"},
			out:  "/spaces/<space_id>/envs/<env_id>/cols/<collection_id>",
			result: &id.ObjectId{Descriptor: &id.CollectionId{
				EnvironmentId: id.EnvironmentId{SpaceId: id.SpaceId{SpaceID: "<space_id>"}, EnvironmentID: "<env_id>"},
				CollectionID:  "<collection_id>",
			}},
		},
		{
			name: "valid map",
			in:   map[string]any{"type": "collection", "space_id": "<space_id>", "env_id": "<env_id>", "col_id": "<collection_id>"},
			out:  "/spaces/<space_id>/envs/<env_id>/cols/<collection_id>",
			result: &id.ObjectId{Descriptor: &id.CollectionId{
				EnvironmentId: id.EnvironmentId{SpaceId: id.SpaceId{SpaceID: "<space_id>"}, EnvironmentID: "<env_id>"},
				CollectionID:  "<collection_id>",
			}},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			i, err := id.NewObjectId(tt.in)

			if tt.err != nil {
				require.ErrorIs(t, err, tt.err)
				return
			}

			require.NoError(t, err)
			require.Equal(t, tt.result, i)
			if tt.out == "" {
				require.Equal(t, tt.in, i.String())
			} else {
				require.Equal(t, tt.out, i.String())
			}
		})
	}
}

func Test_SchemaId(t *testing.T) {

	tests := []struct {
		name   string
		in     any
		out    string
		result *id.ObjectId
		err    error
	}{
		{
			name: "valid string",
			in:   "/spaces/<space_id>/envs/<env_id>/schema/<collection_id>",
			result: &id.ObjectId{Descriptor: &id.SchemaId{
				EnvironmentId: id.EnvironmentId{SpaceId: id.SpaceId{SpaceID: "<space_id>"}, EnvironmentID: "<env_id>"},
				CollectionID:  "<collection_id>",
			}},
		},
		{
			name: "valid map",
			in:   map[string]any{"type": "schema", "space_id": "<space_id>", "env_id": "<env_id>", "col_id": "<collection_id>"},
			out:  "/spaces/<space_id>/envs/<env_id>/schema/<collection_id>",
			result: &id.ObjectId{Descriptor: &id.SchemaId{
				EnvironmentId: id.EnvironmentId{SpaceId: id.SpaceId{SpaceID: "<space_id>"}, EnvironmentID: "<env_id>"},
				CollectionID:  "<collection_id>",
			}},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			i, err := id.NewObjectId(tt.in)

			if tt.err != nil {
				require.ErrorIs(t, err, tt.err)
				return
			}

			require.NoError(t, err)
			require.Equal(t, tt.result, i)
			if tt.out == "" {
				require.Equal(t, tt.in, i.String())
			} else {
				require.Equal(t, tt.out, i.String())
			}
		})
	}
}

func Test_ItemId(t *testing.T) {

	tests := []struct {
		name   string
		in     any
		out    string
		result *id.ObjectId
		err    error
	}{
		{
			name: "valid string",
			in:   "/spaces/<space_id>/envs/<env_id>/cols/<collection_id>/items/<item_id>",
			result: &id.ObjectId{Descriptor: &id.ItemId{
				CollectionId: id.CollectionId{
					EnvironmentId: id.EnvironmentId{
						SpaceId:       id.SpaceId{SpaceID: "<space_id>"},
						EnvironmentID: "<env_id>",
					},
					CollectionID: "<collection_id>",
				},
				ItemID: "<item_id>",
			}},
		},
		{
			name: "valid object",
			in:   &items.Item{SpaceID: "<space_id>", EnvID: "<env_id>", CollectionID: "<collection_id>", ID: "<item_id>"},
			out:  "/spaces/<space_id>/envs/<env_id>/cols/<collection_id>/items/<item_id>",
			result: &id.ObjectId{Descriptor: &id.ItemId{
				CollectionId: id.CollectionId{
					EnvironmentId: id.EnvironmentId{
						SpaceId:       id.SpaceId{SpaceID: "<space_id>"},
						EnvironmentID: "<env_id>",
					},
					CollectionID: "<collection_id>",
				},
				ItemID: "<item_id>",
			}},
		},
		{
			name: "valid map",
			in:   map[string]any{"type": "item", "space_id": "<space_id>", "env_id": "<env_id>", "col_id": "<collection_id>", "item_id": "<item_id>"},
			out:  "/spaces/<space_id>/envs/<env_id>/cols/<collection_id>/items/<item_id>",
			result: &id.ObjectId{Descriptor: &id.ItemId{
				CollectionId: id.CollectionId{
					EnvironmentId: id.EnvironmentId{
						SpaceId:       id.SpaceId{SpaceID: "<space_id>"},
						EnvironmentID: "<env_id>",
					},
					CollectionID: "<collection_id>",
				},
				ItemID: "<item_id>",
			}},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			i, err := id.NewObjectId(tt.in)

			if tt.err != nil {
				require.ErrorIs(t, err, tt.err)
				return
			}

			require.NoError(t, err)
			require.Equal(t, tt.result, i)
			if tt.out == "" {
				require.Equal(t, tt.in, i.String())
			} else {
				require.Equal(t, tt.out, i.String())
			}
		})
	}
}

func Test_FieldId(t *testing.T) {

	tests := []struct {
		name   string
		in     any
		out    string
		result *id.ObjectId
		err    error
	}{
		{
			name: "valid string",
			in:   "/spaces/<space_id>/envs/<env_id>/cols/<collection_id>/items/<item_id>/fields/<field>",
			result: &id.ObjectId{Descriptor: &id.FieldId{
				ItemId: id.ItemId{
					CollectionId: id.CollectionId{
						EnvironmentId: id.EnvironmentId{
							SpaceId:       id.SpaceId{SpaceID: "<space_id>"},
							EnvironmentID: "<env_id>",
						},
						CollectionID: "<collection_id>",
					},
					ItemID: "<item_id>",
				},
				Field: "<field>",
			}},
		},
		{
			name: "valid map",
			in:   map[string]any{"type": "field", "space_id": "<space_id>", "env_id": "<env_id>", "col_id": "<collection_id>", "item_id": "<item_id>", "field": "<field>"},
			out:  "/spaces/<space_id>/envs/<env_id>/cols/<collection_id>/items/<item_id>/fields/<field>",
			result: &id.ObjectId{Descriptor: &id.FieldId{
				ItemId: id.ItemId{
					CollectionId: id.CollectionId{
						EnvironmentId: id.EnvironmentId{
							SpaceId:       id.SpaceId{SpaceID: "<space_id>"},
							EnvironmentID: "<env_id>",
						},
						CollectionID: "<collection_id>",
					},
					ItemID: "<item_id>",
				},
				Field: "<field>",
			}},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			i, err := id.NewObjectId(tt.in)

			if tt.err != nil {
				require.ErrorIs(t, err, tt.err)
				return
			}

			require.NoError(t, err)
			require.Equal(t, tt.result, i)
			if tt.out == "" {
				require.Equal(t, tt.in, i.String())
			} else {
				require.Equal(t, tt.out, i.String())
			}
		})
	}
}

func Test_RevisionId(t *testing.T) {

	tests := []struct {
		name   string
		in     any
		out    string
		result *id.ObjectId
		err    error
	}{
		{
			name: "valid string",
			in:   "/spaces/<space_id>/envs/<env_id>/cols/<collection_id>/items/<item_id>/revs/<rev_id>",
			result: &id.ObjectId{Descriptor: &id.RevisionId{
				ItemId: id.ItemId{
					CollectionId: id.CollectionId{
						EnvironmentId: id.EnvironmentId{
							SpaceId:       id.SpaceId{SpaceID: "<space_id>"},
							EnvironmentID: "<env_id>",
						},
						CollectionID: "<collection_id>",
					},
					ItemID: "<item_id>",
				},
				RevisionID: "<rev_id>",
			}},
		},
		{
			name: "valid map",
			in:   map[string]any{"type": "revision", "space_id": "<space_id>", "env_id": "<env_id>", "col_id": "<collection_id>", "item_id": "<item_id>", "rev_id": "<rev_id>"},
			out:  "/spaces/<space_id>/envs/<env_id>/cols/<collection_id>/items/<item_id>/revs/<rev_id>",
			result: &id.ObjectId{Descriptor: &id.RevisionId{
				ItemId: id.ItemId{
					CollectionId: id.CollectionId{
						EnvironmentId: id.EnvironmentId{
							SpaceId:       id.SpaceId{SpaceID: "<space_id>"},
							EnvironmentID: "<env_id>",
						},
						CollectionID: "<collection_id>",
					},
					ItemID: "<item_id>",
				},
				RevisionID: "<rev_id>",
			}},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			i, err := id.NewObjectId(tt.in)

			if tt.err != nil {
				require.ErrorIs(t, err, tt.err)
				return
			}

			require.NoError(t, err)
			require.Equal(t, tt.result, i)
			if tt.out == "" {
				require.Equal(t, tt.in, i.String())
			} else {
				require.Equal(t, tt.out, i.String())
			}
		})
	}
}

func Test_LocaleId(t *testing.T) {

	tests := []struct {
		name   string
		in     any
		out    string
		result *id.ObjectId
		err    error
	}{
		{
			name: "valid string",
			in:   "/spaces/<space_id>/locales/<locale_id>",
			result: &id.ObjectId{Descriptor: &id.LocaleID{
				SpaceId:  id.SpaceId{SpaceID: "<space_id>"},
				LocaleID: "<locale_id>",
			}},
		},
		{
			name: "invalid string",
			in:   "/locales/<locale_id>",
			result: &id.ObjectId{Descriptor: &id.LocaleID{
				SpaceId:  id.SpaceId{SpaceID: "<space_id>"},
				LocaleID: "<locale_id>",
			}},
			err: id.ErrInvalidID,
		},
		{
			name: "valid object",
			in:   &locales.Locale{SpaceID: "<space_id>", ID: "<locale_id>"},
			out:  "/spaces/<space_id>/locales/<locale_id>",
			result: &id.ObjectId{Descriptor: &id.LocaleID{
				SpaceId:  id.SpaceId{SpaceID: "<space_id>"},
				LocaleID: "<locale_id>",
			}},
		},
		{
			name: "valid map",
			in:   map[string]any{"type": "locale", "space_id": "<space_id>", "locale_id": "<locale_id>"},
			out:  "/spaces/<space_id>/locales/<locale_id>",
			result: &id.ObjectId{Descriptor: &id.LocaleID{
				SpaceId:  id.SpaceId{SpaceID: "<space_id>"},
				LocaleID: "<locale_id>",
			}},
		},
		{
			name: "invalid map 1",
			in:   map[string]any{"type": "client", "space_id": "<space_id>"},
			out:  "/spaces/<space_id>/locales/<locale_id>",
			result: &id.ObjectId{Descriptor: &id.LocaleID{
				SpaceId:  id.SpaceId{SpaceID: "<space_id>"},
				LocaleID: "<locale_id>",
			}},
			err: id.ErrInvalidID,
		},
		{
			name: "invalid map 2",
			in:   map[string]any{"type": "locale", "locale_id": "<locale_id>"},
			out:  "/spaces/<space_id>/locales/<locale_id>",
			result: &id.ObjectId{Descriptor: &id.LocaleID{
				SpaceId:  id.SpaceId{SpaceID: "<space_id>"},
				LocaleID: "<locale_id>",
			}},
			err: id.ErrInvalidID,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			i, err := id.NewObjectId(tt.in)

			if tt.err != nil {
				require.ErrorIs(t, err, tt.err)
				return
			}

			require.NoError(t, err)
			require.Equal(t, tt.result, i)
			if tt.out == "" {
				require.Equal(t, tt.in, i.String())
			} else {
				require.Equal(t, tt.out, i.String())
			}
		})
	}
}