| OLD | NEW |
|---|
| (Empty) |
| 1 library googleapis_beta.taskqueue.v1beta2.test; | |
| 2 | |
| 3 import "dart:core" as core; | |
| 4 import "dart:collection" as collection; | |
| 5 import "dart:async" as async; | |
| 6 import "dart:convert" as convert; | |
| 7 | |
| 8 import 'package:http/http.dart' as http; | |
| 9 import 'package:http/testing.dart' as http_testing; | |
| 10 import 'package:unittest/unittest.dart' as unittest; | |
| 11 import 'package:googleapis_beta/common/common.dart' as common; | |
| 12 import 'package:googleapis_beta/src/common_internal.dart' as common_internal; | |
| 13 import '../common/common_internal_test.dart' as common_test; | |
| 14 | |
| 15 import 'package:googleapis_beta/taskqueue/v1beta2.dart' as api; | |
| 16 | |
| 17 | |
| 18 | |
| 19 core.int buildCounterTask = 0; | |
| 20 buildTask() { | |
| 21 var o = new api.Task(); | |
| 22 buildCounterTask++; | |
| 23 if (buildCounterTask < 3) { | |
| 24 o.enqueueTimestamp = "foo"; | |
| 25 o.id = "foo"; | |
| 26 o.kind = "foo"; | |
| 27 o.leaseTimestamp = "foo"; | |
| 28 o.payloadBase64 = "foo"; | |
| 29 o.queueName = "foo"; | |
| 30 o.retryCount = 42; | |
| 31 o.tag = "foo"; | |
| 32 } | |
| 33 buildCounterTask--; | |
| 34 return o; | |
| 35 } | |
| 36 | |
| 37 checkTask(api.Task o) { | |
| 38 buildCounterTask++; | |
| 39 if (buildCounterTask < 3) { | |
| 40 unittest.expect(o.enqueueTimestamp, unittest.equals('foo')); | |
| 41 unittest.expect(o.id, unittest.equals('foo')); | |
| 42 unittest.expect(o.kind, unittest.equals('foo')); | |
| 43 unittest.expect(o.leaseTimestamp, unittest.equals('foo')); | |
| 44 unittest.expect(o.payloadBase64, unittest.equals('foo')); | |
| 45 unittest.expect(o.queueName, unittest.equals('foo')); | |
| 46 unittest.expect(o.retryCount, unittest.equals(42)); | |
| 47 unittest.expect(o.tag, unittest.equals('foo')); | |
| 48 } | |
| 49 buildCounterTask--; | |
| 50 } | |
| 51 | |
| 52 buildUnnamed1077() { | |
| 53 var o = new core.List<core.String>(); | |
| 54 o.add("foo"); | |
| 55 o.add("foo"); | |
| 56 return o; | |
| 57 } | |
| 58 | |
| 59 checkUnnamed1077(core.List<core.String> o) { | |
| 60 unittest.expect(o, unittest.hasLength(2)); | |
| 61 unittest.expect(o[0], unittest.equals('foo')); | |
| 62 unittest.expect(o[1], unittest.equals('foo')); | |
| 63 } | |
| 64 | |
| 65 buildUnnamed1078() { | |
| 66 var o = new core.List<core.String>(); | |
| 67 o.add("foo"); | |
| 68 o.add("foo"); | |
| 69 return o; | |
| 70 } | |
| 71 | |
| 72 checkUnnamed1078(core.List<core.String> o) { | |
| 73 unittest.expect(o, unittest.hasLength(2)); | |
| 74 unittest.expect(o[0], unittest.equals('foo')); | |
| 75 unittest.expect(o[1], unittest.equals('foo')); | |
| 76 } | |
| 77 | |
| 78 buildUnnamed1079() { | |
| 79 var o = new core.List<core.String>(); | |
| 80 o.add("foo"); | |
| 81 o.add("foo"); | |
| 82 return o; | |
| 83 } | |
| 84 | |
| 85 checkUnnamed1079(core.List<core.String> o) { | |
| 86 unittest.expect(o, unittest.hasLength(2)); | |
| 87 unittest.expect(o[0], unittest.equals('foo')); | |
| 88 unittest.expect(o[1], unittest.equals('foo')); | |
| 89 } | |
| 90 | |
| 91 core.int buildCounterTaskQueueAcl = 0; | |
| 92 buildTaskQueueAcl() { | |
| 93 var o = new api.TaskQueueAcl(); | |
| 94 buildCounterTaskQueueAcl++; | |
| 95 if (buildCounterTaskQueueAcl < 3) { | |
| 96 o.adminEmails = buildUnnamed1077(); | |
| 97 o.consumerEmails = buildUnnamed1078(); | |
| 98 o.producerEmails = buildUnnamed1079(); | |
| 99 } | |
| 100 buildCounterTaskQueueAcl--; | |
| 101 return o; | |
| 102 } | |
| 103 | |
| 104 checkTaskQueueAcl(api.TaskQueueAcl o) { | |
| 105 buildCounterTaskQueueAcl++; | |
| 106 if (buildCounterTaskQueueAcl < 3) { | |
| 107 checkUnnamed1077(o.adminEmails); | |
| 108 checkUnnamed1078(o.consumerEmails); | |
| 109 checkUnnamed1079(o.producerEmails); | |
| 110 } | |
| 111 buildCounterTaskQueueAcl--; | |
| 112 } | |
| 113 | |
| 114 core.int buildCounterTaskQueueStats = 0; | |
| 115 buildTaskQueueStats() { | |
| 116 var o = new api.TaskQueueStats(); | |
| 117 buildCounterTaskQueueStats++; | |
| 118 if (buildCounterTaskQueueStats < 3) { | |
| 119 o.leasedLastHour = "foo"; | |
| 120 o.leasedLastMinute = "foo"; | |
| 121 o.oldestTask = "foo"; | |
| 122 o.totalTasks = 42; | |
| 123 } | |
| 124 buildCounterTaskQueueStats--; | |
| 125 return o; | |
| 126 } | |
| 127 | |
| 128 checkTaskQueueStats(api.TaskQueueStats o) { | |
| 129 buildCounterTaskQueueStats++; | |
| 130 if (buildCounterTaskQueueStats < 3) { | |
| 131 unittest.expect(o.leasedLastHour, unittest.equals('foo')); | |
| 132 unittest.expect(o.leasedLastMinute, unittest.equals('foo')); | |
| 133 unittest.expect(o.oldestTask, unittest.equals('foo')); | |
| 134 unittest.expect(o.totalTasks, unittest.equals(42)); | |
| 135 } | |
| 136 buildCounterTaskQueueStats--; | |
| 137 } | |
| 138 | |
| 139 core.int buildCounterTaskQueue = 0; | |
| 140 buildTaskQueue() { | |
| 141 var o = new api.TaskQueue(); | |
| 142 buildCounterTaskQueue++; | |
| 143 if (buildCounterTaskQueue < 3) { | |
| 144 o.acl = buildTaskQueueAcl(); | |
| 145 o.id = "foo"; | |
| 146 o.kind = "foo"; | |
| 147 o.maxLeases = 42; | |
| 148 o.stats = buildTaskQueueStats(); | |
| 149 } | |
| 150 buildCounterTaskQueue--; | |
| 151 return o; | |
| 152 } | |
| 153 | |
| 154 checkTaskQueue(api.TaskQueue o) { | |
| 155 buildCounterTaskQueue++; | |
| 156 if (buildCounterTaskQueue < 3) { | |
| 157 checkTaskQueueAcl(o.acl); | |
| 158 unittest.expect(o.id, unittest.equals('foo')); | |
| 159 unittest.expect(o.kind, unittest.equals('foo')); | |
| 160 unittest.expect(o.maxLeases, unittest.equals(42)); | |
| 161 checkTaskQueueStats(o.stats); | |
| 162 } | |
| 163 buildCounterTaskQueue--; | |
| 164 } | |
| 165 | |
| 166 buildUnnamed1080() { | |
| 167 var o = new core.List<api.Task>(); | |
| 168 o.add(buildTask()); | |
| 169 o.add(buildTask()); | |
| 170 return o; | |
| 171 } | |
| 172 | |
| 173 checkUnnamed1080(core.List<api.Task> o) { | |
| 174 unittest.expect(o, unittest.hasLength(2)); | |
| 175 checkTask(o[0]); | |
| 176 checkTask(o[1]); | |
| 177 } | |
| 178 | |
| 179 core.int buildCounterTasks = 0; | |
| 180 buildTasks() { | |
| 181 var o = new api.Tasks(); | |
| 182 buildCounterTasks++; | |
| 183 if (buildCounterTasks < 3) { | |
| 184 o.items = buildUnnamed1080(); | |
| 185 o.kind = "foo"; | |
| 186 } | |
| 187 buildCounterTasks--; | |
| 188 return o; | |
| 189 } | |
| 190 | |
| 191 checkTasks(api.Tasks o) { | |
| 192 buildCounterTasks++; | |
| 193 if (buildCounterTasks < 3) { | |
| 194 checkUnnamed1080(o.items); | |
| 195 unittest.expect(o.kind, unittest.equals('foo')); | |
| 196 } | |
| 197 buildCounterTasks--; | |
| 198 } | |
| 199 | |
| 200 buildUnnamed1081() { | |
| 201 var o = new core.List<api.Task>(); | |
| 202 o.add(buildTask()); | |
| 203 o.add(buildTask()); | |
| 204 return o; | |
| 205 } | |
| 206 | |
| 207 checkUnnamed1081(core.List<api.Task> o) { | |
| 208 unittest.expect(o, unittest.hasLength(2)); | |
| 209 checkTask(o[0]); | |
| 210 checkTask(o[1]); | |
| 211 } | |
| 212 | |
| 213 core.int buildCounterTasks2 = 0; | |
| 214 buildTasks2() { | |
| 215 var o = new api.Tasks2(); | |
| 216 buildCounterTasks2++; | |
| 217 if (buildCounterTasks2 < 3) { | |
| 218 o.items = buildUnnamed1081(); | |
| 219 o.kind = "foo"; | |
| 220 } | |
| 221 buildCounterTasks2--; | |
| 222 return o; | |
| 223 } | |
| 224 | |
| 225 checkTasks2(api.Tasks2 o) { | |
| 226 buildCounterTasks2++; | |
| 227 if (buildCounterTasks2 < 3) { | |
| 228 checkUnnamed1081(o.items); | |
| 229 unittest.expect(o.kind, unittest.equals('foo')); | |
| 230 } | |
| 231 buildCounterTasks2--; | |
| 232 } | |
| 233 | |
| 234 | |
| 235 main() { | |
| 236 unittest.group("obj-schema-Task", () { | |
| 237 unittest.test("to-json--from-json", () { | |
| 238 var o = buildTask(); | |
| 239 var od = new api.Task.fromJson(o.toJson()); | |
| 240 checkTask(od); | |
| 241 }); | |
| 242 }); | |
| 243 | |
| 244 | |
| 245 unittest.group("obj-schema-TaskQueueAcl", () { | |
| 246 unittest.test("to-json--from-json", () { | |
| 247 var o = buildTaskQueueAcl(); | |
| 248 var od = new api.TaskQueueAcl.fromJson(o.toJson()); | |
| 249 checkTaskQueueAcl(od); | |
| 250 }); | |
| 251 }); | |
| 252 | |
| 253 | |
| 254 unittest.group("obj-schema-TaskQueueStats", () { | |
| 255 unittest.test("to-json--from-json", () { | |
| 256 var o = buildTaskQueueStats(); | |
| 257 var od = new api.TaskQueueStats.fromJson(o.toJson()); | |
| 258 checkTaskQueueStats(od); | |
| 259 }); | |
| 260 }); | |
| 261 | |
| 262 | |
| 263 unittest.group("obj-schema-TaskQueue", () { | |
| 264 unittest.test("to-json--from-json", () { | |
| 265 var o = buildTaskQueue(); | |
| 266 var od = new api.TaskQueue.fromJson(o.toJson()); | |
| 267 checkTaskQueue(od); | |
| 268 }); | |
| 269 }); | |
| 270 | |
| 271 | |
| 272 unittest.group("obj-schema-Tasks", () { | |
| 273 unittest.test("to-json--from-json", () { | |
| 274 var o = buildTasks(); | |
| 275 var od = new api.Tasks.fromJson(o.toJson()); | |
| 276 checkTasks(od); | |
| 277 }); | |
| 278 }); | |
| 279 | |
| 280 | |
| 281 unittest.group("obj-schema-Tasks2", () { | |
| 282 unittest.test("to-json--from-json", () { | |
| 283 var o = buildTasks2(); | |
| 284 var od = new api.Tasks2.fromJson(o.toJson()); | |
| 285 checkTasks2(od); | |
| 286 }); | |
| 287 }); | |
| 288 | |
| 289 | |
| 290 unittest.group("resource-TaskqueuesResourceApi", () { | |
| 291 unittest.test("method--get", () { | |
| 292 | |
| 293 var mock = new common_test.HttpServerMock(); | |
| 294 api.TaskqueuesResourceApi res = new api.TaskqueueApi(mock).taskqueues; | |
| 295 var arg_project = "foo"; | |
| 296 var arg_taskqueue = "foo"; | |
| 297 var arg_getStats = true; | |
| 298 mock.register(unittest.expectAsync((http.BaseRequest req, json) { | |
| 299 var path = (req.url).path; | |
| 300 var pathOffset = 0; | |
| 301 var index; | |
| 302 var subPart; | |
| 303 unittest.expect(path.substring(pathOffset, pathOffset + 28), unittest.eq
uals("/taskqueue/v1beta2/projects/")); | |
| 304 pathOffset += 28; | |
| 305 index = path.indexOf("/taskqueues/", pathOffset); | |
| 306 unittest.expect(index >= 0, unittest.isTrue); | |
| 307 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index
)); | |
| 308 pathOffset = index; | |
| 309 unittest.expect(subPart, unittest.equals("$arg_project")); | |
| 310 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq
uals("/taskqueues/")); | |
| 311 pathOffset += 12; | |
| 312 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset)); | |
| 313 pathOffset = path.length; | |
| 314 unittest.expect(subPart, unittest.equals("$arg_taskqueue")); | |
| 315 | |
| 316 var query = (req.url).query; | |
| 317 var queryOffset = 0; | |
| 318 var queryMap = {}; | |
| 319 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); | |
| 320 parseBool(n) { | |
| 321 if (n == "true") return true; | |
| 322 if (n == "false") return false; | |
| 323 if (n == null) return null; | |
| 324 throw new core.ArgumentError("Invalid boolean: $n"); | |
| 325 } | |
| 326 if (query.length > 0) { | |
| 327 for (var part in query.split("&")) { | |
| 328 var keyvalue = part.split("="); | |
| 329 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d
ecodeQueryComponent(keyvalue[1])); | |
| 330 } | |
| 331 } | |
| 332 unittest.expect(queryMap["getStats"].first, unittest.equals("$arg_getSta
ts")); | |
| 333 | |
| 334 | |
| 335 var h = { | |
| 336 "content-type" : "application/json; charset=utf-8", | |
| 337 }; | |
| 338 var resp = convert.JSON.encode(buildTaskQueue()); | |
| 339 return new async.Future.value(common_test.stringResponse(200, h, resp)); | |
| 340 }), true); | |
| 341 res.get(arg_project, arg_taskqueue, getStats: arg_getStats).then(unittest.
expectAsync(((api.TaskQueue response) { | |
| 342 checkTaskQueue(response); | |
| 343 }))); | |
| 344 }); | |
| 345 | |
| 346 }); | |
| 347 | |
| 348 | |
| 349 unittest.group("resource-TasksResourceApi", () { | |
| 350 unittest.test("method--delete", () { | |
| 351 | |
| 352 var mock = new common_test.HttpServerMock(); | |
| 353 api.TasksResourceApi res = new api.TaskqueueApi(mock).tasks; | |
| 354 var arg_project = "foo"; | |
| 355 var arg_taskqueue = "foo"; | |
| 356 var arg_task = "foo"; | |
| 357 mock.register(unittest.expectAsync((http.BaseRequest req, json) { | |
| 358 var path = (req.url).path; | |
| 359 var pathOffset = 0; | |
| 360 var index; | |
| 361 var subPart; | |
| 362 unittest.expect(path.substring(pathOffset, pathOffset + 28), unittest.eq
uals("/taskqueue/v1beta2/projects/")); | |
| 363 pathOffset += 28; | |
| 364 index = path.indexOf("/taskqueues/", pathOffset); | |
| 365 unittest.expect(index >= 0, unittest.isTrue); | |
| 366 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index
)); | |
| 367 pathOffset = index; | |
| 368 unittest.expect(subPart, unittest.equals("$arg_project")); | |
| 369 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq
uals("/taskqueues/")); | |
| 370 pathOffset += 12; | |
| 371 index = path.indexOf("/tasks/", pathOffset); | |
| 372 unittest.expect(index >= 0, unittest.isTrue); | |
| 373 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index
)); | |
| 374 pathOffset = index; | |
| 375 unittest.expect(subPart, unittest.equals("$arg_taskqueue")); | |
| 376 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ
als("/tasks/")); | |
| 377 pathOffset += 7; | |
| 378 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset)); | |
| 379 pathOffset = path.length; | |
| 380 unittest.expect(subPart, unittest.equals("$arg_task")); | |
| 381 | |
| 382 var query = (req.url).query; | |
| 383 var queryOffset = 0; | |
| 384 var queryMap = {}; | |
| 385 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); | |
| 386 parseBool(n) { | |
| 387 if (n == "true") return true; | |
| 388 if (n == "false") return false; | |
| 389 if (n == null) return null; | |
| 390 throw new core.ArgumentError("Invalid boolean: $n"); | |
| 391 } | |
| 392 if (query.length > 0) { | |
| 393 for (var part in query.split("&")) { | |
| 394 var keyvalue = part.split("="); | |
| 395 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d
ecodeQueryComponent(keyvalue[1])); | |
| 396 } | |
| 397 } | |
| 398 | |
| 399 | |
| 400 var h = { | |
| 401 "content-type" : "application/json; charset=utf-8", | |
| 402 }; | |
| 403 var resp = ""; | |
| 404 return new async.Future.value(common_test.stringResponse(200, h, resp)); | |
| 405 }), true); | |
| 406 res.delete(arg_project, arg_taskqueue, arg_task).then(unittest.expectAsync
((_) {})); | |
| 407 }); | |
| 408 | |
| 409 unittest.test("method--get", () { | |
| 410 | |
| 411 var mock = new common_test.HttpServerMock(); | |
| 412 api.TasksResourceApi res = new api.TaskqueueApi(mock).tasks; | |
| 413 var arg_project = "foo"; | |
| 414 var arg_taskqueue = "foo"; | |
| 415 var arg_task = "foo"; | |
| 416 mock.register(unittest.expectAsync((http.BaseRequest req, json) { | |
| 417 var path = (req.url).path; | |
| 418 var pathOffset = 0; | |
| 419 var index; | |
| 420 var subPart; | |
| 421 unittest.expect(path.substring(pathOffset, pathOffset + 28), unittest.eq
uals("/taskqueue/v1beta2/projects/")); | |
| 422 pathOffset += 28; | |
| 423 index = path.indexOf("/taskqueues/", pathOffset); | |
| 424 unittest.expect(index >= 0, unittest.isTrue); | |
| 425 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index
)); | |
| 426 pathOffset = index; | |
| 427 unittest.expect(subPart, unittest.equals("$arg_project")); | |
| 428 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq
uals("/taskqueues/")); | |
| 429 pathOffset += 12; | |
| 430 index = path.indexOf("/tasks/", pathOffset); | |
| 431 unittest.expect(index >= 0, unittest.isTrue); | |
| 432 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index
)); | |
| 433 pathOffset = index; | |
| 434 unittest.expect(subPart, unittest.equals("$arg_taskqueue")); | |
| 435 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ
als("/tasks/")); | |
| 436 pathOffset += 7; | |
| 437 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset)); | |
| 438 pathOffset = path.length; | |
| 439 unittest.expect(subPart, unittest.equals("$arg_task")); | |
| 440 | |
| 441 var query = (req.url).query; | |
| 442 var queryOffset = 0; | |
| 443 var queryMap = {}; | |
| 444 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); | |
| 445 parseBool(n) { | |
| 446 if (n == "true") return true; | |
| 447 if (n == "false") return false; | |
| 448 if (n == null) return null; | |
| 449 throw new core.ArgumentError("Invalid boolean: $n"); | |
| 450 } | |
| 451 if (query.length > 0) { | |
| 452 for (var part in query.split("&")) { | |
| 453 var keyvalue = part.split("="); | |
| 454 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d
ecodeQueryComponent(keyvalue[1])); | |
| 455 } | |
| 456 } | |
| 457 | |
| 458 | |
| 459 var h = { | |
| 460 "content-type" : "application/json; charset=utf-8", | |
| 461 }; | |
| 462 var resp = convert.JSON.encode(buildTask()); | |
| 463 return new async.Future.value(common_test.stringResponse(200, h, resp)); | |
| 464 }), true); | |
| 465 res.get(arg_project, arg_taskqueue, arg_task).then(unittest.expectAsync(((
api.Task response) { | |
| 466 checkTask(response); | |
| 467 }))); | |
| 468 }); | |
| 469 | |
| 470 unittest.test("method--insert", () { | |
| 471 | |
| 472 var mock = new common_test.HttpServerMock(); | |
| 473 api.TasksResourceApi res = new api.TaskqueueApi(mock).tasks; | |
| 474 var arg_request = buildTask(); | |
| 475 var arg_project = "foo"; | |
| 476 var arg_taskqueue = "foo"; | |
| 477 mock.register(unittest.expectAsync((http.BaseRequest req, json) { | |
| 478 var obj = new api.Task.fromJson(json); | |
| 479 checkTask(obj); | |
| 480 | |
| 481 var path = (req.url).path; | |
| 482 var pathOffset = 0; | |
| 483 var index; | |
| 484 var subPart; | |
| 485 unittest.expect(path.substring(pathOffset, pathOffset + 28), unittest.eq
uals("/taskqueue/v1beta2/projects/")); | |
| 486 pathOffset += 28; | |
| 487 index = path.indexOf("/taskqueues/", pathOffset); | |
| 488 unittest.expect(index >= 0, unittest.isTrue); | |
| 489 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index
)); | |
| 490 pathOffset = index; | |
| 491 unittest.expect(subPart, unittest.equals("$arg_project")); | |
| 492 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq
uals("/taskqueues/")); | |
| 493 pathOffset += 12; | |
| 494 index = path.indexOf("/tasks", pathOffset); | |
| 495 unittest.expect(index >= 0, unittest.isTrue); | |
| 496 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index
)); | |
| 497 pathOffset = index; | |
| 498 unittest.expect(subPart, unittest.equals("$arg_taskqueue")); | |
| 499 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ
als("/tasks")); | |
| 500 pathOffset += 6; | |
| 501 | |
| 502 var query = (req.url).query; | |
| 503 var queryOffset = 0; | |
| 504 var queryMap = {}; | |
| 505 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); | |
| 506 parseBool(n) { | |
| 507 if (n == "true") return true; | |
| 508 if (n == "false") return false; | |
| 509 if (n == null) return null; | |
| 510 throw new core.ArgumentError("Invalid boolean: $n"); | |
| 511 } | |
| 512 if (query.length > 0) { | |
| 513 for (var part in query.split("&")) { | |
| 514 var keyvalue = part.split("="); | |
| 515 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d
ecodeQueryComponent(keyvalue[1])); | |
| 516 } | |
| 517 } | |
| 518 | |
| 519 | |
| 520 var h = { | |
| 521 "content-type" : "application/json; charset=utf-8", | |
| 522 }; | |
| 523 var resp = convert.JSON.encode(buildTask()); | |
| 524 return new async.Future.value(common_test.stringResponse(200, h, resp)); | |
| 525 }), true); | |
| 526 res.insert(arg_request, arg_project, arg_taskqueue).then(unittest.expectAs
ync(((api.Task response) { | |
| 527 checkTask(response); | |
| 528 }))); | |
| 529 }); | |
| 530 | |
| 531 unittest.test("method--lease", () { | |
| 532 | |
| 533 var mock = new common_test.HttpServerMock(); | |
| 534 api.TasksResourceApi res = new api.TaskqueueApi(mock).tasks; | |
| 535 var arg_project = "foo"; | |
| 536 var arg_taskqueue = "foo"; | |
| 537 var arg_numTasks = 42; | |
| 538 var arg_leaseSecs = 42; | |
| 539 var arg_groupByTag = true; | |
| 540 var arg_tag = "foo"; | |
| 541 mock.register(unittest.expectAsync((http.BaseRequest req, json) { | |
| 542 var path = (req.url).path; | |
| 543 var pathOffset = 0; | |
| 544 var index; | |
| 545 var subPart; | |
| 546 unittest.expect(path.substring(pathOffset, pathOffset + 28), unittest.eq
uals("/taskqueue/v1beta2/projects/")); | |
| 547 pathOffset += 28; | |
| 548 index = path.indexOf("/taskqueues/", pathOffset); | |
| 549 unittest.expect(index >= 0, unittest.isTrue); | |
| 550 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index
)); | |
| 551 pathOffset = index; | |
| 552 unittest.expect(subPart, unittest.equals("$arg_project")); | |
| 553 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq
uals("/taskqueues/")); | |
| 554 pathOffset += 12; | |
| 555 index = path.indexOf("/tasks/lease", pathOffset); | |
| 556 unittest.expect(index >= 0, unittest.isTrue); | |
| 557 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index
)); | |
| 558 pathOffset = index; | |
| 559 unittest.expect(subPart, unittest.equals("$arg_taskqueue")); | |
| 560 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq
uals("/tasks/lease")); | |
| 561 pathOffset += 12; | |
| 562 | |
| 563 var query = (req.url).query; | |
| 564 var queryOffset = 0; | |
| 565 var queryMap = {}; | |
| 566 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); | |
| 567 parseBool(n) { | |
| 568 if (n == "true") return true; | |
| 569 if (n == "false") return false; | |
| 570 if (n == null) return null; | |
| 571 throw new core.ArgumentError("Invalid boolean: $n"); | |
| 572 } | |
| 573 if (query.length > 0) { | |
| 574 for (var part in query.split("&")) { | |
| 575 var keyvalue = part.split("="); | |
| 576 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d
ecodeQueryComponent(keyvalue[1])); | |
| 577 } | |
| 578 } | |
| 579 unittest.expect(core.int.parse(queryMap["numTasks"].first), unittest.equ
als(arg_numTasks)); | |
| 580 unittest.expect(core.int.parse(queryMap["leaseSecs"].first), unittest.eq
uals(arg_leaseSecs)); | |
| 581 unittest.expect(queryMap["groupByTag"].first, unittest.equals("$arg_grou
pByTag")); | |
| 582 unittest.expect(queryMap["tag"].first, unittest.equals(arg_tag)); | |
| 583 | |
| 584 | |
| 585 var h = { | |
| 586 "content-type" : "application/json; charset=utf-8", | |
| 587 }; | |
| 588 var resp = convert.JSON.encode(buildTasks()); | |
| 589 return new async.Future.value(common_test.stringResponse(200, h, resp)); | |
| 590 }), true); | |
| 591 res.lease(arg_project, arg_taskqueue, arg_numTasks, arg_leaseSecs, groupBy
Tag: arg_groupByTag, tag: arg_tag).then(unittest.expectAsync(((api.Tasks respons
e) { | |
| 592 checkTasks(response); | |
| 593 }))); | |
| 594 }); | |
| 595 | |
| 596 unittest.test("method--list", () { | |
| 597 | |
| 598 var mock = new common_test.HttpServerMock(); | |
| 599 api.TasksResourceApi res = new api.TaskqueueApi(mock).tasks; | |
| 600 var arg_project = "foo"; | |
| 601 var arg_taskqueue = "foo"; | |
| 602 mock.register(unittest.expectAsync((http.BaseRequest req, json) { | |
| 603 var path = (req.url).path; | |
| 604 var pathOffset = 0; | |
| 605 var index; | |
| 606 var subPart; | |
| 607 unittest.expect(path.substring(pathOffset, pathOffset + 28), unittest.eq
uals("/taskqueue/v1beta2/projects/")); | |
| 608 pathOffset += 28; | |
| 609 index = path.indexOf("/taskqueues/", pathOffset); | |
| 610 unittest.expect(index >= 0, unittest.isTrue); | |
| 611 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index
)); | |
| 612 pathOffset = index; | |
| 613 unittest.expect(subPart, unittest.equals("$arg_project")); | |
| 614 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq
uals("/taskqueues/")); | |
| 615 pathOffset += 12; | |
| 616 index = path.indexOf("/tasks", pathOffset); | |
| 617 unittest.expect(index >= 0, unittest.isTrue); | |
| 618 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index
)); | |
| 619 pathOffset = index; | |
| 620 unittest.expect(subPart, unittest.equals("$arg_taskqueue")); | |
| 621 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ
als("/tasks")); | |
| 622 pathOffset += 6; | |
| 623 | |
| 624 var query = (req.url).query; | |
| 625 var queryOffset = 0; | |
| 626 var queryMap = {}; | |
| 627 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); | |
| 628 parseBool(n) { | |
| 629 if (n == "true") return true; | |
| 630 if (n == "false") return false; | |
| 631 if (n == null) return null; | |
| 632 throw new core.ArgumentError("Invalid boolean: $n"); | |
| 633 } | |
| 634 if (query.length > 0) { | |
| 635 for (var part in query.split("&")) { | |
| 636 var keyvalue = part.split("="); | |
| 637 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d
ecodeQueryComponent(keyvalue[1])); | |
| 638 } | |
| 639 } | |
| 640 | |
| 641 | |
| 642 var h = { | |
| 643 "content-type" : "application/json; charset=utf-8", | |
| 644 }; | |
| 645 var resp = convert.JSON.encode(buildTasks2()); | |
| 646 return new async.Future.value(common_test.stringResponse(200, h, resp)); | |
| 647 }), true); | |
| 648 res.list(arg_project, arg_taskqueue).then(unittest.expectAsync(((api.Tasks
2 response) { | |
| 649 checkTasks2(response); | |
| 650 }))); | |
| 651 }); | |
| 652 | |
| 653 unittest.test("method--patch", () { | |
| 654 | |
| 655 var mock = new common_test.HttpServerMock(); | |
| 656 api.TasksResourceApi res = new api.TaskqueueApi(mock).tasks; | |
| 657 var arg_request = buildTask(); | |
| 658 var arg_project = "foo"; | |
| 659 var arg_taskqueue = "foo"; | |
| 660 var arg_task = "foo"; | |
| 661 var arg_newLeaseSeconds = 42; | |
| 662 mock.register(unittest.expectAsync((http.BaseRequest req, json) { | |
| 663 var obj = new api.Task.fromJson(json); | |
| 664 checkTask(obj); | |
| 665 | |
| 666 var path = (req.url).path; | |
| 667 var pathOffset = 0; | |
| 668 var index; | |
| 669 var subPart; | |
| 670 unittest.expect(path.substring(pathOffset, pathOffset + 28), unittest.eq
uals("/taskqueue/v1beta2/projects/")); | |
| 671 pathOffset += 28; | |
| 672 index = path.indexOf("/taskqueues/", pathOffset); | |
| 673 unittest.expect(index >= 0, unittest.isTrue); | |
| 674 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index
)); | |
| 675 pathOffset = index; | |
| 676 unittest.expect(subPart, unittest.equals("$arg_project")); | |
| 677 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq
uals("/taskqueues/")); | |
| 678 pathOffset += 12; | |
| 679 index = path.indexOf("/tasks/", pathOffset); | |
| 680 unittest.expect(index >= 0, unittest.isTrue); | |
| 681 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index
)); | |
| 682 pathOffset = index; | |
| 683 unittest.expect(subPart, unittest.equals("$arg_taskqueue")); | |
| 684 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ
als("/tasks/")); | |
| 685 pathOffset += 7; | |
| 686 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset)); | |
| 687 pathOffset = path.length; | |
| 688 unittest.expect(subPart, unittest.equals("$arg_task")); | |
| 689 | |
| 690 var query = (req.url).query; | |
| 691 var queryOffset = 0; | |
| 692 var queryMap = {}; | |
| 693 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); | |
| 694 parseBool(n) { | |
| 695 if (n == "true") return true; | |
| 696 if (n == "false") return false; | |
| 697 if (n == null) return null; | |
| 698 throw new core.ArgumentError("Invalid boolean: $n"); | |
| 699 } | |
| 700 if (query.length > 0) { | |
| 701 for (var part in query.split("&")) { | |
| 702 var keyvalue = part.split("="); | |
| 703 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d
ecodeQueryComponent(keyvalue[1])); | |
| 704 } | |
| 705 } | |
| 706 unittest.expect(core.int.parse(queryMap["newLeaseSeconds"].first), unitt
est.equals(arg_newLeaseSeconds)); | |
| 707 | |
| 708 | |
| 709 var h = { | |
| 710 "content-type" : "application/json; charset=utf-8", | |
| 711 }; | |
| 712 var resp = convert.JSON.encode(buildTask()); | |
| 713 return new async.Future.value(common_test.stringResponse(200, h, resp)); | |
| 714 }), true); | |
| 715 res.patch(arg_request, arg_project, arg_taskqueue, arg_task, arg_newLeaseS
econds).then(unittest.expectAsync(((api.Task response) { | |
| 716 checkTask(response); | |
| 717 }))); | |
| 718 }); | |
| 719 | |
| 720 unittest.test("method--update", () { | |
| 721 | |
| 722 var mock = new common_test.HttpServerMock(); | |
| 723 api.TasksResourceApi res = new api.TaskqueueApi(mock).tasks; | |
| 724 var arg_request = buildTask(); | |
| 725 var arg_project = "foo"; | |
| 726 var arg_taskqueue = "foo"; | |
| 727 var arg_task = "foo"; | |
| 728 var arg_newLeaseSeconds = 42; | |
| 729 mock.register(unittest.expectAsync((http.BaseRequest req, json) { | |
| 730 var obj = new api.Task.fromJson(json); | |
| 731 checkTask(obj); | |
| 732 | |
| 733 var path = (req.url).path; | |
| 734 var pathOffset = 0; | |
| 735 var index; | |
| 736 var subPart; | |
| 737 unittest.expect(path.substring(pathOffset, pathOffset + 28), unittest.eq
uals("/taskqueue/v1beta2/projects/")); | |
| 738 pathOffset += 28; | |
| 739 index = path.indexOf("/taskqueues/", pathOffset); | |
| 740 unittest.expect(index >= 0, unittest.isTrue); | |
| 741 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index
)); | |
| 742 pathOffset = index; | |
| 743 unittest.expect(subPart, unittest.equals("$arg_project")); | |
| 744 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq
uals("/taskqueues/")); | |
| 745 pathOffset += 12; | |
| 746 index = path.indexOf("/tasks/", pathOffset); | |
| 747 unittest.expect(index >= 0, unittest.isTrue); | |
| 748 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index
)); | |
| 749 pathOffset = index; | |
| 750 unittest.expect(subPart, unittest.equals("$arg_taskqueue")); | |
| 751 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ
als("/tasks/")); | |
| 752 pathOffset += 7; | |
| 753 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset)); | |
| 754 pathOffset = path.length; | |
| 755 unittest.expect(subPart, unittest.equals("$arg_task")); | |
| 756 | |
| 757 var query = (req.url).query; | |
| 758 var queryOffset = 0; | |
| 759 var queryMap = {}; | |
| 760 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); | |
| 761 parseBool(n) { | |
| 762 if (n == "true") return true; | |
| 763 if (n == "false") return false; | |
| 764 if (n == null) return null; | |
| 765 throw new core.ArgumentError("Invalid boolean: $n"); | |
| 766 } | |
| 767 if (query.length > 0) { | |
| 768 for (var part in query.split("&")) { | |
| 769 var keyvalue = part.split("="); | |
| 770 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d
ecodeQueryComponent(keyvalue[1])); | |
| 771 } | |
| 772 } | |
| 773 unittest.expect(core.int.parse(queryMap["newLeaseSeconds"].first), unitt
est.equals(arg_newLeaseSeconds)); | |
| 774 | |
| 775 | |
| 776 var h = { | |
| 777 "content-type" : "application/json; charset=utf-8", | |
| 778 }; | |
| 779 var resp = convert.JSON.encode(buildTask()); | |
| 780 return new async.Future.value(common_test.stringResponse(200, h, resp)); | |
| 781 }), true); | |
| 782 res.update(arg_request, arg_project, arg_taskqueue, arg_task, arg_newLease
Seconds).then(unittest.expectAsync(((api.Task response) { | |
| 783 checkTask(response); | |
| 784 }))); | |
| 785 }); | |
| 786 | |
| 787 }); | |
| 788 | |
| 789 | |
| 790 } | |
| 791 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 560323003:
Add discovery service to stable APIs (Closed)
Base URL: git@github.com:dart-lang/googleapis.git@master