TEST_F(RegistrarTest, readmit) { Registrar registrar(state); AWAIT_READY(registrar.recover(MasterInfo())); SlaveInfo info1; info1.set_hostname("localhost"); // Missing ID results in a failure. AWAIT_EXPECT_FAILED(registrar.readmit(info1)); SlaveID id1; id1.set_value("1"); info1.mutable_id()->CopyFrom(id1); SlaveID id2; id2.set_value("2"); SlaveInfo info2; info2.set_hostname("localhost"); info2.mutable_id()->CopyFrom(id2); AWAIT_EQ(true, registrar.admit(info1)); AWAIT_EQ(true, registrar.readmit(info1)); AWAIT_EQ(false, registrar.readmit(info2)); }
// Bad password should return an authentication failure. TEST(SASL, failed1) { // Set up secrets. map<string, string> secrets; secrets["benh"] = "secret1"; sasl::secrets::load(secrets); // Launch a dummy process (somebody to send the AuthenticateMessage). UPID pid = spawn(new ProcessBase(), true); Credential credential; credential.set_principal("benh"); credential.set_secret("secret"); Authenticatee authenticatee(credential, UPID()); Future<Message> message = FUTURE_MESSAGE(Eq(AuthenticateMessage().GetTypeName()), _, _); Future<bool> client = authenticatee.authenticate(pid); AWAIT_READY(message); Authenticator authenticator(message.get().from); Future<bool> server = authenticator.authenticate(); AWAIT_EQ(false, client); AWAIT_EQ(false, server); terminate(pid); }
TEST_F(RegistrarTest, admit) { Registrar registrar(state); SlaveID id1; id1.set_value("1"); SlaveInfo info1; info1.set_hostname("localhost"); info1.mutable_id()->CopyFrom(id1); AWAIT_EQ(true, registrar.admit(id1, info1)); AWAIT_EQ(false, registrar.admit(id1, info1)); }
// This test verifies that a missing secret fails the authenticatee. TYPED_TEST(CRAMMD5Authentication, AuthenticateeSecretMissing) { Credential credential; credential.set_principal("benh"); Try<Authenticatee*> authenticatee = TypeParam::TypeAuthenticatee::create(); CHECK_SOME(authenticatee); Future<bool> future = authenticatee.get()->authenticate(UPID(), UPID(), credential); AWAIT_EQ(false, future); delete authenticatee.get(); }
TEST_F(RegistrarTest, recover) { Registrar registrar(state); SlaveInfo slave; slave.set_hostname("localhost"); SlaveID id; id.set_value("1"); slave.mutable_id()->CopyFrom(id); // Operations preceding recovery will fail. AWAIT_EXPECT_FAILED(registrar.admit(slave)); AWAIT_EXPECT_FAILED(registrar.readmit(slave)); AWAIT_EXPECT_FAILED(registrar.remove(slave)); MasterInfo info; info.set_id("foobar"); info.set_ip(0); info.set_port(5050); info.set_pid("0:5050"); Future<Registry> registry = registrar.recover(info); // Before waiting for the recovery to complete, invoke some // operations to ensure they do not fail. Future<bool> admit = registrar.admit(slave); Future<bool> readmit = registrar.readmit(slave); Future<bool> remove = registrar.remove(slave); AWAIT_READY(registry); EXPECT_EQ(info, registry.get().master().info()); AWAIT_EQ(true, admit); AWAIT_EQ(true, readmit); AWAIT_EQ(true, remove); }
TYPED_TEST(CRAMMD5Authentication, Success) { // Launch a dummy process (somebody to send the AuthenticateMessage). UPID pid = spawn(new ProcessBase(), true); Credential credential1; credential1.set_principal("benh"); credential1.set_secret("secret"); Credentials credentials; Credential* credential2 = credentials.add_credentials(); credential2->set_principal(credential1.principal()); credential2->set_secret(credential1.secret()); Future<Message> message = FUTURE_MESSAGE(Eq(AuthenticateMessage().GetTypeName()), _, _); Try<Authenticatee*> authenticatee = TypeParam::TypeAuthenticatee::create(); CHECK_SOME(authenticatee); Future<bool> client = authenticatee.get()->authenticate(pid, UPID(), credential1); AWAIT_READY(message); Try<Authenticator*> authenticator = TypeParam::TypeAuthenticator::create(); CHECK_SOME(authenticator); EXPECT_SOME(authenticator.get()->initialize(credentials)); Future<Option<string>> principal = authenticator.get()->authenticate(message.get().from); AWAIT_EQ(true, client); AWAIT_READY(principal); EXPECT_SOME_EQ("benh", principal.get()); terminate(pid); delete authenticator.get(); delete authenticatee.get(); }