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()