Create User Service Handler and SDK (#106)

* Create user handler stuff.

* Fixing Not Found errors from DB.

* Fixing param names.

* Update the proto's go package generation.

* Generate the user resource.

* Adding SDK methods for users.

* Fix the base type of Users and add tests.

* Connect user service to the controller handler.

* Attach the default org to the Test Controller's client.

* Take into account the provided request paths when the client builds the org/project path prefix.

* Adding comments to the API.

* rename repo function to repoFn.

* Fix typo in update mask errors.

* Clean up tests.

* Remove special checks for request url content in the api client and fix CORS test.
This commit is contained in:
Todd Knight authored and GitHub committed 2020-06-09 11:20:59 -07:00
1 parent 2c3fbe3024
commit df6ca5289f
25 files changed
+3845 -9

No files matched your search

+2 -1
View File
@@ -162,9 +162,10 @@ func TestHandler_CORS(t *testing.T) {
// Create a client with the right address
client := tc.Client()
client.SetAddr(tc.ApiAddrs()[c.listenerNum-1])
client.SetOrg("o_1234567890")
// Create the request
req, err := client.NewRequest(tc.Context(), c.method, "orgs/o_1234567890/projects", nil)
req, err := client.NewRequest(tc.Context(), c.method, "projects", nil)
assert.NoError(t, err)
// Append headers
+8
View File
@@ -21,6 +21,7 @@ import (
"github.com/hashicorp/watchtower/internal/servers/controller/handlers/host_sets"
"github.com/hashicorp/watchtower/internal/servers/controller/handlers/hosts"
"github.com/hashicorp/watchtower/internal/servers/controller/handlers/projects"
"github.com/hashicorp/watchtower/internal/servers/controller/handlers/users"
)
type HandlerProperties struct {
@@ -84,6 +85,13 @@ func handleGrpcGateway(c *Controller) (http.Handler, error) {
if err := services.RegisterProjectServiceHandlerServer(ctx, mux, ps); err != nil {
return nil, fmt.Errorf("failed to register project service handler: %w", err)
}
us, err := users.NewService(c.IamRepoFn)
if err != nil {
return nil, fmt.Errorf("failed to create user handler service: %w", err)
}
if err := services.RegisterUserServiceHandlerServer(ctx, mux, us); err != nil {
return nil, fmt.Errorf("failed to register user service handler: %w", err)
}
return mux, nil
}
@@ -9,6 +9,7 @@ import (
pb "github.com/hashicorp/watchtower/internal/gen/controller/api/resources/hosts"
pbs "github.com/hashicorp/watchtower/internal/gen/controller/api/services"
"github.com/hashicorp/watchtower/internal/host/static"
"github.com/hashicorp/watchtower/internal/iam"
"github.com/hashicorp/watchtower/internal/servers/controller/common"
"github.com/hashicorp/watchtower/internal/servers/controller/handlers"
"google.golang.org/grpc/codes"
@@ -390,10 +391,10 @@ func validateAncestors(r ancestorProvider) map[string]string {
return badFields
}
if !validId(r.GetOrgId(), "o_") {
if !validId(r.GetOrgId(), iam.OrganizationScope.Prefix()+"_") {
badFields[orgIdFieldName] = "The field is incorrectly formatted."
}
if !validId(r.GetProjectId(), "p_") {
if !validId(r.GetProjectId(), iam.ProjectScope.Prefix()+"_") {
badFields[projectIdFieldName] = "The field is incorrectly formatted."
}
return badFields
@@ -16,6 +16,8 @@ import (
"google.golang.org/protobuf/types/known/wrapperspb"
)
const orgIdFieldName = "org_id"
var (
reInvalidID = regexp.MustCompile("[^A-Za-z0-9]")
// TODO(ICU-28): Find a way to auto update these names and enforce the mappings between wire and storage.
@@ -221,7 +223,7 @@ func toProto(in *iam.Scope) *pb.Project {
// * There are no conflicting parameters provided
func validateGetRequest(req *pbs.GetProjectRequest) error {
badFields := validateAncestors(req)
if !validId(req.GetId(), "p_") {
if !validId(req.GetId(), iam.ProjectScope.Prefix()+"_") {
badFields["id"] = "Invalid formatted project id."
}
if len(badFields) > 0 {
@@ -250,7 +252,7 @@ func validateCreateRequest(req *pbs.CreateProjectRequest) error {
func validateUpdateRequest(req *pbs.UpdateProjectRequest) error {
badFields := validateAncestors(req)
if !validId(req.GetId(), "p_") {
if !validId(req.GetId(), iam.ProjectScope.Prefix()+"_") {
badFields["project_id"] = "Improperly formatted path identifier."
}
if req.GetUpdateMask() == nil {
@@ -284,7 +286,7 @@ func validateUpdateRequest(req *pbs.UpdateProjectRequest) error {
func validateDeleteRequest(req *pbs.DeleteProjectRequest) error {
badFields := validateAncestors(req)
if !validId(req.GetId(), "p_") {
if !validId(req.GetId(), iam.ProjectScope.Prefix()+"_") {
badFields["id"] = "Incorrectly formatted project."
}
if len(badFields) > 0 {
@@ -308,10 +310,10 @@ type ancestorProvider interface {
// validateAncestors verifies that the ancestors of this call are properly set and provided.
func validateAncestors(r ancestorProvider) map[string]string {
if r.GetOrgId() == "" {
return map[string]string{"org_id": "Missing organization id."}
return map[string]string{orgIdFieldName: "Missing organization id."}
}
if !validId(r.GetOrgId(), iam.OrganizationScope.Prefix()+"_") {
return map[string]string{"org_id": "Improperly formatted identifier."}
return map[string]string{orgIdFieldName: "Improperly formatted identifier."}
}
return map[string]string{}
}
@@ -0,0 +1,323 @@
package users
import (
"context"
"errors"
"fmt"
"regexp"
"strings"
"github.com/hashicorp/watchtower/internal/db"
pb "github.com/hashicorp/watchtower/internal/gen/controller/api/resources/users"
pbs "github.com/hashicorp/watchtower/internal/gen/controller/api/services"
"github.com/hashicorp/watchtower/internal/iam"
"github.com/hashicorp/watchtower/internal/servers/controller/handlers"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"google.golang.org/protobuf/types/known/wrapperspb"
)
const orgIdFieldName = "org_id"
var (
reInvalidID = regexp.MustCompile("[^A-Za-z0-9]")
// TODO(ICU-28): Find a way to auto update these names and enforce the mappings between wire and storage.
wireToStorageMask = map[string]string{
"name": "Name",
"description": "Description",
}
)
// Service handles request as described by the pbs.UserServiceServer interface.
type Service struct {
repoFn func() (*iam.Repository, error)
}
// NewService returns a user service which handles user related requests to watchtower.
func NewService(repo func() (*iam.Repository, error)) (Service, error) {
if repo == nil {
return Service{}, fmt.Errorf("nil iam repostiroy provided")
}
return Service{repoFn: repo}, nil
}
var _ pbs.UserServiceServer = Service{}
// CreateUser is not yet implemented but will implement the interface pbs.UserServiceServer.
func (s Service) ListUsers(context.Context, *pbs.ListUsersRequest) (*pbs.ListUsersResponse, error) {
return nil, status.Error(codes.Unimplemented, "List not enabled for this resource.")
}
// GetUsers implements the interface pbs.UserServiceServer.
func (s Service) GetUser(ctx context.Context, req *pbs.GetUserRequest) (*pbs.GetUserResponse, error) {
if err := validateGetRequest(req); err != nil {
return nil, err
}
u, err := s.getFromRepo(ctx, req.GetId())
if err != nil {
return nil, err
}
return &pbs.GetUserResponse{Item: u}, nil
}
// CreateUser implements the interface pbs.UserServiceServer.
func (s Service) CreateUser(ctx context.Context, req *pbs.CreateUserRequest) (*pbs.CreateUserResponse, error) {
if err := validateCreateRequest(req); err != nil {
return nil, err
}
u, err := s.createInRepo(ctx, req.GetOrgId(), req.GetItem())
if err != nil {
return nil, err
}
return &pbs.CreateUserResponse{Item: u, Uri: fmt.Sprintf("orgs/%s/users/%s", req.GetOrgId(), u.GetId())}, nil
}
// UpdateUser implements the interface pbs.UserServiceServer.
func (s Service) UpdateUser(ctx context.Context, req *pbs.UpdateUserRequest) (*pbs.UpdateUserResponse, error) {
if err := validateUpdateRequest(req); err != nil {
return nil, err
}
u, err := s.updateInRepo(ctx, req.GetOrgId(), req.GetId(), req.GetUpdateMask().GetPaths(), req.GetItem())
if err != nil {
return nil, err
}
return &pbs.UpdateUserResponse{Item: u}, nil
}
// DeleteUser implements the interface pbs.UserServiceServer.
func (s Service) DeleteUser(ctx context.Context, req *pbs.DeleteUserRequest) (*pbs.DeleteUserResponse, error) {
if err := validateDeleteRequest(req); err != nil {
return nil, err
}
existed, err := s.deleteFromRepo(ctx, req.GetId())
if err != nil {
return nil, err
}
return &pbs.DeleteUserResponse{Existed: existed}, nil
}
func (s Service) getFromRepo(ctx context.Context, id string) (*pb.User, error) {
repo, err := s.repoFn()
if err != nil {
return nil, err
}
u, err := repo.LookupUser(ctx, id)
if err != nil {
if errors.Is(err, db.ErrRecordNotFound) {
return nil, handlers.NotFoundErrorf("User %q doesn't exist.", id)
}
return nil, err
}
if u == nil {
return nil, handlers.NotFoundErrorf("User %q doesn't exist.", id)
}
return toProto(u), nil
}
func (s Service) createInRepo(ctx context.Context, orgId string, item *pb.User) (*pb.User, error) {
var opts []iam.Option
if item.GetName() != nil {
opts = append(opts, iam.WithName(item.GetName().GetValue()))
}
if item.GetDescription() != nil {
opts = append(opts, iam.WithDescription(item.GetDescription().GetValue()))
}
u, err := iam.NewUser(orgId, opts...)
if err != nil {
return nil, status.Errorf(codes.Internal, "Unable to build user for creation: %v.", err)
}
repo, err := s.repoFn()
if err != nil {
return nil, err
}
out, err := repo.CreateUser(ctx, u)
if err != nil {
return nil, status.Errorf(codes.Internal, "Unable to create user: %v.", err)
}
if out == nil {
return nil, status.Error(codes.Internal, "Unable to create user but no error returned from repository.")
}
return toProto(out), nil
}
func (s Service) updateInRepo(ctx context.Context, orgId, id string, mask []string, item *pb.User) (*pb.User, error) {
var opts []iam.Option
if desc := item.GetDescription(); desc != nil {
opts = append(opts, iam.WithDescription(desc.GetValue()))
}
if name := item.GetName(); name != nil {
opts = append(opts, iam.WithName(name.GetValue()))
}
u, err := iam.NewUser(orgId, opts...)
if err != nil {
return nil, status.Errorf(codes.Internal, "Unable to build user for update: %v.", err)
}
u.PublicId = id
dbMask, err := toDbUpdateMask(mask)
if err != nil {
return nil, err
}
if len(dbMask) == 0 {
return nil, handlers.InvalidArgumentErrorf("No valid fields included in the update mask.", map[string]string{"update_mask": "No valid paths provided in the update mask."})
}
repo, err := s.repoFn()
if err != nil {
return nil, err
}
out, rowsUpdated, err := repo.UpdateUser(ctx, u, dbMask)
if err != nil {
return nil, status.Errorf(codes.Internal, "Unable to update user: %v.", err)
}
if rowsUpdated == 0 {
return nil, handlers.NotFoundErrorf("User %q doesn't exist.", id)
}
return toProto(out), nil
}
func (s Service) deleteFromRepo(ctx context.Context, id string) (bool, error) {
repo, err := s.repoFn()
if err != nil {
return false, err
}
rows, err := repo.DeleteUser(ctx, id)
if err != nil {
if errors.Is(err, db.ErrRecordNotFound) {
return false, nil
}
return false, status.Errorf(codes.Internal, "Unable to delete user: %v.", err)
}
return rows > 0, nil
}
// toDbUpdateMask converts the wire format's FieldMask into a list of strings containing FieldMask paths used
func toDbUpdateMask(paths []string) ([]string, error) {
var dbPaths []string
var invalid []string
for _, p := range paths {
for _, f := range strings.Split(p, ",") {
if dbField, ok := wireToStorageMask[strings.TrimSpace(f)]; ok {
dbPaths = append(dbPaths, dbField)
} else {
invalid = append(invalid, f)
}
}
}
if len(invalid) > 0 {
return nil, handlers.InvalidArgumentErrorf(fmt.Sprintf("Invalid fields passed in update_update mask: %v.", invalid), map[string]string{"update_mask": fmt.Sprintf("Unknown paths provided in update mask: %q", strings.Join(invalid, ","))})
}
return dbPaths, nil
}
func toProto(in *iam.User) *pb.User {
out := pb.User{
Id: in.GetPublicId(),
CreatedTime: in.GetCreateTime().GetTimestamp(),
UpdatedTime: in.GetUpdateTime().GetTimestamp(),
}
if in.GetDescription() != "" {
out.Description = &wrapperspb.StringValue{Value: in.GetDescription()}
}
if in.GetName() != "" {
out.Name = &wrapperspb.StringValue{Value: in.GetName()}
}
return &out
}
// A validateX method should exist for each method above. These methods do not make calls to any backing service but enforce
// requirements on the structure of the request. They verify that:
// * The path passed in is correctly formatted
// * All required parameters are set
// * There are no conflicting parameters provided
func validateGetRequest(req *pbs.GetUserRequest) error {
badFields := validateAncestors(req)
if !validId(req.GetId(), iam.UserPrefix+"_") {
badFields["id"] = "Invalid formatted user id."
}
if len(badFields) > 0 {
return handlers.InvalidArgumentErrorf("Improperly formatted identifier.", badFields)
}
return nil
}
func validateCreateRequest(req *pbs.CreateUserRequest) error {
badFields := validateAncestors(req)
item := req.GetItem()
if item.GetId() != "" {
badFields["id"] = "This is a read only field."
}
if item.GetCreatedTime() != nil {
badFields["created_time"] = "This is a read only field."
}
if item.GetUpdatedTime() != nil {
badFields["updated_time"] = "This is a read only field."
}
if len(badFields) > 0 {
return handlers.InvalidArgumentErrorf("Argument errors found in the request.", badFields)
}
return nil
}
func validateUpdateRequest(req *pbs.UpdateUserRequest) error {
badFields := validateAncestors(req)
if !validId(req.GetId(), iam.UserPrefix+"_") {
badFields["user_id"] = "Improperly formatted path identifier."
}
if req.GetUpdateMask() == nil {
badFields["update_mask"] = "UpdateMask not provided but is required to update a user."
}
item := req.GetItem()
if item == nil {
// It is legitimate for no item to be specified in an update request as it indicates all fields provided in
// the mask will be marked as unset.
return nil
}
if item.GetId() != "" {
badFields["id"] = "This is a read only field and cannot be specified in an update request."
}
if item.GetCreatedTime() != nil {
badFields["created_time"] = "This is a read only field and cannot be specified in an update request."
}
if item.GetUpdatedTime() != nil {
badFields["updated_time"] = "This is a read only field and cannot be specified in an update request."
}
if len(badFields) > 0 {
return handlers.InvalidArgumentErrorf("Errors in provided fields.", badFields)
}
return nil
}
func validateDeleteRequest(req *pbs.DeleteUserRequest) error {
badFields := validateAncestors(req)
if !validId(req.GetId(), iam.UserPrefix+"_") {
badFields["id"] = "Incorrectly formatted identifier."
}
if len(badFields) > 0 {
return handlers.InvalidArgumentErrorf("Errors in provided fields.", badFields)
}
return nil
}
func validId(id, prefix string) bool {
if !strings.HasPrefix(id, prefix) {
return false
}
id = strings.TrimPrefix(id, prefix)
return !reInvalidID.Match([]byte(id))
}
type ancestorProvider interface {
GetOrgId() string
}
// validateAncestors verifies that the ancestors of this call are properly set and provided.
func validateAncestors(r ancestorProvider) map[string]string {
if r.GetOrgId() == "" {
return map[string]string{orgIdFieldName: "Missing organization id."}
}
if !validId(r.GetOrgId(), iam.OrganizationScope.Prefix()+"_") {
return map[string]string{orgIdFieldName: "Improperly formatted identifier."}
}
return map[string]string{}
}
@@ -0,0 +1,533 @@
package users_test
import (
"context"
"fmt"
"strings"
"testing"
"github.com/golang/protobuf/ptypes"
"github.com/hashicorp/watchtower/internal/db"
pb "github.com/hashicorp/watchtower/internal/gen/controller/api/resources/users"
pbs "github.com/hashicorp/watchtower/internal/gen/controller/api/services"
"github.com/hashicorp/watchtower/internal/iam"
"github.com/hashicorp/watchtower/internal/servers/controller/handlers/users"
"google.golang.org/genproto/protobuf/field_mask"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/types/known/wrapperspb"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func createDefaultUserAndRepo(t *testing.T) (*iam.User, func() (*iam.Repository, error)) {
t.Helper()
cleanup, conn, _ := db.TestSetup(t, "postgres")
t.Cleanup(func() {
if err := conn.Close(); err != nil {
t.Errorf("Error when closing gorm DB: %v", err)
}
if err := cleanup(); err != nil {
t.Errorf("Error when cleaning up TestSetup: %v", err)
}
})
rw := db.New(conn)
wrap := db.TestWrapper(t)
repoFn := func() (*iam.Repository, error) {
return iam.NewRepository(rw, rw, wrap)
}
o, _ := iam.TestScopes(t, conn)
u := iam.TestUser(t, conn, o.GetPublicId(), iam.WithDescription("default"), iam.WithName("default"))
return u, repoFn
}
func TestGet(t *testing.T) {
assert := assert.New(t)
require := require.New(t)
u, repo := createDefaultUserAndRepo(t)
toMerge := &pbs.GetUserRequest{
OrgId: u.GetScopeId(),
Id: u.GetPublicId(),
}
wantU := &pb.User{
Id: u.GetPublicId(),
Name: &wrapperspb.StringValue{Value: u.GetName()},
Description: &wrapperspb.StringValue{Value: u.GetDescription()},
CreatedTime: u.CreateTime.GetTimestamp(),
UpdatedTime: u.UpdateTime.GetTimestamp(),
}
cases := []struct {
name string
req *pbs.GetUserRequest
res *pbs.GetUserResponse
errCode codes.Code
}{
{
name: "Get an Existing User",
req: &pbs.GetUserRequest{Id: u.GetPublicId()},
res: &pbs.GetUserResponse{Item: wantU},
errCode: codes.OK,
},
{
name: "Get a non existant User",
req: &pbs.GetUserRequest{Id: iam.UserPrefix + "_DoesntExis"},
res: nil,
errCode: codes.NotFound,
},
{
name: "Wrong id prefix",
req: &pbs.GetUserRequest{Id: "j_1234567890"},
res: nil,
errCode: codes.InvalidArgument,
},
{
name: "space in id",
req: &pbs.GetUserRequest{Id: iam.UserPrefix + "_1 23456789"},
res: nil,
errCode: codes.InvalidArgument,
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
req := proto.Clone(toMerge).(*pbs.GetUserRequest)
proto.Merge(req, tc.req)
s, err := users.NewService(repo)
require.NoError(err, "Couldn't create new user service.")
got, gErr := s.GetUser(context.Background(), req)
assert.Equal(tc.errCode, status.Code(gErr), "GetUser(%+v) got error %v, wanted %v", req, gErr, tc.errCode)
assert.True(proto.Equal(got, tc.res), "GetUser(%q) got response %q, wanted %q", req, got, tc.res)
})
}
}
func TestDelete(t *testing.T) {
require := require.New(t)
u, repo := createDefaultUserAndRepo(t)
s, err := users.NewService(repo)
require.NoError(err, "Error when getting new user service.")
cases := []struct {
name string
req *pbs.DeleteUserRequest
res *pbs.DeleteUserResponse
errCode codes.Code
}{
{
name: "Delete an Existing User",
req: &pbs.DeleteUserRequest{
OrgId: u.GetScopeId(),
Id: u.GetPublicId(),
},
res: &pbs.DeleteUserResponse{
Existed: true,
},
errCode: codes.OK,
},
{
name: "Delete bad user id",
req: &pbs.DeleteUserRequest{
OrgId: u.GetScopeId(),
Id: iam.UserPrefix + "_doesntexis",
},
res: &pbs.DeleteUserResponse{
Existed: false,
},
errCode: codes.OK,
},
{
name: "Delete bad org id",
req: &pbs.DeleteUserRequest{
OrgId: "o_doesntexis",
Id: u.GetPublicId(),
},
res: &pbs.DeleteUserResponse{
Existed: false,
},
errCode: codes.OK,
},
{
name: "Bad org formatting",
req: &pbs.DeleteUserRequest{
OrgId: "bad_format",
Id: u.GetPublicId(),
},
res: nil,
errCode: codes.InvalidArgument,
},
{
name: "Bad User Id formatting",
req: &pbs.DeleteUserRequest{
OrgId: u.GetScopeId(),
Id: "bad_format",
},
res: nil,
errCode: codes.InvalidArgument,
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
assert := assert.New(t)
got, gErr := s.DeleteUser(context.Background(), tc.req)
assert.Equal(tc.errCode, status.Code(gErr), "DeleteUser(%+v) got error %v, wanted %v", tc.req, gErr, tc.errCode)
assert.EqualValuesf(tc.res, got, "DeleteUser(%q) got response %q, wanted %q", tc.req, got, tc.res)
})
}
}
func TestDelete_twice(t *testing.T) {
assert := assert.New(t)
require := require.New(t)
u, repo := createDefaultUserAndRepo(t)
s, err := users.NewService(repo)
require.NoError(err, "Error when getting new user service")
req := &pbs.DeleteUserRequest{
OrgId: u.GetScopeId(),
Id: u.GetPublicId(),
}
got, gErr := s.DeleteUser(context.Background(), req)
assert.NoError(gErr, "First attempt")
assert.True(got.GetExisted(), "Expected existed to be true for the first delete.")
got, gErr = s.DeleteUser(context.Background(), req)
assert.NoError(gErr, "Second attempt")
assert.False(got.GetExisted(), "Expected existed to be false for the second delete.")
}
func TestCreate(t *testing.T) {
require := require.New(t)
defaultUser, repo := createDefaultUserAndRepo(t)
defaultCreated, err := ptypes.Timestamp(defaultUser.GetCreateTime().GetTimestamp())
require.NoError(err, "Error converting proto to timestamp.")
toMerge := &pbs.CreateUserRequest{
OrgId: defaultUser.GetScopeId(),
}
cases := []struct {
name string
req *pbs.CreateUserRequest
res *pbs.CreateUserResponse
errCode codes.Code
}{
{
name: "Create a valid User",
req: &pbs.CreateUserRequest{Item: &pb.User{
Name: &wrapperspb.StringValue{Value: "name"},
Description: &wrapperspb.StringValue{Value: "desc"},
}},
res: &pbs.CreateUserResponse{
Uri: fmt.Sprintf("orgs/%s/users/u_", defaultUser.GetScopeId()),
Item: &pb.User{
Name: &wrapperspb.StringValue{Value: "name"},
Description: &wrapperspb.StringValue{Value: "desc"},
},
},
errCode: codes.OK,
},
{
name: "Can't specify Id",
req: &pbs.CreateUserRequest{Item: &pb.User{
Id: iam.UserPrefix + "_notallowed",
}},
res: nil,
errCode: codes.InvalidArgument,
},
{
name: "Can't specify Created Time",
req: &pbs.CreateUserRequest{Item: &pb.User{
CreatedTime: ptypes.TimestampNow(),
}},
res: nil,
errCode: codes.InvalidArgument,
},
{
name: "Can't specify Update Time",
req: &pbs.CreateUserRequest{Item: &pb.User{
UpdatedTime: ptypes.TimestampNow(),
}},
res: nil,
errCode: codes.InvalidArgument,
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
assert := assert.New(t)
req := proto.Clone(toMerge).(*pbs.CreateUserRequest)
proto.Merge(req, tc.req)
s, err := users.NewService(repo)
require.NoError(err, "Error when getting new user service.")
got, gErr := s.CreateUser(context.Background(), req)
assert.Equal(tc.errCode, status.Code(gErr), "CreateUser(%+v) got error %v, wanted %v", req, gErr, tc.errCode)
if got != nil {
assert.True(strings.HasPrefix(got.GetUri(), tc.res.Uri))
assert.True(strings.HasPrefix(got.GetItem().GetId(), iam.UserPrefix+"_"))
gotCreateTime, err := ptypes.Timestamp(got.GetItem().GetCreatedTime())
require.NoError(err, "Error converting proto to timestamp.")
gotUpdateTime, err := ptypes.Timestamp(got.GetItem().GetUpdatedTime())
require.NoError(err, "Error converting proto to timestamp.")
// Verify it is a user created after the test setup's default user
assert.True(gotCreateTime.After(defaultCreated), "New user should have been created after default user. Was created %v, which is after %v", gotCreateTime, defaultCreated)
assert.True(gotUpdateTime.After(defaultCreated), "New user should have been updated after default user. Was updated %v, which is after %v", gotUpdateTime, defaultCreated)
// Clear all values which are hard to compare against.
got.Uri, tc.res.Uri = "", ""
got.Item.Id, tc.res.Item.Id = "", ""
got.Item.CreatedTime, got.Item.UpdatedTime, tc.res.Item.CreatedTime, tc.res.Item.UpdatedTime = nil, nil, nil, nil
}
assert.True(proto.Equal(got, tc.res), "CreateUser(%q) got response %q, wanted %q", req, got, tc.res)
})
}
}
func TestUpdate(t *testing.T) {
require := require.New(t)
u, repoFn := createDefaultUserAndRepo(t)
tested, err := users.NewService(repoFn)
require.NoError(err, "Error when getting new user service.")
resetUser := func() {
repo, err := repoFn()
require.NoError(err, "Couldn't get a new repo")
u, _, err = repo.UpdateUser(context.Background(), u, []string{"Name", "Description"})
require.NoError(err, "Failed to reset the user")
}
created, err := ptypes.Timestamp(u.GetCreateTime().GetTimestamp())
require.NoError(err, "Error converting proto to timestamp")
toMerge := &pbs.UpdateUserRequest{
OrgId: u.GetScopeId(),
Id: u.GetPublicId(),
}
cases := []struct {
name string
req *pbs.UpdateUserRequest
res *pbs.UpdateUserResponse
errCode codes.Code
}{
{
name: "Update an Existing User",
req: &pbs.UpdateUserRequest{
UpdateMask: &field_mask.FieldMask{
Paths: []string{"name", "description"},
},
Item: &pb.User{
Name: &wrapperspb.StringValue{Value: "new"},
Description: &wrapperspb.StringValue{Value: "desc"},
},
},
res: &pbs.UpdateUserResponse{
Item: &pb.User{
Id: u.GetPublicId(),
Name: &wrapperspb.StringValue{Value: "new"},
Description: &wrapperspb.StringValue{Value: "desc"},
CreatedTime: u.GetCreateTime().GetTimestamp(),
},
},
errCode: codes.OK,
},
{
name: "Multiple Paths in single string",
req: &pbs.UpdateUserRequest{
UpdateMask: &field_mask.FieldMask{
Paths: []string{"name,description"},
},
Item: &pb.User{
Name: &wrapperspb.StringValue{Value: "new"},
Description: &wrapperspb.StringValue{Value: "desc"},
},
},
res: &pbs.UpdateUserResponse{
Item: &pb.User{
Id: u.GetPublicId(),
Name: &wrapperspb.StringValue{Value: "new"},
Description: &wrapperspb.StringValue{Value: "desc"},
CreatedTime: u.GetCreateTime().GetTimestamp(),
},
},
errCode: codes.OK,
},
{
name: "No Update Mask",
req: &pbs.UpdateUserRequest{
Item: &pb.User{
Name: &wrapperspb.StringValue{Value: "updated name"},
Description: &wrapperspb.StringValue{Value: "updated desc"},
},
},
errCode: codes.InvalidArgument,
},
{
name: "No Paths in Mask",
req: &pbs.UpdateUserRequest{
UpdateMask: &field_mask.FieldMask{Paths: []string{}},
Item: &pb.User{
Name: &wrapperspb.StringValue{Value: "updated name"},
Description: &wrapperspb.StringValue{Value: "updated desc"},
},
},
errCode: codes.InvalidArgument,
},
{
name: "Only non-existant paths in Mask",
req: &pbs.UpdateUserRequest{
UpdateMask: &field_mask.FieldMask{Paths: []string{"nonexistant_field"}},
Item: &pb.User{
Name: &wrapperspb.StringValue{Value: "updated name"},
Description: &wrapperspb.StringValue{Value: "updated desc"},
},
},
errCode: codes.InvalidArgument,
},
{
name: "Unset Name",
req: &pbs.UpdateUserRequest{
UpdateMask: &field_mask.FieldMask{
Paths: []string{"name"},
},
Item: &pb.User{
Description: &wrapperspb.StringValue{Value: "ignored"},
},
},
res: &pbs.UpdateUserResponse{
Item: &pb.User{
Id: u.GetPublicId(),
Description: &wrapperspb.StringValue{Value: "default"},
CreatedTime: u.GetCreateTime().GetTimestamp(),
},
},
errCode: codes.OK,
},
{
name: "Update Only Name",
req: &pbs.UpdateUserRequest{
UpdateMask: &field_mask.FieldMask{
Paths: []string{"name"},
},
Item: &pb.User{
Name: &wrapperspb.StringValue{Value: "updated"},
Description: &wrapperspb.StringValue{Value: "ignored"},
},
},
res: &pbs.UpdateUserResponse{
Item: &pb.User{
Id: u.GetPublicId(),
Name: &wrapperspb.StringValue{Value: "updated"},
Description: &wrapperspb.StringValue{Value: "default"},
CreatedTime: u.GetCreateTime().GetTimestamp(),
},
},
errCode: codes.OK,
},
{
name: "Update Only Description",
req: &pbs.UpdateUserRequest{
UpdateMask: &field_mask.FieldMask{
Paths: []string{"description"},
},
Item: &pb.User{
Name: &wrapperspb.StringValue{Value: "ignored"},
Description: &wrapperspb.StringValue{Value: "notignored"},
},
},
res: &pbs.UpdateUserResponse{
Item: &pb.User{
Id: u.GetPublicId(),
Name: &wrapperspb.StringValue{Value: "default"},
Description: &wrapperspb.StringValue{Value: "notignored"},
CreatedTime: u.GetCreateTime().GetTimestamp(),
},
},
errCode: codes.OK,
},
// TODO: Updating a non existant user should result in a NotFound exception but currently results in
// the repoFn returning an internal error.
{
name: "Update a Non Existing User",
req: &pbs.UpdateUserRequest{
Id: iam.UserPrefix + "_DoesntExis",
UpdateMask: &field_mask.FieldMask{
Paths: []string{"description"},
},
Item: &pb.User{
Name: &wrapperspb.StringValue{Value: "new"},
Description: &wrapperspb.StringValue{Value: "desc"},
},
},
errCode: codes.Internal,
},
{
name: "Cant change Id",
req: &pbs.UpdateUserRequest{
Id: u.GetPublicId(),
UpdateMask: &field_mask.FieldMask{
Paths: []string{"id"},
},
Item: &pb.User{
Id: iam.UserPrefix + "_somethinge",
Name: &wrapperspb.StringValue{Value: "new"},
Description: &wrapperspb.StringValue{Value: "new desc"},
}},
res: nil,
errCode: codes.InvalidArgument,
},
{
name: "Cant specify Created Time",
req: &pbs.UpdateUserRequest{
UpdateMask: &field_mask.FieldMask{
Paths: []string{"created_time"},
},
Item: &pb.User{
CreatedTime: ptypes.TimestampNow(),
},
},
res: nil,
errCode: codes.InvalidArgument,
},
{
name: "Cant specify Updated Time",
req: &pbs.UpdateUserRequest{
UpdateMask: &field_mask.FieldMask{
Paths: []string{"updated_time"},
},
Item: &pb.User{
UpdatedTime: ptypes.TimestampNow(),
},
},
res: nil,
errCode: codes.InvalidArgument,
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
defer resetUser()
assert := assert.New(t)
req := proto.Clone(toMerge).(*pbs.UpdateUserRequest)
proto.Merge(req, tc.req)
got, gErr := tested.UpdateUser(context.Background(), req)
assert.Equal(tc.errCode, status.Code(gErr), "UpdateUser(%+v) got error %v, wanted %v", req, gErr, tc.errCode)
if got != nil {
assert.NotNilf(tc.res, "Expected UpdateUser response to be nil, but was %v", got)
gotUpdateTime, err := ptypes.Timestamp(got.GetItem().GetUpdatedTime())
require.NoError(err, "Error converting proto to timestamp")
// Verify it is a user updated after it was created
assert.True(gotUpdateTime.After(created), "Updated user should have been updated after it's creation. Was updated %v, which is after %v", gotUpdateTime, created)
// Clear all values which are hard to compare against.
got.Item.UpdatedTime, tc.res.Item.UpdatedTime = nil, nil
}
assert.True(proto.Equal(got, tc.res), "UpdateUser(%q) got response %q, wanted %q", req, got, tc.res)
})
}
}
+3
View File
@@ -73,6 +73,9 @@ func (tc *TestController) buildClient() {
if err := client.SetAddr(apiAddrs[0]); err != nil {
tc.t.Fatal(fmt.Errorf("error setting client address: %w", err))
}
if tc.b.DefaultOrgId != "" {
client.SetOrg(tc.b.DefaultOrgId)
}
tc.client = client
}