| library googleapis.iam.v1.test; |
| |
| import "dart:core" as core; |
| import "dart:collection" as collection; |
| import "dart:async" as async; |
| import "dart:convert" as convert; |
| |
| import 'package:http/http.dart' as http; |
| import 'package:http/testing.dart' as http_testing; |
| import 'package:unittest/unittest.dart' as unittest; |
| |
| import 'package:googleapis/iam/v1.dart' as api; |
| |
| class HttpServerMock extends http.BaseClient { |
| core.Function _callback; |
| core.bool _expectJson; |
| |
| void register(core.Function callback, core.bool expectJson) { |
| _callback = callback; |
| _expectJson = expectJson; |
| } |
| |
| async.Future<http.StreamedResponse> send(http.BaseRequest request) { |
| if (_expectJson) { |
| return request.finalize() |
| .transform(convert.UTF8.decoder) |
| .join('') |
| .then((core.String jsonString) { |
| if (jsonString.isEmpty) { |
| return _callback(request, null); |
| } else { |
| return _callback(request, convert.JSON.decode(jsonString)); |
| } |
| }); |
| } else { |
| var stream = request.finalize(); |
| if (stream == null) { |
| return _callback(request, []); |
| } else { |
| return stream.toBytes().then((data) { |
| return _callback(request, data); |
| }); |
| } |
| } |
| } |
| } |
| |
| http.StreamedResponse stringResponse( |
| core.int status, core.Map headers, core.String body) { |
| var stream = new async.Stream.fromIterable([convert.UTF8.encode(body)]); |
| return new http.StreamedResponse(stream, status, headers: headers); |
| } |
| |
| core.int buildCounterAuditData = 0; |
| buildAuditData() { |
| var o = new api.AuditData(); |
| buildCounterAuditData++; |
| if (buildCounterAuditData < 3) { |
| o.policyDelta = buildPolicyDelta(); |
| } |
| buildCounterAuditData--; |
| return o; |
| } |
| |
| checkAuditData(api.AuditData o) { |
| buildCounterAuditData++; |
| if (buildCounterAuditData < 3) { |
| checkPolicyDelta(o.policyDelta); |
| } |
| buildCounterAuditData--; |
| } |
| |
| buildUnnamed1109() { |
| var o = new core.List<core.String>(); |
| o.add("foo"); |
| o.add("foo"); |
| return o; |
| } |
| |
| checkUnnamed1109(core.List<core.String> o) { |
| unittest.expect(o, unittest.hasLength(2)); |
| unittest.expect(o[0], unittest.equals('foo')); |
| unittest.expect(o[1], unittest.equals('foo')); |
| } |
| |
| core.int buildCounterBinding = 0; |
| buildBinding() { |
| var o = new api.Binding(); |
| buildCounterBinding++; |
| if (buildCounterBinding < 3) { |
| o.members = buildUnnamed1109(); |
| o.role = "foo"; |
| } |
| buildCounterBinding--; |
| return o; |
| } |
| |
| checkBinding(api.Binding o) { |
| buildCounterBinding++; |
| if (buildCounterBinding < 3) { |
| checkUnnamed1109(o.members); |
| unittest.expect(o.role, unittest.equals('foo')); |
| } |
| buildCounterBinding--; |
| } |
| |
| core.int buildCounterBindingDelta = 0; |
| buildBindingDelta() { |
| var o = new api.BindingDelta(); |
| buildCounterBindingDelta++; |
| if (buildCounterBindingDelta < 3) { |
| o.action = "foo"; |
| o.member = "foo"; |
| o.role = "foo"; |
| } |
| buildCounterBindingDelta--; |
| return o; |
| } |
| |
| checkBindingDelta(api.BindingDelta o) { |
| buildCounterBindingDelta++; |
| if (buildCounterBindingDelta < 3) { |
| unittest.expect(o.action, unittest.equals('foo')); |
| unittest.expect(o.member, unittest.equals('foo')); |
| unittest.expect(o.role, unittest.equals('foo')); |
| } |
| buildCounterBindingDelta--; |
| } |
| |
| core.int buildCounterCreateServiceAccountKeyRequest = 0; |
| buildCreateServiceAccountKeyRequest() { |
| var o = new api.CreateServiceAccountKeyRequest(); |
| buildCounterCreateServiceAccountKeyRequest++; |
| if (buildCounterCreateServiceAccountKeyRequest < 3) { |
| o.keyAlgorithm = "foo"; |
| o.privateKeyType = "foo"; |
| } |
| buildCounterCreateServiceAccountKeyRequest--; |
| return o; |
| } |
| |
| checkCreateServiceAccountKeyRequest(api.CreateServiceAccountKeyRequest o) { |
| buildCounterCreateServiceAccountKeyRequest++; |
| if (buildCounterCreateServiceAccountKeyRequest < 3) { |
| unittest.expect(o.keyAlgorithm, unittest.equals('foo')); |
| unittest.expect(o.privateKeyType, unittest.equals('foo')); |
| } |
| buildCounterCreateServiceAccountKeyRequest--; |
| } |
| |
| core.int buildCounterCreateServiceAccountRequest = 0; |
| buildCreateServiceAccountRequest() { |
| var o = new api.CreateServiceAccountRequest(); |
| buildCounterCreateServiceAccountRequest++; |
| if (buildCounterCreateServiceAccountRequest < 3) { |
| o.accountId = "foo"; |
| o.serviceAccount = buildServiceAccount(); |
| } |
| buildCounterCreateServiceAccountRequest--; |
| return o; |
| } |
| |
| checkCreateServiceAccountRequest(api.CreateServiceAccountRequest o) { |
| buildCounterCreateServiceAccountRequest++; |
| if (buildCounterCreateServiceAccountRequest < 3) { |
| unittest.expect(o.accountId, unittest.equals('foo')); |
| checkServiceAccount(o.serviceAccount); |
| } |
| buildCounterCreateServiceAccountRequest--; |
| } |
| |
| core.int buildCounterEmpty = 0; |
| buildEmpty() { |
| var o = new api.Empty(); |
| buildCounterEmpty++; |
| if (buildCounterEmpty < 3) { |
| } |
| buildCounterEmpty--; |
| return o; |
| } |
| |
| checkEmpty(api.Empty o) { |
| buildCounterEmpty++; |
| if (buildCounterEmpty < 3) { |
| } |
| buildCounterEmpty--; |
| } |
| |
| buildUnnamed1110() { |
| var o = new core.List<api.ServiceAccountKey>(); |
| o.add(buildServiceAccountKey()); |
| o.add(buildServiceAccountKey()); |
| return o; |
| } |
| |
| checkUnnamed1110(core.List<api.ServiceAccountKey> o) { |
| unittest.expect(o, unittest.hasLength(2)); |
| checkServiceAccountKey(o[0]); |
| checkServiceAccountKey(o[1]); |
| } |
| |
| core.int buildCounterListServiceAccountKeysResponse = 0; |
| buildListServiceAccountKeysResponse() { |
| var o = new api.ListServiceAccountKeysResponse(); |
| buildCounterListServiceAccountKeysResponse++; |
| if (buildCounterListServiceAccountKeysResponse < 3) { |
| o.keys = buildUnnamed1110(); |
| } |
| buildCounterListServiceAccountKeysResponse--; |
| return o; |
| } |
| |
| checkListServiceAccountKeysResponse(api.ListServiceAccountKeysResponse o) { |
| buildCounterListServiceAccountKeysResponse++; |
| if (buildCounterListServiceAccountKeysResponse < 3) { |
| checkUnnamed1110(o.keys); |
| } |
| buildCounterListServiceAccountKeysResponse--; |
| } |
| |
| buildUnnamed1111() { |
| var o = new core.List<api.ServiceAccount>(); |
| o.add(buildServiceAccount()); |
| o.add(buildServiceAccount()); |
| return o; |
| } |
| |
| checkUnnamed1111(core.List<api.ServiceAccount> o) { |
| unittest.expect(o, unittest.hasLength(2)); |
| checkServiceAccount(o[0]); |
| checkServiceAccount(o[1]); |
| } |
| |
| core.int buildCounterListServiceAccountsResponse = 0; |
| buildListServiceAccountsResponse() { |
| var o = new api.ListServiceAccountsResponse(); |
| buildCounterListServiceAccountsResponse++; |
| if (buildCounterListServiceAccountsResponse < 3) { |
| o.accounts = buildUnnamed1111(); |
| o.nextPageToken = "foo"; |
| } |
| buildCounterListServiceAccountsResponse--; |
| return o; |
| } |
| |
| checkListServiceAccountsResponse(api.ListServiceAccountsResponse o) { |
| buildCounterListServiceAccountsResponse++; |
| if (buildCounterListServiceAccountsResponse < 3) { |
| checkUnnamed1111(o.accounts); |
| unittest.expect(o.nextPageToken, unittest.equals('foo')); |
| } |
| buildCounterListServiceAccountsResponse--; |
| } |
| |
| buildUnnamed1112() { |
| var o = new core.List<api.Binding>(); |
| o.add(buildBinding()); |
| o.add(buildBinding()); |
| return o; |
| } |
| |
| checkUnnamed1112(core.List<api.Binding> o) { |
| unittest.expect(o, unittest.hasLength(2)); |
| checkBinding(o[0]); |
| checkBinding(o[1]); |
| } |
| |
| core.int buildCounterPolicy = 0; |
| buildPolicy() { |
| var o = new api.Policy(); |
| buildCounterPolicy++; |
| if (buildCounterPolicy < 3) { |
| o.bindings = buildUnnamed1112(); |
| o.etag = "foo"; |
| o.version = 42; |
| } |
| buildCounterPolicy--; |
| return o; |
| } |
| |
| checkPolicy(api.Policy o) { |
| buildCounterPolicy++; |
| if (buildCounterPolicy < 3) { |
| checkUnnamed1112(o.bindings); |
| unittest.expect(o.etag, unittest.equals('foo')); |
| unittest.expect(o.version, unittest.equals(42)); |
| } |
| buildCounterPolicy--; |
| } |
| |
| buildUnnamed1113() { |
| var o = new core.List<api.BindingDelta>(); |
| o.add(buildBindingDelta()); |
| o.add(buildBindingDelta()); |
| return o; |
| } |
| |
| checkUnnamed1113(core.List<api.BindingDelta> o) { |
| unittest.expect(o, unittest.hasLength(2)); |
| checkBindingDelta(o[0]); |
| checkBindingDelta(o[1]); |
| } |
| |
| core.int buildCounterPolicyDelta = 0; |
| buildPolicyDelta() { |
| var o = new api.PolicyDelta(); |
| buildCounterPolicyDelta++; |
| if (buildCounterPolicyDelta < 3) { |
| o.bindingDeltas = buildUnnamed1113(); |
| } |
| buildCounterPolicyDelta--; |
| return o; |
| } |
| |
| checkPolicyDelta(api.PolicyDelta o) { |
| buildCounterPolicyDelta++; |
| if (buildCounterPolicyDelta < 3) { |
| checkUnnamed1113(o.bindingDeltas); |
| } |
| buildCounterPolicyDelta--; |
| } |
| |
| core.int buildCounterQueryGrantableRolesRequest = 0; |
| buildQueryGrantableRolesRequest() { |
| var o = new api.QueryGrantableRolesRequest(); |
| buildCounterQueryGrantableRolesRequest++; |
| if (buildCounterQueryGrantableRolesRequest < 3) { |
| o.fullResourceName = "foo"; |
| } |
| buildCounterQueryGrantableRolesRequest--; |
| return o; |
| } |
| |
| checkQueryGrantableRolesRequest(api.QueryGrantableRolesRequest o) { |
| buildCounterQueryGrantableRolesRequest++; |
| if (buildCounterQueryGrantableRolesRequest < 3) { |
| unittest.expect(o.fullResourceName, unittest.equals('foo')); |
| } |
| buildCounterQueryGrantableRolesRequest--; |
| } |
| |
| buildUnnamed1114() { |
| var o = new core.List<api.Role>(); |
| o.add(buildRole()); |
| o.add(buildRole()); |
| return o; |
| } |
| |
| checkUnnamed1114(core.List<api.Role> o) { |
| unittest.expect(o, unittest.hasLength(2)); |
| checkRole(o[0]); |
| checkRole(o[1]); |
| } |
| |
| core.int buildCounterQueryGrantableRolesResponse = 0; |
| buildQueryGrantableRolesResponse() { |
| var o = new api.QueryGrantableRolesResponse(); |
| buildCounterQueryGrantableRolesResponse++; |
| if (buildCounterQueryGrantableRolesResponse < 3) { |
| o.roles = buildUnnamed1114(); |
| } |
| buildCounterQueryGrantableRolesResponse--; |
| return o; |
| } |
| |
| checkQueryGrantableRolesResponse(api.QueryGrantableRolesResponse o) { |
| buildCounterQueryGrantableRolesResponse++; |
| if (buildCounterQueryGrantableRolesResponse < 3) { |
| checkUnnamed1114(o.roles); |
| } |
| buildCounterQueryGrantableRolesResponse--; |
| } |
| |
| core.int buildCounterRole = 0; |
| buildRole() { |
| var o = new api.Role(); |
| buildCounterRole++; |
| if (buildCounterRole < 3) { |
| o.description = "foo"; |
| o.name = "foo"; |
| o.title = "foo"; |
| } |
| buildCounterRole--; |
| return o; |
| } |
| |
| checkRole(api.Role o) { |
| buildCounterRole++; |
| if (buildCounterRole < 3) { |
| unittest.expect(o.description, unittest.equals('foo')); |
| unittest.expect(o.name, unittest.equals('foo')); |
| unittest.expect(o.title, unittest.equals('foo')); |
| } |
| buildCounterRole--; |
| } |
| |
| core.int buildCounterServiceAccount = 0; |
| buildServiceAccount() { |
| var o = new api.ServiceAccount(); |
| buildCounterServiceAccount++; |
| if (buildCounterServiceAccount < 3) { |
| o.displayName = "foo"; |
| o.email = "foo"; |
| o.etag = "foo"; |
| o.name = "foo"; |
| o.oauth2ClientId = "foo"; |
| o.projectId = "foo"; |
| o.uniqueId = "foo"; |
| } |
| buildCounterServiceAccount--; |
| return o; |
| } |
| |
| checkServiceAccount(api.ServiceAccount o) { |
| buildCounterServiceAccount++; |
| if (buildCounterServiceAccount < 3) { |
| unittest.expect(o.displayName, unittest.equals('foo')); |
| unittest.expect(o.email, unittest.equals('foo')); |
| unittest.expect(o.etag, unittest.equals('foo')); |
| unittest.expect(o.name, unittest.equals('foo')); |
| unittest.expect(o.oauth2ClientId, unittest.equals('foo')); |
| unittest.expect(o.projectId, unittest.equals('foo')); |
| unittest.expect(o.uniqueId, unittest.equals('foo')); |
| } |
| buildCounterServiceAccount--; |
| } |
| |
| core.int buildCounterServiceAccountKey = 0; |
| buildServiceAccountKey() { |
| var o = new api.ServiceAccountKey(); |
| buildCounterServiceAccountKey++; |
| if (buildCounterServiceAccountKey < 3) { |
| o.keyAlgorithm = "foo"; |
| o.name = "foo"; |
| o.privateKeyData = "foo"; |
| o.privateKeyType = "foo"; |
| o.publicKeyData = "foo"; |
| o.validAfterTime = "foo"; |
| o.validBeforeTime = "foo"; |
| } |
| buildCounterServiceAccountKey--; |
| return o; |
| } |
| |
| checkServiceAccountKey(api.ServiceAccountKey o) { |
| buildCounterServiceAccountKey++; |
| if (buildCounterServiceAccountKey < 3) { |
| unittest.expect(o.keyAlgorithm, unittest.equals('foo')); |
| unittest.expect(o.name, unittest.equals('foo')); |
| unittest.expect(o.privateKeyData, unittest.equals('foo')); |
| unittest.expect(o.privateKeyType, unittest.equals('foo')); |
| unittest.expect(o.publicKeyData, unittest.equals('foo')); |
| unittest.expect(o.validAfterTime, unittest.equals('foo')); |
| unittest.expect(o.validBeforeTime, unittest.equals('foo')); |
| } |
| buildCounterServiceAccountKey--; |
| } |
| |
| core.int buildCounterSetIamPolicyRequest = 0; |
| buildSetIamPolicyRequest() { |
| var o = new api.SetIamPolicyRequest(); |
| buildCounterSetIamPolicyRequest++; |
| if (buildCounterSetIamPolicyRequest < 3) { |
| o.policy = buildPolicy(); |
| } |
| buildCounterSetIamPolicyRequest--; |
| return o; |
| } |
| |
| checkSetIamPolicyRequest(api.SetIamPolicyRequest o) { |
| buildCounterSetIamPolicyRequest++; |
| if (buildCounterSetIamPolicyRequest < 3) { |
| checkPolicy(o.policy); |
| } |
| buildCounterSetIamPolicyRequest--; |
| } |
| |
| core.int buildCounterSignBlobRequest = 0; |
| buildSignBlobRequest() { |
| var o = new api.SignBlobRequest(); |
| buildCounterSignBlobRequest++; |
| if (buildCounterSignBlobRequest < 3) { |
| o.bytesToSign = "foo"; |
| } |
| buildCounterSignBlobRequest--; |
| return o; |
| } |
| |
| checkSignBlobRequest(api.SignBlobRequest o) { |
| buildCounterSignBlobRequest++; |
| if (buildCounterSignBlobRequest < 3) { |
| unittest.expect(o.bytesToSign, unittest.equals('foo')); |
| } |
| buildCounterSignBlobRequest--; |
| } |
| |
| core.int buildCounterSignBlobResponse = 0; |
| buildSignBlobResponse() { |
| var o = new api.SignBlobResponse(); |
| buildCounterSignBlobResponse++; |
| if (buildCounterSignBlobResponse < 3) { |
| o.keyId = "foo"; |
| o.signature = "foo"; |
| } |
| buildCounterSignBlobResponse--; |
| return o; |
| } |
| |
| checkSignBlobResponse(api.SignBlobResponse o) { |
| buildCounterSignBlobResponse++; |
| if (buildCounterSignBlobResponse < 3) { |
| unittest.expect(o.keyId, unittest.equals('foo')); |
| unittest.expect(o.signature, unittest.equals('foo')); |
| } |
| buildCounterSignBlobResponse--; |
| } |
| |
| core.int buildCounterSignJwtRequest = 0; |
| buildSignJwtRequest() { |
| var o = new api.SignJwtRequest(); |
| buildCounterSignJwtRequest++; |
| if (buildCounterSignJwtRequest < 3) { |
| o.payload = "foo"; |
| } |
| buildCounterSignJwtRequest--; |
| return o; |
| } |
| |
| checkSignJwtRequest(api.SignJwtRequest o) { |
| buildCounterSignJwtRequest++; |
| if (buildCounterSignJwtRequest < 3) { |
| unittest.expect(o.payload, unittest.equals('foo')); |
| } |
| buildCounterSignJwtRequest--; |
| } |
| |
| core.int buildCounterSignJwtResponse = 0; |
| buildSignJwtResponse() { |
| var o = new api.SignJwtResponse(); |
| buildCounterSignJwtResponse++; |
| if (buildCounterSignJwtResponse < 3) { |
| o.keyId = "foo"; |
| o.signedJwt = "foo"; |
| } |
| buildCounterSignJwtResponse--; |
| return o; |
| } |
| |
| checkSignJwtResponse(api.SignJwtResponse o) { |
| buildCounterSignJwtResponse++; |
| if (buildCounterSignJwtResponse < 3) { |
| unittest.expect(o.keyId, unittest.equals('foo')); |
| unittest.expect(o.signedJwt, unittest.equals('foo')); |
| } |
| buildCounterSignJwtResponse--; |
| } |
| |
| buildUnnamed1115() { |
| var o = new core.List<core.String>(); |
| o.add("foo"); |
| o.add("foo"); |
| return o; |
| } |
| |
| checkUnnamed1115(core.List<core.String> o) { |
| unittest.expect(o, unittest.hasLength(2)); |
| unittest.expect(o[0], unittest.equals('foo')); |
| unittest.expect(o[1], unittest.equals('foo')); |
| } |
| |
| core.int buildCounterTestIamPermissionsRequest = 0; |
| buildTestIamPermissionsRequest() { |
| var o = new api.TestIamPermissionsRequest(); |
| buildCounterTestIamPermissionsRequest++; |
| if (buildCounterTestIamPermissionsRequest < 3) { |
| o.permissions = buildUnnamed1115(); |
| } |
| buildCounterTestIamPermissionsRequest--; |
| return o; |
| } |
| |
| checkTestIamPermissionsRequest(api.TestIamPermissionsRequest o) { |
| buildCounterTestIamPermissionsRequest++; |
| if (buildCounterTestIamPermissionsRequest < 3) { |
| checkUnnamed1115(o.permissions); |
| } |
| buildCounterTestIamPermissionsRequest--; |
| } |
| |
| buildUnnamed1116() { |
| var o = new core.List<core.String>(); |
| o.add("foo"); |
| o.add("foo"); |
| return o; |
| } |
| |
| checkUnnamed1116(core.List<core.String> o) { |
| unittest.expect(o, unittest.hasLength(2)); |
| unittest.expect(o[0], unittest.equals('foo')); |
| unittest.expect(o[1], unittest.equals('foo')); |
| } |
| |
| core.int buildCounterTestIamPermissionsResponse = 0; |
| buildTestIamPermissionsResponse() { |
| var o = new api.TestIamPermissionsResponse(); |
| buildCounterTestIamPermissionsResponse++; |
| if (buildCounterTestIamPermissionsResponse < 3) { |
| o.permissions = buildUnnamed1116(); |
| } |
| buildCounterTestIamPermissionsResponse--; |
| return o; |
| } |
| |
| checkTestIamPermissionsResponse(api.TestIamPermissionsResponse o) { |
| buildCounterTestIamPermissionsResponse++; |
| if (buildCounterTestIamPermissionsResponse < 3) { |
| checkUnnamed1116(o.permissions); |
| } |
| buildCounterTestIamPermissionsResponse--; |
| } |
| |
| buildUnnamed1117() { |
| var o = new core.List<core.String>(); |
| o.add("foo"); |
| o.add("foo"); |
| return o; |
| } |
| |
| checkUnnamed1117(core.List<core.String> o) { |
| unittest.expect(o, unittest.hasLength(2)); |
| unittest.expect(o[0], unittest.equals('foo')); |
| unittest.expect(o[1], unittest.equals('foo')); |
| } |
| |
| |
| main() { |
| unittest.group("obj-schema-AuditData", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildAuditData(); |
| var od = new api.AuditData.fromJson(o.toJson()); |
| checkAuditData(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-Binding", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildBinding(); |
| var od = new api.Binding.fromJson(o.toJson()); |
| checkBinding(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-BindingDelta", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildBindingDelta(); |
| var od = new api.BindingDelta.fromJson(o.toJson()); |
| checkBindingDelta(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-CreateServiceAccountKeyRequest", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildCreateServiceAccountKeyRequest(); |
| var od = new api.CreateServiceAccountKeyRequest.fromJson(o.toJson()); |
| checkCreateServiceAccountKeyRequest(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-CreateServiceAccountRequest", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildCreateServiceAccountRequest(); |
| var od = new api.CreateServiceAccountRequest.fromJson(o.toJson()); |
| checkCreateServiceAccountRequest(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-Empty", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildEmpty(); |
| var od = new api.Empty.fromJson(o.toJson()); |
| checkEmpty(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-ListServiceAccountKeysResponse", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildListServiceAccountKeysResponse(); |
| var od = new api.ListServiceAccountKeysResponse.fromJson(o.toJson()); |
| checkListServiceAccountKeysResponse(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-ListServiceAccountsResponse", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildListServiceAccountsResponse(); |
| var od = new api.ListServiceAccountsResponse.fromJson(o.toJson()); |
| checkListServiceAccountsResponse(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-Policy", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildPolicy(); |
| var od = new api.Policy.fromJson(o.toJson()); |
| checkPolicy(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-PolicyDelta", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildPolicyDelta(); |
| var od = new api.PolicyDelta.fromJson(o.toJson()); |
| checkPolicyDelta(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-QueryGrantableRolesRequest", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildQueryGrantableRolesRequest(); |
| var od = new api.QueryGrantableRolesRequest.fromJson(o.toJson()); |
| checkQueryGrantableRolesRequest(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-QueryGrantableRolesResponse", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildQueryGrantableRolesResponse(); |
| var od = new api.QueryGrantableRolesResponse.fromJson(o.toJson()); |
| checkQueryGrantableRolesResponse(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-Role", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildRole(); |
| var od = new api.Role.fromJson(o.toJson()); |
| checkRole(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-ServiceAccount", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildServiceAccount(); |
| var od = new api.ServiceAccount.fromJson(o.toJson()); |
| checkServiceAccount(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-ServiceAccountKey", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildServiceAccountKey(); |
| var od = new api.ServiceAccountKey.fromJson(o.toJson()); |
| checkServiceAccountKey(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-SetIamPolicyRequest", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildSetIamPolicyRequest(); |
| var od = new api.SetIamPolicyRequest.fromJson(o.toJson()); |
| checkSetIamPolicyRequest(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-SignBlobRequest", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildSignBlobRequest(); |
| var od = new api.SignBlobRequest.fromJson(o.toJson()); |
| checkSignBlobRequest(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-SignBlobResponse", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildSignBlobResponse(); |
| var od = new api.SignBlobResponse.fromJson(o.toJson()); |
| checkSignBlobResponse(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-SignJwtRequest", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildSignJwtRequest(); |
| var od = new api.SignJwtRequest.fromJson(o.toJson()); |
| checkSignJwtRequest(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-SignJwtResponse", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildSignJwtResponse(); |
| var od = new api.SignJwtResponse.fromJson(o.toJson()); |
| checkSignJwtResponse(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-TestIamPermissionsRequest", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildTestIamPermissionsRequest(); |
| var od = new api.TestIamPermissionsRequest.fromJson(o.toJson()); |
| checkTestIamPermissionsRequest(od); |
| }); |
| }); |
| |
| |
| unittest.group("obj-schema-TestIamPermissionsResponse", () { |
| unittest.test("to-json--from-json", () { |
| var o = buildTestIamPermissionsResponse(); |
| var od = new api.TestIamPermissionsResponse.fromJson(o.toJson()); |
| checkTestIamPermissionsResponse(od); |
| }); |
| }); |
| |
| |
| unittest.group("resource-ProjectsServiceAccountsResourceApi", () { |
| unittest.test("method--create", () { |
| |
| var mock = new HttpServerMock(); |
| api.ProjectsServiceAccountsResourceApi res = new api.IamApi(mock).projects.serviceAccounts; |
| var arg_request = buildCreateServiceAccountRequest(); |
| var arg_name = "foo"; |
| mock.register(unittest.expectAsync((http.BaseRequest req, json) { |
| var obj = new api.CreateServiceAccountRequest.fromJson(json); |
| checkCreateServiceAccountRequest(obj); |
| |
| var path = (req.url).path; |
| var pathOffset = 0; |
| var index; |
| var subPart; |
| unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/")); |
| pathOffset += 1; |
| unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/")); |
| pathOffset += 3; |
| // NOTE: We cannot test reserved expansions due to the inability to reverse the operation; |
| |
| var query = (req.url).query; |
| var queryOffset = 0; |
| var queryMap = {}; |
| addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); |
| parseBool(n) { |
| if (n == "true") return true; |
| if (n == "false") return false; |
| if (n == null) return null; |
| throw new core.ArgumentError("Invalid boolean: $n"); |
| } |
| if (query.length > 0) { |
| for (var part in query.split("&")) { |
| var keyvalue = part.split("="); |
| addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1])); |
| } |
| } |
| |
| |
| var h = { |
| "content-type" : "application/json; charset=utf-8", |
| }; |
| var resp = convert.JSON.encode(buildServiceAccount()); |
| return new async.Future.value(stringResponse(200, h, resp)); |
| }), true); |
| res.create(arg_request, arg_name).then(unittest.expectAsync(((api.ServiceAccount response) { |
| checkServiceAccount(response); |
| }))); |
| }); |
| |
| unittest.test("method--delete", () { |
| |
| var mock = new HttpServerMock(); |
| api.ProjectsServiceAccountsResourceApi res = new api.IamApi(mock).projects.serviceAccounts; |
| var arg_name = "foo"; |
| mock.register(unittest.expectAsync((http.BaseRequest req, json) { |
| var path = (req.url).path; |
| var pathOffset = 0; |
| var index; |
| var subPart; |
| unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/")); |
| pathOffset += 1; |
| unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/")); |
| pathOffset += 3; |
| // NOTE: We cannot test reserved expansions due to the inability to reverse the operation; |
| |
| var query = (req.url).query; |
| var queryOffset = 0; |
| var queryMap = {}; |
| addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); |
| parseBool(n) { |
| if (n == "true") return true; |
| if (n == "false") return false; |
| if (n == null) return null; |
| throw new core.ArgumentError("Invalid boolean: $n"); |
| } |
| if (query.length > 0) { |
| for (var part in query.split("&")) { |
| var keyvalue = part.split("="); |
| addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1])); |
| } |
| } |
| |
| |
| var h = { |
| "content-type" : "application/json; charset=utf-8", |
| }; |
| var resp = convert.JSON.encode(buildEmpty()); |
| return new async.Future.value(stringResponse(200, h, resp)); |
| }), true); |
| res.delete(arg_name).then(unittest.expectAsync(((api.Empty response) { |
| checkEmpty(response); |
| }))); |
| }); |
| |
| unittest.test("method--get", () { |
| |
| var mock = new HttpServerMock(); |
| api.ProjectsServiceAccountsResourceApi res = new api.IamApi(mock).projects.serviceAccounts; |
| var arg_name = "foo"; |
| mock.register(unittest.expectAsync((http.BaseRequest req, json) { |
| var path = (req.url).path; |
| var pathOffset = 0; |
| var index; |
| var subPart; |
| unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/")); |
| pathOffset += 1; |
| unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/")); |
| pathOffset += 3; |
| // NOTE: We cannot test reserved expansions due to the inability to reverse the operation; |
| |
| var query = (req.url).query; |
| var queryOffset = 0; |
| var queryMap = {}; |
| addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); |
| parseBool(n) { |
| if (n == "true") return true; |
| if (n == "false") return false; |
| if (n == null) return null; |
| throw new core.ArgumentError("Invalid boolean: $n"); |
| } |
| if (query.length > 0) { |
| for (var part in query.split("&")) { |
| var keyvalue = part.split("="); |
| addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1])); |
| } |
| } |
| |
| |
| var h = { |
| "content-type" : "application/json; charset=utf-8", |
| }; |
| var resp = convert.JSON.encode(buildServiceAccount()); |
| return new async.Future.value(stringResponse(200, h, resp)); |
| }), true); |
| res.get(arg_name).then(unittest.expectAsync(((api.ServiceAccount response) { |
| checkServiceAccount(response); |
| }))); |
| }); |
| |
| unittest.test("method--getIamPolicy", () { |
| |
| var mock = new HttpServerMock(); |
| api.ProjectsServiceAccountsResourceApi res = new api.IamApi(mock).projects.serviceAccounts; |
| var arg_resource = "foo"; |
| mock.register(unittest.expectAsync((http.BaseRequest req, json) { |
| var path = (req.url).path; |
| var pathOffset = 0; |
| var index; |
| var subPart; |
| unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/")); |
| pathOffset += 1; |
| unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/")); |
| pathOffset += 3; |
| // NOTE: We cannot test reserved expansions due to the inability to reverse the operation; |
| |
| var query = (req.url).query; |
| var queryOffset = 0; |
| var queryMap = {}; |
| addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); |
| parseBool(n) { |
| if (n == "true") return true; |
| if (n == "false") return false; |
| if (n == null) return null; |
| throw new core.ArgumentError("Invalid boolean: $n"); |
| } |
| if (query.length > 0) { |
| for (var part in query.split("&")) { |
| var keyvalue = part.split("="); |
| addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1])); |
| } |
| } |
| |
| |
| var h = { |
| "content-type" : "application/json; charset=utf-8", |
| }; |
| var resp = convert.JSON.encode(buildPolicy()); |
| return new async.Future.value(stringResponse(200, h, resp)); |
| }), true); |
| res.getIamPolicy(arg_resource).then(unittest.expectAsync(((api.Policy response) { |
| checkPolicy(response); |
| }))); |
| }); |
| |
| unittest.test("method--list", () { |
| |
| var mock = new HttpServerMock(); |
| api.ProjectsServiceAccountsResourceApi res = new api.IamApi(mock).projects.serviceAccounts; |
| var arg_name = "foo"; |
| var arg_pageToken = "foo"; |
| var arg_pageSize = 42; |
| mock.register(unittest.expectAsync((http.BaseRequest req, json) { |
| var path = (req.url).path; |
| var pathOffset = 0; |
| var index; |
| var subPart; |
| unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/")); |
| pathOffset += 1; |
| unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/")); |
| pathOffset += 3; |
| // NOTE: We cannot test reserved expansions due to the inability to reverse the operation; |
| |
| var query = (req.url).query; |
| var queryOffset = 0; |
| var queryMap = {}; |
| addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); |
| parseBool(n) { |
| if (n == "true") return true; |
| if (n == "false") return false; |
| if (n == null) return null; |
| throw new core.ArgumentError("Invalid boolean: $n"); |
| } |
| if (query.length > 0) { |
| for (var part in query.split("&")) { |
| var keyvalue = part.split("="); |
| addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1])); |
| } |
| } |
| unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken)); |
| unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize)); |
| |
| |
| var h = { |
| "content-type" : "application/json; charset=utf-8", |
| }; |
| var resp = convert.JSON.encode(buildListServiceAccountsResponse()); |
| return new async.Future.value(stringResponse(200, h, resp)); |
| }), true); |
| res.list(arg_name, pageToken: arg_pageToken, pageSize: arg_pageSize).then(unittest.expectAsync(((api.ListServiceAccountsResponse response) { |
| checkListServiceAccountsResponse(response); |
| }))); |
| }); |
| |
| unittest.test("method--setIamPolicy", () { |
| |
| var mock = new HttpServerMock(); |
| api.ProjectsServiceAccountsResourceApi res = new api.IamApi(mock).projects.serviceAccounts; |
| var arg_request = buildSetIamPolicyRequest(); |
| var arg_resource = "foo"; |
| mock.register(unittest.expectAsync((http.BaseRequest req, json) { |
| var obj = new api.SetIamPolicyRequest.fromJson(json); |
| checkSetIamPolicyRequest(obj); |
| |
| var path = (req.url).path; |
| var pathOffset = 0; |
| var index; |
| var subPart; |
| unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/")); |
| pathOffset += 1; |
| unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/")); |
| pathOffset += 3; |
| // NOTE: We cannot test reserved expansions due to the inability to reverse the operation; |
| |
| var query = (req.url).query; |
| var queryOffset = 0; |
| var queryMap = {}; |
| addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); |
| parseBool(n) { |
| if (n == "true") return true; |
| if (n == "false") return false; |
| if (n == null) return null; |
| throw new core.ArgumentError("Invalid boolean: $n"); |
| } |
| if (query.length > 0) { |
| for (var part in query.split("&")) { |
| var keyvalue = part.split("="); |
| addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1])); |
| } |
| } |
| |
| |
| var h = { |
| "content-type" : "application/json; charset=utf-8", |
| }; |
| var resp = convert.JSON.encode(buildPolicy()); |
| return new async.Future.value(stringResponse(200, h, resp)); |
| }), true); |
| res.setIamPolicy(arg_request, arg_resource).then(unittest.expectAsync(((api.Policy response) { |
| checkPolicy(response); |
| }))); |
| }); |
| |
| unittest.test("method--signBlob", () { |
| |
| var mock = new HttpServerMock(); |
| api.ProjectsServiceAccountsResourceApi res = new api.IamApi(mock).projects.serviceAccounts; |
| var arg_request = buildSignBlobRequest(); |
| var arg_name = "foo"; |
| mock.register(unittest.expectAsync((http.BaseRequest req, json) { |
| var obj = new api.SignBlobRequest.fromJson(json); |
| checkSignBlobRequest(obj); |
| |
| var path = (req.url).path; |
| var pathOffset = 0; |
| var index; |
| var subPart; |
| unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/")); |
| pathOffset += 1; |
| unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/")); |
| pathOffset += 3; |
| // NOTE: We cannot test reserved expansions due to the inability to reverse the operation; |
| |
| var query = (req.url).query; |
| var queryOffset = 0; |
| var queryMap = {}; |
| addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); |
| parseBool(n) { |
| if (n == "true") return true; |
| if (n == "false") return false; |
| if (n == null) return null; |
| throw new core.ArgumentError("Invalid boolean: $n"); |
| } |
| if (query.length > 0) { |
| for (var part in query.split("&")) { |
| var keyvalue = part.split("="); |
| addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1])); |
| } |
| } |
| |
| |
| var h = { |
| "content-type" : "application/json; charset=utf-8", |
| }; |
| var resp = convert.JSON.encode(buildSignBlobResponse()); |
| return new async.Future.value(stringResponse(200, h, resp)); |
| }), true); |
| res.signBlob(arg_request, arg_name).then(unittest.expectAsync(((api.SignBlobResponse response) { |
| checkSignBlobResponse(response); |
| }))); |
| }); |
| |
| unittest.test("method--signJwt", () { |
| |
| var mock = new HttpServerMock(); |
| api.ProjectsServiceAccountsResourceApi res = new api.IamApi(mock).projects.serviceAccounts; |
| var arg_request = buildSignJwtRequest(); |
| var arg_name = "foo"; |
| mock.register(unittest.expectAsync((http.BaseRequest req, json) { |
| var obj = new api.SignJwtRequest.fromJson(json); |
| checkSignJwtRequest(obj); |
| |
| var path = (req.url).path; |
| var pathOffset = 0; |
| var index; |
| var subPart; |
| unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/")); |
| pathOffset += 1; |
| unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/")); |
| pathOffset += 3; |
| // NOTE: We cannot test reserved expansions due to the inability to reverse the operation; |
| |
| var query = (req.url).query; |
| var queryOffset = 0; |
| var queryMap = {}; |
| addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); |
| parseBool(n) { |
| if (n == "true") return true; |
| if (n == "false") return false; |
| if (n == null) return null; |
| throw new core.ArgumentError("Invalid boolean: $n"); |
| } |
| if (query.length > 0) { |
| for (var part in query.split("&")) { |
| var keyvalue = part.split("="); |
| addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1])); |
| } |
| } |
| |
| |
| var h = { |
| "content-type" : "application/json; charset=utf-8", |
| }; |
| var resp = convert.JSON.encode(buildSignJwtResponse()); |
| return new async.Future.value(stringResponse(200, h, resp)); |
| }), true); |
| res.signJwt(arg_request, arg_name).then(unittest.expectAsync(((api.SignJwtResponse response) { |
| checkSignJwtResponse(response); |
| }))); |
| }); |
| |
| unittest.test("method--testIamPermissions", () { |
| |
| var mock = new HttpServerMock(); |
| api.ProjectsServiceAccountsResourceApi res = new api.IamApi(mock).projects.serviceAccounts; |
| var arg_request = buildTestIamPermissionsRequest(); |
| var arg_resource = "foo"; |
| mock.register(unittest.expectAsync((http.BaseRequest req, json) { |
| var obj = new api.TestIamPermissionsRequest.fromJson(json); |
| checkTestIamPermissionsRequest(obj); |
| |
| var path = (req.url).path; |
| var pathOffset = 0; |
| var index; |
| var subPart; |
| unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/")); |
| pathOffset += 1; |
| unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/")); |
| pathOffset += 3; |
| // NOTE: We cannot test reserved expansions due to the inability to reverse the operation; |
| |
| var query = (req.url).query; |
| var queryOffset = 0; |
| var queryMap = {}; |
| addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); |
| parseBool(n) { |
| if (n == "true") return true; |
| if (n == "false") return false; |
| if (n == null) return null; |
| throw new core.ArgumentError("Invalid boolean: $n"); |
| } |
| if (query.length > 0) { |
| for (var part in query.split("&")) { |
| var keyvalue = part.split("="); |
| addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1])); |
| } |
| } |
| |
| |
| var h = { |
| "content-type" : "application/json; charset=utf-8", |
| }; |
| var resp = convert.JSON.encode(buildTestIamPermissionsResponse()); |
| return new async.Future.value(stringResponse(200, h, resp)); |
| }), true); |
| res.testIamPermissions(arg_request, arg_resource).then(unittest.expectAsync(((api.TestIamPermissionsResponse response) { |
| checkTestIamPermissionsResponse(response); |
| }))); |
| }); |
| |
| unittest.test("method--update", () { |
| |
| var mock = new HttpServerMock(); |
| api.ProjectsServiceAccountsResourceApi res = new api.IamApi(mock).projects.serviceAccounts; |
| var arg_request = buildServiceAccount(); |
| var arg_name = "foo"; |
| mock.register(unittest.expectAsync((http.BaseRequest req, json) { |
| var obj = new api.ServiceAccount.fromJson(json); |
| checkServiceAccount(obj); |
| |
| var path = (req.url).path; |
| var pathOffset = 0; |
| var index; |
| var subPart; |
| unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/")); |
| pathOffset += 1; |
| unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/")); |
| pathOffset += 3; |
| // NOTE: We cannot test reserved expansions due to the inability to reverse the operation; |
| |
| var query = (req.url).query; |
| var queryOffset = 0; |
| var queryMap = {}; |
| addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); |
| parseBool(n) { |
| if (n == "true") return true; |
| if (n == "false") return false; |
| if (n == null) return null; |
| throw new core.ArgumentError("Invalid boolean: $n"); |
| } |
| if (query.length > 0) { |
| for (var part in query.split("&")) { |
| var keyvalue = part.split("="); |
| addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1])); |
| } |
| } |
| |
| |
| var h = { |
| "content-type" : "application/json; charset=utf-8", |
| }; |
| var resp = convert.JSON.encode(buildServiceAccount()); |
| return new async.Future.value(stringResponse(200, h, resp)); |
| }), true); |
| res.update(arg_request, arg_name).then(unittest.expectAsync(((api.ServiceAccount response) { |
| checkServiceAccount(response); |
| }))); |
| }); |
| |
| }); |
| |
| |
| unittest.group("resource-ProjectsServiceAccountsKeysResourceApi", () { |
| unittest.test("method--create", () { |
| |
| var mock = new HttpServerMock(); |
| api.ProjectsServiceAccountsKeysResourceApi res = new api.IamApi(mock).projects.serviceAccounts.keys; |
| var arg_request = buildCreateServiceAccountKeyRequest(); |
| var arg_name = "foo"; |
| mock.register(unittest.expectAsync((http.BaseRequest req, json) { |
| var obj = new api.CreateServiceAccountKeyRequest.fromJson(json); |
| checkCreateServiceAccountKeyRequest(obj); |
| |
| var path = (req.url).path; |
| var pathOffset = 0; |
| var index; |
| var subPart; |
| unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/")); |
| pathOffset += 1; |
| unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/")); |
| pathOffset += 3; |
| // NOTE: We cannot test reserved expansions due to the inability to reverse the operation; |
| |
| var query = (req.url).query; |
| var queryOffset = 0; |
| var queryMap = {}; |
| addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); |
| parseBool(n) { |
| if (n == "true") return true; |
| if (n == "false") return false; |
| if (n == null) return null; |
| throw new core.ArgumentError("Invalid boolean: $n"); |
| } |
| if (query.length > 0) { |
| for (var part in query.split("&")) { |
| var keyvalue = part.split("="); |
| addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1])); |
| } |
| } |
| |
| |
| var h = { |
| "content-type" : "application/json; charset=utf-8", |
| }; |
| var resp = convert.JSON.encode(buildServiceAccountKey()); |
| return new async.Future.value(stringResponse(200, h, resp)); |
| }), true); |
| res.create(arg_request, arg_name).then(unittest.expectAsync(((api.ServiceAccountKey response) { |
| checkServiceAccountKey(response); |
| }))); |
| }); |
| |
| unittest.test("method--delete", () { |
| |
| var mock = new HttpServerMock(); |
| api.ProjectsServiceAccountsKeysResourceApi res = new api.IamApi(mock).projects.serviceAccounts.keys; |
| var arg_name = "foo"; |
| mock.register(unittest.expectAsync((http.BaseRequest req, json) { |
| var path = (req.url).path; |
| var pathOffset = 0; |
| var index; |
| var subPart; |
| unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/")); |
| pathOffset += 1; |
| unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/")); |
| pathOffset += 3; |
| // NOTE: We cannot test reserved expansions due to the inability to reverse the operation; |
| |
| var query = (req.url).query; |
| var queryOffset = 0; |
| var queryMap = {}; |
| addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); |
| parseBool(n) { |
| if (n == "true") return true; |
| if (n == "false") return false; |
| if (n == null) return null; |
| throw new core.ArgumentError("Invalid boolean: $n"); |
| } |
| if (query.length > 0) { |
| for (var part in query.split("&")) { |
| var keyvalue = part.split("="); |
| addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1])); |
| } |
| } |
| |
| |
| var h = { |
| "content-type" : "application/json; charset=utf-8", |
| }; |
| var resp = convert.JSON.encode(buildEmpty()); |
| return new async.Future.value(stringResponse(200, h, resp)); |
| }), true); |
| res.delete(arg_name).then(unittest.expectAsync(((api.Empty response) { |
| checkEmpty(response); |
| }))); |
| }); |
| |
| unittest.test("method--get", () { |
| |
| var mock = new HttpServerMock(); |
| api.ProjectsServiceAccountsKeysResourceApi res = new api.IamApi(mock).projects.serviceAccounts.keys; |
| var arg_name = "foo"; |
| var arg_publicKeyType = "foo"; |
| mock.register(unittest.expectAsync((http.BaseRequest req, json) { |
| var path = (req.url).path; |
| var pathOffset = 0; |
| var index; |
| var subPart; |
| unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/")); |
| pathOffset += 1; |
| unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/")); |
| pathOffset += 3; |
| // NOTE: We cannot test reserved expansions due to the inability to reverse the operation; |
| |
| var query = (req.url).query; |
| var queryOffset = 0; |
| var queryMap = {}; |
| addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); |
| parseBool(n) { |
| if (n == "true") return true; |
| if (n == "false") return false; |
| if (n == null) return null; |
| throw new core.ArgumentError("Invalid boolean: $n"); |
| } |
| if (query.length > 0) { |
| for (var part in query.split("&")) { |
| var keyvalue = part.split("="); |
| addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1])); |
| } |
| } |
| unittest.expect(queryMap["publicKeyType"].first, unittest.equals(arg_publicKeyType)); |
| |
| |
| var h = { |
| "content-type" : "application/json; charset=utf-8", |
| }; |
| var resp = convert.JSON.encode(buildServiceAccountKey()); |
| return new async.Future.value(stringResponse(200, h, resp)); |
| }), true); |
| res.get(arg_name, publicKeyType: arg_publicKeyType).then(unittest.expectAsync(((api.ServiceAccountKey response) { |
| checkServiceAccountKey(response); |
| }))); |
| }); |
| |
| unittest.test("method--list", () { |
| |
| var mock = new HttpServerMock(); |
| api.ProjectsServiceAccountsKeysResourceApi res = new api.IamApi(mock).projects.serviceAccounts.keys; |
| var arg_name = "foo"; |
| var arg_keyTypes = buildUnnamed1117(); |
| mock.register(unittest.expectAsync((http.BaseRequest req, json) { |
| var path = (req.url).path; |
| var pathOffset = 0; |
| var index; |
| var subPart; |
| unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/")); |
| pathOffset += 1; |
| unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/")); |
| pathOffset += 3; |
| // NOTE: We cannot test reserved expansions due to the inability to reverse the operation; |
| |
| var query = (req.url).query; |
| var queryOffset = 0; |
| var queryMap = {}; |
| addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); |
| parseBool(n) { |
| if (n == "true") return true; |
| if (n == "false") return false; |
| if (n == null) return null; |
| throw new core.ArgumentError("Invalid boolean: $n"); |
| } |
| if (query.length > 0) { |
| for (var part in query.split("&")) { |
| var keyvalue = part.split("="); |
| addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1])); |
| } |
| } |
| unittest.expect(queryMap["keyTypes"], unittest.equals(arg_keyTypes)); |
| |
| |
| var h = { |
| "content-type" : "application/json; charset=utf-8", |
| }; |
| var resp = convert.JSON.encode(buildListServiceAccountKeysResponse()); |
| return new async.Future.value(stringResponse(200, h, resp)); |
| }), true); |
| res.list(arg_name, keyTypes: arg_keyTypes).then(unittest.expectAsync(((api.ListServiceAccountKeysResponse response) { |
| checkListServiceAccountKeysResponse(response); |
| }))); |
| }); |
| |
| }); |
| |
| |
| unittest.group("resource-RolesResourceApi", () { |
| unittest.test("method--queryGrantableRoles", () { |
| |
| var mock = new HttpServerMock(); |
| api.RolesResourceApi res = new api.IamApi(mock).roles; |
| var arg_request = buildQueryGrantableRolesRequest(); |
| mock.register(unittest.expectAsync((http.BaseRequest req, json) { |
| var obj = new api.QueryGrantableRolesRequest.fromJson(json); |
| checkQueryGrantableRolesRequest(obj); |
| |
| var path = (req.url).path; |
| var pathOffset = 0; |
| var index; |
| var subPart; |
| unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/")); |
| pathOffset += 1; |
| unittest.expect(path.substring(pathOffset, pathOffset + 28), unittest.equals("v1/roles:queryGrantableRoles")); |
| pathOffset += 28; |
| |
| var query = (req.url).query; |
| var queryOffset = 0; |
| var queryMap = {}; |
| addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v); |
| parseBool(n) { |
| if (n == "true") return true; |
| if (n == "false") return false; |
| if (n == null) return null; |
| throw new core.ArgumentError("Invalid boolean: $n"); |
| } |
| if (query.length > 0) { |
| for (var part in query.split("&")) { |
| var keyvalue = part.split("="); |
| addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1])); |
| } |
| } |
| |
| |
| var h = { |
| "content-type" : "application/json; charset=utf-8", |
| }; |
| var resp = convert.JSON.encode(buildQueryGrantableRolesResponse()); |
| return new async.Future.value(stringResponse(200, h, resp)); |
| }), true); |
| res.queryGrantableRoles(arg_request).then(unittest.expectAsync(((api.QueryGrantableRolesResponse response) { |
| checkQueryGrantableRolesResponse(response); |
| }))); |
| }); |
| |
| }); |
| |
| |
| } |
| |
