def ParseHydrusNetworkGETArgs(requests_args):
args = ParseTwistedRequestGETArgs(requests_args, INT_PARAMS, BYTE_PARAMS,
STRING_PARAMS, JSON_PARAMS,
JSON_BYTE_LIST_PARAMS)
if 'subject_account_key' in args:
args['subject_identifier'] = HydrusNetwork.AccountIdentifier(
account_key=args['subject_account_key'])
elif 'subject_hash' in args:
hash = args['subject_hash']
if 'subject_tag' in args:
tag = args['subject_tag']
content = HydrusNetwork.Content(HC.CONTENT_TYPE_MAPPING,
(tag, hash))
else:
content = HydrusNetwork.Content(HC.CONTENT_TYPE_FILES, [hash])
args['subject_identifier'] = HydrusNetwork.AccountIdentifier(
content=content)
return args
def _test_content_creation(self):
tag = 'character:samus aran'
hash = HydrusData.GenerateKey()
mappings_content = HydrusNetwork.Content(HC.CONTENT_TYPE_MAPPINGS,
(tag, (hash, )))
mapping_content = HydrusNetwork.Content(HC.CONTENT_TYPE_MAPPING,
(tag, hash))
client_to_server_update = HydrusNetwork.ClientToServerUpdate()
client_to_server_update.AddContent(HC.CONTENT_UPDATE_PEND,
mappings_content)
self._write('update', self._tag_service_key,
self._tag_service_regular_account, client_to_server_update,
HydrusData.GetNow())
# can extend this to generate and fetch an actual update given a timespan
#
result = self._read('account_from_content', self._tag_service_key,
mapping_content)
self.assertEqual(result.GetAccountKey(),
self._tag_service_regular_account.GetAccountKey())
def _test_tag_repo(self, service):
# account from tag
test_tag = 'character:samus aran'
test_hash = HydrusData.GenerateKey()
subject_content = HydrusNetwork.Content(
content_type=HC.CONTENT_TYPE_MAPPING,
content_data=(test_tag, test_hash))
subject_account_identifier = HydrusNetwork.AccountIdentifier(
content=subject_content)
HG.test_controller.SetRead('account', self._account)
response = service.Request(
HC.GET, 'other_account',
{'subject_identifier': subject_account_identifier})
self.assertEqual(repr(response['account']), repr(self._account))
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_repo(self, service):
service_key = service.GetServiceKey()
# num_petitions
num_petitions = [[
HC.CONTENT_TYPE_MAPPINGS, HC.CONTENT_STATUS_PETITIONED, 23
], [HC.CONTENT_TYPE_TAG_PARENTS, HC.CONTENT_STATUS_PENDING, 0]]
HG.test_controller.SetRead('num_petitions', num_petitions)
response = service.Request(HC.GET, 'num_petitions')
self.assertEqual(response['num_petitions'], num_petitions)
# petition
action = HC.CONTENT_UPDATE_PETITION
petitioner_account = HydrusNetwork.Account.GenerateUnknownAccount()
reason = 'it sucks'
contents = [
HydrusNetwork.Content(
HC.CONTENT_TYPE_FILES,
[HydrusData.GenerateKey() for i in range(10)])
]
petition = HydrusNetwork.Petition(action, petitioner_account, reason,
contents)
HG.test_controller.SetRead('petition', petition)
response = service.Request(
HC.GET, 'petition', {
'content_type': HC.CONTENT_TYPE_FILES,
'status': HC.CONTENT_UPDATE_PETITION
})
self.assertEqual(response['petition'].GetSerialisableTuple(),
petition.GetSerialisableTuple())
# definitions
definitions_update = HydrusNetwork.DefinitionsUpdate()
for i in range(100, 200):
definitions_update.AddRow(
(HC.DEFINITIONS_TYPE_TAGS, i, 'series:test ' + str(i)))
definitions_update.AddRow((HC.DEFINITIONS_TYPE_HASHES, i + 500,
HydrusData.GenerateKey()))
definitions_update_network_bytes = definitions_update.DumpToNetworkBytes(
)
definitions_update_hash = hashlib.sha256(
definitions_update_network_bytes).digest()
path = ServerFiles.GetExpectedFilePath(definitions_update_hash)
HydrusPaths.MakeSureDirectoryExists(path)
with open(path, 'wb') as f:
f.write(definitions_update_network_bytes)
response = service.Request(HC.GET, 'update',
{'update_hash': definitions_update_hash})
try:
os.remove(path)
except:
pass
self.assertEqual(response, definitions_update_network_bytes)
# content
rows = [(random.randint(100, 1000),
[random.randint(100, 1000) for i in range(50)])
for j in range(20)]
content_update = HydrusNetwork.ContentUpdate()
for row in rows:
content_update.AddRow(
(HC.CONTENT_TYPE_MAPPINGS, HC.CONTENT_UPDATE_ADD, row))
content_update_network_bytes = content_update.DumpToNetworkBytes()
content_update_hash = hashlib.sha256(
content_update_network_bytes).digest()
path = ServerFiles.GetExpectedFilePath(content_update_hash)
with open(path, 'wb') as f:
f.write(content_update_network_bytes)
response = service.Request(HC.GET, 'update',
{'update_hash': content_update_hash})
try:
os.remove(path)
except:
pass
self.assertEqual(response, content_update_network_bytes)
# metadata
metadata = HydrusNetwork.Metadata()
metadata.AppendUpdate([definitions_update_hash, content_update_hash],
HydrusData.GetNow() - 101000,
HydrusData.GetNow() - 1000,
HydrusData.GetNow() + 100000)
service._metadata = metadata
response = service.Request(HC.GET, 'metadata_slice', {'since': 0})
self.assertEqual(response['metadata_slice'].GetSerialisableTuple(),
metadata.GetSerialisableTuple())
# post content
raise NotImplementedError()
'''
def _test_file_repo(self, service):
# file
path = ServerFiles.GetExpectedFilePath(self._file_hash)
HydrusPaths.MakeSureDirectoryExists(os.path.dirname(path))
with open(path, 'wb') as f:
f.write(EXAMPLE_FILE)
response = service.Request(HC.GET, 'file', {'hash': self._file_hash})
self.assertEqual(response, EXAMPLE_FILE)
#
try:
os.remove(path)
except:
pass
path = os.path.join(HC.STATIC_DIR, 'hydrus.png')
with open(path, 'rb') as f:
file_bytes = f.read()
HG.test_controller.ClearWrites('file')
service.Request(HC.POST, 'file', {'file': file_bytes})
written = HG.test_controller.GetWrite('file')
[(args, kwargs)] = written
(written_service_key, written_account, written_file_dict) = args
hash = b'\xadm5\x99\xa6\xc4\x89\xa5u\xeb\x19\xc0&\xfa\xce\x97\xa9\xcdey\xe7G(\xb0\xce\x94\xa6\x01\xd22\xf3\xc3'
self.assertEqual(written_file_dict['hash'], hash)
self.assertEqual(written_file_dict['ip'], '127.0.0.1')
self.assertEqual(written_file_dict['height'], 200)
self.assertEqual(written_file_dict['width'], 200)
self.assertEqual(written_file_dict['mime'], 2)
self.assertEqual(written_file_dict['size'], 5270)
# ip
(ip, timestamp) = ('94.45.87.123', HydrusData.GetNow() - 100000)
HG.test_controller.SetRead('ip', (ip, timestamp))
response = service.Request(HC.GET, 'ip', {'hash': self._file_hash})
self.assertEqual(response['ip'], ip)
self.assertEqual(response['timestamp'], timestamp)
# account from hash
subject_content = HydrusNetwork.Content(
content_type=HC.CONTENT_TYPE_FILES, content_data=hash)
subject_account_identifier = HydrusNetwork.AccountIdentifier(
content=subject_content)
HG.test_controller.SetRead('account', self._account)
response = service.Request(
HC.GET, 'other_account',
{'subject_identifier': subject_account_identifier})
self.assertEqual(repr(response['account']), repr(self._account))
# thumbnail
path = ServerFiles.GetExpectedThumbnailPath(self._file_hash)
HydrusPaths.MakeSureDirectoryExists(os.path.dirname(path))
with open(path, 'wb') as f:
f.write(EXAMPLE_THUMBNAIL)
response = service.Request(HC.GET, 'thumbnail',
{'hash': self._file_hash})
self.assertEqual(response, EXAMPLE_THUMBNAIL)
try:
os.remove(path)
except:
pass