def test_change_unknown_command(self):
entity = mommy.make(models.Entity, is_single_contact=False)
contact = mommy.make(models.Contact, entity=entity)
entity2 = mommy.make(models.Entity, is_single_contact=True)
url = reverse('crm_change_contact_entity', args=[contact.id])
data= {
'option': 555,
}
response = self.client.post(url, data=data, follow=True)
self.assertEqual(response.status_code, 200)
errors = BeautifulSoup(response.content).select('.field-error')
self.assertEqual(len(errors), 1)
contact = models.Contact.objects.get(id=contact.id)
self.assertEqual(contact.entity, entity)
def test_view_change_contact_entity_single(self):
entity = mommy.make(models.Entity, is_single_contact=True)
contact = mommy.make(models.Contact, entity=entity)
url = reverse('crm_change_contact_entity', args=[contact.id])
response = self.client.get(url, follow=True)
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
expected = [
self.OPTION_ADD_TO_EXISTING_ENTITY,
#self.OPTION_CREATE_NEW_ENTITY,
#self.OPTION_SWITCH_SINGLE_CONTACT,
self.OPTION_SWITCH_ENTITY_CONTACT
]
self.assertEqual(
[x["value"] for x in soup.select("select option")],
["0"]+[str(x) for x in expected]
)
def test_change_contact_entity_invalid_value(self):
entity = mommy.make(models.Entity, is_single_contact=False)
contact = mommy.make(models.Contact, entity=entity)
url = reverse('crm_change_contact_entity', args=[contact.id])
data= {
'option': self.OPTION_ADD_TO_EXISTING_ENTITY,
'entity': 'AAA',
}
response = self.client.post(url, data=data, follow=True)
self.assertEqual(response.status_code, 200)
errors = BeautifulSoup(response.content).select('.field-error')
self.assertEqual(len(errors), 1)
contact = models.Contact.objects.get(id=contact.id)
self.assertEqual(contact.entity, entity)
def test_search_email_full(self):
"""search full emai address"""
entity1 = mommy.make(models.Entity, name="My tiny corp")
contact1 = mommy.make(models.Contact,
email="*****@*****.**",
entity=entity1,
lastname="ABCD",
main_contact=True,
has_left=False)
contact3 = mommy.make(models.Contact,
entity=entity1,
lastname="IJKL",
main_contact=True,
has_left=False)
entity2 = mommy.make(models.Entity,
name="Other corp",
email="*****@*****.**")
contact2 = mommy.make(models.Contact,
entity=entity2,
lastname="WXYZ",
main_contact=True,
has_left=False)
contact4 = mommy.make(models.Contact,
entity=entity2,
lastname="RTYU",
main_contact=True,
has_left=False)
url = reverse('search')
data = {"gr0-_-contact_entity_email-_-0": "*****@*****.**"}
response = self.client.post(url, data=data)
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
self.assertEqual(0, len(soup.select('.field-error')))
self.assertNotContains(response, entity1.name)
self.assertNotContains(response, contact1.lastname)
self.assertNotContains(response, contact3.lastname)
self.assertContains(response, entity2.name)
self.assertContains(response, contact2.lastname)
self.assertContains(response, contact4.lastname)
def test_search_custom_pagination_less(self):
"""less than custom number, it should not display pagination"""
entities = [mommy.make(models.Entity, name="tiny{0:02d}#".format(i)) for i in range(10)]
url = reverse('search')
data = {"gr0-_-entity_name-_-0": 'tiny'}
response = self.client.post(url, data=data)
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
self.assertEqual(0, len(soup.select('ul.pagination')))
for entity in entities:
self.assertContains(response, entity.name)
def test_search_city_entity(self, cities=None, data=None):
"""search by city of the entity"""
if cities:
city1 = cities[0]
city2 = cities[1]
else:
city1 = mommy.make(models.City, name="ZooPark")
city2 = mommy.make(models.City, name="VodooPark")
entity1 = mommy.make(models.Entity, city=city1)
contact1 = entity1.default_contact
contact1.lastname = "ABCDEFGH"
contact1.main_contact = True
contact1.has_left = False
contact1.save()
contact3 = mommy.make(models.Contact,
entity=entity1,
lastname="IJKLMNOP",
main_contact=True,
has_left=False)
entity2 = mommy.make(models.Entity, city=city2)
contact2 = entity2.default_contact
contact2.lastname = "DEFGHIJKL"
contact2.main_contact = True
contact2.has_left = False
contact2.save()
url = reverse('search')
data = data or {"gr0-_-city-_-0": city1.id}
response = self.client.post(url, data=data)
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
self.assertEqual(0, len(soup.select('.field-error')))
self.assertContains(response, entity1.name)
self.assertContains(response, contact1.lastname)
self.assertContains(response, contact3.lastname)
self.assertNotContains(response, entity2.name)
self.assertNotContains(response, contact2.lastname)
def test_search_zipcode(self):
"""search zipcode"""
city1 = mommy.make(models.City, name="ZooPark")
city2 = mommy.make(models.City, name="VodooPark")
entity1 = mommy.make(models.Entity)
contact1 = entity1.default_contact
contact1.lastname = "ABCDEFGH"
contact1.main_contact = True
contact1.has_left = False
contact1.city = city1
contact1.zip_code = "42810"
contact1.save()
contact3 = mommy.make(models.Contact,
entity=entity1,
lastname="IJKLMNOP",
main_contact=True,
has_left=False)
entity2 = mommy.make(models.Entity)
contact2 = entity2.default_contact
contact2.lastname = "DEFGHIJKL"
contact2.main_contact = True
contact2.has_left = False
contact2.city = city2
contact2.zip_code = "26100"
contact2.save()
url = reverse('search')
data = {"gr0-_-zip_code-_-0": "42"}
response = self.client.post(url, data=data)
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
self.assertEqual(0, len(soup.select('.field-error')))
self.assertContains(response, entity1.name)
self.assertContains(response, contact1.lastname)
self.assertNotContains(response, contact3.lastname)
self.assertNotContains(response, entity2.name)
self.assertNotContains(response, contact2.lastname)
def test_action_no_menu(self):
"""test action is displayed if no custom menu"""
action_type1 = mommy.make(models.ActionType)
action = mommy.make(models.Action, type=action_type1)
entity = mommy.make(models.Entity)
action.entities.add(entity)
action.save()
url = reverse('crm_view_entity', args=[entity.id])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
li_tags = soup.select('.ut-custom-action-menu-item')
self.assertEqual(len(li_tags), 0)
def test_show_carousel_context_var(self):
"""display an album"""
media_filer = mommy.make(MediaFilter, name='Album Homepage')
image = mommy.make(Image, _create_files=True)
image.filters.add(media_filer)
image.save()
template_content = '''
{% load coop_utils %}
{% coop_image_list album_name as homepage_album %}
{% include "test/carousel.html" with image_list=homepage_album %}')
'''
tpl = Template(template_content)
html = tpl.render(Context({'album_name': 'Album Homepage'}))
soup = BeautifulSoup(html)
self.assertEqual(1, len(soup.select('img')))
def test_view_update_emailing_lang(self):
"""check the display of the page"""
emailing = mommy.make(Emailing)
url = reverse("emailing_update_emailing", kwargs={'pk': emailing.id})
response = self.client.get(url)
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
self.assertEqual(3, len(soup.select("select#id_lang option")))
self.assertEqual('', soup.select("select#id_lang option")[0]["value"])
self.assertEqual('en',
soup.select("select#id_lang option")[1]["value"])
self.assertEqual('fr',
soup.select("select#id_lang option")[2]["value"])
def test_edit_entity_keep_notes(self):
"""test misisng fields nor changed"""
entity = mommy.make(models.Entity, is_single_contact=False, notes="Toto")
url = reverse('crm_edit_entity', args=[entity.id])
data = {
'name': 'Dupond SA',
}
response = self.client.post(url, data=data)
self.assertEqual(200, response.status_code)
errors = BeautifulSoup(response.content).select('.field-error')
self.assertEqual(len(errors), 0)
next_url = reverse('crm_view_entity', args=[entity.id])
self.assertContains(response, "<script>")
self.assertContains(response, next_url)
entity = models.Entity.objects.get(id=entity.id)
self.assertEqual(entity.name, data['name'])
self.assertEqual(entity.notes, 'Toto')
def test_post_clone_no_type(self):
"""it should not clone and show error"""
action_type_1 = mommy.make(models.ActionType)
action_type_2 = mommy.make(models.ActionType)
action_type_1.next_action_types.add(action_type_2)
action_type_1.save()
action = mommy.make(models.Action, type=action_type_1)
data = {'action_type': ''}
response = self.client.post(reverse('crm_clone_action',
args=[action.id]),
data=data)
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
self.assertEqual(len(soup.select(".error-msg")), 1)
self.assertEqual(1, models.Action.objects.count())
def test_create_action_calculated_amount(self):
"""create with calculated amount"""
action_type = mommy.make(ActionType, is_amount_calculated=False)
mommy.make(models.StoreManagementActionType,
action_type=action_type,
show_amount_as_pre_tax=False)
action_type = ActionType.objects.get(id=action_type.id)
self.assertEqual(action_type.is_amount_calculated, True)
url = reverse('crm_create_action_of_type', args=[0, 0, action_type.id])
response = self.client.get(url)
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
fields = soup.select("#id_amount")
self.assertEqual(len(fields), 1)
self.assertEqual(fields[0]["disabled"], "disabled")
def test_create_contact(self):
"""create a contact: check user is set as last_modified_by"""
url = reverse('crm_add_single_contact')
data = {
'lastname': "Doe",
'firstname': 'John',
}
response = self.client.post(url, data=data, follow=True)
self.assertEqual(response.status_code, 200)
errors = BeautifulSoup(response.content).select('.field-error')
self.assertEqual(len(errors), 0)
self.assertEqual(models.Contact.objects.count(), 1)
john_doe = models.Contact.objects.all()[0]
self.assertEqual(john_doe.lastname, "Doe")
self.assertEqual(john_doe.firstname, "John")
self.assertEqual(john_doe.entity.is_single_contact, True)
self.assertEqual(john_doe.last_modified_by, self.user)
def test_view_clone_action_1_type(self):
"""it should display hidden input for the only allowed type"""
action_type_1 = mommy.make(models.ActionType)
action_type_2 = mommy.make(models.ActionType)
action_type_1.next_action_types.add(action_type_2)
action_type_1.save()
action = mommy.make(models.Action, type=action_type_1)
response = self.client.get(
reverse('crm_clone_action', args=[action.id]))
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
html_fields = soup.select("#id_action_type")
self.assertEqual(1, len(html_fields))
self.assertEqual(html_fields[0]["type"], "hidden")
self.assertEqual(html_fields[0]["value"],
"{0}".format(action_type_2.id))
def test_view_new_link_two_sites(self):
mommy.make(Site)
url = reverse('coop_cms_new_link')
self._log_as_editor()
response = self.client.get(url)
self.assertEqual(200, response.status_code)
self.assertEqual(Link.objects.count(), 0)
soup = BeautifulSoup(response.content)
self.assertEqual(1, len(soup.select("input#id_title")))
self.assertEqual(1, len(soup.select("input#id_url")))
self.assertEqual(1, len(soup.select("input#id_sites_0")))
self.assertEqual(1, len(soup.select("input#id_sites_1")))
elt1 = soup.select("input#id_sites_0")[0]
elt2 = soup.select("input#id_sites_1")[0]
for elt in (elt1, elt2):
# Only the current site is checked
self.assertEqual('checked' in elt,
elt["value"] == settings.SITE_ID)
def test_search_no_pagination(self):
"""less than default number, it should not display pagination"""
del settings.BALAFON_SEARCH_NB_IN_PAGE # use default settings
entities = [mommy.make(models.Entity, name="tiny{0:02d}#".format(i)) for i in range(50)]
url = reverse('search')
data = {"gr0-_-entity_name-_-0": 'tiny'}
response = self.client.post(url, data=data)
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
self.assertEqual(0, len(soup.select('ul.pagination')))
for entity in entities:
self.assertContains(response, entity.name)
def test_search_contact_or_entity_modified_by(self):
"""by modification"""
user1 = mommy.make(models.User, is_staff=True, is_active=True)
user2 = mommy.make(models.User, is_staff=True, is_active=True)
contact1 = mommy.make(
models.Contact, lastname="ABCD", email="*****@*****.**", main_contact=True, has_left=False,
last_modified_by=None
)
contact1.entity.name = 'Tiny Corp'
contact1.entity.default_contact.delete()
contact1.entity.last_modified_by = user1
contact1.entity.save()
contact2 = mommy.make(
models.Contact, lastname="IJKL", email="*****@*****.**", main_contact=True, has_left=False,
last_modified_by=user1
)
contact2.entity.name = 'Other Corp'
contact2.entity.default_contact.delete()
contact2.entity.save()
contact3 = mommy.make(
models.Contact, lastname="MNOP", email="*****@*****.**", main_contact=True, has_left=False,
last_modified_by=None
)
contact3.entity.name = 'Big Corp'
contact3.entity.default_contact.delete()
contact3.entity.last_modified_by = user2
contact3.entity.save()
url = reverse('search')
data = {"gr0-_-contacts_and_entities_modified_by-_-0": user1.id}
response = self.client.post(url, data=data)
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
self.assertEqual(0, len(soup.select('.field-error')))
self.assertContains(response, contact1.email)
self.assertContains(response, contact2.email)
self.assertNotContains(response, contact3.email)
def test_edit_entity(self):
"""edit entity"""
entity = mommy.make(models.Entity, is_single_contact=False)
url = reverse('crm_edit_entity', args=[entity.id])
data = {
'name': 'Dupond SA',
'city': models.City.objects.get(name="Paris").id,
}
response = self.client.post(url, data=data)
self.assertEqual(200, response.status_code)
errors = BeautifulSoup(response.content).select('.field-error')
self.assertEqual(len(errors), 0)
next_url = reverse('crm_view_entity', args=[entity.id])
self.assertContains(response, "<script>")
self.assertContains(response, next_url)
entity = models.Entity.objects.get(id=entity.id)
self.assertEqual(entity.name, data['name'])
self.assertEqual(entity.city.id, data['city'])
def test_open_search(self):
"""test open an existing search"""
group1 = mommy.make(models.Group)
search = mommy.make(Search)
search_group = mommy.make(SearchGroup, name="gr0", search=search)
mommy.make(
SearchField, field='group', value='{0}'.format(group1.id), is_list=False, search_group=search_group
)
url = reverse("search", args=[search.id])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
self.assertEqual(soup.select("input[name=gr0-_-group-_-0]")[0]["value"], '{0}'.format(group1.id))
def test_action_menu_status(self):
"""test custom menus are displayed"""
action_type1 = mommy.make(models.ActionType)
action_status1 = mommy.make(models.ActionStatus)
action_status2 = mommy.make(models.ActionStatus)
action_type1.allowed_status.add(action_status1)
action_type1.allowed_status.add(action_status2)
action_type1.save()
action = mommy.make(models.Action, type=action_type1, status=action_status1)
entity = mommy.make(models.Entity)
action.entities.add(entity)
action.save()
menu1 = mommy.make(
models.ActionMenu, action_type=action_type1,
icon="cog", label="DO ME", view_name='crm_do_action', a_attrs='class="colorbox-form"', order_index=2
)
menu1.only_for_status.add(action_status1)
menu1.save()
menu2 = mommy.make(
models.ActionMenu, action_type=action_type1,
icon="remove", label="DELETE ME", view_name='crm_delete_action', a_attrs='target="_blank"', order_index=1
)
menu2.only_for_status.add(action_status2)
menu2.save()
url = reverse('crm_view_entity', args=[entity.id])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
li_tags = soup.select('.ut-custom-action-menu-item')
self.assertEqual(len(li_tags), 1)
self.assertEqual(li_tags[0].text.strip(), menu1.label)
self.assertEqual(li_tags[0].a['class'], ['colorbox-form'])
self.assertEqual(li_tags[0].a['href'], reverse('crm_do_action', args=[action.id]))
self.assertEqual(li_tags[0].a.i['class'], ['fas', 'fa-{0}'.format(menu1.icon)])
def test_view_update_emailing(self):
"""check the display of the page"""
subscription_type1 = mommy.make(models.SubscriptionType)
subscription_type2 = mommy.make(models.SubscriptionType)
newsletter1 = mommy.make(Newsletter)
newsletter2 = mommy.make(Newsletter)
emailing = mommy.make(Emailing,
subscription_type=subscription_type1,
newsletter=newsletter1)
url = reverse("emailing_update_emailing", kwargs={'pk': emailing.id})
response = self.client.get(url)
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
self.assertEqual(
2, len(soup.select("select#id_subscription_type option")))
self.assertEqual(
subscription_type1.id,
int(soup.select("select#id_subscription_type option")[0]["value"]))
self.assertEqual(
"selected",
soup.select("select#id_subscription_type option")[0]["selected"])
self.assertEqual(
subscription_type2.id,
int(soup.select("select#id_subscription_type option")[1]["value"]))
self.assertEqual(2, len(soup.select("select#id_newsletter option")))
self.assertEqual(
newsletter1.id,
int(soup.select("select#id_newsletter option")[0]["value"]))
self.assertEqual(
"selected",
soup.select("select#id_newsletter option")[0]["selected"])
self.assertEqual(
newsletter2.id,
int(soup.select("select#id_newsletter option")[1]["value"]))
def test_view_clone_action_2_types(self):
"""it should display a select with allowed types"""
action_type_1 = mommy.make(models.ActionType, order_index=1)
action_type_2 = mommy.make(models.ActionType, order_index=2)
action_type_3 = mommy.make(models.ActionType, order_index=3)
action_type_1.next_action_types.add(action_type_2)
action_type_1.next_action_types.add(action_type_3)
action_type_1.save()
action = mommy.make(models.Action, type=action_type_1)
response = self.client.get(reverse('crm_clone_action', args=[action.id]))
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
html_fields = soup.select("#id_action_type")
self.assertEqual(1, len(html_fields))
options = html_fields[0].select("option")
self.assertEqual(len(options), 2)
self.assertEqual(options[0]["value"], "{0}".format(action_type_2.id))
self.assertEqual(options[1]["value"], "{0}".format(action_type_3.id))
def test_new_article_title_required(self):
article_class = get_article_class()
self._log_as_editor()
data = {
'title': "",
'publication': BaseArticle.DRAFT,
'template': get_article_templates(None, self.user)[0][0],
'navigation_parent': None,
'sites': [settings.SITE_ID]
}
response = self.client.post(reverse('coop_cms_new_article'),
data=data,
follow=True)
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
self.assertEqual(article_class.objects.count(), 0)
self.assertEqual(len(soup.select("ul.errorlist")), 1)
def test_update_entity(self):
"""update an entity: check user is set as last_modified_by"""
user2 = User.objects.create(username="******", is_staff=True)
user2.set_password("abc")
user2.save()
self.client.login(username="******", password="******")
entity = mommy.make(models.Entity, is_single_contact=False)
url = reverse('crm_edit_entity', args=[entity.id])
data = {
'name': 'Dupond SA',
}
response = self.client.post(url, data=data)
self.assertEqual(200, response.status_code)
errors = BeautifulSoup(response.content).select('.field-error')
self.assertEqual(len(errors), 0)
entity = models.Entity.objects.get(id=entity.id)
self.assertEqual(entity.name, data['name'])
self.assertEqual(entity.last_modified_by, user2)
def test_view_new_article(self):
other_site = mommy.make(Site)
category1 = mommy.make(ArticleCategory)
category1.sites.clear()
category1.sites.add(Site.objects.get_current())
category1.save()
category2 = mommy.make(ArticleCategory)
category2.sites.clear()
category2.sites.add(Site.objects.get_current())
category2.sites.add(other_site)
category2.save()
category3 = mommy.make(ArticleCategory)
category3.sites.clear()
category3.sites.add(other_site)
category3.save()
category4 = mommy.make(ArticleCategory)
category4.sites.clear()
category4.save()
self._log_as_editor()
response = self.client.get(reverse('coop_cms_new_article'))
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
categories_select_node = soup.select("select#id_category")[0]
categories = [
node.text for node in categories_select_node.select('option')
]
self.assertEqual(3, len(categories))
self.assertTrue('---------' in categories)
self.assertTrue(category1.name in categories)
self.assertTrue(category2.name in categories)
self.assertTrue(category3.name not in categories)
self.assertTrue(category4.name not in categories)
def test_view_register(self):
"""It should display form"""
user_count = User.objects.count()
url = reverse('registration_register')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(User.objects.count(), user_count)
self.assertEqual(len(mail.outbox), 0)
soup = BeautifulSoup(response.content)
self.assertEqual(len(soup.select("input#id_email")), 1)
self.assertEqual(len(soup.select("input#id_password1")), 1)
self.assertEqual(len(soup.select("input#id_password2")), 1)
self.assertEqual(len(soup.select("input#id_username")), 1)
self.assertEqual(len(soup.select("input#id_terms_of_service")), 1)
self.assertEqual(soup.select("input#id_email")[0]['type'], 'email')
self.assertEqual(soup.select("input#id_password1")[0]['type'], 'password')
self.assertEqual(soup.select("input#id_password2")[0]['type'], 'password')
self.assertEqual(soup.select("input#id_username")[0]['type'], 'hidden')
self.assertEqual(soup.select("input#id_terms_of_service")[0]['type'], 'checkbox')
def test_view_emailing_sent(self):
"""view form no emailing sent"""
mommy.make(Emailing, status=Emailing.STATUS_EDITING)
emailing2 = mommy.make(Emailing, status=Emailing.STATUS_SENDING, scheduling_dt=datetime.now())
emailing3 = mommy.make(
Emailing, status=Emailing.STATUS_SENT, scheduling_dt=datetime.now(), sending_dt=datetime.now()
)
mommy.make(Emailing, status=Emailing.STATUS_SCHEDULED, scheduling_dt=datetime.now())
url = reverse('search_get_field', args=['emailing_sent'])
url += "?block=gr0&count=0"
response = self.client.get(url)
self.assertEqual(200, response.status_code)
data = response_as_json(response)
soup = BeautifulSoup(data['form'])
selector = soup.select("select#id_gr0-_-emailing_sent-_-0 option")
self.assertEqual(3, len(selector))
self.assertEqual("", selector[0]["value"])
self.assertEqual(emailing3.id, int(selector[1]["value"]))
self.assertEqual(emailing2.id, int(selector[2]["value"]))
def test_view_opportunity_contact_has_left(self):
"""view opportunity with contact who left"""
entity1 = mommy.make(models.Entity, relationship_date='2012-01-30')
opp1 = mommy.make(models.Opportunity)
contact1 = mommy.make(models.Contact, lastname='ABC', entity=entity1)
contact2 = mommy.make(models.Contact, lastname='DEF', entity=entity1, has_left=True)
act1 = mommy.make(models.Action, opportunity=opp1)
act1.contacts.add(contact1)
act1.contacts.add(contact2)
act1.save()
response = self.client.get(reverse('crm_view_opportunity', args=[opp1.id]))
self.assertEqual(200, response.status_code)
self.assertContains(response, contact1.lastname)
self.assertContains(response, contact2.lastname)
soup = BeautifulSoup(response.content)
self.assertEqual(len(soup.select("td.ut-contact-{0} .ut-has-left".format(contact1.id))), 0)
self.assertEqual(len(soup.select("td.ut-contact-{0} .ut-has-left".format(contact2.id))), 1)
def test_view_photos_gallery(self):
"""view photos"""
self._log_as_mediamgr(perm=self._permission("add", Photo))
gallery = mommy.make(Gallery)
photo1 = mommy.make(Photo)
photo1.galleries.add(gallery)
photo1.save()
mommy.make(Photo)
response = self.client.get(reverse('coop_cms_media_photologue'))
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
nodes = soup.select(".library-thumbnail")
self.assertEqual(2, len(nodes))
nodes = soup.select(".media-filters a")
#All + gallery
self.assertEqual(2, len(nodes))
