def test_get_correct_pagination_attributes_for_offset_zero(self):
limit = 3
current_implicit_offset = 0
for _ in range(limit * 3):
UserContext()
with self.login(email=self.basic_user().email):
limit_arg = "limit={}".format(limit)
url = self.url + "?" + limit_arg
response = self.client.get(url)
results = response.data["results"]
assert limit == len(results)
assert response.data["previous"] is None
assert limit_arg in response.data["next"]
next_offset_arg = "offset={}".format(current_implicit_offset +
limit)
assert next_offset_arg in response.data["next"]
def test_get_expert_with_industries(self):
primary_industry = IndustryFactory()
additional_industries = IndustryFactory.create_batch(2)
context = UserContext(user_type=EXPERT_USER_TYPE,
primary_industry=primary_industry,
additional_industries=additional_industries)
user = context.user
with self.login(email=self.basic_user().email):
url = reverse(UserDetailView.view_name, args=[user.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_get_pagination_attrs_for_offset_greater_than_num_of_results(self):
limit = 4
for _ in range(limit * 5):
UserContext()
with self.login(email=self.basic_user().email):
count = User.objects.count()
current_offset = count + 1
limit_arg = "limit={}".format(limit)
offset_arg = "offset={}".format(current_offset)
url = self.url + "?" + limit_arg + "&" + offset_arg
response = self.client.get(url)
results = response.data["results"]
assert len(results) == 0
prev_offset_arg = "offset={}".format(count - limit)
assert prev_offset_arg in response.data["previous"]
assert response.data["next"] is None
def test_get_pagination_attrs_for_offset_between_count_and_limit(self):
limit = 4
for _ in range(limit * 5):
UserContext()
current_offset = User.objects.count() - limit + 2
with self.login(email=self.basic_user().email):
limit_arg = "limit={}".format(limit)
offset_arg = "offset={}".format(current_offset)
url = self.url + "?" + limit_arg + "&" + offset_arg
response = self.client.get(url)
results = response.data["results"]
assert limit > len(results)
assert len(results) == response.data["count"] - current_offset
prev_offset_arg = "offset={}".format(current_offset - limit)
assert prev_offset_arg in response.data["previous"]
assert response.data["next"] is None
def test_patch_ids(self):
context = UserContext(user_type=EXPERT_USER_TYPE)
user = context.user
profile = get_profile(user)
industry = IndustryFactory()
program_family = ProgramFamilyFactory()
with self.login(email=self.basic_user().email):
url = reverse(UserDetailView.view_name, args=[user.id])
self.client.patch(url, {
"home_program_family_id": program_family.id,
"primary_industry_id": industry.id,
})
user.refresh_from_db()
profile.refresh_from_db()
helper = UserHelper(user)
assert (helper.field_value("home_program_family_id") ==
program_family.id)
assert (helper.profile_helper.subject.primary_industry_id ==
industry.id)
def test_get_pagination_attrs_for_offset_in_the_middle(self):
limit = 4
current_offset = limit + 2
for _ in range(current_offset + limit + 2):
UserContext()
with self.login(email=self.basic_user().email):
limit_arg = "limit={}".format(limit)
offset_arg = "offset={}".format(current_offset)
url = self.url + "?" + limit_arg + "&" + offset_arg
response = self.client.get(url)
results = response.data["results"]
assert limit == len(results)
prev_offset_arg = "offset={}".format(current_offset - limit)
assert prev_offset_arg in response.data["previous"]
assert limit_arg in response.data["next"]
next_offset_arg = "offset={}".format(current_offset + limit)
assert next_offset_arg in response.data["next"]
def test_get_pagination_attrs_for_offset_between_zero_and_limit(self):
limit = 4
current_offset = limit - 2
for _ in range(limit * 3):
UserContext()
with self.login(email=self.basic_user().email):
limit_arg = "limit={}".format(limit)
offset_arg = "offset={}".format(current_offset)
url = self.url + "?" + limit_arg + "&" + offset_arg
response = self.client.get(url)
results = response.data["results"]
assert limit == len(results)
assert response.data["previous"] is not None
assert "offset" not in response.data["previous"]
assert limit_arg in response.data["next"]
next_offset_arg = "offset={}".format(current_offset + limit)
assert next_offset_arg in response.data["next"]
def test_patch_invalid_primary_industry_id(self):
context = UserContext(user_type=EXPERT_USER_TYPE)
user = context.user
with self.login(email=self.basic_user().email):
url = reverse(UserDetailView.view_name, args=[user.id])
bad_value = 0
response = self.client.patch(
url, {
"home_program_family_id": bad_value,
"primary_industry_id": bad_value,
})
assert response.status_code == 403
error_msg = INVALID_ID_ERROR.format(field="home_program_family_id",
classname="ProgramFamily")
assert error_msg in response.data
error_msg = INVALID_ID_ERROR.format(field="primary_industry_id",
classname="Industry")
assert error_msg in response.data
assert "home_program_family_id" in _valid_note(response.data)
def test_patch_expert_fields(self):
context = UserContext(user_type=EXPERT_USER_TYPE)
user = context.user
profile = get_profile(user)
with self.login(email=self.basic_user().email):
url = reverse(UserDetailView.view_name, args=[user.id])
company = profile.company + ", Inc."
expert_category = ExpertCategoryFactory().name
title = "Chief " + profile.title
office_hours_topics = "Fungi"
referred_by = "me"
speaker_topics = "Fungi"
data = {
"company": company,
"expert_category": expert_category,
"title": title,
"office_hours_interest": True,
"office_hours_topics": office_hours_topics,
"referred_by": referred_by,
"speaker_interest": True,
"speaker_topics": speaker_topics,
"judge_interest": False,
"mentor_interest": True,
"mentor_type": "f",
"judge_type": "1",
}
self.client.patch(url, data)
user.refresh_from_db()
profile.refresh_from_db()
helper = UserHelper(user)
assert helper.field_value("company") == company
assert helper.field_value("expert_category") == expert_category
assert helper.field_value("title") == title
assert (helper.field_value("office_hours_interest") is True)
assert (helper.field_value("office_hours_topics") ==
office_hours_topics)
assert helper.field_value("referred_by") == referred_by
assert helper.field_value("speaker_interest") is True
assert helper.field_value("speaker_topics") == speaker_topics
assert helper.field_value("judge_interest") is False
assert helper.field_value("mentor_interest") is True
assert helper.field_value("mentor_type") == "f"
assert helper.field_value("judge_type") == "1"
def test_patch(self):
context = UserContext()
user = context.user
profile = get_profile(user)
with self.login(email=self.basic_user().email):
url = reverse(UserDetailView.view_name, args=[user.id])
bio = profile.bio + " I'm an awesome API!"
email = user.email + ".org"
facebook_url = profile.facebook_url + "/awesome"
first_name = "Awesome"
is_active = not user.is_active
linked_in_url = profile.linked_in_url + "/awesome"
website_url = profile.personal_website_url + "/awesome"
phone = "+1-555-555-1234"
twitter_handle = "@awesome"
data = {
"bio": bio,
"email": email,
"facebook_url": facebook_url,
"first_name": first_name,
"gender": "Male",
"is_active": is_active,
"linked_in_url": linked_in_url,
"personal_website_url": website_url,
"phone": phone,
"twitter_handle": twitter_handle,
}
response = self.client.patch(url, data)
assert response.status_code == 204
user.refresh_from_db()
profile.refresh_from_db()
assert user.email == email
assert user.first_name == first_name
assert user.is_active == is_active
helper = UserHelper(user)
assert helper.field_value("bio") == bio
assert helper.field_value("facebook_url") == facebook_url
assert helper.field_value("gender") == "m"
assert helper.field_value("linked_in_url") == linked_in_url
assert helper.field_value("personal_website_url") == website_url
assert helper.field_value("phone") == phone
assert helper.field_value("twitter_handle") == twitter_handle
def test_options(self):
context = UserContext()
user = context.user
with self.login(email=self.basic_user().email):
url = reverse(UserDetailView.view_name, args=[user.id])
response = self.client.options(url)
assert response.status_code == 200
get_data = response.data["actions"]["GET"]
assert get_data["type"] == "object"
get_options = get_data["properties"]
assert_fields(ENTREPRENEUR_GET_FIELDS, get_options)
assert_fields_missing(EXPERT_GET_FIELDS, get_options)
patch_options = response.data["actions"]["PATCH"]["properties"]
assert_fields_required(["id"], patch_options)
assert_fields_not_required(ENTREPRENEUR_PATCH_FIELDS,
patch_options)
assert_fields_missing(NON_PATCH_FIELDS, patch_options)
assert_fields_missing(EXPERT_ONLY_MUTABLE_FIELDS, patch_options)
assert_fields_missing(EXPERT_WRITE_ONLY_FIELDS, patch_options)
assert_fields_missing(["POST"], response.data["actions"])
def test_post_without_program(self):
context = UserContext()
member = StartupTeamMemberFactory(user=context.user)
startup = member.startup
status1 = StartupStatusFactory(
program_startup_status__badge_display=BADGE_DISPLAYS[0],
program_startup_status__startup_list_include=True,
startup=startup).program_startup_status.startup_status
status2 = StartupStatusFactory(
program_startup_status__badge_display=BADGE_DISPLAYS[0],
program_startup_status__startup_list_include=True,
startup=startup).program_startup_status.startup_status
with self.login(email=self.basic_user().email):
response = self.client.post(STARTUP_DETAIL_URL,
{"StartupKey": startup.id})
assert startup.name == response.data["name"]
statuses = [
status["status_name"] for status in response.data["statuses"]
]
assert status1 in statuses
assert status2 in statuses
def _user_for_date(date):
user = UserContext().user
StartupTeamMemberFactory(user=user)
override_updated_at(get_profile(user), date)
return user
