自学教程：C++ AWAIT_EXPECT_RESPONSE_STATUS_EQ函数代码示例

TEST_F(MesosSchedulerDriverTest, MetricsEndpoint){  Try<Owned<cluster::Master>> master = StartMaster();  ASSERT_SOME(master);  MockScheduler sched;  MesosSchedulerDriver driver(      &sched, DEFAULT_FRAMEWORK_INFO, master.get()->pid, DEFAULT_CREDENTIAL);  Future<Nothing> registered;  EXPECT_CALL(sched, registered(&driver, _, _))    .WillOnce(FutureSatisfy(&registered));  ASSERT_EQ(DRIVER_RUNNING, driver.start());  AWAIT_READY(registered);  Future<process::http::Response> response =    process::http::get(MetricsProcess::instance()->self(), "snapshot");  AWAIT_EXPECT_RESPONSE_STATUS_EQ(OK().status, response);  AWAIT_EXPECT_RESPONSE_HEADER_EQ(APPLICATION_JSON, "Content-Type", response);  Try<JSON::Object> parse = JSON::parse<JSON::Object>(response.get().body);  ASSERT_SOME(parse);  JSON::Object metrics = parse.get();  EXPECT_EQ(1u, metrics.values.count("scheduler/event_queue_messages"));  EXPECT_EQ(1u, metrics.values.count("scheduler/event_queue_dispatches"));  driver.stop();  driver.join();}

// Testing route without authorization header.TEST_F(TeardownTest, TeardownEndpointNoHeader){  Try<PID<Master> > master = StartMaster();  ASSERT_SOME(master);  MockScheduler sched;  MesosSchedulerDriver driver(      &sched, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);  Future<FrameworkID> frameworkId;  EXPECT_CALL(sched, registered(&driver, _, _))    .WillOnce(FutureArg<1>(&frameworkId));  ASSERT_EQ(DRIVER_RUNNING, driver.start());  AWAIT_READY(frameworkId);  Future<Response> response = process::http::post(      master.get(),      "teardown",      None(),      "frameworkId=" + frameworkId.get().value());  AWAIT_READY(response);  AWAIT_EXPECT_RESPONSE_STATUS_EQ(      Unauthorized("Mesos master").status,      response);  driver.stop();  driver.join();  Shutdown();}

// This test expects a BadRequest when 'Content-Type' is omitted.TEST_F(ExecutorHttpApiTest, NoContentType){  Try<PID<Master>> master = StartMaster();  ASSERT_SOME(master);  Future<Nothing> __recover = FUTURE_DISPATCH(_, &Slave::__recover);  Try<PID<Slave>> slave = StartSlave();  ASSERT_SOME(slave);  AWAIT_READY(__recover);  // Wait for recovery to be complete.  Clock::pause();  Clock::settle();  Call call;  call.set_type(Call::MESSAGE);  call.mutable_message()->set_data("hello world");  call.mutable_framework_id()->set_value("dummy_framework_id");  call.mutable_executor_id()->set_value("dummy_executor_id");  Future<Response> response = process::http::post(      slave.get(),      "api/v1/executor",      None(),      serialize(ContentType::JSON, call),      None());  AWAIT_EXPECT_RESPONSE_STATUS_EQ(BadRequest().status, response);  Shutdown();}

// Testing route without frameworkId value.TEST_F(TeardownTest, NoFrameworkId){  Try<Owned<cluster::Master>> master = StartMaster();  ASSERT_SOME(master);  MockScheduler sched;  MesosSchedulerDriver driver(      &sched, DEFAULT_FRAMEWORK_INFO, master.get()->pid, DEFAULT_CREDENTIAL);  Future<FrameworkID> frameworkId;  EXPECT_CALL(sched, registered(&driver, _, _))    .WillOnce(FutureArg<1>(&frameworkId));  ASSERT_EQ(DRIVER_RUNNING, driver.start());  AWAIT_READY(frameworkId);  Future<Response> response = process::http::post(      master.get()->pid,      "teardown",      createBasicAuthHeaders(DEFAULT_CREDENTIAL),      "");  AWAIT_READY(response);  AWAIT_EXPECT_RESPONSE_STATUS_EQ(BadRequest().status, response);  driver.stop();  driver.join();}

// This test sends a malformed body that cannot be deserialized// into a valid protobuf resulting in a BadRequest.TEST_P(ExecutorHttpApiTest, MalformedContent){  Try<PID<Master>> master = StartMaster();  ASSERT_SOME(master);  Future<Nothing> __recover = FUTURE_DISPATCH(_, &Slave::__recover);  Try<PID<Slave>> slave = StartSlave();  ASSERT_SOME(slave);  AWAIT_READY(__recover);  // Wait for recovery to be complete.  Clock::pause();  Clock::settle();  const string body = "MALFORMED_CONTENT";  const ContentType contentType = GetParam();  process::http::Headers headers;  headers["Accept"] = stringify(contentType);  Future<Response> response = process::http::post(      slave.get(),      "api/v1/executor",      headers,      body,      stringify(contentType));  AWAIT_EXPECT_RESPONSE_STATUS_EQ(BadRequest().status, response);  Shutdown();}

