generated/googleapis/test/licensing/v1.dart - Issue 560323003: Add discovery service to stable APIs

Side by Side Diff: generated/googleapis/test/licensing/v1.dart

Issue 560323003: Add discovery service to stable APIs (Closed) Base URL: git@github.com:dart-lang/googleapis.git@master

Patch Set: New generator hash in pubspec.yaml, test files renamed ot have _test.dart postfix Created 6 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 library googleapis.licensing.v1.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/common/common.dart' as common;

12 import 'package:googleapis/src/common_internal.dart' as common_internal;

13 import '../common/common_internal_test.dart' as common_test;

14

15 import 'package:googleapis/licensing/v1.dart' as api;

16

17

18

19 core.int buildCounterLicenseAssignment = 0;

20 buildLicenseAssignment() {

21 var o = new api.LicenseAssignment();

22 buildCounterLicenseAssignment++;

23 if (buildCounterLicenseAssignment < 3) {

24 o.etags = "foo";

25 o.kind = "foo";

26 o.productId = "foo";

27 o.selfLink = "foo";

28 o.skuId = "foo";

29 o.userId = "foo";

30 }

31 buildCounterLicenseAssignment--;

32 return o;

33 }

34

35 checkLicenseAssignment(api.LicenseAssignment o) {

36 buildCounterLicenseAssignment++;

37 if (buildCounterLicenseAssignment < 3) {

38 unittest.expect(o.etags, unittest.equals('foo'));

39 unittest.expect(o.kind, unittest.equals('foo'));

40 unittest.expect(o.productId, unittest.equals('foo'));

41 unittest.expect(o.selfLink, unittest.equals('foo'));

42 unittest.expect(o.skuId, unittest.equals('foo'));

43 unittest.expect(o.userId, unittest.equals('foo'));

44 }

45 buildCounterLicenseAssignment--;

46 }

47

48 core.int buildCounterLicenseAssignmentInsert = 0;

49 buildLicenseAssignmentInsert() {

50 var o = new api.LicenseAssignmentInsert();

51 buildCounterLicenseAssignmentInsert++;

52 if (buildCounterLicenseAssignmentInsert < 3) {

53 o.userId = "foo";

54 }

55 buildCounterLicenseAssignmentInsert--;

56 return o;

57 }

58

59 checkLicenseAssignmentInsert(api.LicenseAssignmentInsert o) {

60 buildCounterLicenseAssignmentInsert++;

61 if (buildCounterLicenseAssignmentInsert < 3) {

62 unittest.expect(o.userId, unittest.equals('foo'));

63 }

64 buildCounterLicenseAssignmentInsert--;

65 }

66

67 buildUnnamed838() {

68 var o = new core.List<api.LicenseAssignment>();

69 o.add(buildLicenseAssignment());

70 o.add(buildLicenseAssignment());

71 return o;

72 }

73

74 checkUnnamed838(core.List<api.LicenseAssignment> o) {

75 unittest.expect(o, unittest.hasLength(2));

76 checkLicenseAssignment(o[0]);

77 checkLicenseAssignment(o[1]);

78 }

79

80 core.int buildCounterLicenseAssignmentList = 0;

81 buildLicenseAssignmentList() {

82 var o = new api.LicenseAssignmentList();

83 buildCounterLicenseAssignmentList++;

84 if (buildCounterLicenseAssignmentList < 3) {

85 o.etag = "foo";

86 o.items = buildUnnamed838();

87 o.kind = "foo";

88 o.nextPageToken = "foo";

89 }

90 buildCounterLicenseAssignmentList--;

91 return o;

92 }

93

94 checkLicenseAssignmentList(api.LicenseAssignmentList o) {

95 buildCounterLicenseAssignmentList++;

96 if (buildCounterLicenseAssignmentList < 3) {

97 unittest.expect(o.etag, unittest.equals('foo'));

98 checkUnnamed838(o.items);

99 unittest.expect(o.kind, unittest.equals('foo'));

100 unittest.expect(o.nextPageToken, unittest.equals('foo'));

101 }

102 buildCounterLicenseAssignmentList--;

103 }

104

105

