github.com/line/line-bot-sdk-go/v7@v7.21.0/linebot/audience_test.go (about)

     1  package linebot
     2  
     3  import (
     4  	"bytes"
     5  	"context"
     6  	"encoding/json"
     7  	"fmt"
     8  	"io"
     9  	"log"
    10  	"net/http"
    11  	"net/http/httptest"
    12  	"reflect"
    13  	"strconv"
    14  	"testing"
    15  	"time"
    16  )
    17  
    18  // TestUploadAudienceGroup tests UploadAudienceGroup
    19  func TestUploadAudienceGroup(t *testing.T) {
    20  	type RequestBody struct {
    21  		Description       string     `json:"description,omitempty"`
    22  		IsIfaAudience     bool       `json:"isIfaAudience,omitempty"`
    23  		UploadDescription string     `json:"uploadDescription,omitempty"`
    24  		Audiences         []audience `json:"audiences,omitempty"`
    25  	}
    26  	type want struct {
    27  		URLPath     string
    28  		RequestBody RequestBody
    29  		Response    *UploadAudienceGroupResponse
    30  		Error       error
    31  	}
    32  	testCases := []struct {
    33  		Label             string
    34  		Description       string
    35  		IsIfaAudience     bool
    36  		UploadDescription string
    37  		Audiences         []string
    38  		RequestID         string
    39  		AcceptedRequestID string
    40  		ResponseCode      int
    41  		Response          []byte
    42  		Want              want
    43  	}{
    44  		{
    45  			Label:        "Create Audience Fail",
    46  			Description:  "audienceGroupName_01",
    47  			RequestID:    "12222",
    48  			ResponseCode: http.StatusBadRequest,
    49  			Response:     []byte(``),
    50  			Want: want{
    51  				URLPath: APIAudienceGroupUpload,
    52  				RequestBody: RequestBody{
    53  					Description: "audienceGroupName_01",
    54  				},
    55  				Error: &APIError{
    56  					Code: http.StatusBadRequest,
    57  				},
    58  			},
    59  		},
    60  		{
    61  			Label:        "Create Audience not include userIDs",
    62  			Description:  "audienceGroupName_01",
    63  			RequestID:    "12222",
    64  			ResponseCode: http.StatusOK,
    65  			Response:     []byte(`{"audienceGroupId":1234567890123,"createRoute":"MESSAGING_API","type":"UPLOAD","description":"audienceGroupName_01","created":1613698278,"permission":"READ_WRITE","expireTimestamp":1629250278}`),
    66  			Want: want{
    67  				URLPath: APIAudienceGroupUpload,
    68  				RequestBody: RequestBody{
    69  					Description: "audienceGroupName_01",
    70  				},
    71  				Response: &UploadAudienceGroupResponse{
    72  					RequestID:       "12222",
    73  					AudienceGroupID: 1234567890123,
    74  					CreateRoute:     "MESSAGING_API",
    75  					Type:            "UPLOAD",
    76  					Description:     "audienceGroupName_01",
    77  					Created:         1613698278,
    78  					Permission:      "READ_WRITE",
    79  					ExpireTimestamp: 1629250278,
    80  					IsIfaAudience:   false,
    81  				},
    82  			},
    83  		},
    84  		{
    85  			Label:       "Create Audience By UserID",
    86  			Description: "audienceGroupName_01",
    87  			Audiences: []string{
    88  				"U4af4980627", "U4af4980628", "U4af4980629",
    89  			},
    90  			RequestID:    "12222",
    91  			ResponseCode: http.StatusOK,
    92  			Response:     []byte(`{"audienceGroupId":1234567890123,"createRoute":"MESSAGING_API","type":"UPLOAD","description":"audienceGroupName_01","created":1613698278,"permission":"READ_WRITE","expireTimestamp":1629250278}`),
    93  			Want: want{
    94  				URLPath: APIAudienceGroupUpload,
    95  				RequestBody: RequestBody{
    96  					Description: "audienceGroupName_01",
    97  					Audiences: []audience{
    98  						{
    99  							ID: "U4af4980627",
   100  						},
   101  						{
   102  							ID: "U4af4980628",
   103  						},
   104  						{
   105  							ID: "U4af4980629",
   106  						},
   107  					},
   108  				},
   109  				Response: &UploadAudienceGroupResponse{
   110  					RequestID:       "12222",
   111  					AudienceGroupID: 1234567890123,
   112  					CreateRoute:     "MESSAGING_API",
   113  					Type:            "UPLOAD",
   114  					Description:     "audienceGroupName_01",
   115  					Created:         1613698278,
   116  					Permission:      "READ_WRITE",
   117  					ExpireTimestamp: 1629250278,
   118  					IsIfaAudience:   false,
   119  				},
   120  			},
   121  		},
   122  		{
   123  			Label:         "Create Audience Is IFA",
   124  			Description:   "audienceGroupName_01",
   125  			IsIfaAudience: true,
   126  			RequestID:     "12222",
   127  			ResponseCode:  http.StatusOK,
   128  			Response:      []byte(`{"audienceGroupId":1234567890123,"createRoute":"MESSAGING_API","type":"UPLOAD","description":"audienceGroupName_01","created":1613698278,"permission":"READ_WRITE","expireTimestamp":1629250278}`),
   129  			Want: want{
   130  				URLPath: APIAudienceGroupUpload,
   131  				RequestBody: RequestBody{
   132  					Description:   "audienceGroupName_01",
   133  					IsIfaAudience: true,
   134  				},
   135  				Response: &UploadAudienceGroupResponse{
   136  					RequestID:       "12222",
   137  					AudienceGroupID: 1234567890123,
   138  					CreateRoute:     "MESSAGING_API",
   139  					Type:            "UPLOAD",
   140  					Description:     "audienceGroupName_01",
   141  					Created:         1613698278,
   142  					Permission:      "READ_WRITE",
   143  					ExpireTimestamp: 1629250278,
   144  					IsIfaAudience:   false,
   145  				},
   146  			},
   147  		},
   148  		{
   149  			Label:             "Create Audience have uploadDescription",
   150  			Description:       "audienceGroupName_01",
   151  			UploadDescription: "audienceGroupNameJob_01",
   152  			RequestID:         "12222",
   153  			ResponseCode:      http.StatusOK,
   154  			Response:          []byte(`{"audienceGroupId":1234567890123,"createRoute":"MESSAGING_API","type":"UPLOAD","description":"audienceGroupName_01","created":1613698278,"permission":"READ_WRITE","expireTimestamp":1629250278}`),
   155  			Want: want{
   156  				URLPath: APIAudienceGroupUpload,
   157  				RequestBody: RequestBody{
   158  					Description:       "audienceGroupName_01",
   159  					UploadDescription: "audienceGroupNameJob_01",
   160  				},
   161  				Response: &UploadAudienceGroupResponse{
   162  					RequestID:       "12222",
   163  					AudienceGroupID: 1234567890123,
   164  					CreateRoute:     "MESSAGING_API",
   165  					Type:            "UPLOAD",
   166  					Description:     "audienceGroupName_01",
   167  					Created:         1613698278,
   168  					Permission:      "READ_WRITE",
   169  					ExpireTimestamp: 1629250278,
   170  					IsIfaAudience:   false,
   171  				},
   172  			},
   173  		},
   174  		{
   175  			Label:             "Create Audience",
   176  			Description:       "audienceGroupName_01",
   177  			UploadDescription: "audienceGroupNameJob_01",
   178  			Audiences: []string{
   179  				"U4af4980627", "U4af4980628", "U4af4980629",
   180  			},
   181  			RequestID:    "12222",
   182  			ResponseCode: http.StatusOK,
   183  			Response:     []byte(`{"audienceGroupId":1234567890123,"createRoute":"MESSAGING_API","type":"UPLOAD","description":"audienceGroupName_01","created":1613698278,"permission":"READ_WRITE","expireTimestamp":1629250278}`),
   184  			Want: want{
   185  				URLPath: APIAudienceGroupUpload,
   186  				RequestBody: RequestBody{
   187  					Description:       "audienceGroupName_01",
   188  					UploadDescription: "audienceGroupNameJob_01",
   189  					Audiences: []audience{
   190  						{
   191  							ID: "U4af4980627",
   192  						},
   193  						{
   194  							ID: "U4af4980628",
   195  						},
   196  						{
   197  							ID: "U4af4980629",
   198  						},
   199  					},
   200  				},
   201  				Response: &UploadAudienceGroupResponse{
   202  					RequestID:       "12222",
   203  					AudienceGroupID: 1234567890123,
   204  					CreateRoute:     "MESSAGING_API",
   205  					Type:            "UPLOAD",
   206  					Description:     "audienceGroupName_01",
   207  					Created:         1613698278,
   208  					Permission:      "READ_WRITE",
   209  					ExpireTimestamp: 1629250278,
   210  					IsIfaAudience:   false,
   211  				},
   212  			},
   213  		},
   214  	}
   215  
   216  	var currentTestIdx int
   217  	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   218  		defer r.Body.Close()
   219  		tc := testCases[currentTestIdx]
   220  		if r.Method != http.MethodPost {
   221  			t.Errorf("Method %s; want %s", r.Method, http.MethodPost)
   222  		}
   223  		if r.URL.Path != tc.Want.URLPath {
   224  			t.Errorf("URLPath %s; want %s", r.URL.Path, tc.Want.URLPath)
   225  		}
   226  		var result RequestBody
   227  		if err := json.NewDecoder(r.Body).Decode(&result); err != nil {
   228  			t.Fatal(err)
   229  		}
   230  		if !reflect.DeepEqual(result, tc.Want.RequestBody) {
   231  			t.Errorf("Request %v; want %v", result, tc.Want.RequestBody)
   232  		}
   233  		w.Header().Set("X-Line-Request-Id", tc.RequestID)
   234  		if tc.AcceptedRequestID != "" {
   235  			w.Header().Set("X-Line-Accepted-Request-Id", tc.AcceptedRequestID)
   236  		}
   237  		w.WriteHeader(tc.ResponseCode)
   238  		w.Write(tc.Response)
   239  	}))
   240  	defer server.Close()
   241  
   242  	dataServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   243  		defer r.Body.Close()
   244  		t.Error("Unexpected data API call")
   245  		w.WriteHeader(http.StatusNotFound)
   246  		w.Write([]byte(`{"message":"Not found"}`))
   247  	}))
   248  	defer dataServer.Close()
   249  
   250  	client, err := mockClient(server, dataServer)
   251  	if err != nil {
   252  		t.Fatal(err)
   253  	}
   254  
   255  	var res *UploadAudienceGroupResponse
   256  	for i, tc := range testCases {
   257  		currentTestIdx = i
   258  		t.Run(strconv.Itoa(i)+"/"+tc.Label, func(t *testing.T) {
   259  			var options []IUploadAudienceGroupOption
   260  			if len(tc.Audiences) > 0 {
   261  				options = append(options, WithUploadAudienceGroupCallAudiences(tc.Audiences...))
   262  			}
   263  			if tc.IsIfaAudience {
   264  				options = append(options, WithUploadAudienceGroupCallIsIfaAudience(true))
   265  			}
   266  			if tc.UploadDescription != "" {
   267  				options = append(options, WithUploadAudienceGroupCallUploadDescription(tc.UploadDescription))
   268  			}
   269  			timeoutCtx, cancelFn := context.WithTimeout(context.Background(), 1*time.Second)
   270  			defer cancelFn()
   271  			res, err = client.UploadAudienceGroup(tc.Description, options...).WithContext(timeoutCtx).Do()
   272  			if tc.Want.Error != nil {
   273  				if !reflect.DeepEqual(err, tc.Want.Error) {
   274  					t.Errorf("Error %v; want %v", err, tc.Want.Error)
   275  				}
   276  			} else {
   277  				if err != nil {
   278  					t.Error(err)
   279  				}
   280  			}
   281  			if tc.Want.Response != nil {
   282  				if !reflect.DeepEqual(res, tc.Want.Response) {
   283  					t.Errorf("Response %v; want %v", res, tc.Want.Response)
   284  				}
   285  			}
   286  		})
   287  	}
   288  }
   289  
   290  // TestUploadAudienceGroupByFile tests UploadAudienceGroupByFile
   291  func TestUploadAudienceGroupByFile(t *testing.T) {
   292  	type RequestBody struct {
   293  		Description       string
   294  		IsIfaAudience     bool
   295  		UploadDescription string
   296  		Audiences         string
   297  	}
   298  	type want struct {
   299  		URLPath     string
   300  		RequestBody RequestBody
   301  		Response    *UploadAudienceGroupResponse
   302  		Error       error
   303  	}
   304  	testCases := []struct {
   305  		Label             string
   306  		Description       string
   307  		IsIfaAudience     bool
   308  		UploadDescription string
   309  		Audiences         []string
   310  		RequestID         string
   311  		AcceptedRequestID string
   312  		ResponseCode      int
   313  		Response          []byte
   314  		Want              want
   315  	}{
   316  		{
   317  			Label:        "Create Audience By File Fail",
   318  			Description:  "audienceGroupName_01",
   319  			RequestID:    "12222",
   320  			ResponseCode: http.StatusBadRequest,
   321  			Response:     []byte(``),
   322  			Want: want{
   323  				URLPath: APIAudienceGroupUploadByFile,
   324  				RequestBody: RequestBody{
   325  					Description: "audienceGroupName_01",
   326  				},
   327  				Error: &APIError{
   328  					Code: http.StatusBadRequest,
   329  				},
   330  			},
   331  		},
   332  		{
   333  			Label:        "Create Audience By File not include userIDs",
   334  			Description:  "audienceGroupName_01",
   335  			RequestID:    "12222",
   336  			ResponseCode: http.StatusOK,
   337  			Response:     []byte(`{"audienceGroupId":1234567890123,"createRoute":"MESSAGING_API","type":"UPLOAD","description":"audienceGroupName_01","created":1613698278,"permission":"READ_WRITE","expireTimestamp":1629250278}`),
   338  			Want: want{
   339  				URLPath: APIAudienceGroupUploadByFile,
   340  				RequestBody: RequestBody{
   341  					Description: "audienceGroupName_01",
   342  				},
   343  				Response: &UploadAudienceGroupResponse{
   344  					RequestID:       "12222",
   345  					AudienceGroupID: 1234567890123,
   346  					CreateRoute:     "MESSAGING_API",
   347  					Type:            "UPLOAD",
   348  					Description:     "audienceGroupName_01",
   349  					Created:         1613698278,
   350  					Permission:      "READ_WRITE",
   351  					ExpireTimestamp: 1629250278,
   352  					IsIfaAudience:   false,
   353  				},
   354  			},
   355  		},
   356  		{
   357  			Label:       "Create Audience By File By UserID",
   358  			Description: "audienceGroupName_01",
   359  			Audiences: []string{
   360  				"U4af4980627", "U4af4980628", "U4af4980629",
   361  			},
   362  			RequestID:    "12222",
   363  			ResponseCode: http.StatusOK,
   364  			Response:     []byte(`{"audienceGroupId":1234567890123,"createRoute":"MESSAGING_API","type":"UPLOAD","description":"audienceGroupName_01","created":1613698278,"permission":"READ_WRITE","expireTimestamp":1629250278}`),
   365  			Want: want{
   366  				URLPath: APIAudienceGroupUploadByFile,
   367  				RequestBody: RequestBody{
   368  					Description: "audienceGroupName_01",
   369  					Audiences:   "U4af4980627\nU4af4980628\nU4af4980629",
   370  				},
   371  				Response: &UploadAudienceGroupResponse{
   372  					RequestID:       "12222",
   373  					AudienceGroupID: 1234567890123,
   374  					CreateRoute:     "MESSAGING_API",
   375  					Type:            "UPLOAD",
   376  					Description:     "audienceGroupName_01",
   377  					Created:         1613698278,
   378  					Permission:      "READ_WRITE",
   379  					ExpireTimestamp: 1629250278,
   380  					IsIfaAudience:   false,
   381  				},
   382  			},
   383  		},
   384  		{
   385  			Label:         "Create Audience By File Is IFA",
   386  			Description:   "audienceGroupName_01",
   387  			IsIfaAudience: true,
   388  			RequestID:     "12222",
   389  			ResponseCode:  http.StatusOK,
   390  			Response:      []byte(`{"audienceGroupId":1234567890123,"createRoute":"MESSAGING_API","type":"UPLOAD","description":"audienceGroupName_01","created":1613698278,"permission":"READ_WRITE","expireTimestamp":1629250278}`),
   391  			Want: want{
   392  				URLPath: APIAudienceGroupUploadByFile,
   393  				RequestBody: RequestBody{
   394  					Description:   "audienceGroupName_01",
   395  					IsIfaAudience: true,
   396  				},
   397  				Response: &UploadAudienceGroupResponse{
   398  					RequestID:       "12222",
   399  					AudienceGroupID: 1234567890123,
   400  					CreateRoute:     "MESSAGING_API",
   401  					Type:            "UPLOAD",
   402  					Description:     "audienceGroupName_01",
   403  					Created:         1613698278,
   404  					Permission:      "READ_WRITE",
   405  					ExpireTimestamp: 1629250278,
   406  					IsIfaAudience:   false,
   407  				},
   408  			},
   409  		},
   410  		{
   411  			Label:             "Create Audience By File have uploadDescription",
   412  			Description:       "audienceGroupName_01",
   413  			UploadDescription: "audienceGroupNameJob_01",
   414  			RequestID:         "12222",
   415  			ResponseCode:      http.StatusOK,
   416  			Response:          []byte(`{"audienceGroupId":1234567890123,"createRoute":"MESSAGING_API","type":"UPLOAD","description":"audienceGroupName_01","created":1613698278,"permission":"READ_WRITE","expireTimestamp":1629250278}`),
   417  			Want: want{
   418  				URLPath: APIAudienceGroupUploadByFile,
   419  				RequestBody: RequestBody{
   420  					Description:       "audienceGroupName_01",
   421  					UploadDescription: "audienceGroupNameJob_01",
   422  				},
   423  				Response: &UploadAudienceGroupResponse{
   424  					RequestID:       "12222",
   425  					AudienceGroupID: 1234567890123,
   426  					CreateRoute:     "MESSAGING_API",
   427  					Type:            "UPLOAD",
   428  					Description:     "audienceGroupName_01",
   429  					Created:         1613698278,
   430  					Permission:      "READ_WRITE",
   431  					ExpireTimestamp: 1629250278,
   432  					IsIfaAudience:   false,
   433  				},
   434  			},
   435  		},
   436  		{
   437  			Label:             "Create Audience By File",
   438  			Description:       "audienceGroupName_01",
   439  			UploadDescription: "audienceGroupNameJob_01",
   440  			Audiences: []string{
   441  				"U4af4980627", "U4af4980628", "U4af4980629",
   442  			},
   443  			RequestID:    "12222",
   444  			ResponseCode: http.StatusOK,
   445  			Response:     []byte(`{"audienceGroupId":1234567890123,"createRoute":"MESSAGING_API","type":"UPLOAD","description":"audienceGroupName_01","created":1613698278,"permission":"READ_WRITE","expireTimestamp":1629250278}`),
   446  			Want: want{
   447  				URLPath: APIAudienceGroupUploadByFile,
   448  				RequestBody: RequestBody{
   449  					Description:       "audienceGroupName_01",
   450  					UploadDescription: "audienceGroupNameJob_01",
   451  					Audiences:         "U4af4980627\nU4af4980628\nU4af4980629",
   452  				},
   453  				Response: &UploadAudienceGroupResponse{
   454  					RequestID:       "12222",
   455  					AudienceGroupID: 1234567890123,
   456  					CreateRoute:     "MESSAGING_API",
   457  					Type:            "UPLOAD",
   458  					Description:     "audienceGroupName_01",
   459  					Created:         1613698278,
   460  					Permission:      "READ_WRITE",
   461  					ExpireTimestamp: 1629250278,
   462  					IsIfaAudience:   false,
   463  				},
   464  			},
   465  		},
   466  	}
   467  
   468  	var currentTestIdx int
   469  	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   470  		defer r.Body.Close()
   471  		t.Error("Unexpected API call")
   472  		w.WriteHeader(http.StatusNotFound)
   473  		w.Write([]byte(`{"message":"Not found"}`))
   474  	}))
   475  	defer server.Close()
   476  
   477  	dataServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   478  		defer r.Body.Close()
   479  		tc := testCases[currentTestIdx]
   480  		if r.Method != http.MethodPost {
   481  			t.Errorf("Method %s; want %s", r.Method, http.MethodPost)
   482  		}
   483  		if r.URL.Path != tc.Want.URLPath {
   484  			t.Errorf("URLPath %s; want %s", r.URL.Path, tc.Want.URLPath)
   485  		}
   486  
   487  		if err := r.ParseMultipartForm(32 << 20); err != nil {
   488  			t.Fatal(err)
   489  		}
   490  		file, _, err := r.FormFile("file")
   491  		if err != nil {
   492  			t.Fatal(err)
   493  		}
   494  		defer file.Close()
   495  		buf := bytes.NewBuffer(nil)
   496  		_, errCopy := io.Copy(buf, file)
   497  		if err != nil {
   498  			t.Fatal(errCopy)
   499  		}
   500  		if buf.String() != tc.Want.RequestBody.Audiences {
   501  			t.Errorf("Audiences %s; want %s", buf.String(), tc.Want.RequestBody.Audiences)
   502  		}
   503  		if v := r.FormValue("description"); v != "" {
   504  			if v != tc.Want.RequestBody.Description {
   505  				t.Errorf("Description %s; want %s", v, tc.Want.RequestBody.Description)
   506  			}
   507  		}
   508  		if v := r.FormValue("uploadDescription"); v != "" {
   509  			if v != tc.Want.RequestBody.UploadDescription {
   510  				t.Errorf("UploadDescription %s; want %s", v, tc.Want.RequestBody.UploadDescription)
   511  			}
   512  		}
   513  		if v := r.FormValue("isIfaAudience"); v != "" {
   514  			isIfaAudience, err := strconv.ParseBool(v)
   515  			if err != nil {
   516  				t.Fatal(errCopy)
   517  			}
   518  			if isIfaAudience != tc.Want.RequestBody.IsIfaAudience {
   519  				t.Errorf("IsIfaAudience %s; want %v", v, tc.Want.RequestBody.IsIfaAudience)
   520  			}
   521  		}
   522  
   523  		w.Header().Set("X-Line-Request-Id", tc.RequestID)
   524  		if tc.AcceptedRequestID != "" {
   525  			w.Header().Set("X-Line-Accepted-Request-Id", tc.AcceptedRequestID)
   526  		}
   527  		w.WriteHeader(tc.ResponseCode)
   528  		w.Write(tc.Response)
   529  	}))
   530  	defer dataServer.Close()
   531  
   532  	client, err := mockClient(server, dataServer)
   533  	if err != nil {
   534  		t.Fatal(err)
   535  	}
   536  
   537  	var res *UploadAudienceGroupResponse
   538  	for i, tc := range testCases {
   539  		currentTestIdx = i
   540  		t.Run(strconv.Itoa(i)+"/"+tc.Label, func(t *testing.T) {
   541  			var options []IUploadAudienceGroupByFileOption
   542  			if tc.IsIfaAudience {
   543  				options = append(options, WithUploadAudienceGroupByFileCallIsIfaAudience(true))
   544  			}
   545  			if tc.UploadDescription != "" {
   546  				options = append(options, WithUploadAudienceGroupByFileCallUploadDescription(tc.UploadDescription))
   547  			}
   548  			timeoutCtx, cancelFn := context.WithTimeout(context.Background(), 1*time.Second)
   549  			defer cancelFn()
   550  			res, err = client.UploadAudienceGroupByFile(tc.Description, tc.Audiences, options...).WithContext(timeoutCtx).Do()
   551  			if tc.Want.Error != nil {
   552  				if !reflect.DeepEqual(err, tc.Want.Error) {
   553  					t.Errorf("Error %v; want %v", err, tc.Want.Error)
   554  				}
   555  			} else {
   556  				if err != nil {
   557  					t.Error(err)
   558  				}
   559  			}
   560  			if tc.Want.Response != nil {
   561  				if !reflect.DeepEqual(res, tc.Want.Response) {
   562  					t.Errorf("Response %v; want %v", res, tc.Want.Response)
   563  				}
   564  			}
   565  		})
   566  	}
   567  }
   568  
   569  // TestAddAudiences tests AddAudiences
   570  func TestAddAudiences(t *testing.T) {
   571  	type RequestBody struct {
   572  		AudienceGroupID   int        `json:"audienceGroupId,omitempty"`
   573  		UploadDescription string     `json:"uploadDescription,omitempty"`
   574  		Audiences         []audience `json:"audiences,omitempty"`
   575  	}
   576  	type want struct {
   577  		URLPath     string
   578  		RequestBody RequestBody
   579  		Response    *BasicResponse
   580  		Error       error
   581  	}
   582  	testCases := []struct {
   583  		Label             string
   584  		AudienceGroupID   int
   585  		UploadDescription string
   586  		Audiences         []string
   587  		RequestID         string
   588  		AcceptedRequestID string
   589  		ResponseCode      int
   590  		Response          []byte
   591  		Want              want
   592  	}{
   593  		{
   594  			Label:             "Add Audience Fail",
   595  			AudienceGroupID:   4389303728991,
   596  			UploadDescription: "audienceGroupNameJob_01",
   597  			Audiences: []string{
   598  				"U4af4980627", "U4af4980628", "U4af4980629",
   599  			},
   600  			RequestID:    "12222",
   601  			ResponseCode: http.StatusBadRequest,
   602  			Response:     []byte(``),
   603  			Want: want{
   604  				URLPath: APIAudienceGroupUpload,
   605  				RequestBody: RequestBody{
   606  					AudienceGroupID:   4389303728991,
   607  					UploadDescription: "audienceGroupNameJob_01",
   608  					Audiences: []audience{
   609  						{
   610  							ID: "U4af4980627",
   611  						},
   612  						{
   613  							ID: "U4af4980628",
   614  						},
   615  						{
   616  							ID: "U4af4980629",
   617  						},
   618  					},
   619  				},
   620  				Error: &APIError{
   621  					Code: http.StatusBadRequest,
   622  				},
   623  			},
   624  		},
   625  		{
   626  			Label:           "add Audience no uploadDescription",
   627  			AudienceGroupID: 4389303728991,
   628  			Audiences: []string{
   629  				"U4af4980627", "U4af4980628", "U4af4980629",
   630  			},
   631  			RequestID:    "12222",
   632  			ResponseCode: http.StatusOK,
   633  			Response:     []byte(``),
   634  			Want: want{
   635  				URLPath: APIAudienceGroupUpload,
   636  				RequestBody: RequestBody{
   637  					AudienceGroupID: 4389303728991,
   638  					Audiences: []audience{
   639  						{
   640  							ID: "U4af4980627",
   641  						},
   642  						{
   643  							ID: "U4af4980628",
   644  						},
   645  						{
   646  							ID: "U4af4980629",
   647  						},
   648  					},
   649  				},
   650  				Response: &BasicResponse{
   651  					RequestID: "12222",
   652  				},
   653  			},
   654  		},
   655  		{
   656  			Label:             "add Audience",
   657  			AudienceGroupID:   4389303728991,
   658  			UploadDescription: "audienceGroupNameJob_01",
   659  			Audiences: []string{
   660  				"U4af4980627", "U4af4980628", "U4af4980629",
   661  			},
   662  			RequestID:    "12222",
   663  			ResponseCode: http.StatusOK,
   664  			Response:     []byte(``),
   665  			Want: want{
   666  				URLPath: APIAudienceGroupUpload,
   667  				RequestBody: RequestBody{
   668  					AudienceGroupID:   4389303728991,
   669  					UploadDescription: "audienceGroupNameJob_01",
   670  					Audiences: []audience{
   671  						{
   672  							ID: "U4af4980627",
   673  						},
   674  						{
   675  							ID: "U4af4980628",
   676  						},
   677  						{
   678  							ID: "U4af4980629",
   679  						},
   680  					},
   681  				},
   682  				Response: &BasicResponse{
   683  					RequestID: "12222",
   684  				},
   685  			},
   686  		},
   687  	}
   688  
   689  	var currentTestIdx int
   690  	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   691  		defer r.Body.Close()
   692  		tc := testCases[currentTestIdx]
   693  		if r.Method != http.MethodPut {
   694  			t.Errorf("Method %s; want %s", r.Method, http.MethodPut)
   695  		}
   696  		if r.URL.Path != tc.Want.URLPath {
   697  			t.Errorf("URLPath %s; want %s", r.URL.Path, tc.Want.URLPath)
   698  		}
   699  		var result RequestBody
   700  		if err := json.NewDecoder(r.Body).Decode(&result); err != nil {
   701  			t.Fatal(err)
   702  		}
   703  		if !reflect.DeepEqual(result, tc.Want.RequestBody) {
   704  			t.Errorf("Request %v; want %v", result, tc.Want.RequestBody)
   705  		}
   706  		w.Header().Set("X-Line-Request-Id", tc.RequestID)
   707  		if tc.AcceptedRequestID != "" {
   708  			w.Header().Set("X-Line-Accepted-Request-Id", tc.AcceptedRequestID)
   709  		}
   710  		w.WriteHeader(tc.ResponseCode)
   711  		w.Write(tc.Response)
   712  	}))
   713  	defer server.Close()
   714  
   715  	dataServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   716  		defer r.Body.Close()
   717  		t.Error("Unexpected data API call")
   718  		w.WriteHeader(http.StatusNotFound)
   719  		w.Write([]byte(`{"message":"Not found"}`))
   720  	}))
   721  	defer dataServer.Close()
   722  
   723  	client, err := mockClient(server, dataServer)
   724  	if err != nil {
   725  		t.Fatal(err)
   726  	}
   727  
   728  	var res *BasicResponse
   729  	for i, tc := range testCases {
   730  		currentTestIdx = i
   731  		t.Run(strconv.Itoa(i)+"/"+tc.Label, func(t *testing.T) {
   732  			var options []IAddAudiencesOption
   733  			if tc.UploadDescription != "" {
   734  				options = append(options, WithAddAudiencesCallUploadDescription(tc.UploadDescription))
   735  			}
   736  			timeoutCtx, cancelFn := context.WithTimeout(context.Background(), 1*time.Second)
   737  			defer cancelFn()
   738  			res, err = client.AddAudiences(tc.AudienceGroupID, tc.Audiences, options...).WithContext(timeoutCtx).Do()
   739  			if tc.Want.Error != nil {
   740  				log.Println(err)
   741  				log.Println(tc.Want.Error)
   742  				if !reflect.DeepEqual(err, tc.Want.Error) {
   743  					t.Errorf("Error %v; want %v", err, tc.Want.Error)
   744  				}
   745  			} else {
   746  				if err != nil {
   747  					t.Error(err)
   748  				}
   749  			}
   750  			if tc.Want.Response != nil {
   751  				if !reflect.DeepEqual(res, tc.Want.Response) {
   752  					t.Errorf("Response %v; want %v", res, tc.Want.Response)
   753  				}
   754  			}
   755  		})
   756  	}
   757  }
   758  
   759  // TestAddAudiencesByFile tests AddAudiencesByFile
   760  func TestAddAudiencesByFile(t *testing.T) {
   761  	type RequestBody struct {
   762  		AudienceGroupID   int
   763  		UploadDescription string
   764  		Audiences         string
   765  	}
   766  	type want struct {
   767  		URLPath     string
   768  		RequestBody RequestBody
   769  		Response    *BasicResponse
   770  		Error       error
   771  	}
   772  	testCases := []struct {
   773  		Label             string
   774  		AudienceGroupID   int
   775  		UploadDescription string
   776  		Audiences         []string
   777  		RequestID         string
   778  		AcceptedRequestID string
   779  		ResponseCode      int
   780  		Response          []byte
   781  		Want              want
   782  	}{
   783  		{
   784  			Label:             "Add Audience By File Fail",
   785  			AudienceGroupID:   4389303728991,
   786  			UploadDescription: "audienceGroupNameJob_01",
   787  			Audiences: []string{
   788  				"U4af4980627", "U4af4980628", "U4af4980629",
   789  			},
   790  			RequestID:    "12222",
   791  			ResponseCode: http.StatusBadRequest,
   792  			Response:     []byte(``),
   793  			Want: want{
   794  				URLPath: APIAudienceGroupUploadByFile,
   795  				RequestBody: RequestBody{
   796  					AudienceGroupID:   4389303728991,
   797  					UploadDescription: "audienceGroupNameJob_01",
   798  					Audiences:         "U4af4980627\nU4af4980628\nU4af4980629",
   799  				},
   800  				Error: &APIError{
   801  					Code: http.StatusBadRequest,
   802  				},
   803  			},
   804  		},
   805  		{
   806  			Label:           "Add Audience By File no uploadDescription",
   807  			AudienceGroupID: 4389303728991,
   808  			Audiences: []string{
   809  				"U4af4980627", "U4af4980628", "U4af4980629",
   810  			},
   811  			RequestID:    "12222",
   812  			ResponseCode: http.StatusOK,
   813  			Response:     []byte(``),
   814  			Want: want{
   815  				URLPath: APIAudienceGroupUploadByFile,
   816  				RequestBody: RequestBody{
   817  					AudienceGroupID: 4389303728991,
   818  					Audiences:       "U4af4980627\nU4af4980628\nU4af4980629",
   819  				},
   820  				Response: &BasicResponse{
   821  					RequestID: "12222",
   822  				},
   823  			},
   824  		},
   825  		{
   826  			Label:             "Add Audience By File",
   827  			AudienceGroupID:   4389303728991,
   828  			UploadDescription: "audienceGroupNameJob_01",
   829  			Audiences: []string{
   830  				"U4af4980627", "U4af4980628", "U4af4980629",
   831  			},
   832  			RequestID:    "12222",
   833  			ResponseCode: http.StatusOK,
   834  			Response:     []byte(``),
   835  			Want: want{
   836  				URLPath: APIAudienceGroupUploadByFile,
   837  				RequestBody: RequestBody{
   838  					AudienceGroupID:   4389303728991,
   839  					UploadDescription: "audienceGroupNameJob_01",
   840  					Audiences:         "U4af4980627\nU4af4980628\nU4af4980629",
   841  				},
   842  				Response: &BasicResponse{
   843  					RequestID: "12222",
   844  				},
   845  			},
   846  		},
   847  	}
   848  
   849  	var currentTestIdx int
   850  	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   851  		defer r.Body.Close()
   852  		t.Error("Unexpected API call")
   853  		w.WriteHeader(http.StatusNotFound)
   854  		w.Write([]byte(`{"message":"Not found"}`))
   855  	}))
   856  	defer server.Close()
   857  
   858  	dataServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   859  		defer r.Body.Close()
   860  		tc := testCases[currentTestIdx]
   861  		if r.Method != http.MethodPut {
   862  			t.Errorf("Method %s; want %s", r.Method, http.MethodPut)
   863  		}
   864  		if r.URL.Path != tc.Want.URLPath {
   865  			t.Errorf("URLPath %s; want %s", r.URL.Path, tc.Want.URLPath)
   866  		}
   867  
   868  		if err := r.ParseMultipartForm(32 << 20); err != nil {
   869  			t.Fatal(err)
   870  		}
   871  		file, _, err := r.FormFile("file")
   872  		if err != nil {
   873  			t.Fatal(err)
   874  		}
   875  		defer file.Close()
   876  		buf := bytes.NewBuffer(nil)
   877  		_, errCopy := io.Copy(buf, file)
   878  		if err != nil {
   879  			t.Fatal(errCopy)
   880  		}
   881  		if buf.String() != tc.Want.RequestBody.Audiences {
   882  			t.Errorf("Audiences %s; want %s", buf.String(), tc.Want.RequestBody.Audiences)
   883  		}
   884  		if v := r.FormValue("audienceGroupId"); v != "" {
   885  			audienceGroupID, err := strconv.ParseInt(v, 10, 64)
   886  			if err != nil {
   887  				t.Fatal(err)
   888  			}
   889  			if int(audienceGroupID) != tc.Want.RequestBody.AudienceGroupID {
   890  				t.Errorf("audienceGroupId %v; want %v", int(audienceGroupID), tc.Want.RequestBody.AudienceGroupID)
   891  			}
   892  		}
   893  		if v := r.FormValue("uploadDescription"); v != "" {
   894  			if v != tc.Want.RequestBody.UploadDescription {
   895  				t.Errorf("UploadDescription %s; want %s", v, tc.Want.RequestBody.UploadDescription)
   896  			}
   897  		}
   898  
   899  		w.Header().Set("X-Line-Request-Id", tc.RequestID)
   900  		if tc.AcceptedRequestID != "" {
   901  			w.Header().Set("X-Line-Accepted-Request-Id", tc.AcceptedRequestID)
   902  		}
   903  		w.WriteHeader(tc.ResponseCode)
   904  		w.Write(tc.Response)
   905  	}))
   906  	defer dataServer.Close()
   907  
   908  	client, err := mockClient(server, dataServer)
   909  	if err != nil {
   910  		t.Fatal(err)
   911  	}
   912  
   913  	var res *BasicResponse
   914  	for i, tc := range testCases {
   915  		currentTestIdx = i
   916  		t.Run(strconv.Itoa(i)+"/"+tc.Label, func(t *testing.T) {
   917  			var options []IAddAudiencesByFileOption
   918  			if tc.UploadDescription != "" {
   919  				options = append(options, WithAddAudiencesByFileCallUploadDescription(tc.UploadDescription))
   920  			}
   921  			timeoutCtx, cancelFn := context.WithTimeout(context.Background(), 1*time.Second)
   922  			defer cancelFn()
   923  			res, err = client.AddAudiencesByFile(tc.AudienceGroupID, tc.Audiences, options...).WithContext(timeoutCtx).Do()
   924  			if tc.Want.Error != nil {
   925  				if !reflect.DeepEqual(err, tc.Want.Error) {
   926  					t.Errorf("Error %v; want %v", err, tc.Want.Error)
   927  				}
   928  			} else {
   929  				if err != nil {
   930  					t.Error(err)
   931  				}
   932  			}
   933  			if tc.Want.Response != nil {
   934  				if !reflect.DeepEqual(res, tc.Want.Response) {
   935  					t.Errorf("Response %v; want %v", res, tc.Want.Response)
   936  				}
   937  			}
   938  		})
   939  	}
   940  }
   941  
   942  // TestClickAudienceGroup tests ClickAudienceGroup
   943  func TestClickAudienceGroup(t *testing.T) {
   944  	type RequestBody struct {
   945  		Description string `json:"description,omitempty"`
   946  		RequestID   string `json:"requestId,omitempty"`
   947  		ClickURL    string `json:"clickUrl,omitempty"`
   948  	}
   949  	type want struct {
   950  		URLPath     string
   951  		RequestBody RequestBody
   952  		Response    *ClickAudienceGroupResponse
   953  		Error       error
   954  	}
   955  	testCases := []struct {
   956  		Label             string
   957  		Description       string
   958  		XRequestID        string
   959  		ClickURL          string
   960  		RequestID         string
   961  		AcceptedRequestID string
   962  		ResponseCode      int
   963  		Response          []byte
   964  		Want              want
   965  	}{
   966  		{
   967  			Label:        "Click Audience Fail",
   968  			Description:  "audienceGroupName_01",
   969  			XRequestID:   "bb9744f9-47fa-4a29-941e-1234567890ab",
   970  			ClickURL:     "https://developers.line.biz/",
   971  			RequestID:    "12222",
   972  			ResponseCode: http.StatusBadRequest,
   973  			Response:     []byte(``),
   974  			Want: want{
   975  				URLPath: APIAudienceGroupClick,
   976  				RequestBody: RequestBody{
   977  					Description: "audienceGroupName_01",
   978  					RequestID:   "bb9744f9-47fa-4a29-941e-1234567890ab",
   979  					ClickURL:    "https://developers.line.biz/",
   980  				},
   981  				Error: &APIError{
   982  					Code: http.StatusBadRequest,
   983  				},
   984  			},
   985  		},
   986  		{
   987  			Label:        "Click Audience No ClickURL",
   988  			Description:  "audienceGroupName_01",
   989  			XRequestID:   "bb9744f9-47fa-4a29-941e-1234567890ab",
   990  			RequestID:    "12222",
   991  			ResponseCode: http.StatusOK,
   992  			Response:     []byte(`{"audienceGroupId":1234567890123,"createRoute":"MESSAGING_API","type":"CLICK","description":"audienceGroupName_01","created":1613705240,"permission":"READ_WRITE","expireTimestamp":1629257239,"requestId":"bb9744f9-47fa-4a29-941e-1234567890ab","clickUrl":"https://developers.line.biz/"}`),
   993  			Want: want{
   994  				URLPath: APIAudienceGroupClick,
   995  				RequestBody: RequestBody{
   996  					Description: "audienceGroupName_01",
   997  					RequestID:   "bb9744f9-47fa-4a29-941e-1234567890ab",
   998  				},
   999  				Response: &ClickAudienceGroupResponse{
  1000  					XRequestID:      "12222",
  1001  					AudienceGroupID: 1234567890123,
  1002  					CreateRoute:     "MESSAGING_API",
  1003  					Type:            "CLICK",
  1004  					Description:     "audienceGroupName_01",
  1005  					Created:         1613705240,
  1006  					Permission:      "READ_WRITE",
  1007  					ExpireTimestamp: 1629257239,
  1008  					IsIfaAudience:   false,
  1009  					RequestID:       "bb9744f9-47fa-4a29-941e-1234567890ab",
  1010  					ClickURL:        "https://developers.line.biz/",
  1011  				},
  1012  			},
  1013  		},
  1014  		{
  1015  			Label:        "Click Audience",
  1016  			Description:  "audienceGroupName_01",
  1017  			XRequestID:   "bb9744f9-47fa-4a29-941e-1234567890ab",
  1018  			ClickURL:     "https://developers.line.biz/",
  1019  			RequestID:    "12222",
  1020  			ResponseCode: http.StatusOK,
  1021  			Response:     []byte(`{"audienceGroupId":1234567890123,"createRoute":"MESSAGING_API","type":"CLICK","description":"audienceGroupName_01","created":1613705240,"permission":"READ_WRITE","expireTimestamp":1629257239,"requestId":"bb9744f9-47fa-4a29-941e-1234567890ab","clickUrl":"https://developers.line.biz/"}`),
  1022  			Want: want{
  1023  				URLPath: APIAudienceGroupClick,
  1024  				RequestBody: RequestBody{
  1025  					Description: "audienceGroupName_01",
  1026  					RequestID:   "bb9744f9-47fa-4a29-941e-1234567890ab",
  1027  					ClickURL:    "https://developers.line.biz/",
  1028  				},
  1029  				Response: &ClickAudienceGroupResponse{
  1030  					XRequestID:      "12222",
  1031  					AudienceGroupID: 1234567890123,
  1032  					CreateRoute:     "MESSAGING_API",
  1033  					Type:            "CLICK",
  1034  					Description:     "audienceGroupName_01",
  1035  					Created:         1613705240,
  1036  					Permission:      "READ_WRITE",
  1037  					ExpireTimestamp: 1629257239,
  1038  					IsIfaAudience:   false,
  1039  					RequestID:       "bb9744f9-47fa-4a29-941e-1234567890ab",
  1040  					ClickURL:        "https://developers.line.biz/",
  1041  				},
  1042  			},
  1043  		},
  1044  	}
  1045  
  1046  	var currentTestIdx int
  1047  	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  1048  		defer r.Body.Close()
  1049  		tc := testCases[currentTestIdx]
  1050  		if r.Method != http.MethodPost {
  1051  			t.Errorf("Method %s; want %s", r.Method, http.MethodPost)
  1052  		}
  1053  		if r.URL.Path != tc.Want.URLPath {
  1054  			t.Errorf("URLPath %s; want %s", r.URL.Path, tc.Want.URLPath)
  1055  		}
  1056  		var result RequestBody
  1057  		if err := json.NewDecoder(r.Body).Decode(&result); err != nil {
  1058  			t.Fatal(err)
  1059  		}
  1060  		if !reflect.DeepEqual(result, tc.Want.RequestBody) {
  1061  			t.Errorf("Request %v; want %v", result, tc.Want.RequestBody)
  1062  		}
  1063  		w.Header().Set("X-Line-Request-Id", tc.RequestID)
  1064  		if tc.AcceptedRequestID != "" {
  1065  			w.Header().Set("X-Line-Accepted-Request-Id", tc.AcceptedRequestID)
  1066  		}
  1067  		w.WriteHeader(tc.ResponseCode)
  1068  		w.Write(tc.Response)
  1069  	}))
  1070  	defer server.Close()
  1071  
  1072  	dataServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  1073  		defer r.Body.Close()
  1074  		t.Error("Unexpected data API call")
  1075  		w.WriteHeader(http.StatusNotFound)
  1076  		w.Write([]byte(`{"message":"Not found"}`))
  1077  	}))
  1078  	defer dataServer.Close()
  1079  
  1080  	client, err := mockClient(server, dataServer)
  1081  	if err != nil {
  1082  		t.Fatal(err)
  1083  	}
  1084  
  1085  	var res *ClickAudienceGroupResponse
  1086  	for i, tc := range testCases {
  1087  		currentTestIdx = i
  1088  		t.Run(strconv.Itoa(i)+"/"+tc.Label, func(t *testing.T) {
  1089  			var options []IClickAudienceGroupOption
  1090  			if tc.ClickURL != "" {
  1091  				options = append(options, WithClickAudienceGroupCallClickURL(tc.ClickURL))
  1092  			}
  1093  			timeoutCtx, cancelFn := context.WithTimeout(context.Background(), 1*time.Second)
  1094  			defer cancelFn()
  1095  			res, err = client.ClickAudienceGroup(tc.Description, tc.XRequestID, options...).WithContext(timeoutCtx).Do()
  1096  			if tc.Want.Error != nil {
  1097  				log.Println(err)
  1098  				log.Println(tc.Want.Error)
  1099  				if !reflect.DeepEqual(err, tc.Want.Error) {
  1100  					t.Errorf("Error %v; want %v", err, tc.Want.Error)
  1101  				}
  1102  			} else {
  1103  				if err != nil {
  1104  					t.Error(err)
  1105  				}
  1106  			}
  1107  			if tc.Want.Response != nil {
  1108  				if !reflect.DeepEqual(res, tc.Want.Response) {
  1109  					t.Errorf("Response %v; want %v", res, tc.Want.Response)
  1110  				}
  1111  			}
  1112  		})
  1113  	}
  1114  }
  1115  
  1116  // TestIMPAudienceGroup tests IMPAudienceGroup
  1117  func TestIMPAudienceGroup(t *testing.T) {
  1118  	type RequestBody struct {
  1119  		Description string `json:"description,omitempty"`
  1120  		RequestID   string `json:"requestId,omitempty"`
  1121  	}
  1122  	type want struct {
  1123  		URLPath     string
  1124  		RequestBody RequestBody
  1125  		Response    *IMPAudienceGroupResponse
  1126  		Error       error
  1127  	}
  1128  	testCases := []struct {
  1129  		Label             string
  1130  		Description       string
  1131  		XRequestID        string
  1132  		RequestID         string
  1133  		AcceptedRequestID string
  1134  		ResponseCode      int
  1135  		Response          []byte
  1136  		Want              want
  1137  	}{
  1138  		{
  1139  			Label:        "IMP Audience Fail",
  1140  			Description:  "audienceGroupName_01",
  1141  			XRequestID:   "bb9744f9-47fa-4a29-941e-1234567890ab",
  1142  			RequestID:    "12222",
  1143  			ResponseCode: http.StatusBadRequest,
  1144  			Response:     []byte(``),
  1145  			Want: want{
  1146  				URLPath: APIAudienceGroupIMP,
  1147  				RequestBody: RequestBody{
  1148  					Description: "audienceGroupName_01",
  1149  					RequestID:   "bb9744f9-47fa-4a29-941e-1234567890ab",
  1150  				},
  1151  				Error: &APIError{
  1152  					Code: http.StatusBadRequest,
  1153  				},
  1154  			},
  1155  		},
  1156  		{
  1157  			Label:        "IMP Audience",
  1158  			Description:  "audienceGroupName_01",
  1159  			XRequestID:   "bb9744f9-47fa-4a29-941e-1234567890ab",
  1160  			RequestID:    "12222",
  1161  			ResponseCode: http.StatusOK,
  1162  			Response:     []byte(`{"audienceGroupId":1234567890123,"createRoute":"MESSAGING_API","type":"IMP","description":"audienceGroupName_01","created":1613707097,"permission":"READ_WRITE","expireTimestamp":1629259095,"requestId":"bb9744f9-47fa-4a29-941e-1234567890ab"}`),
  1163  			Want: want{
  1164  				URLPath: APIAudienceGroupIMP,
  1165  				RequestBody: RequestBody{
  1166  					Description: "audienceGroupName_01",
  1167  					RequestID:   "bb9744f9-47fa-4a29-941e-1234567890ab",
  1168  				},
  1169  				Response: &IMPAudienceGroupResponse{
  1170  					XRequestID:      "12222",
  1171  					AudienceGroupID: 1234567890123,
  1172  					CreateRoute:     "MESSAGING_API",
  1173  					Type:            "IMP",
  1174  					Description:     "audienceGroupName_01",
  1175  					Created:         1613707097,
  1176  					Permission:      "READ_WRITE",
  1177  					ExpireTimestamp: 1629259095,
  1178  					IsIfaAudience:   false,
  1179  					RequestID:       "bb9744f9-47fa-4a29-941e-1234567890ab",
  1180  				},
  1181  			},
  1182  		},
  1183  	}
  1184  
  1185  	var currentTestIdx int
  1186  	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  1187  		defer r.Body.Close()
  1188  		tc := testCases[currentTestIdx]
  1189  		if r.Method != http.MethodPost {
  1190  			t.Errorf("Method %s; want %s", r.Method, http.MethodPost)
  1191  		}
  1192  		if r.URL.Path != tc.Want.URLPath {
  1193  			t.Errorf("URLPath %s; want %s", r.URL.Path, tc.Want.URLPath)
  1194  		}
  1195  		var result RequestBody
  1196  		if err := json.NewDecoder(r.Body).Decode(&result); err != nil {
  1197  			t.Fatal(err)
  1198  		}
  1199  		if !reflect.DeepEqual(result, tc.Want.RequestBody) {
  1200  			t.Errorf("Request %v; want %v", result, tc.Want.RequestBody)
  1201  		}
  1202  		w.Header().Set("X-Line-Request-Id", tc.RequestID)
  1203  		if tc.AcceptedRequestID != "" {
  1204  			w.Header().Set("X-Line-Accepted-Request-Id", tc.AcceptedRequestID)
  1205  		}
  1206  		w.WriteHeader(tc.ResponseCode)
  1207  		w.Write(tc.Response)
  1208  	}))
  1209  	defer server.Close()
  1210  
  1211  	dataServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  1212  		defer r.Body.Close()
  1213  		t.Error("Unexpected data API call")
  1214  		w.WriteHeader(http.StatusNotFound)
  1215  		w.Write([]byte(`{"message":"Not found"}`))
  1216  	}))
  1217  	defer dataServer.Close()
  1218  
  1219  	client, err := mockClient(server, dataServer)
  1220  	if err != nil {
  1221  		t.Fatal(err)
  1222  	}
  1223  
  1224  	var res *IMPAudienceGroupResponse
  1225  	for i, tc := range testCases {
  1226  		currentTestIdx = i
  1227  		t.Run(strconv.Itoa(i)+"/"+tc.Label, func(t *testing.T) {
  1228  			timeoutCtx, cancelFn := context.WithTimeout(context.Background(), 1*time.Second)
  1229  			defer cancelFn()
  1230  			res, err = client.IMPAudienceGroup(tc.Description, tc.XRequestID).WithContext(timeoutCtx).Do()
  1231  			if tc.Want.Error != nil {
  1232  				log.Println(err)
  1233  				log.Println(tc.Want.Error)
  1234  				if !reflect.DeepEqual(err, tc.Want.Error) {
  1235  					t.Errorf("Error %v; want %v", err, tc.Want.Error)
  1236  				}
  1237  			} else {
  1238  				if err != nil {
  1239  					t.Error(err)
  1240  				}
  1241  			}
  1242  			if tc.Want.Response != nil {
  1243  				if !reflect.DeepEqual(res, tc.Want.Response) {
  1244  					t.Errorf("Response %v; want %v", res, tc.Want.Response)
  1245  				}
  1246  			}
  1247  		})
  1248  	}
  1249  }
  1250  
  1251  // TestUpdateAudienceGroupDescription tests UpdateAudienceGroupDescription
  1252  func TestUpdateAudienceGroupDescription(t *testing.T) {
  1253  	type RequestBody struct {
  1254  		Description string `json:"description,omitempty"`
  1255  	}
  1256  	type want struct {
  1257  		URLPath     string
  1258  		RequestBody RequestBody
  1259  		Response    *BasicResponse
  1260  		Error       error
  1261  	}
  1262  	testCases := []struct {
  1263  		Label             string
  1264  		AudienceGroupID   int
  1265  		Description       string
  1266  		RequestID         string
  1267  		AcceptedRequestID string
  1268  		ResponseCode      int
  1269  		Response          []byte
  1270  		Want              want
  1271  	}{
  1272  		{
  1273  			Label:           "Update Audience Description Fail",
  1274  			AudienceGroupID: 1234567890123,
  1275  			Description:     "audienceGroupName_01",
  1276  			RequestID:       "12222",
  1277  			ResponseCode:    http.StatusBadRequest,
  1278  			Response:        []byte(``),
  1279  			Want: want{
  1280  				URLPath: fmt.Sprintf(APIAudienceGroupUpdateDescription, 1234567890123),
  1281  				RequestBody: RequestBody{
  1282  					Description: "audienceGroupName_01",
  1283  				},
  1284  				Error: &APIError{
  1285  					Code: http.StatusBadRequest,
  1286  				},
  1287  			},
  1288  		},
  1289  		{
  1290  			Label:           "Update Audience Description",
  1291  			AudienceGroupID: 1234567890123,
  1292  			Description:     "audienceGroupName_01",
  1293  			RequestID:       "12222",
  1294  			ResponseCode:    http.StatusOK,
  1295  			Response:        []byte(``),
  1296  			Want: want{
  1297  				URLPath: fmt.Sprintf(APIAudienceGroupUpdateDescription, 1234567890123),
  1298  				RequestBody: RequestBody{
  1299  					Description: "audienceGroupName_01",
  1300  				},
  1301  				Response: &BasicResponse{
  1302  					RequestID: "12222",
  1303  				},
  1304  			},
  1305  		},
  1306  	}
  1307  
  1308  	var currentTestIdx int
  1309  	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  1310  		defer r.Body.Close()
  1311  		tc := testCases[currentTestIdx]
  1312  		if r.Method != http.MethodPut {
  1313  			t.Errorf("Method %s; want %s", r.Method, http.MethodPut)
  1314  		}
  1315  		if r.URL.Path != tc.Want.URLPath {
  1316  			t.Errorf("URLPath %s; want %s", r.URL.Path, tc.Want.URLPath)
  1317  		}
  1318  		var result RequestBody
  1319  		if err := json.NewDecoder(r.Body).Decode(&result); err != nil {
  1320  			t.Fatal(err)
  1321  		}
  1322  		if !reflect.DeepEqual(result, tc.Want.RequestBody) {
  1323  			t.Errorf("Request %v; want %v", result, tc.Want.RequestBody)
  1324  		}
  1325  		w.Header().Set("X-Line-Request-Id", tc.RequestID)
  1326  		if tc.AcceptedRequestID != "" {
  1327  			w.Header().Set("X-Line-Accepted-Request-Id", tc.AcceptedRequestID)
  1328  		}
  1329  		w.WriteHeader(tc.ResponseCode)
  1330  		w.Write(tc.Response)
  1331  	}))
  1332  	defer server.Close()
  1333  
  1334  	dataServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  1335  		defer r.Body.Close()
  1336  		t.Error("Unexpected data API call")
  1337  		w.WriteHeader(http.StatusNotFound)
  1338  		w.Write([]byte(`{"message":"Not found"}`))
  1339  	}))
  1340  	defer dataServer.Close()
  1341  
  1342  	client, err := mockClient(server, dataServer)
  1343  	if err != nil {
  1344  		t.Fatal(err)
  1345  	}
  1346  
  1347  	var res *BasicResponse
  1348  	for i, tc := range testCases {
  1349  		currentTestIdx = i
  1350  		t.Run(strconv.Itoa(i)+"/"+tc.Label, func(t *testing.T) {
  1351  			timeoutCtx, cancelFn := context.WithTimeout(context.Background(), 1*time.Second)
  1352  			defer cancelFn()
  1353  			res, err = client.UpdateAudienceGroupDescription(tc.AudienceGroupID, tc.Description).WithContext(timeoutCtx).Do()
  1354  			if tc.Want.Error != nil {
  1355  				if !reflect.DeepEqual(err, tc.Want.Error) {
  1356  					t.Errorf("Error %v; want %v", err, tc.Want.Error)
  1357  				}
  1358  			} else {
  1359  				if err != nil {
  1360  					t.Error(err)
  1361  				}
  1362  			}
  1363  			if tc.Want.Response != nil {
  1364  				if !reflect.DeepEqual(res, tc.Want.Response) {
  1365  					t.Errorf("Response %v; want %v", res, tc.Want.Response)
  1366  				}
  1367  			}
  1368  		})
  1369  	}
  1370  }
  1371  
  1372  // TestActivateAudienceGroup tests ActivateAudienceGroup
  1373  func TestActivateAudienceGroup(t *testing.T) {
  1374  	type RequestBody struct {
  1375  	}
  1376  	type want struct {
  1377  		URLPath     string
  1378  		RequestBody RequestBody
  1379  		Response    *BasicResponse
  1380  		Error       error
  1381  	}
  1382  	testCases := []struct {
  1383  		Label             string
  1384  		AudienceGroupID   int
  1385  		RequestID         string
  1386  		AcceptedRequestID string
  1387  		ResponseCode      int
  1388  		Response          []byte
  1389  		Want              want
  1390  	}{
  1391  		{
  1392  			Label:           "Activate Audience Fail",
  1393  			AudienceGroupID: 1234567890123,
  1394  			RequestID:       "12222",
  1395  			ResponseCode:    http.StatusBadRequest,
  1396  			Response:        []byte(``),
  1397  			Want: want{
  1398  				URLPath:     fmt.Sprintf(APIAudienceGroupActivate, 1234567890123),
  1399  				RequestBody: RequestBody{},
  1400  				Error: &APIError{
  1401  					Code: http.StatusBadRequest,
  1402  				},
  1403  			},
  1404  		},
  1405  		{
  1406  			Label:           "Activate Audience",
  1407  			AudienceGroupID: 1234567890123,
  1408  			RequestID:       "12222",
  1409  			ResponseCode:    http.StatusOK,
  1410  			Response:        []byte(``),
  1411  			Want: want{
  1412  				URLPath:     fmt.Sprintf(APIAudienceGroupActivate, 1234567890123),
  1413  				RequestBody: RequestBody{},
  1414  				Response: &BasicResponse{
  1415  					RequestID: "12222",
  1416  				},
  1417  			},
  1418  		},
  1419  	}
  1420  
  1421  	var currentTestIdx int
  1422  	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  1423  		defer r.Body.Close()
  1424  		tc := testCases[currentTestIdx]
  1425  		if r.Method != http.MethodPut {
  1426  			t.Errorf("Method %s; want %s", r.Method, http.MethodPut)
  1427  		}
  1428  		if r.URL.Path != tc.Want.URLPath {
  1429  			t.Errorf("URLPath %s; want %s", r.URL.Path, tc.Want.URLPath)
  1430  		}
  1431  		w.Header().Set("X-Line-Request-Id", tc.RequestID)
  1432  		if tc.AcceptedRequestID != "" {
  1433  			w.Header().Set("X-Line-Accepted-Request-Id", tc.AcceptedRequestID)
  1434  		}
  1435  		w.WriteHeader(tc.ResponseCode)
  1436  		w.Write(tc.Response)
  1437  	}))
  1438  	defer server.Close()
  1439  
  1440  	dataServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  1441  		defer r.Body.Close()
  1442  		t.Error("Unexpected data API call")
  1443  		w.WriteHeader(http.StatusNotFound)
  1444  		w.Write([]byte(`{"message":"Not found"}`))
  1445  	}))
  1446  	defer dataServer.Close()
  1447  
  1448  	client, err := mockClient(server, dataServer)
  1449  	if err != nil {
  1450  		t.Fatal(err)
  1451  	}
  1452  
  1453  	var res *BasicResponse
  1454  	for i, tc := range testCases {
  1455  		currentTestIdx = i
  1456  		t.Run(strconv.Itoa(i)+"/"+tc.Label, func(t *testing.T) {
  1457  			timeoutCtx, cancelFn := context.WithTimeout(context.Background(), 1*time.Second)
  1458  			defer cancelFn()
  1459  			res, err = client.ActivateAudienceGroup(tc.AudienceGroupID).WithContext(timeoutCtx).Do()
  1460  			if tc.Want.Error != nil {
  1461  				if !reflect.DeepEqual(err, tc.Want.Error) {
  1462  					t.Errorf("Error %v; want %v", err, tc.Want.Error)
  1463  				}
  1464  			} else {
  1465  				if err != nil {
  1466  					t.Error(err)
  1467  				}
  1468  			}
  1469  			if tc.Want.Response != nil {
  1470  				if !reflect.DeepEqual(res, tc.Want.Response) {
  1471  					t.Errorf("Response %v; want %v", res, tc.Want.Response)
  1472  				}
  1473  			}
  1474  		})
  1475  	}
  1476  }
  1477  
  1478  // TestDeleteAudienceGroup tests DeleteAudienceGroup
  1479  func TestDeleteAudienceGroup(t *testing.T) {
  1480  	type RequestBody struct {
  1481  	}
  1482  	type want struct {
  1483  		URLPath     string
  1484  		RequestBody RequestBody
  1485  		Response    *BasicResponse
  1486  		Error       error
  1487  	}
  1488  	testCases := []struct {
  1489  		Label             string
  1490  		AudienceGroupID   int
  1491  		RequestID         string
  1492  		AcceptedRequestID string
  1493  		ResponseCode      int
  1494  		Response          []byte
  1495  		Want              want
  1496  	}{
  1497  		{
  1498  			Label:           "Delete Audience Fail",
  1499  			AudienceGroupID: 1234567890123,
  1500  			RequestID:       "12222",
  1501  			ResponseCode:    http.StatusBadRequest,
  1502  			Response:        []byte(``),
  1503  			Want: want{
  1504  				URLPath:     fmt.Sprintf(APIAudienceGroup, 1234567890123),
  1505  				RequestBody: RequestBody{},
  1506  				Error: &APIError{
  1507  					Code: http.StatusBadRequest,
  1508  				},
  1509  			},
  1510  		},
  1511  		{
  1512  			Label:           "Delete Audience",
  1513  			AudienceGroupID: 1234567890123,
  1514  			RequestID:       "12222",
  1515  			ResponseCode:    http.StatusOK,
  1516  			Response:        []byte(``),
  1517  			Want: want{
  1518  				URLPath:     fmt.Sprintf(APIAudienceGroup, 1234567890123),
  1519  				RequestBody: RequestBody{},
  1520  				Response: &BasicResponse{
  1521  					RequestID: "12222",
  1522  				},
  1523  			},
  1524  		},
  1525  	}
  1526  
  1527  	var currentTestIdx int
  1528  	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  1529  		defer r.Body.Close()
  1530  		tc := testCases[currentTestIdx]
  1531  		if r.Method != http.MethodDelete {
  1532  			t.Errorf("Method %s; want %s", r.Method, http.MethodDelete)
  1533  		}
  1534  		if r.URL.Path != tc.Want.URLPath {
  1535  			t.Errorf("URLPath %s; want %s", r.URL.Path, tc.Want.URLPath)
  1536  		}
  1537  		w.Header().Set("X-Line-Request-Id", tc.RequestID)
  1538  		if tc.AcceptedRequestID != "" {
  1539  			w.Header().Set("X-Line-Accepted-Request-Id", tc.AcceptedRequestID)
  1540  		}
  1541  		w.WriteHeader(tc.ResponseCode)
  1542  		w.Write(tc.Response)
  1543  	}))
  1544  	defer server.Close()
  1545  
  1546  	dataServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  1547  		defer r.Body.Close()
  1548  		t.Error("Unexpected data API call")
  1549  		w.WriteHeader(http.StatusNotFound)
  1550  		w.Write([]byte(`{"message":"Not found"}`))
  1551  	}))
  1552  	defer dataServer.Close()
  1553  
  1554  	client, err := mockClient(server, dataServer)
  1555  	if err != nil {
  1556  		t.Fatal(err)
  1557  	}
  1558  
  1559  	var res *BasicResponse
  1560  	for i, tc := range testCases {
  1561  		currentTestIdx = i
  1562  		t.Run(strconv.Itoa(i)+"/"+tc.Label, func(t *testing.T) {
  1563  			timeoutCtx, cancelFn := context.WithTimeout(context.Background(), 1*time.Second)
  1564  			defer cancelFn()
  1565  			res, err = client.DeleteAudienceGroup(tc.AudienceGroupID).WithContext(timeoutCtx).Do()
  1566  			if tc.Want.Error != nil {
  1567  				if !reflect.DeepEqual(err, tc.Want.Error) {
  1568  					t.Errorf("Error %v; want %v", err, tc.Want.Error)
  1569  				}
  1570  			} else {
  1571  				if err != nil {
  1572  					t.Error(err)
  1573  				}
  1574  			}
  1575  			if tc.Want.Response != nil {
  1576  				if !reflect.DeepEqual(res, tc.Want.Response) {
  1577  					t.Errorf("Response %v; want %v", res, tc.Want.Response)
  1578  				}
  1579  			}
  1580  		})
  1581  	}
  1582  }
  1583  
  1584  // TestGetAudienceGroup tests GetAudienceGroup
  1585  func TestGetAudienceGroup(t *testing.T) {
  1586  	type RequestBody struct {
  1587  	}
  1588  	type want struct {
  1589  		URLPath     string
  1590  		RequestBody RequestBody
  1591  		Response    *GetAudienceGroupResponse
  1592  		Error       error
  1593  	}
  1594  	testCases := []struct {
  1595  		Label             string
  1596  		AudienceGroupID   int
  1597  		RequestID         string
  1598  		AcceptedRequestID string
  1599  		ResponseCode      int
  1600  		Response          []byte
  1601  		Want              want
  1602  	}{
  1603  		{
  1604  			Label:           "Get Audience Fail",
  1605  			AudienceGroupID: 1234567890123,
  1606  			RequestID:       "12222",
  1607  			ResponseCode:    http.StatusBadRequest,
  1608  			Response:        []byte(`{"message":"audience group not found","details":[{"message":"AUDIENCE_GROUP_NOT_FOUND","property":""}],"error":"","error_description":""}`),
  1609  			Want: want{
  1610  				URLPath:     fmt.Sprintf(APIAudienceGroup, 1234567890123),
  1611  				RequestBody: RequestBody{},
  1612  				Error: &APIError{
  1613  					Code: http.StatusBadRequest,
  1614  					Response: &ErrorResponse{
  1615  						Message: "audience group not found",
  1616  						Details: []errorResponseDetail{
  1617  							{
  1618  								Message: "AUDIENCE_GROUP_NOT_FOUND",
  1619  							},
  1620  						},
  1621  					},
  1622  				},
  1623  			},
  1624  		},
  1625  		{
  1626  			Label:           "Get UPLOAD Audience",
  1627  			AudienceGroupID: 1234567890123,
  1628  			RequestID:       "12222",
  1629  			ResponseCode:    http.StatusOK,
  1630  			Response:        []byte(`{"audienceGroup":{"audienceGroupId":1234567890123,"createRoute":"OA_MANAGER","type":"UPLOAD","description":"audienceGroupName_01","status":"READY","audienceCount":1887,"created":1608617466,"permission":"READ","expireTimestamp":1624342266},"jobs":[{"audienceGroupJobId":12345678,"audienceGroupId":1234567890123,"description":"audience_list.txt","type":"DIFF_ADD","status":"FINISHED","created":1608617472,"jobStatus":"FINISHED"}]}`),
  1631  			Want: want{
  1632  				URLPath:     fmt.Sprintf(APIAudienceGroup, 1234567890123),
  1633  				RequestBody: RequestBody{},
  1634  				Response: &GetAudienceGroupResponse{
  1635  					RequestID: "12222",
  1636  					AudienceGroup: AudienceGroup{
  1637  						AudienceGroupID: 1234567890123,
  1638  						CreateRoute:     "OA_MANAGER",
  1639  						Type:            "UPLOAD",
  1640  						Description:     "audienceGroupName_01",
  1641  						Status:          "READY",
  1642  						AudienceCount:   1887,
  1643  						Created:         1608617466,
  1644  						Permission:      "READ",
  1645  						IsIfaAudience:   false,
  1646  						ExpireTimestamp: 1624342266,
  1647  					},
  1648  					Jobs: []Job{
  1649  						{
  1650  							AudienceGroupJobID: 12345678,
  1651  							AudienceGroupID:    1234567890123,
  1652  							Description:        "audience_list.txt",
  1653  							Type:               "DIFF_ADD",
  1654  							Status:             "FINISHED",
  1655  							AudienceCount:      0,
  1656  							Created:            1608617472,
  1657  							JobStatus:          "FINISHED",
  1658  						},
  1659  					},
  1660  				},
  1661  			},
  1662  		},
  1663  		{
  1664  			Label:           "Get CLICK Audience",
  1665  			AudienceGroupID: 1234567890987,
  1666  			RequestID:       "12222",
  1667  			ResponseCode:    http.StatusOK,
  1668  			Response:        []byte(`{"audienceGroup":{"audienceGroupId":1234567890987,"createRoute":"OA_MANAGER","type":"CLICK","description":"audienceGroupName_02","status":"IN_PROGRESS","audienceCount":8619,"created":1611114828,"permission":"READ","requestId":"c10c3d86-f565-...","clickUrl":"https://example.com/","expireTimestamp":1624342266}}`),
  1669  			Want: want{
  1670  				URLPath:     fmt.Sprintf(APIAudienceGroup, 1234567890987),
  1671  				RequestBody: RequestBody{},
  1672  				Response: &GetAudienceGroupResponse{
  1673  					RequestID: "12222",
  1674  					AudienceGroup: AudienceGroup{
  1675  						AudienceGroupID: 1234567890987,
  1676  						CreateRoute:     "OA_MANAGER",
  1677  						Type:            "CLICK",
  1678  						Description:     "audienceGroupName_02",
  1679  						Status:          "IN_PROGRESS",
  1680  						AudienceCount:   8619,
  1681  						Created:         1611114828,
  1682  						Permission:      "READ",
  1683  						IsIfaAudience:   false,
  1684  						ExpireTimestamp: 1624342266,
  1685  						RequestID:       "c10c3d86-f565-...",
  1686  						ClickURL:        "https://example.com/",
  1687  					},
  1688  				},
  1689  			},
  1690  		},
  1691  		{
  1692  			Label:           "Get APP_EVENT Audience",
  1693  			AudienceGroupID: 2345678909876,
  1694  			RequestID:       "12222",
  1695  			ResponseCode:    http.StatusOK,
  1696  			Response:        []byte(`{"audienceGroup":{"audienceGroupId":2345678909876,"createRoute":"AD_MANAGER","type":"APP_EVENT","description":"audienceGroupName_03","status":"READY","audienceCount":8619,"created":1608619802,"permission":"READ","activated":1610068515,"inactivatedTimestamp":1625620516}}`),
  1697  			Want: want{
  1698  				URLPath:     fmt.Sprintf(APIAudienceGroup, 2345678909876),
  1699  				RequestBody: RequestBody{},
  1700  				Response: &GetAudienceGroupResponse{
  1701  					RequestID: "12222",
  1702  					AudienceGroup: AudienceGroup{
  1703  						AudienceGroupID:      2345678909876,
  1704  						CreateRoute:          "AD_MANAGER",
  1705  						Type:                 "APP_EVENT",
  1706  						Description:          "audienceGroupName_03",
  1707  						Status:               "READY",
  1708  						AudienceCount:        8619,
  1709  						Created:              1608619802,
  1710  						Permission:           "READ",
  1711  						Activated:            1610068515,
  1712  						InactivatedTimestamp: 1625620516,
  1713  						IsIfaAudience:        false,
  1714  					},
  1715  				},
  1716  			},
  1717  		},
  1718  	}
  1719  
  1720  	var currentTestIdx int
  1721  	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  1722  		defer r.Body.Close()
  1723  		tc := testCases[currentTestIdx]
  1724  		if r.Method != http.MethodGet {
  1725  			t.Errorf("Method %s; want %s", r.Method, http.MethodGet)
  1726  		}
  1727  		if r.URL.Path != tc.Want.URLPath {
  1728  			t.Errorf("URLPath %s; want %s", r.URL.Path, tc.Want.URLPath)
  1729  		}
  1730  		w.Header().Set("X-Line-Request-Id", tc.RequestID)
  1731  		if tc.AcceptedRequestID != "" {
  1732  			w.Header().Set("X-Line-Accepted-Request-Id", tc.AcceptedRequestID)
  1733  		}
  1734  		w.WriteHeader(tc.ResponseCode)
  1735  		w.Write(tc.Response)
  1736  	}))
  1737  	defer server.Close()
  1738  
  1739  	dataServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  1740  		defer r.Body.Close()
  1741  		t.Error("Unexpected data API call")
  1742  		w.WriteHeader(http.StatusNotFound)
  1743  		w.Write([]byte(`{"message":"Not found"}`))
  1744  	}))
  1745  	defer dataServer.Close()
  1746  
  1747  	client, err := mockClient(server, dataServer)
  1748  	if err != nil {
  1749  		t.Fatal(err)
  1750  	}
  1751  
  1752  	var res *GetAudienceGroupResponse
  1753  	for i, tc := range testCases {
  1754  		currentTestIdx = i
  1755  		t.Run(strconv.Itoa(i)+"/"+tc.Label, func(t *testing.T) {
  1756  			timeoutCtx, cancelFn := context.WithTimeout(context.Background(), 1*time.Second)
  1757  			defer cancelFn()
  1758  			res, err = client.GetAudienceGroup(tc.AudienceGroupID).WithContext(timeoutCtx).Do()
  1759  			if tc.Want.Error != nil {
  1760  				if !reflect.DeepEqual(err, tc.Want.Error) {
  1761  					t.Errorf("Error %v; want %v", err, tc.Want.Error)
  1762  				}
  1763  			} else {
  1764  				if err != nil {
  1765  					t.Error(err)
  1766  				}
  1767  			}
  1768  			if tc.Want.Response != nil {
  1769  				if !reflect.DeepEqual(res, tc.Want.Response) {
  1770  					t.Errorf("Response %v; want %v", res, tc.Want.Response)
  1771  				}
  1772  			}
  1773  		})
  1774  	}
  1775  }
  1776  
  1777  // TestListAudienceGroup tests ListAudienceGroup
  1778  func TestListAudienceGroup(t *testing.T) {
  1779  	type RequestBody struct {
  1780  	}
  1781  	type RequestParameter struct {
  1782  		Page                         int
  1783  		Description                  string
  1784  		Status                       AudienceStatusType
  1785  		Size                         int
  1786  		IncludesExternalPublicGroups bool
  1787  		CreateRoute                  string
  1788  	}
  1789  	type want struct {
  1790  		URLPath          string
  1791  		RequestBody      RequestBody
  1792  		RequestParameter RequestParameter
  1793  		Response         *ListAudienceGroupResponse
  1794  		Error            error
  1795  	}
  1796  	testCases := []struct {
  1797  		Label                        string
  1798  		Page                         int
  1799  		Description                  string
  1800  		Status                       AudienceStatusType
  1801  		Size                         int
  1802  		IncludesExternalPublicGroups bool
  1803  		CreateRoute                  string
  1804  		RequestID                    string
  1805  		AcceptedRequestID            string
  1806  		ResponseCode                 int
  1807  		Response                     []byte
  1808  		Want                         want
  1809  	}{
  1810  		{
  1811  			Label:        "List Audience Fail",
  1812  			Page:         1,
  1813  			Description:  "audienceGroupName",
  1814  			Status:       INPROGRESS,
  1815  			Size:         41,
  1816  			CreateRoute:  "OA_MANAGER",
  1817  			RequestID:    "12222",
  1818  			ResponseCode: http.StatusBadRequest,
  1819  			Response:     []byte(`{"message":"size: must be less than or equal to 40","details":[{"message":"TOO_HIGH","property":""}],"error":"","error_description":""}`),
  1820  			Want: want{
  1821  				URLPath:     APIAudienceGroupList,
  1822  				RequestBody: RequestBody{},
  1823  				RequestParameter: RequestParameter{
  1824  					Page:        1,
  1825  					Description: "audienceGroupName",
  1826  					Status:      INPROGRESS,
  1827  					Size:        41,
  1828  					CreateRoute: "OA_MANAGER",
  1829  				},
  1830  				Error: &APIError{
  1831  					Code: http.StatusBadRequest,
  1832  					Response: &ErrorResponse{
  1833  						Message: "size: must be less than or equal to 40",
  1834  						Details: []errorResponseDetail{
  1835  							{
  1836  								Message: "TOO_HIGH",
  1837  							},
  1838  						},
  1839  					},
  1840  				},
  1841  			},
  1842  		},
  1843  		{
  1844  			Label:        "List Audience",
  1845  			Page:         1,
  1846  			Description:  "audienceGroupName",
  1847  			Size:         40,
  1848  			CreateRoute:  "OA_MANAGER",
  1849  			RequestID:    "12222",
  1850  			ResponseCode: http.StatusOK,
  1851  			Response:     []byte(`{"audienceGroups":[{"audienceGroupId":1234567890123,"createRoute":"OA_MANAGER","type":"CLICK","description":"audienceGroupName_01","status":"IN_PROGRESS","audienceCount":8619,"created":1611114828,"permission":"READ","requestId":"c10c3d86-f565-...","clickUrl":"https://example.com/","expireTimestamp":1626753228},{"audienceGroupId":2345678901234,"createRoute":"AD_MANAGER","type":"APP_EVENT","description":"audienceGroupName_02","status":"READY","audienceCount":3368,"created":1608619802,"permission":"READ","activated":1610068515,"inactivatedTimestamp":1625620516}],"totalCount":2,"page":40,"size":1}`),
  1852  			Want: want{
  1853  				URLPath:     APIAudienceGroupList,
  1854  				RequestBody: RequestBody{},
  1855  				RequestParameter: RequestParameter{
  1856  					Page:        1,
  1857  					Description: "audienceGroupName",
  1858  					Size:        40,
  1859  					CreateRoute: "OA_MANAGER",
  1860  				},
  1861  				Response: &ListAudienceGroupResponse{
  1862  					RequestID: "12222",
  1863  					AudienceGroups: []AudienceGroup{
  1864  						{
  1865  							AudienceGroupID: 1234567890123,
  1866  							CreateRoute:     "OA_MANAGER",
  1867  							Type:            "CLICK",
  1868  							Description:     "audienceGroupName_01",
  1869  							Status:          "IN_PROGRESS",
  1870  							AudienceCount:   8619,
  1871  							Created:         1611114828,
  1872  							Permission:      "READ",
  1873  							IsIfaAudience:   false,
  1874  							ExpireTimestamp: 1626753228,
  1875  							RequestID:       "c10c3d86-f565-...",
  1876  							ClickURL:        "https://example.com/",
  1877  						},
  1878  						{
  1879  							AudienceGroupID:      2345678901234,
  1880  							CreateRoute:          "AD_MANAGER",
  1881  							Type:                 "APP_EVENT",
  1882  							Description:          "audienceGroupName_02",
  1883  							Status:               "READY",
  1884  							AudienceCount:        3368,
  1885  							Created:              1608619802,
  1886  							Permission:           "READ",
  1887  							IsIfaAudience:        false,
  1888  							Activated:            1610068515,
  1889  							InactivatedTimestamp: 1625620516,
  1890  						},
  1891  					},
  1892  					HasNextPage:                      false,
  1893  					TotalCount:                       2,
  1894  					ReadWriteAudienceGroupTotalCount: 0,
  1895  					Page:                             40,
  1896  					Size:                             1,
  1897  				},
  1898  			},
  1899  		},
  1900  		{
  1901  			Label:                        "List Audience no data",
  1902  			Page:                         1,
  1903  			Description:                  "audienceGroupName",
  1904  			IncludesExternalPublicGroups: false,
  1905  			Size:                         40,
  1906  			CreateRoute:                  "OA_MANAGER",
  1907  			RequestID:                    "12222",
  1908  			ResponseCode:                 http.StatusOK,
  1909  			Response:                     []byte(`{"page":40,"size":1}`),
  1910  			Want: want{
  1911  				URLPath:     APIAudienceGroupList,
  1912  				RequestBody: RequestBody{},
  1913  				RequestParameter: RequestParameter{
  1914  					Page:                         1,
  1915  					Description:                  "audienceGroupName",
  1916  					IncludesExternalPublicGroups: false,
  1917  					Size:                         40,
  1918  					CreateRoute:                  "OA_MANAGER",
  1919  				},
  1920  				Response: &ListAudienceGroupResponse{
  1921  					RequestID:                        "12222",
  1922  					HasNextPage:                      false,
  1923  					TotalCount:                       0,
  1924  					ReadWriteAudienceGroupTotalCount: 0,
  1925  					Page:                             40,
  1926  					Size:                             1,
  1927  				},
  1928  			},
  1929  		},
  1930  	}
  1931  
  1932  	var currentTestIdx int
  1933  	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  1934  		defer r.Body.Close()
  1935  		tc := testCases[currentTestIdx]
  1936  		if r.Method != http.MethodGet {
  1937  			t.Errorf("Method %s; want %s", r.Method, http.MethodGet)
  1938  		}
  1939  		if r.URL.Path != tc.Want.URLPath {
  1940  			t.Errorf("URLPath %s; want %s", r.URL.Path, tc.Want.URLPath)
  1941  		}
  1942  
  1943  		if v := r.URL.Query().Get("page"); v != "" {
  1944  			page, err := strconv.ParseInt(v, 10, 64)
  1945  			if err != nil {
  1946  				t.Fatal(err)
  1947  			}
  1948  			if int(page) != tc.Want.RequestParameter.Page {
  1949  				t.Errorf("Request Page %v; want %v", page, tc.Want.RequestParameter.Page)
  1950  			}
  1951  		}
  1952  		if v := r.URL.Query().Get("size"); v != "" {
  1953  			size, err := strconv.ParseInt(v, 10, 64)
  1954  			if err != nil {
  1955  				t.Fatal(err)
  1956  			}
  1957  			if int(size) != tc.Want.RequestParameter.Size {
  1958  				t.Errorf("Request Size %v; want %v", size, tc.Want.RequestParameter.Size)
  1959  			}
  1960  		}
  1961  		if v := r.URL.Query().Get("description"); v != "" {
  1962  			if v != tc.Want.RequestParameter.Description {
  1963  				t.Errorf("Request Description %v; want %v", v, tc.Want.RequestParameter.Description)
  1964  			}
  1965  		}
  1966  		if v := r.URL.Query().Get("status"); v != "" {
  1967  			if v != tc.Want.RequestParameter.Status.String() {
  1968  				t.Errorf("Request Status %v; want %v", v, tc.Want.RequestParameter.Status)
  1969  			}
  1970  		}
  1971  		if v := r.URL.Query().Get("includesExternalPublicGroups"); v != "" {
  1972  			includesExternalPublicGroups, err := strconv.ParseBool(v)
  1973  			if err != nil {
  1974  				t.Fatal(err)
  1975  			}
  1976  			if includesExternalPublicGroups != tc.Want.RequestParameter.IncludesExternalPublicGroups {
  1977  				t.Errorf("Request IncludesExternalPublicGroups %v; want %v", v, tc.Want.RequestParameter.IncludesExternalPublicGroups)
  1978  			}
  1979  		}
  1980  		if v := r.URL.Query().Get("createRoute"); v != "" {
  1981  			if v != tc.Want.RequestParameter.CreateRoute {
  1982  				t.Errorf("Request CreateRoute %v; want %v", v, tc.Want.RequestParameter.CreateRoute)
  1983  			}
  1984  		}
  1985  
  1986  		w.Header().Set("X-Line-Request-Id", tc.RequestID)
  1987  		if tc.AcceptedRequestID != "" {
  1988  			w.Header().Set("X-Line-Accepted-Request-Id", tc.AcceptedRequestID)
  1989  		}
  1990  		w.WriteHeader(tc.ResponseCode)
  1991  		w.Write(tc.Response)
  1992  	}))
  1993  	defer server.Close()
  1994  
  1995  	dataServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  1996  		defer r.Body.Close()
  1997  		t.Error("Unexpected data API call")
  1998  		w.WriteHeader(http.StatusNotFound)
  1999  		w.Write([]byte(`{"message":"Not found"}`))
  2000  	}))
  2001  	defer dataServer.Close()
  2002  
  2003  	client, err := mockClient(server, dataServer)
  2004  	if err != nil {
  2005  		t.Fatal(err)
  2006  	}
  2007  
  2008  	var res *ListAudienceGroupResponse
  2009  	for i, tc := range testCases {
  2010  		currentTestIdx = i
  2011  		t.Run(strconv.Itoa(i)+"/"+tc.Label, func(t *testing.T) {
  2012  			var options []IListAudienceGroupOption
  2013  			if tc.Description != "" {
  2014  				options = append(options, WithListAudienceGroupCallDescription(tc.Description))
  2015  			}
  2016  			if tc.Status != "" {
  2017  				options = append(options, WithListAudienceGroupCallStatus(tc.Status))
  2018  			}
  2019  			if !tc.IncludesExternalPublicGroups {
  2020  				options = append(options, WithListAudienceGroupCallIncludesExternalPublicGroups(tc.IncludesExternalPublicGroups))
  2021  			}
  2022  			if tc.Size > 0 {
  2023  				options = append(options, WithListAudienceGroupCallSize(tc.Size))
  2024  			}
  2025  			if tc.CreateRoute != "" {
  2026  				options = append(options, WithListAudienceGroupCallCreateRoute(tc.CreateRoute))
  2027  			}
  2028  
  2029  			timeoutCtx, cancelFn := context.WithTimeout(context.Background(), 1*time.Second)
  2030  			defer cancelFn()
  2031  			res, err = client.ListAudienceGroup(tc.Page, options...).WithContext(timeoutCtx).Do()
  2032  			if tc.Want.Error != nil {
  2033  				if !reflect.DeepEqual(err, tc.Want.Error) {
  2034  					t.Errorf("Error %v; want %v", err, tc.Want.Error)
  2035  				}
  2036  			} else {
  2037  				if err != nil {
  2038  					t.Error(err)
  2039  				}
  2040  			}
  2041  			if tc.Want.Response != nil {
  2042  				if !reflect.DeepEqual(res, tc.Want.Response) {
  2043  					t.Errorf("Response %v; want %v", res, tc.Want.Response)
  2044  				}
  2045  			}
  2046  		})
  2047  	}
  2048  }
  2049  
  2050  // TestGetAudienceGroupAuthorityLevel tests GetAudienceGroupAuthorityLevel
  2051  func TestGetAudienceGroupAuthorityLevel(t *testing.T) {
  2052  	type RequestBody struct {
  2053  	}
  2054  	type want struct {
  2055  		URLPath     string
  2056  		RequestBody RequestBody
  2057  		Response    *GetAudienceGroupAuthorityLevelResponse
  2058  		Error       error
  2059  	}
  2060  	testCases := []struct {
  2061  		Label             string
  2062  		RequestID         string
  2063  		AcceptedRequestID string
  2064  		ResponseCode      int
  2065  		Response          []byte
  2066  		Want              want
  2067  	}{
  2068  		{
  2069  			Label:        "Get Audience AuthorityLevel Fail",
  2070  			RequestID:    "12222",
  2071  			ResponseCode: http.StatusBadRequest,
  2072  			Response:     []byte(``),
  2073  			Want: want{
  2074  				URLPath:     APIAudienceGroupAuthorityLevel,
  2075  				RequestBody: RequestBody{},
  2076  				Error: &APIError{
  2077  					Code: http.StatusBadRequest,
  2078  				},
  2079  			},
  2080  		},
  2081  		{
  2082  			Label:        "Get Audience AuthorityLevel",
  2083  			RequestID:    "12222",
  2084  			ResponseCode: http.StatusOK,
  2085  			Response:     []byte(`{"authorityLevel":"PUBLIC"}`),
  2086  			Want: want{
  2087  				URLPath:     APIAudienceGroupAuthorityLevel,
  2088  				RequestBody: RequestBody{},
  2089  				Response: &GetAudienceGroupAuthorityLevelResponse{
  2090  					RequestID:      "12222",
  2091  					AuthorityLevel: PUBLIC,
  2092  				},
  2093  			},
  2094  		},
  2095  	}
  2096  
  2097  	var currentTestIdx int
  2098  	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  2099  		defer r.Body.Close()
  2100  		tc := testCases[currentTestIdx]
  2101  		if r.Method != http.MethodGet {
  2102  			t.Errorf("Method %s; want %s", r.Method, http.MethodGet)
  2103  		}
  2104  		if r.URL.Path != tc.Want.URLPath {
  2105  			t.Errorf("URLPath %s; want %s", r.URL.Path, tc.Want.URLPath)
  2106  		}
  2107  		w.Header().Set("X-Line-Request-Id", tc.RequestID)
  2108  		if tc.AcceptedRequestID != "" {
  2109  			w.Header().Set("X-Line-Accepted-Request-Id", tc.AcceptedRequestID)
  2110  		}
  2111  		w.WriteHeader(tc.ResponseCode)
  2112  		w.Write(tc.Response)
  2113  	}))
  2114  	defer server.Close()
  2115  
  2116  	dataServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  2117  		defer r.Body.Close()
  2118  		t.Error("Unexpected data API call")
  2119  		w.WriteHeader(http.StatusNotFound)
  2120  		w.Write([]byte(`{"message":"Not found"}`))
  2121  	}))
  2122  	defer dataServer.Close()
  2123  
  2124  	client, err := mockClient(server, dataServer)
  2125  	if err != nil {
  2126  		t.Fatal(err)
  2127  	}
  2128  
  2129  	var res *GetAudienceGroupAuthorityLevelResponse
  2130  	for i, tc := range testCases {
  2131  		currentTestIdx = i
  2132  		t.Run(strconv.Itoa(i)+"/"+tc.Label, func(t *testing.T) {
  2133  			timeoutCtx, cancelFn := context.WithTimeout(context.Background(), 1*time.Second)
  2134  			defer cancelFn()
  2135  			res, err = client.GetAudienceGroupAuthorityLevel().WithContext(timeoutCtx).Do()
  2136  			if tc.Want.Error != nil {
  2137  				log.Println(err)
  2138  				log.Println(tc.Want.Error)
  2139  				if !reflect.DeepEqual(err, tc.Want.Error) {
  2140  					t.Errorf("Error %v; want %v", err, tc.Want.Error)
  2141  				}
  2142  			} else {
  2143  				if err != nil {
  2144  					t.Error(err)
  2145  				}
  2146  			}
  2147  			if tc.Want.Response != nil {
  2148  				if !reflect.DeepEqual(res, tc.Want.Response) {
  2149  					t.Errorf("Response %v; want %v", res, tc.Want.Response)
  2150  				}
  2151  			}
  2152  		})
  2153  	}
  2154  }
  2155  
  2156  // TestChangeAudienceGroupAuthorityLevel tests ChangeAudienceGroupAuthorityLevel
  2157  func TestChangeAudienceGroupAuthorityLevel(t *testing.T) {
  2158  	type RequestBody struct {
  2159  		AuthorityLevel AudienceAuthorityLevelType
  2160  	}
  2161  	type want struct {
  2162  		URLPath     string
  2163  		RequestBody RequestBody
  2164  		Response    *BasicResponse
  2165  		Error       error
  2166  	}
  2167  	testCases := []struct {
  2168  		Label             string
  2169  		AuthorityLevel    AudienceAuthorityLevelType
  2170  		RequestID         string
  2171  		AcceptedRequestID string
  2172  		ResponseCode      int
  2173  		Response          []byte
  2174  		Want              want
  2175  	}{
  2176  		{
  2177  			Label:          "Change Audience AuthorityLevel Fail",
  2178  			AuthorityLevel: PUBLIC,
  2179  			RequestID:      "12222",
  2180  			ResponseCode:   http.StatusBadRequest,
  2181  			Response:       []byte(``),
  2182  			Want: want{
  2183  				URLPath: APIAudienceGroupAuthorityLevel,
  2184  				RequestBody: RequestBody{
  2185  					AuthorityLevel: PUBLIC,
  2186  				},
  2187  				Error: &APIError{
  2188  					Code: http.StatusBadRequest,
  2189  				},
  2190  			},
  2191  		},
  2192  		{
  2193  			Label:          "Change Audience AuthorityLevel ",
  2194  			AuthorityLevel: PUBLIC,
  2195  			RequestID:      "12222",
  2196  			ResponseCode:   http.StatusOK,
  2197  			Response:       []byte(``),
  2198  			Want: want{
  2199  				URLPath: APIAudienceGroupAuthorityLevel,
  2200  				RequestBody: RequestBody{
  2201  					AuthorityLevel: PUBLIC,
  2202  				},
  2203  				Response: &BasicResponse{
  2204  					RequestID: "12222",
  2205  				},
  2206  			},
  2207  		},
  2208  	}
  2209  
  2210  	var currentTestIdx int
  2211  	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  2212  		defer r.Body.Close()
  2213  		tc := testCases[currentTestIdx]
  2214  		if r.Method != http.MethodPut {
  2215  			t.Errorf("Method %s; want %s", r.Method, http.MethodPut)
  2216  		}
  2217  		if r.URL.Path != tc.Want.URLPath {
  2218  			t.Errorf("URLPath %s; want %s", r.URL.Path, tc.Want.URLPath)
  2219  		}
  2220  
  2221  		var result RequestBody
  2222  		if err := json.NewDecoder(r.Body).Decode(&result); err != nil {
  2223  			t.Fatal(err)
  2224  		}
  2225  		if !reflect.DeepEqual(result, tc.Want.RequestBody) {
  2226  			t.Errorf("Request %v; want %v", result, tc.Want.RequestBody)
  2227  		}
  2228  
  2229  		w.Header().Set("X-Line-Request-Id", tc.RequestID)
  2230  		if tc.AcceptedRequestID != "" {
  2231  			w.Header().Set("X-Line-Accepted-Request-Id", tc.AcceptedRequestID)
  2232  		}
  2233  		w.WriteHeader(tc.ResponseCode)
  2234  		w.Write(tc.Response)
  2235  	}))
  2236  	defer server.Close()
  2237  
  2238  	dataServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  2239  		defer r.Body.Close()
  2240  		t.Error("Unexpected data API call")
  2241  		w.WriteHeader(http.StatusNotFound)
  2242  		w.Write([]byte(`{"message":"Not found"}`))
  2243  	}))
  2244  	defer dataServer.Close()
  2245  
  2246  	client, err := mockClient(server, dataServer)
  2247  	if err != nil {
  2248  		t.Fatal(err)
  2249  	}
  2250  
  2251  	var res *BasicResponse
  2252  	for i, tc := range testCases {
  2253  		currentTestIdx = i
  2254  		t.Run(strconv.Itoa(i)+"/"+tc.Label, func(t *testing.T) {
  2255  			timeoutCtx, cancelFn := context.WithTimeout(context.Background(), 1*time.Second)
  2256  			defer cancelFn()
  2257  			res, err = client.ChangeAudienceGroupAuthorityLevel(tc.AuthorityLevel).WithContext(timeoutCtx).Do()
  2258  			if tc.Want.Error != nil {
  2259  				log.Println(err)
  2260  				log.Println(tc.Want.Error)
  2261  				if !reflect.DeepEqual(err, tc.Want.Error) {
  2262  					t.Errorf("Error %v; want %v", err, tc.Want.Error)
  2263  				}
  2264  			} else {
  2265  				if err != nil {
  2266  					t.Error(err)
  2267  				}
  2268  			}
  2269  			if tc.Want.Response != nil {
  2270  				if !reflect.DeepEqual(res, tc.Want.Response) {
  2271  					t.Errorf("Response %v; want %v", res, tc.Want.Response)
  2272  				}
  2273  			}
  2274  		})
  2275  	}
  2276  }