Exemplo n.º 1
0
    def test_monitor_downloads_stop_ip(self):
        """
        Test whether we stop building IPs when a download doesn't exist anymore
        """
        mock_circuit = MockObject()
        mock_circuit.circuit_id = 0
        mock_circuit.ctype = 'IP_SEEDER'
        mock_circuit.state = 'READY'
        mock_circuit.info_hash = b'a'
        mock_circuit.goal_hops = 1
        mock_circuit.last_activity = 0

        self.nodes[0].overlay.remove_circuit = Mock()
        self.nodes[0].overlay.circuits[0] = mock_circuit
        self.nodes[0].overlay.join_swarm(b'a', 1)
        self.nodes[0].overlay.download_states[b'a'] = 3
        self.nodes[0].overlay.monitor_downloads([])
        self.nodes[0].overlay.remove_circuit.assert_called_with(
            0, 'leaving hidden swarm', destroy=5)
Exemplo n.º 2
0
def test_process_error_alert(test_download):
    """
    Testing whether error alerts are processed correctly
    """
    url = "http://google.com"
    mock_alert = MockObject()
    mock_alert.msg = None
    mock_alert.category = lambda: lt.alert.category_t.error_notification
    mock_alert.status_code = 123
    mock_alert.url = url
    test_download.process_alert(mock_alert, 'tracker_error_alert')
    assert test_download.tracker_status[url][1] == 'HTTP status code 123'

    mock_alert.status_code = 0
    test_download.process_alert(mock_alert, 'tracker_error_alert')
    assert test_download.tracker_status[url][1] == 'Timeout'
Exemplo n.º 3
0
    async def test_remote_select_subscribed_channels(self):
        """
        Test querying remote peers for subscribed channels and updating local votes accordingly
        """

        def mock_notify(overlay, args):
            overlay.notified_results = True
            self.assertTrue("results" in args[0])

        self.nodes[1].overlay.notifier = MockObject()
        self.nodes[1].overlay.notifier.notify = lambda sub, args: mock_notify(self.nodes[1].overlay, args)

        with db_session:
            # Create one channel with zero contents, to check that only non-empty channels are served
            self.nodes[0].overlay.mds.ChannelMetadata.create_channel("channel sub", "")
            for _ in range(0, 5):
                chan = self.nodes[0].overlay.mds.ChannelMetadata.create_channel("channel sub", "")
                chan.num_entries = 5
                chan.sign()
            for _ in range(0, 5):
                channel_uns = self.nodes[0].overlay.mds.ChannelMetadata.create_channel("channel unsub", "")
                channel_uns.subscribed = False

        peer = self.nodes[0].my_peer
        self.nodes[1].overlay.send_remote_select_subscribed_channels(peer)

        await self.deliver_messages(timeout=0.5)

        with db_session:
            received_channels = self.nodes[1].overlay.mds.ChannelMetadata.select(lambda g: g.title == "channel sub")
            self.assertEqual(received_channels.count(), 5)
            # Only subscribed channels should have been transported
            received_channels_all = self.nodes[1].overlay.mds.ChannelMetadata.select()
            self.assertEqual(received_channels_all.count(), 5)

            # Make sure the subscribed channels transport counted as voting
            self.assertEqual(
                self.nodes[1].overlay.mds.ChannelPeer.select().first().public_key, peer.public_key.key_to_bin()[10:]
            )
            for chan in self.nodes[1].overlay.mds.ChannelMetadata.select():
                self.assertTrue(chan.votes > 0.0)

        # Check that the notifier callback is called on new channel entries
        self.assertTrue(self.nodes[1].overlay.notified_results)
Exemplo n.º 4
0
    def test_monitor_downloads_stop_all(self):
        """
        Test whether circuits are removed when all downloads are stopped
        """
        def mocked_remove_circuit(circuit_id, *_, **__):
            mocked_remove_circuit.circuit_id = circuit_id

        mocked_remove_circuit.circuit_id = -1

        mock_circuit = MockObject()
        mock_circuit.circuit_id = 0
        mock_circuit.ctype = 'DATA'
        mock_circuit.state = 'READY'
        mock_circuit.info_hash = b'a'
        mock_circuit.goal_hops = 1
        mock_circuit.last_activity = 0

        self.nodes[0].overlay.remove_circuit = mocked_remove_circuit
        self.nodes[0].overlay.circuits[0] = mock_circuit
        self.nodes[0].overlay.join_swarm(b'a', 1)
        self.nodes[0].overlay.download_states[b'a'] = 3
        self.nodes[0].overlay.monitor_downloads([])
        self.assertEqual(mocked_remove_circuit.circuit_id, 0)
