Api-roll 64: 2018-08-27

generated/googleapis/test/iamcredentials/v1_test.dart

diff --git a/generated/googleapis/test/iamcredentials/v1_test.dart b/generated/googleapis/test/iamcredentials/v1_test.dart
new file mode 100644
index 0000000..472ab25
--- /dev/null
+++ b/generated/googleapis/test/iamcredentials/v1_test.dart
@@ -0,0 +1,578 @@
+library googleapis.iamcredentials.v1.test;
+
+import "dart:core" as core;
+import "dart:async" as async;
+import "dart:convert" as convert;
+
+import 'package:http/http.dart' as http;
+import 'package:test/test.dart' as unittest;
+
+import 'package:googleapis/iamcredentials/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<core.String, core.String> headers, core.String body) {
+  var stream = new async.Stream.fromIterable([convert.utf8.encode(body)]);
+  return new http.StreamedResponse(stream, status, headers: headers);
+}
+
+buildUnnamed4875() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed4875(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'));
+}
+
+buildUnnamed4876() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed4876(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 buildCounterGenerateAccessTokenRequest = 0;
+buildGenerateAccessTokenRequest() {
+  var o = new api.GenerateAccessTokenRequest();
+  buildCounterGenerateAccessTokenRequest++;
+  if (buildCounterGenerateAccessTokenRequest < 3) {
+    o.delegates = buildUnnamed4875();
+    o.lifetime = "foo";
+    o.scope = buildUnnamed4876();
+  }
+  buildCounterGenerateAccessTokenRequest--;
+  return o;
+}
+
+checkGenerateAccessTokenRequest(api.GenerateAccessTokenRequest o) {
+  buildCounterGenerateAccessTokenRequest++;
+  if (buildCounterGenerateAccessTokenRequest < 3) {
+    checkUnnamed4875(o.delegates);
+    unittest.expect(o.lifetime, unittest.equals('foo'));
+    checkUnnamed4876(o.scope);
+  }
+  buildCounterGenerateAccessTokenRequest--;
+}
+
+core.int buildCounterGenerateAccessTokenResponse = 0;
+buildGenerateAccessTokenResponse() {
+  var o = new api.GenerateAccessTokenResponse();
+  buildCounterGenerateAccessTokenResponse++;
+  if (buildCounterGenerateAccessTokenResponse < 3) {
+    o.accessToken = "foo";
+    o.expireTime = "foo";
+  }
+  buildCounterGenerateAccessTokenResponse--;
+  return o;
+}
+
+checkGenerateAccessTokenResponse(api.GenerateAccessTokenResponse o) {
+  buildCounterGenerateAccessTokenResponse++;
+  if (buildCounterGenerateAccessTokenResponse < 3) {
+    unittest.expect(o.accessToken, unittest.equals('foo'));
+    unittest.expect(o.expireTime, unittest.equals('foo'));
+  }
+  buildCounterGenerateAccessTokenResponse--;
+}
+
+buildUnnamed4877() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed4877(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 buildCounterGenerateIdTokenRequest = 0;
+buildGenerateIdTokenRequest() {
+  var o = new api.GenerateIdTokenRequest();
+  buildCounterGenerateIdTokenRequest++;
+  if (buildCounterGenerateIdTokenRequest < 3) {
+    o.audience = "foo";
+    o.delegates = buildUnnamed4877();
+    o.includeEmail = true;
+  }
+  buildCounterGenerateIdTokenRequest--;
+  return o;
+}
+
+checkGenerateIdTokenRequest(api.GenerateIdTokenRequest o) {
+  buildCounterGenerateIdTokenRequest++;
+  if (buildCounterGenerateIdTokenRequest < 3) {
+    unittest.expect(o.audience, unittest.equals('foo'));
+    checkUnnamed4877(o.delegates);
+    unittest.expect(o.includeEmail, unittest.isTrue);
+  }
+  buildCounterGenerateIdTokenRequest--;
+}
+
+core.int buildCounterGenerateIdTokenResponse = 0;
+buildGenerateIdTokenResponse() {
+  var o = new api.GenerateIdTokenResponse();
+  buildCounterGenerateIdTokenResponse++;
+  if (buildCounterGenerateIdTokenResponse < 3) {
+    o.token = "foo";
+  }
+  buildCounterGenerateIdTokenResponse--;
+  return o;
+}
+
+checkGenerateIdTokenResponse(api.GenerateIdTokenResponse o) {
+  buildCounterGenerateIdTokenResponse++;
+  if (buildCounterGenerateIdTokenResponse < 3) {
+    unittest.expect(o.token, unittest.equals('foo'));
+  }
+  buildCounterGenerateIdTokenResponse--;
+}
+
+buildUnnamed4878() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed4878(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 buildCounterSignBlobRequest = 0;
+buildSignBlobRequest() {
+  var o = new api.SignBlobRequest();
+  buildCounterSignBlobRequest++;
+  if (buildCounterSignBlobRequest < 3) {
+    o.delegates = buildUnnamed4878();
+    o.payload = "foo";
+  }
+  buildCounterSignBlobRequest--;
+  return o;
+}
+
+checkSignBlobRequest(api.SignBlobRequest o) {
+  buildCounterSignBlobRequest++;
+  if (buildCounterSignBlobRequest < 3) {
+    checkUnnamed4878(o.delegates);
+    unittest.expect(o.payload, unittest.equals('foo'));
+  }
+  buildCounterSignBlobRequest--;
+}
+
+core.int buildCounterSignBlobResponse = 0;
+buildSignBlobResponse() {
+  var o = new api.SignBlobResponse();
+  buildCounterSignBlobResponse++;
+  if (buildCounterSignBlobResponse < 3) {
+    o.keyId = "foo";
+    o.signedBlob = "foo";
+  }
+  buildCounterSignBlobResponse--;
+  return o;
+}
+
+checkSignBlobResponse(api.SignBlobResponse o) {
+  buildCounterSignBlobResponse++;
+  if (buildCounterSignBlobResponse < 3) {
+    unittest.expect(o.keyId, unittest.equals('foo'));
+    unittest.expect(o.signedBlob, unittest.equals('foo'));
+  }
+  buildCounterSignBlobResponse--;
+}
+
+buildUnnamed4879() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed4879(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 buildCounterSignJwtRequest = 0;
+buildSignJwtRequest() {
+  var o = new api.SignJwtRequest();
+  buildCounterSignJwtRequest++;
+  if (buildCounterSignJwtRequest < 3) {
+    o.delegates = buildUnnamed4879();
+    o.payload = "foo";
+  }
+  buildCounterSignJwtRequest--;
+  return o;
+}
+
+checkSignJwtRequest(api.SignJwtRequest o) {
+  buildCounterSignJwtRequest++;
+  if (buildCounterSignJwtRequest < 3) {
+    checkUnnamed4879(o.delegates);
+    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--;
+}
+
+main() {
+  unittest.group("obj-schema-GenerateAccessTokenRequest", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildGenerateAccessTokenRequest();
+      var od = new api.GenerateAccessTokenRequest.fromJson(o.toJson());
+      checkGenerateAccessTokenRequest(od);
+    });
+  });
+
+  unittest.group("obj-schema-GenerateAccessTokenResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildGenerateAccessTokenResponse();
+      var od = new api.GenerateAccessTokenResponse.fromJson(o.toJson());
+      checkGenerateAccessTokenResponse(od);
+    });
+  });
+
+  unittest.group("obj-schema-GenerateIdTokenRequest", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildGenerateIdTokenRequest();
+      var od = new api.GenerateIdTokenRequest.fromJson(o.toJson());
+      checkGenerateIdTokenRequest(od);
+    });
+  });
+
+  unittest.group("obj-schema-GenerateIdTokenResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildGenerateIdTokenResponse();
+      var od = new api.GenerateIdTokenResponse.fromJson(o.toJson());
+      checkGenerateIdTokenResponse(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("resource-ProjectsServiceAccountsResourceApi", () {
+    unittest.test("method--generateAccessToken", () {
+      var mock = new HttpServerMock();
+      api.ProjectsServiceAccountsResourceApi res =
+          new api.IamcredentialsApi(mock).projects.serviceAccounts;
+      var arg_request = buildGenerateAccessTokenRequest();
+      var arg_name = "foo";
+      var arg_$fields = "foo";
+      mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
+        var obj = new api.GenerateAccessTokenRequest.fromJson(json);
+        checkGenerateAccessTokenRequest(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 = <core.String, core.List<core.String>>{};
+        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["fields"].first, unittest.equals(arg_$fields));
+
+        var h = {
+          "content-type": "application/json; charset=utf-8",
+        };
+        var resp = convert.json.encode(buildGenerateAccessTokenResponse());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res
+          .generateAccessToken(arg_request, arg_name, $fields: arg_$fields)
+          .then(unittest.expectAsync1(((response) {
+        checkGenerateAccessTokenResponse(response);
+      })));
+    });
+
+    unittest.test("method--generateIdToken", () {
+      var mock = new HttpServerMock();
+      api.ProjectsServiceAccountsResourceApi res =
+          new api.IamcredentialsApi(mock).projects.serviceAccounts;
+      var arg_request = buildGenerateIdTokenRequest();
+      var arg_name = "foo";
+      var arg_$fields = "foo";
+      mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
+        var obj = new api.GenerateIdTokenRequest.fromJson(json);
+        checkGenerateIdTokenRequest(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 = <core.String, core.List<core.String>>{};
+        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["fields"].first, unittest.equals(arg_$fields));
+
+        var h = {
+          "content-type": "application/json; charset=utf-8",
+        };
+        var resp = convert.json.encode(buildGenerateIdTokenResponse());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res
+          .generateIdToken(arg_request, arg_name, $fields: arg_$fields)
+          .then(unittest.expectAsync1(((response) {
+        checkGenerateIdTokenResponse(response);
+      })));
+    });
+
+    unittest.test("method--signBlob", () {
+      var mock = new HttpServerMock();
+      api.ProjectsServiceAccountsResourceApi res =
+          new api.IamcredentialsApi(mock).projects.serviceAccounts;
+      var arg_request = buildSignBlobRequest();
+      var arg_name = "foo";
+      var arg_$fields = "foo";
+      mock.register(unittest.expectAsync2((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 = <core.String, core.List<core.String>>{};
+        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["fields"].first, unittest.equals(arg_$fields));
+
+        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, $fields: arg_$fields)
+          .then(unittest.expectAsync1(((response) {
+        checkSignBlobResponse(response);
+      })));
+    });
+
+    unittest.test("method--signJwt", () {
+      var mock = new HttpServerMock();
+      api.ProjectsServiceAccountsResourceApi res =
+          new api.IamcredentialsApi(mock).projects.serviceAccounts;
+      var arg_request = buildSignJwtRequest();
+      var arg_name = "foo";
+      var arg_$fields = "foo";
+      mock.register(unittest.expectAsync2((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 = <core.String, core.List<core.String>>{};
+        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["fields"].first, unittest.equals(arg_$fields));
+
+        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, $fields: arg_$fields)
+          .then(unittest.expectAsync1(((response) {
+        checkSignJwtResponse(response);
+      })));
+    });
+  });
+}