def test_bandwidth_exceeded(self): RESTRICTIVE_DATA_RULES = HydrusNetworking.BandwidthRules() RESTRICTIVE_DATA_RULES.AddRule(HC.BANDWIDTH_TYPE_DATA, None, 10) HYDRUS_NETWORK_CONTEXT = ClientNetworkingContexts.NetworkContext( CC.NETWORK_CONTEXT_HYDRUS, MOCK_HYDRUS_SERVICE_KEY) # job = self._GetJob() self.assertEqual(job.TryToStartBandwidth(), True) job.engine.bandwidth_manager.ReportDataUsed([HYDRUS_NETWORK_CONTEXT], 50) job.engine.bandwidth_manager.SetRules(HYDRUS_NETWORK_CONTEXT, RESTRICTIVE_DATA_RULES) self.assertEqual(job.TryToStartBandwidth(), False) # job = self._GetJob(for_login=True) self.assertEqual(job.TryToStartBandwidth(), True) job.engine.bandwidth_manager.ReportDataUsed([HYDRUS_NETWORK_CONTEXT], 50) job.engine.bandwidth_manager.SetRules(HYDRUS_NETWORK_CONTEXT, RESTRICTIVE_DATA_RULES) self.assertEqual(job.TryToStartBandwidth(), True)
def test_bandwidth_ok(self): PERMISSIVE_DATA_RULES = HydrusNetworking.BandwidthRules() PERMISSIVE_DATA_RULES.AddRule(HC.BANDWIDTH_TYPE_DATA, None, 1048576) DOMAIN_NETWORK_CONTEXT = ClientNetworkingContexts.NetworkContext( CC.NETWORK_CONTEXT_DOMAIN, MOCK_DOMAIN) # job = self._GetJob() job.engine.bandwidth_manager.ReportDataUsed([DOMAIN_NETWORK_CONTEXT], 50) self.assertEqual(job.TryToStartBandwidth(), True) job.engine.bandwidth_manager.SetRules(DOMAIN_NETWORK_CONTEXT, PERMISSIVE_DATA_RULES) self.assertEqual(job.TryToStartBandwidth(), True) # job = self._GetJob(for_login=True) job.engine.bandwidth_manager.ReportDataUsed([DOMAIN_NETWORK_CONTEXT], 50) self.assertEqual(job.TryToStartBandwidth(), True) job.engine.bandwidth_manager.SetRules(DOMAIN_NETWORK_CONTEXT, PERMISSIVE_DATA_RULES) self.assertEqual(job.TryToStartBandwidth(), True)
def _test_restricted(self, service): # access_key registration_key = HydrusData.GenerateKey() HG.test_controller.SetRead('access_key', self._access_key) response = service.Request(HC.GET, 'access_key', {'registration_key': registration_key}) self.assertEqual(response['access_key'], self._access_key) # set up session last_error = 0 account = self._account HG.test_controller.SetRead('service', service) HG.test_controller.SetRead('account_key_from_access_key', HydrusData.GenerateKey()) HG.test_controller.SetRead('account', self._account) # account response = service.Request(HC.GET, 'account') self.assertEqual(repr(response['account']), repr(self._account)) # account from access key HG.test_controller.SetRead('account', self._account) subject_account_identifier = HydrusNetwork.AccountIdentifier( account_key=self._account.GetAccountKey()) response = service.Request( HC.GET, 'other_account', {'subject_identifier': subject_account_identifier}) self.assertEqual(repr(response['account']), repr(self._account)) # account from file HG.test_controller.SetRead('account_from_content', self._account) content = HydrusNetwork.Content( content_type=HC.CONTENT_TYPE_FILES, content_data=(HydrusData.GenerateKey(), )) subject_account_identifier = HydrusNetwork.AccountIdentifier( content=content) response = service.Request( HC.GET, 'other_account', {'subject_identifier': subject_account_identifier}) self.assertEqual(repr(response['account']), repr(self._account)) # account from mapping HG.test_controller.SetRead('account_from_content', self._account) content = HydrusNetwork.Content( content_type=HC.CONTENT_TYPE_MAPPING, content_data=('hello', HydrusData.GenerateKey())) subject_account_identifier = HydrusNetwork.AccountIdentifier( content=content) response = service.Request( HC.GET, 'other_account', {'subject_identifier': subject_account_identifier}) self.assertEqual(repr(response['account']), repr(self._account)) # account_info account_info = {'message': 'hello'} HG.test_controller.SetRead('account_info', account_info) subject_account_identifier = HydrusNetwork.AccountIdentifier( account_key=HydrusData.GenerateKey()) response = service.Request( HC.GET, 'account_info', {'subject_identifier': subject_account_identifier}) self.assertEqual(response['account_info'], account_info) # content = HydrusNetwork.Content( content_type=HC.CONTENT_TYPE_FILES, content_data=(HydrusData.GenerateKey(), )) subject_account_identifier = HydrusNetwork.AccountIdentifier( content=content) with self.assertRaises(HydrusExceptions.BadRequestException): # can only do it with an account id response = service.Request( HC.GET, 'account_info', {'subject_identifier': subject_account_identifier}) content = HydrusNetwork.Content( content_type=HC.CONTENT_TYPE_MAPPING, content_data=('hello', HydrusData.GenerateKey())) subject_account_identifier = HydrusNetwork.AccountIdentifier( content=content) with self.assertRaises(HydrusExceptions.BadRequestException): # can only do it with an account id response = service.Request( HC.GET, 'account_info', {'subject_identifier': subject_account_identifier}) # account_types account_types = [ HydrusNetwork.AccountType.GenerateAdminAccountType( service.GetServiceType()) ] HG.test_controller.SetRead('account_types', account_types) HG.test_controller.ClearWrites('account_types') response = service.Request(HC.GET, 'account_types') self.assertEqual(response['account_types'][0].GetAccountTypeKey(), account_types[0].GetAccountTypeKey()) empty_account_type = HydrusNetwork.AccountType.GenerateNewAccountType( 'empty account', {}, HydrusNetworking.BandwidthRules()) account_types.append(empty_account_type) service.Request( HC.POST, 'account_types', { 'account_types': account_types, 'deletee_account_type_keys_to_new_account_type_keys': {} }) written = HG.test_controller.GetWrite('account_types') [(args, kwargs)] = written (written_service_key, written_account, written_account_types, written_deletee_account_type_keys_to_new_account_type_keys) = args self.assertEqual( {wat.GetAccountTypeKey() for wat in written_account_types}, {at.GetAccountTypeKey() for at in account_types}) self.assertEqual( written_deletee_account_type_keys_to_new_account_type_keys, {}) # registration_keys registration_key = HydrusData.GenerateKey() HG.test_controller.SetRead('registration_keys', [registration_key]) response = service.Request( HC.GET, 'registration_keys', { 'num': 1, 'account_type_key': os.urandom(32), 'expires': HydrusData.GetNow() + 1200 }) self.assertEqual(response['registration_keys'], [registration_key])
def test_can_start(self): EMPTY_RULES = HydrusNetworking.BandwidthRules() PERMISSIVE_DATA_RULES = HydrusNetworking.BandwidthRules() PERMISSIVE_DATA_RULES.AddRule(HC.BANDWIDTH_TYPE_DATA, None, 1048576) PERMISSIVE_REQUEST_RULES = HydrusNetworking.BandwidthRules() PERMISSIVE_REQUEST_RULES.AddRule(HC.BANDWIDTH_TYPE_REQUESTS, None, 10000) RESTRICTIVE_DATA_RULES = HydrusNetworking.BandwidthRules() RESTRICTIVE_DATA_RULES.AddRule(HC.BANDWIDTH_TYPE_DATA, None, 10) RESTRICTIVE_REQUEST_RULES = HydrusNetworking.BandwidthRules() RESTRICTIVE_REQUEST_RULES.AddRule(HC.BANDWIDTH_TYPE_REQUESTS, None, 1) DOMAIN_NETWORK_CONTEXT = ClientNetworkingContexts.NetworkContext( CC.NETWORK_CONTEXT_DOMAIN, MOCK_DOMAIN) SUBDOMAIN_NETWORK_CONTEXT = ClientNetworkingContexts.NetworkContext( CC.NETWORK_CONTEXT_DOMAIN, MOCK_SUBDOMAIN) GLOBAL_NETWORK_CONTEXTS = [ ClientNetworkingContexts.GLOBAL_NETWORK_CONTEXT ] DOMAIN_NETWORK_CONTEXTS = [ ClientNetworkingContexts.GLOBAL_NETWORK_CONTEXT, DOMAIN_NETWORK_CONTEXT ] SUBDOMAIN_NETWORK_CONTEXTS = [ ClientNetworkingContexts.GLOBAL_NETWORK_CONTEXT, DOMAIN_NETWORK_CONTEXT, SUBDOMAIN_NETWORK_CONTEXT ] # fast_forward = HydrusData.GetNow() + 3600 with patch.object(HydrusData, 'GetNow', return_value=fast_forward): bm = ClientNetworkingBandwidth.NetworkBandwidthManager() self.assertTrue(bm.CanStartRequest(GLOBAL_NETWORK_CONTEXTS)) self.assertTrue(bm.CanStartRequest(DOMAIN_NETWORK_CONTEXTS)) self.assertTrue(bm.CanStartRequest(SUBDOMAIN_NETWORK_CONTEXTS)) # bm.ReportRequestUsed(DOMAIN_NETWORK_CONTEXTS) bm.ReportDataUsed(DOMAIN_NETWORK_CONTEXTS, 50) bm.ReportRequestUsed(SUBDOMAIN_NETWORK_CONTEXTS) bm.ReportDataUsed(SUBDOMAIN_NETWORK_CONTEXTS, 25) self.assertTrue(bm.CanStartRequest(GLOBAL_NETWORK_CONTEXTS)) self.assertTrue(bm.CanStartRequest(DOMAIN_NETWORK_CONTEXTS)) self.assertTrue(bm.CanStartRequest(SUBDOMAIN_NETWORK_CONTEXTS)) # bm.SetRules(ClientNetworkingContexts.GLOBAL_NETWORK_CONTEXT, EMPTY_RULES) bm.SetRules(DOMAIN_NETWORK_CONTEXT, EMPTY_RULES) bm.SetRules(SUBDOMAIN_NETWORK_CONTEXT, EMPTY_RULES) self.assertTrue(bm.CanStartRequest(GLOBAL_NETWORK_CONTEXTS)) self.assertTrue(bm.CanStartRequest(DOMAIN_NETWORK_CONTEXTS)) self.assertTrue(bm.CanStartRequest(SUBDOMAIN_NETWORK_CONTEXTS)) bm.SetRules(ClientNetworkingContexts.GLOBAL_NETWORK_CONTEXT, PERMISSIVE_DATA_RULES) bm.SetRules(DOMAIN_NETWORK_CONTEXT, PERMISSIVE_DATA_RULES) bm.SetRules(SUBDOMAIN_NETWORK_CONTEXT, PERMISSIVE_DATA_RULES) self.assertTrue(bm.CanStartRequest(GLOBAL_NETWORK_CONTEXTS)) self.assertTrue(bm.CanStartRequest(DOMAIN_NETWORK_CONTEXTS)) self.assertTrue(bm.CanStartRequest(SUBDOMAIN_NETWORK_CONTEXTS)) bm.SetRules(ClientNetworkingContexts.GLOBAL_NETWORK_CONTEXT, PERMISSIVE_REQUEST_RULES) bm.SetRules(DOMAIN_NETWORK_CONTEXT, PERMISSIVE_REQUEST_RULES) bm.SetRules(SUBDOMAIN_NETWORK_CONTEXT, PERMISSIVE_REQUEST_RULES) self.assertTrue(bm.CanStartRequest(GLOBAL_NETWORK_CONTEXTS)) self.assertTrue(bm.CanStartRequest(DOMAIN_NETWORK_CONTEXTS)) self.assertTrue(bm.CanStartRequest(SUBDOMAIN_NETWORK_CONTEXTS)) # bm.SetRules(SUBDOMAIN_NETWORK_CONTEXT, RESTRICTIVE_DATA_RULES) self.assertTrue(bm.CanStartRequest(GLOBAL_NETWORK_CONTEXTS)) self.assertTrue(bm.CanStartRequest(DOMAIN_NETWORK_CONTEXTS)) self.assertFalse(bm.CanStartRequest(SUBDOMAIN_NETWORK_CONTEXTS)) bm.SetRules(SUBDOMAIN_NETWORK_CONTEXT, RESTRICTIVE_REQUEST_RULES) self.assertTrue(bm.CanStartRequest(GLOBAL_NETWORK_CONTEXTS)) self.assertTrue(bm.CanStartRequest(DOMAIN_NETWORK_CONTEXTS)) self.assertFalse(bm.CanStartRequest(SUBDOMAIN_NETWORK_CONTEXTS)) bm.SetRules(SUBDOMAIN_NETWORK_CONTEXT, PERMISSIVE_REQUEST_RULES) self.assertTrue(bm.CanStartRequest(GLOBAL_NETWORK_CONTEXTS)) self.assertTrue(bm.CanStartRequest(DOMAIN_NETWORK_CONTEXTS)) self.assertTrue(bm.CanStartRequest(SUBDOMAIN_NETWORK_CONTEXTS)) # bm.SetRules(DOMAIN_NETWORK_CONTEXT, RESTRICTIVE_DATA_RULES) self.assertTrue(bm.CanStartRequest(GLOBAL_NETWORK_CONTEXTS)) self.assertFalse(bm.CanStartRequest(DOMAIN_NETWORK_CONTEXTS)) self.assertFalse(bm.CanStartRequest(SUBDOMAIN_NETWORK_CONTEXTS)) bm.SetRules(DOMAIN_NETWORK_CONTEXT, RESTRICTIVE_REQUEST_RULES) self.assertTrue(bm.CanStartRequest(GLOBAL_NETWORK_CONTEXTS)) self.assertFalse(bm.CanStartRequest(DOMAIN_NETWORK_CONTEXTS)) self.assertFalse(bm.CanStartRequest(SUBDOMAIN_NETWORK_CONTEXTS)) bm.SetRules(DOMAIN_NETWORK_CONTEXT, PERMISSIVE_REQUEST_RULES) self.assertTrue(bm.CanStartRequest(GLOBAL_NETWORK_CONTEXTS)) self.assertTrue(bm.CanStartRequest(DOMAIN_NETWORK_CONTEXTS)) self.assertTrue(bm.CanStartRequest(SUBDOMAIN_NETWORK_CONTEXTS)) # bm.SetRules(ClientNetworkingContexts.GLOBAL_NETWORK_CONTEXT, RESTRICTIVE_DATA_RULES) self.assertFalse(bm.CanStartRequest(GLOBAL_NETWORK_CONTEXTS)) self.assertFalse(bm.CanStartRequest(DOMAIN_NETWORK_CONTEXTS)) self.assertFalse(bm.CanStartRequest(SUBDOMAIN_NETWORK_CONTEXTS)) bm.SetRules(ClientNetworkingContexts.GLOBAL_NETWORK_CONTEXT, RESTRICTIVE_REQUEST_RULES) self.assertFalse(bm.CanStartRequest(GLOBAL_NETWORK_CONTEXTS)) self.assertFalse(bm.CanStartRequest(DOMAIN_NETWORK_CONTEXTS)) self.assertFalse(bm.CanStartRequest(SUBDOMAIN_NETWORK_CONTEXTS)) bm.SetRules(ClientNetworkingContexts.GLOBAL_NETWORK_CONTEXT, PERMISSIVE_REQUEST_RULES) self.assertTrue(bm.CanStartRequest(GLOBAL_NETWORK_CONTEXTS)) self.assertTrue(bm.CanStartRequest(DOMAIN_NETWORK_CONTEXTS)) self.assertTrue(bm.CanStartRequest(SUBDOMAIN_NETWORK_CONTEXTS)) # bm.SetRules(ClientNetworkingContexts.GLOBAL_NETWORK_CONTEXT, RESTRICTIVE_DATA_RULES) bm.SetRules(DOMAIN_NETWORK_CONTEXT, RESTRICTIVE_REQUEST_RULES) bm.SetRules(DOMAIN_NETWORK_CONTEXT, EMPTY_RULES) self.assertFalse(bm.CanStartRequest(GLOBAL_NETWORK_CONTEXTS)) self.assertFalse(bm.CanStartRequest(DOMAIN_NETWORK_CONTEXTS)) self.assertFalse(bm.CanStartRequest(SUBDOMAIN_NETWORK_CONTEXTS))
def _test_account_creation(self): result = self._read('account_types', self._tag_service_key, self._tag_service_account) (self._tag_service_admin_account_type, ) = result self.assertEqual(self._tag_service_admin_account_type.GetTitle(), 'administrator') # self._regular_user_account_type = HydrusNetwork.AccountType.GenerateNewAccountType( 'regular user', {HC.CONTENT_TYPE_MAPPINGS: HC.PERMISSION_ACTION_CREATE}, HydrusNetworking.BandwidthRules()) self._deletee_user_account_type = HydrusNetwork.AccountType.GenerateNewAccountType( 'deletee user', {}, HydrusNetworking.BandwidthRules()) new_account_types = [ self._tag_service_admin_account_type, self._regular_user_account_type, self._deletee_user_account_type ] # self._write('account_types', self._tag_service_key, self._tag_service_account, new_account_types, {}) edited_account_types = self._read('account_types', self._tag_service_key, self._tag_service_account) self.assertEqual( {at.GetAccountTypeKey() for at in edited_account_types}, { at.GetAccountTypeKey() for at in (self._tag_service_admin_account_type, self._regular_user_account_type, self._deletee_user_account_type) }) # r_keys = self._read( 'registration_keys', self._tag_service_key, self._tag_service_account, 5, self._deletee_user_account_type.GetAccountTypeKey(), 86400 * 365) access_keys = [ self._read('access_key', self._tag_service_key, r_key) for r_key in r_keys ] account_keys = [ self._read('account_key_from_access_key', self._tag_service_key, access_key) for access_key in access_keys ] accounts = [ self._read('account', self._tag_service_key, account_key) for account_key in account_keys ] for account in accounts: self.assertEqual( account.GetAccountType().GetAccountTypeKey(), self._deletee_user_account_type.GetAccountTypeKey()) # deletee_account_type_keys_to_replacement_account_type_keys = { self._deletee_user_account_type.GetAccountTypeKey(): self._regular_user_account_type.GetAccountTypeKey() } new_account_types = [ self._tag_service_admin_account_type, self._regular_user_account_type ] self._write( 'account_types', self._tag_service_key, self._tag_service_account, new_account_types, deletee_account_type_keys_to_replacement_account_type_keys) accounts = [ self._read('account', self._tag_service_key, account_key) for account_key in account_keys ] self._tag_service_regular_account = accounts[0] for account in accounts: self.assertEqual( account.GetAccountType().GetAccountTypeKey(), self._regular_user_account_type.GetAccountTypeKey()) # r_keys = self._read( 'registration_keys', self._tag_service_key, self._tag_service_account, 5, self._regular_user_account_type.GetAccountTypeKey(), 86400 * 365) self.assertEqual(len(r_keys), 5) for r_key in r_keys: self.assertEqual(len(r_key), 32) r_key = r_keys[0] access_key = self._read('access_key', self._tag_service_key, r_key) access_key_2 = self._read('access_key', self._tag_service_key, r_key) self.assertNotEqual(access_key, access_key_2) with self.assertRaises( HydrusExceptions.InsufficientCredentialsException): # this access key has been replaced self._read('account_key_from_access_key', self._tag_service_key, access_key) account_key = self._read('account_key_from_access_key', self._tag_service_key, access_key_2) with self.assertRaises( HydrusExceptions.InsufficientCredentialsException): # this registration key has been deleted self._read('access_key', self._tag_service_key, r_key)
def test_per_sec( self ): # at short time deltas, we can always start based on data alone rules = HydrusNetworking.BandwidthRules() rules.AddRule( HC.BANDWIDTH_TYPE_DATA, 1, 10240 ) with patch.object( HydrusData, 'GetNow', return_value = now ): self.assertTrue( rules.CanStartRequest( ZERO_USAGE ) ) self.assertTrue( rules.CanStartRequest( LOW_USAGE ) ) self.assertTrue( rules.CanStartRequest( HIGH_USAGE ) ) self.assertTrue( rules.CanContinueDownload( ZERO_USAGE ) ) self.assertTrue( rules.CanContinueDownload( LOW_USAGE ) ) self.assertFalse( rules.CanContinueDownload( HIGH_USAGE ) ) with patch.object( HydrusData, 'GetNow', return_value = now_10 ): self.assertTrue( rules.CanStartRequest( ZERO_USAGE ) ) self.assertTrue( rules.CanStartRequest( LOW_USAGE ) ) self.assertTrue( rules.CanStartRequest( HIGH_USAGE ) ) self.assertTrue( rules.CanContinueDownload( ZERO_USAGE ) ) self.assertTrue( rules.CanContinueDownload( LOW_USAGE ) ) self.assertTrue( rules.CanContinueDownload( HIGH_USAGE ) ) with patch.object( HydrusData, 'GetNow', return_value = now_20 ): self.assertTrue( rules.CanStartRequest( ZERO_USAGE ) ) self.assertTrue( rules.CanStartRequest( LOW_USAGE ) ) self.assertTrue( rules.CanStartRequest( HIGH_USAGE ) ) self.assertTrue( rules.CanContinueDownload( ZERO_USAGE ) ) self.assertTrue( rules.CanContinueDownload( LOW_USAGE ) ) self.assertTrue( rules.CanContinueDownload( HIGH_USAGE ) ) # rules = HydrusNetworking.BandwidthRules() rules.AddRule( HC.BANDWIDTH_TYPE_REQUESTS, 1, 1 ) with patch.object( HydrusData, 'GetNow', return_value = now ): self.assertTrue( rules.CanStartRequest( ZERO_USAGE ) ) self.assertFalse( rules.CanStartRequest( LOW_USAGE ) ) self.assertFalse( rules.CanStartRequest( HIGH_USAGE ) ) self.assertTrue( rules.CanContinueDownload( ZERO_USAGE ) ) self.assertTrue( rules.CanContinueDownload( LOW_USAGE ) ) self.assertTrue( rules.CanContinueDownload( HIGH_USAGE ) ) with patch.object( HydrusData, 'GetNow', return_value = now_10 ): self.assertTrue( rules.CanStartRequest( ZERO_USAGE ) ) self.assertTrue( rules.CanStartRequest( LOW_USAGE ) ) self.assertTrue( rules.CanStartRequest( HIGH_USAGE ) ) self.assertTrue( rules.CanContinueDownload( ZERO_USAGE ) ) self.assertTrue( rules.CanContinueDownload( LOW_USAGE ) ) self.assertTrue( rules.CanContinueDownload( HIGH_USAGE ) ) with patch.object( HydrusData, 'GetNow', return_value = now_20 ): self.assertTrue( rules.CanStartRequest( ZERO_USAGE ) ) self.assertTrue( rules.CanStartRequest( LOW_USAGE ) ) self.assertTrue( rules.CanStartRequest( HIGH_USAGE ) ) self.assertTrue( rules.CanContinueDownload( ZERO_USAGE ) ) self.assertTrue( rules.CanContinueDownload( LOW_USAGE ) ) self.assertTrue( rules.CanContinueDownload( HIGH_USAGE ) ) # rules = HydrusNetworking.BandwidthRules() rules.AddRule( HC.BANDWIDTH_TYPE_DATA, 1, 10240 ) rules.AddRule( HC.BANDWIDTH_TYPE_REQUESTS, 1, 1 ) with patch.object( HydrusData, 'GetNow', return_value = now ): self.assertTrue( rules.CanStartRequest( ZERO_USAGE ) ) self.assertFalse( rules.CanStartRequest( LOW_USAGE ) ) self.assertFalse( rules.CanStartRequest( HIGH_USAGE ) ) self.assertTrue( rules.CanContinueDownload( ZERO_USAGE ) ) self.assertTrue( rules.CanContinueDownload( LOW_USAGE ) ) self.assertFalse( rules.CanContinueDownload( HIGH_USAGE ) ) with patch.object( HydrusData, 'GetNow', return_value = now_10 ): self.assertTrue( rules.CanStartRequest( ZERO_USAGE ) ) self.assertTrue( rules.CanStartRequest( LOW_USAGE ) ) self.assertTrue( rules.CanStartRequest( HIGH_USAGE ) ) self.assertTrue( rules.CanContinueDownload( ZERO_USAGE ) ) self.assertTrue( rules.CanContinueDownload( LOW_USAGE ) ) self.assertTrue( rules.CanContinueDownload( HIGH_USAGE ) ) with patch.object( HydrusData, 'GetNow', return_value = now_20 ): self.assertTrue( rules.CanStartRequest( ZERO_USAGE ) ) self.assertTrue( rules.CanStartRequest( LOW_USAGE ) ) self.assertTrue( rules.CanStartRequest( HIGH_USAGE ) ) self.assertTrue( rules.CanContinueDownload( ZERO_USAGE ) ) self.assertTrue( rules.CanContinueDownload( LOW_USAGE ) ) self.assertTrue( rules.CanContinueDownload( HIGH_USAGE ) )
def test_per_month( self ): rules = HydrusNetworking.BandwidthRules() rules.AddRule( HC.BANDWIDTH_TYPE_DATA, None, 10240 ) with patch.object( HydrusData, 'GetNow', return_value = now ): self.assertTrue( rules.CanStartRequest( ZERO_USAGE ) ) self.assertTrue( rules.CanStartRequest( LOW_USAGE ) ) self.assertFalse( rules.CanStartRequest( HIGH_USAGE ) ) self.assertTrue( rules.CanContinueDownload( ZERO_USAGE ) ) self.assertTrue( rules.CanContinueDownload( LOW_USAGE ) ) self.assertTrue( rules.CanContinueDownload( HIGH_USAGE ) ) with patch.object( HydrusData, 'GetNow', return_value = now_10 ): self.assertTrue( rules.CanStartRequest( ZERO_USAGE ) ) self.assertTrue( rules.CanStartRequest( LOW_USAGE ) ) self.assertFalse( rules.CanStartRequest( HIGH_USAGE ) ) self.assertTrue( rules.CanContinueDownload( ZERO_USAGE ) ) self.assertTrue( rules.CanContinueDownload( LOW_USAGE ) ) self.assertTrue( rules.CanContinueDownload( HIGH_USAGE ) ) with patch.object( HydrusData, 'GetNow', return_value = now_20 ): self.assertTrue( rules.CanStartRequest( ZERO_USAGE ) ) self.assertTrue( rules.CanStartRequest( LOW_USAGE ) ) self.assertFalse( rules.CanStartRequest( HIGH_USAGE ) ) self.assertTrue( rules.CanContinueDownload( ZERO_USAGE ) ) self.assertTrue( rules.CanContinueDownload( LOW_USAGE ) ) self.assertTrue( rules.CanContinueDownload( HIGH_USAGE ) ) # rules = HydrusNetworking.BandwidthRules() rules.AddRule( HC.BANDWIDTH_TYPE_REQUESTS, None, 10 ) with patch.object( HydrusData, 'GetNow', return_value = now ): self.assertTrue( rules.CanStartRequest( ZERO_USAGE ) ) self.assertTrue( rules.CanStartRequest( LOW_USAGE ) ) self.assertFalse( rules.CanStartRequest( HIGH_USAGE ) ) self.assertTrue( rules.CanContinueDownload( ZERO_USAGE ) ) self.assertTrue( rules.CanContinueDownload( LOW_USAGE ) ) self.assertTrue( rules.CanContinueDownload( HIGH_USAGE ) ) with patch.object( HydrusData, 'GetNow', return_value = now_10 ): self.assertTrue( rules.CanStartRequest( ZERO_USAGE ) ) self.assertTrue( rules.CanStartRequest( LOW_USAGE ) ) self.assertFalse( rules.CanStartRequest( HIGH_USAGE ) ) self.assertTrue( rules.CanContinueDownload( ZERO_USAGE ) ) self.assertTrue( rules.CanContinueDownload( LOW_USAGE ) ) self.assertTrue( rules.CanContinueDownload( HIGH_USAGE ) ) with patch.object( HydrusData, 'GetNow', return_value = now_20 ): self.assertTrue( rules.CanStartRequest( ZERO_USAGE ) ) self.assertTrue( rules.CanStartRequest( LOW_USAGE ) ) self.assertFalse( rules.CanStartRequest( HIGH_USAGE ) ) self.assertTrue( rules.CanContinueDownload( ZERO_USAGE ) ) self.assertTrue( rules.CanContinueDownload( LOW_USAGE ) ) self.assertTrue( rules.CanContinueDownload( HIGH_USAGE ) ) # rules = HydrusNetworking.BandwidthRules() rules.AddRule( HC.BANDWIDTH_TYPE_DATA, None, 10240 ) rules.AddRule( HC.BANDWIDTH_TYPE_REQUESTS, None, 10 ) with patch.object( HydrusData, 'GetNow', return_value = now ): self.assertTrue( rules.CanStartRequest( ZERO_USAGE ) ) self.assertTrue( rules.CanStartRequest( LOW_USAGE ) ) self.assertFalse( rules.CanStartRequest( HIGH_USAGE ) ) self.assertTrue( rules.CanContinueDownload( ZERO_USAGE ) ) self.assertTrue( rules.CanContinueDownload( LOW_USAGE ) ) self.assertTrue( rules.CanContinueDownload( HIGH_USAGE ) ) with patch.object( HydrusData, 'GetNow', return_value = now_10 ): self.assertTrue( rules.CanStartRequest( ZERO_USAGE ) ) self.assertTrue( rules.CanStartRequest( LOW_USAGE ) ) self.assertFalse( rules.CanStartRequest( HIGH_USAGE ) ) self.assertTrue( rules.CanContinueDownload( ZERO_USAGE ) ) self.assertTrue( rules.CanContinueDownload( LOW_USAGE ) ) self.assertTrue( rules.CanContinueDownload( HIGH_USAGE ) ) with patch.object( HydrusData, 'GetNow', return_value = now_20 ): self.assertTrue( rules.CanStartRequest( ZERO_USAGE ) ) self.assertTrue( rules.CanStartRequest( LOW_USAGE ) ) self.assertFalse( rules.CanStartRequest( HIGH_USAGE ) ) self.assertTrue( rules.CanContinueDownload( ZERO_USAGE ) ) self.assertTrue( rules.CanContinueDownload( LOW_USAGE ) ) self.assertTrue( rules.CanContinueDownload( HIGH_USAGE ) )
def __init__( self ): HydrusSerialisable.SerialisableBase.__init__( self ) self.engine = None self._dirty = False self._lock = threading.Lock() self._last_pages_gallery_query_timestamps = collections.defaultdict( lambda: 0 ) self._last_subscriptions_gallery_query_timestamps = collections.defaultdict( lambda: 0 ) self._last_watchers_query_timestamps = collections.defaultdict( lambda: 0 ) self._tracker_container_names_to_tracker_containers = {} self._network_contexts_to_tracker_containers = {} self._tracker_container_names = set() self._dirty_tracker_container_names = set() self._deletee_tracker_container_names = set() self._my_bandwidth_tracker = HydrusNetworking.BandwidthTracker() self._network_contexts_to_bandwidth_rules = collections.defaultdict( HydrusNetworking.BandwidthRules ) for context_type in [ CC.NETWORK_CONTEXT_GLOBAL, CC.NETWORK_CONTEXT_HYDRUS, CC.NETWORK_CONTEXT_DOMAIN, CC.NETWORK_CONTEXT_DOWNLOADER_PAGE, CC.NETWORK_CONTEXT_SUBSCRIPTION, CC.NETWORK_CONTEXT_WATCHER_PAGE ]: self._network_contexts_to_bandwidth_rules[ ClientNetworkingContexts.NetworkContext( context_type ) ] = HydrusNetworking.BandwidthRules()