def setup(self):
self.buildpack = BuildPack(repo_url=randchars(),
repo_type='git',
order=1)
self.buildpack.save()
self.app = App(name=randchars(),
repo_url=randchars(),
repo_type='hg',
buildpack=self.buildpack)
self.app.save()
self.image_name = 'ubuntu_precise'
self.image_filepath = os.path.join(self.image_name, 'ubuntu.tar.gz')
self.image_md5 = 'abcdef1234567890'
self.os_image = OSImage(name=self.image_name, file=self.image_filepath)
with mock.patch.object(OSImage,
'_compute_file_md5',
return_value=self.image_md5):
self.os_image.save()
self.version = 'v1'
self.build = Build(
app=self.app,
os_image=self.os_image,
tag=self.version,
)
self.build.save()
def test_swarm_creates_release(self):
# Make an existing release to save with the swarm.
squad = Squad(name=randchars())
squad.save()
release = Release(build=self.build,
env_yaml=self.env,
config_yaml=self.config,
volumes=self.volumes)
release.save()
release_count = Release.objects.count()
swarm = Swarm(app=self.app,
release=release,
config_name=randchars(),
proc_name=randchars(),
squad=squad,
size=1,
config_yaml=self.config,
env_yaml=self.env,
volumes=self.volumes)
swarm.save()
# update the swarm with new config.
swarm.config_yaml = self.config.update({'c': 3})
swarm.save()
# get_current_release should make a new release for us from the new
# config.
r = swarm.get_current_release(self.version)
assert Release.objects.count() == release_count + 1
assert r.id != release.id
def simple_app(self, postgresql):
app = models.App(
name=randchars(),
repo_url=randchars(),
repo_type=randchars(),
)
app.save()
return app
def setup(self):
self.stack = OSStack(name=randchars(), desc=randchars())
self.stack.save()
self.os_image = OSImage(name=randchars(),
stack=self.stack,
active=True)
with mock.patch.object(OSImage,
'_compute_file_md5',
return_value='abcdef1234567890'):
self.os_image.save()
self.app = App(name=randchars(),
repo_url=randchars(),
repo_type='hg',
stack=self.stack)
self.app.save()
self.version = 'v1'
self.build = Build(app=self.app,
os_image=self.os_image,
start_time=timezone.now(),
end_time=timezone.now(),
tag=self.version,
status='success',
buildpack_url=randchars(),
buildpack_version=randchars(),
hash=randchars())
self.build.save()
self.env = {'a': 1}
self.config = {'b': 2}
self.volumes = [['/foo', '/bar'], ['/baz', '/quux']]
def test_release_config_marshaling(postgresql):
app = models.App(name=randchars(), repo_url=randchars(), repo_type='git')
app.save()
b = models.Build(
app=app,
tag=randchars(),
)
b.save()
release = models.Release(
build=b,
config_yaml=None,
# numbers can only be 32 bit in xmlrpc
env_yaml='FACEBOOK_APP_ID: 1234123412341234')
with pytest.raises(ValidationError):
release.save()
def get_user():
u = User(username=randchars())
u.set_password('password123')
u.is_admin = True
u.is_staff = True
u.save()
return u
def test_config_ingredient_marshaling():
ci = models.ConfigIngredient(
name=randchars(),
config_yaml='1: integer keys are not allowed in XMLRPC',
env_yaml=None,
)
with pytest.raises(ValidationError):
ci.save()
def test_new_osimage_invalidates_release(self):
# If you have a swarm with a current release, and you get a new OS
# image on the app's stack, then call get_current_release on the swarm,
# it should give you a new release with a build linked to the new OS
# image.
squad = Squad(name=randchars())
squad.save()
release = Release(build=self.build,
env_yaml=self.env,
config_yaml=self.config,
volumes=self.volumes)
release.save()
swarm = Swarm(app=self.app,
release=release,
config_name=randchars(),
proc_name=randchars(),
squad=squad,
size=1,
config_yaml=self.config,
env_yaml=self.env,
volumes=self.volumes)
swarm.save()
assert swarm.get_current_release(self.version) == release
# Now save a new OS Image to the stack, and assert that we get a new
# release.
new_image = OSImage(name=randchars(),
file=randchars(),
stack=self.stack,
active=True)
with mock.patch.object(OSImage,
'_compute_file_md5',
return_value='abcdef1234567890'):
new_image.save()
new_release = swarm.get_current_release(self.version)
assert new_release != release
assert new_release.build.os_image == new_image
def temp_dir():
"""
Yield a temporary directory on a remote host as the current dir.
"""
target = '/tmp/' + randchars()
sudo('mkdir -p ' + target)
with cd(target):
try:
yield target
finally:
sudo('rm -rf ' + target)
def test_config_xmlrpc_marshaling(postgresql):
u = get_user()
c = BasicAuthClient(u.username, 'password123')
url = get_api_url('ingredients', 'api_dispatch_list')
# data = json.dumps({'config_yaml': {1: 'int key'}})
# data = json.dumps({'config_yaml': '"bigint": 123412341234}'})
data = json.dumps({
'name': randchars(),
'config_yaml': "{'really_big_int': 1234123412341234}"
})
resp = c.post(url, data=data, content_type='application/json')
assert "int exceeds XML-RPC limits" in resp.content.decode('utf-8')
def test_swarm_with_stack_reuses_release(self):
squad = Squad(name=randchars())
squad.save()
release = Release(build=self.build,
env_yaml=self.env,
config_yaml=self.config,
volumes=self.volumes)
release.save()
swarm = Swarm(app=self.app,
release=release,
config_name=randchars(),
proc_name=randchars(),
squad=squad,
size=1,
config_yaml=self.config,
env_yaml=self.env,
volumes=self.volumes)
swarm.save()
assert swarm.get_current_release(self.version) == release
def setup_method(self, method):
self.app = models.App(
name=randchars(),
repo_url=randchars(),
repo_type=randchars(),
)
self.app.save()
self.build = models.Build(
app=self.app,
tag=randchars(),
file=randchars(),
status='success',
hash=randchars(),
)
self.build.save()
self.release = models.Release(
build=self.build,
config_yaml='',
env_yaml='',
hash=randchars(),
)
self.release.save()
self.squad = models.Squad(name=randchars())
self.squad.save()
# create a swarm object
self.swarm = models.Swarm(
app=self.app,
release=self.release,
config_name=randchars(),
proc_name='web',
squad=self.squad,
)
self.swarm.save()
# Get a logged in client ready
self.user = get_user()
self.client = Client()
data = dict(username=self.user.username, password='******')
self.client.post(reverse('login'), data)
def test_build_unusable_status(gridfs):
app_url = randurl()
a = models.App(name=randchars(), repo_url=app_url, repo_type='hg')
a.save()
with somefile() as f:
b = models.Build(
app=a,
tag='blah',
start_time=timezone.now() - relativedelta(minutes=2),
end_time=timezone.now() - relativedelta(minutes=1),
file=File(f),
status='',
)
b.save()
assert b.is_usable() is False
def test_dashboard_app_update_redirection(self, redis):
"""
Test that after swarming an app that belongs to the user's default
dashboard, he/she gets redirected to /dashboard/.
See self.setUp() for more info.
"""
url = reverse('edit_swarm', kwargs={'swarm_id': self.swarm2.id})
payload = {
'app_id':
self.swarm2.app.id,
'os_image_id':
getattr(self.swarm2.release.build.os_image, 'id', ''),
'squad_id':
self.swarm2.squad.id,
'tag':
randchars(),
'config_name':
self.swarm2.config_name,
'config_yaml':
yamlize(self.swarm2.config_yaml),
'env_yaml':
yamlize(self.swarm2.env_yaml),
'volumes':
yamlize(self.swarm2.volumes),
'run_as':
self.swarm2.run_as or 'nobody',
'mem_limit':
self.swarm2.mem_limit,
'memsw_limit':
self.swarm2.memsw_limit,
'proc_name':
self.swarm2.proc_name,
'size':
self.swarm2.size,
'pool':
self.swarm2.pool or '',
'balancer':
'',
'config_ingredients':
[ing.pk for ing in self.swarm2.config_ingredients.all()]
}
resp = self.client.post(url, data=payload)
assert resp._headers['location'][1] == 'http://testserver/dashboard/'
def test_simple_update(self, redis):
url = reverse('edit_swarm', kwargs={'swarm_id': self.swarm.id})
payload = {
'app_id':
self.swarm.app.id,
'os_image_id':
getattr(self.swarm.release.build.os_image, 'id', ''),
'squad_id':
self.swarm.squad.id,
'tag':
randchars(),
'config_name':
self.swarm.config_name,
'config_yaml':
yamlize(self.swarm.config_yaml),
'env_yaml':
yamlize(self.swarm.env_yaml),
'volumes':
yamlize(self.swarm.volumes),
'run_as':
self.swarm.run_as or 'nobody',
'mem_limit':
self.swarm.mem_limit,
'memsw_limit':
self.swarm.memsw_limit,
'proc_name':
self.swarm.proc_name,
'size':
self.swarm.size,
'pool':
self.swarm.pool or '',
'balancer':
'',
'config_ingredients':
[ing.pk for ing in self.swarm.config_ingredients.all()]
}
previous_release_id = self.swarm.release_id
self.client.post(url, data=payload)
saved = models.Swarm.objects.get(id=self.swarm.id)
new_release_id = saved.release_id
assert previous_release_id != new_release_id
def test_env_yaml_marshaling(self):
url = reverse('edit_swarm', kwargs={'swarm_id': self.swarm.id})
payload = {
'app_id':
self.swarm.app.id,
'os_image_id':
getattr(self.swarm.release.build.os_image, 'id', ''),
'squad_id':
self.swarm.squad.id,
'tag':
randchars(),
'config_name':
self.swarm.config_name,
'config_yaml':
yamlize(self.swarm.config_yaml),
'env_yaml':
'TOO_BIG_NUMBER: 1234123412341234',
'volumes':
yamlize(self.swarm.volumes),
'run_as':
self.swarm.run_as or 'nobody',
'mem_limit':
self.swarm.mem_limit,
'memsw_limit':
self.swarm.memsw_limit,
'proc_name':
self.swarm.proc_name,
'size':
self.swarm.size,
'pool':
self.swarm.pool or '',
'balancer':
'',
'config_ingredients':
[ing.pk for ing in self.swarm.config_ingredients.all()]
}
resp = self.client.post(url, data=payload)
assert "Cannot be marshalled to XMLRPC" in resp.content
def test_swarm_without_stack_reuses_release(self):
self.app = App(name=randchars(), repo_url=randchars(), repo_type='hg')
self.app.save()
self.build = Build(app=self.app,
os_image=None,
start_time=timezone.now(),
end_time=timezone.now(),
tag=self.version,
status='success',
buildpack_url=randchars(),
buildpack_version=randchars(),
hash=randchars())
self.build.save()
squad = Squad(name=randchars())
squad.save()
release = Release(build=self.build,
env_yaml=self.env,
config_yaml=self.config,
volumes=self.volumes)
release.save()
swarm = Swarm(app=self.app,
release=release,
config_name=randchars(),
proc_name=randchars(),
squad=squad,
size=1,
config_yaml=self.config,
env_yaml=self.env,
volumes=self.volumes)
swarm.save()
assert swarm.get_current_release(self.version) == release
def test_update_with_ingredient(self):
ing = models.ConfigIngredient(
name=randchars(),
config_yaml='',
env_yaml='',
)
ing.save()
self.swarm.config_ingredients.add(ing)
url = get_api_url('swarms', 'api_dispatch_detail', pk=self.swarm.id)
resp = self.client.get(url)
doc = json.loads(resp.content)
assert doc['config_name'] == self.swarm.config_name
# make a change, PUT it, and assert that it's in the DB.
doc['config_name'] = 'test_config_name'
payload = json.dumps(doc)
resp = self.client.put(url,
data=payload,
content_type='application/json')
saved = models.Swarm.objects.get(id=self.swarm.id)
assert saved.config_name == 'test_config_name'
def test_swarm_config_marshaling(postgresql):
app = models.App(name=randchars(), repo_url=randchars(), repo_type='git')
app.save()
b = models.Build(
app=app,
tag=randchars(),
)
b.save()
release = models.Release(build=b, )
release.save()
squad = models.Squad(name=randchars())
swarm = models.Swarm(
app=app,
release=release,
config_name=randchars(),
proc_name=randchars(),
squad=squad,
config_yaml='1: integer key!',
)
with pytest.raises(ValidationError):
swarm.save()
def setup(self):
self.app = App(name=randchars(), repo_url=randchars(), repo_type='hg')
self.app.save()
self.version = 'v1'
self.build = Build(app=self.app,
start_time=timezone.now(),
end_time=timezone.now(),
tag=self.version,
status='success',
buildpack_url=randchars(),
buildpack_version=randchars(),
hash=randchars())
self.build.file = '%s/build.tar.gz' % randchars()
self.build.save()
self.env = {'a': 1}
self.config = {'b': 2, 'tricky_value': "@We're testing, aren't we?"}
self.volumes = [['/blah', '/blerg']]
self.release = Release(build=self.build,
env_yaml=self.env,
config_yaml=self.config,
volumes=self.volumes)
self.release.save()
def randurl():
return 'http://%s/%s' % (randchars(), randchars())
def setup(self):
self.app = models.App(
name=randchars(),
repo_url=randchars(),
repo_type=randchars(),
)
self.app.save()
self.app2 = models.App(
name=randchars(),
repo_url=randchars(),
repo_type=randchars(),
)
self.app2.save()
self.build = models.Build(
app=self.app,
tag=randchars(),
file=randchars(),
status='success',
hash=randchars(),
)
self.build.save()
self.build2 = models.Build(
app=self.app2,
tag=randchars(),
file=randchars(),
status='success',
hash=randchars(),
)
self.build2.save()
self.release = models.Release(
build=self.build,
config_yaml='',
env_yaml='',
hash=randchars(),
)
self.release.save()
self.release2 = models.Release(
build=self.build2,
config_yaml='',
env_yaml='',
hash=randchars(),
)
self.release2.save()
self.squad = models.Squad(name=randchars())
self.squad.save()
# create a swarm object
self.swarm = models.Swarm(
app=self.app,
release=self.release,
config_name=randchars(),
proc_name='web',
squad=self.squad,
)
self.swarm.save()
self.swarm2 = models.Swarm(
app=self.app2,
release=self.release2,
config_name=randchars(),
proc_name='web',
squad=self.squad,
)
self.swarm2.save()
dashboard_name = randchars()
self.dashboard = models.Dashboard(
name=dashboard_name,
slug=slugify(dashboard_name),
)
self.dashboard.save()
self.dashboard.apps.add(self.app2)
# Get a logged in client ready
self.user = get_user()
models.UserProfile.objects.create(user=self.user)
self.user.userprofile.default_dashboard = self.dashboard
self.user.userprofile.save()
self.client = Client()
self.client.post(reverse('login'), {
'username': self.user.username,
'password': '******'
})
