class TestModels(unittest.TestCase):
def setUp(self):
self.mocker = mocker.Mocker()
self.language = ProgrammingLanguage(name = u'Python')
self.language.put()
def test_save_project_with_slug(self):
"Before put a project, should generate a slug"
project = Project(name = u'My Project', language = self.language, description='Bla bla bla')
project.put()
assert_equals(project.slug, u'my-project')
def test_get_project_url(self):
"The project should contain a URL in the format: /<language-slug>/<project-slug> using url_for for building"
project = Project(name = u'Comunicação avançada', language = self.language, description='Bla bla bla')
project.put()
url = '/%s/%s' %(project.language.slug, project.slug)
url_for_mocked = self.mocker.replace('flask.url_for')
url_for_mocked(mocker.ANY, language_slug = self.language.slug, project_slug = project.slug)
self.mocker.result(url)
self.mocker.replay()
assert_equals(project.get_url(), url)
def test_save_language_with_slug(self):
"Before put a language, should generate a slug"
assert_equals(self.language.slug, u'python')
def tearDown(self):
self.language.delete()
self.mocker.restore()
def create_language():
form = LanguageForm()
if form.validate_on_submit():
language = ProgrammingLanguage(name = form.name.data)
language.put()
flash('Programming language "%s" saved on the database.' % language.name)
return redirect(url_for('list_languages'))
return render_template('admin/languages/new.html', form=form)
def test_delete_a_language(self):
"Should delete a language on URL /admin/languages/<slug>/delete"
self._mock_logged_in()
language = ProgrammingLanguage(name = u'C++')
language.put()
slug = language.slug
self.client.get('/admin/languages/%s/delete' % slug)
language = ProgrammingLanguage.all().filter('slug = ', slug).get()
assert_equals(language, None)
def test_slug_generation_for_model_repeated():
"Should generate a slug with counter for a model when the slug already exists"
language_name = u'Ruby'
expected_slug = u'ruby-1'
from labs.models import ProgrammingLanguage
from labs.util import generate_slug_field
language = ProgrammingLanguage(name = language_name)
language.put()
assert_equals(generate_slug_field(ProgrammingLanguage, language_name), expected_slug)
def test_update_language(self):
"Should update a language with data given by post"
self._mock_logged_in(times = 2)
data = { 'name' : u'Javascript' }
response = self.client.post('/admin/languages/%s' % self.language.slug, data = data, follow_redirects = True)
language = ProgrammingLanguage.all().filter('slug =', self.language.slug).get()
assert_equals(language.name, 'Javascript')
class TestFrontendProjects(unittest.TestCase):
def setUp(self):
self.mocker = mocker.Mocker()
self.client = labs.app.test_client()
self.language = ProgrammingLanguage(name = u'Python')
self.language.put()
self.project = Project(name = u'Talks', language = self.language, github_url = 'http://github.com/franciscosouza/talks', description = 'Bla bla bla')
self.project.put()
self.project_url = '/%s/%s' %(self.language.slug, self.project.slug)
def test_show_a_project(self):
"Should show a project in the URL /<language-slug>/<project-slug>"
title = '<h2>%s</h2>' % self.project.name
response = self.client.get(self.project_url)
assert_true(title in response.data)
def test_link_github(self):
"Should link Github repository when it is present when viewing a project (/<language-slug>/<project-slug>)"
response = self.client.get(self.project_url)
dom = html.fromstring(response.data)
path = '//a[@href="%s"]' % self.project.github_url
link_list = dom.xpath(path)
assert_equals(len(link_list), 1)
def test_list_projects(self):
"Should list all projects on /projects"
mocked_url_for = self.mocker.replace('flask.url_for')
mocked_url_for(mocker.ANY, language_slug = self.project.language.slug, project_slug = self.project.slug)
self.mocker.result(self.project_url)
self.mocker.replay()
response = self.client.get('/projects')
dom = html.fromstring(response.data)
project_link_list = dom.xpath('//a[@href="%s"]' % self.project_url)
assert_true(len(project_link_list) > 0)
self.mocker.verify()
def tearDown(self):
self.mocker.restore()
self.project.delete()
self.language.delete()
def update_language(slug):
form = LanguageForm()
language = ProgrammingLanguage.all().filter('slug =', slug).get()
if form.validate_on_submit():
language.name = form.name.data
language.put()
flash('Programming language "%s" updated.' %language.name)
return redirect(url_for('list_languages'))
return render_template('admin/languages/edit.html', form=form, language=language)
def setUp(self):
self.mocker = mocker.Mocker()
self.client = labs.app.test_client()
self.language = ProgrammingLanguage(name = u'Python')
self.language.put()
self.project = Project(name = u'Testing everything', github_url = u'http://github.com/franciscosouza/test', description = 'Bla bla bla', language = self.language)
self.project.put()
def test_create_language_with_right_data(self):
"Should create a language given data by post"
from labs.util import slugify
language_name = u'Haskell'
language_slug = slugify(language_name)
self._mock_logged_in(times = 2)
data = { 'name' : language_name }
response = self.client.post('/admin/languages', data = data, follow_redirects = True)
from labs.models import ProgrammingLanguage
language = ProgrammingLanguage.all().filter('slug =', language_slug).get()
assert_equals(language.name, language_name)
def setUp(self):
self.mocker = mocker.Mocker()
self.client = labs.app.test_client()
self.language = ProgrammingLanguage(name = u'Python')
self.language.put()
self.project = Project(name = u'Talks', language = self.language, github_url = 'http://github.com/franciscosouza/talks', description = 'Bla bla bla')
self.project.put()
self.project_url = '/%s/%s' %(self.language.slug, self.project.slug)
def test_create_a_unique_slug_to_a_duplicated_programming_language_name(self):
"Should generate a new slug to a duplicated programming language"
from labs.util import slugify
language_name = u'Haskell'
language_slug = slugify(language_name) + '-1'
self._mock_logged_in(times = 4)
data = { 'name' : language_name }
response = self.client.post('/admin/languages', data = data, follow_redirects = True)
response = self.client.post('/admin/languages', data = data, follow_redirects = True)
from labs.models import ProgrammingLanguage
language = ProgrammingLanguage.all().filter('slug =', language_slug).get()
assert_equals(language.name, language_name)
def save(self):
language = ProgrammingLanguage.get(self.language.data)
if self.model:
self.model.name = self.name.data
self.model.github_url = self.github_url.data
self.model.documentation_url = self.documentation_url.data
self.model.language = language
self.model.description = self.description.data
else:
self.model = Project(
name = self.name.data,
github_url = self.github_url.data,
documentation_url = self.documentation_url.data,
language = language,
description = self.description.data
)
self.model.put()
return self.model
class TestAdminProjects(unittest.TestCase):
def setUp(self):
self.mocker = mocker.Mocker()
self.client = labs.app.test_client()
self.language = ProgrammingLanguage(name = u'Python')
self.language.put()
self.project = Project(name = u'Testing everything', github_url = u'http://github.com/franciscosouza/test', description = 'Bla bla bla', language = self.language)
self.project.put()
def _mock_logged_in(self, times = 1):
logged_in = self.mocker.replace('google.appengine.api.users.is_current_user_admin')
logged_in()
self.mocker.result(True)
self.mocker.count(times)
self.mocker.replay()
def test_list_projects(self):
"Should list all projects in /admin/projects"
self._mock_logged_in()
response = self.client.get('/admin/projects')
assert_true('Projects list' in response.data)
def test_project_form(self):
"Should show a form for new projects"
self._mock_logged_in()
response = self.client.get('/admin/projects/new')
assert_true('<h2>New project</h2>' in response.data)
def test_create_a_project(self):
"Should create a project with given data by post"
self._mock_logged_in(times = 2)
expected_name = u'The project'
from labs.util import slugify
expected_slug = slugify(expected_name)
data = {
'name' : expected_name,
'language' : self.language.key(),
'description' : 'Bla bla bla'
}
response = self.client.post('/admin/projects', data = data, follow_redirects = True)
from labs.models import Project
project = Project.all().filter('slug = ', expected_slug).get()
assert_equals(project.name, expected_name)
def test_create_a_duplicated_name_project(self):
"Should generate a new slug to a duplicated project"
self._mock_logged_in(times = 4)
expected_name = u'The project'
from labs.util import slugify
expected_slug = slugify(expected_name) + '-1'
data = {
'name' : expected_name,
'language' : self.language.key(),
'description' : 'Bla bla bla'
}
response = self.client.post('/admin/projects', data = data, follow_redirects = True)
response = self.client.post('/admin/projects', data = data, follow_redirects = True)
from labs.models import Project
project = Project.all().filter('slug = ', expected_slug).get()
assert_equals(project.name, expected_name)
def test_validate_creating_a_project(self):
"Should validate the new project form"
self._mock_logged_in(times = 2)
response = self.client.post('/admin/projects', data = {}, follow_redirects = True)
assert_true('This field is required' in response.data)
def test_form_edit_project(self):
"Should show a form with the project data on /admin/projects/<slug>/edit"
self._mock_logged_in()
response = self.client.get('/admin/projects/%s/edit' % self.project.slug)
dom = html.fromstring(response.data)
name_field = dom.xpath('//input[@type="text" and @name="name"]')[0]
github_field = dom.xpath('//input[@type="text" and @name="github_url"]')[0]
docs_field = dom.xpath('//input[@type="text" and @name="documentation_url"]')[0]
language_select = dom.xpath('//select[@name="language"]')[0]
selected_language = language_select.xpath('//option[@selected="selected"]')[0]
assert_equals(name_field.value, self.project.name)
assert_equals(github_field.value, self.project.github_url)
assert_equals(docs_field.value, '')
assert_equals(selected_language.text, self.project.language.name)
def test_update_a_project(self):
"Should update a project with given data by post"
self._mock_logged_in(times = 2)
project = Project(name = u'The big project', description='Bla bla bla', language = self.language)
project.put()
slug = project.slug
github_url = 'http://github.com/franciscosouza/labs'
data = {
'name' : project.name,
'language' : project.language.key(),
'description' : 'Bla bla bla',
'github_url' : github_url
}
self.client.post('/admin/projects/%s' % slug, data = data, follow_redirects = True)
project = Project.all().filter('slug =', slug).get()
assert_equals(project.github_url, github_url)
def test_failing_update(self):
"Should not update if the data was not provided"
self._mock_logged_in(times = 2)
response = self.client.post('/admin/projects/%s' % self.project.slug, data = {}, follow_redirects = True)
assert_true('This field is required' in response.data)
def test_delete_a_project(self):
"Should delete a project on URL /projects/<slug>/delete"
self._mock_logged_in()
from labs.models import Project
project = Project(name = u'Ruby on Rails', description = 'Bla bla bla', language = self.language)
project.put()
project_slug = project.slug
url = '/admin/projects/%s/delete' %(project_slug)
response = self.client.get(url)
project = Project.all().filter('slug = ', project_slug).get()
assert_true(project is None)
def tearDown(self):
self.mocker.restore()
self.language.delete()
from labs.models import Project
from google.appengine.ext import db
projects = Project.all().fetch(1000)
db.delete(projects)
def setUp(self):
self.mocker = mocker.Mocker()
self.client = labs.app.test_client()
self.language = ProgrammingLanguage(name = u'Java')
self.language.put()
class TestAdminLanguages(unittest.TestCase):
def setUp(self):
self.mocker = mocker.Mocker()
self.client = labs.app.test_client()
self.language = ProgrammingLanguage(name = u'Java')
self.language.put()
def _mock_logged_in(self, times = 1):
logged_in = self.mocker.replace('google.appengine.api.users.is_current_user_admin')
logged_in()
self.mocker.result(True)
self.mocker.count(times)
self.mocker.replay()
def test_list_languages(self):
"Should list all languages in /admin/languages"
self._mock_logged_in()
response = self.client.get('/admin/languages')
assert_true('Languages list' in response.data)
def test_show_the_languages_form(self):
"Should show a form for language in /admin/languages/new"
self._mock_logged_in()
response = self.client.get('/admin/languages/new')
assert_true('Fill the form' in response.data)
def test_create_language_with_right_data(self):
"Should create a language given data by post"
from labs.util import slugify
language_name = u'Haskell'
language_slug = slugify(language_name)
self._mock_logged_in(times = 2)
data = { 'name' : language_name }
response = self.client.post('/admin/languages', data = data, follow_redirects = True)
from labs.models import ProgrammingLanguage
language = ProgrammingLanguage.all().filter('slug =', language_slug).get()
assert_equals(language.name, language_name)
def test_create_a_unique_slug_to_a_duplicated_programming_language_name(self):
"Should generate a new slug to a duplicated programming language"
from labs.util import slugify
language_name = u'Haskell'
language_slug = slugify(language_name) + '-1'
self._mock_logged_in(times = 4)
data = { 'name' : language_name }
response = self.client.post('/admin/languages', data = data, follow_redirects = True)
response = self.client.post('/admin/languages', data = data, follow_redirects = True)
from labs.models import ProgrammingLanguage
language = ProgrammingLanguage.all().filter('slug =', language_slug).get()
assert_equals(language.name, language_name)
def test_fail_creating_language(self):
"Should not create a language without the name"
self._mock_logged_in(times = 2)
response = self.client.post('/admin/languages', data = {}, follow_redirects = True)
assert_true('This field is required' in response.data)
def test_form_edit_language(self):
"Should shows a form to edit the language on /admin/languages/<slug>/edit"
self._mock_logged_in()
response = self.client.get('/admin/languages/%s/edit' % self.language.slug)
from lxml import html
dom = html.fromstring(response.data)
field = dom.xpath('//input[@type="text" and @name="name"]')[0]
assert_equals(field.value, self.language.name)
def test_update_language(self):
"Should update a language with data given by post"
self._mock_logged_in(times = 2)
data = { 'name' : u'Javascript' }
response = self.client.post('/admin/languages/%s' % self.language.slug, data = data, follow_redirects = True)
language = ProgrammingLanguage.all().filter('slug =', self.language.slug).get()
assert_equals(language.name, 'Javascript')
def test_fail_update_language(self):
"Should not update a language if the name is not provided"
self._mock_logged_in(times = 2)
response = self.client.post('/admin/languages/%s' % self.language.slug, data = {}, follow_redirects = True)
assert_true('This field is required' in response.data)
def test_delete_a_language(self):
"Should delete a language on URL /admin/languages/<slug>/delete"
self._mock_logged_in()
language = ProgrammingLanguage(name = u'C++')
language.put()
slug = language.slug
self.client.get('/admin/languages/%s/delete' % slug)
language = ProgrammingLanguage.all().filter('slug = ', slug).get()
assert_equals(language, None)
def tearDown(self):
self.mocker.restore()
self.language.delete()
def setUp(self):
self.mocker = mocker.Mocker()
self.language = ProgrammingLanguage(name = u'Python')
self.language.put()
def list_languages():
languages = ProgrammingLanguage.all().order('name')
return render_template('admin/languages/list.html', languages=languages)
def delete_language(slug):
language = ProgrammingLanguage.all().filter('slug = ', slug).get()
language.delete()
flash('Language successful deleted.')
return redirect(url_for('list_languages'))
def edit_language(slug):
language = ProgrammingLanguage.all().filter('slug = ', slug).get()
form = LanguageForm()
form.name.data = language.name
return render_template('admin/languages/edit.html', form=form, language=language)
