Add grpc delete user implementation

client/users/users_client.go

@@ -50,34 +50,6 @@ func (a *Client) CreateUser(params *CreateUserParams, authInfo runtime.ClientAut
 	return result.(*CreateUserCreated), nil
 }
 
-/*
-DeleteUser deletes user
-
-Delete user
-*/
-func (a *Client) DeleteUser(params *DeleteUserParams, authInfo runtime.ClientAuthInfoWriter) (*DeleteUserNoContent, error) {
-	// TODO: Validate the params before sending
-	if params == nil {
-		params = NewDeleteUserParams()
-	}
-
-	result, err := a.transport.Submit(&runtime.ClientOperation{
-		ID:                 "deleteUser",
-		Method:             "DELETE",
-		PathPattern:        "/users/{user_id}",
-		ProducesMediaTypes: []string{"application/json"},
-		ConsumesMediaTypes: []string{"application/json"},
-		Schemes:            []string{"http"},
-		Params:             params,
-		Reader:             &DeleteUserReader{formats: a.formats},
-		AuthInfo:           authInfo,
-	})
-	if err != nil {
-		return nil, err
-	}
-	return result.(*DeleteUserNoContent), nil
-}
-
 /*
 GetUserDetails gets user details
 

cmd/client/cmd/teresaclient.go

@@ -169,14 +169,6 @@ func (tc TeresaClient) CreateUser(name, email, password string, isAdmin bool) (u
 	return r.Payload, nil
 }
 
-// DeleteUser Delete an user
-func (tc TeresaClient) DeleteUser(ID int64) error {
-	params := users.NewDeleteUserParams()
-	params.UserID = ID
-	_, err := tc.teresa.Users.DeleteUser(params, tc.apiKeyAuthFunc)
-	return err
-}
-
 // GetTeams returns a list with my teams
 func (tc TeresaClient) GetTeams() (teamsList []*models.Team, err error) {
 	params := teams.NewGetTeamsParams()

cmd/client/cmd/user.go

@@ -42,18 +42,8 @@ Note that the user's password must be at least 8 characters long. eg.:
 var deleteUserCmd = &cobra.Command{
 	Use:   "user",
 	Short: "Delete an user",
-	Long: `Delete an user.
-	`,
-	Run: func(cmd *cobra.Command, args []string) {
-		if userIDFlag == 0 {
-			Usage(cmd)
-			return
-		}
-		if err := NewTeresa().DeleteUser(userIDFlag); err != nil {
-			Fatalf(cmd, "Failed to delete user, err: %s\n", err)
-		}
-		log.Infof("User deleted.")
-	},
+	Long:  `Delete an user.`,
+	Run:   deleteUser,
 }
 
 // set password for an user
@@ -84,6 +74,31 @@ func setPassword(cmd *cobra.Command, args []string) {
 	fmt.Println("Password updated")
 }
 
+func deleteUser(cmd *cobra.Command, args []string) {
+	email, _ := cmd.Flags().GetString("email")
+	if email == "" {
+		cmd.Usage()
+		return
+	}
+	conn, err := connection.New(cfgFile)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "Error connecting to server: ", err)
+		return
+	}
+	defer conn.Close()
+
+	cli := userpb.NewUserClient(conn)
+	_, err = cli.Delete(
+		context.Background(),
+		&userpb.DeleteRequest{Email: email},
+	)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, client.GetErrorMsg(err))
+		return
+	}
+	fmt.Println("User deleted")
+}
+
 func init() {
 	createCmd.AddCommand(userCmd)
 	userCmd.Flags().StringVar(&userNameFlag, "name", "", "user name [required]")
@@ -92,7 +107,7 @@ func init() {
 	userCmd.Flags().BoolVar(&isAdminFlag, "admin", false, "admin")
 
 	deleteCmd.AddCommand(deleteUserCmd)
-	deleteUserCmd.Flags().Int64Var(&userIDFlag, "id", 0, "user ID [required]")
+	deleteUserCmd.Flags().String("email", "", "user email [required]")
 
 	RootCmd.AddCommand(setUserPasswordCmd)
 }

pkg/protobuf/user.proto

@@ -5,6 +5,7 @@ package user;
 service User {
     rpc Login(LoginRequest) returns (LoginResponse);
     rpc SetPassword(SetPasswordRequest) returns (Empty);
+    rpc Delete(DeleteRequest) returns (Empty);
 }
 
 message LoginRequest {
@@ -20,4 +21,8 @@ message SetPasswordRequest {
     string password = 1;
 }
 
+message DeleteRequest {
+    string email = 1;
+}
+
 message Empty {}

pkg/server/user/fake.go

@@ -44,6 +44,17 @@ func (f *FakeOperations) SetPassword(email, newPassword string) error {
 	return nil
 }
 
+func (f *FakeOperations) Delete(email string) error {
+	f.mutex.Lock()
+	defer f.mutex.Unlock()
+
+	if _, ok := f.Storage[email]; !ok {
+		return ErrNotFound
+	}
+	delete(f.Storage, email)
+	return nil
+}
+
 func NewFakeOperations() Operations {
 	return &FakeOperations{
 		mutex:   &sync.RWMutex{},

pkg/server/user/fake_test.go

@@ -77,3 +77,26 @@ func TestFakeOperationsSetPasswordUserNotFound(t *testing.T) {
 		t.Errorf("expected ErrNotFound, got %v", err)
 	}
 }
+
+func TestFakeOperationsDelete(t *testing.T) {
+	fake := NewFakeOperations()
+
+	email := "teresa@luizalabs.com"
+	fake.(*FakeOperations).Storage[email] = "gopher"
+
+	if err := fake.Delete(email); err != nil {
+		t.Fatal("Error performing delete in FakeOperations: ", err)
+	}
+	_, ok := fake.(*FakeOperations).Storage[email]
+	if ok {
+		t.Errorf("expected false for key %s, got true", email)
+	}
+}
+
+func TestFakeOperationsDeleteUserNotFound(t *testing.T) {
+	fake := NewFakeOperations()
+
+	if err := fake.Delete("gopher@luizalabs.com"); err != ErrNotFound {
+		t.Errorf("expected ErrNotFound, got %v", err)
+	}
+}

pkg/server/user/handlers.go

@@ -29,6 +29,17 @@ func (s *Service) SetPassword(ctx context.Context, request *userpb.SetPasswordRe
 	return &userpb.Empty{}, nil
 }
 
+func (s *Service) Delete(ctx context.Context, request *userpb.DeleteRequest) (*userpb.Empty, error) {
+	u := ctx.Value("user").(*storage.User)
+	if !u.IsAdmin {
+		return nil, auth.ErrPermissionDenied
+	}
+	if err := s.ops.Delete(request.Email); err != nil {
+		return nil, err
+	}
+	return &userpb.Empty{}, nil
+}
+
 func (s *Service) RegisterService(grpcServer *grpc.Server) {
 	userpb.RegisterUserServer(grpcServer, s)
 }

pkg/server/user/handlers_test.go

@@ -59,3 +59,44 @@ func TestSetPasswordSuccess(t *testing.T) {
 		t.Error("Got error on make SetPassword: ", err)
 	}
 }
+
+func TestDeleteSuccess(t *testing.T) {
+	fake := NewFakeOperations()
+
+	admin := &storage.User{
+		Email:   "admin@luizalabs.com",
+		IsAdmin: true,
+	}
+	email := "teresa@luizalabs.com"
+	fake.(*FakeOperations).Storage[email] = "gopher"
+
+	s := NewService(fake)
+	ctx := context.WithValue(context.Background(), "user", admin)
+	_, err := s.Delete(
+		ctx,
+		&userpb.DeleteRequest{Email: email},
+	)
+	if err != nil {
+		t.Error("Got error on Delete: ", err)
+	}
+}
+
+func TestDeletePermissionDenied(t *testing.T) {
+	fake := NewFakeOperations()
+
+	fakeAdmin := &storage.User{
+		Email: "admin@luizalabs.com",
+	}
+	email := "teresa@luizalabs.com"
+	fake.(*FakeOperations).Storage[email] = "gopher"
+
+	s := NewService(fake)
+	ctx := context.WithValue(context.Background(), "user", fakeAdmin)
+	_, err := s.Delete(
+		ctx,
+		&userpb.DeleteRequest{Email: email},
+	)
+	if err != auth.ErrPermissionDenied {
+		t.Errorf("expected ErrPermissionDenied, got %s", err)
+	}
+}

pkg/server/user/user.go

@@ -13,6 +13,7 @@ type Operations interface {
 	Login(email, password string) (string, error)
 	GetUser(email string) (*storage.User, error)
 	SetPassword(email, newPassword string) error
+	Delete(email string) error
 }
 
 type DatabaseOperations struct {
@@ -61,6 +62,14 @@ func (dbu *DatabaseOperations) SetPassword(email, newPassword string) error {
 	return dbu.DB.Save(u).Error
 }
 
+func (dbu *DatabaseOperations) Delete(email string) error {
+	u, err := dbu.GetUser(email)
+	if err != nil {
+		return err
+	}
+	return dbu.DB.Delete(u).Error
+}
+
 func NewDatabaseOperations(db *gorm.DB, a auth.Auth) Operations {
 	db.AutoMigrate(&storage.User{})
 	return &DatabaseOperations{DB: db, auth: a}