def test_fetch_organization(self):
""" Unit Test: test_fetch_organization"""
organization1 = OrganizationFactory.create()
organization2 = OrganizationFactory.create()
with self.assertNumQueries(2):
self.assertEqual(data.fetch_organization(organization1.id)['id'], organization1.id)
self.assertEqual(data.fetch_organization(organization2.id)['id'], organization2.id)
def test_filter_courses_based_on_org(self):
"""
Test course are filtered properly on current site organization.
"""
edx_org_1 = OrganizationFactory()
edx_org_2 = OrganizationFactory()
courses_of_org_1 = CourseFactory.create_batch(2,
org=edx_org_1.short_name)
CourseFactory.create(org=edx_org_2.short_name)
assert len(modulestore().get_courses()) == 3
EdlySubOrganizationFactory(edx_organization=edx_org_1,
lms_site=self.request.site,
studio_site=self.request.site)
create_user_link_with_edly_sub_organization(self.request,
self.request.user)
response = cookies_api.set_logged_in_edly_cookies(
self.request, HttpResponse(), self.user,
cookie_settings(self.request))
self._copy_cookies_to_request(response, self.request)
filtered_courses = filter_courses_based_on_org(self.request,
courses_of_org_1)
assert len(filtered_courses) == 2
edx_orgs_of_filterd_courses = [
course.org for course in filtered_courses
]
for org in edx_orgs_of_filterd_courses:
assert org == edx_org_1.short_name
def test_saml_provider_not_found(self):
"""
Test an exception is thrown if no SAML provider exists for this program's organization
"""
OrganizationFactory.create(short_name=self.organization_key)
with pytest.raises(ProviderDoesNotExistException):
get_user_by_program_id(self.external_user_id, self.program_uuid)
def test_saml_provider_not_found(self):
"""
Test that Prov exception is thrown if no SAML provider exists for this
program's organization.
"""
OrganizationFactory.create(short_name=self.organization_key)
with self.assertRaises(ProviderDoesNotExistException):
get_users_by_external_keys(self.program_uuid, [])
def test_saml_provider_not_found(self):
"""
Test an exception is thrown if no SAML provider exists for this program's organization
"""
OrganizationFactory.create(short_name=self.organization_key)
with pytest.raises(ProviderDoesNotExistException):
get_user_by_program_id(self.external_user_id, self.program_uuid)
def test_fetch_organization(self):
""" Unit Test: test_fetch_organization"""
organization1 = OrganizationFactory.create()
organization2 = OrganizationFactory.create()
with self.assertNumQueries(2):
self.assertEqual(
data.fetch_organization(organization1.id)['id'],
organization1.id)
self.assertEqual(
data.fetch_organization(organization2.id)['id'],
organization2.id)
def setUp(self):
super(_DispatchingViewTestCase, self).setUp()
self.dop_adapter = adapters.DOPAdapter()
self.dot_adapter = adapters.DOTAdapter()
self.user = UserFactory()
self.dot_app = self.dot_adapter.create_public_client(
name='test dot application',
user=self.user,
redirect_uri=DUMMY_REDIRECT_URL,
client_id='dot-app-client-id',
)
self.dop_app = self.dop_adapter.create_public_client(
name='test dop client',
user=self.user,
redirect_uri=DUMMY_REDIRECT_URL,
client_id='dop-app-client-id',
)
self.dot_app_access = models.ApplicationAccess.objects.create(
application=self.dot_app,
scopes=['grades:read'],
)
self.dot_app_org = models.ApplicationOrganization.objects.create(
application=self.dot_app, organization=OrganizationFactory())
# Create a "restricted" DOT Application which means any AccessToken/JWT
# generated for this application will be immediately expired
self.restricted_dot_app = self.dot_adapter.create_public_client(
name='test restricted dot application',
user=self.user,
redirect_uri=DUMMY_REDIRECT_URL,
client_id='dot-restricted-app-client-id',
)
models.RestrictedApplication.objects.create(
application=self.restricted_dot_app)
def setup():
user = UserFactory.create()
organization = OrganizationFactory.create()
project = ProjectFactory.create(organization=organization)
document = DocumentFactory.create(project=project)
return user, organization, project, document, Client()
def test_same_user_key_in_multiple_organizations(self):
uox_program_enrollment = self._create_waiting_program_enrollment()
second_organization = OrganizationFactory.create()
SAMLProviderConfigFactory.create(organization=second_organization,
slug='aiu')
catalog_org = CatalogOrganizationFactory.create(
key=second_organization.short_name)
program_uuid = self._create_catalog_program(catalog_org)['uuid']
# aiu enrollment with the same student key as our uox user
aiu_program_enrollment = ProgramEnrollmentFactory.create(
user=None,
external_user_key=self.external_id,
program_uuid=program_uuid)
UserSocialAuth.objects.create(
user=UserFactory.create(),
uid='{0}:{1}'.format('not_used', self.external_id),
)
UserSocialAuth.objects.create(
user=self.user,
uid='{0}:{1}'.format(self.provider_slug, self.external_id),
)
self._assert_program_enrollment_user(uox_program_enrollment, self.user)
aiu_user = UserFactory.create()
UserSocialAuth.objects.create(
user=aiu_user,
uid='{0}:{1}'.format('aiu', self.external_id),
)
self._assert_program_enrollment_user(aiu_program_enrollment, aiu_user)
def test_user_has_document_permissions():
user = UserFactory.create()
organization = OrganizationFactory.create()
project = ProjectFactory.create(organization=organization)
document = DocumentFactory.create(project=project)
document.add_create(user)
assert len(user.get_organizations()) == 1
assert len(user.get_projects()) == 1
assert len(user.get_documents()) == 1
assert organization.can_manage(user) == False
assert organization.can_invite(user) == False
assert organization.can_create(user) == False
assert project.can_invite(user) == False
assert project.can_create(user) == False
assert project.can_manage(user) == False
assert document.can_create(user) == True
assert document.can_invite(user) == False
assert document.can_manage(user) == False
document.delete_create(user)
document.add_invite(user)
assert document.can_create(user) == True
assert document.can_invite(user) == True
assert document.can_manage(user) == False
document.delete_invite(user)
document.add_manage(user)
assert document.can_create(user) == True
assert document.can_invite(user) == True
assert document.can_manage(user) == True
def setup():
user = UserFactory.create()
organization = OrganizationFactory.create()
project = ProjectFactory.create(organization=organization)
document = DocumentFactory.create(project=project)
return user, organization, project, document, Client()
def test_course_org_db_logo_association(self):
"""
Suppose we created a course and incorrectly called it `MITX/Demo/2017` while we want Hsoub logo on it?
This ensures that we can override it using the `OrganizationCourse` model.
"""
org_id = 'PSUT'
course_key = 'PSUT/Demo/Fall2018'
with utils.OrganizationLogo(org_id, course_key) as prev_logo:
self.assertEquals('psut.png', os.path.basename(
prev_logo.name)) # Should use the PSUT legacy logo
moe_logo = 'moe.png'
with open(os.path.join(STATIC_DIR, moe_logo), 'rb') as updated_logo:
wanted_org = OrganizationFactory.create(
name='Ministry of Education',
short_name='MoE',
logo=SimpleUploadedFile(moe_logo, content=updated_logo.read()),
)
# Associate the course with a different organization
OrganizationCourse.objects.create(organization=wanted_org,
course_id=course_key)
with utils.OrganizationLogo(org_id, course_key) as overridden_logo:
self.assertRegexpMatches(
os.path.basename(overridden_logo.name),
r'.*moe.*.\.png*') # Now it's an MoE course!
def test_multiple_saml_providers(self):
"""
Test that get_users_by_external_keys returns the expected
mapping of external keys to users when multiple saml providers
are configured.
"""
organization = OrganizationFactory.create(
short_name=self.organization_key)
provider_1 = SAMLProviderConfigFactory.create(
organization=organization)
provider_2 = SAMLProviderConfigFactory.create(
organization=organization, slug='test-shib-2', enabled=True)
self.create_social_auth_entry(self.user_0, provider_1, 'ext-user-0')
self.create_social_auth_entry(self.user_1, provider_1, 'ext-user-1')
self.create_social_auth_entry(self.user_1, provider_2, 'ext-user-1')
self.create_social_auth_entry(self.user_2, provider_2, 'ext-user-2')
requested_keys = {'ext-user-1', 'ext-user-2', 'ext-user-3'}
actual = get_users_by_external_keys(self.program_uuid, requested_keys)
# ext-user-0 not requested, ext-user-3 doesn't exist,
# ext-user-2 is authorized with secondary provider
# ext-user-1 has an entry in both providers
expected = {
'ext-user-1': self.user_1,
'ext-user-2': self.user_2,
'ext-user-3': None,
}
assert actual == expected
def test_same_user_key_in_multiple_organizations(self):
uox_program_enrollment = self._create_waiting_program_enrollment()
second_organization = OrganizationFactory.create()
SAMLProviderConfigFactory.create(organization=second_organization, slug='aiu')
catalog_org = CatalogOrganizationFactory.create(key=second_organization.short_name)
program_uuid = self._create_catalog_program(catalog_org)['uuid']
# aiu enrollment with the same student key as our uox user
aiu_program_enrollment = ProgramEnrollmentFactory.create(
user=None,
external_user_key=self.external_id,
program_uuid=program_uuid
)
UserSocialAuth.objects.create(
user=UserFactory.create(),
uid='{0}:{1}'.format('not_used', self.external_id),
)
UserSocialAuth.objects.create(
user=self.user,
uid='{0}:{1}'.format(self.provider_slug, self.external_id),
)
self._assert_program_enrollment_user(uox_program_enrollment, self.user)
aiu_user = UserFactory.create()
UserSocialAuth.objects.create(
user=aiu_user,
uid='{0}:{1}'.format('aiu', self.external_id),
)
self._assert_program_enrollment_user(aiu_program_enrollment, aiu_user)
def test_multiple_saml_providers(self, second_config_enabled):
"""
If multiple samlprovider records exist with the same organization
an exception is raised
"""
organization = OrganizationFactory.create(
short_name=self.organization_key)
provider = SAMLProviderConfigFactory.create(organization=organization)
self.create_social_auth_entry(self.user, provider,
self.external_user_id)
# create a second active config for the same organization
SAMLProviderConfigFactory.create(organization=organization,
slug='foox',
enabled=second_config_enabled)
try:
get_user_by_program_id(self.external_user_id, self.program_uuid)
except ProviderConfigurationException:
self.assertTrue(second_config_enabled,
'Unexpected error when second config is disabled')
else:
self.assertFalse(
second_config_enabled,
'Expected error was not raised when second config is enabled')
def test_jwt_access_token_scopes_and_filters(self, grant_type):
"""
Verify the JWT contains the expected scopes and filters.
"""
dot_app = self.dot_adapter.create_public_client(
name='test dot application',
user=self.user,
redirect_uri=DUMMY_REDIRECT_URL,
client_id='dot-app-client-id-{grant_type}'.format(
grant_type=grant_type),
grant_type=grant_type,
)
dot_app_access = models.ApplicationAccess.objects.create(
application=dot_app,
scopes=['grades:read'],
)
models.ApplicationOrganization.objects.create(
application=dot_app, organization=OrganizationFactory())
scopes = dot_app_access.scopes
filters = self.dot_adapter.get_authorization_filters(dot_app)
response = self._post_request(self.user,
dot_app,
token_type='jwt',
scope=scopes)
self.assertEqual(response.status_code, 200)
data = json.loads(response.content.decode('utf-8'))
self.assert_valid_jwt_access_token(
data['access_token'],
self.user,
scopes,
filters=filters,
)
def test_create_organization_already_exists(self):
organization = OrganizationFactory(name='GITRello')
payload = {
'name': organization.name,
}
user = UserFactory()
api_client = APIClient()
api_client.force_authenticate(user=user)
with patch.object(
OrganizationService,
'create_organization',
side_effect=OrganizationAlreadyExistsException) as mocked_create_organization:
response = api_client.post('/api/v1/organizations', data=payload, format='json')
self.assertEqual(response.status_code, 400)
mocked_create_organization.assert_called_with(
owner_id=user.id,
name=payload['name'],
)
expected_response = {
'error_code': OrganizationAlreadyExistsException.code,
'error_message': OrganizationAlreadyExistsException.message,
}
self.assertDictEqual(response.data, expected_response)
def test_course_org_db_logo_override_legacy(self):
"""
Want to re-upload an organization logo? You can do it!
Just create an organization with and upload the logo.
"""
org_id = 'MITX'
course_key = 'MITX/Demo/2017'
with utils.OrganizationLogo(org_id, course_key) as prev_logo:
# Should provide the legacy logo
self.assertEquals('edx.png', os.path.basename(prev_logo.name))
hsoub_logo = 'hsoub.png' # Sorry we're using this all over the place!
with open(os.path.join(STATIC_DIR, hsoub_logo), 'rb') as updated_logo:
org = OrganizationFactory.create(
short_name='MITX',
logo=SimpleUploadedFile(hsoub_logo,
content=updated_logo.read()),
)
with utils.OrganizationLogo(org_id, course_key) as updated_logo:
# Should use the database logo
self.assertRegexpMatches(os.path.basename(updated_logo.name),
r'.*hsoub.*\.png.*')
def test_add_member_board_not_found(self):
organization = OrganizationFactory()
with self.assertRaises(BoardNotFoundException):
_ = BoardMembershipService.create_board_membership(
board_id=-1,
organization_membership_id=organization.id,
)
def test_send_invite_user_not_found(self):
organization = OrganizationFactory()
with self.assertRaises(UserNotFoundException):
_ = OrganizationInviteService.create_organization_invite(
organization_id=organization.id,
email='*****@*****.**',
message='message',
)
def setUp(self):
super(TestOrganizationsView, self).setUp()
self.user_password = '******'
self.user = UserFactory(password=self.user_password, is_superuser=True)
self.organization = OrganizationFactory.create()
self.organization_list_url = reverse('v0:organization-list')
self.client.login(username=self.user.username, password=self.user_password)
def setUp(self):
super(TestOrganizationsView, self).setUp()
self.user_password = '******'
self.user = UserFactory(password=self.user_password)
self.organization = OrganizationFactory.create()
self.organization_list_url = reverse('v0:organization-list')
self.client.login(username=self.user.username, password=self.user_password)
def test_empty_request(self):
"""
Test that requesting no external keys does not cause an exception.
"""
organization = OrganizationFactory.create(short_name=self.organization_key)
SAMLProviderConfigFactory.create(organization=organization)
actual = get_users_by_external_keys(self.program_uuid, set())
assert actual == {}
def setUp(self):
super(AMCAdminPermissionsTestCase, self).setUp()
self.user = UserFactory.create()
self.site = SiteFactory.create(domain='foo.dev', name='foo.dev')
factory = APIRequestFactory()
self.request = factory.get('/test/')
self.request.user = self.user
self.organization = OrganizationFactory()
def test_lms_organization_not_found(self):
"""
Test an OrganizationDoesNotExistException is thrown if the LMS has no organization
matching the catalog program's authoring_organization
"""
organization = OrganizationFactory.create(short_name='some_other_org')
SAMLProviderConfigFactory.create(organization=organization)
with self.assertRaises(OrganizationDoesNotExistException):
get_users_by_external_keys(self.program_uuid, [])
def setUp(self):
super(ProgramEnrollmentsInspectorViewTests, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
self.url = reverse("support:program_enrollments_inspector")
SupportStaffRole().add_users(self.user)
self.program_uuid = str(uuid4())
self.external_user_key = 'abcaaa'
# Setup three orgs and their SAML providers
self.org_key_list = ['test_org', 'donut_org', 'tri_org']
for org_key in self.org_key_list:
lms_org = OrganizationFactory(short_name=org_key)
SAMLProviderConfigFactory(
organization=lms_org,
slug=org_key,
enabled=True,
)
self.no_saml_org_key = 'no_saml_org'
self.no_saml_lms_org = OrganizationFactory(
short_name=self.no_saml_org_key)
def test_social_auth_user_not_created(self):
"""
None should be returned if no lms user exists for an external id
"""
organization = OrganizationFactory.create(short_name=self.organization_key)
SAMLProviderConfigFactory.create(organization=organization)
user = get_user_by_program_id(self.external_user_id, self.program_uuid)
self.assertIsNone(user)
def test_no_double_organization_course(self):
"""
Apparently edX allows multiple organizations per course, but my limited imagination wouldn't grok it!
"""
org_id = 'PSUT'
course_key = 'PSUT/Demo/Fall2018'
wanted_org = OrganizationFactory.create(short_name='MITX')
OrganizationCourse.objects.create(organization=wanted_org,
course_id=course_key)
unwanted_org = OrganizationFactory.create(short_name='AnythingX')
OrganizationCourse.objects.create(organization=unwanted_org,
course_id=course_key)
with self.assertRaisesRegexp(Exception, '.*multiple organizations.*'):
with utils.OrganizationLogo(org_id, course_key):
self.fail('Should fail when having multiple organizations')
def test_social_auth_user_not_created(self):
"""
None should be returned if no lms user exists for an external id
"""
organization = OrganizationFactory.create(short_name=self.organization_key)
SAMLProviderConfigFactory.create(organization=organization)
user = get_user_by_program_id(self.external_user_id, self.program_uuid)
self.assertIsNone(user)
def test_create_organization_name_not_unique(self):
organization = OrganizationFactory()
user = UserFactory()
with self.assertRaises(OrganizationAlreadyExistsException):
_ = OrganizationService().create_organization(
owner_id=user.id,
name=organization.name,
)
def test_get_user_success(self):
"""
Test lms user is successfully found
"""
organization = OrganizationFactory.create(short_name=self.organization_key)
provider = SAMLProviderConfigFactory.create(organization=organization)
self.create_social_auth_entry(self.user, provider, self.external_user_id)
user = get_user_by_program_id(self.external_user_id, self.program_uuid)
self.assertEquals(user, self.user)
def setUp(self):
self.owner = UserFactory()
self.organization = OrganizationFactory(owner=self.owner)
self.discipline = DisciplineFactory()
self.team = TeamFactory(
organization=self.organization,
discipline=self.discipline,
)
self.tournament = TournamentWithTeamsFactory()
self.stage = StageFactory(tournament=self.tournament)
def test_get_user_success(self):
"""
Test lms user is successfully found
"""
organization = OrganizationFactory.create(short_name=self.organization_key)
provider = SAMLProviderConfigFactory.create(organization=organization)
self.create_social_auth_entry(self.user, provider, self.external_user_id)
user = get_user_by_program_id(self.external_user_id, self.program_uuid)
self.assertEquals(user, self.user)
def test_lms_organization_not_found(self):
"""
Test an OrganizationDoesNotExistException is thrown if the LMS has no organization
matching the catalog program's authoring_organization
"""
organization = OrganizationFactory.create(short_name='some_other_org')
provider = SAMLProviderConfigFactory.create(organization=organization)
self.create_social_auth_entry(self.user, provider, self.external_user_id)
with pytest.raises(OrganizationDoesNotExistException):
get_user_by_program_id(self.external_user_id, self.program_uuid)
def test_lms_organization_not_found(self):
"""
Test an OrganizationDoesNotExistException is thrown if the LMS has no organization
matching the catalog program's authoring_organization
"""
organization = OrganizationFactory.create(short_name='some_other_org')
provider = SAMLProviderConfigFactory.create(organization=organization)
self.create_social_auth_entry(self.user, provider, self.external_user_id)
with pytest.raises(OrganizationDoesNotExistException):
get_user_by_program_id(self.external_user_id, self.program_uuid)
def create_course(self):
# Make the `may_certify()` true!
past_week = datetime.now(pytz.UTC) - timedelta(days=7)
course = CourseFactory.create(
start=past_week,
end=past_week,
)
from edraak_certificates.utils import STATIC_DIR
from django.core.files.uploadedfile import SimpleUploadedFile
# Enforce a DB logo
logo_file_name = 'moe.png'
with open(os.path.join(STATIC_DIR, logo_file_name), 'rb') as logo:
OrganizationFactory.create(
short_name=course.org,
logo=SimpleUploadedFile(logo_file_name, content=logo.read()),
)
return course
def test_user_has_superuser():
user = UserFactory.create(is_superuser=True)
organization = OrganizationFactory.create()
project = ProjectFactory.create(organization=organization)
DocumentFactory.create(project=project)
UserFactory.create()
assert len(user.get_organizations()) == 1
assert len(user.get_projects()) == 1
assert len(user.get_documents()) == 1
assert len(user.get_users()) == 2
def test_extra_saml_provider_disabled(self):
"""
If multiple samlprovider records exist with the same organization,
but the extra record is disabled, no exception is raised.
"""
organization = OrganizationFactory.create(short_name=self.organization_key)
SAMLProviderConfigFactory.create(organization=organization)
# create a second active config for the same organization, NOT enabled
SAMLProviderConfigFactory.create(
organization=organization, slug='foox', enabled=False
)
get_users_by_external_keys(self.program_uuid, [])
def test_user_has_no_permissions():
user = UserFactory.create()
# Create some objects that the user should not be able to see
organization = OrganizationFactory.create()
project = ProjectFactory.create(organization=organization)
DocumentFactory.create(project=project)
UserFactory.create()
assert len(user.get_organizations()) == 0
assert len(user.get_projects()) == 0
assert len(user.get_documents()) == 0
assert len(user.get_users()) == 0
def test_multiple_active_saml_providers(self):
"""
If multiple samlprovider records exist with the same organization
an exception is raised
"""
organization = OrganizationFactory.create(short_name=self.organization_key)
provider = SAMLProviderConfigFactory.create(organization=organization)
self.create_social_auth_entry(self.user, provider, self.external_user_id)
# create a second active config for the same organization
SAMLProviderConfigFactory.create(organization=organization, slug='foox')
with pytest.raises(UserLookupException):
get_user_by_program_id(self.external_user_id, self.program_uuid)
def setUpClass(cls):
super(SocialAuthEnrollmentCompletionSignalTest, cls).setUpClass()
cls.external_id = '0000'
cls.provider_slug = 'uox'
cls.course_keys = [
CourseKey.from_string('course-v1:edX+DemoX+Test_Course'),
CourseKey.from_string('course-v1:edX+DemoX+Another_Test_Course'),
]
cls.organization = OrganizationFactory.create(
short_name='UoX'
)
cls.user = UserFactory.create()
for course_key in cls.course_keys:
CourseOverviewFactory(id=course_key)
cls.provider_config = SAMLProviderConfigFactory.create(organization=cls.organization, slug=cls.provider_slug)
def test_catalog_program_missing_org(self):
"""
Test OrganizationDoesNotExistException is thrown if the cached program does not
have an authoring organization.
"""
program = ProgramFactory.create(
uuid=self.program_uuid,
authoring_organizations=[]
)
cache.set(PROGRAM_CACHE_KEY_TPL.format(uuid=self.program_uuid), program, None)
organization = OrganizationFactory.create(short_name=self.organization_key)
provider = SAMLProviderConfigFactory.create(organization=organization)
self.create_social_auth_entry(self.user, provider, self.external_user_id)
with pytest.raises(OrganizationDoesNotExistException):
get_user_by_program_id(self.external_user_id, self.program_uuid)
def setup():
user = UserFactory.create()
organization = OrganizationFactory.create()
return user, organization, Client()
def setUp(self):
super(TestOrganizationSerializer, self).setUp()
self.organization = OrganizationFactory.create()
def test_transfer_ownership():
user, organization, project, client = setup()
project.add_manage(user)
assert login(client, user)
# Test that the user does not have permissions yet.
new_organization = OrganizationFactory()
# Valid case
assert project.organization.pk == organization.pk
response = client.post(
path=reverse('projects:transfer_ownership', args=[project.pk]),
data={
'organization': new_organization.pk,
},
follow=True
)
assert response.status_code == HTTP_200_OK
project.refresh_from_db()
assert project.organization.pk != new_organization.pk
# Test that if the user does not have enough permissions, that things do not work.
new_organization.add_create(user)
# Valid case
assert project.organization.pk == organization.pk
response = client.post(
path=reverse('projects:transfer_ownership', args=[project.pk]),
data={
'organization': new_organization.pk,
},
follow=True
)
assert response.status_code == HTTP_200_OK
project.refresh_from_db()
assert project.organization.pk == organization.pk
new_organization.delete_create(user)
# Test that if the user does not have enough permissions, that things do not work.
new_organization.add_invite(user)
# Valid case
assert project.organization.pk == organization.pk
response = client.post(
path=reverse('projects:transfer_ownership', args=[project.pk]),
data={
'organization': new_organization.pk,
},
follow=True
)
assert response.status_code == HTTP_200_OK
project.refresh_from_db()
assert project.organization.pk == organization.pk
new_organization.delete_invite(user)
# Now test that they do.
new_organization.add_manage(user)
# Valid case
assert project.organization.pk == organization.pk
response = client.post(
path=reverse('projects:transfer_ownership', args=[project.pk]),
data={
'organization': new_organization.pk,
},
follow=True
)
assert response.redirect_chain[0][0] == reverse('projects:transfer_ownership', args=[project.pk])
assert response.redirect_chain[0][1] == HTTP_302_FOUND
project.refresh_from_db()
assert project.organization.pk == new_organization.pk
def test_authenticated_user(self):
""" Verify that the authenticated user gets data."""
OrganizationFactory.create()
response = self.client.get(self.organization_list_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data['results']), 2)
def setUp(self):
super(TestOrganizationModel, self).setUp()
self.organization = OrganizationFactory.create()