Exemplo n.º 5
0
    def test_monitor_downloads_intro(self):
        """
        Test whether rendezvous points are removed when a download is stopped
        """
        def mocked_remove_circuit(circuit_id, *_, **__):
            mocked_remove_circuit.circuit_id = circuit_id

        mocked_remove_circuit.circuit_id = -1

        mock_circuit = MockObject()
        mock_circuit.circuit_id = 0
        mock_circuit.ctype = 'RP_DOWNLOADER'
        mock_circuit.state = 'READY'
        mock_circuit.info_hash = b'a'
        mock_circuit.goal_hops = 1
        mock_circuit.last_activity = 0

        self.nodes[0].overlay.remove_circuit = mocked_remove_circuit
        self.nodes[0].overlay.circuits[0] = mock_circuit
        self.nodes[0].overlay.join_swarm(b'a', 1)
        self.nodes[0].overlay.swarms[b'a'].add_connection(mock_circuit, None)
        self.nodes[0].overlay.download_states[b'a'] = 3
        self.nodes[0].overlay.monitor_downloads([])
        self.assertEqual(mocked_remove_circuit.circuit_id, 0)
Exemplo n.º 6
0
 async def test_save_resume(self):
     """
     testing call resume data alert
     """
     tdef = self.create_tdef()
     alert = Mock(resume_data={b'info-hash': tdef.get_infohash()})
     dl = Download(self.session, tdef)
     dl.setup()
     dl.handle = MockObject()
     dl.handle.is_valid = lambda: True
     dl.handle.save_resume_data = lambda: dl.register_task(
         'post_alert',
         dl.process_alert,
         alert,
         'save_resume_data_alert',
         delay=0.1)
     await dl.save_resume_data()
     basename = hexlify(tdef.get_infohash()) + '.conf'
     filename = self.session.dlmgr.get_checkpoint_dir() / basename
     dcfg = DownloadConfig.load(filename)
     self.assertEqual(tdef.get_infohash(),
                      dcfg.get_engineresumedata().get(b'info-hash'))
     await dl.shutdown()
Exemplo n.º 7
0
    def test_monitor_downloads_stop_ip(self):
        """
        Test whether we stop building IPs when a download doesn't exist anymore
        """
        def mocked_remove_circuit(circuit_id, *_, **__):
            mocked_remove_circuit.circuit_id = circuit_id

        mocked_remove_circuit.circuit_id = -1

        mock_circuit = MockObject()
        mock_circuit.circuit_id = 0
        mock_circuit.ctype = 'IP_SEEDER'
        mock_circuit.state = 'READY'
        mock_circuit.info_hash = b'a'
        mock_circuit.goal_hops = 1

        self.nodes[0].overlay.remove_circuit = mocked_remove_circuit
        self.nodes[0].overlay.circuits[0] = mock_circuit
        self.nodes[0].overlay.join_swarm(b'a', 1)
        self.nodes[0].overlay.download_states[b'a'] = 3
        self.nodes[0].overlay.monitor_downloads([])
        self.assertEqual(mocked_remove_circuit.circuit_id, 0)
Exemplo n.º 8
0
    def test_update_torrent(self):
        """
        Test updating a torrent when a circuit breaks
        """
        self.nodes[0].overlay.find_circuits = lambda: True
        self.nodes[0].overlay.readd_bittorrent_peers = lambda: None
        mock_handle = MockObject()
        mock_handle.get_peer_info = lambda: {
            Mock(ip=('2.2.2.2', 2)),
            Mock(ip=('3.3.3.3', 3))
        }
        mock_handle.is_valid = lambda: True
        mock_download = MockObject()
        mock_download.handle = mock_handle
        peers = {('1.1.1.1', 1), ('2.2.2.2', 2)}
        self.nodes[0].overlay.update_torrent(peers, mock_download)
        self.assertIn(mock_download, self.nodes[0].overlay.bittorrent_peers)

        # Test adding peers
        self.nodes[0].overlay.bittorrent_peers[mock_download] = {('4.4.4.4', 4)
                                                                 }
        self.nodes[0].overlay.update_torrent(peers, mock_download)
