class TestCoupleActions(DataSetuoMixin, TestCase): fixtures = ['brands', 'prods'] def setUp(self) -> None: self.client = Client() self.usr = get_user_model().objects.get(username='******') self.wedding = GiftList.objects.get(user=self.usr, active=True) self.client._login(self.usr) # self.client.login(username='******', # password='******') def test_add_gift(self): self.assertEqual( GiftListItem.objects.filter(gift_list=self.wedding).count(), 0) resp = self.client.generic('POST', reverse('api-gift'), '{"product_id": 12}') self.assertEqual(resp.status_code, 200) self.assertEqual( GiftListItem.objects.filter(gift_list=self.wedding).count(), 1) def test_add_gift_unauthorised(self): self.client.logout() resp = self.client.generic('POST', reverse('api-gift'), '{"product_id": 12}') self.assertEqual(resp.status_code, 401) self.assertEqual( GiftListItem.objects.filter(gift_list=self.wedding).count(), 0) def add_gift(self): item = GiftListItem(gift_list=self.wedding, qty=1, added_by=self.usr, product_id=11) item.save() def test_remove_gift(self): self.add_gift() item = GiftListItem.objects.filter(gift_list=self.wedding).first() resp = self.client.delete( reverse('api-gift-item', kwargs=dict(item_id=item.pk))) self.assertEqual(resp.status_code, 200) self.assertEqual( GiftListItem.objects.filter(gift_list=self.wedding, ).count(), 0) def test_remove_gift_unauthorised(self): self.client.logout() self.add_gift() item = GiftListItem.objects.filter(gift_list=self.wedding).first() resp = self.client.delete( reverse('api-gift-item', kwargs=dict(item_id=item.pk))) self.assertEqual(resp.status_code, 401) self.assertEqual( GiftListItem.objects.filter(gift_list=self.wedding, ).count(), 1)
class DeleteFBVTestCase(TestCase): 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.create_tag_by_channel_port') p.start() self.addCleanup(p.stop) self.client = Client() self.tag = mommy.make(Tag) contacts_map = mommy.make(ContactsMap) self.mlpav4 = mommy.make( MLPAv4, tag=self.tag, make_m2m=True) self.mlpav4.asn.contactsmap_set.add(contacts_map) def test_delete_service(self): resp = self.client.generic( 'POST', "{}".format(reverse("core:service_delete", args=[self.mlpav4.pk]),)) self.assertEqual(resp.status_code, 200) def test_fail_with_message_to_delete_service(self): resp = self.client.generic( 'POST', "{}".format(reverse("core:service_delete", args=[self.tag.pk]),)) content = json.loads(resp.content.decode()) self.assertEqual(resp.status_code, 400) self.assertEqual(content['message'][0], 'Invalid service primary key') def test_fail_without_message_to_delete_service(self): resp = self.client.generic( 'GET', "{}".format(reverse("core:service_delete", args=[self.mlpav4.pk]),)) self.assertEqual(resp.status_code, 400) self.assertEqual(resp.content, b'')
class TestRequester(Requester): def __init__(self, host, port, base_url, logger=None): super(TestRequester, self).__init__(host, port, base_url, logger) self.client = Client() def make_request(self, request_type, method, data=None): params = "" if data and data.params: params = six.moves.urllib.parse.urlencode({ key: str(value) for key, value in get_dict_leafs(data.params).items() }) response = self.client.generic( method, "{}?{}".format(os.path.join(self.base_url, request_type.URI), params), data=json.dumps(data.body) if data else None, content_type="application/json") response_content = response.content.decode("utf-8") try: return response, json.loads(response_content) except: return (response, response_content if response_content != "" else {})
def test_ipn_view_invalid_total(self): count_before = 0 self.assertEqual(count_before, GlobeeIPN.objects.all().count()) payment_data = { "id": "a1B2c3D4e5F6g7H8i9J0kL", "status": "paid", "total": "ERROR", "currency": "USD", "custom_payment_id": "742", "callback_data": "example data", "customer": { "name": "John Smit", "email": "*****@*****.**" }, "redirect_url": "http:\/\/globee.com\/invoice\/a1B2c3D4e5F6g7H8i9J0kL", "success_url": "https:\/\/www.example.com/success", "cancel_url": "https:\/\/www.example.com/cancel", "ipn_url": "https:\/\/www.example.com/globee/ipn-callback", "notification_email": None, "confirmation_speed": "medium", "expires_at": "2018-01-25 12:31:04", "created_at": "2018-01-25 12:16:04" } client = Client() response = client.generic('POST', reverse('globee-ipn'), bytes(json.dumps(payment_data), 'utf-8')) self.assertEqual(response.status_code, 400) self.assertEqual(count_before, GlobeeIPN.objects.all().count())
def test_redirects_to_login_page_if_not_logged_in(self, http_method): """The view should redirect to the login page if the user isn't authenticated.""" client = Client() response = client.generic(http_method, add_access_token_url) assert response.status_code == status.HTTP_302_FOUND assert response['Location'] == self.login_url_with_redirect( add_access_token_url)
def test_ipn_view_invalid_key_error(self): count_before = 0 self.assertEqual(count_before, GlobeeIPN.objects.all().count()) payment_data = { "id": "a1B2c3D4e5F6g7H8i9J0kL", } client = Client() response = client.generic('POST', reverse('globee-ipn'), bytes(json.dumps(payment_data), 'utf-8')) self.assertEqual(response.status_code, 400) self.assertEqual(count_before, GlobeeIPN.objects.all().count())
class AssistantFormViewTestCase(TestCase): def setUp(self): self.factory = RequestFactory() self.client = Client() self.settings = SettingsFactory() today = datetime.date.today() self.current_academic_year = AcademicYearFactory( start_date=today, end_date=today.replace(year=today.year + 1), year=today.year) self.assistant_mandate = AssistantMandateFactory( academic_year=self.current_academic_year) self.assistant_mandate.state = assistant_mandate_state.TRTS self.assistant_mandate.save() LearningUnitYearFactory(academic_year=self.current_academic_year, acronym="LBIR1210") LearningUnitYearFactory(academic_year=self.current_academic_year, acronym="LBIR1211") def test_assistant_form_part4_edit_view_basic(self): self.client.force_login(self.assistant_mandate.assistant.person.user) response = self.client.get('/assistants/assistant/form/part4/edit/') self.assertEqual(response.status_code, HTTP_OK) def test_get_learning_units_year(self): self.client.force_login(self.assistant_mandate.assistant.person.user) response = self.client.generic( method='get', path= '/assistants/assistant/form/part2/get_learning_units_year/?term=LBIR1211', HTTP_X_REQUESTED_WITH='XMLHttpRequest') data = json.loads(response.content.decode('utf-8')) self.assertEqual(data[0]['value'], 'LBIR1211') self.assertEqual(len(data), 1) response = self.client.generic( method='get', path= '/assistants/assistant/form/part2/get_learning_units_year/?term=LBIR12', HTTP_X_REQUESTED_WITH='XMLHttpRequest') data = json.loads(response.content.decode('utf-8')) self.assertEqual(len(data), 2)
class AssistantFormViewTestCase(TestCase): def setUp(self): self.factory = RequestFactory() self.client = Client() self.settings = SettingsFactory() today = datetime.date.today() self.current_academic_year = AcademicYearFactory( start_date=today.replace(year=today.year-1), end_date=today.replace(year=today.year+1), year=today.year-1, ) self.assistant_mandate = AssistantMandateFactory(academic_year=self.current_academic_year) self.assistant_mandate.state = assistant_mandate_state.TRTS self.assistant_mandate.save() LearningUnitYearFactory(academic_year=self.current_academic_year, acronym="LBIR1210") LearningUnitYearFactory(academic_year=self.current_academic_year, acronym="LBIR1211") def test_assistant_form_part4_edit_view_basic(self): self.client.force_login(self.assistant_mandate.assistant.person.user) response = self.client.get('/assistants/assistant/form/part4/edit/') self.assertEqual(response.status_code, HTTP_OK) def test_get_learning_units_year(self): self.client.force_login(self.assistant_mandate.assistant.person.user) response = self.client.generic(method='get', path='/assistants/assistant/form/part2/get_learning_units_year/?term=LBIR1211', HTTP_X_REQUESTED_WITH='XMLHttpRequest') data = json.loads(response.content.decode('utf-8')) self.assertEqual(data[0]['value'], 'LBIR1211') self.assertEqual(len(data), 1) response = self.client.generic(method='get', path='/assistants/assistant/form/part2/get_learning_units_year/?term=LBIR12', HTTP_X_REQUESTED_WITH='XMLHttpRequest') data = json.loads(response.content.decode('utf-8')) self.assertEqual(len(data), 2)
def test_ix_detail_pix__ix_detail(self): c = Client() resp = c.generic( 'GET', '{0}?pix={1}'.format( reverse('core:ix_detail_pix', args=[self.ix.code]), str(self.switch.pix.uuid))) context = json.loads(resp.content.decode('UTF-8')) self.assertEqual(context['asn_amount'], len(self.asnumber)) self.assertEqual(context['mlpav4_amount'], 3) self.assertEqual(context['mlpav6_amount'], 1) self.assertEqual(context['bilateral_amount'], 1) self.assertEqual(context['switch_set']['0']['model'], self.switch.model.model) self.assertEqual(context['switch_set']['0']['management_ip'], self.switch.management_ip)
class TestWordCountFormView(TestCase): def setUp(self): self.client = Client() self.bag_of_ten_words = "uno dos tes cuatro cinco sies siete ocho nueve diez" def test_get_success_url(self): resp = self.client.generic( 'GET', reverse("core:word-count")) self.assertEqual(resp.status_code, 200) def test_post_form(self): resp = self.client.post(reverse("core:word-count"), {'words': self.bag_of_ten_words}, follow=True) self.assertEqual(resp.status_code, 200) self.assertIn(COUNT_RESULT_MESSAGE.format(10), str(resp.content))
def generic(self, method, path, data='', content_type='application/octet-stream', secure=False, **extra): # This is the only part that isn't copypasta from Client.post if SIG_KEY not in extra: extra[SIG_KEY] = self.sign(path, data) return Client.generic( self, method, path, data=data, content_type=content_type, secure=secure, **extra )
def test_ix_detail_cix__ix_detail(self): c = Client() resp = c.generic( 'GET', '{0}?uuid={1}'.format( reverse('core:ix_detail_cix', args=[self.ix.code]), str(self.customer_channel.uuid))) context_cix = json.loads(resp.content.decode('UTF-8')) self.assertEqual(context_cix['mlpav4_amount'], 3) self.assertEqual(context_cix['mlpav6_amount'], 1) self.assertEqual(context_cix['bilateral_amount'], 1) self.assertEqual(context_cix['switch_set']['0']['management_ip'], self.switch.management_ip) self.assertEqual( context_cix['port_master'], '{0}: {1}'.format(self.port_master.switch.management_ip, self.port_master.name)) self.assertEqual( context_cix['lag'], { self.switch.management_ip: [port.name for port in self.customer_channel.get_ports()] })
class SimpleTest(TestCase): def setUp(self): self.client = Client() self.tokens = {} def test_scenario1(self): self.signup(P1, 201) self.signup(P1, 400) self.signup(P2, 201) self.signup(P3, 201) self.login(P1['person_id'], 200) self.login(P2['person_id'], 400) self.login(P4['person_id'], 401) self.login(P1['person_id'], 200) self.logout('something', 400) self.logout(self.tokens[P1['person_id']], 200) self.logout(self.tokens[P1['person_id']], 400) self.login(P2['person_id'], 200) self.signup(P4, 201) self.logout(self.tokens[P2['person_id']], 200) self.logout(self.tokens[P2['person_id']], 400) self.login(P4['person_id'], 200) def test_car(self): pass """ random_data(toycar) self.car_data(toycar, 403) random_data(toycar) self.car_data(toycar, 403) self.signup(P1, 201) self.login(P1['person_id'], 200) self.car_data(toycar, 201) random_data(toycar) self.car_data(toycar, 201) random_data(toycar) self.car_data(toycar, 201) random_data(toycar) self.car_data(toycar, 201) self.logout(self.tokens[P1['person_id']], 200) random_data(toycar) self.car_data(toycar, 403) random_data(toycar) self.car_data(toycar, 403) """ def test_notloggedin(self): random_data(toycar) self.car_data(toycar, 403) self.start_game('notoken', 403) self.start_wheel('notoken', 403) self.start_parrot('notoken', 403) self.stop_parrot('notoken', 403) # self.new_session('notoken', 403) def test_stages(self): self.signup(P1, 201) self.signup(P2, 201) self.login(P1['person_id'], 200) self.start_wheel(self.tokens[P1['person_id']], 403) self.start_parrot(self.tokens[P1['person_id']], 403) self.stop_parrot(self.tokens[P1['person_id']], 403) # self.new_session(self.tokens[P1['person_id']], 403) random_data(toycar) self.car_data(toycar, 403) self.start_game(self.tokens[P1['person_id']], 200) self.start_parrot(self.tokens[P1['person_id']], 403) self.stop_parrot(self.tokens[P1['person_id']], 403) # self.new_session(self.tokens[P1['person_id']], 403) random_data(toycar) self.car_data(toycar, 201) random_data(toycar) self.car_data(toycar, 201) random_data(toycar) self.car_data(toycar, 201) random_data(toycar) self.car_data(toycar, 201) random_data(toycar) self.car_data(toycar, 201) self.start_wheel(self.tokens[P1['person_id']], 200) self.stop_parrot(self.tokens[P1['person_id']], 403) # self.new_session(self.tokens[P1['person_id']], 403) self.start_game(self.tokens[P1['person_id']], 403) random_data(toycar) self.car_data(toycar, 403) self.start_parrot(self.tokens[P1['person_id']], 200) self.start_wheel(self.tokens[P1['person_id']], 403) # self.new_session(self.tokens[P1['person_id']], 403) self.start_game(self.tokens[P1['person_id']], 403) random_data(toycar) self.car_data(toycar, 403) self.stop_parrot(self.tokens[P1['person_id']], 200) self.start_wheel(self.tokens[P1['person_id']], 403) self.start_parrot(self.tokens[P1['person_id']], 403) self.stop_parrot(self.tokens[P1['person_id']], 403) self.end_session(self.tokens[P1['person_id']], 403) self.start_game(self.tokens[P1['person_id']], 200) # self.new_session(self.tokens[P1['person_id']], 200) # self.new_session(self.tokens[P1['person_id']], 403) self.start_parrot(self.tokens[P1['person_id']], 403) self.stop_parrot(self.tokens[P1['person_id']], 403) self.start_wheel(self.tokens[P1['person_id']], 200) self.start_parrot(self.tokens[P1['person_id']], 200) self.stop_parrot(self.tokens[P1['person_id']], 200) def test_multi_users(self): self.signup(P1, 201) self.signup(P2, 201) self.login(P1['person_id'], 200) self.start_wheel(self.tokens[P1['person_id']], 403) self.start_parrot(self.tokens[P1['person_id']], 403) self.stop_parrot(self.tokens[P1['person_id']], 403) # self.new_session(self.tokens[P1['person_id']], 403) random_data(toycar) self.car_data(toycar, 403) self.start_game(self.tokens[P1['person_id']], 200) self.start_parrot(self.tokens[P1['person_id']], 403) self.stop_parrot(self.tokens[P1['person_id']], 403) # self.new_session(self.tokens[P1['person_id']], 403) random_data(toycar) self.car_data(toycar, 201) random_data(toycar) self.car_data(toycar, 201) random_data(toycar) self.car_data(toycar, 201) self.logout(self.tokens[P1['person_id']], 200) self.logout(self.tokens[P1['person_id']], 400) self.login(P2['person_id'], 200) self.start_wheel(self.tokens[P2['person_id']], 403) self.start_parrot(self.tokens[P2['person_id']], 403) self.stop_parrot(self.tokens[P2['person_id']], 403) # self.new_session(self.tokens[P2['person_id']], 403) random_data(toycar) self.car_data(toycar, 403) self.start_game(self.tokens[P2['person_id']], 200) self.start_parrot(self.tokens[P2['person_id']], 403) self.stop_parrot(self.tokens[P2['person_id']], 403) # self.new_session(self.tokens[P1['person_id']], 403) random_data(toycar) self.car_data(toycar, 201) random_data(toycar) self.car_data(toycar, 201) random_data(toycar) self.car_data(toycar, 201) random_data(toycar) self.car_data(toycar, 201) random_data(toycar) self.car_data(toycar, 201) random_data(toycar) self.car_data(toycar, 201) self.login(P1['person_id'], 400) self.logout(self.tokens[P1['person_id']], 400) self.logout(self.tokens[P2['person_id']], 200) self.login(P1['person_id'], 200) self.start_game(self.tokens[P1['person_id']], 200) random_data(toycar) self.car_data(toycar, 201) random_data(toycar) self.car_data(toycar, 201) random_data(toycar) self.car_data(toycar, 201) self.start_wheel(self.tokens[P1['person_id']], 200) self.stop_parrot(self.tokens[P1['person_id']], 403) # self.new_session(self.tokens[P1['person_id']], 403) self.start_game(self.tokens[P1['person_id']], 403) random_data(toycar) self.car_data(toycar, 403) self.start_parrot(self.tokens[P1['person_id']], 200) self.start_wheel(self.tokens[P1['person_id']], 403) # self.new_session(self.tokens[P1['person_id']], 403) self.start_game(self.tokens[P1['person_id']], 403) random_data(toycar) self.car_data(toycar, 403) self.stop_parrot(self.tokens[P1['person_id']], 200) self.start_wheel(self.tokens[P1['person_id']], 403) self.start_parrot(self.tokens[P1['person_id']], 403) self.stop_parrot(self.tokens[P1['person_id']], 403) self.end_session(self.tokens[P1['person_id']], 403) self.end_session(self.tokens[P1['person_id']], 403) self.start_game(self.tokens[P1['person_id']], 200) # self.new_session(self.tokens[P1['person_id']], 200) # self.new_session(self.tokens[P1['person_id']], 403) self.start_parrot(self.tokens[P1['person_id']], 403) self.stop_parrot(self.tokens[P1['person_id']], 403) self.start_wheel(self.tokens[P1['person_id']], 200) self.start_parrot(self.tokens[P1['person_id']], 200) self.stop_parrot(self.tokens[P1['person_id']], 200) self.logout(self.tokens[P1['person_id']], 200) self.login(P2['person_id'], 200) self.start_game(self.tokens[P2['person_id']], 200) random_data(toycar) self.car_data(toycar, 201) random_data(toycar) self.car_data(toycar, 201) self.start_wheel(self.tokens[P2['person_id']], 200) self.stop_parrot(self.tokens[P2['person_id']], 403) # self.new_session(self.tokens[P2['person_id']], 403) self.start_game(self.tokens[P2['person_id']], 403) random_data(toycar) self.car_data(toycar, 403) self.start_parrot(self.tokens[P2['person_id']], 200) self.start_wheel(self.tokens[P2['person_id']], 403) # self.new_session(self.tokens[P2['person_id']], 403) self.start_game(self.tokens[P2['person_id']], 403) random_data(toycar) self.car_data(toycar, 403) self.stop_parrot(self.tokens[P2['person_id']], 200) self.start_wheel(self.tokens[P2['person_id']], 403) self.start_parrot(self.tokens[P2['person_id']], 403) self.stop_parrot(self.tokens[P2['person_id']], 403) self.end_session(self.tokens[P2['person_id']], 403) self.start_game(self.tokens[P2['person_id']], 200) # self.new_session(self.tokens[P2['person_id']], 200) # self.new_session(self.tokens[P2['person_id']], 403) self.start_parrot(self.tokens[P2['person_id']], 403) self.stop_parrot(self.tokens[P2['person_id']], 403) self.start_wheel(self.tokens[P2['person_id']], 200) self.start_parrot(self.tokens[P2['person_id']], 200) self.stop_parrot(self.tokens[P2['person_id']], 200) def start_game(self, token, expected_status): response = self.client.generic('GET', '/api/stage/game/start/', HTTP_TOKEN=token) if response.status_code != expected_status: print('start_game failed', response.content) self.assertEqual(response.status_code, expected_status) def start_wheel(self, token, expected_status): response = self.client.generic('GET', '/api/stage/wheel/start/', HTTP_TOKEN=token) self.assertEqual(response.status_code, expected_status) def start_parrot(self, token, expected_status): response = self.client.generic('GET', '/api/stage/parrot/start/', HTTP_TOKEN=token) self.assertEqual(response.status_code, expected_status) def stop_parrot(self, token, expected_status): response = self.client.generic('GET', '/api/stage/parrot/stop/', HTTP_TOKEN=token) self.assertEqual(response.status_code, expected_status) def car_data(self, data, expected_status): response = self.client.generic('POST', '/api/toycar', content_type='application/json', data=json.dumps(data)) self.assertEqual(response.status_code, expected_status) def login(self, id, expected_status): response = self.client.generic('POST', '/api/auth/login', json.dumps({'person_id': id})) self.assertEqual(response.status_code, expected_status) if (expected_status == 200): data = json.loads(codecs.decode(response.content, 'utf-8')) self.tokens[id] = (data['token']) def logout(self, token, expected_status): response = self.client.generic('POST', '/api/auth/logout', HTTP_TOKEN=token) self.assertEqual(response.status_code, expected_status) def signup(self, body, expected_status): response = self.client.post('/api/user/', body) if response.status_code != expected_status: print(response.content) self.assertEqual(response.status_code, expected_status) def end_session(self, token, expected_status): response = self.client.generic('GET', '/api/session/stop/', HTTP_TOKEN=token) self.assertEqual(response.status_code, expected_status)
class TestCase(BaseTestCase): def setup(self): self.setup_users_and_clients() self.dj_client = Client() # # Test upload endpoints # def test_upload_video(self): v=Video.objects.create(team=self.user.default_team) # test creation of ticket response = self.client_user1.get(REQUEST_URL.format(v.pk)) self.assertEqual(response.status_code, 200) v = Video.objects.get(pk=v.id) self.assertEqual(v.draft.source.status, Source.STATUS_WAITING) self.assertEqual(v.draft.source.service, 'videopath') ticket_id = response.data["ticket_id"] # test complete notification response = self.client_user1.get(COMPLETE_URL.format(ticket_id)) v = Video.objects.get(pk=v.id) self.assertEqual(response.status_code, 200) #self.assertEqual(v.draft.source.status, Source.STATUS_PROCESSING) # # Test notifications # def test_progressing_notification(self): v = Video.objects.create(team=self.user.default_team) v.draft.source = Source.objects.create(key = FILE_KEY) v.draft.save() data = { "Type":"something", "Message": json.dumps(progress_notification) } self.dj_client.generic("POST", PROGRESSING_URL, data=json.dumps(data)) self.assertEqual(Source.objects.first().status, Source.STATUS_PROCESSING) def test_fail_notification(self): v = Video.objects.create(team=self.user.default_team) v.draft.source = Source.objects.create(key = FILE_KEY) v.draft.save() data = { "Type":"something", "Message": json.dumps(failed_notification) } self.dj_client.generic("POST", PROGRESSING_URL, data=json.dumps(data)) self.assertEqual(Source.objects.first().status, Source.STATUS_ERROR) def test_success_notification(self): v = Video.objects.create(team=self.user.default_team) v.draft.source = Source.objects.create(key = FILE_KEY) v.draft.save() data = { "Type":"something", "Message": json.dumps(completed_notification) } self.dj_client.generic("POST", PROGRESSING_URL, data=json.dumps(data)) source = Source.objects.first() self.assertEqual(source.status, Source.STATUS_OK) self.assertEqual(source.duration, 90) self.assertTrue(source.aspect > 1.6)
class TestStatsViews(TransactionTestCase): reset_sequences = True def setUp(self): self.client = Client() # load stats initial_data_setup() # load data for ports setup.setup_test_data() def test_submission(self): submission_body = """submission[data]={ "id": "974EEF9C-XXXX-XXXX-XXXX-XXXXXXXXXXX1", "os": { "macports_version": "2.5.4", "osx_version": "10.14", "os_arch": "i386", "os_platform": "darwin", "cxx_stdlib": "libc++", "build_arch": "x86_64", "gcc_version": "none", "prefix": "/opt/local", "xcode_version": "10.3" }, "active_ports": [ {"name": "db48", "version": "4.8.30_4"}, {"name": "expat", "version": "2.2.6_1"}, {"name": "ncurses", "version": "6.1_0"}, {"name": "bzip2", "version": "1.0.6_0"}, {"name": "mpstats-gsoc", "version": "0.1.8_2", "requested": "true"} ] }""" self.client.generic('POST', reverse('stats_submit'), submission_body) self.assertEquals(UUID.objects.count(), 6) self.assertEquals(Submission.objects.count(), 7) self.assertEquals(PortInstallation.objects.count(), 29) def test_port_installation_counts(self): response1 = self.client.get(reverse('port_stats', kwargs={ 'name': 'port-A1' })) self.assertEquals(response1.context['count']['all'], 4) self.assertEquals(response1.context['count']['requested'], 2) def test_time_travel(self): time_now = datetime.datetime.now(tz=datetime.timezone.utc) # Go back in time 35 days time_35_days_ago = time_now - datetime.timedelta(days=35) submission = QUICK_SUBMISSION_JSON # Make a submission dated 35 days ago submission_id = Submission.populate(submission, time_35_days_ago) PortInstallation.populate(submission['active_ports'], submission_id) # Call for stats between 30-60 days response1 = self.client.get(reverse('port_stats', kwargs={'name': 'port-B1'}), data={ 'days': 30, 'days_ago': 30 }) # Call for stats between 30-37 days response2 = self.client.get(reverse('port_stats', kwargs={'name': 'port-B1'}), data={ 'days': 7, 'days_ago': 30 }) # Call for stats of some other port between 30-60 days response3 = self.client.get(reverse('port_stats', kwargs={'name': 'port-A4'}), data={ 'days': 30, 'days_ago': 30 }) Port.add_or_update([ { "name": "port-A4", "version": "1.2.3", "portdir": "categoryA/port-A4" } ]) self.assertEquals(response1.context['count']['all'], 1) self.assertEquals(response1.context['count']['requested'], 0) self.assertEquals(response2.context['count']['all'], 1) self.assertEquals(response2.context['count']['requested'], 0) self.assertEquals(response3.context['count']['all'], 0) def test_users_count(self): today_day = datetime.datetime.now().day three_months_ago = datetime.datetime.now(tz=datetime.timezone.utc) - datetime.timedelta(days=int(today_day) + 90) eleven_months_ago = datetime.datetime.now(tz=datetime.timezone.utc) - datetime.timedelta(days=int(today_day) + 335) eleven_months_ago_month = str(eleven_months_ago.month) three_months_ago_month = str(three_months_ago.month) eleven_months_ago_year = str(eleven_months_ago.year) three_months_ago_year = str(three_months_ago.year) submission = QUICK_SUBMISSION_JSON for i in three_months_ago, eleven_months_ago: submission_id = Submission.populate(submission, i) PortInstallation.populate(submission['active_ports'], submission_id) response = self.client.get(reverse('stats')) three_months_count = 0 eleven_months_count = 0 for i in response.context['users_by_month']: if i['month'] == datetime.datetime.strptime(three_months_ago_year + "-" + three_months_ago_month + "-01 00:00:00-+0000", '%Y-%m-%d %H:%M:%S-%z'): three_months_count = i['num'] if i['month'] == datetime.datetime.strptime(eleven_months_ago_year + "-" + eleven_months_ago_month + "-01 00:00:00-+0000", '%Y-%m-%d %H:%M:%S-%z'): eleven_months_count = i['num'] self.assertEquals(three_months_count, 1) self.assertEquals(eleven_months_count, 1) self.assertEquals(response.context['total_submissions'], 8) self.assertEquals(response.context['unique_users'], 6) self.assertEquals(response.context['current_week'], 5) self.assertEquals(response.context['last_week'], 0) def test_validation_general_stats(self): response1 = self.client.get(reverse('stats'), data={ 'days': 91 }) response2 = self.client.get(reverse('stats'), data={ 'days': "randomString" }) response3 = self.client.get(reverse('stats'), data={ 'days': 30 }) self.assertEquals(response1.content, b"'91' is an invalid value. Allowed values are: [0, 7, 30, 90, 180, 365]") self.assertEquals(response2.content, b"Received 'randomString'. Expecting an integer.") self.assertIsInstance(response3.context['days'], int) def test_validation_port_stats(self): response1 = self.client.get(reverse('port_stats', kwargs={'name': 'port-B1'}), data={ 'days': 91 }) response2 = self.client.get(reverse('port_stats', kwargs={'name': 'port-B1'}), data={ 'days': "randomString" }) response3 = self.client.get(reverse('port_stats', kwargs={'name': 'port-B1'}), data={ 'days': 30 }) self.assertEquals(response1.content, b"'91' is an invalid value. Allowed values are: [0, 7, 30, 90, 180, 365]") self.assertEquals(response2.content, b"Received 'randomString'. Expecting an integer.") self.assertIsInstance(response3.context['days'], int)
class AprobacionOrdenesTestCase(TestCase): """ Clase AprobacionOrdenesTestCase. Clase encargada de generar las pruebas unitarias para aprobacion de ordenes de pedido y comentarios. """ def setUp(self): """ Metodo setUp que crea los datos asociados a las entidades que se van a probar. Se crean dos usuarios, cuatro tipos, una orden. """ # Every test needs a client. self.client = Client() enAprobacion = Tipo.objects.create(grupo='ORDENPEDIDO', nombre='En aprobacion') enAprobacion.save() aprobada = Tipo.objects.create(grupo='ORDENPEDIDO', nombre='Aprobada') aprobada.save() rechazada = Tipo.objects.create(grupo='ORDENPEDIDO', nombre='Rechazada') rechazada.save() enProveedor = Tipo.objects.create(grupo='ORDENPEDIDO', nombre='En proveedor') enProveedor.save() ordenParaAprobar = OrdenPedido(estado=enAprobacion) ordenParaAprobar.save() ordenParaRechazar = OrdenPedido(estado=enAprobacion) ordenParaRechazar.save() ordenConComentario = OrdenPedido(estado=aprobada) ordenConComentario.save() comentario = ComentarioOrden(comentario="Un comentario", timestamp=timezone.now(), orden=ordenConComentario) comentario.save() def test_aprobar_orden(self): """ Metodo test aprobar orden. Prueba unitaria que verifica la aprobacion de una orden de pedido el metodo a verificar de view es: aprobar_orden. La respuesta debe contener una orden con el estado "Aprobada" y un comentario. """ response = self.client.generic( 'POST', '/laboratorio/aprobarOrden/', '{"id_op": 1, "comentario": "Comentario Aprobado"}') self.assertIn("ok", response.json()["mensaje"]) self.assertEquals("Aprobada", OrdenPedido.objects.get(id=1).estado.nombre) self.assertEquals( "Comentario Aprobado", OrdenPedido.objects.get(id=1).op_comentarios.first().comentario) def test_rechazar_orden(self): """ Metodo test rechazar orden. Prueba unitaria que verifica el rechazo de una orden de pedido el metodo a verificar de view es: rechazar_orden. La respuesta debe contener una orden con el estado "Rechazada" y un comentario. """ response = self.client.generic( 'POST', '/laboratorio/rechazarOrden/', '{"id_op": 2, "comentario": "Comentario Rechazado"}') self.assertIn("ok", response.json()["mensaje"]) self.assertEquals("Rechazada", OrdenPedido.objects.get(id=2).estado.nombre) self.assertEquals( "Comentario Rechazado", OrdenPedido.objects.get(id=2).op_comentarios.first().comentario) def test_comentario_orden(self): """ Metodo test obtener comentarios orden. Prueba unitaria para obtener los comentarios de una orden de pedido el metodo a verificar de view es: obtener_comentarios_orden. La respuesta debe contener un comentario. """ response = self.client.get('/laboratorio/obtenerComentariosOrden/', {"id_op": 3}) self.assertIn("Un comentario", response.json()) def test_cambiar_aprobada_en_proveedor(self): """ Metodo test cambiar a estado En proveedor. Prueba unitaria que verifica el paso a En proveedor el metodo a verificar de view es: cambiar_aprobada_en_proveedor. La respuesta debe contener un comentario. """ response = self.client.post('/laboratorio/enProveedor/', {"id_op": 3}, format="multipart") self.assertIn("ok", response.json()["mensaje"]) self.assertEquals("En proveedor", OrdenPedido.objects.get(id=3).estado.nombre)
class TelegramBotTest(TestCase): # fixtures = ["datas.json"] def setUp(self): self.client = Client() self.button_response_from_telegram = '''{ "update_id": 134884061, "callback_query": { "id": "1783103291429351918", "from": { "id": 415161087, "is_bot": false, "first_name": "Suhail", "username": "******", "language_code": "en" }, "message": { "message_id": 53, "from": { "id": 1449605051, "is_bot": true, "first_name": "Impress", "username": "******" }, "chat": { "id": 415161087, "first_name": "Suhail", "username": "******", "type": "private" }, "date": 1611684401, "text": "Yo Mama is so fat, when the cops see her on a street corner, they yell, Break it up!", "reply_markup": { "inline_keyboard": [ [{ "text": "Fat", "callback_data": "fat" }, { "text": "Stupid", "callback_data": "stupid" }, { "text": "Dumb", "callback_data": "dumb" }] ] } }, "chat_instance": "-4531526532594316154", "data": "fat" } }''' self.text_response_from_telegram = '''{ "update_id": 134884062, "message": { "message_id": 56, "from": { "id": 415161087, "is_bot": false, "first_name": "Suhail", "username": "******", "language_code": "en" }, "chat": { "id": 415161087, "first_name": "Suhail", "username": "******", "type": "private" }, "date": 1611710359, "text": "S" } }''' def test_homepage_displays_telegram_users(self): # make a dummy telegram button click post request self.client.generic('POST', reverse('bot'), self.button_response_from_telegram) response = self.client.get(reverse('home')) self.assertEqual(response.status_code, 200) # there is html table in homepage and check there is user Suhail in the table table = f''' <tbody> <tr> <td rowspan="2">415161087</td> <td rowspan="2">suhail_vs</td> <td rowspan="2">Suhail</td> </tr> <tr> <td>fat</td> <td>1</td> </tr> </tbody>''' # make a dummy telegram text message post request self.client.generic('POST', reverse('bot'), self.text_response_from_telegram) response = self.client.get(reverse('home')) self.assertEqual(response.status_code, 200)
class GetIPsAndTagsByIXTestCase(TestCase): 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.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() self.c = Client() 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, _quantity=5, ix=self.ix, tag=seq(2)) self.mlpav4 = mommy.make( MLPAv4, mlpav4_address=self.ipv4[0]) def test_if_return_correct_IP_only_v4(self): resp = self.c.generic( 'GET', "{}?option=only_v4&ix={}&channel={}".format( reverse("core:get_ips_and_tags_by_ix"), self.ix.code, self.customer_channel.uuid)) context = json.loads(resp.content.decode('UTF-8')) self.assertFalse('ipv6' in context) self.assertEqual(context['ipv4'][0], self.ipv4[1].address) self.assertEqual(context['tag'][0], self.tags[0].tag) self.assertEqual(context['tag'][1], self.tags[1].tag) def test_if_return_correct_IP_only_v6(self): resp = self.c.generic( 'GET', "{}?option=only_v6&ix={}&channel={}".format( reverse("core:get_ips_and_tags_by_ix"), self.ix.code, self.customer_channel.uuid)) context = json.loads(resp.content.decode('UTF-8')) self.assertFalse('ipv4' in context) self.assertEqual(context['ipv6'][0], self.ipv6[0].address) self.assertEqual(context['tag'][0], self.tags[0].tag) self.assertEqual(context['tag'][1], self.tags[1].tag) def test_if_return_correct_IPs_v4_and_v6_with_v4_already_used(self): resp = self.c.generic( 'GET', "{}?option=v4_and_v6&ix={}&channel={}".format( reverse("core:get_ips_and_tags_by_ix"), self.ix.code, self.customer_channel.uuid)) context = json.loads(resp.content.decode('UTF-8')) self.assertEqual(context['ipv4'][0], self.ipv4[1].address) self.assertEqual(context['ipv6'][0], self.ipv6[1].address) self.assertEqual(context['tag'][0], self.tags[0].tag) self.assertEqual(context['tag'][1], self.tags[1].tag) self.assertEqual( context['cix_type'], self.customer_channel.cix_type) def test_if_return_correct_IPs_v4_and_v6_with_v6_already_used(self): self.mlpav6 = mommy.make( MLPAv6, mlpav6_address=cycle(self.ipv6), _quantity=2) resp = self.c.generic( 'GET', "{}?option=v4_and_v6&ix={}&channel={}".format( reverse("core:get_ips_and_tags_by_ix"), self.ix.code, self.customer_channel.uuid)) context = json.loads(resp.content.decode('UTF-8')) self.assertEqual(context['ipv4'][0], self.ipv4[2].address) self.assertEqual(context['ipv6'][0], self.ipv6[2].address) self.assertEqual(context['tag'][0], self.tags[0].tag) self.assertEqual(context['tag'][1], self.tags[1].tag) self.assertEqual( context['cix_type'], self.customer_channel.cix_type) def test_if_return_correct_tags(self): self.tags[0].status = "ALLOCATED" self.tags[0].save() resp = self.c.generic( 'GET', "{}?option=v4_and_v6&ix={}&channel={}".format( reverse("core:get_ips_and_tags_by_ix"), self.ix.code, self.customer_channel.uuid)) context = json.loads(resp.content.decode('UTF-8')) self.assertEqual(context['ipv4'][0], self.ipv4[1].address) self.assertEqual(context['ipv6'][0], self.ipv6[1].address) self.assertEqual(context['tag'][0], self.tags[1].tag) self.assertEqual(context['tag'][1], self.tags[2].tag) self.assertEqual( context['cix_type'], self.customer_channel.cix_type)
class IPsViewTestCase(TestCase): def setUp(self): MakeFakeTestData.__init__(self) # Instance a Request Factory self.response = self.client.get(reverse( 'core:ip_list', args=[self.sp.code])) self.c = Client() def test_login(self): """ Check if is logged """ # The participant make login into the application self.assertTrue(self.login) def test_ips_basics(self): """Test that the solo view returns a 200 response, uses the correct template, and has the correct context """ self.assertEqual(200, self.response.status_code) self.assertTemplateUsed('core/ip_list.html') def test_ips_return(self): ix_code = self.response.context['ix'].code self.assertEqual(ix_code, self.sp.code) ips_name = self.response.context['ips'] self.assertIs(type(ips_name), dict) self.assertEqual(ips_name[1]['v4'], self.ipv4_sp_kinikinau) self.assertEqual(ips_name[1]['v6'], self.ipv6_sp_kinikinau) self.assertEqual(ips_name[2]['v4'], self.ipv4_sp_monitor_v4_1) self.assertEqual(ips_name[2]['v6'], self.ipv6_sp_monitor_v4_1) self.assertEqual(ips_name[3]['v4'], self.ipv4_sp_monitor_v4_2) self.assertEqual(ips_name[3]['v6'], self.ipv6_sp_monitor_v4_2) self.assertEqual(ips_name[4]['v4'], self.ipv4_sp_monitor_v4_3) self.assertEqual(ips_name[4]['v6'], self.ipv6_sp_monitor_v4_3) self.assertEqual(ips_name[5]['v4'], self.ipv4_sp_chamacoco) self.assertEqual(ips_name[5]['v6'], self.ipv6_sp_chamacoco) self.assertEqual(ips_name[6]['v4'], self.ipv4_sp_none) self.assertEqual(ips_name[6]['v6'], self.ipv6_sp_none) self.assertEqual(ips_name[7]['v4'], self.ipv4_sp_terena) self.assertEqual(ips_name[7]['v6'], self.ipv6_sp_terena) def test_get_ip_informations_by_click__ip_views(self): # To a valid request resp = self.c.generic( 'GET', reverse( 'core:get_ip_informations_by_click__ip_views', args=[ self.sp.code]) + '?ipv4=' + self.ipv4_sp_chamacoco.address + '&ipv6=' + self.ipv6_sp_chamacoco.address + '&ip_opened=2') context = ast.literal_eval(resp.content.decode('UTF-8')) self.assertEqual(context['asn_ipv4'], self.chamacoco.number) self.assertEqual(context['asn_ipv6'], self.chamacoco.number) self.assertEqual(context['ip_opened'], 2) self.assertEqual(context['ipv4_name'], 'Chamacoco') self.assertEqual(context['ipv6_name'], 'Chamacoco') resp = self.c.generic( 'GET', reverse( 'core:get_ip_informations_by_click__ip_views', args=[ self.sp.code]) + '?ipv4=' + self.ipv4_sp_terena.address + '&ipv6=' + self.ipv6_sp_terena.address + '&ip_opened=3') context = ast.literal_eval(resp.content.decode('UTF-8')) self.assertEqual(context['asn_ipv4'], self.terena.number) self.assertEqual(context['asn_ipv6'], '') self.assertEqual(context['ip_opened'], 3) self.assertEqual(context['ipv4_name'], 'Terena') self.assertEqual(context['ipv6_name'], '') def test_get_match_ips_by_asn_search__ip_views(self): resp = self.c.generic( 'GET', reverse('core:get_match_ips_by_asn_search__ip_views', args=[ self.sp.code]) + '?asn=' + str(self.kinikinau.number)) context_ip = ast.literal_eval(resp.content.decode('UTF-8')) self.assertEqual(context_ip['ipv4'], [self.ipv4_sp_kinikinau.address]) self.assertEqual(context_ip['ipv6'], []) resp = self.c.generic( 'GET', reverse('core:get_match_ips_by_asn_search__ip_views', args=[ self.sp.code]) + '?asn=12') context_ip = ast.literal_eval(resp.content.decode('UTF-8')) self.assertEqual(context_ip['ipv4'], []) self.assertEqual(context_ip['ipv6'], []) def tearDown(self): super().tearDown()