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