Exemplo n.º 9
0
def test_get_valid_next_tracker_for_auto_check(torrent_checker):
    """
    Test if only valid tracker url are used for auto check
    """
    mock_tracker_state_invalid = MockObject()
    mock_tracker_state_invalid.url = "http://anno nce.torrentsmd.com:8080/announce"
    mock_tracker_state_valid = MockObject()
    mock_tracker_state_valid.url = "http://announce.torrentsmd.com:8080/announce"
    tracker_states = [mock_tracker_state_invalid, mock_tracker_state_valid]

    def get_next_tracker_for_auto_check():
        return tracker_states[0] if tracker_states else None

    def remove_tracker(_):
        tracker_states.remove(mock_tracker_state_invalid)

    torrent_checker.get_next_tracker_for_auto_check = get_next_tracker_for_auto_check
    torrent_checker.remove_tracker = remove_tracker

    next_tracker = torrent_checker.get_valid_next_tracker_for_auto_check()
    assert len(tracker_states) == 1
    assert next_tracker.url == "http://announce.torrentsmd.com:8080/announce"
Exemplo n.º 10
0
 def __init__(self, infohash, dirname):
     self.infohash = infohash
     self.dirname = dirname
     self.tdef = MockObject()
     self.tdef.get_name_utf8 = lambda: self.dirname
     self.tdef.get_infohash = lambda: infohash
Exemplo n.º 11
0
async def test_check_channels_updates(personal_channel, gigachannel_manager,
                                      metadata_store):
    torrents_added = 0
    # We add our personal channel in an inconsistent state to make sure the GigaChannel Manager will
    # not try to update it in the same way it should update other's channels
    with db_session:
        my_channel = metadata_store.ChannelMetadata.get_my_channels().first()
        my_channel.local_version -= 1

        # Subscribed, not updated
        metadata_store.ChannelMetadata(
            title="bla1",
            public_key=b'123',
            signature=b'345',
            skip_key_check=True,
            timestamp=123,
            local_version=123,
            subscribed=True,
            infohash=random_infohash(),
        )
        # Not subscribed, updated
        metadata_store.ChannelMetadata(
            title="bla2",
            public_key=b'124',
            signature=b'346',
            skip_key_check=True,
            timestamp=123,
            local_version=122,
            subscribed=False,
            infohash=random_infohash(),
        )
        # Subscribed, updated - only this one should be downloaded
        chan3 = metadata_store.ChannelMetadata(
            title="bla3",
            public_key=b'125',
            signature=b'347',
            skip_key_check=True,
            timestamp=123,
            local_version=122,
            subscribed=True,
            infohash=random_infohash(),
        )

        def mock_download_channel(chan1):
            nonlocal torrents_added
            torrents_added += 1
            assert chan1 == chan3

        gigachannel_manager.download_channel = mock_download_channel

        @db_session
        def fake_get_metainfo(infohash, **_):
            return {
                'info': {
                    'name':
                    metadata_store.ChannelMetadata.get(
                        infohash=infohash).dirname
                }
            }

        gigachannel_manager.download_manager.get_metainfo = fake_get_metainfo
        gigachannel_manager.download_manager.metainfo_requests = {}
        gigachannel_manager.download_manager.download_exists = lambda _: False

        # Manually fire the channel updates checking routine
        gigachannel_manager.check_channels_updates()
        # download_channel should only fire once - for the original subscribed channel
        assert torrents_added == 1

        # Check that downloaded, but unprocessed channel torrent is added to the processing queue
        gigachannel_manager.download_manager = MockObject()
        gigachannel_manager.download_manager.download_exists = lambda _: True

        mock_download = Mock()
        mock_download.get_state.get_status = DLSTATUS_SEEDING

        gigachannel_manager.download_manager.get_download = lambda _: mock_download

        def mock_process_channel_dir(c, _):
            # Only the subscribed, but not processed (with local_version < timestamp) channel should be processed
            assert c == chan3

        gigachannel_manager.process_channel_dir = mock_process_channel_dir

        # Manually fire the channel updates checking routine
        gigachannel_manager.check_channels_updates()
        await gigachannel_manager.process_queued_channels()

        # The queue should be empty afterwards
        assert not gigachannel_manager.channels_processing_queue
