def test_api_object_list(self):
StartupFactory(is_visible=1, organization__url_slug="test1")
StartupFactory(is_visible=1, organization__url_slug="test2")
StartupFactory(is_visible=1, organization__url_slug="test3")
Permission.objects.get_or_create(
content_type=ContentType.objects.get(app_label='accelerator',
model='startup'),
codename='view_startup_stealth_mode_false')
view_perm, _ = Permission.objects.get_or_create(
content_type=ContentType.objects.get(app_label='accelerator',
model='startup'),
codename='view_startup')
url_name = "object-list"
view_kwargs = {'app': 'accelerator', "model": "startup"}
self.response_401(self.get(url_name, **view_kwargs))
basic_user = self.make_user('*****@*****.**')
with self.login(basic_user):
self.response_403(self.get(url_name, **view_kwargs))
perm_user = self.make_user('*****@*****.**',
perms=["mc.view_startup"])
perm_user.user_permissions.add(view_perm)
perm_user.save()
with self.login(perm_user):
response = self.get(url_name, **view_kwargs)
self.response_200(response)
response_dict = json.loads(response.content)
self.assertIn("short_pitch", response_dict['results'][0].keys())
for startup in response_dict['results']:
self.assertEqual(startup["is_visible"], 1)
def test_api_related_object_list_get(self):
StartupFactory(is_visible=1, organization__url_slug="test1")
StartupFactory(is_visible=1, organization__url_slug="test2")
StartupFactory(is_visible=1, organization__url_slug="test3")
view_perm, _ = Permission.objects.get_or_create(
content_type=ContentType.objects.get(app_label='accelerator',
model='startup'),
codename='view_startup_additional_industries')
url_name = "related-object-list"
view_kwargs = {
"app": "accelerator",
"model": "startup",
"related_model": "additional_industries"
}
self.response_401(self.get(url_name, **view_kwargs))
basic_user = self.make_user('*****@*****.**')
with self.login(basic_user):
self.response_403(self.get(url_name, **view_kwargs))
perm_user = self.make_user(
'*****@*****.**',
perms=["mc.view_startup_additional_industries"])
perm_user.user_permissions.add(view_perm)
with self.login(perm_user):
response = self.get(url_name, **view_kwargs)
self.response_200(response)
def test_get_with_limit(self):
count = 5
StartupFactory.create_batch(count)
with self.login(email=self.basic_user().email):
limit = 2
url = self.url + "?limit=%s" % limit
response = self.client.get(url)
assert response.data['count'] == count
assert len(response.data['results']) == limit
def test_startup_organization_has_startup_id(self):
count = 5
StartupFactory.create_batch(count)
with self.login(email=self.basic_user().email):
response = self.client.get(self.url)
[
self.assertTrue(result.get('startup_id') > 0)
for result in response.data['results']
]
def test_organization_schema_endpoint(self):
count = 5
StartupFactory.create_batch(count)
response = ''
with self.login(email=self.basic_user().email):
url = reverse("organization")
response = self.client.options(url)
results = response.data["actions"]["GET"]["properties"]["results"]
properties = results["item"]["properties"]
self.assertEqual(ORGANIZATION_FIELDS.keys(), properties.keys())
def test_results_are_filtered_by_name(self):
name = "foo"
other_name = "bar"
startup = StartupFactory(organization__name=name)
other_startup = StartupFactory(organization__name=other_name)
with self.login(email=self.basic_user().email):
url = self.url + "?name=%s" % name
response = self.client.get(url)
assert response.data['count'] == 1
assert _contains_org(startup.organization, response.data)
assert not _contains_org(other_startup.organization, response.data)
def test_startup_created_no_created_datetime(self):
startup = StartupFactory(created_datetime=None)
startup.created_at = None
startup.save()
with self.login(email=self.basic_user().email):
url = reverse(OrganizationHistoryView.view_name,
args=[startup.organization.id])
response = self.client.get(url)
events = find_events(response.data["results"],
OrganizationCreatedEvent.EVENT_TYPE)
self.assertEqual(1, len(events))
self.assertEqual(DAWN_OF_TIME, events[0]["datetime"])
def test_user_schema_endpoint(self):
count = 5
StartupFactory.create_batch(count)
response = ''
with self.login(email=self.basic_user().email):
url = reverse("user")
response = self.client.options(url)
results = response.data["actions"]["GET"]["properties"]["results"]
properties = results["item"]["properties"]
response_keys = set(properties.keys())
self.assertTrue(len(response_keys) > 0)
self.assertFalse(response_keys - set(USER_FIELDS.keys()))
def test_deleted_startup(self):
startup = StartupFactory()
startup_id = startup.id
startup.delete()
program = ProgramFactory()
with self.login(email=self.basic_user().email):
response = self.client.post(STARTUP_DETAIL_URL, {
"ProgramKey": program.id,
"StartupKey": startup_id
})
assert response.status_code == 404
assert match_errors({"StartupKey": str(startup_id)}, response.data)
def test_api_object_get(self):
url_name = "object-detail"
StartupFactory(id=1)
view_kwargs = {
'app': 'accelerator',
"model": "startup",
"pk": 1,
}
self.response_401(self.get(url_name, **view_kwargs))
startup_permission, _ = Permission.objects.get_or_create(
content_type=ContentType.objects.get(app_label='accelerator',
model='startup'),
codename='view_startup',
)
basic_user = self.make_user('*****@*****.**')
with self.login(basic_user):
self.response_403(self.get(url_name, **view_kwargs))
perm_user = self.make_user('*****@*****.**',
perms=["mc.view_startup"])
perm = PermissionFactory.create(codename='change_startup')
view_perm = PermissionFactory.create(codename='view_startup')
perm_user.user_permissions.add(perm)
perm_user.user_permissions.add(startup_permission)
perm_user.user_permissions.add(view_perm)
perm_user.save()
with self.login(perm_user):
response = self.get(url_name, **view_kwargs)
self.response_200(response)
response_dict = json.loads(response.content)
self.assertIn("is_visible", response_dict.keys())
def test_options(self):
startup = StartupFactory()
with self.login(email=self.basic_user().email):
url = reverse(OrganizationHistoryView.view_name, args=[startup.id])
response = self.client.options(url)
assert response.status_code == 200
results = response.data["actions"]["GET"]["properties"]["results"]
get_options = results["item"]["properties"]
assert_fields(OrganizationHistoryView.fields().keys(), get_options)
def test_next_info_contains_filter(self):
name = "foo"
for i in range(20):
StartupFactory(organization__name=name + str(i))
with self.login(email=self.basic_user().email):
name_query_parameter = "name=%s" % name
url = self.url + "?" + name_query_parameter
response = self.client.get(url)
assert name_query_parameter in response.data['next']
def test_startup_options(self):
organization = StartupFactory().organization
with self.login(email=self.basic_user().email):
url = reverse(OrganizationDetailView.view_name,
args=[organization.id])
response = self.client.options(url)
assert response.status_code == 200
get_options = response.data["actions"]["GET"]["properties"]
assert_fields(STARTUP_GET_FIELDS, get_options)
def test_get_startup(self):
count = 5
startups = StartupFactory.create_batch(count)
with self.login(email=self.basic_user().email):
response = self.client.get(self.url)
assert response.data['count'] == count
assert all([
OrganizationListView.serialize(startup.organization)
in response.data['results'] for startup in startups
])
def test_options_against_get(self):
startup = StartupFactory()
with self.login(email=self.basic_user().email):
url = reverse(OrganizationHistoryView.view_name, args=[startup.id])
options_response = self.client.options(url)
get_response = self.client.get(url)
schema = options_response.data["actions"]["GET"]
validator = Draft4Validator(schema)
assert validator.is_valid(json.loads(get_response.content))
def test_user_organization_schema_endpoint(self):
count = 5
startups = StartupFactory.create_batch(count)
response = ''
with self.login(email=self.basic_user().email):
url = reverse("user_organizations", args=[startups[0].user.pk])
response = self.client.options(url)
response_json = json.loads(response.content)
self.assertEqual(
ORGANIZATION_USER_FIELDS.keys(), response_json["actions"]["GET"]
["properties"]["organizations"]["item"]["properties"].keys())
def test_get_startup(self):
startup = StartupFactory()
with self.login(email=self.basic_user().email):
url = reverse(OrganizationDetailView.view_name,
args=[startup.organization.id])
response = self.client.get(url)
assert response.data["name"] == startup.organization.name
assert response.data["url_slug"] == startup.organization.url_slug
assert (response.data["public_inquiry_email"] ==
startup.public_inquiry_email)
assert response.data["is_startup"] is True
assert response.data["is_partner"] is False
def test_startup_became_winner(self):
startup = StartupFactory()
startup_status = StartupStatusFactory(
program_startup_status__startup_role__name=StartupRole.GOLD_WINNER,
startup=startup)
role = startup_status.program_startup_status.startup_role
with self.login(email=self.basic_user().email):
url = reverse(OrganizationHistoryView.view_name,
args=[startup.organization.id])
response = self.client.get(url)
events = find_events(response.data["results"],
OrganizationBecameWinnerEvent.EVENT_TYPE)
self.assertEqual(1, len(events))
self.assertEqual(role.name, events[0]["winner_level"])
def setUp(self):
# Many objects must be created to scaffold this thing
Site.objects.create()
_site = Site.objects.first()
startup1, startup2 = StartupFactory.create_batch(2)
startup1.high_resolution_logo = "hamsterdance.gif"
startup1.save()
JobPostingFactory(startup=startup1)
JobPostingFactory(startup=startup2)
self.program = ProgramFactory()
_pss = ProgramStartupStatusFactory(program=self.program)
StartupStatusFactory(startup=startup1, program_startup_status=_pss)
StartupStatusFactory(startup=startup2, program_startup_status=_pss)
SiteProgramAuthorizationFactory(site=_site, program=self.program)
self.url = reverse("job_posting_list")
def test_api_object_get_field_filter(self):
startup_content_type = ContentType.objects.get(app_label='accelerator',
model='startup')
stealth_perm = PermissionFactory(
content_type=startup_content_type,
codename='view_startup_stealth_mode_true')
StartupFactory(id=3, is_visible=0)
url_name = "object-detail"
view_kwargs = {
'app': 'accelerator',
"model": "startup",
"pk": 3, # has stealth mode enabled
}
response = self.get(url_name, **view_kwargs)
self.response_401(response)
basic_user = self.make_user('*****@*****.**')
with self.login(basic_user):
response = self.get(url_name, **view_kwargs)
self.response_403(response)
perm_user = self.make_user('*****@*****.**',
perms=["mc.view_startup"])
perm = Permission.objects.get(codename='change_startup',
content_type=startup_content_type)
view_perm = PermissionFactory.create(codename='view_startup',
content_type=startup_content_type)
perm_user.save()
with self.login(perm_user):
self.response_403(self.get(url_name, **view_kwargs))
correct_perm_user = self.make_user(
'*****@*****.**',
perms=[
"mc.view_startup", "mc.change_startup",
"mc.view_startup_stealth_mode_true"
])
correct_perm_user.user_permissions.add(perm)
correct_perm_user.user_permissions.add(view_perm)
correct_perm_user.user_permissions.add(stealth_perm)
correct_perm_user.save()
with self.login(correct_perm_user):
response = self.get(url_name, **view_kwargs)
self.response_200(response)
response_dict = json.loads(response.content)
self.assertIn("is_visible", response_dict.keys())
def test_startup_became_winner_no_created_at(self):
startup = StartupFactory()
end_date = days_from_now(-10)
startup_status = StartupStatusFactory(
program_startup_status__startup_role__name=StartupRole.GOLD_WINNER,
program_startup_status__program__end_date=end_date,
startup=startup)
startup_status.created_at = None
startup_status.save()
with self.login(email=self.basic_user().email):
url = reverse(OrganizationHistoryView.view_name,
args=[startup.organization.id])
response = self.client.get(url)
events = find_events(response.data["results"],
OrganizationBecameWinnerEvent.EVENT_TYPE)
self.assertEqual(1, len(events))
self.assertEqual(end_date, events[0]["datetime"])
def test_get_startup_with_industries(self):
primary_industry = IndustryFactory()
additional_industries = IndustryFactory.create_batch(2)
startup = StartupFactory(primary_industry=primary_industry,
additional_industries=additional_industries)
with self.login(email=self.basic_user().email):
url = reverse(OrganizationDetailView.view_name,
args=[startup.organization.id])
response = self.client.get(url)
assert (
response.data["primary_industry"]["id"] == primary_industry.id)
additional_industry_ids = [
datum["id"] for datum in response.data["additional_industries"]
]
assert all([
industry.id in additional_industry_ids
for industry in additional_industries
])
def test_startup_became_finalist(self):
startup = StartupFactory()
startup_status = StartupStatusFactory(
program_startup_status__startup_role__name=StartupRole.FINALIST,
startup=startup)
program = startup_status.program_startup_status.program
with self.login(email=self.basic_user().email):
url = reverse(OrganizationHistoryView.view_name,
args=[startup.organization.id])
response = self.client.get(url)
events = find_events(response.data["results"],
OrganizationBecameFinalistEvent.EVENT_TYPE)
self.assertEqual(1, len(events))
self.assertTrue(program.name in events[0]["description"])
self.assertEqual(program.name, events[0]["program"])
self.assertEqual(program.id, events[0]["program_id"])
self.assertEqual(program.cycle.name, events[0]["cycle"])
self.assertEqual(program.cycle.id, events[0]["cycle_id"])
def test_startup_created_using_other_startups(self):
prev_created_datetime = days_from_now(-10)
StartupFactory(created_datetime=prev_created_datetime)
startup = StartupFactory(created_datetime=None)
startup.created_at = None
startup.save()
next_created_datetime = days_from_now(-2)
StartupFactory(created_datetime=next_created_datetime)
with self.login(email=self.basic_user().email):
url = reverse(OrganizationHistoryView.view_name,
args=[startup.organization.id])
response = self.client.get(url)
events = find_events(response.data["results"],
OrganizationCreatedEvent.EVENT_TYPE)
self.assertEqual(1, len(events))
self.assertEqual(prev_created_datetime, events[0]["datetime"])
self.assertEqual(next_created_datetime,
events[0]["latest_datetime"])
def test_api_object_delete(self):
StartupFactory(id=2)
url_name = "object-detail"
view_kwargs = {
'app': 'accelerator',
"model": "startup",
"pk": 2,
}
self.response_401(self.get(url_name, **view_kwargs))
basic_user = self.make_user('*****@*****.**')
startup_delete_permission, _ = Permission.objects.get_or_create(
content_type=ContentType.objects.get(app_label='accelerator',
model='startup'),
codename='delete_startup',
)
startup_view_permission, _ = Permission.objects.get_or_create(
content_type=ContentType.objects.get(app_label='accelerator',
model='startup'),
codename='delete_startup',
)
with self.login(basic_user):
response = self.get(url_name, **view_kwargs)
self.response_403(response)
perm_user = self.make_user('*****@*****.**',
perms=[
"mc.view_startup", "mc.change_startup",
"mc.delete_startup"
])
perm = PermissionFactory.create(codename='change_startup')
perm_user.user_permissions.add(perm)
perm_user.user_permissions.add(startup_delete_permission)
perm_user.user_permissions.add(startup_view_permission)
perm_user.save()
with self.login(perm_user):
self.delete(url_name, **view_kwargs)
self.assertEqual(204, self.last_response.status_code)
def test_startup(self):
startup = StartupFactory()
assert startup.created_at <= startup.updated_at
def test_api_object_put(self):
url_name = "object-detail"
startup = StartupFactory(id=1, is_visible=False)
get_kwargs = {
'app': 'accelerator',
"model": "startup",
"pk": 1,
}
data = json.dumps({
"is_visible": True,
"name": "test",
"primary_industry": startup.primary_industry.id,
"short_pitch": "test",
"full_elevator_pitch": "test",
"website_url": "http://test.com",
"linked_in_url": "http://test.com",
"facebook_url": "http://test.com",
"twitter_handle": "@test",
"public_inquiry_email": "*****@*****.**",
"video_elevator_pitch_url": "http://example.com",
"user": startup.user.id,
"created_datetime": None,
"last_updated_datetime": None,
"community": "red",
"url_slug": "testing",
"profile_background_color": "000000",
"profile_text_color": "FFFFFF",
"currency": "",
"date_founded": "test",
"location_city": "test",
"location_national": "test",
"location_postcode": "test",
"location_regional": "test",
"landing_page": "test"
}) # field "high_resolution_logo" was removed, to be solved in AC-4750
extra = {"content_type": "application/json"}
put_kwargs = get_kwargs.copy()
put_kwargs["data"] = data
put_kwargs["extra"] = extra
self.response_401(self.put(url_name, **put_kwargs))
basic_user = self.make_user('*****@*****.**')
with self.login(basic_user):
self.response_403(self.get(url_name, **get_kwargs))
startup_content_type = ContentType.objects.get(app_label='accelerator',
model='startup')
stealth_startup_permission, _ = Permission.objects.get_or_create(
content_type=startup_content_type,
codename='view_startup_is_visible_false')
invisible_startup_view_permission, _ = (
Permission.objects.get_or_create(
content_type=startup_content_type,
codename='view_startup_is_visible_false'))
visible_startup_change_permission, _ = (
Permission.objects.get_or_create(
content_type=startup_content_type,
codename='change_startup_is_visible_true'))
stealth_startup_change_permission, _ = (
Permission.objects.get_or_create(
content_type=startup_content_type,
codename='change_startup_is_visible_false'))
visible_startup_view_permission, _ = Permission.objects.get_or_create(
content_type=startup_content_type,
codename='view_startup_is_visible_true')
startup_member_permission, _ = Permission.objects.get_or_create(
content_type=ContentType.objects.get(app_label='accelerator',
model='startupteammember'),
codename='view_startupteammember',
)
startup_permission, _ = Permission.objects.get_or_create(
content_type=startup_content_type,
codename='view_startup',
)
change_startup_permission, _ = Permission.objects.get_or_create(
content_type=startup_content_type,
codename='change_startup',
)
perm_user = self.make_user('*****@*****.**')
perm_user.user_permissions.add(startup_permission)
perm_user.user_permissions.add(stealth_startup_permission)
perm_user.user_permissions.add(change_startup_permission)
perm_user.user_permissions.add(visible_startup_view_permission)
perm_user.user_permissions.add(visible_startup_change_permission)
perm_user.user_permissions.add(startup_member_permission)
perm_user.user_permissions.add(invisible_startup_view_permission)
perm_user.user_permissions.add(stealth_startup_change_permission)
perm_user.save()
with self.login(perm_user):
response = self.get(url_name, **get_kwargs)
self.response_200(response)
response_dict = json.loads(response.content)
self.assertIn("is_visible", response_dict.keys())
self.assertEqual(response_dict["is_visible"], False)
# we can now put a different value
response = self.put(url_name, **put_kwargs)
self.response_200(response)
response_dict = json.loads(response.content)
self.assertIn("is_visible", response_dict.keys())
self.assertEqual(response_dict["is_visible"], True)
def test_str(self):
startup = StartupFactory()
assert str(startup) == startup.name
def test_logo_url_returns_empty_string_if_none(self):
startup = StartupFactory(high_resolution_logo=None)
assert logo_url(startup) == ""
