def test_get_projects_as_anonymous(self):
ProjectFactory.create_batch(size=5)
url = reverse('project-list')
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(response.data, {'detail': 'Authentication credentials were not provided.'})
def setUp(self):
super(TestAggregates, self).setUp()
self.user = UserFactory()
self.userdata = UserData.objects.create(user=self.user)
self.billable_code = AccountingCodeFactory(billable=True)
self.nonbillable_code = AccountingCodeFactory(billable=False)
self.billable_project = ProjectFactory(
accounting_code=self.billable_code)
self.nonbillable_project = ProjectFactory(
accounting_code=self.nonbillable_code)
self.period = ReportingPeriodFactory(
start_date=datetime.datetime(2015, 11, 1))
self.timecard = TimecardFactory(user=self.user,
reporting_period=self.period)
self.grade = EmployeeGrade.objects.create(
employee=self.user,
grade=15,
g_start_date=datetime.datetime(2016, 1, 1))
self.timecard_objects = [
TimecardObjectFactory(
timecard=self.timecard,
project=self.billable_project,
hours_spent=15,
grade=self.grade,
),
TimecardObjectFactory(timecard=self.timecard,
project=self.nonbillable_project,
hours_spent=5,
grade=self.grade),
]
def test_get_env(self):
project = ProjectFactory()
ProjectConfigFactory(project=project)
build = ProjectBuildFactory(project=project)
release = ProjectReleaseFactory(build=build)
env = release.get_env()
for key, value in project.get_configs().items():
self.assertTrue(key in env)
self.assertEqual(env[key], value)
def test_unauthenticated():
ProjectFactory.create_batch(10, public=True)
ProjectFactory.create_batch(10, public=False)
view = ProjectList.as_view()
factory = APIRequestFactory()
request = factory.get('/projects/api/projects')
response = view(request)
assert len(response.data) == 10
def _create_projects(self):
"""
"""
count = randint(5, 10)
for i in range(count):
ProjectFactory.create(tags=(self.tags[i]
for i in range(randint(1, 10))))
print("Created {0} Projects".format(count))
def _create_projects(self):
"""
"""
count = randint(5, 10)
for i in range(count):
ProjectFactory.create(
tags=(self.tags[i] for i in range(randint(1, 10))))
print("Created {0} Projects".format(count))
def test_get_projects_as_admin(self):
ProjectFactory.create_batch(size=5)
user = AdminFactory()
self.client.force_login(user)
url = reverse('project-list')
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 0)
self.assertEqual(len(Project.objects.available_for_user(user)), len(response.data))
def test_project_config_with_addons(self):
project = ProjectFactory()
mysql = AddonMySQLFactory()
mysql.attach(project)
pa = ProjectAddon.objects.get(project=project, addon=mysql)
configs = project.get_configs()
for key, value in mysql.get_config(primary=pa.primary,
alias=pa.alias).items():
self.assertIn(key, configs.keys())
self.assertEqual(value, configs[key])
def test_get_labels(self):
project = ProjectFactory(name="demo")
build = ProjectBuildFactory(project=project)
release = ProjectReleaseFactory(build=build)
labels = release.get_labels()
keys = labels.keys()
self.assertTrue("HAPROXY_GROUP" in keys)
self.assertEqual(labels["HAPROXY_GROUP"], "external")
self.assertTrue("HAPROXY_0_VHOST" in keys)
self.assertEqual(labels["HAPROXY_0_VHOST"], release.project.vhost)
self.assertFalse("HAPROXY_0_REDIRECT_TO_HTTPS" in keys)
self.assertFalse("HAPROXY_0_USE_HSTS" in keys)
demo = Project.objects.get(name="demo")
demo.redirect_https = True
demo.use_hsts = True
demo.save()
build = ProjectBuildFactory(project=demo)
release = ProjectReleaseFactory(build=build)
labels = release.get_labels()
keys = labels.keys()
self.assertTrue("HAPROXY_0_REDIRECT_TO_HTTPS" in keys)
self.assertEqual(labels["HAPROXY_0_REDIRECT_TO_HTTPS"], "true")
self.assertTrue("HAPROXY_0_USE_HSTS" in keys)
self.assertEqual(labels["HAPROXY_0_USE_HSTS"], "true")
def test_get_volumes(self):
user = CustomUserFactory()
project = ProjectFactory(user=user)
build = ProjectBuildFactory(project=project)
release = ProjectReleaseFactory(build=build)
self.assertEqual(release.get_volumes(), [])
self.assertEqual(release.container_paths, [])
host_path = "/app/host_path"
container_path = "/app/container_path"
volume = ProjectVolumeFactory(project=project, host_path="")
self.assertEqual(ProjectVolume.objects.count(), 1)
self.assertIn(volume, release.container_paths)
hostpath = os.path.join("/mnt/container-volumes/",
release.get_marathon_app_id(),
volume.container_path.strip('/'))
self.assertEqual(hostpath, release.get_volumes()[0].host_path)
self.assertEqual(ProjectVolume.MODE.RW, release.get_volumes()[0].mode)
volume.delete()
volume = ProjectVolumeFactory(project=project,
host_path=host_path,
container_path=container_path,
mode=ProjectVolume.MODE.RO)
self.assertEqual(ProjectVolume.objects.count(), 1)
self.assertIn(volume, release.container_paths)
self.assertIn(volume.host_path, release.get_volumes()[0].host_path)
self.assertEqual(ProjectVolume.MODE.RO, release.get_volumes()[0].mode)
def test_is_micropurchase(self):
iaa = IAAFactory(budget=500000)
project = ProjectFactory(iaa=iaa, non_cogs_amount=300000)
buy = BuyFactory(project=project, budget=2000)
assert buy.is_micropurchase() is True
buy.budget = 3500
assert buy.is_micropurchase() is True
buy.budget = 3501
assert buy.is_micropurchase() is False
def test_get_project_as_admin(self):
project, *_ = ProjectFactory.create_batch(size=5)
url = reverse('project-detail', args=(project.pk,))
user = AdminFactory()
self.client.force_login(user)
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(len(Project.objects.available_for_user(user)), 0)
def test_resource(self):
mem = 1024
cpus = 2
instances = 3
project = ProjectFactory(mem=mem, cpus=cpus, instances=instances)
build = ProjectBuildFactory(project=project)
release = ProjectReleaseFactory(build=build)
self.assertEqual(release.get_mem(), mem)
self.assertEqual(release.get_cpus(), cpus)
self.assertEqual(release.get_instances(), instances)
def test_authenticated():
ProjectFactory.create_batch(10, public=True)
ProjectFactory.create_batch(10, public=False)
# Create a user
user = UserFactory.create()
# Get required permission
content_type = ContentType.objects.get_for_model(Project)
permission = Permission.objects.get(
codename='view_project',
content_type=content_type,
)
user.user_permissions.add(permission)
# Make authenticated request
view = ProjectList.as_view()
factory = APIRequestFactory()
request = factory.get('/projects/api/projects')
force_authenticate(request, user=user)
response = view(request)
assert len(response.data) == 20
def test_is_under_sat(self):
iaa = IAAFactory(budget=500000)
project = ProjectFactory(iaa=iaa, non_cogs_amount=300000)
buy = BuyFactory(project=project, budget=2000)
assert buy.is_under_sat() is True
buy.budget = 15000
assert buy.is_under_sat() is True
buy.budget = 150000
assert buy.is_under_sat() is True
buy.budget = 150001
assert buy.is_under_sat() is False
def test_get_projects_as_owner(self):
project, *_ = ProjectFactory.create_batch(size=4)
self.client.force_login(project.owner)
url = reverse('project-list')
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(Project.objects.filter(owner=project.owner).count(), len(response.data))
self.assertEqual(Project.objects.available_for_user(project.owner).count(), len(response.data))
self.assertEqual(project.name, response.data[0]['name'])
def test_create_buy_form():
project = ProjectFactory.create()
procurement_method = ProcurementMethodFactory.create()
data = {
"name": "New Buy",
"description": "This is a new buy for things",
"budget": 50,
"project": project.id,
"procurement_method": procurement_method.id
}
form = CreateBuyForm(data)
assert form.is_valid(), form.errors
def handle(self, *args, **options):
# Creates an admin with the credentials `admin // admin`
admin = AdminFactory()
user = UserFactory()
# Creates a first project with admin as an admin
project = ProjectFactory()
ProjectMemberRoleFactory(user=admin, project=project)
ProjectMemberRoleFactory(user=user, project=project, is_admin=False)
parameters_project = ProjectAuditParametersFactory(project=project)
parameters2_project = ProjectAuditParametersFactory(
project=project,
name="Dulles | Chrome | 3G",
network_shape=NetworkShapeOptions.THREE_G.name,
)
page = PageFactory(project=project)
page2 = PageFactory(project=project, name="Docs")
# Creates a month worth of audits, with history and results
for day in range(0, 30):
audit = AuditFactory(parameters=parameters_project, page=page)
timestamp = datetime.now(
pytz.timezone("Europe/Paris")) - timedelta(days=day)
Audit.objects.filter(pk=audit.pk).update(created_at=timestamp)
AuditStatusHistoryFactory(audit=audit)
results = AuditResultsFactory(audit=audit)
AuditResults.objects.filter(pk=results.pk).update(
created_at=timestamp)
audit2 = AuditFactory(parameters=parameters2_project, page=page)
Audit.objects.filter(pk=audit2.pk).update(created_at=timestamp)
AuditStatusHistoryFactory(audit=audit2)
results2 = AuditResultsFactory(audit=audit2)
AuditResults.objects.filter(pk=results2.pk).update(
created_at=timestamp)
audit3 = AuditFactory(parameters=parameters_project, page=page2)
Audit.objects.filter(pk=audit3.pk).update(created_at=timestamp)
AuditStatusHistoryFactory(audit=audit3)
results3 = AuditResultsFactory(audit=audit3)
AuditResults.objects.filter(pk=results3.pk).update(
created_at=timestamp)
audit4 = AuditFactory(parameters=parameters2_project, page=page2)
Audit.objects.filter(pk=audit4.pk).update(created_at=timestamp)
AuditStatusHistoryFactory(audit=audit4)
results4 = AuditResultsFactory(audit=audit4)
AuditResults.objects.filter(pk=results4.pk).update(
created_at=timestamp)
def handle(self, *args, **options):
call_command('migrate')
call_command('makemigrations')
users_number = options['users_number']
projects_number = options['projects_number']
users_list = []
can_skill = True
while can_skill:
try:
SkillFactory()
except IntegrityError:
can_skill = False
skill_id_list = Skill.objects.values_list('id', flat=True)[::1]
for idx in range(users_number):
user = UserFactory()
users_list.append(user)
random_skill_ids = random.sample(skill_id_list, 2)
level_list = random.sample([1, 2, 3, 4, 5], 2)
SkillUserFactory(user=user,
skill=Skill.objects.get(id=random_skill_ids[0]),
level=level_list[0])
SkillUserFactory(user=user,
skill=Skill.objects.get(id=random_skill_ids[1]),
level=level_list[1])
for idx in range(projects_number):
members = random.sample(users_list, 2)
possible_owner = [
user for user in users_list if user not in members
]
owner = random.choice(possible_owner)
user_without_members = deepcopy(members)
user_without_members.remove(members[0])
user_without_members.remove(members[1])
i_want_to_join = random.sample(
user_without_members, 2 if len(user_without_members) else 0)
skills = random.sample(skill_id_list, 2)
ProjectFactory(members=members,
owner=owner,
i_want_to_join=i_want_to_join,
skills=skills)
def setUp(self):
self.project = ProjectFactory()
self.user = CustomUserFactory()
def test_project_creation(self):
project = ProjectFactory()
self.assertTrue(isinstance(project, Project))
self.assertEqual(project.title, project.__str__())
def test_project_unique_title(self):
project_b = ProjectFactory.create(title="other title")
project_b.title = self.project.title
with self.assertRaises(IntegrityError):
project_b.save()
def setUp(self):
self.project = ProjectFactory.create()
self.content_type = ContentType.objects.get(app_label='projects',
model='project')
def setUp(self):
self.project = ProjectFactory.create()
def handle(self, *args, **options):
ProjectFactory.create_batch(5)
def test_is_private(self):
project = ProjectFactory(public=True)
buy = BuyFactory(project=project, public=True)
assert buy.is_private() is False
buy.public = False
assert buy.is_private() is True
def test_budget_remaining(self):
project = ProjectFactory.create(non_cogs_amount=200, cogs_amount=0)
buy = BuyFactory.create(budget=50, project=project)
assert project.budget_remaining() == 150
buy2 = BuyFactory.create(budget=50, project=project)
assert project.budget_remaining() == 100
def test_marathon_app_id(self):
project = ProjectFactory()
build = ProjectBuildFactory(project=project)
release = ProjectReleaseFactory(build=build)
self.assertEqual(release.marathon_app_id, project.slug)
def test_get_ports(self):
project = ProjectFactory()
build = ProjectBuildFactory(project=project)
release = ProjectReleaseFactory(build=build)
self.assertEqual(release.get_ports(), project.get_ports())
def test_budget(self):
project = ProjectFactory.create(
cogs_amount=75,
non_cogs_amount=25,
)
assert project.budget() == 100
def test_slug(self):
user = CustomUserFactory()
project = ProjectFactory(user=user)
slug = u"{0}-{1}".format(project.name, user.username)
self.assertEqual(project.slug, slug)
def test_budget_remaining_clean(self):
project = ProjectFactory.create(non_cogs_amount=200)
buy = BuyFactory.create(budget=150,
project=project,
public=project.public)
buy.full_clean()
