Example #1
0
def get_test_daemon(data_rate=None, generous=True, with_fee=False):
    if data_rate is None:
        data_rate = conf.ADJUSTABLE_SETTINGS['data_rate'][1]

    rates = {
        'BTCLBC': {'spot': 3.0, 'ts': util.DEFAULT_ISO_TIME + 1},
        'USDBTC': {'spot': 2.0, 'ts': util.DEFAULT_ISO_TIME + 2}
    }
    component_manager = ComponentManager(
        skip_components=[DATABASE_COMPONENT, DHT_COMPONENT, WALLET_COMPONENT, UPNP_COMPONENT,
                         PEER_PROTOCOL_SERVER_COMPONENT, REFLECTOR_COMPONENT, HASH_ANNOUNCER_COMPONENT,
                         STREAM_IDENTIFIER_COMPONENT, EXCHANGE_RATE_MANAGER_COMPONENT, BLOB_COMPONENT,
                         HEADERS_COMPONENT, RATE_LIMITER_COMPONENT],
        file_manager=FakeFileManager
    )
    daemon = LBRYDaemon(component_manager=component_manager)
    daemon.payment_rate_manager = OnlyFreePaymentsManager()
    daemon.wallet_manager = mock.Mock(spec=LbryWalletManager)
    daemon.wallet_manager.wallet = mock.Mock(spec=Wallet)
    daemon.wallet_manager.wallet.use_encryption = False
    daemon.wallet_manager.network = FakeNetwork()
    daemon.storage = mock.Mock(spec=SQLiteStorage)
    market_feeds = [BTCLBCFeed(), USDBTCFeed()]
    daemon.exchange_rate_manager = DummyExchangeRateManager(market_feeds, rates)
    daemon.file_manager = component_manager.get_component(FILE_MANAGER_COMPONENT)

    metadata = {
        "author": "fake author",
        "language": "en",
        "content_type": "fake/format",
        "description": "fake description",
        "license": "fake license",
        "license_url": "fake license url",
        "nsfw": False,
        "sources": {
            "lbry_sd_hash": 'd2b8b6e907dde95245fe6d144d16c2fdd60c4e0c6463ec98'
                            'b85642d06d8e9414e8fcfdcb7cb13532ec5454fb8fe7f280'
        },
        "thumbnail": "fake thumbnail",
        "title": "fake title",
        "ver": "0.0.3"
    }
    if with_fee:
        metadata.update(
            {"fee": {"USD": {"address": "bQ6BGboPV2SpTMEP7wLNiAcnsZiH8ye6eA", "amount": 0.75}}})
    migrated = smart_decode(json.dumps(metadata))
    daemon._resolve = daemon.wallet_manager.resolve = lambda *_: defer.succeed(
        {"test": {'claim': {'value': migrated.claim_dict}}})
    return daemon
Example #2
0
 def setUp(self):
     self.reactor = Clock()
     mocks.mock_conf_settings(self)
     self.component_manager = ComponentManager(
         skip_components=[
             DATABASE_COMPONENT, DHT_COMPONENT, HASH_ANNOUNCER_COMPONENT,
             STREAM_IDENTIFIER_COMPONENT, PEER_PROTOCOL_SERVER_COMPONENT,
             REFLECTOR_COMPONENT, UPNP_COMPONENT, HEADERS_COMPONENT,
             PAYMENT_RATE_COMPONENT, RATE_LIMITER_COMPONENT,
             EXCHANGE_RATE_MANAGER_COMPONENT
         ],
         reactor=self.reactor,
         wallet=mocks.FakeDelayedWallet,
         file_manager=mocks.FakeDelayedFileManager,
         blob_manager=mocks.FakeDelayedBlobManager)
Example #3
0
    def test_init_with_wrong_overrides(self):
        class FakeRandomComponent:
            component_name = "someComponent"
            depends_on = []

        with self.assertRaises(SyntaxError):
            ComponentManager(randomComponent=FakeRandomComponent)
