def test_delete_favorites(self):
"""It should delete all favorites"""
store_item1 = mommy.make(models.StoreItem)
store_item2 = mommy.make(models.StoreItem)
create_profile_contact(self.user)
url = reverse('store_favorites_api')
mommy.make(models.Favorite, user=self.user, item=store_item1)
mommy.make(models.Favorite, user=self.user, item=store_item2)
data = {
'items': [],
}
response = self.client.post(url, data=data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['ok'], True)
self.assertEqual(0, models.Favorite.objects.count())
self.assertEqual(1, models.StoreItem.objects.filter(id=store_item1.id).count())
self.assertEqual(1, models.StoreItem.objects.filter(id=store_item2.id).count())
def test_view_favorites(self):
"""It should return favorites"""
other_user = mommy.make(models.User)
store_item1 = mommy.make(models.StoreItem)
store_item2 = mommy.make(models.StoreItem)
store_item3 = mommy.make(models.StoreItem)
create_profile_contact(self.user)
mommy.make(models.Favorite, user=self.user, item=store_item1)
mommy.make(models.Favorite, user=self.user, item=store_item2)
mommy.make(models.Favorite, user=other_user, item=store_item3)
mommy.make(models.Favorite, user=other_user, item=store_item1)
url = reverse('store_favorites_api')
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
favorites = response.data['favorites']
self.assertEqual(len(favorites), 2)
data = sorted(favorites, key=lambda item_: item_['id'])
item1 = data[0]
item2 = data[1]
self.assertEqual(item1['id'], store_item1.id)
self.assertEqual(item2['id'], store_item2.id)
def test_delete_favorites(self):
"""It should delete all favorites"""
store_item1 = mommy.make(models.StoreItem)
store_item2 = mommy.make(models.StoreItem)
create_profile_contact(self.user)
url = reverse('store_favorites_api')
mommy.make(models.Favorite, user=self.user, item=store_item1)
mommy.make(models.Favorite, user=self.user, item=store_item2)
data = {
'items': [],
}
response = self.client.post(url, data=data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['ok'], True)
self.assertEqual(0, models.Favorite.objects.count())
self.assertEqual(1, models.StoreItem.objects.filter(id=store_item1.id).count())
self.assertEqual(1, models.StoreItem.objects.filter(id=store_item2.id).count())
def test_view_favorites_unpublished(self):
"""It should return favorites"""
other_user = mommy.make(models.User)
store_item1 = mommy.make(models.StoreItem)
store_item2 = mommy.make(models.StoreItem, published=False)
store_item3 = mommy.make(models.StoreItem)
create_profile_contact(self.user)
mommy.make(models.Favorite, user=self.user, item=store_item1)
mommy.make(models.Favorite, user=self.user, item=store_item2)
mommy.make(models.Favorite, user=other_user, item=store_item3)
mommy.make(models.Favorite, user=other_user, item=store_item1)
url = reverse('store_favorites_api')
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
favorites = response.data['favorites']
self.assertEqual(len(favorites), 1)
data = sorted(favorites, key=lambda item_: item_['id'])
item1 = data[0]
self.assertEqual(item1['id'], store_item1.id)
def test_view_anonymous(self):
"""It should return http error"""
create_profile_contact(self.user)
self.client.logout()
url = reverse('store_last_sales_api')
response = self.client.get(url, format='json')
self.assertTrue(response.status_code in (status.HTTP_403_FORBIDDEN, status.HTTP_401_UNAUTHORIZED))
def test_view_anonymous(self):
"""It should return http error"""
create_profile_contact(self.user)
self.client.logout()
url = reverse('store_last_sales_api')
response = self.client.get(url, format='json')
self.assertTrue(response.status_code in (status.HTTP_403_FORBIDDEN, status.HTTP_401_UNAUTHORIZED))
def test_view_empty_list(self):
"""It should return none"""
store_item1 = mommy.make(models.StoreItem)
store_item2 = mommy.make(models.StoreItem)
create_profile_contact(self.user)
url = reverse('store_favorites_api')
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
favorites = response.data['favorites']
self.assertEqual(len(favorites), 0)
def test_view_empty_list(self):
"""It should return none"""
store_item1 = mommy.make(models.StoreItem)
store_item2 = mommy.make(models.StoreItem)
create_profile_contact(self.user)
url = reverse('store_favorites_api')
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
favorites = response.data['favorites']
self.assertEqual(len(favorites), 0)
def test_group_not_allowed(self):
#Create contact for the user
profile = create_profile_contact(self.user)
contact = profile.contact
#Create group
gr = models.Group.objects.create(name="Group")
gr.contacts.add(contact)
gr.save()
#Create category
cat = ArticleCategory.objects.create(name="CAT")
#Create CategoryPermission
cat_perm = CategoryPermission.objects.create(category=cat)
#cat_perm.can_view_groups.add(gr)
cat_perm.save()
#Create article
article_class = get_article_class()
article_class.objects.create(slug='test', title="Test", category=cat)
tpl = Template('{% load balafon_profile_perm %}{% if_can_do_article "test" %}HELLO{% else %}SORRY{% endif %}')
html = tpl.render(Context({'request': self._request()}))
self.assertEqual(html, "SORRY")
self.assertEqual(article_class.objects.count(), 1)
a = article_class.objects.all()[0]
self.assertEqual(a.slug, "test")
response = self.client.get(a.get_absolute_url())
self.assertEqual(response.status_code, 403)
def test_download_private_group_not_allowed(self):
# Create contact for the user
profile = create_profile_contact(self.user)
contact = profile.contact
# Create group
gr = models.Group.objects.create(name="Group")
gr.contacts.add(contact)
gr.save()
# Create category
cat = ArticleCategory.objects.create(name="CAT")
cat_perm = CategoryPermission.objects.create(category=cat)
# create a public doc
file = File(self._get_file())
doc = mommy.make(Document, is_private=True, file=file, category=cat)
# check the url
private_url = reverse('coop_cms_download_doc', args=[doc.id])
self.assertEqual(doc.get_download_url(), private_url)
# login and download
response = self.client.get(doc.get_download_url(), follow=True)
self.assertEqual(response.status_code, 403)
def test_view_last_sales_only_one(self):
"""It should return one store item"""
store_item1 = mommy.make(models.StoreItem)
mommy.make(models.StoreItem)
self.user.first_name = u'John'
self.user.last_name = u'Doe'
self.user.save()
profile = create_profile_contact(self.user)
contact = profile.contact
action = mommy.make(Action, planned_date=datetime.now())
action.contacts.add(contact)
action.save()
sale = mommy.make(models.Sale, action=action)
mommy.make(models.SaleItem, sale=sale, item=store_item1, quantity=1)
url = reverse('store_last_sales_api')
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
items = response.data
self.assertEqual(len(items), 1)
self.assertEqual(items[0]['id'], store_item1.id)
self.assertEqual(items[0]['name'], store_item1.name)
def test_group_not_allowed(self):
#Create contact for the user
profile = create_profile_contact(self.user)
contact = profile.contact
#Create group
gr = models.Group.objects.create(name="Group")
gr.contacts.add(contact)
gr.save()
#Create category
cat = ArticleCategory.objects.create(name="CAT")
#Create CategoryPermission
cat_perm = CategoryPermission.objects.create(category=cat)
#cat_perm.can_view_groups.add(gr)
cat_perm.save()
#Create article
article_class = get_article_class()
article_class.objects.create(slug='test', title="Test", category=cat)
tpl = Template('{% load balafon_profile_perm %}{% if_can_do_article "test" %}HELLO{% else %}SORRY{% endif %}')
html = tpl.render(Context({'request': self._request()}))
self.assertEqual(html, "SORRY")
self.assertEqual(article_class.objects.count(), 1)
a = article_class.objects.all()[0]
self.assertEqual(a.slug, "test")
response = self.client.get(a.get_absolute_url())
self.assertEqual(response.status_code, 403)
def activate(self, request, *args, **kwargs):
activated_user = super(AcceptNewsletterActivationView, self).activate(request, *args, **kwargs)
# The account has been activated: We can create the corresponding contact in Balafon
if activated_user:
profile = create_profile_contact(activated_user)
notify_registration(profile)
return activated_user
def test_cart_when_deleted_article(self):
"""The cart should not be removed if store_item is deleted"""
# Create contact for the user
profile = create_profile_contact(self.user)
contact = profile.contact
store_item1 = mommy.make(models.StoreItem, stock_count=Decimal('10'))
store_item2 = mommy.make(models.StoreItem, stock_count=Decimal('0.5'))
sale = mommy.make(models.Sale)
sale_item1 = mommy.make(
models.SaleItem,
sale=sale,
item=store_item1,
quantity=2,
vat_rate=store_item1.vat_rate,
pre_tax_price=store_item1.pre_tax_price
)
sale_item2 = mommy.make(
models.SaleItem,
sale=sale,
item=store_item2,
quantity=1,
vat_rate=store_item2.vat_rate,
pre_tax_price=store_item2.pre_tax_price
)
store_item1.delete()
self.assertEqual(1, models.Sale.objects.count())
self.assertEqual(sale.id, models.Sale.objects.all()[0].id)
def test_cart_when_deleted_article(self):
"""The cart should not be removed if store_item is deleted"""
# Create contact for the user
profile = create_profile_contact(self.user)
contact = profile.contact
store_item1 = mommy.make(models.StoreItem, stock_count=Decimal('10'))
store_item2 = mommy.make(models.StoreItem, stock_count=Decimal('0.5'))
sale = mommy.make(models.Sale)
sale_item1 = mommy.make(models.SaleItem,
sale=sale,
item=store_item1,
quantity=2,
vat_rate=store_item1.vat_rate,
pre_tax_price=store_item1.pre_tax_price)
sale_item2 = mommy.make(models.SaleItem,
sale=sale,
item=store_item2,
quantity=1,
vat_rate=store_item2.vat_rate,
pre_tax_price=store_item2.pre_tax_price)
store_item1.delete()
self.assertEqual(1, models.Sale.objects.count())
self.assertEqual(sale.id, models.Sale.objects.all()[0].id)
def test_view_last_sales_only_one(self):
"""It should return one store item"""
store_item1 = mommy.make(models.StoreItem)
mommy.make(models.StoreItem)
self.user.first_name = 'John'
self.user.last_name = 'Doe'
self.user.save()
profile = create_profile_contact(self.user)
contact = profile.contact
action = mommy.make(Action, planned_date=datetime.now())
action.contacts.add(contact)
action.save()
sale = mommy.make(models.Sale, action=action)
mommy.make(models.SaleItem, sale=sale, item=store_item1, quantity=1)
url = reverse('store_last_sales_api')
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
items = response.data
self.assertEqual(len(items), 1)
self.assertEqual(items[0]['id'], store_item1.id)
self.assertEqual(items[0]['name'], store_item1.name)
def test_post_cart_not_available(self):
"""It should create a new sale and ignore articles which are not available"""
# Create contact for the user
profile = create_profile_contact(self.user)
contact = profile.contact
store_item1 = mommy.make(models.StoreItem, stock_count=Decimal('10'))
store_item2 = mommy.make(models.StoreItem, stock_count=Decimal('0.5'), available=False)
delivery_point = mommy.make(models.DeliveryPoint)
data = {
'items': [
{'id': store_item1.id, 'quantity': 2},
{'id': store_item2.id, 'quantity': 1},
],
'delivery_point': delivery_point.id,
'purchase_datetime': datetime(2015, 7, 23, 12, 0)
}
url = reverse('store_post_cart')
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['ok'], True)
self.assertEqual(len(response.data['warnings']), 1)
self.assertEqual(response.data['deliveryDate'], data['purchase_datetime'])
self.assertEqual(response.data['deliveryPlace'], delivery_point.name)
action_type = ActionType.objects.get(name=get_cart_type_name())
action_queryset = Action.objects.filter(type=action_type)
self.assertEqual(action_queryset.count(), 1)
action = action_queryset[0]
self.assertEqual(list(action.contacts.all()), [contact])
self.assertEqual(action.subject, '')
self.assertEqual(action.detail, '')
self.assertEqual(action.planned_date, data['purchase_datetime'])
self.assertEqual(action.sale.saleitem_set.count(), 1)
self.assertEqual(action.sale.saleitem_set.all()[0].item, store_item1)
self.assertEqual(action.sale.saleitem_set.all()[0].text, store_item1.name)
self.assertEqual(action.sale.saleitem_set.all()[0].unit_price(), store_item1.pre_tax_price)
self.assertEqual(action.sale.saleitem_set.all()[0].vat_rate, store_item1.vat_rate)
self.assertEqual(action.sale.saleitem_set.all()[0].quantity, 2)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[0].to, [profile.contact.email])
self.assertEqual(mail.outbox[1].to, [settings.BALAFON_NOTIFICATION_EMAIL])
store_item1 = models.StoreItem.objects.get(id=store_item1.id)
self.assertEqual(store_item1.stock_count, Decimal("8"))
store_item2 = models.StoreItem.objects.get(id=store_item2.id)
self.assertEqual(store_item2.stock_count, Decimal("0.5"))
def test_post_cart_notes_several_lines(self):
"""It should create a new sale and action"""
# Create contact for the user
profile = create_profile_contact(self.user)
contact = profile.contact
store_item1 = mommy.make(models.StoreItem)
store_item2 = mommy.make(models.StoreItem)
delivery_point = mommy.make(models.DeliveryPoint)
data = {
'items': [
{'id': store_item1.id, 'quantity': 2},
{'id': store_item2.id, 'quantity': 1},
],
'delivery_point': delivery_point.id,
'notes': 'a\nB\nc',
'purchase_datetime': datetime(2015, 7, 23, 12, 0)
}
url = reverse('store_post_cart')
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['ok'], True)
self.assertEqual(len(response.data['warnings']), 0)
self.assertEqual(response.data['deliveryDate'], data['purchase_datetime'])
self.assertEqual(response.data['deliveryPlace'], delivery_point.name)
action_type = ActionType.objects.get(name=get_cart_type_name())
action_queryset = Action.objects.filter(type=action_type)
self.assertEqual(action_queryset.count(), 1)
action = action_queryset[0]
self.assertEqual(list(action.contacts.all()), [contact])
self.assertEqual(action.subject, _(u'Notes'))
self.assertEqual(action.detail, 'a\nB\nc')
self.assertEqual(action.planned_date, data['purchase_datetime'])
self.assertEqual(action.sale.saleitem_set.count(), 2)
self.assertEqual(action.sale.saleitem_set.all()[0].item, store_item1)
self.assertEqual(action.sale.saleitem_set.all()[0].text, store_item1.name)
self.assertEqual(action.sale.saleitem_set.all()[0].unit_price(), store_item1.pre_tax_price)
self.assertEqual(action.sale.saleitem_set.all()[0].vat_rate, store_item1.vat_rate)
self.assertEqual(action.sale.saleitem_set.all()[0].quantity, 2)
self.assertEqual(action.sale.saleitem_set.all()[1].item, store_item2)
self.assertEqual(action.sale.saleitem_set.all()[1].text, store_item2.name)
self.assertEqual(action.sale.saleitem_set.all()[1].unit_price(), store_item2.pre_tax_price)
self.assertEqual(action.sale.saleitem_set.all()[1].vat_rate, store_item2.vat_rate)
self.assertEqual(action.sale.saleitem_set.all()[1].quantity, 1)
self.assertEqual(len(mail.outbox), 2)
def test_view_store_items_only_for_group(self):
"""It should return items if only_for_groups is empty or user contact is member of one of the groups"""
group1 = mommy.make(models.Group)
group2 = mommy.make(models.Group)
group3 = mommy.make(models.Group)
profile = create_profile_contact(self.user)
group1.contacts.add(profile.contact)
group1.save()
group2.entities.add(profile.contact.entity)
group2.save()
store_item1 = mommy.make(models.StoreItem)
store_item2 = mommy.make(models.StoreItem)
store_item2.only_for_groups.add(group1)
store_item2.save()
store_item3 = mommy.make(models.StoreItem)
store_item3.only_for_groups.add(group2)
store_item3.save()
store_item4 = mommy.make(models.StoreItem)
store_item4.only_for_groups.add(group1)
store_item4.only_for_groups.add(group2)
store_item4.only_for_groups.add(group3)
store_item4.save()
store_item5 = mommy.make(models.StoreItem)
store_item5.only_for_groups.add(group3)
store_item5.save()
url = reverse('store_store-items-list')
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 4)
data = sorted(response.data, key=lambda item_: item_['id'])
item1 = data[0]
item2 = data[1]
item3 = data[2]
item4 = data[3]
self.assertEqual(item1['id'], store_item1.id)
self.assertEqual(item1['name'], store_item1.name)
self.assertEqual(item2['id'], store_item2.id)
self.assertEqual(item2['name'], store_item2.name)
self.assertEqual(item3['id'], store_item3.id)
self.assertEqual(item3['name'], store_item3.name)
self.assertEqual(item4['id'], store_item4.id)
self.assertEqual(item4['name'], store_item4.name)
def test_view_last_sales_only_two_sales(self):
"""It should return three store item"""
store_item1 = mommy.make(models.StoreItem, name='Orange')
store_item2 = mommy.make(models.StoreItem, name='Banana')
store_item3 = mommy.make(models.StoreItem, name='Apple')
store_item4 = mommy.make(models.StoreItem)
self.user.first_name = 'John'
self.user.last_name = 'Doe'
self.user.save()
profile = create_profile_contact(self.user)
contact = profile.contact
other_contact = mommy.make(Contact)
action1 = mommy.make(Action, planned_date=datetime.now())
action1.contacts.add(contact)
action1.save()
sale1 = mommy.make(models.Sale, action=action1)
mommy.make(models.SaleItem, sale=sale1, item=store_item1, quantity=1)
mommy.make(models.SaleItem, sale=sale1, item=store_item2, quantity=5)
action2 = mommy.make(Action,
planned_date=datetime.now() - timedelta(days=30))
action2.contacts.add(contact)
action2.save()
sale2 = mommy.make(models.Sale, action=action2)
mommy.make(models.SaleItem, sale=sale2, item=store_item1, quantity=1)
mommy.make(models.SaleItem, sale=sale2, item=store_item3, quantity=2)
action3 = mommy.make(Action, planned_date=datetime.now())
action3.contacts.add(other_contact)
action3.save()
sale3 = mommy.make(models.Sale, action=action3)
mommy.make(models.SaleItem, sale=sale3, item=store_item1, quantity=1)
mommy.make(models.SaleItem, sale=sale3, item=store_item4, quantity=2)
url = reverse('store_last_sales_api')
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
items = response.data
self.assertEqual(len(items), 3)
self.assertEqual(items[0]['id'], store_item2.id)
self.assertEqual(items[0]['name'], store_item2.name)
self.assertEqual(items[1]['id'], store_item1.id)
self.assertEqual(items[1]['name'], store_item1.name)
self.assertEqual(items[2]['id'], store_item3.id)
self.assertEqual(items[2]['name'], store_item3.name)
def test_view_last_sales_only_two_sales(self):
"""It should return three store item"""
store_item1 = mommy.make(models.StoreItem, name=u'Orange')
store_item2 = mommy.make(models.StoreItem, name=u'Banana')
store_item3 = mommy.make(models.StoreItem, name=u'Apple')
store_item4 = mommy.make(models.StoreItem)
self.user.first_name = u'John'
self.user.last_name = u'Doe'
self.user.save()
profile = create_profile_contact(self.user)
contact = profile.contact
other_contact = mommy.make(Contact)
action1 = mommy.make(Action, planned_date=datetime.now())
action1.contacts.add(contact)
action1.save()
sale1 = mommy.make(models.Sale, action=action1)
mommy.make(models.SaleItem, sale=sale1, item=store_item1, quantity=1)
mommy.make(models.SaleItem, sale=sale1, item=store_item2, quantity=5)
action2 = mommy.make(Action, planned_date=datetime.now() - timedelta(days=30))
action2.contacts.add(contact)
action2.save()
sale2 = mommy.make(models.Sale, action=action2)
mommy.make(models.SaleItem, sale=sale2, item=store_item1, quantity=1)
mommy.make(models.SaleItem, sale=sale2, item=store_item3, quantity=2)
action3 = mommy.make(Action, planned_date=datetime.now())
action3.contacts.add(other_contact)
action3.save()
sale3 = mommy.make(models.Sale, action=action3)
mommy.make(models.SaleItem, sale=sale3, item=store_item1, quantity=1)
mommy.make(models.SaleItem, sale=sale3, item=store_item4, quantity=2)
url = reverse('store_last_sales_api')
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
items = response.data
self.assertEqual(len(items), 3)
self.assertEqual(items[0]['id'], store_item2.id)
self.assertEqual(items[0]['name'], store_item2.name)
self.assertEqual(items[1]['id'], store_item1.id)
self.assertEqual(items[1]['name'], store_item1.name)
self.assertEqual(items[2]['id'], store_item3.id)
self.assertEqual(items[2]['name'], store_item3.name)
def test_post_cart_empty(self):
"""It should create a new sale and ignore articles which are not available"""
# Create contact for the user
profile = create_profile_contact(self.user)
contact = profile.contact
store_item1 = mommy.make(models.StoreItem,
stock_count=Decimal('10'),
available=False)
store_item2 = mommy.make(models.StoreItem,
stock_count=Decimal('0.5'),
available=False)
delivery_point = mommy.make(models.DeliveryPoint)
data = {
'items': [
{
'id': store_item1.id,
'quantity': 2
},
{
'id': store_item2.id,
'quantity': 1
},
],
'delivery_point':
delivery_point.id,
'purchase_datetime':
datetime(2015, 7, 23, 12, 0)
}
url = reverse('store_post_cart')
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['ok'], False)
self.assertEqual(len(response.data['warnings']), 2)
action_type = ActionType.objects.get(name=get_cart_type_name())
action_queryset = Action.objects.filter(type=action_type)
self.assertEqual(action_queryset.count(), 0)
self.assertEqual(len(mail.outbox), 0)
store_item1 = models.StoreItem.objects.get(id=store_item1.id)
self.assertEqual(store_item1.stock_count, Decimal("10"))
store_item2 = models.StoreItem.objects.get(id=store_item2.id)
self.assertEqual(store_item2.stock_count, Decimal("0.5"))
def test_view_store_items_profile(self):
"""It should return all"""
store_item1 = mommy.make(models.StoreItem)
store_item2 = mommy.make(models.StoreItem)
url = reverse('store_store-items-list')
create_profile_contact(self.user)
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 2)
data = sorted(response.data, key=lambda item_: item_['id'])
item1 = data[0]
item2 = data[1]
self.assertEqual(item1['id'], store_item1.id)
self.assertEqual(item1['name'], store_item1.name)
self.assertEqual(item2['id'], store_item2.id)
self.assertEqual(item2['name'], store_item2.name)
def test_view_empty_list(self):
"""It should return empty list"""
store_item1 = mommy.make(models.StoreItem)
store_item2 = mommy.make(models.StoreItem)
profile = create_profile_contact(self.user)
url = reverse('store_last_sales_api')
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
items = response.data
self.assertEqual(len(items), 0)
def test_view_empty_list(self):
"""It should return empty list"""
store_item1 = mommy.make(models.StoreItem)
store_item2 = mommy.make(models.StoreItem)
profile = create_profile_contact(self.user)
url = reverse('store_last_sales_api')
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
items = response.data
self.assertEqual(len(items), 0)
def test_download_private_permission(self):
# Create contact for the user
profile = create_profile_contact(self.user)
contact = profile.contact
# Create group
gr = models.Group.objects.create(name="Group")
gr.contacts.add(contact)
gr.save()
# Create category
cat = ArticleCategory.objects.create(name="CAT")
# Create CategoryPermission
cat_perm = CategoryPermission.objects.create(category=cat)
cat_perm.can_view_groups.add(gr)
cat_perm.save()
# create a public doc
file = File(self._get_file())
doc = mommy.make(Document, is_private=True, file=file, category=cat)
# check the url
private_url = reverse('coop_cms_download_doc', args=[doc.id])
self.assertEqual(doc.get_download_url(), private_url)
# login and download
response = self.client.get(doc.get_download_url(), follow=True)
self.assertEqual(response.status_code, 200)
# self.assertEquals(response['Content-Disposition'], "attachment; filename=unittest1.txt")
self.assertEquals(response['Content-Type'], "text/plain")
# TODO: This change I/O Exception in UnitTest
# self.assertEqual(response.content, self._get_file().read())
# logout and download
self.client.logout()
response = self.client.get(doc.get_download_url(), follow=True)
self.assertEqual(response.status_code, 200)
redirect_url = response.redirect_chain[-1][0]
login_url = reverse('login')
self.assertTrue(redirect_url.find(login_url) >= 0)
def test_create_balafon_contact_multiple_email(self):
user = self._create_user()
contact1 = mommy.make(models.Contact, email=user.email)
contact2 = mommy.make(models.Contact, email=user.email)
# remove default contacts
contact1.entity.contact_set.exclude(id=contact1.id).delete()
contact2.entity.contact_set.exclude(id=contact2.id).delete()
profile = create_profile_contact(user)
contact = profile.contact
self.assertEqual(contact.lastname, user.last_name)
self.assertEqual(contact.firstname, user.first_name)
self.assertEqual(
models.Contact.objects.filter(email=user.email).count(), 3)
# warn duplicates + account creation
self.assertEqual(models.Action.objects.count(), 2)
for action in models.Action.objects.all():
self.assertEqual(list(action.contacts.all()), [contact])
def test_post_cart_empty(self):
"""It should create a new sale and ignore articles which are not available"""
# Create contact for the user
profile = create_profile_contact(self.user)
contact = profile.contact
store_item1 = mommy.make(models.StoreItem, stock_count=Decimal('10'), available=False)
store_item2 = mommy.make(models.StoreItem, stock_count=Decimal('0.5'), available=False)
delivery_point = mommy.make(models.DeliveryPoint)
data = {
'items': [
{'id': store_item1.id, 'quantity': 2},
{'id': store_item2.id, 'quantity': 1},
],
'delivery_point': delivery_point.id,
'purchase_datetime': datetime(2015, 7, 23, 12, 0)
}
url = reverse('store_post_cart')
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['ok'], False)
self.assertEqual(len(response.data['warnings']), 2)
action_type = ActionType.objects.get(name=get_cart_type_name())
action_queryset = Action.objects.filter(type=action_type)
self.assertEqual(action_queryset.count(), 0)
self.assertEqual(len(mail.outbox), 0)
store_item1 = models.StoreItem.objects.get(id=store_item1.id)
self.assertEqual(store_item1.stock_count, Decimal("10"))
store_item2 = models.StoreItem.objects.get(id=store_item2.id)
self.assertEqual(store_item2.stock_count, Decimal("0.5"))
def test_download_private_no_permission(self):
# Create contact for the user
profile = create_profile_contact(self.user)
contact = profile.contact
# Create category
cat = ArticleCategory.objects.create(name="CAT")
# create a public doc
file_ = File(self._get_file())
doc = mommy.make(Document, is_private=True, file=file_, category=cat)
# check the url
private_url = reverse('coop_cms_download_doc', args=[doc.id])
self.assertEqual(doc.get_download_url(), private_url)
# login and download
response = self.client.get(doc.get_download_url(), follow=True)
self.assertEqual(response.status_code, 200)
# self.assertEquals(response['Content-Disposition'], "attachment; filename=unittest1.txt")
self.assertEquals(response['Content-Type'], "text/plain")
def test_post_cart_notes_several_lines(self):
"""It should create a new sale and action"""
# Create contact for the user
profile = create_profile_contact(self.user)
contact = profile.contact
store_item1 = mommy.make(models.StoreItem)
store_item2 = mommy.make(models.StoreItem)
delivery_point = mommy.make(models.DeliveryPoint)
data = {
'items': [
{
'id': store_item1.id,
'quantity': 2
},
{
'id': store_item2.id,
'quantity': 1
},
],
'delivery_point':
delivery_point.id,
'notes':
'a\nB\nc',
'purchase_datetime':
datetime(2015, 7, 23, 12, 0)
}
url = reverse('store_post_cart')
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['ok'], True)
self.assertEqual(len(response.data['warnings']), 0)
self.assertEqual(response.data['deliveryDate'],
data['purchase_datetime'])
self.assertEqual(response.data['deliveryPlace'], delivery_point.name)
action_type = ActionType.objects.get(name=get_cart_type_name())
action_queryset = Action.objects.filter(type=action_type)
self.assertEqual(action_queryset.count(), 1)
action = action_queryset[0]
self.assertEqual(list(action.contacts.all()), [contact])
self.assertEqual(action.subject, _('Notes'))
self.assertEqual(action.detail, 'a\nB\nc')
self.assertEqual(action.planned_date, data['purchase_datetime'])
self.assertEqual(action.sale.saleitem_set.count(), 2)
self.assertEqual(action.sale.saleitem_set.all()[0].item, store_item1)
self.assertEqual(action.sale.saleitem_set.all()[0].text,
store_item1.name)
self.assertEqual(action.sale.saleitem_set.all()[0].unit_price(),
store_item1.pre_tax_price)
self.assertEqual(action.sale.saleitem_set.all()[0].vat_rate,
store_item1.vat_rate)
self.assertEqual(action.sale.saleitem_set.all()[0].quantity, 2)
self.assertEqual(action.sale.saleitem_set.all()[1].item, store_item2)
self.assertEqual(action.sale.saleitem_set.all()[1].text,
store_item2.name)
self.assertEqual(action.sale.saleitem_set.all()[1].unit_price(),
store_item2.pre_tax_price)
self.assertEqual(action.sale.saleitem_set.all()[1].vat_rate,
store_item2.vat_rate)
self.assertEqual(action.sale.saleitem_set.all()[1].quantity, 1)
self.assertEqual(len(mail.outbox), 2)
def test_post_cart_not_available(self):
"""It should create a new sale and ignore articles which are not available"""
# Create contact for the user
profile = create_profile_contact(self.user)
contact = profile.contact
store_item1 = mommy.make(models.StoreItem, stock_count=Decimal('10'))
store_item2 = mommy.make(models.StoreItem,
stock_count=Decimal('0.5'),
available=False)
delivery_point = mommy.make(models.DeliveryPoint)
data = {
'items': [
{
'id': store_item1.id,
'quantity': 2
},
{
'id': store_item2.id,
'quantity': 1
},
],
'delivery_point':
delivery_point.id,
'purchase_datetime':
datetime(2015, 7, 23, 12, 0)
}
url = reverse('store_post_cart')
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['ok'], True)
self.assertEqual(len(response.data['warnings']), 1)
self.assertEqual(response.data['deliveryDate'],
data['purchase_datetime'])
self.assertEqual(response.data['deliveryPlace'], delivery_point.name)
action_type = ActionType.objects.get(name=get_cart_type_name())
action_queryset = Action.objects.filter(type=action_type)
self.assertEqual(action_queryset.count(), 1)
action = action_queryset[0]
self.assertEqual(list(action.contacts.all()), [contact])
self.assertEqual(action.subject, '')
self.assertEqual(action.detail, '')
self.assertEqual(action.planned_date, data['purchase_datetime'])
self.assertEqual(action.sale.saleitem_set.count(), 1)
self.assertEqual(action.sale.saleitem_set.all()[0].item, store_item1)
self.assertEqual(action.sale.saleitem_set.all()[0].text,
store_item1.name)
self.assertEqual(action.sale.saleitem_set.all()[0].unit_price(),
store_item1.pre_tax_price)
self.assertEqual(action.sale.saleitem_set.all()[0].vat_rate,
store_item1.vat_rate)
self.assertEqual(action.sale.saleitem_set.all()[0].quantity, 2)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[0].to, [profile.contact.email])
self.assertEqual(mail.outbox[1].to,
[settings.BALAFON_NOTIFICATION_EMAIL])
store_item1 = models.StoreItem.objects.get(id=store_item1.id)
self.assertEqual(store_item1.stock_count, Decimal("8"))
store_item2 = models.StoreItem.objects.get(id=store_item2.id)
self.assertEqual(store_item2.stock_count, Decimal("0.5"))
def test_cart_with_discount(self):
"""The cart should take account discount into account"""
# Create contact for the user
profile = create_profile_contact(self.user)
contact = profile.contact
discount = mommy.make(models.Discount,
active=True,
name="10% si + de 5",
rate=Decimal("10"),
quantity=Decimal("5"))
price_class = mommy.make(models.PriceClass, name="Vrac")
price_class.discounts.add(discount)
price_class.save()
store_item1 = mommy.make(models.StoreItem,
pre_tax_price=Decimal('10'),
price_class=price_class)
store_item2 = mommy.make(models.StoreItem,
pre_tax_price=Decimal('1'),
price_class=price_class)
store_item3 = mommy.make(models.StoreItem,
pre_tax_price=Decimal('2'),
price_class=None)
delivery_point = mommy.make(models.DeliveryPoint)
data = {
'items': [
{
'id': store_item1.id,
'quantity': 5
},
{
'id': store_item2.id,
'quantity': 2
},
{
'id': store_item3.id,
'quantity': 5
},
],
'delivery_point':
delivery_point.id,
'purchase_datetime':
datetime(2015, 7, 23, 12, 0)
}
url = reverse('store_post_cart')
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['ok'], True)
self.assertEqual(len(response.data['warnings']), 0)
action_type = ActionType.objects.get(name=get_cart_type_name())
action_queryset = Action.objects.filter(type=action_type)
self.assertEqual(action_queryset.count(), 1)
action = action_queryset[0]
self.assertEqual(list(action.contacts.all()), [contact])
self.assertEqual(action.subject, '')
self.assertEqual(action.detail, '')
self.assertEqual(action.planned_date, data['purchase_datetime'])
self.assertEqual(action.sale.saleitem_set.count(), 3)
self.assertEqual(action.sale.saleitem_set.all()[0].item, store_item1)
self.assertEqual(action.sale.saleitem_set.all()[0].text,
store_item1.name)
self.assertEqual(action.sale.saleitem_set.all()[0].unit_price(),
store_item1.pre_tax_price * Decimal("0.9"))
self.assertEqual(action.sale.saleitem_set.all()[0].vat_rate,
store_item1.vat_rate)
self.assertEqual(action.sale.saleitem_set.all()[0].quantity, 5)
self.assertEqual(action.sale.saleitem_set.all()[1].item, store_item2)
self.assertEqual(action.sale.saleitem_set.all()[1].text,
store_item2.name)
self.assertEqual(action.sale.saleitem_set.all()[1].unit_price(),
store_item2.pre_tax_price)
self.assertEqual(action.sale.saleitem_set.all()[1].vat_rate,
store_item2.vat_rate)
self.assertEqual(action.sale.saleitem_set.all()[1].quantity, 2)
self.assertEqual(action.sale.saleitem_set.all()[2].item, store_item3)
self.assertEqual(action.sale.saleitem_set.all()[2].text,
store_item3.name)
self.assertEqual(action.sale.saleitem_set.all()[2].unit_price(),
store_item3.pre_tax_price)
self.assertEqual(action.sale.saleitem_set.all()[2].vat_rate,
store_item3.vat_rate)
self.assertEqual(action.sale.saleitem_set.all()[2].quantity, 5)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[0].to, [profile.contact.email])
self.assertEqual(mail.outbox[1].to,
[settings.BALAFON_NOTIFICATION_EMAIL])
def test_post_cart_callback(self):
"""It should create a new sale and action"""
global GLOBAL_COUNTER
GLOBAL_COUNTER = 0
# Create contact for the user
profile = create_profile_contact(self.user)
contact = profile.contact
store_item1 = mommy.make(models.StoreItem)
store_item2 = mommy.make(models.StoreItem)
delivery_point = mommy.make(models.DeliveryPoint)
data = {
'items': [
{
'id': store_item1.id,
'quantity': 2
},
{
'id': store_item2.id,
'quantity': 1
},
],
'delivery_point':
delivery_point.id,
'purchase_datetime':
datetime(2015, 7, 23, 12, 0)
}
url = reverse('store_post_cart')
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['ok'], True)
self.assertEqual(len(response.data['warnings']), 0)
self.assertEqual(response.data['deliveryDate'],
data['purchase_datetime'])
self.assertEqual(response.data['deliveryPlace'], delivery_point.name)
action_type = ActionType.objects.get(name=get_cart_type_name())
action_queryset = Action.objects.filter(type=action_type)
self.assertEqual(action_queryset.count(), 1)
action = action_queryset[0]
self.assertEqual(list(action.contacts.all()), [contact])
self.assertEqual(action.subject, '')
self.assertEqual(action.detail, '')
self.assertEqual(action.planned_date, data['purchase_datetime'])
self.assertEqual(action.sale.analysis_code,
models.SaleAnalysisCode.objects.get(name='Internet'))
self.assertEqual(action.sale.saleitem_set.count(), 2)
self.assertEqual(action.sale.saleitem_set.all()[0].item, store_item1)
self.assertEqual(action.sale.saleitem_set.all()[0].text,
store_item1.name)
self.assertEqual(action.sale.saleitem_set.all()[0].unit_price(),
store_item1.pre_tax_price)
self.assertEqual(action.sale.saleitem_set.all()[0].vat_rate,
store_item1.vat_rate)
self.assertEqual(action.sale.saleitem_set.all()[0].quantity, 2)
self.assertEqual(action.sale.saleitem_set.all()[1].item, store_item2)
self.assertEqual(action.sale.saleitem_set.all()[1].text,
store_item2.name)
self.assertEqual(action.sale.saleitem_set.all()[1].unit_price(),
store_item2.pre_tax_price)
self.assertEqual(action.sale.saleitem_set.all()[1].vat_rate,
store_item2.vat_rate)
self.assertEqual(action.sale.saleitem_set.all()[1].quantity, 1)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[0].to, [profile.contact.email])
self.assertEqual(mail.outbox[1].to,
[settings.BALAFON_NOTIFICATION_EMAIL])
store_item1 = models.StoreItem.objects.get(id=store_item1.id)
self.assertEqual(store_item1.stock_count, None)
store_item2 = models.StoreItem.objects.get(id=store_item2.id)
self.assertEqual(store_item2.stock_count, None)
# Make sure the calback has been called
self.assertEqual(GLOBAL_COUNTER, 1)
def _create_profile_and_check(self, user):
profile = create_profile_contact(user)
contact = models.Contact.objects.get(email=user.email)
self.assertEqual(contact.lastname, user.last_name)
self.assertEqual(contact.firstname, user.first_name)
return profile
def test_cart_with_discount(self):
"""The cart should take account discount into account"""
# Create contact for the user
profile = create_profile_contact(self.user)
contact = profile.contact
discount = mommy.make(
models.Discount, active=True, name="10% si + de 5", rate=Decimal("10"), quantity=Decimal("5")
)
price_class = mommy.make(models.PriceClass, name="Vrac")
price_class.discounts.add(discount)
price_class.save()
store_item1 = mommy.make(models.StoreItem, pre_tax_price=Decimal('10'), price_class=price_class)
store_item2 = mommy.make(models.StoreItem, pre_tax_price=Decimal('1'), price_class=price_class)
store_item3 = mommy.make(models.StoreItem, pre_tax_price=Decimal('2'), price_class=None)
delivery_point = mommy.make(models.DeliveryPoint)
data = {
'items': [
{'id': store_item1.id, 'quantity': 5},
{'id': store_item2.id, 'quantity': 2},
{'id': store_item3.id, 'quantity': 5},
],
'delivery_point': delivery_point.id,
'purchase_datetime': datetime(2015, 7, 23, 12, 0)
}
url = reverse('store_post_cart')
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['ok'], True)
self.assertEqual(len(response.data['warnings']), 0)
action_type = ActionType.objects.get(name=get_cart_type_name())
action_queryset = Action.objects.filter(type=action_type)
self.assertEqual(action_queryset.count(), 1)
action = action_queryset[0]
self.assertEqual(list(action.contacts.all()), [contact])
self.assertEqual(action.subject, '')
self.assertEqual(action.detail, '')
self.assertEqual(action.planned_date, data['purchase_datetime'])
self.assertEqual(action.sale.saleitem_set.count(), 3)
self.assertEqual(action.sale.saleitem_set.all()[0].item, store_item1)
self.assertEqual(action.sale.saleitem_set.all()[0].text, store_item1.name)
self.assertEqual(action.sale.saleitem_set.all()[0].unit_price(), store_item1.pre_tax_price * Decimal("0.9"))
self.assertEqual(action.sale.saleitem_set.all()[0].vat_rate, store_item1.vat_rate)
self.assertEqual(action.sale.saleitem_set.all()[0].quantity, 5)
self.assertEqual(action.sale.saleitem_set.all()[1].item, store_item2)
self.assertEqual(action.sale.saleitem_set.all()[1].text, store_item2.name)
self.assertEqual(action.sale.saleitem_set.all()[1].unit_price(), store_item2.pre_tax_price)
self.assertEqual(action.sale.saleitem_set.all()[1].vat_rate, store_item2.vat_rate)
self.assertEqual(action.sale.saleitem_set.all()[1].quantity, 2)
self.assertEqual(action.sale.saleitem_set.all()[2].item, store_item3)
self.assertEqual(action.sale.saleitem_set.all()[2].text, store_item3.name)
self.assertEqual(action.sale.saleitem_set.all()[2].unit_price(), store_item3.pre_tax_price)
self.assertEqual(action.sale.saleitem_set.all()[2].vat_rate, store_item3.vat_rate)
self.assertEqual(action.sale.saleitem_set.all()[2].quantity, 5)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[0].to, [profile.contact.email])
self.assertEqual(mail.outbox[1].to, [settings.BALAFON_NOTIFICATION_EMAIL])