106 main() {

107 unittest.group("obj-schema-LicenseAssignment", () {

108 unittest.test("to-json--from-json", () {

109 var o = buildLicenseAssignment();

110 var od = new api.LicenseAssignment.fromJson(o.toJson());

111 checkLicenseAssignment(od);

112 });

113 });

114

115

116 unittest.group("obj-schema-LicenseAssignmentInsert", () {

117 unittest.test("to-json--from-json", () {

118 var o = buildLicenseAssignmentInsert();

119 var od = new api.LicenseAssignmentInsert.fromJson(o.toJson());

120 checkLicenseAssignmentInsert(od);

121 });

122 });

123

124

125 unittest.group("obj-schema-LicenseAssignmentList", () {

126 unittest.test("to-json--from-json", () {

127 var o = buildLicenseAssignmentList();

128 var od = new api.LicenseAssignmentList.fromJson(o.toJson());

129 checkLicenseAssignmentList(od);

130 });

131 });

132

133

134 unittest.group("resource-LicenseAssignmentsResourceApi", () {

135 unittest.test("method--delete", () {

136

137 var mock = new common_test.HttpServerMock();

138 api.LicenseAssignmentsResourceApi res = new api.LicensingApi(mock).license Assignments;

139 var arg_productId = "foo";

140 var arg_skuId = "foo";

141 var arg_userId = "foo";

142 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

143 var path = (req.url).path;

144 var pathOffset = 0;

145 var index;

146 var subPart;

147 unittest.expect(path.substring(pathOffset, pathOffset + 27), unittest.eq uals("/apps/licensing/v1/product/"));

148 pathOffset += 27;

149 index = path.indexOf("/sku/", pathOffset);

150 unittest.expect(index >= 0, unittest.isTrue);

151 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

152 pathOffset = index;

153 unittest.expect(subPart, unittest.equals("$arg_productId"));

154 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("/sku/"));

155 pathOffset += 5;

156 index = path.indexOf("/user/", pathOffset);

157 unittest.expect(index >= 0, unittest.isTrue);

158 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

159 pathOffset = index;

160 unittest.expect(subPart, unittest.equals("$arg_skuId"));

161 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/user/"));

162 pathOffset += 6;

163 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

164 pathOffset = path.length;

165 unittest.expect(subPart, unittest.equals("$arg_userId"));

166

167 var query = (req.url).query;

168 var queryOffset = 0;

169 var queryMap = {};

170 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

171 parseBool(n) {

172 if (n == "true") return true;

173 if (n == "false") return false;

174 if (n == null) return null;

175 throw new core.ArgumentError("Invalid boolean: $n");

176 }

177 if (query.length > 0) {

178 for (var part in query.split("&")) {

179 var keyvalue = part.split("=");

180 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

181 }

182 }

183

184

185 var h = {

186 "content-type" : "application/json; charset=utf-8",

187 };

188 var resp = "";

189 return new async.Future.value(common_test.stringResponse(200, h, resp));

190 }), true);

191 res.delete(arg_productId, arg_skuId, arg_userId).then(unittest.expectAsync ((_) {}));

192 });

193

194 unittest.test("method--get", () {

195

196 var mock = new common_test.HttpServerMock();

197 api.LicenseAssignmentsResourceApi res = new api.LicensingApi(mock).license Assignments;

198 var arg_productId = "foo";

199 var arg_skuId = "foo";

200 var arg_userId = "foo";

201 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

202 var path = (req.url).path;

203 var pathOffset = 0;

204 var index;

205 var subPart;

206 unittest.expect(path.substring(pathOffset, pathOffset + 27), unittest.eq uals("/apps/licensing/v1/product/"));

207 pathOffset += 27;

208 index = path.indexOf("/sku/", pathOffset);

209 unittest.expect(index >= 0, unittest.isTrue);

210 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

211 pathOffset = index;

212 unittest.expect(subPart, unittest.equals("$arg_productId"));

213 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("/sku/"));

214 pathOffset += 5;

215 index = path.indexOf("/user/", pathOffset);

216 unittest.expect(index >= 0, unittest.isTrue);

217 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

218 pathOffset = index;

219 unittest.expect(subPart, unittest.equals("$arg_skuId"));

220 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/user/"));

221 pathOffset += 6;

222 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

223 pathOffset = path.length;

224 unittest.expect(subPart, unittest.equals("$arg_userId"));

225

226 var query = (req.url).query;

227 var queryOffset = 0;

228 var queryMap = {};

229 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

230 parseBool(n) {

231 if (n == "true") return true;

232 if (n == "false") return false;

233 if (n == null) return null;

234 throw new core.ArgumentError("Invalid boolean: $n");

235 }

236 if (query.length > 0) {

237 for (var part in query.split("&")) {

238 var keyvalue = part.split("=");

239 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

240 }

241 }

242

243

244 var h = {

245 "content-type" : "application/json; charset=utf-8",

246 };

247 var resp = convert.JSON.encode(buildLicenseAssignment());

248 return new async.Future.value(common_test.stringResponse(200, h, resp));

249 }), true);

