def setUp(self):
self.test_instances = [
ProjectFactory(title="Boring Project"),
ProjectFactory(title="Exciting Project"),
ProjectFactory(title="Other Project"),
]
self.response = self.client.get('/proj/')
def test_interaction_with_filter_by_project(self):
project_1 = ProjectFactory()
project_2 = ProjectFactory()
for _ in range(2):
InteractionFactory(project=project_1)
InteractionFactory(project=project_2)
response = self.client.get(f"{reverse('interaction:list')}?project={project_1.pk}")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['interaction_list'].count(), 2)
response = self.client.get(f"{reverse('interaction:list')}?project={project_2.pk}")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['interaction_list'].count(), 1)
def setUp(self):
self.test_instance = ProjectFactory()
self.fields = ['title', 'description']
self.templates = ['base.html', 'projects/project.html']
# Add some users
self.admin_user = UserFactory()
self.test_instance.administrators.add(self.admin_user)
self.outside_user = UserFactory()
self.nominator = UserFactory()
self.test_instance.nominators.add(self.nominator)
self.blacklisted_user = UserFactory()
self.test_instance.nominator_blacklist.add(self.blacklisted_user)
# Add some nominations
self.user_nominations = {
'facebook.com': ('user1', 'user3'),
'linkedin.com': ('user2', 'user3'),
'myspace.com': ('user3'),
'twitter.com': ('user1', 'user2', 'user3'),
'ucla.edu': ('user1', 'user3'),
}
for url, users in self.user_nominations.items():
nom = NominationFactory(
project=self.test_instance,
resource=ResourceFactory(url=url),
)
for username in users:
nom.endorsements.add(UserFactory(username=username))
self.client.logout()
self.test_response = self.client.get(
self.test_instance.get_absolute_url()
)
def test_interaction_with_filter_by_company(self):
company_1 = CompanyFactory()
company_2 = CompanyFactory()
for _ in range(2):
InteractionFactory(project=ProjectFactory(company=company_1))
InteractionFactory(project=ProjectFactory(company=company_2))
response = self.client.get(f"{reverse('interaction:list')}?company={company_1.pk}")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['interaction_list'].count(), 2)
response = self.client.get(f"{reverse('interaction:list')}?company={company_2.pk}")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['interaction_list'].count(), 1)
def test_owner_access_private(self):
"""Test owner access private"""
user = self._create_user()
ProjectFactory(owner=user, is_private=True, name='test')
self._create_tasks(is_private=True, allowed_users=[user.id])
response = self.api_client.get(self.url)
data = self.deserialize(response)
data['meta']['total_count'].should.be.equal(20)
def test_projects_list_is_not_empty(self):
for _ in range(3):
ProjectFactory()
response = self.client.get(reverse('project:list'))
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, "Список проектов пуст.")
self.assertEqual(response.context['project_list'].count(), 3)
def test_create_task(self):
"""Test create node task"""
ProjectFactory(
name='octokitty/testing',
run_here=True,
is_enabled=True,
)
response = self.api_client.post(self._url, data=self._data)
response.status_code.should.be.equal(201)
NodeTask.objects.count().should.be.equal(1)
def test_other_user_cant_access_private(self):
"""Test other user cant access private"""
user = self._create_user()
ProjectFactory(
owner=user, is_private=True, name='test',
)
self._create_tasks(is_private=True)
response = self.api_client.get(self.url)
data = self.deserialize(response)
data['meta']['total_count'].should.be.equal(0)
def setUp(self):
self.project = ProjectFactory()
self.project.save()
# make some users
self.admin_user = UserFactory()
self.project.administrators.add(self.admin_user)
# get a default response
self.url = self.project.get_edit_url()
self.client.force_login(self.admin_user)
self.response = self.client.get(self.url)
def test_organization_member_access_private(self):
"""Test organization member access private"""
user = self._create_user()
project = ProjectFactory(
owner=user, is_private=True,
name='test', organization__users=[user],
)
self._create_tasks(
is_private=True, organization=project.organization.id,
)
response = self.api_client.get(self.url)
data = self.deserialize(response)
data['meta']['total_count'].should.be.equal(20)
def setUp(self):
self.factory = APIRequestFactory()
self.user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.user.is_superuser = True
self.user.save()
self.token = Token.objects.create(user=self.user)
self.token.save()
self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.token.key)
for i in range(10):
ProjectFactory()
def test_fail_with_wrong_project(self):
"""Test fail with wrong project"""
task_id = Tasks.save({
'project': 'test',
'service': {
'name': 'token',
'token': ProjectFactory().token,
}
})
data = Tasks.find_one(task_id)
with LogCapture() as log_capture:
token_service(data).should.be.none
list(log_capture.actual())[0].should.contain('ERROR')
Tasks.find({}).count().should.be.equal(0)
def _create_task(self):
"""Create task"""
ProjectFactory(name='test')
data = {
'service': {
'name': 'dummy',
},
'project': 'test',
'branch': 'develop',
'commit': 'asdfg',
'violations': [
{'name': 'dummy', 'raw': '1'},
]
}
jobs.create_task(models.Tasks.save(data))
def test_create_new_project(self):
project = ProjectFactory()
new_project_data = {
'name': project.name,
'description': project.description,
'start_date': project.start_date,
'end_date': project.end_date,
'price': project.price,
'company': project.company.pk
}
project.delete()
response = self.client.post(reverse('project:create'),
new_project_data)
self.assertEqual(response.status_code, 302)
self.assertEqual(new_project_data['name'], Project.objects.last().name)
def test_comment(self):
"""Test comment"""
ProjectFactory(name='test')
task = {
'project': 'test',
'pull_request_id': 2,
'violations': [
{'name': 'dummy', 'preview': 'rew'},
{'name': 'dummy!!!', 'raw': 'rwww'},
{'name': 'dummy', 'raw': 'row'},
],
'commit': {'hash': 'test'},
}
jobs.comment_pull_request.when\
.called_with(models.Tasks.save(task))\
.should_not.throw(Exception)
def test_create_project(self):
project_from_factory = ProjectFactory()
project_from_db = Project.objects.first()
self.assertEqual(Project.objects.count(), 1)
self.assertEqual(project_from_factory.name, project_from_db.name)
self.assertEqual(project_from_factory.description,
project_from_db.description)
self.assertEqual(project_from_factory.start_date,
project_from_db.start_date)
self.assertEqual(project_from_factory.end_date,
project_from_db.end_date)
self.assertEqual(project_from_factory.price, project_from_db.price)
self.assertEqual(project_from_factory.company, project_from_db.company)
self.assertEqual(project_from_factory.name, project_from_db.__str__())
self.assertEqual(
reverse('project:detail', kwargs={'pk': project_from_factory.pk}),
project_from_db.get_absolute_url())
def test_new_project_no_permissions():
user, organization, client = setup()
assert login(client, user)
assert len(user.get_projects()) == 0
response = client.post(
path=reverse('projects:new_project'),
data={},
)
assert response.status_code == HTTP_403_FORBIDDEN
project = ProjectFactory(organization=organization)
project.add_manage(user)
assert len(user.get_projects()) == 1
response = client.post(
path=reverse('projects:new_project'),
data={
'name': 'Test Project',
'description': 'Test Description',
'organization': organization.pk
},
)
assert response.status_code == HTTP_403_FORBIDDEN
assert len(user.get_projects()) == 1
def setUp(self):
super(BaseTaskResourceCase, self).setUp()
self.project = ProjectFactory(name='test', is_enabled=True)
def setUp(self):
super(TokenServiceCase, self).setUp()
self.project = ProjectFactory(name='test')
def setUp(self):
super(PrepareViolationsJobCase, self).setUp()
self._mock_mark_commit()
self._mock_comment_lines()
self._mock_quality_game()
ProjectFactory(name='test')
def setUp(self):
super(CommentLinesCase, self).setUp()
self._mock_github()
ProjectFactory(name='test')
def setUpTestData(cls):
UserModel.objects.create_user(username='******',
password='******')
for _ in range(3):
ProjectFactory()
def test_nomination_create_view_get(client):
project = ProjectFactory(nomination_policy='Public')
response = client.get(project.get_add_nomination_url())
assert response.status_code == 200
def setUp(self):
super(MarkCommitWithStatusCase, self).setUp()
self._mock_github()
self._mock_make_https()
ProjectFactory(name='test')
def test_register_key_on_github(self):
"""Test register key on github"""
ProjectFactory(run_here=True, is_enabled=True)
models.Project.repo.create_key.call_count.should.be.equal(1)