2022-2-WS_group_project_bankmanagement-system/tests/test_createEmployeeAccount.c

#ifdef TEST

#include "unity.h"

#include "createEmployeeAccount.h"

void setUp(void)
{
}

void tearDown(void)
{
}

void test_isValidEmployeeID(void)
{
    //test case 0
    /*Arrange*/

    char* validEmployeeId [] = {"Atharva","Can","Haytham","Julius","Mohamed","Shivam","Fizz","Buzz","JohnDoe","Foobar","waz","Objectoriented","INSTITUTIONALISATIOL","Intercommunicational","1234","1.6"};
    int validStringLengths = 20;
    bool validEmployeeIdExpected = true;

    /*Act and Assert*/

    for(int i=0; i<15; i++)
    {
        bool validEmployeeIdResult = isValidEmployeeID(validEmployeeId[i],validStringLengths);
        TEST_ASSERT_EQUAL(validEmployeeIdExpected,validEmployeeIdResult);
    }
}

void test_isNotValidEmployeeID(void)
{
    //test case 1
    /*Arrange*/
    
    char* invalidEmployeeId [] = {"Atha rva","Ca n","Geschwindigkeitsbegrenzungen","1234 15","John  Doe","fizz Fuzz"};
    int invalidStringLengths = 20;
    bool invalidEmployeeIdExpected = false;

    /*Act and Assert*/

    for(int i=0; i<6; i++)
    {
        bool invalidEmployeeIdResult = isValidEmployeeID(invalidEmployeeId[i],invalidStringLengths);
        TEST_ASSERT_EQUAL(invalidEmployeeIdExpected,invalidEmployeeIdResult);
    }
   
}

void test_validEmployeePassword(void)
{
    /*Arrange*/

    char* validPassword [] = {"Atharva.123","02.September.2023","fdai7207.","array[20]","malloc(20*sizeof(int))","12.2E1234"};
    int minimalLength = 8;
    bool validPasswordexpectation = true;
    bool validPasswordResult[6];

    /*Act and Assert*/

    for(int i=0; i<6; i++)
    {
        validPasswordResult[i] = isValidPassword(validPassword[i],minimalLength);
        TEST_ASSERT_EQUAL(validPasswordexpectation,validPasswordResult[i]);
    }

}

void test_invalidEmployeePassword(void)
{
    /*Arrange*/

    char* invalidPassword [] = {"fizzbuzzio","02.09.2023",".^^_*+/-.","RTX4050ti","Can","github.com/bankmanagement-system"};
    int minimalLength = 8;
    bool invalidPasswordexpected = false;
    bool invalidPasswordResult[6];

    /*Act and Assert*/

    for(int i=0; i<6; i++)
    {
        invalidPasswordResult[i] = isValidPassword(invalidPassword[i],minimalLength);
        TEST_ASSERT_EQUAL(invalidPasswordexpected,invalidPasswordResult[i]);
    }

}

void test_verifyPasswordSuccess()
{
    /*Arrange*/

    char* passwordsAndVerifications[][2] = {
                                            {"Atharva123.","Atharva123."},
                                            {"fdai.7207","fdai.7207"},
                                            {"fizz.buzz132","fizz.buzz132"},
                                            {"23.March.1999","23.March.1999"},
                                            {"John.doe99","John.doe99"},
                                            {"foo/bar2","foo/bar2"},
                                            {"fizz+3buzz","fizz+3buzz"},
                                            {"gitlab2.com","gitlab2.com"},
                                            {"4test:all","4test:all"},
                                            {"WS-2023","WS-2023"}
                                            };
    
    bool expectation = true;

    /*Act and Assert*/

    for(int i=0; i<10; i++)
    {
        bool result = verifyPassword(passwordsAndVerifications[i][0],passwordsAndVerifications[i][1]);
        TEST_ASSERT_EQUAL(expectation,result);
    }
}

void test_verifyPasswordFailure()
{
    /*Arrange*/

    char* passwordsAndVerifications[][2] = {
                                            {"Atharva123.","Atharva123"},
                                            {"fdai.7207","fdai.72"},
                                            {"fizz.buzz132","invalidPassword"},
                                            {"23.March.1999","23.May.1999"},
                                            {"John.doe99","Jane.doe99"},
                                            {"foo/bar2","foo*bar3"},
                                            {"fizz+3buzz","fizz-3buzz"},
                                            {"gitlab2.com","github.com"},
                                            {"4test:all","4ceedlingtest:all"},
                                            {"WS-2023","SS-2023"}
                                            };
    
    bool expectation = false;

    /*Act and Assert*/

    for(int i=0; i<10; i++)
    {
        bool result = verifyPassword(passwordsAndVerifications[i][0],passwordsAndVerifications[i][1]);
        TEST_ASSERT_EQUAL(expectation,result);
    }

}

void test_employeesDataStoringSuccess(void)
{
    /*Arrange*/
    char* data[][4] ={
                        {"John","Doe","fulda,leipzigerstr12","+4926428421469"},
                        {"Jane","Done","fulda,leipzigerstr13","+4932517359874"},
                        {"Foo","Bar","fulda,leipzigerstr14","+4913598765315"},
                        {"Mustermann","Mustermanpass","fulda,leipzigerstr16","+4938197853812"}
                    };
    bool creationExpectation = true;

    /*Act and Assert*/

    for(int i=0;i<4;i++)
    {
            bool creationResult = storeEmployeeData(data[i][0],data[i][1],data[i][2],data[i][3]);
            TEST_ASSERT_EQUAL(creationExpectation,creationResult);
    }

}

void test_employeeCreatedSuccessfully(void)
{
    /*Arrange*/
    char* potentialEmployees[][2] = {
	                          {"John", "Doe"},
							  {"Fizz", "Buzz"},
							  {"Jane", "Doe"},
							  {"Foo", "Bar"},
							  {"MusterMann", "MusterManPassword"},
							  {"MusterFrau", "MusterFrauPassword"}
						     };

    bool expected = true;
    bool result; 

    /*Act and Assert*/

    for(int i=0; i<6;i++)
    {
        result =  createNewEmployee(potentialEmployees[i][0],potentialEmployees[i][1]);
        TEST_ASSERT_EQUAL(expected,result);
    }

}

void test_validName(void)
{
    /*Arrange*/

    char* validNames[] = {"John","Jane","Fizz","Foo","Atharva","Can","Julius","Haytham","Mohamed","Shivam"};
    int minimalLength = 4;
    bool validNamesResult[10];

    /*Act*/

    for(int i = 0;i<10;i++)
    {
        validNamesResult[i] = isValidName(validNames[i],minimalLength);
    }

    /*Assert*/

    for(int i = 0;i<10;i++)
    {
        TEST_ASSERT_TRUE(validNames[i]);
    }

}

void test_invalidName(void)
{
    /*Arrange*/

    char* invalidNames[] = {"Jo hn","Jane.","Fizz36","Foo8","Ath,arva","C .a1n","Jul132ius","123Haytham",".Mohamed"," Shivam"};
    int minimalLength = 4;
    bool invalidNamesResult[10];

    /*Act*/

    for(int i = 0;i<10;i++)
    {
        invalidNamesResult[i] = isValidName(invalidNames[i],minimalLength);
    }

    /*Assert*/

    for(int i = 0;i<10;i++)
    {
        TEST_ASSERT_FALSE(invalidNamesResult[i]);
    }

}

#endif // TEST