def test_article_detail(self):
"""
Teste da ``view function`` ``article_detail``, deve retornar uma página
que usa o template ``article/detail.html``.
"""
with current_app.app_context():
collection = utils.makeOneCollection()
resource = utils.makeOneResource()
journal = utils.makeOneJournal()
issue = utils.makeOneIssue({'journal': journal})
article = utils.makeOneArticle({'title': 'Article Y',
'htmls': [resource],
'issue': issue,
'journal': journal,
'url_segment': '10-11'})
response = self.client.get(url_for('main.article_detail',
url_seg=journal.url_segment,
url_seg_issue=issue.url_segment,
url_seg_article=article.url_segment,
lang_code='pt'))
self.assertStatus(response, 200)
self.assertTemplateUsed('article/detail.html')
self.assertEqual(self.get_context_variable('article').id, article.id)
self.assertEqual(self.get_context_variable('journal').id, article.journal.id)
self.assertEqual(self.get_context_variable('issue').id, article.issue.id)
def test_journal_open_access_in_issue_grid(self):
"""
Testa se os links e o conteúdo da licença este de acordo com a licença
cadastrado no periódico.
"""
with current_app.app_context():
collection = utils.makeOneCollection()
journal = utils.makeOneJournal()
issue = utils.makeOneIssue({'journal': journal})
with self.client as c:
response = c.get(url_for('main.issue_grid',
url_seg=journal.url_segment))
self.assertStatus(response, 200)
self.assertTemplateUsed('issue/grid.html')
self.assertIn('/static/img/oa_logo_32.png', response.data)
self.assertIn('href="%s"' % url_for('main.open_access'), response.data)
self.assertIn('Open Access', response.data)
def test_collection_list_feed(self):
"""
Teste para verificar a reposta da ``view funciton``collection_list_feed
Se cadastra 10 periódicos, deve retornar na interface do rss, utilizando
o template ``collection/list_feed_content.html```.
"""
with current_app.app_context():
collection = utils.makeOneCollection()
journals = utils.makeAnyJournal(items=10)
issues = []
for journal in journals:
issue = utils.makeOneIssue({'journal': journal.id})
utils.makeAnyArticle(
issue=issue,
attrib={'journal': journal.id, 'issue': issue.id}
)
issues.append(issue)
response = self.client.get(url_for('main.collection_list_feed'))
self.assertStatus(response, 200)
self.assertTemplateUsed('collection/list_feed_content.html')
for journal in journals:
self.assertIn('%s' % journal.url_segment,
response.data.decode('utf-8'))
for issue in issues:
self.assertIn('%s' % issue.url_segment,
response.data.decode('utf-8'))
def test_journal_without_social_networks_show_no_links(self):
"""
COM:
- Periódico sem redes socials
QUANDO:
- Acessarmos a home do periódico
VERIFICAMOS:
- Que não aparece a seção de redes sociais
- O div com class="journalLinks" deve aparecer
"""
with current_app.app_context():
# with
collection = utils.makeOneCollection()
journal = utils.makeOneJournal({'collection': collection})
with self.client as c:
# when
response = c.get(url_for('main.journal_detail', url_seg=journal.url_segment))
# then
self.assertEqual(journal.social_networks, [])
self.assertStatus(response, 200)
social_networks_class = u"journalLinks"
self.assertIn(social_networks_class, response.data.decode('utf-8'))
twitter_btn_class = u"bigTwitter"
self.assertNotIn(twitter_btn_class, response.data.decode('utf-8'))
facebook_btn_class = u"bigFacebook"
self.assertNotIn(facebook_btn_class, response.data.decode('utf-8'))
google_btn_class = u"bigGooglePlus"
self.assertNotIn(google_btn_class, response.data.decode('utf-8'))
def test_collection_sponsors_at_homepage(self):
"""
acessar na homepage deve mostrar os sponsors no rodapé
"""
# with
with current_app.app_context():
collection = utils.makeOneCollection()
sponsor1 = utils.makeOneSponsor({'name': 'spo1', 'url': 'http://sponsor1.com', 'logo_url': 'http://sponsor1.com/logo1.png'})
sponsor2 = utils.makeOneSponsor({'name': 'spo2', 'url': 'http://sponsor2.com', 'logo_url': 'http://sponsor2.com/logo1.png'})
sponsor3 = utils.makeOneSponsor({'name': 'spo3', 'url': 'http://sponsor2.com', 'logo_url': 'http://sponsor2.com/logo1.png'})
collection.sponsors = [
sponsor1,
sponsor2,
sponsor3,
]
collection.save()
# when
response = self.client.get(url_for('main.index'))
# then
self.assertStatus(response, 200)
self.assertIn('<div class="partners">', response.data.decode('utf-8'))
for sponsor in [sponsor1, sponsor2, sponsor3]:
self.assertIn(sponsor.name, response.data.decode('utf-8'))
self.assertIn(sponsor.url, response.data.decode('utf-8'))
self.assertIn(sponsor.logo_url, response.data.decode('utf-8'))
def test_journal_detail_mission_with_EN_language(self):
"""
Teste para verificar se na interface inicial da revista esta retornando
o texto no idioma Inglês.
"""
journal = utils.makeOneJournal()
with self.client as c:
# Criando uma coleção para termos o objeto ``g`` na interface
collection = utils.makeOneCollection()
header = {'Referer': url_for('main.journal_detail',
url_seg=journal.url_segment)}
response = c.get(url_for('main.set_locale',
lang_code='en'),
headers=header,
follow_redirects=True)
self.assertEqual(200, response.status_code)
self.assertEqual(flask.session['lang'], 'en')
self.assertIn(u"This journal is aiming xpto",
response.data.decode('utf-8'))
def test_the_title_of_the_article_list_without_unknow_language_for_article(self):
"""
Teste para verificar se a interface do TOC esta retornando o título no
idioma original quando não conhece o idioma.
"""
journal = utils.makeOneJournal()
with self.client as c:
# Criando uma coleção para termos o objeto ``g`` na interface
collection = utils.makeOneCollection()
issue = utils.makeOneIssue({"journal": journal})
translated_titles = []
article = utils.makeOneArticle(
{"issue": issue, "title": "Article Y", "translated_titles": translated_titles}
)
header = {
"Referer": url_for("main.issue_toc", url_seg=journal.url_segment, url_seg_issue=issue.url_segment)
}
response = c.get(url_for("main.set_locale", lang_code="es_MX"), headers=header, follow_redirects=True)
self.assertEqual(200, response.status_code)
self.assertEqual(flask.session["lang"], "es_MX")
self.assertIn(u"Article Y", response.data.decode("utf-8"))
def test_issue_feed(self):
"""
Teste da ``view function`` ``issue_feed``, deve retornar um rss
que usa o template ``issue/feed_content.html`` e o título do periódico no
corpo da página.
"""
with current_app.app_context():
collection = utils.makeOneCollection()
journal = utils.makeOneJournal()
issue = utils.makeOneIssue({'number': '31',
'volume': '10',
'journal': journal})
articles = utils.makeAnyArticle(
issue=issue,
attrib={'journal': issue.journal.id, 'issue': issue.id}
)
response = self.client.get(url_for('main.issue_feed',
url_seg=journal.url_segment,
url_seg_issue=issue.url_segment))
self.assertStatus(response, 200)
self.assertTemplateUsed('issue/feed_content.html')
self.assertIn(u'Vol. 10 No. 31', response.data.decode('utf-8'))
def test_the_title_of_the_article_list_when_language_EN(self):
"""
Teste para verificar se a interface do TOC esta retornando o título no
idioma Inglês.
"""
journal = utils.makeOneJournal()
with self.client as c:
# Criando uma coleção para termos o objeto ``g`` na interface
collection = utils.makeOneCollection()
issue = utils.makeOneIssue({"journal": journal})
translated_titles = [
{"name": "Artigo Com Título Em Português", "language": "pt"},
{"name": "Título Del Artículo En Portugués", "language": "es"},
{"name": "Article Title In Portuguese", "language": "en"},
]
article = utils.makeOneArticle(
{"issue": issue, "title": "Article Y", "translated_titles": translated_titles}
)
header = {
"Referer": url_for("main.issue_toc", url_seg=journal.url_segment, url_seg_issue=issue.url_segment)
}
response = c.get(url_for("main.set_locale", lang_code="en"), headers=header, follow_redirects=True)
self.assertEqual(200, response.status_code)
self.assertEqual(flask.session["lang"], "en")
self.assertIn(u"Article Title In Portuguese", response.data.decode("utf-8"))
def test_collection_list_institution(self):
"""
Teste para a ``view function`` collection_list_institution, será avaliado
somente o template utilizado pois essa função depende de definição do atributo
instituição no manager.
"""
collecton = utils.makeOneCollection()
warnings.warn("Necessário definir o atributo instituição no modelo do Manager")
response = self.client.get(url_for('main.collection_list') + '#publisher')
self.assertStatus(response, 200)
self.assertTemplateUsed('collection/list_journal.html')
def test_collection_list_feed_without_journals(self):
"""
Teste para avaliar o retorno da ``view function`` collection_list_feed
quando não existe periódicos cadastrados deve retorna a msg
``Nenhum periódico encontrado`` no corpo da resposta.
"""
with current_app.app_context():
collection = utils.makeOneCollection()
response = self.client.get(url_for('main.collection_list_feed'))
self.assertStatus(response, 200)
self.assertIn(u'Nenhum periódico encontrado',
response.data.decode('utf-8'))
def test_collection_list_institution_without_journals(self):
"""
Teste para avaliar o retorno da ``view function`` collection_list_institution
quando não existe periódicos cadastrados deve retorna a msg
``Nenhum periódico encontrado`` no corpo da resposta.
"""
collecton = utils.makeOneCollection()
response = self.client.get(url_for('main.collection_list'))
self.assertStatus(response, 200)
self.assertTemplateUsed('collection/list_journal.html')
self.assertIn(u'Nenhum periódico encontrado',
response.data.decode('utf-8'))
def test_collection_address_at_journal_list_page_footer(self):
"""
acessar na pagina Alfabética deve mostrar o endereço da coleção
"""
# with
with current_app.app_context():
collection_data = {
'address1': 'foo address',
'address2': 'foo address',
}
collection = utils.makeOneCollection(attrib=collection_data)
# when
response = self.client.get(url_for('main.collection_list'))
# then
self.assertStatus(response, 200)
self.assertIn(collection['address1'], response.data.decode('utf-8'))
self.assertIn(collection['address2'], response.data.decode('utf-8'))
def test_collection_open_access_list_theme(self):
"""
Testa se os links e o conteúdo da licença esta de acordo com a licença
cadastrada na coleção.
"""
with current_app.app_context():
collection = utils.makeOneCollection()
with self.client as c:
response = c.get(url_for('main.collection_list'))
self.assertStatus(response, 200)
self.assertTemplateUsed('collection/list_journal.html')
self.assertIn('/static/img/oa_logo_32.png', response.data)
self.assertIn('href="%s"' % url_for('main.open_access'), response.data)
self.assertIn('Open Access', response.data)
def test_journal_with_googleplus_social_networks_show_links(self):
"""
COM:
- Periódico COM redes socials
QUANDO:
- Acessarmos a home do periódico
VERIFICAMOS:
- Que SIM aparece a seção de redes sociais
- O div com class="journalLinks" deve aparecer
"""
with current_app.app_context():
# with
collection = utils.makeOneCollection()
journal_data = {
'collection': collection,
'social_networks': [
{
'network': u'google',
'account': u'http://plus.google.com/+foo'
}
]
}
journal = utils.makeOneJournal(journal_data)
with self.client as c:
# when
response = c.get(url_for('main.journal_detail', url_seg=journal.url_segment))
# then
self.assertStatus(response, 200)
social_networks_class = u"journalLinks"
self.assertIn(social_networks_class, response.data.decode('utf-8'))
twitter_btn_class = u"bigTwitter"
self.assertNotIn(twitter_btn_class, response.data.decode('utf-8'))
facebook_btn_class = u"bigFacebook"
self.assertNotIn(facebook_btn_class, response.data.decode('utf-8'))
google_btn_class = u"bigGooglePlus"
self.assertIn(google_btn_class, response.data.decode('utf-8'))
expected_social_link = u'<a href="{account}" data-toggle="tooltip" title="{network}">'.format(
account=journal_data['social_networks'][0]['account'],
network=journal_data['social_networks'][0]['network'].title(),
)
self.assertIn(expected_social_link, response.data.decode('utf-8'))
def test_collection_list_feed_without_issues(self):
"""
Teste para verificar a reposta da ``view funciton``collection_list_feed
Se cadastra 10 periódicos sem fascículo, deve retornar na interface do
rss, utilizando o template ``collection/list_feed_content.html```.
"""
with current_app.app_context():
collection = utils.makeOneCollection()
journals = utils.makeAnyJournal(items=10)
response = self.client.get(url_for('main.collection_list_feed'))
self.assertStatus(response, 200)
self.assertTemplateUsed('collection/list_feed_content.html')
for journal in journals:
self.assertIn('%s' % journal.url_segment,
response.data.decode('utf-8'))
def test_journal_detail(self):
"""
Teste da ``view function`` ``journal_detail``, deve retornar uma página
que usa o template ``journal/detail.html`` e o título do periódico no
corpo da página.
"""
with current_app.app_context():
collection = utils.makeOneCollection()
journal = utils.makeOneJournal({'title': 'Revista X'})
response = self.client.get(url_for('main.journal_detail',
url_seg=journal.url_segment))
self.assertTrue(200, response.status_code)
self.assertTemplateUsed('journal/detail.html')
self.assertIn(u'Revista X',
response.data.decode('utf-8'))
self.assertEqual(self.get_context_variable('journal').id, journal.id)
def test_collection_list_alpha(self):
"""
Teste para avaliar o retorno da ``view function`` collection_list_alpha,
ao cadastrarmos 10 periódico a interface deve retornar uma listagem
contendo elementos esperado também deve retornar o template
``collection/list_alpha.html``.
"""
collecton = utils.makeOneCollection()
journals = utils.makeAnyJournal(items=10)
response = self.client.get(url_for('main.collection_list') + '#alpha')
self.assertStatus(response, 200)
self.assertTemplateUsed('collection/list_journal.html')
for journal in journals:
self.assertIn('journals/%s' % journal.id,
response.data.decode('utf-8'))
self.assertListEqual(sorted([journal.id for journal in journals]),
sorted([journal.id for journal in self.get_context_variable('journals')]))
def test_issue_grid_without_issues(self):
"""
Teste para avaliar o retorno da ``view function`` ``issue_grid``
quando não existe fascículo cadastrado deve retornar ``status_code`` 200
e a msg ``Nenhum fascículo encontrado para esse perióico``
"""
with current_app.app_context():
collection = utils.makeOneCollection()
journal = utils.makeOneJournal()
response = self.client.get(url_for('main.issue_grid',
url_seg=journal.url_segment))
self.assertStatus(response, 200)
self.assertTemplateUsed('issue/grid.html')
self.assertIn(u'Nenhum fascículo encontrado para esse perióico',
response.data.decode('utf-8'))
def test_journal_feed(self):
"""
Teste da ``view function`` ``journal_feed``, deve retornar um rss
que usa o template ``issue/feed_content.html`` e o título do periódico no
corpo da página.
"""
with current_app.app_context():
collection = utils.makeOneCollection()
journal = utils.makeOneJournal({'title': 'Revista X'})
issue = utils.makeOneIssue({'journal': journal})
articles = utils.makeAnyArticle(
issue=issue,
attrib={'journal': journal.id, 'issue': issue.id}
)
response = self.client.get(url_for('main.journal_feed',
url_seg=journal.url_segment))
self.assertTrue(200, response.status_code)
self.assertTemplateUsed('issue/feed_content.html')
def test_g_object_has_collection_object(self):
"""
COM:
- uma nova collection criada com o mesmo acronimo da setting: OPAC_CONFIG
QUANDO:
- solicitamo uma pagina
VERIFICAMOS:
- que no contexto, a variável 'g' tenha asociado uma instancia da collection
"""
with current_app.app_context():
# with
collection_db_record = utils.makeOneCollection()
# when
with self.client as c:
response = self.client.get(url_for('main.index'))
# then
self.assertStatus(response, 200)
self.assertTrue(hasattr(g, 'collection'))
g_collection = g.get('collection')
self.assertEqual(g_collection._id, collection_db_record._id)
def test_collection_list_theme(self):
"""
Teste para avaliar o retorno da ``view function`` collection_list_theme
ao cadastrarmos 60 periódico a interface deve retornar uma listagem
contendo elementos esperado tambémdeve retornar o template
``collection/list_theme.html``.
"""
collecton = utils.makeOneCollection()
journals = utils.makeAnyJournal(items=30,
attrib={"study_areas": ["Engineering"]})
journals = utils.makeAnyJournal(items=30,
attrib={"study_areas": ["Human Sciences",
"Biological Sciences", "Engineering"]})
response = self.client.get(url_for('main.collection_list') + '#theme')
self.assertStatus(response, 200)
self.assertTemplateUsed('collection/list_journal.html')
for journal in journals:
self.assertIn('journals/%s' % journal.id,
response.data.decode('utf-8'))
def test_issue_grid(self):
"""
Teste da ``view function`` ``issue_grid`` acessando a grade de fascículos
de um periódico, nesse teste deve ser retornado todos os fascículos com
o atributo is_public=True de um fascículo, sendo que o template deve ser
``issue/grid.html``.
"""
with current_app.app_context():
collection = utils.makeOneCollection()
journal = utils.makeOneJournal()
issues = utils.makeAnyIssue(attrib={'journal': journal.id})
response = self.client.get(url_for('main.issue_grid',
url_seg=journal.url_segment))
self.assertStatus(response, 200)
self.assertTemplateUsed('issue/grid.html')
for issue in issues:
self.assertIn('/journal_acron', response.data.decode('utf-8'))
def test_issue_toc(self):
"""
Teste da ``view function`` ``issue_toc`` acessando a página do fascículo,
deve retorna status_code 200 e o template ``issue/toc.html``.
"""
with current_app.app_context():
collection = utils.makeOneCollection()
journal = utils.makeOneJournal()
issue = utils.makeOneIssue({'number': '31',
'volume': '10',
'journal': journal})
response = self.client.get(url_for('main.issue_toc',
url_seg=journal.url_segment,
url_seg_issue=issue.url_segment))
self.assertStatus(response, 200)
self.assertTemplateUsed('issue/toc.html')
# self.assertIn(u'Vol. 10 No. 31', response.data.decode('utf-8'))
self.assertEqual(self.get_context_variable('issue').id, issue.id)
def test_get_current_collection(self):
collection = utils.makeOneCollection()
controller_col = controllers.get_current_collection()
self.assertEqual(collection, controller_col)
