github.com/PagerDuty/go-pagerduty@v1.8.0/service_test.go (about) 1 package pagerduty 2 3 import ( 4 "context" 5 "fmt" 6 "net/http" 7 "strconv" 8 "testing" 9 ) 10 11 // ListServices 12 func TestService_List(t *testing.T) { 13 setup() 14 defer teardown() 15 16 mux.HandleFunc("/services", func(w http.ResponseWriter, r *http.Request) { 17 testMethod(t, r, "GET") 18 _, _ = w.Write([]byte(`{"services": [{"id": "1"}]}`)) 19 }) 20 21 listObj := APIListObject{Limit: 0, Offset: 0, More: false, Total: 0} 22 client := defaultTestClient(server.URL, "foo") 23 opts := ListServiceOptions{ 24 Limit: listObj.Limit, 25 Offset: listObj.Offset, 26 TeamIDs: []string{}, 27 TimeZone: "foo", 28 SortBy: "bar", 29 Query: "baz", 30 Includes: []string{}, 31 } 32 res, err := client.ListServices(opts) 33 34 want := &ListServiceResponse{ 35 APIListObject: listObj, 36 Services: []Service{ 37 { 38 APIObject: APIObject{ 39 ID: "1", 40 }, 41 }, 42 }, 43 } 44 45 if err != nil { 46 t.Fatal(err) 47 } 48 testEqual(t, want, res) 49 } 50 51 // ListServices 52 func TestService_ListPaginated(t *testing.T) { 53 setup() 54 defer teardown() 55 56 mux.HandleFunc("/services", func(w http.ResponseWriter, r *http.Request) { 57 testMethod(t, r, "GET") 58 offsetStr := r.URL.Query()["offset"][0] 59 offset, _ := strconv.ParseInt(offsetStr, 10, 32) 60 61 var more string 62 if offset == 0 { 63 more = "true" 64 } else { 65 more = "false" 66 } 67 resp := fmt.Sprintf(`{"services": [{"id": "%d"}], 68 "More": %s, 69 "Offset": %d, 70 "Limit": 1}`, offset, more, offset) 71 _, _ = w.Write([]byte(resp)) 72 }) 73 74 listObj := APIListObject{Limit: 1, Offset: 0, More: false, Total: 0} 75 client := defaultTestClient(server.URL, "foo") 76 opts := ListServiceOptions{ 77 Limit: listObj.Limit, 78 Offset: listObj.Offset, 79 TeamIDs: []string{}, 80 TimeZone: "foo", 81 SortBy: "bar", 82 Query: "baz", 83 Includes: []string{}, 84 } 85 res, err := client.ListServicesPaginated(context.Background(), opts) 86 87 want := []Service{ 88 { 89 APIObject: APIObject{ 90 ID: "0", 91 }, 92 }, 93 { 94 APIObject: APIObject{ 95 ID: "1", 96 }, 97 }, 98 } 99 100 if err != nil { 101 t.Fatal(err) 102 } 103 testEqual(t, want, res) 104 } 105 106 // Get Service 107 func TestService_Get(t *testing.T) { 108 setup() 109 defer teardown() 110 111 mux.HandleFunc("/services/1", func(w http.ResponseWriter, r *http.Request) { 112 testMethod(t, r, "GET") 113 _, _ = w.Write([]byte(`{"service": {"id": "1","name":"foo"}}`)) 114 }) 115 116 client := defaultTestClient(server.URL, "foo") 117 118 id := "1" 119 opts := &GetServiceOptions{ 120 Includes: []string{}, 121 } 122 res, err := client.GetService(id, opts) 123 124 want := &Service{ 125 APIObject: APIObject{ 126 ID: "1", 127 }, 128 Name: "foo", 129 } 130 131 if err != nil { 132 t.Fatal(err) 133 } 134 testEqual(t, want, res) 135 } 136 137 // Create Service 138 func TestService_Create(t *testing.T) { 139 setup() 140 defer teardown() 141 142 mux.HandleFunc("/services", func(w http.ResponseWriter, r *http.Request) { 143 testMethod(t, r, "POST") 144 _, _ = w.Write([]byte(`{"service": {"id": "1","name":"foo"}}`)) 145 }) 146 147 client := defaultTestClient(server.URL, "foo") 148 input := Service{ 149 Name: "foo", 150 } 151 res, err := client.CreateService(input) 152 153 want := &Service{ 154 APIObject: APIObject{ 155 ID: "1", 156 }, 157 Name: "foo", 158 } 159 160 if err != nil { 161 t.Fatal(err) 162 } 163 testEqual(t, want, res) 164 } 165 166 // Create Service with AlertGroupingParameters of type time 167 func TestService_CreateWithAlertGroupParamsTime(t *testing.T) { 168 setup() 169 defer teardown() 170 171 mux.HandleFunc("/services", func(w http.ResponseWriter, r *http.Request) { 172 testMethod(t, r, "POST") 173 _, _ = w.Write([]byte(`{"service": {"id": "1","name":"foo"}}`)) 174 }) 175 176 client := defaultTestClient(server.URL, "foo") 177 input := Service{ 178 Name: "foo", 179 AlertGroupingParameters: &AlertGroupingParameters{ 180 Type: "time", 181 Config: &AlertGroupParamsConfig{ 182 Timeout: new(uint), 183 }, 184 }, 185 } 186 res, err := client.CreateService(input) 187 188 want := &Service{ 189 APIObject: APIObject{ 190 ID: "1", 191 }, 192 Name: "foo", 193 } 194 195 if err != nil { 196 t.Fatal(err) 197 } 198 testEqual(t, want, res) 199 } 200 201 // Create Service with AlertGroupingParameters of type content_based 202 func TestService_CreateWithAlertGroupParamsContentBased(t *testing.T) { 203 setup() 204 defer teardown() 205 206 mux.HandleFunc("/services", func(w http.ResponseWriter, r *http.Request) { 207 testMethod(t, r, "POST") 208 _, _ = w.Write([]byte(`{"service": {"id": "1","name":"foo"}}`)) 209 }) 210 211 client := defaultTestClient(server.URL, "foo") 212 input := Service{ 213 Name: "foo", 214 AlertGroupingParameters: &AlertGroupingParameters{ 215 Type: "content_based", 216 Config: &AlertGroupParamsConfig{ 217 Aggregate: "any", 218 Fields: []string{"source", "component"}, 219 }, 220 }, 221 } 222 res, err := client.CreateService(input) 223 224 want := &Service{ 225 APIObject: APIObject{ 226 ID: "1", 227 }, 228 Name: "foo", 229 } 230 231 if err != nil { 232 t.Fatal(err) 233 } 234 testEqual(t, want, res) 235 } 236 237 // Create Service with AlertGroupingParameters of type intelligent 238 func TestService_CreateWithAlertGroupParamsIntelligent(t *testing.T) { 239 setup() 240 defer teardown() 241 242 mux.HandleFunc("/services", func(w http.ResponseWriter, r *http.Request) { 243 testMethod(t, r, "POST") 244 _, _ = w.Write([]byte(`{"service": {"id": "1","name":"foo"}}`)) 245 }) 246 247 client := defaultTestClient(server.URL, "foo") 248 input := Service{ 249 Name: "foo", 250 AlertGroupingParameters: &AlertGroupingParameters{ 251 Type: "intelligent", 252 }, 253 } 254 res, err := client.CreateService(input) 255 256 want := &Service{ 257 APIObject: APIObject{ 258 ID: "1", 259 }, 260 Name: "foo", 261 } 262 263 if err != nil { 264 t.Fatal(err) 265 } 266 testEqual(t, want, res) 267 } 268 269 // Create Service with AutoPauseNotificationsParameters 270 func TestService_CreateWithAutoPauseNotificationsParameters(t *testing.T) { 271 setup() 272 defer teardown() 273 274 mux.HandleFunc("/services", func(w http.ResponseWriter, r *http.Request) { 275 testMethod(t, r, "POST") 276 _, _ = w.Write([]byte(`{"service": {"id": "1","name":"foo"}}`)) 277 }) 278 279 client := defaultTestClient(server.URL, "foo") 280 input := Service{ 281 Name: "foo", 282 AutoPauseNotificationsParameters: &AutoPauseNotificationsParameters{ 283 Enabled: true, 284 Timeout: 60, 285 }, 286 } 287 res, err := client.CreateService(input) 288 289 want := &Service{ 290 APIObject: APIObject{ 291 ID: "1", 292 }, 293 Name: "foo", 294 } 295 296 if err != nil { 297 t.Fatal(err) 298 } 299 testEqual(t, want, res) 300 } 301 302 // Update Service 303 func TestService_Update(t *testing.T) { 304 setup() 305 defer teardown() 306 307 mux.HandleFunc("/services/1", func(w http.ResponseWriter, r *http.Request) { 308 testMethod(t, r, "PUT") 309 _, _ = w.Write([]byte(`{"service": {"id": "1","name":"foo"}}`)) 310 }) 311 312 client := defaultTestClient(server.URL, "foo") 313 314 input := Service{ 315 APIObject: APIObject{ 316 ID: "1", 317 }, 318 Name: "foo", 319 } 320 res, err := client.UpdateService(input) 321 322 want := &Service{ 323 APIObject: APIObject{ 324 ID: "1", 325 }, 326 Name: "foo", 327 } 328 329 if err != nil { 330 t.Fatal(err) 331 } 332 testEqual(t, want, res) 333 } 334 335 // Delete Service 336 func TestService_Delete(t *testing.T) { 337 setup() 338 defer teardown() 339 340 mux.HandleFunc("/services/1", func(w http.ResponseWriter, r *http.Request) { 341 testMethod(t, r, "DELETE") 342 }) 343 344 client := defaultTestClient(server.URL, "foo") 345 id := "1" 346 err := client.DeleteService(id) 347 if err != nil { 348 t.Fatal(err) 349 } 350 } 351 352 // List Service Rules 353 func TestService_ListRules(t *testing.T) { 354 setup() 355 defer teardown() 356 357 mux.HandleFunc("/services/1/rules", func(w http.ResponseWriter, r *http.Request) { 358 testMethod(t, r, "GET") 359 _, _ = w.Write([]byte(`{"rules": [{"id": "1"}]}`)) 360 }) 361 362 client := defaultTestClient(server.URL, "foo") 363 364 serviceID := "1" 365 res, err := client.ListServiceRulesPaginated(context.Background(), serviceID) 366 if err != nil { 367 t.Fatal(err) 368 } 369 370 want := []ServiceRule{{ID: "1"}} 371 testEqual(t, want, res) 372 } 373 374 // Create Service Rule 375 func TestService_CreateServiceRule(t *testing.T) { 376 setup() 377 defer teardown() 378 379 mux.HandleFunc("/services/1/rules/", func(w http.ResponseWriter, r *http.Request) { 380 testMethod(t, r, "POST") 381 _, _ = w.Write([]byte(`{"rule": {"id": "1"}}`)) 382 }) 383 384 client := defaultTestClient(server.URL, "foo") 385 386 serviceID := "1" 387 rule := ServiceRule{} 388 389 res, err := client.CreateServiceRule(context.Background(), serviceID, rule) 390 if err != nil { 391 t.Fatal(err) 392 } 393 394 want := ServiceRule{ 395 ID: "1", 396 } 397 testEqual(t, want, res) 398 } 399 400 // Get Service Rule 401 func TestService_GetServiceRule(t *testing.T) { 402 setup() 403 defer teardown() 404 405 mux.HandleFunc("/services/1/rules/1", func(w http.ResponseWriter, r *http.Request) { 406 testMethod(t, r, "GET") 407 _, _ = w.Write([]byte(`{"rule": {"id": "1"}}`)) 408 }) 409 410 client := defaultTestClient(server.URL, "foo") 411 412 serviceID := "1" 413 ruleID := "1" 414 res, err := client.GetServiceRule(context.Background(), serviceID, ruleID) 415 if err != nil { 416 t.Fatal(err) 417 } 418 419 want := ServiceRule{ 420 ID: "1", 421 } 422 testEqual(t, want, res) 423 } 424 425 // Update Service Rule 426 func TestService_UpdateServiceRule(t *testing.T) { 427 setup() 428 defer teardown() 429 430 mux.HandleFunc("/services/1/rules/1", func(w http.ResponseWriter, r *http.Request) { 431 testMethod(t, r, "PUT") 432 _, _ = w.Write([]byte(`{"rule": {"id": "1"}}`)) 433 }) 434 435 client := defaultTestClient(server.URL, "foo") 436 437 serviceID := "1" 438 ruleID := "1" 439 rule := ServiceRule{} 440 441 res, err := client.UpdateServiceRule(context.Background(), serviceID, ruleID, rule) 442 if err != nil { 443 t.Fatal(err) 444 } 445 446 want := ServiceRule{ 447 ID: "1", 448 } 449 testEqual(t, want, res) 450 } 451 452 // Delete Service Rule 453 func TestService_DeleteServiceRule(t *testing.T) { 454 setup() 455 defer teardown() 456 457 mux.HandleFunc("/services/1/rules/1", func(w http.ResponseWriter, r *http.Request) { 458 testMethod(t, r, "DELETE") 459 }) 460 461 client := defaultTestClient(server.URL, "foo") 462 serviceID := "1" 463 ruleID := "1" 464 465 err := client.DeleteServiceRule(context.Background(), serviceID, ruleID) 466 if err != nil { 467 t.Fatal(err) 468 } 469 }