Exemplo n.º 12
0
 async def setUp(self):
     await super(BaseTestMyChannelEndpoint, self).setUp()
     self.session.gigachannel_manager = MockObject()
     self.session.gigachannel_manager.shutdown = lambda: succeed(None)
     self.session.gigachannel_manager.updated_my_channel = lambda _: succeed(None)
Exemplo n.º 13
0
    async def test_check_channels_updates(self):
        # We add our personal channel in an inconsistent state to make sure the GigaChannel Manager will
        # not try to update it in the same way it should update other's channels
        with db_session:
            chan = self.generate_personal_channel()
            chan.commit_channel_torrent()
            chan.local_version -= 1

            # Subscribed, not updated
            self.mock_session.mds.ChannelMetadata(
                title="bla1",
                public_key=database_blob(b'123'),
                signature=database_blob(b'345'),
                skip_key_check=True,
                timestamp=123,
                local_version=123,
                subscribed=True,
                infohash=random_infohash(),
            )
            # Not subscribed, updated
            self.mock_session.mds.ChannelMetadata(
                title="bla2",
                public_key=database_blob(b'124'),
                signature=database_blob(b'346'),
                skip_key_check=True,
                timestamp=123,
                local_version=122,
                subscribed=False,
                infohash=random_infohash(),
            )
            # Subscribed, updated - only this one should be downloaded
            chan3 = self.mock_session.mds.ChannelMetadata(
                title="bla3",
                public_key=database_blob(b'125'),
                signature=database_blob(b'347'),
                skip_key_check=True,
                timestamp=123,
                local_version=122,
                subscribed=True,
                infohash=random_infohash(),
            )
            self.torrents_added = 0

            def mock_download_channel(chan1):
                self.torrents_added += 1
                self.assertEqual(chan1, chan3)

            self.chanman.download_channel = mock_download_channel

            @db_session
            def fake_get_metainfo(infohash, **_):
                return {
                    'info': {
                        'name': self.mock_session.mds.ChannelMetadata.get(infohash=database_blob(infohash)).dirname
                    }
                }

            self.mock_session.dlmgr = MockObject()
            self.mock_session.dlmgr.get_metainfo = fake_get_metainfo
            self.mock_session.dlmgr.metainfo_requests = {}
            self.mock_session.dlmgr.download_exists = lambda _: False

            # Manually fire the channel updates checking routine
            self.chanman.check_channels_updates()
            # download_channel should only fire once - for the original subscribed channel
            self.assertEqual(1, self.torrents_added)

            # Check that downloaded, but unprocessed channel torrent is added to the processing queue
            self.mock_session.dlmgr = MockObject()
            self.mock_session.dlmgr.download_exists = lambda _: True

            class MockDownload(object):
                def get_state(self):
                    class MockState(object):
                        def get_status(self):
                            return DLSTATUS_SEEDING

                    return MockState()

            self.mock_session.dlmgr.get_download = lambda _: MockDownload()

            def mock_process_channel_dir(c, _):
                # Only the subscribed, but not processed (with local_version < timestamp) channel should be processed
                self.assertEqual(c, chan3)

            self.chanman.process_channel_dir = mock_process_channel_dir

            # Manually fire the channel updates checking routine
            self.chanman.check_channels_updates()
            await self.chanman.process_queued_channels()

            # The queue should be empty afterwards
            self.assertEqual(0, len(self.chanman.channels_processing_queue))
