Merge pull request #384 from joerocklin/fix_unblock

Fix block/unblock

users.go

@@ -22,6 +22,13 @@ import (
 	"time"
 )
 
+// List a couple of standard errors.
+var (
+	ErrUserBlockPrevented   = errors.New("Cannot block a user that is already blocked by LDAP synchronization")
+	ErrUserNotFound         = errors.New("User does not exist")
+	ErrUserUnblockPrevented = errors.New("Cannot unblock a user that is blocked by LDAP synchronization")
+)
+
 // UsersService handles communication with the user related methods of
 // the GitLab API.
 //
@@ -425,7 +432,7 @@ func (s *UsersService) BlockUser(user int, options ...OptionFunc) error {
 	}
 
 	resp, err := s.client.Do(req, nil)
-	if err != nil {
+	if err != nil && resp == nil {
 		return err
 	}
 
@@ -433,9 +440,9 @@ func (s *UsersService) BlockUser(user int, options ...OptionFunc) error {
 	case 201:
 		return nil
 	case 403:
-		return errors.New("Cannot block a user that is already blocked by LDAP synchronization")
+		return ErrUserBlockPrevented
 	case 404:
-		return errors.New("User does not exist")
+		return ErrUserNotFound
 	default:
 		return fmt.Errorf("Received unexpected result code: %d", resp.StatusCode)
 	}
@@ -453,7 +460,7 @@ func (s *UsersService) UnblockUser(user int, options ...OptionFunc) error {
 	}
 
 	resp, err := s.client.Do(req, nil)
-	if err != nil {
+	if err != nil && resp == nil {
 		return err
 	}
 
@@ -461,9 +468,9 @@ func (s *UsersService) UnblockUser(user int, options ...OptionFunc) error {
 	case 201:
 		return nil
 	case 403:
-		return errors.New("Cannot unblock a user that is blocked by LDAP synchronization")
+		return ErrUserUnblockPrevented
 	case 404:
-		return errors.New("User does not exist")
+		return ErrUserNotFound
 	default:
 		return fmt.Errorf("Received unexpected result code: %d", resp.StatusCode)
 	}

users_test.go

+package gitlab
+
+import (
+	"fmt"
+	"net/http"
+	"reflect"
+	"testing"
+)
+
+func TestBlockUser(t *testing.T) {
+	mux, server, client := setup()
+	defer teardown(server)
+
+	path := fmt.Sprintf("/%susers/1/block", apiVersionPath)
+	mux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "POST")
+		w.WriteHeader(http.StatusCreated)
+	})
+
+	err := client.Users.BlockUser(1)
+	if err != nil {
+		t.Errorf("Users.BlockUser returned error: %v", err)
+	}
+}
+
+func TestBlockUser_UserNotFound(t *testing.T) {
+	mux, server, client := setup()
+	defer teardown(server)
+
+	path := fmt.Sprintf("/%susers/1/block", apiVersionPath)
+	mux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "POST")
+		w.WriteHeader(http.StatusNotFound)
+	})
+
+	err := client.Users.BlockUser(1)
+	if err != ErrUserNotFound {
+		t.Errorf("Users.BlockUser error.\nExpected: %+v\n     Got: %+v", ErrUserNotFound, err)
+	}
+}
+
+func TestBlockUser_BlockPrevented(t *testing.T) {
+	mux, server, client := setup()
+	defer teardown(server)
+
+	path := fmt.Sprintf("/%susers/1/block", apiVersionPath)
+	mux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "POST")
+		w.WriteHeader(http.StatusForbidden)
+	})
+
+	err := client.Users.BlockUser(1)
+	if err != ErrUserBlockPrevented {
+		t.Errorf("Users.BlockUser error.\nExpected: %+v\n     Got: %+v", ErrUserBlockPrevented, err)
+	}
+}
+
+func TestBlockUser_UnknownError(t *testing.T) {
+	mux, server, client := setup()
+	defer teardown(server)
+
+	path := fmt.Sprintf("/%susers/1/block", apiVersionPath)
+	mux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "POST")
+		w.WriteHeader(http.StatusTeapot)
+	})
+
+	want := fmt.Errorf("Received unexpected result code: %d", http.StatusTeapot)
+
+	err := client.Users.BlockUser(1)
+	if !reflect.DeepEqual(err, want) {
+		t.Errorf("Users.BlockUser error.\nExpected: %+v\n     Got: %+v", want, err)
+	}
+}
+
+func TestBlockUser_BadResponseFromNet(t *testing.T) {
+	client := NewClient(nil, "")
+	client.SetBaseURL("")
+
+	want := fmt.Sprintf("Post /%susers/1/block: unsupported protocol scheme \"\"", apiVersionPath)
+
+	err := client.Users.BlockUser(1)
+	if err.Error() != want {
+		t.Errorf("Users.BlockUser error.\nExpected: %+v\n     Got: %+v", want, err)
+	}
+}
+
+//  ------------------------  Unblock user -------------------------
+func TestUnblockUser(t *testing.T) {
+	mux, server, client := setup()
+	defer teardown(server)
+
+	path := fmt.Sprintf("/%susers/1/unblock", apiVersionPath)
+	mux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "POST")
+		w.WriteHeader(http.StatusCreated)
+	})
+
+	err := client.Users.UnblockUser(1)
+	if err != nil {
+		t.Errorf("Users.UnblockUser returned error: %v", err)
+	}
+}
+
+func TestUnblockUser_UserNotFound(t *testing.T) {
+	mux, server, client := setup()
+	defer teardown(server)
+
+	path := fmt.Sprintf("/%susers/1/unblock", apiVersionPath)
+	mux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "POST")
+		w.WriteHeader(http.StatusNotFound)
+	})
+
+	err := client.Users.UnblockUser(1)
+	if err != ErrUserNotFound {
+		t.Errorf("Users.UnblockUser error.\nExpected: %+v\n     Got: %+v", ErrUserNotFound, err)
+	}
+}
+
+func TestUnblockUser_UnblockPrevented(t *testing.T) {
+	mux, server, client := setup()
+	defer teardown(server)
+
+	path := fmt.Sprintf("/%susers/1/unblock", apiVersionPath)
+	mux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "POST")
+		w.WriteHeader(http.StatusForbidden)
+	})
+
+	err := client.Users.UnblockUser(1)
+	if err != ErrUserUnblockPrevented {
+		t.Errorf("Users.UnblockUser error.\nExpected: %+v\n     Got: %+v", ErrUserUnblockPrevented, err)
+	}
+}
+
+func TestUnblockUser_UnknownError(t *testing.T) {
+	mux, server, client := setup()
+	defer teardown(server)
+
+	path := fmt.Sprintf("/%susers/1/unblock", apiVersionPath)
+	mux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "POST")
+		w.WriteHeader(http.StatusTeapot)
+	})
+
+	want := fmt.Errorf("Received unexpected result code: %d", http.StatusTeapot)
+
+	err := client.Users.UnblockUser(1)
+	if !reflect.DeepEqual(err, want) {
+		t.Errorf("Users.UnblockUser error.\nExpected: %+v\n     Got: %+v", want, err)
+	}
+}
+
+func TestUnblockUser_BadResponseFromNet(t *testing.T) {
+	client := NewClient(nil, "")
+	client.SetBaseURL("")
+
+	want := fmt.Sprintf("Post /%susers/1/unblock: unsupported protocol scheme \"\"", apiVersionPath)
+
+	err := client.Users.UnblockUser(1)
+	if err.Error() != want {
+		t.Errorf("Users.UnblockUser error.\nExpected: %+v\n     Got: %+v", want, err)
+	}
+}