def uploadAsset(self, asset_id, content, params=None):
if params is None:
params = {}
response = self.client.post('/tracker/asset/upload/%s/' % asset_id, params)
url = get_redirect_url(response)
as_file = StringIO()
as_file.write(content)
as_file.seek(0)
as_file.name = 'xxNamexx'
params.update({ 'file': as_file })
response = self.client.post(url, params)
as_file.close()
url = get_redirect_url(response)
self.assertEquals(url, '/tracker/asset/view/%s/' % asset_id)
self.assertContains(self.client.get(url), 'Upload was successful') # Which should show a nice message
def testPasswordChange(self):
self.assertRedirects(self.client.get('/accounts/changepassword/'), 'http://testserver/accounts/login/?next=/accounts/changepassword/') # No accnt
self.doLogin()
self.assertContains(self.client.get('/accounts/changepassword/'), 'Enter a new password for your account')
self.assertContains(self.client.post('/accounts/changepassword/'), 'is required')
self.assertContains(self.client.post('/accounts/changepassword/', {
'password1': 'imzzzzzzzzpossible',
'password2': 'impossible',
}), 'The two password fields didn')
url = get_redirect_url(self.client.post('/accounts/changepassword/', {
'password1': 'impossible',
'password2': 'impossible',
}))
self.assertContains(
self.client.get(url),
'successfully changed',
)
# Fail to login with last password
self.assertFalse(self.client.login(username=self.username, password=self.password))
# Succeed with new one
self.assertTrue(self.client.login(username=self.username, password='******'))
def run_test(add_player):
with ReplaceRepurposing():
response = self.client.post("/tracker/activity/requisition/%s/" % activity_id)
url = get_redirect_url(response)
self.assertContains(self.client.get(url), "successfully")
for i in range(3):
parsed = self.updateInstance(
user="******", admin="admk1", players=0, max_players=10, validation="aproof"
) # Still empty
self.assertEquals(parsed["activity_id"][0], activity_id) # Told to run the activity
instance = get_instance()
self.assertEquals(instance.players, 0)
self.assertEquals(instance.activity, activity) # Still set to that, instance should do that
self.assertEquals(instance.status, ServerInstance.STATUS.Preparing)
for i in range(3):
add_player()
instance = get_instance()
self.assertTrue(instance.players >= 1)
self.assertEquals(instance.activity, activity) # Still running
self.assertEquals(instance.status, ServerInstance.STATUS.Preparing)
for i in range(3):
parsed = self.updateInstance(
user="******", admin="admk1", players=0, max_players=10, validation="aproof"
) # The someone has left
self.assertTrue("activity_id" not in parsed) # NOT told to run the activity
instance = get_instance()
self.assertEquals(instance.players, 0)
self.assertEquals(instance.activity, None) # Freed up
self.assertEquals(instance.requisitioner, None) # Freed up
self.assertEquals(instance.status, ServerInstance.STATUS.Inactive)
def createActivity(self, asset_id):
response = self.client.post('/tracker/activity/new/', {
'asset_id': asset_id,
})
url = get_redirect_url(response)
m = re.match('^/tracker/activity/view/(\w+)/$', url)
if m is None: return None # creation failed, maybe we wanted that
activity_id = m.group(1)
self.assertRedirects(response, '/tracker/activity/view/%s/' % activity_id)
return activity_id
def testActivityDelete(self):
self.doLogin()
asset_id = self.createAsset()
activity_id = self.createActivity(asset_id)
self.assertEqual(len(Activity.objects.filter(uuid=activity_id)), 1) # There now
# Try to delete. Should redirect to a message page
response = self.client.post('/tracker/activity/delete/%s/' % activity_id)
url = get_redirect_url(response)
self.assertEqual(len(Activity.objects.filter(uuid=activity_id)), 0) # No longer there
def test(location, params={}):
full_params = {
'location': location,
'original': AssetInfo.get_emptymap().id,
}
full_params.update(params)
response = self.client.post('/tracker/tools/map_wizard/', full_params)
url = get_redirect_url(response)
self.assertContains(self.client.get(url), 'successfully')
new_asset = AssetInfo.objects.get(location=location) # should exist
assert(new_asset.kb_size == AssetInfo.get_emptymap().kb_size)
new_activity = Activity.objects.get(asset = new_asset) # should exist
def testAsset(self):
self.doLogin()
asset_id = self.createAsset()
asset = AssetInfo.objects.get(uuid=asset_id)
self.assertEquals(asset.kb_size, 0) #No contents yet
# Modify the location
self.assertNotContains(self.client.get('/tracker/asset/view/%s/' % asset_id), '/test/loc/')
self.assertRedirects(self.client.post('/tracker/asset/view/%s/' % asset_id, {
'location': '/test/loc/',
'dependencies': [],
'owners': [self.account.pk],
'type_x': AssetInfo.TYPE.Both,
'comment': '',
}), '/tracker/asset/view/%s/' % asset_id)
self.assertContains(self.client.get('/tracker/asset/view/%s/' % asset_id), '/test/loc/')
# Try an upload. We get redirected to the web page that does the actual upload
# (this might be on a separate asset server, for example)
response = self.client.post('/tracker/asset/upload/%s/' % asset_id)
url = get_redirect_url(response)
# Create dummy binary data
dummy_data = '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x08\x00\x00\x00\x08\x08\x00\x00\x00\x00\xe1d\xe1W\x00\x00\x00\x01sRGB\x00\xae\xce\x1c\xe9\x00\x00\x00\tpHYs\x00\x00\x0b\x13\x00\x00\x0b\x13\x01\x00\x9a\x9c\x18\x00\x00\x00\x07tIME\x07\xd9\x07\x1c\x07(/\xa2\xc9V\x06\x00\x00\x00\x19tEXtComment\x00Created with GIMPW\x81\x0e\x17\x00\x00\x00:IDAT\x08\xd7=\xca\xb1\x11\xc00\x0c\xc3@\x9ekw\x1e@\x1eW3\xa8\xe0\x9e\xa8\x98"\x97\xa0}h7\t\xbd\xd5ep\xb5p\xcd\x94Q\x98s\x86,}\xfd\xe4w\xb6\xaeI\xf0}\x00\xd9m"5sk\x9e\xe2\x00\x00\x00\x00IEND\xaeB`\x82' # An actual PNG file
assert(len(dummy_data) == 205) # Make sure not ascii mangled
self.uploadAsset(asset_id, dummy_data)
asset = AssetInfo.objects.get(uuid=asset_id)
self.assertEquals(asset.kb_size, 1) # 205 bytes, rounded up to 1K
self.assertNotEquals(asset.hash_value, '')
self.assertNotEquals(asset.hash_value, '?')
# Try to download it back. Again we are initially redirected.
response = self.client.post('/tracker/asset/download/%s/' % asset_id)
url = get_redirect_url(response)
self.assertContains(self.client.get(url), dummy_data)
def try_req(fail=None, succeed=None, instance=None):
if succeed is not None:
fail = not succeed
assert(fail is not None)
if fail:
response = self.client.post('/tracker/activity/requisition/%s/' % activity_id)
url = get_redirect_url(response)
self.assertContains(self.client.get(url), 'Could not find')
else:
# We try to repurpose an instance at localhost, this fails with an internal IOError and returns failure
response = self.client.post('/tracker/activity/requisition/%s/' % activity_id)
url = get_redirect_url(response)
self.assertContains(self.client.get(url), 'Could not find')
class Output: pass
def do_it(*args, **kwargs): Output.data = 1567; return True
# Now prevent this error by patching in the class
with ReplaceRepurposing(do_it):
response = self.client.post('/tracker/activity/requisition/%s/' % activity_id)
url = get_redirect_url(response)
self.assertContains(self.client.get(url), 'successfully')
self.assertEquals(Output.data, 1567)
def run_test(add_player):
with ReplaceRepurposing():
response = self.client.post(
'/tracker/activity/requisition/%s/' % activity_id)
url = get_redirect_url(response)
self.assertContains(self.client.get(url), 'successfully')
for i in range(3):
parsed = self.updateInstance(
user='******',
admin='admk1',
players=0,
max_players=10,
validation='aproof') # Still empty
self.assertEquals(parsed['activity_id'][0],
activity_id) # Told to run the activity
instance = get_instance()
self.assertEquals(instance.players, 0)
self.assertEquals(
instance.activity,
activity) # Still set to that, instance should do that
self.assertEquals(instance.status,
ServerInstance.STATUS.Preparing)
for i in range(3):
add_player()
instance = get_instance()
self.assertTrue(instance.players >= 1)
self.assertEquals(instance.activity,
activity) # Still running
self.assertEquals(instance.status,
ServerInstance.STATUS.Preparing)
for i in range(3):
parsed = self.updateInstance(
user='******',
admin='admk1',
players=0,
max_players=10,
validation='aproof') # The someone has left
self.assertTrue(
'activity_id'
not in parsed) # NOT told to run the activity
instance = get_instance()
self.assertEquals(instance.players, 0)
self.assertEquals(instance.activity, None) # Freed up
self.assertEquals(instance.requisitioner, None) # Freed up
self.assertEquals(instance.status,
ServerInstance.STATUS.Inactive)
def createAsset(self):
# Create asset, check success and redirect to right page
response = self.client.post('/tracker/asset/new/')
url = get_redirect_url(response)
m = re.match('^/tracker/asset/view/(\w+)/$', url)
self.assertTrue(m is not None)
asset_id = m.group(1)
self.assertRedirects(response, '/tracker/asset/view/%s/' % asset_id)
self.assertContains(self.client.get('/tracker/asset/view/%s/' % asset_id), 'Upload content')
asset = AssetInfo.objects.get(uuid=asset_id)
global asset_counter
asset.location = 'base/test%d.tar.gz' % asset_counter # Make an activity-friendly asset by default
asset.save()
asset_counter += 1
return asset_id
def test(location, params={}):
full_params = {
'location': location,
'original': AssetInfo.get_emptymap().id,
}
full_params.update(params)
response = self.client.post('/tracker/tools/map_wizard/',
full_params)
url = get_redirect_url(response)
self.assertContains(self.client.get(url), 'successfully')
new_asset = AssetInfo.objects.get(
location=location) # should exist
assert (new_asset.kb_size == AssetInfo.get_emptymap().kb_size)
new_activity = Activity.objects.get(
asset=new_asset) # should exist
def testAssetDelete(self):
self.doLogin()
asset_id = self.createAsset()
self.assertEqual(len(AssetInfo.objects.filter(uuid=asset_id)), 1)
# Upload something
self.uploadAsset(asset_id, 'some dummy data')
# Try to delete. Should redirect to a message page
response = self.client.post('/tracker/asset/delete/%s/' % asset_id)
url = get_redirect_url(response)
self.assertEqual(len(AssetInfo.objects.filter(uuid=asset_id)), 0) # No longer there
# Check no longer in asset storage system either
self.assertRaises(IOError, singleton_send, retrieve_asset, None, asset_uuid=asset_id)
def testAssetClone(self):
self.doLogin()
asset_id = self.createAsset()
dummy_data = '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00'
self.uploadAsset(asset_id, dummy_data)
asset = AssetInfo.objects.get(uuid=asset_id)
dep_asset_id = self.createAsset()
asset.dependencies.add(AssetInfo.objects.get(uuid=dep_asset_id))
asset.save()
# Create a clone
def process_clone_response(response):
url = get_redirect_url(response)
m = re.match('^/tracker/asset/view/(\w+)/$', url)
self.assertTrue(m is not None)
clone_asset_id = m.group(1)
return clone_asset_id
response = self.client.post('/tracker/asset/clone/%s/' % asset_id)
clone_asset_id = process_clone_response(response)
self.assertEquals(asset_id == clone_asset_id, False) # Different uuid
# Check data is ok for both
for curr_asset_id in (asset_id, clone_asset_id):
response = self.client.post('/tracker/asset/download/%s/' % curr_asset_id)
url = get_redirect_url(response)
self.assertContains(self.client.get(url), dummy_data)
asset, clone_asset = map(lambda uuid: AssetInfo.objects.get(uuid=uuid), (asset_id, clone_asset_id))
self.assertEquals(asset.kb_size, clone_asset.kb_size)
self.assertEquals(asset.hash_value, clone_asset.hash_value)
self.assertEquals(set(asset.owners.all()), set(clone_asset.owners.all())) # The original asset was ours, so same ownership
self.assertEquals(asset.dependencies.all()[0].uuid, clone_asset.dependencies.all()[0].uuid)
# Ownership: new asset is new user's, and new user's alone, not old one
emptymap_asset = AssetInfo.objects.get(location='base/emptymap.tar.gz')
response = self.client.post('/tracker/asset/clone/%s/' % emptymap_asset.uuid)
clone_asset_id = process_clone_response(response)
clone_asset = AssetInfo.objects.get(uuid=clone_asset_id)
self.assertNotEquals(emptymap_asset.owners, clone_asset.owners)
self.assertEquals([owner.uuid for owner in clone_asset.owners.all()], [self.account.uuid])
def testErrorLogSaving(self):
self.doLogin()
asset_id = self.createAsset()
activity_id = self.createActivity(asset_id)
with FakeInstanceValidation('aproof'):
instance_id = self.createInstance(user='******', admin='admk1', players=0, max_players=10, validation='aproof')
def get_instance():
return ServerInstance.objects.get(uuid=instance_id)
for i in range(4):
last_error_log_index = get_last_error_log_index(self.account)
with ReplaceRepurposing():
response = self.client.post('/tracker/activity/requisition/%s/' % activity_id)
url = get_redirect_url(response)
self.assertContains(self.client.get(url), 'successfully')
with IntensityConfSetting('Email', 'username', ''): # Disable normal email
response = self.client.post('/instance/uploadlog', {
'instance_id': instance_id,
'session_id': get_instance().session_id,
'error_log': '1234onluggage' + str(i),
})
self.assertEqual(last_error_log_index + 1, get_last_error_log_index(self.account)) # added one log
self.assertTrue('1234onluggage' + str(i) in get_error_log(self.account, get_last_error_log_index(self.account))) # content is there
self.assertContains(
self.client.get('/tracker/account/error_log/view/%d/' % get_last_error_log_index(self.account)),
'1234onluggage' + str(i)
) # View via web
self.assertContains(self.client.get('/tracker/account/error_log/view/'), '1234onluggage' + str(i)) # No arg, get last -this
def process_clone_response(response):
url = get_redirect_url(response)
m = re.match('^/tracker/asset/view/(\w+)/$', url)
self.assertTrue(m is not None)
clone_asset_id = m.group(1)
return clone_asset_id
def testRequisitionServerInstance(self):
self.doLogin()
asset_id = self.createAsset()
activity_id = self.createActivity(asset_id)
def try_req(fail=None, succeed=None, instance=None):
if succeed is not None:
fail = not succeed
assert(fail is not None)
if fail:
response = self.client.post('/tracker/activity/requisition/%s/' % activity_id)
url = get_redirect_url(response)
self.assertContains(self.client.get(url), 'Could not find')
else:
# We try to repurpose an instance at localhost, this fails with an internal IOError and returns failure
response = self.client.post('/tracker/activity/requisition/%s/' % activity_id)
url = get_redirect_url(response)
self.assertContains(self.client.get(url), 'Could not find')
class Output: pass
def do_it(*args, **kwargs): Output.data = 1567; return True
# Now prevent this error by patching in the class
with ReplaceRepurposing(do_it):
response = self.client.post('/tracker/activity/requisition/%s/' % activity_id)
url = get_redirect_url(response)
self.assertContains(self.client.get(url), 'successfully')
self.assertEquals(Output.data, 1567)
try_req(fail=True) # Fail, as no server instances
# Add a valid server instance
params = {
'user_interface': 'someplace.com:8888',
'admin_interface': 'admikal_irk',
'players': 8,
'max_players': 22,
'validation': 'proofz',
'version': INTENSITY_VERSION_STRING,
}
response = self.client.get('/instance/update', params)
instance = ServerInstance.objects.get(user_interface='someplace.com:8888')
try_req(fail=True) # Fail, as no Pooled server instances (it cannot validate)
# Validate one, but keep it active - not free for reqqing
with FakeInstanceValidation():
response = self.client.get('/instance/update', params)
instance = ServerInstance.objects.get(user_interface='someplace.com:8888')
instance.status = ServerInstance.STATUS.Active
instance.save()
try_req(fail=True) # Fail, as no server instances - the validated one is already active
# And now we should succeed
instance.status = ServerInstance.STATUS.Inactive
instance.save()
try_req(succeed=True, instance=instance)
instance = ServerInstance.objects.get(user_interface='someplace.com:8888')
self.assertEquals(instance.status, ServerInstance.STATUS.Preparing)
self.assertEquals(instance.requisitioner, self.account)
self.assertEquals(instance.activity, Activity.objects.get(uuid=activity_id))
# Unreq
response = self.client.post('/tracker/instance/unrequisition/%s/' % instance.uuid)
url = get_redirect_url(response)
self.assertContains(self.client.get(url), 'successfully')
instance = ServerInstance.objects.get(user_interface='someplace.com:8888')
self.assertEquals(instance.status, ServerInstance.STATUS.Inactive)
self.assertEquals(instance.requisitioner, None)
self.assertEquals(instance.activity, None)
def testInstanceUploadLog(self):
# Make instance
instance_id = self.createInstance('uzer', 'admik', 5, 17)
session_id = ServerInstance.objects.get(user_interface='uzer').session_id
class Content:
emails = []
def adder(sender, **kwargs):
Content.emails.append(kwargs['body'])
instance = ServerInstance.objects.get(uuid=instance_id)
instance.status = ServerInstance.STATUS.Active
with EmailSender(adder): # Add 'dummy' emailer for testing
with IntensityConfSetting('Email', 'username', ''): # Disable normal email
response = self.client.post('/instance/uploadlog', {
'instance_id': instance_id,
'session_id': session_id,
'error_log': '1234onluggage',
})
self.assertEquals(len(Content.emails), 1)
self.assertTrue('1234onluggage' in Content.emails[0])
self.assertTrue(self.username not in Content.emails[0]) # Didn't requisition
instance = ServerInstance.objects.get(uuid=instance_id)
self.assertEquals(instance.status, ServerInstance.STATUS.Inactive) # Has been deactivated after crash
# With requisition, want username
self.doLogin()
asset_id = self.createAsset()
activity_id = self.createActivity(asset_id)
params = {
'user_interface': 'someplace.com:8888',
'admin_interface': 'admikal_irk',
'players': 8,
'max_players': 22,
'validation': 'proofz',
'version': INTENSITY_VERSION_STRING,
}
with FakeInstanceValidation():
response = self.client.get('/instance/update', params)
instance = ServerInstance.objects.get(user_interface='someplace.com:8888')
instance.status = ServerInstance.STATUS.Inactive
instance.save()
with ReplaceRepurposing():
response = self.client.post('/tracker/activity/requisition/%s/' % activity_id)
instance = ServerInstance.objects.get(user_interface='someplace.com:8888')
url = get_redirect_url(response)
self.assertContains(self.client.get(url), 'successfully')
instance = ServerInstance.objects.get(user_interface='someplace.com:8888')
with IntensityConfSetting('Email', 'username', ''): # Disable normal email
response = self.client.post('/instance/uploadlog', {
'instance_id': instance.uuid,
'session_id': instance.session_id,
'error_log': '1234onluggage',
})
self.assertTrue(self.username in Content.emails[1]) # Name appears