250 res.get(arg_productId, arg_skuId, arg_userId).then(unittest.expectAsync((( api.LicenseAssignment response) {

251 checkLicenseAssignment(response);

252 })));

253 });

254

255 unittest.test("method--insert", () {

256

257 var mock = new common_test.HttpServerMock();

258 api.LicenseAssignmentsResourceApi res = new api.LicensingApi(mock).license Assignments;

259 var arg_request = buildLicenseAssignmentInsert();

260 var arg_productId = "foo";

261 var arg_skuId = "foo";

262 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

263 var obj = new api.LicenseAssignmentInsert.fromJson(json);

264 checkLicenseAssignmentInsert(obj);

265

266 var path = (req.url).path;

267 var pathOffset = 0;

268 var index;

269 var subPart;

270 unittest.expect(path.substring(pathOffset, pathOffset + 27), unittest.eq uals("/apps/licensing/v1/product/"));

271 pathOffset += 27;

272 index = path.indexOf("/sku/", pathOffset);

273 unittest.expect(index >= 0, unittest.isTrue);

274 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

275 pathOffset = index;

276 unittest.expect(subPart, unittest.equals("$arg_productId"));

277 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("/sku/"));

278 pathOffset += 5;

279 index = path.indexOf("/user", pathOffset);

280 unittest.expect(index >= 0, unittest.isTrue);

281 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

282 pathOffset = index;

283 unittest.expect(subPart, unittest.equals("$arg_skuId"));

284 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("/user"));

285 pathOffset += 5;

286

287 var query = (req.url).query;

288 var queryOffset = 0;

289 var queryMap = {};

290 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

291 parseBool(n) {

292 if (n == "true") return true;

293 if (n == "false") return false;

294 if (n == null) return null;

295 throw new core.ArgumentError("Invalid boolean: $n");

296 }

297 if (query.length > 0) {

298 for (var part in query.split("&")) {

299 var keyvalue = part.split("=");

300 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

301 }

302 }

303

304

305 var h = {

306 "content-type" : "application/json; charset=utf-8",

307 };

308 var resp = convert.JSON.encode(buildLicenseAssignment());

309 return new async.Future.value(common_test.stringResponse(200, h, resp));

310 }), true);

311 res.insert(arg_request, arg_productId, arg_skuId).then(unittest.expectAsyn c(((api.LicenseAssignment response) {

312 checkLicenseAssignment(response);

313 })));

314 });

315

316 unittest.test("method--listForProduct", () {

317

318 var mock = new common_test.HttpServerMock();

319 api.LicenseAssignmentsResourceApi res = new api.LicensingApi(mock).license Assignments;

320 var arg_productId = "foo";

321 var arg_customerId = "foo";

322 var arg_maxResults = 42;

323 var arg_pageToken = "foo";

324 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

325 var path = (req.url).path;

326 var pathOffset = 0;

327 var index;

328 var subPart;

329 unittest.expect(path.substring(pathOffset, pathOffset + 27), unittest.eq uals("/apps/licensing/v1/product/"));

330 pathOffset += 27;

331 index = path.indexOf("/users", pathOffset);

332 unittest.expect(index >= 0, unittest.isTrue);

333 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

334 pathOffset = index;

335 unittest.expect(subPart, unittest.equals("$arg_productId"));

336 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/users"));

337 pathOffset += 6;

338

339 var query = (req.url).query;

340 var queryOffset = 0;

341 var queryMap = {};

342 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

343 parseBool(n) {

344 if (n == "true") return true;

345 if (n == "false") return false;

346 if (n == null) return null;

347 throw new core.ArgumentError("Invalid boolean: $n");

348 }

349 if (query.length > 0) {

350 for (var part in query.split("&")) {

351 var keyvalue = part.split("=");

352 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

353 }

354 }

355 unittest.expect(queryMap["customerId"].first, unittest.equals(arg_custom erId));

356 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

357 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

358

359

360 var h = {

361 "content-type" : "application/json; charset=utf-8",

362 };

363 var resp = convert.JSON.encode(buildLicenseAssignmentList());

364 return new async.Future.value(common_test.stringResponse(200, h, resp));

365 }), true);

