def test_can_get_all_status_code(self):
for i in range(3):
for j in range(4):
RequestFactory.create(
url='http://m.com/page-%d' % j,
domain_name='m.com',
status_code=200 + (100*j),
)
self.db.flush()
response = yield self.authenticated_fetch(
'/last-requests/status-code/'
)
expect(response.code).to_equal(200)
expect(loads(response.body)).to_be_like([
{
u'statusCodeTitle': u'OK',
u'statusCode': 200
}, {
u'statusCodeTitle': u'Multiple Choices',
u'statusCode': 300
}, {
u'statusCodeTitle': u'Bad Request',
u'statusCode': 400
}, {
u'statusCodeTitle': u'Internal Server Error',
u'statusCode': 500
}
])
def test_voucher_update_view_for_voucher_in_set(self):
vs = voucher.VoucherSetFactory(count=10)
v = vs.vouchers.first()
view = views.VoucherUpdateView.as_view()
request = RequestFactory().get('/')
response = view(request, pk=v.pk)
assert response.status_code == 302
assert response.url == reverse('dashboard:voucher-set-update', kwargs={'pk': vs.pk})
assert [(m.level_tag, str(m.message)) for m in get_messages(request)][0] == (
'warning', "The voucher can only be edited as part of its set")
data = {
'code': v.code,
'name': "New name",
'start_datetime': v.start_datetime,
'end_datetime': v.end_datetime,
'usage': v.usage,
'offers': [v.offers],
}
request = RequestFactory().post('/', data=data)
response = view(request, pk=v.pk)
assert response.status_code == 302
assert response.url == reverse('dashboard:voucher-set-update', kwargs={'pk': vs.pk})
assert [(m.level_tag, str(m.message)) for m in get_messages(request)][0] == (
'warning', "The voucher can only be edited as part of its set")
v.refresh_from_db()
assert v.name != "New name"
def test_offer_delete_view_for_voucher_offer_with_vouchers(self):
offer = ConditionalOfferFactory(offer_type=ConditionalOffer.VOUCHER)
VoucherFactory().offers.add(offer)
view = offer_views.OfferDeleteView.as_view()
request = RequestFactory().get('/')
response = view(request, pk=offer.pk)
assert response.status_code == 302
assert response.url == reverse('dashboard:offer-detail',
kwargs={'pk': offer.pk})
assert [
(m.level_tag, str(m.message)) for m in get_messages(request)
][0] == (
'warning',
"This offer can only be deleted if it has no vouchers attached to it"
)
request = RequestFactory().post('/')
response = view(request, pk=offer.pk)
assert response.status_code == 302
assert response.url == reverse('dashboard:offer-detail',
kwargs={'pk': offer.pk})
assert [
(m.level_tag, str(m.message)) for m in get_messages(request)
][0] == (
'warning',
"This offer can only be deleted if it has no vouchers attached to it"
)
assert ConditionalOffer.objects.exists()
def test_offer_condition_view_with_custom_condition_type(self):
range_ = RangeFactory()
condition = create_condition(CustomConditionModel)
request = RequestFactory().post('/',
data={
'range': range_.pk,
'custom_condition': condition.pk,
})
request.session['offer_wizard'] = {
self.metadata_form_kwargs_key:
json.dumps(self.metadata_form_kwargs_session_data),
self.metadata_obj_key:
json.dumps(self.metadata_obj_session_data),
self.benefit_form_kwargs_key:
json.dumps(self.benefit_form_kwargs_session_data),
self.benefit_obj_key:
json.dumps(self.benefit_obj_session_data),
}
response = offer_views.OfferConditionView.as_view(update=True)(
request, pk=self.offer.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(
response.url,
reverse('dashboard:offer-restrictions',
kwargs={'pk': self.offer.pk}))
self.assertJSONEqual(
request.session['offer_wizard'][self.metadata_form_kwargs_key],
self.metadata_form_kwargs_session_data)
self.assertJSONEqual(
request.session['offer_wizard'][self.metadata_obj_key],
self.metadata_obj_session_data)
self.assertJSONEqual(
request.session['offer_wizard'][self.benefit_form_kwargs_key],
self.benefit_form_kwargs_session_data)
self.assertJSONEqual(
request.session['offer_wizard'][self.benefit_obj_key],
self.benefit_obj_session_data)
self.assertJSONEqual(
request.session['offer_wizard'][self.condition_form_kwargs_key], {
'data': {
'range': range_.pk,
'type': '',
'value': None,
'custom_condition': str(condition.pk),
},
})
self.assertJSONEqual(
request.session['offer_wizard'][self.condition_obj_key],
[{
'model': 'offer.condition',
'pk': condition.pk,
'fields': {
'range': None,
'type': '',
'value': None,
'proxy_class': condition.proxy_class,
}
}])
def test_offer_restrictions_view(self):
request = RequestFactory().post('/', data={
'priority': 0,
})
request.session['offer_wizard'] = {
self.metadata_form_kwargs_key:
json.dumps(self.metadata_form_kwargs_session_data),
self.metadata_obj_key:
json.dumps(self.metadata_obj_session_data),
self.benefit_form_kwargs_key:
json.dumps(self.benefit_form_kwargs_session_data),
self.benefit_obj_key:
json.dumps(self.benefit_obj_session_data),
self.condition_form_kwargs_key:
json.dumps(self.condition_form_kwargs_session_data),
self.condition_obj_key:
json.dumps(self.condition_obj_session_data),
}
response = offer_views.OfferRestrictionsView.as_view(update=True)(
request, pk=self.offer.pk)
self.offer.refresh_from_db()
self.assertEqual(response.status_code, 302)
self.assertEqual(
response.url,
reverse('dashboard:offer-detail', kwargs={'pk': self.offer.pk}))
self.assertEqual([(m.level_tag, str(m.message))
for m in get_messages(request)][0],
('success', "Offer '%s' updated" % self.offer.name))
self.assertEqual(request.session['offer_wizard'], {})
def test_can_get_response_time_avg(self):
self.db.query(Request).delete()
domain = DomainFactory.create()
avg = domain.get_response_time_avg(self.db)
expect(avg).to_be_like(0)
RequestFactory.create(status_code=200,
domain_name=domain.name,
response_time=0.25)
RequestFactory.create(status_code=304,
domain_name=domain.name,
response_time=0.35)
avg = domain.get_response_time_avg(self.db)
expect(avg).to_be_like(0.3)
RequestFactory.create(status_code=400,
domain_name=domain.name,
response_time=0.25)
RequestFactory.create(status_code=403,
domain_name=domain.name,
response_time=0.35)
RequestFactory.create(status_code=404,
domain_name=domain.name,
response_time=0.25)
avg = domain.get_response_time_avg(self.db)
expect(avg).to_be_like(0.3)
def test_can_get_all_status_code(self):
self.db.query(Request).delete()
for i in range(4):
RequestFactory.create(
url='http://m.com/page-%d' % i,
domain_name='m.com',
status_code=200 + (100*i),
completed_date=date.today() - timedelta(days=i)
)
status_code = Request.get_all_status_code(self.db)
expect(status_code).to_length(4)
expect(status_code).to_be_like([
{
'statusCodeTitle': 'OK',
'statusCode': 200
}, {
'statusCodeTitle': 'Multiple Choices',
'statusCode': 300
}, {
'statusCodeTitle': 'Bad Request',
'statusCode': 400
}, {
'statusCodeTitle': 'Internal Server Error',
'statusCode': 500
}
])
def test_can_get_all_status_code(self):
self.db.query(Request).delete()
for i in range(4):
RequestFactory.create(
url='http://m.com/page-%d' % i,
domain_name='m.com',
status_code=200 + (100*i),
completed_date=date.today() - timedelta(days=i)
)
status_code = Request.get_all_status_code(self.db)
expect(status_code).to_length(4)
expect(status_code).to_be_like([
{
'statusCodeTitle': 'OK',
'statusCode': 200
}, {
'statusCodeTitle': 'Multiple Choices',
'statusCode': 300
}, {
'statusCodeTitle': 'Bad Request',
'statusCode': 400
}, {
'statusCodeTitle': 'Internal Server Error',
'statusCode': 500
}
])
def test_can_get_domains_details(self):
self.db.query(Domain).delete()
details = Domain.get_domains_details(self.db)
expect(details).to_length(0)
domain = DomainFactory.create(name='domain-1.com',
url='http://domain-1.com/')
domain2 = DomainFactory.create(name='domain-2.com',
url='http://domain-2.com/')
DomainFactory.create()
page = PageFactory.create(domain=domain)
page2 = PageFactory.create(domain=domain)
page3 = PageFactory.create(domain=domain2)
ReviewFactory.create(domain=domain,
page=page,
is_active=True,
number_of_violations=20)
ReviewFactory.create(domain=domain,
page=page2,
is_active=True,
number_of_violations=10)
ReviewFactory.create(domain=domain2,
page=page3,
is_active=True,
number_of_violations=30)
RequestFactory.create(status_code=200,
domain_name=domain.name,
response_time=0.25)
RequestFactory.create(status_code=304,
domain_name=domain.name,
response_time=0.35)
RequestFactory.create(status_code=400,
domain_name=domain.name,
response_time=0.25)
RequestFactory.create(status_code=403,
domain_name=domain.name,
response_time=0.35)
RequestFactory.create(status_code=404,
domain_name=domain.name,
response_time=0.25)
details = Domain.get_domains_details(self.db)
expect(details).to_length(3)
expect(details[0]).to_length(10)
expect(details[0]['url']).to_equal('http://domain-1.com/')
expect(details[0]['name']).to_equal('domain-1.com')
expect(details[0]['violationCount']).to_equal(30)
expect(details[0]['pageCount']).to_equal(2)
expect(details[0]['reviewCount']).to_equal(2)
expect(details[0]['reviewPercentage']).to_equal(100.0)
expect(details[0]['errorPercentage']).to_equal(60.0)
expect(details[0]['is_active']).to_be_true()
expect(details[0]['averageResponseTime']).to_equal(0.3)
def test_offer_benefit_view_with_built_in_benefit_type(self):
range_ = RangeFactory()
request = RequestFactory().post('/',
data={
'range': range_.pk,
'type': Benefit.FIXED,
'value': 2000,
})
request.session['offer_wizard'] = {
self.metadata_form_kwargs_key:
json.dumps(self.metadata_form_kwargs_session_data),
self.metadata_obj_key:
json.dumps(self.metadata_obj_session_data),
}
response = offer_views.OfferBenefitView.as_view(update=True)(
request, pk=self.offer.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(
response.url,
reverse('dashboard:offer-condition', kwargs={'pk': self.offer.pk}))
self.assertJSONEqual(
request.session['offer_wizard'][self.metadata_form_kwargs_key],
self.metadata_form_kwargs_session_data)
self.assertJSONEqual(
request.session['offer_wizard'][self.metadata_obj_key],
self.metadata_obj_session_data)
self.assertJSONEqual(
request.session['offer_wizard'][self.benefit_form_kwargs_key], {
'data': {
'range': range_.pk,
'type': Benefit.FIXED,
'value': '2000',
'max_affected_items': None,
'custom_benefit': '',
},
})
self.assertJSONEqual(
request.session['offer_wizard'][self.benefit_obj_key],
[{
'model': 'offer.benefit',
'pk': self.offer.benefit.pk,
'fields': {
'range': range_.pk,
'type': Benefit.FIXED,
'value': '2000',
'max_affected_items': None,
'proxy_class': '',
},
}])
def test_can_increment_requests_count(self):
self.db.query(Request).delete()
self.cache.redis.delete('requests-count')
for i in range(2):
RequestFactory.create()
yield self.cache.increment_requests_count(2)
request_count = yield self.cache.get_requests_count()
expect(request_count).to_equal(4)
# should get from cache
self.cache.db = None
request_count = yield self.cache.increment_requests_count(5)
expect(request_count).to_equal(9)
def test_offer_delete_view_for_voucher_offer_without_vouchers(self):
offer = ConditionalOfferFactory(offer_type=ConditionalOffer.VOUCHER)
view = offer_views.OfferDeleteView.as_view()
request = RequestFactory().get('/')
response = view(request, pk=offer.pk)
assert response.status_code == 200
request = RequestFactory().post('/')
response = view(request, pk=offer.pk)
assert response.status_code == 302
assert response.url == reverse('dashboard:offer-list')
assert [(m.level_tag, str(m.message)) for m in get_messages(request)
][0] == ('success', "Offer deleted!")
assert not ConditionalOffer.objects.exists()
def test_get_last_requests(self):
self.db.query(Request).delete()
self.cache.redis.delete('requests-count')
dt1 = datetime(2013, 11, 12, 13, 25, 27)
dt1_timestamp = calendar.timegm(dt1.utctimetuple())
request = RequestFactory.create(completed_date=dt1)
response = yield self.http_client.fetch(self.get_url('/last-requests/'))
expect(response.code).to_equal(200)
expect(loads(response.body)).to_be_like({
u'requestsCount': 1,
u'requests': [{
u'url': request.url,
u'status_code': request.status_code,
u'completed_date': dt1_timestamp,
u'domain_name': request.domain_name,
u'effective_url': request.effective_url,
u'review_url': request.review_url,
u'response_time': request.response_time
}]
})
def test_default_shipping_address(self):
user_address = factories.UserAddressFactory(
country=self.country, user=self.user, is_default_for_shipping=True
)
request = RequestFactory().get(self.url, user=self.user)
view = views.BasketView(request=request)
self.assertEquals(view.get_default_shipping_address(), user_address)
def test_can_get_requests_by_status_code(self):
request = RequestFactory.create(
domain_name='globo.com',
status_code=200
)
loaded = Request.get_requests_by_status_code('globo.com', 200, self.db)
expect(loaded[0].url).to_equal(request.url)
expect(loaded[0].review_url).to_equal(request.review_url)
expect(loaded[0].completed_date).to_equal(request.completed_date)
invalid_domain = Request.get_requests_by_status_code(
'g1.globo.com',
200,
self.db
)
expect(invalid_domain).to_equal([])
invalid_code = Request.get_requests_by_status_code(
'globo.com',
2300,
self.db
)
expect(invalid_code).to_equal([])
def test_get(self):
request = RequestFactory().get('/')
view = views.VoucherAddView.as_view()
response = view(request)
self.assertEqual(response.status_code, 302)
def test_can_get_domains_full_data(self):
domains = []
for i in range(3):
domains.append(DomainFactory.create(name='domain-%d.com' % i))
pages = []
for i, domain in enumerate(domains):
pages.append([])
for j in range(3):
pages[i].append(PageFactory.create(domain=domain))
requests = reviews = []
for i, (domain, page) in enumerate(zip(domains, pages)):
for j in range(i + 1):
reviews.append(
ReviewFactory.create(domain=domain,
page=page[j],
is_active=True,
number_of_violations=(5 + 2 * j)))
requests.append(
RequestFactory.create(status_code=200 if j %
2 == 0 else 404,
domain_name=domain.name,
response_time=0.25 * (i + 1)))
self.server.application.violation_definitions = {
'key.%s' % i: {
'title':
'title.%s' % i,
'category':
'category.%s' % (i % 3),
'key':
Key.get_or_create(self.db, 'key.%d' % i,
'category.%d' % (i % 3))
}
for i in range(9)
}
response = yield self.authenticated_fetch('/domains-details')
expect(response.code).to_equal(200)
full_data = loads(response.body)
expect(full_data).to_length(3)
expect(full_data[0].keys()).to_length(10)
expect(map(lambda d: d['name'], full_data)).to_be_like(
['domain-0.com', 'domain-1.com', 'domain-2.com'])
expect(map(lambda d: d['pageCount'], full_data)).to_be_like([3, 3, 3])
expect(map(lambda d: d['reviewCount'],
full_data)).to_be_like([1, 2, 3])
expect(map(lambda d: d['violationCount'],
full_data)).to_be_like([5, 12, 21])
expect(map(lambda d: d['reviewPercentage'],
full_data)).to_be_like([33.33, 66.67, 100.0])
expect(map(lambda d: d['errorPercentage'],
full_data)).to_be_like([0.0, 50.0, 33.33])
expect(map(lambda d: d['averageResponseTime'],
full_data)).to_be_like([0.25, 0.5, 0.75])
def test_can_get_requests_by_status_code(self):
request = RequestFactory.create(
domain_name='globo.com',
status_code=200
)
loaded = Request.get_requests_by_status_code('globo.com', 200, self.db)
expect(loaded[0].url).to_equal(request.url)
expect(loaded[0].review_url).to_equal(request.review_url)
expect(loaded[0].completed_date).to_equal(request.completed_date)
invalid_domain = Request.get_requests_by_status_code(
'g1.globo.com',
200,
self.db
)
expect(invalid_domain).to_equal([])
invalid_code = Request.get_requests_by_status_code(
'globo.com',
2300,
self.db
)
expect(invalid_code).to_equal([])
def test_offer_condition_view_with_built_in_condition_type(self):
range_ = RangeFactory()
request = RequestFactory().post('/',
data={
'range': range_.pk,
'type': Condition.COUNT,
'value': 10,
})
request.session['offer_wizard'] = {
'metadata': json.dumps(self.metadata_form_kwargs_session_data),
'metadata_obj': json.dumps(self.metadata_obj_session_data),
'benefit': json.dumps(self.benefit_form_kwargs_session_data),
'benefit_obj': json.dumps(self.benefit_obj_session_data),
}
response = offer_views.OfferConditionView.as_view()(request)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.url, reverse('dashboard:offer-restrictions'))
self.assertJSONEqual(request.session['offer_wizard']['metadata'],
self.metadata_form_kwargs_session_data)
self.assertJSONEqual(request.session['offer_wizard']['metadata_obj'],
self.metadata_obj_session_data)
self.assertJSONEqual(request.session['offer_wizard']['benefit'],
self.benefit_form_kwargs_session_data)
self.assertJSONEqual(request.session['offer_wizard']['benefit_obj'],
self.benefit_obj_session_data)
self.assertJSONEqual(
request.session['offer_wizard']['condition'], {
'data': {
'range': range_.pk,
'type': Condition.COUNT,
'value': '10',
'custom_condition': '',
},
})
self.assertJSONEqual(request.session['offer_wizard']['condition_obj'],
[{
'model': 'offer.condition',
'pk': None,
'fields': {
'range': range_.pk,
'type': Condition.COUNT,
'value': '10',
'proxy_class': None,
},
}])
def test_can_get_requests_count(self):
self.db.query(Request).delete()
key = 'requests-count'
self.cache.redis.delete(key)
for i in range(2):
RequestFactory.create()
request_count = yield self.cache.get_requests_count()
expect(request_count).to_equal(2)
# should get from cache
self.cache.db = None
request_count = yield self.cache.get_requests_count()
expect(request_count).to_equal(2)
def test_can_remove_old_requests(self):
self.db.query(Request).delete()
config = Config()
config.DAYS_TO_KEEP_REQUESTS = 1
for i in range(4):
RequestFactory.create(
url='http://m.com/page-%d' % i,
domain_name='m.com',
status_code=200,
completed_date=date.today() - timedelta(days=i)
)
Request.delete_old_requests(self.db, config)
requests = self.db.query(Request).all()
expect(requests).to_length(1)
def test_can_remove_old_requests(self):
self.db.query(Request).delete()
config = Config()
config.DAYS_TO_KEEP_REQUESTS = 1
for i in range(4):
RequestFactory.create(
url='http://m.com/page-%d' % i,
domain_name='m.com',
status_code=200,
completed_date=date.today() - timedelta(days=i)
)
Request.delete_old_requests(self.db, config)
requests = self.db.query(Request).all()
expect(requests).to_length(1)
def test_can_get_status_code_info(self):
request = RequestFactory.create(domain_name='g1.globo.com')
loaded = Request.get_status_code_info('g1.globo.com', self.db)
expect(loaded[0].get('code')).to_equal(request.status_code)
expect(loaded[0].get('total')).to_equal(1)
invalid_domain = Request.get_status_code_info('g2.globo.com', self.db)
expect(invalid_domain).to_equal([])
def test_can_increment_requests_count(self):
self.db.query(Request).delete()
key = 'requests-count'
self.sync_cache.redis.delete(key)
for i in range(5):
RequestFactory.create()
self.sync_cache.increment_requests_count(4)
page_count = self.sync_cache.redis.get(key)
expect(page_count).to_equal('9')
# should get from cache
self.sync_cache.db = None
self.sync_cache.increment_requests_count(10)
page_count = self.sync_cache.redis.get(key)
expect(page_count).to_equal('19')
def test_can_get_status_code_info(self):
request = RequestFactory.create(domain_name='g1.globo.com')
loaded = Request.get_status_code_info('g1.globo.com', self.db)
expect(loaded[0].get('code')).to_equal(request.status_code)
expect(loaded[0].get('total')).to_equal(1)
invalid_domain = Request.get_status_code_info('g2.globo.com', self.db)
expect(invalid_domain).to_equal([])
def test_get_last_requests(self):
self.db.query(Request).delete()
dt1 = datetime(2013, 11, 12)
dt1_timestamp = calendar.timegm(dt1.utctimetuple())
domain1 = DomainFactory.create()
domain2 = DomainFactory.create()
request = RequestFactory.create(
domain_name=domain1.name, completed_date=dt1
)
response = yield self.authenticated_fetch('/last-requests/')
expect(response.code).to_equal(200)
expect(loads(response.body)).to_be_like({
u'requests': [{
u'url': request.url,
u'status_code': request.status_code,
u'completed_date': dt1_timestamp,
u'domain_name': request.domain_name,
u'effective_url': request.effective_url,
u'review_url': request.review_url,
u'response_time': request.response_time
}]
})
request = RequestFactory.create(domain_name=domain2.name,
completed_date=dt1)
response = yield self.authenticated_fetch('/last-requests/')
expect(response.code).to_equal(200)
expect(len(loads(response.body)['requests'])).to_be_like(2)
response = yield self.authenticated_fetch(
'/last-requests/?domain_filter=%s' % domain2.name
)
expect(response.code).to_equal(200)
response_body = loads(response.body)
expect(len(response_body['requests'])).to_be_like(1)
expect(response_body['requests'][0]['domain_name']).to_be_like(domain2.name)
def test_get_last_requests_filter_by_staus_code(self):
for i in range(3):
RequestFactory.create(
status_code=200,
domain_name='globo.com'
)
RequestFactory.create(
status_code=404,
domain_name='g1.globo.com'
)
response = yield self.authenticated_fetch(
'/last-requests/?status_code_filter=200'
)
expect(response.code).to_equal(200)
response_body = loads(response.body)
expect(response_body['requests']).to_length(3)
expect(response_body['requests'][0]['domain_name']).to_be_like('globo.com')
def test_can_get_response_time_avg(self):
self.db.query(Request).delete()
domain = DomainFactory.create()
avg = domain.get_response_time_avg(self.db)
expect(avg).to_be_like(0)
RequestFactory.create(status_code=200, domain_name=domain.name, response_time=0.25)
RequestFactory.create(status_code=304, domain_name=domain.name, response_time=0.35)
avg = domain.get_response_time_avg(self.db)
expect(avg).to_be_like(0.3)
RequestFactory.create(status_code=400, domain_name=domain.name, response_time=0.25)
RequestFactory.create(status_code=403, domain_name=domain.name, response_time=0.35)
RequestFactory.create(status_code=404, domain_name=domain.name, response_time=0.25)
avg = domain.get_response_time_avg(self.db)
expect(avg).to_be_like(0.3)
def test_can_get_bad_request_count(self):
self.db.query(Request).delete()
domain = DomainFactory.create()
bad = domain.get_bad_request_count(self.db)
expect(bad).to_equal(0)
RequestFactory.create(status_code=200, domain_name=domain.name)
RequestFactory.create(status_code=304, domain_name=domain.name)
bad = domain.get_bad_request_count(self.db)
expect(bad).to_equal(0)
RequestFactory.create(status_code=400, domain_name=domain.name)
RequestFactory.create(status_code=403, domain_name=domain.name)
RequestFactory.create(status_code=404, domain_name=domain.name)
bad = domain.get_bad_request_count(self.db)
expect(bad).to_equal(3)
def test_voucher_delete_view_for_voucher_in_set(self):
vs = voucher.VoucherSetFactory(count=10)
assert Voucher.objects.count() == 10
request = RequestFactory().post('/')
response = views.VoucherDeleteView.as_view()(request, pk=vs.vouchers.first().pk)
vs.refresh_from_db()
assert vs.count == 9 # "count" is updated
assert Voucher.objects.count() == 9
assert response.status_code == 302
assert response.url == reverse('dashboard:voucher-set-detail', kwargs={'pk': vs.pk})
assert [(m.level_tag, str(m.message)) for m in get_messages(request)][0] == ('warning', "Voucher deleted")
def test_can_get_bad_request_count(self):
self.db.query(Request).delete()
domain = DomainFactory.create()
bad = domain.get_bad_request_count(self.db)
expect(bad).to_equal(0)
RequestFactory.create(status_code=200, domain_name=domain.name)
RequestFactory.create(status_code=304, domain_name=domain.name)
bad = domain.get_bad_request_count(self.db)
expect(bad).to_equal(0)
RequestFactory.create(status_code=400, domain_name=domain.name)
RequestFactory.create(status_code=403, domain_name=domain.name)
RequestFactory.create(status_code=404, domain_name=domain.name)
bad = domain.get_bad_request_count(self.db)
expect(bad).to_equal(3)
def test_voucher_set_delete_view(self):
vs = voucher.VoucherSetFactory(count=10)
assert VoucherSet.objects.count() == 1
assert Voucher.objects.count() == 10
request = RequestFactory().post('/')
response = views.VoucherSetDeleteView.as_view()(request, pk=vs.pk)
assert VoucherSet.objects.count() == 0
assert Voucher.objects.count() == 0
assert response.status_code == 302
assert response.url == reverse('dashboard:voucher-set-list')
assert [(m.level_tag, str(m.message)) for m in get_messages(request)][0] == ('warning', "Voucher set deleted")
def test_offer_benefit_view_with_custom_benefit_type(self):
benefit = create_benefit(CustomBenefitModel)
request = RequestFactory().post('/',
data={
'custom_benefit': benefit.pk,
})
request.session['offer_wizard'] = {
'metadata': json.dumps(self.metadata_form_kwargs_session_data),
'metadata_obj': json.dumps(self.metadata_obj_session_data),
}
response = offer_views.OfferBenefitView.as_view()(request)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.url, reverse('dashboard:offer-condition'))
self.assertJSONEqual(request.session['offer_wizard']['metadata'],
self.metadata_form_kwargs_session_data)
self.assertJSONEqual(request.session['offer_wizard']['metadata_obj'],
self.metadata_obj_session_data)
self.assertJSONEqual(
request.session['offer_wizard']['benefit'], {
'data': {
'range': None,
'type': '',
'value': None,
'max_affected_items': None,
'custom_benefit': str(benefit.pk),
},
})
self.assertJSONEqual(request.session['offer_wizard']['benefit_obj'],
[{
'model': 'offer.benefit',
'pk': benefit.pk,
'fields': {
'range': None,
'type': '',
'value': None,
'max_affected_items': None,
'proxy_class': benefit.proxy_class,
}
}])
def test_can_get_response_time_avg_for_domain(self):
self.db.query(Request).delete()
self.db.query(Domain).delete()
DomainFactory.create(url='http://globo.com', name='globo.com')
key = 'globo.com-response-time-avg'
self.cache.redis.delete(key)
RequestFactory.create(status_code=200, domain_name='globo.com', response_time=0.25)
RequestFactory.create(status_code=304, domain_name='globo.com', response_time=0.35)
RequestFactory.create(status_code=400, domain_name='globo.com', response_time=0.25)
RequestFactory.create(status_code=403, domain_name='globo.com', response_time=0.35)
RequestFactory.create(status_code=404, domain_name='globo.com', response_time=0.25)
avg = yield self.cache.get_response_time_avg('globo.com')
expect(avg).to_be_like(0.3)
self.cache.db = None
avg = yield self.cache.get_response_time_avg('globo.com')
expect(avg).to_be_like(0.3)
def test_can_convert_request_to_dict(self):
request = RequestFactory.create()
request_dict = request.to_dict()
expect(request_dict['domain_name']).to_equal(str(request.domain_name))
expect(request_dict['url']).to_equal(request.url)
expect(request_dict['effective_url']).to_equal(request.effective_url)
expect(request_dict['status_code']).to_equal(request.status_code)
expect(request_dict['response_time']).to_equal(request.response_time)
expect(request_dict['completed_date']).to_equal(request.completed_date)
expect(request_dict['review_url']).to_equal(request.review_url)
def test_can_convert_request_to_dict(self):
request = RequestFactory.create()
request_dict = request.to_dict()
expect(request_dict['domain_name']).to_equal(str(request.domain_name))
expect(request_dict['url']).to_equal(request.url)
expect(request_dict['effective_url']).to_equal(request.effective_url)
expect(request_dict['status_code']).to_equal(request.status_code)
expect(request_dict['response_time']).to_equal(request.response_time)
expect(request_dict['completed_date']).to_equal(request.completed_date)
expect(request_dict['review_url']).to_equal(request.review_url)
def test_can_get_bad_request_count_for_domain(self):
self.db.query(Request).delete()
self.db.query(Domain).delete()
DomainFactory.create(url='http://globo.com', name='globo.com')
key = 'globo.com-bad-request-count'
self.cache.redis.delete(key)
RequestFactory.create(status_code=200, domain_name='globo.com')
RequestFactory.create(status_code=304, domain_name='globo.com')
RequestFactory.create(status_code=400, domain_name='globo.com')
RequestFactory.create(status_code=403, domain_name='globo.com')
RequestFactory.create(status_code=404, domain_name='globo.com')
bad = yield self.cache.get_bad_request_count('globo.com')
expect(bad).to_equal(3)
self.cache.db = None
bad = yield self.cache.get_bad_request_count('globo.com')
expect(bad).to_equal(3)
def test_can_get_domains_full_data(self):
domains = []
for i in xrange(3):
domains.append(DomainFactory.create(name='domain-%d.com' % i))
pages = []
for i, domain in enumerate(domains):
pages.append([])
for j in xrange(3):
pages[i].append(PageFactory.create(domain=domain))
requests = reviews = []
for i, (domain, page) in enumerate(zip(domains, pages)):
for j in xrange(i + 1):
reviews.append(ReviewFactory.create(
domain=domain,
page=page[j],
is_active=True,
number_of_violations=(5 + 2 * j)
))
requests.append(RequestFactory.create(
status_code=200 if j % 2 == 0 else 404,
domain_name=domain.name,
response_time=0.25 * (i + 1)
))
self.server.application.violation_definitions = {
'key.%s' % i: {
'title': 'title.%s' % i,
'category': 'category.%s' % (i % 3),
'key': Key.get_or_create(self.db, 'key.%d' % i, 'category.%d' % (i % 3))
} for i in xrange(9)
}
response = yield self.http_client.fetch(
self.get_url('/domains-details')
)
expect(response.code).to_equal(200)
full_data = loads(response.body)
expect(full_data).to_length(3)
expect(full_data[0].keys()).to_length(10)
expect(map(lambda d: d['name'], full_data)).to_be_like(['domain-0.com', 'domain-1.com', 'domain-2.com'])
expect(map(lambda d: d['pageCount'], full_data)).to_be_like([3, 3, 3])
expect(map(lambda d: d['reviewCount'], full_data)).to_be_like([1, 2, 3])
expect(map(lambda d: d['violationCount'], full_data)).to_be_like([5, 12, 21])
expect(map(lambda d: d['reviewPercentage'], full_data)).to_be_like([33.33, 66.67, 100.0])
expect(map(lambda d: d['errorPercentage'], full_data)).to_be_like([0.0, 50.0, 33.33])
expect(map(lambda d: d['averageResponseTime'], full_data)).to_be_like([0.25, 0.5, 0.75])
def test_voucher_delete_view(self):
v = voucher.VoucherFactory()
v.offers.add(ConditionalOfferFactory(offer_type=ConditionalOffer.VOUCHER))
assert Voucher.objects.count() == 1
assert ConditionalOffer.objects.count() == 1
request = RequestFactory().post('/')
response = views.VoucherDeleteView.as_view()(request, pk=v.pk)
assert Voucher.objects.count() == 0
# Related offer is not deleted
assert ConditionalOffer.objects.count() == 1
assert response.status_code == 302
assert response.url == reverse('dashboard:voucher-list')
assert [(m.level_tag, str(m.message)) for m in get_messages(request)][0] == ('warning', "Voucher deleted")
def test_post_with_missing_voucher(self):
""" If the voucher is missing, verify the view queues a message and redirects. """
pk = '12345'
view = views.VoucherRemoveView.as_view()
request = RequestFactory().post('/')
request.basket.save()
response = view(request, pk=pk)
self.assertEqual(response.status_code, 302)
actual = list(get_messages(request))[-1].message
expected = "No voucher found with id '{}'".format(pk)
self.assertEqual(actual, expected)
def test_can_create_request(self):
request = RequestFactory.create()
expect(str(request)).to_equal('http://g1.globo.com (301)')
expect(request.id).not_to_be_null()
expect(request.domain_name).to_equal('g1.globo.com')
expect(request.url).to_equal('http://g1.globo.com')
expect(request.effective_url).to_equal('http://g1.globo.com/')
expect(request.status_code).to_equal(301)
expect(request.response_time).to_equal(0.23)
expect(request.completed_date).to_equal(date(2013, 2, 12))
expect(request.review_url).to_equal('http://globo.com/')
def test_can_create_request(self):
request = RequestFactory.create()
expect(str(request)).to_equal('http://g1.globo.com (301)')
expect(request.id).not_to_be_null()
expect(request.domain_name).to_equal('g1.globo.com')
expect(request.url).to_equal('http://g1.globo.com')
expect(request.effective_url).to_equal('http://g1.globo.com/')
expect(request.status_code).to_equal(301)
expect(request.response_time).to_equal(0.23)
expect(request.completed_date).to_equal(date(2013, 2, 12))
expect(request.review_url).to_equal('http://globo.com/')
def test_offer_meta_data_view(self):
request = RequestFactory().post('/',
data={
'name': 'Test offer',
'description': 'Test description',
'offer_type':
ConditionalOffer.VOUCHER,
})
response = offer_views.OfferMetaDataView.as_view(update=True)(
request, pk=self.offer.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(
response.url,
reverse('dashboard:offer-benefit', kwargs={'pk': self.offer.pk}))
self.assertJSONEqual(
request.session['offer_wizard'][self.metadata_form_kwargs_key], {
'data': {
'name': 'Test offer',
'description': 'Test description',
'offer_type': ConditionalOffer.VOUCHER,
},
})
self.assertJSONEqual(
request.session['offer_wizard'][self.metadata_obj_key],
[{
'model': 'offer.conditionaloffer',
'pk': self.offer.pk,
'fields': {
'name': 'Test offer',
'slug': self.offer.slug,
'description': 'Test description',
'offer_type': ConditionalOffer.VOUCHER,
'exclusive': True,
'status': ConditionalOffer.OPEN,
'condition': self.offer.condition.pk,
'benefit': self.offer.benefit.pk,
'priority': 0,
'start_datetime': None,
'end_datetime': None,
'max_global_applications': None,
'max_user_applications': None,
'max_basket_applications': None,
'max_discount': None,
'total_discount': '0.00',
'num_applications': 0,
'num_orders': 0,
'redirect_url': '',
'date_created': '2021-04-23T14:00:00Z',
},
}])
def test_can_get_domains_details(self):
self.db.query(Domain).delete()
details = Domain.get_domains_details(self.db)
expect(details).to_length(0)
domain = DomainFactory.create(name='domain-1.com', url='http://domain-1.com/')
domain2 = DomainFactory.create(name='domain-2.com', url='http://domain-2.com/')
DomainFactory.create()
page = PageFactory.create(domain=domain)
page2 = PageFactory.create(domain=domain)
page3 = PageFactory.create(domain=domain2)
ReviewFactory.create(domain=domain, page=page, is_active=True, number_of_violations=20)
ReviewFactory.create(domain=domain, page=page2, is_active=True, number_of_violations=10)
ReviewFactory.create(domain=domain2, page=page3, is_active=True, number_of_violations=30)
RequestFactory.create(status_code=200, domain_name=domain.name, response_time=0.25)
RequestFactory.create(status_code=304, domain_name=domain.name, response_time=0.35)
RequestFactory.create(status_code=400, domain_name=domain.name, response_time=0.25)
RequestFactory.create(status_code=403, domain_name=domain.name, response_time=0.35)
RequestFactory.create(status_code=404, domain_name=domain.name, response_time=0.25)
details = Domain.get_domains_details(self.db)
expect(details).to_length(3)
expect(details[0]).to_length(10)
expect(details[0]['url']).to_equal('http://domain-1.com/')
expect(details[0]['name']).to_equal('domain-1.com')
expect(details[0]['violationCount']).to_equal(30)
expect(details[0]['pageCount']).to_equal(2)
expect(details[0]['reviewCount']).to_equal(2)
expect(details[0]['reviewPercentage']).to_equal(100.0)
expect(details[0]['errorPercentage']).to_equal(60.0)
expect(details[0]['is_active']).to_be_true()
expect(details[0]['averageResponseTime']).to_equal(0.3)
def test_offer_restrictions_view(self):
request = RequestFactory().post('/', data={
'priority': 0,
})
request.session['offer_wizard'] = {
'metadata': json.dumps(self.metadata_form_kwargs_session_data),
'metadata_obj': json.dumps(self.metadata_obj_session_data),
'benefit': json.dumps(self.benefit_form_kwargs_session_data),
'benefit_obj': json.dumps(self.benefit_obj_session_data),
'condition': json.dumps(self.condition_form_kwargs_session_data),
'condition_obj': json.dumps(self.condition_obj_session_data),
}
response = offer_views.OfferRestrictionsView.as_view()(request)
offer = ConditionalOffer.objects.get()
self.assertEqual(response.status_code, 302)
self.assertEqual(
response.url,
reverse('dashboard:offer-detail', kwargs={'pk': offer.pk}))
self.assertEqual([(m.level_tag, str(m.message))
for m in get_messages(request)][0],
('success', "Offer '%s' created!" % offer.name))
self.assertEqual(request.session['offer_wizard'], {})
def test_post_valid(self):
voucher = VoucherFactory(num_basket_additions=5)
data = {'code': voucher.code}
request = RequestFactory().post('/', data=data)
request.basket.save()
request.basket.vouchers.add(voucher)
view = views.VoucherRemoveView.as_view()
response = view(request, pk=voucher.pk)
self.assertEqual(response.status_code, 302)
voucher = voucher.__class__.objects.get(pk=voucher.pk)
self.assertEqual(voucher.num_basket_additions, 4)
def test_can_get_requests_by_status_count(self):
for i in range(4):
RequestFactory.create(domain_name='globo.com', status_code=200)
total = Request.get_requests_by_status_count(
'globo.com',
200,
self.db
)
expect(total).to_equal(4)
invalid_domain = Request.get_requests_by_status_code(
'g1.globo.com',
200,
self.db
)
expect(invalid_domain).to_equal([])
invalid_code = Request.get_requests_by_status_code(
'globo.com',
2300,
self.db
)
expect(invalid_code).to_equal([])
def test_can_get_requests_count_by_status(self):
utcnow = datetime.utcnow()
DomainFactory.create(name='globo.com')
DomainFactory.create(name='globoesporte.com')
DomainFactory.create(name='domain3.com')
for i in range(3):
RequestFactory.create(
status_code=200,
completed_date=utcnow.date() - timedelta(days=i),
domain_name='globo.com'
)
RequestFactory.create(
status_code=404,
completed_date=utcnow.date() - timedelta(days=i),
domain_name='globo.com'
)
RequestFactory.create(
status_code=404,
completed_date=utcnow.date() - timedelta(days=i),
domain_name='globoesporte.com'
)
RequestFactory.create(
status_code=599,
completed_date=utcnow.date() - timedelta(days=i),
)
self.db.flush()
counts = Request.get_requests_count_by_status(self.db)
expect(counts).to_equal({
'_all': [(200, 3), (404, 6)],
u'globo.com': [(200, 3), (404, 3)],
u'domain3.com': [],
u'globoesporte.com': [(404, 3)]
})
def test_get_requests_in_last_day(self):
utcnow = datetime.utcnow().date()
for i in range(3):
RequestFactory.create(
status_code=200,
completed_date=utcnow - timedelta(days=1)
)
RequestFactory.create(
status_code=404,
completed_date=utcnow - timedelta(days=i)
)
RequestFactory.create(
status_code=599,
completed_date=utcnow - timedelta(days=i + 1)
)
self.db.flush()
response = yield self.http_client.fetch(self.get_url('/requests-in-last-day/'))
expect(response.code).to_equal(200)
expect(loads(response.body)).to_be_like([
{
'statusCode': 200,
'statusCodeTitle': 'OK',
'count': 3
}, {
'statusCode': 404,
'statusCodeTitle': 'Not Found',
'count': 2
}, {
'statusCode': 599,
'statusCodeTitle': 'Tornado Timeout',
'count': 1
}
])
def test_can_get_latest_failed_responses(self):
self.db.query(Request).delete()
utcnow = datetime.utcnow()
DomainFactory.create(name='globo.com')
DomainFactory.create(name='globoesporte.com')
DomainFactory.create(name='domain3.com')
for i in range(3):
RequestFactory.create(
status_code=200,
completed_date=utcnow.date() - timedelta(days=i),
domain_name='globo.com'
)
RequestFactory.create(
status_code=404,
completed_date=utcnow.date() - timedelta(days=i),
domain_name='globo.com'
)
RequestFactory.create(
status_code=404,
completed_date=utcnow.date() - timedelta(days=i),
domain_name='globoesporte.com'
)
RequestFactory.create(
status_code=599,
completed_date=utcnow.date() - timedelta(days=i),
domain_name='g1.globo.com'
)
self.db.flush()
response = yield self.authenticated_fetch(
'/last-requests/failed-responses/'
)
expect(response.code).to_equal(200)
expect(loads(response.body)).to_be_like([
{u'count': 3, u'statusCodeTitle': u'OK', u'statusCode': 200},
{u'count': 6, u'statusCodeTitle': u'Not Found', u'statusCode': 404}
])
response = yield self.authenticated_fetch(
'/last-requests/failed-responses/?domain_filter=globo.com'
)
expect(response.code).to_equal(200)
expect(loads(response.body)).to_be_like([
{u'count': 3, u'statusCodeTitle': u'OK', u'statusCode': 200},
{u'count': 3, u'statusCodeTitle': u'Not Found', u'statusCode': 404}
])
response = yield self.authenticated_fetch(
'/last-requests/failed-responses/?domain_filter=globoesporte.com'
)
expect(response.code).to_equal(200)
expect(loads(response.body)).to_be_like([
{u'count': 3, u'statusCodeTitle': u'Not Found', u'statusCode': 404}
])
response = yield self.authenticated_fetch(
'/last-requests/failed-responses/?domain_filter=g1.globo.com'
)
expect(response.code).to_equal(200)
expect(loads(response.body)).to_be_like([])
response = yield self.authenticated_fetch(
'/last-requests/failed-responses/?domain_filter=domain3.com'
)
expect(response.code).to_equal(200)
expect(loads(response.body)).to_be_like([])
