+ CPPUNIT_TEST_SUITE(OutgoingJingleFileTransferTest);

+ CPPUNIT_TEST(test_SendSessionInitiateOnStart);

+ CPPUNIT_TEST(test_FallbackToIBBAfterFailingS5B);

+ CPPUNIT_TEST(test_ReceiveSessionTerminateAfterSessionInitiate);

+ CPPUNIT_TEST(test_DeclineEmitsFinishedStateCanceled);

+ CPPUNIT_TEST_SUITE_END();

+

+ class FTStatusHelper {

+ public:

+ FTStatusHelper() : finishedCalled(false), error(FileTransferError::UnknownError) {

+ }

+

+ void handleFileTransferFinished(boost::optional<FileTransferError> error) {

+ finishedCalled = true;

+ if (error.is_initialized()) this->error = error.get().getType();

+ }

+

+ void handleFileTransferStatusChanged(FileTransfer::State fileTransferSTate) {

+ state = fileTransferSTate;

+ }

+

+ public:

+ bool finishedCalled;

+ FileTransferError::Type error;

+ boost::optional<FileTransfer::State> state;

+ };

+ boost::shared_ptr<OutgoingJingleFileTransfer> createTestling(const FileTransferOptions& options = FileTransferOptions().withAssistedAllowed(false).withDirectAllowed(false).withProxiedAllowed(false)) {

+ JID to("test@foo.com/bla");

+ JingleFileTransferFileInfo fileInfo;

+ fileInfo.setDescription("some file");

+ fileInfo.setName("test.bin");

+ fileInfo.addHash(HashElement("sha-1", ByteArray()));

+ fileInfo.setSize(1024 * 1024);

+ return boost::shared_ptr<OutgoingJingleFileTransfer>(new OutgoingJingleFileTransfer(

+ to,

+ boost::shared_ptr<JingleSession>(fakeJingleSession),

+ stream,

+ ftTransportFactory,

+ timerFactory,

+ idGen,

+ fileInfo,

+ options,

+ crypto.get()));

+ }

+

+ IQ::ref createIBBRequest(IBB::ref ibb, const JID& from, const std::string& id) {

+ IQ::ref request = IQ::createRequest(IQ::Set, JID("foo@bar.com/baz"), id, ibb);

+ request->setFrom(from);

+ return request;

+ }

+

+ void setUp() {

+ crypto = boost::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

+ fakeJingleSession = new FakeJingleSession("foo@bar.com/baz", "mysession");

+ jingleContentPayload = boost::make_shared<JingleContentPayload>();

+ stanzaChannel = new DummyStanzaChannel();

+ iqRouter = new IQRouter(stanzaChannel);

+ eventLoop = new DummyEventLoop();

+ timerFactory = new DummyTimerFactory();

+ connectionFactory = new DummyConnectionFactory(eventLoop);

+ serverConnectionFactory = new DummyConnectionServerFactory(eventLoop);

+ s5bRegistry = new SOCKS5BytestreamRegistry();

+ networkEnvironment = new PlatformNetworkEnvironment();

+ natTraverser = new PlatformNATTraversalWorker(eventLoop);

+ bytestreamServerManager = new SOCKS5BytestreamServerManager(s5bRegistry, serverConnectionFactory, networkEnvironment, natTraverser);

+

+ data.clear();

+ for (int n=0; n < 1024 * 1024; ++n) {

+ data.push_back(34);

+ }

+

+ stream = boost::make_shared<ByteArrayReadBytestream>(data);

+

+ idGen = new IDGenerator();

+ s5bProxy = new SOCKS5BytestreamProxiesManager(connectionFactory, timerFactory, resolver, iqRouter, "bar.com");

+ ftTransportFactory = new DummyFileTransferTransporterFactory(s5bRegistry, bytestreamServerManager, s5bProxy, idGen, connectionFactory, timerFactory, crypto.get(), iqRouter);

+ }

+

+ void tearDown() {

+ delete ftTransportFactory;

+ delete s5bProxy;

+ delete idGen;

+ delete bytestreamServerManager;

+ delete natTraverser;

+ delete networkEnvironment;

+ delete s5bRegistry;

+ delete serverConnectionFactory;

+ delete connectionFactory;

+ delete timerFactory;

+ delete eventLoop;

+ delete iqRouter;

+ delete stanzaChannel;

+ }

+

+

+ void test_SendSessionInitiateOnStart() {

+ boost::shared_ptr<OutgoingJingleFileTransfer> transfer = createTestling();

+ transfer->start();

+

+ FakeJingleSession::InitiateCall call = getCall<FakeJingleSession::InitiateCall>(0);

+ JingleFileTransferDescription::ref description = boost::dynamic_pointer_cast<JingleFileTransferDescription>(call.description);

+ CPPUNIT_ASSERT(description);

+ CPPUNIT_ASSERT(static_cast<size_t>(1048576) == description->getFileInfo().getSize());

+

+ JingleIBBTransportPayload::ref transport = boost::dynamic_pointer_cast<JingleIBBTransportPayload>(call.payload);

+ CPPUNIT_ASSERT(transport);

+ }

+