Exemplo n.º 14
0
    def test_getters_setters_2(self):
        """
        Testing various getters and setters in DownloadState
        """
        lt_status = MockObject()
        lt_status.state = 3
        lt_status.upload_rate = 123
        lt_status.download_rate = 43
        lt_status.total_upload = 100
        lt_status.total_download = 200
        lt_status.all_time_upload = 100
        lt_status.all_time_download = 200
        lt_status.list_peers = 10
        lt_status.list_seeds = 5
        lt_status.progress = 0.75
        lt_status.error = False
        lt_status.paused = False
        lt_status.state = 3
        lt_status.num_pieces = 0
        lt_status.pieces = []
        lt_status.finished_time = 10

        download_state = DownloadState(self.mock_download, lt_status, None)

        self.assertEqual(download_state.get_status(), DLSTATUS_DOWNLOADING)
        self.assertEqual(download_state.get_current_speed(UPLOAD), 123)
        self.assertEqual(download_state.get_current_speed(DOWNLOAD), 43)
        self.assertEqual(download_state.get_total_transferred(UPLOAD), 100)
        self.assertEqual(download_state.get_total_transferred(DOWNLOAD), 200)
        self.assertEqual(download_state.get_seeding_ratio(), 0.5)
        self.assertEqual(download_state.get_eta(), 0.25)
        self.assertEqual(download_state.get_num_seeds_peers(), (5, 5))
        self.assertEqual(download_state.get_pieces_complete(), [])
        self.assertEqual(download_state.get_pieces_total_complete(), (0, 0))
        self.assertEqual(download_state.get_seeding_time(), 10)

        lt_status.num_pieces = 6
        lt_status.pieces = [1, 1, 1, 0, 0, 0]
        self.assertEqual(download_state.get_pieces_complete(), [1, 1, 1, 0, 0, 0])
        self.assertEqual(download_state.get_pieces_total_complete(), (6, 3))

        self.mock_download.config = MockObject()
        self.mock_download.config.get_selected_files = lambda: ['test']
        self.assertEqual(download_state.get_selected_files(), ['test'])
        self.assertEqual(download_state.get_progress(), 0.75)
Exemplo n.º 15
0
    async def setUp(self):
        await TriblerCoreTest.setUp(self)
        self.download = Download(Mock(), None)
        mock_handle = MockObject()
        mock_status = MockObject()
        mock_status.pieces = [True, False, True, True, False]
        torrent_info = MockObject()
        file_info = MockObject()
        file_info.size = 1234
        torrent_info.file_at = lambda _: file_info
        map_file_result = MockObject()
        map_file_result.piece = 123
        torrent_info.map_file = lambda _dummy1, _dummy2, _dummy3: map_file_result
        torrent_info.num_pieces = lambda: 5

        mock_handle.is_valid = lambda: True
        mock_handle.status = lambda: mock_status
        mock_handle.get_torrent_info = lambda: torrent_info
        mock_handle.set_sequential_download = lambda _: None
        mock_handle.set_priority = lambda _: None
        mock_handle.prioritize_pieces = lambda _: None
        mock_handle.save_resume_data = lambda: None

        self.download.handle = mock_handle

        # Create a fake tdef
        self.download.tdef = MockObject()
        self.download.tdef.get_name = lambda: "ubuntu.iso"
        self.download.tdef.get_name_as_unicode = lambda: "ubuntu.iso"
        self.download.tdef.get_infohash = lambda: b'a' * 20
        self.download.tdef.is_multifile_torrent = lambda: False

        self.download.config = DownloadConfig()