Example #4
0
 def __init__(self,
              analytics_manager=None,
              component_manager=None,
              use_authentication=None,
              use_https=None,
              to_skip=None,
              looping_calls=None,
              reactor=None):
     if not reactor:
         from twisted.internet import reactor
     self.analytics_manager = analytics_manager or analytics.Manager.new_instance(
     )
     self.component_manager = component_manager or ComponentManager(
         analytics_manager=self.analytics_manager,
         skip_components=to_skip or [],
         reactor=reactor)
     self.looping_call_manager = LoopingCallManager(
         {n: lc
          for n, (lc, t) in (looping_calls or {}).items()})
     self._looping_call_times = {
         n: t
         for n, (lc, t) in (looping_calls or {}).items()
     }
     self._use_authentication = use_authentication or conf.settings[
         'use_auth_http']
     self._use_https = use_https or conf.settings['use_https']
     self.listening_port = None
     self._component_setup_deferred = None
     self.announced_startup = False
     self.sessions = {}
     self.server = None
     self.keyring = Keyring.generate_and_save()
Example #5
0
    def test_init_with_overrides(self):
        class FakeWallet:
            component_name = "wallet"
            depends_on = []

            def __init__(self, component_manager):
                self.component_manager = component_manager

            @property
            def component(self):
                return self

        new_component_manager = ComponentManager(wallet=FakeWallet)
        fake_wallet = new_component_manager.get_component("wallet")
        # wallet should be an instance of FakeWallet and not WalletComponent from Components.py
        self.assertIsInstance(fake_wallet, FakeWallet)
        self.assertNotIsInstance(fake_wallet, Components.WalletComponent)
Example #6
0
 def setUp(self):
     mocks.mock_conf_settings(self)
     self.default_components_sort = [
         [
             Components.HeadersComponent, Components.DatabaseComponent,
             Components.ExchangeRateManagerComponent,
             Components.PaymentRateComponent,
             Components.RateLimiterComponent, Components.UPnPComponent
         ], [Components.DHTComponent, Components.WalletComponent],
         [Components.BlobComponent, Components.HashAnnouncerComponent],
         [
             Components.PeerProtocolServerComponent,
             Components.StreamIdentifierComponent
         ], [Components.FileManagerComponent],
         [Components.ReflectorComponent]
     ]
     self.component_manager = ComponentManager()
Example #7
0
class TestComponentManager(unittest.TestCase):
    def setUp(self):
        mocks.mock_conf_settings(self)
        self.default_components_sort = [
            [
                Components.HeadersComponent, Components.DatabaseComponent,
                Components.ExchangeRateManagerComponent,
                Components.PaymentRateComponent,
                Components.RateLimiterComponent, Components.UPnPComponent
            ], [Components.DHTComponent, Components.WalletComponent],
            [Components.BlobComponent, Components.HashAnnouncerComponent],
            [
                Components.PeerProtocolServerComponent,
                Components.StreamIdentifierComponent
            ], [Components.FileManagerComponent],
            [Components.ReflectorComponent]
        ]
        self.component_manager = ComponentManager()

    def tearDown(self):
        pass

    def test_sort_components(self):
        stages = self.component_manager.sort_components()

        for stage_list, sorted_stage_list in zip(stages,
                                                 self.default_components_sort):
            self.assertEqual([type(stage) for stage in stage_list],
                             sorted_stage_list)

    def test_sort_components_reverse(self):
        rev_stages = self.component_manager.sort_components(reverse=True)
        reverse_default_components_sort = reversed(
            self.default_components_sort)

        for stage_list, sorted_stage_list in zip(
                rev_stages, reverse_default_components_sort):
            self.assertEqual([type(stage) for stage in stage_list],
                             sorted_stage_list)

    def test_get_component_not_exists(self):

        with self.assertRaises(NameError):
            self.component_manager.get_component("random_component")
    async def setUp(self):
        await super().setUp()

        if self.VERBOSE:
            log.setLevel(logging.DEBUG)
            logging.getLogger('lbrynet.core').setLevel(logging.DEBUG)

        lbry_conf.settings = None
        lbry_conf.initialize_settings(load_conf_file=False)
        lbry_conf.settings['data_dir'] = self.stack.wallet.data_path
        lbry_conf.settings['lbryum_wallet_dir'] = self.stack.wallet.data_path
        lbry_conf.settings['download_directory'] = self.stack.wallet.data_path
        lbry_conf.settings['use_upnp'] = False
        lbry_conf.settings['reflect_uploads'] = False
        lbry_conf.settings['blockchain_name'] = 'lbrycrd_regtest'
        lbry_conf.settings['lbryum_servers'] = [('localhost', 50001)]
        lbry_conf.settings['known_dht_nodes'] = []
        lbry_conf.settings.node_id = None

        await d2f(self.account.ensure_address_gap())
        address = (await d2f(
            self.account.receiving.get_addresses(1, only_usable=True)))[0]
        sendtxid = await self.blockchain.send_to_address(address, 10)
        await self.confirm_tx(sendtxid)
        await self.generate(5)

        def wallet_maker(component_manager):
            self.wallet_component = WalletComponent(component_manager)
            self.wallet_component.wallet = self.manager
            self.wallet_component._running = True
            return self.wallet_component

        skip = [
            #UPNP_COMPONENT,
            PEER_PROTOCOL_SERVER_COMPONENT,
            REFLECTOR_COMPONENT
        ]
        analytics_manager = FakeAnalytics()
        self.daemon = Daemon(
            analytics_manager,
            ComponentManager(analytics_manager=analytics_manager,
                             skip_components=skip,
                             wallet=wallet_maker,
                             dht=FakeDHT,
                             hash_announcer=FakeHashAnnouncerComponent,
                             exchange_rate_manager=FakeExchangeRateComponent,
                             upnp=FakeUPnP))
        #for component in skip:
        #    self.daemon.component_attributes.pop(component, None)
        await d2f(self.daemon.setup())
        self.daemon.wallet = self.wallet_component.wallet
        self.manager.old_db = self.daemon.storage
