Пример #1
0
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)
Пример #2
0
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'')
Пример #3
0
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 {})
Пример #4
0
 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())
Пример #5
0
 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)
Пример #6
0
 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())
Пример #7
0
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)
Пример #9
0
 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)
Пример #10
0
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))
Пример #11
0
    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
        )
Пример #12
0
 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()]
         })
Пример #13
0
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)
Пример #15
0
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)
Пример #17
0
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)
Пример #18
0
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)
Пример #19
0
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()