pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2025-12-11 21:01:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[Tests] Cleanup Hand-in Tests (#4749)

Browse Source
This commit is contained in:
Chris Miles 2025-03-04 17:15:27 -06:00 committed by GitHub
parent 0615864d51
commit 4bc881da4b
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 169 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
zone/cli/databuckets.cpp
View File

@ -40,7 +40,7 @@ void ZoneCLI::DataBuckets(int argc, char **argv, argh::parser &cmd, std::string
LogSys.EnableConsoleLogging(); LogSys.EnableConsoleLogging();
std::cout << "===========================================\n"; std::cout << "===========================================\n";
std::cout << "Running DataBuckets Tests...\n"; std::cout << "⚙\uFE0F> Running DataBuckets Tests...\n";
std::cout << "===========================================\n\n"; std::cout << "===========================================\n\n";
Client *client = new Client(); Client *client = new Client();

251
zone/cli/npc_handins.cpp
View File

@ -4,8 +4,76 @@
#include "../zone.h" #include "../zone.h"
#include "../client.h" #include "../client.h"
#include "../../common/net/eqstream.h" #include "../../common/net/eqstream.h"
#include "../../common/json/json.hpp"
extern Zone *zone; extern Zone *zone;
using json = nlohmann::json;
struct HandinEntry {
std::string item_id = "0";
uint32 count = 0;
const EQ::ItemInstance *item = nullptr;
bool is_multiquest_item = false; // state
};
struct HandinMoney {
uint32 platinum = 0;
uint32 gold = 0;
uint32 silver = 0;
uint32 copper = 0;
};
struct Handin {
std::vector<HandinEntry> items = {}; // items can be removed from this set as successful handins are made
HandinMoney money = {}; // money can be removed from this set as successful handins are made
};
struct TestCase {
std::string description;
Handin hand_in;
Handin required;
Handin returned;
bool handin_check_result;
};
void RunTest(const std::string &test_name, bool expected, bool actual)
{
if (expected == actual) {
std::cout << "[✅] " << test_name << " PASSED\n";
}
else {
std::cerr << "[❌] " << test_name << " FAILED\n";
std::cerr << " 📌 Expected: " << (expected ? "true" : "false") << "\n";
std::cerr << " ❌ Got: " << (actual ? "true" : "false") << "\n";
std::exit(1);
}
}
void RunSerializedTest(const std::string &test_name, const std::string &expected, const std::string &actual)
{
if (expected == actual) {
std::cout << "[✅] " << test_name << " PASSED\n";
}
else {
std::cerr << "[❌] " << test_name << " FAILED\n";
std::cerr << " 📌 Expected: " << expected << "\n";
std::cerr << " ❌ Got: " << actual << "\n";
std::exit(1);
}
}
std::string SerializeHandin(const std::map<std::string, uint32> &items, const HandinMoney &money)
{
json j;
j["items"] = items;
j["money"] = {
{"platinum", money.platinum},
{"gold", money.gold},
{"silver", money.silver},
{"copper", money.copper}
};
return j.dump();
}
void ZoneCLI::NpcHandins(int argc, char **argv, argh::parser &cmd, std::string &description) void ZoneCLI::NpcHandins(int argc, char **argv, argh::parser &cmd, std::string &description)
{ {
@ -13,15 +81,6 @@ void ZoneCLI::NpcHandins(int argc, char **argv, argh::parser &cmd, std::string &
return; return;
} }
uint32 break_length = 50;
int failed_count = 0;
RegisterExecutablePlatform(EQEmuExePlatform::ExePlatformZoneSidecar);
LogInfo("{}", Strings::Repeat("-", break_length));
LogInfo("Booting test zone for NPC handins");
LogInfo("{}", Strings::Repeat("-", break_length));
LogSys.SilenceConsoleLogging(); LogSys.SilenceConsoleLogging();
Zone::Bootup(ZoneID("qrg"), 0, false); Zone::Bootup(ZoneID("qrg"), 0, false);
@ -30,9 +89,9 @@ void ZoneCLI::NpcHandins(int argc, char **argv, argh::parser &cmd, std::string &
entity_list.Process(); entity_list.Process();
entity_list.MobProcess(); entity_list.MobProcess();
LogInfo("{}", Strings::Repeat("-", break_length)); std::cout << "===========================================\n";
LogInfo("> Done booting test zone"); std::cout << "⚙\uFE0F> Running Hand-in Tests...\n";
LogInfo("{}", Strings::Repeat("-", break_length)); std::cout << "===========================================\n\n";
Client *c = new Client(); Client *c = new Client();
auto npc_type = content_db.LoadNPCTypesData(754008); auto npc_type = content_db.LoadNPCTypesData(754008);
@ -46,36 +105,6 @@ void ZoneCLI::NpcHandins(int argc, char **argv, argh::parser &cmd, std::string &
entity_list.AddNPC(npc); entity_list.AddNPC(npc);
LogInfo("> Spawned NPC [{}]", npc->GetCleanName());
LogInfo("> Spawned client [{}]", c->GetCleanName());
struct HandinEntry {
std::string item_id = "0";
uint32 count = 0;
const EQ::ItemInstance *item = nullptr;
bool is_multiquest_item = false; // state
};
struct HandinMoney {
uint32 platinum = 0;
uint32 gold = 0;
uint32 silver = 0;
uint32 copper = 0;
};
struct Handin {
std::vector<HandinEntry> items = {}; // items can be removed from this set as successful handins are made
HandinMoney money = {}; // money can be removed from this set as successful handins are made
};
struct TestCase {
std::string description = "";
Handin hand_in;
Handin required;
Handin returned;
bool handin_check_result;
};
std::vector<TestCase> test_cases = { std::vector<TestCase> test_cases = {
TestCase{ TestCase{
.description = "Test basic cloth-cap hand-in", .description = "Test basic cloth-cap hand-in",
@ -155,7 +184,10 @@ void ZoneCLI::NpcHandins(int argc, char **argv, argh::parser &cmd, std::string &
.items = {}, .items = {},
.money = {.platinum = 100}, .money = {.platinum = 100},
}, },
.returned = {}, .returned = {
.items = {},
.money = {.platinum = 1},
},
.handin_check_result = false, .handin_check_result = false,
}, },
TestCase{ TestCase{
@ -168,7 +200,10 @@ void ZoneCLI::NpcHandins(int argc, char **argv, argh::parser &cmd, std::string &
.items = {}, .items = {},
.money = {.platinum = 100, .gold = 100, .silver = 100, .copper = 100}, .money = {.platinum = 100, .gold = 100, .silver = 100, .copper = 100},
}, },
.returned = {}, .returned = {
.items = {},
.money = {.platinum = 1, .gold = 1, .silver = 1, .copper = 1},
},
.handin_check_result = false, .handin_check_result = false,
}, },
TestCase{ TestCase{
@ -217,8 +252,11 @@ void ZoneCLI::NpcHandins(int argc, char **argv, argh::parser &cmd, std::string &
}, },
.returned = { .returned = {
.items = { .items = {
HandinEntry{.item_id = "1001", .count = 1}, HandinEntry{
.item_id = "1001", .count = 0,
},
}, },
.money = {.platinum = 1},
}, },
.handin_check_result = false, .handin_check_result = false,
}, },
@ -304,12 +342,7 @@ void ZoneCLI::NpcHandins(int argc, char **argv, argh::parser &cmd, std::string &
HandinEntry{.item_id = "1007", .count = 1}, HandinEntry{.item_id = "1007", .count = 1},
HandinEntry{.item_id = "1007", .count = 1}, HandinEntry{.item_id = "1007", .count = 1},
}, },
.money = { .money = {},
.platinum = 1,
.gold = 666,
.silver = 234,
.copper = 444,
},
}, },
.handin_check_result = true, .handin_check_result = true,
}, },
@ -402,8 +435,8 @@ void ZoneCLI::NpcHandins(int argc, char **argv, argh::parser &cmd, std::string &
}, },
}; };
std::map<std::string, uint32> hand_ins; std::map<std::string, uint32> hand_ins;
std::map<std::string, uint32> required; std::map<std::string, uint32> required;
std::vector<EQ::ItemInstance *> items; std::vector<EQ::ItemInstance *> items;
LogSys.EnableConsoleLogging(); LogSys.EnableConsoleLogging();
@ -411,14 +444,12 @@ void ZoneCLI::NpcHandins(int argc, char **argv, argh::parser &cmd, std::string &
// turn this on to see debugging output // turn this on to see debugging output
LogSys.log_settings[Logs::NpcHandin].log_to_console = std::getenv("DEBUG") ? 3 : 0; LogSys.log_settings[Logs::NpcHandin].log_to_console = std::getenv("DEBUG") ? 3 : 0;
LogInfo("{}", Strings::Repeat("-", break_length)); for (auto &test: test_cases) {
for (auto &test_case: test_cases) {
hand_ins.clear(); hand_ins.clear();
required.clear(); required.clear();
items.clear(); items.clear();
for (auto &hand_in: test_case.hand_in.items) { for (auto &hand_in: test.hand_in.items) {
auto item_id = Strings::ToInt(hand_in.item_id); auto item_id = Strings::ToInt(hand_in.item_id);
EQ::ItemInstance *inst = database.CreateItem(item_id); EQ::ItemInstance *inst = database.CreateItem(item_id);
if (inst->IsStackable()) { if (inst->IsStackable()) {
@ -434,72 +465,76 @@ void ZoneCLI::NpcHandins(int argc, char **argv, argh::parser &cmd, std::string &
} }
// money // money
if (test_case.hand_in.money.platinum > 0) { if (test.hand_in.money.platinum > 0) {
hand_ins["platinum"] = test_case.hand_in.money.platinum; hand_ins["platinum"] = test.hand_in.money.platinum;
} }
if (test_case.hand_in.money.gold > 0) { if (test.hand_in.money.gold > 0) {
hand_ins["gold"] = test_case.hand_in.money.gold; hand_ins["gold"] = test.hand_in.money.gold;
} }
if (test_case.hand_in.money.silver > 0) { if (test.hand_in.money.silver > 0) {
hand_ins["silver"] = test_case.hand_in.money.silver; hand_ins["silver"] = test.hand_in.money.silver;
} }
if (test_case.hand_in.money.copper > 0) { if (test.hand_in.money.copper > 0) {
hand_ins["copper"] = test_case.hand_in.money.copper; hand_ins["copper"] = test.hand_in.money.copper;
} }
for (auto &req: test_case.required.items) { for (auto &req: test.required.items) {
required[req.item_id] = req.count; required[req.item_id] = req.count;
} }
// money // money
if (test_case.required.money.platinum > 0) { if (test.required.money.platinum > 0) {
required["platinum"] = test_case.required.money.platinum; required["platinum"] = test.required.money.platinum;
} }
if (test_case.required.money.gold > 0) { if (test.required.money.gold > 0) {
required["gold"] = test_case.required.money.gold; required["gold"] = test.required.money.gold;
} }
if (test_case.required.money.silver > 0) { if (test.required.money.silver > 0) {
required["silver"] = test_case.required.money.silver; required["silver"] = test.required.money.silver;
} }
if (test_case.required.money.copper > 0) { if (test.required.money.copper > 0) {
required["copper"] = test_case.required.money.copper; required["copper"] = test.required.money.copper;
} }
auto result = npc->CheckHandin(c, hand_ins, required, items); auto result = npc->CheckHandin(c, hand_ins, required, items);
if (result != test_case.handin_check_result) {
failed_count++; RunTest(test.description, test.handin_check_result, result);
LogError("FAIL [{}]", test_case.description);
// print out the hand-ins
LogError("Hand-ins >");
for (auto &hand_in: hand_ins) {
LogError(" > Item [{}] count [{}]", hand_in.first, hand_in.second);
}
LogError("Required >");
for (auto &req: required) {
LogError(" > Item [{}] count [{}]", req.first, req.second);
}
LogError("Expected [{}] got [{}]", test_case.handin_check_result, result);
}
else {
LogInfo("PASS [{}]", test_case.description);
}
auto returned = npc->ReturnHandinItems(c); auto returned = npc->ReturnHandinItems(c);
// assert that returned items are expected std::map<std::string, uint32> returned_items;
for (auto &item: test_case.returned.items) { HandinMoney returned_money{};
auto found = false;
for (auto &ret: returned.items) { // Serialize returned items
if (ret.item_id == item.item_id) { for (const auto &ret: returned.items) {
found = true; // if (ret.item->IsStackable() && ret.item->GetCharges() != ret.count) {
break; // ret.item->SetCharges(ret.count);
} // }
} returned_items[ret.item_id] += ret.count;
if (!found) {
LogError("Returned item [{}] not expected", item.item_id);
}
} }
// Serialize returned money
returned_money.platinum = returned.money.platinum;
returned_money.gold = returned.money.gold;
returned_money.silver = returned.money.silver;
returned_money.copper = returned.money.copper;
// Serialize expected and actual return values for comparison
std::map<std::string, uint32> expected_returned_items;
for (const auto &entry: test.returned.items) {
expected_returned_items[entry.item_id] += entry.count;
}
std::string expected_serialized = SerializeHandin(
expected_returned_items,
test.returned.money
);
std::string actual_serialized = SerializeHandin(returned_items, returned_money);
// Run serialization check test
RunSerializedTest(test.description + " (Return Validation)", expected_serialized, actual_serialized);
npc->ResetHandin(); npc->ResetHandin();
if (LogSys.log_settings[Logs::NpcHandin].log_to_console > 0) { if (LogSys.log_settings[Logs::NpcHandin].log_to_console > 0) {
@ -508,11 +543,7 @@ void ZoneCLI::NpcHandins(int argc, char **argv, argh::parser &cmd, std::string &
} }
} }
if (failed_count > 0) { std::cout << "\n===========================================\n";
LogError("Failed [{}] tests", failed_count); std::cout << "✅ All NPC Hand-in Tests Completed!\n";
std::exit(1); std::cout << "===========================================\n";
}
else {
LogInfo("All tests passed");
}
} }

98
zone/cli/npc_handins_multiquest.cpp
View File

@ -16,12 +16,6 @@ void ZoneCLI::NpcHandinsMultiQuest(int argc, char **argv, argh::parser &cmd, std
uint32 break_length = 50; uint32 break_length = 50;
int failed_count = 0; int failed_count = 0;
RegisterExecutablePlatform(EQEmuExePlatform::ExePlatformZoneSidecar);
LogInfo("{}", Strings::Repeat("-", break_length));
LogInfo("Booting test zone for NPC handins (MultiQuest)");
LogInfo("{}", Strings::Repeat("-", break_length));
LogSys.SilenceConsoleLogging(); LogSys.SilenceConsoleLogging();
Zone::Bootup(ZoneID("qrg"), 0, false); Zone::Bootup(ZoneID("qrg"), 0, false);
@ -30,9 +24,9 @@ void ZoneCLI::NpcHandinsMultiQuest(int argc, char **argv, argh::parser &cmd, std
entity_list.Process(); entity_list.Process();
entity_list.MobProcess(); entity_list.MobProcess();
LogInfo("{}", Strings::Repeat("-", break_length)); std::cout << "===========================================\n";
LogInfo("> Done booting test zone"); std::cout << "⚙\uFE0F> Running Hand-in Tests (Multi-Quest)...\n";
LogInfo("{}", Strings::Repeat("-", break_length)); std::cout << "===========================================\n\n";
Client *c = new Client(); Client *c = new Client();
auto npc_type = content_db.LoadNPCTypesData(754008); auto npc_type = content_db.LoadNPCTypesData(754008);
@ -47,9 +41,6 @@ void ZoneCLI::NpcHandinsMultiQuest(int argc, char **argv, argh::parser &cmd, std
entity_list.AddNPC(npc); entity_list.AddNPC(npc);
npc->MultiQuestEnable(); npc->MultiQuestEnable();
LogInfo("> Spawned NPC [{}]", npc->GetCleanName());
LogInfo("> Spawned client [{}]", c->GetCleanName());
struct HandinEntry { struct HandinEntry {
std::string item_id = "0"; std::string item_id = "0";
uint32 count = 0; uint32 count = 0;
@ -108,12 +99,10 @@ void ZoneCLI::NpcHandinsMultiQuest(int argc, char **argv, argh::parser &cmd, std
// turn this on to see debugging output // turn this on to see debugging output
LogSys.log_settings[Logs::NpcHandin].log_to_console = std::getenv("DEBUG") ? 3 : 0; LogSys.log_settings[Logs::NpcHandin].log_to_console = std::getenv("DEBUG") ? 3 : 0;
LogInfo("{}", Strings::Repeat("-", break_length)); for (auto &test: test_cases) {
for (auto &test_case: test_cases) {
required.clear(); required.clear();
for (auto &hand_in: test_case.hand_in.items) { for (auto &hand_in: test.hand_in.items) {
hand_ins.clear(); hand_ins.clear();
items.clear(); items.clear();
@ -135,72 +124,43 @@ void ZoneCLI::NpcHandinsMultiQuest(int argc, char **argv, argh::parser &cmd, std
} }
// money // money
if (test_case.hand_in.money.platinum > 0) { if (test.hand_in.money.platinum > 0) {
hand_ins["platinum"] = test_case.hand_in.money.platinum; hand_ins["platinum"] = test.hand_in.money.platinum;
} }
if (test_case.hand_in.money.gold > 0) { if (test.hand_in.money.gold > 0) {
hand_ins["gold"] = test_case.hand_in.money.gold; hand_ins["gold"] = test.hand_in.money.gold;
} }
if (test_case.hand_in.money.silver > 0) { if (test.hand_in.money.silver > 0) {
hand_ins["silver"] = test_case.hand_in.money.silver; hand_ins["silver"] = test.hand_in.money.silver;
} }
if (test_case.hand_in.money.copper > 0) { if (test.hand_in.money.copper > 0) {
hand_ins["copper"] = test_case.hand_in.money.copper; hand_ins["copper"] = test.hand_in.money.copper;
} }
for (auto &req: test_case.required.items) { for (auto &req: test.required.items) {
required[req.item_id] = req.count; required[req.item_id] = req.count;
} }
// money // money
if (test_case.required.money.platinum > 0) { if (test.required.money.platinum > 0) {
required["platinum"] = test_case.required.money.platinum; required["platinum"] = test.required.money.platinum;
} }
if (test_case.required.money.gold > 0) { if (test.required.money.gold > 0) {
required["gold"] = test_case.required.money.gold; required["gold"] = test.required.money.gold;
} }
if (test_case.required.money.silver > 0) { if (test.required.money.silver > 0) {
required["silver"] = test_case.required.money.silver; required["silver"] = test.required.money.silver;
} }
if (test_case.required.money.copper > 0) { if (test.required.money.copper > 0) {
required["copper"] = test_case.required.money.copper; required["copper"] = test.required.money.copper;
} }
auto result = npc->CheckHandin(c, hand_ins, required, items); auto result = npc->CheckHandin(c, hand_ins, required, items);
if (result != test_case.handin_check_result) {
failed_count++; RunTest(test.description, test.handin_check_result, result);
LogError("FAIL [{}]", test_case.description);
// print out the hand-ins
LogError("Hand-ins >");
for (auto &item: npc->GetHandin().items) {
LogError(" > Item [{}] count [{}]", item.item_id, item.count);
}
LogError("Required >");
for (auto &req: required) {
LogError(" > Item [{}] count [{}]", req.first, req.second);
}
LogError("Expected [{}] got [{}]", test_case.handin_check_result, result);
}
else {
LogInfo("PASS [{}]", test_case.description);
}
auto returned = npc->ReturnHandinItems(c); auto returned = npc->ReturnHandinItems(c);
// assert that returned items are expected
for (auto &item: test_case.returned.items) {
auto found = false;
for (auto &ret: returned.items) {
if (ret.item_id == item.item_id) {
found = true;
break;
}
}
if (!found) {
LogError("Returned item [{}] not expected", item.item_id);
}
}
npc->ResetHandin(); npc->ResetHandin();
if (LogSys.log_settings[Logs::NpcHandin].log_to_console > 0) { if (LogSys.log_settings[Logs::NpcHandin].log_to_console > 0) {
@ -209,11 +169,7 @@ void ZoneCLI::NpcHandinsMultiQuest(int argc, char **argv, argh::parser &cmd, std
} }
} }
if (failed_count > 0) { std::cout << "\n===========================================\n";
LogError("Failed [{}] tests", failed_count); std::cout << "✅ All NPC Hand-in Tests Completed (Multi-Quest)!\n";
std::exit(1); std::cout << "===========================================\n";
}
else {
LogInfo("All tests passed");
}
} }