def test_article_category(self):
self._log_as_editor()
article_class = get_article_class()
site1 = Site.objects.get(id=settings.SITE_ID)
site2 = mommy.make(Site)
cat = mommy.make(ArticleCategory)
self.assertEqual(list(cat.sites.all()), [site1])
cat2 = mommy.make(ArticleCategory)
cat2.sites.remove(site1)
cat2.sites.add(site2)
cat2.save()
self.assertEqual(list(cat2.sites.all()), [site2])
cat3 = mommy.make(ArticleCategory)
cat3.sites.remove(site1)
cat3.save()
self.assertEqual(list(cat3.sites.all()), [])
art1 = mommy.make(article_class, slug="test", category=cat, publication=BaseArticle.PUBLISHED)
url = reverse('coop_cms_article_settings', args=[art1.id])
response = self.client.get(url)
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
cat_choices = soup.select("select#id_category option")
self.assertEqual(2, len(cat_choices))
self.assertEqual("", cat_choices[0]["value"])
self.assertEqual(str(cat.id), cat_choices[1]["value"])
self.assertEqual(cat.name, cat_choices[1].text)
def test_show_carousel_several_images(self):
"""display an album"""
media_filer = mommy.make(MediaFilter, name='Album Homepage')
image1 = mommy.make(Image, _create_files=True)
image1.filters.add(media_filer)
image1.save()
image2 = mommy.make(Image, _create_files=True)
image2.filters.add(media_filer)
image2.save()
image3 = mommy.make(Image, _create_files=True)
template_content = '''
{% load coop_utils %}
{% coop_image_list 'Album Homepage' as homepage_album %}
{% include "test/carousel.html" with image_list=homepage_album %}')
'''
tpl = Template(template_content)
html = tpl.render(Context({}))
soup = BeautifulSoup(html)
tags = soup.select('img')
self.assertEqual(2, len(tags))
self.assertEqual(
sorted([img.get_absolute_url() for img in (image1, image2)]),
sorted([tag['src'] for tag in tags]),
)
def test_article_settings_no_sites(self):
other_site = mommy.make(Site)
initial_data = {'title': "test", 'content': "this is my article content"}
article_class = get_article_class()
art1 = article_class.objects.create(publication=BaseArticle.PUBLISHED, **initial_data)
self._log_as_editor()
data = {
'template': get_article_templates(None, self.user)[0][0],
'category': '',
'publication': BaseArticle.PUBLISHED,
'publication_date': "2013-01-01 12:00:00",
'headline': True,
'in_newsletter': True,
'summary': 'short summary',
'navigation_parent': None,
'sites': []
}
response = self.client.post(reverse('coop_cms_article_settings', args=[art1.id]), data=data, follow=True)
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
self.assertEqual(len(soup.select("ul.errorlist")), 1)
self.assertEqual(article_class.objects.exclude(id=art1.id).count(), 0)
art1 = article_class.objects.get(id=art1.id)
self.assertNotEqual(art1.summary, data['summary'])
self.assertEqual(sorted([a.id for a in art1.sites.all()]), [settings.SITE_ID])
def test_new_article_invalid_category_site(self):
article_class = get_article_class()
category1 = mommy.make(ArticleCategory)
category1.sites.clear()
category1.sites.add(Site.objects.get_current())
category1.save()
category2 = mommy.make(ArticleCategory)
category2.sites.clear()
category2.save()
self._log_as_editor()
data = {
'title': "Un titre",
'category': category2.id,
'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)
self.assertEqual(article_class.objects.count(), 0)
soup = BeautifulSoup(response.content)
self.assertEqual(len(soup.select("ul.errorlist")), 1)
def test_view_new_article(self):
self._log_as_editor()
url = reverse('coop_cms_new_article')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
self.assertEqual(1, len(soup.select("#id_dummy")))
def test_view_object_viewer(self):
self._log_as_viewer()
obj = mommy.make(TestClass)
response = self.client.get(obj.get_absolute_url())
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
self.assertEqual("ABC", soup.select("#properties")[0].text)
def test_view_object_viewer_bool_false(self):
self._log_as_viewer()
obj = mommy.make(TestClass, bool_field=False)
response = self.client.get(obj.get_absolute_url())
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
self.assertEqual(0, len(soup.select(".bool_field_is_true")))
self.assertEqual(1, len(soup.select(".bool_field_is_false")))
def test_view_article_settings(self):
self._log_as_editor()
article_class = coop_settings.get_article_class()
article = mommy.make(article_class, slug="test")
url = reverse('coop_cms_article_settings', args=[article.id])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
self.assertEqual(1, len(soup.select("#id_dummy")))
def test_additional_field_on_create(self):
self._log_as_editor()
url = reverse("coop_cms_new_newsletter")
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
self.assertEqual(1, len(soup.select("#id_dummy")))
def test_view_login(self):
"""test the user can view the login page"""
url = reverse("login")
response = self.client.get(url)
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
self.assertTrue(len(soup.select("input[name=email]")) > 0)
self.assertTrue(len(soup.select("input[name=password]")) > 0)
self.assertEqual(0, len(soup.select("input[name=username]")))
def test_edit_formset_no_objects(self):
self._log_as_editor()
url = reverse('coop_cms_testapp_formset_edit')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
self.assertEqual(1, len(soup.select('form')))
def test_add_link_no_title(self):
self._log_as_editor()
data = {'title': "", 'url': "http://www.google.fr", 'sites': [settings.SITE_ID]}
response = self.client.post(reverse('coop_cms_new_link'), data=data, follow=True)
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
self.assertEqual(len(soup.select("ul.errorlist")), 1)
self.assertEqual(Link.objects.count(), 0)
def test_view_article_set_homepage(self):
self._log_as_editor(can_add=True)
article_class = get_article_class()
art = mommy.make(article_class, slug="test", publication=BaseArticle.PUBLISHED)
url = art.get_edit_url()
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
url = reverse('coop_cms_set_homepage', args=[art.id])
links = soup.select('.coop-bar a[href="{0}"]'.format(url))
self.assertEqual(1, len(links))
def test_show_empty_carousel_missing_filter(self):
"""display an album"""
template_content = '''
{% load coop_utils %}
{% coop_image_list 'Album Homepage' as homepage_album %}
{% include "test/carousel.html" with image_list=homepage_album %}')
'''
tpl = Template(template_content)
html = tpl.render(Context({}))
soup = BeautifulSoup(html)
self.assertEqual(0, len(soup.select('img')))
def test_view_reason_unknown(self):
"""Check custom page with unknown"""
factory = RequestFactory()
request = factory.get('/')
request.user = AnonymousUser()
response = csrf_failure(request, "?")
self.assertEqual(403, response.status_code)
soup = BeautifulSoup(response.content)
self.assertEqual(0, len(soup.select('.cookies-error')))
self.assertEqual(0, len(soup.select('.referer-error')))
self.assertEqual(1, len(soup.select('.unknown-error')))
def test_no_a_tags(self):
"""Make sure that content is returned properly if no a tag in content"""
html = '''
<p>
<h1>Test</h1>
</p>
'''
soup = BeautifulSoup(html)
fixed_html = strip_a_tags(soup.prettify())
expected_html = '<p>\n <h1>\n Test\n </h1>\n</p>\n'
self.assertEqual(fixed_html, expected_html)
def test_additional_field_on_edit(self):
self._log_as_editor()
newsletter = mommy.make(
Newsletter,
subject="a little intro for this newsletter",
template="test/newsletter_blue.html",
)
url = reverse("coop_cms_newsletter_settings", args=[newsletter.id])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
self.assertEqual(1, len(soup.select("#id_dummy")))
def test_view_newsletter_items(self):
self._log_as_editor()
article_class = get_article_class()
site = Site.objects.get_current()
other_site = mommy.make(Site)
article_1 = mommy.make(article_class, slug="test1", in_newsletter=True)
article_2 = mommy.make(article_class, slug="test2", in_newsletter=True, sites=[other_site])
article_3 = mommy.make(article_class, slug="test3", in_newsletter=True)
article_4 = mommy.make(article_class, slug="test4", in_newsletter=False)
article_2.sites.clear()
article_2.sites.add(other_site)
article_2.save()
ct = ContentType.objects.get_for_model(article_class)
self.assertEqual(3, NewsletterItem.objects.count())
item_1 = NewsletterItem.objects.get(content_type=ct, object_id=article_1.id)
item_2 = NewsletterItem.objects.get(content_type=ct, object_id=article_2.id)
item_3 = NewsletterItem.objects.get(content_type=ct, object_id=article_3.id)
newsletter = mommy.make(
Newsletter,
subject="a little intro for this newsletter",
template="test/newsletter_red.html",
items=[item_1]
)
url = reverse("coop_cms_newsletter_settings", args=[newsletter.id])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
options = soup.select("#id_items option")
self.assertEqual(2, len(options))
self.assertEqual(
sorted([int(id_["value"]) for id_ in options]),
sorted([item.id for item in [item_1, item_3]])
)
options = soup.select("#id_items option[selected=selected]")
self.assertEqual(1, len(options))
self.assertEqual(
sorted([int(id_["value"]) for id_ in options]),
sorted([item.id for item in [item_1]])
)
def test_save_newsletter_items_no_newsletter(self):
self._log_as_editor()
article_class = get_article_class()
site = Site.objects.get_current()
other_site = mommy.make(Site)
article_1 = mommy.make(article_class, slug="test1", in_newsletter=True)
article_2 = mommy.make(article_class, slug="test2", in_newsletter=True)
article_3 = mommy.make(article_class, slug="test3", in_newsletter=True)
content_type = ContentType.objects.get_for_model(article_class)
self.assertEqual(3, NewsletterItem.objects.count())
item_1 = NewsletterItem.objects.get(content_type=content_type, object_id=article_1.id)
item_2 = NewsletterItem.objects.get(content_type=content_type, object_id=article_2.id)
item_3 = NewsletterItem.objects.get(content_type=content_type, object_id=article_3.id)
article_2.in_newsletter = False
article_2.save()
self.assertEqual(2, NewsletterItem.objects.count())
newsletter = mommy.make(
Newsletter,
subject="a little intro for this newsletter",
template="test/newsletter_red.html",
items=[item_1]
)
data = {
"subject": "test",
"template": "test/newsletter_blue.html",
'items': [item_2.id, item_3.id]
}
url = reverse("coop_cms_newsletter_settings", args=[newsletter.id])
response = self.client.post(url, data=data)
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
self.assertEqual(len(soup.select(".errorlist")), 1)
self.assertEqual(len(soup.select("#id_items")[0].parent.select(".errorlist")), 1)
newsletter = Newsletter.objects.get(id=newsletter.id)
self.assertNotEqual(newsletter.subject, data["subject"])
self.assertNotEqual(newsletter.template, data["template"])
self.assertEqual([item_1.id], [x.id for x in newsletter.items.all()])
def test_view_formset_one_object(self):
self._log_as_viewer()
obj = mommy.make(TestClass)
url = reverse('coop_cms_testapp_formset')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
self.assertEqual(0, len(soup.select('form')))
self.assertContains(response, obj.field1)
self.assertContains(response, obj.field2)
self.assertContains(response, obj.other_field)
def test_create_edit_poc(self):
tpl = Template('{% load coop_edition %}{% coop_piece_of_html "test" %}')
html = tpl.render(Context({"inline_html_edit": True}))
self.assertNotEqual(html, "")
soup = BeautifulSoup(html)
tags = soup.select("#html_editor_html_editor__coop_cms__PieceOfHtml__div_id__test__content")
self.assertEqual(len(tags), 1)
self.assertEqual(tags[0].text, "")
tags_hidden = soup.select("#html_editor_html_editor__coop_cms__PieceOfHtml__div_id__test__content_hidden")
self.assertEqual(len(tags_hidden), 1)
self.assertEqual(tags_hidden[0].get("value", ""), "")
self.assertEqual(PieceOfHtml.objects.count(), 1)
poc = PieceOfHtml.objects.all()[0]
self.assertEqual(poc.div_id, "test")
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_register_refuse_wrong_email(self):
"""It should display error"""
url = reverse('registration_register')
data = {
'email': 'john',
'password1': 'blabla-123',
'password2': 'blabla-123',
'terms_of_service': True,
}
self.assertEqual(User.objects.filter(email=data['email']).count(), 0)
response = self.client.post(url, data=data)
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
self.assertEqual(len(soup.select('.errorlist')), 1)
self.assertEqual(User.objects.filter(email=data['email']).count(), 0)
self.assertEqual(len(mail.outbox), 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_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_edit_poc_extra_id(self):
poc = mommy.make(PieceOfHtml, div_id="test", content="HELLO!!!", extra_id="1")
tpl = Template('{% load coop_edition %}{% coop_piece_of_html "test" extra_id=1 %}')
html = tpl.render(Context({"inline_html_edit": True}))
soup = BeautifulSoup(html)
#print html
tags = soup.select("input[type=hidden]")
self.assertEqual(len(tags), 1)
div_selector = tags[0].attrs['id']
div_selector = div_selector.replace("_hidden", "")
tags = soup.select("#"+div_selector)
self.assertEqual(len(tags), 1)
self.assertEqual(tags[0].text, poc.content)
self.assertEqual(PieceOfHtml.objects.count(), 1)
poc = PieceOfHtml.objects.all()[0]
self.assertEqual(poc.div_id, "test")
self.assertEqual(poc.extra_id, "1")
def test_get_language_switcher(self):
"""get article with locale slug"""
original_text = '*!-+' * 10
translated_text = ':%@/' * 9
art1 = get_article_class().objects.create(title="Home", content=original_text)
origin_lang = settings.LANGUAGES[0][0]
trans_lang = settings.LANGUAGES[1][0]
setattr(art1, 'title_' + trans_lang, 'Accueil')
setattr(art1, 'content_' + trans_lang, translated_text)
art1.save()
url = reverse('coop_cms_switch_language_popup')
response = self.client.get(url)
soup = BeautifulSoup(response.content)
self.assertEqual(len(soup.select('select#id_language option')), len(settings.LANGUAGES))
def test_show_carousel(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()
mommy.make(Image)
template_content = '''
{% load coop_utils %}
{% coop_image_list 'Album Homepage' as homepage_album %}
{% include "test/carousel.html" with image_list=homepage_album %}')
'''
tpl = Template(template_content)
html = tpl.render(Context({}))
soup = BeautifulSoup(html)
tags = soup.select('img')
self.assertEqual(1, len(tags))
self.assertEqual(image.get_absolute_url(), tags[0]['src'])
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_strip_a_tags(self):
"""Make sure that the a tags have no space inside"""
html = '''
<p>
<h1>Test</h1>
<a class="link" href="/">
Cool
</a>
<div>
<a href="/test">
Test
</a>
</div>
</p>
'''
soup = BeautifulSoup(html)
fixed_html = strip_a_tags(soup.prettify())
expected_html = '<p>\n <h1>\n Test\n </h1>\n <a class="link" href="/">Cool</a>\n <div>\n ' \
'<a href="/test">Test</a>\n </div>\n</p>\n'
self.assertEqual(fixed_html, expected_html)
def test_add_opportunity_no_desc(self):
"""create an opportunity without description"""
url = reverse("crm_add_opportunity")
data = {
'name': "DEF",
"detail": "",
}
response = self.client.post(url, data=data)
self.assertEqual(200, response.status_code)
self.assertEqual(BeautifulSoup(response.content).select('.field-error'), [])
self.assertEqual(1, models.Opportunity.objects.count())
opportunity = models.Opportunity.objects.all()[0]
for key, value in data.items():
self.assertEqual(getattr(opportunity, key), value)
def test_view_new_link(self):
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.assertNotEqual(
None,
soup.select("input#id_sites_0")[0].get("checked", None))
self.assertEqual(0, len(soup.select("input#id_sites_1")))
def test_add_relationship_no_type(self):
contact1 = mommy.make(models.Contact, firstname="John", lastname="Lennon")
contact2 = mommy.make(models.Contact, firstname="Paul", lastname="McCartney")
relation_type = mommy.make(models.RelationshipType, name="Partners")
mommy.make(models.RelationshipType, name="Friends")
mommy.make(models.RelationshipType, name="Enemies")
url = reverse("crm_add_relationship", args=[contact1.id])
response = self.client.post(url, data={'contact2': contact2.id, 'relationship_type': ''})
self.assertEqual(200, response.status_code)
errors = BeautifulSoup(response.content).select('.field-error')
self.assertEqual(len(errors), 1)
self.assertEqual(0, models.Relationship.objects.filter(contact1=contact1, contact2=contact2).count())
def test_edit_opportunity(self):
"""edit an opportunity"""
opportunity = mommy.make(models.Opportunity)
url = reverse("crm_edit_opportunity", args=[opportunity.id])
data = {
'name': "ABC",
"detail": "ooo",
}
response = self.client.post(url, data=data)
self.assertEqual(200, response.status_code)
self.assertEqual(BeautifulSoup(response.content).select('.field-error'), [])
self.assertEqual(1, models.Opportunity.objects.count())
opportunity = models.Opportunity.objects.all()[0]
for key, value in data.items():
self.assertEqual(getattr(opportunity, key), value)
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_view_name_new_search(self):
"""test view save a new search: name is empty"""
url = reverse("search_save", args=[0])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
self.assertEqual(len(soup.select("#id_name")), 1)
self.assertEqual(len(soup.select("#id_search_id")), 1)
self.assertEqual(soup.select("#id_name")[0].get("value", ""), "")
self.assertEqual(len(soup.select("#id_search_id")), 1)
self.assertEqual(soup.select("#id_search_id")[0]["value"], "0")
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_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_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_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_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_name_existing_search(self):
"""test view save an existing search: name is set"""
search = mommy.make(Search, name="ABC")
url = reverse("search_save", args=[search.id])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
self.assertEqual(len(soup.select("#id_name")), 1)
self.assertEqual(soup.select("#id_name")[0]["value"], "ABC")
self.assertEqual(len(soup.select("#id_search_id")), 1)
self.assertEqual(soup.select("#id_search_id")[0]["value"], '{0}'.format(search.id))
def test_add_relationship(self):
entity1 = mommy.make(models.Entity, name="The Beatles")
entity2 = mommy.make(models.Entity, name="Apple Records")
contact1 = mommy.make(models.Contact, entity=entity1, firstname="John", lastname="Lennon")
contact2 = mommy.make(models.Contact, entity=entity2, firstname="Paul", lastname="McCartney")
relation_type = mommy.make(models.RelationshipType, name="Partners")
mommy.make(models.RelationshipType, name="Friends")
mommy.make(models.RelationshipType, name="Enemies")
url = reverse("crm_add_relationship", args=[contact1.id])
response = self.client.post(url, data={'contact2': contact2.id, 'relationship_type': relation_type.id})
self.assertEqual(200, response.status_code)
errors = BeautifulSoup(response.content).select('.field-error')
self.assertEqual(list(errors), [])
#refresh
contact1 = models.Contact.objects.get(id=contact1.id)
contact2 = models.Contact.objects.get(id=contact2.id)
r = models.Relationship.objects.get(contact1=contact1, contact2=contact2)
self.assertEqual(r.relationship_type, relation_type)
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_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_has_address_contact(self, has_address=True):
"""has address on contacts"""
city1 = mommy.make(models.City, name="ZooPark")
mommy.make(models.City, name="VodooPark")
entity1, contact1 = self._make_contact("ABCD", None, "")
contact1.city = city1
contact1.zip_code = "44444"
contact1.address = "123 something street"
contact1.save()
contact5 = mommy.make(models.Contact, entity=entity1, lastname="QRST")
entity2, contact2 = self._make_contact("EFGH", None, "")
contact2.city = city1
contact2.zip_code = "4444"
contact2.save()
entity3, contact3 = self._make_contact("IJKL", None, "44444")
contact3.city = city1
contact3.zip_code = "44444"
contact3.save()
entity4, contact4 = self._make_contact("MNOP", None, "")
contact4.city = None
contact4.zip_code = ""
contact4.save()
response = self.client.post(
reverse('search'),
data={"gr0-_-has_address-_-0": 1 if has_address else 0})
self.assertEqual(200, response.status_code)
self.assertEqual(
0, len(BeautifulSoup(response.content).select('.field-error')))
def test_add_reversed_relationship(self):
contact1 = mommy.make(models.Contact, firstname="Alex", lastname="Ferguson")
contact2 = mommy.make(models.Contact, firstname="Eric", lastname="Cantona")
relation_type = mommy.make(models.RelationshipType, name="Coach of", reverse="Player of")
url = reverse("crm_add_relationship", args=[contact2.id])
response = self.client.get(url)
self.assertEqual(200, response.status_code)
self.assertContains(response, relation_type.name)
self.assertContains(response, relation_type.reverse)
response = self.client.post(url, data={'contact2': contact1.id, 'relationship_type': -relation_type.id})
self.assertEqual(200, response.status_code)
errors = BeautifulSoup(response.content).select('.field-error')
self.assertEqual(list(errors), [])
#refresh
contact1 = models.Contact.objects.get(id=contact1.id)
contact2 = models.Contact.objects.get(id=contact2.id)
r = models.Relationship.objects.get(contact1=contact1, contact2=contact2)
self.assertEqual(r.relationship_type, relation_type)
def test_create_action(self):
"""create an action: check user is set as last_modified_by"""
url = reverse('crm_create_action', args=[0, 0])
data = {
'subject': "tested",
'type': '',
'date': "2014-01-31",
'time': "11:34",
'status': '',
'in_charge': '',
'detail': "ABCDEF",
'amount': 200,
'number': 5
}
response = self.client.post(url, data=data, follow=True)
self.assertEqual(response.status_code, 200)
errors = BeautifulSoup(response.content).select('.field-error')
self.assertEqual(list(errors), [])
self.assertEqual(models.Action.objects.count(), 1)
action = models.Action.objects.all()[0]
self.assertEqual(action.subject, data["subject"])
self.assertEqual(action.last_modified_by, self.user)
def _test_search_multi_zones(self,
cities=None,
data=None,
entity_search=False):
"""search by zone"""
city1 = cities[0]
city2 = cities[1]
city3 = mommy.make(models.City, name="BlablaPark")
entity1 = mommy.make(models.Entity,
city=city1 if entity_search else None)
contact1a = entity1.default_contact
contact1a.lastname = "ABCDEFGH"
contact1a.main_contact = True
contact1a.has_left = False
contact1a.city = city1
contact1a.save()
contact1b = mommy.make(models.Contact,
entity=entity1,
lastname="IJKLMNOP",
main_contact=True,
has_left=False)
entity2 = mommy.make(models.Entity,
city=city2 if entity_search else None)
contact2 = entity2.default_contact
contact2.lastname = "DEFGHIJKL"
contact2.main_contact = True
contact2.has_left = False
contact2.city = None if entity_search else city2
contact2.save()
entity3 = mommy.make(models.Entity)
contact3 = entity3.default_contact
contact3.lastname = "MNOPQRST"
contact3.main_contact = True
contact3.has_left = False
contact3.city = city3
contact3.save()
url = reverse('search')
response = self.client.post(url, data=data)
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
self.assertEqual([], soup.select('.field-error'))
self.assertContains(response, entity1.name)
self.assertContains(response, contact1a.lastname)
if entity_search:
self.assertContains(response, contact1b.lastname)
else:
self.assertNotContains(response, contact1b.lastname)
self.assertContains(response, entity2.name)
self.assertContains(response, contact2.lastname)
self.assertNotContains(response, entity3.name)
self.assertNotContains(response, contact3.lastname)
def test_view_search(self):
"""test view search and field choice is populated"""
response = self.client.get(reverse('search'))
self.assertEqual(200, response.status_code)
soup = BeautifulSoup(response.content)
self.assertTrue(len(soup.select("#id_field_choice option")) > 0)
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')