366 res.listForProduct(arg_productId, arg_customerId, maxResults: arg_maxResul ts, pageToken: arg_pageToken).then(unittest.expectAsync(((api.LicenseAssignmentL ist response) {

367 checkLicenseAssignmentList(response);

368 })));

369 });

370

371 unittest.test("method--listForProductAndSku", () {

372

373 var mock = new common_test.HttpServerMock();

374 api.LicenseAssignmentsResourceApi res = new api.LicensingApi(mock).license Assignments;

375 var arg_productId = "foo";

376 var arg_skuId = "foo";

377 var arg_customerId = "foo";

378 var arg_maxResults = 42;

379 var arg_pageToken = "foo";

380 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

381 var path = (req.url).path;

382 var pathOffset = 0;

383 var index;

384 var subPart;

385 unittest.expect(path.substring(pathOffset, pathOffset + 27), unittest.eq uals("/apps/licensing/v1/product/"));

386 pathOffset += 27;

387 index = path.indexOf("/sku/", pathOffset);

388 unittest.expect(index >= 0, unittest.isTrue);

389 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

390 pathOffset = index;

391 unittest.expect(subPart, unittest.equals("$arg_productId"));

392 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("/sku/"));

393 pathOffset += 5;

394 index = path.indexOf("/users", pathOffset);

395 unittest.expect(index >= 0, unittest.isTrue);

396 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

397 pathOffset = index;

398 unittest.expect(subPart, unittest.equals("$arg_skuId"));

399 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/users"));

400 pathOffset += 6;

401

402 var query = (req.url).query;

403 var queryOffset = 0;

404 var queryMap = {};

405 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

406 parseBool(n) {

407 if (n == "true") return true;

408 if (n == "false") return false;

409 if (n == null) return null;

410 throw new core.ArgumentError("Invalid boolean: $n");

411 }

412 if (query.length > 0) {

413 for (var part in query.split("&")) {

414 var keyvalue = part.split("=");

415 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

416 }

417 }

418 unittest.expect(queryMap["customerId"].first, unittest.equals(arg_custom erId));

419 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

420 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

421

422

423 var h = {

424 "content-type" : "application/json; charset=utf-8",

425 };

426 var resp = convert.JSON.encode(buildLicenseAssignmentList());

427 return new async.Future.value(common_test.stringResponse(200, h, resp));

428 }), true);

429 res.listForProductAndSku(arg_productId, arg_skuId, arg_customerId, maxResu lts: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.L icenseAssignmentList response) {

430 checkLicenseAssignmentList(response);

431 })));

432 });

433

