github.com/google/go-github/v49@v49.1.0/github/users_blocking_test.go (about)

     1  // Copyright 2017 The go-github AUTHORS. All rights reserved.
     2  //
     3  // Use of this source code is governed by a BSD-style
     4  // license that can be found in the LICENSE file.
     5  
     6  package github
     7  
     8  import (
     9  	"context"
    10  	"fmt"
    11  	"net/http"
    12  	"testing"
    13  
    14  	"github.com/google/go-cmp/cmp"
    15  )
    16  
    17  func TestUsersService_ListBlockedUsers(t *testing.T) {
    18  	client, mux, _, teardown := setup()
    19  	defer teardown()
    20  
    21  	mux.HandleFunc("/user/blocks", func(w http.ResponseWriter, r *http.Request) {
    22  		testMethod(t, r, "GET")
    23  		testHeader(t, r, "Accept", mediaTypeBlockUsersPreview)
    24  		testFormValues(t, r, values{"page": "2"})
    25  		fmt.Fprint(w, `[{
    26  			"login": "octocat"
    27  		}]`)
    28  	})
    29  
    30  	opt := &ListOptions{Page: 2}
    31  	ctx := context.Background()
    32  	blockedUsers, _, err := client.Users.ListBlockedUsers(ctx, opt)
    33  	if err != nil {
    34  		t.Errorf("Users.ListBlockedUsers returned error: %v", err)
    35  	}
    36  
    37  	want := []*User{{Login: String("octocat")}}
    38  	if !cmp.Equal(blockedUsers, want) {
    39  		t.Errorf("Users.ListBlockedUsers returned %+v, want %+v", blockedUsers, want)
    40  	}
    41  
    42  	const methodName = "ListBlockedUsers"
    43  	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
    44  		got, resp, err := client.Users.ListBlockedUsers(ctx, opt)
    45  		if got != nil {
    46  			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
    47  		}
    48  		return resp, err
    49  	})
    50  }
    51  
    52  func TestUsersService_IsBlocked(t *testing.T) {
    53  	client, mux, _, teardown := setup()
    54  	defer teardown()
    55  
    56  	mux.HandleFunc("/user/blocks/u", func(w http.ResponseWriter, r *http.Request) {
    57  		testMethod(t, r, "GET")
    58  		testHeader(t, r, "Accept", mediaTypeBlockUsersPreview)
    59  		w.WriteHeader(http.StatusNoContent)
    60  	})
    61  
    62  	ctx := context.Background()
    63  	isBlocked, _, err := client.Users.IsBlocked(ctx, "u")
    64  	if err != nil {
    65  		t.Errorf("Users.IsBlocked returned error: %v", err)
    66  	}
    67  	if want := true; isBlocked != want {
    68  		t.Errorf("Users.IsBlocked returned %+v, want %+v", isBlocked, want)
    69  	}
    70  
    71  	const methodName = "IsBlocked"
    72  	testBadOptions(t, methodName, func() (err error) {
    73  		_, _, err = client.Users.IsBlocked(ctx, "\n")
    74  		return err
    75  	})
    76  
    77  	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
    78  		got, resp, err := client.Users.IsBlocked(ctx, "u")
    79  		if got {
    80  			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
    81  		}
    82  		return resp, err
    83  	})
    84  }
    85  
    86  func TestUsersService_BlockUser(t *testing.T) {
    87  	client, mux, _, teardown := setup()
    88  	defer teardown()
    89  
    90  	mux.HandleFunc("/user/blocks/u", func(w http.ResponseWriter, r *http.Request) {
    91  		testMethod(t, r, "PUT")
    92  		testHeader(t, r, "Accept", mediaTypeBlockUsersPreview)
    93  		w.WriteHeader(http.StatusNoContent)
    94  	})
    95  
    96  	ctx := context.Background()
    97  	_, err := client.Users.BlockUser(ctx, "u")
    98  	if err != nil {
    99  		t.Errorf("Users.BlockUser returned error: %v", err)
   100  	}
   101  
   102  	const methodName = "BlockUser"
   103  	testBadOptions(t, methodName, func() (err error) {
   104  		_, err = client.Users.BlockUser(ctx, "\n")
   105  		return err
   106  	})
   107  
   108  	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
   109  		return client.Users.BlockUser(ctx, "u")
   110  	})
   111  }
   112  
   113  func TestUsersService_UnblockUser(t *testing.T) {
   114  	client, mux, _, teardown := setup()
   115  	defer teardown()
   116  
   117  	mux.HandleFunc("/user/blocks/u", func(w http.ResponseWriter, r *http.Request) {
   118  		testMethod(t, r, "DELETE")
   119  		testHeader(t, r, "Accept", mediaTypeBlockUsersPreview)
   120  		w.WriteHeader(http.StatusNoContent)
   121  	})
   122  
   123  	ctx := context.Background()
   124  	_, err := client.Users.UnblockUser(ctx, "u")
   125  	if err != nil {
   126  		t.Errorf("Users.UnblockUser returned error: %v", err)
   127  	}
   128  
   129  	const methodName = "UnblockUser"
   130  	testBadOptions(t, methodName, func() (err error) {
   131  		_, err = client.Users.UnblockUser(ctx, "\n")
   132  		return err
   133  	})
   134  
   135  	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
   136  		return client.Users.UnblockUser(ctx, "u")
   137  	})
   138  }