diff --git a/tests/libtransport/basictest.cpp b/tests/libtransport/basictest.cpp new file mode 100644 index 0000000000000000000000000000000000000000..952e6aa88797ede9ff3f8b4a2251e992f6518c06 --- /dev/null +++ b/tests/libtransport/basictest.cpp @@ -0,0 +1,268 @@ +#include "basictest.h" +#include "XMPPFrontend.h" +#include "XMPPUserRegistration.h" +#include "XMPPUserManager.h" +#include +#include +#include +#include +#include +#include +#include +#include "Swiften/Server/ServerStanzaChannel.h" +#include "Swiften/Server/ServerFromClientSession.h" +#include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h" + +#include "Swiften/Serializer/GenericPayloadSerializer.h" + +#include "storageparser.h" +#include "Swiften/Parser/PayloadParsers/AttentionParser.h" +#include "Swiften/Serializer/PayloadSerializers/AttentionSerializer.h" +#include "Swiften/Parser/PayloadParsers/XHTMLIMParser.h" +#include "Swiften/Serializer/PayloadSerializers/XHTMLIMSerializer.h" +#include "Swiften/Parser/PayloadParsers/StatsParser.h" +#include "Swiften/Serializer/PayloadSerializers/StatsSerializer.h" +#include "Swiften/Parser/PayloadParsers/GatewayPayloadParser.h" +#include "Swiften/Serializer/PayloadSerializers/GatewayPayloadSerializer.h" +#include "Swiften/Serializer/PayloadSerializers/SpectrumErrorSerializer.h" +#include "Swiften/Parser/PayloadParsers/MUCPayloadParser.h" +#include "BlockParser.h" +#include "BlockSerializer.h" +#include "Swiften/Parser/PayloadParsers/InvisibleParser.h" +#include "Swiften/Serializer/PayloadSerializers/InvisibleSerializer.h" + +using namespace Transport; + +void BasicTest::setMeUp (void) { + streamEnded = false; + std::istringstream ifs("service.server_mode = 1\nservice.jid=localhost\nservice.more_resources=1\n"); + cfg = new Config(); + cfg->load(ifs); + + factory = new TestingFactory(); + + storage = new TestingStorageBackend(); + + loop = new Swift::DummyEventLoop(); + factories = new Swift::DummyNetworkFactories(loop); + + userRegistry = new UserRegistry(cfg, factories); + + frontend = new Transport::XMPPFrontend(); + + component = new Component(frontend, loop, factories, cfg, factory, userRegistry); + component->start(); + + userManager = frontend->createUserManager(component, userRegistry, storage); + + itemsResponder = frontend->getDiscoItemsResponder(); + + payloadSerializers = new Swift::FullPayloadSerializerCollection(); + payloadParserFactories = new Swift::FullPayloadParserFactoryCollection(); + + payloadParserFactories->addFactory(new Swift::GenericPayloadParserFactory("private", "jabber:iq:private")); + payloadParserFactories->addFactory(new Swift::GenericPayloadParserFactory("attention", "urn:xmpp:attention:0")); + payloadParserFactories->addFactory(new Swift::GenericPayloadParserFactory("html", "http://jabber.org/protocol/xhtml-im")); + payloadParserFactories->addFactory(new Swift::GenericPayloadParserFactory("block", "urn:xmpp:block:0")); + payloadParserFactories->addFactory(new Swift::GenericPayloadParserFactory("invisible", "urn:xmpp:invisible:0")); + payloadParserFactories->addFactory(new Swift::GenericPayloadParserFactory("query", "http://jabber.org/protocol/stats")); + payloadParserFactories->addFactory(new Swift::GenericPayloadParserFactory("query", "jabber:iq:gateway")); + payloadParserFactories->addFactory(new Swift::GenericPayloadParserFactory("x", "http://jabber.org/protocol/muc")); + + payloadSerializers->addSerializer(new Swift::AttentionSerializer()); + payloadSerializers->addSerializer(new Swift::XHTMLIMSerializer()); + payloadSerializers->addSerializer(new Transport::BlockSerializer()); + payloadSerializers->addSerializer(new Swift::InvisibleSerializer()); + payloadSerializers->addSerializer(new Swift::StatsSerializer()); + payloadSerializers->addSerializer(new Swift::SpectrumErrorSerializer()); + payloadSerializers->addSerializer(new Swift::GatewayPayloadSerializer()); + + parser = new Swift::XMPPParser(this, payloadParserFactories, factories->getXMLParserFactory()); + parser2 = new Swift::XMPPParser(this, payloadParserFactories, factories->getXMLParserFactory()); + + serverFromClientSession = boost::shared_ptr(new Swift::ServerFromClientSession("id", factories->getConnectionFactory()->createConnection(), + payloadParserFactories, payloadSerializers, userRegistry, factories->getXMLParserFactory(), Swift::JID("user@localhost/resource"))); + serverFromClientSession->startSession(); + + serverFromClientSession->onDataWritten.connect(boost::bind(&BasicTest::handleDataReceived, this, _1)); + + dynamic_cast(static_cast(component->getFrontend())->getStanzaChannel())->addSession(serverFromClientSession); + parser->parse(""); + parser2->parse(""); + received.clear(); + received2.clear(); + receivedData.clear(); + loop->processEvents(); +} + +void BasicTest::tearMeDown (void) { + dynamic_cast(static_cast(component->getFrontend())->getStanzaChannel())->removeSession(serverFromClientSession); + if (serverFromClientSession2) { + dynamic_cast(static_cast(component->getFrontend())->getStanzaChannel())->removeSession(serverFromClientSession2); + serverFromClientSession2.reset(); + } + delete component; + delete frontend; + delete userRegistry; + delete factories; + delete factory; + delete loop; + delete cfg; + delete parser; + delete parser2; + delete storage; +// delete userRegistration; + received.clear(); + received2.clear(); + receivedData.clear(); + receivedData2.clear(); +} + +void BasicTest::handleDataReceived(const Swift::SafeByteArray &data) { +// std::cout << safeByteArrayToString(data) << "\n"; + stream1_active = true; + receivedData += safeByteArrayToString(data) + "\n"; + parser->parse(safeByteArrayToString(data)); +} + +void BasicTest::handleDataReceived2(const Swift::SafeByteArray &data) { +// std::cout << safeByteArrayToString(data) << "\n"; + stream1_active = false; + receivedData2 += safeByteArrayToString(data) + "\n"; + parser2->parse(safeByteArrayToString(data)); +} + +void BasicTest::handleStreamStart(const Swift::ProtocolHeader&) { + +} + +void BasicTest::dumpReceived() { + std::cout << "\nStream1:\n"; + std::cout << receivedData << "\n"; + std::cout << "Stream2:\n"; + std::cout << receivedData2 << "\n"; +} +#if HAVE_SWIFTEN_3 +void BasicTest::handleElement(boost::shared_ptr element) { +#else +void BasicTest::handleElement(boost::shared_ptr element) { +#endif + if (stream1_active) { + received.push_back(element); + } + else { + received2.push_back(element); + } +} + +void BasicTest::handleStreamEnd() { + streamEnded = true; +} + +void BasicTest::injectPresence(boost::shared_ptr &response) { + dynamic_cast(static_cast(component->getFrontend())->getStanzaChannel())->onPresenceReceived(response); +} + +void BasicTest::injectIQ(boost::shared_ptr iq) { + dynamic_cast(static_cast(component->getFrontend())->getStanzaChannel())->onIQReceived(iq); +} + +void BasicTest::injectMessage(boost::shared_ptr msg) { + dynamic_cast(static_cast(component->getFrontend())->getStanzaChannel())->onMessageReceived(msg); +} + +Swift::Stanza *BasicTest::getStanza(boost::shared_ptr element) { + Swift::Stanza *stanza = dynamic_cast(element.get()); + CPPUNIT_ASSERT(stanza); + return stanza; +} + +void BasicTest::connectUser() { + CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount()); + userRegistry->isValidUserPassword(Swift::JID("user@localhost/resource"), serverFromClientSession.get(), Swift::createSafeByteArray("password")); + userRegistry->onPasswordValid(Swift::JID("user@localhost/resource")); + loop->processEvents(); + CPPUNIT_ASSERT_EQUAL(1, userManager->getUserCount()); + + User *user = userManager->getUser("user@localhost"); + CPPUNIT_ASSERT(user); + + UserInfo userInfo = user->getUserInfo(); + CPPUNIT_ASSERT_EQUAL(std::string("password"), userInfo.password); + CPPUNIT_ASSERT(user->isReadyToConnect() == true); + CPPUNIT_ASSERT(user->isConnected() == false); + + user->setConnected(true); + CPPUNIT_ASSERT(user->isConnected() == true); + + CPPUNIT_ASSERT_EQUAL(2, (int) received.size()); + CPPUNIT_ASSERT(getStanza(received[0])->getPayload()); + + received.clear(); + receivedData.clear(); +} + +void BasicTest::connectSecondResource() { + serverFromClientSession2 = boost::shared_ptr(new Swift::ServerFromClientSession("id", factories->getConnectionFactory()->createConnection(), + payloadParserFactories, payloadSerializers, userRegistry, factories->getXMLParserFactory(), Swift::JID("user@localhost/resource2"))); + serverFromClientSession2->startSession(); + + serverFromClientSession2->onDataWritten.connect(boost::bind(&BasicTest::handleDataReceived2, this, _1)); + + dynamic_cast(static_cast(component->getFrontend())->getStanzaChannel())->addSession(serverFromClientSession2); + + userRegistry->isValidUserPassword(Swift::JID("user@localhost/resource2"), serverFromClientSession2.get(), Swift::createSafeByteArray("password")); + userRegistry->onPasswordValid(Swift::JID("user@localhost/resource2")); + + loop->processEvents(); + + Swift::Presence::ref response = Swift::Presence::create(); + response->setTo("localhost"); + response->setFrom("user@localhost/resource2"); + injectPresence(response); + loop->processEvents(); + + CPPUNIT_ASSERT_EQUAL(1, userManager->getUserCount()); + + User *user = userManager->getUser("user@localhost"); + CPPUNIT_ASSERT(user); + CPPUNIT_ASSERT_EQUAL(2, user->getResourceCount()); + + CPPUNIT_ASSERT(getStanza(received2[1])->getPayload()); +} + +void BasicTest::disconnectUser() { + User *user = userManager->getUser("user@localhost"); + if (user) { + user->addUserSetting("stay_connected", "0"); + } + else { + return; + } + received.clear(); + userManager->disconnectUser("user@localhost"); + dynamic_cast(factories->getTimerFactory())->setTime(100); + loop->processEvents(); + + CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount()); + CPPUNIT_ASSERT_EQUAL(1, (int) received.size()); + CPPUNIT_ASSERT(dynamic_cast(getStanza(received[0]))); +} + +void BasicTest::add2Buddies() { + User *user = userManager->getUser("user@localhost"); + CPPUNIT_ASSERT(user); + + std::vector grp; + grp.push_back("group1"); + LocalBuddy *buddy = new LocalBuddy(user->getRosterManager(), -1, "buddy1", "Buddy 1", grp, BUDDY_JID_ESCAPING); + user->getRosterManager()->setBuddy(buddy); + buddy->setStatus(Swift::StatusShow(Swift::StatusShow::Away), "status1"); + + std::vector grp2; + grp2.push_back("group2"); + buddy = new LocalBuddy(user->getRosterManager(), -1, "buddy2", "Buddy 2", grp2, BUDDY_JID_ESCAPING); + user->getRosterManager()->setBuddy(buddy); + buddy->setStatus(Swift::StatusShow(Swift::StatusShow::Away), "status2"); +} +