// This test sets an unsupported media type as Content-Type. This// should result in a 415 (UnsupportedMediaType) response.TEST_P(SchedulerHttpApiTest, UnsupportedContentMediaType){  Try<Owned<cluster::Master>> master = StartMaster();  ASSERT_SOME(master);  const string contentType = GetParam();  process::http::Headers headers = createBasicAuthHeaders(DEFAULT_CREDENTIAL);  headers["Accept"] = contentType;  Call call;  call.set_type(Call::SUBSCRIBE);  Call::Subscribe* subscribe = call.mutable_subscribe();  subscribe->mutable_framework_info()->CopyFrom(v1::DEFAULT_FRAMEWORK_INFO);  const string unknownMediaType = "application/unknown-media-type";  Future<Response> response = process::http::post(      master.get()->pid,      "api/v1/scheduler",      headers,      serialize(call, contentType),      unknownMediaType);  AWAIT_EXPECT_RESPONSE_STATUS_EQ(UnsupportedMediaType().status, response);}

// This test verifies that only authorized principals// can access the '/flags' endpoint.TYPED_TEST(SlaveAuthorizerTest, AuthorizeFlagsEndpoint){  const string endpoint = "flags";  // Setup ACLs so that only the default principal  // can access the '/flags' endpoint.  ACLs acls;  acls.set_permissive(false);  mesos::ACL::GetEndpoint* acl = acls.add_get_endpoints();  acl->mutable_principals()->add_values(DEFAULT_CREDENTIAL.principal());  acl->mutable_paths()->add_values("/" + endpoint);  // Create an `Authorizer` with the ACLs.  Try<Authorizer*> create = TypeParam::create(parameterize(acls));  ASSERT_SOME(create);  Owned<Authorizer> authorizer(create.get());  StandaloneMasterDetector detector;  Try<Owned<cluster::Slave>> agent =    this->StartSlave(&detector, authorizer.get());  ASSERT_SOME(agent);  Future<Response> response = http::get(      agent.get()->pid,      endpoint,      None(),      createBasicAuthHeaders(DEFAULT_CREDENTIAL));  AWAIT_EXPECT_RESPONSE_STATUS_EQ(OK().status, response)    << response.get().body;  response = http::get(      agent.get()->pid,      endpoint,      None(),      createBasicAuthHeaders(DEFAULT_CREDENTIAL_2));  AWAIT_EXPECT_RESPONSE_STATUS_EQ(Forbidden().status, response)    << response.get().body;}

TEST_F(SchedulerHttpApiTest, AuthenticationRequired){  Try<Owned<cluster::Master>> master = StartMaster();  ASSERT_SOME(master);  Future<Response> response = process::http::post(      master.get()->pid,      "api/v1/scheduler",      None(),      None());  AWAIT_EXPECT_RESPONSE_STATUS_EQ(Unauthorized({}).status, response);}

JSON::Object Metrics(){  process::UPID upid("metrics", process::address());  process::Future<process::http::Response> response =      process::http::get(upid, "snapshot");  AWAIT_EXPECT_RESPONSE_STATUS_EQ(process::http::OK().status, response);  AWAIT_EXPECT_RESPONSE_HEADER_EQ(APPLICATION_JSON, "Content-Type", response);  Try<JSON::Object> parse = JSON::parse<JSON::Object>(response.get().body);  CHECK_SOME(parse);  return parse.get();}

JSON::Object Metrics(){  process::UPID upid("metrics", process::address());  process::Future<process::http::Response> response =      process::http::get(upid, "snapshot");  AWAIT_EXPECT_RESPONSE_STATUS_EQ(process::http::OK().status, response);  EXPECT_SOME_EQ(      "application/json",      response.get().headers.get("Content-Type"));  Try<JSON::Object> parse = JSON::parse<JSON::Object>(response.get().body);  CHECK_SOME(parse);  return parse.get();}

