def test_create_update_times(self):
lesson = Lesson()
lesson.title = "Lesson Title"
lesson.text = "Lesson Text"
lesson.save()
lesson.full_clean()
# compare created time to modified time
created_ms = lesson.created.microsecond
modified_ms = lesson.modified.microsecond
self.assertTrue(created_ms < modified_ms)
sleep(1)
# modify lesson
lesson.text = "new text"
lesson.save()
# assert that the modify times don't match
self.assertNotAlmostEqual(
created_ms,
lesson.modified.microsecond,
delta=95
)
self.assertNotEqual(
modified_ms,
lesson.modified.microsecond
)
def setUp(self):
# Create the model instances required for the relationship
self.new_difficulty = Difficulty(name="Very Tough")
self.new_difficulty.save()
self.new_category = Category(name="Solid Cakes")
self.new_category.save()
# Create the raw data for testing
lesson_raw_data = {
"name":"Cherry Cake",
"price": 3000,
"average_class_size": 25,
"difficulty_level": self.new_difficulty,
"description": "Good Stuff",
}
product_raw_data = {
"name": "Fairy Cake",
"price": 3000,
"category":self.new_category,
"description": "Great Cake!",
"sizes": "S"
}
self.new_lesson = Lesson(**lesson_raw_data)
self.new_lesson.save()
self.new_product = Product(**product_raw_data)
self.new_product.save()
def copy(request, lesson_id):
""" Create a user-owned copy of the lesson """
lessonOriginal = get_object_or_404(Lesson, pk=lesson_id)
dataOriginal = read_lesson_data(lessonOriginal)
ownerOriginal = lessonOriginal.owner
lessonCopy = Lesson(
owner = request.user,
title = dataOriginal['title'],
tags = dataOriginal['tags'],
created = timezone.now(),
file = ContentFile(
json.dumps(dataOriginal).encode('utf-8'),
name='dummy_name'
),
original_owner = lessonOriginal.owner,
original_lesson = lessonOriginal,
)
if lessonCopy:
lessonCopy.save()
lessonOriginal.times_copied = F('times_copied') + 1
lessonOriginal.save(update_fields=['times_copied'])
return redirect('edit', lesson_id=lessonCopy.id)
if not lessonCopy:
raise Http404('For an unknown reason, we failed to copy the lesson. Sorry!')
def setUp(self):
# Create the model instances required for the relationship
self.new_difficulty = Difficulty(name="Very Tough")
self.new_difficulty.save()
self.new_category = Category(name="Solid Cakes")
self.new_category.save()
# Create the raw data for testing
raw_data = {
"name": "Cherry Cake",
"price": 3000,
"average_class_size": 25,
"difficulty_level": self.new_difficulty,
"description": "Good Stuff",
}
product_raw_data = {
"name": "Fairy Cake",
"price": 3000,
"category": self.new_category,
"description": "Great Cake!",
"sizes": "S"
}
#Pass the dictionary as named parameters to a function call
self.new_lesson = Lesson(**raw_data)
self.new_lesson.save()
self.new_product = Product(**product_raw_data)
self.new_product.save()
self.user = User.objects.create_user(username='******',
password='******')
self.client.login(username='******', password='******')
def create_lesson_inst():
dialog = Dialog()
dialog.save()
home_work = HomeWork()
home_work.save()
lesson = Lesson(dialog = dialog, home_work = home_work)
lesson.save()
return lesson
def lesson_add(request):
# This is how you do it with a functional view <side eye>
if request.method == 'POST':
form = LessonAddForm(request.POST)
if form.is_valid():
l = Lesson()
l.name = form.cleaned_data['name']
l.url = form.cleaned_data['url']
l.save()
return HttpResponseRedirect(reverse('lessons.views.detail', args=(l.id,)))
else:
# will return errors if any, and prepopulate what was passed in before
return render_to_response('lessons/add.html', { 'form': form }, context_instance=RequestContext(request))
else:
form = LessonAddForm()
return render_to_response('lessons/add.html', { 'form': form }, context_instance=RequestContext(request))
def test_slug_is_set(self):
l = Lesson()
l.title = "Lesson Title"
l.text = "Lesson Text"
l.save()
l.full_clean()
self.assertEqual(l.slug, 'lesson-title')
def add_lesson(request):
"""
Create a lesson with timeslot, and qualifications based on teacher input
"""
try:
target_profile= Profile.objects.get(email=request.user.email)
timeslot=create_timeslot(request)
skill= Skill.objects.get(name=request.POST['skill'])
date= request.POST['date']
desc= request.POST['desc']
lesson= Lesson(teacher= target_profile, timeslot=timeslot, date=date, desc=desc)
except MultiValueDictKeyError:
return index(request, error="No timeslot added")
except AttributeError:
return HttpResponseRedirect(CONST_LOGIN_PATH)
lesson.skill=skill
lesson.save()
return HttpResponseRedirect(CONST_PROFILE_PATH)
def callback(msg):
lessons_data = get_data()
Lesson.objects.all().delete()
Lesson.objects.bulk_create(
[
Lesson(**lesson) for lesson in lessons_data
]
)
producer.publish_message(
{"action": "ready", "channel_name": msg.get('channel_name')}
)
def new(request):
""" Create a new lesson from scratch """
lessonData = get_validated_lesson_data(get_new_lesson_data());
lesson = Lesson(
owner = request.user,
title = lessonData['title'],
tags = lessonData['tags'],
created = timezone.now(),
file = ContentFile(
json.dumps(lessonData).encode('utf-8'),
name='dummy_name'
),
original_owner = request.user,
original_lesson = None,
)
if lesson:
lesson.save()
return redirect('edit', lesson_id=lesson.id)
if not lesson:
raise Http404('For an unknown reason, we failed to save the lesson. Sorry!')
def schedule_create_page(request, course_id):
course = get_object_or_404(Course, id=course_id)
if not course.user_is_teacher(request.user):
return HttpResponseForbidden()
if request.method == 'POST':
return lesson_create(request, course)
schools = course.school_set.all()
context = {
'is_create': True,
'course': course,
'period_types': Lesson().PERIOD_CHOICES,
'school': schools[0] if schools else '',
'user_location': request.user.profile.location,
'geo_suggest_url': settings.GEO_SUGGEST_URL
}
return render_to_response('lesson_create.html',
context,
context_instance=RequestContext(request))
def test_saving_and_retreiving_lessons(self):
first_lesson = Lesson()
first_lesson.title = "Title of first lesson"
first_lesson.text = "Text of first lesson"
first_lesson.save()
first_lesson.full_clean()
second_lesson = Lesson()
second_lesson.title = "Titulo de la segunda lesson"
second_lesson.text = "Texto de la segunda"
second_lesson.save()
second_lesson.full_clean()
saved_lessons = Lesson.objects.all()
self.assertEqual(saved_lessons.count(), 2)
recent_saved_lesson = saved_lessons[0]
oldest_saved_lesson = saved_lessons[1]
self.assertEqual(
oldest_saved_lesson.title,
first_lesson.title
)
self.assertEqual(
oldest_saved_lesson.text,
first_lesson.text
)
self.assertEqual(
recent_saved_lesson.title,
second_lesson.title
)
self.assertEqual(
recent_saved_lesson.text,
second_lesson.text
)
def test_cannot_save_empty_lesson(self):
lesson = Lesson(title="listo", text='')
with self.assertRaises(ValidationError):
lesson.save()
lesson.full_clean()
from django.db import migrations
from lessons.models import Lesson
initial_lessons = [
Lesson(title="O universo do desenvolvimento no Mercado Livre",
author="Daniel Ambrosio",
description=""),
Lesson(title="O ecosistema de frameworks Javascript",
author="Diego Fernandes",
description=""),
Lesson(title="As grandes oportunidades para Full Cycle Developers",
author="Rodrigo Branas / Tiago Baeta / Robson Marques",
description=""),
Lesson(title="Serverless, o mínimo que todo dev precisa saber",
author="Erick Wendel",
description=""),
Lesson(title="Produtividade eXtrema com Python e Django",
author="Henrique Bastos",
description=""),
Lesson(title="Containers na prática: do Docker ao Kubernetes",
author="Fabricio Veronez",
description=""),
Lesson(title="Microsserviços e Integração Contínua com Sunarqube",
author="Wesley Willians",
description=""),
Lesson(title="Monitoramento Inteligente + Encerramento",
author="Wesley Willians",
description=""),
]
class TestCartViews(TestCase):
def setUp(self):
# Create the model instances required for the relationship
self.new_difficulty = Difficulty(name="Very Tough")
self.new_difficulty.save()
self.new_category = Category(name="Solid Cakes")
self.new_category.save()
# Create the raw data for testing
lesson_raw_data = {
"name":"Cherry Cake",
"price": 3000,
"average_class_size": 25,
"difficulty_level": self.new_difficulty,
"description": "Good Stuff",
}
product_raw_data = {
"name": "Fairy Cake",
"price": 3000,
"category":self.new_category,
"description": "Great Cake!",
"sizes": "S"
}
self.new_lesson = Lesson(**lesson_raw_data)
self.new_lesson.save()
self.new_product = Product(**product_raw_data)
self.new_product.save()
def test_get_view_cart_page(self):
response = self.client.get('/cart/')
self.assertEqual(response.status_code,200)
self.assertTemplateUsed(response,'cart/view_cart.template.html')
def test_add_lesson_to_cart(self):
response = self.client.get(f'/cart/add/{self.new_lesson.id}')
session = self.client.session.get('lesson_shopping_cart')
for k,v in session.items():
lesson_added = v
# Verify that the lesson has been added to cart
self.assertEqual(lesson_added['id'],str(self.new_lesson.id))
self.assertEqual(lesson_added['name'],self.new_lesson.name)
self.assertEqual(lesson_added['cost'],'${:.2f}'.format(int(self.new_lesson.price/100)))
def test_remove_lesson_from_cart(self):
self.client.get(f'/cart/add/{self.new_lesson.id}')
session = self.client.session.get('lesson_shopping_cart')
for k,v in session.items():
lesson_added = v
# Check that the lesson has been added to the cart
self.assertEqual(lesson_added['id'],str(self.new_lesson.id))
self.assertEqual(lesson_added['name'],self.new_lesson.name)
self.assertEqual(lesson_added['cost'],'${:.2f}'.format(int(self.new_lesson.price/100)))
response=self.client.get(f'/cart/remove/{self.new_lesson.id}')
#Check that lesson has been removed from the cart
self.assertEqual(bool(self.client.session.get('lesson_shopping_cart')),False)
def test_add_product_to_cart(self):
response = self.client.get(reverse('add_product_to_cart_route',kwargs={'product_id':self.new_product.id}))
session = self.client.session.get('product_shopping_cart')
for k,v in session.items():
product_added = v
# Verify that the product has been added to cart
self.assertEqual(product_added['id'],str(self.new_product.id))
self.assertEqual(product_added['name'],self.new_product.name)
self.assertEqual(product_added['cost'],'${:.2f}'.format(int(self.new_product.price/100)))
def test_remove_product_from_cart(self):
self.client.get(reverse('add_product_to_cart_route',kwargs={'product_id':self.new_product.id}))
session = self.client.session.get('product_shopping_cart')
for k,v in session.items():
product_added = v
# Check that the product has been added to cart
self.assertEqual(product_added['id'],str(self.new_product.id))
self.assertEqual(product_added['name'],self.new_product.name)
self.assertEqual(product_added['cost'],'${:.2f}'.format(int(self.new_product.price/100)))
self.assertEqual(product_added['qty'],1)
response = self.client.post(reverse('remove_product_from_cart_route',kwargs={'product_id':self.new_product.id}))
#Check that the product has been removed from the cart
self.assertEqual(bool(self.client.session.get('product_shopping_cart')),False)
def test_update_quantity_for_product(self):
self.client.get(reverse('add_product_to_cart_route',kwargs={'product_id':self.new_product.id}))
session = self.client.session.get('product_shopping_cart')
for k,v in session.items():
product_added = v
# Verify that the product has been added to cart
self.assertEqual(product_added['id'],str(self.new_product.id))
self.assertEqual(product_added['name'],self.new_product.name)
self.assertEqual(product_added['cost'],'${:.2f}'.format(int(self.new_product.price/100)))
self.assertEqual(product_added['cost'],'${:.2f}'.format(int(self.new_product.price/100)))
# Execute the update quantity view function
response = self.client.post(reverse('update_product_quantity_to_cart_route',kwargs={'product_id':self.new_product.id}),{
'qty':3
})
for k,v in self.client.session.get('product_shopping_cart').items():
updated_product = v
# Check that the quantity has been updated
self.assertEqual(updated_product['qty'],str(3))
def set_params(params, course, group, user, schedule_id, lssn_date, lesson=None):
lssn = Lesson() if not lesson else lesson
lssn.title = params['lesson_title']
lssn.course = course
lssn.schedule_id = schedule_id
lssn.date_starttime = lssn_date[0]
lssn.date_endtime = lssn_date[1]
lssn.period = params['period']
lssn.date_end = params['date_end']
lssn.days = params['lesson_days']
lssn.description = params['lesson_description']
lssn.updated_by = user
lssn.group = group
lssn.save()
lssn.set_position()
return lssn.id
def createLesson(request):
lesson = Lesson.create(request.POST.get('lessonName'), request.user)
lesson.save()
return HttpResponseRedirect('/index/')
class TestReviewsForms(TestCase):
def setUp(self):
# Create the model instances required for the relationship
self.new_difficulty = Difficulty(name="Very Tough")
self.new_difficulty.save()
self.new_category = Category(name="Solid Cakes")
self.new_category.save()
# Create the raw data for testing
raw_data = {
"name": "Cherry Cake",
"price": 3000,
"average_class_size": 25,
"difficulty_level": self.new_difficulty,
"description": "Good Stuff",
}
product_raw_data = {
"name": "Fairy Cake",
"price": 3000,
"category": self.new_category,
"description": "Great Cake!",
"sizes": "S"
}
#Pass the dictionary as named parameters to a function call
self.new_lesson = Lesson(**raw_data)
self.new_lesson.save()
self.new_product = Product(**product_raw_data)
self.new_product.save()
self.user = User.objects.create_user(username='******',
password='******')
self.client.login(username='******', password='******')
def test_get_create_lesson_review_page(self):
response = self.client.get(f'/reviews/create/{self.new_lesson.id}')
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response,
'reviews/create_lesson_review.template.html')
def test_create_lesson_review(self):
raw_data = {
'title': 'Not Good Lesson!',
'content': 'Waste Time!',
'ratings': 1
}
response = self.client.post(f'/reviews/create/{self.new_lesson.id}',
raw_data)
self.assertEqual(response.status_code, 302)
new_review = Lesson_Review.objects.get(title="Not Good Lesson!")
self.assertNotEqual(new_review, None)
self.assertEqual(new_review.title, raw_data["title"])
self.assertEqual(new_review.content, raw_data["content"])
self.assertEqual(new_review.ratings, raw_data["ratings"])
def test_get_create_product_review_page(self):
response = self.client.get(
reverse('create_product_review_route',
kwargs={'product_id': str(self.new_product.id)}))
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response,
'reviews/create_product_review.template.html')
def test_create_product_review(self):
raw_data = {
'title': 'Good Cake!',
'content': 'Worth Every Penny!',
'ratings': 5
}
response = self.client.post(
reverse('create_product_review_route',
kwargs={'product_id': str(self.new_product.id)}), raw_data)
print(response.content)
self.assertEqual(response.status_code, 302)
new_review = Product_Review.objects.get(title="Good Cake!")
self.assertNotEqual(new_review, None)
self.assertEqual(new_review.title, raw_data["title"])
self.assertEqual(new_review.content, raw_data["content"])
self.assertEqual(new_review.ratings, raw_data["ratings"])
def set_params(params,
course,
group,
user,
schedule_id,
lssn_date,
lesson=None):
lssn = Lesson() if not lesson else lesson
lssn.title = params['lesson_title']
lssn.course = course
lssn.schedule_id = schedule_id
lssn.date_starttime = lssn_date[0]
lssn.date_endtime = lssn_date[1]
lssn.period = params['period']
lssn.date_end = params['date_end']
lssn.days = params['lesson_days']
lssn.description = params['lesson_description']
lssn.updated_by = user
lssn.group = group
lssn.save()
lssn.set_position()
return lssn.id
def test_published_attribute(self):
l = Lesson()
l.title = "Lesson Title"
l.text = "Lesson Text"
l.save()
l.full_clean()
self.assertFalse(l.published)
l.published = True
l.save()
l.full_clean()
self.assertTrue(l.published)
