Merge branch 'worktree-agent-acef51f9a1658599e'

This commit is contained in:
2026-10-25 15:24:28 +01:00
24 changed files with 3949 additions and 3 deletions
@@ -0,0 +1,62 @@
// Routes: POST /google/workspace/call, /list, /delegation
// Reads: 422 on bad input, 503 google_not_configured without a credential.
// Writes, deletes and sends: dry run unless confirm:true. Nothing reaches Google.
#include "support/GoogleRig.hpp"
using namespace molo::example::test;
int main() {
GoogleRig rig(false);
Fixture f(rig.client);
const char* json = "application/json";
auto post = [&](const char* path, const std::string& body) { return f.client->post(path, body, json); };
auto read = post("/google/workspace/call", "{\"api\":\"gmail\",\"id\":\"gmail.users.getProfile\",\"params\":{\"userId\":\"me\"}}");
check(read.status == 503 && contains(read.body, "google_not_configured"), "valid read without credential is 503");
check(post("/google/workspace/call", "{}").status == 422, "api and id required");
check(post("/google/workspace/call", "{\"api\":\"nope\",\"id\":\"x\"}").status == 422, "unknown api is 422");
check(post("/google/workspace/call", "{\"api\":\"gmail\",\"id\":\"drive.files.list\"}").status == 422, "id of another api is 422");
check(post("/google/workspace/call", "{\"api\":\"gmail\",\"id\":\"gmail.users.getProfile\",\"params\":{}}").status == 422, "missing path param is 422");
check(post("/google/workspace/call", "{\"api\":\"gmail\",\"id\":\"gmail.users.getProfile\",\"params\":{\"userId\":\"me\",\"x\":1}}").status == 422, "unknown param is 422");
check(post("/google/workspace/call", "{\"api\":\"gmail\",\"id\":\"gmail.users.getProfile\",\"params\":[]}").status == 422, "params must be an object");
check(post("/google/workspace/call", "{\"api\":\"gmail\",\"id\":\"gmail.users.getProfile\",\"params\":{\"userId\":\"me\"},\"confirm\":\"yes\"}").status == 422, "confirm must be a bool");
check(post("/google/workspace/call", "not json").status == 422, "bad json is 422");
check(post("/google/workspace/call", "{\"api\":\"drive\",\"id\":\"drive.files.export\",\"params\":{\"fileId\":\"1\",\"mimeType\":\"text/plain\"}}").status == 422, "bytes responses are refused");
// sends, writes and deletes are dry runs by default, even without a credential
auto send = post("/google/workspace/call", "{\"api\":\"gmail\",\"id\":\"gmail.users.messages.send\",\"params\":{\"userId\":\"me\"},\"body\":{\"raw\":\"AAAA\"}}");
check(send.status == 200 && contains(send.body, "\"dry_run\":true") && contains(send.body, "\"kind\":\"send\"") &&
contains(send.body, "/gmail/v1/users/me/messages/send"),
"send is a dry run");
auto del = post("/google/workspace/call", "{\"api\":\"drive\",\"id\":\"drive.files.delete\",\"params\":{\"fileId\":\"abc\"}}");
check(del.status == 200 && contains(del.body, "\"dry_run\":true") && contains(del.body, "\"kind\":\"destroy\""), "delete is a dry run");
auto wr = post("/google/workspace/call", "{\"api\":\"sheets\",\"id\":\"sheets.spreadsheets.values.update\",\"params\":{\"spreadsheetId\":\"s\",\"range\":\"A1\",\"valueInputOption\":\"RAW\"},\"body\":{\"values\":[[1]]}}");
check(wr.status == 200 && contains(wr.body, "\"kind\":\"write\""), "write is a dry run");
check(post("/google/workspace/call", "{\"api\":\"gmail\",\"id\":\"gmail.users.messages.send\",\"params\":{\"userId\":\"me\"},\"body\":{\"nonsense\":1}}").status == 422, "unknown body field is 422 even for a dry run");
auto confirmed = post("/google/workspace/call", "{\"api\":\"gmail\",\"id\":\"gmail.users.messages.send\",\"params\":{\"userId\":\"me\"},\"body\":{\"raw\":\"AAAA\"},\"confirm\":true}");
check(confirmed.status == 503 && contains(confirmed.body, "google_not_configured"), "confirmed send without credential is 503");
// list
check(post("/google/workspace/list", "{\"api\":\"drive\",\"id\":\"drive.files.list\"}").status == 503, "list without credential is 503");
check(post("/google/workspace/list", "{\"api\":\"drive\",\"id\":\"drive.files.list\",\"maxPages\":9}").status == 422, "maxPages over 5 is 422");
check(post("/google/workspace/list", "{\"api\":\"gmail\",\"id\":\"gmail.users.getProfile\",\"params\":{\"userId\":\"me\"}}").status == 422, "no items array is 422");
check(post("/google/workspace/list", "{\"api\":\"gmail\",\"id\":\"gmail.users.messages.send\",\"params\":{\"userId\":\"me\"}}").status == 422, "list of a send is 422");
// delegation: local validation only
auto del_ok = post("/google/workspace/delegation", "{\"subject\":\"admin@example.com\",\"apis\":\"gmail,drive\"}");
check(del_ok.status == 200 && contains(del_ok.body, "\"impersonating\":true") && contains(del_ok.body, "gmail.readonly"), "delegation preview");
check(post("/google/workspace/delegation", "{\"subject\":\"not-an-email\",\"apis\":\"gmail\"}").status == 422, "bad subject is 422");
check(post("/google/workspace/delegation", "{\"apis\":\"nope\"}").status == 422, "unknown api is 422");
check(post("/google/workspace/delegation", "{}").status == 422, "apis required");
check(f.client->get("/google/workspace/call").status == 405, "get is 405");
check(f.client->get("/google/workspace/list").status == 405, "get list is 405");
check(rig.mock->send_count() == 0, "nothing reached Google");
// environment-built client (no injection): same contract
Fixture g;
auto env_read = g.client->post("/google/workspace/call", "{\"api\":\"calendar\",\"id\":\"calendar.calendarList.list\"}", json);
check(env_read.status == 503 && contains(env_read.body, "google_not_configured"), "env client without credential is 503");
return finish("google/workspace/call");
}
@@ -0,0 +1,18 @@
// Route: GET /google/workspace (page, no credential needed)
#include "support/GoogleRig.hpp"
using namespace molo::example::test;
int main() {
GoogleRig rig(false);
Fixture f(rig.client);
auto res = f.client->get("/google/workspace");
check(res.status == 200, "status 200");
check(contains(res.headers.get("Content-Type"), "text/html"), "html");
check(contains(res.body, "Google Workspace") && contains(res.body, "viewport"), "page and mobile viewport");
check(contains(res.body, "/embedded/google_workspace.js"), "script wired");
check(contains(res.body, "<select"), "dropdowns, not a button wall");
check(f.client->post("/google/workspace", "{}", "application/json").status == 405, "post is 405");
check(rig.mock->send_count() == 0, "no network");
return finish("google/workspace");
}
@@ -0,0 +1,34 @@
// Routes: GET /google/workspace/{status,apis,calls,scopes}
#include "support/GoogleRig.hpp"
using namespace molo::example::test;
int main() {
GoogleRig rig(false);
Fixture f(rig.client);
auto st = f.client->get("/google/workspace/status");
check(st.status == 200 && contains(st.body, "\"configured\":false"), "status without credential");
check(contains(st.body, "\"apis\":20"), "twenty apis");
auto apis = f.client->get("/google/workspace/apis");
check(apis.status == 200 && contains(apis.body, "\"name\":\"gmail\"") &&
contains(apis.body, "\"name\":\"vault\"") && contains(apis.body, "\"name\":\"directory\""),
"apis listed");
check(contains(apis.body, "gmail.googleapis.com"), "service to enable shown");
auto calls = f.client->get("/google/workspace/calls?api=gmail&kind=s");
check(calls.status == 200 && contains(calls.body, "gmail.users.messages.send") &&
!contains(calls.body, "gmail.users.messages.list"),
"calls filtered by api and kind");
check(f.client->get("/google/workspace/calls?api=nope").status == 422, "unknown api is 422");
check(f.client->get("/google/workspace/calls?kind=x").status == 422, "unknown kind is 422");
auto all = f.client->get("/google/workspace/calls");
check(all.status == 200 && contains(all.body, "\"truncated\":true"), "unfiltered listing is capped");
auto scopes = f.client->get("/google/workspace/scopes?apis=gmail,drive&readonly=true");
check(scopes.status == 200 && contains(scopes.body, "gmail.readonly") && contains(scopes.body, "drive.readonly"),
"readonly scopes");
check(!contains(scopes.body, "auth/gmail.send"), "no write scope in the readonly set");
check(f.client->get("/google/workspace/scopes").status == 422, "apis required");
check(f.client->get("/google/workspace/scopes?apis=gmail&readonly=maybe").status == 422, "readonly must be a bool");
check(f.client->post("/google/workspace/status", "{}", "application/json").status == 405, "post is 405");
check(rig.mock->send_count() == 0, "no network");
return finish("google/workspace/status");
}
@@ -0,0 +1,377 @@
// Workspace: deterministic local tests (call table, request building,
// validation, caps, kinds, scopes, delegation claims) plus opt-in live
// read-only checks (test_workspace_live.cpp). No scripted Google replies:
// shapes are proven against Discovery by tools/check_discovery.py.
#include <wolfssl/options.h>
#include <wolfssl/wolfcrypt/asn_public.h>
#include <wolfssl/wolfcrypt/random.h>
#include <wolfssl/wolfcrypt/rsa.h>
#include <wolfssl/wolfcrypt/signature.h>
#include <cstdlib>
#include <iostream>
#include <memory>
#include <set>
#include "framework.h"
#include "clients/transports/mock_transport.h"
#include "google/errors.h"
#include "google/workspace/calls.h"
#include "google/workspace/caps.h"
#include "google/workspace/delegation.h"
#include "google/workspace/prepared_call.h"
#include "google/workspace/workspace_client.h"
#include "security/crypto/Base64.h"
using namespace molo::google;
using namespace molo::google::workspace;
using molo::clients::Method;
using molo::clients::body::Json;
using molo::clients::transports::MockTransport;
using molo::security::crypto::Base64;
namespace {
struct Rig {
MockTransport* mock;
std::shared_ptr<GoogleClient> client;
Rig() {
auto t = std::make_unique<MockTransport>();
mock = t.get();
client = std::make_shared<GoogleClient>(std::move(t), nullptr);
}
};
Json obj(std::initializer_list<std::pair<const char*, Json>> kv) {
Json o = Json::object();
for (const auto& [k, v] : kv) o.set(k, v);
return o;
}
std::string pem_key(RsaKey& key, WC_RNG& rng) {
wc_InitRng(&rng);
wc_InitRsaKey(&key, nullptr);
if (wc_MakeRsaKey(&key, 2048, 65537, &rng) != 0) FAIL("key generation failed");
std::string der(4096, '\0');
int n = wc_RsaKeyToDer(&key, reinterpret_cast<byte*>(der.data()), der.size());
if (n <= 0) FAIL("key export failed");
der.resize(n);
std::string pem(8192, '\0');
int p = wc_DerToPem(reinterpret_cast<const byte*>(der.data()), der.size(),
reinterpret_cast<byte*>(pem.data()), pem.size(), PRIVATEKEY_TYPE);
if (p <= 0) FAIL("pem export failed");
pem.resize(p);
return pem;
}
ServiceAccountKey make_key(const std::string& pem) {
Json j = obj({{"type", Json("service_account")},
{"client_email", Json("sa@p-1.iam.gserviceaccount.com")},
{"private_key", Json(pem)}});
return ServiceAccountKey::parse(j.dump());
}
std::vector<std::string> dots(const std::string& s) {
std::vector<std::string> out;
std::size_t pos = 0, d;
while ((d = s.find('.', pos)) != std::string::npos) {
out.push_back(s.substr(pos, d - pos));
pos = d + 1;
}
out.push_back(s.substr(pos));
return out;
}
} // namespace
TEST(workspace_table, covers_twenty_apis_and_every_call_is_well_formed) {
ASSERT_EQ(kApiTableSize, 20u);
ASSERT_TRUE(kCallTableSize >= 700);
std::set<std::string> ids;
for (std::size_t i = 0; i < kCallTableSize; ++i) {
const CallSpec& c = kCallTable[i];
ASSERT_TRUE(ids.insert(std::string(c.api) + "/" + c.id).second); // unique per API
ASSERT_TRUE(find_api(c.api) != nullptr);
ASSERT_TRUE(std::string("rwds").find(c.kind[0]) != std::string::npos);
ASSERT_EQ(std::string(c.kind).size(), 1u);
if (std::string(c.http) == "GET") ASSERT_TRUE(kind_of(c) == Kind::kRead);
if (std::string(c.http) == "DELETE") ASSERT_TRUE(kind_of(c) == Kind::kDestroy);
// every path placeholder has a path parameter
std::set<std::string> path_params;
for (const auto& p : params_of(c))
if (p.path) path_params.insert(p.name);
std::string t = c.path;
std::size_t placeholders = 0;
for (std::size_t k = t.find('{'); k != std::string::npos; k = t.find('{', k + 1)) {
std::size_t e = t.find('}', k);
std::string n = t.substr(k + 1, e - k - 1);
if (!n.empty() && n[0] == '+') n.erase(0, 1);
ASSERT_TRUE(path_params.count(n) == 1);
++placeholders;
}
ASSERT_EQ(placeholders, path_params.size());
}
for (const char* api : {"gmail", "drive", "calendar", "sheets", "docs", "slides", "forms", "tasks",
"chat", "meet", "people", "keep", "classroom", "youtube",
"youtubeanalytics", "youtubereporting", "directory", "reports",
"groupssettings", "vault"})
ASSERT_TRUE(!calls_of(api).empty());
}
TEST(workspace_table, kinds_of_named_calls) {
ASSERT_TRUE(kind_of(*find_call("gmail.users.messages.send")) == Kind::kSend);
ASSERT_TRUE(kind_of(*find_call("chat.spaces.messages.create")) == Kind::kSend);
ASSERT_TRUE(kind_of(*find_call("gmail.users.messages.list")) == Kind::kRead);
ASSERT_TRUE(kind_of(*find_call("calendar.freebusy.query")) == Kind::kRead);
ASSERT_TRUE(kind_of(*find_call("drive.files.delete")) == Kind::kDestroy);
ASSERT_TRUE(kind_of(*find_call("directory.users.signOut")) == Kind::kDestroy);
ASSERT_TRUE(kind_of(*find_call("sheets.spreadsheets.values.update")) == Kind::kWrite);
ASSERT_TRUE(kind_of(*find_call("docs.documents.batchUpdate")) == Kind::kWrite);
ASSERT_TRUE(has_flag(*find_call("drive.files.export"), 'b'));
ASSERT_TRUE(find_call("nope.nothing") == nullptr);
}
TEST(workspace_request, path_and_query_are_encoded_from_the_table) {
const CallSpec& c = *find_call("gmail.users.messages.list");
Json p = obj({{"userId", Json("me")}, {"q", Json("from:a@b.c is:unread")}, {"maxResults", Json(5)}});
Json labels = Json::array();
labels.push(Json("INBOX"));
labels.push(Json("UNREAD"));
p.set("labelIds", labels);
p.set("includeSpamTrash", Json(false));
PreparedCall call = PreparedCall::build(c, p, nullptr);
ASSERT_TRUE(call.method == Method::kGet);
ASSERT_EQ(call.path,
"/gmail/v1/users/me/messages?includeSpamTrash=false&labelIds=INBOX&labelIds=UNREAD"
"&maxResults=5&q=from%3Aa%40b.c%20is%3Aunread");
}
TEST(workspace_request, plus_params_keep_slashes_and_plain_ones_do_not) {
PreparedCall chat = PreparedCall::build(*find_call("chat.spaces.messages.list"),
obj({{"parent", Json("spaces/AAAA")}}), nullptr);
ASSERT_EQ(chat.path, "/v1/spaces/AAAA/messages");
ASSERT_THROW(PreparedCall::build(*find_call("gmail.users.getProfile"),
obj({{"userId", Json("a/b")}}), nullptr), GoogleError);
ASSERT_THROW(PreparedCall::build(*find_call("chat.spaces.messages.list"),
obj({{"parent", Json("spaces/../x")}}), nullptr), GoogleError);
PreparedCall cal = PreparedCall::build(*find_call("calendar.events.list"),
obj({{"calendarId", Json("en.usa#holiday@group.v.calendar.google.com")}}),
nullptr);
ASSERT_EQ(cal.path, "/calendars/en.usa%23holiday%40group.v.calendar.google.com/events");
PreparedCall sheet = PreparedCall::build(*find_call("sheets.spreadsheets.values.get"),
obj({{"spreadsheetId", Json("abc")}, {"range", Json("Sheet1!A1:B2")}}),
nullptr);
ASSERT_EQ(sheet.path, "/v4/spreadsheets/abc/values/Sheet1%21A1%3AB2");
}
TEST(workspace_request, validation_rejects_before_any_traffic) {
const CallSpec& list = *find_call("gmail.users.messages.list");
ASSERT_THROW(PreparedCall::build(list, obj({}), nullptr), GoogleError); // userId missing
ASSERT_THROW(PreparedCall::build(list, obj({{"userId", Json("me")}, {"bogus", Json("x")}}), nullptr), GoogleError);
ASSERT_THROW(PreparedCall::build(list, obj({{"userId", Json("me")}, {"maxResults", Json("abc")}}), nullptr), GoogleError);
ASSERT_THROW(PreparedCall::build(list, obj({{"userId", Json("me")}, {"includeSpamTrash", Json("yes")}}), nullptr), GoogleError);
ASSERT_THROW(PreparedCall::build(list, obj({{"userId", Json("me")}, {"labelIds", Json("INBOX")}}), nullptr), GoogleError);
ASSERT_THROW(PreparedCall::build(list, obj({{"userId", Json(std::string(600, 'a'))}}), nullptr), GoogleError);
ASSERT_THROW(PreparedCall::build(list, obj({{"userId", Json("me")}, {"q", Json(std::string(3000, 'a'))}}), nullptr), GoogleError);
ASSERT_THROW(PreparedCall::build(list, obj({{"userId", Json("m\ne")}}), nullptr), GoogleError);
Json body = obj({{"x", Json(1)}});
ASSERT_THROW(PreparedCall::build(list, obj({{"userId", Json("me")}}), &body), GoogleError); // no body
// required query parameter (youtube part)
ASSERT_THROW(PreparedCall::build(*find_call("youtube.channels.list"), obj({{"mine", Json(true)}}), nullptr), GoogleError);
// unknown body field
Json bad = obj({{"nonsense", Json(1)}});
ASSERT_THROW(PreparedCall::build(*find_call("gmail.users.messages.send"), obj({{"userId", Json("me")}}), &bad), GoogleError);
Json good = obj({{"raw", Json("AAAA")}});
PreparedCall ok = PreparedCall::build(*find_call("gmail.users.messages.send"), obj({{"userId", Json("me")}}), &good);
ASSERT_TRUE(ok.method == Method::kPost && ok.has_body);
Json huge = obj({{"raw", Json(std::string(WorkspaceCaps::kMaxBodyBytes + 1, 'a'))}});
ASSERT_THROW(PreparedCall::build(*find_call("gmail.users.messages.send"), obj({{"userId", Json("me")}}), &huge), GoogleError);
// fields selector is allowed on every call, capped
PreparedCall f = PreparedCall::build(*find_call("drive.about.get"), obj({{"fields", Json("user")}}), nullptr);
ASSERT_EQ(f.path, "/about?fields=user");
ASSERT_THROW(PreparedCall::build(*find_call("drive.about.get"), obj({{"fields", Json(std::string(2000, 'a'))}}), nullptr), GoogleError);
}
TEST(workspace_request, groups_settings_asks_for_json) {
PreparedCall c = PreparedCall::build(*find_call("groupsSettings.groups.get"),
obj({{"groupUniqueId", Json("g@example.com")}}), nullptr);
ASSERT_EQ(c.path, "/g%40example.com?alt=json");
Rig rig;
WorkspaceApi api(rig.client, "groupssettings");
ASSERT_EQ(api.endpoint().base_url, "https://www.googleapis.com/groups/v1/groups");
}
TEST(workspace_api, kinds_gate_the_methods_and_confirm_has_no_default) {
Rig rig;
WorkspaceApi gmail(rig.client, "gmail");
Json user = obj({{"userId", Json("me")}});
Json raw = obj({{"raw", Json("AAAA")}});
// read() refuses a send, send() refuses without confirm, both before traffic
ASSERT_THROW(gmail.read("gmail.users.messages.send", user, &raw), GoogleError);
try {
gmail.send("gmail.users.messages.send", user, &raw, false);
FAIL("send without confirm must throw");
} catch (const GoogleError& e) {
ASSERT_EQ(e.http_status(), 400);
ASSERT_EQ(e.status(), "INVALID_ARGUMENT");
}
ASSERT_THROW(gmail.write("gmail.users.messages.send", user, &raw, true), GoogleError); // wrong kind
ASSERT_THROW(gmail.destroy("gmail.users.messages.delete",
obj({{"userId", Json("me")}, {"id", Json("1")}}), false), GoogleError);
// confirmed and valid: only now does it reach the credential check
ASSERT_THROW(gmail.send("gmail.users.messages.send", user, &raw, true), NotConfiguredError);
ASSERT_THROW(gmail.read("drive.files.list"), GoogleError); // another API's call
ASSERT_THROW(gmail.read("drive.files.export"), GoogleError);
WorkspaceApi drive(rig.client, "drive");
ASSERT_THROW(drive.read("drive.files.export", obj({{"fileId", Json("1")}, {"mimeType", Json("text/plain")}})), GoogleError); // bytes
ASSERT_THROW(WorkspaceApi(rig.client, "nope"), GoogleError);
ASSERT_EQ(rig.mock->send_count(), 0u);
}
TEST(workspace_api, no_credential_is_loud_for_every_typed_service) {
Rig rig;
Workspace ws(rig.client);
ASSERT_THROW(ws.gmail().profile(), NotConfiguredError);
ASSERT_THROW(ws.drive().about(), NotConfiguredError);
ASSERT_THROW(ws.calendar().calendars(), NotConfiguredError);
ASSERT_THROW(ws.sheets().spreadsheet("abc"), NotConfiguredError);
ASSERT_THROW(ws.docs().document("abc"), NotConfiguredError);
ASSERT_THROW(ws.slides().presentation("abc"), NotConfiguredError);
ASSERT_THROW(ws.forms().form("abc"), NotConfiguredError);
ASSERT_THROW(ws.tasks().task_lists(), NotConfiguredError);
ASSERT_THROW(ws.chat().spaces(), NotConfiguredError);
ASSERT_THROW(ws.meet().conference_records(), NotConfiguredError);
ASSERT_THROW(ws.people().me(), NotConfiguredError);
ASSERT_THROW(ws.keep().notes(), NotConfiguredError);
ASSERT_THROW(ws.classroom().courses(), NotConfiguredError);
ASSERT_THROW(ws.youtube().my_channel(), NotConfiguredError);
ASSERT_THROW(ws.youtube_analytics().report("channel==MINE", "2026-01-01", "2026-01-31", "views"), NotConfiguredError);
ASSERT_THROW(ws.youtube_reporting().jobs(), NotConfiguredError);
ASSERT_THROW(ws.directory().users(), NotConfiguredError);
ASSERT_THROW(ws.reports().activities("all", "login"), NotConfiguredError);
ASSERT_THROW(ws.groups_settings().group("g@example.com"), NotConfiguredError);
ASSERT_THROW(ws.vault().matters(), NotConfiguredError);
ASSERT_EQ(Workspace::api_names().size(), 20u);
ASSERT_EQ(rig.mock->send_count(), 0u);
}
TEST(workspace_api, page_walk_caps) {
Rig rig;
WorkspaceApi gmail(rig.client, "gmail");
Json p = obj({{"userId", Json("me")}});
ASSERT_THROW(gmail.pages("gmail.users.messages.list", p, 0), GoogleError);
ASSERT_THROW(gmail.pages("gmail.users.messages.list", p, WorkspaceCaps::kMaxPages + 1), GoogleError);
ASSERT_THROW(gmail.pages("gmail.users.messages.send", p, 1), GoogleError); // not a read
ASSERT_THROW(gmail.list("gmail.users.getProfile", p, 1), GoogleError); // no items array
}
TEST(workspace_scopes, per_api_scopes_and_readonly_subsets) {
auto gm = Scopes::all_of("gmail");
ASSERT_TRUE(gm.size() >= 5);
for (const auto& s : Scopes::readonly_of("gmail")) ASSERT_TRUE(s.find("readonly") != std::string::npos || s.find("metadata") != std::string::npos);
// groupssettings has no readonly scope: its full scope stands in
ASSERT_EQ(Scopes::readonly_of("groupssettings").size(), 1u);
auto mix = Scopes::for_apis({"gmail", "drive", "calendar"}, true);
ASSERT_TRUE(mix.size() >= 3 && mix.size() <= 40);
std::set<std::string> uniq(mix.begin(), mix.end());
ASSERT_EQ(uniq.size(), mix.size());
ASSERT_THROW(Scopes::for_apis({}, true), GoogleError);
ASSERT_THROW(Scopes::for_apis({"nope"}, true), GoogleError);
for (std::size_t i = 0; i < kApiTableSize; ++i) {
ASSERT_TRUE(Scopes::all_of(kApiTable[i].name).size() >= 1);
for (const auto& s : Scopes::all_of(kApiTable[i].name)) ASSERT_TRUE(s.rfind("https://", 0) == 0);
}
}
TEST(workspace_delegation, assertion_carries_sub_and_verifies) {
RsaKey key;
WC_RNG rng;
std::string pem = pem_key(key, rng);
ServiceAccountKey sak = make_key(pem);
Delegation d{"admin@example.com"};
std::string jwt = DelegatedAuth::assertion(sak, "https://www.googleapis.com/auth/gmail.readonly", d, 1700000000);
auto parts = dots(jwt);
ASSERT_EQ(parts.size(), 3u);
std::string hdr, claims, sig;
ASSERT_TRUE(Base64::decode_url(parts[0], hdr));
ASSERT_TRUE(Base64::decode_url(parts[1], claims));
ASSERT_TRUE(Base64::decode_url(parts[2], sig));
Json c = Json::parse(claims);
ASSERT_EQ(c.find("sub")->as_string(), "admin@example.com");
ASSERT_EQ(c.find("iss")->as_string(), "sa@p-1.iam.gserviceaccount.com");
ASSERT_EQ(c.find("scope")->as_string(), "https://www.googleapis.com/auth/gmail.readonly");
ASSERT_EQ(c.find("exp")->as_int(), 1700003600L);
std::string input = parts[0] + "." + parts[1];
ASSERT_EQ(wc_SignatureVerify(WC_HASH_TYPE_SHA256, WC_SIGNATURE_TYPE_RSA_W_ENC,
reinterpret_cast<const byte*>(input.data()), input.size(),
reinterpret_cast<const byte*>(sig.data()), sig.size(), &key, sizeof(key)), 0);
// without a subject the claim is absent: the token acts as the service account
std::string plain = DelegatedAuth::assertion(sak, "s", Delegation{}, 1700000000);
std::string pc;
ASSERT_TRUE(Base64::decode_url(dots(plain)[1], pc));
ASSERT_TRUE(Json::parse(pc).find("sub") == nullptr);
wc_FreeRsaKey(&key);
wc_FreeRng(&rng);
}
TEST(workspace_delegation, subject_and_scope_validation) {
for (const char* bad : {"nobody", "@x.com", "a@", "a@b@c", "a b@c.com", "a\n@c.com"})
ASSERT_THROW(Delegation{bad}.validate(), GoogleError);
ASSERT_THROW(Delegation{std::string(300, 'a') + "@x.com"}.validate(), GoogleError);
Delegation{}.validate();
Delegation{"a@b.com"}.validate();
RsaKey key;
WC_RNG rng;
ServiceAccountKey sak = make_key(pem_key(key, rng));
ASSERT_THROW(DelegatedAuth(sak, {}, Delegation{}), GoogleError);
ASSERT_THROW(DelegatedAuth(sak, {"not-a-url"}, Delegation{}), GoogleError);
ASSERT_THROW(DelegatedAuth(sak, {"https://x/a b"}, Delegation{}), GoogleError);
ASSERT_THROW(DelegatedAuth(sak, {"https://x/a"}, Delegation{"bad"}), GoogleError);
DelegatedAuth ok(sak, {"https://www.googleapis.com/auth/drive.readonly", "https://www.googleapis.com/auth/gmail.readonly"},
Delegation{"u@example.com"});
ASSERT_EQ(ok.scope_string(), "https://www.googleapis.com/auth/drive.readonly https://www.googleapis.com/auth/gmail.readonly");
ASSERT_EQ(ok.delegation().subject, "u@example.com");
wc_FreeRsaKey(&key);
wc_FreeRng(&rng);
}
TEST(workspace_delegation, credential_mode_follows_the_documented_order) {
// Credentials::env may cache and the live tests need the real environment:
// this test owns the environment only in the offline run.
if (std::getenv("MOLO_LIVE_NET")) {
std::cout << "SKIP workspace_delegation.credential_mode (offline test; unset MOLO_LIVE_NET)\n";
return;
}
// The process environment is shared with the live tests: save and restore.
auto save = [](const char* n) { const char* v = std::getenv(n); return v ? std::string(v) : std::string(); };
const std::string old_env_files = save("MOLO_ENV_FILES"), old_token = save("GOOGLE_ACCESS_TOKEN"),
old_key = save("GOOGLE_APPLICATION_CREDENTIALS"), old_sub = save("GOOGLE_WORKSPACE_SUBJECT");
struct Restore {
std::vector<std::pair<const char*, std::string>> vars;
~Restore() {
for (auto& [n, v] : vars) v.empty() ? unsetenv(n) : setenv(n, v.c_str(), 1);
}
} restore{{{"MOLO_ENV_FILES", old_env_files}, {"GOOGLE_ACCESS_TOKEN", old_token},
{"GOOGLE_APPLICATION_CREDENTIALS", old_key}, {"GOOGLE_WORKSPACE_SUBJECT", old_sub}}};
setenv("MOLO_ENV_FILES", "off", 1);
unsetenv("GOOGLE_WORKSPACE_SUBJECT");
unsetenv("GOOGLE_ACCESS_TOKEN");
unsetenv("GOOGLE_APPLICATION_CREDENTIALS");
WorkspaceOptions o;
o.apis = {"gmail"};
ASSERT_EQ(WorkspaceAuth::mode_from_env(o), "none");
ASSERT_TRUE(WorkspaceAuth::from_env(o) == nullptr);
setenv("GOOGLE_APPLICATION_CREDENTIALS", "/nonexistent/key.json", 1);
ASSERT_EQ(WorkspaceAuth::mode_from_env(o), "service-account");
setenv("GOOGLE_ACCESS_TOKEN", "tok", 1);
ASSERT_EQ(WorkspaceAuth::mode_from_env(o), "user-token");
ASSERT_TRUE(WorkspaceAuth::from_env(o) != nullptr);
o.delegation = Delegation{"admin@example.com"};
ASSERT_EQ(WorkspaceAuth::mode_from_env(o), "delegated");
ASSERT_THROW(WorkspaceAuth::from_env(o), GoogleError); // key file unreadable
unsetenv("GOOGLE_APPLICATION_CREDENTIALS");
ASSERT_THROW(WorkspaceAuth::from_env(o), GoogleError); // subject without key
o.delegation = Delegation{"bad"};
ASSERT_THROW(WorkspaceAuth::from_env(o), GoogleError);
unsetenv("GOOGLE_ACCESS_TOKEN");
}
@@ -0,0 +1,135 @@
// Opt-in live, read-only checks (MOLO_LIVE_NET=1). Nothing is sent, created,
// changed or deleted. Workspace data belongs to humans: the service account of
// the test project has none and no domain-wide delegation, so the expected
// answers are 400/401/403 or empty lists. Each probe prints what Google said;
// a disabled API is reported loudly as "API NOT ENABLED".
#include <cstdlib>
#include <iostream>
#include "framework.h"
#include "google/credentials.h"
#include "google/errors.h"
#include "clients/transports/http_transport.h"
#include "google/workspace/workspace_client.h"
using namespace molo::google;
using namespace molo::google::workspace;
namespace {
bool net() { return std::getenv("MOLO_LIVE_NET") != nullptr; }
// Other suites in this binary unset GOOGLE_ACCESS_TOKEN, so it is captured
// before main() runs.
const std::string kStartToken = [] {
const char* v = std::getenv("GOOGLE_ACCESS_TOKEN");
return v ? std::string(v) : std::string();
}();
std::string clip(const std::string& s) { return s.size() > 140 ? s.substr(0, 140) + "..." : s; }
// Runs one read, prints the outcome, returns the HTTP status (200 on success,
// 0 for an unexpected local failure). Fails the test on a transport failure.
template <typename F>
int probe(const char* name, F&& f) {
try {
f();
std::cout << " " << name << ": 200 OK\n";
return 200;
} catch (const GoogleError& e) {
bool disabled = e.status() == "SERVICE_DISABLED" ||
e.message().find("has not been used") != std::string::npos ||
e.message().find("is not enabled") != std::string::npos;
std::cout << " " << name << ": " << e.http_status() << " " << e.status()
<< (disabled ? " API NOT ENABLED" : "") << " | " << clip(e.message()) << "\n";
if (e.status() == "UNAVAILABLE") FAIL(std::string(name) + ": transport failure " + e.message());
return e.http_status();
}
}
} // namespace
TEST(workspace_live, reads_with_the_cloud_platform_token) {
if (!net() || kStartToken.empty()) {
std::cout << "SKIP workspace_live.reads_with_the_cloud_platform_token (set MOLO_LIVE_NET=1 and GOOGLE_ACCESS_TOKEN)\n";
return;
}
Workspace ws(std::make_shared<GoogleClient>(
std::make_unique<molo::clients::transports::HttpTransport>(), nullptr,
Credentials::bearer(kStartToken)));
std::cout << " mode: user-token (cloud-platform scope of the test service account)\n";
probe("gmail.getProfile", [&] { ws.gmail().profile(); });
probe("drive.about", [&] { ws.drive().about(); });
probe("calendar.calendarList", [&] { ws.calendar().calendars(); });
probe("sheets.get(unknown)", [&] { ws.sheets().spreadsheet("1x"); });
probe("docs.get(unknown)", [&] { ws.docs().document("1x"); });
probe("slides.get(unknown)", [&] { ws.slides().presentation("1x"); });
probe("forms.get(unknown)", [&] { ws.forms().form("1x"); });
probe("tasks.tasklists", [&] { ws.tasks().task_lists(); });
probe("chat.spaces", [&] { ws.chat().spaces(); });
probe("meet.conferenceRecords", [&] { ws.meet().conference_records(); });
probe("people.me", [&] { ws.people().me(); });
probe("keep.notes", [&] { ws.keep().notes(); });
probe("classroom.courses", [&] { ws.classroom().courses(); });
probe("youtube.channels(mine)", [&] { ws.youtube().my_channel(); });
probe("youtubereporting.reportTypes", [&] { ws.youtube_reporting().report_types(); });
probe("directory.users", [&] { ws.directory().users(); });
probe("reports.activities", [&] { ws.reports().activities("all", "login", 1); });
probe("groupssettings.get", [&] { ws.groups_settings().group("nobody@example.com"); });
probe("vault.matters", [&] { ws.vault().matters(); });
}
TEST(workspace_live, scoped_service_account_token_without_and_with_a_subject) {
std::string key_path = Credentials::env("GOOGLE_APPLICATION_CREDENTIALS");
if (!net() || key_path.empty()) {
std::cout << "SKIP workspace_live.scoped_service_account_token_without_and_with_a_subject "
"(set MOLO_LIVE_NET=1 and GOOGLE_APPLICATION_CREDENTIALS)\n";
return;
}
ServiceAccountKey key = ServiceAccountKey::load_file(key_path);
std::vector<std::string> scopes = Scopes::for_apis({"drive", "calendar", "tasks", "people"}, true);
// No subject: the token acts as the service account itself (its own, empty, data).
auto plain = std::make_shared<DelegatedAuth>(key, scopes);
int token = probe("token without sub", [&] { plain->fetch_token(); });
ASSERT_EQ(token, 200);
auto client = std::make_shared<GoogleClient>(
std::make_unique<molo::clients::transports::HttpTransport>(), nullptr, plain);
Workspace ws(client);
probe("drive.about (own)", [&] { ws.drive().about(); });
probe("drive.files.list (own)", [&] { ws.drive().files("", 5); });
probe("calendar.calendarList (own)", [&] { ws.calendar().calendars(); });
probe("tasks.tasklists (own)", [&] { ws.tasks().task_lists(); });
// The other APIs with their own read-only scopes (still no subject).
auto client_for = [&](const std::vector<std::string>& apis) {
auto auth = std::make_shared<DelegatedAuth>(key, Scopes::for_apis(apis, true));
return std::make_shared<GoogleClient>(
std::make_unique<molo::clients::transports::HttpTransport>(), nullptr, auth);
};
Workspace a(client_for({"gmail", "sheets", "docs", "slides", "forms"}));
probe("gmail.getProfile (sa, no sub)", [&] { a.gmail().profile(); });
probe("sheets.get unknown (sa)", [&] { a.sheets().spreadsheet("1x"); });
probe("docs.get unknown (sa)", [&] { a.docs().document("1x"); });
probe("slides.get unknown (sa)", [&] { a.slides().presentation("1x"); });
probe("forms.get unknown (sa)", [&] { a.forms().form("1x"); });
Workspace b(client_for({"chat", "meet", "people", "keep", "classroom"}));
probe("chat.spaces (sa)", [&] { b.chat().spaces(); });
probe("meet.conferenceRecords (sa)", [&] { b.meet().conference_records(); });
probe("people.me (sa)", [&] { b.people().me(); });
probe("keep.notes (sa)", [&] { b.keep().notes(); });
probe("classroom.courses (sa)", [&] { b.classroom().courses(); });
Workspace c(client_for({"youtube", "youtubereporting", "vault", "directory", "reports", "groupssettings"}));
probe("youtube.channels mine (sa)", [&] { c.youtube().my_channel(); });
probe("youtubereporting.reportTypes (sa)", [&] { c.youtube_reporting().report_types(); });
probe("vault.matters (sa)", [&] { c.vault().matters(); });
probe("directory.users (sa)", [&] { c.directory().users(); });
probe("reports.activities (sa)", [&] { c.reports().activities("all", "login", 1); });
probe("groupssettings.get (sa)", [&] { c.groups_settings().group("nobody@example.com"); });
// With a subject but no domain-wide delegation grant: Google must refuse
// the exchange (unauthorized_client). This proves the `sub` claim is sent.
auto delegated = std::make_shared<DelegatedAuth>(key, scopes, Delegation{"nobody@example.com"});
int refused = probe("token with sub (no DWD grant)", [&] { delegated->fetch_token(); });
ASSERT_TRUE(refused == 401 || refused == 400 || refused == 403);
}