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