Example #9
0
class TestComponentManagerProperStart(unittest.TestCase):
    def setUp(self):
        self.reactor = Clock()
        mocks.mock_conf_settings(self)
        self.component_manager = ComponentManager(
            skip_components=[
                DATABASE_COMPONENT, DHT_COMPONENT, HASH_ANNOUNCER_COMPONENT,
                STREAM_IDENTIFIER_COMPONENT, PEER_PROTOCOL_SERVER_COMPONENT,
                REFLECTOR_COMPONENT, UPNP_COMPONENT, HEADERS_COMPONENT,
                PAYMENT_RATE_COMPONENT, RATE_LIMITER_COMPONENT,
                EXCHANGE_RATE_MANAGER_COMPONENT
            ],
            reactor=self.reactor,
            wallet=mocks.FakeDelayedWallet,
            file_manager=mocks.FakeDelayedFileManager,
            blob_manager=mocks.FakeDelayedBlobManager)

    def tearDown(self):
        pass

    def test_proper_starting_of_components(self):
        self.component_manager.setup()
        self.assertTrue(self.component_manager.get_component('wallet').running)
        self.assertFalse(
            self.component_manager.get_component('blob_manager').running)
        self.assertFalse(
            self.component_manager.get_component('file_manager').running)

        self.reactor.advance(1)
        self.assertTrue(self.component_manager.get_component('wallet').running)
        self.assertTrue(
            self.component_manager.get_component('blob_manager').running)
        self.assertFalse(
            self.component_manager.get_component('file_manager').running)

        self.reactor.advance(1)
        self.assertTrue(self.component_manager.get_component('wallet').running)
        self.assertTrue(
            self.component_manager.get_component('blob_manager').running)
        self.assertTrue(
            self.component_manager.get_component('file_manager').running)

    def test_proper_stopping_of_components(self):
        self.component_manager.setup()
        self.reactor.advance(1)
        self.reactor.advance(1)
        self.component_manager.stop()
        self.assertFalse(
            self.component_manager.get_component('file_manager').running)
        self.assertTrue(
            self.component_manager.get_component('blob_manager').running)
        self.assertTrue(self.component_manager.get_component('wallet').running)

        self.reactor.advance(1)
        self.assertFalse(
            self.component_manager.get_component('file_manager').running)
        self.assertFalse(
            self.component_manager.get_component('blob_manager').running)
        self.assertTrue(self.component_manager.get_component('wallet').running)

        self.reactor.advance(1)
        self.assertFalse(
            self.component_manager.get_component('file_manager').running)
        self.assertFalse(
            self.component_manager.get_component('blob_manager').running)
        self.assertFalse(
            self.component_manager.get_component('wallet').running)