def testAddDomain(self):
header, body = parseResponse(
asBytes(
self.dna.all.handleRequest(
user=CallTrace(returnValues=dict(isAdmin=False)),
path="/actions/addDomain",
Body=bytes(urlencode(dict(identifier="aap")),
encoding="utf-8"),
Method='Post')))
self.assertEqual(0, len(self.observable.calledMethods))
self.assertEqual("200", header['StatusCode'])
self.assertEqual("application/json", header['Headers']['Content-Type'])
response = JsonDict.loads(body)
self.assertFalse(response['success'])
self.assertEqual("Not allowed", response['message'])
header, body = parseResponse(
asBytes(
self.dna.all.handleRequest(
user=CallTrace(returnValues=dict(isAdmin=True)),
path="/actions/addDomain",
Body=bytes(urlencode(dict(identifier="aap")),
encoding="utf-8"),
Method='Post')))
self.assertEqual("200", header['StatusCode'])
self.assertEqual("application/json", header['Headers']['Content-Type'])
response = JsonDict.loads(body)
self.assertTrue(response['success'])
self.assertEqual(1, len(self.observable.calledMethods))
self.assertEqual("addDomain", self.observable.calledMethods[0].name)
self.assertEqual(dict(identifier='aap'),
self.observable.calledMethods[0].kwargs)
def validate(self):
for core in self.cores:
if core == self.resultsFrom:
continue
try:
self._matchCoreSpecs(self.resultsFrom, core)
except KeyError:
raise ValueError("No match set for cores %s" % str((self.resultsFrom, core)))
if self.relationalFilterJson:
try:
JsonDict.loads(self.relationalFilterJson)
except JSONDecodeError:
raise ValueError("Value '%s' for 'relationalFilterJson' can not be parsed as JSON." % self.relationalFilterJson)
def testUpdateRepositoryGroup(self):
header, body = parseResponse(
asBytes(
self.dna.all.handleRequest(
user=CallTrace(returnValues=dict(isAdmin=True)),
Method='POST',
path='/somewhere/updateRepositoryGroup',
Body=bUrlencode(dict(
identifier='group',
domainId='domain',
nl_name="De nieuwe naam",
en_name="The old name",
),
doseq=True))))
self.assertEqual('200', header['StatusCode'])
self.assertEqual(dict(success=True), JsonDict.loads(body))
self.assertEqual(1, len(self.observable.calledMethods))
self.assertEqual('updateRepositoryGroup',
self.observable.calledMethods[0].name)
self.assertEqual(
{
'identifier': 'group',
'domainId': 'domain',
'name': {
'nl': 'De nieuwe naam',
'en': 'The old name'
}
}, self.observable.calledMethods[0].kwargs)
def testUpdateRepositoryActionForm_Action(self):
header, body = parseResponse(
asBytes(
self.dna.all.handleRequest(
user=CallTrace(returnValues=dict(isAdmin=True)),
Method='POST',
path='/actions/updateRepositoryActionAttributes',
Body=bUrlencode(dict(
identifier='repo-id',
domainId='domain-id',
action="-",
),
doseq=True))))
self.assertEqual('200', header['StatusCode'])
self.assertEqual(dict(success=True), JsonDict.loads(body))
self.assertEqual(1, len(self.observable.calledMethods))
self.assertEqual('updateRepositoryAttributes',
self.observable.calledMethods[0].name)
self.assertEqual(
{
'complete': False,
'continuous': None,
'domainId': 'domain-id',
'identifier': 'repo-id',
'maximumIgnore': 0,
'action': None,
'use': False
}, self.observable.calledMethods[0].kwargs)
def _readState(self):
self._counts = JsonDict.load(
self._countFilepath) if self._countFilepath.is_file(
) else JsonDict()
if self._resumptionFilepath.is_file():
values = JsonDict.loads(self._resumptionFilepath.read_text())
self.token = values.get('resumptionToken', None) or None
self.from_ = values.get('from', '') or None
self.lastSuccessfulHarvest = values.get('lastSuccessfulHarvest',
'') or None
return
# The mechanism below will only be carried out once in case the resumption file does not yet exist.
if self._statsfilepath.is_file():
self._statsfile = self._statsfilepath.open()
logline = None
for logline in self._filterNonErrorLogLine(self._statsfile):
if not self.token:
self.from_ = getStartDate(logline)
self.token = getResumptionToken(logline)
if logline and self._isDeleted(logline):
self.from_ = None
self.token = None
self._statsfile.close()
self._statsfile = None
def testGetStatusForDomain(self):
self.controlHelper(action='allInvalid')
self.startHarvester(repository=REPOSITORY)
header, result = getRequest(self.harvesterInternalServerPortNumber, '/get', {'verb': 'GetStatus', 'domainId': 'adomain'}, parse=False)
data = JsonDict.loads(result)
self.assertEquals(2, len(data['response']['GetStatus']))
self.assertEquals("adomain", data['request']['domainId'])
def testAddClosingHours(self):
header, body = parseResponse(
asBytes(
self.dna.all.handleRequest(
user=CallTrace(returnValues=dict(isAdmin=True)),
Method='POST',
path='/actions/addRepositoryClosingHours',
Body=bUrlencode(dict(repositoryId='repo-id',
domainId='domain-id',
week="*",
day="1",
startHour="10",
endHour="14"),
doseq=True))))
self.assertEqual('200', header['StatusCode'])
self.assertEqual(dict(success=True), JsonDict.loads(body))
self.assertEqual(1, len(self.observable.calledMethods))
self.assertEqual('addClosingHours',
self.observable.calledMethods[0].name)
self.assertEqual(
{
'day': '1',
'domainId': 'domain-id',
'endHour': '14',
'identifier': 'repo-id',
'startHour': '10',
'week': '*'
}, self.observable.calledMethods[0].kwargs)
def testUpdateRepositoryFieldDefinition(self):
header, body = parseResponse(
asBytes(
self.dna.all.handleRequest(
user=CallTrace(returnValues=dict(isAdmin=True)),
Method='POST',
path='/actions/updateRepositoryFieldDefinitions',
Body=bUrlencode(dict(
identifier='repo-id',
domainId='domain-id',
extra_name="Herman in de zon op een terras",
extra_no_such_field="Bestaat niet"),
doseq=True))))
self.assertEqual('200', header['StatusCode'])
self.assertEqual(dict(success=True), JsonDict.loads(body))
self.assertEqual(1, len(self.observable.calledMethods))
self.assertEqual('updateRepositoryFieldDefinitions',
self.observable.calledMethods[0].name)
self.assertEqual(
{
'identifier': 'repo-id',
'domainId': 'domain-id',
'extra_no_such_field': 'Bestaat niet',
'extra_name': "Herman in de zon op een terras"
}, self.observable.calledMethods[0].kwargs)
def validate(self):
for core in self.cores:
if core == self.resultsFrom:
continue
try:
self._matchCoreSpecs(self.resultsFrom, core)
except KeyError:
raise ValueError("No match set for cores %s" % str(
(self.resultsFrom, core)))
if self.relationalFilterJson:
try:
JsonDict.loads(self.relationalFilterJson)
except JSONDecodeError:
raise ValueError(
"Value '%s' for 'relationalFilterJson' can not be parsed as JSON."
% self.relationalFilterJson)
def testErrorReportedToGustos(self):
baseUrl = join(self.integrationTempdir, "choppy_oai.xml")
filename = "{}?verb=ListRecords&metadataPrefix=oai_dc".format(baseUrl)
with open(filename, "w") as fp:
fp.write("""<?xml version="1.0" encoding="UTF-8"?>
<OAI-PMH xmlns="http://www.openarchives.org/OAI/2.0/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.openarchives.org/OAI/2.0/ http://www.openarchives.org/OAI/2.0/OAI-PMH.xsd"><responseDate>2017-10-31T15:12:52Z</responseDate><request from="2017-10-04T11:52:57Z" metadataPrefix="didl_mods" verb="ListRecords">https://surfsharekit.nl/oai/hhs/</request><ListRecords><record><header><identifier>oai:surfsharekit.nl:b6ea6503-e2fc-4974-8941-2a4a405dc72f</identifier><datestamp>2017-10-04T14:16:22Z</datestamp></header><metadata><didl:DIDL xmlns:didl="urn:mpeg:mpeg21:2002:02-DIDL-NS" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<didl:Item> <didl:Descriptor> <didl:Statement mimeType="application/xml"> <dii:Identifier xmlns:dii="urn:mpeg:mpeg21:2002:01-DII-NS">urn:nbn:nl:hs:18-b6ea6503-e2fc-4974-8941-2a4a405dc72f</dii:Identifier>
</didl:Statement> </didl:Descrip""")
errorCount = len(self.gustosUdpListener.log())
self.saveRepository(DOMAIN,
REPOSITORY,
REPOSITORYGROUP,
baseUrl="file://{}".format(baseUrl))
t = Thread(
target=lambda: self.startHarvester(concurrency=1, runOnce=True))
t.start()
sleepWheel(5)
last_logs = [
JsonDict.loads(l)['data']
for l in self.gustosUdpListener.log()[errorCount:]
]
for data in reversed(last_logs):
my_group_log = data.get(f'Harvester ({DOMAIN})',
{}).get(f'{REPOSITORYGROUP}:{REPOSITORY}')
if my_group_log is not None:
break
self.assertEqual({"count": 1}, my_group_log['errors'])
def testClear(self):
self.startHarvester(repository=REPOSITORY)
self.assertEquals(BATCHSIZE, self.sizeDumpDir())
header, result = getRequest(self.harvesterInternalServerPortNumber, '/get', {'verb': 'GetStatus', 'domainId': DOMAIN, 'repositoryId': REPOSITORY}, parse=False)
data = JsonDict.loads(result)
self.assertEquals(8, data['response']['GetStatus'][0]['total'])
self.saveRepository(DOMAIN, REPOSITORY, REPOSITORYGROUP, action='clear')
self.startHarvester(repository=REPOSITORY)
self.assertEquals(18, self.sizeDumpDir())
for filename in sorted(listdir(self.dumpDir))[-8:]:
self.assertTrue('_delete.updateRequest' in filename, filename)
header, result = getRequest(self.harvesterInternalServerPortNumber, '/get', {'verb': 'GetStatus', 'domainId': DOMAIN, 'repositoryId': REPOSITORY}, parse=False)
self.assertEqual(0, JsonDict.loads(result)['response']['GetStatus'][0]['total'])
def testKeysAll(self):
result = asString(self.dna.all.handleRequest(
path='/service/v2/list',
Method='GET',
arguments={'__all__':['True']}
))
header, body = httpSplit(result)
dictBodyV2 = JsonDict.loads(body)
self.assertEquals(['api_version', 'collections', 'config', 'domain', 'other', 'services', 'software_version'], sorted(dictBodyV2.keys()))
def testRemovingNotListedKeys(self):
result = asString(self.dna.all.handleRequest(
path='/service/v2/list',
Method='GET',
arguments={'keys':['-no']}
))
header, body = httpSplit(result)
dictBodyV2 = JsonDict.loads(body)
self.assertEquals(['api_version', 'config', 'domain', 'services', 'software_version'], sorted(dictBodyV2.keys()))
def testNonexistingKeys(self):
result = asString(self.dna.all.handleRequest(
path='/service/v2/list',
Method='GET',
arguments={'keys':['no']}
))
header, body = httpSplit(result)
dictBodyV2 = JsonDict.loads(body)
self.assertEquals(['api_version', 'config', 'domain', 'errors', 'services', 'software_version'], sorted(dictBodyV2.keys()))
self.assertEquals(["Key 'no' not found."], dictBodyV2['errors'])
def testGetStatusForDomainAndRepositoryId(self):
self.controlHelper(action='allInvalid')
self.startHarvester(repository=REPOSITORY)
header, result = getRequest(self.harvesterInternalServerPortNumber, '/get', {'verb': 'GetStatus', 'domainId': 'adomain', 'repositoryId': 'integrationtest'}, parse=False)
data = JsonDict.loads(result)
self.assertEquals("GetStatus", data['request']['verb'])
self.assertEquals("adomain", data['request']['domainId'])
self.assertEquals("integrationtest", data['request']['repositoryId'])
self.assertEquals("IntegrationTest", data['response']['GetStatus'][0]['repositoryGroupId'])
self.assertEquals(6, data['response']['GetStatus'][0]['invalid'])
def testShouldHaveGlobalConfigForVersion2(self):
result = asString(self.dna.all.handleRequest(
path='/service/v2/list',
arguments={},
Method='GET',
))
header, body = httpSplit(result)
dictBodyV2 = JsonDict.loads(body)
self.assertEquals(['host', 'port'], sorted(dictBodyV2['config'].keys()))
self.assertEquals(['api_version', 'config', 'domain', 'services', 'software_version'], sorted(dictBodyV2.keys()))
def testGetRepository(self):
header, result = getRequest(self.harvesterInternalServerPortNumber,
'/get', {
'verb': 'GetRepository',
'domainId': 'adomain',
'identifier': 'integrationtest'
},
parse=False)
data = JsonDict.loads(result)
self.assertEqual(
"IntegrationTest",
data['response']['GetRepository']['repositoryGroupId'])
def testGetStatusForDomain(self):
self.controlHelper(action='allInvalid')
self.startHarvester(repository=REPOSITORY)
header, result = getRequest(self.harvesterInternalServerPortNumber,
'/get', {
'verb': 'GetStatus',
'domainId': 'adomain'
},
parse=False)
data = JsonDict.loads(result)
self.assertEqual(2, len(data['response']['GetStatus']))
self.assertEqual("adomain", data['request']['domainId'])
def testGetSomethingIsAllowed(self):
dataRetrieve = HarvesterDataRetrieve()
observer = CallTrace('observer', returnValues=dict(getSomething='get something result', listSomething=['a', 'b']))
dataRetrieve.addObserver(observer)
result = asString(dataRetrieve.handleRequest(arguments=dict(verb=['GetSomething'], argument=['value'])))
header, body = result.split(CRLF*2,1)
self.assertEqual(okJson, header+CRLF*2)
self.assertEquals({'request': {
'verb': 'GetSomething', 'argument': 'value',
}, 'response': {'GetSomething': 'get something result'}}, JsonDict.loads(body))
self.assertEquals(['getSomething'], observer.calledMethodNames())
self.assertEquals({'argument': 'value'}, observer.calledMethods[0].kwargs)
def testAllKeys(self):
result = asString(self.dna.all.handleRequest(
path='/service/v2/list',
Method='GET',
arguments={'keys':['collections,other']}
))
header, body = httpSplit(result)
dictBodyV2 = JsonDict.loads(body)
self.assertEquals(['api_version', 'collections', 'config', 'domain', 'other', 'services', 'software_version'], sorted(dictBodyV2.keys()))
self.assertEquals({'collection': {'provenanceSource': 'collection_source', 'enabled': True, 'name': 'collection'}}, dictBodyV2['collections'])
self.assertEquals(['other'], dictBodyV2['other'])
self.assertEquals({'host': 'localhost', 'port': 8000}, dictBodyV2['config'])
self.assertEquals({}, dictBodyV2['services'])
def parseHeaderAndBody(h, b=None, parseBody=True):
if b is None:
h, b = h
header, body = parseResponse(h + CRLF * 2 + b)
if body and parseBody and 'Content-Type' in header['Headers']:
contentType = header['Headers']['Content-Type']
if 'xml' in contentType:
return header, XML(body)
if 'json' in contentType:
try:
return header, JsonDict.loads(body) if body[0] == '{' else JsonList.loads(body)
except JSONDecodeError:
return header, 'JSONDecodeError in: ' + body
return header, body
def _load(self):
if not isfile(self._jsonFilepath):
return {}
data = open(self._jsonFilepath).read().strip()
result = {}
if '[' != data[0]:
for identifier, serviceDict in JsonDict.loads(data).items():
service = Service(domainname=self._domainname, timeout=self._timeout, identifier=identifier, ultimateTimeout=self._ultimateTimeout, **serviceDict)
service.validate()
result[service.identifier] = service
return result
for service in (Service(domainname=self._domainname, timeout=self._timeout, ultimateTimeout=self._ultimateTimeout, **item) for item in JsonList.loads(data)):
service.validate()
result[service.identifier] = service
return result
def testUpdateFieldDefinition_error(self):
header, body = parseResponse(
asBytes(
self.dna.all.handleRequest(
user=CallTrace(returnValues=dict(isAdmin=True)),
Method='POST',
path='/actions/updateFieldDefinition',
Body=bUrlencode(dict(
domainId='domain-id',
fieldDefinition='{"is no json"}',
),
doseq=True))))
self.assertEqual('200', header['StatusCode'])
self.assertEqual(dict(success=False, message='Ongeldige JSON'),
JsonDict.loads(body))
self.assertEqual(0, len(self.observable.calledMethods))
def testNoVerb(self):
dataRetrieve, mockHarvesterData = setupDataRetrieve()
header, body = doRequest(dataRetrieve, argument=['value'])
self.assertEqual(okJson, header + CRLF * 2)
self.assertEqual(
{
'request': {
'argument': 'value'
},
'error': {
'message':
'Value of the verb argument is not a legal verb, the verb argument is missing, or the verb argument is repeated.',
'code': 'badVerb'
}
}, JsonDict.loads(body))
self.assertEqual([], mockHarvesterData.calledMethodNames())
def testErrorInCall(self):
dataRetrieve, mockHarvesterData = setupDataRetrieve(exceptions=dict(
getError=Exception('Bad Bad Bad')))
header, body = doRequest(dataRetrieve, verb=['GetError'])
self.assertEqual(okJson, header + CRLF * 2)
self.assertEqual(
{
'request': {
'verb': 'GetError'
},
'error': {
'message': "Exception('Bad Bad Bad')",
'code': 'unknown'
}
}, JsonDict.loads(body))
self.assertEqual(['getError'], mockHarvesterData.calledMethodNames())
def testGetStatusForDomainAndRepositoryId(self):
self.controlHelper(action='allInvalid')
self.startHarvester(repository=REPOSITORY)
header, result = getRequest(self.harvesterInternalServerPortNumber,
'/get', {
'verb': 'GetStatus',
'domainId': 'adomain',
'repositoryId': 'integrationtest'
},
parse=False)
data = JsonDict.loads(result)
self.assertEqual("GetStatus", data['request']['verb'])
self.assertEqual("adomain", data['request']['domainId'])
self.assertEqual("integrationtest", data['request']['repositoryId'])
self.assertEqual("IntegrationTest",
data['response']['GetStatus'][0]['repositoryGroupId'])
self.assertEqual(6, data['response']['GetStatus'][0]['invalid'])
def testKnownCodeException(self):
dataRetrieve, mockHarvesterData = setupDataRetrieve(exceptions=dict(
getError=Exception('idDoesNotExist')))
header, body = doRequest(dataRetrieve, verb=['GetError'])
self.assertEqual(okJson, header + CRLF * 2)
self.assertEqual(
{
'request': {
'verb': 'GetError'
},
'error': {
'message':
'The value of an argument (id or key) is unknown or illegal.',
'code': 'idDoesNotExist'
}
}, JsonDict.loads(body))
self.assertEqual(['getError'], mockHarvesterData.calledMethodNames())
def testShouldReturnOnlyRequestedKeysWithUpdate(self):
hash = serviceUpdateHash(secret='guessme!', identifier='cc635329-c089-41a8-91be-2a4554851515', type='srv', ipAddress='127.0.0.1', infoport=1234)
postBody = urlencode({
'identifier': 'cc635329-c089-41a8-91be-2a4554851515',
'type': 'srv',
'ipAddress': '127.0.0.1',
'infoport': '1234',
'data': dumps({'VERSION': '2.718281828'}),
'hash': hash,
})
result = ''.join(compose(self.dna.all.handleRequest(
path='/service/v2/update',
Method='POST',
arguments={'keys':['collections']},
Body=postBody,
)))
header, body = httpSplit(result)
dictBodyV2 = JsonDict.loads(body)
self.assertEquals(['api_version', 'collections', 'config', 'domain', 'services', 'software_version', 'this_service'], sorted(dictBodyV2.keys()))
def testGetSomethingIsAllowed(self):
dataRetrieve, mockHarvesterData = setupDataRetrieve(
getSomething='get something result', listSomething=['a', 'b'])
header, body = doRequest(dataRetrieve,
verb=['GetSomething'],
argument=['value'])
self.assertEqual(okJson, header + CRLF * 2)
self.assertEqual(
{
'request': {
'verb': 'GetSomething',
'argument': 'value',
},
'response': {
'GetSomething': 'get something result'
}
}, JsonDict.loads(body))
self.assertEqual(['getSomething'],
mockHarvesterData.calledMethodNames())
self.assertEqual({'argument': 'value'},
mockHarvesterData.calledMethods[0].kwargs)
def _add(self, values, identifier, **kwargs):
self._validate(self, identifier=identifier, **kwargs)
olddata = values.get(identifier, {})
data = dict()
for key in self._register['keys']:
data[key] = kwargs.get(key, [olddata.get(key, '')])[0]
for key in self._register['listKeys']:
data[key] = kwargs.get(key, olddata.get(key, []))
for key in self._register['jsonKeys']:
newdata = kwargs.get(key, [None])[0]
if newdata is None and key in olddata:
data[key] = olddata[key]
continue
data[key] = JsonDict.loads(newdata or '{}')
for key in self._register['booleanKeys']:
data[key] = olddata.get(key, False)
for key in kwargs.get('__booleanKeys__', self._register['booleanKeys']):
if not key:
continue
data[key] = key in kwargs
values[identifier] = data
self._save(values)
def testDeleteClosingHours(self):
header, body = parseResponse(
asBytes(
self.dna.all.handleRequest(
user=CallTrace(returnValues=dict(isAdmin=True)),
Method='POST',
path='/actions/deleteRepositoryClosingHours',
Body=bUrlencode(dict(repositoryId='repo-id',
domainId='domain-id',
closingHour="0"),
doseq=True))))
self.assertEqual('200', header['StatusCode'])
self.assertEqual(dict(success=True), JsonDict.loads(body))
self.assertEqual(1, len(self.observable.calledMethods))
self.assertEqual('deleteClosingHours',
self.observable.calledMethods[0].name)
self.assertEqual(
{
'domainId': 'domain-id',
'identifier': 'repo-id',
'closingHoursIndex': '0'
}, self.observable.calledMethods[0].kwargs)
def testGetUnexisting(self):
dataRetrieve, mockHarvesterData = setupDataRetrieve(
exceptions={'getUnexisting': DeclineMessage()})
header, body = doRequest(dataRetrieve,
verb=['GetUnexisting'],
argument=['value'])
self.assertEqual(okJson, header + CRLF * 2)
self.assertEqual(
{
'request': {
'verb': 'GetUnexisting',
'argument': 'value'
},
'error': {
'message':
'Value of the verb argument is not a legal verb, the verb argument is missing, or the verb argument is repeated.',
'code': 'badVerb'
}
}, JsonDict.loads(body))
self.assertEqual(['getUnexisting'],
mockHarvesterData.calledMethodNames())
self.assertEqual({'argument': 'value'},
mockHarvesterData.calledMethods[0].kwargs)
def _add(self, values, identifier, **kwargs):
self._validate(self, identifier=identifier, **kwargs)
olddata = values.get(identifier, {})
data = dict()
for key in self._register['keys']:
data[key] = kwargs.get(key, [olddata.get(key, '')])[0]
for key in self._register['listKeys']:
data[key] = kwargs.get(key, olddata.get(key, []))
for key in self._register['jsonKeys']:
newdata = kwargs.get(key, [None])[0]
if newdata is None and key in olddata:
data[key] = olddata[key]
continue
data[key] = JsonDict.loads(newdata or '{}')
for key in self._register['booleanKeys']:
data[key] = olddata.get(key, False)
for key in kwargs.get('__booleanKeys__',
self._register['booleanKeys']):
if not key:
continue
data[key] = key in kwargs
values[identifier] = data
self._save(values)
def testUpdateFieldDefinition(self):
header, body = parseResponse(
asBytes(
self.dna.all.handleRequest(
user=CallTrace(returnValues=dict(isAdmin=True)),
Method='POST',
path='/actions/updateFieldDefinition',
Body=bUrlencode(dict(
domainId='domain-id',
fieldDefinition='{"is":"json"}',
),
doseq=True))))
self.assertEqual('200', header['StatusCode'])
self.assertEqual(dict(success=True), JsonDict.loads(body))
self.assertEqual(1, len(self.observable.calledMethods))
self.assertEqual('updateFieldDefinition',
self.observable.calledMethods[0].name)
self.assertEqual({
'domainId': 'domain-id',
'data': {
'is': 'json'
},
}, self.observable.calledMethods[0].kwargs)
def testCreateRepository(self):
header, body = parseResponse(
asBytes(
self.dna.all.handleRequest(
user=CallTrace(returnValues=dict(isAdmin=True)),
Method='POST',
path='/actions/addRepository',
Body=bUrlencode(dict(
identifier='repo-id',
domainId='domain-id',
repositoryGroupId='repositoryGroupId',
),
doseq=True))))
self.assertEqual('200', header['StatusCode'])
self.assertEqual(dict(success=True), JsonDict.loads(body))
self.assertEqual(1, len(self.observable.calledMethods))
self.assertEqual('addRepository',
self.observable.calledMethods[0].name)
self.assertEqual(
{
'domainId': 'domain-id',
'identifier': 'repo-id',
'repositoryGroupId': 'repositoryGroupId'
}, self.observable.calledMethods[0].kwargs)
def _read(self):
result = JsonDict.loads(self._storage.retrieve(self._name))
assert result['version'] == self.version, 'Expected database version %s' % self.version
return result['users']
def testLoads(self):
jd = JsonDict({'hello': 'world'})
jd2 = JsonDict.loads(str(jd))
self.assertEquals(jd, jd2)
def testShouldUpdateServicesOnHttpPostRequest(self):
hash = serviceUpdateHash(secret='guessme!', identifier='cc635329-c089-41a8-91be-2a4554851515', type='srv', ipAddress='127.0.0.1', infoport=1234)
postBody = urlencode({
'identifier': 'cc635329-c089-41a8-91be-2a4554851515',
'type': 'srv',
'ipAddress': '127.0.0.1',
'infoport': '1234',
'hash': hash,
'data': dumps({'error': 1, 'VERSION': '2.718281828'}),
})
result = ''.join(compose(self.dna.all.handleRequest(
path='/service/v2/update',
Method='POST',
arguments={},
Body=postBody,
)))
header, body = httpSplit(result)
dictBody = JsonDict.loads(body)
lastseen = dictBody['services']['cc635329-c089-41a8-91be-2a4554851515']['lastseen']
body = dictBody.pretty_print()
self.assertEquals('HTTP/1.0 200 OK\r\nContent-Type: application/json; charset=utf-8', header)
self.assertEquals(
{
"services": {
"cc635329-c089-41a8-91be-2a4554851515": {
"type": "srv",
"fqdn": "srv0.seecr.nl",
"identifier": "cc635329-c089-41a8-91be-2a4554851515",
"number": 0,
"lastseen": lastseen,
"lastseen_delta": 0,
"active": True,
"ipAddress": "127.0.0.1",
"infoport": 1234,
'readable': False,
'writable': False,
'data': {'error': 1, 'VERSION': '2.718281828'}
}
},
"this_service": {
"type": "srv",
"fqdn": "srv0.seecr.nl",
"identifier": "cc635329-c089-41a8-91be-2a4554851515",
"number": 0,
"lastseen": lastseen,
"lastseen_delta": 0,
"active": True,
"ipAddress": "127.0.0.1",
"infoport": 1234,
'readable': False,
'writable': False,
"state": {
'readable': False,
'writable': False,
},
'data': {'error': 1, 'VERSION': '2.718281828'}
},
"config": {
"host": "localhost",
"port": 8000
},
'api_version': 2,
'software_version': '42',
'domain': 'seecr.nl'
}, loads(body))
result = self.serviceRegistry.listServices()
result['cc635329-c089-41a8-91be-2a4554851515']['lastseen'] = 666.6
self.assertEquals({
'cc635329-c089-41a8-91be-2a4554851515': {
'type': 'srv',
'fqdn': 'srv0.seecr.nl',
"identifier": "cc635329-c089-41a8-91be-2a4554851515",
'number': 0,
'lastseen': 666.6,
"lastseen_delta": 0,
'active': True,
'ipAddress': '127.0.0.1',
'infoport': 1234,
'readable': False,
'writable': False,
'data': {'error': 1, 'VERSION': '2.718281828'}}
}, result)
self.assertEquals(['getConfig'], self.configuration.calledMethodNames())
self.assertEquals(["updateZone"], self.dns.calledMethodNames())
self.assertEquals([((), {'ipAddress': '127.0.0.1', 'fqdn': 'srv0.seecr.nl'})], [(m.args, m.kwargs) for m in self.dns.calledMethods])
def testShouldListMultipleServices(self):
hash = serviceUpdateHash(secret='guessme!', identifier='cc635329-c089-41a8-91be-2a4554851515', type='srv', ipAddress='127.0.0.1', infoport=1234)
postBody = urlencode({
'identifier': 'cc635329-c089-41a8-91be-2a4554851515',
'type': 'srv',
'ipAddress': '127.0.0.1',
'infoport': '1234',
'data': dumps({'VERSION': '2.718281828'}),
'hash': hash,
})
result = ''.join(compose(self.dna.all.handleRequest(
path='/service/v2/update',
Method='POST',
arguments={},
Body=postBody,
)))
hash = serviceUpdateHash(secret='guessme!', identifier='11111111-aaaa-3333-eeee-444444444444', type='nice', ipAddress='128.0.0.8', infoport=6666)
postBody = urlencode({
'identifier': '11111111-aaaa-3333-eeee-444444444444',
'type': 'nice',
'ipAddress': '128.0.0.8',
'infoport': '6666',
'data': dumps({'VERSION': '2.718281828'}),
'hash': hash,
})
result = ''.join(compose(self.dna.all.handleRequest(
path='/service/v2/update',
Method='POST',
arguments={},
Body=postBody,
)))
result = ''.join(compose(self.dna.all.handleRequest(
path='/service/v2/list',
arguments={'identifier': ['11111111-aaaa-3333-eeee-444444444444'], 'allServiceInfo': ['True']},
Method='GET',
)))
header, body = httpSplit(result)
dictBody = JsonDict.loads(body)
lastseenCC = dictBody['services']['cc635329-c089-41a8-91be-2a4554851515']['lastseen']
lastseen11 = dictBody['services']['11111111-aaaa-3333-eeee-444444444444']['lastseen']
body = dictBody.pretty_print()
self.assertEquals('HTTP/1.0 200 OK\r\nContent-Type: application/json; charset=utf-8', header)
self.assertDictEquals(
{
"services": {
"11111111-aaaa-3333-eeee-444444444444": {
"type": "nice",
"fqdn": "nice0.seecr.nl",
"identifier": "11111111-aaaa-3333-eeee-444444444444",
"number": 0,
"lastseen": lastseen11,
"lastseen_delta": 0,
"active": True,
"ipAddress": "128.0.0.8",
"infoport": 6666,
'readable': False,
'writable': False,
"state":{
'readable': False,
'writable': False,
},
'data': {'VERSION': '2.718281828'}
},
"cc635329-c089-41a8-91be-2a4554851515": {
"type": "srv",
"fqdn": "srv0.seecr.nl",
"identifier": "cc635329-c089-41a8-91be-2a4554851515",
"number": 0,
"lastseen": lastseenCC,
"lastseen_delta": 0,
"active": True,
"ipAddress": "127.0.0.1",
"infoport": 1234,
'readable': False,
'writable': False,
"state":{
'readable': False,
'writable': False,
},
'data': {'VERSION': '2.718281828'}
}
},
"config": {
"host": "localhost",
"port": 8000,
},
"this_service": {
"type": "nice",
"fqdn": "nice0.seecr.nl",
"identifier": "11111111-aaaa-3333-eeee-444444444444",
"number": 0,
"lastseen": lastseen11,
"lastseen_delta": 0,
"active": True,
"ipAddress": "128.0.0.8",
"infoport": 6666,
'readable': False,
'writable': False,
"state":{
'readable': False,
'writable': False,
},
'data': {'VERSION': '2.718281828'}
},
'api_version': 2,
'software_version': '42',
'domain': 'seecr.nl'
}, loads(body))
def testLoads(self):
jd = JsonDict({'hello': 'world'})
jd2 = JsonDict.loads(str(jd))
self.assertEquals(jd, jd2)
def _read(self):
result = JsonDict.loads(self._storage.retrieve(self._name))
assert result['version'] == self.version, 'Expected database version %s' % self.version
return result['users']
def testGetRepository(self):
header, result = getRequest(self.harvesterInternalServerPortNumber, '/get', {'verb': 'GetRepository', 'domainId': 'adomain', 'identifier': 'integrationtest'}, parse=False)
data = JsonDict.loads(result)
self.assertEquals("IntegrationTest", data['response']['GetRepository']['repositoryGroupId'])
def testErrorInCall(self):
dataRetrieve = HarvesterDataRetrieve()
observer = CallTrace('observer')
observer.exceptions = dict(getError=Exception('Bad Bad Bad'))
dataRetrieve.addObserver(observer)
result = asString(dataRetrieve.handleRequest(arguments=dict(verb=['GetError'])))
header, body = result.split(CRLF*2,1)
self.assertEqual(okJson, header+CRLF*2)
self.assertEquals({'request': {'verb': 'GetError'}, 'error': {'message': "Exception('Bad Bad Bad',)", 'code': 'unknown'}}, JsonDict.loads(body))
self.assertEquals(['getError'], observer.calledMethodNames())
def handle(self, data):
d = JsonDict.loads(data)
self._cache.update(configuration=d)
yield self.updateConfig(**d)
def testSomethingElseThanGetIsNotAllowed(self):
dataRetrieve = HarvesterDataRetrieve()
observer = CallTrace('observer')
dataRetrieve.addObserver(observer)
result = asString(dataRetrieve.handleRequest(arguments=dict(argument=['value'], verb=['AddObserver'])))
header, body = result.split(CRLF*2,1)
self.assertEqual(okJson, header+CRLF*2)
self.assertEquals({'request': {'verb': 'AddObserver', 'argument': 'value'}, 'error': {'message': 'Value of the verb argument is not a legal verb, the verb argument is missing, or the verb argument is repeated.', 'code': 'badVerb'}}, JsonDict.loads(body))
self.assertEquals([], observer.calledMethodNames())
def testUpdateRepositoryAttributes(self):
header, body = parseResponse(
asBytes(
self.dna.all.handleRequest(
user=CallTrace(returnValues=dict(isAdmin=True)),
Method='POST',
path='/actions/updateRepositoryAttributes',
Body=bUrlencode(dict(
identifier='repo-id',
domainId='domain-id',
userAgent="Herman in de zon op een terras",
),
doseq=True))))
self.assertEqual('200', header['StatusCode'])
self.assertEqual(dict(success=True), JsonDict.loads(body))
self.assertEqual(1, len(self.observable.calledMethods))
self.assertEqual('updateRepositoryAttributes',
self.observable.calledMethods[0].name)
self.assertEqual(
{
'identifier': 'repo-id',
'domainId': 'domain-id',
'baseurl': None,
'set': None,
'metadataPrefix': None,
'userAgent': 'Herman in de zon op een terras',
'collection': None,
'authorizationKey': None,
'mappingId': None,
'targetId': None
}, self.observable.calledMethods[0].kwargs)
header, body = parseResponse(
asBytes(
self.dna.all.handleRequest(
user=CallTrace(returnValues=dict(isAdmin=True)),
Method='POST',
path='/actions/updateRepositoryAttributes',
Body=bUrlencode(dict(
identifier='repo-id',
domainId='domain-id',
userAgent="",
),
doseq=True))))
self.assertEqual('200', header['StatusCode'])
self.assertEqual(dict(success=True), JsonDict.loads(body))
self.assertEqual(2, len(self.observable.calledMethods))
self.assertEqual('updateRepositoryAttributes',
self.observable.calledMethods[1].name)
self.assertEqual(
{
'identifier': 'repo-id',
'domainId': 'domain-id',
'baseurl': None,
'set': None,
'metadataPrefix': None,
'userAgent': None,
'collection': None,
'authorizationKey': None,
'mappingId': None,
'targetId': None
}, self.observable.calledMethods[1].kwargs)
def testGetUnexisting(self):
dataRetrieve = HarvesterDataRetrieve()
observer = CallTrace('observer')
observer.exceptions=dict(getUnexisting=DeclineMessage())
dataRetrieve.addObserver(observer)
result = asString(dataRetrieve.handleRequest(arguments=dict(verb=['GetUnexisting'], argument=['value'])))
header, body = result.split(CRLF*2,1)
self.assertEqual(okJson, header+CRLF*2)
self.assertEquals({'request': {'verb': 'GetUnexisting', 'argument': 'value'}, 'error': {'message': 'Value of the verb argument is not a legal verb, the verb argument is missing, or the verb argument is repeated.', 'code': 'badVerb'}}, JsonDict.loads(body))
self.assertEquals(['getUnexisting'], observer.calledMethodNames())
self.assertEquals({'argument': 'value'}, observer.calledMethods[0].kwargs)
def testKnownCodeException(self):
dataRetrieve = HarvesterDataRetrieve()
observer = CallTrace('observer')
observer.exceptions = dict(getError=Exception('idDoesNotExist'))
dataRetrieve.addObserver(observer)
result = asString(dataRetrieve.handleRequest(arguments=dict(verb=['GetError'])))
header, body = result.split(CRLF*2,1)
self.assertEqual(okJson, header+CRLF*2)
self.assertEquals({'request': {'verb': 'GetError'}, 'error': {'message': 'The value of an argument (id or key) is unknown or illegal.', 'code': 'idDoesNotExist'}}, JsonDict.loads(body))
self.assertEquals(['getError'], observer.calledMethodNames())
