github.com/akamai/AkamaiOPEN-edgegrid-golang/v4@v4.1.0/pkg/dns/zonebulk_test.go (about)

     1  package dns
     2  
     3  import (
     4  	"context"
     5  	"errors"
     6  	"net/http"
     7  	"net/http/httptest"
     8  	"testing"
     9  
    10  	"github.com/stretchr/testify/assert"
    11  	"github.com/stretchr/testify/require"
    12  )
    13  
    14  func TestDns_GetBulkZoneCreateStatus(t *testing.T) {
    15  	tests := map[string]struct {
    16  		requestid        string
    17  		responseStatus   int
    18  		responseBody     string
    19  		expectedPath     string
    20  		expectedResponse *BulkStatusResponse
    21  		withError        error
    22  	}{
    23  		"200 OK": {
    24  			requestid:      "15bc138f-8d82-451b-80b7-a56b88ffc474",
    25  			responseStatus: http.StatusOK,
    26  			responseBody: `
    27    {
    28      "requestId": "15bc138f-8d82-451b-80b7-a56b88ffc474",
    29      "zonesSubmitted": 2,
    30      "successCount": 0,
    31      "failureCount": 2,
    32      "isComplete": true,
    33      "expirationDate": "2020-10-28T17:10:04.515792Z"
    34    }`,
    35  			expectedPath: "/config-dns/v2/zones/create-requests/15bc138f-8d82-451b-80b7-a56b88ffc474",
    36  			expectedResponse: &BulkStatusResponse{
    37  				RequestId:      "15bc138f-8d82-451b-80b7-a56b88ffc474",
    38  				ZonesSubmitted: 2,
    39  				SuccessCount:   0,
    40  				FailureCount:   2,
    41  				IsComplete:     true,
    42  				ExpirationDate: "2020-10-28T17:10:04.515792Z",
    43  			},
    44  		},
    45  		"500 internal server error": {
    46  			requestid:      "15bc138f-8d82-451b-80b7-a56b88ffc474",
    47  			responseStatus: http.StatusInternalServerError,
    48  			responseBody: `
    49  {
    50  	"type": "internal_error",
    51      "title": "Internal Server Error",
    52      "detail": "Error fetching authorities",
    53      "status": 500
    54  }`,
    55  			expectedPath: "/config-dns/v2/zones/create-requests/15bc138f-8d82-451b-80b7-a56b88ffc474",
    56  			withError: &Error{
    57  				Type:       "internal_error",
    58  				Title:      "Internal Server Error",
    59  				Detail:     "Error fetching authorities",
    60  				StatusCode: http.StatusInternalServerError,
    61  			},
    62  		},
    63  	}
    64  
    65  	for name, test := range tests {
    66  		t.Run(name, func(t *testing.T) {
    67  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    68  				//assert.Equal(t, test.expectedPath, r.URL.String())
    69  				assert.Equal(t, http.MethodGet, r.Method)
    70  				w.WriteHeader(test.responseStatus)
    71  				_, err := w.Write([]byte(test.responseBody))
    72  				assert.NoError(t, err)
    73  			}))
    74  			client := mockAPIClient(t, mockServer)
    75  			result, err := client.GetBulkZoneCreateStatus(context.Background(), test.requestid)
    76  			if test.withError != nil {
    77  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
    78  				return
    79  			}
    80  			require.NoError(t, err)
    81  			assert.Equal(t, test.expectedResponse, result)
    82  		})
    83  	}
    84  }
    85  
    86  func TestDns_GetBulkZoneCreateResult(t *testing.T) {
    87  	tests := map[string]struct {
    88  		requestid        string
    89  		responseStatus   int
    90  		responseBody     string
    91  		expectedPath     string
    92  		expectedResponse *BulkCreateResultResponse
    93  		withError        error
    94  	}{
    95  		"200 OK": {
    96  			requestid:      "15bc138f-8d82-451b-80b7-a56b88ffc474",
    97  			responseStatus: http.StatusOK,
    98  			responseBody: `
    99    {
   100      "requestId": "15bc138f-8d82-451b-80b7-a56b88ffc474",
   101      "successfullyCreatedZones": [],
   102      "failedZones": [
   103        {
   104          "zone": "one.testbulk.net",
   105          "failureReason": "ZONE_ALREADY_EXISTS"
   106        }
   107      ]
   108    }`,
   109  			expectedPath: "/config-dns/v2/zones/create-requests/15bc138f-8d82-451b-80b7-a56b88ffc474/result",
   110  			expectedResponse: &BulkCreateResultResponse{
   111  				RequestId:                "15bc138f-8d82-451b-80b7-a56b88ffc474",
   112  				SuccessfullyCreatedZones: make([]string, 0),
   113  				FailedZones: []*BulkFailedZone{
   114  					{
   115  						Zone:          "one.testbulk.net",
   116  						FailureReason: "ZONE_ALREADY_EXISTS",
   117  					},
   118  				},
   119  			},
   120  		},
   121  		"500 internal server error": {
   122  			requestid:      "15bc138f-8d82-451b-80b7-a56b88ffc474",
   123  			responseStatus: http.StatusInternalServerError,
   124  			responseBody: `
   125  {
   126          "type": "internal_error",
   127      "title": "Internal Server Error",
   128      "detail": "Error fetching authorities",
   129      "status": 500
   130  }`,
   131  			expectedPath: "/config-dns/v2/zones/create-requests/15bc138f-8d82-451b-80b7-a56b88ffc474/result",
   132  			withError: &Error{
   133  				Type:       "internal_error",
   134  				Title:      "Internal Server Error",
   135  				Detail:     "Error fetching authorities",
   136  				StatusCode: http.StatusInternalServerError,
   137  			},
   138  		},
   139  	}
   140  
   141  	for name, test := range tests {
   142  		t.Run(name, func(t *testing.T) {
   143  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   144  				//assert.Equal(t, test.expectedPath, r.URL.String())
   145  				assert.Equal(t, http.MethodGet, r.Method)
   146  				w.WriteHeader(test.responseStatus)
   147  				_, err := w.Write([]byte(test.responseBody))
   148  				assert.NoError(t, err)
   149  			}))
   150  			client := mockAPIClient(t, mockServer)
   151  			result, err := client.GetBulkZoneCreateResult(context.Background(), test.requestid)
   152  			if test.withError != nil {
   153  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   154  				return
   155  			}
   156  			require.NoError(t, err)
   157  			assert.Equal(t, test.expectedResponse, result)
   158  		})
   159  	}
   160  }
   161  
   162  func TestDns_CreateBulkZones(t *testing.T) {
   163  	tests := map[string]struct {
   164  		zones            BulkZonesCreate
   165  		query            ZoneQueryString
   166  		responseStatus   int
   167  		responseBody     string
   168  		expectedResponse *BulkZonesResponse
   169  		expectedPath     string
   170  		withError        error
   171  	}{
   172  		"200 Created": {
   173  			zones: BulkZonesCreate{
   174  				Zones: []*ZoneCreate{
   175  					{
   176  						Zone:    "one.testbulk.net",
   177  						Type:    "secondary",
   178  						Comment: "testing bulk operations",
   179  						Masters: []string{"1.2.3.4", "1.2.3.10"},
   180  					},
   181  					{
   182  						Zone:    "two.testbulk.net",
   183  						Type:    "secondary",
   184  						Comment: "testing bulk operations",
   185  						Masters: []string{"1.2.3.6", "1.2.3.70"},
   186  					},
   187  				},
   188  			},
   189  			query:          ZoneQueryString{Contract: "1-2ABCDE", Group: "testgroup"},
   190  			responseStatus: http.StatusCreated,
   191  			responseBody: `
   192  {
   193      "requestId": "93e97a28-4e05-45f4-8b9a-cebd71155949",
   194      "expirationDate": "2020-10-28T19:50:36.272668Z"
   195  }`,
   196  			expectedResponse: &BulkZonesResponse{
   197  				RequestId:      "93e97a28-4e05-45f4-8b9a-cebd71155949",
   198  				ExpirationDate: "2020-10-28T19:50:36.272668Z",
   199  			},
   200  			expectedPath: "/config-dns/v2/zones/create-requests?contractId=1-2ABCDE&gid=testgroup",
   201  		},
   202  		"500 internal server error": {
   203  			zones: BulkZonesCreate{
   204  				Zones: []*ZoneCreate{
   205  					{
   206  						Zone:    "one.testbulk.net",
   207  						Type:    "secondary",
   208  						Comment: "testing bulk operations",
   209  						Masters: []string{"1.2.3.4", "1.2.3.10"},
   210  					},
   211  					{
   212  						Zone:    "two.testbulk.net",
   213  						Type:    "secondary",
   214  						Comment: "testing bulk operations",
   215  						Masters: []string{"1.2.3.6", "1.2.3.70"},
   216  					},
   217  				},
   218  			},
   219  			query:          ZoneQueryString{Contract: "1-2ABCDE", Group: "testgroup"},
   220  			responseStatus: http.StatusInternalServerError,
   221  			responseBody: `
   222  {
   223  	"type": "internal_error",
   224      "title": "Internal Server Error",
   225      "detail": "Error creating zone",
   226      "status": 500
   227  }`,
   228  			expectedPath: "/config-dns/v2/zones/create-requests?contractId=1-2ABCDE&gid=testgroup",
   229  			withError: &Error{
   230  				Type:       "internal_error",
   231  				Title:      "Internal Server Error",
   232  				Detail:     "Error creating zone",
   233  				StatusCode: http.StatusInternalServerError,
   234  			},
   235  		},
   236  	}
   237  
   238  	for name, test := range tests {
   239  		t.Run(name, func(t *testing.T) {
   240  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   241  				assert.Equal(t, http.MethodPost, r.Method)
   242  				w.WriteHeader(test.responseStatus)
   243  				if len(test.responseBody) > 0 {
   244  					_, err := w.Write([]byte(test.responseBody))
   245  					assert.NoError(t, err)
   246  				}
   247  			}))
   248  			client := mockAPIClient(t, mockServer)
   249  			result, err := client.CreateBulkZones(context.Background(), &test.zones, test.query)
   250  			if test.withError != nil {
   251  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   252  				return
   253  			}
   254  			require.NoError(t, err)
   255  			assert.Equal(t, test.expectedResponse, result)
   256  		})
   257  	}
   258  }
   259  
   260  // Bulk Delete tests
   261  func TestDns_GetBulkZoneDeleteStatus(t *testing.T) {
   262  	tests := map[string]struct {
   263  		requestid        string
   264  		responseStatus   int
   265  		responseBody     string
   266  		expectedPath     string
   267  		expectedResponse *BulkStatusResponse
   268  		withError        error
   269  	}{
   270  		"200 OK": {
   271  			requestid:      "15bc138f-8d82-451b-80b7-a56b88ffc474",
   272  			responseStatus: http.StatusOK,
   273  			responseBody: `
   274    {
   275      "requestId": "15bc138f-8d82-451b-80b7-a56b88ffc474",
   276      "zonesSubmitted": 2,
   277      "successCount": 0,
   278      "failureCount": 2,
   279      "isComplete": true,
   280      "expirationDate": "2020-10-28T17:10:04.515792Z"
   281    }`,
   282  			expectedPath: "/config-dns/v2/zones/delete-requests/15bc138f-8d82-451b-80b7-a56b88ffc474",
   283  			expectedResponse: &BulkStatusResponse{
   284  				RequestId:      "15bc138f-8d82-451b-80b7-a56b88ffc474",
   285  				ZonesSubmitted: 2,
   286  				SuccessCount:   0,
   287  				FailureCount:   2,
   288  				IsComplete:     true,
   289  				ExpirationDate: "2020-10-28T17:10:04.515792Z",
   290  			},
   291  		},
   292  		"500 internal server error": {
   293  			requestid:      "15bc138f-8d82-451b-80b7-a56b88ffc474",
   294  			responseStatus: http.StatusInternalServerError,
   295  			responseBody: `
   296  {
   297          "type": "internal_error",
   298      "title": "Internal Server Error",
   299      "detail": "Error fetching authorities",
   300      "status": 500
   301  }`,
   302  			expectedPath: "/config-dns/v2/zones/delete-requests/15bc138f-8d82-451b-80b7-a56b88ffc474",
   303  			withError: &Error{
   304  				Type:       "internal_error",
   305  				Title:      "Internal Server Error",
   306  				Detail:     "Error fetching authorities",
   307  				StatusCode: http.StatusInternalServerError,
   308  			},
   309  		},
   310  	}
   311  
   312  	for name, test := range tests {
   313  		t.Run(name, func(t *testing.T) {
   314  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   315  				//assert.Equal(t, test.expectedPath, r.URL.String())
   316  				assert.Equal(t, http.MethodGet, r.Method)
   317  				w.WriteHeader(test.responseStatus)
   318  				_, err := w.Write([]byte(test.responseBody))
   319  				assert.NoError(t, err)
   320  			}))
   321  			client := mockAPIClient(t, mockServer)
   322  			result, err := client.GetBulkZoneDeleteStatus(context.Background(), test.requestid)
   323  			if test.withError != nil {
   324  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   325  				return
   326  			}
   327  			require.NoError(t, err)
   328  			assert.Equal(t, test.expectedResponse, result)
   329  		})
   330  	}
   331  }
   332  
   333  func TestDns_GetBulkZoneDeleteResult(t *testing.T) {
   334  	tests := map[string]struct {
   335  		requestid        string
   336  		responseStatus   int
   337  		responseBody     string
   338  		expectedPath     string
   339  		expectedResponse *BulkDeleteResultResponse
   340  		withError        error
   341  	}{
   342  		"200 OK": {
   343  			requestid:      "15bc138f-8d82-451b-80b7-a56b88ffc474",
   344  			responseStatus: http.StatusOK,
   345  			responseBody: `
   346    {
   347      "requestId": "15bc138f-8d82-451b-80b7-a56b88ffc474",
   348      "successfullyDeletedZones": [],
   349      "failedZones": [
   350        {
   351          "zone": "one.testbulk.net",
   352          "failureReason": "ZONE_ALREADY_EXISTS"
   353        }
   354      ]
   355    }`,
   356  			expectedPath: "/config-dns/v2/zones/delete-requests/15bc138f-8d82-451b-80b7-a56b88ffc474/result",
   357  			expectedResponse: &BulkDeleteResultResponse{
   358  				RequestId:                "15bc138f-8d82-451b-80b7-a56b88ffc474",
   359  				SuccessfullyDeletedZones: make([]string, 0),
   360  				FailedZones: []*BulkFailedZone{
   361  					{
   362  						Zone:          "one.testbulk.net",
   363  						FailureReason: "ZONE_ALREADY_EXISTS",
   364  					},
   365  				},
   366  			},
   367  		},
   368  		"500 internal server error": {
   369  			requestid:      "15bc138f-8d82-451b-80b7-a56b88ffc474",
   370  			responseStatus: http.StatusInternalServerError,
   371  			responseBody: `
   372  {
   373          "type": "internal_error",
   374      "title": "Internal Server Error",
   375      "detail": "Error fetching authorities",
   376      "status": 500
   377  }`,
   378  			expectedPath: "/config-dns/v2/zones/create-requests/15bc138f-8d82-451b-80b7-a56b88ffc474/result",
   379  			withError: &Error{
   380  				Type:       "internal_error",
   381  				Title:      "Internal Server Error",
   382  				Detail:     "Error fetching authorities",
   383  				StatusCode: http.StatusInternalServerError,
   384  			},
   385  		},
   386  	}
   387  
   388  	for name, test := range tests {
   389  		t.Run(name, func(t *testing.T) {
   390  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   391  				//assert.Equal(t, test.expectedPath, r.URL.String())
   392  				assert.Equal(t, http.MethodGet, r.Method)
   393  				w.WriteHeader(test.responseStatus)
   394  				_, err := w.Write([]byte(test.responseBody))
   395  				assert.NoError(t, err)
   396  			}))
   397  			client := mockAPIClient(t, mockServer)
   398  			result, err := client.GetBulkZoneDeleteResult(context.Background(), test.requestid)
   399  			if test.withError != nil {
   400  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   401  				return
   402  			}
   403  			require.NoError(t, err)
   404  			assert.Equal(t, test.expectedResponse, result)
   405  		})
   406  	}
   407  }
   408  
   409  func TestDns_DeleteBulkZones(t *testing.T) {
   410  	tests := map[string]struct {
   411  		zoneslist        ZoneNameListResponse
   412  		bypassSafety     bool
   413  		responseStatus   int
   414  		responseBody     string
   415  		expectedResponse *BulkZonesResponse
   416  		expectedPath     string
   417  		withError        error
   418  	}{
   419  		"200 Created": {
   420  			zoneslist: ZoneNameListResponse{
   421  				Zones: []string{"one.testbulk.net", "two.testbulk.net"},
   422  			},
   423  			bypassSafety:   true,
   424  			responseStatus: http.StatusCreated,
   425  			responseBody: `
   426  {
   427      "requestId": "93e97a28-4e05-45f4-8b9a-cebd71155949",
   428      "expirationDate": "2020-10-28T19:50:36.272668Z"
   429  }`,
   430  			expectedResponse: &BulkZonesResponse{
   431  				RequestId:      "93e97a28-4e05-45f4-8b9a-cebd71155949",
   432  				ExpirationDate: "2020-10-28T19:50:36.272668Z",
   433  			},
   434  			expectedPath: "/config-dns/v2/zones/delete-requests?bypassSafetyChecks=true",
   435  		},
   436  		"500 internal server error": {
   437  			zoneslist: ZoneNameListResponse{
   438  				Zones: []string{"one.testbulk.net", "two.testbulk.net"},
   439  			},
   440  			bypassSafety:   true,
   441  			responseStatus: http.StatusInternalServerError,
   442  			responseBody: `
   443  {
   444          "type": "internal_error",
   445      "title": "Internal Server Error",
   446      "detail": "Error creating zone",
   447      "status": 500
   448  }`,
   449  			expectedPath: "/config-dns/v2/zones/delete-requests?bypassSafetyChecks=true",
   450  			withError: &Error{
   451  				Type:       "internal_error",
   452  				Title:      "Internal Server Error",
   453  				Detail:     "Error creating zone",
   454  				StatusCode: http.StatusInternalServerError,
   455  			},
   456  		},
   457  	}
   458  
   459  	for name, test := range tests {
   460  		t.Run(name, func(t *testing.T) {
   461  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   462  				assert.Equal(t, http.MethodPost, r.Method)
   463  				w.WriteHeader(test.responseStatus)
   464  				if len(test.responseBody) > 0 {
   465  					_, err := w.Write([]byte(test.responseBody))
   466  					assert.NoError(t, err)
   467  				}
   468  			}))
   469  			client := mockAPIClient(t, mockServer)
   470  			result, err := client.DeleteBulkZones(context.Background(), &test.zoneslist, test.bypassSafety)
   471  			if test.withError != nil {
   472  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   473  				return
   474  			}
   475  			require.NoError(t, err)
   476  			assert.Equal(t, test.expectedResponse, result)
   477  		})
   478  	}
   479  }