+ void test_FallbackToIBBAfterFailingS5B() {

+ boost::shared_ptr<OutgoingJingleFileTransfer> transfer = createTestling(FileTransferOptions().withAssistedAllowed(true).withDirectAllowed(true).withProxiedAllowed(true));

+ transfer->start();

+

+ FakeJingleSession::InitiateCall call = getCall<FakeJingleSession::InitiateCall>(0);

+

+ CPPUNIT_ASSERT(boost::dynamic_pointer_cast<JingleS5BTransportPayload>(call.payload));

+ fakeJingleSession->handleSessionAcceptReceived(call.id, call.description, call.payload);

+

+ // send candidate failure

+ JingleS5BTransportPayload::ref candidateFailurePayload = boost::make_shared<JingleS5BTransportPayload>();

+ candidateFailurePayload->setCandidateError(true);

+ candidateFailurePayload->setSessionID(call.payload->getSessionID());

+ fakeJingleSession->handleTransportInfoReceived(call.id, candidateFailurePayload);

+

+ // no S5B candidates -> fallback to IBB

+ // call at position 1 is the candidate our candidate error

+ FakeJingleSession::ReplaceTransportCall replaceCall = getCall<FakeJingleSession::ReplaceTransportCall>(2);

+

+ // accept transport replace

+ fakeJingleSession->handleTransportAcceptReceived(replaceCall.id, replaceCall.payload);

+

+ IQ::ref iqOpenStanza = stanzaChannel->getStanzaAtIndex<IQ>(0);

+ CPPUNIT_ASSERT(iqOpenStanza);

+ IBB::ref ibbOpen = iqOpenStanza->getPayload<IBB>();

+ CPPUNIT_ASSERT(ibbOpen);

+ CPPUNIT_ASSERT_EQUAL(IBB::Open, ibbOpen->getAction());

+ }

+

+ void test_ReceiveSessionTerminateAfterSessionInitiate() {

+ boost::shared_ptr<OutgoingJingleFileTransfer> transfer = createTestling();

+ transfer->start();

+

+ getCall<FakeJingleSession::InitiateCall>(0);

+

+ FTStatusHelper helper;

+ helper.finishedCalled = false;

+ transfer->onFinished.connect(bind(&FTStatusHelper::handleFileTransferFinished, &helper, _1));

+ fakeJingleSession->handleSessionTerminateReceived(JinglePayload::Reason(JinglePayload::Reason::Busy));

+ CPPUNIT_ASSERT_EQUAL(true, helper.finishedCalled);

+ CPPUNIT_ASSERT(FileTransferError::PeerError == helper.error);

+ }

+

+ void test_DeclineEmitsFinishedStateCanceled() {

+ boost::shared_ptr<OutgoingJingleFileTransfer> transfer = createTestling();

+ transfer->start();

+

+ getCall<FakeJingleSession::InitiateCall>(0);

+

+ FTStatusHelper helper;

+ helper.finishedCalled = false;

+ transfer->onFinished.connect(bind(&FTStatusHelper::handleFileTransferFinished, &helper, _1));

+ transfer->onStateChanged.connect(bind(&FTStatusHelper::handleFileTransferStatusChanged, &helper, _1));

+ fakeJingleSession->handleSessionTerminateReceived(JinglePayload::Reason(JinglePayload::Reason::Decline));

+ CPPUNIT_ASSERT_EQUAL(true, helper.finishedCalled);

+ CPPUNIT_ASSERT(FileTransferError::UnknownError == helper.error);

+ CPPUNIT_ASSERT_EQUAL(true, helper.state.is_initialized());

+ CPPUNIT_ASSERT(FileTransfer::State::Canceled == helper.state.get().type);

+ }

+ void addFileTransferDescription() {

+ boost::shared_ptr<JingleFileTransferDescription> desc = boost::make_shared<JingleFileTransferDescription>();

+ desc->setFileInfo(JingleFileTransferFileInfo());

+ jingleContentPayload->addDescription(desc);

+ }

+

+ boost::shared_ptr<JingleS5BTransportPayload> addJingleS5BPayload() {

+ JingleS5BTransportPayload::ref payLoad = boost::make_shared<JingleS5BTransportPayload>();

+ payLoad->setSessionID("mysession");

+ jingleContentPayload->addTransport(payLoad);

+ return payLoad;

+ }

+

+ boost::shared_ptr<JingleIBBTransportPayload> addJingleIBBPayload() {

+ JingleIBBTransportPayload::ref payLoad = boost::make_shared<JingleIBBTransportPayload>();

+ payLoad->setSessionID("mysession");

+ jingleContentPayload->addTransport(payLoad);

+ return payLoad;

+ }

+

+ JingleContentID getContentID() const {

+ return JingleContentID(jingleContentPayload->getName(), jingleContentPayload->getCreator());

+ }

+

+ template <typename T> T getCall(int i) const {

+ size_t index = static_cast<size_t>(i);

+ CPPUNIT_ASSERT(index < fakeJingleSession->calledCommands.size());

+ T* cmd = boost::get<T>(&fakeJingleSession->calledCommands[index]);

+ CPPUNIT_ASSERT(cmd);

+ return *cmd;

+ }

+ std::vector<unsigned char> data;

+ boost::shared_ptr<ByteArrayReadBytestream> stream;

+ FakeJingleSession* fakeJingleSession;

+ boost::shared_ptr<JingleContentPayload> jingleContentPayload;

+ FileTransferTransporterFactory* ftTransportFactory;

+ SOCKS5BytestreamServerManager* bytestreamServerManager;

+ DummyStanzaChannel* stanzaChannel;

+ IQRouter* iqRouter;

+ IDGenerator* idGen;

+ EventLoop *eventLoop;

+ SOCKS5BytestreamRegistry* s5bRegistry;

+ SOCKS5BytestreamProxiesManager* s5bProxy;

+ DummyTimerFactory* timerFactory;

+ DummyConnectionFactory* connectionFactory;

+ DummyConnectionServerFactory* serverConnectionFactory;

+ boost::shared_ptr<CryptoProvider> crypto;

+ NetworkEnvironment* networkEnvironment;

+ NATTraverser* natTraverser;

+ DomainNameResolver* resolver;