434 unittest.test("method--patch", () {

435

436 var mock = new common_test.HttpServerMock();

437 api.LicenseAssignmentsResourceApi res = new api.LicensingApi(mock).license Assignments;

438 var arg_request = buildLicenseAssignment();

439 var arg_productId = "foo";

440 var arg_skuId = "foo";

441 var arg_userId = "foo";

442 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

443 var obj = new api.LicenseAssignment.fromJson(json);

444 checkLicenseAssignment(obj);

445

446 var path = (req.url).path;

447 var pathOffset = 0;

448 var index;

449 var subPart;

450 unittest.expect(path.substring(pathOffset, pathOffset + 27), unittest.eq uals("/apps/licensing/v1/product/"));

451 pathOffset += 27;

452 index = path.indexOf("/sku/", pathOffset);

453 unittest.expect(index >= 0, unittest.isTrue);

454 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

455 pathOffset = index;

456 unittest.expect(subPart, unittest.equals("$arg_productId"));

457 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("/sku/"));

458 pathOffset += 5;

459 index = path.indexOf("/user/", pathOffset);

460 unittest.expect(index >= 0, unittest.isTrue);

461 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

462 pathOffset = index;

463 unittest.expect(subPart, unittest.equals("$arg_skuId"));

464 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/user/"));

465 pathOffset += 6;

466 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

467 pathOffset = path.length;

468 unittest.expect(subPart, unittest.equals("$arg_userId"));

469

470 var query = (req.url).query;

471 var queryOffset = 0;

472 var queryMap = {};

473 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

474 parseBool(n) {

475 if (n == "true") return true;

476 if (n == "false") return false;

477 if (n == null) return null;

478 throw new core.ArgumentError("Invalid boolean: $n");

479 }

480 if (query.length > 0) {

481 for (var part in query.split("&")) {

482 var keyvalue = part.split("=");

483 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

484 }

485 }

486

487

488 var h = {

489 "content-type" : "application/json; charset=utf-8",

490 };

491 var resp = convert.JSON.encode(buildLicenseAssignment());

492 return new async.Future.value(common_test.stringResponse(200, h, resp));

493 }), true);

494 res.patch(arg_request, arg_productId, arg_skuId, arg_userId).then(unittest .expectAsync(((api.LicenseAssignment response) {

495 checkLicenseAssignment(response);

496 })));

497 });

498

499 unittest.test("method--update", () {

500

501 var mock = new common_test.HttpServerMock();

502 api.LicenseAssignmentsResourceApi res = new api.LicensingApi(mock).license Assignments;

503 var arg_request = buildLicenseAssignment();

504 var arg_productId = "foo";

505 var arg_skuId = "foo";

506 var arg_userId = "foo";

507 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

508 var obj = new api.LicenseAssignment.fromJson(json);

509 checkLicenseAssignment(obj);

510

511 var path = (req.url).path;

512 var pathOffset = 0;

513 var index;

514 var subPart;

515 unittest.expect(path.substring(pathOffset, pathOffset + 27), unittest.eq uals("/apps/licensing/v1/product/"));

516 pathOffset += 27;

517 index = path.indexOf("/sku/", pathOffset);

518 unittest.expect(index >= 0, unittest.isTrue);

519 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

520 pathOffset = index;

521 unittest.expect(subPart, unittest.equals("$arg_productId"));

522 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("/sku/"));

523 pathOffset += 5;

524 index = path.indexOf("/user/", pathOffset);

525 unittest.expect(index >= 0, unittest.isTrue);

526 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

527 pathOffset = index;

528 unittest.expect(subPart, unittest.equals("$arg_skuId"));

529 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/user/"));

530 pathOffset += 6;

531 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

532 pathOffset = path.length;

533 unittest.expect(subPart, unittest.equals("$arg_userId"));

534

535 var query = (req.url).query;

536 var queryOffset = 0;

537 var queryMap = {};

538 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

539 parseBool(n) {

540 if (n == "true") return true;

541 if (n == "false") return false;

542 if (n == null) return null;

543 throw new core.ArgumentError("Invalid boolean: $n");

544 }

545 if (query.length > 0) {

546 for (var part in query.split("&")) {

547 var keyvalue = part.split("=");

548 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

549 }

550 }

551

552

553 var h = {

554 "content-type" : "application/json; charset=utf-8",

555 };

556 var resp = convert.JSON.encode(buildLicenseAssignment());

557 return new async.Future.value(common_test.stringResponse(200, h, resp));

558 }), true);

559 res.update(arg_request, arg_productId, arg_skuId, arg_userId).then(unittes t.expectAsync(((api.LicenseAssignment response) {

560 checkLicenseAssignment(response);

561 })));

562 });

563

564 });

565

566

567 }

568

OLD	NEW

« no previous file with comments | « generated/googleapis/test/identitytoolkit/v3_test.dart ('k') | generated/googleapis/test/licensing/v1_test.dart » ('j') | no next file with comments »