JSON::Object Metrics(){  process::UPID upid("metrics", process::address());  // TODO(neilc): This request might timeout if the current value of a  // metric cannot be determined. In tests, a common cause for this is  // MESOS-6231 when multiple scheduler drivers are in use.  process::Future<process::http::Response> response =    process::http::get(upid, "snapshot");  AWAIT_EXPECT_RESPONSE_STATUS_EQ(process::http::OK().status, response);  AWAIT_EXPECT_RESPONSE_HEADER_EQ(APPLICATION_JSON, "Content-Type", response);  Try<JSON::Object> parse = JSON::parse<JSON::Object>(response.get().body);  CHECK_SOME(parse);  return parse.get();}

TEST_F(FilesTest, ReadTest){  Files files;  process::UPID upid("files", process::address());  Future<Response> response =    process::http::get(upid, "read.json");  AWAIT_EXPECT_RESPONSE_STATUS_EQ(BadRequest().status, response);  AWAIT_EXPECT_RESPONSE_BODY_EQ(      "Expecting 'path=value' in query./n",      response);  response = process::http::get(upid, "read.json", "path=none&offset=hello");  AWAIT_EXPECT_RESPONSE_STATUS_EQ(BadRequest().status, response);  AWAIT_EXPECT_RESPONSE_BODY_EQ(      "Failed to parse offset: Failed to convert 'hello' to number./n",      response);  response = process::http::get(upid, "read.json", "path=none&length=hello");  AWAIT_EXPECT_RESPONSE_STATUS_EQ(BadRequest().status, response);  AWAIT_EXPECT_RESPONSE_BODY_EQ(      "Failed to parse length: Failed to convert 'hello' to number./n",      response);  // Now write a file.  ASSERT_SOME(os::write("file", "body"));  AWAIT_EXPECT_READY(files.attach("file", "/myname"));  AWAIT_EXPECT_READY(files.attach("file", "myname"));  // Read a valid file.  JSON::Object expected;  expected.values["offset"] = 0;  expected.values["data"] = "body";  response = process::http::get(upid, "read.json", "path=/myname&offset=0");  AWAIT_EXPECT_RESPONSE_STATUS_EQ(OK().status, response);  AWAIT_EXPECT_RESPONSE_BODY_EQ(stringify(expected), response);  response = process::http::get(upid, "read.json", "path=myname&offset=0");  AWAIT_EXPECT_RESPONSE_STATUS_EQ(OK().status, response);  AWAIT_EXPECT_RESPONSE_BODY_EQ(stringify(expected), response);  // Missing file.  AWAIT_EXPECT_RESPONSE_STATUS_EQ(      NotFound().status,      process::http::get(upid, "read.json", "path=missing"));}

// Tests that requests for an agent endpoint// always succeed if the authorizer is absent.TEST_P(SlaveEndpointTest, NoAuthorizer){  const string endpoint = GetParam();  StandaloneMasterDetector detector;  Try<Owned<cluster::Slave>> agent = StartSlave(&detector, CreateSlaveFlags());  ASSERT_SOME(agent);  Future<Response> response = http::get(      agent.get()->pid,      endpoint,      None(),      createBasicAuthHeaders(DEFAULT_CREDENTIAL));  AWAIT_EXPECT_RESPONSE_STATUS_EQ(OK().status, response)    << response.get().body;}

// This test verifies the correct handling of the statistics// endpoint when there is no executor running.TEST(MonitorTest, NoExecutor){  ResourceMonitor monitor([]() -> Future<ResourceUsage> {    return ResourceUsage();  });  UPID upid("monitor", process::address());  Future<http::Response> response = http::get(upid, "statistics");  AWAIT_READY(response);  AWAIT_EXPECT_RESPONSE_STATUS_EQ(http::OK().status, response);  AWAIT_EXPECT_RESPONSE_HEADER_EQ(      "application/json",      "Content-Type",      response);  AWAIT_EXPECT_RESPONSE_BODY_EQ("[]", response);}

// This test sends a unsupported Accept media type for the Accept// header. The response should be NotAcceptable in this case.TEST_P(ExecutorHttpApiTest, NotAcceptable){  Try<PID<Master>> master = StartMaster();  ASSERT_SOME(master);  Future<Nothing> __recover = FUTURE_DISPATCH(_, &Slave::__recover);  Try<PID<Slave>> slave = StartSlave();  ASSERT_SOME(slave);  AWAIT_READY(__recover);  // Wait for recovery to be complete.  Clock::pause();  Clock::settle();  // Retrieve the parameter passed as content type to this test.  const ContentType contentType = GetParam();  process::http::Headers headers;  headers["Accept"] = "foo";  // Only subscribe needs to 'Accept' JSON or protobuf.  Call call;  call.mutable_framework_id()->set_value("dummy_framework_id");  call.mutable_executor_id()->set_value("dummy_executor_id");  call.set_type(Call::SUBSCRIBE);  call.mutable_subscribe();  Future<Response> response = process::http::streaming::post(      slave.get(),      "api/v1/executor",      headers,      serialize(contentType, call),      stringify(contentType));  AWAIT_EXPECT_RESPONSE_STATUS_EQ(NotAcceptable().status, response);  Shutdown();}