ChocAnTest.cpp

#include "ChocAn.h"

// Helper to check if a provider with a given ID exists in a vector
bool containsProviderWithId(const vector<Provider> &providers, int prov_id) {
    for (const auto &p : providers) {
        if (p.prov_id == prov_id) return true;
    }
    return false;
}

// Helper to check if a member with a given ID exists in a vector
bool containsMemberWithId(const vector<Member> &members, int mem_id) {
    for (const auto &m : members) {
        if (m.mem_id == mem_id) return true;
    }
    return false;
}

// Helper to check if a service with a given code exists in a vector
bool containsServiceWithCode(const vector<Service> &services, int code) {
    for (const auto &s : services) {
        if (s.code == code) return true;
    }
    return false;
}

// Test provider function to run tests with a more clean main
int testProvider()
{
    cout << "Starting Provider tests..." << endl;

    ChocAnDB db;
    bool ok = db.initialize();
    assert(ok && "Failed to initialize database");

    // Use a test provider ID that shouldn't collide with real data
    const int TEST_PROV_ID = 999999;

    // Clean up any leftover test provider from previous runs
    db.deleteProvider(TEST_PROV_ID);


    //Test addProvider
    cout << "[1] Testing addProvider..." << endl;

    Provider p;
    p.prov_id   = TEST_PROV_ID;
    p.prov_name = "Test Provider";
    p.address   = "123 Test St";
    p.city      = "Portland";
    p.state     = "OR";
    p.zip       = "97203";

    ok = db.addProvider(p);
    assert(ok && "addProvider should return true");

    //Test getProvider after add
    cout << "[2] Testing getProvider after add..." << endl;

    Provider *fetched = db.getProvider(TEST_PROV_ID);
    assert(fetched != nullptr && "getProvider should not return nullptr after add");
    assert(fetched->prov_id   == TEST_PROV_ID);
    assert(fetched->prov_name == "Test Provider");
    assert(fetched->address   == "123 Test St");
    assert(fetched->city      == "Portland");
    assert(fetched->state     == "OR");
    assert(fetched->zip       == "97203");

    delete fetched;  // avoid memory leak

    //Test updateProvider
    cout << "[3] Testing updateProvider..." << endl;

    Provider updated;
    updated.prov_id   = TEST_PROV_ID;    // same ID, different data
    updated.prov_name = "Updated Provider";
    updated.address   = "456 Updated Ave";
    updated.city      = "Beaverton";
    updated.state     = "OR";
    updated.zip       = "97005";

    ok = db.updateProvider(updated);
    assert(ok && "updateProvider should return true");

    // Verify the update took effect
    fetched = db.getProvider(TEST_PROV_ID);
    assert(fetched != nullptr && "getProvider should still find provider after update");
    assert(fetched->prov_name == "Updated Provider");
    assert(fetched->address   == "456 Updated Ave");
    assert(fetched->city      == "Beaverton");
    assert(fetched->state     == "OR");
    assert(fetched->zip       == "97005");

    delete fetched;

    //Test getAllProviders
    cout << "[4] Testing getAllProviders..." << endl;

    vector<Provider> allProviders = db.getAllProviders();
    assert(!allProviders.empty() && "getAllProviders should return at least one provider");
    assert(containsProviderWithId(allProviders, TEST_PROV_ID) &&
           "getAllProviders should include the test provider");

    //Test deleteProvider
    cout << "[5] Testing deleteProvider..." << endl;

    ok = db.deleteProvider(TEST_PROV_ID);
    assert(ok && "deleteProvider should return true");

    fetched = db.getProvider(TEST_PROV_ID);
    assert(fetched == nullptr && "getProvider should return nullptr after delete");

    // Final cleanup / shutdown
    db.close();

    cout << "All provider tests passed successfully!" << endl;
    return 0;
}

