mmo-ref/cyphesis
1
0
Fork 0
mirror of https://github.com/worldforge/cyphesis synced 2026-08-13 12:26:04 -04:00
Code Issues Projects Releases Packages Wiki Activity
cyphesis/tests/AccountIntegration.cpp
Erik Ogenvik 2eeab96efa Separate BBox property from Density property.
2018-12-16 20:40:48 +01:00

469 lines
12 KiB
C++
Raw Permalink Blame History

// Cyphesis Online RPG Server and AI Engine
// Copyright (C) 2009 Alistair Riddoch
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software Foundation,
// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
#ifdef NDEBUG
#undef NDEBUG
#endif
#ifndef DEBUG
#define DEBUG
#endif
#include "TestBase.h"
#include "server/Account.h"
#include "server/EntityBuilder.h"
#include "server/EntityRuleHandler.h"
#include "server/Ruleset.h"
#include "server/ServerRouting.h"
#include "server/Connection.h"
#include "server/WorldRouter.h"
#include "rules/Domain.h"
#include "rules/simulation/Entity.h"
#include "rules/simulation/ExternalMind.h"
#include "rules/simulation/MindsProperty.h"
#include "common/CommSocket.h"
#include "common/Inheritance.h"
#include "common/SystemTime.h"
#include "TestWorld.h"
#include "DatabaseNull.h"
#include <Atlas/Objects/SmartPtr.h>
#include <Atlas/Objects/Anonymous.h>
#include <Atlas/Objects/Operation.h>
#include <cassert>
#include <server/Persistence.h>
#include <common/Monitors.h>
#include <server/ExternalMindsManager.h>
#include <server/PossessionAuthenticator.h>
using Atlas::Message::Element;
using Atlas::Message::ListType;
using Atlas::Message::MapType;
using Atlas::Objects::Root;
using Atlas::Objects::Entity::RootEntity;
using Atlas::Objects::Entity::Anonymous;
using Atlas::Objects::Operation::Create;
using Atlas::Objects::Operation::Get;
using Atlas::Objects::Operation::Imaginary;
using Atlas::Objects::Operation::Logout;
using Atlas::Objects::Operation::Look;
using Atlas::Objects::Operation::Set;
using Atlas::Objects::Operation::Talk;
using Atlas::Objects::Operation::Move;
class TestCommSocket : public CommSocket
{
public:
TestCommSocket() : CommSocket(*(boost::asio::io_service*)0)
{
}
virtual void disconnect()
{
}
virtual int flush()
{
return 0;
}
};
class TestAccount : public Account {
public:
TestAccount(Connection * conn, const std::string & username,
const std::string & passwd,
const std::string & id, long intId) :
Account(conn, username, passwd, id, intId) {
}
virtual int characterError(const Operation & op,
const Atlas::Objects::Root & ent,
OpVector & res) const {
return 0;
}
};
class Accountintegration : public Cyphesis::TestBase
{
DatabaseNull m_database;
Persistence* m_persistence;
SystemTime * m_time;
WorldRouter * m_world;
ServerRouting * m_server;
CommSocket * m_tc;
Connection * m_c;
TestAccount * m_ac;
public:
Accountintegration();
void setup();
void teardown();
void test_addNewCharacter();
void test_getType();
void test_addToMessage();
void test_addToEntity();
void test_CreateOperation();
void test_GetOperation();
void test_ImaginaryOperation();
void test_LookOperation();
void test_SetOperation();
void test_TalkOperation();
void test_LogoutOperation();
void test_connectCharacter_entity();
void test_connectCharacter_character();
Inheritance* m_inheritance;
Ref<Entity> m_rootEntity;
EntityBuilder* m_eb;
};
Accountintegration::Accountintegration()
{
ADD_TEST(Accountintegration::test_addNewCharacter);
ADD_TEST(Accountintegration::test_getType);
ADD_TEST(Accountintegration::test_addToMessage);
ADD_TEST(Accountintegration::test_addToEntity);
ADD_TEST(Accountintegration::test_CreateOperation);
ADD_TEST(Accountintegration::test_GetOperation);
ADD_TEST(Accountintegration::test_ImaginaryOperation);
ADD_TEST(Accountintegration::test_LookOperation);
ADD_TEST(Accountintegration::test_SetOperation);
ADD_TEST(Accountintegration::test_TalkOperation);
ADD_TEST(Accountintegration::test_LogoutOperation);
ADD_TEST(Accountintegration::test_connectCharacter_entity);
ADD_TEST(Accountintegration::test_connectCharacter_character);
}
Atlas::Objects::Root composeDeclaration(std::string class_name, std::string parent, Atlas::Message::MapType rawAttributes) {
Atlas::Objects::Root decl;
decl->setObjtype("class");
decl->setId(class_name);
decl->setParent(parent);
Atlas::Message::MapType composed;
for (const auto& entry : rawAttributes) {
composed[entry.first] = Atlas::Message::MapType{
{"default", entry.second}
};
}
decl->setAttr("attributes", composed);
return decl;
};
void Accountintegration::setup()
{
m_rootEntity = new Entity("", 0);
m_persistence = new Persistence(m_database);
m_inheritance = new Inheritance();
m_time = new SystemTime;
m_eb = new EntityBuilder();
auto entityRuleHandler = new EntityRuleHandler(m_eb);
m_world = new WorldRouter(*m_time, m_rootEntity);
m_server = new ServerRouting(*m_world, "noruleset", "unittesting",
"1", 1, "2", 2);
m_tc = new TestCommSocket();
m_c = new Connection(*m_tc, *m_server, "addr", "3", 3);
m_ac = new TestAccount(m_c, "user", "password", "4", 4);
std::string dependent, reason;
{
auto decl = composeDeclaration("thing", "game_entity", {});
std::map<const TypeNode*, TypeNode::PropertiesUpdate> changes;
entityRuleHandler->install(decl->getId(), decl->getParent(), decl, dependent, reason, changes);
}
}
void Accountintegration::teardown()
{
delete m_server;
delete m_ac;
delete m_world;
m_rootEntity = nullptr;
delete m_eb;
delete m_inheritance;
delete m_persistence;
}
void Accountintegration::test_addNewCharacter()
{
WorldRouter::instance().createSpawnPoint(Atlas::Message::MapType{
{"name", "foo"},
{"entities", Atlas::Message::MapType{{"thing", Atlas::Message::MapType{}}}}
}, m_rootEntity.get());
OpVector res;
Anonymous new_char;
RootEntity args;
args->setAttr("spawn_name", "foo");
args->setParent("thing");
auto chr = m_ac->addNewCharacter(new_char, args, res);
assert(chr);
std::cout << "Test 1" << std::endl << std::flush;
}
void Accountintegration::test_getType()
{
m_ac->getType();
}
void Accountintegration::test_addToMessage()
{
MapType emap;
m_ac->addToMessage(emap);
}
void Accountintegration::test_addToEntity()
{
RootEntity ent;
m_ac->addToEntity(ent);
}
void Accountintegration::test_CreateOperation()
{
Anonymous op_arg;
op_arg->setParent("game_entity");
op_arg->setName("Bob");
Create op;
op->setArgs1(op_arg);
OpVector res;
m_ac->operation(op, res);
}
void Accountintegration::test_GetOperation()
{
Anonymous op_arg;
op_arg->setParent("");
Get op;
op->setArgs1(op_arg);
OpVector res;
m_ac->operation(op, res);
}
void Accountintegration::test_ImaginaryOperation()
{
Anonymous op_arg;
op_arg->setLoc("2");
Imaginary op;
op->setArgs1(op_arg);
op->setSerialno(1);
OpVector res;
m_ac->operation(op, res);
// FIXME Test response is sent to Lobby
}
void Accountintegration::test_LookOperation()
{
WorldRouter::instance().createSpawnPoint(Atlas::Message::MapType{
{"name", "foo"},
{"entities", Atlas::Message::MapType{{"thing", Atlas::Message::MapType{}}}}
}, m_rootEntity.get());
OpVector res;
Anonymous new_char;
RootEntity args;
args->setAttr("spawn_name", "foo");
args->setParent("thing");
auto chr = m_ac->addNewCharacter(new_char, args, res);
Anonymous op_arg;
op_arg->setId("1");
op_arg->setId(chr->getId());
Look op;
op->setArgs1(op_arg);
m_ac->operation(op, res);
// FIXME This doesn't test a lot
}
void Accountintegration::test_SetOperation()
{
WorldRouter::instance().createSpawnPoint(Atlas::Message::MapType{
{"name", "foo"},
{"entities", Atlas::Message::MapType{{"thing", Atlas::Message::MapType{}}}}
}, m_rootEntity.get());
OpVector res;
Anonymous new_char;
RootEntity args;
args->setAttr("spawn_name", "foo");
args->setParent("thing");
auto chr = m_ac->addNewCharacter(new_char, args, res);
BBox newBox(WFMath::Point<3>(-0.5, 0.0, -0.5),
WFMath::Point<3>(-0.5, 2.0, -0.5));
chr->m_location.setBBox(newBox);
Anonymous op_arg;
op_arg->setId(chr->getId());
op_arg->setAttr("guise", "foo");
op_arg->setAttr("height", 3.0);
op_arg->setAttr("tasks", ListType());
Set op;
op->setArgs1(op_arg);
m_ac->operation(op, res);
// FIXME Ensure character has been modified
}
void Accountintegration::test_TalkOperation()
{
Anonymous op_arg;
op_arg->setParent("");
op_arg->setLoc("1");
Talk op;
op->setSerialno(1);
op->setArgs1(op_arg);
OpVector res;
m_ac->operation(op, res);
// FIXME Sound op should have been sent to the lobby
}
void Accountintegration::test_LogoutOperation()
{
Logout op;
op->setSerialno(1);
Anonymous op_arg;
op_arg->setParent("");
op->setArgs1(op_arg);
OpVector res;
m_ac->operation(op, res);
// FIXME Account should have been removed from Lobby, and also from
// Connection
}
void Accountintegration::test_connectCharacter_entity()
{
OpVector res;
Ref<Entity> e = new Entity("7", 7);
int ret = m_ac->connectCharacter(e.get(), res);
ASSERT_EQUAL(ret, 0);
}
void Accountintegration::test_connectCharacter_character()
{
Ref<Entity> e = new Entity("8", 8);
OpVector res;
int ret = m_ac->connectCharacter(e.get(), res);
ASSERT_EQUAL(ret, 0);
ASSERT_NOT_NULL(e->getPropertyClassFixed<MindsProperty>());
ASSERT_FALSE(e->getPropertyClassFixed<MindsProperty>()->getMinds().empty());
}
int main()
{
PossessionAuthenticator possesionAuthenticator;
ExternalMindsManager externalMindsManager;
Monitors m;
Accountintegration t;
return t.run();
}
// stubs
#include "server/ArithmeticBuilder.h"
#include "server/EntityFactory.h"
#include "server/ArchetypeFactory.h"
#include "server/Juncture.h"
#include "server/Persistence.h"
#include "server/Player.h"
#include "server/Ruleset.h"
#include "server/TeleportProperty.h"
#include "rules/simulation/AreaProperty.h"
#include "rules/AtlasProperties.h"
#include "rules/BBoxProperty.h"
#include "rules/simulation/BiomassProperty.h"
#include "rules/simulation/BurnSpeedProperty.h"
#include "rules/simulation/DecaysProperty.h"
#include "rules/simulation/CalendarProperty.h"
#include "rules/simulation/EntityProperty.h"
#include "rules/simulation/ExternalProperty.h"
#include "rules/simulation/InternalProperties.h"
#include "rules/simulation/LineProperty.h"
#include "rules/simulation/MindProperty.h"
#include "rules/SolidProperty.h"
#include "rules/simulation/SpawnProperty.h"
#include "rules/simulation/StatusProperty.h"
#include "rules/simulation/StatisticsProperty.h"
#include "rules/simulation/TasksProperty.h"
#include "rules/simulation/TerrainModProperty.h"
#include "rules/simulation/TerrainProperty.h"
#include "rules/simulation/TransientProperty.h"
#include "rules/simulation/VisibilityProperty.h"
#include "rules/simulation/SuspendedProperty.h"
#include "rules/simulation/SpawnerProperty.h"
#include "rules/simulation/ImmortalProperty.h"
#include "rules/simulation/RespawningProperty.h"
#include "rules/simulation/DefaultLocationProperty.h"
#include "rules/simulation/DomainProperty.h"
#include "rules/simulation/LimboProperty.h"
#include "rules/simulation/Stackable.h"
#include "stubs/rules/stubScaleProperty.h"
#include "common/const.h"
#include "common/globals.h"
#include "common/log.h"
#include "common/Monitors.h"
#include "common/PropertyFactory.h"
#include "common/system.h"
#include "common/TypeNode.h"
#include "common/Variable.h"
#include "rules/python/PythonScriptFactory.h"
Reference in a new issue View git blame Copy permalink