Exemplo n.º 16
0
    async def test_remove_cruft_channels(self):
        with db_session:
            # Our personal chan is created, then updated, so there are 2 files on disk and there are 2 torrents:
            # the old one and the new one
            my_chan = self.generate_personal_channel()
            my_chan.commit_channel_torrent()
            my_chan_old_infohash = my_chan.infohash
            _ = self.mock_session.mds.TorrentMetadata.from_dict(
                dict(self.torrent_template, origin_id=my_chan.id_, status=NEW)
            )
            my_chan.commit_channel_torrent()

            # Now we add an external channel we are subscribed to.
            chan2 = self.mock_session.mds.ChannelMetadata(
                title="bla1",
                infohash=database_blob(b'123'),
                public_key=database_blob(b'123'),
                signature=database_blob(b'345'),
                skip_key_check=True,
                timestamp=123,
                local_version=123,
                subscribed=True,
            )

            # Another external channel, but there is a catch: we recently unsubscribed from it
            chan3 = self.mock_session.mds.ChannelMetadata(
                title="bla2",
                infohash=database_blob(b'124'),
                public_key=database_blob(b'124'),
                signature=database_blob(b'346'),
                skip_key_check=True,
                timestamp=123,
                local_version=123,
                subscribed=False,
            )

        class MockDownload(MockObject):
            def __init__(self, infohash, dirname):
                self.infohash = infohash
                self.dirname = dirname
                self.tdef = MockObject()
                self.tdef.get_name_utf8 = lambda: self.dirname
                self.tdef.get_infohash = lambda: infohash

            def get_def(self):
                a = MockObject()
                a.infohash = self.infohash
                a.get_name_utf8 = lambda: self.dirname
                a.get_infohash = lambda: self.infohash
                return a

        # Double conversion is required to make sure that buffers signatures are not the same
        mock_dl_list = [
            # Downloads for the personal channel
            MockDownload(database_blob(bytes(my_chan_old_infohash)), my_chan.dirname),
            MockDownload(database_blob(bytes(my_chan.infohash)), my_chan.dirname),
            # Downloads for the updated external channel: "old ones" and "recent"
            MockDownload(database_blob(b'12331244'), chan2.dirname),
            MockDownload(database_blob(bytes(chan2.infohash)), chan2.dirname),
            # Downloads for the unsubscribed external channel
            MockDownload(database_blob(b'1231551'), chan3.dirname),
            MockDownload(database_blob(bytes(chan3.infohash)), chan3.dirname),
            # Orphaned download
            MockDownload(database_blob(b'333'), u"blabla"),
        ]

        def mock_get_channel_downloads(**_):
            return mock_dl_list

        self.remove_list = []

        def mock_remove(infohash, remove_content=False):
            d = Future()
            d.set_result(None)
            self.remove_list.append((infohash, remove_content))
            return d

        self.mock_session.dlmgr = MockObject()
        self.mock_session.dlmgr.get_channel_downloads = mock_get_channel_downloads
        self.chanman.session.dlmgr.remove_download = mock_remove

        self.chanman.remove_cruft_channels()
        await self.chanman.process_queued_channels()
        # We want to remove torrents for (a) deleted channels and (b) unsubscribed channels
        self.assertCountEqual(
            self.remove_list,
            [
                (mock_dl_list[0], False),
                (mock_dl_list[2], False),
                (mock_dl_list[4], True),
                (mock_dl_list[5], True),
                (mock_dl_list[6], True),
            ],
        )
Exemplo n.º 17
0
 async def setUp(self):
     self.timeout = 15
     await super(TestTorrentCheckerSession, self).setUp()
     self.mock_transport = MockObject()
     self.mock_transport.write = lambda *_: None
     self.socket_mgr = FakeUdpSocketManager()
Exemplo n.º 18
0
    def test_monitor_downloads_recreate_ip(self):
        """
        Test whether an old introduction point is recreated
        """
        mock_state = MockObject()
        mock_download = MockObject()
        mock_tdef = MockObject()
        mock_tdef.get_infohash = lambda: b'a'
        mock_download.get_def = lambda: mock_tdef
        mock_download.add_peer = lambda _: succeed(None)
        mock_download.get_state = lambda: mock_state
        mock_download.config = MockObject()
        mock_download.config.get_hops = lambda: 1
        mock_download.apply_ip_filter = lambda _: None
        mock_state.get_status = lambda: 4
        mock_state.get_download = lambda: mock_download

        def mock_create_ip(*_, **__):
            mock_create_ip.called = True

        mock_create_ip.called = False
        self.nodes[0].overlay.create_introduction_point = mock_create_ip

        self.nodes[0].overlay.download_states[b'a'] = 3
        self.nodes[0].overlay.monitor_downloads([mock_state])
        self.assertTrue(mock_create_ip.called)
Exemplo n.º 19
0
def create_fake_download_and_state():
    """
    Create a fake download and state which can be passed to the global download callback.
    """
    tdef = TorrentDef()
    tdef.get_infohash = lambda: b'aaaa'
    fake_peer = {'extended_version': 'Tribler', 'id': 'a' * 20, 'dtotal': 10 * 1024 * 1024}
    fake_download = MockObject()
    fake_download.get_def = lambda: tdef
    fake_download.get_def().get_name_as_unicode = lambda: "test.iso"
    fake_download.get_peerlist = lambda: [fake_peer]
    fake_download.hidden = False
    fake_download.checkpoint = lambda: succeed(None)
    fake_download.stop = lambda: succeed(None)
    fake_download.shutdown = lambda: succeed(None)
    dl_state = MockObject()
    dl_state.get_infohash = lambda: b'aaaa'
    dl_state.get_status = lambda: DLSTATUS_SEEDING
    dl_state.get_download = lambda: fake_download
    fake_config = MockObject()
    fake_config.get_hops = lambda: 0
    fake_config.get_safe_seeding = lambda: True
    fake_download.config = fake_config

    return fake_download, dl_state