// Test member function to run tests with a more clean main
int testMember()
{
	cout << "Starting Member tests..." << endl;

	ChocAnDB db;
	bool ok = db.initialize();
	assert(ok && "Failed to initialize database");

	// Use a test member ID that shouldn't collide with real data
	const int TEST_MEM_ID = 888888;

	// Clean up any leftover test member from previous runs
	db.deleteMember(TEST_MEM_ID);


	//Test addMember
	cout << "[1] Testing addMember..." << endl;

	Member m;
	m.mem_id   = TEST_MEM_ID;
	m.mem_name = "Test Member";
	m.address  = "123 Test St";
	m.city     = "Portland";
	m.state    = "OR";
	m.zip      = "97203";
	m.status   = "active";

	ok = db.addMember(m);
	assert(ok && "addMember should return true");

	//Test getMember after add
	cout << "[2] Testing getMember after add..." << endl;

	Member *fetched = db.getMember(TEST_MEM_ID);
	assert(fetched != nullptr && "getMember should not return nullptr after add");
	assert(fetched->mem_id   == TEST_MEM_ID);
	assert(fetched->mem_name == "Test Member");
	assert(fetched->address  == "123 Test St");
	assert(fetched->city     == "Portland");
	assert(fetched->state    == "OR");
	assert(fetched->zip      == "97203");
	assert(fetched->status   == "active");

	delete fetched;  // avoid memory leak

	//Test updateMember
	cout << "[3] Testing updateMember..." << endl;

	Member updated;
	updated.mem_id   = TEST_MEM_ID;    // same ID, different data
	updated.mem_name = "Updated Member";
	updated.address  = "456 Updated Ave";
	updated.city     = "Beaverton";
	updated.state    = "OR";
	updated.zip      = "97005";
	updated.status   = "suspended";

	ok = db.updateMember(updated);
	assert(ok && "updateMember should return true");

	// Verify the update took effect
	fetched = db.getMember(TEST_MEM_ID);
	assert(fetched != nullptr && "getMember should still find member after update");
	assert(fetched->mem_name == "Updated Member");
	assert(fetched->address  == "456 Updated Ave");
	assert(fetched->city     == "Beaverton");
	assert(fetched->state    == "OR");
	assert(fetched->zip      == "97005");
	assert(fetched->status   == "suspended");

	delete fetched;

	//Test getAllMembers
	cout << "[4] Testing getAllMembers..." << endl;

	vector<Member> allMembers = db.getAllMembers();
	assert(!allMembers.empty() && "getAllMembers should return at least one member");
	assert(containsMemberWithId(allMembers, TEST_MEM_ID) &&
				 "getAllMembers should include the test member");

	//Test deleteMember
	cout << "[5] Testing deleteMember..." << endl;

	ok = db.deleteMember(TEST_MEM_ID);
	assert(ok && "deleteMember should return true");

	fetched = db.getMember(TEST_MEM_ID);
	assert(fetched == nullptr && "getMember should return nullptr after delete");

	// Final cleanup / shutdown
	db.close();

	cout << "All member tests passed successfully!" << endl;
	return 0;
}

int testService()
{
	cout << "Starting Service tests..." << endl;

	ChocAnDB db;
	bool ok = db.initialize();
	assert(ok && "Failed to initialize database");

	// Use a test service code that shouldn't collide with real data
	const int TEST_CODE = 777777;

	// Clean up any leftover test service from previous runs
	db.deleteService(TEST_CODE);


	//Test addService
	cout << "[1] Testing addService..." << endl;

	Service s;
	s.code = TEST_CODE;
	s.name = "Test Service";
	s.fee  = 99.99;

	ok = db.addService(s);
	assert(ok && "addService should return true");

	//Test getService after add
	cout << "[2] Testing getService after add..." << endl;

	Service *fetched = db.getService(TEST_CODE);
	assert(fetched != nullptr && "getService should not return nullptr after add");
	assert(fetched->code == TEST_CODE);
	assert(fetched->name == "Test Service");
	assert(fetched->fee  == 99.99);

	delete fetched;  // avoid memory leak

	//Test updateService
	cout << "[3] Testing updateService..." << endl;

	Service updated;
	updated.code = TEST_CODE;    // same code, different data
	updated.name = "Updated Service";
	updated.fee  = 149.99;

	ok = db.updateService(updated);
	assert(ok && "updateService should return true");

	// Verify the update took effect
	fetched = db.getService(TEST_CODE);
	assert(fetched != nullptr && "getService should still find service after update");
	assert(fetched->name == "Updated Service");
	assert(fetched->fee  == 149.99);

	delete fetched;

	//Test getAllServices
	cout << "[4] Testing getAllServices..." << endl;

	vector<Service> allServices = db.getAllServices();
	assert(!allServices.empty() && "getAllServices should return at least one service");
	assert(containsServiceWithCode(allServices, TEST_CODE) &&
				 "getAllServices should include the test service");

	//Test deleteService
	cout << "[5] Testing deleteService..." << endl;

	ok = db.deleteService(TEST_CODE);
	assert(ok && "deleteService should return true");

	fetched = db.getService(TEST_CODE);
	assert(fetched == nullptr && "getService should return nullptr after delete");

	// Final cleanup / shutdown
	db.close();

	cout << "All service tests passed successfully!" << endl;
	return 0;
}

int main() {
	testProvider();
	testMember();
	testService();
}