def test_bidcycle_fixture(authorized_user):
bidcycle = mommy.make(BidCycle, id=1, name="Bidcycle 1", cycle_start_date="2017-01-01T00:00:00Z", cycle_deadline_date="2017-05-05T00:00:00Z", cycle_end_date="2018-01-01T00:00:00Z", active=True)
for i in range(5):
bidcycle.positions.add(mommy.make('position.Position', position_number=seq("2")))
# Create 5 "in search" positions
mommy.make('position.Position', position_number=seq("56"), _quantity=5)
mommy.make('position.Position', position_number=seq("1"), _quantity=2)
mommy.make('user_profile.SavedSearch',
id=1,
name="Test search",
owner=authorized_user.profile,
endpoint='/api/v1/position/',
filters={
"position_number__startswith": ["56"],
})
# A non-position search
mommy.make('user_profile.SavedSearch',
id=2,
name="Test search",
owner=authorized_user.profile,
endpoint='/api/v1/orgpost/',
filters={
"differential_rate__gt": ["0"],
})
def test_create_packages_max_packages(self):
"""
Test that packages are created on save.
If package_max_count is reached, the box must be split into two.
"""
city = mommy.make("City", name="Foo city")
subsidiary = mommy.make(
"Subsidiary",
address_street="Foo street",
address_psc=12234,
address_street_number="123",
address_city="Foo city",
city=city,
address_recipient="Foo recipient",
)
user_attendance = UserAttendanceRecipe.make(
userprofile__user__first_name="Foo",
userprofile__user__last_name=seq("Name "),
approved_for_team="approved",
team__subsidiary=subsidiary,
team__name=seq("Team "),
discount_coupon__discount=100,
discount_coupon__coupon_type__name="Discount",
_quantity=2,
)
user_attendance[0].campaign.package_max_count = 1
user_attendance[0].campaign.save()
delivery_batch = mommy.make(
"DeliveryBatch",
campaign=user_attendance[0].campaign,
)
subsidiary_boxes = delivery_batch.subsidiarybox_set
self.assertQuerysetEqual(
subsidiary_boxes.all().order_by("pk"),
(
"<SubsidiaryBox: Krabice pro pobočku Foo recipient, Foo street 123, 122 34 Foo city - Foo city>",
"<SubsidiaryBox: Krabice pro pobočku Foo recipient, Foo street 123, 122 34 Foo city - Foo city>",
),
)
pdf = PdfFileReader(subsidiary_boxes.all()[0].customer_sheets)
pdf_string = pdf.pages[0].extractText()
self.assertTrue("Foo Name 1" in pdf_string)
pdf = PdfFileReader(subsidiary_boxes.all()[1].customer_sheets)
pdf_string = pdf.pages[0].extractText()
self.assertTrue("Foo Name 2" in pdf_string)
self.assertQuerysetEqual(
subsidiary_boxes.first().teampackage_set.all().order_by("pk"),
[
"<TeamPackage: Balíček pro tým Team 1>",
],
)
self.assertQuerysetEqual(
PackageTransaction.objects.all().order_by("pk"),
[
"<PackageTransaction: Package transaction for user Foo Name 1>",
"<PackageTransaction: Package transaction for user Foo Name 2>",
],
)
def test_create_packages(self):
"""
Test that packages are created on save
"""
city = mommy.make("City", name="Foo city")
subsidiary = mommy.make(
"Subsidiary",
address_street="Foo street",
address_psc=12234,
address_street_number="123",
address_city="Foo city",
city=city,
address_recipient="Foo recipient",
)
user_attendance = UserAttendanceRecipe.make(
userprofile__user__first_name="Foo",
userprofile__user__last_name=seq("Name "),
approved_for_team="approved",
team__subsidiary=subsidiary,
team__name=seq("Team "),
discount_coupon__discount=100,
discount_coupon__coupon_type__name="Discount",
_quantity=2,
)
delivery_batch = mommy.make(
"DeliveryBatch",
campaign=user_attendance[0].campaign,
)
self.assertQuerysetEqual(
delivery_batch.subsidiarybox_set.all(),
("<SubsidiaryBox: Krabice pro pobočku Foo recipient, Foo street 123, 122 34 Foo city - Foo city>",
),
)
self.assertQuerysetEqual(
delivery_batch.subsidiarybox_set.first().teampackage_set.all().
order_by("pk"),
[
"<TeamPackage: Balíček pro tým Team 1>",
"<TeamPackage: Balíček pro tým Team 2>",
],
)
self.assertQuerysetEqual(
PackageTransaction.objects.all().order_by("pk"),
[
"<PackageTransaction: Package transaction for user Foo Name 1>",
"<PackageTransaction: Package transaction for user Foo Name 2>",
],
)
# Test that PackageTransaction object is created
self.assertEqual(
PackageTransaction.objects.first().team_package.box.delivery_batch,
delivery_batch,
)
# Test that PDF is created correctly - with the t-shirt sizes for all UserAttendance objects
pdf = PdfFileReader(
delivery_batch.subsidiarybox_set.first().customer_sheets)
pdf_string = pdf.pages[0].extractText()
self.assertTrue("Foo Name" in pdf_string)
def xtest_no_filter_shows_all_sizes_of_business(self):
get_contract_recipe().make(_quantity=5, vendor_name=seq("Large Biz"), business_size='o')
get_contract_recipe().make(_quantity=5, vendor_name=seq("Small Biz"), business_size='s')
driver = self.load_and_wait()
self.assert_results_count(driver, 10)
self.assertIsNotNone(re.search(r'Small Biz\d+', driver.page_source))
self.assertIsNotNone(re.search(r'Large Biz\d+', driver.page_source))
def setUp(self):
DefaultLogin.__init__(self)
p = patch(
'ixbr_api.core.models.create_all_ips')
p.start()
self.addCleanup(p.stop)
p = patch(
'ixbr_api.core.models.HistoricalTimeStampedModel.full_clean')
p.start()
self.addCleanup(p.stop)
p = patch('ixbr_api.core.models.create_tag_by_channel_port')
p.start()
self.addCleanup(p.stop)
p = patch(
'ixbr_api.core.models.Switch.full_clean')
self.addCleanup(p.stop)
p.start()
tags = [17, 18, 19]
status_tags = ['PRODUCTION', 'AVAILABLE', 'PRODUCTION']
self.ix = mommy.make(
IX,
tags_policy="ix_managed",
create_tags=False,
code="ria")
self.customer_channel = mommy.make(CustomerChannel,)
self.port = mommy.make(
Port,
switch__pix__ix=self.ix,
channel_port=self.customer_channel.channel_port)
self.ipv4 = mommy.make(
IPv4Address,
address=seq('187.16.193.'),
ix=self.ix,
_quantity=3)
self.ipv6 = mommy.make(
IPv6Address,
ix=self.ix,
address=seq("2001:12f8:0:16::"),
_quantity=3)
self.tags = mommy.make(
Tag,
ix=self.ix,
tag=cycle(tags),
status=cycle(status_tags),
_quantity=len(tags))
self.mlpav4 = mommy.make(
MLPAv4,
mlpav4_address=self.ipv4[0],
tag=self.tags[0])
def test_no_filter_shows_all_sizes_of_business(self):
get_contract_recipe().make(_quantity=5, vendor_name=seq("Large Biz"), business_size='o')
get_contract_recipe().make(_quantity=5, vendor_name=seq("Small Biz"), business_size='s')
driver = self.load_and_wait()
self.assert_results_count(driver, 10)
self.assertIsNotNone(re.search(r'Small Biz\d+', driver.page_source))
self.assertIsNotNone(re.search(r'Large Biz\d+', driver.page_source))
def setUp(self):
self.dataset = mommy.make(Dataset)
self.zero_dataset = mommy.make(Dataset)
records = mommy.make(DatasetRecord, _quantity=10, value=seq(0))
zero_records = mommy.make(DatasetRecord, _quantity=10, value=seq(-1))
for record in records:
self.dataset.records.add(record)
for record in zero_records:
self.zero_dataset.records.add(record)
def get_contract_recipe():
return Recipe(
Contract,
idv_piid=seq('ABC123'),
piid=piid,
vendor_name=seq("CompanyName"),
labor_category="Business Analyst II",
schedule=cycle(SCHEDULES),
min_years_experience=seq(5),
hourly_rate_year1=seq('2'),
current_price=seq('2'),
)
def test_pesquisa_data_adesao_sistema_de_cultura(client):
mommy.make('SistemaCultura', _quantity=5, ente_federado__cod_ibge=seq(110),
data_publicacao_acordo=seq(datetime.date(2018, 12, 21),
datetime.timedelta(days=1)), _fill_optional=True)
sistema_de_cultura = SistemaCultura.sistema.first()
data_param = '?data_adesao={}'.format(sistema_de_cultura.data_publicacao_acordo)
url = url_sistemadeculturalocal + data_param
request = client.get(url, content_type="application/hal+json")
assert len(request.data["_embedded"]["items"]) == 1
assert request.data["_embedded"]["items"][0]["data_adesao"] == str(sistema_de_cultura.data_publicacao_acordo)
def test_filter_schedules(self):
get_contract_recipe().make(_quantity=5, vendor_name=seq("MOBIS"), schedule='MOBIS')
get_contract_recipe().make(_quantity=5, vendor_name=seq("AIMS"), schedule='AIMS')
driver = self.load_and_wait()
form = self.get_form()
self.set_form_value(form, 'schedule', 'MOBIS')
self.submit_form_and_wait()
self.assert_results_count(driver, 5)
self.assertIsNone(re.search(r'AIMS\d+', driver.page_source))
self.assertIsNotNone(re.search(r'MOBIS\d+', driver.page_source))
def test_filter_experience_range(self):
get_contract_recipe().make(_quantity=5, vendor_name=seq("4 years of experience"), min_years_experience=4)
get_contract_recipe().make(_quantity=5, vendor_name=seq("5 years of experience"), min_years_experience=5)
driver = self.load_and_wait()
form = self.get_form()
self.set_form_value(form, 'experience_range', '5,10')
self.submit_form_and_wait()
self.assert_results_count(driver, 5)
self.assertIsNone(re.search(r'4 years of experience\d+', driver.page_source))
self.assertIsNotNone(re.search(r'5 years of experience\d+', driver.page_source))
def xtest_filter_to_only_small_businesses(self):
get_contract_recipe().make(_quantity=5, vendor_name=seq("Large Biz"), business_size="o")
get_contract_recipe().make(_quantity=5, vendor_name=seq("Small Biz"), business_size="s")
driver = self.load_and_wait()
form = self.get_form()
self.set_form_value(form, "business_size", "s")
self.submit_form_and_wait()
self.assert_results_count(driver, 5)
self.assertIsNone(re.search(r"Large Biz\d+", driver.page_source))
self.assertIsNotNone(re.search(r"Small Biz\d+", driver.page_source))
def xtest_filter_schedules(self):
get_contract_recipe().make(_quantity=5, vendor_name=seq("MOBIS"), schedule='MOBIS')
get_contract_recipe().make(_quantity=5, vendor_name=seq("AIMS"), schedule='AIMS')
driver = self.load_and_wait()
form = self.get_form()
self.set_form_value(form, 'schedule', 'MOBIS')
self.submit_form_and_wait()
self.assert_results_count(driver, 5)
self.assertIsNone(re.search(r'AIMS\d+', driver.page_source))
self.assertIsNotNone(re.search(r'MOBIS\d+', driver.page_source))
def xtest_filter_to_only_large_businesses(self):
get_contract_recipe().make(_quantity=5, vendor_name=seq("Large Biz"), business_size='o')
get_contract_recipe().make(_quantity=5, vendor_name=seq("Small Biz"), business_size='s')
driver = self.load_and_wait()
form = self.get_form()
self.set_form_value(form, 'business_size', 'o')
self.submit_form_and_wait()
self.assert_results_count(driver, 5)
self.assertIsNone(re.search(r'Small Biz\d+', driver.page_source))
self.assertIsNotNone(re.search(r'Large Biz\d+', driver.page_source))
def test_filter_to_only_large_businesses(self):
get_contract_recipe().make(_quantity=5, vendor_name=seq("Large Biz"), business_size='o')
get_contract_recipe().make(_quantity=5, vendor_name=seq("Small Biz"), business_size='s')
driver = self.load_and_wait()
form = self.get_form()
self.set_form_value(form, 'business_size', 'o')
self.submit_form_and_wait()
self.assert_results_count(driver, 5)
self.assertIsNone(re.search(r'Small Biz\d+', driver.page_source))
self.assertIsNotNone(re.search(r'Large Biz\d+', driver.page_source))
def test_completed_todo(self):
mommy.make('Todo',
user=self.user,
title=recipe.seq('hello'),
_quantity=3)
mommy.make('Todo',
user=self.user,
title=recipe.seq('hello112'),
_quantity=5,
completed=datetime(2020, 5, 4))
url = reverse('completedtodo')
res = self.client.get(url)
self.assertEqual(res.status_code, 200)
self.assertEqual(len(res.context['todos']), 5)
def test_current_todo(self):
mommy.make('Todo',
user=self.user,
title=recipe.seq('hello'),
_quantity=5)
mommy.make('Todo',
user=self.user,
title=recipe.seq('helloii'),
_quantity=5,
completed=datetime(2019, 5, 5))
res = self.client.get(CURRENT_TODO_URL)
self.assertEqual(res.status_code, 200)
self.assertEqual(len(res.context['todos']), 5)
self.assertTemplateUsed(res, 'todo/currenttodo.html')
def test_send_mass_communication(self):
users = user_profile_recipe.make(username=seq("Foo "), _quantity=5)
for u in users:
donor_payment_channel_recipe.make(user=u)
mommy.make("Preference", send_mailing_lists=True, user=u)
model_admin = django_admin.site._registry[DonorPaymentChannel]
request = self.post_request({})
for queryset in (
UserProfile.objects.filter(id__in=(u.id for u in users)),
DonorPaymentChannel.objects.all(),
):
response = admin.send_mass_communication_action(
model_admin, request, queryset)
self.assertEqual(response.status_code, 302)
self.assertEqual(
response.url,
"/aklub/masscommunication/add/?send_to_users=%s" %
"%2C".join(str(getattr(u, "user", u).id) for u in queryset),
)
self.client.force_login(self.superuser)
response = self.client.get(response.url, follow=True)
for u in queryset:
user = getattr(u, "user", u)
self.assertContains(
response,
'<option value="%s" selected>%s</option>' %
(user.id, str(user)),
html=True,
)
def test_deve_gerar_classificacao_considerando_nascimento_como_quarto_criterio(self):
pre_analises = []
pontuacao = 5.0
pontuacao_pt = 5.0
pontuacao_mt = 5.0
nascimento_seq = recipe.seq(datetime.date.today(), increment_by=datetime.timedelta(days=1))
for inscricao in self.inscricoes:
pre_analises.append(
recipes.inscricao_pre_analise.make(
candidato=inscricao.candidato,
fase=self.fase_analise,
curso=self.curso,
modalidade=self.modalidade_ampla,
situacao=models.SituacaoInscricao.DEFERIDA.name,
pontuacao=pontuacao,
pontuacao_pt=pontuacao_pt,
pontuacao_mt=pontuacao_mt,
nascimento=next(nascimento_seq)
)
)
with mock.patch("psct.export.export"):
tasks.resultado.gerar_resultado_preliminar(self.fase_analise.pk)
resultados_inscricoes = models.ResultadoPreliminarInscricao.objects.all()
self.assertEqual(
pre_analises,
[resultado.inscricao_preanalise for resultado in resultados_inscricoes]
)
def test_defining_recipes_str(self):
from model_mommy.recipe import seq
p = Recipe('generic.Person', name=seq('foo'))
try:
p.make(_quantity=5)
except AttributeError as e:
self.fail('%s' % e)
def test_titles_are_correct(self):
get_contract_recipe().make(_quantity=1,
labor_category=seq("Architect"))
driver = self.load_and_wait()
self.assertTrue(
driver.title.startswith('CALC'),
'Title mismatch, {} does not start with CALC'.format(driver.title))
def setUp(self):
DefaultLogin.__init__(self)
p = patch('ixbr_api.core.models.create_all_ips')
self.addCleanup(p.stop)
p.start()
p = patch('ixbr_api.core.models.HistoricalTimeStampedModel.full_clean')
self.addCleanup(p.stop)
p.start()
p = patch('ixbr_api.core.models.Switch.full_clean')
self.addCleanup(p.stop)
p.start()
self.ix = mommy.make(IX, code='sp')
self.pix = mommy.make(PIX, ix=self.ix)
self.asn = mommy.make(ASN, number=20121)
self.contactsmap = mommy.make(ContactsMap, asn=self.asn, ix=self.ix)
self.models = ['[X460-48t]', '[X670-72x]']
self.switch_models = mommy.make(SwitchModel,
model=cycle(self.models),
vendor='EXTREME',
_quantity=len(self.models))
self.switchs = mommy.make(Switch,
pix=self.pix,
model=cycle(self.switch_models),
management_ip=seq('192.168.28.'),
_quantity=2)
self.channel_port_customer = mommy.make(ChannelPort, create_tags=False)
self.ports = mommy.make(Port,
switch=cycle(self.switchs),
name=seq('1'),
channel_port=self.channel_port_customer,
_quantity=len(self.switchs))
self.ticket = 1234
self.channel_name = 'ct-1'
self.cix_type = 0
def test_titles_are_correct(self):
get_contract_recipe().make(_quantity=1,
labor_category=seq("Architect"))
driver = self.load_and_wait()
self.assertTrue(
driver.title.startswith('CALC'),
'Title mismatch, {} does not start with CALC'.format(driver.title)
)
def test_logarithmic_not_in_get_scale_options(self):
self.dataset = mommy.make(Dataset)
records = mommy.make(DatasetRecord, _quantity=10, value=seq(-5))
for record in records:
self.dataset.records.add(record)
scales = self.dataset.get_scale_options()
self.assertIn(SCALE_CHOICES[0], scales)
self.assertNotIn(SCALE_CHOICES[1], scales)
def test_defining_recipes_str(self):
from model_mommy.recipe import seq
p = Recipe("generic.Person", name=seq("foo"))
try:
p.make(_quantity=5)
except AttributeError as e:
self.fail("%s" % e)
def xtest_filter_experience_range(self):
get_contract_recipe().make(_quantity=5, vendor_name=seq("4 years of experience"), min_years_experience='4')
get_contract_recipe().make(_quantity=5, vendor_name=seq("5 years of experience"), min_years_experience='5')
driver = self.load_and_wait()
form = self.get_form()
# self.set_form_value(form, 'experience_range', '5,10')
self.set_form_value(form, 'min_experience', "5")
self.set_form_value(form, 'max_experience', "10")
self.submit_form_and_wait()
self.assert_results_count(driver, 5)
self.assertIsNone(re.search(r'4 years of experience\d+', driver.page_source))
self.assertIsNotNone(re.search(r'5 years of experience\d+', driver.page_source))
def test_there_is_no_business_size_column(self):
get_contract_recipe().make(_quantity=5, vendor_name=seq("Large Biz"), business_size='o')
driver = self.load()
form = self.get_form()
col_headers = get_column_headers(driver)
for head in col_headers:
self.assertFalse(has_matching_class(head, 'column-business[_-]size'))
def test_defining_recipes_str(self):
from model_mommy.recipe import seq
p = Recipe('generic.Person',
name=seq('foo')
)
try:
p.make(_quantity=5)
except AttributeError, e:
self.fail('%s' %e)
def test_delete_todo_invalid(self):
mommy.make('Todo',
user=self.user,
title=recipe.seq('hello'),
_quantity=3)
url = reverse('deletetodo', args=[99])
data = {}
res = self.client.post(url, data)
self.assertEqual(res.status_code, 404)
def test_pesquisa_data_adesao_sistema_de_cultura(client):
mommy.make('SistemaCultura',
_quantity=5,
ente_federado__cod_ibge=seq(110),
data_publicacao_acordo=seq(datetime.date(2018, 12, 21),
datetime.timedelta(days=1)),
_fill_optional=True)
sistema_de_cultura = SistemaCultura.sistema.first()
data_param = '?data_adesao={}'.format(
sistema_de_cultura.data_publicacao_acordo)
url = url_sistemadeculturalocal + data_param
request = client.get(url, content_type="application/hal+json")
assert len(request.data["_embedded"]["items"]) == 1
assert request.data["_embedded"]["items"][0]["data_adesao"] == str(
sistema_de_cultura.data_publicacao_acordo)
def test_complete_todo_invalid_pk(self):
mommy.make('Todo',
user=self.user,
title=recipe.seq('hello'),
_quantity=3)
url = reverse('completetodo', args=[66])
data = {'completed': datetime(2020, 4, 2)}
res = self.client.post(url, data)
self.assertEqual(res.status_code, 404)
def test_view_todo_post(self):
mommy.make('Todo',
user=self.user,
title=recipe.seq('hello'),
_quantity=3)
data = {'title': 'helloblah', 'important': True}
view_url = reverse('viewtodo', args=[1])
res = self.client.post(view_url, data)
self.assertEqual(res.status_code, 302)
def xtest_price_lte(self):
# note: the hourly rates here will actually start at 80-- this seems
# like a bug, but whatever
get_contract_recipe().make(
_quantity=10, labor_category=seq("Contractor"), hourly_rate_year1=seq(70, 10), current_price=seq(70, 10)
)
driver = self.load()
form = self.get_form()
self.search_for("Contractor")
maximum = 100
# add results count check
self.set_form_value(form, "price__lte", maximum)
self.submit_form_and_wait()
self.assertTrue(
("price__lte=%d" % maximum) in driver.current_url, 'Missing "price__lte=%d" in query string' % maximum
)
self.assert_results_count(driver, 3)
def test_there_is_no_business_size_column(self):
get_contract_recipe().make(_quantity=5, vendor_name=seq("Large Biz"), business_size='o')
driver = self.load()
form = self.get_form()
col_headers = get_column_headers(driver)
for head in col_headers:
self.assertFalse(has_matching_class(head, 'column-business[_-]size'))
def xtest_price_lte(self):
# note: the hourly rates here will actually start at 80-- this seems
# like a bug, but whatever
get_contract_recipe().make(_quantity=10,
labor_category=seq("Contractor"),
hourly_rate_year1=seq(70, 10),
current_price=seq(70, 10))
driver = self.load()
form = self.get_form()
self.search_for('Contractor')
maximum = 100
# add results count check
self.set_form_value(form, 'price__lte', maximum)
self.submit_form_and_wait()
self.assertTrue(('price__lte=%d' % maximum) in driver.current_url,
'Missing "price__lte=%d" in query string' % maximum)
self.assert_results_count(driver, 3)
def test_model_todo(self):
"""Tests for the model methods"""
mommy.make('Todo',
user=self.user,
title=recipe.seq('hello'),
_quantity=5)
todos = Todo.objects.all()
self.assertEqual(len(todos), 5)
self.assertIn('hello', todos.__str__())
def test_retorno_maximo_de_100_objetos_sistema_de_cultura(client):
mommy.make('SistemaCultura', ente_federado__cod_ibge=seq(110), _quantity=110)
limit_param = '?limit=150'
url = url_sistemadeculturalocal + limit_param
request = client.get(url, content_type="application/hal+json")
assert len(request.data["_embedded"]["items"]) == 100
def test_dont_find_any_tasks(self, send_mock):
mommy.make(
'TaskSchedule',
database=cycle(self.databases),
scheduled_for=seq(FAKE_NOW, timedelta(hours=1)),
status=0,
_quantity=3
)
send_mail_24hours_before_auto_task()
self.assertFalse(send_mock.called)
def xtest_form_submit_loading(self):
get_contract_recipe().make(_quantity=1, labor_category=seq("Architect"))
self.load()
self.search_for('Architect')
form = self.submit_form()
# print(self.driver.execute_script('document.querySelector("#search").className'))
self.assertTrue(has_class(form, 'loading'), "Form doesn't have 'loading' class")
self.wait_for(self.data_is_loaded)
self.assertTrue(has_class(form, 'loaded'), "Form doesn't have 'loaded' class")
self.assertFalse(has_class(form, 'loading'), "Form shouldn't have 'loading' class after loading")
def xtest_filter_order_is_correct(self):
get_contract_recipe().make(_quantity=1, labor_category=seq("Architect"))
driver = self.load()
form = self.get_form()
inputs = form.find_elements_by_css_selector("input:not([type='hidden'])")
# the last visible form inputs should be the price filters
self.assertEqual(inputs[-2].get_attribute('name'), 'price__gte')
self.assertEqual(inputs[-1].get_attribute('name'), 'price__lte')
def xtest_form_submit_loading(self):
get_contract_recipe().make(_quantity=1, labor_category=seq("Architect"))
self.load()
self.search_for('Architect')
form = self.submit_form()
# print(self.driver.execute_script('document.querySelector("#search").className'))
self.assertTrue(has_class(form, 'loading'), "Form doesn't have 'loading' class")
self.wait_for(self.data_is_loaded)
self.assertTrue(has_class(form, 'loaded'), "Form doesn't have 'loaded' class")
self.assertFalse(has_class(form, 'loading'), "Form shouldn't have 'loading' class after loading")
def test_retorno_maximo_de_100_objetos_sistema_de_cultura(client):
mommy.make('Municipio', cidade__codigo_ibge=seq(110), _quantity=110)
limit_param = '?limit=150'
url = url_sistemadeculturalocal + limit_param
request = client.get(url, content_type="application/hal+json")
assert len(request.data["_embedded"]["items"]) == 100
def xtest_filter_order_is_correct(self):
get_contract_recipe().make(_quantity=1, labor_category=seq("Architect"))
driver = self.load()
form = self.get_form()
inputs = form.find_elements_by_css_selector("input:not([type='hidden'])")
# the last visible form inputs should be the price filters
self.assertEqual(inputs[-2].get_attribute('name'), 'price__gte')
self.assertEqual(inputs[-1].get_attribute('name'), 'price__lte')
def test__get_non_zero_max_record(self):
self.dataset = mommy.make(Dataset)
value_seq = seq(1, increment_by=-1)
records = mommy.make(DatasetRecord, _quantity=10, value=value_seq)
for record in records:
self.dataset.records.add(record)
max_record = self.dataset._get_max_record()
non_zero_max_record = self.dataset._get_non_zero_max_record()
self.assertEqual(int(max_record), 0)
self.assertEqual(int(non_zero_max_record), -1)
def test_URL_sistema_cultura_local_retorna_10_sistemas(client):
for ente in mommy.make('EnteFederado', _quantity=12, cod_ibge=seq(110)):
mommy.make('SistemaCultura', ente_federado=ente)
request = client.get(url_sistemadeculturalocal,
content_type="application/hal+json")
assert isinstance(request.data["_embedded"]["items"], list)
assert len(request.data["_embedded"]["items"]) == 10
def test_URL_sistema_cultura_local_retorna_10_sistemas(client):
for ente in mommy.make('EnteFederado', _quantity=12, cod_ibge=seq(110)):
mommy.make('SistemaCultura', ente_federado=ente)
request = client.get(url_sistemadeculturalocal,
content_type="application/hal+json")
assert isinstance(request.data["_embedded"]["items"], list)
assert len(request.data["_embedded"]["items"]) == 10
def test_pesquisa_por_cnpj_prefeitura_em_sistema_de_cultura(client):
sistema_cultura = mommy.make('SistemaCultura', ente_federado__cod_ibge=seq(111), _quantity=2, _fill_optional=True)
cnpj_param = '?cnpj_prefeitura={}'.format(sistema_cultura[0].sede.cnpj)
url = url_sistemadeculturalocal + cnpj_param
request = client.get(url, content_type="application/hal+json")
assert len(request.data["_embedded"]["items"]) == 1
assert request.data["_embedded"]["items"][0]["_embedded"]["sede"]["localizacao"]["cnpj"] == sistema_cultura[0].sede.cnpj
def test_queryset_to_model_migrator():
ignored_old_polls = mommy.make(OldPoll, _quantity=3)
collected_old_polls = mommy.make(
OldPoll, old_poll_name=seq('herpderp'), _quantity=3)
migrator = mp.QuerysetToModelMigrator()
migrator.run_migration()
assert NewPoll.objects.count() == 3
for p in collected_old_polls:
np_match = NewPoll.objects.filter(new_poll_name=p.old_poll_name)
assert np_match.count() == 1
def test_sql_query_to_model_migrator():
ignored_old_polls = mommy.make(OldPoll, _quantity=3)
collected_old_polls = mommy.make(
OldPoll, old_poll_name=seq('herpderp'), _quantity=3)
migrator = mp.ComplexPollsBySQLMigrator()
migrator.run_migration()
assert NewPoll.objects.count() == 3
for p in collected_old_polls:
np_match = NewPoll.objects.filter(
new_poll_name=p.old_poll_name + ' (old)')
assert np_match.count() == 1
def test_view_todo_get(self):
mommy.make('Todo',
user=self.user,
title=recipe.seq('hello'),
_quantity=5)
view_url = reverse('viewtodo', args=[1])
res = self.client.get(view_url)
self.assertEqual(res.status_code, 200)
self.assertIn('hello', res.context['todo'].title)
view_url = reverse('viewtodo', args=[6])
res = self.client.get(view_url)
self.assertEqual(res.status_code, 404)
def test_database_dead(self, task_register_mock):
DatabaseHelper.create(
name=seq('test'), status=Database.DEAD, _quantity=4
)
task_register_mock.return_value = self.task_history
check_databases_status()
self.assertEqual(self.task_history.task_status, 'ERROR')
self.assertIn('Dead', self.task_history.details)
self.assertIn('test1', self.task_history.details)
self.assertIn('test2', self.task_history.details)
self.assertIn('test3', self.task_history.details)
self.assertIn('test4', self.task_history.details)
def xtest_form_submit_loading(self):
get_contract_recipe().make(_quantity=1,
labor_category=seq("Architect"))
self.load()
self.search_for('Architect')
form = self.submit_form()
self.assertTrue(has_class(form, 'loading'),
"Form doesn't have 'loading' class")
self.wait_for(self.data_is_loaded)
self.assertTrue(has_class(form, 'loaded'),
"Form doesn't have 'loaded' class")
self.assertFalse(has_class(form, 'loading'),
"Form shouldn't have 'loading' class after loading")
def test_pesquisa_por_nome_municipio_em_sistema_de_cultura_letras_minusculas(client):
sistema_cultura = mommy.make('SistemaCultura', ente_federado__cod_ibge=seq(
111), _quantity=2, _fill_optional=True)
nome_ente_minusculo = sistema_cultura[0].ente_federado.nome.lower()
nome_ente_param = '?ente_federado={}'.format(nome_ente_minusculo)
url = url_sistemadeculturalocal + nome_ente_param
request = client.get(url, content_type="application/hal+json")
assert len(request.data["_embedded"]["items"]) == 1
assert request.data["_embedded"]["items"][0]["_embedded"]["ente_federado"]["nome"] == sistema_cultura[0].ente_federado.nome
def get_contract_recipe(schedule=None, sin=None):
return Recipe(
Contract,
idv_piid=seq('ABC123'),
vendor_name=seq("CompanyName"),
labor_category="Business Analyst II",
schedule=schedule or cycle(SCHEDULES),
sin=sin or cycle(SINS),
min_years_experience=seq(5),
hourly_rate_year1=seq('2'),
current_price=seq('2'),
next_year_price=seq('3'),
second_year_price=seq('4'),
)
def test_filter_by_site(self):
get_contract_recipe().make(_quantity=3, contractor_site=seq('Q'))
resp = self.c.get(self.path, {'site': 'Q3'})
self.assertEqual(resp.status_code, 200)
self.assertEqual(len(resp.data['results']), 1)
self.assertResultsEqual(resp.data['results'],
[{'idv_piid': 'ABC1233',
'vendor_name': 'CompanyName3',
'labor_category': 'Business Analyst II',
'education_level': None,
'min_years_experience': 8,
'hourly_rate_year1': 23.0,
'current_price': 23.0,
'schedule': 'MOBIS',
'contractor_site': 'Q3',
'business_size': None}])
person = Recipe(Person,
name = 'John Doe',
nickname = 'joe',
age = 18,
bio = 'Someone in the crowd',
blog = 'http://joe.blogspot.com',
wanted_games_qtd = 4,
birthday = now().date(),
appointment = now(),
birth_time = now()
)
serial_person = Recipe(Person,
name = seq('joe'),
)
serial_numbers = Recipe(DummyDefaultFieldsModel,
default_decimal_field = seq(Decimal('20.1')),
default_int_field = seq(10),
default_float_field = seq(1.23)
)
serial_numbers_by = Recipe(DummyDefaultFieldsModel,
default_decimal_field = seq(Decimal('20.1'), increment_by=Decimal('2.4')),
default_int_field = seq(10, increment_by=3),
default_float_field = seq(1.23, increment_by=1.8)
)
serial_datetime = Recipe(DummyDefaultFieldsModel,
from model_mommy.recipe import Recipe, seq
from .models import User
email_seq = seq('*****@*****.**')
user = Recipe(User,
first_name='Johnny',
last_name=seq('User'),
email=email_seq,)
def test_results_count(self):
get_contract_recipe().make(_quantity=10, labor_category=seq("Engineer"))
driver = self.load_and_wait()
self.assert_results_count(driver, 10)
from model_mommy.recipe import Recipe, seq
from contracts.models import Contract
from itertools import cycle
SCHEDULES = ('MOBIS', 'PES')
piid = seq('123')
def get_contract_recipe(schedule=None):
return Recipe(
Contract,
idv_piid=seq('ABC123'),
piid=piid,
vendor_name=seq("CompanyName"),
labor_category="Business Analyst II",
schedule=schedule or cycle(SCHEDULES),
min_years_experience=seq(5),
hourly_rate_year1=seq('2'),
current_price=seq('2'),
next_year_price=seq('3'),
second_year_price=seq('4'),
)
an **object-oriented** computer programming language commonly used to
create interactive effects within *web browsers*.''',
''''# Python
a *high-level* **general-purpose** _programming language_.''',
]
user = Recipe(
User,
email="*****@*****.**",
is_active=True
)
category = Recipe(
Category,
title=seq('Category'),
author=foreign_key(user),
description=cycle('description'),
_quantity=3
)
article = Recipe(
Article,
title=seq('Article'),
author=foreign_key(user),
category=foreign_key(category),
content=cycle(definitions),
_quantity=5
)