Exemplo n.º 20
0
    def test_on_tunnel_in(self):
        """
        Test whether no data is sent to the SOCKS5 server when we receive data from the tunnels
        """
        mock_circuit = MockObject()
        mock_circuit.goal_hops = 300
        mock_circuit.circuit_id = b'a'
        mock_circuit.ctype = CIRCUIT_TYPE_DATA
        origin = ("0.0.0.0", 1024)
        self.assertFalse(
            self.dispatcher.on_incoming_from_tunnel(self.mock_tunnel_community,
                                                    mock_circuit, origin,
                                                    b'a'))

        mock_circuit.goal_hops = 1
        mock_sock_server = MockObject()
        mock_session = MockObject()
        mock_session._udp_socket = None
        mock_sock_server.sessions = [mock_session]
        self.dispatcher.set_socks_servers([mock_sock_server])
        self.dispatcher.destinations[1] = {b'a': mock_circuit}
        self.assertFalse(
            self.dispatcher.on_incoming_from_tunnel(self.mock_tunnel_community,
                                                    mock_circuit, origin,
                                                    b'a'))

        mock_session._udp_socket = MockObject()
        mock_session._udp_socket.sendDatagram = lambda _: True
        self.assertTrue(
            self.dispatcher.on_incoming_from_tunnel(self.mock_tunnel_community,
                                                    mock_circuit, origin,
                                                    b'a'))
Exemplo n.º 21
0
 def __init__(self, _):
     super(ChannelsEndpoint, self).__init__(MockObject())
Exemplo n.º 22
0
    async def test_multifile_torrent(self):
        # Achtung! This test is completely and utterly broken, as is the whole libtorrent wrapper!
        # Don't try to understand it, it is a legacy thing!

        tdef = TorrentDef()

        tdef.add_content(TESTS_DATA_DIR / "video.avi")
        tdef.set_tracker("http://tribler.org/announce")
        tdef.save()

        fake_handler = MockObject()
        fake_handler.is_valid = lambda: True
        fake_handler.status = lambda: fake_status
        fake_handler.set_share_mode = lambda _: None
        fake_handler.set_priority = lambda _: None
        fake_handler.set_sequential_download = lambda _: None
        fake_handler.resume = lambda: None
        fake_handler.set_max_connections = lambda _: None
        fake_handler.apply_ip_filter = lambda _: None
        fake_handler.save_resume_data = lambda: None
        fake_status = MockObject()
        fake_status.share_mode = False
        dl = Download(self.session, tdef)
        dl.set_selected_files = lambda: None
        dl.future_added = succeed(fake_handler)
        # Create a dummy download config
        dl.config = DownloadConfig()
        dl.config.set_engineresumedata({
            b"save_path":
            path_util.abspath(self.state_dir),
            b"info-hash":
            b'\x00' * 20
        })
        dl.setup()

        dl.config.set_engineresumedata({
            b"save_path":
            path_util.abspath(self.state_dir),
            b"info-hash":
            b'\x00' * 20
        })
        dl.setup()

        dl.config.set_engineresumedata({
            b"save_path": "some_local_dir",
            b"info-hash": b'\x00' * 20
        })
        dl.setup()
        await dl.shutdown()
Exemplo n.º 23
0
 def get_def(self):
     a = MockObject()
     a.infohash = self.infohash
     a.get_name_utf8 = lambda: self.dirname
     a.get_infohash = lambda: self.infohash
     return a
Exemplo n.º 24
0
 def mock_download_from_tdef(*_, **__):
     global initiated_download
     initiated_download = True
     mock_dl = MockObject()
     mock_dl.future_finished = succeed(None)
     return mock_dl
Exemplo n.º 25
0
 def create_mock_status(self):
     status = MockObject()
     status.state = 3
     status.upload_rate = 123
     status.download_rate = 43
     status.upload_payload_rate = 123
     status.download_payload_rate = 43
     status.total_upload = 100
     status.total_download = 200
     status.all_time_upload = 100
     status.all_time_download = 200
     status.list_peers = 10
     status.list_seeds = 5
     status.progress = 0.75
     status.error = False
     status.paused = False
     status.state = 3
     status.num_pieces = 0
     status.pieces = []
     return status