feat(proxy): check error with proxy

- regex to check user input - unit test
TheRealPad · Feb 29, 2024 · b4dbdb6 · b4dbdb6
1 parent 6c177a8
commit b4dbdb6
Show file tree

Hide file tree

Showing 6 changed files with 185 additions and 1 deletion.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -22,6 +22,7 @@ set(TEST_SRC
         tests/test.cpp
         tests/Error.cpp
         tests/Calculator.cpp
+        tests/OperationsPriorities.cpp
 )
 
 add_executable(${NAME} main.cpp ${SRC})

diff --git a/src/Error/Error.cpp b/src/Error/Error.cpp
@@ -20,6 +20,8 @@ namespace ErrorCalculator {
             return this->_errorMsg.c_str();
         if (this->_error == ErrorType::DIVISION_BY_0)
             return "Division by 0";
+        if (this->_error == ErrorType::TYPO_USER_INPUT)
+            return "Typo in user input";
         return "Unknow error";
     }
 

diff --git a/src/Error/Error.h b/src/Error/Error.h
@@ -16,7 +16,8 @@ namespace ErrorCalculator {
 
             enum ErrorType {
                 CUSTOM,
-                DIVISION_BY_0
+                DIVISION_BY_0,
+                TYPO_USER_INPUT
             };
             Error() = default;
             ~Error() override = default;

diff --git a/src/OperationsPriorities/ProxyOperationsPriorities.cpp b/src/OperationsPriorities/ProxyOperationsPriorities.cpp
@@ -2,15 +2,36 @@
 // Created by Pierre-Alexandre Delgado on 28/02/2024.
 //
 
+#include <regex>
 #include "ProxyOperationsPriorities.h"
 
+#include <Error.h>
+
 namespace Operations {
 
     ProxyOperationsPriorities::ProxyOperationsPriorities() {
         this->_operationsPriorities = std::make_unique<OperationsPriorities>();
     }
 
+    bool ProxyOperationsPriorities::checkParenthesis(std::string const &operation) {
+        unsigned int nbrLeftParenthesis = 0;
+
+        for (auto const &c : operation) {
+            if (c == '(')
+                ++nbrLeftParenthesis;
+            if (c == ')' && nbrLeftParenthesis == 0)
+                return false;
+            if (c == ')')
+                --nbrLeftParenthesis;
+        }
+        return nbrLeftParenthesis == 0;
+    }
+
+
     std::string ProxyOperationsPriorities::makeOperation(std::string &operation) {
+        std::regex self_regex("^[0-9()+*/%\\- ]+$",std::regex_constants::ECMAScript | std::regex_constants::icase);
+        if (!std::regex_search(operation, self_regex) || !this->checkParenthesis(operation))
+            throw ErrorCalculator::Error(ErrorCalculator::Error::TYPO_USER_INPUT);
         return this->_operationsPriorities->makeOperation(operation);
     }
 

diff --git a/src/OperationsPriorities/ProxyOperationsPriorities.h b/src/OperationsPriorities/ProxyOperationsPriorities.h
@@ -17,6 +17,8 @@ namespace Operations {
             std::string makeOperation(std::string &operation) override;
 
         private:
+            bool checkParenthesis(std::string const &operation);
+
             std::unique_ptr<OperationsPriorities> _operationsPriorities;
     };
 

diff --git a/tests/OperationsPriorities.cpp b/tests/OperationsPriorities.cpp
@@ -0,0 +1,157 @@
+#include <Error.h>
+#include <gtest/gtest.h>
+#include "ProxyOperationsPriorities.h"
+
+TEST(ProxyOperationsPriorities, ValidStringOne)
+{
+    std::unique_ptr<Operations::IOperations> operations = std::make_unique<Operations::ProxyOperationsPriorities>();
+    std::string str = "()";
+    bool isValid = true;
+
+    try {
+        operations->makeOperation(str);
+    } catch (ErrorCalculator::Error &e) {
+        isValid = false;
+    }
+    EXPECT_EQ(isValid, true);
+}
+
+TEST(ProxyOperationsPriorities, ValidStringTwo)
+{
+    std::unique_ptr<Operations::IOperations> operations = std::make_unique<Operations::ProxyOperationsPriorities>();
+    std::string str = "(1)";
+    bool isValid = true;
+
+    try {
+        operations->makeOperation(str);
+    } catch (ErrorCalculator::Error &e) {
+        isValid = false;
+    }
+    EXPECT_EQ(isValid, true);
+}
+
+TEST(ProxyOperationsPriorities, ValidStringThree)
+{
+    std::unique_ptr<Operations::IOperations> operations = std::make_unique<Operations::ProxyOperationsPriorities>();
+    std::string str = "(1 + 1)";
+    bool isValid = true;
+
+    try {
+        operations->makeOperation(str);
+    } catch (ErrorCalculator::Error &e) {
+        isValid = false;
+    }
+    EXPECT_EQ(isValid, true);
+}
+
+TEST(ProxyOperationsPriorities, ValidStringFour)
+{
+    std::unique_ptr<Operations::IOperations> operations = std::make_unique<Operations::ProxyOperationsPriorities>();
+    std::string str = "(1+1)-4 + (1 * 23456)";
+    bool isValid = true;
+
+    try {
+        operations->makeOperation(str);
+    } catch (ErrorCalculator::Error &e) {
+        isValid = false;
+    }
+    EXPECT_EQ(isValid, true);
+}
+
+TEST(ProxyOperationsPriorities, ValidStringFive)
+{
+    std::unique_ptr<Operations::IOperations> operations = std::make_unique<Operations::ProxyOperationsPriorities>();
+    std::string str = "(((1 + 4) * 3) / 2) % 1";
+    bool isValid = true;
+
+    try {
+        operations->makeOperation(str);
+    } catch (ErrorCalculator::Error &e) {
+        isValid = false;
+    }
+    EXPECT_EQ(isValid, true);
+}
+
+TEST(ProxyOperationsPriorities, ValidStringSix)
+{
+    std::unique_ptr<Operations::IOperations> operations = std::make_unique<Operations::ProxyOperationsPriorities>();
+    std::string str = "(((1 + 4) * 3) / 2) % (1 +3+((3% 4) + 4))";
+    bool isValid = true;
+
+    try {
+        operations->makeOperation(str);
+    } catch (ErrorCalculator::Error &e) {
+        isValid = false;
+    }
+    EXPECT_EQ(isValid, true);
+}
+
+TEST(ProxyOperationsPriorities, InvalidStringOne)
+{
+    std::unique_ptr<Operations::IOperations> operations = std::make_unique<Operations::ProxyOperationsPriorities>();
+    std::string str = "invalid content";
+    bool isValid = true;
+
+    try {
+        operations->makeOperation(str);
+    } catch (ErrorCalculator::Error &e) {
+        isValid = false;
+    }
+    EXPECT_EQ(isValid, false);
+}
+
+TEST(ProxyOperationsPriorities, InvalidStringTwo)
+{
+    std::unique_ptr<Operations::IOperations> operations = std::make_unique<Operations::ProxyOperationsPriorities>();
+    std::string str = "1 + a";
+    bool isValid = true;
+
+    try {
+        operations->makeOperation(str);
+    } catch (ErrorCalculator::Error &e) {
+        isValid = false;
+    }
+    EXPECT_EQ(isValid, false);
+}
+
+TEST(ProxyOperationsPriorities, InvalidStringThree)
+{
+    std::unique_ptr<Operations::IOperations> operations = std::make_unique<Operations::ProxyOperationsPriorities>();
+    std::string str = "(";
+    bool isValid = true;
+
+    try {
+        operations->makeOperation(str);
+    } catch (ErrorCalculator::Error &e) {
+        isValid = false;
+    }
+    EXPECT_EQ(isValid, false);
+}
+
+TEST(ProxyOperationsPriorities, InvalidStringFour)
+{
+    std::unique_ptr<Operations::IOperations> operations = std::make_unique<Operations::ProxyOperationsPriorities>();
+    std::string str = ")";
+    bool isValid = true;
+
+    try {
+        operations->makeOperation(str);
+    } catch (ErrorCalculator::Error &e) {
+        isValid = false;
+    }
+    EXPECT_EQ(isValid, false);
+}
+
+TEST(ProxyOperationsPriorities, InvalidStringFive)
+{
+    std::unique_ptr<Operations::IOperations> operations = std::make_unique<Operations::ProxyOperationsPriorities>();
+    std::string str = "(1 + 3";
+    bool isValid = true;
+
+    try {
+        operations->makeOperation(str);
+    } catch (ErrorCalculator::Error &e) {
+        isValid = false;
+    }
+    EXPECT_EQ(isValid, false);
+}