diff --git a/test/certs_manager_test.cpp b/test/certs_manager_test.cpp
index da08996..9caa9d3 100644
--- a/test/certs_manager_test.cpp
+++ b/test/certs_manager_test.cpp
@@ -197,8 +197,8 @@
         }
 
         unsigned long hash = X509_subject_name_hash(cert.get());
-        static constexpr auto AUTH_CERT_HASH_LENGTH = 9;
-        char hashBuf[AUTH_CERT_HASH_LENGTH];
+        static constexpr auto authCertHashLength = 9;
+        char hashBuf[authCertHashLength];
         sprintf(hashBuf, "%08lx", hash);
         return std::string(hashBuf);
     }
@@ -271,7 +271,7 @@
 TEST_F(TestCertificates, InvokeServerInstall)
 {
     std::string endpoint("https");
-    CertificateType type = CertificateType::Server;
+    CertificateType type = CertificateType::server;
     std::string installPath(certDir + "/" + certificateFile);
     std::string verifyPath(installPath);
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
@@ -294,7 +294,7 @@
 TEST_F(TestCertificates, InvokeClientInstall)
 {
     std::string endpoint("ldap");
-    CertificateType type = CertificateType::Server;
+    CertificateType type = CertificateType::server;
     std::string installPath(certDir + "/" + certificateFile);
     std::string verifyPath(installPath);
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
@@ -317,7 +317,7 @@
 TEST_F(TestCertificates, InvokeAuthorityInstall)
 {
     std::string endpoint("ldap");
-    CertificateType type = CertificateType::Authority;
+    CertificateType type = CertificateType::authority;
     std::string verifyDir(certDir);
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
     auto objPath = std::string(objectNamePrefix) + '/' +
@@ -360,7 +360,7 @@
 TEST_F(TestCertificates, InvokeAuthorityInstallNeverExpiredRootCert)
 {
     std::string endpoint("ldap");
-    CertificateType type = CertificateType::Authority;
+    CertificateType type = CertificateType::authority;
     std::string verifyDir(certDir);
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
     auto objPath = std::string(objectNamePrefix) + '/' +
@@ -401,7 +401,7 @@
 TEST_F(TestCertificates, InvokeInstallSameCertTwice)
 {
     std::string endpoint("ldap");
-    CertificateType type = CertificateType::Authority;
+    CertificateType type = CertificateType::authority;
     std::string verifyDir(certDir);
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
     auto objPath = std::string(objectNamePrefix) + '/' +
@@ -457,7 +457,7 @@
 TEST_F(TestCertificates, InvokeInstallSameSubjectTwice)
 {
     std::string endpoint("ldap");
-    CertificateType type = CertificateType::Authority;
+    CertificateType type = CertificateType::authority;
     std::string verifyDir(certDir);
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
     auto objPath = std::string(objectNamePrefix) + '/' +
@@ -515,7 +515,7 @@
 TEST_F(TestCertificates, InvokeInstallAuthCertLimit)
 {
     std::string endpoint("ldap");
-    CertificateType type = CertificateType::Authority;
+    CertificateType type = CertificateType::authority;
     std::string verifyDir(certDir);
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
     auto objPath = std::string(objectNamePrefix) + '/' +
@@ -591,7 +591,7 @@
 TEST_F(TestCertificates, CompareInstalledCertificate)
 {
     std::string endpoint("ldap");
-    CertificateType type = CertificateType::Client;
+    CertificateType type = CertificateType::client;
     std::string installPath(certDir + "/" + certificateFile);
     std::string verifyPath(installPath);
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
@@ -615,7 +615,7 @@
 TEST_F(TestCertificates, TestNoCertificateFile)
 {
     std::string endpoint("ldap");
-    CertificateType type = CertificateType::Client;
+    CertificateType type = CertificateType::client;
     std::string installPath(certDir + "/" + certificateFile);
     std::string verifyPath(installPath);
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
@@ -648,7 +648,7 @@
 TEST_F(TestCertificates, TestReplaceCertificate)
 {
     std::string endpoint("ldap");
-    CertificateType type = CertificateType::Server;
+    CertificateType type = CertificateType::server;
     std::string installPath(certDir + "/" + certificateFile);
     std::string verifyPath(installPath);
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
@@ -678,7 +678,7 @@
 TEST_F(TestCertificates, TestAuthorityReplaceCertificate)
 {
     std::string endpoint("ldap");
-    CertificateType type = CertificateType::Authority;
+    CertificateType type = CertificateType::authority;
     std::string verifyDir(certDir);
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
     auto objPath = std::string(objectNamePrefix) + '/' +
@@ -688,9 +688,9 @@
     bus.attach_event(event.get(), SD_EVENT_PRIORITY_NORMAL);
     ManagerInTest manager(bus, event, objPath.c_str(), type, verifyUnit,
                           certDir);
-    constexpr const unsigned int REPLACE_ITERATIONS = 10;
+    constexpr const unsigned int replaceIterations = 10;
     EXPECT_CALL(manager, reloadOrReset(Eq(ManagerInTest::unitToRestartInTest)))
-        .Times(REPLACE_ITERATIONS + 1)
+        .Times(replaceIterations + 1)
         .WillRepeatedly(Return());
     MainApp mainApp(&manager);
     mainApp.install(certificateFile);
@@ -698,7 +698,7 @@
     std::vector<std::unique_ptr<Certificate>>& certs =
         manager.getCertificates();
 
-    for (unsigned int i = 0; i < REPLACE_ITERATIONS; i++)
+    for (unsigned int i = 0; i < replaceIterations; i++)
     {
         // Certificate successfully installed
         EXPECT_FALSE(certs.empty());
@@ -728,7 +728,7 @@
 TEST_F(TestCertificates, TestStorageDeleteCertificate)
 {
     std::string endpoint("ldap");
-    CertificateType type = CertificateType::Authority;
+    CertificateType type = CertificateType::authority;
     std::string verifyDir(certDir);
     std::string verifyUnit((ManagerInTest::unitToRestartInTest));
     auto objPath = std::string(objectNamePrefix) + '/' +
@@ -781,7 +781,7 @@
 TEST_F(TestCertificates, TestEmptyCertificateFile)
 {
     std::string endpoint("ldap");
-    CertificateType type = CertificateType::Client;
+    CertificateType type = CertificateType::client;
     std::string installPath(certDir + "/" + certificateFile);
     std::string verifyPath(installPath);
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
@@ -818,7 +818,7 @@
 TEST_F(TestCertificates, TestInvalidCertificateFile)
 {
     std::string endpoint("ldap");
-    CertificateType type = CertificateType::Client;
+    CertificateType type = CertificateType::client;
 
     std::ofstream ofs;
     ofs.open(certificateFile, std::ofstream::out);
@@ -905,7 +905,7 @@
 TEST_F(TestInvalidCertificate, TestMissingPrivateKey)
 {
     std::string endpoint("ldap");
-    CertificateType type = CertificateType::Client;
+    CertificateType type = CertificateType::client;
     std::string installPath(certDir + "/" + certificateFile);
     std::string verifyPath(installPath);
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
@@ -937,7 +937,7 @@
 TEST_F(TestInvalidCertificate, TestMissingCeritificate)
 {
     std::string endpoint("ldap");
-    CertificateType type = CertificateType::Client;
+    CertificateType type = CertificateType::client;
     std::string installPath(certDir + "/" + keyFile);
     std::string verifyPath(installPath);
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
@@ -972,7 +972,7 @@
     using NotAllowed =
         sdbusplus::xyz::openbmc_project::Common::Error::NotAllowed;
     std::string endpoint("ldap");
-    CertificateType type = CertificateType::Client;
+    CertificateType type = CertificateType::client;
     std::string installPath(certDir + "/" + certificateFile);
     std::string verifyPath(installPath);
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
@@ -1005,10 +1005,10 @@
 {
     std::string endpoint("https");
     std::string unit;
-    CertificateType type = CertificateType::Server;
+    CertificateType type = CertificateType::server;
     std::string installPath(certDir + "/" + certificateFile);
     std::string verifyPath(installPath);
-    std::string CSRPath(certDir + "/" + CSRFile);
+    std::string csrPath(certDir + "/" + CSRFile);
     std::string privateKeyPath(certDir + "/" + privateKeyFile);
     std::vector<std::string> alternativeNames{"localhost1", "localhost2"};
     std::string challengePassword("Password");
@@ -1036,7 +1036,7 @@
     Manager manager(bus, event, objPath.c_str(), type, std::move(unit),
                     std::move(installPath));
     Status status;
-    CSR csr(bus, objPath.c_str(), CSRPath.c_str(), status);
+    CSR csr(bus, objPath.c_str(), csrPath.c_str(), status);
     MainApp mainApp(&manager, &csr);
     mainApp.generateCSR(alternativeNames, challengePassword, city, commonName,
                         contactPerson, country, email, givenName, initials,
@@ -1045,7 +1045,7 @@
                         unstructuredName);
     std::string csrData("");
     // generateCSR takes considerable time to create CSR and privateKey Files
-    EXPECT_FALSE(fs::exists(CSRPath));
+    EXPECT_FALSE(fs::exists(csrPath));
     EXPECT_FALSE(fs::exists(privateKeyPath));
     EXPECT_THROW(
         {
@@ -1061,7 +1061,7 @@
         InternalFailure);
     // wait for 10 sec to get CSR and privateKey Files generated
     sleep(10);
-    EXPECT_TRUE(fs::exists(CSRPath));
+    EXPECT_TRUE(fs::exists(csrPath));
     EXPECT_TRUE(fs::exists(privateKeyPath));
     csrData = csr.csr();
     ASSERT_NE("", csrData.c_str());
@@ -1074,10 +1074,10 @@
 {
     std::string endpoint("https");
     std::string unit;
-    CertificateType type = CertificateType::Server;
+    CertificateType type = CertificateType::server;
     std::string installPath(certDir + "/" + certificateFile);
     std::string verifyPath(installPath);
-    std::string CSRPath(certDir + "/" + CSRFile);
+    std::string csrPath(certDir + "/" + CSRFile);
     std::string privateKeyPath(certDir + "/" + privateKeyFile);
     std::vector<std::string> alternativeNames{"localhost1", "localhost2"};
     std::string challengePassword("Password");
@@ -1103,7 +1103,7 @@
     Manager manager(bus, event, objPath.c_str(), type, std::move(unit),
                     std::move(installPath));
     Status status;
-    CSR csr(bus, objPath.c_str(), CSRPath.c_str(), status);
+    CSR csr(bus, objPath.c_str(), csrPath.c_str(), status);
     MainApp mainApp(&manager, &csr);
     mainApp.generateCSR(alternativeNames, challengePassword, city, commonName,
                         contactPerson, country, email, givenName, initials,
@@ -1111,7 +1111,7 @@
                         organization, organizationalUnit, state, surname,
                         unstructuredName);
     sleep(10);
-    EXPECT_TRUE(fs::exists(CSRPath));
+    EXPECT_TRUE(fs::exists(csrPath));
     EXPECT_TRUE(fs::exists(privateKeyPath));
 }
 
@@ -1122,10 +1122,10 @@
 {
     std::string endpoint("https");
     std::string unit;
-    CertificateType type = CertificateType::Server;
+    CertificateType type = CertificateType::server;
     std::string installPath(certDir + "/" + certificateFile);
     std::string verifyPath(installPath);
-    std::string CSRPath(certDir + "/" + CSRFile);
+    std::string csrPath(certDir + "/" + CSRFile);
     std::string privateKeyPath(certDir + "/" + privateKeyFile);
     std::vector<std::string> alternativeNames{"localhost1", "localhost2"};
     std::string challengePassword("Password");
@@ -1151,14 +1151,14 @@
     Manager manager(bus, event, objPath.c_str(), type, std::move(unit),
                     std::move(installPath));
     Status status;
-    CSR csr(bus, objPath.c_str(), CSRPath.c_str(), status);
+    CSR csr(bus, objPath.c_str(), csrPath.c_str(), status);
     MainApp mainApp(&manager, &csr);
     mainApp.generateCSR(alternativeNames, challengePassword, city, commonName,
                         contactPerson, country, email, givenName, initials,
                         keyBitLength, keyCurveId, keyPairAlgorithm, keyUsage,
                         organization, organizationalUnit, state, surname,
                         unstructuredName);
-    EXPECT_FALSE(fs::exists(CSRPath));
+    EXPECT_FALSE(fs::exists(csrPath));
     EXPECT_FALSE(fs::exists(privateKeyPath));
 }
 
@@ -1169,10 +1169,10 @@
 {
     std::string endpoint("https");
     std::string unit;
-    CertificateType type = CertificateType::Server;
+    CertificateType type = CertificateType::server;
     std::string installPath(certDir + "/" + certificateFile);
     std::string verifyPath(installPath);
-    std::string CSRPath(certDir + "/" + CSRFile);
+    std::string csrPath(certDir + "/" + CSRFile);
     std::string privateKeyPath(certDir + "/" + privateKeyFile);
     std::vector<std::string> alternativeNames{"localhost1", "localhost2"};
     std::string challengePassword("Password");
@@ -1198,14 +1198,14 @@
     Manager manager(bus, event, objPath.c_str(), type, std::move(unit),
                     std::move(installPath));
     Status status;
-    CSR csr(bus, objPath.c_str(), CSRPath.c_str(), status);
+    CSR csr(bus, objPath.c_str(), csrPath.c_str(), status);
     MainApp mainApp(&manager, &csr);
     mainApp.generateCSR(alternativeNames, challengePassword, city, commonName,
                         contactPerson, country, email, givenName, initials,
                         keyBitLength, keyCurveId, keyPairAlgorithm, keyUsage,
                         organization, organizationalUnit, state, surname,
                         unstructuredName);
-    EXPECT_FALSE(fs::exists(CSRPath));
+    EXPECT_FALSE(fs::exists(csrPath));
     EXPECT_FALSE(fs::exists(privateKeyPath));
 }
 
@@ -1215,10 +1215,10 @@
 {
     std::string endpoint("https");
     std::string unit;
-    CertificateType type = CertificateType::Server;
+    CertificateType type = CertificateType::server;
     std::string installPath(certDir + "/" + certificateFile);
     std::string verifyPath(installPath);
-    std::string CSRPath(certDir + "/" + CSRFile);
+    std::string csrPath(certDir + "/" + CSRFile);
     std::string privateKeyPath(certDir + "/" + privateKeyFile);
     std::vector<std::string> alternativeNames{"localhost1", "localhost2"};
     std::string challengePassword("Password");
@@ -1244,7 +1244,7 @@
     Manager manager(bus, event, objPath.c_str(), type, std::move(unit),
                     std::move(installPath));
     Status status;
-    CSR csr(bus, objPath.c_str(), CSRPath.c_str(), status);
+    CSR csr(bus, objPath.c_str(), csrPath.c_str(), status);
     MainApp mainApp(&manager, &csr);
     mainApp.generateCSR(alternativeNames, challengePassword, city, commonName,
                         contactPerson, country, email, givenName, initials,
@@ -1252,7 +1252,7 @@
                         organization, organizationalUnit, state, surname,
                         unstructuredName);
     sleep(10);
-    EXPECT_TRUE(fs::exists(CSRPath));
+    EXPECT_TRUE(fs::exists(csrPath));
     EXPECT_TRUE(fs::exists(privateKeyPath));
 }
 
@@ -1262,10 +1262,10 @@
 {
     std::string endpoint("https");
     std::string unit;
-    CertificateType type = CertificateType::Server;
+    CertificateType type = CertificateType::server;
     std::string installPath(certDir + "/" + certificateFile);
     std::string verifyPath(installPath);
-    std::string CSRPath(certDir + "/" + CSRFile);
+    std::string csrPath(certDir + "/" + CSRFile);
     std::string privateKeyPath(certDir + "/" + privateKeyFile);
     std::vector<std::string> alternativeNames{"localhost1", "localhost2"};
     std::string challengePassword("Password");
@@ -1291,17 +1291,17 @@
     Manager manager(bus, event, objPath.c_str(), type, std::move(unit),
                     std::move(installPath));
     Status status;
-    CSR csr(bus, objPath.c_str(), CSRPath.c_str(), status);
+    CSR csr(bus, objPath.c_str(), csrPath.c_str(), status);
     MainApp mainApp(&manager, &csr);
     mainApp.generateCSR(alternativeNames, challengePassword, city, commonName,
                         contactPerson, country, email, givenName, initials,
                         keyBitLength, keyCurveId, keyPairAlgorithm, keyUsage,
                         organization, organizationalUnit, state, surname,
                         unstructuredName);
-    std::cout << "CSRPath: " << CSRPath << std::endl
+    std::cout << "CSRPath: " << csrPath << std::endl
               << "privateKeyPath: " << privateKeyPath << std::endl;
     sleep(10);
-    EXPECT_TRUE(fs::exists(CSRPath));
+    EXPECT_TRUE(fs::exists(csrPath));
     EXPECT_TRUE(fs::exists(privateKeyPath));
 }
 
@@ -1312,10 +1312,10 @@
 {
     std::string endpoint("https");
     std::string unit;
-    CertificateType type = CertificateType::Server;
+    CertificateType type = CertificateType::server;
     std::string installPath(certDir + "/" + certificateFile);
     std::string verifyPath(installPath);
-    std::string CSRPath(certDir + "/" + CSRFile);
+    std::string csrPath(certDir + "/" + CSRFile);
     std::string privateKeyPath(certDir + "/" + privateKeyFile);
     std::vector<std::string> alternativeNames{"localhost1", "localhost2"};
     std::string challengePassword("Password");
@@ -1341,14 +1341,14 @@
     Manager manager(bus, event, objPath.c_str(), type, std::move(unit),
                     std::move(installPath));
     Status status;
-    CSR csr(bus, objPath.c_str(), CSRPath.c_str(), status);
+    CSR csr(bus, objPath.c_str(), csrPath.c_str(), status);
     MainApp mainApp(&manager, &csr);
     mainApp.generateCSR(alternativeNames, challengePassword, city, commonName,
                         contactPerson, country, email, givenName, initials,
                         keyBitLength, keyCurveId, keyPairAlgorithm, keyUsage,
                         organization, organizationalUnit, state, surname,
                         unstructuredName);
-    EXPECT_FALSE(fs::exists(CSRPath));
+    EXPECT_FALSE(fs::exists(csrPath));
     EXPECT_FALSE(fs::exists(privateKeyPath));
 }
 
@@ -1358,10 +1358,10 @@
 {
     std::string endpoint("https");
     std::string unit;
-    CertificateType type = CertificateType::Server;
+    CertificateType type = CertificateType::server;
     std::string installPath(certDir + "/" + certificateFile);
     std::string verifyPath(installPath);
-    std::string CSRPath(certDir + "/" + CSRFile);
+    std::string csrPath(certDir + "/" + CSRFile);
     std::string privateKeyPath(certDir + "/" + privateKeyFile);
     std::vector<std::string> alternativeNames{"localhost1", "localhost2"};
     std::string challengePassword("Password");
@@ -1391,14 +1391,14 @@
     fs::remove(rsaPrivateKeyFilePath);
 
     Status status;
-    CSR csr(bus, objPath.c_str(), CSRPath.c_str(), status);
+    CSR csr(bus, objPath.c_str(), csrPath.c_str(), status);
     MainApp mainApp(&manager, &csr);
     mainApp.generateCSR(alternativeNames, challengePassword, city, commonName,
                         contactPerson, country, email, givenName, initials,
                         keyBitLength, keyCurveId, keyPairAlgorithm, keyUsage,
                         organization, organizationalUnit, state, surname,
                         unstructuredName);
-    EXPECT_FALSE(fs::exists(CSRPath));
+    EXPECT_FALSE(fs::exists(csrPath));
     EXPECT_FALSE(fs::exists(privateKeyPath));
 }
 
@@ -1409,10 +1409,10 @@
 {
     std::string endpoint("https");
     std::string unit;
-    CertificateType type = CertificateType::Server;
+    CertificateType type = CertificateType::server;
     std::string installPath(certDir + "/" + certificateFile);
     std::string verifyPath(installPath);
-    std::string CSRPath(certDir + "/" + CSRFile);
+    std::string csrPath(certDir + "/" + CSRFile);
     std::string privateKeyPath(certDir + "/" + privateKeyFile);
     std::vector<std::string> alternativeNames{"localhost1", "localhost2"};
     std::string challengePassword("Password");
@@ -1438,7 +1438,7 @@
     Manager manager(bus, event, objPath.c_str(), type, std::move(unit),
                     std::move(installPath));
     Status status;
-    CSR csr(bus, objPath.c_str(), CSRPath.c_str(), status);
+    CSR csr(bus, objPath.c_str(), csrPath.c_str(), status);
     MainApp mainApp(&manager, &csr);
     mainApp.generateCSR(alternativeNames, challengePassword, city, commonName,
                         contactPerson, country, email, givenName, initials,
@@ -1446,7 +1446,7 @@
                         organization, organizationalUnit, state, surname,
                         unstructuredName);
     sleep(10);
-    EXPECT_TRUE(fs::exists(CSRPath));
+    EXPECT_TRUE(fs::exists(csrPath));
     EXPECT_TRUE(fs::exists(privateKeyPath));
 }
 
@@ -1454,7 +1454,7 @@
 TEST_F(TestCertificates, TestGenerateRSAPrivateKeyFile)
 {
     std::string endpoint("https");
-    CertificateType type = CertificateType::Server;
+    CertificateType type = CertificateType::server;
     std::string installPath(certDir + "/" + certificateFile);
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
     auto objPath = std::string(objectNamePrefix) + '/' +
@@ -1606,7 +1606,7 @@
 {
     std::string endpoint("ldap");
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
-    CertificateType type = CertificateType::Authority;
+    CertificateType type = CertificateType::authority;
 
     std::string object = std::string(objectNamePrefix) + '/' +
                          certificateTypeToString(type) + '/' + endpoint;
@@ -1634,7 +1634,7 @@
 {
     std::string endpoint("ldap");
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
-    CertificateType type = CertificateType::Authority;
+    CertificateType type = CertificateType::authority;
 
     std::string object = std::string(objectNamePrefix) + '/' +
                          certificateTypeToString(type) + '/' + endpoint;
@@ -1686,7 +1686,7 @@
 {
     std::string endpoint("ldap");
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
-    CertificateType type = CertificateType::Authority;
+    CertificateType type = CertificateType::authority;
 
     std::string object = std::string(objectNamePrefix) + '/' +
                          certificateTypeToString(type) + '/' + endpoint;
@@ -1714,7 +1714,7 @@
 TEST_F(AuthoritiesListTest, InstallAllWrongManagerType)
 {
     std::string endpoint("ldap");
-    CertificateType type = CertificateType::Server;
+    CertificateType type = CertificateType::server;
 
     std::string object = std::string(objectNamePrefix) + '/' +
                          certificateTypeToString(type) + '/' + endpoint;
@@ -1727,7 +1727,7 @@
     EXPECT_THROW(serverManager.installAll(sourceAuthoritiesListFile),
                  sdbusplus::xyz::openbmc_project::Common::Error::NotAllowed);
 
-    type = CertificateType::Client;
+    type = CertificateType::client;
     object = std::string(objectNamePrefix) + '/' +
              certificateTypeToString(type) + '/' + endpoint;
     ManagerInTest clientManager(bus, event, object.c_str(), type, "",
@@ -1740,7 +1740,7 @@
 {
     std::string endpoint("ldap");
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
-    CertificateType type = CertificateType::Authority;
+    CertificateType type = CertificateType::authority;
 
     std::string object = std::string(objectNamePrefix) + '/' +
                          certificateTypeToString(type) + '/' + endpoint;
@@ -1764,7 +1764,7 @@
 {
     std::string endpoint("ldap");
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
-    CertificateType type = CertificateType::Authority;
+    CertificateType type = CertificateType::authority;
 
     std::string object = std::string(objectNamePrefix) + '/' +
                          certificateTypeToString(type) + '/' + endpoint;
@@ -1783,7 +1783,7 @@
 {
     std::string endpoint("ldap");
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
-    CertificateType type = CertificateType::Authority;
+    CertificateType type = CertificateType::authority;
 
     std::string object = std::string(objectNamePrefix) + '/' +
                          certificateTypeToString(type) + '/' + endpoint;
@@ -1802,7 +1802,7 @@
 {
     std::string endpoint("ldap");
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
-    CertificateType type = CertificateType::Authority;
+    CertificateType type = CertificateType::authority;
 
     std::string object = std::string(objectNamePrefix) + '/' +
                          certificateTypeToString(type) + '/' + endpoint;
@@ -1828,7 +1828,7 @@
 {
     std::string endpoint("ldap");
     std::string verifyUnit(ManagerInTest::unitToRestartInTest);
-    CertificateType type = CertificateType::Authority;
+    CertificateType type = CertificateType::authority;
 
     std::string object = std::string(objectNamePrefix) + '/' +
                          certificateTypeToString(type) + '/' + endpoint;